blob: 9a5777b6aa494483270857ba77c0ff1751962e1a [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 }
40};
Brian Carlstroma331b3c2011-07-18 17:47:56 -070041
42TEST_F(ObjectTest, IsInSamePackage) {
Carl Shapiro894d0fa2011-06-30 14:48:49 -070043 // Matches
Brian Carlstrom9cff8e12011-08-18 16:47:29 -070044 EXPECT_TRUE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("Ljava/lang/Object;"),
45 String::AllocFromModifiedUtf8("Ljava/lang/Class")));
46 EXPECT_TRUE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("LFoo;"),
47 String::AllocFromModifiedUtf8("LBar;")));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070048
49 // Mismatches
Brian Carlstrom9cff8e12011-08-18 16:47:29 -070050 EXPECT_FALSE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("Ljava/lang/Object;"),
51 String::AllocFromModifiedUtf8("Ljava/io/File;")));
52 EXPECT_FALSE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("Ljava/lang/Object;"),
53 String::AllocFromModifiedUtf8("Ljava/lang/reflect/Method;")));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070054}
55
Elliott Hughes081be7f2011-09-18 16:50:26 -070056TEST_F(ObjectTest, Clone) {
57 ObjectArray<Object>* a1 = class_linker_->AllocObjectArray<Object>(256);
58 size_t s1 = a1->SizeOf();
59 Object* clone = a1->Clone();
60 EXPECT_EQ(s1, clone->SizeOf());
61 EXPECT_TRUE(clone->GetClass() == a1->GetClass());
62}
63
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070064TEST_F(ObjectTest, AllocObjectArray) {
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070065 ObjectArray<Object>* oa = class_linker_->AllocObjectArray<Object>(2);
Elliott Hughesd8ddfd52011-08-15 14:32:53 -070066 EXPECT_EQ(2, oa->GetLength());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070067 EXPECT_TRUE(oa->Get(0) == NULL);
68 EXPECT_TRUE(oa->Get(1) == NULL);
69 oa->Set(0, oa);
70 EXPECT_TRUE(oa->Get(0) == oa);
71 EXPECT_TRUE(oa->Get(1) == NULL);
72 oa->Set(1, oa);
73 EXPECT_TRUE(oa->Get(0) == oa);
74 EXPECT_TRUE(oa->Get(1) == oa);
75
Elliott Hughes710a0cb2011-08-16 14:32:37 -070076 Thread* self = Thread::Current();
77 Class* aioobe = class_linker_->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
78
79 EXPECT_TRUE(oa->Get(-1) == NULL);
80 EXPECT_TRUE(self->IsExceptionPending());
81 EXPECT_EQ(aioobe, self->GetException()->GetClass());
82 self->ClearException();
83
84 EXPECT_TRUE(oa->Get(2) == NULL);
85 EXPECT_TRUE(self->IsExceptionPending());
86 EXPECT_EQ(aioobe, self->GetException()->GetClass());
87 self->ClearException();
88
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070089 ASSERT_TRUE(oa->GetClass() != NULL);
90 ASSERT_EQ(2U, oa->GetClass()->NumInterfaces());
91 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/lang/Cloneable;"),
92 oa->GetClass()->GetInterface(0));
93 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/io/Serializable;"),
94 oa->GetClass()->GetInterface(1));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070095}
96
Elliott Hughes68f4fa02011-08-21 10:46:59 -070097TEST_F(ObjectTest, AllocArray) {
98 Class* c = class_linker_->FindSystemClass("[I");
99 Array* a = Array::Alloc(c, 1);
100 ASSERT_TRUE(c == a->GetClass());
101
102 c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
103 a = Array::Alloc(c, 1);
104 ASSERT_TRUE(c == a->GetClass());
105
106 c = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
107 a = Array::Alloc(c, 1);
108 ASSERT_TRUE(c == a->GetClass());
109}
110
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700111template<typename ArrayT>
112void TestPrimitiveArray(ClassLinker* cl) {
113 typedef typename ArrayT::ElementType T;
114
115 ArrayT* a = ArrayT::Alloc(2);
116 EXPECT_EQ(2, a->GetLength());
117 EXPECT_EQ(0, a->Get(0));
118 EXPECT_EQ(0, a->Get(1));
119 a->Set(0, T(123));
120 EXPECT_EQ(T(123), a->Get(0));
121 EXPECT_EQ(0, a->Get(1));
122 a->Set(1, T(321));
123 EXPECT_EQ(T(123), a->Get(0));
124 EXPECT_EQ(T(321), a->Get(1));
125
126 Thread* self = Thread::Current();
127 Class* aioobe = cl->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
128
129 EXPECT_EQ(0, a->Get(-1));
130 EXPECT_TRUE(self->IsExceptionPending());
131 EXPECT_EQ(aioobe, self->GetException()->GetClass());
132 self->ClearException();
133
134 EXPECT_EQ(0, a->Get(2));
135 EXPECT_TRUE(self->IsExceptionPending());
136 EXPECT_EQ(aioobe, self->GetException()->GetClass());
137 self->ClearException();
138}
139
140TEST_F(ObjectTest, PrimitiveArray_Boolean_Alloc) {
141 TestPrimitiveArray<BooleanArray>(class_linker_);
142}
143TEST_F(ObjectTest, PrimitiveArray_Byte_Alloc) {
144 TestPrimitiveArray<ByteArray>(class_linker_);
145}
146TEST_F(ObjectTest, PrimitiveArray_Char_Alloc) {
147 TestPrimitiveArray<CharArray>(class_linker_);
148}
149TEST_F(ObjectTest, PrimitiveArray_Double_Alloc) {
150 TestPrimitiveArray<DoubleArray>(class_linker_);
151}
152TEST_F(ObjectTest, PrimitiveArray_Float_Alloc) {
153 TestPrimitiveArray<FloatArray>(class_linker_);
154}
155TEST_F(ObjectTest, PrimitiveArray_Int_Alloc) {
156 TestPrimitiveArray<IntArray>(class_linker_);
157}
158TEST_F(ObjectTest, PrimitiveArray_Long_Alloc) {
159 TestPrimitiveArray<LongArray>(class_linker_);
160}
161TEST_F(ObjectTest, PrimitiveArray_Short_Alloc) {
162 TestPrimitiveArray<ShortArray>(class_linker_);
163}
164
Brian Carlstromb63ec392011-08-27 17:38:27 -0700165TEST_F(ObjectTest, AllocObjectFromCode) {
166 // pretend we are trying to call 'new String' from Object.toString
167 Class* java_lang_Object = class_linker_->FindSystemClass("Ljava/lang/Object;");
168 Method* toString = java_lang_Object->FindVirtualMethod("toString", "()Ljava/lang/String;");
169 uint32_t type_idx = FindTypeIdxByDescriptor(*java_lang_dex_file_.get(), "Ljava/lang/String;");
Brian Carlstrom1f870082011-08-23 16:02:11 -0700170 Object* string = Class::AllocObjectFromCode(type_idx, toString);
Brian Carlstromb63ec392011-08-27 17:38:27 -0700171 EXPECT_TRUE(string->IsString());
172}
173
Ian Rogersb886da82011-09-23 16:27:54 -0700174extern "C" Array* artArrayAllocFromCode(uint32_t type_idx, Method* method, int32_t component_count);
175TEST_F(ObjectTest, ArrayAllocFromCode) {
Brian Carlstromb63ec392011-08-27 17:38:27 -0700176 // pretend we are trying to call 'new char[3]' from String.toCharArray
177 Class* java_lang_String = class_linker_->FindSystemClass("Ljava/lang/String;");
178 Method* toCharArray = java_lang_String->FindVirtualMethod("toCharArray", "()[C");
179 uint32_t type_idx = FindTypeIdxByDescriptor(*java_lang_dex_file_.get(), "[C");
Ian Rogersb886da82011-09-23 16:27:54 -0700180 Object* array = artArrayAllocFromCode(type_idx, toCharArray, 3);
181 EXPECT_TRUE(array->IsArrayInstance());
182 EXPECT_EQ(3, array->AsArray()->GetLength());
183 EXPECT_TRUE(array->GetClass()->IsArrayClass());
184 EXPECT_TRUE(array->GetClass()->GetComponentType()->IsPrimitive());
185}
186
187extern "C" Array* artCheckAndArrayAllocFromCode(uint32_t type_idx, Method* method,
188 int32_t component_count);
189TEST_F(ObjectTest, CheckAndArrayAllocFromCode) {
190 // pretend we are trying to call 'new char[3]' from String.toCharArray
191 Class* java_util_Arrays = class_linker_->FindSystemClass("Ljava/util/Arrays;");
192 Method* sort = java_util_Arrays->FindDirectMethod("sort", "([I)V");
193 uint32_t type_idx = FindTypeIdxByDescriptor(*java_lang_dex_file_.get(), "[I");
194 Object* array = artCheckAndArrayAllocFromCode(type_idx, sort, 3);
Brian Carlstromb63ec392011-08-27 17:38:27 -0700195 EXPECT_TRUE(array->IsArrayInstance());
196 EXPECT_EQ(3, array->AsArray()->GetLength());
197 EXPECT_TRUE(array->GetClass()->IsArrayClass());
198 EXPECT_TRUE(array->GetClass()->GetComponentType()->IsPrimitive());
199}
200
Brian Carlstromb9edb842011-08-28 16:31:06 -0700201TEST_F(ObjectTest, StaticFieldFromCode) {
Brian Carlstrom848a4b32011-09-04 11:29:27 -0700202 // pretend we are trying to access 'Static.s8' from Statics.<clinit>
203 const ClassLoader* class_loader = LoadDex("Statics");
204 const DexFile* dex_file = ClassLoader::GetClassPath(class_loader)[0];
205 CHECK(dex_file != NULL);
206
207 Class* Statics = class_linker_->FindClass("LStatics;", class_loader);
208 Method* clinit = Statics->FindDirectMethod("<clinit>", "()V");
209 uint32_t field_idx = FindFieldIdxByDescriptorAndName(*dex_file, "LStatics;", "s8");
210 Object* s8 = Field::GetObjStaticFromCode(field_idx, clinit);
211 EXPECT_EQ(NULL, s8);
Brian Carlstromb9edb842011-08-28 16:31:06 -0700212
213 CharArray* char_array = CharArray::Alloc(0);
214 Field::SetObjStaticFromCode(field_idx, clinit, char_array);
215 EXPECT_EQ(char_array, Field::GetObjStaticFromCode(field_idx, clinit));
216
217 Field::SetObjStaticFromCode(field_idx, clinit, NULL);
218 EXPECT_EQ(NULL, Field::GetObjStaticFromCode(field_idx, clinit));
Brian Carlstrom9f30b382011-08-28 22:41:38 -0700219
Brian Carlstromb9edb842011-08-28 16:31:06 -0700220 // TODO: more exhaustive tests of all 6 cases of Field::*FromCode
221}
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));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700347
348 Class* Class_class = class_linker_->FindSystemClass("Ljava/lang/Class;");
349 Class* Object_array_class = class_linker_->FindSystemClass("[Ljava/lang/Object;");
350 EXPECT_FALSE(Class_class->InstanceOf(Object_array_class));
351 EXPECT_TRUE(Object_array_class->InstanceOf(Class_class));
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700352}
353
354TEST_F(ObjectTest, IsAssignableFrom) {
Brian Carlstrom9baa4ae2011-09-01 21:14:14 -0700355 const ClassLoader* class_loader = LoadDex("XandY");
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700356 Class* X = class_linker_->FindClass("LX;", class_loader);
357 Class* Y = class_linker_->FindClass("LY;", class_loader);
358
359 EXPECT_TRUE(X->IsAssignableFrom(X));
360 EXPECT_TRUE(X->IsAssignableFrom(Y));
361 EXPECT_FALSE(Y->IsAssignableFrom(X));
362 EXPECT_TRUE(Y->IsAssignableFrom(Y));
363}
364
365TEST_F(ObjectTest, IsAssignableFromArray) {
Brian Carlstrom9baa4ae2011-09-01 21:14:14 -0700366 const ClassLoader* class_loader = LoadDex("XandY");
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700367 Class* X = class_linker_->FindClass("LX;", class_loader);
368 Class* Y = class_linker_->FindClass("LY;", class_loader);
369 ASSERT_TRUE(X != NULL);
370 ASSERT_TRUE(Y != NULL);
371
372 Class* YA = class_linker_->FindClass("[LY;", class_loader);
373 Class* YAA = class_linker_->FindClass("[[LY;", class_loader);
374 ASSERT_TRUE(YA != NULL);
375 ASSERT_TRUE(YAA != NULL);
376
377 Class* XAA = class_linker_->FindClass("[[LX;", class_loader);
378 ASSERT_TRUE(XAA != NULL);
379
380 Class* O = class_linker_->FindSystemClass("Ljava/lang/Object;");
381 Class* OA = class_linker_->FindSystemClass("[Ljava/lang/Object;");
382 Class* OAA = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
383 Class* OAAA = class_linker_->FindSystemClass("[[[Ljava/lang/Object;");
384 ASSERT_TRUE(O != NULL);
385 ASSERT_TRUE(OA != NULL);
386 ASSERT_TRUE(OAA != NULL);
387 ASSERT_TRUE(OAAA != NULL);
388
389 Class* S = class_linker_->FindSystemClass("Ljava/io/Serializable;");
390 Class* SA = class_linker_->FindSystemClass("[Ljava/io/Serializable;");
391 Class* SAA = class_linker_->FindSystemClass("[[Ljava/io/Serializable;");
392 ASSERT_TRUE(S != NULL);
393 ASSERT_TRUE(SA != NULL);
394 ASSERT_TRUE(SAA != NULL);
395
396 Class* IA = class_linker_->FindSystemClass("[I");
397 ASSERT_TRUE(IA != NULL);
398
399 EXPECT_TRUE(YAA->IsAssignableFrom(YAA)); // identity
400 EXPECT_TRUE(XAA->IsAssignableFrom(YAA)); // element superclass
401 EXPECT_FALSE(YAA->IsAssignableFrom(XAA));
402 EXPECT_FALSE(Y->IsAssignableFrom(YAA));
403 EXPECT_FALSE(YA->IsAssignableFrom(YAA));
404 EXPECT_TRUE(O->IsAssignableFrom(YAA)); // everything is an Object
405 EXPECT_TRUE(OA->IsAssignableFrom(YAA));
406 EXPECT_TRUE(OAA->IsAssignableFrom(YAA));
407 EXPECT_TRUE(S->IsAssignableFrom(YAA)); // all arrays are Serializable
408 EXPECT_TRUE(SA->IsAssignableFrom(YAA));
409 EXPECT_FALSE(SAA->IsAssignableFrom(YAA)); // unless Y was Serializable
410
411 EXPECT_FALSE(IA->IsAssignableFrom(OA));
412 EXPECT_FALSE(OA->IsAssignableFrom(IA));
413 EXPECT_TRUE(O->IsAssignableFrom(IA));
414}
415
Elliott Hughescdf53122011-08-19 15:46:09 -0700416TEST_F(ObjectTest, FindInstanceField) {
417 String* s = String::AllocFromModifiedUtf8("ABC");
418 ASSERT_TRUE(s != NULL);
419 Class* c = s->GetClass();
420 ASSERT_TRUE(c != NULL);
421
422 // Wrong type.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700423 EXPECT_TRUE(c->FindDeclaredInstanceField("count", class_linker_->FindSystemClass("J")) == NULL);
424 EXPECT_TRUE(c->FindInstanceField("count", class_linker_->FindSystemClass("J")) == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700425
426 // Wrong name.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700427 EXPECT_TRUE(c->FindDeclaredInstanceField("Count", class_linker_->FindSystemClass("I")) == NULL);
428 EXPECT_TRUE(c->FindInstanceField("Count", class_linker_->FindSystemClass("I")) == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700429
430 // Right name and type.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700431 Field* f1 = c->FindDeclaredInstanceField("count", class_linker_->FindSystemClass("I"));
432 Field* f2 = c->FindInstanceField("count", class_linker_->FindSystemClass("I"));
Elliott Hughescdf53122011-08-19 15:46:09 -0700433 EXPECT_TRUE(f1 != NULL);
434 EXPECT_TRUE(f2 != NULL);
435 EXPECT_EQ(f1, f2);
436
437 // TODO: check that s.count == 3.
438
439 // Ensure that we handle superclass fields correctly...
440 c = class_linker_->FindSystemClass("Ljava/lang/StringBuilder;");
441 ASSERT_TRUE(c != NULL);
442 // No StringBuilder.count...
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700443 EXPECT_TRUE(c->FindDeclaredInstanceField("count", class_linker_->FindSystemClass("I")) == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700444 // ...but there is an AbstractStringBuilder.count.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700445 EXPECT_TRUE(c->FindInstanceField("count", class_linker_->FindSystemClass("I")) != NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700446}
447
448TEST_F(ObjectTest, FindStaticField) {
449 String* s = String::AllocFromModifiedUtf8("ABC");
450 ASSERT_TRUE(s != NULL);
451 Class* c = s->GetClass();
452 ASSERT_TRUE(c != NULL);
453
454 // Wrong type.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700455 EXPECT_TRUE(c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("I")) == NULL);
456 EXPECT_TRUE(c->FindStaticField("CASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("I")) == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700457
458 // Wrong name.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700459 EXPECT_TRUE(c->FindDeclaredStaticField("cASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("Ljava/util/Comparator;")) == NULL);
460 EXPECT_TRUE(c->FindStaticField("cASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("Ljava/util/Comparator;")) == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700461
462 // Right name and type.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700463 Field* f1 = c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("Ljava/util/Comparator;"));
464 Field* f2 = c->FindStaticField("CASE_INSENSITIVE_ORDER", class_linker_->FindSystemClass("Ljava/util/Comparator;"));
Elliott Hughescdf53122011-08-19 15:46:09 -0700465 EXPECT_TRUE(f1 != NULL);
466 EXPECT_TRUE(f2 != NULL);
467 EXPECT_EQ(f1, f2);
468
469 // TODO: test static fields via superclasses.
470 // TODO: test static fields via interfaces.
471 // TODO: test that interfaces trump superclasses.
472}
473
Carl Shapiro894d0fa2011-06-30 14:48:49 -0700474} // namespace art