common_runtime_test.cc revision 966878d987cec1940fdfa8633fc79f8112320821 
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "common_runtime_test.h"
18
19#include <cstdio>
20#include <dirent.h>
21#include <dlfcn.h>
22#include <fcntl.h>
23#include <ScopedLocalRef.h>
24#include <stdlib.h>
25
26#include "../../external/icu/icu4c/source/common/unicode/uvernum.h"
27#include "art_field-inl.h"
28#include "base/macros.h"
29#include "base/logging.h"
30#include "base/stl_util.h"
31#include "base/stringprintf.h"
32#include "base/unix_file/fd_file.h"
33#include "class_linker.h"
34#include "compiler_callbacks.h"
35#include "dex_file-inl.h"
36#include "gc_root-inl.h"
37#include "gc/heap.h"
38#include "gtest/gtest.h"
39#include "handle_scope-inl.h"
40#include "interpreter/unstarted_runtime.h"
41#include "jni_internal.h"
42#include "mirror/class-inl.h"
43#include "mirror/class_loader.h"
44#include "mem_map.h"
45#include "native/dalvik_system_DexFile.h"
46#include "noop_compiler_callbacks.h"
47#include "os.h"
48#include "primitive.h"
49#include "runtime-inl.h"
50#include "scoped_thread_state_change.h"
51#include "thread.h"
52#include "well_known_classes.h"
53
54int main(int argc, char **argv) {
55  // Gtests can be very noisy. For example, an executable with multiple tests will trigger native
56  // bridge warnings. The following line reduces the minimum log severity to ERROR and suppresses
57  // everything else. In case you want to see all messages, comment out the line.
58  setenv("ANDROID_LOG_TAGS", "*:e", 1);
59
60  art::InitLogging(argv);
61  LOG(::art::INFO) << "Running main() from common_runtime_test.cc...";
62  testing::InitGoogleTest(&argc, argv);
63  return RUN_ALL_TESTS();
64}
65
66namespace art {
67
68ScratchFile::ScratchFile() {
69  // ANDROID_DATA needs to be set
70  CHECK_NE(static_cast<char*>(nullptr), getenv("ANDROID_DATA")) <<
71      "Are you subclassing RuntimeTest?";
72  filename_ = getenv("ANDROID_DATA");
73  filename_ += "/TmpFile-XXXXXX";
74  int fd = mkstemp(&filename_[0]);
75  CHECK_NE(-1, fd);
76  file_.reset(new File(fd, GetFilename(), true));
77}
78
79ScratchFile::ScratchFile(const ScratchFile& other, const char* suffix) {
80  filename_ = other.GetFilename();
81  filename_ += suffix;
82  int fd = open(filename_.c_str(), O_RDWR | O_CREAT, 0666);
83  CHECK_NE(-1, fd);
84  file_.reset(new File(fd, GetFilename(), true));
85}
86
87ScratchFile::ScratchFile(File* file) {
88  CHECK(file != nullptr);
89  filename_ = file->GetPath();
90  file_.reset(file);
91}
92
93ScratchFile::~ScratchFile() {
94  Unlink();
95}
96
97int ScratchFile::GetFd() const {
98  return file_->Fd();
99}
100
101void ScratchFile::Close() {
102  if (file_.get() != nullptr) {
103    if (file_->FlushCloseOrErase() != 0) {
104      PLOG(WARNING) << "Error closing scratch file.";
105    }
106  }
107}
108
109void ScratchFile::Unlink() {
110  if (!OS::FileExists(filename_.c_str())) {
111    return;
112  }
113  Close();
114  int unlink_result = unlink(filename_.c_str());
115  CHECK_EQ(0, unlink_result);
116}
117
118static bool unstarted_initialized_ = false;
119
120CommonRuntimeTest::CommonRuntimeTest() {}
121CommonRuntimeTest::~CommonRuntimeTest() {
122  // Ensure the dex files are cleaned up before the runtime.
123  loaded_dex_files_.clear();
124  runtime_.reset();
125}
126
127void CommonRuntimeTest::SetUpAndroidRoot() {
128  if (IsHost()) {
129    // $ANDROID_ROOT is set on the device, but not necessarily on the host.
130    // But it needs to be set so that icu4c can find its locale data.
131    const char* android_root_from_env = getenv("ANDROID_ROOT");
132    if (android_root_from_env == nullptr) {
133      // Use ANDROID_HOST_OUT for ANDROID_ROOT if it is set.
134      const char* android_host_out = getenv("ANDROID_HOST_OUT");
135      if (android_host_out != nullptr) {
136        setenv("ANDROID_ROOT", android_host_out, 1);
137      } else {
138        // Build it from ANDROID_BUILD_TOP or cwd
139        std::string root;
140        const char* android_build_top = getenv("ANDROID_BUILD_TOP");
141        if (android_build_top != nullptr) {
142          root += android_build_top;
143        } else {
144          // Not set by build server, so default to current directory
145          char* cwd = getcwd(nullptr, 0);
146          setenv("ANDROID_BUILD_TOP", cwd, 1);
147          root += cwd;
148          free(cwd);
149        }
150#if defined(__linux__)
151        root += "/out/host/linux-x86";
152#elif defined(__APPLE__)
153        root += "/out/host/darwin-x86";
154#else
155#error unsupported OS
156#endif
157        setenv("ANDROID_ROOT", root.c_str(), 1);
158      }
159    }
160    setenv("LD_LIBRARY_PATH", ":", 0);  // Required by java.lang.System.<clinit>.
161
162    // Not set by build server, so default
163    if (getenv("ANDROID_HOST_OUT") == nullptr) {
164      setenv("ANDROID_HOST_OUT", getenv("ANDROID_ROOT"), 1);
165    }
166  }
167}
168
169void CommonRuntimeTest::SetUpAndroidData(std::string& android_data) {
170  // On target, Cannot use /mnt/sdcard because it is mounted noexec, so use subdir of dalvik-cache
171  if (IsHost()) {
172    const char* tmpdir = getenv("TMPDIR");
173    if (tmpdir != nullptr && tmpdir[0] != 0) {
174      android_data = tmpdir;
175    } else {
176      android_data = "/tmp";
177    }
178  } else {
179    android_data = "/data/dalvik-cache";
180  }
181  android_data += "/art-data-XXXXXX";
182  if (mkdtemp(&android_data[0]) == nullptr) {
183    PLOG(FATAL) << "mkdtemp(\"" << &android_data[0] << "\") failed";
184  }
185  setenv("ANDROID_DATA", android_data.c_str(), 1);
186}
187
188void CommonRuntimeTest::TearDownAndroidData(const std::string& android_data, bool fail_on_error) {
189  if (fail_on_error) {
190    ASSERT_EQ(rmdir(android_data.c_str()), 0);
191  } else {
192    rmdir(android_data.c_str());
193  }
194}
195
196// Helper - find directory with the following format:
197// ${ANDROID_BUILD_TOP}/${subdir1}/${subdir2}-${version}/${subdir3}/bin/
198static std::string GetAndroidToolsDir(const std::string& subdir1,
199                                      const std::string& subdir2,
200                                      const std::string& subdir3) {
201  std::string root;
202  const char* android_build_top = getenv("ANDROID_BUILD_TOP");
203  if (android_build_top != nullptr) {
204    root = android_build_top;
205  } else {
206    // Not set by build server, so default to current directory
207    char* cwd = getcwd(nullptr, 0);
208    setenv("ANDROID_BUILD_TOP", cwd, 1);
209    root = cwd;
210    free(cwd);
211  }
212
213  std::string toolsdir = root + "/" + subdir1;
214  std::string founddir;
215  DIR* dir;
216  if ((dir = opendir(toolsdir.c_str())) != nullptr) {
217    float maxversion = 0;
218    struct dirent* entry;
219    while ((entry = readdir(dir)) != nullptr) {
220      std::string format = subdir2 + "-%f";
221      float version;
222      if (std::sscanf(entry->d_name, format.c_str(), &version) == 1) {
223        if (version > maxversion) {
224          maxversion = version;
225          founddir = toolsdir + "/" + entry->d_name + "/" + subdir3 + "/bin/";
226        }
227      }
228    }
229    closedir(dir);
230  }
231
232  if (founddir.empty()) {
233    ADD_FAILURE() << "Can not find Android tools directory.";
234  }
235  return founddir;
236}
237
238std::string CommonRuntimeTest::GetAndroidHostToolsDir() {
239  return GetAndroidToolsDir("prebuilts/gcc/linux-x86/host",
240                            "x86_64-linux-glibc2.15",
241                            "x86_64-linux");
242}
243
244std::string CommonRuntimeTest::GetAndroidTargetToolsDir(InstructionSet isa) {
245  switch (isa) {
246    case kArm:
247    case kThumb2:
248      return GetAndroidToolsDir("prebuilts/gcc/linux-x86/arm",
249                                "arm-linux-androideabi",
250                                "arm-linux-androideabi");
251    case kArm64:
252      return GetAndroidToolsDir("prebuilts/gcc/linux-x86/aarch64",
253                                "aarch64-linux-android",
254                                "aarch64-linux-android");
255    case kX86:
256    case kX86_64:
257      return GetAndroidToolsDir("prebuilts/gcc/linux-x86/x86",
258                                "x86_64-linux-android",
259                                "x86_64-linux-android");
260    case kMips:
261    case kMips64:
262      return GetAndroidToolsDir("prebuilts/gcc/linux-x86/mips",
263                                "mips64el-linux-android",
264                                "mips64el-linux-android");
265    case kNone:
266      break;
267  }
268  ADD_FAILURE() << "Invalid isa " << isa;
269  return "";
270}
271
272std::string CommonRuntimeTest::GetCoreArtLocation() {
273  return GetCoreFileLocation("art");
274}
275
276std::string CommonRuntimeTest::GetCoreOatLocation() {
277  return GetCoreFileLocation("oat");
278}
279
280std::unique_ptr<const DexFile> CommonRuntimeTest::LoadExpectSingleDexFile(const char* location) {
281  std::vector<std::unique_ptr<const DexFile>> dex_files;
282  std::string error_msg;
283  MemMap::Init();
284  if (!DexFile::Open(location, location, &error_msg, &dex_files)) {
285    LOG(FATAL) << "Could not open .dex file '" << location << "': " << error_msg << "\n";
286    UNREACHABLE();
287  } else {
288    CHECK_EQ(1U, dex_files.size()) << "Expected only one dex file in " << location;
289    return std::move(dex_files[0]);
290  }
291}
292
293void CommonRuntimeTest::SetUp() {
294  SetUpAndroidRoot();
295  SetUpAndroidData(android_data_);
296  dalvik_cache_.append(android_data_.c_str());
297  dalvik_cache_.append("/dalvik-cache");
298  int mkdir_result = mkdir(dalvik_cache_.c_str(), 0700);
299  ASSERT_EQ(mkdir_result, 0);
300
301  std::string min_heap_string(StringPrintf("-Xms%zdm", gc::Heap::kDefaultInitialSize / MB));
302  std::string max_heap_string(StringPrintf("-Xmx%zdm", gc::Heap::kDefaultMaximumSize / MB));
303
304
305  RuntimeOptions options;
306  std::string boot_class_path_string = "-Xbootclasspath";
307  for (const std::string &core_dex_file_name : GetLibCoreDexFileNames()) {
308    boot_class_path_string += ":";
309    boot_class_path_string += core_dex_file_name;
310  }
311
312  options.push_back(std::make_pair(boot_class_path_string, nullptr));
313  options.push_back(std::make_pair("-Xcheck:jni", nullptr));
314  options.push_back(std::make_pair(min_heap_string, nullptr));
315  options.push_back(std::make_pair(max_heap_string, nullptr));
316
317  callbacks_.reset(new NoopCompilerCallbacks());
318
319  SetUpRuntimeOptions(&options);
320
321  // Install compiler-callbacks if SetupRuntimeOptions hasn't deleted them.
322  if (callbacks_.get() != nullptr) {
323    options.push_back(std::make_pair("compilercallbacks", callbacks_.get()));
324  }
325
326  PreRuntimeCreate();
327  if (!Runtime::Create(options, false)) {
328    LOG(FATAL) << "Failed to create runtime";
329    return;
330  }
331  PostRuntimeCreate();
332  runtime_.reset(Runtime::Current());
333  class_linker_ = runtime_->GetClassLinker();
334  class_linker_->FixupDexCaches(runtime_->GetResolutionMethod());
335
336  // Runtime::Create acquired the mutator_lock_ that is normally given away when we
337  // Runtime::Start, give it away now and then switch to a more managable ScopedObjectAccess.
338  Thread::Current()->TransitionFromRunnableToSuspended(kNative);
339
340  // Get the boot class path from the runtime so it can be used in tests.
341  boot_class_path_ = class_linker_->GetBootClassPath();
342  ASSERT_FALSE(boot_class_path_.empty());
343  java_lang_dex_file_ = boot_class_path_[0];
344
345  FinalizeSetup();
346}
347
348void CommonRuntimeTest::FinalizeSetup() {
349  // Initialize maps for unstarted runtime. This needs to be here, as running clinits needs this
350  // set up.
351  if (!unstarted_initialized_) {
352    interpreter::UnstartedRuntime::Initialize();
353    unstarted_initialized_ = true;
354  }
355
356  {
357    ScopedObjectAccess soa(Thread::Current());
358    class_linker_->RunRootClinits();
359  }
360
361  // We're back in native, take the opportunity to initialize well known classes.
362  WellKnownClasses::Init(Thread::Current()->GetJniEnv());
363
364  // Create the heap thread pool so that the GC runs in parallel for tests. Normally, the thread
365  // pool is created by the runtime.
366  runtime_->GetHeap()->CreateThreadPool();
367  runtime_->GetHeap()->VerifyHeap();  // Check for heap corruption before the test
368  // Reduce timinig-dependent flakiness in OOME behavior (eg StubTest.AllocObject).
369  runtime_->GetHeap()->SetMinIntervalHomogeneousSpaceCompactionByOom(0U);
370}
371
372void CommonRuntimeTest::ClearDirectory(const char* dirpath) {
373  ASSERT_TRUE(dirpath != nullptr);
374  DIR* dir = opendir(dirpath);
375  ASSERT_TRUE(dir != nullptr);
376  dirent* e;
377  struct stat s;
378  while ((e = readdir(dir)) != nullptr) {
379    if ((strcmp(e->d_name, ".") == 0) || (strcmp(e->d_name, "..") == 0)) {
380      continue;
381    }
382    std::string filename(dirpath);
383    filename.push_back('/');
384    filename.append(e->d_name);
385    int stat_result = lstat(filename.c_str(), &s);
386    ASSERT_EQ(0, stat_result) << "unable to stat " << filename;
387    if (S_ISDIR(s.st_mode)) {
388      ClearDirectory(filename.c_str());
389      int rmdir_result = rmdir(filename.c_str());
390      ASSERT_EQ(0, rmdir_result) << filename;
391    } else {
392      int unlink_result = unlink(filename.c_str());
393      ASSERT_EQ(0, unlink_result) << filename;
394    }
395  }
396  closedir(dir);
397}
398
399void CommonRuntimeTest::TearDown() {
400  const char* android_data = getenv("ANDROID_DATA");
401  ASSERT_TRUE(android_data != nullptr);
402  ClearDirectory(dalvik_cache_.c_str());
403  int rmdir_cache_result = rmdir(dalvik_cache_.c_str());
404  ASSERT_EQ(0, rmdir_cache_result);
405  TearDownAndroidData(android_data_, true);
406
407  // icu4c has a fixed 10-element array "gCommonICUDataArray".
408  // If we run > 10 tests, we fill that array and u_setCommonData fails.
409  // There's a function to clear the array, but it's not public...
410  typedef void (*IcuCleanupFn)();
411  void* sym = dlsym(RTLD_DEFAULT, "u_cleanup_" U_ICU_VERSION_SHORT);
412  CHECK(sym != nullptr) << dlerror();
413  IcuCleanupFn icu_cleanup_fn = reinterpret_cast<IcuCleanupFn>(sym);
414  (*icu_cleanup_fn)();
415
416  Runtime::Current()->GetHeap()->VerifyHeap();  // Check for heap corruption after the test
417
418  // Manually closing the JNI libraries.
419  // Runtime does not support repeatedly doing JNI->CreateVM, thus we need to manually clean up the
420  // dynamic linking loader so that gtests would not fail.
421  // Bug: 25785594
422  if (runtime_->IsStarted()) {
423    {
424      // We retrieve the handle by calling dlopen on the library. To close it, we need to call
425      // dlclose twice, the first time to undo our dlopen and the second time to actually unload it.
426      // See man dlopen.
427      void* handle = dlopen("libjavacore.so", RTLD_LAZY);
428      dlclose(handle);
429      CHECK_EQ(0, dlclose(handle));
430    }
431    {
432      void* handle = dlopen("libopenjdkd.so", RTLD_LAZY);
433      dlclose(handle);
434      CHECK_EQ(0, dlclose(handle));
435    }
436  }
437}
438
439static std::string GetDexFileName(const std::string& jar_prefix, bool host) {
440  std::string path;
441  if (host) {
442    const char* host_dir = getenv("ANDROID_HOST_OUT");
443    CHECK(host_dir != nullptr);
444    path = host_dir;
445  } else {
446    path = GetAndroidRoot();
447  }
448
449  std::string suffix = host
450      ? "-hostdex"                 // The host version.
451      : "-testdex";                // The unstripped target version.
452
453  return StringPrintf("%s/framework/%s%s.jar", path.c_str(), jar_prefix.c_str(), suffix.c_str());
454}
455
456std::vector<std::string> CommonRuntimeTest::GetLibCoreDexFileNames() {
457  return std::vector<std::string>({GetDexFileName("core-oj", IsHost()),
458                                   GetDexFileName("core-libart", IsHost())});
459}
460
461std::string CommonRuntimeTest::GetTestAndroidRoot() {
462  if (IsHost()) {
463    const char* host_dir = getenv("ANDROID_HOST_OUT");
464    CHECK(host_dir != nullptr);
465    return host_dir;
466  }
467  return GetAndroidRoot();
468}
469
470// Check that for target builds we have ART_TARGET_NATIVETEST_DIR set.
471#ifdef ART_TARGET
472#ifndef ART_TARGET_NATIVETEST_DIR
473#error "ART_TARGET_NATIVETEST_DIR not set."
474#endif
475// Wrap it as a string literal.
476#define ART_TARGET_NATIVETEST_DIR_STRING STRINGIFY(ART_TARGET_NATIVETEST_DIR) "/"
477#else
478#define ART_TARGET_NATIVETEST_DIR_STRING ""
479#endif
480
481std::string CommonRuntimeTest::GetTestDexFileName(const char* name) {
482  CHECK(name != nullptr);
483  std::string filename;
484  if (IsHost()) {
485    filename += getenv("ANDROID_HOST_OUT");
486    filename += "/framework/";
487  } else {
488    filename += ART_TARGET_NATIVETEST_DIR_STRING;
489  }
490  filename += "art-gtest-";
491  filename += name;
492  filename += ".jar";
493  return filename;
494}
495
496std::vector<std::unique_ptr<const DexFile>> CommonRuntimeTest::OpenTestDexFiles(const char* name) {
497  std::string filename = GetTestDexFileName(name);
498  std::string error_msg;
499  std::vector<std::unique_ptr<const DexFile>> dex_files;
500  bool success = DexFile::Open(filename.c_str(), filename.c_str(), &error_msg, &dex_files);
501  CHECK(success) << "Failed to open '" << filename << "': " << error_msg;
502  for (auto& dex_file : dex_files) {
503    CHECK_EQ(PROT_READ, dex_file->GetPermissions());
504    CHECK(dex_file->IsReadOnly());
505  }
506  return dex_files;
507}
508
509std::unique_ptr<const DexFile> CommonRuntimeTest::OpenTestDexFile(const char* name) {
510  std::vector<std::unique_ptr<const DexFile>> vector = OpenTestDexFiles(name);
511  EXPECT_EQ(1U, vector.size());
512  return std::move(vector[0]);
513}
514
515std::vector<const DexFile*> CommonRuntimeTest::GetDexFiles(jobject jclass_loader) {
516  std::vector<const DexFile*> ret;
517
518  ScopedObjectAccess soa(Thread::Current());
519
520  StackHandleScope<2> hs(soa.Self());
521  Handle<mirror::ClassLoader> class_loader = hs.NewHandle(
522      soa.Decode<mirror::ClassLoader*>(jclass_loader));
523
524  DCHECK_EQ(class_loader->GetClass(),
525            soa.Decode<mirror::Class*>(WellKnownClasses::dalvik_system_PathClassLoader));
526  DCHECK_EQ(class_loader->GetParent()->GetClass(),
527            soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_BootClassLoader));
528
529  // The class loader is a PathClassLoader which inherits from BaseDexClassLoader.
530  // We need to get the DexPathList and loop through it.
531  ArtField* cookie_field = soa.DecodeField(WellKnownClasses::dalvik_system_DexFile_cookie);
532  ArtField* dex_file_field =
533      soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile);
534  mirror::Object* dex_path_list =
535      soa.DecodeField(WellKnownClasses::dalvik_system_PathClassLoader_pathList)->
536      GetObject(class_loader.Get());
537  if (dex_path_list != nullptr && dex_file_field!= nullptr && cookie_field != nullptr) {
538    // DexPathList has an array dexElements of Elements[] which each contain a dex file.
539    mirror::Object* dex_elements_obj =
540        soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList_dexElements)->
541        GetObject(dex_path_list);
542    // Loop through each dalvik.system.DexPathList$Element's dalvik.system.DexFile and look
543    // at the mCookie which is a DexFile vector.
544    if (dex_elements_obj != nullptr) {
545      Handle<mirror::ObjectArray<mirror::Object>> dex_elements =
546          hs.NewHandle(dex_elements_obj->AsObjectArray<mirror::Object>());
547      for (int32_t i = 0; i < dex_elements->GetLength(); ++i) {
548        mirror::Object* element = dex_elements->GetWithoutChecks(i);
549        if (element == nullptr) {
550          // Should never happen, fall back to java code to throw a NPE.
551          break;
552        }
553        mirror::Object* dex_file = dex_file_field->GetObject(element);
554        if (dex_file != nullptr) {
555          mirror::LongArray* long_array = cookie_field->GetObject(dex_file)->AsLongArray();
556          DCHECK(long_array != nullptr);
557          int32_t long_array_size = long_array->GetLength();
558          for (int32_t j = kDexFileIndexStart; j < long_array_size; ++j) {
559            const DexFile* cp_dex_file = reinterpret_cast<const DexFile*>(static_cast<uintptr_t>(
560                long_array->GetWithoutChecks(j)));
561            if (cp_dex_file == nullptr) {
562              LOG(WARNING) << "Null DexFile";
563              continue;
564            }
565            ret.push_back(cp_dex_file);
566          }
567        }
568      }
569    }
570  }
571
572  return ret;
573}
574
575const DexFile* CommonRuntimeTest::GetFirstDexFile(jobject jclass_loader) {
576  std::vector<const DexFile*> tmp(GetDexFiles(jclass_loader));
577  DCHECK(!tmp.empty());
578  const DexFile* ret = tmp[0];
579  DCHECK(ret != nullptr);
580  return ret;
581}
582
583jobject CommonRuntimeTest::LoadDex(const char* dex_name) {
584  std::vector<std::unique_ptr<const DexFile>> dex_files = OpenTestDexFiles(dex_name);
585  std::vector<const DexFile*> class_path;
586  CHECK_NE(0U, dex_files.size());
587  for (auto& dex_file : dex_files) {
588    class_path.push_back(dex_file.get());
589    loaded_dex_files_.push_back(std::move(dex_file));
590  }
591
592  Thread* self = Thread::Current();
593  jobject class_loader = Runtime::Current()->GetClassLinker()->CreatePathClassLoader(self,
594                                                                                     class_path);
595  self->SetClassLoaderOverride(class_loader);
596  return class_loader;
597}
598
599std::string CommonRuntimeTest::GetCoreFileLocation(const char* suffix) {
600  CHECK(suffix != nullptr);
601
602  std::string location;
603  if (IsHost()) {
604    const char* host_dir = getenv("ANDROID_HOST_OUT");
605    CHECK(host_dir != nullptr);
606    location = StringPrintf("%s/framework/core.%s", host_dir, suffix);
607  } else {
608    location = StringPrintf("/data/art-test/core.%s", suffix);
609  }
610
611  return location;
612}
613
614CheckJniAbortCatcher::CheckJniAbortCatcher() : vm_(Runtime::Current()->GetJavaVM()) {
615  vm_->SetCheckJniAbortHook(Hook, &actual_);
616}
617
618CheckJniAbortCatcher::~CheckJniAbortCatcher() {
619  vm_->SetCheckJniAbortHook(nullptr, nullptr);
620  EXPECT_TRUE(actual_.empty()) << actual_;
621}
622
623void CheckJniAbortCatcher::Check(const char* expected_text) {
624  EXPECT_TRUE(actual_.find(expected_text) != std::string::npos) << "\n"
625      << "Expected to find: " << expected_text << "\n"
626      << "In the output   : " << actual_;
627  actual_.clear();
628}
629
630void CheckJniAbortCatcher::Hook(void* data, const std::string& reason) {
631  // We use += because when we're hooking the aborts like this, multiple problems can be found.
632  *reinterpret_cast<std::string*>(data) += reason;
633}
634
635}  // namespace art
636
637namespace std {
638
639template <typename T>
640std::ostream& operator<<(std::ostream& os, const std::vector<T>& rhs) {
641os << ::art::ToString(rhs);
642return os;
643}
644
645}  // namespace std
646