ObjPtr<>-ify tests using ClassLinker::FindClass().
ClassLinker::FindClass() returns a non-ObjPtr<> reference
but it has a lot of uses, so we shall change the uses in
a few steps. This change deals with several tests.
Test: Rely on TreeHugger.
Bug: 31113334
Change-Id: Ib75e20e7ebaff01fb607a09f96675f8cf397ae52
diff --git a/runtime/class_linker_test.cc b/runtime/class_linker_test.cc
index 8cd0604..6ed029c 100644
--- a/runtime/class_linker_test.cc
+++ b/runtime/class_linker_test.cc
@@ -62,9 +62,10 @@
Thread* self = Thread::Current();
EXPECT_TRUE(class_linker_->FindSystemClass(self, descriptor.c_str()) == nullptr);
EXPECT_TRUE(self->IsExceptionPending());
- mirror::Object* exception = self->GetException();
+ StackHandleScope<1> hs(self);
+ Handle<mirror::Object> exception = hs.NewHandle<mirror::Object>(self->GetException());
self->ClearException();
- mirror::Class* exception_class =
+ ObjPtr<mirror::Class> exception_class =
class_linker_->FindSystemClass(self, "Ljava/lang/NoClassDefFoundError;");
EXPECT_TRUE(exception->InstanceOf(exception_class));
}
@@ -75,7 +76,7 @@
AssertPrimitiveClass(descriptor, class_linker_->FindSystemClass(self, descriptor.c_str()));
}
- void AssertPrimitiveClass(const std::string& descriptor, mirror::Class* primitive)
+ void AssertPrimitiveClass(const std::string& descriptor, ObjPtr<mirror::Class> primitive)
REQUIRES_SHARED(Locks::mutator_lock_) {
ASSERT_TRUE(primitive != nullptr);
ASSERT_TRUE(primitive->GetClass() != nullptr);
@@ -113,13 +114,13 @@
EXPECT_EQ(kAccPublic | kAccFinal | kAccAbstract, primitive->GetAccessFlags());
}
- void AssertObjectClass(mirror::Class* JavaLangObject)
+ void AssertObjectClass(ObjPtr<mirror::Class> JavaLangObject)
REQUIRES_SHARED(Locks::mutator_lock_) {
ASSERT_TRUE(JavaLangObject != nullptr);
ASSERT_TRUE(JavaLangObject->GetClass() != nullptr);
ASSERT_EQ(JavaLangObject->GetClass(),
JavaLangObject->GetClass()->GetClass());
- EXPECT_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass());
+ EXPECT_OBJ_PTR_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass());
std::string temp;
ASSERT_STREQ(JavaLangObject->GetDescriptor(&temp), "Ljava/lang/Object;");
EXPECT_TRUE(JavaLangObject->GetSuperClass() == nullptr);
@@ -172,7 +173,7 @@
void AssertArrayClass(const std::string& array_descriptor,
const std::string& component_type,
- mirror::ClassLoader* class_loader)
+ ObjPtr<mirror::ClassLoader> class_loader)
REQUIRES_SHARED(Locks::mutator_lock_) {
Thread* self = Thread::Current();
StackHandleScope<2> hs(self);
@@ -181,7 +182,7 @@
hs.NewHandle(class_linker_->FindClass(self, array_descriptor.c_str(), loader)));
std::string temp;
EXPECT_STREQ(component_type.c_str(), array->GetComponentType()->GetDescriptor(&temp));
- EXPECT_EQ(class_loader, array->GetClassLoader());
+ EXPECT_OBJ_PTR_EQ(loader.Get(), array->GetClassLoader());
EXPECT_EQ(kAccFinal | kAccAbstract, (array->GetAccessFlags() & (kAccFinal | kAccAbstract)));
AssertArrayClass(array_descriptor, array);
}
@@ -234,7 +235,7 @@
EXPECT_OBJ_PTR_EQ(class_linker_->FindArrayClass(self, &array_ptr), array.Get());
PointerSize pointer_size = class_linker_->GetImagePointerSize();
- mirror::Class* JavaLangObject =
+ ObjPtr<mirror::Class> JavaLangObject =
class_linker_->FindSystemClass(self, "Ljava/lang/Object;");
ImTable* JavaLangObject_imt = JavaLangObject->GetImt(pointer_size);
// IMT of a array class should be shared with the IMT of the java.lag.Object
@@ -292,9 +293,9 @@
}
}
EXPECT_EQ(klass->IsInterface(), !klass->HasVTable());
- mirror::IfTable* iftable = klass->GetIfTable();
+ ObjPtr<mirror::IfTable> iftable = klass->GetIfTable();
for (int i = 0; i < klass->GetIfTableCount(); i++) {
- mirror::Class* interface = iftable->GetInterface(i);
+ ObjPtr<mirror::Class> interface = iftable->GetInterface(i);
ASSERT_TRUE(interface != nullptr);
if (klass->IsInterface()) {
EXPECT_EQ(0U, iftable->GetMethodArrayCount(i));
@@ -322,13 +323,13 @@
for (ArtMethod& method : klass->GetDirectMethods(kRuntimePointerSize)) {
AssertMethod(&method);
EXPECT_TRUE(method.IsDirect());
- EXPECT_EQ(klass.Get(), method.GetDeclaringClass());
+ EXPECT_OBJ_PTR_EQ(klass.Get(), method.GetDeclaringClass());
}
for (ArtMethod& method : klass->GetDeclaredVirtualMethods(kRuntimePointerSize)) {
AssertMethod(&method);
EXPECT_FALSE(method.IsDirect());
- EXPECT_EQ(klass.Get(), method.GetDeclaringClass());
+ EXPECT_OBJ_PTR_EQ(klass.Get(), method.GetDeclaringClass());
}
for (ArtMethod& method : klass->GetCopiedMethods(kRuntimePointerSize)) {
@@ -386,7 +387,7 @@
ASSERT_EQ(end_ref_offset.Uint32Value(), current_ref_offset.Uint32Value());
uint32_t total_num_reference_instance_fields = 0;
- mirror::Class* k = klass.Get();
+ ObjPtr<mirror::Class> k = klass.Get();
while (k != nullptr) {
total_num_reference_instance_fields += k->NumReferenceInstanceFields();
k = k->GetSuperClass();
@@ -400,7 +401,7 @@
}
}
- void AssertDexFileClass(mirror::ClassLoader* class_loader, const std::string& descriptor)
+ void AssertDexFileClass(ObjPtr<mirror::ClassLoader> class_loader, const std::string& descriptor)
REQUIRES_SHARED(Locks::mutator_lock_) {
ASSERT_TRUE(descriptor != nullptr);
Thread* self = Thread::Current();
@@ -409,8 +410,8 @@
hs.NewHandle(class_linker_->FindSystemClass(self, descriptor.c_str())));
ASSERT_TRUE(klass != nullptr);
std::string temp;
- EXPECT_STREQ(descriptor.c_str(), klass.Get()->GetDescriptor(&temp));
- EXPECT_EQ(class_loader, klass->GetClassLoader());
+ EXPECT_STREQ(descriptor.c_str(), klass->GetDescriptor(&temp));
+ EXPECT_OBJ_PTR_EQ(class_loader, klass->GetClassLoader());
if (klass->IsPrimitive()) {
AssertPrimitiveClass(descriptor, klass.Get());
} else if (klass->IsArrayClass()) {
@@ -420,7 +421,7 @@
}
}
- void AssertDexFile(const DexFile& dex, mirror::ClassLoader* class_loader)
+ void AssertDexFile(const DexFile& dex, ObjPtr<mirror::ClassLoader> class_loader)
REQUIRES_SHARED(Locks::mutator_lock_) {
// Verify all the classes defined in this file
for (size_t i = 0; i < dex.NumClassDefs(); i++) {
@@ -469,7 +470,7 @@
bool Check() REQUIRES_SHARED(Locks::mutator_lock_) {
Thread* self = Thread::Current();
- mirror::Class* klass =
+ ObjPtr<mirror::Class> klass =
Runtime::Current()->GetClassLinker()->FindSystemClass(self, class_descriptor.c_str());
CHECK(klass != nullptr) << class_descriptor;
@@ -875,12 +876,13 @@
Handle<mirror::ClassLoader> class_loader(
hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Nested"))));
- mirror::Class* outer = class_linker_->FindClass(soa.Self(), "LNested;", class_loader);
+ ObjPtr<mirror::Class> outer = class_linker_->FindClass(soa.Self(), "LNested;", class_loader);
ASSERT_TRUE(outer != nullptr);
EXPECT_EQ(0U, outer->NumVirtualMethods());
EXPECT_EQ(1U, outer->NumDirectMethods());
- mirror::Class* inner = class_linker_->FindClass(soa.Self(), "LNested$Inner;", class_loader);
+ ObjPtr<mirror::Class> inner =
+ class_linker_->FindClass(soa.Self(), "LNested$Inner;", class_loader);
ASSERT_TRUE(inner != nullptr);
EXPECT_EQ(0U, inner->NumVirtualMethods());
EXPECT_EQ(1U, inner->NumDirectMethods());
@@ -902,23 +904,24 @@
TEST_F(ClassLinkerTest, FindClass) {
ScopedObjectAccess soa(Thread::Current());
- mirror::Class* JavaLangObject = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
- AssertObjectClass(JavaLangObject);
+ StackHandleScope<2> hs(soa.Self());
+ Handle<mirror::Class> JavaLangObject = hs.NewHandle(
+ class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"));
+ AssertObjectClass(JavaLangObject.Get());
- StackHandleScope<1> hs(soa.Self());
Handle<mirror::ClassLoader> class_loader(
hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("MyClass"))));
AssertNonExistentClass("LMyClass;");
- mirror::Class* MyClass = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader);
+ ObjPtr<mirror::Class> MyClass = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader);
ASSERT_TRUE(MyClass != nullptr);
ASSERT_TRUE(MyClass->GetClass() != nullptr);
ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
- EXPECT_EQ(JavaLangObject, MyClass->GetClass()->GetSuperClass());
+ EXPECT_OBJ_PTR_EQ(JavaLangObject.Get(), MyClass->GetClass()->GetSuperClass());
std::string temp;
ASSERT_STREQ(MyClass->GetDescriptor(&temp), "LMyClass;");
- EXPECT_TRUE(MyClass->GetSuperClass() == JavaLangObject);
+ EXPECT_OBJ_PTR_EQ(MyClass->GetSuperClass(), JavaLangObject.Get());
EXPECT_TRUE(MyClass->HasSuperClass());
- EXPECT_EQ(class_loader.Get(), MyClass->GetClassLoader());
+ EXPECT_OBJ_PTR_EQ(class_loader.Get(), MyClass->GetClassLoader());
EXPECT_EQ(ClassStatus::kResolved, MyClass->GetStatus());
EXPECT_FALSE(MyClass->IsErroneous());
EXPECT_TRUE(MyClass->IsLoaded());
@@ -1057,8 +1060,9 @@
// start of the object
TEST_F(ClassLinkerTest, ValidateObjectArrayElementsOffset) {
ScopedObjectAccess soa(Thread::Current());
- mirror::Class* array_class = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
- mirror::ObjectArray<mirror::String>* array =
+ ObjPtr<mirror::Class> array_class =
+ class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
+ ObjPtr<mirror::ObjectArray<mirror::String>> array =
mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), array_class, 0);
uintptr_t data_offset =
reinterpret_cast<uintptr_t>(array->GetRawData(sizeof(mirror::HeapReference<mirror::String>),
@@ -1106,7 +1110,7 @@
// This lets UnboxPrimitive avoid searching for the field by name at runtime.
ScopedObjectAccess soa(Thread::Current());
ScopedNullHandle<mirror::ClassLoader> class_loader;
- mirror::Class* c;
+ ObjPtr<mirror::Class> c;
c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Boolean;", class_loader);
EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName());
c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Byte;", class_loader);
@@ -1127,16 +1131,18 @@
TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
ScopedObjectAccess soa(Thread::Current());
- StackHandleScope<2> hs(soa.Self());
+ StackHandleScope<3> hs(soa.Self());
Handle<mirror::ClassLoader> class_loader_1(
hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("MyClass"))));
Handle<mirror::ClassLoader> class_loader_2(
hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("MyClass"))));
- mirror::Class* MyClass_1 = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_1);
- mirror::Class* MyClass_2 = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_2);
+ Handle<mirror::Class> MyClass_1 = hs.NewHandle(
+ class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_1));
+ ObjPtr<mirror::Class> MyClass_2 =
+ class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_2);
EXPECT_TRUE(MyClass_1 != nullptr);
EXPECT_TRUE(MyClass_2 != nullptr);
- EXPECT_NE(MyClass_1, MyClass_2);
+ EXPECT_OBJ_PTR_NE(MyClass_1.Get(), MyClass_2);
}
TEST_F(ClassLinkerTest, StaticFields) {
@@ -1200,7 +1206,7 @@
soa.Self(), statics.Get(), "s8", "Ljava/lang/String;");
EXPECT_EQ(s8->GetTypeAsPrimitiveType(), Primitive::kPrimNot);
EXPECT_TRUE(s8->GetObject(statics.Get())->AsString()->Equals("android"));
- mirror::String* str_value = mirror::String::AllocFromModifiedUtf8(soa.Self(), "robot");
+ ObjPtr<mirror::String> str_value = mirror::String::AllocFromModifiedUtf8(soa.Self(), "robot");
s8->SetObject<false>(s8->GetDeclaringClass(), str_value);
// TODO: Remove EXPECT_FALSE when GCC can handle EXPECT_EQ
@@ -1300,7 +1306,8 @@
StackHandleScope<1> hs(soa.Self());
Handle<mirror::ClassLoader> class_loader(
hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
- mirror::Class* klass = class_linker_->FindClass(soa.Self(), "LStaticsFromCode;", class_loader);
+ ObjPtr<mirror::Class> klass =
+ class_linker_->FindClass(soa.Self(), "LStaticsFromCode;", class_loader);
ArtMethod* clinit = klass->FindClassInitializer(kRuntimePointerSize);
ArtMethod* getS0 =
klass->FindClassMethod("getS0", "()Ljava/lang/Object;", kRuntimePointerSize);
@@ -1345,7 +1352,7 @@
TEST_F(ClassLinkerTest, FinalizableBit) {
ScopedObjectAccess soa(Thread::Current());
- mirror::Class* c;
+ ObjPtr<mirror::Class> c;
// Object has a finalize method, but we know it's empty.
c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
@@ -1381,7 +1388,7 @@
ScopedObjectAccess soa(Thread::Current());
std::string temp;
for (int i = 0; i < ClassLinker::kClassRootsMax; i++) {
- mirror::Class* klass = class_linker_->GetClassRoot(ClassLinker::ClassRoot(i));
+ ObjPtr<mirror::Class> klass = class_linker_->GetClassRoot(ClassLinker::ClassRoot(i));
EXPECT_GT(strlen(klass->GetDescriptor(&temp)), 0U);
EXPECT_STREQ(klass->GetDescriptor(&temp),
class_linker_->GetClassRootDescriptor(ClassLinker::ClassRoot(i))) << " i = " << i;
@@ -1391,7 +1398,7 @@
TEST_F(ClassLinkerTest, ValidatePredefinedClassSizes) {
ScopedObjectAccess soa(Thread::Current());
ScopedNullHandle<mirror::ClassLoader> class_loader;
- mirror::Class* c;
+ ObjPtr<mirror::Class> c;
c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Class;", class_loader);
ASSERT_TRUE(c != nullptr);
@@ -1418,7 +1425,7 @@
}
}
-static void CheckVerificationAttempted(mirror::Class* c, bool preverified)
+static void CheckVerificationAttempted(ObjPtr<mirror::Class> c, bool preverified)
REQUIRES_SHARED(Locks::mutator_lock_) {
EXPECT_EQ((c->GetAccessFlags() & kAccVerificationAttempted) != 0U, preverified)
<< "Class " << mirror::Class::PrettyClass(c) << " not as expected";
@@ -1430,7 +1437,8 @@
TEST_F(ClassLinkerTest, Preverified_InitializedBoot) {
ScopedObjectAccess soa(Thread::Current());
- mirror::Class* JavaLangObject = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
+ ObjPtr<mirror::Class> JavaLangObject =
+ class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
ASSERT_TRUE(JavaLangObject != nullptr);
EXPECT_TRUE(JavaLangObject->IsInitialized()) << "Not testing already initialized class from the "
"core";
@@ -1479,13 +1487,13 @@
Handle<mirror::Class> jlo_class(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
ASSERT_TRUE(jlo_class != nullptr);
- EXPECT_TRUE(jlo_class.Get()->IsBootStrapClassLoaded());
+ EXPECT_TRUE(jlo_class->IsBootStrapClassLoaded());
// Statics is not a bootstrap class.
Handle<mirror::Class> statics(
hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStatics;", class_loader)));
ASSERT_TRUE(statics != nullptr);
- EXPECT_FALSE(statics.Get()->IsBootStrapClassLoaded());
+ EXPECT_FALSE(statics->IsBootStrapClassLoaded());
}
// Regression test for b/26799552.
@@ -1563,13 +1571,13 @@
Handle<mirror::Class> string_class(hs.NewHandle(class_linker_->FindClass(soa.Self(),
"Ljava/lang/String;",
class_loader)));
- ASSERT_EQ(string_class.Get(), method1_type->GetRType());
- ASSERT_EQ(string_class.Get(), method1_type->GetPTypes()->Get(0));
+ ASSERT_OBJ_PTR_EQ(string_class.Get(), method1_type->GetRType());
+ ASSERT_OBJ_PTR_EQ(string_class.Get(), method1_type->GetPTypes()->Get(0));
// Resolve the method type again and assert that we get back the same value.
Handle<mirror::MethodType> method1_type2 = hs.NewHandle(
class_linker_->ResolveMethodType(soa.Self(), method1_id.proto_idx_, dex_cache, class_loader));
- ASSERT_EQ(method1_type.Get(), method1_type2.Get());
+ ASSERT_OBJ_PTR_EQ(method1_type.Get(), method1_type2.Get());
// Resolve the MethodType associated with a different method signature
// and assert it's different.
@@ -1582,7 +1590,7 @@
const DexFile::MethodId& method2_id = dex_file.GetMethodId(method2->GetDexMethodIndex());
Handle<mirror::MethodType> method2_type = hs.NewHandle(
class_linker_->ResolveMethodType(soa.Self(), method2_id.proto_idx_, dex_cache, class_loader));
- ASSERT_TRUE(method1_type.Get() != method2_type.Get());
+ ASSERT_OBJ_PTR_NE(method1_type.Get(), method2_type.Get());
}
// Verify that ClassLinker's CreateWellknownClassLoader works as expected
@@ -1599,18 +1607,18 @@
TEST_F(ClassLinkerTest, PrettyClass) {
ScopedObjectAccess soa(Thread::Current());
EXPECT_EQ("null", mirror::Class::PrettyClass(nullptr));
- mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
+ ObjPtr<mirror::Class> c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
ASSERT_TRUE(c != nullptr);
- mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
+ ObjPtr<mirror::Object> o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
EXPECT_EQ("java.lang.Class<java.lang.String[]>", mirror::Class::PrettyClass(o->GetClass()));
}
TEST_F(ClassLinkerTest, PrettyClassAndClassLoader) {
ScopedObjectAccess soa(Thread::Current());
EXPECT_EQ("null", mirror::Class::PrettyClassAndClassLoader(nullptr));
- mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
+ ObjPtr<mirror::Class> c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
ASSERT_TRUE(c != nullptr);
- mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
+ ObjPtr<mirror::Object> o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
EXPECT_EQ("java.lang.Class<java.lang.String[],null>",
mirror::Class::PrettyClassAndClassLoader(o->GetClass()));
}
@@ -1619,8 +1627,8 @@
ScopedObjectAccess soa(Thread::Current());
EXPECT_EQ("null", ArtField::PrettyField(nullptr));
- mirror::Class* java_lang_String = class_linker_->FindSystemClass(soa.Self(),
- "Ljava/lang/String;");
+ ObjPtr<mirror::Class> java_lang_String = class_linker_->FindSystemClass(soa.Self(),
+ "Ljava/lang/String;");
ArtField* f;
f = java_lang_String->FindDeclaredInstanceField("count", "I");
@@ -1630,7 +1638,7 @@
TEST_F(ClassLinkerTest, JniShortName_JniLongName) {
ScopedObjectAccess soa(Thread::Current());
- mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/String;");
+ ObjPtr<mirror::Class> c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/String;");
ASSERT_TRUE(c != nullptr);
ArtMethod* m;
@@ -1682,7 +1690,7 @@
ASSERT_TRUE(klass != nullptr) << descriptor;
Handle<mirror::ClassLoader> expected_class_loader(
hs.NewHandle(soa.Decode<mirror::ClassLoader>(expected_class_loader_obj)));
- ASSERT_EQ(klass->GetClassLoader(), expected_class_loader.Get());
+ ASSERT_OBJ_PTR_EQ(klass->GetClassLoader(), expected_class_loader.Get());
}
}
};