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