Improved ClassLoader support
Change-Id: I587c0fa439c64a0c947641b01c072149f480bf85
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index 8672cf9..d521183 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -23,6 +23,7 @@
ASSERT_EQ(descriptor, primitive->GetDescriptor());
EXPECT_TRUE(primitive->GetSuperClass() == NULL);
EXPECT_FALSE(primitive->HasSuperClass());
+ EXPECT_TRUE(primitive->GetClassLoader() == NULL);
EXPECT_TRUE(primitive->GetComponentType() == NULL);
EXPECT_TRUE(primitive->GetStatus() == Class::kStatusInitialized);
EXPECT_FALSE(primitive->IsErroneous());
@@ -44,8 +45,9 @@
void AssertArrayClass(const StringPiece& array_descriptor,
int32_t array_rank,
- const StringPiece& component_type) {
- Class* array = class_linker_->FindSystemClass(array_descriptor);
+ const StringPiece& component_type,
+ ClassLoader* class_loader) {
+ Class* array = class_linker_->FindClass(array_descriptor, class_loader);
ASSERT_TRUE(array != NULL);
ASSERT_TRUE(array->GetClass() != NULL);
ASSERT_EQ(array->GetClass(), array->GetClass()->GetClass());
@@ -54,6 +56,7 @@
EXPECT_TRUE(array->GetSuperClass() != NULL);
EXPECT_EQ(class_linker_->FindSystemClass("Ljava/lang/Object;"), array->GetSuperClass());
EXPECT_TRUE(array->HasSuperClass());
+ EXPECT_EQ(class_loader, array->GetClassLoader());
ASSERT_TRUE(array->GetComponentType() != NULL);
ASSERT_TRUE(array->GetComponentType()->GetDescriptor() != NULL);
EXPECT_EQ(component_type, array->GetComponentType()->GetDescriptor());
@@ -75,18 +78,18 @@
EXPECT_EQ(2U, array->NumInterfaces());
}
- void AssertDexFileClass(const DexFile* dex, const char* descriptor) {
+ void AssertDexFileClass(ClassLoader* class_loader, const char* descriptor) {
ASSERT_TRUE(descriptor != NULL);
- Class* klass = class_linker_->FindClass(descriptor, NULL, dex);
+ Class* klass = class_linker_->FindSystemClass(descriptor);
ASSERT_TRUE(klass != NULL);
EXPECT_EQ(descriptor, klass->GetDescriptor());
if (klass->descriptor_ == "Ljava/lang/Object;") {
- EXPECT_FALSE(klass->HasSuperClass());
+ EXPECT_FALSE(klass->HasSuperClass());
} else {
- EXPECT_TRUE(klass->HasSuperClass());
- EXPECT_TRUE(klass->GetSuperClass() != NULL);
+ EXPECT_TRUE(klass->HasSuperClass());
+ EXPECT_TRUE(klass->GetSuperClass() != NULL);
}
- // EXPECT_TRUE(klass->GetClassLoader() != NULL); // TODO needs class loader
+ EXPECT_EQ(class_loader, klass->GetClassLoader());
EXPECT_TRUE(klass->GetDexCache() != NULL);
EXPECT_TRUE(klass->GetComponentType() == NULL);
EXPECT_TRUE(klass->GetComponentType() == NULL);
@@ -98,78 +101,78 @@
EXPECT_TRUE(klass->IsInSamePackage(klass));
EXPECT_TRUE(Class::IsInSamePackage(klass->GetDescriptor(), klass->GetDescriptor()));
if (klass->IsInterface()) {
- EXPECT_TRUE(klass->IsAbstract());
- if (klass->NumDirectMethods() == 1) {
- EXPECT_PRED2(String::EqualsUtf8, klass->GetDirectMethod(0)->GetName(), "<clinit>");
- } else {
- EXPECT_EQ(0U, klass->NumDirectMethods());
- }
+ EXPECT_TRUE(klass->IsAbstract());
+ if (klass->NumDirectMethods() == 1) {
+ EXPECT_PRED2(String::EqualsUtf8, klass->GetDirectMethod(0)->GetName(), "<clinit>");
+ } else {
+ EXPECT_EQ(0U, klass->NumDirectMethods());
+ }
} else {
- if (!klass->IsSynthetic()) {
- EXPECT_NE(0U, klass->NumDirectMethods());
- }
+ if (!klass->IsSynthetic()) {
+ EXPECT_NE(0U, klass->NumDirectMethods());
+ }
}
if (klass->IsAbstract()) {
- EXPECT_FALSE(klass->IsFinal());
+ EXPECT_FALSE(klass->IsFinal());
} else {
- EXPECT_FALSE(klass->IsAnnotation());
+ EXPECT_FALSE(klass->IsAnnotation());
}
if (klass->IsFinal()) {
- EXPECT_FALSE(klass->IsAbstract());
- EXPECT_FALSE(klass->IsAnnotation());
+ EXPECT_FALSE(klass->IsAbstract());
+ EXPECT_FALSE(klass->IsAnnotation());
}
if (klass->IsAnnotation()) {
- EXPECT_FALSE(klass->IsFinal());
- EXPECT_TRUE(klass->IsAbstract());
+ EXPECT_FALSE(klass->IsFinal());
+ EXPECT_TRUE(klass->IsAbstract());
}
EXPECT_FALSE(klass->IsPrimitive());
EXPECT_TRUE(klass->CanAccess(klass));
for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
- Method* method = klass->GetDirectMethod(i);
- EXPECT_TRUE(method != NULL);
+ Method* method = klass->GetDirectMethod(i);
+ EXPECT_TRUE(method != NULL);
}
for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
- Method* method = klass->GetVirtualMethod(i);
- EXPECT_TRUE(method != NULL);
+ Method* method = klass->GetVirtualMethod(i);
+ EXPECT_TRUE(method != NULL);
}
for (size_t i = 0; i < klass->NumInstanceFields(); i++) {
- InstanceField* field = klass->GetInstanceField(i);
- EXPECT_TRUE(field != NULL);
+ InstanceField* field = klass->GetInstanceField(i);
+ EXPECT_TRUE(field != NULL);
}
for (size_t i = 0; i < klass->NumStaticFields(); i++) {
- StaticField* field = klass->GetStaticField(i);
- EXPECT_TRUE(field != NULL);
+ StaticField* field = klass->GetStaticField(i);
+ EXPECT_TRUE(field != NULL);
}
// Confirm that all instances fields are packed together at the start
EXPECT_GE(klass->NumInstanceFields(), klass->NumReferenceInstanceFields());
for (size_t i = 0; i < klass->NumReferenceInstanceFields(); i++) {
- InstanceField* field = klass->GetInstanceField(i);
- ASSERT_TRUE(field != NULL);
- ASSERT_TRUE(field->GetDescriptor() != NULL);
- Class* fieldType = class_linker_->FindClass(field->GetDescriptor(), NULL, dex);
- ASSERT_TRUE(fieldType != NULL);
- EXPECT_FALSE(fieldType->IsPrimitive());
+ InstanceField* field = klass->GetInstanceField(i);
+ ASSERT_TRUE(field != NULL);
+ ASSERT_TRUE(field->GetDescriptor() != NULL);
+ Class* field_type = class_linker_->FindClass(field->GetDescriptor(), class_loader);
+ ASSERT_TRUE(field_type != NULL);
+ EXPECT_FALSE(field_type->IsPrimitive());
}
for (size_t i = klass->NumReferenceInstanceFields(); i < klass->NumInstanceFields(); i++) {
- InstanceField* field = klass->GetInstanceField(i);
- ASSERT_TRUE(field != NULL);
- ASSERT_TRUE(field->GetDescriptor() != NULL);
- Class* fieldType = class_linker_->FindClass(field->GetDescriptor(), NULL, dex);
- ASSERT_TRUE(fieldType != NULL);
- EXPECT_TRUE(fieldType->IsPrimitive());
+ InstanceField* field = klass->GetInstanceField(i);
+ ASSERT_TRUE(field != NULL);
+ ASSERT_TRUE(field->GetDescriptor() != NULL);
+ Class* field_type = class_linker_->FindClass(field->GetDescriptor(), class_loader);
+ ASSERT_TRUE(field_type != NULL);
+ EXPECT_TRUE(field_type->IsPrimitive());
}
size_t total_num_reference_instance_fields = 0;
Class* k = klass;
while (k != NULL) {
- total_num_reference_instance_fields += k->NumReferenceInstanceFields();
- k = k->GetSuperClass();
+ total_num_reference_instance_fields += k->NumReferenceInstanceFields();
+ k = k->GetSuperClass();
}
EXPECT_EQ(klass->GetReferenceOffsets() == 0,
total_num_reference_instance_fields == 0);
@@ -179,13 +182,12 @@
EXPECT_TRUE(root != NULL);
}
- void AssertDexFile(const DexFile* dex) {
+ void AssertDexFile(const DexFile* dex, ClassLoader* class_loader) {
ASSERT_TRUE(dex != NULL);
- class_linker_->RegisterDexFile(dex);
for (size_t i = 0; i < dex->NumClassDefs(); i++) {
const DexFile::ClassDef class_def = dex->GetClassDef(i);
const char* descriptor = dex->GetClassDescriptor(class_def);
- AssertDexFileClass(dex, descriptor);
+ AssertDexFileClass(class_loader, descriptor);
}
class_linker_->VisitRoots(TestRootVisitor, NULL);
}
@@ -199,15 +201,15 @@
}
TEST_F(ClassLinkerTest, FindClassNested) {
- scoped_ptr<DexFile> nested_dex(OpenDexFileBase64(kNestedDex));
- class_linker_->RegisterDexFile(nested_dex.get());
+ scoped_ptr<DexFile> dex(OpenDexFileBase64(kNestedDex));
+ PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
- Class* outer = class_linker_->FindClass("LNested;", NULL, nested_dex.get());
+ Class* outer = class_linker_->FindClass("LNested;", class_loader);
ASSERT_TRUE(outer != NULL);
EXPECT_EQ(0U, outer->NumVirtualMethods());
EXPECT_EQ(1U, outer->NumDirectMethods());
- Class* inner = class_linker_->FindClass("LNested$Inner;", NULL, nested_dex.get());
+ Class* inner = class_linker_->FindClass("LNested$Inner;", class_loader);
ASSERT_TRUE(inner != NULL);
EXPECT_EQ(0U, inner->NumVirtualMethods());
EXPECT_EQ(1U, inner->NumDirectMethods());
@@ -235,6 +237,7 @@
ASSERT_TRUE(JavaLangObject->GetDescriptor() == "Ljava/lang/Object;");
EXPECT_TRUE(JavaLangObject->GetSuperClass() == NULL);
EXPECT_FALSE(JavaLangObject->HasSuperClass());
+ EXPECT_TRUE(JavaLangObject->GetClassLoader() == NULL);
EXPECT_TRUE(JavaLangObject->GetComponentType() == NULL);
EXPECT_FALSE(JavaLangObject->IsErroneous());
EXPECT_FALSE(JavaLangObject->IsVerified());
@@ -254,9 +257,9 @@
scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassDex));
- linker->RegisterDexFile(dex.get());
+ PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
EXPECT_TRUE(linker->FindSystemClass("LMyClass;") == NULL);
- Class* MyClass = linker->FindClass("LMyClass;", NULL, dex.get());
+ Class* MyClass = linker->FindClass("LMyClass;", class_loader);
ASSERT_TRUE(MyClass != NULL);
ASSERT_TRUE(MyClass->GetClass() != NULL);
ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
@@ -264,6 +267,7 @@
ASSERT_TRUE(MyClass->GetDescriptor() == "LMyClass;");
EXPECT_TRUE(MyClass->GetSuperClass() == JavaLangObject);
EXPECT_TRUE(MyClass->HasSuperClass());
+ EXPECT_EQ(class_loader, MyClass->GetClassLoader());
EXPECT_TRUE(MyClass->GetComponentType() == NULL);
EXPECT_TRUE(MyClass->GetStatus() == Class::kStatusResolved);
EXPECT_FALSE(MyClass->IsErroneous());
@@ -285,11 +289,11 @@
EXPECT_EQ(JavaLangObject->GetClass()->GetClass(), MyClass->GetClass()->GetClass());
// created by class_linker
- AssertArrayClass("[C", 1, "C");
- AssertArrayClass("[Ljava/lang/Object;", 1, "Ljava/lang/Object;");
+ AssertArrayClass("[C", 1, "C", NULL);
+ AssertArrayClass("[Ljava/lang/Object;", 1, "Ljava/lang/Object;", NULL);
// synthesized on the fly
- AssertArrayClass("[[C", 2, "C");
- AssertArrayClass("[[[LMyClass;", 3, "LMyClass;");
+ AssertArrayClass("[[C", 2, "C", NULL);
+ AssertArrayClass("[[[LMyClass;", 3, "LMyClass;", class_loader);
// or not available at all
AssertNonExistantClass("[[[[LNonExistantClass;");
}
@@ -297,10 +301,10 @@
TEST_F(ClassLinkerTest, ProtoCompare) {
ClassLinker* linker = class_linker_;
- scoped_ptr<DexFile> proto_dex_file(OpenDexFileBase64(kProtoCompareDex));
- linker->RegisterDexFile(proto_dex_file.get());
+ scoped_ptr<DexFile> dex(OpenDexFileBase64(kProtoCompareDex));
+ PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
- Class* klass = linker->FindClass("LProtoCompare;", NULL, proto_dex_file.get());
+ Class* klass = linker->FindClass("LProtoCompare;", class_loader);
ASSERT_TRUE(klass != NULL);
ASSERT_EQ(4U, klass->NumVirtualMethods());
@@ -352,13 +356,13 @@
ClassLinker* linker = class_linker_;
scoped_ptr<DexFile> proto1_dex_file(OpenDexFileBase64(kProtoCompareDex));
- linker->RegisterDexFile(proto1_dex_file.get());
+ PathClassLoader* class_loader_1 = AllocPathClassLoader(proto1_dex_file.get());
scoped_ptr<DexFile> proto2_dex_file(OpenDexFileBase64(kProtoCompare2Dex));
- linker->RegisterDexFile(proto2_dex_file.get());
+ PathClassLoader* class_loader_2 = AllocPathClassLoader(proto2_dex_file.get());
- Class* klass1 = linker->FindClass("LProtoCompare;", NULL, proto1_dex_file.get());
+ Class* klass1 = linker->FindClass("LProtoCompare;", class_loader_1);
ASSERT_TRUE(klass1 != NULL);
- Class* klass2 = linker->FindClass("LProtoCompare2;", NULL, proto2_dex_file.get());
+ Class* klass2 = linker->FindClass("LProtoCompare2;", class_loader_2);
ASSERT_TRUE(klass2 != NULL);
Method* m1_1 = klass1->GetVirtualMethod(0);
@@ -393,9 +397,10 @@
}
TEST_F(ClassLinkerTest, LibCore) {
+ UseLibCoreDex();
scoped_ptr<DexFile> libcore_dex_file(GetLibCoreDex());
- EXPECT_TRUE(libcore_dex_file.get() != NULL); // Passes on host only until we have DexFile::OpenJar
- AssertDexFile(libcore_dex_file.get());
+ EXPECT_TRUE(libcore_dex_file.get() != NULL);
+ AssertDexFile(libcore_dex_file.get(), NULL);
}
// C++ fields must exactly match the fields in the Java classes. If this fails,
@@ -403,18 +408,18 @@
// ClassLinker::LinkInstanceFields.
TEST_F(ClassLinkerTest, ValidateFieldOrderOfJavaCppUnionClasses) {
UseLibCoreDex();
- Class* string = class_linker_->FindClass( "Ljava/lang/String;", NULL, java_lang_dex_file_.get());
+ Class* string = class_linker_->FindSystemClass( "Ljava/lang/String;");
ASSERT_EQ(4U, string->NumInstanceFields());
EXPECT_PRED2(String::EqualsUtf8, string->GetInstanceField(0)->GetName(), "value");
EXPECT_PRED2(String::EqualsUtf8, string->GetInstanceField(1)->GetName(), "hashCode");
EXPECT_PRED2(String::EqualsUtf8, string->GetInstanceField(2)->GetName(), "offset");
EXPECT_PRED2(String::EqualsUtf8, string->GetInstanceField(3)->GetName(), "count");
- Class* accessible_object = class_linker_->FindClass("Ljava/lang/reflect/AccessibleObject;", NULL, java_lang_dex_file_.get());
+ Class* accessible_object = class_linker_->FindSystemClass("Ljava/lang/reflect/AccessibleObject;");
ASSERT_EQ(1U, accessible_object->NumInstanceFields());
EXPECT_PRED2(String::EqualsUtf8, accessible_object->GetInstanceField(0)->GetName(), "flag");
- Class* field = class_linker_->FindClass("Ljava/lang/reflect/Field;", NULL, java_lang_dex_file_.get());
+ Class* field = class_linker_->FindSystemClass("Ljava/lang/reflect/Field;");
ASSERT_EQ(6U, field->NumInstanceFields());
EXPECT_PRED2(String::EqualsUtf8, field->GetInstanceField(0)->GetName(), "declaringClass");
EXPECT_PRED2(String::EqualsUtf8, field->GetInstanceField(1)->GetName(), "genericType");
@@ -423,7 +428,7 @@
EXPECT_PRED2(String::EqualsUtf8, field->GetInstanceField(4)->GetName(), "slot");
EXPECT_PRED2(String::EqualsUtf8, field->GetInstanceField(5)->GetName(), "genericTypesAreInitialized");
- Class* method = class_linker_->FindClass("Ljava/lang/reflect/Method;", NULL, java_lang_dex_file_.get());
+ Class* method = class_linker_->FindSystemClass("Ljava/lang/reflect/Method;");
ASSERT_EQ(11U, method->NumInstanceFields());
EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 0)->GetName(), "declaringClass");
EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 1)->GetName(), "exceptionTypes");
@@ -436,6 +441,28 @@
EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 8)->GetName(), "parameterTypes");
EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 9)->GetName(), "genericTypesAreInitialized");
EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField(10)->GetName(), "slot");
+
+ Class* class_loader = class_linker_->FindSystemClass("Ljava/lang/ClassLoader;");
+ ASSERT_EQ(2U, class_loader->NumInstanceFields());
+ EXPECT_PRED2(String::EqualsUtf8, class_loader->GetInstanceField(0)->GetName(), "packages");
+ EXPECT_PRED2(String::EqualsUtf8, class_loader->GetInstanceField(1)->GetName(), "parent");
+
+ Class* dex_base_class_loader = class_linker_->FindSystemClass("Ldalvik/system/BaseDexClassLoader;");
+ ASSERT_EQ(2U, dex_base_class_loader->NumInstanceFields());
+ EXPECT_PRED2(String::EqualsUtf8, dex_base_class_loader->GetInstanceField(0)->GetName(), "originalPath");
+ EXPECT_PRED2(String::EqualsUtf8, dex_base_class_loader->GetInstanceField(1)->GetName(), "pathList");
+}
+
+TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
+ scoped_ptr<DexFile> dex_1(OpenDexFileBase64(kMyClassDex));
+ scoped_ptr<DexFile> dex_2(OpenDexFileBase64(kMyClassDex));
+ PathClassLoader* class_loader_1 = AllocPathClassLoader(dex_1.get());
+ PathClassLoader* class_loader_2 = AllocPathClassLoader(dex_2.get());
+ Class* MyClass_1 = class_linker_->FindClass("LMyClass;", class_loader_1);
+ Class* MyClass_2 = class_linker_->FindClass("LMyClass;", class_loader_2);
+ EXPECT_TRUE(MyClass_1 != NULL);
+ EXPECT_TRUE(MyClass_2 != NULL);
+ EXPECT_NE(MyClass_1, MyClass_2);
}
} // namespace art