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 24 #include "../../external/icu/icu4c/source/common/unicode/uvernum.h" 25 #include "base/macros.h" 26 #include "base/logging.h" 27 #include "base/stl_util.h" 28 #include "base/stringprintf.h" 29 #include "base/unix_file/fd_file.h" 30 #include "class_linker.h" 31 #include "compiler_callbacks.h" 32 #include "dex_file.h" 33 #include "gc_root-inl.h" 34 #include "gc/heap.h" 35 #include "gtest/gtest.h" 36 #include "jni_internal.h" 37 #include "mirror/class_loader.h" 38 #include "noop_compiler_callbacks.h" 39 #include "os.h" 40 #include "runtime-inl.h" 41 #include "scoped_thread_state_change.h" 42 #include "thread.h" 43 #include "well_known_classes.h" 44 45 int main(int argc, char **argv) { 46 art::InitLogging(argv); 47 LOG(INFO) << "Running main() from common_runtime_test.cc..."; 48 testing::InitGoogleTest(&argc, argv); 49 return RUN_ALL_TESTS(); 50 } 51 52 namespace art { 53 54 ScratchFile::ScratchFile() { 55 // ANDROID_DATA needs to be set 56 CHECK_NE(static_cast<char*>(nullptr), getenv("ANDROID_DATA")) << 57 "Are you subclassing RuntimeTest?"; 58 filename_ = getenv("ANDROID_DATA"); 59 filename_ += "/TmpFile-XXXXXX"; 60 int fd = mkstemp(&filename_[0]); 61 CHECK_NE(-1, fd); 62 file_.reset(new File(fd, GetFilename())); 63 } 64 65 ScratchFile::ScratchFile(const ScratchFile& other, const char* suffix) { 66 filename_ = other.GetFilename(); 67 filename_ += suffix; 68 int fd = open(filename_.c_str(), O_RDWR | O_CREAT, 0666); 69 CHECK_NE(-1, fd); 70 file_.reset(new File(fd, GetFilename())); 71 } 72 73 ScratchFile::ScratchFile(File* file) { 74 CHECK(file != NULL); 75 filename_ = file->GetPath(); 76 file_.reset(file); 77 } 78 79 ScratchFile::~ScratchFile() { 80 Unlink(); 81 } 82 83 int ScratchFile::GetFd() const { 84 return file_->Fd(); 85 } 86 87 void ScratchFile::Unlink() { 88 if (!OS::FileExists(filename_.c_str())) { 89 return; 90 } 91 int unlink_result = unlink(filename_.c_str()); 92 CHECK_EQ(0, unlink_result); 93 } 94 95 CommonRuntimeTest::CommonRuntimeTest() {} 96 CommonRuntimeTest::~CommonRuntimeTest() {} 97 98 void CommonRuntimeTest::SetUpAndroidRoot() { 99 if (IsHost()) { 100 // $ANDROID_ROOT is set on the device, but not necessarily on the host. 101 // But it needs to be set so that icu4c can find its locale data. 102 const char* android_root_from_env = getenv("ANDROID_ROOT"); 103 if (android_root_from_env == nullptr) { 104 // Use ANDROID_HOST_OUT for ANDROID_ROOT if it is set. 105 const char* android_host_out = getenv("ANDROID_HOST_OUT"); 106 if (android_host_out != nullptr) { 107 setenv("ANDROID_ROOT", android_host_out, 1); 108 } else { 109 // Build it from ANDROID_BUILD_TOP or cwd 110 std::string root; 111 const char* android_build_top = getenv("ANDROID_BUILD_TOP"); 112 if (android_build_top != nullptr) { 113 root += android_build_top; 114 } else { 115 // Not set by build server, so default to current directory 116 char* cwd = getcwd(nullptr, 0); 117 setenv("ANDROID_BUILD_TOP", cwd, 1); 118 root += cwd; 119 free(cwd); 120 } 121 #if defined(__linux__) 122 root += "/out/host/linux-x86"; 123 #elif defined(__APPLE__) 124 root += "/out/host/darwin-x86"; 125 #else 126 #error unsupported OS 127 #endif 128 setenv("ANDROID_ROOT", root.c_str(), 1); 129 } 130 } 131 setenv("LD_LIBRARY_PATH", ":", 0); // Required by java.lang.System.<clinit>. 132 133 // Not set by build server, so default 134 if (getenv("ANDROID_HOST_OUT") == nullptr) { 135 setenv("ANDROID_HOST_OUT", getenv("ANDROID_ROOT"), 1); 136 } 137 } 138 } 139 140 void CommonRuntimeTest::SetUpAndroidData(std::string& android_data) { 141 // On target, Cannot use /mnt/sdcard because it is mounted noexec, so use subdir of dalvik-cache 142 if (IsHost()) { 143 const char* tmpdir = getenv("TMPDIR"); 144 if (tmpdir != nullptr && tmpdir[0] != 0) { 145 android_data = tmpdir; 146 } else { 147 android_data = "/tmp"; 148 } 149 } else { 150 android_data = "/data/dalvik-cache"; 151 } 152 android_data += "/art-data-XXXXXX"; 153 if (mkdtemp(&android_data[0]) == nullptr) { 154 PLOG(FATAL) << "mkdtemp(\"" << &android_data[0] << "\") failed"; 155 } 156 setenv("ANDROID_DATA", android_data.c_str(), 1); 157 } 158 159 void CommonRuntimeTest::TearDownAndroidData(const std::string& android_data, bool fail_on_error) { 160 if (fail_on_error) { 161 ASSERT_EQ(rmdir(android_data.c_str()), 0); 162 } else { 163 rmdir(android_data.c_str()); 164 } 165 } 166 167 168 const DexFile* CommonRuntimeTest::LoadExpectSingleDexFile(const char* location) { 169 std::vector<const DexFile*> dex_files; 170 std::string error_msg; 171 if (!DexFile::Open(location, location, &error_msg, &dex_files)) { 172 LOG(FATAL) << "Could not open .dex file '" << location << "': " << error_msg << "\n"; 173 return nullptr; 174 } else { 175 CHECK_EQ(1U, dex_files.size()) << "Expected only one dex file in " << location; 176 return dex_files[0]; 177 } 178 } 179 180 void CommonRuntimeTest::SetUp() { 181 SetUpAndroidRoot(); 182 SetUpAndroidData(android_data_); 183 dalvik_cache_.append(android_data_.c_str()); 184 dalvik_cache_.append("/dalvik-cache"); 185 int mkdir_result = mkdir(dalvik_cache_.c_str(), 0700); 186 ASSERT_EQ(mkdir_result, 0); 187 188 MemMap::Init(); // For LoadExpectSingleDexFile 189 190 std::string error_msg; 191 java_lang_dex_file_ = LoadExpectSingleDexFile(GetLibCoreDexFileName().c_str()); 192 boot_class_path_.push_back(java_lang_dex_file_); 193 194 std::string min_heap_string(StringPrintf("-Xms%zdm", gc::Heap::kDefaultInitialSize / MB)); 195 std::string max_heap_string(StringPrintf("-Xmx%zdm", gc::Heap::kDefaultMaximumSize / MB)); 196 197 callbacks_.reset(new NoopCompilerCallbacks()); 198 199 RuntimeOptions options; 200 options.push_back(std::make_pair("bootclasspath", &boot_class_path_)); 201 options.push_back(std::make_pair("-Xcheck:jni", nullptr)); 202 options.push_back(std::make_pair(min_heap_string.c_str(), nullptr)); 203 options.push_back(std::make_pair(max_heap_string.c_str(), nullptr)); 204 options.push_back(std::make_pair("compilercallbacks", callbacks_.get())); 205 SetUpRuntimeOptions(&options); 206 if (!Runtime::Create(options, false)) { 207 LOG(FATAL) << "Failed to create runtime"; 208 return; 209 } 210 runtime_.reset(Runtime::Current()); 211 class_linker_ = runtime_->GetClassLinker(); 212 class_linker_->FixupDexCaches(runtime_->GetResolutionMethod()); 213 class_linker_->RunRootClinits(); 214 215 // Runtime::Create acquired the mutator_lock_ that is normally given away when we 216 // Runtime::Start, give it away now and then switch to a more managable ScopedObjectAccess. 217 Thread::Current()->TransitionFromRunnableToSuspended(kNative); 218 219 // We're back in native, take the opportunity to initialize well known classes. 220 WellKnownClasses::Init(Thread::Current()->GetJniEnv()); 221 222 // Create the heap thread pool so that the GC runs in parallel for tests. Normally, the thread 223 // pool is created by the runtime. 224 runtime_->GetHeap()->CreateThreadPool(); 225 runtime_->GetHeap()->VerifyHeap(); // Check for heap corruption before the test 226 } 227 228 void CommonRuntimeTest::ClearDirectory(const char* dirpath) { 229 ASSERT_TRUE(dirpath != nullptr); 230 DIR* dir = opendir(dirpath); 231 ASSERT_TRUE(dir != nullptr); 232 dirent* e; 233 struct stat s; 234 while ((e = readdir(dir)) != nullptr) { 235 if ((strcmp(e->d_name, ".") == 0) || (strcmp(e->d_name, "..") == 0)) { 236 continue; 237 } 238 std::string filename(dirpath); 239 filename.push_back('/'); 240 filename.append(e->d_name); 241 int stat_result = lstat(filename.c_str(), &s); 242 ASSERT_EQ(0, stat_result) << "unable to stat " << filename; 243 if (S_ISDIR(s.st_mode)) { 244 ClearDirectory(filename.c_str()); 245 int rmdir_result = rmdir(filename.c_str()); 246 ASSERT_EQ(0, rmdir_result) << filename; 247 } else { 248 int unlink_result = unlink(filename.c_str()); 249 ASSERT_EQ(0, unlink_result) << filename; 250 } 251 } 252 closedir(dir); 253 } 254 255 void CommonRuntimeTest::TearDown() { 256 const char* android_data = getenv("ANDROID_DATA"); 257 ASSERT_TRUE(android_data != nullptr); 258 ClearDirectory(dalvik_cache_.c_str()); 259 int rmdir_cache_result = rmdir(dalvik_cache_.c_str()); 260 ASSERT_EQ(0, rmdir_cache_result); 261 TearDownAndroidData(android_data_, true); 262 263 // icu4c has a fixed 10-element array "gCommonICUDataArray". 264 // If we run > 10 tests, we fill that array and u_setCommonData fails. 265 // There's a function to clear the array, but it's not public... 266 typedef void (*IcuCleanupFn)(); 267 void* sym = dlsym(RTLD_DEFAULT, "u_cleanup_" U_ICU_VERSION_SHORT); 268 CHECK(sym != nullptr) << dlerror(); 269 IcuCleanupFn icu_cleanup_fn = reinterpret_cast<IcuCleanupFn>(sym); 270 (*icu_cleanup_fn)(); 271 272 STLDeleteElements(&opened_dex_files_); 273 274 Runtime::Current()->GetHeap()->VerifyHeap(); // Check for heap corruption after the test 275 } 276 277 std::string CommonRuntimeTest::GetLibCoreDexFileName() { 278 return GetDexFileName("core-libart"); 279 } 280 281 std::string CommonRuntimeTest::GetDexFileName(const std::string& jar_prefix) { 282 if (IsHost()) { 283 const char* host_dir = getenv("ANDROID_HOST_OUT"); 284 CHECK(host_dir != nullptr); 285 return StringPrintf("%s/framework/%s-hostdex.jar", host_dir, jar_prefix.c_str()); 286 } 287 return StringPrintf("%s/framework/%s.jar", GetAndroidRoot(), jar_prefix.c_str()); 288 } 289 290 std::string CommonRuntimeTest::GetTestAndroidRoot() { 291 if (IsHost()) { 292 const char* host_dir = getenv("ANDROID_HOST_OUT"); 293 CHECK(host_dir != nullptr); 294 return host_dir; 295 } 296 return GetAndroidRoot(); 297 } 298 299 // Check that for target builds we have ART_TARGET_NATIVETEST_DIR set. 300 #ifdef ART_TARGET 301 #ifndef ART_TARGET_NATIVETEST_DIR 302 #error "ART_TARGET_NATIVETEST_DIR not set." 303 #endif 304 // Wrap it as a string literal. 305 #define ART_TARGET_NATIVETEST_DIR_STRING STRINGIFY(ART_TARGET_NATIVETEST_DIR) "/" 306 #else 307 #define ART_TARGET_NATIVETEST_DIR_STRING "" 308 #endif 309 310 std::vector<const DexFile*> CommonRuntimeTest::OpenTestDexFiles(const char* name) { 311 CHECK(name != nullptr); 312 std::string filename; 313 if (IsHost()) { 314 filename += getenv("ANDROID_HOST_OUT"); 315 filename += "/framework/"; 316 } else { 317 filename += ART_TARGET_NATIVETEST_DIR_STRING; 318 } 319 filename += "art-gtest-"; 320 filename += name; 321 filename += ".jar"; 322 std::string error_msg; 323 std::vector<const DexFile*> dex_files; 324 bool success = DexFile::Open(filename.c_str(), filename.c_str(), &error_msg, &dex_files); 325 CHECK(success) << "Failed to open '" << filename << "': " << error_msg; 326 for (const DexFile* dex_file : dex_files) { 327 CHECK_EQ(PROT_READ, dex_file->GetPermissions()); 328 CHECK(dex_file->IsReadOnly()); 329 } 330 opened_dex_files_.insert(opened_dex_files_.end(), dex_files.begin(), dex_files.end()); 331 return dex_files; 332 } 333 334 const DexFile* CommonRuntimeTest::OpenTestDexFile(const char* name) { 335 std::vector<const DexFile*> vector = OpenTestDexFiles(name); 336 EXPECT_EQ(1U, vector.size()); 337 return vector[0]; 338 } 339 340 jobject CommonRuntimeTest::LoadDex(const char* dex_name) { 341 std::vector<const DexFile*> dex_files = OpenTestDexFiles(dex_name); 342 CHECK_NE(0U, dex_files.size()); 343 for (const DexFile* dex_file : dex_files) { 344 class_linker_->RegisterDexFile(*dex_file); 345 } 346 ScopedObjectAccessUnchecked soa(Thread::Current()); 347 ScopedLocalRef<jobject> class_loader_local(soa.Env(), 348 soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader)); 349 jobject class_loader = soa.Env()->NewGlobalRef(class_loader_local.get()); 350 soa.Self()->SetClassLoaderOverride(soa.Decode<mirror::ClassLoader*>(class_loader_local.get())); 351 Runtime::Current()->SetCompileTimeClassPath(class_loader, dex_files); 352 return class_loader; 353 } 354 355 CheckJniAbortCatcher::CheckJniAbortCatcher() : vm_(Runtime::Current()->GetJavaVM()) { 356 vm_->check_jni_abort_hook = Hook; 357 vm_->check_jni_abort_hook_data = &actual_; 358 } 359 360 CheckJniAbortCatcher::~CheckJniAbortCatcher() { 361 vm_->check_jni_abort_hook = nullptr; 362 vm_->check_jni_abort_hook_data = nullptr; 363 EXPECT_TRUE(actual_.empty()) << actual_; 364 } 365 366 void CheckJniAbortCatcher::Check(const char* expected_text) { 367 EXPECT_TRUE(actual_.find(expected_text) != std::string::npos) << "\n" 368 << "Expected to find: " << expected_text << "\n" 369 << "In the output : " << actual_; 370 actual_.clear(); 371 } 372 373 void CheckJniAbortCatcher::Hook(void* data, const std::string& reason) { 374 // We use += because when we're hooking the aborts like this, multiple problems can be found. 375 *reinterpret_cast<std::string*>(data) += reason; 376 } 377 378 } // namespace art 379 380 namespace std { 381 382 template <typename T> 383 std::ostream& operator<<(std::ostream& os, const std::vector<T>& rhs) { 384 os << ::art::ToString(rhs); 385 return os; 386 } 387 388 } // namespace std 389
