1 /* 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 */ 16 17 #include "object.h" 18 19 #include <stdint.h> 20 #include <stdio.h> 21 #include <memory> 22 23 #include "array-inl.h" 24 #include "art_field-inl.h" 25 #include "art_method-inl.h" 26 #include "asm_support.h" 27 #include "class-inl.h" 28 #include "class_linker.h" 29 #include "class_linker-inl.h" 30 #include "common_runtime_test.h" 31 #include "dex_file.h" 32 #include "entrypoints/entrypoint_utils-inl.h" 33 #include "gc/accounting/card_table-inl.h" 34 #include "gc/heap.h" 35 #include "handle_scope-inl.h" 36 #include "iftable-inl.h" 37 #include "object-inl.h" 38 #include "object_array-inl.h" 39 #include "scoped_thread_state_change.h" 40 #include "string-inl.h" 41 42 namespace art { 43 namespace mirror { 44 45 class ObjectTest : public CommonRuntimeTest { 46 protected: 47 void AssertString(int32_t expected_utf16_length, 48 const char* utf8_in, 49 const char* utf16_expected_le, 50 int32_t expected_hash) 51 SHARED_REQUIRES(Locks::mutator_lock_) { 52 std::unique_ptr<uint16_t[]> utf16_expected(new uint16_t[expected_utf16_length]); 53 for (int32_t i = 0; i < expected_utf16_length; i++) { 54 uint16_t ch = (((utf16_expected_le[i*2 + 0] & 0xff) << 8) | 55 ((utf16_expected_le[i*2 + 1] & 0xff) << 0)); 56 utf16_expected[i] = ch; 57 } 58 59 Thread* self = Thread::Current(); 60 StackHandleScope<1> hs(self); 61 Handle<String> string( 62 hs.NewHandle(String::AllocFromModifiedUtf8(self, expected_utf16_length, utf8_in))); 63 ASSERT_EQ(expected_utf16_length, string->GetLength()); 64 ASSERT_TRUE(string->GetValue() != nullptr); 65 // strlen is necessary because the 1-character string "\x00\x00" is interpreted as "" 66 ASSERT_TRUE(string->Equals(utf8_in) || (expected_utf16_length == 1 && strlen(utf8_in) == 0)); 67 ASSERT_TRUE(string->Equals(StringPiece(utf8_in)) || 68 (expected_utf16_length == 1 && strlen(utf8_in) == 0)); 69 for (int32_t i = 0; i < expected_utf16_length; i++) { 70 EXPECT_EQ(utf16_expected[i], string->CharAt(i)); 71 } 72 EXPECT_EQ(expected_hash, string->GetHashCode()); 73 } 74 }; 75 76 // Keep constants in sync. 77 TEST_F(ObjectTest, Constants) { 78 EXPECT_EQ(kObjectReferenceSize, sizeof(HeapReference<Object>)); 79 EXPECT_EQ(kObjectHeaderSize, sizeof(Object)); 80 EXPECT_EQ(ART_METHOD_QUICK_CODE_OFFSET_32, 81 ArtMethod::EntryPointFromQuickCompiledCodeOffset(4).Int32Value()); 82 EXPECT_EQ(ART_METHOD_QUICK_CODE_OFFSET_64, 83 ArtMethod::EntryPointFromQuickCompiledCodeOffset(8).Int32Value()); 84 } 85 86 TEST_F(ObjectTest, IsInSamePackage) { 87 // Matches 88 EXPECT_TRUE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/lang/Class;")); 89 EXPECT_TRUE(Class::IsInSamePackage("LFoo;", "LBar;")); 90 91 // Mismatches 92 EXPECT_FALSE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/io/File;")); 93 EXPECT_FALSE(Class::IsInSamePackage("Ljava/lang/Object;", "Ljava/lang/reflect/Method;")); 94 } 95 96 TEST_F(ObjectTest, Clone) { 97 ScopedObjectAccess soa(Thread::Current()); 98 StackHandleScope<2> hs(soa.Self()); 99 Handle<ObjectArray<Object>> a1( 100 hs.NewHandle(class_linker_->AllocObjectArray<Object>(soa.Self(), 256))); 101 size_t s1 = a1->SizeOf(); 102 Object* clone = a1->Clone(soa.Self()); 103 EXPECT_EQ(s1, clone->SizeOf()); 104 EXPECT_TRUE(clone->GetClass() == a1->GetClass()); 105 } 106 107 TEST_F(ObjectTest, AllocObjectArray) { 108 ScopedObjectAccess soa(Thread::Current()); 109 StackHandleScope<2> hs(soa.Self()); 110 Handle<ObjectArray<Object>> oa( 111 hs.NewHandle(class_linker_->AllocObjectArray<Object>(soa.Self(), 2))); 112 EXPECT_EQ(2, oa->GetLength()); 113 EXPECT_TRUE(oa->Get(0) == nullptr); 114 EXPECT_TRUE(oa->Get(1) == nullptr); 115 oa->Set<false>(0, oa.Get()); 116 EXPECT_TRUE(oa->Get(0) == oa.Get()); 117 EXPECT_TRUE(oa->Get(1) == nullptr); 118 oa->Set<false>(1, oa.Get()); 119 EXPECT_TRUE(oa->Get(0) == oa.Get()); 120 EXPECT_TRUE(oa->Get(1) == oa.Get()); 121 122 Class* aioobe = class_linker_->FindSystemClass(soa.Self(), 123 "Ljava/lang/ArrayIndexOutOfBoundsException;"); 124 125 EXPECT_TRUE(oa->Get(-1) == nullptr); 126 EXPECT_TRUE(soa.Self()->IsExceptionPending()); 127 EXPECT_EQ(aioobe, soa.Self()->GetException()->GetClass()); 128 soa.Self()->ClearException(); 129 130 EXPECT_TRUE(oa->Get(2) == nullptr); 131 EXPECT_TRUE(soa.Self()->IsExceptionPending()); 132 EXPECT_EQ(aioobe, soa.Self()->GetException()->GetClass()); 133 soa.Self()->ClearException(); 134 135 ASSERT_TRUE(oa->GetClass() != nullptr); 136 Handle<mirror::Class> klass(hs.NewHandle(oa->GetClass())); 137 ASSERT_EQ(2U, klass->NumDirectInterfaces()); 138 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Cloneable;"), 139 mirror::Class::GetDirectInterface(soa.Self(), klass, 0)); 140 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "Ljava/io/Serializable;"), 141 mirror::Class::GetDirectInterface(soa.Self(), klass, 1)); 142 } 143 144 TEST_F(ObjectTest, AllocArray) { 145 ScopedObjectAccess soa(Thread::Current()); 146 Class* c = class_linker_->FindSystemClass(soa.Self(), "[I"); 147 StackHandleScope<1> hs(soa.Self()); 148 MutableHandle<Array> a( 149 hs.NewHandle(Array::Alloc<true>(soa.Self(), c, 1, c->GetComponentSizeShift(), 150 Runtime::Current()->GetHeap()->GetCurrentAllocator()))); 151 EXPECT_TRUE(c == a->GetClass()); 152 EXPECT_EQ(1, a->GetLength()); 153 154 c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;"); 155 a.Assign(Array::Alloc<true>(soa.Self(), c, 1, c->GetComponentSizeShift(), 156 Runtime::Current()->GetHeap()->GetCurrentAllocator())); 157 EXPECT_TRUE(c == a->GetClass()); 158 EXPECT_EQ(1, a->GetLength()); 159 160 c = class_linker_->FindSystemClass(soa.Self(), "[[Ljava/lang/Object;"); 161 a.Assign(Array::Alloc<true>(soa.Self(), c, 1, c->GetComponentSizeShift(), 162 Runtime::Current()->GetHeap()->GetCurrentAllocator())); 163 EXPECT_TRUE(c == a->GetClass()); 164 EXPECT_EQ(1, a->GetLength()); 165 } 166 167 TEST_F(ObjectTest, AllocArray_FillUsable) { 168 ScopedObjectAccess soa(Thread::Current()); 169 Class* c = class_linker_->FindSystemClass(soa.Self(), "[B"); 170 StackHandleScope<1> hs(soa.Self()); 171 MutableHandle<Array> a( 172 hs.NewHandle(Array::Alloc<true, true>(soa.Self(), c, 1, c->GetComponentSizeShift(), 173 Runtime::Current()->GetHeap()->GetCurrentAllocator()))); 174 EXPECT_TRUE(c == a->GetClass()); 175 EXPECT_LE(1, a->GetLength()); 176 177 c = class_linker_->FindSystemClass(soa.Self(), "[I"); 178 a.Assign(Array::Alloc<true, true>(soa.Self(), c, 2, c->GetComponentSizeShift(), 179 Runtime::Current()->GetHeap()->GetCurrentAllocator())); 180 EXPECT_TRUE(c == a->GetClass()); 181 EXPECT_LE(2, a->GetLength()); 182 183 c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;"); 184 a.Assign(Array::Alloc<true, true>(soa.Self(), c, 2, c->GetComponentSizeShift(), 185 Runtime::Current()->GetHeap()->GetCurrentAllocator())); 186 EXPECT_TRUE(c == a->GetClass()); 187 EXPECT_LE(2, a->GetLength()); 188 189 c = class_linker_->FindSystemClass(soa.Self(), "[[Ljava/lang/Object;"); 190 a.Assign(Array::Alloc<true, true>(soa.Self(), c, 2, c->GetComponentSizeShift(), 191 Runtime::Current()->GetHeap()->GetCurrentAllocator())); 192 EXPECT_TRUE(c == a->GetClass()); 193 EXPECT_LE(2, a->GetLength()); 194 } 195 196 template<typename ArrayT> 197 void TestPrimitiveArray(ClassLinker* cl) { 198 ScopedObjectAccess soa(Thread::Current()); 199 typedef typename ArrayT::ElementType T; 200 201 ArrayT* a = ArrayT::Alloc(soa.Self(), 2); 202 EXPECT_EQ(2, a->GetLength()); 203 EXPECT_EQ(0, a->Get(0)); 204 EXPECT_EQ(0, a->Get(1)); 205 a->Set(0, T(123)); 206 EXPECT_EQ(T(123), a->Get(0)); 207 EXPECT_EQ(0, a->Get(1)); 208 a->Set(1, T(321)); 209 EXPECT_EQ(T(123), a->Get(0)); 210 EXPECT_EQ(T(321), a->Get(1)); 211 212 Class* aioobe = cl->FindSystemClass(soa.Self(), "Ljava/lang/ArrayIndexOutOfBoundsException;"); 213 214 EXPECT_EQ(0, a->Get(-1)); 215 EXPECT_TRUE(soa.Self()->IsExceptionPending()); 216 EXPECT_EQ(aioobe, soa.Self()->GetException()->GetClass()); 217 soa.Self()->ClearException(); 218 219 EXPECT_EQ(0, a->Get(2)); 220 EXPECT_TRUE(soa.Self()->IsExceptionPending()); 221 EXPECT_EQ(aioobe, soa.Self()->GetException()->GetClass()); 222 soa.Self()->ClearException(); 223 } 224 225 TEST_F(ObjectTest, PrimitiveArray_Boolean_Alloc) { 226 TestPrimitiveArray<BooleanArray>(class_linker_); 227 } 228 TEST_F(ObjectTest, PrimitiveArray_Byte_Alloc) { 229 TestPrimitiveArray<ByteArray>(class_linker_); 230 } 231 TEST_F(ObjectTest, PrimitiveArray_Char_Alloc) { 232 TestPrimitiveArray<CharArray>(class_linker_); 233 } 234 TEST_F(ObjectTest, PrimitiveArray_Int_Alloc) { 235 TestPrimitiveArray<IntArray>(class_linker_); 236 } 237 TEST_F(ObjectTest, PrimitiveArray_Long_Alloc) { 238 TestPrimitiveArray<LongArray>(class_linker_); 239 } 240 TEST_F(ObjectTest, PrimitiveArray_Short_Alloc) { 241 TestPrimitiveArray<ShortArray>(class_linker_); 242 } 243 244 TEST_F(ObjectTest, PrimitiveArray_Double_Alloc) { 245 typedef DoubleArray ArrayT; 246 ScopedObjectAccess soa(Thread::Current()); 247 typedef typename ArrayT::ElementType T; 248 249 ArrayT* a = ArrayT::Alloc(soa.Self(), 2); 250 EXPECT_EQ(2, a->GetLength()); 251 EXPECT_DOUBLE_EQ(0, a->Get(0)); 252 EXPECT_DOUBLE_EQ(0, a->Get(1)); 253 a->Set(0, T(123)); 254 EXPECT_DOUBLE_EQ(T(123), a->Get(0)); 255 EXPECT_DOUBLE_EQ(0, a->Get(1)); 256 a->Set(1, T(321)); 257 EXPECT_DOUBLE_EQ(T(123), a->Get(0)); 258 EXPECT_DOUBLE_EQ(T(321), a->Get(1)); 259 260 Class* aioobe = class_linker_->FindSystemClass(soa.Self(), 261 "Ljava/lang/ArrayIndexOutOfBoundsException;"); 262 263 EXPECT_DOUBLE_EQ(0, a->Get(-1)); 264 EXPECT_TRUE(soa.Self()->IsExceptionPending()); 265 EXPECT_EQ(aioobe, soa.Self()->GetException()->GetClass()); 266 soa.Self()->ClearException(); 267 268 EXPECT_DOUBLE_EQ(0, a->Get(2)); 269 EXPECT_TRUE(soa.Self()->IsExceptionPending()); 270 EXPECT_EQ(aioobe, soa.Self()->GetException()->GetClass()); 271 soa.Self()->ClearException(); 272 } 273 274 TEST_F(ObjectTest, PrimitiveArray_Float_Alloc) { 275 typedef FloatArray ArrayT; 276 ScopedObjectAccess soa(Thread::Current()); 277 typedef typename ArrayT::ElementType T; 278 279 ArrayT* a = ArrayT::Alloc(soa.Self(), 2); 280 EXPECT_FLOAT_EQ(2, a->GetLength()); 281 EXPECT_FLOAT_EQ(0, a->Get(0)); 282 EXPECT_FLOAT_EQ(0, a->Get(1)); 283 a->Set(0, T(123)); 284 EXPECT_FLOAT_EQ(T(123), a->Get(0)); 285 EXPECT_FLOAT_EQ(0, a->Get(1)); 286 a->Set(1, T(321)); 287 EXPECT_FLOAT_EQ(T(123), a->Get(0)); 288 EXPECT_FLOAT_EQ(T(321), a->Get(1)); 289 290 Class* aioobe = class_linker_->FindSystemClass(soa.Self(), 291 "Ljava/lang/ArrayIndexOutOfBoundsException;"); 292 293 EXPECT_FLOAT_EQ(0, a->Get(-1)); 294 EXPECT_TRUE(soa.Self()->IsExceptionPending()); 295 EXPECT_EQ(aioobe, soa.Self()->GetException()->GetClass()); 296 soa.Self()->ClearException(); 297 298 EXPECT_FLOAT_EQ(0, a->Get(2)); 299 EXPECT_TRUE(soa.Self()->IsExceptionPending()); 300 EXPECT_EQ(aioobe, soa.Self()->GetException()->GetClass()); 301 soa.Self()->ClearException(); 302 } 303 304 305 TEST_F(ObjectTest, CheckAndAllocArrayFromCode) { 306 // pretend we are trying to call 'new char[3]' from String.toCharArray 307 ScopedObjectAccess soa(Thread::Current()); 308 Class* java_util_Arrays = class_linker_->FindSystemClass(soa.Self(), "Ljava/util/Arrays;"); 309 ArtMethod* sort = java_util_Arrays->FindDirectMethod("sort", "([I)V", sizeof(void*)); 310 const DexFile::TypeId* type_id = java_lang_dex_file_->FindTypeId("[I"); 311 ASSERT_TRUE(type_id != nullptr); 312 uint32_t type_idx = java_lang_dex_file_->GetIndexForTypeId(*type_id); 313 Object* array = CheckAndAllocArrayFromCodeInstrumented( 314 type_idx, 3, sort, Thread::Current(), false, 315 Runtime::Current()->GetHeap()->GetCurrentAllocator()); 316 EXPECT_TRUE(array->IsArrayInstance()); 317 EXPECT_EQ(3, array->AsArray()->GetLength()); 318 EXPECT_TRUE(array->GetClass()->IsArrayClass()); 319 EXPECT_TRUE(array->GetClass()->GetComponentType()->IsPrimitive()); 320 } 321 322 TEST_F(ObjectTest, CreateMultiArray) { 323 ScopedObjectAccess soa(Thread::Current()); 324 325 StackHandleScope<2> hs(soa.Self()); 326 Handle<Class> c(hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "I"))); 327 MutableHandle<IntArray> dims(hs.NewHandle(IntArray::Alloc(soa.Self(), 1))); 328 dims->Set<false>(0, 1); 329 Array* multi = Array::CreateMultiArray(soa.Self(), c, dims); 330 EXPECT_TRUE(multi->GetClass() == class_linker_->FindSystemClass(soa.Self(), "[I")); 331 EXPECT_EQ(1, multi->GetLength()); 332 333 dims->Set<false>(0, -1); 334 multi = Array::CreateMultiArray(soa.Self(), c, dims); 335 EXPECT_TRUE(soa.Self()->IsExceptionPending()); 336 EXPECT_EQ(PrettyDescriptor(soa.Self()->GetException()->GetClass()), 337 "java.lang.NegativeArraySizeException"); 338 soa.Self()->ClearException(); 339 340 dims.Assign(IntArray::Alloc(soa.Self(), 2)); 341 for (int i = 1; i < 20; ++i) { 342 for (int j = 0; j < 20; ++j) { 343 dims->Set<false>(0, i); 344 dims->Set<false>(1, j); 345 multi = Array::CreateMultiArray(soa.Self(), c, dims); 346 EXPECT_TRUE(multi->GetClass() == class_linker_->FindSystemClass(soa.Self(), "[[I")); 347 EXPECT_EQ(i, multi->GetLength()); 348 for (int k = 0; k < i; ++k) { 349 Array* outer = multi->AsObjectArray<Array>()->Get(k); 350 EXPECT_TRUE(outer->GetClass() == class_linker_->FindSystemClass(soa.Self(), "[I")); 351 EXPECT_EQ(j, outer->GetLength()); 352 } 353 } 354 } 355 } 356 357 TEST_F(ObjectTest, StaticFieldFromCode) { 358 // pretend we are trying to access 'Static.s0' from StaticsFromCode.<clinit> 359 ScopedObjectAccess soa(Thread::Current()); 360 jobject class_loader = LoadDex("StaticsFromCode"); 361 const DexFile* dex_file = GetFirstDexFile(class_loader); 362 363 StackHandleScope<2> hs(soa.Self()); 364 Handle<mirror::ClassLoader> loader(hs.NewHandle(soa.Decode<ClassLoader*>(class_loader))); 365 Class* klass = class_linker_->FindClass(soa.Self(), "LStaticsFromCode;", loader); 366 ArtMethod* clinit = klass->FindClassInitializer(sizeof(void*)); 367 const DexFile::TypeId* klass_type_id = dex_file->FindTypeId("LStaticsFromCode;"); 368 ASSERT_TRUE(klass_type_id != nullptr); 369 370 const DexFile::TypeId* type_type_id = dex_file->FindTypeId("Ljava/lang/Object;"); 371 ASSERT_TRUE(type_type_id != nullptr); 372 373 const DexFile::StringId* name_str_id = dex_file->FindStringId("s0"); 374 ASSERT_TRUE(name_str_id != nullptr); 375 376 const DexFile::FieldId* field_id = dex_file->FindFieldId( 377 *klass_type_id, *name_str_id, *type_type_id); 378 ASSERT_TRUE(field_id != nullptr); 379 uint32_t field_idx = dex_file->GetIndexForFieldId(*field_id); 380 381 ArtField* field = FindFieldFromCode<StaticObjectRead, true>(field_idx, clinit, Thread::Current(), 382 sizeof(HeapReference<Object>)); 383 Object* s0 = field->GetObj(klass); 384 EXPECT_TRUE(s0 != nullptr); 385 386 Handle<CharArray> char_array(hs.NewHandle(CharArray::Alloc(soa.Self(), 0))); 387 field->SetObj<false>(field->GetDeclaringClass(), char_array.Get()); 388 EXPECT_EQ(char_array.Get(), field->GetObj(klass)); 389 390 field->SetObj<false>(field->GetDeclaringClass(), nullptr); 391 EXPECT_EQ(nullptr, field->GetObj(klass)); 392 393 // TODO: more exhaustive tests of all 6 cases of ArtField::*FromCode 394 } 395 396 TEST_F(ObjectTest, String) { 397 ScopedObjectAccess soa(Thread::Current()); 398 // Test the empty string. 399 AssertString(0, "", "", 0); 400 401 // Test one-byte characters. 402 AssertString(1, " ", "\x00\x20", 0x20); 403 AssertString(1, "", "\x00\x00", 0); 404 AssertString(1, "\x7f", "\x00\x7f", 0x7f); 405 AssertString(2, "hi", "\x00\x68\x00\x69", (31 * 0x68) + 0x69); 406 407 // Test two-byte characters. 408 AssertString(1, "\xc2\x80", "\x00\x80", 0x80); 409 AssertString(1, "\xd9\xa6", "\x06\x66", 0x0666); 410 AssertString(1, "\xdf\xbf", "\x07\xff", 0x07ff); 411 AssertString(3, "h\xd9\xa6i", "\x00\x68\x06\x66\x00\x69", 412 (31 * ((31 * 0x68) + 0x0666)) + 0x69); 413 414 // Test three-byte characters. 415 AssertString(1, "\xe0\xa0\x80", "\x08\x00", 0x0800); 416 AssertString(1, "\xe1\x88\xb4", "\x12\x34", 0x1234); 417 AssertString(1, "\xef\xbf\xbf", "\xff\xff", 0xffff); 418 AssertString(3, "h\xe1\x88\xb4i", "\x00\x68\x12\x34\x00\x69", 419 (31 * ((31 * 0x68) + 0x1234)) + 0x69); 420 421 // Test four-byte characters. 422 AssertString(2, "\xf0\x9f\x8f\xa0", "\xd8\x3c\xdf\xe0", (31 * 0xd83c) + 0xdfe0); 423 AssertString(2, "\xf0\x9f\x9a\x80", "\xd8\x3d\xde\x80", (31 * 0xd83d) + 0xde80); 424 AssertString(4, "h\xf0\x9f\x9a\x80i", "\x00\x68\xd8\x3d\xde\x80\x00\x69", 425 (31 * (31 * (31 * 0x68 + 0xd83d) + 0xde80) + 0x69)); 426 } 427 428 TEST_F(ObjectTest, StringEqualsUtf8) { 429 ScopedObjectAccess soa(Thread::Current()); 430 StackHandleScope<2> hs(soa.Self()); 431 Handle<String> string(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "android"))); 432 EXPECT_TRUE(string->Equals("android")); 433 EXPECT_FALSE(string->Equals("Android")); 434 EXPECT_FALSE(string->Equals("ANDROID")); 435 EXPECT_FALSE(string->Equals("")); 436 EXPECT_FALSE(string->Equals("and")); 437 EXPECT_FALSE(string->Equals("androids")); 438 439 Handle<String> empty(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), ""))); 440 EXPECT_TRUE(empty->Equals("")); 441 EXPECT_FALSE(empty->Equals("a")); 442 } 443 444 TEST_F(ObjectTest, StringEquals) { 445 ScopedObjectAccess soa(Thread::Current()); 446 StackHandleScope<3> hs(soa.Self()); 447 Handle<String> string(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "android"))); 448 Handle<String> string_2(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "android"))); 449 EXPECT_TRUE(string->Equals(string_2.Get())); 450 EXPECT_FALSE(string->Equals("Android")); 451 EXPECT_FALSE(string->Equals("ANDROID")); 452 EXPECT_FALSE(string->Equals("")); 453 EXPECT_FALSE(string->Equals("and")); 454 EXPECT_FALSE(string->Equals("androids")); 455 456 Handle<String> empty(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), ""))); 457 EXPECT_TRUE(empty->Equals("")); 458 EXPECT_FALSE(empty->Equals("a")); 459 } 460 461 TEST_F(ObjectTest, StringCompareTo) { 462 ScopedObjectAccess soa(Thread::Current()); 463 StackHandleScope<5> hs(soa.Self()); 464 Handle<String> string(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "android"))); 465 Handle<String> string_2(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "android"))); 466 Handle<String> string_3(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "Android"))); 467 Handle<String> string_4(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "and"))); 468 Handle<String> string_5(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), ""))); 469 EXPECT_EQ(0, string->CompareTo(string_2.Get())); 470 EXPECT_LT(0, string->CompareTo(string_3.Get())); 471 EXPECT_GT(0, string_3->CompareTo(string.Get())); 472 EXPECT_LT(0, string->CompareTo(string_4.Get())); 473 EXPECT_GT(0, string_4->CompareTo(string.Get())); 474 EXPECT_LT(0, string->CompareTo(string_5.Get())); 475 EXPECT_GT(0, string_5->CompareTo(string.Get())); 476 } 477 478 TEST_F(ObjectTest, StringLength) { 479 ScopedObjectAccess soa(Thread::Current()); 480 StackHandleScope<1> hs(soa.Self()); 481 Handle<String> string(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "android"))); 482 EXPECT_EQ(string->GetLength(), 7); 483 EXPECT_EQ(string->GetUtfLength(), 7); 484 } 485 486 TEST_F(ObjectTest, DescriptorCompare) { 487 // Two classloaders conflicts in compile_time_class_paths_. 488 ScopedObjectAccess soa(Thread::Current()); 489 ClassLinker* linker = class_linker_; 490 491 jobject jclass_loader_1 = LoadDex("ProtoCompare"); 492 jobject jclass_loader_2 = LoadDex("ProtoCompare2"); 493 StackHandleScope<4> hs(soa.Self()); 494 Handle<ClassLoader> class_loader_1(hs.NewHandle(soa.Decode<ClassLoader*>(jclass_loader_1))); 495 Handle<ClassLoader> class_loader_2(hs.NewHandle(soa.Decode<ClassLoader*>(jclass_loader_2))); 496 497 Class* klass1 = linker->FindClass(soa.Self(), "LProtoCompare;", class_loader_1); 498 ASSERT_TRUE(klass1 != nullptr); 499 Class* klass2 = linker->FindClass(soa.Self(), "LProtoCompare2;", class_loader_2); 500 ASSERT_TRUE(klass2 != nullptr); 501 502 ArtMethod* m1_1 = klass1->GetVirtualMethod(0, sizeof(void*)); 503 EXPECT_STREQ(m1_1->GetName(), "m1"); 504 ArtMethod* m2_1 = klass1->GetVirtualMethod(1, sizeof(void*)); 505 EXPECT_STREQ(m2_1->GetName(), "m2"); 506 ArtMethod* m3_1 = klass1->GetVirtualMethod(2, sizeof(void*)); 507 EXPECT_STREQ(m3_1->GetName(), "m3"); 508 ArtMethod* m4_1 = klass1->GetVirtualMethod(3, sizeof(void*)); 509 EXPECT_STREQ(m4_1->GetName(), "m4"); 510 511 ArtMethod* m1_2 = klass2->GetVirtualMethod(0, sizeof(void*)); 512 EXPECT_STREQ(m1_2->GetName(), "m1"); 513 ArtMethod* m2_2 = klass2->GetVirtualMethod(1, sizeof(void*)); 514 EXPECT_STREQ(m2_2->GetName(), "m2"); 515 ArtMethod* m3_2 = klass2->GetVirtualMethod(2, sizeof(void*)); 516 EXPECT_STREQ(m3_2->GetName(), "m3"); 517 ArtMethod* m4_2 = klass2->GetVirtualMethod(3, sizeof(void*)); 518 EXPECT_STREQ(m4_2->GetName(), "m4"); 519 } 520 521 TEST_F(ObjectTest, StringHashCode) { 522 ScopedObjectAccess soa(Thread::Current()); 523 StackHandleScope<3> hs(soa.Self()); 524 Handle<String> empty(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), ""))); 525 Handle<String> A(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "A"))); 526 Handle<String> ABC(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "ABC"))); 527 528 EXPECT_EQ(0, empty->GetHashCode()); 529 EXPECT_EQ(65, A->GetHashCode()); 530 EXPECT_EQ(64578, ABC->GetHashCode()); 531 } 532 533 TEST_F(ObjectTest, InstanceOf) { 534 ScopedObjectAccess soa(Thread::Current()); 535 jobject jclass_loader = LoadDex("XandY"); 536 StackHandleScope<3> hs(soa.Self()); 537 Handle<ClassLoader> class_loader(hs.NewHandle(soa.Decode<ClassLoader*>(jclass_loader))); 538 539 Class* X = class_linker_->FindClass(soa.Self(), "LX;", class_loader); 540 Class* Y = class_linker_->FindClass(soa.Self(), "LY;", class_loader); 541 ASSERT_TRUE(X != nullptr); 542 ASSERT_TRUE(Y != nullptr); 543 544 Handle<Object> x(hs.NewHandle(X->AllocObject(soa.Self()))); 545 Handle<Object> y(hs.NewHandle(Y->AllocObject(soa.Self()))); 546 ASSERT_TRUE(x.Get() != nullptr); 547 ASSERT_TRUE(y.Get() != nullptr); 548 549 EXPECT_TRUE(x->InstanceOf(X)); 550 EXPECT_FALSE(x->InstanceOf(Y)); 551 EXPECT_TRUE(y->InstanceOf(X)); 552 EXPECT_TRUE(y->InstanceOf(Y)); 553 554 Class* java_lang_Class = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Class;"); 555 Class* Object_array_class = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;"); 556 557 EXPECT_FALSE(java_lang_Class->InstanceOf(Object_array_class)); 558 EXPECT_TRUE(Object_array_class->InstanceOf(java_lang_Class)); 559 560 // All array classes implement Cloneable and Serializable. 561 Object* array = ObjectArray<Object>::Alloc(soa.Self(), Object_array_class, 1); 562 Class* java_lang_Cloneable = 563 class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Cloneable;"); 564 Class* java_io_Serializable = 565 class_linker_->FindSystemClass(soa.Self(), "Ljava/io/Serializable;"); 566 EXPECT_TRUE(array->InstanceOf(java_lang_Cloneable)); 567 EXPECT_TRUE(array->InstanceOf(java_io_Serializable)); 568 } 569 570 TEST_F(ObjectTest, IsAssignableFrom) { 571 ScopedObjectAccess soa(Thread::Current()); 572 jobject jclass_loader = LoadDex("XandY"); 573 StackHandleScope<1> hs(soa.Self()); 574 Handle<ClassLoader> class_loader(hs.NewHandle(soa.Decode<ClassLoader*>(jclass_loader))); 575 Class* X = class_linker_->FindClass(soa.Self(), "LX;", class_loader); 576 Class* Y = class_linker_->FindClass(soa.Self(), "LY;", class_loader); 577 578 EXPECT_TRUE(X->IsAssignableFrom(X)); 579 EXPECT_TRUE(X->IsAssignableFrom(Y)); 580 EXPECT_FALSE(Y->IsAssignableFrom(X)); 581 EXPECT_TRUE(Y->IsAssignableFrom(Y)); 582 583 // class final String implements CharSequence, .. 584 Class* string = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/String;"); 585 Class* charseq = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/CharSequence;"); 586 // Can String be assigned to CharSequence without a cast? 587 EXPECT_TRUE(charseq->IsAssignableFrom(string)); 588 // Can CharSequence be assigned to String without a cast? 589 EXPECT_FALSE(string->IsAssignableFrom(charseq)); 590 591 // Primitive types are only assignable to themselves 592 const char* prims = "ZBCSIJFD"; 593 Class* prim_types[strlen(prims)]; 594 for (size_t i = 0; i < strlen(prims); i++) { 595 prim_types[i] = class_linker_->FindPrimitiveClass(prims[i]); 596 } 597 for (size_t i = 0; i < strlen(prims); i++) { 598 for (size_t j = 0; i < strlen(prims); i++) { 599 if (i == j) { 600 EXPECT_TRUE(prim_types[i]->IsAssignableFrom(prim_types[j])); 601 } else { 602 EXPECT_FALSE(prim_types[i]->IsAssignableFrom(prim_types[j])); 603 } 604 } 605 } 606 } 607 608 TEST_F(ObjectTest, IsAssignableFromArray) { 609 ScopedObjectAccess soa(Thread::Current()); 610 jobject jclass_loader = LoadDex("XandY"); 611 StackHandleScope<1> hs(soa.Self()); 612 Handle<ClassLoader> class_loader(hs.NewHandle(soa.Decode<ClassLoader*>(jclass_loader))); 613 Class* X = class_linker_->FindClass(soa.Self(), "LX;", class_loader); 614 Class* Y = class_linker_->FindClass(soa.Self(), "LY;", class_loader); 615 ASSERT_TRUE(X != nullptr); 616 ASSERT_TRUE(Y != nullptr); 617 618 Class* YA = class_linker_->FindClass(soa.Self(), "[LY;", class_loader); 619 Class* YAA = class_linker_->FindClass(soa.Self(), "[[LY;", class_loader); 620 ASSERT_TRUE(YA != nullptr); 621 ASSERT_TRUE(YAA != nullptr); 622 623 Class* XAA = class_linker_->FindClass(soa.Self(), "[[LX;", class_loader); 624 ASSERT_TRUE(XAA != nullptr); 625 626 Class* O = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"); 627 Class* OA = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;"); 628 Class* OAA = class_linker_->FindSystemClass(soa.Self(), "[[Ljava/lang/Object;"); 629 Class* OAAA = class_linker_->FindSystemClass(soa.Self(), "[[[Ljava/lang/Object;"); 630 ASSERT_TRUE(O != nullptr); 631 ASSERT_TRUE(OA != nullptr); 632 ASSERT_TRUE(OAA != nullptr); 633 ASSERT_TRUE(OAAA != nullptr); 634 635 Class* S = class_linker_->FindSystemClass(soa.Self(), "Ljava/io/Serializable;"); 636 Class* SA = class_linker_->FindSystemClass(soa.Self(), "[Ljava/io/Serializable;"); 637 Class* SAA = class_linker_->FindSystemClass(soa.Self(), "[[Ljava/io/Serializable;"); 638 ASSERT_TRUE(S != nullptr); 639 ASSERT_TRUE(SA != nullptr); 640 ASSERT_TRUE(SAA != nullptr); 641 642 Class* IA = class_linker_->FindSystemClass(soa.Self(), "[I"); 643 ASSERT_TRUE(IA != nullptr); 644 645 EXPECT_TRUE(YAA->IsAssignableFrom(YAA)); // identity 646 EXPECT_TRUE(XAA->IsAssignableFrom(YAA)); // element superclass 647 EXPECT_FALSE(YAA->IsAssignableFrom(XAA)); 648 EXPECT_FALSE(Y->IsAssignableFrom(YAA)); 649 EXPECT_FALSE(YA->IsAssignableFrom(YAA)); 650 EXPECT_TRUE(O->IsAssignableFrom(YAA)); // everything is an Object 651 EXPECT_TRUE(OA->IsAssignableFrom(YAA)); 652 EXPECT_TRUE(OAA->IsAssignableFrom(YAA)); 653 EXPECT_TRUE(S->IsAssignableFrom(YAA)); // all arrays are Serializable 654 EXPECT_TRUE(SA->IsAssignableFrom(YAA)); 655 EXPECT_FALSE(SAA->IsAssignableFrom(YAA)); // unless Y was Serializable 656 657 EXPECT_FALSE(IA->IsAssignableFrom(OA)); 658 EXPECT_FALSE(OA->IsAssignableFrom(IA)); 659 EXPECT_TRUE(O->IsAssignableFrom(IA)); 660 } 661 662 TEST_F(ObjectTest, FindInstanceField) { 663 ScopedObjectAccess soa(Thread::Current()); 664 StackHandleScope<1> hs(soa.Self()); 665 Handle<String> s(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "ABC"))); 666 ASSERT_TRUE(s.Get() != nullptr); 667 Class* c = s->GetClass(); 668 ASSERT_TRUE(c != nullptr); 669 670 // Wrong type. 671 EXPECT_TRUE(c->FindDeclaredInstanceField("count", "J") == nullptr); 672 EXPECT_TRUE(c->FindInstanceField("count", "J") == nullptr); 673 674 // Wrong name. 675 EXPECT_TRUE(c->FindDeclaredInstanceField("Count", "I") == nullptr); 676 EXPECT_TRUE(c->FindInstanceField("Count", "I") == nullptr); 677 678 // Right name and type. 679 ArtField* f1 = c->FindDeclaredInstanceField("count", "I"); 680 ArtField* f2 = c->FindInstanceField("count", "I"); 681 EXPECT_TRUE(f1 != nullptr); 682 EXPECT_TRUE(f2 != nullptr); 683 EXPECT_EQ(f1, f2); 684 685 // TODO: check that s.count == 3. 686 687 // Ensure that we handle superclass fields correctly... 688 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/StringBuilder;"); 689 ASSERT_TRUE(c != nullptr); 690 // No StringBuilder.count... 691 EXPECT_TRUE(c->FindDeclaredInstanceField("count", "I") == nullptr); 692 // ...but there is an AbstractStringBuilder.count. 693 EXPECT_TRUE(c->FindInstanceField("count", "I") != nullptr); 694 } 695 696 TEST_F(ObjectTest, FindStaticField) { 697 ScopedObjectAccess soa(Thread::Current()); 698 StackHandleScope<4> hs(soa.Self()); 699 Handle<String> s(hs.NewHandle(String::AllocFromModifiedUtf8(soa.Self(), "ABC"))); 700 ASSERT_TRUE(s.Get() != nullptr); 701 Handle<Class> c(hs.NewHandle(s->GetClass())); 702 ASSERT_TRUE(c.Get() != nullptr); 703 704 // Wrong type. 705 EXPECT_TRUE(c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "I") == nullptr); 706 EXPECT_TRUE(mirror::Class::FindStaticField( 707 soa.Self(), c, "CASE_INSENSITIVE_ORDER", "I") == nullptr); 708 709 // Wrong name. 710 EXPECT_TRUE(c->FindDeclaredStaticField( 711 "cASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;") == nullptr); 712 EXPECT_TRUE( 713 mirror::Class::FindStaticField(soa.Self(), c, "cASE_INSENSITIVE_ORDER", 714 "Ljava/util/Comparator;") == nullptr); 715 716 // Right name and type. 717 ArtField* f1 = c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;"); 718 ArtField* f2 = mirror::Class::FindStaticField(soa.Self(), c, "CASE_INSENSITIVE_ORDER", 719 "Ljava/util/Comparator;"); 720 EXPECT_TRUE(f1 != nullptr); 721 EXPECT_TRUE(f2 != nullptr); 722 EXPECT_EQ(f1, f2); 723 724 // TODO: test static fields via superclasses. 725 // TODO: test static fields via interfaces. 726 // TODO: test that interfaces trump superclasses. 727 } 728 729 TEST_F(ObjectTest, IdentityHashCode) { 730 // Regression test for b/19046417 which had an infinite loop if the 731 // (seed & LockWord::kHashMask) == 0. seed 0 triggered the infinite loop since we did the check 732 // before the CAS which resulted in the same seed the next loop iteration. 733 mirror::Object::SetHashCodeSeed(0); 734 int32_t hash_code = mirror::Object::GenerateIdentityHashCode(); 735 EXPECT_NE(hash_code, 0); 736 } 737 738 } // namespace mirror 739 } // namespace art 740
