common_runtime_test.cc revision bb9c6b1c55e9e2308b4f5892a398a8837231fdbd 
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 <dirent.h>
20#include <dlfcn.h>
21#include <fcntl.h>
22#include <ScopedLocalRef.h>
23#include <stdlib.h>
24
25#include "../../external/icu/icu4c/source/common/unicode/uvernum.h"
26#include "base/macros.h"
27#include "base/logging.h"
28#include "base/stl_util.h"
29#include "base/stringprintf.h"
30#include "base/unix_file/fd_file.h"
31#include "class_linker.h"
32#include "compiler_callbacks.h"
33#include "dex_file.h"
34#include "gc_root-inl.h"
35#include "gc/heap.h"
36#include "gtest/gtest.h"
37#include "handle_scope-inl.h"
38#include "interpreter/unstarted_runtime.h"
39#include "jni_internal.h"
40#include "mirror/class_loader.h"
41#include "mem_map.h"
42#include "noop_compiler_callbacks.h"
43#include "os.h"
44#include "runtime-inl.h"
45#include "scoped_thread_state_change.h"
46#include "thread.h"
47#include "well_known_classes.h"
48
49int main(int argc, char **argv) {
50  // Gtests can be very noisy. For example, an executable with multiple tests will trigger native
51  // bridge warnings. The following line reduces the minimum log severity to ERROR and suppresses
52  // everything else. In case you want to see all messages, comment out the line.
53  setenv("ANDROID_LOG_TAGS", "*:e", 1);
54
55  art::InitLogging(argv);
56  LOG(::art::INFO) << "Running main() from common_runtime_test.cc...";
57  testing::InitGoogleTest(&argc, argv);
58  return RUN_ALL_TESTS();
59}
60
61namespace art {
62
63ScratchFile::ScratchFile() {
64  // ANDROID_DATA needs to be set
65  CHECK_NE(static_cast<char*>(nullptr), getenv("ANDROID_DATA")) <<
66      "Are you subclassing RuntimeTest?";
67  filename_ = getenv("ANDROID_DATA");
68  filename_ += "/TmpFile-XXXXXX";
69  int fd = mkstemp(&filename_[0]);
70  CHECK_NE(-1, fd);
71  file_.reset(new File(fd, GetFilename(), true));
72}
73
74ScratchFile::ScratchFile(const ScratchFile& other, const char* suffix) {
75  filename_ = other.GetFilename();
76  filename_ += suffix;
77  int fd = open(filename_.c_str(), O_RDWR | O_CREAT, 0666);
78  CHECK_NE(-1, fd);
79  file_.reset(new File(fd, GetFilename(), true));
80}
81
82ScratchFile::ScratchFile(File* file) {
83  CHECK(file != NULL);
84  filename_ = file->GetPath();
85  file_.reset(file);
86}
87
88ScratchFile::~ScratchFile() {
89  Unlink();
90}
91
92int ScratchFile::GetFd() const {
93  return file_->Fd();
94}
95
96void ScratchFile::Close() {
97  if (file_.get() != nullptr) {
98    if (file_->FlushCloseOrErase() != 0) {
99      PLOG(WARNING) << "Error closing scratch file.";
100    }
101  }
102}
103
104void ScratchFile::Unlink() {
105  if (!OS::FileExists(filename_.c_str())) {
106    return;
107  }
108  Close();
109  int unlink_result = unlink(filename_.c_str());
110  CHECK_EQ(0, unlink_result);
111}
112
113static bool unstarted_initialized_ = false;
114
115CommonRuntimeTest::CommonRuntimeTest() {}
116CommonRuntimeTest::~CommonRuntimeTest() {
117  // Ensure the dex files are cleaned up before the runtime.
118  loaded_dex_files_.clear();
119  runtime_.reset();
120}
121
122void CommonRuntimeTest::SetUpAndroidRoot() {
123  if (IsHost()) {
124    // $ANDROID_ROOT is set on the device, but not necessarily on the host.
125    // But it needs to be set so that icu4c can find its locale data.
126    const char* android_root_from_env = getenv("ANDROID_ROOT");
127    if (android_root_from_env == nullptr) {
128      // Use ANDROID_HOST_OUT for ANDROID_ROOT if it is set.
129      const char* android_host_out = getenv("ANDROID_HOST_OUT");
130      if (android_host_out != nullptr) {
131        setenv("ANDROID_ROOT", android_host_out, 1);
132      } else {
133        // Build it from ANDROID_BUILD_TOP or cwd
134        std::string root;
135        const char* android_build_top = getenv("ANDROID_BUILD_TOP");
136        if (android_build_top != nullptr) {
137          root += android_build_top;
138        } else {
139          // Not set by build server, so default to current directory
140          char* cwd = getcwd(nullptr, 0);
141          setenv("ANDROID_BUILD_TOP", cwd, 1);
142          root += cwd;
143          free(cwd);
144        }
145#if defined(__linux__)
146        root += "/out/host/linux-x86";
147#elif defined(__APPLE__)
148        root += "/out/host/darwin-x86";
149#else
150#error unsupported OS
151#endif
152        setenv("ANDROID_ROOT", root.c_str(), 1);
153      }
154    }
155    setenv("LD_LIBRARY_PATH", ":", 0);  // Required by java.lang.System.<clinit>.
156
157    // Not set by build server, so default
158    if (getenv("ANDROID_HOST_OUT") == nullptr) {
159      setenv("ANDROID_HOST_OUT", getenv("ANDROID_ROOT"), 1);
160    }
161  }
162}
163
164void CommonRuntimeTest::SetUpAndroidData(std::string& android_data) {
165  // On target, Cannot use /mnt/sdcard because it is mounted noexec, so use subdir of dalvik-cache
166  if (IsHost()) {
167    const char* tmpdir = getenv("TMPDIR");
168    if (tmpdir != nullptr && tmpdir[0] != 0) {
169      android_data = tmpdir;
170    } else {
171      android_data = "/tmp";
172    }
173  } else {
174    android_data = "/data/dalvik-cache";
175  }
176  android_data += "/art-data-XXXXXX";
177  if (mkdtemp(&android_data[0]) == nullptr) {
178    PLOG(FATAL) << "mkdtemp(\"" << &android_data[0] << "\") failed";
179  }
180  setenv("ANDROID_DATA", android_data.c_str(), 1);
181}
182
183void CommonRuntimeTest::TearDownAndroidData(const std::string& android_data, bool fail_on_error) {
184  if (fail_on_error) {
185    ASSERT_EQ(rmdir(android_data.c_str()), 0);
186  } else {
187    rmdir(android_data.c_str());
188  }
189}
190
191std::string CommonRuntimeTest::GetCoreArtLocation() {
192  return GetCoreFileLocation("art");
193}
194
195std::string CommonRuntimeTest::GetCoreOatLocation() {
196  return GetCoreFileLocation("oat");
197}
198
199std::unique_ptr<const DexFile> CommonRuntimeTest::LoadExpectSingleDexFile(const char* location) {
200  std::vector<std::unique_ptr<const DexFile>> dex_files;
201  std::string error_msg;
202  MemMap::Init();
203  if (!DexFile::Open(location, location, &error_msg, &dex_files)) {
204    LOG(FATAL) << "Could not open .dex file '" << location << "': " << error_msg << "\n";
205    UNREACHABLE();
206  } else {
207    CHECK_EQ(1U, dex_files.size()) << "Expected only one dex file in " << location;
208    return std::move(dex_files[0]);
209  }
210}
211
212void CommonRuntimeTest::SetUp() {
213  SetUpAndroidRoot();
214  SetUpAndroidData(android_data_);
215  dalvik_cache_.append(android_data_.c_str());
216  dalvik_cache_.append("/dalvik-cache");
217  int mkdir_result = mkdir(dalvik_cache_.c_str(), 0700);
218  ASSERT_EQ(mkdir_result, 0);
219
220  std::string min_heap_string(StringPrintf("-Xms%zdm", gc::Heap::kDefaultInitialSize / MB));
221  std::string max_heap_string(StringPrintf("-Xmx%zdm", gc::Heap::kDefaultMaximumSize / MB));
222
223
224  RuntimeOptions options;
225  std::string boot_class_path_string = "-Xbootclasspath:" + GetLibCoreDexFileName();
226  options.push_back(std::make_pair(boot_class_path_string, nullptr));
227  options.push_back(std::make_pair("-Xcheck:jni", nullptr));
228  options.push_back(std::make_pair(min_heap_string, nullptr));
229  options.push_back(std::make_pair(max_heap_string, nullptr));
230
231  callbacks_.reset(new NoopCompilerCallbacks());
232
233  SetUpRuntimeOptions(&options);
234
235  // Install compiler-callbacks if SetupRuntimeOptions hasn't deleted them.
236  if (callbacks_.get() != nullptr) {
237    options.push_back(std::make_pair("compilercallbacks", callbacks_.get()));
238  }
239
240  PreRuntimeCreate();
241  if (!Runtime::Create(options, false)) {
242    LOG(FATAL) << "Failed to create runtime";
243    return;
244  }
245  PostRuntimeCreate();
246  runtime_.reset(Runtime::Current());
247  class_linker_ = runtime_->GetClassLinker();
248  class_linker_->FixupDexCaches(runtime_->GetResolutionMethod());
249
250  // Initialize maps for unstarted runtime. This needs to be here, as running clinits needs this
251  // set up.
252  if (!unstarted_initialized_) {
253    interpreter::UnstartedRuntimeInitialize();
254    unstarted_initialized_ = true;
255  }
256
257  class_linker_->RunRootClinits();
258  boot_class_path_ = class_linker_->GetBootClassPath();
259  java_lang_dex_file_ = boot_class_path_[0];
260
261
262  // Runtime::Create acquired the mutator_lock_ that is normally given away when we
263  // Runtime::Start, give it away now and then switch to a more managable ScopedObjectAccess.
264  Thread::Current()->TransitionFromRunnableToSuspended(kNative);
265
266  // We're back in native, take the opportunity to initialize well known classes.
267  WellKnownClasses::Init(Thread::Current()->GetJniEnv());
268
269  // Create the heap thread pool so that the GC runs in parallel for tests. Normally, the thread
270  // pool is created by the runtime.
271  runtime_->GetHeap()->CreateThreadPool();
272  runtime_->GetHeap()->VerifyHeap();  // Check for heap corruption before the test
273  // Reduce timinig-dependent flakiness in OOME behavior (eg StubTest.AllocObject).
274  runtime_->GetHeap()->SetMinIntervalHomogeneousSpaceCompactionByOom(0U);
275
276  // Get the boot class path from the runtime so it can be used in tests.
277  boot_class_path_ = class_linker_->GetBootClassPath();
278  ASSERT_FALSE(boot_class_path_.empty());
279  java_lang_dex_file_ = boot_class_path_[0];
280}
281
282void CommonRuntimeTest::ClearDirectory(const char* dirpath) {
283  ASSERT_TRUE(dirpath != nullptr);
284  DIR* dir = opendir(dirpath);
285  ASSERT_TRUE(dir != nullptr);
286  dirent* e;
287  struct stat s;
288  while ((e = readdir(dir)) != nullptr) {
289    if ((strcmp(e->d_name, ".") == 0) || (strcmp(e->d_name, "..") == 0)) {
290      continue;
291    }
292    std::string filename(dirpath);
293    filename.push_back('/');
294    filename.append(e->d_name);
295    int stat_result = lstat(filename.c_str(), &s);
296    ASSERT_EQ(0, stat_result) << "unable to stat " << filename;
297    if (S_ISDIR(s.st_mode)) {
298      ClearDirectory(filename.c_str());
299      int rmdir_result = rmdir(filename.c_str());
300      ASSERT_EQ(0, rmdir_result) << filename;
301    } else {
302      int unlink_result = unlink(filename.c_str());
303      ASSERT_EQ(0, unlink_result) << filename;
304    }
305  }
306  closedir(dir);
307}
308
309void CommonRuntimeTest::TearDown() {
310  const char* android_data = getenv("ANDROID_DATA");
311  ASSERT_TRUE(android_data != nullptr);
312  ClearDirectory(dalvik_cache_.c_str());
313  int rmdir_cache_result = rmdir(dalvik_cache_.c_str());
314  ASSERT_EQ(0, rmdir_cache_result);
315  TearDownAndroidData(android_data_, true);
316
317  // icu4c has a fixed 10-element array "gCommonICUDataArray".
318  // If we run > 10 tests, we fill that array and u_setCommonData fails.
319  // There's a function to clear the array, but it's not public...
320  typedef void (*IcuCleanupFn)();
321  void* sym = dlsym(RTLD_DEFAULT, "u_cleanup_" U_ICU_VERSION_SHORT);
322  CHECK(sym != nullptr) << dlerror();
323  IcuCleanupFn icu_cleanup_fn = reinterpret_cast<IcuCleanupFn>(sym);
324  (*icu_cleanup_fn)();
325
326  Runtime::Current()->GetHeap()->VerifyHeap();  // Check for heap corruption after the test
327}
328
329std::string CommonRuntimeTest::GetLibCoreDexFileName() {
330  return GetDexFileName("core-libart");
331}
332
333std::string CommonRuntimeTest::GetDexFileName(const std::string& jar_prefix) {
334  if (IsHost()) {
335    const char* host_dir = getenv("ANDROID_HOST_OUT");
336    CHECK(host_dir != nullptr);
337    return StringPrintf("%s/framework/%s-hostdex.jar", host_dir, jar_prefix.c_str());
338  }
339  return StringPrintf("%s/framework/%s.jar", GetAndroidRoot(), jar_prefix.c_str());
340}
341
342std::string CommonRuntimeTest::GetTestAndroidRoot() {
343  if (IsHost()) {
344    const char* host_dir = getenv("ANDROID_HOST_OUT");
345    CHECK(host_dir != nullptr);
346    return host_dir;
347  }
348  return GetAndroidRoot();
349}
350
351// Check that for target builds we have ART_TARGET_NATIVETEST_DIR set.
352#ifdef ART_TARGET
353#ifndef ART_TARGET_NATIVETEST_DIR
354#error "ART_TARGET_NATIVETEST_DIR not set."
355#endif
356// Wrap it as a string literal.
357#define ART_TARGET_NATIVETEST_DIR_STRING STRINGIFY(ART_TARGET_NATIVETEST_DIR) "/"
358#else
359#define ART_TARGET_NATIVETEST_DIR_STRING ""
360#endif
361
362std::string CommonRuntimeTest::GetTestDexFileName(const char* name) {
363  CHECK(name != nullptr);
364  std::string filename;
365  if (IsHost()) {
366    filename += getenv("ANDROID_HOST_OUT");
367    filename += "/framework/";
368  } else {
369    filename += ART_TARGET_NATIVETEST_DIR_STRING;
370  }
371  filename += "art-gtest-";
372  filename += name;
373  filename += ".jar";
374  return filename;
375}
376
377std::vector<std::unique_ptr<const DexFile>> CommonRuntimeTest::OpenTestDexFiles(const char* name) {
378  std::string filename = GetTestDexFileName(name);
379  std::string error_msg;
380  std::vector<std::unique_ptr<const DexFile>> dex_files;
381  bool success = DexFile::Open(filename.c_str(), filename.c_str(), &error_msg, &dex_files);
382  CHECK(success) << "Failed to open '" << filename << "': " << error_msg;
383  for (auto& dex_file : dex_files) {
384    CHECK_EQ(PROT_READ, dex_file->GetPermissions());
385    CHECK(dex_file->IsReadOnly());
386  }
387  return dex_files;
388}
389
390std::unique_ptr<const DexFile> CommonRuntimeTest::OpenTestDexFile(const char* name) {
391  std::vector<std::unique_ptr<const DexFile>> vector = OpenTestDexFiles(name);
392  EXPECT_EQ(1U, vector.size());
393  return std::move(vector[0]);
394}
395
396std::vector<const DexFile*> CommonRuntimeTest::GetDexFiles(jobject jclass_loader) {
397  std::vector<const DexFile*> ret;
398
399  ScopedObjectAccess soa(Thread::Current());
400
401  StackHandleScope<4> hs(Thread::Current());
402  Handle<mirror::ClassLoader> class_loader = hs.NewHandle(
403      soa.Decode<mirror::ClassLoader*>(jclass_loader));
404
405  DCHECK_EQ(class_loader->GetClass(),
406            soa.Decode<mirror::Class*>(WellKnownClasses::dalvik_system_PathClassLoader));
407  DCHECK_EQ(class_loader->GetParent()->GetClass(),
408            soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_BootClassLoader));
409
410  // The class loader is a PathClassLoader which inherits from BaseDexClassLoader.
411  // We need to get the DexPathList and loop through it.
412  Handle<mirror::ArtField> cookie_field =
413      hs.NewHandle(soa.DecodeField(WellKnownClasses::dalvik_system_DexFile_cookie));
414  Handle<mirror::ArtField> dex_file_field =
415      hs.NewHandle(
416          soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile));
417  mirror::Object* dex_path_list =
418      soa.DecodeField(WellKnownClasses::dalvik_system_PathClassLoader_pathList)->
419      GetObject(class_loader.Get());
420  if (dex_path_list != nullptr && dex_file_field.Get() != nullptr &&
421      cookie_field.Get() != nullptr) {
422    // DexPathList has an array dexElements of Elements[] which each contain a dex file.
423    mirror::Object* dex_elements_obj =
424        soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList_dexElements)->
425        GetObject(dex_path_list);
426    // Loop through each dalvik.system.DexPathList$Element's dalvik.system.DexFile and look
427    // at the mCookie which is a DexFile vector.
428    if (dex_elements_obj != nullptr) {
429      Handle<mirror::ObjectArray<mirror::Object>> dex_elements =
430          hs.NewHandle(dex_elements_obj->AsObjectArray<mirror::Object>());
431      for (int32_t i = 0; i < dex_elements->GetLength(); ++i) {
432        mirror::Object* element = dex_elements->GetWithoutChecks(i);
433        if (element == nullptr) {
434          // Should never happen, fall back to java code to throw a NPE.
435          break;
436        }
437        mirror::Object* dex_file = dex_file_field->GetObject(element);
438        if (dex_file != nullptr) {
439          mirror::LongArray* long_array = cookie_field->GetObject(dex_file)->AsLongArray();
440          DCHECK(long_array != nullptr);
441          int32_t long_array_size = long_array->GetLength();
442          for (int32_t j = 0; j < long_array_size; ++j) {
443            const DexFile* cp_dex_file = reinterpret_cast<const DexFile*>(static_cast<uintptr_t>(
444                long_array->GetWithoutChecks(j)));
445            if (cp_dex_file == nullptr) {
446              LOG(WARNING) << "Null DexFile";
447              continue;
448            }
449            ret.push_back(cp_dex_file);
450          }
451        }
452      }
453    }
454  }
455
456  return ret;
457}
458
459const DexFile* CommonRuntimeTest::GetFirstDexFile(jobject jclass_loader) {
460  std::vector<const DexFile*> tmp(GetDexFiles(jclass_loader));
461  DCHECK(!tmp.empty());
462  const DexFile* ret = tmp[0];
463  DCHECK(ret != nullptr);
464  return ret;
465}
466
467jobject CommonRuntimeTest::LoadDex(const char* dex_name) {
468  std::vector<std::unique_ptr<const DexFile>> dex_files = OpenTestDexFiles(dex_name);
469  std::vector<const DexFile*> class_path;
470  CHECK_NE(0U, dex_files.size());
471  for (auto& dex_file : dex_files) {
472    class_path.push_back(dex_file.get());
473    loaded_dex_files_.push_back(std::move(dex_file));
474  }
475
476  Thread* self = Thread::Current();
477  jobject class_loader = Runtime::Current()->GetClassLinker()->CreatePathClassLoader(self,                                                                                   class_path);
478  self->SetClassLoaderOverride(class_loader);
479  return class_loader;
480}
481
482std::string CommonRuntimeTest::GetCoreFileLocation(const char* suffix) {
483  CHECK(suffix != nullptr);
484
485  std::string location;
486  if (IsHost()) {
487    const char* host_dir = getenv("ANDROID_HOST_OUT");
488    CHECK(host_dir != NULL);
489    location = StringPrintf("%s/framework/core.%s", host_dir, suffix);
490  } else {
491    location = StringPrintf("/data/art-test/core.%s", suffix);
492  }
493
494  return location;
495}
496
497CheckJniAbortCatcher::CheckJniAbortCatcher() : vm_(Runtime::Current()->GetJavaVM()) {
498  vm_->SetCheckJniAbortHook(Hook, &actual_);
499}
500
501CheckJniAbortCatcher::~CheckJniAbortCatcher() {
502  vm_->SetCheckJniAbortHook(nullptr, nullptr);
503  EXPECT_TRUE(actual_.empty()) << actual_;
504}
505
506void CheckJniAbortCatcher::Check(const char* expected_text) {
507  EXPECT_TRUE(actual_.find(expected_text) != std::string::npos) << "\n"
508      << "Expected to find: " << expected_text << "\n"
509      << "In the output   : " << actual_;
510  actual_.clear();
511}
512
513void CheckJniAbortCatcher::Hook(void* data, const std::string& reason) {
514  // We use += because when we're hooking the aborts like this, multiple problems can be found.
515  *reinterpret_cast<std::string*>(data) += reason;
516}
517
518}  // namespace art
519
520namespace std {
521
522template <typename T>
523std::ostream& operator<<(std::ostream& os, const std::vector<T>& rhs) {
524os << ::art::ToString(rhs);
525return os;
526}
527
528}  // namespace std
529