/* * 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 <unicode/uvernum.h> #include "art_field-inl.h" #include "base/file_utils.h" #include "base/logging.h" #include "base/macros.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_root-inl.h" #include "gtest/gtest.h" #include "handle_scope-inl.h" #include "interpreter/unstarted_runtime.h" #include "java_vm_ext.h" #include "jni_internal.h" #include "mem_map.h" #include "mirror/class-inl.h" #include "mirror/class_loader.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" 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); LOG(INFO) << "Running main() from common_runtime_test.cc..."; testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } namespace art { using android::base::StringPrintf; ScratchFile::ScratchFile() { // ANDROID_DATA needs to be set CHECK_NE(static_cast<char*>(nullptr), getenv("ANDROID_DATA")) << "Are you subclassing RuntimeTest?"; filename_ = getenv("ANDROID_DATA"); filename_ += "/TmpFile-XXXXXX"; int fd = mkstemp(&filename_[0]); CHECK_NE(-1, fd) << strerror(errno) << " for " << filename_; file_.reset(new File(fd, GetFilename(), true)); } ScratchFile::ScratchFile(const ScratchFile& other, const char* suffix) : ScratchFile(other.GetFilename() + suffix) {} ScratchFile::ScratchFile(const std::string& filename) : filename_(filename) { int fd = open(filename_.c_str(), O_RDWR | O_CREAT, 0666); CHECK_NE(-1, fd); file_.reset(new File(fd, GetFilename(), true)); } ScratchFile::ScratchFile(File* file) { CHECK(file != nullptr); filename_ = file->GetPath(); file_.reset(file); } ScratchFile::ScratchFile(ScratchFile&& other) { *this = std::move(other); } ScratchFile& ScratchFile::operator=(ScratchFile&& other) { if (GetFile() != other.GetFile()) { std::swap(filename_, other.filename_); std::swap(file_, other.file_); } return *this; } ScratchFile::~ScratchFile() { Unlink(); } int ScratchFile::GetFd() const { return file_->Fd(); } void ScratchFile::Close() { if (file_.get() != nullptr) { if (file_->FlushCloseOrErase() != 0) { PLOG(WARNING) << "Error closing scratch file."; } } } void ScratchFile::Unlink() { if (!OS::FileExists(filename_.c_str())) { return; } Close(); int unlink_result = unlink(filename_.c_str()); CHECK_EQ(0, unlink_result); } 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(); } void CommonRuntimeTestImpl::SetUpAndroidRoot() { if (IsHost()) { // $ANDROID_ROOT is set on the device, but not necessarily on the host. // But it needs to be set so that icu4c can find its locale data. const char* android_root_from_env = getenv("ANDROID_ROOT"); if (android_root_from_env == nullptr) { // Use ANDROID_HOST_OUT for ANDROID_ROOT if it is set. const char* android_host_out = getenv("ANDROID_HOST_OUT"); if (android_host_out != nullptr) { setenv("ANDROID_ROOT", android_host_out, 1); } else { // Build it from ANDROID_BUILD_TOP or cwd std::string root; const char* android_build_top = getenv("ANDROID_BUILD_TOP"); if (android_build_top != nullptr) { root += android_build_top; } else { // Not set by build server, so default to current directory char* cwd = getcwd(nullptr, 0); setenv("ANDROID_BUILD_TOP", cwd, 1); root += cwd; free(cwd); } #if defined(__linux__) root += "/out/host/linux-x86"; #elif defined(__APPLE__) root += "/out/host/darwin-x86"; #else #error unsupported OS #endif setenv("ANDROID_ROOT", root.c_str(), 1); } } setenv("LD_LIBRARY_PATH", ":", 0); // Required by java.lang.System.<clinit>. // Not set by build server, so default if (getenv("ANDROID_HOST_OUT") == nullptr) { setenv("ANDROID_HOST_OUT", getenv("ANDROID_ROOT"), 1); } } } void CommonRuntimeTestImpl::SetUpAndroidData(std::string& android_data) { // On target, Cannot use /mnt/sdcard because it is mounted noexec, so use subdir of dalvik-cache if (IsHost()) { const char* tmpdir = getenv("TMPDIR"); if (tmpdir != nullptr && tmpdir[0] != 0) { android_data = tmpdir; } else { android_data = "/tmp"; } } else { android_data = "/data/dalvik-cache"; } android_data += "/art-data-XXXXXX"; if (mkdtemp(&android_data[0]) == nullptr) { PLOG(FATAL) << "mkdtemp(\"" << &android_data[0] << "\") failed"; } setenv("ANDROID_DATA", android_data.c_str(), 1); } void CommonRuntimeTestImpl::TearDownAndroidData(const std::string& android_data, bool fail_on_error) { if (fail_on_error) { ASSERT_EQ(rmdir(android_data.c_str()), 0); } else { rmdir(android_data.c_str()); } } // Helper - find directory with the following format: // ${ANDROID_BUILD_TOP}/${subdir1}/${subdir2}-${version}/${subdir3}/bin/ static std::string GetAndroidToolsDir(const std::string& subdir1, const std::string& subdir2, const std::string& subdir3) { std::string root; const char* android_build_top = getenv("ANDROID_BUILD_TOP"); if (android_build_top != nullptr) { root = android_build_top; } else { // Not set by build server, so default to current directory char* cwd = getcwd(nullptr, 0); setenv("ANDROID_BUILD_TOP", cwd, 1); root = cwd; free(cwd); } std::string toolsdir = root + "/" + subdir1; std::string founddir; DIR* dir; if ((dir = opendir(toolsdir.c_str())) != nullptr) { float maxversion = 0; struct dirent* entry; while ((entry = readdir(dir)) != nullptr) { std::string format = subdir2 + "-%f"; float version; if (std::sscanf(entry->d_name, format.c_str(), &version) == 1) { if (version > maxversion) { maxversion = version; founddir = toolsdir + "/" + entry->d_name + "/" + subdir3 + "/bin/"; } } } closedir(dir); } if (founddir.empty()) { ADD_FAILURE() << "Cannot find Android tools directory."; } return founddir; } std::string CommonRuntimeTestImpl::GetAndroidHostToolsDir() { return GetAndroidToolsDir("prebuilts/gcc/linux-x86/host", "x86_64-linux-glibc2.15", "x86_64-linux"); } 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 ""; } std::string CommonRuntimeTestImpl::GetCoreArtLocation() { return GetCoreFileLocation("art"); } std::string CommonRuntimeTestImpl::GetCoreOatLocation() { return GetCoreFileLocation("oat"); } std::unique_ptr<const DexFile> CommonRuntimeTestImpl::LoadExpectSingleDexFile( const char* location) { std::vector<std::unique_ptr<const DexFile>> dex_files; std::string error_msg; MemMap::Init(); static constexpr bool kVerifyChecksum = true; const ArtDexFileLoader dex_file_loader; if (!dex_file_loader.Open( location, location, /* verify */ true, kVerifyChecksum, &error_msg, &dex_files)) { LOG(FATAL) << "Could not open .dex file '" << location << "': " << error_msg << "\n"; UNREACHABLE(); } else { CHECK_EQ(1U, dex_files.size()) << "Expected only one dex file in " << location; return std::move(dex_files[0]); } } void CommonRuntimeTestImpl::SetUp() { SetUpAndroidRoot(); SetUpAndroidData(android_data_); dalvik_cache_.append(android_data_.c_str()); dalvik_cache_.append("/dalvik-cache"); int mkdir_result = mkdir(dalvik_cache_.c_str(), 0700); ASSERT_EQ(mkdir_result, 0); 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 = "-Xbootclasspath"; for (const std::string &core_dex_file_name : GetLibCoreDexFileNames()) { boot_class_path_string += ":"; boot_class_path_string += core_dex_file_name; } options.push_back(std::make_pair(boot_class_path_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"; return; } 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()); class_linker_->RunRootClinits(); } // 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::ClearDirectory(const char* dirpath, bool recursive) { ASSERT_TRUE(dirpath != nullptr); DIR* dir = opendir(dirpath); ASSERT_TRUE(dir != nullptr); dirent* e; struct stat s; while ((e = readdir(dir)) != nullptr) { if ((strcmp(e->d_name, ".") == 0) || (strcmp(e->d_name, "..") == 0)) { continue; } std::string filename(dirpath); filename.push_back('/'); filename.append(e->d_name); int stat_result = lstat(filename.c_str(), &s); ASSERT_EQ(0, stat_result) << "unable to stat " << filename; if (S_ISDIR(s.st_mode)) { if (recursive) { ClearDirectory(filename.c_str()); int rmdir_result = rmdir(filename.c_str()); ASSERT_EQ(0, rmdir_result) << filename; } } else { int unlink_result = unlink(filename.c_str()); ASSERT_EQ(0, unlink_result) << filename; } } closedir(dir); } void CommonRuntimeTestImpl::TearDown() { const char* android_data = getenv("ANDROID_DATA"); ASSERT_TRUE(android_data != nullptr); ClearDirectory(dalvik_cache_.c_str()); int rmdir_cache_result = rmdir(dalvik_cache_.c_str()); ASSERT_EQ(0, rmdir_cache_result); TearDownAndroidData(android_data_, true); dalvik_cache_.clear(); if (runtime_ != nullptr) { runtime_->GetHeap()->VerifyHeap(); // Check for heap corruption after the test } } static std::string GetDexFileName(const std::string& jar_prefix, bool host) { std::string path; if (host) { const char* host_dir = getenv("ANDROID_HOST_OUT"); CHECK(host_dir != nullptr); path = host_dir; } else { path = GetAndroidRoot(); } std::string suffix = host ? "-hostdex" // The host version. : "-testdex"; // The unstripped target version. return StringPrintf("%s/framework/%s%s.jar", path.c_str(), jar_prefix.c_str(), suffix.c_str()); } std::vector<std::string> CommonRuntimeTestImpl::GetLibCoreDexFileNames() { return std::vector<std::string>({GetDexFileName("core-oj", IsHost()), GetDexFileName("core-libart", IsHost())}); } std::string CommonRuntimeTestImpl::GetTestAndroidRoot() { if (IsHost()) { const char* host_dir = getenv("ANDROID_HOST_OUT"); CHECK(host_dir != nullptr); return host_dir; } return GetAndroidRoot(); } // 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::string CommonRuntimeTestImpl::GetTestDexFileName(const char* name) const { CHECK(name != nullptr); std::string filename; if (IsHost()) { filename += getenv("ANDROID_HOST_OUT"); filename += "/framework/"; } else { filename += ART_TARGET_NATIVETEST_DIR_STRING; } filename += "art-gtest-"; filename += name; filename += ".jar"; return filename; } std::vector<std::unique_ptr<const DexFile>> CommonRuntimeTestImpl::OpenTestDexFiles( const char* name) { std::string filename = GetTestDexFileName(name); static constexpr bool kVerifyChecksum = true; std::string error_msg; const ArtDexFileLoader dex_file_loader; std::vector<std::unique_ptr<const DexFile>> dex_files; bool success = dex_file_loader.Open(filename.c_str(), filename.c_str(), /* verify */ true, kVerifyChecksum, &error_msg, &dex_files); CHECK(success) << "Failed to open '" << filename << "': " << error_msg; for (auto& dex_file : dex_files) { CHECK_EQ(PROT_READ, dex_file->GetPermissions()); CHECK(dex_file->IsReadOnly()); } return dex_files; } std::unique_ptr<const DexFile> CommonRuntimeTestImpl::OpenTestDexFile(const char* name) { std::vector<std::unique_ptr<const DexFile>> vector = OpenTestDexFiles(name); EXPECT_EQ(1U, vector.size()); return std::move(vector[0]); } 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) { 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); { // 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) { return LoadDexInWellKnownClassLoader(dex_name, WellKnownClasses::dalvik_system_PathClassLoader, parent_loader); } jobject CommonRuntimeTestImpl::LoadDexInDelegateLastClassLoader(const std::string& dex_name, jobject parent_loader) { return LoadDexInWellKnownClassLoader(dex_name, WellKnownClasses::dalvik_system_DelegateLastClassLoader, parent_loader); } std::string CommonRuntimeTestImpl::GetCoreFileLocation(const char* suffix) { CHECK(suffix != nullptr); std::string location; if (IsHost()) { const char* host_dir = getenv("ANDROID_HOST_OUT"); CHECK(host_dir != nullptr); location = StringPrintf("%s/framework/core.%s", host_dir, suffix); } else { location = StringPrintf("/data/art-test/core.%s", suffix); } return location; } std::string CommonRuntimeTestImpl::CreateClassPath( const std::vector<std::unique_ptr<const DexFile>>& dex_files) { CHECK(!dex_files.empty()); std::string classpath = dex_files[0]->GetLocation(); for (size_t i = 1; i < dex_files.size(); i++) { classpath += ":" + dex_files[i]->GetLocation(); } return classpath; } std::string CommonRuntimeTestImpl::CreateClassPathWithChecksums( const std::vector<std::unique_ptr<const DexFile>>& dex_files) { CHECK(!dex_files.empty()); std::string classpath = dex_files[0]->GetLocation() + "*" + std::to_string(dex_files[0]->GetLocationChecksum()); for (size_t i = 1; i < dex_files.size(); i++) { classpath += ":" + dex_files[i]->GetLocation() + "*" + std::to_string(dex_files[i]->GetLocationChecksum()); } return classpath; } 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); } } 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