blob: 79a1f2da4bb451fb0fb9610b172c936045cfe476 [file] [log] [blame]
Carl Shapiro894d0fa2011-06-30 14:48:49 -07001// Copyright 2011 Google Inc. All Rights Reserved.
Carl Shapiro894d0fa2011-06-30 14:48:49 -07002
Elliott Hughes90a33692011-08-30 13:27:07 -07003#include "object.h"
4
5#include <stdint.h>
6#include <stdio.h>
7
8#include "UniquePtr.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07009#include "class_linker.h"
10#include "common_test.h"
11#include "dex_file.h"
12#include "heap.h"
Carl Shapiro894d0fa2011-06-30 14:48:49 -070013
14namespace art {
15
Brian Carlstromf734cf52011-08-17 16:28:14 -070016class ObjectTest : public CommonTest {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070017 protected:
Elliott Hughes814e4032011-08-23 12:07:56 -070018 void AssertString(int32_t length,
Brian Carlstrom0b138b22011-07-27 15:19:17 -070019 const char* utf8_in,
20 const char* utf16_expected_le,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070021 int32_t expected_hash) {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070022 uint16_t utf16_expected[length];
Elliott Hughes814e4032011-08-23 12:07:56 -070023 for (int32_t i = 0; i < length; i++) {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070024 uint16_t ch = (((utf16_expected_le[i*2 + 0] & 0xff) << 8) |
25 ((utf16_expected_le[i*2 + 1] & 0xff) << 0));
26 utf16_expected[i] = ch;
27 }
28
Jesse Wilson8989d992011-08-02 13:39:42 -070029 String* string = String::AllocFromModifiedUtf8(length, utf8_in);
Carl Shapiro8860c0e2011-08-04 17:36:16 -070030 ASSERT_EQ(length, string->GetLength());
31 ASSERT_TRUE(string->GetCharArray() != NULL);
Jesse Wilsonfd687c52011-08-04 19:27:35 -070032 ASSERT_TRUE(string->GetCharArray()->GetData() != NULL);
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -040033 // strlen is necessary because the 1-character string "\0" is interpreted as ""
Elliott Hughes814e4032011-08-23 12:07:56 -070034 ASSERT_TRUE(string->Equals(utf8_in) || length != static_cast<int32_t>(strlen(utf8_in)));
35 for (int32_t i = 0; i < length; i++) {
Jesse Wilsonfd687c52011-08-04 19:27:35 -070036 EXPECT_EQ(utf16_expected[i], string->CharAt(i));
Brian Carlstrom0b138b22011-07-27 15:19:17 -070037 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070038 EXPECT_EQ(expected_hash, string->GetHashCode());
Brian Carlstrom0b138b22011-07-27 15:19:17 -070039 }
Brian Carlstromb63ec392011-08-27 17:38:27 -070040
41 uint32_t FindTypeIdxByDescriptor(const DexFile& dex_file, const StringPiece& descriptor) {
42 for (size_t i = 0; i < dex_file.NumTypeIds(); i++) {
43 const DexFile::TypeId& type_id = dex_file.GetTypeId(i);
44 if (descriptor == dex_file.GetTypeDescriptor(type_id)) {
45 return i;
46 }
47 }
48 CHECK(false) << "Could not find type index for " << descriptor;
49 return 0;
50 }
51
Brian Carlstromb9edb842011-08-28 16:31:06 -070052 uint32_t FindFieldIdxByDescriptorAndName(const DexFile& dex_file,
53 const StringPiece& class_descriptor,
54 const StringPiece& field_name) {
55 for (size_t i = 0; i < dex_file.NumFieldIds(); i++) {
56 const DexFile::FieldId& field_id = dex_file.GetFieldId(i);
57 if (class_descriptor == dex_file.GetFieldClassDescriptor(field_id)
58 && field_name == dex_file.GetFieldName(field_id)) {
59 return i;
60 }
61 }
62 CHECK(false) << "Could not find field index for " << class_descriptor << " " << field_name;
63 return 0;
64 }
Brian Carlstrom0b138b22011-07-27 15:19:17 -070065};
Brian Carlstroma331b3c2011-07-18 17:47:56 -070066
67TEST_F(ObjectTest, IsInSamePackage) {
Carl Shapiro894d0fa2011-06-30 14:48:49 -070068 // Matches
Brian Carlstrom9cff8e12011-08-18 16:47:29 -070069 EXPECT_TRUE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("Ljava/lang/Object;"),
70 String::AllocFromModifiedUtf8("Ljava/lang/Class")));
71 EXPECT_TRUE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("LFoo;"),
72 String::AllocFromModifiedUtf8("LBar;")));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070073
74 // Mismatches
Brian Carlstrom9cff8e12011-08-18 16:47:29 -070075 EXPECT_FALSE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("Ljava/lang/Object;"),
76 String::AllocFromModifiedUtf8("Ljava/io/File;")));
77 EXPECT_FALSE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("Ljava/lang/Object;"),
78 String::AllocFromModifiedUtf8("Ljava/lang/reflect/Method;")));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070079}
80
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070081TEST_F(ObjectTest, AllocObjectArray) {
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070082 ObjectArray<Object>* oa = class_linker_->AllocObjectArray<Object>(2);
Elliott Hughesd8ddfd52011-08-15 14:32:53 -070083 EXPECT_EQ(2, oa->GetLength());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070084 EXPECT_TRUE(oa->Get(0) == NULL);
85 EXPECT_TRUE(oa->Get(1) == NULL);
86 oa->Set(0, oa);
87 EXPECT_TRUE(oa->Get(0) == oa);
88 EXPECT_TRUE(oa->Get(1) == NULL);
89 oa->Set(1, oa);
90 EXPECT_TRUE(oa->Get(0) == oa);
91 EXPECT_TRUE(oa->Get(1) == oa);
92
Elliott Hughes710a0cb2011-08-16 14:32:37 -070093 Thread* self = Thread::Current();
94 Class* aioobe = class_linker_->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
95
96 EXPECT_TRUE(oa->Get(-1) == NULL);
97 EXPECT_TRUE(self->IsExceptionPending());
98 EXPECT_EQ(aioobe, self->GetException()->GetClass());
99 self->ClearException();
100
101 EXPECT_TRUE(oa->Get(2) == NULL);
102 EXPECT_TRUE(self->IsExceptionPending());
103 EXPECT_EQ(aioobe, self->GetException()->GetClass());
104 self->ClearException();
105
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700106 ASSERT_TRUE(oa->GetClass() != NULL);
107 ASSERT_EQ(2U, oa->GetClass()->NumInterfaces());
108 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/lang/Cloneable;"),
109 oa->GetClass()->GetInterface(0));
110 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/io/Serializable;"),
111 oa->GetClass()->GetInterface(1));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700112}
113
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700114TEST_F(ObjectTest, AllocArray) {
115 Class* c = class_linker_->FindSystemClass("[I");
116 Array* a = Array::Alloc(c, 1);
117 ASSERT_TRUE(c == a->GetClass());
118
119 c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
120 a = Array::Alloc(c, 1);
121 ASSERT_TRUE(c == a->GetClass());
122
123 c = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
124 a = Array::Alloc(c, 1);
125 ASSERT_TRUE(c == a->GetClass());
126}
127
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700128template<typename ArrayT>
129void TestPrimitiveArray(ClassLinker* cl) {
130 typedef typename ArrayT::ElementType T;
131
132 ArrayT* a = ArrayT::Alloc(2);
133 EXPECT_EQ(2, a->GetLength());
134 EXPECT_EQ(0, a->Get(0));
135 EXPECT_EQ(0, a->Get(1));
136 a->Set(0, T(123));
137 EXPECT_EQ(T(123), a->Get(0));
138 EXPECT_EQ(0, a->Get(1));
139 a->Set(1, T(321));
140 EXPECT_EQ(T(123), a->Get(0));
141 EXPECT_EQ(T(321), a->Get(1));
142
143 Thread* self = Thread::Current();
144 Class* aioobe = cl->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
145
146 EXPECT_EQ(0, a->Get(-1));
147 EXPECT_TRUE(self->IsExceptionPending());
148 EXPECT_EQ(aioobe, self->GetException()->GetClass());
149 self->ClearException();
150
151 EXPECT_EQ(0, a->Get(2));
152 EXPECT_TRUE(self->IsExceptionPending());
153 EXPECT_EQ(aioobe, self->GetException()->GetClass());
154 self->ClearException();
155}
156
157TEST_F(ObjectTest, PrimitiveArray_Boolean_Alloc) {
158 TestPrimitiveArray<BooleanArray>(class_linker_);
159}
160TEST_F(ObjectTest, PrimitiveArray_Byte_Alloc) {
161 TestPrimitiveArray<ByteArray>(class_linker_);
162}
163TEST_F(ObjectTest, PrimitiveArray_Char_Alloc) {
164 TestPrimitiveArray<CharArray>(class_linker_);
165}
166TEST_F(ObjectTest, PrimitiveArray_Double_Alloc) {
167 TestPrimitiveArray<DoubleArray>(class_linker_);
168}
169TEST_F(ObjectTest, PrimitiveArray_Float_Alloc) {
170 TestPrimitiveArray<FloatArray>(class_linker_);
171}
172TEST_F(ObjectTest, PrimitiveArray_Int_Alloc) {
173 TestPrimitiveArray<IntArray>(class_linker_);
174}
175TEST_F(ObjectTest, PrimitiveArray_Long_Alloc) {
176 TestPrimitiveArray<LongArray>(class_linker_);
177}
178TEST_F(ObjectTest, PrimitiveArray_Short_Alloc) {
179 TestPrimitiveArray<ShortArray>(class_linker_);
180}
181
Brian Carlstromb63ec392011-08-27 17:38:27 -0700182TEST_F(ObjectTest, AllocObjectFromCode) {
183 // pretend we are trying to call 'new String' from Object.toString
184 Class* java_lang_Object = class_linker_->FindSystemClass("Ljava/lang/Object;");
185 Method* toString = java_lang_Object->FindVirtualMethod("toString", "()Ljava/lang/String;");
186 uint32_t type_idx = FindTypeIdxByDescriptor(*java_lang_dex_file_.get(), "Ljava/lang/String;");
Brian Carlstrom1f870082011-08-23 16:02:11 -0700187 Object* string = Class::AllocObjectFromCode(type_idx, toString);
Brian Carlstromb63ec392011-08-27 17:38:27 -0700188 EXPECT_TRUE(string->IsString());
189}
190
191TEST_F(ObjectTest, AllocArrayFromCode) {
192 // pretend we are trying to call 'new char[3]' from String.toCharArray
193 Class* java_lang_String = class_linker_->FindSystemClass("Ljava/lang/String;");
194 Method* toCharArray = java_lang_String->FindVirtualMethod("toCharArray", "()[C");
195 uint32_t type_idx = FindTypeIdxByDescriptor(*java_lang_dex_file_.get(), "[C");
196 Object* array = Array::AllocFromCode(type_idx, toCharArray, 3);
197 EXPECT_TRUE(array->IsArrayInstance());
198 EXPECT_EQ(3, array->AsArray()->GetLength());
199 EXPECT_TRUE(array->GetClass()->IsArrayClass());
200 EXPECT_TRUE(array->GetClass()->GetComponentType()->IsPrimitive());
201}
202
Brian Carlstromb9edb842011-08-28 16:31:06 -0700203TEST_F(ObjectTest, StaticFieldFromCode) {
Brian Carlstrom9f30b382011-08-28 22:41:38 -0700204 // pretend we are trying to access 'String.ASCII' from String.<clinit>
Brian Carlstromb9edb842011-08-28 16:31:06 -0700205 Class* java_lang_String = class_linker_->FindSystemClass("Ljava/lang/String;");
206 Method* clinit = java_lang_String->FindDirectMethod("<clinit>", "()V");
207 uint32_t field_idx = FindFieldIdxByDescriptorAndName(*java_lang_dex_file_.get(),
208 "Ljava/lang/String;", "ASCII");
209 Object* ASCII = Field::GetObjStaticFromCode(field_idx, clinit);
210 EXPECT_EQ(NULL, ASCII);
211
212 CharArray* char_array = CharArray::Alloc(0);
213 Field::SetObjStaticFromCode(field_idx, clinit, char_array);
214 EXPECT_EQ(char_array, Field::GetObjStaticFromCode(field_idx, clinit));
215
216 Field::SetObjStaticFromCode(field_idx, clinit, NULL);
217 EXPECT_EQ(NULL, Field::GetObjStaticFromCode(field_idx, clinit));
Brian Carlstrom9f30b382011-08-28 22:41:38 -0700218
Brian Carlstromb9edb842011-08-28 16:31:06 -0700219 // TODO: more exhaustive tests of all 6 cases of Field::*FromCode
Brian Carlstrom9f30b382011-08-28 22:41:38 -0700220 // TODO: test should not assume private internals such as String.ASCII field.
Brian Carlstromb9edb842011-08-28 16:31:06 -0700221}
222
Brian Carlstrom0b138b22011-07-27 15:19:17 -0700223TEST_F(ObjectTest, String) {
224 // Test the empty string.
225 AssertString(0, "", "", 0);
226
227 // Test one-byte characters.
228 AssertString(1, " ", "\x00\x20", 0x20);
229 AssertString(1, "", "\x00\x00", 0);
230 AssertString(1, "\x7f", "\x00\x7f", 0x7f);
231 AssertString(2, "hi", "\x00\x68\x00\x69", (31 * 0x68) + 0x69);
232
233 // Test two-byte characters.
234 AssertString(1, "\xc2\x80", "\x00\x80", 0x80);
235 AssertString(1, "\xd9\xa6", "\x06\x66", 0x0666);
236 AssertString(1, "\xdf\xbf", "\x07\xff", 0x07ff);
237 AssertString(3, "h\xd9\xa6i", "\x00\x68\x06\x66\x00\x69", (31 * ((31 * 0x68) + 0x0666)) + 0x69);
238
239 // Test three-byte characters.
240 AssertString(1, "\xe0\xa0\x80", "\x08\x00", 0x0800);
241 AssertString(1, "\xe1\x88\xb4", "\x12\x34", 0x1234);
242 AssertString(1, "\xef\xbf\xbf", "\xff\xff", 0xffff);
243 AssertString(3, "h\xe1\x88\xb4i", "\x00\x68\x12\x34\x00\x69", (31 * ((31 * 0x68) + 0x1234)) + 0x69);
244}
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400245
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700246TEST_F(ObjectTest, StringEqualsUtf8) {
Elliott Hughesbfaadc82011-08-18 17:36:58 -0700247 String* string = String::AllocFromModifiedUtf8("android");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700248 EXPECT_TRUE(string->Equals("android"));
249 EXPECT_FALSE(string->Equals("Android"));
250 EXPECT_FALSE(string->Equals("ANDROID"));
251 EXPECT_FALSE(string->Equals(""));
252 EXPECT_FALSE(string->Equals("and"));
253 EXPECT_FALSE(string->Equals("androids"));
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700254
Elliott Hughesbfaadc82011-08-18 17:36:58 -0700255 String* empty = String::AllocFromModifiedUtf8("");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700256 EXPECT_TRUE(empty->Equals(""));
257 EXPECT_FALSE(empty->Equals("a"));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400258}
259
260TEST_F(ObjectTest, StringEquals) {
Elliott Hughesbfaadc82011-08-18 17:36:58 -0700261 String* string = String::AllocFromModifiedUtf8("android");
262 EXPECT_TRUE(string->Equals(String::AllocFromModifiedUtf8("android")));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700263 EXPECT_FALSE(string->Equals("Android"));
264 EXPECT_FALSE(string->Equals("ANDROID"));
265 EXPECT_FALSE(string->Equals(""));
266 EXPECT_FALSE(string->Equals("and"));
267 EXPECT_FALSE(string->Equals("androids"));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400268
Elliott Hughesbfaadc82011-08-18 17:36:58 -0700269 String* empty = String::AllocFromModifiedUtf8("");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700270 EXPECT_TRUE(empty->Equals(""));
271 EXPECT_FALSE(empty->Equals("a"));
272}
273
274TEST_F(ObjectTest, DescriptorCompare) {
275 ClassLinker* linker = class_linker_;
276
Brian Carlstrom9baa4ae2011-09-01 21:14:14 -0700277 const ClassLoader* class_loader_1 = LoadDex("ProtoCompare");
278 const ClassLoader* class_loader_2 = LoadDex("ProtoCompare2");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700279
280 Class* klass1 = linker->FindClass("LProtoCompare;", class_loader_1);
281 ASSERT_TRUE(klass1 != NULL);
282 Class* klass2 = linker->FindClass("LProtoCompare2;", class_loader_2);
283 ASSERT_TRUE(klass2 != NULL);
284
285 Method* m1_1 = klass1->GetVirtualMethod(0);
286 EXPECT_TRUE(m1_1->GetName()->Equals("m1"));
287 Method* m2_1 = klass1->GetVirtualMethod(1);
288 EXPECT_TRUE(m2_1->GetName()->Equals("m2"));
289 Method* m3_1 = klass1->GetVirtualMethod(2);
290 EXPECT_TRUE(m3_1->GetName()->Equals("m3"));
291 Method* m4_1 = klass1->GetVirtualMethod(3);
292 EXPECT_TRUE(m4_1->GetName()->Equals("m4"));
293
294 Method* m1_2 = klass2->GetVirtualMethod(0);
295 EXPECT_TRUE(m1_2->GetName()->Equals("m1"));
296 Method* m2_2 = klass2->GetVirtualMethod(1);
297 EXPECT_TRUE(m2_2->GetName()->Equals("m2"));
298 Method* m3_2 = klass2->GetVirtualMethod(2);
299 EXPECT_TRUE(m3_2->GetName()->Equals("m3"));
300 Method* m4_2 = klass2->GetVirtualMethod(3);
301 EXPECT_TRUE(m4_2->GetName()->Equals("m4"));
302
303 EXPECT_TRUE(m1_1->HasSameNameAndDescriptor(m1_2));
304 EXPECT_TRUE(m1_2->HasSameNameAndDescriptor(m1_1));
305
306 EXPECT_TRUE(m2_1->HasSameNameAndDescriptor(m2_2));
307 EXPECT_TRUE(m2_2->HasSameNameAndDescriptor(m2_1));
308
309 EXPECT_TRUE(m3_1->HasSameNameAndDescriptor(m3_2));
310 EXPECT_TRUE(m3_2->HasSameNameAndDescriptor(m3_1));
311
312 EXPECT_TRUE(m4_1->HasSameNameAndDescriptor(m4_2));
313 EXPECT_TRUE(m4_2->HasSameNameAndDescriptor(m4_1));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400314}
315
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700316
317TEST_F(ObjectTest, StringHashCode) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700318 EXPECT_EQ(0, String::AllocFromModifiedUtf8("")->GetHashCode());
319 EXPECT_EQ(65, String::AllocFromModifiedUtf8("A")->GetHashCode());
320 EXPECT_EQ(64578, String::AllocFromModifiedUtf8("ABC")->GetHashCode());
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700321}
322
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700323TEST_F(ObjectTest, InstanceOf) {
Brian Carlstrom9baa4ae2011-09-01 21:14:14 -0700324 const ClassLoader* class_loader = LoadDex("XandY");
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700325 Class* X = class_linker_->FindClass("LX;", class_loader);
326 Class* Y = class_linker_->FindClass("LY;", class_loader);
327 ASSERT_TRUE(X != NULL);
328 ASSERT_TRUE(Y != NULL);
329
330 EXPECT_FALSE(Object::InstanceOf(NULL, X));
331 EXPECT_FALSE(Object::InstanceOf(NULL, Y));
332
Brian Carlstrom1f870082011-08-23 16:02:11 -0700333 Object* x = X->AllocObject();
334 Object* y = Y->AllocObject();
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700335 ASSERT_TRUE(x != NULL);
336 ASSERT_TRUE(y != NULL);
337
338 EXPECT_TRUE(Object::InstanceOf(x, X));
339 EXPECT_FALSE(Object::InstanceOf(x, Y));
340 EXPECT_TRUE(Object::InstanceOf(y, X));
341 EXPECT_TRUE(Object::InstanceOf(y, Y));
342
343 EXPECT_TRUE(x->InstanceOf(X));
344 EXPECT_FALSE(x->InstanceOf(Y));
345 EXPECT_TRUE(y->InstanceOf(X));
346 EXPECT_TRUE(y->InstanceOf(Y));
347}
348
349TEST_F(ObjectTest, IsAssignableFrom) {
Brian Carlstrom9baa4ae2011-09-01 21:14:14 -0700350 const ClassLoader* class_loader = LoadDex("XandY");
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700351 Class* X = class_linker_->FindClass("LX;", class_loader);
352 Class* Y = class_linker_->FindClass("LY;", class_loader);
353
354 EXPECT_TRUE(X->IsAssignableFrom(X));
355 EXPECT_TRUE(X->IsAssignableFrom(Y));
356 EXPECT_FALSE(Y->IsAssignableFrom(X));
357 EXPECT_TRUE(Y->IsAssignableFrom(Y));
358}
359
360TEST_F(ObjectTest, IsAssignableFromArray) {
Brian Carlstrom9baa4ae2011-09-01 21:14:14 -0700361 const ClassLoader* class_loader = LoadDex("XandY");
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700362 Class* X = class_linker_->FindClass("LX;", class_loader);
363 Class* Y = class_linker_->FindClass("LY;", class_loader);
364 ASSERT_TRUE(X != NULL);
365 ASSERT_TRUE(Y != NULL);
366
367 Class* YA = class_linker_->FindClass("[LY;", class_loader);
368 Class* YAA = class_linker_->FindClass("[[LY;", class_loader);
369 ASSERT_TRUE(YA != NULL);
370 ASSERT_TRUE(YAA != NULL);
371
372 Class* XAA = class_linker_->FindClass("[[LX;", class_loader);
373 ASSERT_TRUE(XAA != NULL);
374
375 Class* O = class_linker_->FindSystemClass("Ljava/lang/Object;");
376 Class* OA = class_linker_->FindSystemClass("[Ljava/lang/Object;");
377 Class* OAA = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
378 Class* OAAA = class_linker_->FindSystemClass("[[[Ljava/lang/Object;");
379 ASSERT_TRUE(O != NULL);
380 ASSERT_TRUE(OA != NULL);
381 ASSERT_TRUE(OAA != NULL);
382 ASSERT_TRUE(OAAA != NULL);
383
384 Class* S = class_linker_->FindSystemClass("Ljava/io/Serializable;");
385 Class* SA = class_linker_->FindSystemClass("[Ljava/io/Serializable;");
386 Class* SAA = class_linker_->FindSystemClass("[[Ljava/io/Serializable;");
387 ASSERT_TRUE(S != NULL);
388 ASSERT_TRUE(SA != NULL);
389 ASSERT_TRUE(SAA != NULL);
390
391 Class* IA = class_linker_->FindSystemClass("[I");
392 ASSERT_TRUE(IA != NULL);
393
394 EXPECT_TRUE(YAA->IsAssignableFrom(YAA)); // identity
395 EXPECT_TRUE(XAA->IsAssignableFrom(YAA)); // element superclass
396 EXPECT_FALSE(YAA->IsAssignableFrom(XAA));
397 EXPECT_FALSE(Y->IsAssignableFrom(YAA));
398 EXPECT_FALSE(YA->IsAssignableFrom(YAA));
399 EXPECT_TRUE(O->IsAssignableFrom(YAA)); // everything is an Object
400 EXPECT_TRUE(OA->IsAssignableFrom(YAA));
401 EXPECT_TRUE(OAA->IsAssignableFrom(YAA));
402 EXPECT_TRUE(S->IsAssignableFrom(YAA)); // all arrays are Serializable
403 EXPECT_TRUE(SA->IsAssignableFrom(YAA));
404 EXPECT_FALSE(SAA->IsAssignableFrom(YAA)); // unless Y was Serializable
405
406 EXPECT_FALSE(IA->IsAssignableFrom(OA));
407 EXPECT_FALSE(OA->IsAssignableFrom(IA));
408 EXPECT_TRUE(O->IsAssignableFrom(IA));
409}
410
Elliott Hughescdf53122011-08-19 15:46:09 -0700411TEST_F(ObjectTest, FindInstanceField) {
412 String* s = String::AllocFromModifiedUtf8("ABC");
413 ASSERT_TRUE(s != NULL);
414 Class* c = s->GetClass();
415 ASSERT_TRUE(c != NULL);
416
417 // Wrong type.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700418 EXPECT_TRUE(c->FindDeclaredInstanceField("count", class_linker_->FindSystemClass("J")) == NULL);
419 EXPECT_TRUE(c->FindInstanceField("count", class_linker_->FindSystemClass("J")) == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700420
421 // Wrong name.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700422 EXPECT_TRUE(c->FindDeclaredInstanceField("Count", class_linker_->FindSystemClass("I")) == NULL);
423 EXPECT_TRUE(c->FindInstanceField("Count", class_linker_->FindSystemClass("I")) == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700424
425 // Right name and type.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700426 Field* f1 = c->FindDeclaredInstanceField("count", class_linker_->FindSystemClass("I"));
427 Field* f2 = c->FindInstanceField("count", class_linker_->FindSystemClass("I"));
Elliott Hughescdf53122011-08-19 15:46:09 -0700428 EXPECT_TRUE(f1 != NULL);
429 EXPECT_TRUE(f2 != NULL);
430 EXPECT_EQ(f1, f2);
431
432 // TODO: check that s.count == 3.
433
434 // Ensure that we handle superclass fields correctly...
435 c = class_linker_->FindSystemClass("Ljava/lang/StringBuilder;");
436 ASSERT_TRUE(c != NULL);
437 // No StringBuilder.count...
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700438 EXPECT_TRUE(c->FindDeclaredInstanceField("count", class_linker_->FindSystemClass("I")) == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700439 // ...but there is an AbstractStringBuilder.count.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700440 EXPECT_TRUE(c->FindInstanceField("count", class_linker_->FindSystemClass("I")) != NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700441}
442
443TEST_F(ObjectTest, FindStaticField) {
444 String* s = String::AllocFromModifiedUtf8("ABC");
445 ASSERT_TRUE(s != NULL);
446 Class* c = s->GetClass();
447 ASSERT_TRUE(c != NULL);
448
449 // Wrong type.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700450 EXPECT_TRUE(c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("I")) == NULL);
451 EXPECT_TRUE(c->FindStaticField("CASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("I")) == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700452
453 // Wrong name.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700454 EXPECT_TRUE(c->FindDeclaredStaticField("cASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("Ljava/util/Comparator;")) == NULL);
455 EXPECT_TRUE(c->FindStaticField("cASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("Ljava/util/Comparator;")) == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700456
457 // Right name and type.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700458 Field* f1 = c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("Ljava/util/Comparator;"));
459 Field* f2 = c->FindStaticField("CASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("Ljava/util/Comparator;"));
Elliott Hughescdf53122011-08-19 15:46:09 -0700460 EXPECT_TRUE(f1 != NULL);
461 EXPECT_TRUE(f2 != NULL);
462 EXPECT_EQ(f1, f2);
463
464 // TODO: test static fields via superclasses.
465 // TODO: test static fields via interfaces.
466 // TODO: test that interfaces trump superclasses.
467}
468
Carl Shapiro894d0fa2011-06-30 14:48:49 -0700469} // namespace art