Replace NULL with nullptr

Also fixed some lines that were too long, and a few other minor
details.

Change-Id: I6efba5fb6e03eb5d0a300fddb2a75bf8e2f175cb

1 files changed, 15 insertions, 16 deletions

diff --git a/compiler/driver/compiler_driver_test.cc b/compiler/driver/compiler_driver_test.cc
index ded50ca105..5085f32aec 100644
--- a/compiler/driver/compiler_driver_test.cc
+++ b/compiler/driver/compiler_driver_test.cc
@@ -56,20 +56,20 @@ class CompilerDriverTest : public CommonCompilerTest {
     CHECK(started);
     env_ = Thread::Current()->GetJniEnv();
     class_ = env_->FindClass(class_name);
-    CHECK(class_ != NULL) << "Class not found: " << class_name;
+    CHECK(class_ != nullptr) << "Class not found: " << class_name;
     if (is_virtual) {
       mid_ = env_->GetMethodID(class_, method, signature);
     } else {
       mid_ = env_->GetStaticMethodID(class_, method, signature);
     }
-    CHECK(mid_ != NULL) << "Method not found: " << class_name << "." << method << signature;
+    CHECK(mid_ != nullptr) << "Method not found: " << class_name << "." << method << signature;
   }
 
   void MakeAllExecutable(jobject class_loader) {
     const std::vector<const DexFile*> class_path = GetDexFiles(class_loader);
     for (size_t i = 0; i != class_path.size(); ++i) {
       const DexFile* dex_file = class_path[i];
-      CHECK(dex_file != NULL);
+      CHECK(dex_file != nullptr);
       MakeDexFileExecutable(class_loader, *dex_file);
     }
   }
@@ -84,7 +84,7 @@ class CompilerDriverTest : public CommonCompilerTest {
       Handle<mirror::ClassLoader> loader(
           hs.NewHandle(soa.Decode<mirror::ClassLoader*>(class_loader)));
       mirror::Class* c = class_linker->FindClass(soa.Self(), descriptor, loader);
-      CHECK(c != NULL);
+      CHECK(c != nullptr);
       for (size_t j = 0; j < c->NumDirectMethods(); j++) {
         MakeExecutable(c->GetDirectMethod(j));
       }
@@ -101,39 +101,38 @@ class CompilerDriverTest : public CommonCompilerTest {
 
 // Disabled due to 10 second runtime on host
 TEST_F(CompilerDriverTest, DISABLED_LARGE_CompileDexLibCore) {
-  CompileAll(NULL);
+  CompileAll(nullptr);
 
   // All libcore references should resolve
   ScopedObjectAccess soa(Thread::Current());
-  ASSERT_TRUE(java_lang_dex_file_ != NULL);
+  ASSERT_TRUE(java_lang_dex_file_ != nullptr);
   const DexFile& dex = *java_lang_dex_file_;
   mirror::DexCache* dex_cache = class_linker_->FindDexCache(dex);
   EXPECT_EQ(dex.NumStringIds(), dex_cache->NumStrings());
   for (size_t i = 0; i < dex_cache->NumStrings(); i++) {
     const mirror::String* string = dex_cache->GetResolvedString(i);
-    EXPECT_TRUE(string != NULL) << "string_idx=" << i;
+    EXPECT_TRUE(string != nullptr) << "string_idx=" << i;
   }
   EXPECT_EQ(dex.NumTypeIds(), dex_cache->NumResolvedTypes());
   for (size_t i = 0; i < dex_cache->NumResolvedTypes(); i++) {
     mirror::Class* type = dex_cache->GetResolvedType(i);
-    EXPECT_TRUE(type != NULL) << "type_idx=" << i
+    EXPECT_TRUE(type != nullptr) << "type_idx=" << i
                               << " " << dex.GetTypeDescriptor(dex.GetTypeId(i));
   }
   EXPECT_EQ(dex.NumMethodIds(), dex_cache->NumResolvedMethods());
   for (size_t i = 0; i < dex_cache->NumResolvedMethods(); i++) {
     mirror::ArtMethod* method = dex_cache->GetResolvedMethod(i);
-    EXPECT_TRUE(method != NULL) << "method_idx=" << i
+    EXPECT_TRUE(method != nullptr) << "method_idx=" << i
                                 << " " << dex.GetMethodDeclaringClassDescriptor(dex.GetMethodId(i))
                                 << " " << dex.GetMethodName(dex.GetMethodId(i));
-    EXPECT_TRUE(method->GetEntryPointFromQuickCompiledCode() != NULL) << "method_idx=" << i
-                                           << " "
-                                           << dex.GetMethodDeclaringClassDescriptor(dex.GetMethodId(i))
-                                           << " " << dex.GetMethodName(dex.GetMethodId(i));
+    EXPECT_TRUE(method->GetEntryPointFromQuickCompiledCode() != nullptr) << "method_idx=" << i
+        << " " << dex.GetMethodDeclaringClassDescriptor(dex.GetMethodId(i)) << " "
+        << dex.GetMethodName(dex.GetMethodId(i));
   }
   EXPECT_EQ(dex.NumFieldIds(), dex_cache->NumResolvedFields());
   for (size_t i = 0; i < dex_cache->NumResolvedFields(); i++) {
     ArtField* field = Runtime::Current()->GetClassLinker()->GetResolvedField(i, dex_cache);
-    EXPECT_TRUE(field != NULL) << "field_idx=" << i
+    EXPECT_TRUE(field != nullptr) << "field_idx=" << i
                                << " " << dex.GetFieldDeclaringClassDescriptor(dex.GetFieldId(i))
                                << " " << dex.GetFieldName(dex.GetFieldId(i));
   }
@@ -153,14 +152,14 @@ TEST_F(CompilerDriverTest, AbstractMethodErrorStub) {
     CompileDirectMethod(NullHandle<mirror::ClassLoader>(), "java.lang.Object", "<init>", "()V");
     class_loader = LoadDex("AbstractMethod");
   }
-  ASSERT_TRUE(class_loader != NULL);
+  ASSERT_TRUE(class_loader != nullptr);
   EnsureCompiled(class_loader, "AbstractClass", "foo", "()V", true);
 
   // Create a jobj_ of ConcreteClass, NOT AbstractClass.
   jclass c_class = env_->FindClass("ConcreteClass");
   jmethodID constructor = env_->GetMethodID(c_class, "<init>", "()V");
   jobject jobj_ = env_->NewObject(c_class, constructor);
-  ASSERT_TRUE(jobj_ != NULL);
+  ASSERT_TRUE(jobj_ != nullptr);
 
   // Force non-virtual call to AbstractClass foo, will throw AbstractMethodError exception.
   env_->CallNonvirtualVoidMethod(jobj_, class_, mid_);