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 "arch/instruction_set.h"
26 #include "base/mutex.h"
27 #include "globals.h"
28 // TODO: Add inl file and avoid including inl.
29 #include "obj_ptr-inl.h"
30 #include "os.h"
31 
32 namespace art {
33 
34 // OBJ pointer helpers to avoid needing .Decode everywhere.
35 #define EXPECT_OBJ_PTR_EQ(a, b) EXPECT_EQ(MakeObjPtr(a).Ptr(), MakeObjPtr(b).Ptr());
36 #define ASSERT_OBJ_PTR_EQ(a, b) ASSERT_EQ(MakeObjPtr(a).Ptr(), MakeObjPtr(b).Ptr());
37 #define EXPECT_OBJ_PTR_NE(a, b) EXPECT_NE(MakeObjPtr(a).Ptr(), MakeObjPtr(b).Ptr());
38 #define ASSERT_OBJ_PTR_NE(a, b) ASSERT_NE(MakeObjPtr(a).Ptr(), MakeObjPtr(b).Ptr());
39 
40 class ClassLinker;
41 class CompilerCallbacks;
42 class DexFile;
43 class JavaVMExt;
44 class Runtime;
45 typedef std::vector<std::pair<std::string, const void*>> RuntimeOptions;
46 
47 uint8_t* DecodeBase64(const char* src, size_t* dst_size);
48 
49 class ScratchFile {
50  public:
51   ScratchFile();
52 
53   explicit ScratchFile(const std::string& filename);
54 
55   ScratchFile(const ScratchFile& other, const char* suffix);
56 
57   ScratchFile(ScratchFile&& other);
58 
59   ScratchFile& operator=(ScratchFile&& other);
60 
61   explicit ScratchFile(File* file);
62 
63   ~ScratchFile();
64 
GetFilename()65   const std::string& GetFilename() const {
66     return filename_;
67   }
68 
GetFile()69   File* GetFile() const {
70     return file_.get();
71   }
72 
73   int GetFd() const;
74 
75   void Close();
76   void Unlink();
77 
78  private:
79   std::string filename_;
80   std::unique_ptr<File> file_;
81 };
82 
83 class CommonRuntimeTestImpl {
84  public:
85   CommonRuntimeTestImpl();
86   virtual ~CommonRuntimeTestImpl();
87   static void SetUpAndroidRoot();
88 
89   // Note: setting up ANDROID_DATA may create a temporary directory. If this is used in a
90   // non-derived class, be sure to also call the corresponding tear-down below.
91   static void SetUpAndroidData(std::string& android_data);
92 
93   static void TearDownAndroidData(const std::string& android_data, bool fail_on_error);
94 
95   // Gets the paths of the libcore dex files.
96   static std::vector<std::string> GetLibCoreDexFileNames();
97 
98   // Returns bin directory which contains host's prebuild tools.
99   static std::string GetAndroidHostToolsDir();
100 
101   // Returns bin directory wahich contains target's prebuild tools.
102   static std::string GetAndroidTargetToolsDir(InstructionSet isa);
103 
104  protected:
105   // Allow subclases such as CommonCompilerTest to add extra options.
SetUpRuntimeOptions(RuntimeOptions * options ATTRIBUTE_UNUSED)106   virtual void SetUpRuntimeOptions(RuntimeOptions* options ATTRIBUTE_UNUSED) {}
107 
108   // Called before the runtime is created.
PreRuntimeCreate()109   virtual void PreRuntimeCreate() {}
110 
111   // Called after the runtime is created.
PostRuntimeCreate()112   virtual void PostRuntimeCreate() {}
113 
IsHost()114   static bool IsHost() {
115     return !kIsTargetBuild;
116   }
117 
118   // File location to core.art, e.g. $ANDROID_HOST_OUT/system/framework/core.art
119   static std::string GetCoreArtLocation();
120 
121   // File location to core.oat, e.g. $ANDROID_HOST_OUT/system/framework/core.oat
122   static std::string GetCoreOatLocation();
123 
124   std::unique_ptr<const DexFile> LoadExpectSingleDexFile(const char* location);
125 
126   void ClearDirectory(const char* dirpath);
127 
128   std::string GetTestAndroidRoot();
129 
130   std::string GetTestDexFileName(const char* name) const;
131 
132   std::vector<std::unique_ptr<const DexFile>> OpenTestDexFiles(const char* name);
133 
134   std::unique_ptr<const DexFile> OpenTestDexFile(const char* name)
135       REQUIRES_SHARED(Locks::mutator_lock_);
136 
137   jobject LoadDex(const char* dex_name) REQUIRES_SHARED(Locks::mutator_lock_);
138   jobject LoadMultiDex(const char* first_dex_name, const char* second_dex_name)
139       REQUIRES_SHARED(Locks::mutator_lock_);
140 
141   std::string android_data_;
142   std::string dalvik_cache_;
143 
144   std::unique_ptr<Runtime> runtime_;
145 
146   // The class_linker_, java_lang_dex_file_, and boot_class_path_ are all
147   // owned by the runtime.
148   ClassLinker* class_linker_;
149   const DexFile* java_lang_dex_file_;
150   std::vector<const DexFile*> boot_class_path_;
151 
152   // Get the dex files from a PathClassLoader. This in order of the dex elements and their dex
153   // arrays.
154   std::vector<const DexFile*> GetDexFiles(jobject jclass_loader);
155 
156   // Get the first dex file from a PathClassLoader. Will abort if it is null.
157   const DexFile* GetFirstDexFile(jobject jclass_loader);
158 
159   std::unique_ptr<CompilerCallbacks> callbacks_;
160 
161   virtual void SetUp();
162 
163   virtual void TearDown();
164 
165   // Called to finish up runtime creation and filling test fields. By default runs root
166   // initializers, initialize well-known classes, and creates the heap thread pool.
167   virtual void FinalizeSetup();
168 
169  private:
170   static std::string GetCoreFileLocation(const char* suffix);
171 
172   std::vector<std::unique_ptr<const DexFile>> loaded_dex_files_;
173 };
174 
175 template <typename TestType>
176 class CommonRuntimeTestBase : public TestType, public CommonRuntimeTestImpl {
177  public:
CommonRuntimeTestBase()178   CommonRuntimeTestBase() {}
~CommonRuntimeTestBase()179   virtual ~CommonRuntimeTestBase() {}
180 
181  protected:
SetUp()182   virtual void SetUp() OVERRIDE {
183     CommonRuntimeTestImpl::SetUp();
184   }
185 
TearDown()186   virtual void TearDown() OVERRIDE {
187     CommonRuntimeTestImpl::TearDown();
188   }
189 };
190 
191 using CommonRuntimeTest = CommonRuntimeTestBase<testing::Test>;
192 
193 template <typename Param>
194 using CommonRuntimeTestWithParam = CommonRuntimeTestBase<testing::TestWithParam<Param>>;
195 
196 // Sets a CheckJni abort hook to catch failures. Note that this will cause CheckJNI to carry on
197 // rather than aborting, so be careful!
198 class CheckJniAbortCatcher {
199  public:
200   CheckJniAbortCatcher();
201 
202   ~CheckJniAbortCatcher();
203 
204   void Check(const std::string& expected_text);
205   void Check(const char* expected_text);
206 
207  private:
208   static void Hook(void* data, const std::string& reason);
209 
210   JavaVMExt* const vm_;
211   std::string actual_;
212 
213   DISALLOW_COPY_AND_ASSIGN(CheckJniAbortCatcher);
214 };
215 
216 #define TEST_DISABLED_FOR_TARGET() \
217   if (kIsTargetBuild) { \
218     printf("WARNING: TEST DISABLED FOR TARGET\n"); \
219     return; \
220   }
221 
222 #define TEST_DISABLED_FOR_MIPS() \
223   if (kRuntimeISA == kMips) { \
224     printf("WARNING: TEST DISABLED FOR MIPS\n"); \
225     return; \
226   }
227 
228 #define TEST_DISABLED_FOR_X86() \
229   if (kRuntimeISA == kX86) { \
230     printf("WARNING: TEST DISABLED FOR X86\n"); \
231     return; \
232   }
233 
234 #define TEST_DISABLED_FOR_STRING_COMPRESSION() \
235   if (mirror::kUseStringCompression) { \
236     printf("WARNING: TEST DISABLED FOR STRING COMPRESSION\n"); \
237     return; \
238   }
239 
240 #define TEST_DISABLED_FOR_NON_STATIC_HOST_BUILDS() \
241   if (!kHostStaticBuildEnabled) { \
242     printf("WARNING: TEST DISABLED FOR NON-STATIC HOST BUILDS\n"); \
243     return; \
244   }
245 
246 }  // namespace art
247 
248 namespace std {
249 
250 // TODO: isn't gtest supposed to be able to print STL types for itself?
251 template <typename T>
252 std::ostream& operator<<(std::ostream& os, const std::vector<T>& rhs);
253 
254 }  // namespace std
255 
256 #endif  // ART_RUNTIME_COMMON_RUNTIME_TEST_H_
257