Convert NULL to nullptr

util/mach/symbolic_constants_mach_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 23 matching lines @@
     0,
     kAllowFullName,
     kAllowShortName,
     kAllowFullName | kAllowShortName,
     kAllowNumber,
     kAllowFullName | kAllowNumber,
     kAllowShortName | kAllowNumber,
     kAllowFullName | kAllowShortName | kAllowNumber,
 };
 
-// If |expect| is NULL, the conversion is expected to fail. If |expect| is
+// If |expect| is nullptr, the conversion is expected to fail. If |expect| is
 // empty, the conversion is expected to succeed, but the precise returned string
 // value is unknown. Otherwise, the conversion is expected to succeed, and
 // |expect| contains the precise expected string value to be returned. If
 // |expect| contains the substring "0x1", the conversion is expected only to
 // succeed when kUnknownIsNumeric is set.
 //
 // Only set kUseFullName or kUseShortName when calling this. Other options are
 // exercised directly by this function.
 template <typename Traits>
 void TestSomethingToStringOnce(typename Traits::ValueType value,
@@ skipping 109 matching lines @@
                           kExceptionTestData[index].short_name);
   }
 
   for (exception_type_t exception = 0;
        exception < EXC_TYPES_COUNT + 8;
        ++exception) {
     SCOPED_TRACE(base::StringPrintf("exception %d", exception));
     if (exception > 0 && exception < EXC_TYPES_COUNT) {
       TestExceptionToString(exception, "", "");
     } else {
-      TestExceptionToString(exception, NULL, NULL);
+      TestExceptionToString(exception, nullptr, nullptr);
     }
   }
 }
 
 void TestStringToException(const base::StringPiece& string,
                            StringToSymbolicConstantOptions options,
                            bool expect_result,
                            exception_type_t expect_value) {
   return TestStringToSomething<ConvertExceptionTraits>(
       string, options, expect_result, expect_value);
@@ skipping 399 matching lines @@
                                   kExceptionBehaviorTestData[index].short_name);
   }
 
   for (exception_behavior_t behavior = 0; behavior < 8; ++behavior) {
     SCOPED_TRACE(base::StringPrintf("behavior %d", behavior));
     exception_behavior_t behavior_mach = behavior | MACH_EXCEPTION_CODES;
     if (behavior > 0 && behavior <= EXCEPTION_STATE_IDENTITY) {
       TestExceptionBehaviorToString(behavior, "", "");
       TestExceptionBehaviorToString(behavior_mach, "", "");
     } else {
-      TestExceptionBehaviorToString(behavior, NULL, NULL);
-      TestExceptionBehaviorToString(behavior_mach, NULL, NULL);
+      TestExceptionBehaviorToString(behavior, nullptr, nullptr);
+      TestExceptionBehaviorToString(behavior_mach, nullptr, nullptr);
     }
   }
 }
 
 void TestStringToExceptionBehavior(const base::StringPiece& string,
                                    StringToSymbolicConstantOptions options,
                                    bool expect_result,
                                    exception_behavior_t expect_value) {
   return TestStringToSomething<ConvertExceptionBehaviorTraits>(
       string, options, expect_result, expect_value);
@@ skipping 254 matching lines @@
         flavor <= THREAD_STATE_NONE
 #elif defined(__arm__) || defined(__arm64__)
         (flavor <= ARM_EXCEPTION_STATE64 || flavor == ARM_THREAD_STATE32 ||
          (flavor >= ARM_DEBUG_STATE32 && flavor <= ARM_NEON_STATE64))
 #endif
         ||
         flavor == THREAD_STATE_FLAVOR_LIST_NEW ||
         flavor == THREAD_STATE_FLAVOR_LIST_10_9) {
       TestThreadStateFlavorToString(flavor, "", "");
     } else {
-      TestThreadStateFlavorToString(flavor, NULL, NULL);
+      TestThreadStateFlavorToString(flavor, nullptr, nullptr);
     }
   }
 }
 
 void TestStringToThreadStateFlavor(const base::StringPiece& string,
                                    StringToSymbolicConstantOptions options,
                                    bool expect_result,
                                    thread_state_flavor_t expect_value) {
   return TestStringToSomething<ConvertThreadStateFlavorTraits>(
       string, options, expect_result, expect_value);
@@ skipping 176 matching lines @@
     TestStringToThreadStateFlavor(base::StringPiece("FLAVOR_LIST_NEWS", 15),
                                   kAllowShortName,
                                   true,
                                   THREAD_STATE_FLAVOR_LIST_NEW);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad