blob: b1d5885c629e3db16014befefdf6b06a590c1ca9 [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"
Ian Rogersce9eca62011-10-07 17:11:03 -070013#include "runtime_support.h"
Carl Shapiro894d0fa2011-06-30 14:48:49 -070014
15namespace art {
16
Brian Carlstromf734cf52011-08-17 16:28:14 -070017class ObjectTest : public CommonTest {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070018 protected:
Elliott Hughes814e4032011-08-23 12:07:56 -070019 void AssertString(int32_t length,
Brian Carlstrom0b138b22011-07-27 15:19:17 -070020 const char* utf8_in,
21 const char* utf16_expected_le,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070022 int32_t expected_hash) {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070023 uint16_t utf16_expected[length];
Elliott Hughes814e4032011-08-23 12:07:56 -070024 for (int32_t i = 0; i < length; i++) {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070025 uint16_t ch = (((utf16_expected_le[i*2 + 0] & 0xff) << 8) |
26 ((utf16_expected_le[i*2 + 1] & 0xff) << 0));
27 utf16_expected[i] = ch;
28 }
29
Brian Carlstrom40381fb2011-10-19 14:13:40 -070030 SirtRef<String> string(String::AllocFromModifiedUtf8(length, utf8_in));
Carl Shapiro8860c0e2011-08-04 17:36:16 -070031 ASSERT_EQ(length, string->GetLength());
32 ASSERT_TRUE(string->GetCharArray() != NULL);
Jesse Wilsonfd687c52011-08-04 19:27:35 -070033 ASSERT_TRUE(string->GetCharArray()->GetData() != NULL);
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -040034 // strlen is necessary because the 1-character string "\0" is interpreted as ""
Elliott Hughes814e4032011-08-23 12:07:56 -070035 ASSERT_TRUE(string->Equals(utf8_in) || length != static_cast<int32_t>(strlen(utf8_in)));
36 for (int32_t i = 0; i < length; i++) {
Jesse Wilsonfd687c52011-08-04 19:27:35 -070037 EXPECT_EQ(utf16_expected[i], string->CharAt(i));
Brian Carlstrom0b138b22011-07-27 15:19:17 -070038 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070039 EXPECT_EQ(expected_hash, string->GetHashCode());
Brian Carlstrom0b138b22011-07-27 15:19:17 -070040 }
41};
Brian Carlstroma331b3c2011-07-18 17:47:56 -070042
43TEST_F(ObjectTest, IsInSamePackage) {
Carl Shapiro894d0fa2011-06-30 14:48:49 -070044 // Matches
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080045 EXPECT_TRUE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/lang/Class;"));
46 EXPECT_TRUE(Class::IsInSamePackage("LFoo;", "LBar;"));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070047
48 // Mismatches
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080049 EXPECT_FALSE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/io/File;"));
50 EXPECT_FALSE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/lang/reflect/Method;"));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070051}
52
Elliott Hughes081be7f2011-09-18 16:50:26 -070053TEST_F(ObjectTest, Clone) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -070054 SirtRef<ObjectArray<Object> > a1(class_linker_->AllocObjectArray<Object>(256));
Elliott Hughes081be7f2011-09-18 16:50:26 -070055 size_t s1 = a1->SizeOf();
56 Object* clone = a1->Clone();
57 EXPECT_EQ(s1, clone->SizeOf());
58 EXPECT_TRUE(clone->GetClass() == a1->GetClass());
59}
60
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070061TEST_F(ObjectTest, AllocObjectArray) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -070062 SirtRef<ObjectArray<Object> > oa(class_linker_->AllocObjectArray<Object>(2));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -070063 EXPECT_EQ(2, oa->GetLength());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070064 EXPECT_TRUE(oa->Get(0) == NULL);
65 EXPECT_TRUE(oa->Get(1) == NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -070066 oa->Set(0, oa.get());
67 EXPECT_TRUE(oa->Get(0) == oa.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070068 EXPECT_TRUE(oa->Get(1) == NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -070069 oa->Set(1, oa.get());
70 EXPECT_TRUE(oa->Get(0) == oa.get());
71 EXPECT_TRUE(oa->Get(1) == oa.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070072
Elliott Hughes710a0cb2011-08-16 14:32:37 -070073 Thread* self = Thread::Current();
74 Class* aioobe = class_linker_->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
75
76 EXPECT_TRUE(oa->Get(-1) == NULL);
77 EXPECT_TRUE(self->IsExceptionPending());
78 EXPECT_EQ(aioobe, self->GetException()->GetClass());
79 self->ClearException();
80
81 EXPECT_TRUE(oa->Get(2) == NULL);
82 EXPECT_TRUE(self->IsExceptionPending());
83 EXPECT_EQ(aioobe, self->GetException()->GetClass());
84 self->ClearException();
85
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070086 ASSERT_TRUE(oa->GetClass() != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080087 ClassHelper oa_ch(oa->GetClass());
88 ASSERT_EQ(2U, oa_ch.NumInterfaces());
89 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/lang/Cloneable;"), oa_ch.GetInterface(0));
90 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/io/Serializable;"), oa_ch.GetInterface(1));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070091}
92
Elliott Hughes68f4fa02011-08-21 10:46:59 -070093TEST_F(ObjectTest, AllocArray) {
94 Class* c = class_linker_->FindSystemClass("[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -070095 SirtRef<Array> a(Array::Alloc(c, 1));
Elliott Hughes68f4fa02011-08-21 10:46:59 -070096 ASSERT_TRUE(c == a->GetClass());
97
98 c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -070099 a.reset(Array::Alloc(c, 1));
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700100 ASSERT_TRUE(c == a->GetClass());
101
102 c = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700103 a.reset(Array::Alloc(c, 1));
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700104 ASSERT_TRUE(c == a->GetClass());
105}
106
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700107template<typename ArrayT>
108void TestPrimitiveArray(ClassLinker* cl) {
109 typedef typename ArrayT::ElementType T;
110
111 ArrayT* a = ArrayT::Alloc(2);
112 EXPECT_EQ(2, a->GetLength());
113 EXPECT_EQ(0, a->Get(0));
114 EXPECT_EQ(0, a->Get(1));
115 a->Set(0, T(123));
116 EXPECT_EQ(T(123), a->Get(0));
117 EXPECT_EQ(0, a->Get(1));
118 a->Set(1, T(321));
119 EXPECT_EQ(T(123), a->Get(0));
120 EXPECT_EQ(T(321), a->Get(1));
121
122 Thread* self = Thread::Current();
123 Class* aioobe = cl->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
124
125 EXPECT_EQ(0, a->Get(-1));
126 EXPECT_TRUE(self->IsExceptionPending());
127 EXPECT_EQ(aioobe, self->GetException()->GetClass());
128 self->ClearException();
129
130 EXPECT_EQ(0, a->Get(2));
131 EXPECT_TRUE(self->IsExceptionPending());
132 EXPECT_EQ(aioobe, self->GetException()->GetClass());
133 self->ClearException();
134}
135
136TEST_F(ObjectTest, PrimitiveArray_Boolean_Alloc) {
137 TestPrimitiveArray<BooleanArray>(class_linker_);
138}
139TEST_F(ObjectTest, PrimitiveArray_Byte_Alloc) {
140 TestPrimitiveArray<ByteArray>(class_linker_);
141}
142TEST_F(ObjectTest, PrimitiveArray_Char_Alloc) {
143 TestPrimitiveArray<CharArray>(class_linker_);
144}
145TEST_F(ObjectTest, PrimitiveArray_Double_Alloc) {
146 TestPrimitiveArray<DoubleArray>(class_linker_);
147}
148TEST_F(ObjectTest, PrimitiveArray_Float_Alloc) {
149 TestPrimitiveArray<FloatArray>(class_linker_);
150}
151TEST_F(ObjectTest, PrimitiveArray_Int_Alloc) {
152 TestPrimitiveArray<IntArray>(class_linker_);
153}
154TEST_F(ObjectTest, PrimitiveArray_Long_Alloc) {
155 TestPrimitiveArray<LongArray>(class_linker_);
156}
157TEST_F(ObjectTest, PrimitiveArray_Short_Alloc) {
158 TestPrimitiveArray<ShortArray>(class_linker_);
159}
160
Elliott Hughesb408de72011-10-04 14:35:05 -0700161TEST_F(ObjectTest, CheckAndAllocArrayFromCode) {
Ian Rogersb886da82011-09-23 16:27:54 -0700162 // pretend we are trying to call 'new char[3]' from String.toCharArray
163 Class* java_util_Arrays = class_linker_->FindSystemClass("Ljava/util/Arrays;");
164 Method* sort = java_util_Arrays->FindDirectMethod("sort", "([I)V");
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800165 const DexFile::StringId* string_id = java_lang_dex_file_->FindStringId("[I");
166 ASSERT_TRUE(string_id != NULL);
167 const DexFile::TypeId* type_id = java_lang_dex_file_->FindTypeId(
168 java_lang_dex_file_->GetIndexForStringId(*string_id));
169 ASSERT_TRUE(type_id != NULL);
170 uint32_t type_idx = java_lang_dex_file_->GetIndexForTypeId(*type_id);
Ian Rogersce9eca62011-10-07 17:11:03 -0700171 Object* array = CheckAndAllocArrayFromCode(type_idx, sort, 3, Thread::Current());
Brian Carlstromb63ec392011-08-27 17:38:27 -0700172 EXPECT_TRUE(array->IsArrayInstance());
173 EXPECT_EQ(3, array->AsArray()->GetLength());
174 EXPECT_TRUE(array->GetClass()->IsArrayClass());
175 EXPECT_TRUE(array->GetClass()->GetComponentType()->IsPrimitive());
176}
177
Brian Carlstromb9edb842011-08-28 16:31:06 -0700178TEST_F(ObjectTest, StaticFieldFromCode) {
jeffhaoabcfde32011-09-29 15:05:18 -0700179 // pretend we are trying to access 'Static.s0' from StaticsFromCode.<clinit>
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700180 SirtRef<ClassLoader> class_loader(LoadDex("StaticsFromCode"));
181 const DexFile* dex_file = ClassLoader::GetCompileTimeClassPath(class_loader.get())[0];
Brian Carlstrom848a4b32011-09-04 11:29:27 -0700182 CHECK(dex_file != NULL);
183
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700184 Class* klass = class_linker_->FindClass("LStaticsFromCode;", class_loader.get());
jeffhaoabcfde32011-09-29 15:05:18 -0700185 Method* clinit = klass->FindDirectMethod("<clinit>", "()V");
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800186 const DexFile::StringId* klass_string_id = dex_file->FindStringId("LStaticsFromCode;");
187 ASSERT_TRUE(klass_string_id != NULL);
188 const DexFile::TypeId* klass_type_id = dex_file->FindTypeId(
189 dex_file->GetIndexForStringId(*klass_string_id));
190 ASSERT_TRUE(klass_type_id != NULL);
191
192 const DexFile::StringId* type_string_id = dex_file->FindStringId("Ljava/lang/Object;");
193 ASSERT_TRUE(type_string_id != NULL);
194 const DexFile::TypeId* type_type_id = dex_file->FindTypeId(
195 dex_file->GetIndexForStringId(*type_string_id));
196 ASSERT_TRUE(type_type_id != NULL);
197
198 const DexFile::StringId* name_str_id = dex_file->FindStringId("s0");
199 ASSERT_TRUE(name_str_id != NULL);
200
201 const DexFile::FieldId* field_id = dex_file->FindFieldId(
202 *klass_type_id, *name_str_id, *type_type_id);
203 ASSERT_TRUE(field_id != NULL);
204 uint32_t field_idx = dex_file->GetIndexForFieldId(*field_id);
205
Ian Rogersce9eca62011-10-07 17:11:03 -0700206 Field* field = FindFieldFromCode(field_idx, clinit, true);
207 Object* s0 = field->GetObj(NULL);
jeffhaoabcfde32011-09-29 15:05:18 -0700208 EXPECT_EQ(NULL, s0);
Brian Carlstromb9edb842011-08-28 16:31:06 -0700209
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700210 SirtRef<CharArray> char_array(CharArray::Alloc(0));
211 field->SetObj(NULL, char_array.get());
212 EXPECT_EQ(char_array.get(), field->GetObj(NULL));
Brian Carlstromb9edb842011-08-28 16:31:06 -0700213
Ian Rogersce9eca62011-10-07 17:11:03 -0700214 field->SetObj(NULL, NULL);
215 EXPECT_EQ(NULL, field->GetObj(NULL));
Brian Carlstrom9f30b382011-08-28 22:41:38 -0700216
Brian Carlstromb9edb842011-08-28 16:31:06 -0700217 // TODO: more exhaustive tests of all 6 cases of Field::*FromCode
218}
219
Brian Carlstrom0b138b22011-07-27 15:19:17 -0700220TEST_F(ObjectTest, String) {
221 // Test the empty string.
222 AssertString(0, "", "", 0);
223
224 // Test one-byte characters.
225 AssertString(1, " ", "\x00\x20", 0x20);
226 AssertString(1, "", "\x00\x00", 0);
227 AssertString(1, "\x7f", "\x00\x7f", 0x7f);
228 AssertString(2, "hi", "\x00\x68\x00\x69", (31 * 0x68) + 0x69);
229
230 // Test two-byte characters.
231 AssertString(1, "\xc2\x80", "\x00\x80", 0x80);
232 AssertString(1, "\xd9\xa6", "\x06\x66", 0x0666);
233 AssertString(1, "\xdf\xbf", "\x07\xff", 0x07ff);
234 AssertString(3, "h\xd9\xa6i", "\x00\x68\x06\x66\x00\x69", (31 * ((31 * 0x68) + 0x0666)) + 0x69);
235
236 // Test three-byte characters.
237 AssertString(1, "\xe0\xa0\x80", "\x08\x00", 0x0800);
238 AssertString(1, "\xe1\x88\xb4", "\x12\x34", 0x1234);
239 AssertString(1, "\xef\xbf\xbf", "\xff\xff", 0xffff);
240 AssertString(3, "h\xe1\x88\xb4i", "\x00\x68\x12\x34\x00\x69", (31 * ((31 * 0x68) + 0x1234)) + 0x69);
241}
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400242
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700243TEST_F(ObjectTest, StringEqualsUtf8) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700244 SirtRef<String> string(String::AllocFromModifiedUtf8("android"));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700245 EXPECT_TRUE(string->Equals("android"));
246 EXPECT_FALSE(string->Equals("Android"));
247 EXPECT_FALSE(string->Equals("ANDROID"));
248 EXPECT_FALSE(string->Equals(""));
249 EXPECT_FALSE(string->Equals("and"));
250 EXPECT_FALSE(string->Equals("androids"));
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700251
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700252 SirtRef<String> empty(String::AllocFromModifiedUtf8(""));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700253 EXPECT_TRUE(empty->Equals(""));
254 EXPECT_FALSE(empty->Equals("a"));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400255}
256
257TEST_F(ObjectTest, StringEquals) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700258 SirtRef<String> string(String::AllocFromModifiedUtf8("android"));
259 SirtRef<String> string_2(String::AllocFromModifiedUtf8("android"));
260 EXPECT_TRUE(string->Equals(string_2.get()));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700261 EXPECT_FALSE(string->Equals("Android"));
262 EXPECT_FALSE(string->Equals("ANDROID"));
263 EXPECT_FALSE(string->Equals(""));
264 EXPECT_FALSE(string->Equals("and"));
265 EXPECT_FALSE(string->Equals("androids"));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400266
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700267 SirtRef<String> empty(String::AllocFromModifiedUtf8(""));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700268 EXPECT_TRUE(empty->Equals(""));
269 EXPECT_FALSE(empty->Equals("a"));
270}
271
272TEST_F(ObjectTest, DescriptorCompare) {
273 ClassLinker* linker = class_linker_;
274
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700275 SirtRef<ClassLoader> class_loader_1(LoadDex("ProtoCompare"));
276 SirtRef<ClassLoader> class_loader_2(LoadDex("ProtoCompare2"));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700277
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700278 Class* klass1 = linker->FindClass("LProtoCompare;", class_loader_1.get());
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700279 ASSERT_TRUE(klass1 != NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700280 Class* klass2 = linker->FindClass("LProtoCompare2;", class_loader_2.get());
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700281 ASSERT_TRUE(klass2 != NULL);
282
283 Method* m1_1 = klass1->GetVirtualMethod(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800284 MethodHelper mh(m1_1);
285 EXPECT_STREQ(mh.GetName(), "m1");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700286 Method* m2_1 = klass1->GetVirtualMethod(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800287 mh.ChangeMethod(m2_1);
288 EXPECT_STREQ(mh.GetName(), "m2");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700289 Method* m3_1 = klass1->GetVirtualMethod(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800290 mh.ChangeMethod(m3_1);
291 EXPECT_STREQ(mh.GetName(), "m3");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700292 Method* m4_1 = klass1->GetVirtualMethod(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800293 mh.ChangeMethod(m4_1);
294 EXPECT_STREQ(mh.GetName(), "m4");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700295
296 Method* m1_2 = klass2->GetVirtualMethod(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800297 mh.ChangeMethod(m1_2);
298 EXPECT_STREQ(mh.GetName(), "m1");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700299 Method* m2_2 = klass2->GetVirtualMethod(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800300 mh.ChangeMethod(m2_2);
301 EXPECT_STREQ(mh.GetName(), "m2");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700302 Method* m3_2 = klass2->GetVirtualMethod(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800303 mh.ChangeMethod(m3_2);
304 EXPECT_STREQ(mh.GetName(), "m3");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700305 Method* m4_2 = klass2->GetVirtualMethod(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800306 mh.ChangeMethod(m4_2);
307 EXPECT_STREQ(mh.GetName(), "m4");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700308
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800309 mh.ChangeMethod(m1_1);
310 MethodHelper mh2(m1_2);
311 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
312 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700313
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800314 mh.ChangeMethod(m2_1);
315 mh2.ChangeMethod(m2_2);
316 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
317 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700318
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800319 mh.ChangeMethod(m3_1);
320 mh2.ChangeMethod(m3_2);
321 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
322 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700323
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800324 mh.ChangeMethod(m4_1);
325 mh2.ChangeMethod(m4_2);
326 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
327 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400328}
329
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700330
331TEST_F(ObjectTest, StringHashCode) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700332 SirtRef<String> empty(String::AllocFromModifiedUtf8(""));
333 SirtRef<String> A(String::AllocFromModifiedUtf8("A"));
334 SirtRef<String> ABC(String::AllocFromModifiedUtf8("ABC"));
335
336 EXPECT_EQ(0, empty->GetHashCode());
337 EXPECT_EQ(65, A->GetHashCode());
338 EXPECT_EQ(64578, ABC->GetHashCode());
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700339}
340
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700341TEST_F(ObjectTest, InstanceOf) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700342 SirtRef<ClassLoader> class_loader(LoadDex("XandY"));
343 Class* X = class_linker_->FindClass("LX;", class_loader.get());
344 Class* Y = class_linker_->FindClass("LY;", class_loader.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700345 ASSERT_TRUE(X != NULL);
346 ASSERT_TRUE(Y != NULL);
347
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700348 SirtRef<Object> x(X->AllocObject());
349 SirtRef<Object> y(Y->AllocObject());
350 ASSERT_TRUE(x.get() != NULL);
351 ASSERT_TRUE(y.get() != NULL);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700352
Ian Rogerscaab8c42011-10-12 12:11:18 -0700353 EXPECT_EQ(1U, IsAssignableFromCode(X, x->GetClass()));
354 EXPECT_EQ(0U, IsAssignableFromCode(Y, x->GetClass()));
355 EXPECT_EQ(1U, IsAssignableFromCode(X, y->GetClass()));
356 EXPECT_EQ(1U, IsAssignableFromCode(Y, y->GetClass()));
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700357
358 EXPECT_TRUE(x->InstanceOf(X));
359 EXPECT_FALSE(x->InstanceOf(Y));
360 EXPECT_TRUE(y->InstanceOf(X));
361 EXPECT_TRUE(y->InstanceOf(Y));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700362
Elliott Hughes92f14b22011-10-06 12:29:54 -0700363 Class* java_lang_Class = class_linker_->FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700364 Class* Object_array_class = class_linker_->FindSystemClass("[Ljava/lang/Object;");
Elliott Hughes92f14b22011-10-06 12:29:54 -0700365
366 EXPECT_FALSE(java_lang_Class->InstanceOf(Object_array_class));
367 EXPECT_TRUE(Object_array_class->InstanceOf(java_lang_Class));
368
369 // All array classes implement Cloneable and Serializable.
370 Object* array = ObjectArray<Object>::Alloc(Object_array_class, 1);
371 Class* java_lang_Cloneable = class_linker_->FindSystemClass("Ljava/lang/Cloneable;");
372 Class* java_io_Serializable = class_linker_->FindSystemClass("Ljava/io/Serializable;");
373 EXPECT_TRUE(array->InstanceOf(java_lang_Cloneable));
374 EXPECT_TRUE(array->InstanceOf(java_io_Serializable));
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700375}
376
377TEST_F(ObjectTest, IsAssignableFrom) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700378 SirtRef<ClassLoader> class_loader(LoadDex("XandY"));
379 Class* X = class_linker_->FindClass("LX;", class_loader.get());
380 Class* Y = class_linker_->FindClass("LY;", class_loader.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700381
382 EXPECT_TRUE(X->IsAssignableFrom(X));
383 EXPECT_TRUE(X->IsAssignableFrom(Y));
384 EXPECT_FALSE(Y->IsAssignableFrom(X));
385 EXPECT_TRUE(Y->IsAssignableFrom(Y));
Ian Rogersd81871c2011-10-03 13:57:23 -0700386
387 // class final String implements CharSequence, ..
388 Class* string = class_linker_->FindSystemClass("Ljava/lang/String;");
389 Class* charseq = class_linker_->FindSystemClass("Ljava/lang/CharSequence;");
390 // Can String be assigned to CharSequence without a cast?
391 EXPECT_TRUE(charseq->IsAssignableFrom(string));
392 // Can CharSequence be assigned to String without a cast?
393 EXPECT_FALSE(string->IsAssignableFrom(charseq));
394
395 // Primitive types are only assignable to themselves
396 const char* prims = "ZBCSIJFD";
397 Class* prim_types[strlen(prims)];
398 for (size_t i = 0; i < strlen(prims); i++) {
399 prim_types[i] = class_linker_->FindPrimitiveClass(prims[i]);
400 }
401 for (size_t i = 0; i < strlen(prims); i++) {
402 for (size_t j = 0; i < strlen(prims); i++) {
403 if (i == j) {
404 EXPECT_TRUE(prim_types[i]->IsAssignableFrom(prim_types[j]));
405 } else {
406 EXPECT_FALSE(prim_types[i]->IsAssignableFrom(prim_types[j]));
407 }
408 }
409 }
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700410}
411
412TEST_F(ObjectTest, IsAssignableFromArray) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700413 SirtRef<ClassLoader> class_loader(LoadDex("XandY"));
414 Class* X = class_linker_->FindClass("LX;", class_loader.get());
415 Class* Y = class_linker_->FindClass("LY;", class_loader.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700416 ASSERT_TRUE(X != NULL);
417 ASSERT_TRUE(Y != NULL);
418
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700419 Class* YA = class_linker_->FindClass("[LY;", class_loader.get());
420 Class* YAA = class_linker_->FindClass("[[LY;", class_loader.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700421 ASSERT_TRUE(YA != NULL);
422 ASSERT_TRUE(YAA != NULL);
423
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700424 Class* XAA = class_linker_->FindClass("[[LX;", class_loader.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700425 ASSERT_TRUE(XAA != NULL);
426
427 Class* O = class_linker_->FindSystemClass("Ljava/lang/Object;");
428 Class* OA = class_linker_->FindSystemClass("[Ljava/lang/Object;");
429 Class* OAA = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
430 Class* OAAA = class_linker_->FindSystemClass("[[[Ljava/lang/Object;");
431 ASSERT_TRUE(O != NULL);
432 ASSERT_TRUE(OA != NULL);
433 ASSERT_TRUE(OAA != NULL);
434 ASSERT_TRUE(OAAA != NULL);
435
436 Class* S = class_linker_->FindSystemClass("Ljava/io/Serializable;");
437 Class* SA = class_linker_->FindSystemClass("[Ljava/io/Serializable;");
438 Class* SAA = class_linker_->FindSystemClass("[[Ljava/io/Serializable;");
439 ASSERT_TRUE(S != NULL);
440 ASSERT_TRUE(SA != NULL);
441 ASSERT_TRUE(SAA != NULL);
442
443 Class* IA = class_linker_->FindSystemClass("[I");
444 ASSERT_TRUE(IA != NULL);
445
446 EXPECT_TRUE(YAA->IsAssignableFrom(YAA)); // identity
447 EXPECT_TRUE(XAA->IsAssignableFrom(YAA)); // element superclass
448 EXPECT_FALSE(YAA->IsAssignableFrom(XAA));
449 EXPECT_FALSE(Y->IsAssignableFrom(YAA));
450 EXPECT_FALSE(YA->IsAssignableFrom(YAA));
451 EXPECT_TRUE(O->IsAssignableFrom(YAA)); // everything is an Object
452 EXPECT_TRUE(OA->IsAssignableFrom(YAA));
453 EXPECT_TRUE(OAA->IsAssignableFrom(YAA));
454 EXPECT_TRUE(S->IsAssignableFrom(YAA)); // all arrays are Serializable
455 EXPECT_TRUE(SA->IsAssignableFrom(YAA));
456 EXPECT_FALSE(SAA->IsAssignableFrom(YAA)); // unless Y was Serializable
457
458 EXPECT_FALSE(IA->IsAssignableFrom(OA));
459 EXPECT_FALSE(OA->IsAssignableFrom(IA));
460 EXPECT_TRUE(O->IsAssignableFrom(IA));
461}
462
Elliott Hughescdf53122011-08-19 15:46:09 -0700463TEST_F(ObjectTest, FindInstanceField) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700464 SirtRef<String> s(String::AllocFromModifiedUtf8("ABC"));
465 ASSERT_TRUE(s.get() != NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700466 Class* c = s->GetClass();
467 ASSERT_TRUE(c != NULL);
468
469 // Wrong type.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700470 EXPECT_TRUE(c->FindDeclaredInstanceField("count", "J") == NULL);
471 EXPECT_TRUE(c->FindInstanceField("count", "J") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700472
473 // Wrong name.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700474 EXPECT_TRUE(c->FindDeclaredInstanceField("Count", "I") == NULL);
475 EXPECT_TRUE(c->FindInstanceField("Count", "I") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700476
477 // Right name and type.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700478 Field* f1 = c->FindDeclaredInstanceField("count", "I");
479 Field* f2 = c->FindInstanceField("count", "I");
Elliott Hughescdf53122011-08-19 15:46:09 -0700480 EXPECT_TRUE(f1 != NULL);
481 EXPECT_TRUE(f2 != NULL);
482 EXPECT_EQ(f1, f2);
483
484 // TODO: check that s.count == 3.
485
486 // Ensure that we handle superclass fields correctly...
487 c = class_linker_->FindSystemClass("Ljava/lang/StringBuilder;");
488 ASSERT_TRUE(c != NULL);
489 // No StringBuilder.count...
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700490 EXPECT_TRUE(c->FindDeclaredInstanceField("count", "I") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700491 // ...but there is an AbstractStringBuilder.count.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700492 EXPECT_TRUE(c->FindInstanceField("count", "I") != NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700493}
494
495TEST_F(ObjectTest, FindStaticField) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700496 SirtRef<String> s(String::AllocFromModifiedUtf8("ABC"));
497 ASSERT_TRUE(s.get() != NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700498 Class* c = s->GetClass();
499 ASSERT_TRUE(c != NULL);
500
501 // Wrong type.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700502 EXPECT_TRUE(c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "I") == NULL);
503 EXPECT_TRUE(c->FindStaticField("CASE_INSENSITIVE_ORDER", "I") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700504
505 // Wrong name.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700506 EXPECT_TRUE(c->FindDeclaredStaticField("cASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;") == NULL);
507 EXPECT_TRUE(c->FindStaticField("cASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700508
509 // Right name and type.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700510 Field* f1 = c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
511 Field* f2 = c->FindStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
Elliott Hughescdf53122011-08-19 15:46:09 -0700512 EXPECT_TRUE(f1 != NULL);
513 EXPECT_TRUE(f2 != NULL);
514 EXPECT_EQ(f1, f2);
515
516 // TODO: test static fields via superclasses.
517 // TODO: test static fields via interfaces.
518 // TODO: test that interfaces trump superclasses.
519}
520
Carl Shapiro894d0fa2011-06-30 14:48:49 -0700521} // namespace art