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