runtime/common_runtime_test.cc - LeafOS-Project/android_art - Gitiles

 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
  * 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,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "common_runtime_test.h"

 #include <dirent.h>
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <cstdio>
 #include "nativehelper/scoped_local_ref.h"

 #include "android-base/stringprintf.h"

 #include "art_field-inl.h"
 #include "base/file_utils.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/mem_map.h"
 #include "base/mutex.h"
 #include "base/os.h"
 #include "base/runtime_debug.h"
 #include "base/stl_util.h"
 #include "base/unix_file/fd_file.h"
 #include "class_linker.h"
 #include "class_loader_utils.h"
 #include "compiler_callbacks.h"
 #include "dex/art_dex_file_loader.h"
 #include "dex/dex_file-inl.h"
 #include "dex/dex_file_loader.h"
 #include "dex/primitive.h"
 #include "gc/heap.h"
 #include "gc/space/image_space.h"
 #include "gc_root-inl.h"
 #include "gtest/gtest.h"
 #include "handle_scope-inl.h"
 #include "interpreter/unstarted_runtime.h"
 #include "jni/java_vm_ext.h"
 #include "jni/jni_internal.h"
 #include "mirror/class-alloc-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader-inl.h"
 #include "mirror/object_array-alloc-inl.h"
 #include "native/dalvik_system_DexFile.h"
 #include "noop_compiler_callbacks.h"
 #include "runtime-inl.h"
 #include "scoped_thread_state_change-inl.h"
 #include "thread.h"
 #include "well_known_classes.h"

 namespace art {

 using android::base::StringPrintf;

 static bool unstarted_initialized_ = false;

 CommonRuntimeTestImpl::CommonRuntimeTestImpl()
     : class_linker_(nullptr), java_lang_dex_file_(nullptr) {
 }

 CommonRuntimeTestImpl::~CommonRuntimeTestImpl() {
   // Ensure the dex files are cleaned up before the runtime.
   loaded_dex_files_.clear();
   runtime_.reset();
 }

 std::string CommonRuntimeTestImpl::GetAndroidTargetToolsDir(InstructionSet isa) {
   switch (isa) {
     case InstructionSet::kArm:
     case InstructionSet::kThumb2:
       return GetAndroidToolsDir("prebuilts/gcc/linux-x86/arm",
                                 "arm-linux-androideabi",
                                 "arm-linux-androideabi");
     case InstructionSet::kArm64:
       return GetAndroidToolsDir("prebuilts/gcc/linux-x86/aarch64",
                                 "aarch64-linux-android",
                                 "aarch64-linux-android");
     case InstructionSet::kX86:
     case InstructionSet::kX86_64:
       return GetAndroidToolsDir("prebuilts/gcc/linux-x86/x86",
                                 "x86_64-linux-android",
                                 "x86_64-linux-android");
     case InstructionSet::kMips:
     case InstructionSet::kMips64:
       return GetAndroidToolsDir("prebuilts/gcc/linux-x86/mips",
                                 "mips64el-linux-android",
                                 "mips64el-linux-android");
     case InstructionSet::kNone:
       break;
   }
   ADD_FAILURE() << "Invalid isa " << isa;
   return "";
 }

 void CommonRuntimeTestImpl::SetUp() {
   CommonArtTestImpl::SetUp();

   std::string min_heap_string(StringPrintf("-Xms%zdm", gc::Heap::kDefaultInitialSize / MB));
   std::string max_heap_string(StringPrintf("-Xmx%zdm", gc::Heap::kDefaultMaximumSize / MB));

   RuntimeOptions options;
   std::string boot_class_path_string =
       GetClassPathOption("-Xbootclasspath:", GetLibCoreDexFileNames());
   std::string boot_class_path_locations_string =
       GetClassPathOption("-Xbootclasspath-locations:", GetLibCoreDexLocations());

   options.push_back(std::make_pair(boot_class_path_string, nullptr));
   options.push_back(std::make_pair(boot_class_path_locations_string, nullptr));
   options.push_back(std::make_pair("-Xcheck:jni", nullptr));
   options.push_back(std::make_pair(min_heap_string, nullptr));
   options.push_back(std::make_pair(max_heap_string, nullptr));
   options.push_back(std::make_pair("-XX:SlowDebug=true", nullptr));
   static bool gSlowDebugTestFlag = false;
   RegisterRuntimeDebugFlag(&gSlowDebugTestFlag);

   callbacks_.reset(new NoopCompilerCallbacks());

   SetUpRuntimeOptions(&options);

   // Install compiler-callbacks if SetupRuntimeOptions hasn't deleted them.
   if (callbacks_.get() != nullptr) {
     options.push_back(std::make_pair("compilercallbacks", callbacks_.get()));
   }

   PreRuntimeCreate();
   if (!Runtime::Create(options, false)) {
     LOG(FATAL) << "Failed to create runtime";
     UNREACHABLE();
   }
   PostRuntimeCreate();
   runtime_.reset(Runtime::Current());
   class_linker_ = runtime_->GetClassLinker();

   // Runtime::Create acquired the mutator_lock_ that is normally given away when we
   // Runtime::Start, give it away now and then switch to a more managable ScopedObjectAccess.
   Thread::Current()->TransitionFromRunnableToSuspended(kNative);

   // Get the boot class path from the runtime so it can be used in tests.
   boot_class_path_ = class_linker_->GetBootClassPath();
   ASSERT_FALSE(boot_class_path_.empty());
   java_lang_dex_file_ = boot_class_path_[0];

   FinalizeSetup();

   // Ensure that we're really running with debug checks enabled.
   CHECK(gSlowDebugTestFlag);
 }

 void CommonRuntimeTestImpl::FinalizeSetup() {
   // Initialize maps for unstarted runtime. This needs to be here, as running clinits needs this
   // set up.
   if (!unstarted_initialized_) {
     interpreter::UnstartedRuntime::Initialize();
     unstarted_initialized_ = true;
   }

   {
     ScopedObjectAccess soa(Thread::Current());
     runtime_->RunRootClinits(soa.Self());
   }

   // We're back in native, take the opportunity to initialize well known classes.
   WellKnownClasses::Init(Thread::Current()->GetJniEnv());

   // Create the heap thread pool so that the GC runs in parallel for tests. Normally, the thread
   // pool is created by the runtime.
   runtime_->GetHeap()->CreateThreadPool();
   runtime_->GetHeap()->VerifyHeap();  // Check for heap corruption before the test
   // Reduce timinig-dependent flakiness in OOME behavior (eg StubTest.AllocObject).
   runtime_->GetHeap()->SetMinIntervalHomogeneousSpaceCompactionByOom(0U);
 }

 void CommonRuntimeTestImpl::TearDown() {
   CommonArtTestImpl::TearDown();
   if (runtime_ != nullptr) {
     runtime_->GetHeap()->VerifyHeap();  // Check for heap corruption after the test
   }
 }

 // Check that for target builds we have ART_TARGET_NATIVETEST_DIR set.
 #ifdef ART_TARGET
 #ifndef ART_TARGET_NATIVETEST_DIR
 #error "ART_TARGET_NATIVETEST_DIR not set."
 #endif
 // Wrap it as a string literal.
 #define ART_TARGET_NATIVETEST_DIR_STRING STRINGIFY(ART_TARGET_NATIVETEST_DIR) "/"
 #else
 #define ART_TARGET_NATIVETEST_DIR_STRING ""
 #endif

 std::vector<const DexFile*> CommonRuntimeTestImpl::GetDexFiles(jobject jclass_loader) {
   ScopedObjectAccess soa(Thread::Current());

   StackHandleScope<1> hs(soa.Self());
   Handle<mirror::ClassLoader> class_loader = hs.NewHandle(
       soa.Decode<mirror::ClassLoader>(jclass_loader));
   return GetDexFiles(soa, class_loader);
 }

 std::vector<const DexFile*> CommonRuntimeTestImpl::GetDexFiles(
     ScopedObjectAccess& soa,
     Handle<mirror::ClassLoader> class_loader) {
   DCHECK(
       (class_loader->GetClass() ==
           soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader)) ||
       (class_loader->GetClass() ==
           soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_DelegateLastClassLoader)));

   std::vector<const DexFile*> ret;
   VisitClassLoaderDexFiles(soa,
                            class_loader,
                            [&](const DexFile* cp_dex_file) {
                              if (cp_dex_file == nullptr) {
                                LOG(WARNING) << "Null DexFile";
                              } else {
                                ret.push_back(cp_dex_file);
                              }
                              return true;
                            });
   return ret;
 }

 const DexFile* CommonRuntimeTestImpl::GetFirstDexFile(jobject jclass_loader) {
   std::vector<const DexFile*> tmp(GetDexFiles(jclass_loader));
   DCHECK(!tmp.empty());
   const DexFile* ret = tmp[0];
   DCHECK(ret != nullptr);
   return ret;
 }

 jobject CommonRuntimeTestImpl::LoadMultiDex(const char* first_dex_name,
                                             const char* second_dex_name) {
   std::vector<std::unique_ptr<const DexFile>> first_dex_files = OpenTestDexFiles(first_dex_name);
   std::vector<std::unique_ptr<const DexFile>> second_dex_files = OpenTestDexFiles(second_dex_name);
   std::vector<const DexFile*> class_path;
   CHECK_NE(0U, first_dex_files.size());
   CHECK_NE(0U, second_dex_files.size());
   for (auto& dex_file : first_dex_files) {
     class_path.push_back(dex_file.get());
     loaded_dex_files_.push_back(std::move(dex_file));
   }
   for (auto& dex_file : second_dex_files) {
     class_path.push_back(dex_file.get());
     loaded_dex_files_.push_back(std::move(dex_file));
   }

   Thread* self = Thread::Current();
   jobject class_loader = Runtime::Current()->GetClassLinker()->CreatePathClassLoader(self,
                                                                                      class_path);
   self->SetClassLoaderOverride(class_loader);
   return class_loader;
 }

 jobject CommonRuntimeTestImpl::LoadDex(const char* dex_name) {
   jobject class_loader = LoadDexInPathClassLoader(dex_name, nullptr);
   Thread::Current()->SetClassLoaderOverride(class_loader);
   return class_loader;
 }

 jobject CommonRuntimeTestImpl::LoadDexInWellKnownClassLoader(const std::string& dex_name,
                                                              jclass loader_class,
                                                              jobject parent_loader,
                                                              jobject shared_libraries) {
   std::vector<std::unique_ptr<const DexFile>> dex_files = OpenTestDexFiles(dex_name.c_str());
   std::vector<const DexFile*> class_path;
   CHECK_NE(0U, dex_files.size());
   for (auto& dex_file : dex_files) {
     class_path.push_back(dex_file.get());
     loaded_dex_files_.push_back(std::move(dex_file));
   }
   Thread* self = Thread::Current();
   ScopedObjectAccess soa(self);

   jobject result = Runtime::Current()->GetClassLinker()->CreateWellKnownClassLoader(
       self,
       class_path,
       loader_class,
       parent_loader,
       shared_libraries);

   {
     // Verify we build the correct chain.

     ObjPtr<mirror::ClassLoader> actual_class_loader = soa.Decode<mirror::ClassLoader>(result);
     // Verify that the result has the correct class.
     CHECK_EQ(soa.Decode<mirror::Class>(loader_class), actual_class_loader->GetClass());
     // Verify that the parent is not null. The boot class loader will be set up as a
     // proper object.
     ObjPtr<mirror::ClassLoader> actual_parent(actual_class_loader->GetParent());
     CHECK(actual_parent != nullptr);

     if (parent_loader != nullptr) {
       // We were given a parent. Verify that it's what we expect.
       ObjPtr<mirror::ClassLoader> expected_parent = soa.Decode<mirror::ClassLoader>(parent_loader);
       CHECK_EQ(expected_parent, actual_parent);
     } else {
       // No parent given. The parent must be the BootClassLoader.
       CHECK(Runtime::Current()->GetClassLinker()->IsBootClassLoader(soa, actual_parent));
     }
   }

   return result;
 }

 jobject CommonRuntimeTestImpl::LoadDexInPathClassLoader(const std::string& dex_name,
                                                         jobject parent_loader,
                                                         jobject shared_libraries) {
   return LoadDexInWellKnownClassLoader(dex_name,
                                        WellKnownClasses::dalvik_system_PathClassLoader,
                                        parent_loader,
                                        shared_libraries);
 }

 jobject CommonRuntimeTestImpl::LoadDexInDelegateLastClassLoader(const std::string& dex_name,
                                                                 jobject parent_loader) {
   return LoadDexInWellKnownClassLoader(dex_name,
                                        WellKnownClasses::dalvik_system_DelegateLastClassLoader,
                                        parent_loader);
 }

 jobject CommonRuntimeTestImpl::LoadDexInInMemoryDexClassLoader(const std::string& dex_name,
                                                                jobject parent_loader) {
   return LoadDexInWellKnownClassLoader(dex_name,
                                        WellKnownClasses::dalvik_system_InMemoryDexClassLoader,
                                        parent_loader);
 }

 void CommonRuntimeTestImpl::FillHeap(Thread* self,
                                      ClassLinker* class_linker,
                                      VariableSizedHandleScope* handle_scope) {
   DCHECK(handle_scope != nullptr);

   Runtime::Current()->GetHeap()->SetIdealFootprint(1 * GB);

   // Class java.lang.Object.
   Handle<mirror::Class> c(handle_scope->NewHandle(
       class_linker->FindSystemClass(self, "Ljava/lang/Object;")));
   // Array helps to fill memory faster.
   Handle<mirror::Class> ca(handle_scope->NewHandle(
       class_linker->FindSystemClass(self, "[Ljava/lang/Object;")));

   // Start allocating with ~128K
   size_t length = 128 * KB;
   while (length > 40) {
     const int32_t array_length = length / 4;  // Object[] has elements of size 4.
     MutableHandle<mirror::Object> h(handle_scope->NewHandle<mirror::Object>(
         mirror::ObjectArray<mirror::Object>::Alloc(self, ca.Get(), array_length)));
     if (self->IsExceptionPending() || h == nullptr) {
       self->ClearException();

       // Try a smaller length
       length = length / 2;
       // Use at most a quarter the reported free space.
       size_t mem = Runtime::Current()->GetHeap()->GetFreeMemory();
       if (length * 4 > mem) {
         length = mem / 4;
       }
     }
   }

   // Allocate simple objects till it fails.
   while (!self->IsExceptionPending()) {
     handle_scope->NewHandle<mirror::Object>(c->AllocObject(self));
   }
   self->ClearException();
 }

 void CommonRuntimeTestImpl::SetUpRuntimeOptionsForFillHeap(RuntimeOptions *options) {
   // Use a smaller heap
   bool found = false;
   for (std::pair<std::string, const void*>& pair : *options) {
     if (pair.first.find("-Xmx") == 0) {
       pair.first = "-Xmx4M";  // Smallest we can go.
       found = true;
     }
   }
   if (!found) {
     options->emplace_back("-Xmx4M", nullptr);
   }
 }

 void CommonRuntimeTestImpl::MakeInterpreted(ObjPtr<mirror::Class> klass) {
   PointerSize pointer_size = class_linker_->GetImagePointerSize();
   for (ArtMethod& method : klass->GetMethods(pointer_size)) {
     class_linker_->SetEntryPointsToInterpreter(&method);
   }
 }

 bool CommonRuntimeTestImpl::StartDex2OatCommandLine(/*out*/std::vector<std::string>* argv,
                                                     /*out*/std::string* error_msg) {
   DCHECK(argv != nullptr);
   DCHECK(argv->empty());

   Runtime* runtime = Runtime::Current();
   const std::vector<gc::space::ImageSpace*>& image_spaces =
       runtime->GetHeap()->GetBootImageSpaces();
   if (image_spaces.empty()) {
     *error_msg = "No image location found for Dex2Oat.";
     return false;
   }
   std::string image_location = image_spaces[0]->GetImageLocation();

   argv->push_back(runtime->GetCompilerExecutable());
   if (runtime->IsJavaDebuggable()) {
     argv->push_back("--debuggable");
   }
   runtime->AddCurrentRuntimeFeaturesAsDex2OatArguments(argv);

   argv->push_back("--runtime-arg");
   argv->push_back(GetClassPathOption("-Xbootclasspath:", GetLibCoreDexFileNames()));
   argv->push_back("--runtime-arg");
   argv->push_back(GetClassPathOption("-Xbootclasspath-locations:", GetLibCoreDexLocations()));

   argv->push_back("--boot-image=" + image_location);

   std::vector<std::string> compiler_options = runtime->GetCompilerOptions();
   argv->insert(argv->end(), compiler_options.begin(), compiler_options.end());
   return true;
 }

 CheckJniAbortCatcher::CheckJniAbortCatcher() : vm_(Runtime::Current()->GetJavaVM()) {
   vm_->SetCheckJniAbortHook(Hook, &actual_);
 }

 CheckJniAbortCatcher::~CheckJniAbortCatcher() {
   vm_->SetCheckJniAbortHook(nullptr, nullptr);
   EXPECT_TRUE(actual_.empty()) << actual_;
 }

 void CheckJniAbortCatcher::Check(const std::string& expected_text) {
   Check(expected_text.c_str());
 }

 void CheckJniAbortCatcher::Check(const char* expected_text) {
   EXPECT_TRUE(actual_.find(expected_text) != std::string::npos) << "\n"
       << "Expected to find: " << expected_text << "\n"
       << "In the output   : " << actual_;
   actual_.clear();
 }

 void CheckJniAbortCatcher::Hook(void* data, const std::string& reason) {
   // We use += because when we're hooking the aborts like this, multiple problems can be found.
   *reinterpret_cast<std::string*>(data) += reason;
 }

 }  // namespace art

 // Allow other test code to run global initialization/configuration before
 // gtest infra takes over.
 extern "C"
 __attribute__((visibility("default"))) __attribute__((weak))
 void ArtTestGlobalInit() {
   LOG(ERROR) << "ArtTestGlobalInit in common_runtime_test";
 }

 int main(int argc, char **argv) {
   // Gtests can be very noisy. For example, an executable with multiple tests will trigger native
   // bridge warnings. The following line reduces the minimum log severity to ERROR and suppresses
   // everything else. In case you want to see all messages, comment out the line.
   setenv("ANDROID_LOG_TAGS", "*:e", 1);

   art::Locks::Init();
   art::InitLogging(argv, art::Runtime::Abort);
   art::MemMap::Init();
   LOG(INFO) << "Running main() from common_runtime_test.cc...";
   testing::InitGoogleTest(&argc, argv);
   ArtTestGlobalInit();
   return RUN_ALL_TESTS();
 }
	/*
	* Copyright (C) 2012 The Android Open Source Project
	*
	* 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,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "common_runtime_test.h"

	#include <dirent.h>
	#include <dlfcn.h>
	#include <fcntl.h>
	#include <stdlib.h>
	#include <cstdio>
	#include "nativehelper/scoped_local_ref.h"

	#include "android-base/stringprintf.h"

	#include "art_field-inl.h"
	#include "base/file_utils.h"
	#include "base/logging.h"
	#include "base/macros.h"
	#include "base/mem_map.h"
	#include "base/mutex.h"
	#include "base/os.h"
	#include "base/runtime_debug.h"
	#include "base/stl_util.h"
	#include "base/unix_file/fd_file.h"
	#include "class_linker.h"
	#include "class_loader_utils.h"
	#include "compiler_callbacks.h"
	#include "dex/art_dex_file_loader.h"
	#include "dex/dex_file-inl.h"
	#include "dex/dex_file_loader.h"
	#include "dex/primitive.h"
	#include "gc/heap.h"
	#include "gc/space/image_space.h"
	#include "gc_root-inl.h"
	#include "gtest/gtest.h"
	#include "handle_scope-inl.h"
	#include "interpreter/unstarted_runtime.h"
	#include "jni/java_vm_ext.h"
	#include "jni/jni_internal.h"
	#include "mirror/class-alloc-inl.h"
	#include "mirror/class-inl.h"
	#include "mirror/class_loader-inl.h"
	#include "mirror/object_array-alloc-inl.h"
	#include "native/dalvik_system_DexFile.h"
	#include "noop_compiler_callbacks.h"
	#include "runtime-inl.h"
	#include "scoped_thread_state_change-inl.h"
	#include "thread.h"
	#include "well_known_classes.h"

	namespace art {

	using android::base::StringPrintf;

	static bool unstarted_initialized_ = false;

	CommonRuntimeTestImpl::CommonRuntimeTestImpl()
	: class_linker_(nullptr), java_lang_dex_file_(nullptr) {
	}

	CommonRuntimeTestImpl::~CommonRuntimeTestImpl() {
	// Ensure the dex files are cleaned up before the runtime.
	loaded_dex_files_.clear();
	runtime_.reset();
	}

	std::string CommonRuntimeTestImpl::GetAndroidTargetToolsDir(InstructionSet isa) {
	switch (isa) {
	case InstructionSet::kArm:
	case InstructionSet::kThumb2:
	return GetAndroidToolsDir("prebuilts/gcc/linux-x86/arm",
	"arm-linux-androideabi",
	"arm-linux-androideabi");
	case InstructionSet::kArm64:
	return GetAndroidToolsDir("prebuilts/gcc/linux-x86/aarch64",
	"aarch64-linux-android",
	"aarch64-linux-android");
	case InstructionSet::kX86:
	case InstructionSet::kX86_64:
	return GetAndroidToolsDir("prebuilts/gcc/linux-x86/x86",
	"x86_64-linux-android",
	"x86_64-linux-android");
	case InstructionSet::kMips:
	case InstructionSet::kMips64:
	return GetAndroidToolsDir("prebuilts/gcc/linux-x86/mips",
	"mips64el-linux-android",
	"mips64el-linux-android");
	case InstructionSet::kNone:
	break;
	}
	ADD_FAILURE() << "Invalid isa " << isa;
	return "";
	}

	void CommonRuntimeTestImpl::SetUp() {
	CommonArtTestImpl::SetUp();

	std::string min_heap_string(StringPrintf("-Xms%zdm", gc::Heap::kDefaultInitialSize / MB));
	std::string max_heap_string(StringPrintf("-Xmx%zdm", gc::Heap::kDefaultMaximumSize / MB));

	RuntimeOptions options;
	std::string boot_class_path_string =
	GetClassPathOption("-Xbootclasspath:", GetLibCoreDexFileNames());
	std::string boot_class_path_locations_string =
	GetClassPathOption("-Xbootclasspath-locations:", GetLibCoreDexLocations());

	options.push_back(std::make_pair(boot_class_path_string, nullptr));
	options.push_back(std::make_pair(boot_class_path_locations_string, nullptr));
	options.push_back(std::make_pair("-Xcheck:jni", nullptr));
	options.push_back(std::make_pair(min_heap_string, nullptr));
	options.push_back(std::make_pair(max_heap_string, nullptr));
	options.push_back(std::make_pair("-XX:SlowDebug=true", nullptr));
	static bool gSlowDebugTestFlag = false;
	RegisterRuntimeDebugFlag(&gSlowDebugTestFlag);

	callbacks_.reset(new NoopCompilerCallbacks());

	SetUpRuntimeOptions(&options);

	// Install compiler-callbacks if SetupRuntimeOptions hasn't deleted them.
	if (callbacks_.get() != nullptr) {
	options.push_back(std::make_pair("compilercallbacks", callbacks_.get()));
	}

	PreRuntimeCreate();
	if (!Runtime::Create(options, false)) {
	LOG(FATAL) << "Failed to create runtime";
	UNREACHABLE();
	}
	PostRuntimeCreate();
	runtime_.reset(Runtime::Current());
	class_linker_ = runtime_->GetClassLinker();

	// Runtime::Create acquired the mutator_lock_ that is normally given away when we
	// Runtime::Start, give it away now and then switch to a more managable ScopedObjectAccess.
	Thread::Current()->TransitionFromRunnableToSuspended(kNative);

	// Get the boot class path from the runtime so it can be used in tests.
	boot_class_path_ = class_linker_->GetBootClassPath();
	ASSERT_FALSE(boot_class_path_.empty());
	java_lang_dex_file_ = boot_class_path_[0];

	FinalizeSetup();

	// Ensure that we're really running with debug checks enabled.
	CHECK(gSlowDebugTestFlag);
	}

	void CommonRuntimeTestImpl::FinalizeSetup() {
	// Initialize maps for unstarted runtime. This needs to be here, as running clinits needs this
	// set up.
	if (!unstarted_initialized_) {
	interpreter::UnstartedRuntime::Initialize();
	unstarted_initialized_ = true;
	}

	{
	ScopedObjectAccess soa(Thread::Current());
	runtime_->RunRootClinits(soa.Self());
	}

	// We're back in native, take the opportunity to initialize well known classes.
	WellKnownClasses::Init(Thread::Current()->GetJniEnv());

	// Create the heap thread pool so that the GC runs in parallel for tests. Normally, the thread
	// pool is created by the runtime.
	runtime_->GetHeap()->CreateThreadPool();
	runtime_->GetHeap()->VerifyHeap(); // Check for heap corruption before the test
	// Reduce timinig-dependent flakiness in OOME behavior (eg StubTest.AllocObject).
	runtime_->GetHeap()->SetMinIntervalHomogeneousSpaceCompactionByOom(0U);
	}

	void CommonRuntimeTestImpl::TearDown() {
	CommonArtTestImpl::TearDown();
	if (runtime_ != nullptr) {
	runtime_->GetHeap()->VerifyHeap(); // Check for heap corruption after the test
	}
	}

	// Check that for target builds we have ART_TARGET_NATIVETEST_DIR set.
	#ifdef ART_TARGET
	#ifndef ART_TARGET_NATIVETEST_DIR
	#error "ART_TARGET_NATIVETEST_DIR not set."
	#endif
	// Wrap it as a string literal.
	#define ART_TARGET_NATIVETEST_DIR_STRING STRINGIFY(ART_TARGET_NATIVETEST_DIR) "/"
	#else
	#define ART_TARGET_NATIVETEST_DIR_STRING ""
	#endif

	std::vector<const DexFile*> CommonRuntimeTestImpl::GetDexFiles(jobject jclass_loader) {
	ScopedObjectAccess soa(Thread::Current());

	StackHandleScope<1> hs(soa.Self());
	Handle<mirror::ClassLoader> class_loader = hs.NewHandle(
	soa.Decode<mirror::ClassLoader>(jclass_loader));
	return GetDexFiles(soa, class_loader);
	}

	std::vector<const DexFile*> CommonRuntimeTestImpl::GetDexFiles(
	ScopedObjectAccess& soa,
	Handle<mirror::ClassLoader> class_loader) {
	DCHECK(
	(class_loader->GetClass() ==
	soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader)) \|\|
	(class_loader->GetClass() ==
	soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_DelegateLastClassLoader)));

	std::vector<const DexFile*> ret;
	VisitClassLoaderDexFiles(soa,
	class_loader,
	[&](const DexFile* cp_dex_file) {
	if (cp_dex_file == nullptr) {
	LOG(WARNING) << "Null DexFile";
	} else {
	ret.push_back(cp_dex_file);
	}
	return true;
	});
	return ret;
	}

	const DexFile* CommonRuntimeTestImpl::GetFirstDexFile(jobject jclass_loader) {
	std::vector<const DexFile*> tmp(GetDexFiles(jclass_loader));
	DCHECK(!tmp.empty());
	const DexFile* ret = tmp[0];
	DCHECK(ret != nullptr);
	return ret;
	}

	jobject CommonRuntimeTestImpl::LoadMultiDex(const char* first_dex_name,
	const char* second_dex_name) {
	std::vector<std::unique_ptr<const DexFile>> first_dex_files = OpenTestDexFiles(first_dex_name);
	std::vector<std::unique_ptr<const DexFile>> second_dex_files = OpenTestDexFiles(second_dex_name);
	std::vector<const DexFile*> class_path;
	CHECK_NE(0U, first_dex_files.size());
	CHECK_NE(0U, second_dex_files.size());
	for (auto& dex_file : first_dex_files) {
	class_path.push_back(dex_file.get());
	loaded_dex_files_.push_back(std::move(dex_file));
	}
	for (auto& dex_file : second_dex_files) {
	class_path.push_back(dex_file.get());
	loaded_dex_files_.push_back(std::move(dex_file));
	}

	Thread* self = Thread::Current();
	jobject class_loader = Runtime::Current()->GetClassLinker()->CreatePathClassLoader(self,
	class_path);
	self->SetClassLoaderOverride(class_loader);
	return class_loader;
	}

	jobject CommonRuntimeTestImpl::LoadDex(const char* dex_name) {
	jobject class_loader = LoadDexInPathClassLoader(dex_name, nullptr);
	Thread::Current()->SetClassLoaderOverride(class_loader);
	return class_loader;
	}

	jobject CommonRuntimeTestImpl::LoadDexInWellKnownClassLoader(const std::string& dex_name,
	jclass loader_class,
	jobject parent_loader,
	jobject shared_libraries) {
	std::vector<std::unique_ptr<const DexFile>> dex_files = OpenTestDexFiles(dex_name.c_str());
	std::vector<const DexFile*> class_path;
	CHECK_NE(0U, dex_files.size());
	for (auto& dex_file : dex_files) {
	class_path.push_back(dex_file.get());
	loaded_dex_files_.push_back(std::move(dex_file));
	}
	Thread* self = Thread::Current();
	ScopedObjectAccess soa(self);

	jobject result = Runtime::Current()->GetClassLinker()->CreateWellKnownClassLoader(
	self,
	class_path,
	loader_class,
	parent_loader,
	shared_libraries);

	{
	// Verify we build the correct chain.

	ObjPtr<mirror::ClassLoader> actual_class_loader = soa.Decode<mirror::ClassLoader>(result);
	// Verify that the result has the correct class.
	CHECK_EQ(soa.Decode<mirror::Class>(loader_class), actual_class_loader->GetClass());
	// Verify that the parent is not null. The boot class loader will be set up as a
	// proper object.
	ObjPtr<mirror::ClassLoader> actual_parent(actual_class_loader->GetParent());
	CHECK(actual_parent != nullptr);

	if (parent_loader != nullptr) {
	// We were given a parent. Verify that it's what we expect.
	ObjPtr<mirror::ClassLoader> expected_parent = soa.Decode<mirror::ClassLoader>(parent_loader);
	CHECK_EQ(expected_parent, actual_parent);
	} else {
	// No parent given. The parent must be the BootClassLoader.
	CHECK(Runtime::Current()->GetClassLinker()->IsBootClassLoader(soa, actual_parent));
	}
	}

	return result;
	}

	jobject CommonRuntimeTestImpl::LoadDexInPathClassLoader(const std::string& dex_name,
	jobject parent_loader,
	jobject shared_libraries) {
	return LoadDexInWellKnownClassLoader(dex_name,
	WellKnownClasses::dalvik_system_PathClassLoader,
	parent_loader,
	shared_libraries);
	}

	jobject CommonRuntimeTestImpl::LoadDexInDelegateLastClassLoader(const std::string& dex_name,
	jobject parent_loader) {
	return LoadDexInWellKnownClassLoader(dex_name,
	WellKnownClasses::dalvik_system_DelegateLastClassLoader,
	parent_loader);
	}

	jobject CommonRuntimeTestImpl::LoadDexInInMemoryDexClassLoader(const std::string& dex_name,
	jobject parent_loader) {
	return LoadDexInWellKnownClassLoader(dex_name,
	WellKnownClasses::dalvik_system_InMemoryDexClassLoader,
	parent_loader);
	}

	void CommonRuntimeTestImpl::FillHeap(Thread* self,
	ClassLinker* class_linker,
	VariableSizedHandleScope* handle_scope) {
	DCHECK(handle_scope != nullptr);

	Runtime::Current()->GetHeap()->SetIdealFootprint(1 * GB);

	// Class java.lang.Object.
	Handle<mirror::Class> c(handle_scope->NewHandle(
	class_linker->FindSystemClass(self, "Ljava/lang/Object;")));
	// Array helps to fill memory faster.
	Handle<mirror::Class> ca(handle_scope->NewHandle(
	class_linker->FindSystemClass(self, "[Ljava/lang/Object;")));

	// Start allocating with ~128K
	size_t length = 128 * KB;
	while (length > 40) {
	const int32_t array_length = length / 4; // Object[] has elements of size 4.
	MutableHandle<mirror::Object> h(handle_scope->NewHandle<mirror::Object>(
	mirror::ObjectArray<mirror::Object>::Alloc(self, ca.Get(), array_length)));
	if (self->IsExceptionPending() \|\| h == nullptr) {
	self->ClearException();

	// Try a smaller length
	length = length / 2;
	// Use at most a quarter the reported free space.
	size_t mem = Runtime::Current()->GetHeap()->GetFreeMemory();
	if (length * 4 > mem) {
	length = mem / 4;
	}
	}
	}

	// Allocate simple objects till it fails.
	while (!self->IsExceptionPending()) {
	handle_scope->NewHandle<mirror::Object>(c->AllocObject(self));
	}
	self->ClearException();
	}

	void CommonRuntimeTestImpl::SetUpRuntimeOptionsForFillHeap(RuntimeOptions *options) {
	// Use a smaller heap
	bool found = false;
	for (std::pair<std::string, const void>& pair : options) {
	if (pair.first.find("-Xmx") == 0) {
	pair.first = "-Xmx4M"; // Smallest we can go.
	found = true;
	}
	}
	if (!found) {
	options->emplace_back("-Xmx4M", nullptr);
	}
	}

	void CommonRuntimeTestImpl::MakeInterpreted(ObjPtr<mirror::Class> klass) {
	PointerSize pointer_size = class_linker_->GetImagePointerSize();
	for (ArtMethod& method : klass->GetMethods(pointer_size)) {
	class_linker_->SetEntryPointsToInterpreter(&method);
	}
	}

	bool CommonRuntimeTestImpl::StartDex2OatCommandLine(/out/std::vector<std::string>* argv,
	/out/std::string* error_msg) {
	DCHECK(argv != nullptr);
	DCHECK(argv->empty());

	Runtime* runtime = Runtime::Current();
	const std::vector<gc::space::ImageSpace*>& image_spaces =
	runtime->GetHeap()->GetBootImageSpaces();
	if (image_spaces.empty()) {
	*error_msg = "No image location found for Dex2Oat.";
	return false;
	}
	std::string image_location = image_spaces[0]->GetImageLocation();

	argv->push_back(runtime->GetCompilerExecutable());
	if (runtime->IsJavaDebuggable()) {
	argv->push_back("--debuggable");
	}
	runtime->AddCurrentRuntimeFeaturesAsDex2OatArguments(argv);

	argv->push_back("--runtime-arg");
	argv->push_back(GetClassPathOption("-Xbootclasspath:", GetLibCoreDexFileNames()));
	argv->push_back("--runtime-arg");
	argv->push_back(GetClassPathOption("-Xbootclasspath-locations:", GetLibCoreDexLocations()));

	argv->push_back("--boot-image=" + image_location);

	std::vector<std::string> compiler_options = runtime->GetCompilerOptions();
	argv->insert(argv->end(), compiler_options.begin(), compiler_options.end());
	return true;
	}

	CheckJniAbortCatcher::CheckJniAbortCatcher() : vm_(Runtime::Current()->GetJavaVM()) {
	vm_->SetCheckJniAbortHook(Hook, &actual_);
	}

	CheckJniAbortCatcher::~CheckJniAbortCatcher() {
	vm_->SetCheckJniAbortHook(nullptr, nullptr);
	EXPECT_TRUE(actual_.empty()) << actual_;
	}

	void CheckJniAbortCatcher::Check(const std::string& expected_text) {
	Check(expected_text.c_str());
	}

	void CheckJniAbortCatcher::Check(const char* expected_text) {
	EXPECT_TRUE(actual_.find(expected_text) != std::string::npos) << "\n"
	<< "Expected to find: " << expected_text << "\n"
	<< "In the output : " << actual_;
	actual_.clear();
	}

	void CheckJniAbortCatcher::Hook(void* data, const std::string& reason) {
	// We use += because when we're hooking the aborts like this, multiple problems can be found.
	reinterpret_cast<std::string>(data) += reason;
	}

	} // namespace art

	// Allow other test code to run global initialization/configuration before
	// gtest infra takes over.
	extern "C"
	__attribute__((visibility("default"))) __attribute__((weak))
	void ArtTestGlobalInit() {
	LOG(ERROR) << "ArtTestGlobalInit in common_runtime_test";
	}

	int main(int argc, char **argv) {
	// Gtests can be very noisy. For example, an executable with multiple tests will trigger native
	// bridge warnings. The following line reduces the minimum log severity to ERROR and suppresses
	// everything else. In case you want to see all messages, comment out the line.
	setenv("ANDROID_LOG_TAGS", "*:e", 1);

	art::Locks::Init();
	art::InitLogging(argv, art::Runtime::Abort);
	art::MemMap::Init();
	LOG(INFO) << "Running main() from common_runtime_test.cc...";
	testing::InitGoogleTest(&argc, argv);
	ArtTestGlobalInit();
	return RUN_ALL_TESTS();
	}