blob: d5211838300ef09f6ebf89a50799ee0539177d5c [file] [log] [blame]
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001// Copyright 2011 Google Inc. All Rights Reserved.
2
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003#include "common_test.h"
4#include "class_linker.h"
5#include "dex_file.h"
6#include "heap.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007#include "gtest/gtest.h"
8
9namespace art {
10
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070011class ClassLinkerTest : public RuntimeTest {
12 protected:
13 void AssertNonExistantClass(const StringPiece& descriptor) {
Carl Shapiro7a909592011-07-24 19:21:59 -070014 EXPECT_TRUE(class_linker_->FindSystemClass(descriptor) == NULL);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070015 }
16
17 void AssertPrimitiveClass(const StringPiece& descriptor) {
Carl Shapiro7a909592011-07-24 19:21:59 -070018 Class* primitive = class_linker_->FindSystemClass(descriptor);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070019 ASSERT_TRUE(primitive != NULL);
20 ASSERT_TRUE(primitive->GetClass() != NULL);
21 ASSERT_EQ(primitive->GetClass(), primitive->GetClass()->GetClass());
22 EXPECT_TRUE(primitive->GetClass()->GetSuperClass() != NULL);
23 ASSERT_EQ(descriptor, primitive->GetDescriptor());
24 EXPECT_TRUE(primitive->GetSuperClass() == NULL);
25 EXPECT_FALSE(primitive->HasSuperClass());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070026 EXPECT_TRUE(primitive->GetClassLoader() == NULL);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070027 EXPECT_TRUE(primitive->GetComponentType() == NULL);
28 EXPECT_TRUE(primitive->GetStatus() == Class::kStatusInitialized);
29 EXPECT_FALSE(primitive->IsErroneous());
30 EXPECT_TRUE(primitive->IsVerified());
31 EXPECT_TRUE(primitive->IsLinked());
32 EXPECT_FALSE(primitive->IsArray());
33 EXPECT_EQ(0, primitive->array_rank_);
34 EXPECT_FALSE(primitive->IsInterface());
35 EXPECT_TRUE(primitive->IsPublic());
36 EXPECT_TRUE(primitive->IsFinal());
37 EXPECT_TRUE(primitive->IsPrimitive());
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070038 EXPECT_FALSE(primitive->IsSynthetic());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070039 EXPECT_EQ(0U, primitive->NumDirectMethods());
40 EXPECT_EQ(0U, primitive->NumVirtualMethods());
41 EXPECT_EQ(0U, primitive->NumInstanceFields());
42 EXPECT_EQ(0U, primitive->NumStaticFields());
Brian Carlstrom913af1b2011-07-23 21:41:13 -070043 EXPECT_EQ(0U, primitive->NumInterfaces());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070044 }
45
46 void AssertArrayClass(const StringPiece& array_descriptor,
47 int32_t array_rank,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070048 const StringPiece& component_type,
49 ClassLoader* class_loader) {
50 Class* array = class_linker_->FindClass(array_descriptor, class_loader);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070051 ASSERT_TRUE(array != NULL);
52 ASSERT_TRUE(array->GetClass() != NULL);
53 ASSERT_EQ(array->GetClass(), array->GetClass()->GetClass());
54 EXPECT_TRUE(array->GetClass()->GetSuperClass() != NULL);
55 ASSERT_EQ(array_descriptor, array->GetDescriptor());
56 EXPECT_TRUE(array->GetSuperClass() != NULL);
Carl Shapiro7a909592011-07-24 19:21:59 -070057 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/lang/Object;"), array->GetSuperClass());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070058 EXPECT_TRUE(array->HasSuperClass());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070059 EXPECT_EQ(class_loader, array->GetClassLoader());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070060 ASSERT_TRUE(array->GetComponentType() != NULL);
61 ASSERT_TRUE(array->GetComponentType()->GetDescriptor() != NULL);
62 EXPECT_EQ(component_type, array->GetComponentType()->GetDescriptor());
63 EXPECT_TRUE(array->GetStatus() == Class::kStatusInitialized);
64 EXPECT_FALSE(array->IsErroneous());
65 EXPECT_TRUE(array->IsVerified());
66 EXPECT_TRUE(array->IsLinked());
67 EXPECT_TRUE(array->IsArray());
68 EXPECT_EQ(array_rank, array->array_rank_);
69 EXPECT_FALSE(array->IsInterface());
70 EXPECT_EQ(array->GetComponentType()->IsPublic(), array->IsPublic());
71 EXPECT_TRUE(array->IsFinal());
72 EXPECT_FALSE(array->IsPrimitive());
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070073 EXPECT_FALSE(array->IsSynthetic());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070074 EXPECT_EQ(0U, array->NumDirectMethods());
75 EXPECT_EQ(0U, array->NumVirtualMethods());
76 EXPECT_EQ(0U, array->NumInstanceFields());
77 EXPECT_EQ(0U, array->NumStaticFields());
Brian Carlstrom913af1b2011-07-23 21:41:13 -070078 EXPECT_EQ(2U, array->NumInterfaces());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070079 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -070080
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070081 void AssertDexFileClass(ClassLoader* class_loader, const char* descriptor) {
Brian Carlstromae3ac012011-07-27 01:30:28 -070082 ASSERT_TRUE(descriptor != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070083 Class* klass = class_linker_->FindSystemClass(descriptor);
Brian Carlstromae3ac012011-07-27 01:30:28 -070084 ASSERT_TRUE(klass != NULL);
85 EXPECT_EQ(descriptor, klass->GetDescriptor());
86 if (klass->descriptor_ == "Ljava/lang/Object;") {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070087 EXPECT_FALSE(klass->HasSuperClass());
Brian Carlstromae3ac012011-07-27 01:30:28 -070088 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070089 EXPECT_TRUE(klass->HasSuperClass());
90 EXPECT_TRUE(klass->GetSuperClass() != NULL);
Brian Carlstromae3ac012011-07-27 01:30:28 -070091 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070092 EXPECT_EQ(class_loader, klass->GetClassLoader());
Brian Carlstromae3ac012011-07-27 01:30:28 -070093 EXPECT_TRUE(klass->GetDexCache() != NULL);
94 EXPECT_TRUE(klass->GetComponentType() == NULL);
95 EXPECT_TRUE(klass->GetComponentType() == NULL);
96 EXPECT_EQ(Class::kStatusResolved, klass->GetStatus());
97 EXPECT_FALSE(klass->IsErroneous());
98 EXPECT_FALSE(klass->IsVerified());
99 EXPECT_TRUE(klass->IsLinked());
100 EXPECT_TRUE(klass->IsLoaded());
101 EXPECT_TRUE(klass->IsInSamePackage(klass));
102 EXPECT_TRUE(Class::IsInSamePackage(klass->GetDescriptor(), klass->GetDescriptor()));
103 if (klass->IsInterface()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700104 EXPECT_TRUE(klass->IsAbstract());
105 if (klass->NumDirectMethods() == 1) {
106 EXPECT_PRED2(String::EqualsUtf8, klass->GetDirectMethod(0)->GetName(), "<clinit>");
107 } else {
108 EXPECT_EQ(0U, klass->NumDirectMethods());
109 }
Brian Carlstromae3ac012011-07-27 01:30:28 -0700110 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700111 if (!klass->IsSynthetic()) {
112 EXPECT_NE(0U, klass->NumDirectMethods());
113 }
Brian Carlstromae3ac012011-07-27 01:30:28 -0700114 }
115 if (klass->IsAbstract()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700116 EXPECT_FALSE(klass->IsFinal());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700117 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700118 EXPECT_FALSE(klass->IsAnnotation());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700119 }
120 if (klass->IsFinal()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700121 EXPECT_FALSE(klass->IsAbstract());
122 EXPECT_FALSE(klass->IsAnnotation());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700123 }
124 if (klass->IsAnnotation()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700125 EXPECT_FALSE(klass->IsFinal());
126 EXPECT_TRUE(klass->IsAbstract());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700127 }
128
129 EXPECT_FALSE(klass->IsPrimitive());
130 EXPECT_TRUE(klass->CanAccess(klass));
131
132 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700133 Method* method = klass->GetDirectMethod(i);
134 EXPECT_TRUE(method != NULL);
Brian Carlstromae3ac012011-07-27 01:30:28 -0700135 }
136
137 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700138 Method* method = klass->GetVirtualMethod(i);
139 EXPECT_TRUE(method != NULL);
Brian Carlstromae3ac012011-07-27 01:30:28 -0700140 }
141
142 for (size_t i = 0; i < klass->NumInstanceFields(); i++) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700143 InstanceField* field = klass->GetInstanceField(i);
144 EXPECT_TRUE(field != NULL);
Brian Carlstromae3ac012011-07-27 01:30:28 -0700145 }
146
147 for (size_t i = 0; i < klass->NumStaticFields(); i++) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700148 StaticField* field = klass->GetStaticField(i);
149 EXPECT_TRUE(field != NULL);
Brian Carlstromae3ac012011-07-27 01:30:28 -0700150 }
151
152 // Confirm that all instances fields are packed together at the start
153 EXPECT_GE(klass->NumInstanceFields(), klass->NumReferenceInstanceFields());
154 for (size_t i = 0; i < klass->NumReferenceInstanceFields(); i++) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700155 InstanceField* field = klass->GetInstanceField(i);
156 ASSERT_TRUE(field != NULL);
157 ASSERT_TRUE(field->GetDescriptor() != NULL);
158 Class* field_type = class_linker_->FindClass(field->GetDescriptor(), class_loader);
159 ASSERT_TRUE(field_type != NULL);
160 EXPECT_FALSE(field_type->IsPrimitive());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700161 }
162 for (size_t i = klass->NumReferenceInstanceFields(); i < klass->NumInstanceFields(); i++) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700163 InstanceField* field = klass->GetInstanceField(i);
164 ASSERT_TRUE(field != NULL);
165 ASSERT_TRUE(field->GetDescriptor() != NULL);
166 Class* field_type = class_linker_->FindClass(field->GetDescriptor(), class_loader);
167 ASSERT_TRUE(field_type != NULL);
168 EXPECT_TRUE(field_type->IsPrimitive());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700169 }
170
171 size_t total_num_reference_instance_fields = 0;
172 Class* k = klass;
173 while (k != NULL) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700174 total_num_reference_instance_fields += k->NumReferenceInstanceFields();
175 k = k->GetSuperClass();
Brian Carlstromae3ac012011-07-27 01:30:28 -0700176 }
177 EXPECT_EQ(klass->GetReferenceOffsets() == 0,
178 total_num_reference_instance_fields == 0);
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700179 }
180
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700181 static void TestRootVisitor(Object* root, void* arg) {
182 EXPECT_TRUE(root != NULL);
183 }
184
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700185 void AssertDexFile(const DexFile* dex, ClassLoader* class_loader) {
Brian Carlstromae3ac012011-07-27 01:30:28 -0700186 ASSERT_TRUE(dex != NULL);
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700187 for (size_t i = 0; i < dex->NumClassDefs(); i++) {
188 const DexFile::ClassDef class_def = dex->GetClassDef(i);
189 const char* descriptor = dex->GetClassDescriptor(class_def);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700190 AssertDexFileClass(class_loader, descriptor);
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700191 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700192 class_linker_->VisitRoots(TestRootVisitor, NULL);
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700193 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700194};
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700195
196TEST_F(ClassLinkerTest, FindClassNonexistent) {
Carl Shapiro7a909592011-07-24 19:21:59 -0700197 Class* result1 = class_linker_->FindSystemClass("NoSuchClass;");
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700198 EXPECT_TRUE(result1 == NULL);
Carl Shapiro7a909592011-07-24 19:21:59 -0700199 Class* result2 = class_linker_->FindSystemClass("LNoSuchClass;");
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700200 EXPECT_TRUE(result2 == NULL);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700201}
202
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700203TEST_F(ClassLinkerTest, FindClassNested) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700204 scoped_ptr<DexFile> dex(OpenDexFileBase64(kNestedDex));
205 PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Brian Carlstrom934486c2011-07-12 23:42:50 -0700206
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700207 Class* outer = class_linker_->FindClass("LNested;", class_loader);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700208 ASSERT_TRUE(outer != NULL);
209 EXPECT_EQ(0U, outer->NumVirtualMethods());
210 EXPECT_EQ(1U, outer->NumDirectMethods());
Brian Carlstrom934486c2011-07-12 23:42:50 -0700211
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700212 Class* inner = class_linker_->FindClass("LNested$Inner;", class_loader);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700213 ASSERT_TRUE(inner != NULL);
214 EXPECT_EQ(0U, inner->NumVirtualMethods());
215 EXPECT_EQ(1U, inner->NumDirectMethods());
Brian Carlstrom934486c2011-07-12 23:42:50 -0700216}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700217
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700218TEST_F(ClassLinkerTest, FindClass) {
Carl Shapiro7a909592011-07-24 19:21:59 -0700219 ClassLinker* linker = class_linker_;
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700220
221 StringPiece expected = "BCDFIJSZV";
222 for (int ch = 0; ch < 255; ch++) {
223 char* s = reinterpret_cast<char*>(&ch);
224 StringPiece descriptor(s, 1);
225 if (expected.find(ch) == StringPiece::npos) {
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700226 AssertNonExistantClass(descriptor);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700227 } else {
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700228 AssertPrimitiveClass(descriptor);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700229 }
230 }
Elliott Hughesa5780da2011-07-17 11:39:39 -0700231
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700232 Class* JavaLangObject = linker->FindSystemClass("Ljava/lang/Object;");
Brian Carlstrom934486c2011-07-12 23:42:50 -0700233 ASSERT_TRUE(JavaLangObject != NULL);
Brian Carlstroma0808032011-07-18 00:39:23 -0700234 ASSERT_TRUE(JavaLangObject->GetClass() != NULL);
235 ASSERT_EQ(JavaLangObject->GetClass(), JavaLangObject->GetClass()->GetClass());
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700236 EXPECT_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass());
Brian Carlstrom934486c2011-07-12 23:42:50 -0700237 ASSERT_TRUE(JavaLangObject->GetDescriptor() == "Ljava/lang/Object;");
238 EXPECT_TRUE(JavaLangObject->GetSuperClass() == NULL);
239 EXPECT_FALSE(JavaLangObject->HasSuperClass());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700240 EXPECT_TRUE(JavaLangObject->GetClassLoader() == NULL);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700241 EXPECT_TRUE(JavaLangObject->GetComponentType() == NULL);
242 EXPECT_FALSE(JavaLangObject->IsErroneous());
243 EXPECT_FALSE(JavaLangObject->IsVerified());
244 EXPECT_TRUE(JavaLangObject->IsLinked());
245 EXPECT_FALSE(JavaLangObject->IsArray());
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700246 EXPECT_EQ(0, JavaLangObject->array_rank_);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700247 EXPECT_FALSE(JavaLangObject->IsInterface());
248 EXPECT_TRUE(JavaLangObject->IsPublic());
249 EXPECT_FALSE(JavaLangObject->IsFinal());
250 EXPECT_FALSE(JavaLangObject->IsPrimitive());
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700251 EXPECT_FALSE(JavaLangObject->IsSynthetic());
Carl Shapirof10edca2011-07-14 23:16:21 -0700252 EXPECT_EQ(1U, JavaLangObject->NumDirectMethods());
253 EXPECT_EQ(0U, JavaLangObject->NumVirtualMethods());
254 EXPECT_EQ(0U, JavaLangObject->NumInstanceFields());
255 EXPECT_EQ(0U, JavaLangObject->NumStaticFields());
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700256 EXPECT_EQ(0U, JavaLangObject->NumInterfaces());
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700257
Brian Carlstrom934486c2011-07-12 23:42:50 -0700258
Brian Carlstromf615a612011-07-23 12:50:34 -0700259 scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassDex));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700260 PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700261 EXPECT_TRUE(linker->FindSystemClass("LMyClass;") == NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700262 Class* MyClass = linker->FindClass("LMyClass;", class_loader);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700263 ASSERT_TRUE(MyClass != NULL);
Brian Carlstroma0808032011-07-18 00:39:23 -0700264 ASSERT_TRUE(MyClass->GetClass() != NULL);
265 ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700266 EXPECT_EQ(JavaLangObject, MyClass->GetClass()->GetSuperClass());
Brian Carlstrom934486c2011-07-12 23:42:50 -0700267 ASSERT_TRUE(MyClass->GetDescriptor() == "LMyClass;");
268 EXPECT_TRUE(MyClass->GetSuperClass() == JavaLangObject);
269 EXPECT_TRUE(MyClass->HasSuperClass());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700270 EXPECT_EQ(class_loader, MyClass->GetClassLoader());
Brian Carlstrom934486c2011-07-12 23:42:50 -0700271 EXPECT_TRUE(MyClass->GetComponentType() == NULL);
272 EXPECT_TRUE(MyClass->GetStatus() == Class::kStatusResolved);
273 EXPECT_FALSE(MyClass->IsErroneous());
274 EXPECT_FALSE(MyClass->IsVerified());
275 EXPECT_TRUE(MyClass->IsLinked());
276 EXPECT_FALSE(MyClass->IsArray());
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700277 EXPECT_EQ(0, JavaLangObject->array_rank_);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700278 EXPECT_FALSE(MyClass->IsInterface());
279 EXPECT_FALSE(MyClass->IsPublic());
280 EXPECT_FALSE(MyClass->IsFinal());
281 EXPECT_FALSE(MyClass->IsPrimitive());
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700282 EXPECT_FALSE(MyClass->IsSynthetic());
Carl Shapirof10edca2011-07-14 23:16:21 -0700283 EXPECT_EQ(1U, MyClass->NumDirectMethods());
284 EXPECT_EQ(0U, MyClass->NumVirtualMethods());
285 EXPECT_EQ(0U, MyClass->NumInstanceFields());
286 EXPECT_EQ(0U, MyClass->NumStaticFields());
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700287 EXPECT_EQ(0U, MyClass->NumInterfaces());
Brian Carlstroma0808032011-07-18 00:39:23 -0700288
289 EXPECT_EQ(JavaLangObject->GetClass()->GetClass(), MyClass->GetClass()->GetClass());
290
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700291 // created by class_linker
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700292 AssertArrayClass("[C", 1, "C", NULL);
293 AssertArrayClass("[Ljava/lang/Object;", 1, "Ljava/lang/Object;", NULL);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700294 // synthesized on the fly
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700295 AssertArrayClass("[[C", 2, "C", NULL);
296 AssertArrayClass("[[[LMyClass;", 3, "LMyClass;", class_loader);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700297 // or not available at all
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700298 AssertNonExistantClass("[[[[LNonExistantClass;");
299}
300
301TEST_F(ClassLinkerTest, ProtoCompare) {
Carl Shapiro7a909592011-07-24 19:21:59 -0700302 ClassLinker* linker = class_linker_;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700303
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700304 scoped_ptr<DexFile> dex(OpenDexFileBase64(kProtoCompareDex));
305 PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700306
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700307 Class* klass = linker->FindClass("LProtoCompare;", class_loader);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700308 ASSERT_TRUE(klass != NULL);
309
310 ASSERT_EQ(4U, klass->NumVirtualMethods());
311
312 Method* m1 = klass->GetVirtualMethod(0);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700313 EXPECT_PRED2(String::EqualsUtf8, m1->GetName(), "m1");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700314
315 Method* m2 = klass->GetVirtualMethod(1);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700316 EXPECT_PRED2(String::EqualsUtf8, m2->GetName(), "m2");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700317
318 Method* m3 = klass->GetVirtualMethod(2);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700319 EXPECT_PRED2(String::EqualsUtf8, m3->GetName(), "m3");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700320
321 Method* m4 = klass->GetVirtualMethod(3);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700322 EXPECT_PRED2(String::EqualsUtf8, m4->GetName(), "m4");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700323
324 EXPECT_TRUE(linker->HasSameReturnType(m1, m2));
325 EXPECT_TRUE(linker->HasSameReturnType(m2, m1));
326
327 EXPECT_TRUE(linker->HasSameReturnType(m1, m2));
328 EXPECT_TRUE(linker->HasSameReturnType(m2, m1));
329
330 EXPECT_FALSE(linker->HasSameReturnType(m1, m4));
331 EXPECT_FALSE(linker->HasSameReturnType(m4, m1));
332
333 EXPECT_TRUE(linker->HasSameArgumentTypes(m1, m2));
334 EXPECT_TRUE(linker->HasSameArgumentTypes(m2, m1));
335
336 EXPECT_FALSE(linker->HasSameArgumentTypes(m1, m3));
337 EXPECT_FALSE(linker->HasSameArgumentTypes(m3, m1));
338
339 EXPECT_FALSE(linker->HasSameArgumentTypes(m1, m4));
340 EXPECT_FALSE(linker->HasSameArgumentTypes(m4, m1));
341
342 EXPECT_TRUE(linker->HasSamePrototype(m1, m2));
343 EXPECT_TRUE(linker->HasSamePrototype(m2, m1));
344
345 EXPECT_FALSE(linker->HasSamePrototype(m1, m3));
346 EXPECT_FALSE(linker->HasSamePrototype(m3, m1));
347
348 EXPECT_FALSE(linker->HasSamePrototype(m3, m4));
349 EXPECT_FALSE(linker->HasSamePrototype(m4, m3));
350
351 EXPECT_FALSE(linker->HasSameName(m1, m2));
352 EXPECT_FALSE(linker->HasSameNameAndPrototype(m1, m2));
353}
354
355TEST_F(ClassLinkerTest, ProtoCompare2) {
Carl Shapiro7a909592011-07-24 19:21:59 -0700356 ClassLinker* linker = class_linker_;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700357
Brian Carlstromf615a612011-07-23 12:50:34 -0700358 scoped_ptr<DexFile> proto1_dex_file(OpenDexFileBase64(kProtoCompareDex));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700359 PathClassLoader* class_loader_1 = AllocPathClassLoader(proto1_dex_file.get());
Brian Carlstromf615a612011-07-23 12:50:34 -0700360 scoped_ptr<DexFile> proto2_dex_file(OpenDexFileBase64(kProtoCompare2Dex));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700361 PathClassLoader* class_loader_2 = AllocPathClassLoader(proto2_dex_file.get());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700362
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700363 Class* klass1 = linker->FindClass("LProtoCompare;", class_loader_1);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700364 ASSERT_TRUE(klass1 != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700365 Class* klass2 = linker->FindClass("LProtoCompare2;", class_loader_2);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700366 ASSERT_TRUE(klass2 != NULL);
367
368 Method* m1_1 = klass1->GetVirtualMethod(0);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700369 EXPECT_PRED2(String::EqualsUtf8, m1_1->GetName(), "m1");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700370 Method* m2_1 = klass1->GetVirtualMethod(1);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700371 EXPECT_PRED2(String::EqualsUtf8, m2_1->GetName(), "m2");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700372 Method* m3_1 = klass1->GetVirtualMethod(2);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700373 EXPECT_PRED2(String::EqualsUtf8, m3_1->GetName(), "m3");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700374 Method* m4_1 = klass1->GetVirtualMethod(3);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700375 EXPECT_PRED2(String::EqualsUtf8, m4_1->GetName(), "m4");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700376
377 Method* m1_2 = klass2->GetVirtualMethod(0);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700378 EXPECT_PRED2(String::EqualsUtf8, m1_2->GetName(), "m1");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700379 Method* m2_2 = klass2->GetVirtualMethod(1);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700380 EXPECT_PRED2(String::EqualsUtf8, m2_2->GetName(), "m2");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700381 Method* m3_2 = klass2->GetVirtualMethod(2);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700382 EXPECT_PRED2(String::EqualsUtf8, m3_2->GetName(), "m3");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700383 Method* m4_2 = klass2->GetVirtualMethod(3);
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700384 EXPECT_PRED2(String::EqualsUtf8, m4_2->GetName(), "m4");
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700385
386 EXPECT_TRUE(linker->HasSameNameAndPrototype(m1_1, m1_2));
387 EXPECT_TRUE(linker->HasSameNameAndPrototype(m1_2, m1_1));
388
389 EXPECT_TRUE(linker->HasSameNameAndPrototype(m2_1, m2_2));
390 EXPECT_TRUE(linker->HasSameNameAndPrototype(m2_2, m2_1));
391
392 EXPECT_TRUE(linker->HasSameNameAndPrototype(m3_1, m3_2));
393 EXPECT_TRUE(linker->HasSameNameAndPrototype(m3_2, m3_1));
394
395 EXPECT_TRUE(linker->HasSameNameAndPrototype(m4_1, m4_2));
396 EXPECT_TRUE(linker->HasSameNameAndPrototype(m4_2, m4_1));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700397}
398
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700399TEST_F(ClassLinkerTest, LibCore) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700400 UseLibCoreDex();
Jesse Wilsonac5b9e22011-07-27 15:11:13 -0400401 scoped_ptr<DexFile> libcore_dex_file(GetLibCoreDex());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700402 EXPECT_TRUE(libcore_dex_file.get() != NULL);
403 AssertDexFile(libcore_dex_file.get(), NULL);
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700404}
405
Jesse Wilson46cdd4b2011-07-28 17:40:48 -0400406// C++ fields must exactly match the fields in the Java classes. If this fails,
Jesse Wilsonac5b9e22011-07-27 15:11:13 -0400407// reorder the fields in the C++ class. Managed class fields are ordered by
408// ClassLinker::LinkInstanceFields.
Jesse Wilson46cdd4b2011-07-28 17:40:48 -0400409TEST_F(ClassLinkerTest, ValidateFieldOrderOfJavaCppUnionClasses) {
410 UseLibCoreDex();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700411 Class* string = class_linker_->FindSystemClass( "Ljava/lang/String;");
Jesse Wilson46cdd4b2011-07-28 17:40:48 -0400412 ASSERT_EQ(4U, string->NumInstanceFields());
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700413 EXPECT_PRED2(String::EqualsUtf8, string->GetInstanceField(0)->GetName(), "value");
414 EXPECT_PRED2(String::EqualsUtf8, string->GetInstanceField(1)->GetName(), "hashCode");
415 EXPECT_PRED2(String::EqualsUtf8, string->GetInstanceField(2)->GetName(), "offset");
416 EXPECT_PRED2(String::EqualsUtf8, string->GetInstanceField(3)->GetName(), "count");
Jesse Wilson46cdd4b2011-07-28 17:40:48 -0400417
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700418 Class* accessible_object = class_linker_->FindSystemClass("Ljava/lang/reflect/AccessibleObject;");
Jesse Wilson46cdd4b2011-07-28 17:40:48 -0400419 ASSERT_EQ(1U, accessible_object->NumInstanceFields());
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700420 EXPECT_PRED2(String::EqualsUtf8, accessible_object->GetInstanceField(0)->GetName(), "flag");
Jesse Wilson46cdd4b2011-07-28 17:40:48 -0400421
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700422 Class* field = class_linker_->FindSystemClass("Ljava/lang/reflect/Field;");
Jesse Wilson46cdd4b2011-07-28 17:40:48 -0400423 ASSERT_EQ(6U, field->NumInstanceFields());
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700424 EXPECT_PRED2(String::EqualsUtf8, field->GetInstanceField(0)->GetName(), "declaringClass");
425 EXPECT_PRED2(String::EqualsUtf8, field->GetInstanceField(1)->GetName(), "genericType");
426 EXPECT_PRED2(String::EqualsUtf8, field->GetInstanceField(2)->GetName(), "type");
427 EXPECT_PRED2(String::EqualsUtf8, field->GetInstanceField(3)->GetName(), "name");
428 EXPECT_PRED2(String::EqualsUtf8, field->GetInstanceField(4)->GetName(), "slot");
429 EXPECT_PRED2(String::EqualsUtf8, field->GetInstanceField(5)->GetName(), "genericTypesAreInitialized");
Jesse Wilson46cdd4b2011-07-28 17:40:48 -0400430
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700431 Class* method = class_linker_->FindSystemClass("Ljava/lang/reflect/Method;");
Jesse Wilson46cdd4b2011-07-28 17:40:48 -0400432 ASSERT_EQ(11U, method->NumInstanceFields());
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700433 EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 0)->GetName(), "declaringClass");
434 EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 1)->GetName(), "exceptionTypes");
435 EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 2)->GetName(), "formalTypeParameters");
436 EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 3)->GetName(), "genericExceptionTypes");
437 EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 4)->GetName(), "genericParameterTypes");
438 EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 5)->GetName(), "genericReturnType");
439 EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 6)->GetName(), "returnType");
440 EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 7)->GetName(), "name");
441 EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 8)->GetName(), "parameterTypes");
442 EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField( 9)->GetName(), "genericTypesAreInitialized");
443 EXPECT_PRED2(String::EqualsUtf8, method->GetInstanceField(10)->GetName(), "slot");
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700444
445 Class* class_loader = class_linker_->FindSystemClass("Ljava/lang/ClassLoader;");
446 ASSERT_EQ(2U, class_loader->NumInstanceFields());
447 EXPECT_PRED2(String::EqualsUtf8, class_loader->GetInstanceField(0)->GetName(), "packages");
448 EXPECT_PRED2(String::EqualsUtf8, class_loader->GetInstanceField(1)->GetName(), "parent");
449
450 Class* dex_base_class_loader = class_linker_->FindSystemClass("Ldalvik/system/BaseDexClassLoader;");
451 ASSERT_EQ(2U, dex_base_class_loader->NumInstanceFields());
452 EXPECT_PRED2(String::EqualsUtf8, dex_base_class_loader->GetInstanceField(0)->GetName(), "originalPath");
453 EXPECT_PRED2(String::EqualsUtf8, dex_base_class_loader->GetInstanceField(1)->GetName(), "pathList");
454}
455
456TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
457 scoped_ptr<DexFile> dex_1(OpenDexFileBase64(kMyClassDex));
458 scoped_ptr<DexFile> dex_2(OpenDexFileBase64(kMyClassDex));
459 PathClassLoader* class_loader_1 = AllocPathClassLoader(dex_1.get());
460 PathClassLoader* class_loader_2 = AllocPathClassLoader(dex_2.get());
461 Class* MyClass_1 = class_linker_->FindClass("LMyClass;", class_loader_1);
462 Class* MyClass_2 = class_linker_->FindClass("LMyClass;", class_loader_2);
463 EXPECT_TRUE(MyClass_1 != NULL);
464 EXPECT_TRUE(MyClass_2 != NULL);
465 EXPECT_NE(MyClass_1, MyClass_2);
Jesse Wilsonac5b9e22011-07-27 15:11:13 -0400466}
467
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700468} // namespace art