1 /*
2  * Copyright (C) 2017 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 "class_loader_context.h"
18 
19 #include <gtest/gtest.h>
20 
21 #include "android-base/strings.h"
22 #include "art_field-inl.h"
23 #include "base/dchecked_vector.h"
24 #include "base/stl_util.h"
25 #include "class_linker.h"
26 #include "class_root-inl.h"
27 #include "common_runtime_test.h"
28 #include "dex/dex_file.h"
29 #include "handle_scope-inl.h"
30 #include "jni/jni_internal.h"
31 #include "mirror/class.h"
32 #include "mirror/class_loader-inl.h"
33 #include "mirror/object-inl.h"
34 #include "mirror/object_array-alloc-inl.h"
35 #include "oat_file_assistant.h"
36 #include "runtime.h"
37 #include "scoped_thread_state_change-inl.h"
38 #include "thread.h"
39 #include "well_known_classes.h"
40 
41 namespace art {
42 
43 class ClassLoaderContextTest : public CommonRuntimeTest {
44  public:
VerifyContextSize(ClassLoaderContext * context,size_t expected_size)45   void VerifyContextSize(ClassLoaderContext* context, size_t expected_size) {
46     ASSERT_TRUE(context != nullptr);
47     ASSERT_EQ(expected_size, context->GetParentChainSize());
48   }
49 
VerifyClassLoaderPCL(ClassLoaderContext * context,size_t index,const std::string & classpath)50   void VerifyClassLoaderPCL(ClassLoaderContext* context,
51                             size_t index,
52                             const std::string& classpath) {
53     VerifyClassLoaderInfo(
54         context, index, ClassLoaderContext::kPathClassLoader, classpath);
55   }
56 
VerifyClassLoaderDLC(ClassLoaderContext * context,size_t index,const std::string & classpath)57   void VerifyClassLoaderDLC(ClassLoaderContext* context,
58                             size_t index,
59                             const std::string& classpath) {
60     VerifyClassLoaderInfo(
61         context, index, ClassLoaderContext::kDelegateLastClassLoader, classpath);
62   }
63 
VerifyClassLoaderIMC(ClassLoaderContext * context,size_t index,const std::string & classpath)64   void VerifyClassLoaderIMC(ClassLoaderContext* context,
65                             size_t index,
66                             const std::string& classpath) {
67     VerifyClassLoaderInfo(
68         context, index, ClassLoaderContext::kInMemoryDexClassLoader, classpath);
69   }
70 
VerifyClassLoaderSharedLibraryPCL(ClassLoaderContext * context,size_t loader_index,size_t shared_library_index,const std::string & classpath)71   void VerifyClassLoaderSharedLibraryPCL(ClassLoaderContext* context,
72                                          size_t loader_index,
73                                          size_t shared_library_index,
74                                          const std::string& classpath) {
75     VerifyClassLoaderInfoSL(
76         context, loader_index, shared_library_index, ClassLoaderContext::kPathClassLoader,
77         classpath);
78   }
79 
VerifyClassLoaderSharedLibraryIMC(ClassLoaderContext * context,size_t loader_index,size_t shared_library_index,const std::string & classpath)80   void VerifyClassLoaderSharedLibraryIMC(ClassLoaderContext* context,
81                                          size_t loader_index,
82                                          size_t shared_library_index,
83                                          const std::string& classpath) {
84     VerifyClassLoaderInfoSL(
85         context, loader_index, shared_library_index, ClassLoaderContext::kInMemoryDexClassLoader,
86         classpath);
87   }
88 
VerifySharedLibrariesSize(ClassLoaderContext * context,size_t loader_index,size_t expected_size)89   void VerifySharedLibrariesSize(ClassLoaderContext* context,
90                                  size_t loader_index,
91                                  size_t expected_size) {
92     ASSERT_TRUE(context != nullptr);
93     ASSERT_GT(context->GetParentChainSize(), loader_index);
94     const ClassLoaderContext::ClassLoaderInfo& info = *context->GetParent(loader_index);
95     ASSERT_EQ(info.shared_libraries.size(), expected_size);
96   }
97 
VerifyClassLoaderSharedLibraryDLC(ClassLoaderContext * context,size_t loader_index,size_t shared_library_index,const std::string & classpath)98   void VerifyClassLoaderSharedLibraryDLC(ClassLoaderContext* context,
99                                          size_t loader_index,
100                                          size_t shared_library_index,
101                                          const std::string& classpath) {
102     VerifyClassLoaderInfoSL(
103         context, loader_index, shared_library_index, ClassLoaderContext::kDelegateLastClassLoader,
104         classpath);
105   }
106 
VerifyClassLoaderPCLFromTestDex(ClassLoaderContext * context,size_t index,const std::string & test_name)107   void VerifyClassLoaderPCLFromTestDex(ClassLoaderContext* context,
108                                        size_t index,
109                                        const std::string& test_name) {
110     VerifyClassLoaderFromTestDex(
111         context, index, ClassLoaderContext::kPathClassLoader, test_name);
112   }
113 
VerifyClassLoaderDLCFromTestDex(ClassLoaderContext * context,size_t index,const std::string & test_name)114   void VerifyClassLoaderDLCFromTestDex(ClassLoaderContext* context,
115                                        size_t index,
116                                        const std::string& test_name) {
117     VerifyClassLoaderFromTestDex(
118         context, index, ClassLoaderContext::kDelegateLastClassLoader, test_name);
119   }
120 
VerifyClassLoaderIMCFromTestDex(ClassLoaderContext * context,size_t index,const std::string & test_name)121   void VerifyClassLoaderIMCFromTestDex(ClassLoaderContext* context,
122                                        size_t index,
123                                        const std::string& test_name) {
124     VerifyClassLoaderFromTestDex(
125         context, index, ClassLoaderContext::kInMemoryDexClassLoader, test_name, "<unknown>");
126   }
127 
128   enum class LocationCheck {
129     kEquals,
130     kEndsWith
131   };
132   enum class BaseLocationCheck {
133     kEquals,
134     kEndsWith
135   };
136 
IsAbsoluteLocation(const std::string & location)137   static bool IsAbsoluteLocation(const std::string& location) {
138     return !location.empty() && location[0] == '/';
139   }
140 
VerifyOpenDexFiles(ClassLoaderContext * context,size_t index,std::vector<std::unique_ptr<const DexFile>> * all_dex_files,bool classpath_matches_dex_location=true)141   void VerifyOpenDexFiles(
142       ClassLoaderContext* context,
143       size_t index,
144       std::vector<std::unique_ptr<const DexFile>>* all_dex_files,
145       bool classpath_matches_dex_location = true) {
146     ASSERT_TRUE(context != nullptr);
147     ASSERT_TRUE(context->dex_files_open_attempted_);
148     ASSERT_TRUE(context->dex_files_open_result_);
149     ClassLoaderContext::ClassLoaderInfo& info = *context->GetParent(index);
150     ASSERT_EQ(all_dex_files->size(), info.classpath.size());
151     ASSERT_EQ(all_dex_files->size(), info.opened_dex_files.size());
152     size_t cur_open_dex_index = 0;
153     for (size_t k = 0; k < all_dex_files->size(); k++) {
154       std::unique_ptr<const DexFile>& opened_dex_file =
155             info.opened_dex_files[cur_open_dex_index++];
156       std::unique_ptr<const DexFile>& expected_dex_file = (*all_dex_files)[k];
157 
158       std::string expected_location = expected_dex_file->GetLocation();
159 
160       const std::string& opened_location = opened_dex_file->GetLocation();
161       if (!IsAbsoluteLocation(opened_location)) {
162         // If the opened location is relative (it was open from a relative path without a
163         // classpath_dir) it might not match the expected location which is absolute in tests).
164         // So we compare the endings (the checksum will validate it's actually the same file).
165         ASSERT_EQ(0, expected_location.compare(
166             expected_location.length() - opened_location.length(),
167             opened_location.length(),
168             opened_location));
169       } else {
170         ASSERT_EQ(expected_location, opened_location);
171       }
172       ASSERT_EQ(expected_dex_file->GetLocationChecksum(), opened_dex_file->GetLocationChecksum());
173       if (classpath_matches_dex_location) {
174         ASSERT_EQ(info.classpath[k], opened_location);
175       }
176     }
177   }
178 
CreateContextForClassLoader(jobject class_loader)179   std::unique_ptr<ClassLoaderContext> CreateContextForClassLoader(jobject class_loader) {
180     return ClassLoaderContext::CreateContextForClassLoader(class_loader, nullptr);
181   }
182 
ParseContextWithChecksums(const std::string & context_spec)183   std::unique_ptr<ClassLoaderContext> ParseContextWithChecksums(const std::string& context_spec) {
184     std::unique_ptr<ClassLoaderContext> context(new ClassLoaderContext());
185     if (!context->Parse(context_spec, /*parse_checksums=*/ true)) {
186       return nullptr;
187     }
188     return context;
189   }
190 
VerifyContextForClassLoader(ClassLoaderContext * context)191   void VerifyContextForClassLoader(ClassLoaderContext* context) {
192     ASSERT_TRUE(context != nullptr);
193     ASSERT_TRUE(context->dex_files_open_attempted_);
194     ASSERT_TRUE(context->dex_files_open_result_);
195     ASSERT_FALSE(context->owns_the_dex_files_);
196     ASSERT_FALSE(context->special_shared_library_);
197   }
198 
VerifyClassLoaderDexFiles(ScopedObjectAccess & soa,Handle<mirror::ClassLoader> class_loader,jclass type,std::vector<const DexFile * > & expected_dex_files)199   void VerifyClassLoaderDexFiles(ScopedObjectAccess& soa,
200                                  Handle<mirror::ClassLoader> class_loader,
201                                  jclass type,
202                                  std::vector<const DexFile*>& expected_dex_files)
203       REQUIRES_SHARED(Locks::mutator_lock_) {
204     ASSERT_TRUE(class_loader->GetClass() == soa.Decode<mirror::Class>(type));
205 
206     std::vector<const DexFile*> class_loader_dex_files = GetDexFiles(soa, class_loader);
207     ASSERT_EQ(expected_dex_files.size(), class_loader_dex_files.size());
208 
209     for (size_t i = 0; i < expected_dex_files.size(); i++) {
210       ASSERT_EQ(expected_dex_files[i]->GetLocation(),
211                 class_loader_dex_files[i]->GetLocation());
212       ASSERT_EQ(expected_dex_files[i]->GetLocationChecksum(),
213                 class_loader_dex_files[i]->GetLocationChecksum());
214     }
215   }
216 
PretendContextOpenedDexFiles(ClassLoaderContext * context)217   void PretendContextOpenedDexFiles(ClassLoaderContext* context) {
218     context->dex_files_open_attempted_ = true;
219     context->dex_files_open_result_ = true;
220   }
221 
222  private:
VerifyClassLoaderInfo(ClassLoaderContext * context,size_t index,ClassLoaderContext::ClassLoaderType type,const std::string & classpath)223   void VerifyClassLoaderInfo(ClassLoaderContext* context,
224                              size_t index,
225                              ClassLoaderContext::ClassLoaderType type,
226                              const std::string& classpath) {
227     ASSERT_TRUE(context != nullptr);
228     ASSERT_GT(context->GetParentChainSize(), index);
229     ClassLoaderContext::ClassLoaderInfo& info = *context->GetParent(index);
230     ASSERT_EQ(type, info.type);
231     std::vector<std::string> expected_classpath;
232     Split(classpath, ':', &expected_classpath);
233     ASSERT_EQ(expected_classpath, info.classpath);
234   }
235 
VerifyClassLoaderInfoSL(ClassLoaderContext * context,size_t loader_index,size_t shared_library_index,ClassLoaderContext::ClassLoaderType type,const std::string & classpath)236   void VerifyClassLoaderInfoSL(ClassLoaderContext* context,
237                                size_t loader_index,
238                                size_t shared_library_index,
239                                ClassLoaderContext::ClassLoaderType type,
240                                const std::string& classpath) {
241     ASSERT_TRUE(context != nullptr);
242     ASSERT_GT(context->GetParentChainSize(), loader_index);
243     const ClassLoaderContext::ClassLoaderInfo& info = *context->GetParent(loader_index);
244     ASSERT_GT(info.shared_libraries.size(), shared_library_index);
245     const ClassLoaderContext::ClassLoaderInfo& sl =
246         *info.shared_libraries[shared_library_index].get();
247     ASSERT_EQ(type, info.type);
248     std::vector<std::string> expected_classpath;
249     Split(classpath, ':', &expected_classpath);
250     ASSERT_EQ(expected_classpath, sl.classpath);
251   }
252 
VerifyClassLoaderFromTestDex(ClassLoaderContext * context,size_t index,ClassLoaderContext::ClassLoaderType type,const std::string & test_name,const std::string & classpath="")253   void VerifyClassLoaderFromTestDex(ClassLoaderContext* context,
254                                     size_t index,
255                                     ClassLoaderContext::ClassLoaderType type,
256                                     const std::string& test_name,
257                                     const std::string& classpath = "") {
258     std::vector<std::unique_ptr<const DexFile>> dex_files = OpenTestDexFiles(test_name.c_str());
259 
260     // If `classpath` is set, override the expected value of ClassLoaderInfo::classpath.
261     // Otherwise assume it is equal to dex location (here test dex file name).
262     VerifyClassLoaderInfo(context,
263                           index,
264                           type,
265                           classpath.empty() ? GetTestDexFileName(test_name.c_str()) : classpath);
266     VerifyOpenDexFiles(context,
267                        index,
268                        &dex_files,
269                        /* classpath_matches_dex_location= */ classpath.empty());
270   }
271 };
272 
TEST_F(ClassLoaderContextTest,ParseValidEmptyContext)273 TEST_F(ClassLoaderContextTest, ParseValidEmptyContext) {
274   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create("");
275   // An empty context should create a single empty PathClassLoader.
276   VerifyContextSize(context.get(), 1);
277   VerifyClassLoaderPCL(context.get(), 0, "");
278 }
279 
TEST_F(ClassLoaderContextTest,ParseValidSharedLibraryContext)280 TEST_F(ClassLoaderContextTest, ParseValidSharedLibraryContext) {
281   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create("&");
282   // An shared library context should have no class loader in the chain.
283   VerifyContextSize(context.get(), 0);
284 }
285 
TEST_F(ClassLoaderContextTest,ParseValidContextPCL)286 TEST_F(ClassLoaderContextTest, ParseValidContextPCL) {
287   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create("PCL[a.dex]");
288   VerifyContextSize(context.get(), 1);
289   VerifyClassLoaderPCL(context.get(), 0, "a.dex");
290 }
291 
TEST_F(ClassLoaderContextTest,ParseValidContextDLC)292 TEST_F(ClassLoaderContextTest, ParseValidContextDLC) {
293   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create("DLC[a.dex]");
294   VerifyContextSize(context.get(), 1);
295   VerifyClassLoaderDLC(context.get(), 0, "a.dex");
296 }
297 
TEST_F(ClassLoaderContextTest,ParseValidContextIMC)298 TEST_F(ClassLoaderContextTest, ParseValidContextIMC) {
299   std::unique_ptr<ClassLoaderContext> context = ParseContextWithChecksums("IMC[<unknown>*111]");
300   ASSERT_FALSE(context == nullptr);
301 }
302 
TEST_F(ClassLoaderContextTest,ParseInvalidContextIMCNoChecksum)303 TEST_F(ClassLoaderContextTest, ParseInvalidContextIMCNoChecksum) {
304   // IMC is treated as an unknown class loader unless a checksum is provided.
305   // This is because the dex location is always bogus.
306   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create("IMC[<unknown>]");
307   ASSERT_TRUE(context == nullptr);
308 }
309 
TEST_F(ClassLoaderContextTest,ParseInvalidContextIMCWrongClasspathMagic)310 TEST_F(ClassLoaderContextTest, ParseInvalidContextIMCWrongClasspathMagic) {
311   // IMC does not support arbitrary dex location. A magic marker must be used
312   // otherwise the spec should be rejected.
313   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create("IMC[a.dex*111]");
314   ASSERT_TRUE(context == nullptr);
315 }
316 
TEST_F(ClassLoaderContextTest,ParseValidContextChain)317 TEST_F(ClassLoaderContextTest, ParseValidContextChain) {
318   std::unique_ptr<ClassLoaderContext> context =
319       ClassLoaderContext::Create("PCL[a.dex:b.dex];DLC[c.dex:d.dex];PCL[e.dex]");
320   VerifyContextSize(context.get(), 3);
321   VerifyClassLoaderPCL(context.get(), 0, "a.dex:b.dex");
322   VerifyClassLoaderDLC(context.get(), 1, "c.dex:d.dex");
323   VerifyClassLoaderPCL(context.get(), 2, "e.dex");
324 }
325 
TEST_F(ClassLoaderContextTest,ParseSharedLibraries)326 TEST_F(ClassLoaderContextTest, ParseSharedLibraries) {
327   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(
328       "PCL[a.dex:b.dex]{PCL[s1.dex]#PCL[s2.dex:s3.dex]};DLC[c.dex:d.dex]{DLC[s4.dex]}");
329   VerifyContextSize(context.get(), 2);
330   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 0, "s1.dex");
331   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 1, "s2.dex:s3.dex");
332   VerifyClassLoaderDLC(context.get(), 1, "c.dex:d.dex");
333   VerifyClassLoaderSharedLibraryDLC(context.get(), 1, 0, "s4.dex");
334 }
335 
TEST_F(ClassLoaderContextTest,ParseEnclosingSharedLibraries)336 TEST_F(ClassLoaderContextTest, ParseEnclosingSharedLibraries) {
337   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(
338       "PCL[a.dex:b.dex]{PCL[s1.dex]{PCL[s2.dex:s3.dex];PCL[s4.dex]}}");
339   VerifyContextSize(context.get(), 1);
340   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 0, "s1.dex");
341 }
342 
TEST_F(ClassLoaderContextTest,ParseComplexSharedLibraries1)343 TEST_F(ClassLoaderContextTest, ParseComplexSharedLibraries1) {
344   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(
345       "PCL[]{PCL[s4.dex]{PCL[s5.dex]{PCL[s6.dex]}#PCL[s6.dex]}}");
346   VerifyContextSize(context.get(), 1);
347   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 0, "s4.dex");
348 }
349 
TEST_F(ClassLoaderContextTest,ParseComplexSharedLibraries2)350 TEST_F(ClassLoaderContextTest, ParseComplexSharedLibraries2) {
351   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(
352       "PCL[]{PCL[s1.dex]{PCL[s2.dex]}#PCL[s2.dex]#"
353       "PCL[s3.dex]#PCL[s4.dex]{PCL[s5.dex]{PCL[s6.dex]}#PCL[s6.dex]}#PCL[s5.dex]{PCL[s6.dex]}}");
354   VerifyContextSize(context.get(), 1);
355   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 0, "s1.dex");
356   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 1, "s2.dex");
357   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 2, "s3.dex");
358   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 3, "s4.dex");
359   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 4, "s5.dex");
360 }
361 
TEST_F(ClassLoaderContextTest,ParseValidEmptyContextDLC)362 TEST_F(ClassLoaderContextTest, ParseValidEmptyContextDLC) {
363   std::unique_ptr<ClassLoaderContext> context =
364       ClassLoaderContext::Create("DLC[]");
365   VerifyContextSize(context.get(), 1);
366   VerifyClassLoaderDLC(context.get(), 0, "");
367 }
368 
TEST_F(ClassLoaderContextTest,ParseValidEmptyContextSharedLibrary)369 TEST_F(ClassLoaderContextTest, ParseValidEmptyContextSharedLibrary) {
370   std::unique_ptr<ClassLoaderContext> context =
371       ClassLoaderContext::Create("DLC[]{}");
372   VerifyContextSize(context.get(), 1);
373   VerifySharedLibrariesSize(context.get(), 0, 0);
374 }
375 
TEST_F(ClassLoaderContextTest,ParseValidContextSpecialSymbol)376 TEST_F(ClassLoaderContextTest, ParseValidContextSpecialSymbol) {
377   std::unique_ptr<ClassLoaderContext> context =
378     ClassLoaderContext::Create(OatFile::kSpecialSharedLibrary);
379   VerifyContextSize(context.get(), 0);
380 }
381 
TEST_F(ClassLoaderContextTest,ParseInvalidValidContexts)382 TEST_F(ClassLoaderContextTest, ParseInvalidValidContexts) {
383   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("ABC[a.dex]"));
384   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("PCL"));
385   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("PCL[a.dex"));
386   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("PCLa.dex]"));
387   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("PCL{a.dex}"));
388   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("PCL[a.dex];DLC[b.dex"));
389   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("PCL[a.dex]{ABC};DLC[b.dex"));
390   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("PCL[a.dex]{};DLC[b.dex"));
391   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("DLC[s4.dex]}"));
392   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("DLC[s4.dex]{"));
393   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("DLC{DLC[s4.dex]}"));
394   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("PCL{##}"));
395   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("PCL{PCL[s4.dex]#}"));
396   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("PCL{PCL[s4.dex]##}"));
397   ASSERT_TRUE(nullptr == ClassLoaderContext::Create("PCL{PCL[s4.dex]{PCL[s3.dex]}#}"));
398 }
399 
TEST_F(ClassLoaderContextTest,OpenInvalidDexFiles)400 TEST_F(ClassLoaderContextTest, OpenInvalidDexFiles) {
401   std::unique_ptr<ClassLoaderContext> context =
402       ClassLoaderContext::Create("PCL[does_not_exist.dex]");
403   VerifyContextSize(context.get(), 1);
404   ASSERT_FALSE(context->OpenDexFiles(InstructionSet::kArm, "."));
405 }
406 
TEST_F(ClassLoaderContextTest,OpenValidDexFiles)407 TEST_F(ClassLoaderContextTest, OpenValidDexFiles) {
408   std::string multidex_name = GetTestDexFileName("MultiDex");
409   std::string myclass_dex_name = GetTestDexFileName("MyClass");
410   std::string dex_name = GetTestDexFileName("Main");
411 
412 
413   std::unique_ptr<ClassLoaderContext> context =
414       ClassLoaderContext::Create(
415           "PCL[" + multidex_name + ":" + myclass_dex_name + "];" +
416           "DLC[" + dex_name + "]");
417 
418   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, /*classpath_dir=*/ ""));
419 
420   VerifyContextSize(context.get(), 2);
421 
422   std::vector<std::unique_ptr<const DexFile>> all_dex_files0 = OpenTestDexFiles("MultiDex");
423   std::vector<std::unique_ptr<const DexFile>> myclass_dex_files = OpenTestDexFiles("MyClass");
424   for (size_t i = 0; i < myclass_dex_files.size(); i++) {
425     all_dex_files0.emplace_back(myclass_dex_files[i].release());
426   }
427   VerifyOpenDexFiles(context.get(), 0, &all_dex_files0);
428 
429   std::vector<std::unique_ptr<const DexFile>> all_dex_files1 = OpenTestDexFiles("Main");
430   VerifyOpenDexFiles(context.get(), 1, &all_dex_files1);
431 }
432 
433 // Creates a relative path from cwd to 'in'. Returns false if it cannot be done.
434 // TODO We should somehow support this in all situations. b/72042237.
CreateRelativeString(const std::string & in,const char * cwd,std::string * out)435 static bool CreateRelativeString(const std::string& in, const char* cwd, std::string* out) {
436   int cwd_len = strlen(cwd);
437   if (!android::base::StartsWith(in, cwd) || (cwd_len < 1)) {
438     return false;
439   }
440   bool contains_trailing_slash = (cwd[cwd_len - 1] == '/');
441   int start_position = cwd_len + (contains_trailing_slash ? 0 : 1);
442   *out = in.substr(start_position);
443   return true;
444 }
445 
TEST_F(ClassLoaderContextTest,OpenValidDexFilesRelative)446 TEST_F(ClassLoaderContextTest, OpenValidDexFilesRelative) {
447   char cwd_buf[4096];
448   if (getcwd(cwd_buf, arraysize(cwd_buf)) == nullptr) {
449     PLOG(FATAL) << "Could not get working directory";
450   }
451   std::string multidex_name;
452   std::string myclass_dex_name;
453   std::string dex_name;
454   if (!CreateRelativeString(GetTestDexFileName("MultiDex"), cwd_buf, &multidex_name) ||
455       !CreateRelativeString(GetTestDexFileName("MyClass"), cwd_buf, &myclass_dex_name) ||
456       !CreateRelativeString(GetTestDexFileName("Main"), cwd_buf, &dex_name)) {
457     LOG(ERROR) << "Test OpenValidDexFilesRelative cannot be run because target dex files have no "
458                << "relative path.";
459     SUCCEED();
460     return;
461   }
462 
463   std::unique_ptr<ClassLoaderContext> context =
464       ClassLoaderContext::Create(
465           "PCL[" + multidex_name + ":" + myclass_dex_name + "];" +
466           "DLC[" + dex_name + "]");
467 
468   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, /*classpath_dir=*/ ""));
469 
470   std::vector<std::unique_ptr<const DexFile>> all_dex_files0 = OpenTestDexFiles("MultiDex");
471   std::vector<std::unique_ptr<const DexFile>> myclass_dex_files = OpenTestDexFiles("MyClass");
472   for (size_t i = 0; i < myclass_dex_files.size(); i++) {
473     all_dex_files0.emplace_back(myclass_dex_files[i].release());
474   }
475   VerifyOpenDexFiles(context.get(), 0, &all_dex_files0);
476 
477   std::vector<std::unique_ptr<const DexFile>> all_dex_files1 = OpenTestDexFiles("Main");
478   VerifyOpenDexFiles(context.get(), 1, &all_dex_files1);
479 }
480 
TEST_F(ClassLoaderContextTest,OpenValidDexFilesClasspathDir)481 TEST_F(ClassLoaderContextTest, OpenValidDexFilesClasspathDir) {
482   char cwd_buf[4096];
483   if (getcwd(cwd_buf, arraysize(cwd_buf)) == nullptr) {
484     PLOG(FATAL) << "Could not get working directory";
485   }
486   std::string multidex_name;
487   std::string myclass_dex_name;
488   std::string dex_name;
489   if (!CreateRelativeString(GetTestDexFileName("MultiDex"), cwd_buf, &multidex_name) ||
490       !CreateRelativeString(GetTestDexFileName("MyClass"), cwd_buf, &myclass_dex_name) ||
491       !CreateRelativeString(GetTestDexFileName("Main"), cwd_buf, &dex_name)) {
492     LOG(ERROR) << "Test OpenValidDexFilesClasspathDir cannot be run because target dex files have "
493                << "no relative path.";
494     SUCCEED();
495     return;
496   }
497   std::unique_ptr<ClassLoaderContext> context =
498       ClassLoaderContext::Create(
499           "PCL[" + multidex_name + ":" + myclass_dex_name + "];" +
500           "DLC[" + dex_name + "]");
501 
502   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, cwd_buf));
503 
504   VerifyContextSize(context.get(), 2);
505   std::vector<std::unique_ptr<const DexFile>> all_dex_files0 = OpenTestDexFiles("MultiDex");
506   std::vector<std::unique_ptr<const DexFile>> myclass_dex_files = OpenTestDexFiles("MyClass");
507   for (size_t i = 0; i < myclass_dex_files.size(); i++) {
508     all_dex_files0.emplace_back(myclass_dex_files[i].release());
509   }
510   VerifyOpenDexFiles(context.get(), 0, &all_dex_files0);
511 
512   std::vector<std::unique_ptr<const DexFile>> all_dex_files1 = OpenTestDexFiles("Main");
513   VerifyOpenDexFiles(context.get(), 1, &all_dex_files1);
514 }
515 
TEST_F(ClassLoaderContextTest,OpenInvalidDexFilesMix)516 TEST_F(ClassLoaderContextTest, OpenInvalidDexFilesMix) {
517   std::string dex_name = GetTestDexFileName("Main");
518   std::unique_ptr<ClassLoaderContext> context =
519       ClassLoaderContext::Create("PCL[does_not_exist.dex];DLC[" + dex_name + "]");
520   ASSERT_FALSE(context->OpenDexFiles(InstructionSet::kArm, ""));
521 }
522 
TEST_F(ClassLoaderContextTest,OpenDexFilesForIMCFails)523 TEST_F(ClassLoaderContextTest, OpenDexFilesForIMCFails) {
524   std::unique_ptr<ClassLoaderContext> context;
525   std::string dex_name = GetTestDexFileName("Main");
526 
527   context = ParseContextWithChecksums("IMC[<unknown>*111]");
528   VerifyContextSize(context.get(), 1);
529   ASSERT_FALSE(context->OpenDexFiles(InstructionSet::kArm, "."));
530 }
531 
TEST_F(ClassLoaderContextTest,CreateClassLoader)532 TEST_F(ClassLoaderContextTest, CreateClassLoader) {
533   std::string dex_name = GetTestDexFileName("Main");
534   std::unique_ptr<ClassLoaderContext> context =
535       ClassLoaderContext::Create("PCL[" + dex_name + "]");
536   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
537 
538   std::vector<std::unique_ptr<const DexFile>> classpath_dex = OpenTestDexFiles("Main");
539   std::vector<std::unique_ptr<const DexFile>> compilation_sources = OpenTestDexFiles("MultiDex");
540 
541   std::vector<const DexFile*> compilation_sources_raw =
542       MakeNonOwningPointerVector(compilation_sources);
543   jobject jclass_loader = context->CreateClassLoader(compilation_sources_raw);
544   ASSERT_TRUE(jclass_loader != nullptr);
545 
546   ScopedObjectAccess soa(Thread::Current());
547 
548   StackHandleScope<1> hs(soa.Self());
549   Handle<mirror::ClassLoader> class_loader = hs.NewHandle(
550       soa.Decode<mirror::ClassLoader>(jclass_loader));
551 
552   ASSERT_TRUE(class_loader->GetClass() ==
553       soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader));
554   ASSERT_TRUE(class_loader->GetParent()->GetClass() ==
555       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
556 
557   // For the first class loader the class path dex files must come first and then the
558   // compilation sources.
559   std::vector<const DexFile*> expected_classpath = MakeNonOwningPointerVector(classpath_dex);
560   for (auto& dex : compilation_sources_raw) {
561     expected_classpath.push_back(dex);
562   }
563 
564   VerifyClassLoaderDexFiles(soa,
565                             class_loader,
566                             WellKnownClasses::dalvik_system_PathClassLoader,
567                             expected_classpath);
568 }
569 
TEST_F(ClassLoaderContextTest,CreateClassLoaderWithEmptyContext)570 TEST_F(ClassLoaderContextTest, CreateClassLoaderWithEmptyContext) {
571   std::unique_ptr<ClassLoaderContext> context =
572       ClassLoaderContext::Create("");
573   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
574 
575   std::vector<std::unique_ptr<const DexFile>> compilation_sources = OpenTestDexFiles("MultiDex");
576 
577   std::vector<const DexFile*> compilation_sources_raw =
578       MakeNonOwningPointerVector(compilation_sources);
579   jobject jclass_loader = context->CreateClassLoader(compilation_sources_raw);
580   ASSERT_TRUE(jclass_loader != nullptr);
581 
582   ScopedObjectAccess soa(Thread::Current());
583 
584   StackHandleScope<1> hs(soa.Self());
585   Handle<mirror::ClassLoader> class_loader = hs.NewHandle(
586       soa.Decode<mirror::ClassLoader>(jclass_loader));
587 
588   // An empty context should create a single PathClassLoader with only the compilation sources.
589   VerifyClassLoaderDexFiles(soa,
590                             class_loader,
591                             WellKnownClasses::dalvik_system_PathClassLoader,
592                             compilation_sources_raw);
593   ASSERT_TRUE(class_loader->GetParent()->GetClass() ==
594       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
595 }
596 
TEST_F(ClassLoaderContextTest,CreateClassLoaderWithSharedLibraryContext)597 TEST_F(ClassLoaderContextTest, CreateClassLoaderWithSharedLibraryContext) {
598   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create("&");
599 
600   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
601 
602   std::vector<std::unique_ptr<const DexFile>> compilation_sources = OpenTestDexFiles("MultiDex");
603 
604   std::vector<const DexFile*> compilation_sources_raw =
605       MakeNonOwningPointerVector(compilation_sources);
606   jobject jclass_loader = context->CreateClassLoader(compilation_sources_raw);
607   ASSERT_TRUE(jclass_loader != nullptr);
608 
609   ScopedObjectAccess soa(Thread::Current());
610 
611   StackHandleScope<1> hs(soa.Self());
612   Handle<mirror::ClassLoader> class_loader = hs.NewHandle(
613       soa.Decode<mirror::ClassLoader>(jclass_loader));
614 
615   // A shared library context should create a single PathClassLoader with only the compilation
616   // sources.
617   VerifyClassLoaderDexFiles(soa,
618       class_loader,
619       WellKnownClasses::dalvik_system_PathClassLoader,
620       compilation_sources_raw);
621   ASSERT_TRUE(class_loader->GetParent()->GetClass() ==
622   soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
623 }
624 
TEST_F(ClassLoaderContextTest,CreateClassLoaderWithComplexChain)625 TEST_F(ClassLoaderContextTest, CreateClassLoaderWithComplexChain) {
626   // Setup the context.
627   std::vector<std::unique_ptr<const DexFile>> classpath_dex_a = OpenTestDexFiles("ForClassLoaderA");
628   std::vector<std::unique_ptr<const DexFile>> classpath_dex_b = OpenTestDexFiles("ForClassLoaderB");
629   std::vector<std::unique_ptr<const DexFile>> classpath_dex_c = OpenTestDexFiles("ForClassLoaderC");
630   std::vector<std::unique_ptr<const DexFile>> classpath_dex_d = OpenTestDexFiles("ForClassLoaderD");
631 
632   std::string context_spec =
633       "PCL[" + CreateClassPath(classpath_dex_a) + ":" + CreateClassPath(classpath_dex_b) + "];" +
634       "DLC[" + CreateClassPath(classpath_dex_c) + "];" +
635       "PCL[" + CreateClassPath(classpath_dex_d) + "]";
636 
637   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(context_spec);
638   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
639 
640   // Setup the compilation sources.
641   std::vector<std::unique_ptr<const DexFile>> compilation_sources = OpenTestDexFiles("MultiDex");
642   std::vector<const DexFile*> compilation_sources_raw =
643       MakeNonOwningPointerVector(compilation_sources);
644 
645   // Create the class loader.
646   jobject jclass_loader = context->CreateClassLoader(compilation_sources_raw);
647   ASSERT_TRUE(jclass_loader != nullptr);
648 
649   // Verify the class loader.
650   ScopedObjectAccess soa(Thread::Current());
651 
652   StackHandleScope<3> hs(soa.Self());
653   Handle<mirror::ClassLoader> class_loader_1 = hs.NewHandle(
654       soa.Decode<mirror::ClassLoader>(jclass_loader));
655 
656   // Verify the first class loader
657 
658   // For the first class loader the class path dex files must come first and then the
659   // compilation sources.
660   std::vector<const DexFile*> class_loader_1_dex_files =
661       MakeNonOwningPointerVector(classpath_dex_a);
662   for (auto& dex : classpath_dex_b) {
663     class_loader_1_dex_files.push_back(dex.get());
664   }
665   for (auto& dex : compilation_sources_raw) {
666     class_loader_1_dex_files.push_back(dex);
667   }
668   VerifyClassLoaderDexFiles(soa,
669                             class_loader_1,
670                             WellKnownClasses::dalvik_system_PathClassLoader,
671                             class_loader_1_dex_files);
672 
673   // Verify the second class loader
674   Handle<mirror::ClassLoader> class_loader_2 = hs.NewHandle(class_loader_1->GetParent());
675   std::vector<const DexFile*> class_loader_2_dex_files =
676       MakeNonOwningPointerVector(classpath_dex_c);
677   VerifyClassLoaderDexFiles(soa,
678                             class_loader_2,
679                             WellKnownClasses::dalvik_system_DelegateLastClassLoader,
680                             class_loader_2_dex_files);
681 
682   // Verify the third class loader
683   Handle<mirror::ClassLoader> class_loader_3 = hs.NewHandle(class_loader_2->GetParent());
684   std::vector<const DexFile*> class_loader_3_dex_files =
685       MakeNonOwningPointerVector(classpath_dex_d);
686   VerifyClassLoaderDexFiles(soa,
687                             class_loader_3,
688                             WellKnownClasses::dalvik_system_PathClassLoader,
689                             class_loader_3_dex_files);
690   // The last class loader should have the BootClassLoader as a parent.
691   ASSERT_TRUE(class_loader_3->GetParent()->GetClass() ==
692       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
693 }
694 
TEST_F(ClassLoaderContextTest,CreateClassLoaderWithSharedLibraries)695 TEST_F(ClassLoaderContextTest, CreateClassLoaderWithSharedLibraries) {
696   // Setup the context.
697   std::vector<std::unique_ptr<const DexFile>> classpath_dex_a = OpenTestDexFiles("ForClassLoaderA");
698   std::vector<std::unique_ptr<const DexFile>> classpath_dex_b = OpenTestDexFiles("ForClassLoaderB");
699   std::vector<std::unique_ptr<const DexFile>> classpath_dex_c = OpenTestDexFiles("ForClassLoaderC");
700   std::vector<std::unique_ptr<const DexFile>> classpath_dex_d = OpenTestDexFiles("ForClassLoaderD");
701 
702   std::string context_spec =
703       "PCL[" + CreateClassPath(classpath_dex_a) + ":" + CreateClassPath(classpath_dex_b) + "]{" +
704       "DLC[" + CreateClassPath(classpath_dex_c) + "]#" +
705       "PCL[" + CreateClassPath(classpath_dex_d) + "]}";
706 
707   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(context_spec);
708   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
709 
710   // Setup the compilation sources.
711   std::vector<std::unique_ptr<const DexFile>> compilation_sources = OpenTestDexFiles("MultiDex");
712   std::vector<const DexFile*> compilation_sources_raw =
713       MakeNonOwningPointerVector(compilation_sources);
714 
715   // Create the class loader.
716   jobject jclass_loader = context->CreateClassLoader(compilation_sources_raw);
717   ASSERT_TRUE(jclass_loader != nullptr);
718 
719   // Verify the class loader.
720   ScopedObjectAccess soa(Thread::Current());
721 
722   StackHandleScope<4> hs(soa.Self());
723   Handle<mirror::ClassLoader> class_loader_1 = hs.NewHandle(
724       soa.Decode<mirror::ClassLoader>(jclass_loader));
725 
726   // For the first class loader the class path dex files must come first and then the
727   // compilation sources.
728   std::vector<const DexFile*> class_loader_1_dex_files =
729       MakeNonOwningPointerVector(classpath_dex_a);
730   for (auto& dex : classpath_dex_b) {
731     class_loader_1_dex_files.push_back(dex.get());
732   }
733   for (auto& dex : compilation_sources_raw) {
734     class_loader_1_dex_files.push_back(dex);
735   }
736   VerifyClassLoaderDexFiles(soa,
737                             class_loader_1,
738                             WellKnownClasses::dalvik_system_PathClassLoader,
739                             class_loader_1_dex_files);
740 
741   // Verify the shared libraries.
742   ArtField* field =
743       jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_sharedLibraryLoaders);
744   ObjPtr<mirror::Object> raw_shared_libraries = field->GetObject(class_loader_1.Get());
745   ASSERT_TRUE(raw_shared_libraries != nullptr);
746 
747   Handle<mirror::ObjectArray<mirror::ClassLoader>> shared_libraries(
748       hs.NewHandle(raw_shared_libraries->AsObjectArray<mirror::ClassLoader>()));
749   ASSERT_EQ(shared_libraries->GetLength(), 2);
750 
751   // Verify the first shared library.
752   Handle<mirror::ClassLoader> class_loader_2 = hs.NewHandle(shared_libraries->Get(0));
753   std::vector<const DexFile*> class_loader_2_dex_files =
754       MakeNonOwningPointerVector(classpath_dex_c);
755   VerifyClassLoaderDexFiles(soa,
756                             class_loader_2,
757                             WellKnownClasses::dalvik_system_DelegateLastClassLoader,
758                             class_loader_2_dex_files);
759   raw_shared_libraries = field->GetObject(class_loader_2.Get());
760   ASSERT_TRUE(raw_shared_libraries == nullptr);
761 
762   // Verify the second shared library.
763   Handle<mirror::ClassLoader> class_loader_3 = hs.NewHandle(shared_libraries->Get(1));
764   std::vector<const DexFile*> class_loader_3_dex_files =
765       MakeNonOwningPointerVector(classpath_dex_d);
766   VerifyClassLoaderDexFiles(soa,
767                             class_loader_3,
768                             WellKnownClasses::dalvik_system_PathClassLoader,
769                             class_loader_3_dex_files);
770   raw_shared_libraries = field->GetObject(class_loader_3.Get());
771   ASSERT_TRUE(raw_shared_libraries == nullptr);
772 
773   // All class loaders should have the BootClassLoader as a parent.
774   ASSERT_TRUE(class_loader_1->GetParent()->GetClass() ==
775       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
776   ASSERT_TRUE(class_loader_2->GetParent()->GetClass() ==
777       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
778   ASSERT_TRUE(class_loader_3->GetParent()->GetClass() ==
779       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
780 }
781 
TEST_F(ClassLoaderContextTest,CreateClassLoaderWithSharedLibrariesInParentToo)782 TEST_F(ClassLoaderContextTest, CreateClassLoaderWithSharedLibrariesInParentToo) {
783   // Setup the context.
784   std::vector<std::unique_ptr<const DexFile>> classpath_dex_a = OpenTestDexFiles("ForClassLoaderA");
785   std::vector<std::unique_ptr<const DexFile>> classpath_dex_b = OpenTestDexFiles("ForClassLoaderB");
786   std::vector<std::unique_ptr<const DexFile>> classpath_dex_c = OpenTestDexFiles("ForClassLoaderC");
787   std::vector<std::unique_ptr<const DexFile>> classpath_dex_d = OpenTestDexFiles("ForClassLoaderD");
788 
789   std::string context_spec =
790       "PCL[" + CreateClassPath(classpath_dex_a) + "]{" +
791       "PCL[" + CreateClassPath(classpath_dex_b) + "]};" +
792       "PCL[" + CreateClassPath(classpath_dex_c) + "]{" +
793       "PCL[" + CreateClassPath(classpath_dex_d) + "]}";
794 
795   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(context_spec);
796   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
797 
798   // Setup the compilation sources.
799   std::vector<std::unique_ptr<const DexFile>> compilation_sources = OpenTestDexFiles("MultiDex");
800   std::vector<const DexFile*> compilation_sources_raw =
801       MakeNonOwningPointerVector(compilation_sources);
802 
803   // Create the class loader.
804   jobject jclass_loader = context->CreateClassLoader(compilation_sources_raw);
805   ASSERT_TRUE(jclass_loader != nullptr);
806 
807   // Verify the class loader.
808   ScopedObjectAccess soa(Thread::Current());
809 
810   StackHandleScope<6> hs(soa.Self());
811   Handle<mirror::ClassLoader> class_loader_1 = hs.NewHandle(
812       soa.Decode<mirror::ClassLoader>(jclass_loader));
813 
814   // For the first class loader the class path dex files must come first and then the
815   // compilation sources.
816   std::vector<const DexFile*> class_loader_1_dex_files =
817       MakeNonOwningPointerVector(classpath_dex_a);
818   for (auto& dex : compilation_sources_raw) {
819     class_loader_1_dex_files.push_back(dex);
820   }
821   VerifyClassLoaderDexFiles(soa,
822                             class_loader_1,
823                             WellKnownClasses::dalvik_system_PathClassLoader,
824                             class_loader_1_dex_files);
825 
826   // Verify its shared library.
827   ArtField* field =
828       jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_sharedLibraryLoaders);
829   ObjPtr<mirror::Object> raw_shared_libraries = field->GetObject(class_loader_1.Get());
830   ASSERT_TRUE(raw_shared_libraries != nullptr);
831 
832   Handle<mirror::ObjectArray<mirror::ClassLoader>> shared_libraries(
833       hs.NewHandle(raw_shared_libraries->AsObjectArray<mirror::ClassLoader>()));
834   ASSERT_EQ(shared_libraries->GetLength(), 1);
835 
836   Handle<mirror::ClassLoader> class_loader_2 = hs.NewHandle(shared_libraries->Get(0));
837   std::vector<const DexFile*> class_loader_2_dex_files =
838       MakeNonOwningPointerVector(classpath_dex_b);
839   VerifyClassLoaderDexFiles(soa,
840                             class_loader_2,
841                             WellKnownClasses::dalvik_system_PathClassLoader,
842                             class_loader_2_dex_files);
843   raw_shared_libraries = field->GetObject(class_loader_2.Get());
844   ASSERT_TRUE(raw_shared_libraries == nullptr);
845 
846   // Verify the parent.
847   Handle<mirror::ClassLoader> class_loader_3 = hs.NewHandle(class_loader_1->GetParent());
848   std::vector<const DexFile*> class_loader_3_dex_files =
849       MakeNonOwningPointerVector(classpath_dex_c);
850   VerifyClassLoaderDexFiles(soa,
851                             class_loader_3,
852                             WellKnownClasses::dalvik_system_PathClassLoader,
853                             class_loader_3_dex_files);
854 
855   // Verify its shared library.
856   raw_shared_libraries = field->GetObject(class_loader_3.Get());
857   ASSERT_TRUE(raw_shared_libraries != nullptr);
858 
859   Handle<mirror::ObjectArray<mirror::ClassLoader>> shared_libraries_2(
860       hs.NewHandle(raw_shared_libraries->AsObjectArray<mirror::ClassLoader>()));
861   ASSERT_EQ(shared_libraries->GetLength(), 1);
862 
863   Handle<mirror::ClassLoader> class_loader_4 = hs.NewHandle(shared_libraries_2->Get(0));
864   std::vector<const DexFile*> class_loader_4_dex_files =
865       MakeNonOwningPointerVector(classpath_dex_d);
866   VerifyClassLoaderDexFiles(soa,
867                             class_loader_4,
868                             WellKnownClasses::dalvik_system_PathClassLoader,
869                             class_loader_4_dex_files);
870   raw_shared_libraries = field->GetObject(class_loader_4.Get());
871   ASSERT_TRUE(raw_shared_libraries == nullptr);
872 
873   // Class loaders should have the BootClassLoader as a parent.
874   ASSERT_TRUE(class_loader_2->GetParent()->GetClass() ==
875       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
876   ASSERT_TRUE(class_loader_3->GetParent()->GetClass() ==
877       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
878   ASSERT_TRUE(class_loader_4->GetParent()->GetClass() ==
879       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
880 }
881 
TEST_F(ClassLoaderContextTest,CreateClassLoaderWithSharedLibrariesDependencies)882 TEST_F(ClassLoaderContextTest, CreateClassLoaderWithSharedLibrariesDependencies) {
883   // Setup the context.
884   std::vector<std::unique_ptr<const DexFile>> classpath_dex_a = OpenTestDexFiles("ForClassLoaderA");
885   std::vector<std::unique_ptr<const DexFile>> classpath_dex_b = OpenTestDexFiles("ForClassLoaderB");
886   std::vector<std::unique_ptr<const DexFile>> classpath_dex_c = OpenTestDexFiles("ForClassLoaderC");
887   std::vector<std::unique_ptr<const DexFile>> classpath_dex_d = OpenTestDexFiles("ForClassLoaderD");
888 
889   std::string context_spec =
890       "PCL[" + CreateClassPath(classpath_dex_a) + "]{" +
891       "PCL[" + CreateClassPath(classpath_dex_b) + "]{" +
892       "PCL[" + CreateClassPath(classpath_dex_c) + "]}};" +
893       "PCL[" + CreateClassPath(classpath_dex_d) + "]";
894 
895   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(context_spec);
896   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
897 
898   // Setup the compilation sources.
899   std::vector<std::unique_ptr<const DexFile>> compilation_sources = OpenTestDexFiles("MultiDex");
900   std::vector<const DexFile*> compilation_sources_raw =
901       MakeNonOwningPointerVector(compilation_sources);
902 
903   // Create the class loader.
904   jobject jclass_loader = context->CreateClassLoader(compilation_sources_raw);
905   ASSERT_TRUE(jclass_loader != nullptr);
906 
907   // Verify the class loader.
908   ScopedObjectAccess soa(Thread::Current());
909 
910   StackHandleScope<6> hs(soa.Self());
911   Handle<mirror::ClassLoader> class_loader_1 = hs.NewHandle(
912       soa.Decode<mirror::ClassLoader>(jclass_loader));
913 
914   // For the first class loader the class path dex files must come first and then the
915   // compilation sources.
916   std::vector<const DexFile*> class_loader_1_dex_files =
917       MakeNonOwningPointerVector(classpath_dex_a);
918   for (auto& dex : compilation_sources_raw) {
919     class_loader_1_dex_files.push_back(dex);
920   }
921   VerifyClassLoaderDexFiles(soa,
922                             class_loader_1,
923                             WellKnownClasses::dalvik_system_PathClassLoader,
924                             class_loader_1_dex_files);
925 
926   // Verify its shared library.
927   ArtField* field =
928       jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_sharedLibraryLoaders);
929   ObjPtr<mirror::Object> raw_shared_libraries = field->GetObject(class_loader_1.Get());
930   ASSERT_TRUE(raw_shared_libraries != nullptr);
931 
932   Handle<mirror::ObjectArray<mirror::ClassLoader>> shared_libraries(
933       hs.NewHandle(raw_shared_libraries->AsObjectArray<mirror::ClassLoader>()));
934   ASSERT_EQ(shared_libraries->GetLength(), 1);
935 
936   Handle<mirror::ClassLoader> class_loader_2 = hs.NewHandle(shared_libraries->Get(0));
937   std::vector<const DexFile*> class_loader_2_dex_files =
938       MakeNonOwningPointerVector(classpath_dex_b);
939   VerifyClassLoaderDexFiles(soa,
940                             class_loader_2,
941                             WellKnownClasses::dalvik_system_PathClassLoader,
942                             class_loader_2_dex_files);
943 
944   // Verify the shared library dependency of the shared library.
945   raw_shared_libraries = field->GetObject(class_loader_2.Get());
946   ASSERT_TRUE(raw_shared_libraries != nullptr);
947 
948   Handle<mirror::ObjectArray<mirror::ClassLoader>> shared_libraries_2(
949       hs.NewHandle(raw_shared_libraries->AsObjectArray<mirror::ClassLoader>()));
950   ASSERT_EQ(shared_libraries_2->GetLength(), 1);
951 
952   Handle<mirror::ClassLoader> class_loader_3 = hs.NewHandle(shared_libraries_2->Get(0));
953   std::vector<const DexFile*> class_loader_3_dex_files =
954       MakeNonOwningPointerVector(classpath_dex_c);
955   VerifyClassLoaderDexFiles(soa,
956                             class_loader_3,
957                             WellKnownClasses::dalvik_system_PathClassLoader,
958                             class_loader_3_dex_files);
959   raw_shared_libraries = field->GetObject(class_loader_3.Get());
960   ASSERT_TRUE(raw_shared_libraries == nullptr);
961 
962   // Verify the parent.
963   Handle<mirror::ClassLoader> class_loader_4 = hs.NewHandle(class_loader_1->GetParent());
964   std::vector<const DexFile*> class_loader_4_dex_files =
965       MakeNonOwningPointerVector(classpath_dex_d);
966   VerifyClassLoaderDexFiles(soa,
967                             class_loader_4,
968                             WellKnownClasses::dalvik_system_PathClassLoader,
969                             class_loader_4_dex_files);
970   raw_shared_libraries = field->GetObject(class_loader_4.Get());
971   ASSERT_TRUE(raw_shared_libraries == nullptr);
972 
973   // Class loaders should have the BootClassLoader as a parent.
974   ASSERT_TRUE(class_loader_2->GetParent()->GetClass() ==
975       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
976   ASSERT_TRUE(class_loader_3->GetParent()->GetClass() ==
977       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
978   ASSERT_TRUE(class_loader_4->GetParent()->GetClass() ==
979       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
980 }
981 
TEST_F(ClassLoaderContextTest,RemoveSourceLocations)982 TEST_F(ClassLoaderContextTest, RemoveSourceLocations) {
983   std::unique_ptr<ClassLoaderContext> context =
984       ClassLoaderContext::Create("PCL[a.dex]");
985   dchecked_vector<std::string> classpath_dex;
986   classpath_dex.push_back("a.dex");
987   dchecked_vector<std::string> compilation_sources;
988   compilation_sources.push_back("src.dex");
989 
990   // Nothing should be removed.
991   ASSERT_FALSE(context->RemoveLocationsFromClassPaths(compilation_sources));
992   VerifyClassLoaderPCL(context.get(), 0, "a.dex");
993   // Classes should be removed.
994   ASSERT_TRUE(context->RemoveLocationsFromClassPaths(classpath_dex));
995   VerifyClassLoaderPCL(context.get(), 0, "");
996 }
997 
TEST_F(ClassLoaderContextTest,CreateClassLoaderWithSameSharedLibraries)998 TEST_F(ClassLoaderContextTest, CreateClassLoaderWithSameSharedLibraries) {
999   // Setup the context.
1000   std::vector<std::unique_ptr<const DexFile>> classpath_dex_a = OpenTestDexFiles("ForClassLoaderA");
1001   std::vector<std::unique_ptr<const DexFile>> classpath_dex_b = OpenTestDexFiles("ForClassLoaderB");
1002   std::vector<std::unique_ptr<const DexFile>> classpath_dex_c = OpenTestDexFiles("ForClassLoaderC");
1003 
1004   std::string context_spec =
1005       "PCL[" + CreateClassPath(classpath_dex_a) + "]{" +
1006       "PCL[" + CreateClassPath(classpath_dex_b) + "]};" +
1007       "PCL[" + CreateClassPath(classpath_dex_c) + "]{" +
1008       "PCL[" + CreateClassPath(classpath_dex_b) + "]}";
1009 
1010   std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(context_spec);
1011   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
1012 
1013   // Setup the compilation sources.
1014   std::vector<std::unique_ptr<const DexFile>> compilation_sources = OpenTestDexFiles("MultiDex");
1015   std::vector<const DexFile*> compilation_sources_raw =
1016       MakeNonOwningPointerVector(compilation_sources);
1017 
1018   // Create the class loader.
1019   jobject jclass_loader = context->CreateClassLoader(compilation_sources_raw);
1020   ASSERT_TRUE(jclass_loader != nullptr);
1021 
1022   // Verify the class loader.
1023   ScopedObjectAccess soa(Thread::Current());
1024 
1025   StackHandleScope<6> hs(soa.Self());
1026   Handle<mirror::ClassLoader> class_loader_1 = hs.NewHandle(
1027       soa.Decode<mirror::ClassLoader>(jclass_loader));
1028 
1029   // For the first class loader the class path dex files must come first and then the
1030   // compilation sources.
1031   std::vector<const DexFile*> class_loader_1_dex_files =
1032       MakeNonOwningPointerVector(classpath_dex_a);
1033   for (auto& dex : compilation_sources_raw) {
1034     class_loader_1_dex_files.push_back(dex);
1035   }
1036   VerifyClassLoaderDexFiles(soa,
1037                             class_loader_1,
1038                             WellKnownClasses::dalvik_system_PathClassLoader,
1039                             class_loader_1_dex_files);
1040 
1041   // Verify its shared library.
1042   ArtField* field =
1043       jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_sharedLibraryLoaders);
1044   ObjPtr<mirror::Object> raw_shared_libraries = field->GetObject(class_loader_1.Get());
1045   ASSERT_TRUE(raw_shared_libraries != nullptr);
1046 
1047   Handle<mirror::ObjectArray<mirror::ClassLoader>> shared_libraries(
1048       hs.NewHandle(raw_shared_libraries->AsObjectArray<mirror::ClassLoader>()));
1049   ASSERT_EQ(shared_libraries->GetLength(), 1);
1050 
1051   Handle<mirror::ClassLoader> class_loader_2 = hs.NewHandle(shared_libraries->Get(0));
1052   std::vector<const DexFile*> class_loader_2_dex_files =
1053       MakeNonOwningPointerVector(classpath_dex_b);
1054   VerifyClassLoaderDexFiles(soa,
1055                             class_loader_2,
1056                             WellKnownClasses::dalvik_system_PathClassLoader,
1057                             class_loader_2_dex_files);
1058 
1059   // Verify the parent.
1060   Handle<mirror::ClassLoader> class_loader_3 = hs.NewHandle(class_loader_1->GetParent());
1061   std::vector<const DexFile*> class_loader_3_dex_files =
1062       MakeNonOwningPointerVector(classpath_dex_c);
1063   VerifyClassLoaderDexFiles(soa,
1064                             class_loader_3,
1065                             WellKnownClasses::dalvik_system_PathClassLoader,
1066                             class_loader_3_dex_files);
1067 
1068   // Verify its shared library is the same as the child.
1069   raw_shared_libraries = field->GetObject(class_loader_3.Get());
1070   ASSERT_TRUE(raw_shared_libraries != nullptr);
1071   Handle<mirror::ObjectArray<mirror::ClassLoader>> shared_libraries_2(
1072       hs.NewHandle(raw_shared_libraries->AsObjectArray<mirror::ClassLoader>()));
1073   ASSERT_EQ(shared_libraries_2->GetLength(), 1);
1074   ASSERT_OBJ_PTR_EQ(shared_libraries_2->Get(0), class_loader_2.Get());
1075 
1076   // Class loaders should have the BootClassLoader as a parent.
1077   ASSERT_TRUE(class_loader_2->GetParent()->GetClass() ==
1078       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
1079   ASSERT_TRUE(class_loader_3->GetParent()->GetClass() ==
1080       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader));
1081 }
1082 
TEST_F(ClassLoaderContextTest,EncodeInOatFile)1083 TEST_F(ClassLoaderContextTest, EncodeInOatFile) {
1084   std::string dex1_name = GetTestDexFileName("Main");
1085   std::string dex2_name = GetTestDexFileName("MyClass");
1086   std::unique_ptr<ClassLoaderContext> context =
1087       ClassLoaderContext::Create("PCL[" + dex1_name + ":" + dex2_name + "]");
1088   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
1089 
1090   std::vector<std::unique_ptr<const DexFile>> dex1 = OpenTestDexFiles("Main");
1091   std::vector<std::unique_ptr<const DexFile>> dex2 = OpenTestDexFiles("MyClass");
1092   std::string encoding = context->EncodeContextForOatFile("");
1093   std::string expected_encoding = "PCL[" + CreateClassPathWithChecksums(dex1) + ":" +
1094       CreateClassPathWithChecksums(dex2) + "]";
1095   ASSERT_EQ(expected_encoding, context->EncodeContextForOatFile(""));
1096 }
1097 
TEST_F(ClassLoaderContextTest,EncodeInOatFileIMC)1098 TEST_F(ClassLoaderContextTest, EncodeInOatFileIMC) {
1099   jobject class_loader_a = LoadDexInPathClassLoader("Main", nullptr);
1100   jobject class_loader_b = LoadDexInInMemoryDexClassLoader("MyClass", class_loader_a);
1101 
1102   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader_b);
1103   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
1104 
1105   std::vector<std::unique_ptr<const DexFile>> dex1 = OpenTestDexFiles("Main");
1106   std::vector<std::unique_ptr<const DexFile>> dex2 = OpenTestDexFiles("MyClass");
1107   ASSERT_EQ(dex2.size(), 1u);
1108 
1109   std::string encoding = context->EncodeContextForOatFile("");
1110   std::string expected_encoding = "IMC[<unknown>*" + std::to_string(dex2[0]->GetLocationChecksum())
1111       + "];PCL[" + CreateClassPathWithChecksums(dex1) + "]";
1112   ASSERT_EQ(expected_encoding, context->EncodeContextForOatFile(""));
1113 }
1114 
TEST_F(ClassLoaderContextTest,EncodeForDex2oat)1115 TEST_F(ClassLoaderContextTest, EncodeForDex2oat) {
1116   std::string dex1_name = GetTestDexFileName("Main");
1117   std::string dex2_name = GetTestDexFileName("MultiDex");
1118   std::unique_ptr<ClassLoaderContext> context =
1119       ClassLoaderContext::Create("PCL[" + dex1_name + ":" + dex2_name + "]");
1120   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
1121 
1122   std::string encoding = context->EncodeContextForDex2oat("");
1123   std::string expected_encoding = "PCL[" + dex1_name + ":" + dex2_name + "]";
1124   ASSERT_EQ(expected_encoding, context->EncodeContextForDex2oat(""));
1125 }
1126 
TEST_F(ClassLoaderContextTest,EncodeForDex2oatIMC)1127 TEST_F(ClassLoaderContextTest, EncodeForDex2oatIMC) {
1128   jobject class_loader_a = LoadDexInPathClassLoader("Main", nullptr);
1129   jobject class_loader_b = LoadDexInInMemoryDexClassLoader("MyClass", class_loader_a);
1130 
1131   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader_b);
1132   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, ""));
1133 
1134   std::string encoding = context->EncodeContextForDex2oat("");
1135   std::string expected_encoding = "IMC[<unknown>];PCL[" + GetTestDexFileName("Main") + "]";
1136   ASSERT_EQ(expected_encoding, context->EncodeContextForDex2oat(""));
1137 }
1138 
TEST_F(ClassLoaderContextTest,EncodeContextsSinglePath)1139 TEST_F(ClassLoaderContextTest, EncodeContextsSinglePath) {
1140   jobject class_loader = LoadDexInPathClassLoader("Main", nullptr);
1141   std::unique_ptr<ClassLoaderContext> context =
1142       CreateContextForClassLoader(class_loader);
1143 
1144   std::map<std::string, std::string> encodings = context->EncodeClassPathContexts("");
1145   ASSERT_EQ(1u, encodings.size());
1146   ASSERT_EQ("PCL[]", encodings.at(GetTestDexFileName("Main")));
1147 }
1148 
TEST_F(ClassLoaderContextTest,EncodeContextsMultiDex)1149 TEST_F(ClassLoaderContextTest, EncodeContextsMultiDex) {
1150   jobject class_loader = LoadDexInPathClassLoader("MultiDex", nullptr);
1151   std::unique_ptr<ClassLoaderContext> context =
1152       CreateContextForClassLoader(class_loader);
1153 
1154   std::map<std::string, std::string> encodings = context->EncodeClassPathContexts("");
1155   ASSERT_EQ(1u, encodings.size());
1156   ASSERT_EQ("PCL[]", encodings.at(GetTestDexFileName("MultiDex")));
1157 }
1158 
TEST_F(ClassLoaderContextTest,EncodeContextsRepeatedMultiDex)1159 TEST_F(ClassLoaderContextTest, EncodeContextsRepeatedMultiDex) {
1160   jobject top_class_loader = LoadDexInPathClassLoader("MultiDex", nullptr);
1161   jobject middle_class_loader =
1162       LoadDexInPathClassLoader("Main", top_class_loader);
1163   jobject bottom_class_loader =
1164       LoadDexInPathClassLoader("MultiDex", middle_class_loader);
1165   std::unique_ptr<ClassLoaderContext> context =
1166       CreateContextForClassLoader(bottom_class_loader);
1167 
1168   std::map<std::string, std::string> encodings = context->EncodeClassPathContexts("");
1169   ASSERT_EQ(1u, encodings.size());
1170 
1171   std::string main_dex_name = GetTestDexFileName("Main");
1172   std::string multidex_dex_name = GetTestDexFileName("MultiDex");
1173   ASSERT_EQ(
1174       "PCL[];PCL[" + main_dex_name + "];PCL[" + multidex_dex_name + "]",
1175       encodings.at(multidex_dex_name));
1176 }
1177 
TEST_F(ClassLoaderContextTest,EncodeContextsSinglePathWithShared)1178 TEST_F(ClassLoaderContextTest, EncodeContextsSinglePathWithShared) {
1179   jobject class_loader_a = LoadDexInPathClassLoader("MyClass", nullptr);
1180 
1181   ScopedObjectAccess soa(Thread::Current());
1182   StackHandleScope<1> hs(soa.Self());
1183   Handle<mirror::ObjectArray<mirror::ClassLoader>> libraries = hs.NewHandle(
1184     mirror::ObjectArray<mirror::ClassLoader>::Alloc(
1185         soa.Self(),
1186         GetClassRoot<mirror::ObjectArray<mirror::ClassLoader>>(),
1187         1));
1188   libraries->Set(0, soa.Decode<mirror::ClassLoader>(class_loader_a));
1189 
1190   jobject class_loader_b = LoadDexInPathClassLoader(
1191       "Main", nullptr, soa.AddLocalReference<jobject>(libraries.Get()));
1192 
1193   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader_b);
1194 
1195   std::map<std::string, std::string> encodings = context->EncodeClassPathContexts("");
1196   ASSERT_EQ(1u, encodings.size());
1197   ASSERT_EQ(
1198       "PCL[]{PCL[" + GetTestDexFileName("MyClass") + "]}",
1199       encodings.at(GetTestDexFileName("Main")));
1200 }
1201 
TEST_F(ClassLoaderContextTest,EncodeContextsMultiplePaths)1202 TEST_F(ClassLoaderContextTest, EncodeContextsMultiplePaths) {
1203   jobject class_loader = LoadDexInPathClassLoader(
1204       std::vector<std::string>{ "Main", "MultiDex"}, nullptr);
1205 
1206   std::unique_ptr<ClassLoaderContext> context =
1207       CreateContextForClassLoader(class_loader);
1208 
1209   std::map<std::string, std::string> encodings = context->EncodeClassPathContexts("");
1210   ASSERT_EQ(2u, encodings.size());
1211   ASSERT_EQ("PCL[]", encodings.at(GetTestDexFileName("Main")));
1212   ASSERT_EQ(
1213       "PCL[" + GetTestDexFileName("Main") + "]", encodings.at(GetTestDexFileName("MultiDex")));
1214 }
1215 
TEST_F(ClassLoaderContextTest,EncodeContextsMultiplePathsWithShared)1216 TEST_F(ClassLoaderContextTest, EncodeContextsMultiplePathsWithShared) {
1217   jobject class_loader_a = LoadDexInPathClassLoader("MyClass", nullptr);
1218 
1219   ScopedObjectAccess soa(Thread::Current());
1220   StackHandleScope<1> hs(soa.Self());
1221   Handle<mirror::ObjectArray<mirror::ClassLoader>> libraries = hs.NewHandle(
1222     mirror::ObjectArray<mirror::ClassLoader>::Alloc(
1223         soa.Self(),
1224         GetClassRoot<mirror::ObjectArray<mirror::ClassLoader>>(),
1225         1));
1226   libraries->Set(0, soa.Decode<mirror::ClassLoader>(class_loader_a));
1227 
1228   jobject class_loader_b = LoadDexInPathClassLoader(
1229       std::vector<std::string> { "Main", "MultiDex" },
1230       nullptr, soa.AddLocalReference<jobject>(libraries.Get()));
1231 
1232   std::unique_ptr<ClassLoaderContext> context =
1233       CreateContextForClassLoader(class_loader_b);
1234 
1235   std::map<std::string, std::string> encodings = context->EncodeClassPathContexts("");
1236   ASSERT_EQ(2u, encodings.size());
1237   const std::string context_suffix =
1238       "{PCL[" + GetTestDexFileName("MyClass") + "]}";
1239   ASSERT_EQ("PCL[]" + context_suffix, encodings.at(GetTestDexFileName("Main")));
1240   ASSERT_EQ(
1241       "PCL[" + GetTestDexFileName("Main") + "]" + context_suffix,
1242       encodings.at(GetTestDexFileName("MultiDex")));
1243 }
1244 
TEST_F(ClassLoaderContextTest,EncodeContextsIMC)1245 TEST_F(ClassLoaderContextTest, EncodeContextsIMC) {
1246   jobject class_loader_a = LoadDexInPathClassLoader("Main", nullptr);
1247   jobject class_loader_b =
1248       LoadDexInInMemoryDexClassLoader("MyClass", class_loader_a);
1249 
1250   std::unique_ptr<ClassLoaderContext> context =
1251       CreateContextForClassLoader(class_loader_b);
1252 
1253   std::map<std::string, std::string> encodings = context->EncodeClassPathContexts("");
1254   ASSERT_EQ(1u, encodings.size());
1255   ASSERT_EQ(
1256       "IMC[];PCL[" + GetTestDexFileName("Main") + "]",
1257       encodings.at("<unknown>"));
1258 }
1259 
TEST_F(ClassLoaderContextTest,EncodeContextsForSingleDex)1260 TEST_F(ClassLoaderContextTest, EncodeContextsForSingleDex) {
1261   jobject class_loader = LoadDexInPathClassLoader("Main", nullptr);
1262   std::map<std::string, std::string> encodings =
1263       ClassLoaderContext::EncodeClassPathContextsForClassLoader(class_loader);
1264   ASSERT_EQ(1u, encodings.size());
1265   ASSERT_EQ("PCL[]", encodings.at(GetTestDexFileName("Main")));
1266 }
1267 
CreateForeignClassLoader()1268 static jobject CreateForeignClassLoader() {
1269   ScopedObjectAccess soa(Thread::Current());
1270   JNIEnv* env = soa.Env();
1271 
1272   // We cannot instantiate a ClassLoader directly, so instead we allocate an Object to represent
1273   // our foreign ClassLoader (this works because the runtime does proper instanceof checks before
1274   // operating on this object.
1275   jmethodID ctor = env->GetMethodID(WellKnownClasses::java_lang_Object, "<init>", "()V");
1276   return env->NewObject(WellKnownClasses::java_lang_Object, ctor);
1277 }
1278 
TEST_F(ClassLoaderContextTest,EncodeContextsForUnsupportedBase)1279 TEST_F(ClassLoaderContextTest, EncodeContextsForUnsupportedBase) {
1280   std::map<std::string, std::string> empty;
1281   ASSERT_EQ(
1282       empty, ClassLoaderContext::EncodeClassPathContextsForClassLoader(CreateForeignClassLoader()));
1283 }
1284 
TEST_F(ClassLoaderContextTest,EncodeContextsForUnsupportedChain)1285 TEST_F(ClassLoaderContextTest, EncodeContextsForUnsupportedChain) {
1286   jobject class_loader = LoadDexInPathClassLoader("Main", CreateForeignClassLoader());
1287   std::map<std::string, std::string> encodings =
1288       ClassLoaderContext::EncodeClassPathContextsForClassLoader(class_loader);
1289   ASSERT_EQ(1u, encodings.size());
1290   ASSERT_EQ(
1291       ClassLoaderContext::kUnsupportedClassLoaderContextEncoding,
1292       encodings.at(GetTestDexFileName("Main")));
1293 }
1294 
TEST_F(ClassLoaderContextTest,EncodeContextsForUnsupportedChainMultiPath)1295 TEST_F(ClassLoaderContextTest, EncodeContextsForUnsupportedChainMultiPath) {
1296   jobject class_loader = LoadDexInPathClassLoader(std::vector<std::string> { "Main", "MyClass" },
1297                                                   CreateForeignClassLoader());
1298   std::map<std::string, std::string> encodings =
1299       ClassLoaderContext::EncodeClassPathContextsForClassLoader(class_loader);
1300   ASSERT_EQ(2u, encodings.size());
1301   ASSERT_EQ(
1302       ClassLoaderContext::kUnsupportedClassLoaderContextEncoding,
1303       encodings.at(GetTestDexFileName("Main")));
1304   ASSERT_EQ(
1305       ClassLoaderContext::kUnsupportedClassLoaderContextEncoding,
1306       encodings.at(GetTestDexFileName("MyClass")));
1307 }
1308 
TEST_F(ClassLoaderContextTest,EncodeContextsForUnsupportedChainMultiDex)1309 TEST_F(ClassLoaderContextTest, EncodeContextsForUnsupportedChainMultiDex) {
1310   jobject class_loader = LoadDexInPathClassLoader("MultiDex", CreateForeignClassLoader());
1311   std::map<std::string, std::string> encodings =
1312       ClassLoaderContext::EncodeClassPathContextsForClassLoader(class_loader);
1313   ASSERT_EQ(1u, encodings.size());
1314   ASSERT_EQ(
1315       ClassLoaderContext::kUnsupportedClassLoaderContextEncoding,
1316       encodings.at(GetTestDexFileName("MultiDex")));
1317 }
1318 
TEST_F(ClassLoaderContextTest,IsValidEncoding)1319 TEST_F(ClassLoaderContextTest, IsValidEncoding) {
1320   ASSERT_TRUE(ClassLoaderContext::IsValidEncoding("PCL[]"));
1321   ASSERT_TRUE(ClassLoaderContext::IsValidEncoding("PCL[foo.dex]"));
1322   ASSERT_TRUE(ClassLoaderContext::IsValidEncoding("PCL[foo.dex];PCL[bar.dex]"));
1323   ASSERT_TRUE(ClassLoaderContext::IsValidEncoding("DLC[];PCL[bar.dex]"));
1324   ASSERT_TRUE(
1325       ClassLoaderContext::IsValidEncoding(
1326         ClassLoaderContext::kUnsupportedClassLoaderContextEncoding));
1327   ASSERT_FALSE(ClassLoaderContext::IsValidEncoding("not_valid"));
1328   ASSERT_FALSE(ClassLoaderContext::IsValidEncoding("[]"));
1329   ASSERT_FALSE(ClassLoaderContext::IsValidEncoding("FCL[]"));
1330   ASSERT_FALSE(ClassLoaderContext::IsValidEncoding("foo.dex:bar.dex"));
1331 }
1332 
1333 // TODO(calin) add a test which creates the context for a class loader together with dex_elements.
TEST_F(ClassLoaderContextTest,CreateContextForClassLoader)1334 TEST_F(ClassLoaderContextTest, CreateContextForClassLoader) {
1335   // The chain is
1336   //    ClassLoaderA (PathClassLoader)
1337   //       ^
1338   //       |
1339   //    ClassLoaderB (DelegateLastClassLoader)
1340   //       ^
1341   //       |
1342   //    ClassLoaderC (PathClassLoader)
1343   //       ^
1344   //       |
1345   //    ClassLoaderD (DelegateLastClassLoader)
1346 
1347   jobject class_loader_a = LoadDexInPathClassLoader("ForClassLoaderA", nullptr);
1348   jobject class_loader_b = LoadDexInDelegateLastClassLoader("ForClassLoaderB", class_loader_a);
1349   jobject class_loader_c = LoadDexInPathClassLoader("ForClassLoaderC", class_loader_b);
1350   jobject class_loader_d = LoadDexInDelegateLastClassLoader("ForClassLoaderD", class_loader_c);
1351 
1352   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader_d);
1353 
1354   VerifyContextForClassLoader(context.get());
1355   VerifyContextSize(context.get(), 4);
1356 
1357   VerifyClassLoaderDLCFromTestDex(context.get(), 0, "ForClassLoaderD");
1358   VerifyClassLoaderPCLFromTestDex(context.get(), 1, "ForClassLoaderC");
1359   VerifyClassLoaderDLCFromTestDex(context.get(), 2, "ForClassLoaderB");
1360   VerifyClassLoaderPCLFromTestDex(context.get(), 3, "ForClassLoaderA");
1361 }
1362 
TEST_F(ClassLoaderContextTest,CreateContextForClassLoaderIMC)1363 TEST_F(ClassLoaderContextTest, CreateContextForClassLoaderIMC) {
1364   // The chain is
1365   //    ClassLoaderA (PathClassLoader)
1366   //       ^
1367   //       |
1368   //    ClassLoaderB (InMemoryDexClassLoader)
1369   //       ^
1370   //       |
1371   //    ClassLoaderC (InMemoryDexClassLoader)
1372   //       ^
1373   //       |
1374   //    ClassLoaderD (DelegateLastClassLoader)
1375 
1376   jobject class_loader_a = LoadDexInPathClassLoader("ForClassLoaderA", nullptr);
1377   jobject class_loader_b = LoadDexInInMemoryDexClassLoader("ForClassLoaderB", class_loader_a);
1378   jobject class_loader_c = LoadDexInInMemoryDexClassLoader("ForClassLoaderC", class_loader_b);
1379   jobject class_loader_d = LoadDexInDelegateLastClassLoader("ForClassLoaderD", class_loader_c);
1380 
1381   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader_d);
1382 
1383   VerifyContextForClassLoader(context.get());
1384   VerifyContextSize(context.get(), 4);
1385 
1386   VerifyClassLoaderDLCFromTestDex(context.get(), 0, "ForClassLoaderD");
1387   VerifyClassLoaderIMCFromTestDex(context.get(), 1, "ForClassLoaderC");
1388   VerifyClassLoaderIMCFromTestDex(context.get(), 2, "ForClassLoaderB");
1389   VerifyClassLoaderPCLFromTestDex(context.get(), 3, "ForClassLoaderA");
1390 }
1391 
TEST_F(ClassLoaderContextTest,VerifyClassLoaderContextFirstElement)1392 TEST_F(ClassLoaderContextTest, VerifyClassLoaderContextFirstElement) {
1393   std::string context_spec = "PCL[]";
1394   std::unique_ptr<ClassLoaderContext> context = ParseContextWithChecksums(context_spec);
1395   ASSERT_TRUE(context != nullptr);
1396   PretendContextOpenedDexFiles(context.get());
1397   // Ensure that the special shared library marks as verified for the first thing in the class path.
1398   ASSERT_EQ(context->VerifyClassLoaderContextMatch(OatFile::kSpecialSharedLibrary),
1399             ClassLoaderContext::VerificationResult::kVerifies);
1400 }
1401 
TEST_F(ClassLoaderContextTest,VerifyClassLoaderContextMatch)1402 TEST_F(ClassLoaderContextTest, VerifyClassLoaderContextMatch) {
1403   std::string context_spec = "PCL[a.dex*123:b.dex*456];DLC[c.dex*890]";
1404   std::unique_ptr<ClassLoaderContext> context = ParseContextWithChecksums(context_spec);
1405   // Pretend that we successfully open the dex files to pass the DCHECKS.
1406   // (as it's much easier to test all the corner cases without relying on actual dex files).
1407   PretendContextOpenedDexFiles(context.get());
1408 
1409   VerifyContextSize(context.get(), 2);
1410   VerifyClassLoaderPCL(context.get(), 0, "a.dex:b.dex");
1411   VerifyClassLoaderDLC(context.get(), 1, "c.dex");
1412 
1413   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context_spec),
1414             ClassLoaderContext::VerificationResult::kVerifies);
1415 
1416   std::string wrong_class_loader_type = "PCL[a.dex*123:b.dex*456];PCL[c.dex*890]";
1417   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_class_loader_type),
1418             ClassLoaderContext::VerificationResult::kMismatch);
1419 
1420   std::string wrong_class_loader_order = "DLC[c.dex*890];PCL[a.dex*123:b.dex*456]";
1421   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_class_loader_order),
1422             ClassLoaderContext::VerificationResult::kMismatch);
1423 
1424   std::string wrong_classpath_order = "PCL[b.dex*456:a.dex*123];DLC[c.dex*890]";
1425   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_classpath_order),
1426             ClassLoaderContext::VerificationResult::kMismatch);
1427 
1428   std::string wrong_checksum = "PCL[a.dex*999:b.dex*456];DLC[c.dex*890]";
1429   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_checksum),
1430             ClassLoaderContext::VerificationResult::kMismatch);
1431 
1432   std::string wrong_extra_class_loader = "PCL[a.dex*123:b.dex*456];DLC[c.dex*890];PCL[d.dex*321]";
1433   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_extra_class_loader),
1434             ClassLoaderContext::VerificationResult::kMismatch);
1435 
1436   std::string wrong_extra_classpath = "PCL[a.dex*123:b.dex*456];DLC[c.dex*890:d.dex*321]";
1437   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_extra_classpath),
1438             ClassLoaderContext::VerificationResult::kMismatch);
1439 
1440   std::string wrong_spec = "PCL[a.dex*999:b.dex*456];DLC[";
1441   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_spec),
1442             ClassLoaderContext::VerificationResult::kMismatch);
1443 }
1444 
TEST_F(ClassLoaderContextTest,VerifyClassLoaderContextWithIMCMatch)1445 TEST_F(ClassLoaderContextTest, VerifyClassLoaderContextWithIMCMatch) {
1446   std::string context_spec = "PCL[a.dex*123:b.dex*456];DLC[c.dex*890];IMC[<unknown>*111]";
1447   std::unique_ptr<ClassLoaderContext> context = ParseContextWithChecksums(context_spec);
1448   // Pretend that we successfully open the dex files to pass the DCHECKS.
1449   // (as it's much easier to test all the corner cases without relying on actual dex files).
1450   PretendContextOpenedDexFiles(context.get());
1451 
1452   VerifyContextSize(context.get(), 3);
1453   VerifyClassLoaderPCL(context.get(), 0, "a.dex:b.dex");
1454   VerifyClassLoaderDLC(context.get(), 1, "c.dex");
1455   VerifyClassLoaderIMC(context.get(), 2, "<unknown>");
1456 
1457   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context_spec),
1458             ClassLoaderContext::VerificationResult::kVerifies);
1459 }
1460 
TEST_F(ClassLoaderContextTest,VerifyClassLoaderContextMatchSpecial)1461 TEST_F(ClassLoaderContextTest, VerifyClassLoaderContextMatchSpecial) {
1462   std::string context_spec = "&";
1463   std::unique_ptr<ClassLoaderContext> context = ParseContextWithChecksums(context_spec);
1464   // Pretend that we successfully open the dex files to pass the DCHECKS.
1465   // (as it's much easier to test all the corner cases without relying on actual dex files).
1466   PretendContextOpenedDexFiles(context.get());
1467 
1468   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context_spec),
1469             ClassLoaderContext::VerificationResult::kForcedToSkipChecks);
1470 }
1471 
TEST_F(ClassLoaderContextTest,VerifyClassLoaderContextMatchWithSL)1472 TEST_F(ClassLoaderContextTest, VerifyClassLoaderContextMatchWithSL) {
1473   std::string context_spec =
1474       "PCL[a.dex*123:b.dex*456]{PCL[d.dex*321];PCL[e.dex*654]#PCL[f.dex*098:g.dex*999]}"
1475       ";DLC[c.dex*890]";
1476   std::unique_ptr<ClassLoaderContext> context = ParseContextWithChecksums(context_spec);
1477   // Pretend that we successfully open the dex files to pass the DCHECKS.
1478   // (as it's much easier to test all the corner cases without relying on actual dex files).
1479   PretendContextOpenedDexFiles(context.get());
1480 
1481   VerifyContextSize(context.get(), 2);
1482   VerifyClassLoaderPCL(context.get(), 0, "a.dex:b.dex");
1483   VerifyClassLoaderDLC(context.get(), 1, "c.dex");
1484   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 0, "d.dex");
1485   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 1, "f.dex:g.dex");
1486 
1487   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context_spec),
1488             ClassLoaderContext::VerificationResult::kVerifies);
1489 
1490   std::string wrong_class_loader_type =
1491       "PCL[a.dex*123:b.dex*456]{DLC[d.dex*321];PCL[e.dex*654]#PCL[f.dex*098:g.dex*999]}"
1492       ";DLC[c.dex*890]";
1493   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_class_loader_type),
1494             ClassLoaderContext::VerificationResult::kMismatch);
1495 
1496   std::string wrong_class_loader_order =
1497       "PCL[a.dex*123:b.dex*456]{PCL[f.dex#098:g.dex#999}#PCL[d.dex*321];PCL[e.dex*654]}"
1498       ";DLC[c.dex*890]";
1499   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_class_loader_order),
1500             ClassLoaderContext::VerificationResult::kMismatch);
1501 
1502   std::string wrong_classpath_order =
1503       "PCL[a.dex*123:b.dex*456]{PCL[d.dex*321];PCL[e.dex*654]#PCL[g.dex*999:f.dex*098]}"
1504       ";DLC[c.dex*890]";
1505   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_classpath_order),
1506             ClassLoaderContext::VerificationResult::kMismatch);
1507 
1508   std::string wrong_checksum =
1509       "PCL[a.dex*123:b.dex*456]{PCL[d.dex*333];PCL[e.dex*654]#PCL[g.dex*999:f.dex*098]}"
1510       ";DLC[c.dex*890]";
1511   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_checksum),
1512             ClassLoaderContext::VerificationResult::kMismatch);
1513 
1514   std::string wrong_extra_class_loader =
1515       "PCL[a.dex*123:b.dex*456]"
1516       "{PCL[d.dex*321];PCL[e.dex*654]#PCL[f.dex*098:g.dex*999];PCL[i.dex#444]}"
1517       ";DLC[c.dex*890]";
1518   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_extra_class_loader),
1519             ClassLoaderContext::VerificationResult::kMismatch);
1520 
1521   std::string wrong_extra_classpath =
1522       "PCL[a.dex*123:b.dex*456]{PCL[d.dex*321:i.dex#444];PCL[e.dex*654]#PCL[f.dex*098:g.dex*999]}"
1523       ";DLC[c.dex*890]";
1524   ASSERT_EQ(context->VerifyClassLoaderContextMatch(wrong_extra_classpath),
1525             ClassLoaderContext::VerificationResult::kMismatch);
1526 }
1527 
TEST_F(ClassLoaderContextTest,VerifyClassLoaderContextMatchWithIMCSL)1528 TEST_F(ClassLoaderContextTest, VerifyClassLoaderContextMatchWithIMCSL) {
1529   std::string context_spec =
1530       "IMC[<unknown>*123:<unknown>*456]"
1531       "{IMC[<unknown>*321];IMC[<unknown>*654]#IMC[<unknown>*098:<unknown>*999]};"
1532       "DLC[c.dex*890]";
1533   std::unique_ptr<ClassLoaderContext> context = ParseContextWithChecksums(context_spec);
1534   // Pretend that we successfully open the dex files to pass the DCHECKS.
1535   // (as it's much easier to test all the corner cases without relying on actual dex files).
1536   PretendContextOpenedDexFiles(context.get());
1537 
1538   VerifyContextSize(context.get(), 2);
1539   VerifyClassLoaderIMC(context.get(), 0, "<unknown>:<unknown>");
1540   VerifyClassLoaderDLC(context.get(), 1, "c.dex");
1541   VerifyClassLoaderSharedLibraryIMC(context.get(), 0, 0, "<unknown>");
1542   VerifyClassLoaderSharedLibraryIMC(context.get(), 0, 1, "<unknown>:<unknown>");
1543 
1544   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context_spec),
1545             ClassLoaderContext::VerificationResult::kVerifies);
1546 }
1547 
TEST_F(ClassLoaderContextTest,VerifyClassLoaderContextMatchAfterEncoding)1548 TEST_F(ClassLoaderContextTest, VerifyClassLoaderContextMatchAfterEncoding) {
1549   jobject class_loader_a = LoadDexInPathClassLoader("ForClassLoaderA", nullptr);
1550   jobject class_loader_b = LoadDexInDelegateLastClassLoader("ForClassLoaderB", class_loader_a);
1551   jobject class_loader_c = LoadDexInPathClassLoader("ForClassLoaderC", class_loader_b);
1552   jobject class_loader_d = LoadDexInDelegateLastClassLoader("ForClassLoaderD", class_loader_c);
1553 
1554   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader_d);
1555 
1556   std::string context_with_no_base_dir = context->EncodeContextForOatFile("");
1557   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context_with_no_base_dir),
1558             ClassLoaderContext::VerificationResult::kVerifies);
1559 
1560   std::string dex_location = GetTestDexFileName("ForClassLoaderA");
1561   size_t pos = dex_location.rfind('/');
1562   ASSERT_NE(std::string::npos, pos);
1563   std::string parent = dex_location.substr(0, pos);
1564 
1565   std::string context_with_base_dir = context->EncodeContextForOatFile(parent);
1566   ASSERT_NE(context_with_base_dir, context_with_no_base_dir);
1567   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context_with_base_dir),
1568             ClassLoaderContext::VerificationResult::kVerifies);
1569 }
1570 
TEST_F(ClassLoaderContextTest,VerifyClassLoaderContextMatchAfterEncodingIMC)1571 TEST_F(ClassLoaderContextTest, VerifyClassLoaderContextMatchAfterEncodingIMC) {
1572   jobject class_loader_a = LoadDexInPathClassLoader("ForClassLoaderA", nullptr);
1573   jobject class_loader_b = LoadDexInInMemoryDexClassLoader("ForClassLoaderB", class_loader_a);
1574   jobject class_loader_c = LoadDexInInMemoryDexClassLoader("ForClassLoaderC", class_loader_b);
1575   jobject class_loader_d = LoadDexInDelegateLastClassLoader("ForClassLoaderD", class_loader_c);
1576 
1577   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader_d);
1578 
1579   std::string context_with_no_base_dir = context->EncodeContextForOatFile("");
1580   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context_with_no_base_dir),
1581             ClassLoaderContext::VerificationResult::kVerifies);
1582 
1583   std::string dex_location = GetTestDexFileName("ForClassLoaderA");
1584   size_t pos = dex_location.rfind('/');
1585   ASSERT_NE(std::string::npos, pos);
1586   std::string parent = dex_location.substr(0, pos);
1587 
1588   std::string context_with_base_dir = context->EncodeContextForOatFile(parent);
1589   ASSERT_NE(context_with_base_dir, context_with_no_base_dir);
1590   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context_with_base_dir),
1591             ClassLoaderContext::VerificationResult::kVerifies);
1592 }
1593 
TEST_F(ClassLoaderContextTest,VerifyClassLoaderContextMatchAfterEncodingMultidex)1594 TEST_F(ClassLoaderContextTest, VerifyClassLoaderContextMatchAfterEncodingMultidex) {
1595   jobject class_loader = LoadDexInPathClassLoader("MultiDex", nullptr);
1596 
1597   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader);
1598 
1599   std::string context_with_no_base_dir = context->EncodeContextForOatFile("");
1600   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context_with_no_base_dir),
1601             ClassLoaderContext::VerificationResult::kVerifies);
1602 
1603   std::string dex_location = GetTestDexFileName("MultiDex");
1604   size_t pos = dex_location.rfind('/');
1605   ASSERT_NE(std::string::npos, pos);
1606   std::string parent = dex_location.substr(0, pos);
1607 
1608   std::string context_with_base_dir = context->EncodeContextForOatFile(parent);
1609   ASSERT_NE(context_with_base_dir, context_with_no_base_dir);
1610   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context_with_base_dir),
1611             ClassLoaderContext::VerificationResult::kVerifies);
1612 }
1613 
TEST_F(ClassLoaderContextTest,CreateContextForClassLoaderWithSharedLibraries)1614 TEST_F(ClassLoaderContextTest, CreateContextForClassLoaderWithSharedLibraries) {
1615   jobject class_loader_a = LoadDexInPathClassLoader("ForClassLoaderA", nullptr);
1616 
1617   ScopedObjectAccess soa(Thread::Current());
1618   StackHandleScope<1> hs(soa.Self());
1619   Handle<mirror::ObjectArray<mirror::ClassLoader>> libraries = hs.NewHandle(
1620     mirror::ObjectArray<mirror::ClassLoader>::Alloc(
1621         soa.Self(),
1622         GetClassRoot<mirror::ObjectArray<mirror::ClassLoader>>(),
1623         1));
1624   libraries->Set(0, soa.Decode<mirror::ClassLoader>(class_loader_a));
1625 
1626   jobject class_loader_b = LoadDexInPathClassLoader(
1627       "ForClassLoaderB", nullptr, soa.AddLocalReference<jobject>(libraries.Get()));
1628 
1629   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader_b);
1630   ASSERT_TRUE(context != nullptr);
1631   std::vector<std::unique_ptr<const DexFile>> dex_files = OpenTestDexFiles("ForClassLoaderB");
1632   VerifyClassLoaderPCL(context.get(), 0, dex_files[0]->GetLocation());
1633   dex_files = OpenTestDexFiles("ForClassLoaderA");
1634   VerifyClassLoaderSharedLibraryPCL(context.get(), 0, 0, dex_files[0]->GetLocation());
1635 
1636   ASSERT_EQ(context->VerifyClassLoaderContextMatch(context->EncodeContextForOatFile("")),
1637             ClassLoaderContext::VerificationResult::kVerifies);
1638 }
1639 
TEST_F(ClassLoaderContextTest,CheckForDuplicateDexFilesNotFoundSingleCL)1640 TEST_F(ClassLoaderContextTest, CheckForDuplicateDexFilesNotFoundSingleCL) {
1641   jobject class_loader = LoadDexInPathClassLoader("Main", nullptr);
1642 
1643   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader);
1644 
1645   std::set<const DexFile*> result = context->CheckForDuplicateDexFiles(
1646       std::vector<const DexFile*>());
1647   ASSERT_EQ(0u, result.size());
1648 
1649   std::vector<std::unique_ptr<const DexFile>> dex1 = OpenTestDexFiles("ForClassLoaderA");
1650   std::vector<const DexFile*> dex1_raw = MakeNonOwningPointerVector(dex1);
1651   result = context->CheckForDuplicateDexFiles(dex1_raw);
1652   ASSERT_EQ(0u, result.size());
1653 }
1654 
TEST_F(ClassLoaderContextTest,CheckForDuplicateDexFilesFound)1655 TEST_F(ClassLoaderContextTest, CheckForDuplicateDexFilesFound) {
1656   jobject class_loader = LoadDexInPathClassLoader(std::vector<std::string> { "Main", "Main" }, nullptr);
1657 
1658   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader);
1659 
1660   std::vector<std::unique_ptr<const DexFile>> dex1 = OpenTestDexFiles("Main");
1661   std::vector<const DexFile*> dex1_raw = MakeNonOwningPointerVector(dex1);
1662   std::set<const DexFile*> result = context->CheckForDuplicateDexFiles(dex1_raw);
1663   ASSERT_EQ(1u, result.size()) << context->EncodeContextForOatFile("");
1664   ASSERT_EQ(dex1_raw[0], *(result.begin()));
1665 }
1666 
1667 
TEST_F(ClassLoaderContextTest,CheckForDuplicateCrossCLNotFound)1668 TEST_F(ClassLoaderContextTest, CheckForDuplicateCrossCLNotFound) {
1669   jobject class_loader_a = LoadDexInPathClassLoader("ForClassLoaderA", nullptr);
1670   jobject class_loader_b = LoadDexInInMemoryDexClassLoader("ForClassLoaderB", class_loader_a);
1671 
1672   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader_b);
1673 
1674   std::vector<std::unique_ptr<const DexFile>> dex1 = OpenTestDexFiles("ForClassLoaderA");
1675   std::vector<const DexFile*> dex1_raw = MakeNonOwningPointerVector(dex1);
1676   std::set<const DexFile*> result = context->CheckForDuplicateDexFiles(dex1_raw);
1677   ASSERT_EQ(0u, result.size());
1678 }
1679 
1680 }  // namespace art
1681