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 <android-base/logging.h> 26 27 #include "arch/instruction_set.h" 28 #include "base/common_art_test.h" 29 #include "base/locks.h" 30 #include "base/os.h" 31 #include "base/unix_file/fd_file.h" 32 #include "dex/art_dex_file_loader.h" 33 #include "dex/compact_dex_level.h" 34 // TODO: Add inl file and avoid including inl. 35 #include "obj_ptr-inl.h" 36 #include "runtime_globals.h" 37 #include "scoped_thread_state_change-inl.h" 38 39 namespace art { 40 41 using LogSeverity = android::base::LogSeverity; 42 using ScopedLogSeverity = android::base::ScopedLogSeverity; 43 44 class ClassLinker; 45 class CompilerCallbacks; 46 class DexFile; 47 class JavaVMExt; 48 class Runtime; 49 typedef std::vector<std::pair<std::string, const void*>> RuntimeOptions; 50 class Thread; 51 class VariableSizedHandleScope; 52 53 class CommonRuntimeTestImpl : public CommonArtTestImpl { 54 public: 55 CommonRuntimeTestImpl(); 56 virtual ~CommonRuntimeTestImpl(); 57 58 static std::string GetAndroidTargetToolsDir(InstructionSet isa); 59 60 // A helper function to fill the heap. 61 static void FillHeap(Thread* self, 62 ClassLinker* class_linker, 63 VariableSizedHandleScope* handle_scope) 64 REQUIRES_SHARED(Locks::mutator_lock_); 65 // A helper to set up a small heap (4M) to make FillHeap faster. 66 static void SetUpRuntimeOptionsForFillHeap(RuntimeOptions *options); 67 68 template <typename Mutator> MutateDexFile(File * output_dex,const std::string & input_jar,const Mutator & mutator)69 bool MutateDexFile(File* output_dex, const std::string& input_jar, const Mutator& mutator) { 70 std::vector<std::unique_ptr<const DexFile>> dex_files; 71 std::string error_msg; 72 const ArtDexFileLoader dex_file_loader; 73 CHECK(dex_file_loader.Open(input_jar.c_str(), 74 input_jar.c_str(), 75 /*verify=*/ true, 76 /*verify_checksum=*/ true, 77 &error_msg, 78 &dex_files)) << error_msg; 79 EXPECT_EQ(dex_files.size(), 1u) << "Only one input dex is supported"; 80 const std::unique_ptr<const DexFile>& dex = dex_files[0]; 81 CHECK(dex->EnableWrite()) << "Failed to enable write"; 82 DexFile* dex_file = const_cast<DexFile*>(dex.get()); 83 mutator(dex_file); 84 const_cast<DexFile::Header&>(dex_file->GetHeader()).checksum_ = dex_file->CalculateChecksum(); 85 if (!output_dex->WriteFully(dex->Begin(), dex->Size())) { 86 return false; 87 } 88 if (output_dex->Flush() != 0) { 89 PLOG(FATAL) << "Could not flush the output file."; 90 } 91 return true; 92 } 93 94 void MakeInterpreted(ObjPtr<mirror::Class> klass) 95 REQUIRES_SHARED(Locks::mutator_lock_); 96 97 bool StartDex2OatCommandLine(/*out*/std::vector<std::string>* argv, 98 /*out*/std::string* error_msg); 99 100 protected: 101 // Allow subclases such as CommonCompilerTest to add extra options. SetUpRuntimeOptions(RuntimeOptions * options ATTRIBUTE_UNUSED)102 virtual void SetUpRuntimeOptions(RuntimeOptions* options ATTRIBUTE_UNUSED) {} 103 104 // Called before the runtime is created. PreRuntimeCreate()105 virtual void PreRuntimeCreate() {} 106 107 // Called after the runtime is created. PostRuntimeCreate()108 virtual void PostRuntimeCreate() {} 109 110 // Loads the test dex file identified by the given dex_name into a PathClassLoader. 111 // Returns the created class loader. 112 jobject LoadDex(const char* dex_name) REQUIRES_SHARED(Locks::mutator_lock_); 113 // Loads the test dex file identified by the given first_dex_name and second_dex_name 114 // into a PathClassLoader. Returns the created class loader. 115 jobject LoadMultiDex(const char* first_dex_name, const char* second_dex_name) 116 REQUIRES_SHARED(Locks::mutator_lock_); 117 118 jobject LoadDexInPathClassLoader(const std::string& dex_name, 119 jobject parent_loader, 120 jobject shared_libraries = nullptr); 121 jobject LoadDexInDelegateLastClassLoader(const std::string& dex_name, jobject parent_loader); 122 jobject LoadDexInInMemoryDexClassLoader(const std::string& dex_name, jobject parent_loader); 123 jobject LoadDexInWellKnownClassLoader(const std::string& dex_name, 124 jclass loader_class, 125 jobject parent_loader, 126 jobject shared_libraries = nullptr); 127 128 std::unique_ptr<Runtime> runtime_; 129 130 // The class_linker_, java_lang_dex_file_, and boot_class_path_ are all 131 // owned by the runtime. 132 ClassLinker* class_linker_; 133 const DexFile* java_lang_dex_file_; 134 std::vector<const DexFile*> boot_class_path_; 135 136 // Get the dex files from a PathClassLoader or DelegateLastClassLoader. 137 // This only looks into the current class loader and does not recurse into the parents. 138 std::vector<const DexFile*> GetDexFiles(jobject jclass_loader); 139 std::vector<const DexFile*> GetDexFiles(ScopedObjectAccess& soa, 140 Handle<mirror::ClassLoader> class_loader) 141 REQUIRES_SHARED(Locks::mutator_lock_); 142 143 // Get the first dex file from a PathClassLoader. Will abort if it is null. 144 const DexFile* GetFirstDexFile(jobject jclass_loader); 145 146 std::unique_ptr<CompilerCallbacks> callbacks_; 147 148 virtual void SetUp(); 149 150 virtual void TearDown(); 151 152 // Called to finish up runtime creation and filling test fields. By default runs root 153 // initializers, initialize well-known classes, and creates the heap thread pool. 154 virtual void FinalizeSetup(); 155 }; 156 157 template <typename TestType> 158 class CommonRuntimeTestBase : public TestType, public CommonRuntimeTestImpl { 159 public: CommonRuntimeTestBase()160 CommonRuntimeTestBase() {} ~CommonRuntimeTestBase()161 virtual ~CommonRuntimeTestBase() {} 162 163 protected: SetUp()164 void SetUp() override { 165 CommonRuntimeTestImpl::SetUp(); 166 } 167 TearDown()168 void TearDown() override { 169 CommonRuntimeTestImpl::TearDown(); 170 } 171 }; 172 173 using CommonRuntimeTest = CommonRuntimeTestBase<testing::Test>; 174 175 template <typename Param> 176 using CommonRuntimeTestWithParam = CommonRuntimeTestBase<testing::TestWithParam<Param>>; 177 178 // Sets a CheckJni abort hook to catch failures. Note that this will cause CheckJNI to carry on 179 // rather than aborting, so be careful! 180 class CheckJniAbortCatcher { 181 public: 182 CheckJniAbortCatcher(); 183 184 ~CheckJniAbortCatcher(); 185 186 void Check(const std::string& expected_text); 187 void Check(const char* expected_text); 188 189 private: 190 static void Hook(void* data, const std::string& reason); 191 192 JavaVMExt* const vm_; 193 std::string actual_; 194 195 DISALLOW_COPY_AND_ASSIGN(CheckJniAbortCatcher); 196 }; 197 198 #define TEST_DISABLED_FOR_ARM() \ 199 if (kRuntimeISA == InstructionSet::kArm || kRuntimeISA == InstructionSet::kThumb2) { \ 200 printf("WARNING: TEST DISABLED FOR ARM\n"); \ 201 return; \ 202 } 203 204 #define TEST_DISABLED_FOR_ARM64() \ 205 if (kRuntimeISA == InstructionSet::kArm64) { \ 206 printf("WARNING: TEST DISABLED FOR ARM64\n"); \ 207 return; \ 208 } 209 210 #define TEST_DISABLED_FOR_MIPS() \ 211 if (kRuntimeISA == InstructionSet::kMips) { \ 212 printf("WARNING: TEST DISABLED FOR MIPS\n"); \ 213 return; \ 214 } 215 216 #define TEST_DISABLED_FOR_MIPS64() \ 217 if (kRuntimeISA == InstructionSet::kMips64) { \ 218 printf("WARNING: TEST DISABLED FOR MIPS64\n"); \ 219 return; \ 220 } 221 222 #define TEST_DISABLED_FOR_X86() \ 223 if (kRuntimeISA == InstructionSet::kX86) { \ 224 printf("WARNING: TEST DISABLED FOR X86\n"); \ 225 return; \ 226 } 227 228 #define TEST_DISABLED_FOR_STRING_COMPRESSION() \ 229 if (mirror::kUseStringCompression) { \ 230 printf("WARNING: TEST DISABLED FOR STRING COMPRESSION\n"); \ 231 return; \ 232 } 233 234 #define TEST_DISABLED_WITHOUT_BAKER_READ_BARRIERS() \ 235 if (!kEmitCompilerReadBarrier || !kUseBakerReadBarrier) { \ 236 printf("WARNING: TEST DISABLED FOR GC WITHOUT BAKER READ BARRIER\n"); \ 237 return; \ 238 } 239 240 #define TEST_DISABLED_FOR_HEAP_POISONING() \ 241 if (kPoisonHeapReferences) { \ 242 printf("WARNING: TEST DISABLED FOR HEAP POISONING\n"); \ 243 return; \ 244 } 245 246 #define TEST_DISABLED_FOR_MEMORY_TOOL_WITH_HEAP_POISONING_WITHOUT_READ_BARRIERS() \ 247 if (kRunningOnMemoryTool && kPoisonHeapReferences && !kEmitCompilerReadBarrier) { \ 248 printf("WARNING: TEST DISABLED FOR MEMORY TOOL WITH HEAP POISONING WITHOUT READ BARRIERS\n"); \ 249 return; \ 250 } 251 252 } // namespace art 253 254 #endif // ART_RUNTIME_COMMON_RUNTIME_TEST_H_ 255