1 /* 2 * Copyright (C) 2014 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 "transaction.h" 18 19 #include "art_field-inl.h" 20 #include "art_method-inl.h" 21 #include "class_linker-inl.h" 22 #include "common_runtime_test.h" 23 #include "dex_file.h" 24 #include "mirror/array-inl.h" 25 #include "scoped_thread_state_change-inl.h" 26 27 namespace art { 28 29 class TransactionTest : public CommonRuntimeTest { 30 public: 31 // Tests failing class initialization due to native call with transaction rollback. 32 void testTransactionAbort(const char* tested_class_signature) { 33 ScopedObjectAccess soa(Thread::Current()); 34 jobject jclass_loader = LoadDex("Transaction"); 35 StackHandleScope<2> hs(soa.Self()); 36 Handle<mirror::ClassLoader> class_loader( 37 hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader))); 38 ASSERT_TRUE(class_loader != nullptr); 39 40 // Load and initialize java.lang.ExceptionInInitializerError and the exception class used 41 // to abort transaction so they can be thrown during class initialization if the transaction 42 // aborts. 43 MutableHandle<mirror::Class> h_klass( 44 hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), 45 "Ljava/lang/ExceptionInInitializerError;"))); 46 ASSERT_TRUE(h_klass != nullptr); 47 class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true); 48 ASSERT_TRUE(h_klass->IsInitialized()); 49 50 h_klass.Assign(class_linker_->FindSystemClass(soa.Self(), 51 Transaction::kAbortExceptionSignature)); 52 ASSERT_TRUE(h_klass != nullptr); 53 class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true); 54 ASSERT_TRUE(h_klass->IsInitialized()); 55 56 // Load and verify utility class. 57 h_klass.Assign(class_linker_->FindClass(soa.Self(), "LTransaction$AbortHelperClass;", 58 class_loader)); 59 ASSERT_TRUE(h_klass != nullptr); 60 class_linker_->VerifyClass(soa.Self(), h_klass); 61 ASSERT_TRUE(h_klass->IsVerified()); 62 63 // Load and verify tested class. 64 h_klass.Assign(class_linker_->FindClass(soa.Self(), tested_class_signature, class_loader)); 65 ASSERT_TRUE(h_klass != nullptr); 66 class_linker_->VerifyClass(soa.Self(), h_klass); 67 ASSERT_TRUE(h_klass->IsVerified()); 68 69 mirror::Class::Status old_status = h_klass->GetStatus(); 70 LockWord old_lock_word = h_klass->GetLockWord(false); 71 72 Transaction transaction; 73 Runtime::Current()->EnterTransactionMode(&transaction); 74 bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true); 75 Runtime::Current()->ExitTransactionMode(); 76 ASSERT_FALSE(success); 77 ASSERT_TRUE(h_klass->IsErroneous()); 78 ASSERT_TRUE(soa.Self()->IsExceptionPending()); 79 ASSERT_TRUE(transaction.IsAborted()); 80 81 // Check class's monitor get back to its original state without rolling back changes. 82 LockWord new_lock_word = h_klass->GetLockWord(false); 83 EXPECT_TRUE(LockWord::Equal<false>(old_lock_word, new_lock_word)); 84 85 // Check class status is rolled back properly. 86 soa.Self()->ClearException(); 87 transaction.Rollback(); 88 ASSERT_EQ(old_status, h_klass->GetStatus()); 89 } 90 }; 91 92 // Tests object's class is preserved after transaction rollback. 93 TEST_F(TransactionTest, Object_class) { 94 ScopedObjectAccess soa(Thread::Current()); 95 StackHandleScope<2> hs(soa.Self()); 96 Handle<mirror::Class> h_klass( 97 hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"))); 98 ASSERT_TRUE(h_klass != nullptr); 99 100 Transaction transaction; 101 Runtime::Current()->EnterTransactionMode(&transaction); 102 Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self()))); 103 ASSERT_TRUE(h_obj != nullptr); 104 ASSERT_EQ(h_obj->GetClass(), h_klass.Get()); 105 Runtime::Current()->ExitTransactionMode(); 106 107 // Rolling back transaction's changes must not clear the Object::class field. 108 transaction.Rollback(); 109 EXPECT_EQ(h_obj->GetClass(), h_klass.Get()); 110 } 111 112 // Tests object's monitor state is preserved after transaction rollback. 113 TEST_F(TransactionTest, Object_monitor) { 114 ScopedObjectAccess soa(Thread::Current()); 115 StackHandleScope<2> hs(soa.Self()); 116 Handle<mirror::Class> h_klass( 117 hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"))); 118 ASSERT_TRUE(h_klass != nullptr); 119 Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self()))); 120 ASSERT_TRUE(h_obj != nullptr); 121 ASSERT_EQ(h_obj->GetClass(), h_klass.Get()); 122 123 // Lock object's monitor outside the transaction. 124 h_obj->MonitorEnter(soa.Self()); 125 LockWord old_lock_word = h_obj->GetLockWord(false); 126 127 Transaction transaction; 128 Runtime::Current()->EnterTransactionMode(&transaction); 129 // Unlock object's monitor inside the transaction. 130 h_obj->MonitorExit(soa.Self()); 131 LockWord new_lock_word = h_obj->GetLockWord(false); 132 Runtime::Current()->ExitTransactionMode(); 133 134 // Rolling back transaction's changes must not change monitor's state. 135 transaction.Rollback(); 136 LockWord aborted_lock_word = h_obj->GetLockWord(false); 137 EXPECT_FALSE(LockWord::Equal<false>(old_lock_word, new_lock_word)); 138 EXPECT_TRUE(LockWord::Equal<false>(aborted_lock_word, new_lock_word)); 139 } 140 141 // Tests array's length is preserved after transaction rollback. 142 TEST_F(TransactionTest, Array_length) { 143 ScopedObjectAccess soa(Thread::Current()); 144 StackHandleScope<2> hs(soa.Self()); 145 Handle<mirror::Class> h_klass( 146 hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;"))); 147 ASSERT_TRUE(h_klass != nullptr); 148 149 constexpr int32_t kArraySize = 2; 150 151 Transaction transaction; 152 Runtime::Current()->EnterTransactionMode(&transaction); 153 154 // Allocate an array during transaction. 155 Handle<mirror::Array> h_obj( 156 hs.NewHandle( 157 mirror::Array::Alloc<true>(soa.Self(), h_klass.Get(), kArraySize, 158 h_klass->GetComponentSizeShift(), 159 Runtime::Current()->GetHeap()->GetCurrentAllocator()))); 160 ASSERT_TRUE(h_obj != nullptr); 161 ASSERT_EQ(h_obj->GetClass(), h_klass.Get()); 162 Runtime::Current()->ExitTransactionMode(); 163 164 // Rolling back transaction's changes must not reset array's length. 165 transaction.Rollback(); 166 EXPECT_EQ(h_obj->GetLength(), kArraySize); 167 } 168 169 // Tests static fields are reset to their default value after transaction rollback. 170 TEST_F(TransactionTest, StaticFieldsTest) { 171 ScopedObjectAccess soa(Thread::Current()); 172 StackHandleScope<4> hs(soa.Self()); 173 Handle<mirror::ClassLoader> class_loader( 174 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction")))); 175 ASSERT_TRUE(class_loader != nullptr); 176 177 Handle<mirror::Class> h_klass( 178 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStaticFieldsTest;", class_loader))); 179 ASSERT_TRUE(h_klass != nullptr); 180 bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true); 181 ASSERT_TRUE(success); 182 ASSERT_TRUE(h_klass->IsInitialized()); 183 ASSERT_FALSE(soa.Self()->IsExceptionPending()); 184 185 // Lookup fields. 186 ArtField* booleanField = h_klass->FindDeclaredStaticField("booleanField", "Z"); 187 ASSERT_TRUE(booleanField != nullptr); 188 ASSERT_EQ(booleanField->GetTypeAsPrimitiveType(), Primitive::kPrimBoolean); 189 ASSERT_EQ(booleanField->GetBoolean(h_klass.Get()), false); 190 191 ArtField* byteField = h_klass->FindDeclaredStaticField("byteField", "B"); 192 ASSERT_TRUE(byteField != nullptr); 193 ASSERT_EQ(byteField->GetTypeAsPrimitiveType(), Primitive::kPrimByte); 194 ASSERT_EQ(byteField->GetByte(h_klass.Get()), 0); 195 196 ArtField* charField = h_klass->FindDeclaredStaticField("charField", "C"); 197 ASSERT_TRUE(charField != nullptr); 198 ASSERT_EQ(charField->GetTypeAsPrimitiveType(), Primitive::kPrimChar); 199 ASSERT_EQ(charField->GetChar(h_klass.Get()), 0u); 200 201 ArtField* shortField = h_klass->FindDeclaredStaticField("shortField", "S"); 202 ASSERT_TRUE(shortField != nullptr); 203 ASSERT_EQ(shortField->GetTypeAsPrimitiveType(), Primitive::kPrimShort); 204 ASSERT_EQ(shortField->GetShort(h_klass.Get()), 0); 205 206 ArtField* intField = h_klass->FindDeclaredStaticField("intField", "I"); 207 ASSERT_TRUE(intField != nullptr); 208 ASSERT_EQ(intField->GetTypeAsPrimitiveType(), Primitive::kPrimInt); 209 ASSERT_EQ(intField->GetInt(h_klass.Get()), 0); 210 211 ArtField* longField = h_klass->FindDeclaredStaticField("longField", "J"); 212 ASSERT_TRUE(longField != nullptr); 213 ASSERT_EQ(longField->GetTypeAsPrimitiveType(), Primitive::kPrimLong); 214 ASSERT_EQ(longField->GetLong(h_klass.Get()), static_cast<int64_t>(0)); 215 216 ArtField* floatField = h_klass->FindDeclaredStaticField("floatField", "F"); 217 ASSERT_TRUE(floatField != nullptr); 218 ASSERT_EQ(floatField->GetTypeAsPrimitiveType(), Primitive::kPrimFloat); 219 ASSERT_FLOAT_EQ(floatField->GetFloat(h_klass.Get()), static_cast<float>(0.0f)); 220 221 ArtField* doubleField = h_klass->FindDeclaredStaticField("doubleField", "D"); 222 ASSERT_TRUE(doubleField != nullptr); 223 ASSERT_EQ(doubleField->GetTypeAsPrimitiveType(), Primitive::kPrimDouble); 224 ASSERT_DOUBLE_EQ(doubleField->GetDouble(h_klass.Get()), static_cast<double>(0.0)); 225 226 ArtField* objectField = h_klass->FindDeclaredStaticField("objectField", 227 "Ljava/lang/Object;"); 228 ASSERT_TRUE(objectField != nullptr); 229 ASSERT_EQ(objectField->GetTypeAsPrimitiveType(), Primitive::kPrimNot); 230 ASSERT_EQ(objectField->GetObject(h_klass.Get()), nullptr); 231 232 // Create a java.lang.Object instance to set objectField. 233 Handle<mirror::Class> object_klass( 234 hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"))); 235 ASSERT_TRUE(object_klass != nullptr); 236 Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self()))); 237 ASSERT_TRUE(h_obj != nullptr); 238 ASSERT_EQ(h_obj->GetClass(), h_klass.Get()); 239 240 // Modify fields inside transaction then rollback changes. 241 Transaction transaction; 242 Runtime::Current()->EnterTransactionMode(&transaction); 243 booleanField->SetBoolean<true>(h_klass.Get(), true); 244 byteField->SetByte<true>(h_klass.Get(), 1); 245 charField->SetChar<true>(h_klass.Get(), 1u); 246 shortField->SetShort<true>(h_klass.Get(), 1); 247 intField->SetInt<true>(h_klass.Get(), 1); 248 longField->SetLong<true>(h_klass.Get(), 1); 249 floatField->SetFloat<true>(h_klass.Get(), 1.0); 250 doubleField->SetDouble<true>(h_klass.Get(), 1.0); 251 objectField->SetObject<true>(h_klass.Get(), h_obj.Get()); 252 Runtime::Current()->ExitTransactionMode(); 253 transaction.Rollback(); 254 255 // Check values have properly been restored to their original (default) value. 256 EXPECT_EQ(booleanField->GetBoolean(h_klass.Get()), false); 257 EXPECT_EQ(byteField->GetByte(h_klass.Get()), 0); 258 EXPECT_EQ(charField->GetChar(h_klass.Get()), 0u); 259 EXPECT_EQ(shortField->GetShort(h_klass.Get()), 0); 260 EXPECT_EQ(intField->GetInt(h_klass.Get()), 0); 261 EXPECT_EQ(longField->GetLong(h_klass.Get()), static_cast<int64_t>(0)); 262 EXPECT_FLOAT_EQ(floatField->GetFloat(h_klass.Get()), static_cast<float>(0.0f)); 263 EXPECT_DOUBLE_EQ(doubleField->GetDouble(h_klass.Get()), static_cast<double>(0.0)); 264 EXPECT_EQ(objectField->GetObject(h_klass.Get()), nullptr); 265 } 266 267 // Tests instance fields are reset to their default value after transaction rollback. 268 TEST_F(TransactionTest, InstanceFieldsTest) { 269 ScopedObjectAccess soa(Thread::Current()); 270 StackHandleScope<5> hs(soa.Self()); 271 Handle<mirror::ClassLoader> class_loader( 272 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction")))); 273 ASSERT_TRUE(class_loader != nullptr); 274 275 Handle<mirror::Class> h_klass( 276 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInstanceFieldsTest;", class_loader))); 277 ASSERT_TRUE(h_klass != nullptr); 278 bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true); 279 ASSERT_TRUE(success); 280 ASSERT_TRUE(h_klass->IsInitialized()); 281 ASSERT_FALSE(soa.Self()->IsExceptionPending()); 282 283 // Allocate an InstanceFieldTest object. 284 Handle<mirror::Object> h_instance(hs.NewHandle(h_klass->AllocObject(soa.Self()))); 285 ASSERT_TRUE(h_instance != nullptr); 286 287 // Lookup fields. 288 ArtField* booleanField = h_klass->FindDeclaredInstanceField("booleanField", "Z"); 289 ASSERT_TRUE(booleanField != nullptr); 290 ASSERT_EQ(booleanField->GetTypeAsPrimitiveType(), Primitive::kPrimBoolean); 291 ASSERT_EQ(booleanField->GetBoolean(h_instance.Get()), false); 292 293 ArtField* byteField = h_klass->FindDeclaredInstanceField("byteField", "B"); 294 ASSERT_TRUE(byteField != nullptr); 295 ASSERT_EQ(byteField->GetTypeAsPrimitiveType(), Primitive::kPrimByte); 296 ASSERT_EQ(byteField->GetByte(h_instance.Get()), 0); 297 298 ArtField* charField = h_klass->FindDeclaredInstanceField("charField", "C"); 299 ASSERT_TRUE(charField != nullptr); 300 ASSERT_EQ(charField->GetTypeAsPrimitiveType(), Primitive::kPrimChar); 301 ASSERT_EQ(charField->GetChar(h_instance.Get()), 0u); 302 303 ArtField* shortField = h_klass->FindDeclaredInstanceField("shortField", "S"); 304 ASSERT_TRUE(shortField != nullptr); 305 ASSERT_EQ(shortField->GetTypeAsPrimitiveType(), Primitive::kPrimShort); 306 ASSERT_EQ(shortField->GetShort(h_instance.Get()), 0); 307 308 ArtField* intField = h_klass->FindDeclaredInstanceField("intField", "I"); 309 ASSERT_TRUE(intField != nullptr); 310 ASSERT_EQ(intField->GetTypeAsPrimitiveType(), Primitive::kPrimInt); 311 ASSERT_EQ(intField->GetInt(h_instance.Get()), 0); 312 313 ArtField* longField = h_klass->FindDeclaredInstanceField("longField", "J"); 314 ASSERT_TRUE(longField != nullptr); 315 ASSERT_EQ(longField->GetTypeAsPrimitiveType(), Primitive::kPrimLong); 316 ASSERT_EQ(longField->GetLong(h_instance.Get()), static_cast<int64_t>(0)); 317 318 ArtField* floatField = h_klass->FindDeclaredInstanceField("floatField", "F"); 319 ASSERT_TRUE(floatField != nullptr); 320 ASSERT_EQ(floatField->GetTypeAsPrimitiveType(), Primitive::kPrimFloat); 321 ASSERT_FLOAT_EQ(floatField->GetFloat(h_instance.Get()), static_cast<float>(0.0f)); 322 323 ArtField* doubleField = h_klass->FindDeclaredInstanceField("doubleField", "D"); 324 ASSERT_TRUE(doubleField != nullptr); 325 ASSERT_EQ(doubleField->GetTypeAsPrimitiveType(), Primitive::kPrimDouble); 326 ASSERT_DOUBLE_EQ(doubleField->GetDouble(h_instance.Get()), static_cast<double>(0.0)); 327 328 ArtField* objectField = h_klass->FindDeclaredInstanceField("objectField", 329 "Ljava/lang/Object;"); 330 ASSERT_TRUE(objectField != nullptr); 331 ASSERT_EQ(objectField->GetTypeAsPrimitiveType(), Primitive::kPrimNot); 332 ASSERT_EQ(objectField->GetObject(h_instance.Get()), nullptr); 333 334 // Create a java.lang.Object instance to set objectField. 335 Handle<mirror::Class> object_klass( 336 hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"))); 337 ASSERT_TRUE(object_klass != nullptr); 338 Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self()))); 339 ASSERT_TRUE(h_obj != nullptr); 340 ASSERT_EQ(h_obj->GetClass(), h_klass.Get()); 341 342 // Modify fields inside transaction then rollback changes. 343 Transaction transaction; 344 Runtime::Current()->EnterTransactionMode(&transaction); 345 booleanField->SetBoolean<true>(h_instance.Get(), true); 346 byteField->SetByte<true>(h_instance.Get(), 1); 347 charField->SetChar<true>(h_instance.Get(), 1u); 348 shortField->SetShort<true>(h_instance.Get(), 1); 349 intField->SetInt<true>(h_instance.Get(), 1); 350 longField->SetLong<true>(h_instance.Get(), 1); 351 floatField->SetFloat<true>(h_instance.Get(), 1.0); 352 doubleField->SetDouble<true>(h_instance.Get(), 1.0); 353 objectField->SetObject<true>(h_instance.Get(), h_obj.Get()); 354 Runtime::Current()->ExitTransactionMode(); 355 transaction.Rollback(); 356 357 // Check values have properly been restored to their original (default) value. 358 EXPECT_EQ(booleanField->GetBoolean(h_instance.Get()), false); 359 EXPECT_EQ(byteField->GetByte(h_instance.Get()), 0); 360 EXPECT_EQ(charField->GetChar(h_instance.Get()), 0u); 361 EXPECT_EQ(shortField->GetShort(h_instance.Get()), 0); 362 EXPECT_EQ(intField->GetInt(h_instance.Get()), 0); 363 EXPECT_EQ(longField->GetLong(h_instance.Get()), static_cast<int64_t>(0)); 364 EXPECT_FLOAT_EQ(floatField->GetFloat(h_instance.Get()), static_cast<float>(0.0f)); 365 EXPECT_DOUBLE_EQ(doubleField->GetDouble(h_instance.Get()), static_cast<double>(0.0)); 366 EXPECT_EQ(objectField->GetObject(h_instance.Get()), nullptr); 367 } 368 369 // Tests static array fields are reset to their default value after transaction rollback. 370 TEST_F(TransactionTest, StaticArrayFieldsTest) { 371 ScopedObjectAccess soa(Thread::Current()); 372 StackHandleScope<4> hs(soa.Self()); 373 Handle<mirror::ClassLoader> class_loader( 374 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction")))); 375 ASSERT_TRUE(class_loader != nullptr); 376 377 Handle<mirror::Class> h_klass( 378 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStaticArrayFieldsTest;", class_loader))); 379 ASSERT_TRUE(h_klass != nullptr); 380 bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true); 381 ASSERT_TRUE(success); 382 ASSERT_TRUE(h_klass->IsInitialized()); 383 ASSERT_FALSE(soa.Self()->IsExceptionPending()); 384 385 // Lookup fields. 386 ArtField* booleanArrayField = h_klass->FindDeclaredStaticField("booleanArrayField", "[Z"); 387 ASSERT_TRUE(booleanArrayField != nullptr); 388 mirror::BooleanArray* booleanArray = booleanArrayField->GetObject(h_klass.Get())->AsBooleanArray(); 389 ASSERT_TRUE(booleanArray != nullptr); 390 ASSERT_EQ(booleanArray->GetLength(), 1); 391 ASSERT_EQ(booleanArray->GetWithoutChecks(0), false); 392 393 ArtField* byteArrayField = h_klass->FindDeclaredStaticField("byteArrayField", "[B"); 394 ASSERT_TRUE(byteArrayField != nullptr); 395 mirror::ByteArray* byteArray = byteArrayField->GetObject(h_klass.Get())->AsByteArray(); 396 ASSERT_TRUE(byteArray != nullptr); 397 ASSERT_EQ(byteArray->GetLength(), 1); 398 ASSERT_EQ(byteArray->GetWithoutChecks(0), 0); 399 400 ArtField* charArrayField = h_klass->FindDeclaredStaticField("charArrayField", "[C"); 401 ASSERT_TRUE(charArrayField != nullptr); 402 mirror::CharArray* charArray = charArrayField->GetObject(h_klass.Get())->AsCharArray(); 403 ASSERT_TRUE(charArray != nullptr); 404 ASSERT_EQ(charArray->GetLength(), 1); 405 ASSERT_EQ(charArray->GetWithoutChecks(0), 0u); 406 407 ArtField* shortArrayField = h_klass->FindDeclaredStaticField("shortArrayField", "[S"); 408 ASSERT_TRUE(shortArrayField != nullptr); 409 mirror::ShortArray* shortArray = shortArrayField->GetObject(h_klass.Get())->AsShortArray(); 410 ASSERT_TRUE(shortArray != nullptr); 411 ASSERT_EQ(shortArray->GetLength(), 1); 412 ASSERT_EQ(shortArray->GetWithoutChecks(0), 0); 413 414 ArtField* intArrayField = h_klass->FindDeclaredStaticField("intArrayField", "[I"); 415 ASSERT_TRUE(intArrayField != nullptr); 416 mirror::IntArray* intArray = intArrayField->GetObject(h_klass.Get())->AsIntArray(); 417 ASSERT_TRUE(intArray != nullptr); 418 ASSERT_EQ(intArray->GetLength(), 1); 419 ASSERT_EQ(intArray->GetWithoutChecks(0), 0); 420 421 ArtField* longArrayField = h_klass->FindDeclaredStaticField("longArrayField", "[J"); 422 ASSERT_TRUE(longArrayField != nullptr); 423 mirror::LongArray* longArray = longArrayField->GetObject(h_klass.Get())->AsLongArray(); 424 ASSERT_TRUE(longArray != nullptr); 425 ASSERT_EQ(longArray->GetLength(), 1); 426 ASSERT_EQ(longArray->GetWithoutChecks(0), static_cast<int64_t>(0)); 427 428 ArtField* floatArrayField = h_klass->FindDeclaredStaticField("floatArrayField", "[F"); 429 ASSERT_TRUE(floatArrayField != nullptr); 430 mirror::FloatArray* floatArray = floatArrayField->GetObject(h_klass.Get())->AsFloatArray(); 431 ASSERT_TRUE(floatArray != nullptr); 432 ASSERT_EQ(floatArray->GetLength(), 1); 433 ASSERT_FLOAT_EQ(floatArray->GetWithoutChecks(0), static_cast<float>(0.0f)); 434 435 ArtField* doubleArrayField = h_klass->FindDeclaredStaticField("doubleArrayField", "[D"); 436 ASSERT_TRUE(doubleArrayField != nullptr); 437 mirror::DoubleArray* doubleArray = doubleArrayField->GetObject(h_klass.Get())->AsDoubleArray(); 438 ASSERT_TRUE(doubleArray != nullptr); 439 ASSERT_EQ(doubleArray->GetLength(), 1); 440 ASSERT_DOUBLE_EQ(doubleArray->GetWithoutChecks(0), static_cast<double>(0.0f)); 441 442 ArtField* objectArrayField = h_klass->FindDeclaredStaticField("objectArrayField", 443 "[Ljava/lang/Object;"); 444 ASSERT_TRUE(objectArrayField != nullptr); 445 mirror::ObjectArray<mirror::Object>* objectArray = 446 objectArrayField->GetObject(h_klass.Get())->AsObjectArray<mirror::Object>(); 447 ASSERT_TRUE(objectArray != nullptr); 448 ASSERT_EQ(objectArray->GetLength(), 1); 449 ASSERT_EQ(objectArray->GetWithoutChecks(0), nullptr); 450 451 // Create a java.lang.Object instance to set objectField. 452 Handle<mirror::Class> object_klass( 453 hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"))); 454 ASSERT_TRUE(object_klass != nullptr); 455 Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self()))); 456 ASSERT_TRUE(h_obj != nullptr); 457 ASSERT_EQ(h_obj->GetClass(), h_klass.Get()); 458 459 // Modify fields inside transaction then rollback changes. 460 Transaction transaction; 461 Runtime::Current()->EnterTransactionMode(&transaction); 462 booleanArray->SetWithoutChecks<true>(0, true); 463 byteArray->SetWithoutChecks<true>(0, 1); 464 charArray->SetWithoutChecks<true>(0, 1u); 465 shortArray->SetWithoutChecks<true>(0, 1); 466 intArray->SetWithoutChecks<true>(0, 1); 467 longArray->SetWithoutChecks<true>(0, 1); 468 floatArray->SetWithoutChecks<true>(0, 1.0); 469 doubleArray->SetWithoutChecks<true>(0, 1.0); 470 objectArray->SetWithoutChecks<true>(0, h_obj.Get()); 471 Runtime::Current()->ExitTransactionMode(); 472 transaction.Rollback(); 473 474 // Check values have properly been restored to their original (default) value. 475 EXPECT_EQ(booleanArray->GetWithoutChecks(0), false); 476 EXPECT_EQ(byteArray->GetWithoutChecks(0), 0); 477 EXPECT_EQ(charArray->GetWithoutChecks(0), 0u); 478 EXPECT_EQ(shortArray->GetWithoutChecks(0), 0); 479 EXPECT_EQ(intArray->GetWithoutChecks(0), 0); 480 EXPECT_EQ(longArray->GetWithoutChecks(0), static_cast<int64_t>(0)); 481 EXPECT_FLOAT_EQ(floatArray->GetWithoutChecks(0), static_cast<float>(0.0f)); 482 EXPECT_DOUBLE_EQ(doubleArray->GetWithoutChecks(0), static_cast<double>(0.0f)); 483 EXPECT_EQ(objectArray->GetWithoutChecks(0), nullptr); 484 } 485 486 // Tests rolling back interned strings and resolved strings. 487 TEST_F(TransactionTest, ResolveString) { 488 ScopedObjectAccess soa(Thread::Current()); 489 StackHandleScope<3> hs(soa.Self()); 490 Handle<mirror::ClassLoader> class_loader( 491 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction")))); 492 ASSERT_TRUE(class_loader != nullptr); 493 494 Handle<mirror::Class> h_klass( 495 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LTransaction$ResolveString;", 496 class_loader))); 497 ASSERT_TRUE(h_klass != nullptr); 498 499 Handle<mirror::DexCache> h_dex_cache(hs.NewHandle(h_klass->GetDexCache())); 500 ASSERT_TRUE(h_dex_cache != nullptr); 501 const DexFile* const dex_file = h_dex_cache->GetDexFile(); 502 ASSERT_TRUE(dex_file != nullptr); 503 504 // Go search the dex file to find the string id of our string. 505 static const char* kResolvedString = "ResolvedString"; 506 const DexFile::StringId* string_id = dex_file->FindStringId(kResolvedString); 507 ASSERT_TRUE(string_id != nullptr); 508 dex::StringIndex string_idx = dex_file->GetIndexForStringId(*string_id); 509 ASSERT_TRUE(string_idx.IsValid()); 510 // String should only get resolved by the initializer. 511 EXPECT_TRUE(class_linker_->LookupString(*dex_file, string_idx, h_dex_cache.Get()) == nullptr); 512 EXPECT_TRUE(h_dex_cache->GetResolvedString(string_idx) == nullptr); 513 // Do the transaction, then roll back. 514 Transaction transaction; 515 Runtime::Current()->EnterTransactionMode(&transaction); 516 bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true); 517 ASSERT_TRUE(success); 518 ASSERT_TRUE(h_klass->IsInitialized()); 519 // Make sure the string got resolved by the transaction. 520 { 521 mirror::String* s = class_linker_->LookupString(*dex_file, string_idx, h_dex_cache.Get()); 522 ASSERT_TRUE(s != nullptr); 523 EXPECT_STREQ(s->ToModifiedUtf8().c_str(), kResolvedString); 524 EXPECT_EQ(s, h_dex_cache->GetResolvedString(string_idx)); 525 } 526 Runtime::Current()->ExitTransactionMode(); 527 transaction.Rollback(); 528 // Check that the string did not stay resolved. 529 EXPECT_TRUE(class_linker_->LookupString(*dex_file, string_idx, h_dex_cache.Get()) == nullptr); 530 EXPECT_TRUE(h_dex_cache->GetResolvedString(string_idx) == nullptr); 531 ASSERT_FALSE(h_klass->IsInitialized()); 532 ASSERT_FALSE(soa.Self()->IsExceptionPending()); 533 } 534 535 // Tests successful class initialization without class initializer. 536 TEST_F(TransactionTest, EmptyClass) { 537 ScopedObjectAccess soa(Thread::Current()); 538 StackHandleScope<2> hs(soa.Self()); 539 Handle<mirror::ClassLoader> class_loader( 540 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction")))); 541 ASSERT_TRUE(class_loader != nullptr); 542 543 Handle<mirror::Class> h_klass( 544 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LTransaction$EmptyStatic;", 545 class_loader))); 546 ASSERT_TRUE(h_klass != nullptr); 547 class_linker_->VerifyClass(soa.Self(), h_klass); 548 ASSERT_TRUE(h_klass->IsVerified()); 549 550 Transaction transaction; 551 Runtime::Current()->EnterTransactionMode(&transaction); 552 bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true); 553 Runtime::Current()->ExitTransactionMode(); 554 ASSERT_TRUE(success); 555 ASSERT_TRUE(h_klass->IsInitialized()); 556 ASSERT_FALSE(soa.Self()->IsExceptionPending()); 557 } 558 559 // Tests successful class initialization with class initializer. 560 TEST_F(TransactionTest, StaticFieldClass) { 561 ScopedObjectAccess soa(Thread::Current()); 562 StackHandleScope<2> hs(soa.Self()); 563 Handle<mirror::ClassLoader> class_loader( 564 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction")))); 565 ASSERT_TRUE(class_loader != nullptr); 566 567 Handle<mirror::Class> h_klass( 568 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LTransaction$StaticFieldClass;", 569 class_loader))); 570 ASSERT_TRUE(h_klass != nullptr); 571 class_linker_->VerifyClass(soa.Self(), h_klass); 572 ASSERT_TRUE(h_klass->IsVerified()); 573 574 Transaction transaction; 575 Runtime::Current()->EnterTransactionMode(&transaction); 576 bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true); 577 Runtime::Current()->ExitTransactionMode(); 578 ASSERT_TRUE(success); 579 ASSERT_TRUE(h_klass->IsInitialized()); 580 ASSERT_FALSE(soa.Self()->IsExceptionPending()); 581 } 582 583 // Tests failing class initialization due to native call. 584 TEST_F(TransactionTest, NativeCallAbortClass) { 585 testTransactionAbort("LTransaction$NativeCallAbortClass;"); 586 } 587 588 // Tests failing class initialization due to native call in a "synchronized" statement 589 // (which must catch any exception, do the monitor-exit then re-throw the caught exception). 590 TEST_F(TransactionTest, SynchronizedNativeCallAbortClass) { 591 testTransactionAbort("LTransaction$SynchronizedNativeCallAbortClass;"); 592 } 593 594 // Tests failing class initialization due to native call, even if an "all" catch handler 595 // catches the exception thrown when aborting the transaction. 596 TEST_F(TransactionTest, CatchNativeCallAbortClass) { 597 testTransactionAbort("LTransaction$CatchNativeCallAbortClass;"); 598 } 599 600 // Tests failing class initialization with multiple transaction aborts. 601 TEST_F(TransactionTest, MultipleNativeCallAbortClass) { 602 testTransactionAbort("LTransaction$MultipleNativeCallAbortClass;"); 603 } 604 605 // Tests failing class initialization due to allocating instance of finalizable class. 606 TEST_F(TransactionTest, FinalizableAbortClass) { 607 testTransactionAbort("LTransaction$FinalizableAbortClass;"); 608 } 609 } // namespace art 610
