1 /* 2 * Copyright (C) 2011 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 #ifndef ART_RUNTIME_COMMON_RUNTIME_TEST_H_ 18 #define ART_RUNTIME_COMMON_RUNTIME_TEST_H_ 19 20 #include <gtest/gtest.h> 21 #include <jni.h> 22 23 #include <string> 24 25 #include "base/mutex.h" 26 #include "globals.h" 27 #include "os.h" 28 29 namespace art { 30 31 class ClassLinker; 32 class CompilerCallbacks; 33 class DexFile; 34 class JavaVMExt; 35 class Runtime; 36 typedef std::vector<std::pair<std::string, const void*>> RuntimeOptions; 37 38 class ScratchFile { 39 public: 40 ScratchFile(); 41 42 ScratchFile(const ScratchFile& other, const char* suffix); 43 44 explicit ScratchFile(File* file); 45 46 ~ScratchFile(); 47 48 const std::string& GetFilename() const { 49 return filename_; 50 } 51 52 File* GetFile() const { 53 return file_.get(); 54 } 55 56 int GetFd() const; 57 58 void Unlink(); 59 60 private: 61 std::string filename_; 62 std::unique_ptr<File> file_; 63 }; 64 65 class CommonRuntimeTest : public testing::Test { 66 public: 67 static void SetUpAndroidRoot(); 68 69 // Note: setting up ANDROID_DATA may create a temporary directory. If this is used in a 70 // non-derived class, be sure to also call the corresponding tear-down below. 71 static void SetUpAndroidData(std::string& android_data); 72 73 static void TearDownAndroidData(const std::string& android_data, bool fail_on_error); 74 75 CommonRuntimeTest(); 76 ~CommonRuntimeTest(); 77 78 protected: 79 static bool IsHost() { 80 return !kIsTargetBuild; 81 } 82 83 const DexFile* LoadExpectSingleDexFile(const char* location); 84 85 virtual void SetUp(); 86 87 // Allow subclases such as CommonCompilerTest to add extra options. 88 virtual void SetUpRuntimeOptions(RuntimeOptions* options) {} 89 90 void ClearDirectory(const char* dirpath); 91 92 virtual void TearDown(); 93 94 // Gets the path of the libcore dex file. 95 std::string GetLibCoreDexFileName(); 96 97 // Gets the path of the specified dex file for host or target. 98 std::string GetDexFileName(const std::string& jar_prefix); 99 100 std::string GetTestAndroidRoot(); 101 102 std::vector<const DexFile*> OpenTestDexFiles(const char* name) 103 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 104 105 const DexFile* OpenTestDexFile(const char* name) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 106 107 jobject LoadDex(const char* dex_name) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 108 109 std::string android_data_; 110 std::string dalvik_cache_; 111 const DexFile* java_lang_dex_file_; // owned by runtime_ 112 std::vector<const DexFile*> boot_class_path_; 113 std::unique_ptr<Runtime> runtime_; 114 // Owned by the runtime 115 ClassLinker* class_linker_; 116 117 private: 118 std::unique_ptr<CompilerCallbacks> callbacks_; 119 std::vector<const DexFile*> opened_dex_files_; 120 }; 121 122 // Sets a CheckJni abort hook to catch failures. Note that this will cause CheckJNI to carry on 123 // rather than aborting, so be careful! 124 class CheckJniAbortCatcher { 125 public: 126 CheckJniAbortCatcher(); 127 128 ~CheckJniAbortCatcher(); 129 130 void Check(const char* expected_text); 131 132 private: 133 static void Hook(void* data, const std::string& reason); 134 135 JavaVMExt* vm_; 136 std::string actual_; 137 138 DISALLOW_COPY_AND_ASSIGN(CheckJniAbortCatcher); 139 }; 140 141 // TODO: These tests were disabled for portable when we went to having 142 // MCLinker link LLVM ELF output because we no longer just have code 143 // blobs in memory. We'll need to dlopen to load and relocate 144 // temporary output to resurrect these tests. 145 #define TEST_DISABLED_FOR_PORTABLE() \ 146 if (kUsePortableCompiler) { \ 147 printf("WARNING: TEST DISABLED FOR PORTABLE\n"); \ 148 return; \ 149 } 150 151 // TODO: When heap reference poisoning works with the compiler, get rid of this. 152 #define TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING() \ 153 if (kPoisonHeapReferences) { \ 154 printf("WARNING: TEST DISABLED FOR HEAP REFERENCE POISONING\n"); \ 155 return; \ 156 } 157 158 #define TEST_DISABLED_FOR_MIPS() \ 159 if (kRuntimeISA == kMips || kRuntimeISA == kMips64) { \ 160 printf("WARNING: TEST DISABLED FOR MIPS\n"); \ 161 return; \ 162 } 163 164 } // namespace art 165 166 namespace std { 167 168 // TODO: isn't gtest supposed to be able to print STL types for itself? 169 template <typename T> 170 std::ostream& operator<<(std::ostream& os, const std::vector<T>& rhs); 171 172 } // namespace std 173 174 #endif // ART_RUNTIME_COMMON_RUNTIME_TEST_H_ 175