blob: 081be4b2c142c36586afa95b57a638f17a1c0b58 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Carl Shapiro894d0fa2011-06-30 14:48:49 -070016
Elliott Hughes90a33692011-08-30 13:27:07 -070017#include "object.h"
18
19#include <stdint.h>
20#include <stdio.h>
21
22#include "UniquePtr.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070023#include "class_linker.h"
24#include "common_test.h"
25#include "dex_file.h"
26#include "heap.h"
Ian Rogersce9eca62011-10-07 17:11:03 -070027#include "runtime_support.h"
buzbeefc9e6fa2012-03-23 15:14:29 -070028#include "asm_support.h"
Carl Shapiro894d0fa2011-06-30 14:48:49 -070029
30namespace art {
31
Brian Carlstromf734cf52011-08-17 16:28:14 -070032class ObjectTest : public CommonTest {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070033 protected:
Elliott Hughes814e4032011-08-23 12:07:56 -070034 void AssertString(int32_t length,
Brian Carlstrom0b138b22011-07-27 15:19:17 -070035 const char* utf8_in,
36 const char* utf16_expected_le,
Ian Rogers00f7d0e2012-07-19 15:28:27 -070037 int32_t expected_hash)
Ian Rogersb726dcb2012-09-05 08:57:23 -070038 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesee0fa762012-03-26 17:12:41 -070039 UniquePtr<uint16_t[]> utf16_expected(new uint16_t[length]);
Elliott Hughes814e4032011-08-23 12:07:56 -070040 for (int32_t i = 0; i < length; i++) {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070041 uint16_t ch = (((utf16_expected_le[i*2 + 0] & 0xff) << 8) |
42 ((utf16_expected_le[i*2 + 1] & 0xff) << 0));
43 utf16_expected[i] = ch;
44 }
45
Brian Carlstrom40381fb2011-10-19 14:13:40 -070046 SirtRef<String> string(String::AllocFromModifiedUtf8(length, utf8_in));
Carl Shapiro8860c0e2011-08-04 17:36:16 -070047 ASSERT_EQ(length, string->GetLength());
48 ASSERT_TRUE(string->GetCharArray() != NULL);
Jesse Wilsonfd687c52011-08-04 19:27:35 -070049 ASSERT_TRUE(string->GetCharArray()->GetData() != NULL);
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -040050 // strlen is necessary because the 1-character string "\0" is interpreted as ""
Elliott Hughes814e4032011-08-23 12:07:56 -070051 ASSERT_TRUE(string->Equals(utf8_in) || length != static_cast<int32_t>(strlen(utf8_in)));
52 for (int32_t i = 0; i < length; i++) {
Jesse Wilsonfd687c52011-08-04 19:27:35 -070053 EXPECT_EQ(utf16_expected[i], string->CharAt(i));
Brian Carlstrom0b138b22011-07-27 15:19:17 -070054 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070055 EXPECT_EQ(expected_hash, string->GetHashCode());
Brian Carlstrom0b138b22011-07-27 15:19:17 -070056 }
57};
Brian Carlstroma331b3c2011-07-18 17:47:56 -070058
buzbeefc9e6fa2012-03-23 15:14:29 -070059// Keep the assembly code in sync
60TEST_F(ObjectTest, AsmConstants) {
61 ASSERT_EQ(STRING_VALUE_OFFSET, String::ValueOffset().Int32Value());
62 ASSERT_EQ(STRING_COUNT_OFFSET, String::CountOffset().Int32Value());
63 ASSERT_EQ(STRING_OFFSET_OFFSET, String::OffsetOffset().Int32Value());
64 ASSERT_EQ(STRING_DATA_OFFSET, Array::DataOffset(sizeof(uint16_t)).Int32Value());
65}
66
Brian Carlstroma331b3c2011-07-18 17:47:56 -070067TEST_F(ObjectTest, IsInSamePackage) {
Carl Shapiro894d0fa2011-06-30 14:48:49 -070068 // Matches
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080069 EXPECT_TRUE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/lang/Class;"));
70 EXPECT_TRUE(Class::IsInSamePackage("LFoo;", "LBar;"));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070071
72 // Mismatches
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080073 EXPECT_FALSE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/io/File;"));
74 EXPECT_FALSE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/lang/reflect/Method;"));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070075}
76
Elliott Hughes081be7f2011-09-18 16:50:26 -070077TEST_F(ObjectTest, Clone) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -070078 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -070079 SirtRef<ObjectArray<Object> > a1(class_linker_->AllocObjectArray<Object>(256));
Elliott Hughes081be7f2011-09-18 16:50:26 -070080 size_t s1 = a1->SizeOf();
81 Object* clone = a1->Clone();
82 EXPECT_EQ(s1, clone->SizeOf());
83 EXPECT_TRUE(clone->GetClass() == a1->GetClass());
84}
85
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070086TEST_F(ObjectTest, AllocObjectArray) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -070087 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -070088 SirtRef<ObjectArray<Object> > oa(class_linker_->AllocObjectArray<Object>(2));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -070089 EXPECT_EQ(2, oa->GetLength());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070090 EXPECT_TRUE(oa->Get(0) == NULL);
91 EXPECT_TRUE(oa->Get(1) == NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -070092 oa->Set(0, oa.get());
93 EXPECT_TRUE(oa->Get(0) == oa.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070094 EXPECT_TRUE(oa->Get(1) == NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -070095 oa->Set(1, oa.get());
96 EXPECT_TRUE(oa->Get(0) == oa.get());
97 EXPECT_TRUE(oa->Get(1) == oa.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070098
Elliott Hughes710a0cb2011-08-16 14:32:37 -070099 Thread* self = Thread::Current();
100 Class* aioobe = class_linker_->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
101
102 EXPECT_TRUE(oa->Get(-1) == NULL);
103 EXPECT_TRUE(self->IsExceptionPending());
104 EXPECT_EQ(aioobe, self->GetException()->GetClass());
105 self->ClearException();
106
107 EXPECT_TRUE(oa->Get(2) == NULL);
108 EXPECT_TRUE(self->IsExceptionPending());
109 EXPECT_EQ(aioobe, self->GetException()->GetClass());
110 self->ClearException();
111
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700112 ASSERT_TRUE(oa->GetClass() != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800113 ClassHelper oa_ch(oa->GetClass());
Ian Rogersd24e2642012-06-06 21:21:43 -0700114 ASSERT_EQ(2U, oa_ch.NumDirectInterfaces());
115 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/lang/Cloneable;"), oa_ch.GetDirectInterface(0));
116 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/io/Serializable;"), oa_ch.GetDirectInterface(1));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700117}
118
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700119TEST_F(ObjectTest, AllocArray) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700120 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700121 Class* c = class_linker_->FindSystemClass("[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700122 SirtRef<Array> a(Array::Alloc(c, 1));
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700123 ASSERT_TRUE(c == a->GetClass());
124
125 c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700126 a.reset(Array::Alloc(c, 1));
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700127 ASSERT_TRUE(c == a->GetClass());
128
129 c = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700130 a.reset(Array::Alloc(c, 1));
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700131 ASSERT_TRUE(c == a->GetClass());
132}
133
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700134template<typename ArrayT>
135void TestPrimitiveArray(ClassLinker* cl) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700136 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700137 typedef typename ArrayT::ElementType T;
138
139 ArrayT* a = ArrayT::Alloc(2);
140 EXPECT_EQ(2, a->GetLength());
141 EXPECT_EQ(0, a->Get(0));
142 EXPECT_EQ(0, a->Get(1));
143 a->Set(0, T(123));
144 EXPECT_EQ(T(123), a->Get(0));
145 EXPECT_EQ(0, a->Get(1));
146 a->Set(1, T(321));
147 EXPECT_EQ(T(123), a->Get(0));
148 EXPECT_EQ(T(321), a->Get(1));
149
150 Thread* self = Thread::Current();
151 Class* aioobe = cl->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
152
153 EXPECT_EQ(0, a->Get(-1));
154 EXPECT_TRUE(self->IsExceptionPending());
155 EXPECT_EQ(aioobe, self->GetException()->GetClass());
156 self->ClearException();
157
158 EXPECT_EQ(0, a->Get(2));
159 EXPECT_TRUE(self->IsExceptionPending());
160 EXPECT_EQ(aioobe, self->GetException()->GetClass());
161 self->ClearException();
162}
163
164TEST_F(ObjectTest, PrimitiveArray_Boolean_Alloc) {
165 TestPrimitiveArray<BooleanArray>(class_linker_);
166}
167TEST_F(ObjectTest, PrimitiveArray_Byte_Alloc) {
168 TestPrimitiveArray<ByteArray>(class_linker_);
169}
170TEST_F(ObjectTest, PrimitiveArray_Char_Alloc) {
171 TestPrimitiveArray<CharArray>(class_linker_);
172}
173TEST_F(ObjectTest, PrimitiveArray_Double_Alloc) {
174 TestPrimitiveArray<DoubleArray>(class_linker_);
175}
176TEST_F(ObjectTest, PrimitiveArray_Float_Alloc) {
177 TestPrimitiveArray<FloatArray>(class_linker_);
178}
179TEST_F(ObjectTest, PrimitiveArray_Int_Alloc) {
180 TestPrimitiveArray<IntArray>(class_linker_);
181}
182TEST_F(ObjectTest, PrimitiveArray_Long_Alloc) {
183 TestPrimitiveArray<LongArray>(class_linker_);
184}
185TEST_F(ObjectTest, PrimitiveArray_Short_Alloc) {
186 TestPrimitiveArray<ShortArray>(class_linker_);
187}
188
Elliott Hughesb408de72011-10-04 14:35:05 -0700189TEST_F(ObjectTest, CheckAndAllocArrayFromCode) {
Ian Rogersb886da82011-09-23 16:27:54 -0700190 // pretend we are trying to call 'new char[3]' from String.toCharArray
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700191 ScopedObjectAccess soa(Thread::Current());
Ian Rogersb886da82011-09-23 16:27:54 -0700192 Class* java_util_Arrays = class_linker_->FindSystemClass("Ljava/util/Arrays;");
193 Method* sort = java_util_Arrays->FindDirectMethod("sort", "([I)V");
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800194 const DexFile::StringId* string_id = java_lang_dex_file_->FindStringId("[I");
195 ASSERT_TRUE(string_id != NULL);
196 const DexFile::TypeId* type_id = java_lang_dex_file_->FindTypeId(
197 java_lang_dex_file_->GetIndexForStringId(*string_id));
198 ASSERT_TRUE(type_id != NULL);
199 uint32_t type_idx = java_lang_dex_file_->GetIndexForTypeId(*type_id);
Ian Rogers0eb7d7e2012-01-31 21:12:32 -0800200 Object* array = CheckAndAllocArrayFromCode(type_idx, sort, 3, Thread::Current(), false);
Brian Carlstromb63ec392011-08-27 17:38:27 -0700201 EXPECT_TRUE(array->IsArrayInstance());
202 EXPECT_EQ(3, array->AsArray()->GetLength());
203 EXPECT_TRUE(array->GetClass()->IsArrayClass());
204 EXPECT_TRUE(array->GetClass()->GetComponentType()->IsPrimitive());
205}
206
Brian Carlstromb9edb842011-08-28 16:31:06 -0700207TEST_F(ObjectTest, StaticFieldFromCode) {
jeffhaoabcfde32011-09-29 15:05:18 -0700208 // pretend we are trying to access 'Static.s0' from StaticsFromCode.<clinit>
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700209 ScopedObjectAccess soa(Thread::Current());
210 jobject class_loader = LoadDex("StaticsFromCode");
211 const DexFile* dex_file = Runtime::Current()->GetCompileTimeClassPath(class_loader)[0];
Brian Carlstrom848a4b32011-09-04 11:29:27 -0700212 CHECK(dex_file != NULL);
213
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700214 Class* klass =
215 class_linker_->FindClass("LStaticsFromCode;", soa.Decode<ClassLoader*>(class_loader));
jeffhaoabcfde32011-09-29 15:05:18 -0700216 Method* clinit = klass->FindDirectMethod("<clinit>", "()V");
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800217 const DexFile::StringId* klass_string_id = dex_file->FindStringId("LStaticsFromCode;");
218 ASSERT_TRUE(klass_string_id != NULL);
219 const DexFile::TypeId* klass_type_id = dex_file->FindTypeId(
220 dex_file->GetIndexForStringId(*klass_string_id));
221 ASSERT_TRUE(klass_type_id != NULL);
222
223 const DexFile::StringId* type_string_id = dex_file->FindStringId("Ljava/lang/Object;");
224 ASSERT_TRUE(type_string_id != NULL);
225 const DexFile::TypeId* type_type_id = dex_file->FindTypeId(
226 dex_file->GetIndexForStringId(*type_string_id));
227 ASSERT_TRUE(type_type_id != NULL);
228
229 const DexFile::StringId* name_str_id = dex_file->FindStringId("s0");
230 ASSERT_TRUE(name_str_id != NULL);
231
232 const DexFile::FieldId* field_id = dex_file->FindFieldId(
233 *klass_type_id, *name_str_id, *type_type_id);
234 ASSERT_TRUE(field_id != NULL);
235 uint32_t field_idx = dex_file->GetIndexForFieldId(*field_id);
236
Ian Rogers08f753d2012-08-24 14:35:25 -0700237 Field* field = FindFieldFromCode(field_idx, clinit, Thread::Current(), StaticObjectRead,
238 sizeof(Object*));
Ian Rogersce9eca62011-10-07 17:11:03 -0700239 Object* s0 = field->GetObj(NULL);
jeffhaoabcfde32011-09-29 15:05:18 -0700240 EXPECT_EQ(NULL, s0);
Brian Carlstromb9edb842011-08-28 16:31:06 -0700241
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700242 SirtRef<CharArray> char_array(CharArray::Alloc(0));
243 field->SetObj(NULL, char_array.get());
244 EXPECT_EQ(char_array.get(), field->GetObj(NULL));
Brian Carlstromb9edb842011-08-28 16:31:06 -0700245
Ian Rogersce9eca62011-10-07 17:11:03 -0700246 field->SetObj(NULL, NULL);
247 EXPECT_EQ(NULL, field->GetObj(NULL));
Brian Carlstrom9f30b382011-08-28 22:41:38 -0700248
Brian Carlstromb9edb842011-08-28 16:31:06 -0700249 // TODO: more exhaustive tests of all 6 cases of Field::*FromCode
250}
251
Brian Carlstrom0b138b22011-07-27 15:19:17 -0700252TEST_F(ObjectTest, String) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700253 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom0b138b22011-07-27 15:19:17 -0700254 // Test the empty string.
255 AssertString(0, "", "", 0);
256
257 // Test one-byte characters.
258 AssertString(1, " ", "\x00\x20", 0x20);
259 AssertString(1, "", "\x00\x00", 0);
260 AssertString(1, "\x7f", "\x00\x7f", 0x7f);
261 AssertString(2, "hi", "\x00\x68\x00\x69", (31 * 0x68) + 0x69);
262
263 // Test two-byte characters.
264 AssertString(1, "\xc2\x80", "\x00\x80", 0x80);
265 AssertString(1, "\xd9\xa6", "\x06\x66", 0x0666);
266 AssertString(1, "\xdf\xbf", "\x07\xff", 0x07ff);
267 AssertString(3, "h\xd9\xa6i", "\x00\x68\x06\x66\x00\x69", (31 * ((31 * 0x68) + 0x0666)) + 0x69);
268
269 // Test three-byte characters.
270 AssertString(1, "\xe0\xa0\x80", "\x08\x00", 0x0800);
271 AssertString(1, "\xe1\x88\xb4", "\x12\x34", 0x1234);
272 AssertString(1, "\xef\xbf\xbf", "\xff\xff", 0xffff);
273 AssertString(3, "h\xe1\x88\xb4i", "\x00\x68\x12\x34\x00\x69", (31 * ((31 * 0x68) + 0x1234)) + 0x69);
274}
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400275
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700276TEST_F(ObjectTest, StringEqualsUtf8) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700277 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700278 SirtRef<String> string(String::AllocFromModifiedUtf8("android"));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700279 EXPECT_TRUE(string->Equals("android"));
280 EXPECT_FALSE(string->Equals("Android"));
281 EXPECT_FALSE(string->Equals("ANDROID"));
282 EXPECT_FALSE(string->Equals(""));
283 EXPECT_FALSE(string->Equals("and"));
284 EXPECT_FALSE(string->Equals("androids"));
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700285
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700286 SirtRef<String> empty(String::AllocFromModifiedUtf8(""));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700287 EXPECT_TRUE(empty->Equals(""));
288 EXPECT_FALSE(empty->Equals("a"));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400289}
290
291TEST_F(ObjectTest, StringEquals) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700292 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700293 SirtRef<String> string(String::AllocFromModifiedUtf8("android"));
294 SirtRef<String> string_2(String::AllocFromModifiedUtf8("android"));
295 EXPECT_TRUE(string->Equals(string_2.get()));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700296 EXPECT_FALSE(string->Equals("Android"));
297 EXPECT_FALSE(string->Equals("ANDROID"));
298 EXPECT_FALSE(string->Equals(""));
299 EXPECT_FALSE(string->Equals("and"));
300 EXPECT_FALSE(string->Equals("androids"));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400301
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700302 SirtRef<String> empty(String::AllocFromModifiedUtf8(""));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700303 EXPECT_TRUE(empty->Equals(""));
304 EXPECT_FALSE(empty->Equals("a"));
305}
306
jeffhao0ce13152012-03-27 19:45:50 -0700307TEST_F(ObjectTest, StringLength) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700308 ScopedObjectAccess soa(Thread::Current());
jeffhao0ce13152012-03-27 19:45:50 -0700309 SirtRef<String> string(String::AllocFromModifiedUtf8("android"));
310 EXPECT_EQ(string->GetLength(), 7);
311 EXPECT_EQ(string->GetUtfLength(), 7);
312
313 string->SetOffset(2);
314 string->SetCount(5);
315 EXPECT_TRUE(string->Equals("droid"));
316 EXPECT_EQ(string->GetLength(), 5);
317 EXPECT_EQ(string->GetUtfLength(), 5);
318}
319
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700320TEST_F(ObjectTest, DescriptorCompare) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700321 ScopedObjectAccess soa(Thread::Current());
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700322 ClassLinker* linker = class_linker_;
323
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700324 jobject jclass_loader_1 = LoadDex("ProtoCompare");
325 jobject jclass_loader_2 = LoadDex("ProtoCompare2");
326 SirtRef<ClassLoader> class_loader_1(soa.Decode<ClassLoader*>(jclass_loader_1));
327 SirtRef<ClassLoader> class_loader_2(soa.Decode<ClassLoader*>(jclass_loader_2));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700328
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700329 Class* klass1 = linker->FindClass("LProtoCompare;", class_loader_1.get());
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700330 ASSERT_TRUE(klass1 != NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700331 Class* klass2 = linker->FindClass("LProtoCompare2;", class_loader_2.get());
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700332 ASSERT_TRUE(klass2 != NULL);
333
334 Method* m1_1 = klass1->GetVirtualMethod(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800335 MethodHelper mh(m1_1);
336 EXPECT_STREQ(mh.GetName(), "m1");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700337 Method* m2_1 = klass1->GetVirtualMethod(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800338 mh.ChangeMethod(m2_1);
339 EXPECT_STREQ(mh.GetName(), "m2");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700340 Method* m3_1 = klass1->GetVirtualMethod(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800341 mh.ChangeMethod(m3_1);
342 EXPECT_STREQ(mh.GetName(), "m3");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700343 Method* m4_1 = klass1->GetVirtualMethod(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800344 mh.ChangeMethod(m4_1);
345 EXPECT_STREQ(mh.GetName(), "m4");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700346
347 Method* m1_2 = klass2->GetVirtualMethod(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800348 mh.ChangeMethod(m1_2);
349 EXPECT_STREQ(mh.GetName(), "m1");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700350 Method* m2_2 = klass2->GetVirtualMethod(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800351 mh.ChangeMethod(m2_2);
352 EXPECT_STREQ(mh.GetName(), "m2");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700353 Method* m3_2 = klass2->GetVirtualMethod(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800354 mh.ChangeMethod(m3_2);
355 EXPECT_STREQ(mh.GetName(), "m3");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700356 Method* m4_2 = klass2->GetVirtualMethod(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800357 mh.ChangeMethod(m4_2);
358 EXPECT_STREQ(mh.GetName(), "m4");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700359
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800360 mh.ChangeMethod(m1_1);
361 MethodHelper mh2(m1_2);
362 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
363 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700364
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800365 mh.ChangeMethod(m2_1);
366 mh2.ChangeMethod(m2_2);
367 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
368 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700369
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800370 mh.ChangeMethod(m3_1);
371 mh2.ChangeMethod(m3_2);
372 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
373 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700374
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800375 mh.ChangeMethod(m4_1);
376 mh2.ChangeMethod(m4_2);
377 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
378 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400379}
380
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700381
382TEST_F(ObjectTest, StringHashCode) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700383 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700384 SirtRef<String> empty(String::AllocFromModifiedUtf8(""));
385 SirtRef<String> A(String::AllocFromModifiedUtf8("A"));
386 SirtRef<String> ABC(String::AllocFromModifiedUtf8("ABC"));
387
388 EXPECT_EQ(0, empty->GetHashCode());
389 EXPECT_EQ(65, A->GetHashCode());
390 EXPECT_EQ(64578, ABC->GetHashCode());
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700391}
392
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700393TEST_F(ObjectTest, InstanceOf) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700394 ScopedObjectAccess soa(Thread::Current());
395 jobject jclass_loader = LoadDex("XandY");
396 SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(jclass_loader));
397
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700398 Class* X = class_linker_->FindClass("LX;", class_loader.get());
399 Class* Y = class_linker_->FindClass("LY;", class_loader.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700400 ASSERT_TRUE(X != NULL);
401 ASSERT_TRUE(Y != NULL);
402
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700403 SirtRef<Object> x(X->AllocObject());
404 SirtRef<Object> y(Y->AllocObject());
405 ASSERT_TRUE(x.get() != NULL);
406 ASSERT_TRUE(y.get() != NULL);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700407
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700408 EXPECT_TRUE(x->InstanceOf(X));
409 EXPECT_FALSE(x->InstanceOf(Y));
410 EXPECT_TRUE(y->InstanceOf(X));
411 EXPECT_TRUE(y->InstanceOf(Y));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700412
Elliott Hughes92f14b22011-10-06 12:29:54 -0700413 Class* java_lang_Class = class_linker_->FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700414 Class* Object_array_class = class_linker_->FindSystemClass("[Ljava/lang/Object;");
Elliott Hughes92f14b22011-10-06 12:29:54 -0700415
416 EXPECT_FALSE(java_lang_Class->InstanceOf(Object_array_class));
417 EXPECT_TRUE(Object_array_class->InstanceOf(java_lang_Class));
418
419 // All array classes implement Cloneable and Serializable.
420 Object* array = ObjectArray<Object>::Alloc(Object_array_class, 1);
421 Class* java_lang_Cloneable = class_linker_->FindSystemClass("Ljava/lang/Cloneable;");
422 Class* java_io_Serializable = class_linker_->FindSystemClass("Ljava/io/Serializable;");
423 EXPECT_TRUE(array->InstanceOf(java_lang_Cloneable));
424 EXPECT_TRUE(array->InstanceOf(java_io_Serializable));
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700425}
426
427TEST_F(ObjectTest, IsAssignableFrom) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700428 ScopedObjectAccess soa(Thread::Current());
429 jobject jclass_loader = LoadDex("XandY");
430 SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(jclass_loader));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700431 Class* X = class_linker_->FindClass("LX;", class_loader.get());
432 Class* Y = class_linker_->FindClass("LY;", class_loader.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700433
434 EXPECT_TRUE(X->IsAssignableFrom(X));
435 EXPECT_TRUE(X->IsAssignableFrom(Y));
436 EXPECT_FALSE(Y->IsAssignableFrom(X));
437 EXPECT_TRUE(Y->IsAssignableFrom(Y));
Ian Rogersd81871c2011-10-03 13:57:23 -0700438
439 // class final String implements CharSequence, ..
440 Class* string = class_linker_->FindSystemClass("Ljava/lang/String;");
441 Class* charseq = class_linker_->FindSystemClass("Ljava/lang/CharSequence;");
442 // Can String be assigned to CharSequence without a cast?
443 EXPECT_TRUE(charseq->IsAssignableFrom(string));
444 // Can CharSequence be assigned to String without a cast?
445 EXPECT_FALSE(string->IsAssignableFrom(charseq));
446
447 // Primitive types are only assignable to themselves
448 const char* prims = "ZBCSIJFD";
449 Class* prim_types[strlen(prims)];
450 for (size_t i = 0; i < strlen(prims); i++) {
451 prim_types[i] = class_linker_->FindPrimitiveClass(prims[i]);
452 }
453 for (size_t i = 0; i < strlen(prims); i++) {
454 for (size_t j = 0; i < strlen(prims); i++) {
455 if (i == j) {
456 EXPECT_TRUE(prim_types[i]->IsAssignableFrom(prim_types[j]));
457 } else {
458 EXPECT_FALSE(prim_types[i]->IsAssignableFrom(prim_types[j]));
459 }
460 }
461 }
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700462}
463
464TEST_F(ObjectTest, IsAssignableFromArray) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700465 ScopedObjectAccess soa(Thread::Current());
466 jobject jclass_loader = LoadDex("XandY");
467 SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(jclass_loader));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700468 Class* X = class_linker_->FindClass("LX;", class_loader.get());
469 Class* Y = class_linker_->FindClass("LY;", class_loader.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700470 ASSERT_TRUE(X != NULL);
471 ASSERT_TRUE(Y != NULL);
472
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700473 Class* YA = class_linker_->FindClass("[LY;", class_loader.get());
474 Class* YAA = class_linker_->FindClass("[[LY;", class_loader.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700475 ASSERT_TRUE(YA != NULL);
476 ASSERT_TRUE(YAA != NULL);
477
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700478 Class* XAA = class_linker_->FindClass("[[LX;", class_loader.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700479 ASSERT_TRUE(XAA != NULL);
480
481 Class* O = class_linker_->FindSystemClass("Ljava/lang/Object;");
482 Class* OA = class_linker_->FindSystemClass("[Ljava/lang/Object;");
483 Class* OAA = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
484 Class* OAAA = class_linker_->FindSystemClass("[[[Ljava/lang/Object;");
485 ASSERT_TRUE(O != NULL);
486 ASSERT_TRUE(OA != NULL);
487 ASSERT_TRUE(OAA != NULL);
488 ASSERT_TRUE(OAAA != NULL);
489
490 Class* S = class_linker_->FindSystemClass("Ljava/io/Serializable;");
491 Class* SA = class_linker_->FindSystemClass("[Ljava/io/Serializable;");
492 Class* SAA = class_linker_->FindSystemClass("[[Ljava/io/Serializable;");
493 ASSERT_TRUE(S != NULL);
494 ASSERT_TRUE(SA != NULL);
495 ASSERT_TRUE(SAA != NULL);
496
497 Class* IA = class_linker_->FindSystemClass("[I");
498 ASSERT_TRUE(IA != NULL);
499
500 EXPECT_TRUE(YAA->IsAssignableFrom(YAA)); // identity
501 EXPECT_TRUE(XAA->IsAssignableFrom(YAA)); // element superclass
502 EXPECT_FALSE(YAA->IsAssignableFrom(XAA));
503 EXPECT_FALSE(Y->IsAssignableFrom(YAA));
504 EXPECT_FALSE(YA->IsAssignableFrom(YAA));
505 EXPECT_TRUE(O->IsAssignableFrom(YAA)); // everything is an Object
506 EXPECT_TRUE(OA->IsAssignableFrom(YAA));
507 EXPECT_TRUE(OAA->IsAssignableFrom(YAA));
508 EXPECT_TRUE(S->IsAssignableFrom(YAA)); // all arrays are Serializable
509 EXPECT_TRUE(SA->IsAssignableFrom(YAA));
510 EXPECT_FALSE(SAA->IsAssignableFrom(YAA)); // unless Y was Serializable
511
512 EXPECT_FALSE(IA->IsAssignableFrom(OA));
513 EXPECT_FALSE(OA->IsAssignableFrom(IA));
514 EXPECT_TRUE(O->IsAssignableFrom(IA));
515}
516
Elliott Hughescdf53122011-08-19 15:46:09 -0700517TEST_F(ObjectTest, FindInstanceField) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700518 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700519 SirtRef<String> s(String::AllocFromModifiedUtf8("ABC"));
520 ASSERT_TRUE(s.get() != NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700521 Class* c = s->GetClass();
522 ASSERT_TRUE(c != NULL);
523
524 // Wrong type.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700525 EXPECT_TRUE(c->FindDeclaredInstanceField("count", "J") == NULL);
526 EXPECT_TRUE(c->FindInstanceField("count", "J") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700527
528 // Wrong name.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700529 EXPECT_TRUE(c->FindDeclaredInstanceField("Count", "I") == NULL);
530 EXPECT_TRUE(c->FindInstanceField("Count", "I") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700531
532 // Right name and type.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700533 Field* f1 = c->FindDeclaredInstanceField("count", "I");
534 Field* f2 = c->FindInstanceField("count", "I");
Elliott Hughescdf53122011-08-19 15:46:09 -0700535 EXPECT_TRUE(f1 != NULL);
536 EXPECT_TRUE(f2 != NULL);
537 EXPECT_EQ(f1, f2);
538
539 // TODO: check that s.count == 3.
540
541 // Ensure that we handle superclass fields correctly...
542 c = class_linker_->FindSystemClass("Ljava/lang/StringBuilder;");
543 ASSERT_TRUE(c != NULL);
544 // No StringBuilder.count...
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700545 EXPECT_TRUE(c->FindDeclaredInstanceField("count", "I") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700546 // ...but there is an AbstractStringBuilder.count.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700547 EXPECT_TRUE(c->FindInstanceField("count", "I") != NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700548}
549
550TEST_F(ObjectTest, FindStaticField) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700551 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700552 SirtRef<String> s(String::AllocFromModifiedUtf8("ABC"));
553 ASSERT_TRUE(s.get() != NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700554 Class* c = s->GetClass();
555 ASSERT_TRUE(c != NULL);
556
557 // Wrong type.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700558 EXPECT_TRUE(c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "I") == NULL);
559 EXPECT_TRUE(c->FindStaticField("CASE_INSENSITIVE_ORDER", "I") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700560
561 // Wrong name.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700562 EXPECT_TRUE(c->FindDeclaredStaticField("cASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;") == NULL);
563 EXPECT_TRUE(c->FindStaticField("cASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700564
565 // Right name and type.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700566 Field* f1 = c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
567 Field* f2 = c->FindStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
Elliott Hughescdf53122011-08-19 15:46:09 -0700568 EXPECT_TRUE(f1 != NULL);
569 EXPECT_TRUE(f2 != NULL);
570 EXPECT_EQ(f1, f2);
571
572 // TODO: test static fields via superclasses.
573 // TODO: test static fields via interfaces.
574 // TODO: test that interfaces trump superclasses.
575}
576
Carl Shapiro894d0fa2011-06-30 14:48:49 -0700577} // namespace art