blob: 36371810f4cc94798e5eb29a6ff0544dc9c392f9 [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
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080022#include "array-inl.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070023#include "art_field-inl.h"
Ian Rogers1f539342012-10-03 21:09:42 -070024#include "asm_support.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080025#include "class-inl.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070026#include "class_linker.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080027#include "class_linker-inl.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070028#include "common_test.h"
29#include "dex_file.h"
Ian Rogers7655f292013-07-29 11:07:13 -070030#include "entrypoints/entrypoint_utils.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070031#include "gc/accounting/card_table-inl.h"
32#include "gc/heap.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080033#include "iftable-inl.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070034#include "art_method-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080035#include "object-inl.h"
36#include "object_array-inl.h"
Ian Rogers1f539342012-10-03 21:09:42 -070037#include "sirt_ref.h"
38#include "UniquePtr.h"
Carl Shapiro894d0fa2011-06-30 14:48:49 -070039
40namespace art {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080041namespace mirror {
Carl Shapiro894d0fa2011-06-30 14:48:49 -070042
Brian Carlstromf734cf52011-08-17 16:28:14 -070043class ObjectTest : public CommonTest {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070044 protected:
Brian Carlstrom0a02d122013-09-06 15:42:40 -070045 void AssertString(int32_t expected_utf16_length,
Brian Carlstrom0b138b22011-07-27 15:19:17 -070046 const char* utf8_in,
47 const char* utf16_expected_le,
Ian Rogers00f7d0e2012-07-19 15:28:27 -070048 int32_t expected_hash)
Ian Rogersb726dcb2012-09-05 08:57:23 -070049 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstrom0a02d122013-09-06 15:42:40 -070050 UniquePtr<uint16_t[]> utf16_expected(new uint16_t[expected_utf16_length]);
51 for (int32_t i = 0; i < expected_utf16_length; i++) {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070052 uint16_t ch = (((utf16_expected_le[i*2 + 0] & 0xff) << 8) |
53 ((utf16_expected_le[i*2 + 1] & 0xff) << 0));
54 utf16_expected[i] = ch;
55 }
56
Ian Rogers50b35e22012-10-04 10:09:15 -070057 Thread* self = Thread::Current();
Brian Carlstrom0a02d122013-09-06 15:42:40 -070058 SirtRef<String> string(self, String::AllocFromModifiedUtf8(self, expected_utf16_length, utf8_in));
59 ASSERT_EQ(expected_utf16_length, string->GetLength());
Carl Shapiro8860c0e2011-08-04 17:36:16 -070060 ASSERT_TRUE(string->GetCharArray() != NULL);
Jesse Wilsonfd687c52011-08-04 19:27:35 -070061 ASSERT_TRUE(string->GetCharArray()->GetData() != NULL);
Brian Carlstrom0a02d122013-09-06 15:42:40 -070062 // strlen is necessary because the 1-character string "\x00\x00" is interpreted as ""
63 ASSERT_TRUE(string->Equals(utf8_in) || (expected_utf16_length == 1 && strlen(utf8_in) == 0));
64 ASSERT_TRUE(string->Equals(StringPiece(utf8_in)) || (expected_utf16_length == 1 && strlen(utf8_in) == 0));
65 for (int32_t i = 0; i < expected_utf16_length; i++) {
Jesse Wilsonfd687c52011-08-04 19:27:35 -070066 EXPECT_EQ(utf16_expected[i], string->CharAt(i));
Brian Carlstrom0b138b22011-07-27 15:19:17 -070067 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070068 EXPECT_EQ(expected_hash, string->GetHashCode());
Brian Carlstrom0b138b22011-07-27 15:19:17 -070069 }
70};
Brian Carlstroma331b3c2011-07-18 17:47:56 -070071
buzbeefc9e6fa2012-03-23 15:14:29 -070072// Keep the assembly code in sync
73TEST_F(ObjectTest, AsmConstants) {
Ian Rogersa9a82542013-10-04 11:17:26 -070074 EXPECT_EQ(CLASS_OFFSET, Object::ClassOffset().Int32Value());
75 EXPECT_EQ(LOCK_WORD_OFFSET, Object::MonitorOffset().Int32Value());
Jeff Hao5d917302013-02-27 17:57:33 -080076
Ian Rogersa9a82542013-10-04 11:17:26 -070077 EXPECT_EQ(CLASS_COMPONENT_TYPE_OFFSET, Class::ComponentTypeOffset().Int32Value());
78
79 EXPECT_EQ(ARRAY_LENGTH_OFFSET, Array::LengthOffset().Int32Value());
80 EXPECT_EQ(OBJECT_ARRAY_DATA_OFFSET, Array::DataOffset(sizeof(Object*)).Int32Value());
81
82 EXPECT_EQ(STRING_VALUE_OFFSET, String::ValueOffset().Int32Value());
83 EXPECT_EQ(STRING_COUNT_OFFSET, String::CountOffset().Int32Value());
84 EXPECT_EQ(STRING_OFFSET_OFFSET, String::OffsetOffset().Int32Value());
85 EXPECT_EQ(STRING_DATA_OFFSET, Array::DataOffset(sizeof(uint16_t)).Int32Value());
86
Jeff Hao88474b42013-10-23 16:24:40 -070087 EXPECT_EQ(METHOD_DEX_CACHE_METHODS_OFFSET, ArtMethod::DexCacheResolvedMethodsOffset().Int32Value());
Ian Rogersa9a82542013-10-04 11:17:26 -070088 EXPECT_EQ(METHOD_CODE_OFFSET, ArtMethod::EntryPointFromCompiledCodeOffset().Int32Value());
buzbeefc9e6fa2012-03-23 15:14:29 -070089}
90
Brian Carlstroma331b3c2011-07-18 17:47:56 -070091TEST_F(ObjectTest, IsInSamePackage) {
Carl Shapiro894d0fa2011-06-30 14:48:49 -070092 // Matches
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080093 EXPECT_TRUE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/lang/Class;"));
94 EXPECT_TRUE(Class::IsInSamePackage("LFoo;", "LBar;"));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070095
96 // Mismatches
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080097 EXPECT_FALSE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/io/File;"));
98 EXPECT_FALSE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/lang/reflect/Method;"));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070099}
100
Elliott Hughes081be7f2011-09-18 16:50:26 -0700101TEST_F(ObjectTest, Clone) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700102 ScopedObjectAccess soa(Thread::Current());
Ian Rogers50b35e22012-10-04 10:09:15 -0700103 SirtRef<ObjectArray<Object> > a1(soa.Self(),
104 class_linker_->AllocObjectArray<Object>(soa.Self(), 256));
Elliott Hughes081be7f2011-09-18 16:50:26 -0700105 size_t s1 = a1->SizeOf();
Ian Rogers50b35e22012-10-04 10:09:15 -0700106 Object* clone = a1->Clone(soa.Self());
Elliott Hughes081be7f2011-09-18 16:50:26 -0700107 EXPECT_EQ(s1, clone->SizeOf());
108 EXPECT_TRUE(clone->GetClass() == a1->GetClass());
109}
110
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700111TEST_F(ObjectTest, AllocObjectArray) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700112 ScopedObjectAccess soa(Thread::Current());
Ian Rogers50b35e22012-10-04 10:09:15 -0700113 SirtRef<ObjectArray<Object> > oa(soa.Self(),
114 class_linker_->AllocObjectArray<Object>(soa.Self(), 2));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700115 EXPECT_EQ(2, oa->GetLength());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700116 EXPECT_TRUE(oa->Get(0) == NULL);
117 EXPECT_TRUE(oa->Get(1) == NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700118 oa->Set(0, oa.get());
119 EXPECT_TRUE(oa->Get(0) == oa.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700120 EXPECT_TRUE(oa->Get(1) == NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700121 oa->Set(1, oa.get());
122 EXPECT_TRUE(oa->Get(0) == oa.get());
123 EXPECT_TRUE(oa->Get(1) == oa.get());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700124
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700125 Class* aioobe = class_linker_->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
126
127 EXPECT_TRUE(oa->Get(-1) == NULL);
Ian Rogers1f539342012-10-03 21:09:42 -0700128 EXPECT_TRUE(soa.Self()->IsExceptionPending());
Ian Rogers62d6c772013-02-27 08:32:07 -0800129 EXPECT_EQ(aioobe, soa.Self()->GetException(NULL)->GetClass());
Ian Rogers1f539342012-10-03 21:09:42 -0700130 soa.Self()->ClearException();
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700131
132 EXPECT_TRUE(oa->Get(2) == NULL);
Ian Rogers1f539342012-10-03 21:09:42 -0700133 EXPECT_TRUE(soa.Self()->IsExceptionPending());
Ian Rogers62d6c772013-02-27 08:32:07 -0800134 EXPECT_EQ(aioobe, soa.Self()->GetException(NULL)->GetClass());
Ian Rogers1f539342012-10-03 21:09:42 -0700135 soa.Self()->ClearException();
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700136
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700137 ASSERT_TRUE(oa->GetClass() != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800138 ClassHelper oa_ch(oa->GetClass());
Ian Rogersd24e2642012-06-06 21:21:43 -0700139 ASSERT_EQ(2U, oa_ch.NumDirectInterfaces());
140 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/lang/Cloneable;"), oa_ch.GetDirectInterface(0));
141 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/io/Serializable;"), oa_ch.GetDirectInterface(1));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700142}
143
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700144TEST_F(ObjectTest, AllocArray) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700145 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700146 Class* c = class_linker_->FindSystemClass("[I");
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800147 SirtRef<Array> a(soa.Self(), Array::Alloc<true>(soa.Self(), c, 1));
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700148 ASSERT_TRUE(c == a->GetClass());
149
150 c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800151 a.reset(Array::Alloc<true>(soa.Self(), c, 1));
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700152 ASSERT_TRUE(c == a->GetClass());
153
154 c = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800155 a.reset(Array::Alloc<true>(soa.Self(), c, 1));
Elliott Hughes68f4fa02011-08-21 10:46:59 -0700156 ASSERT_TRUE(c == a->GetClass());
157}
158
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700159template<typename ArrayT>
160void TestPrimitiveArray(ClassLinker* cl) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700161 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700162 typedef typename ArrayT::ElementType T;
163
Ian Rogers50b35e22012-10-04 10:09:15 -0700164 ArrayT* a = ArrayT::Alloc(soa.Self(), 2);
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700165 EXPECT_EQ(2, a->GetLength());
166 EXPECT_EQ(0, a->Get(0));
167 EXPECT_EQ(0, a->Get(1));
168 a->Set(0, T(123));
169 EXPECT_EQ(T(123), a->Get(0));
170 EXPECT_EQ(0, a->Get(1));
171 a->Set(1, T(321));
172 EXPECT_EQ(T(123), a->Get(0));
173 EXPECT_EQ(T(321), a->Get(1));
174
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700175 Class* aioobe = cl->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
176
177 EXPECT_EQ(0, a->Get(-1));
Ian Rogers1f539342012-10-03 21:09:42 -0700178 EXPECT_TRUE(soa.Self()->IsExceptionPending());
Ian Rogers62d6c772013-02-27 08:32:07 -0800179 EXPECT_EQ(aioobe, soa.Self()->GetException(NULL)->GetClass());
Ian Rogers1f539342012-10-03 21:09:42 -0700180 soa.Self()->ClearException();
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700181
182 EXPECT_EQ(0, a->Get(2));
Ian Rogers1f539342012-10-03 21:09:42 -0700183 EXPECT_TRUE(soa.Self()->IsExceptionPending());
Ian Rogers62d6c772013-02-27 08:32:07 -0800184 EXPECT_EQ(aioobe, soa.Self()->GetException(NULL)->GetClass());
Ian Rogers1f539342012-10-03 21:09:42 -0700185 soa.Self()->ClearException();
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700186}
187
188TEST_F(ObjectTest, PrimitiveArray_Boolean_Alloc) {
189 TestPrimitiveArray<BooleanArray>(class_linker_);
190}
191TEST_F(ObjectTest, PrimitiveArray_Byte_Alloc) {
192 TestPrimitiveArray<ByteArray>(class_linker_);
193}
194TEST_F(ObjectTest, PrimitiveArray_Char_Alloc) {
195 TestPrimitiveArray<CharArray>(class_linker_);
196}
197TEST_F(ObjectTest, PrimitiveArray_Double_Alloc) {
198 TestPrimitiveArray<DoubleArray>(class_linker_);
199}
200TEST_F(ObjectTest, PrimitiveArray_Float_Alloc) {
201 TestPrimitiveArray<FloatArray>(class_linker_);
202}
203TEST_F(ObjectTest, PrimitiveArray_Int_Alloc) {
204 TestPrimitiveArray<IntArray>(class_linker_);
205}
206TEST_F(ObjectTest, PrimitiveArray_Long_Alloc) {
207 TestPrimitiveArray<LongArray>(class_linker_);
208}
209TEST_F(ObjectTest, PrimitiveArray_Short_Alloc) {
210 TestPrimitiveArray<ShortArray>(class_linker_);
211}
212
Elliott Hughesb408de72011-10-04 14:35:05 -0700213TEST_F(ObjectTest, CheckAndAllocArrayFromCode) {
Ian Rogersb886da82011-09-23 16:27:54 -0700214 // pretend we are trying to call 'new char[3]' from String.toCharArray
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700215 ScopedObjectAccess soa(Thread::Current());
Ian Rogersb886da82011-09-23 16:27:54 -0700216 Class* java_util_Arrays = class_linker_->FindSystemClass("Ljava/util/Arrays;");
Brian Carlstromea46f952013-07-30 01:26:50 -0700217 ArtMethod* sort = java_util_Arrays->FindDirectMethod("sort", "([I)V");
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800218 const DexFile::StringId* string_id = java_lang_dex_file_->FindStringId("[I");
219 ASSERT_TRUE(string_id != NULL);
220 const DexFile::TypeId* type_id = java_lang_dex_file_->FindTypeId(
221 java_lang_dex_file_->GetIndexForStringId(*string_id));
222 ASSERT_TRUE(type_id != NULL);
223 uint32_t type_idx = java_lang_dex_file_->GetIndexForTypeId(*type_id);
Hiroshi Yamauchie4e23c02013-12-06 13:38:43 -0800224 Object* array = CheckAndAllocArrayFromCodeInstrumented(type_idx, sort, 3, Thread::Current(), false,
225 Runtime::Current()->GetHeap()->GetCurrentAllocator());
Brian Carlstromb63ec392011-08-27 17:38:27 -0700226 EXPECT_TRUE(array->IsArrayInstance());
227 EXPECT_EQ(3, array->AsArray()->GetLength());
228 EXPECT_TRUE(array->GetClass()->IsArrayClass());
229 EXPECT_TRUE(array->GetClass()->GetComponentType()->IsPrimitive());
230}
231
Ian Rogers64b6d142012-10-29 16:34:15 -0700232TEST_F(ObjectTest, CreateMultiArray) {
233 ScopedObjectAccess soa(Thread::Current());
234
235 SirtRef<Class> c(soa.Self(), class_linker_->FindSystemClass("I"));
236 SirtRef<IntArray> dims(soa.Self(), IntArray::Alloc(soa.Self(), 1));
237 dims->Set(0, 1);
238 Array* multi = Array::CreateMultiArray(soa.Self(), c.get(), dims.get());
239 EXPECT_TRUE(multi->GetClass() == class_linker_->FindSystemClass("[I"));
240 EXPECT_EQ(1, multi->GetLength());
241
242 dims->Set(0, -1);
243 multi = Array::CreateMultiArray(soa.Self(), c.get(), dims.get());
244 EXPECT_TRUE(soa.Self()->IsExceptionPending());
Ian Rogers62d6c772013-02-27 08:32:07 -0800245 EXPECT_EQ(PrettyDescriptor(soa.Self()->GetException(NULL)->GetClass()),
Ian Rogers64b6d142012-10-29 16:34:15 -0700246 "java.lang.NegativeArraySizeException");
247 soa.Self()->ClearException();
248
249 dims.reset(IntArray::Alloc(soa.Self(), 2));
250 for (int i = 1; i < 20; ++i) {
251 for (int j = 0; j < 20; ++j) {
252 dims->Set(0, i);
253 dims->Set(1, j);
254 multi = Array::CreateMultiArray(soa.Self(), c.get(), dims.get());
255 EXPECT_TRUE(multi->GetClass() == class_linker_->FindSystemClass("[[I"));
256 EXPECT_EQ(i, multi->GetLength());
257 for (int k = 0; k < i; ++k) {
258 Array* outer = multi->AsObjectArray<Array>()->Get(k);
259 EXPECT_TRUE(outer->GetClass() == class_linker_->FindSystemClass("[I"));
260 EXPECT_EQ(j, outer->GetLength());
261 }
262 }
263 }
264}
265
Brian Carlstromb9edb842011-08-28 16:31:06 -0700266TEST_F(ObjectTest, StaticFieldFromCode) {
jeffhaoabcfde32011-09-29 15:05:18 -0700267 // pretend we are trying to access 'Static.s0' from StaticsFromCode.<clinit>
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700268 ScopedObjectAccess soa(Thread::Current());
269 jobject class_loader = LoadDex("StaticsFromCode");
270 const DexFile* dex_file = Runtime::Current()->GetCompileTimeClassPath(class_loader)[0];
Brian Carlstrom848a4b32011-09-04 11:29:27 -0700271 CHECK(dex_file != NULL);
272
Mathieu Chartier590fee92013-09-13 13:46:47 -0700273 SirtRef<mirror::ClassLoader> loader(soa.Self(), soa.Decode<ClassLoader*>(class_loader));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700274 Class* klass =
Mathieu Chartier590fee92013-09-13 13:46:47 -0700275 class_linker_->FindClass("LStaticsFromCode;", loader);
Ian Rogers241b5de2013-10-09 17:58:57 -0700276 ArtMethod* clinit = klass->FindClassInitializer();
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800277 const DexFile::StringId* klass_string_id = dex_file->FindStringId("LStaticsFromCode;");
278 ASSERT_TRUE(klass_string_id != NULL);
279 const DexFile::TypeId* klass_type_id = dex_file->FindTypeId(
280 dex_file->GetIndexForStringId(*klass_string_id));
281 ASSERT_TRUE(klass_type_id != NULL);
282
283 const DexFile::StringId* type_string_id = dex_file->FindStringId("Ljava/lang/Object;");
284 ASSERT_TRUE(type_string_id != NULL);
285 const DexFile::TypeId* type_type_id = dex_file->FindTypeId(
286 dex_file->GetIndexForStringId(*type_string_id));
287 ASSERT_TRUE(type_type_id != NULL);
288
289 const DexFile::StringId* name_str_id = dex_file->FindStringId("s0");
290 ASSERT_TRUE(name_str_id != NULL);
291
292 const DexFile::FieldId* field_id = dex_file->FindFieldId(
293 *klass_type_id, *name_str_id, *type_type_id);
294 ASSERT_TRUE(field_id != NULL);
295 uint32_t field_idx = dex_file->GetIndexForFieldId(*field_id);
296
Sebastien Hertzd4beb6b2013-10-02 17:07:20 +0200297 ArtField* field = FindFieldFromCode<StaticObjectRead, true>(field_idx, clinit, Thread::Current(),
298 sizeof(Object*));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700299 Object* s0 = field->GetObj(klass);
Ian Rogers64b6d142012-10-29 16:34:15 -0700300 EXPECT_TRUE(s0 != NULL);
Brian Carlstromb9edb842011-08-28 16:31:06 -0700301
Ian Rogers50b35e22012-10-04 10:09:15 -0700302 SirtRef<CharArray> char_array(soa.Self(), CharArray::Alloc(soa.Self(), 0));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700303 field->SetObj(field->GetDeclaringClass(), char_array.get());
304 EXPECT_EQ(char_array.get(), field->GetObj(klass));
Brian Carlstromb9edb842011-08-28 16:31:06 -0700305
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700306 field->SetObj(field->GetDeclaringClass(), NULL);
307 EXPECT_EQ(NULL, field->GetObj(klass));
Brian Carlstrom9f30b382011-08-28 22:41:38 -0700308
Brian Carlstromea46f952013-07-30 01:26:50 -0700309 // TODO: more exhaustive tests of all 6 cases of ArtField::*FromCode
Brian Carlstromb9edb842011-08-28 16:31:06 -0700310}
311
Brian Carlstrom0b138b22011-07-27 15:19:17 -0700312TEST_F(ObjectTest, String) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700313 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom0b138b22011-07-27 15:19:17 -0700314 // Test the empty string.
315 AssertString(0, "", "", 0);
316
317 // Test one-byte characters.
318 AssertString(1, " ", "\x00\x20", 0x20);
319 AssertString(1, "", "\x00\x00", 0);
320 AssertString(1, "\x7f", "\x00\x7f", 0x7f);
321 AssertString(2, "hi", "\x00\x68\x00\x69", (31 * 0x68) + 0x69);
322
323 // Test two-byte characters.
324 AssertString(1, "\xc2\x80", "\x00\x80", 0x80);
325 AssertString(1, "\xd9\xa6", "\x06\x66", 0x0666);
326 AssertString(1, "\xdf\xbf", "\x07\xff", 0x07ff);
327 AssertString(3, "h\xd9\xa6i", "\x00\x68\x06\x66\x00\x69", (31 * ((31 * 0x68) + 0x0666)) + 0x69);
328
329 // Test three-byte characters.
330 AssertString(1, "\xe0\xa0\x80", "\x08\x00", 0x0800);
331 AssertString(1, "\xe1\x88\xb4", "\x12\x34", 0x1234);
332 AssertString(1, "\xef\xbf\xbf", "\xff\xff", 0xffff);
333 AssertString(3, "h\xe1\x88\xb4i", "\x00\x68\x12\x34\x00\x69", (31 * ((31 * 0x68) + 0x1234)) + 0x69);
334}
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400335
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700336TEST_F(ObjectTest, StringEqualsUtf8) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700337 ScopedObjectAccess soa(Thread::Current());
Ian Rogers50b35e22012-10-04 10:09:15 -0700338 SirtRef<String> string(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "android"));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700339 EXPECT_TRUE(string->Equals("android"));
340 EXPECT_FALSE(string->Equals("Android"));
341 EXPECT_FALSE(string->Equals("ANDROID"));
342 EXPECT_FALSE(string->Equals(""));
343 EXPECT_FALSE(string->Equals("and"));
344 EXPECT_FALSE(string->Equals("androids"));
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700345
Ian Rogers50b35e22012-10-04 10:09:15 -0700346 SirtRef<String> empty(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), ""));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700347 EXPECT_TRUE(empty->Equals(""));
348 EXPECT_FALSE(empty->Equals("a"));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400349}
350
351TEST_F(ObjectTest, StringEquals) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700352 ScopedObjectAccess soa(Thread::Current());
Ian Rogers50b35e22012-10-04 10:09:15 -0700353 SirtRef<String> string(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "android"));
354 SirtRef<String> string_2(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "android"));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700355 EXPECT_TRUE(string->Equals(string_2.get()));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700356 EXPECT_FALSE(string->Equals("Android"));
357 EXPECT_FALSE(string->Equals("ANDROID"));
358 EXPECT_FALSE(string->Equals(""));
359 EXPECT_FALSE(string->Equals("and"));
360 EXPECT_FALSE(string->Equals("androids"));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400361
Ian Rogers50b35e22012-10-04 10:09:15 -0700362 SirtRef<String> empty(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), ""));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700363 EXPECT_TRUE(empty->Equals(""));
364 EXPECT_FALSE(empty->Equals("a"));
365}
366
Ian Rogers64b6d142012-10-29 16:34:15 -0700367TEST_F(ObjectTest, StringCompareTo) {
368 ScopedObjectAccess soa(Thread::Current());
369 SirtRef<String> string(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "android"));
370 SirtRef<String> string_2(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "android"));
371 SirtRef<String> string_3(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "Android"));
372 SirtRef<String> string_4(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "and"));
373 SirtRef<String> string_5(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), ""));
374 EXPECT_EQ(0, string->CompareTo(string_2.get()));
375 EXPECT_LT(0, string->CompareTo(string_3.get()));
376 EXPECT_GT(0, string_3->CompareTo(string.get()));
377 EXPECT_LT(0, string->CompareTo(string_4.get()));
378 EXPECT_GT(0, string_4->CompareTo(string.get()));
379 EXPECT_LT(0, string->CompareTo(string_5.get()));
380 EXPECT_GT(0, string_5->CompareTo(string.get()));
381}
382
jeffhao0ce13152012-03-27 19:45:50 -0700383TEST_F(ObjectTest, StringLength) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700384 ScopedObjectAccess soa(Thread::Current());
Ian Rogers50b35e22012-10-04 10:09:15 -0700385 SirtRef<String> string(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "android"));
jeffhao0ce13152012-03-27 19:45:50 -0700386 EXPECT_EQ(string->GetLength(), 7);
387 EXPECT_EQ(string->GetUtfLength(), 7);
388
389 string->SetOffset(2);
390 string->SetCount(5);
391 EXPECT_TRUE(string->Equals("droid"));
392 EXPECT_EQ(string->GetLength(), 5);
393 EXPECT_EQ(string->GetUtfLength(), 5);
394}
395
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700396TEST_F(ObjectTest, DescriptorCompare) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700397 // Two classloaders conflicts in compile_time_class_paths_.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700398 ScopedObjectAccess soa(Thread::Current());
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700399 ClassLinker* linker = class_linker_;
400
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700401 jobject jclass_loader_1 = LoadDex("ProtoCompare");
402 jobject jclass_loader_2 = LoadDex("ProtoCompare2");
Ian Rogers1f539342012-10-03 21:09:42 -0700403 SirtRef<ClassLoader> class_loader_1(soa.Self(), soa.Decode<ClassLoader*>(jclass_loader_1));
404 SirtRef<ClassLoader> class_loader_2(soa.Self(), soa.Decode<ClassLoader*>(jclass_loader_2));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700405
Mathieu Chartier590fee92013-09-13 13:46:47 -0700406 Class* klass1 = linker->FindClass("LProtoCompare;", class_loader_1);
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700407 ASSERT_TRUE(klass1 != NULL);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700408 Class* klass2 = linker->FindClass("LProtoCompare2;", class_loader_2);
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700409 ASSERT_TRUE(klass2 != NULL);
410
Brian Carlstromea46f952013-07-30 01:26:50 -0700411 ArtMethod* m1_1 = klass1->GetVirtualMethod(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800412 MethodHelper mh(m1_1);
413 EXPECT_STREQ(mh.GetName(), "m1");
Brian Carlstromea46f952013-07-30 01:26:50 -0700414 ArtMethod* m2_1 = klass1->GetVirtualMethod(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800415 mh.ChangeMethod(m2_1);
416 EXPECT_STREQ(mh.GetName(), "m2");
Brian Carlstromea46f952013-07-30 01:26:50 -0700417 ArtMethod* m3_1 = klass1->GetVirtualMethod(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800418 mh.ChangeMethod(m3_1);
419 EXPECT_STREQ(mh.GetName(), "m3");
Brian Carlstromea46f952013-07-30 01:26:50 -0700420 ArtMethod* m4_1 = klass1->GetVirtualMethod(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800421 mh.ChangeMethod(m4_1);
422 EXPECT_STREQ(mh.GetName(), "m4");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700423
Brian Carlstromea46f952013-07-30 01:26:50 -0700424 ArtMethod* m1_2 = klass2->GetVirtualMethod(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800425 mh.ChangeMethod(m1_2);
426 EXPECT_STREQ(mh.GetName(), "m1");
Brian Carlstromea46f952013-07-30 01:26:50 -0700427 ArtMethod* m2_2 = klass2->GetVirtualMethod(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800428 mh.ChangeMethod(m2_2);
429 EXPECT_STREQ(mh.GetName(), "m2");
Brian Carlstromea46f952013-07-30 01:26:50 -0700430 ArtMethod* m3_2 = klass2->GetVirtualMethod(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800431 mh.ChangeMethod(m3_2);
432 EXPECT_STREQ(mh.GetName(), "m3");
Brian Carlstromea46f952013-07-30 01:26:50 -0700433 ArtMethod* m4_2 = klass2->GetVirtualMethod(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800434 mh.ChangeMethod(m4_2);
435 EXPECT_STREQ(mh.GetName(), "m4");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700436
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800437 mh.ChangeMethod(m1_1);
438 MethodHelper mh2(m1_2);
439 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
440 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700441
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800442 mh.ChangeMethod(m2_1);
443 mh2.ChangeMethod(m2_2);
444 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
445 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700446
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800447 mh.ChangeMethod(m3_1);
448 mh2.ChangeMethod(m3_2);
449 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
450 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700451
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800452 mh.ChangeMethod(m4_1);
453 mh2.ChangeMethod(m4_2);
454 EXPECT_TRUE(mh.HasSameNameAndSignature(&mh2));
455 EXPECT_TRUE(mh2.HasSameNameAndSignature(&mh));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400456}
457
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700458TEST_F(ObjectTest, StringHashCode) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700459 ScopedObjectAccess soa(Thread::Current());
Ian Rogers50b35e22012-10-04 10:09:15 -0700460 SirtRef<String> empty(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), ""));
461 SirtRef<String> A(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "A"));
462 SirtRef<String> ABC(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "ABC"));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700463
464 EXPECT_EQ(0, empty->GetHashCode());
465 EXPECT_EQ(65, A->GetHashCode());
466 EXPECT_EQ(64578, ABC->GetHashCode());
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700467}
468
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700469TEST_F(ObjectTest, InstanceOf) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700470 ScopedObjectAccess soa(Thread::Current());
471 jobject jclass_loader = LoadDex("XandY");
Ian Rogers1f539342012-10-03 21:09:42 -0700472 SirtRef<ClassLoader> class_loader(soa.Self(), soa.Decode<ClassLoader*>(jclass_loader));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700473
Mathieu Chartier590fee92013-09-13 13:46:47 -0700474 Class* X = class_linker_->FindClass("LX;", class_loader);
475 Class* Y = class_linker_->FindClass("LY;", class_loader);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700476 ASSERT_TRUE(X != NULL);
477 ASSERT_TRUE(Y != NULL);
478
Ian Rogers50b35e22012-10-04 10:09:15 -0700479 SirtRef<Object> x(soa.Self(), X->AllocObject(soa.Self()));
480 SirtRef<Object> y(soa.Self(), Y->AllocObject(soa.Self()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700481 ASSERT_TRUE(x.get() != NULL);
482 ASSERT_TRUE(y.get() != NULL);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700483
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700484 EXPECT_TRUE(x->InstanceOf(X));
485 EXPECT_FALSE(x->InstanceOf(Y));
486 EXPECT_TRUE(y->InstanceOf(X));
487 EXPECT_TRUE(y->InstanceOf(Y));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700488
Elliott Hughes92f14b22011-10-06 12:29:54 -0700489 Class* java_lang_Class = class_linker_->FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700490 Class* Object_array_class = class_linker_->FindSystemClass("[Ljava/lang/Object;");
Elliott Hughes92f14b22011-10-06 12:29:54 -0700491
492 EXPECT_FALSE(java_lang_Class->InstanceOf(Object_array_class));
493 EXPECT_TRUE(Object_array_class->InstanceOf(java_lang_Class));
494
495 // All array classes implement Cloneable and Serializable.
Ian Rogers50b35e22012-10-04 10:09:15 -0700496 Object* array = ObjectArray<Object>::Alloc(soa.Self(), Object_array_class, 1);
Elliott Hughes92f14b22011-10-06 12:29:54 -0700497 Class* java_lang_Cloneable = class_linker_->FindSystemClass("Ljava/lang/Cloneable;");
498 Class* java_io_Serializable = class_linker_->FindSystemClass("Ljava/io/Serializable;");
499 EXPECT_TRUE(array->InstanceOf(java_lang_Cloneable));
500 EXPECT_TRUE(array->InstanceOf(java_io_Serializable));
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700501}
502
503TEST_F(ObjectTest, IsAssignableFrom) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700504 ScopedObjectAccess soa(Thread::Current());
505 jobject jclass_loader = LoadDex("XandY");
Ian Rogers1f539342012-10-03 21:09:42 -0700506 SirtRef<ClassLoader> class_loader(soa.Self(), soa.Decode<ClassLoader*>(jclass_loader));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700507 Class* X = class_linker_->FindClass("LX;", class_loader);
508 Class* Y = class_linker_->FindClass("LY;", class_loader);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700509
510 EXPECT_TRUE(X->IsAssignableFrom(X));
511 EXPECT_TRUE(X->IsAssignableFrom(Y));
512 EXPECT_FALSE(Y->IsAssignableFrom(X));
513 EXPECT_TRUE(Y->IsAssignableFrom(Y));
Ian Rogersd81871c2011-10-03 13:57:23 -0700514
515 // class final String implements CharSequence, ..
516 Class* string = class_linker_->FindSystemClass("Ljava/lang/String;");
517 Class* charseq = class_linker_->FindSystemClass("Ljava/lang/CharSequence;");
518 // Can String be assigned to CharSequence without a cast?
519 EXPECT_TRUE(charseq->IsAssignableFrom(string));
520 // Can CharSequence be assigned to String without a cast?
521 EXPECT_FALSE(string->IsAssignableFrom(charseq));
522
523 // Primitive types are only assignable to themselves
524 const char* prims = "ZBCSIJFD";
525 Class* prim_types[strlen(prims)];
526 for (size_t i = 0; i < strlen(prims); i++) {
527 prim_types[i] = class_linker_->FindPrimitiveClass(prims[i]);
528 }
529 for (size_t i = 0; i < strlen(prims); i++) {
530 for (size_t j = 0; i < strlen(prims); i++) {
531 if (i == j) {
532 EXPECT_TRUE(prim_types[i]->IsAssignableFrom(prim_types[j]));
533 } else {
534 EXPECT_FALSE(prim_types[i]->IsAssignableFrom(prim_types[j]));
535 }
536 }
537 }
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700538}
539
540TEST_F(ObjectTest, IsAssignableFromArray) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700541 ScopedObjectAccess soa(Thread::Current());
542 jobject jclass_loader = LoadDex("XandY");
Ian Rogers1f539342012-10-03 21:09:42 -0700543 SirtRef<ClassLoader> class_loader(soa.Self(), soa.Decode<ClassLoader*>(jclass_loader));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700544 Class* X = class_linker_->FindClass("LX;", class_loader);
545 Class* Y = class_linker_->FindClass("LY;", class_loader);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700546 ASSERT_TRUE(X != NULL);
547 ASSERT_TRUE(Y != NULL);
548
Mathieu Chartier590fee92013-09-13 13:46:47 -0700549 Class* YA = class_linker_->FindClass("[LY;", class_loader);
550 Class* YAA = class_linker_->FindClass("[[LY;", class_loader);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700551 ASSERT_TRUE(YA != NULL);
552 ASSERT_TRUE(YAA != NULL);
553
Mathieu Chartier590fee92013-09-13 13:46:47 -0700554 Class* XAA = class_linker_->FindClass("[[LX;", class_loader);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700555 ASSERT_TRUE(XAA != NULL);
556
557 Class* O = class_linker_->FindSystemClass("Ljava/lang/Object;");
558 Class* OA = class_linker_->FindSystemClass("[Ljava/lang/Object;");
559 Class* OAA = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
560 Class* OAAA = class_linker_->FindSystemClass("[[[Ljava/lang/Object;");
561 ASSERT_TRUE(O != NULL);
562 ASSERT_TRUE(OA != NULL);
563 ASSERT_TRUE(OAA != NULL);
564 ASSERT_TRUE(OAAA != NULL);
565
566 Class* S = class_linker_->FindSystemClass("Ljava/io/Serializable;");
567 Class* SA = class_linker_->FindSystemClass("[Ljava/io/Serializable;");
568 Class* SAA = class_linker_->FindSystemClass("[[Ljava/io/Serializable;");
569 ASSERT_TRUE(S != NULL);
570 ASSERT_TRUE(SA != NULL);
571 ASSERT_TRUE(SAA != NULL);
572
573 Class* IA = class_linker_->FindSystemClass("[I");
574 ASSERT_TRUE(IA != NULL);
575
576 EXPECT_TRUE(YAA->IsAssignableFrom(YAA)); // identity
577 EXPECT_TRUE(XAA->IsAssignableFrom(YAA)); // element superclass
578 EXPECT_FALSE(YAA->IsAssignableFrom(XAA));
579 EXPECT_FALSE(Y->IsAssignableFrom(YAA));
580 EXPECT_FALSE(YA->IsAssignableFrom(YAA));
581 EXPECT_TRUE(O->IsAssignableFrom(YAA)); // everything is an Object
582 EXPECT_TRUE(OA->IsAssignableFrom(YAA));
583 EXPECT_TRUE(OAA->IsAssignableFrom(YAA));
584 EXPECT_TRUE(S->IsAssignableFrom(YAA)); // all arrays are Serializable
585 EXPECT_TRUE(SA->IsAssignableFrom(YAA));
586 EXPECT_FALSE(SAA->IsAssignableFrom(YAA)); // unless Y was Serializable
587
588 EXPECT_FALSE(IA->IsAssignableFrom(OA));
589 EXPECT_FALSE(OA->IsAssignableFrom(IA));
590 EXPECT_TRUE(O->IsAssignableFrom(IA));
591}
592
Elliott Hughescdf53122011-08-19 15:46:09 -0700593TEST_F(ObjectTest, FindInstanceField) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700594 ScopedObjectAccess soa(Thread::Current());
Ian Rogers50b35e22012-10-04 10:09:15 -0700595 SirtRef<String> s(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "ABC"));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700596 ASSERT_TRUE(s.get() != NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700597 Class* c = s->GetClass();
598 ASSERT_TRUE(c != NULL);
599
600 // Wrong type.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700601 EXPECT_TRUE(c->FindDeclaredInstanceField("count", "J") == NULL);
602 EXPECT_TRUE(c->FindInstanceField("count", "J") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700603
604 // Wrong name.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700605 EXPECT_TRUE(c->FindDeclaredInstanceField("Count", "I") == NULL);
606 EXPECT_TRUE(c->FindInstanceField("Count", "I") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700607
608 // Right name and type.
Brian Carlstromea46f952013-07-30 01:26:50 -0700609 ArtField* f1 = c->FindDeclaredInstanceField("count", "I");
610 ArtField* f2 = c->FindInstanceField("count", "I");
Elliott Hughescdf53122011-08-19 15:46:09 -0700611 EXPECT_TRUE(f1 != NULL);
612 EXPECT_TRUE(f2 != NULL);
613 EXPECT_EQ(f1, f2);
614
615 // TODO: check that s.count == 3.
616
617 // Ensure that we handle superclass fields correctly...
618 c = class_linker_->FindSystemClass("Ljava/lang/StringBuilder;");
619 ASSERT_TRUE(c != NULL);
620 // No StringBuilder.count...
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700621 EXPECT_TRUE(c->FindDeclaredInstanceField("count", "I") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700622 // ...but there is an AbstractStringBuilder.count.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700623 EXPECT_TRUE(c->FindInstanceField("count", "I") != NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700624}
625
626TEST_F(ObjectTest, FindStaticField) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700627 ScopedObjectAccess soa(Thread::Current());
Ian Rogers50b35e22012-10-04 10:09:15 -0700628 SirtRef<String> s(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "ABC"));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700629 ASSERT_TRUE(s.get() != NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700630 Class* c = s->GetClass();
631 ASSERT_TRUE(c != NULL);
632
633 // Wrong type.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700634 EXPECT_TRUE(c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "I") == NULL);
635 EXPECT_TRUE(c->FindStaticField("CASE_INSENSITIVE_ORDER", "I") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700636
637 // Wrong name.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700638 EXPECT_TRUE(c->FindDeclaredStaticField("cASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;") == NULL);
639 EXPECT_TRUE(c->FindStaticField("cASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;") == NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -0700640
641 // Right name and type.
Brian Carlstromea46f952013-07-30 01:26:50 -0700642 ArtField* f1 = c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
643 ArtField* f2 = c->FindStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
Elliott Hughescdf53122011-08-19 15:46:09 -0700644 EXPECT_TRUE(f1 != NULL);
645 EXPECT_TRUE(f2 != NULL);
646 EXPECT_EQ(f1, f2);
647
648 // TODO: test static fields via superclasses.
649 // TODO: test static fields via interfaces.
650 // TODO: test that interfaces trump superclasses.
651}
652
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800653} // namespace mirror
Carl Shapiro894d0fa2011-06-30 14:48:49 -0700654} // namespace art