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.
testTransactionAbort(const char * tested_class_signature)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.
TEST_F(TransactionTest,Object_class)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.
TEST_F(TransactionTest,Object_monitor)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.
TEST_F(TransactionTest,Array_length)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.
TEST_F(TransactionTest,StaticFieldsTest)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.
TEST_F(TransactionTest,InstanceFieldsTest)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.
TEST_F(TransactionTest,StaticArrayFieldsTest)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.
TEST_F(TransactionTest,ResolveString)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.
TEST_F(TransactionTest,EmptyClass)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.
TEST_F(TransactionTest,StaticFieldClass)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.
TEST_F(TransactionTest,NativeCallAbortClass)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).
TEST_F(TransactionTest,SynchronizedNativeCallAbortClass)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.
TEST_F(TransactionTest,CatchNativeCallAbortClass)596 TEST_F(TransactionTest, CatchNativeCallAbortClass) {
597 testTransactionAbort("LTransaction$CatchNativeCallAbortClass;");
598 }
599
600 // Tests failing class initialization with multiple transaction aborts.
TEST_F(TransactionTest,MultipleNativeCallAbortClass)601 TEST_F(TransactionTest, MultipleNativeCallAbortClass) {
602 testTransactionAbort("LTransaction$MultipleNativeCallAbortClass;");
603 }
604
605 // Tests failing class initialization due to allocating instance of finalizable class.
TEST_F(TransactionTest,FinalizableAbortClass)606 TEST_F(TransactionTest, FinalizableAbortClass) {
607 testTransactionAbort("LTransaction$FinalizableAbortClass;");
608 }
609 } // namespace art
610