Convert NULL to nullptr

util/mach/exc_client_variants_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 82 matching lines @@
     if (code_count >= 1) {
       EXPECT_EQ(expect_code, code[0]);
     }
     if (code_count >= 2) {
       EXPECT_EQ(expect_subcode, code[1]);
     }
 
     if (HasState()) {
       EXPECT_EQ(exception_ + 10, *flavor);
       EXPECT_EQ(MACHINE_THREAD_STATE_COUNT, old_state_count);
-      EXPECT_NE(static_cast<const natural_t*>(NULL), old_state);
+      EXPECT_NE(nullptr, old_state);
       EXPECT_EQ(static_cast<mach_msg_type_number_t>(THREAD_STATE_MAX),
                 *new_state_count);
-      EXPECT_NE(static_cast<natural_t*>(NULL), new_state);
+      EXPECT_NE(nullptr, new_state);
 
       for (size_t index = 0; index < old_state_count; ++index) {
         EXPECT_EQ(index, old_state[index]);
       }
 
       // Use a flavor known to be different from the incoming flavor, for a test
       // of the “out” side of the inout flavor parameter.
       *flavor = exception_ + 20;
       *new_state_count = MACHINE_THREAD_STATE_COUNT;
 
       // Send a new state back to the client.
       for (size_t index = 0; index < *new_state_count; ++index) {
         EXPECT_EQ(0u, new_state[index]);
         new_state[index] = MACHINE_THREAD_STATE_COUNT - index;
       }
     } else {
       EXPECT_EQ(THREAD_STATE_NONE, *flavor);
       EXPECT_EQ(0u, old_state_count);
-      EXPECT_EQ(NULL, old_state);
+      EXPECT_EQ(nullptr, old_state);
       EXPECT_EQ(0u, *new_state_count);
-      EXPECT_EQ(NULL, new_state);
+      EXPECT_EQ(nullptr, new_state);
     }
 
     return KERN_SUCCESS;
   }
 
  private:
   // MachMultiprocess:
 
   virtual void MachMultiprocessParent() override {
     kern_return_t kr = MachMessageServer::Run(this,
@@ skipping 16 matching lines @@
     };
 
     thread_t thread = THREAD_NULL;
     task_t task = TASK_NULL;
     if (all_fields_ || HasIdentity()) {
       thread = MachThreadSelf();
       task = mach_task_self();
     }
 
     thread_state_flavor_t flavor;
-    thread_state_flavor_t* flavor_p = NULL;
+    thread_state_flavor_t* flavor_p = nullptr;
     natural_t old_state[MACHINE_THREAD_STATE_COUNT];
-    thread_state_t old_state_p = NULL;
+    thread_state_t old_state_p = nullptr;
     mach_msg_type_number_t old_state_count = 0;
     natural_t new_state[THREAD_STATE_MAX];
-    thread_state_t new_state_p = NULL;
+    thread_state_t new_state_p = nullptr;
     mach_msg_type_number_t new_state_count;
-    mach_msg_type_number_t* new_state_count_p = NULL;
+    mach_msg_type_number_t* new_state_count_p = nullptr;
     if (all_fields_ || HasState()) {
       // Pick a different flavor each time based on the value of exception_.
       // These aren’t real flavors, it’s just for testing.
       flavor = exception_ + 10;
       flavor_p = &flavor;
       for (size_t index = 0; index < arraysize(old_state); ++index) {
         old_state[index] = index;
       }
       old_state_p = reinterpret_cast<thread_state_t>(&old_state);
       old_state_count = arraysize(old_state);
@@ skipping 99 matching lines @@
 
       TestExcClientVariants test_exc_client_variants(behavior, true);
       test_exc_client_variants.Run();
     }
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad