xref: /aosp_15_r20/art/dex2oat/transaction_test.cc (revision 795d594fd825385562da6b089ea9b2033f3abf5a) 
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_transaction_test.h"
23 #include "common_throws.h"
24 #include "dex/dex_file.h"
25 #include "mirror/array-alloc-inl.h"
26 #include "mirror/class-alloc-inl.h"
27 #include "scoped_thread_state_change-inl.h"
28 
29 namespace art HIDDEN {
30 
31 class TransactionTest : public CommonTransactionTest {
32  protected:
TransactionTest()33   TransactionTest() {
34     this->use_boot_image_ = true;  // We need the boot image for this test.
35   }
36 
37   // Tests failing class initialization due to native call with transaction rollback.
testTransactionAbort(const char * tested_class_signature)38   void testTransactionAbort(const char* tested_class_signature) {
39     ScopedObjectAccess soa(Thread::Current());
40     jobject jclass_loader = LoadDex("Transaction");
41     StackHandleScope<2> hs(soa.Self());
42     Handle<mirror::ClassLoader> class_loader(
43         hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
44     ASSERT_TRUE(class_loader != nullptr);
45 
46     // Load and initialize java.lang.ExceptionInInitializerError and the exception class used
47     // to abort transaction so they can be thrown during class initialization if the transaction
48     // aborts.
49     MutableHandle<mirror::Class> h_klass(
50         hs.NewHandle(class_linker_->FindSystemClass(soa.Self(),
51                                                     "Ljava/lang/ExceptionInInitializerError;")));
52     ASSERT_TRUE(h_klass != nullptr);
53     class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true);
54     ASSERT_TRUE(h_klass->IsInitialized());
55 
56     h_klass.Assign(class_linker_->FindSystemClass(soa.Self(), kTransactionAbortErrorDescriptor));
57     ASSERT_TRUE(h_klass != nullptr);
58     class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true);
59     ASSERT_TRUE(h_klass->IsInitialized());
60 
61     // Load and verify utility class.
62     h_klass.Assign(FindClass("LTransaction$AbortHelperClass;", class_loader));
63     ASSERT_TRUE(h_klass != nullptr);
64     class_linker_->VerifyClass(soa.Self(), /* verifier_deps= */ nullptr, h_klass);
65     ASSERT_TRUE(h_klass->IsVerified());
66 
67     // Load and verify tested class.
68     h_klass.Assign(FindClass(tested_class_signature, class_loader));
69     ASSERT_TRUE(h_klass != nullptr);
70     class_linker_->VerifyClass(soa.Self(), /* verifier_deps= */ nullptr, h_klass);
71     ASSERT_TRUE(h_klass->IsVerified());
72 
73     ClassStatus old_status = h_klass->GetStatus();
74     LockWord old_lock_word = h_klass->GetLockWord(false);
75 
76     EnterTransactionMode();
77     bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true);
78     ASSERT_TRUE(IsTransactionAborted());
79     ASSERT_FALSE(success);
80     ASSERT_TRUE(h_klass->IsErroneous());
81     ASSERT_TRUE(soa.Self()->IsExceptionPending());
82 
83     // Check class's monitor get back to its original state without rolling back changes.
84     LockWord new_lock_word = h_klass->GetLockWord(false);
85     EXPECT_TRUE(LockWord::Equal<false>(old_lock_word, new_lock_word));
86 
87     // Check class status is rolled back properly.
88     soa.Self()->ClearException();
89     RollbackAndExitTransactionMode();
90     ASSERT_EQ(old_status, h_klass->GetStatus());
91   }
92 };
93 
94 // Tests object's class is preserved after transaction rollback.
TEST_F(TransactionTest,Object_class)95 TEST_F(TransactionTest, Object_class) {
96   ScopedObjectAccess soa(Thread::Current());
97   StackHandleScope<2> hs(soa.Self());
98   Handle<mirror::Class> h_klass(
99       hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
100   ASSERT_TRUE(h_klass != nullptr);
101 
102   EnterTransactionMode();
103   Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self())));
104   ASSERT_TRUE(h_obj != nullptr);
105   ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
106   // Rolling back transaction's changes must not clear the Object::class field.
107   RollbackAndExitTransactionMode();
108   EXPECT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
109 }
110 
111 // Tests object's monitor state is preserved after transaction rollback.
TEST_F(TransactionTest,Object_monitor)112 TEST_F(TransactionTest, Object_monitor) {
113   ScopedObjectAccess soa(Thread::Current());
114   StackHandleScope<2> hs(soa.Self());
115   Handle<mirror::Class> h_klass(
116       hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
117   ASSERT_TRUE(h_klass != nullptr);
118   Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self())));
119   ASSERT_TRUE(h_obj != nullptr);
120   ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
121 
122   // Lock object's monitor outside the transaction.
123   h_obj->MonitorEnter(soa.Self());
124   LockWord old_lock_word = h_obj->GetLockWord(false);
125 
126   EnterTransactionMode();
127   // Unlock object's monitor inside the transaction.
128   h_obj->MonitorExit(soa.Self());
129   LockWord new_lock_word = h_obj->GetLockWord(false);
130   // Rolling back transaction's changes must not change monitor's state.
131   RollbackAndExitTransactionMode();
132 
133   LockWord aborted_lock_word = h_obj->GetLockWord(false);
134   EXPECT_FALSE(LockWord::Equal<false>(old_lock_word, new_lock_word));
135   EXPECT_TRUE(LockWord::Equal<false>(aborted_lock_word, new_lock_word));
136 }
137 
138 // Tests array's length is preserved after transaction rollback.
TEST_F(TransactionTest,Array_length)139 TEST_F(TransactionTest, Array_length) {
140   ScopedObjectAccess soa(Thread::Current());
141   StackHandleScope<2> hs(soa.Self());
142   Handle<mirror::Class> h_klass(
143       hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;")));
144   ASSERT_TRUE(h_klass != nullptr);
145 
146   constexpr int32_t kArraySize = 2;
147 
148   EnterTransactionMode();
149 
150   // Allocate an array during transaction.
151   Handle<mirror::Array> h_obj = hs.NewHandle(
152       mirror::Array::Alloc(soa.Self(),
153                            h_klass.Get(),
154                            kArraySize,
155                            h_klass->GetComponentSizeShift(),
156                            Runtime::Current()->GetHeap()->GetCurrentAllocator()));
157   ASSERT_TRUE(h_obj != nullptr);
158   ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
159   RollbackAndExitTransactionMode();
160 
161   // Rolling back transaction's changes must not reset array's length.
162   EXPECT_EQ(h_obj->GetLength(), kArraySize);
163 }
164 
165 // Tests static fields are reset to their default value after transaction rollback.
TEST_F(TransactionTest,StaticFieldsTest)166 TEST_F(TransactionTest, StaticFieldsTest) {
167   ScopedObjectAccess soa(Thread::Current());
168   StackHandleScope<4> hs(soa.Self());
169   Handle<mirror::ClassLoader> class_loader(
170       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction"))));
171   ASSERT_TRUE(class_loader != nullptr);
172 
173   Handle<mirror::Class> h_klass = hs.NewHandle(FindClass("LStaticFieldsTest;", class_loader));
174   ASSERT_TRUE(h_klass != nullptr);
175   bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true);
176   ASSERT_TRUE(success);
177   ASSERT_TRUE(h_klass->IsInitialized());
178   ASSERT_FALSE(soa.Self()->IsExceptionPending());
179 
180   // Lookup fields.
181   ArtField* booleanField = h_klass->FindDeclaredStaticField("booleanField", "Z");
182   ASSERT_TRUE(booleanField != nullptr);
183   ASSERT_EQ(booleanField->GetTypeAsPrimitiveType(), Primitive::kPrimBoolean);
184   ASSERT_EQ(booleanField->GetBoolean(h_klass.Get()), false);
185 
186   ArtField* byteField = h_klass->FindDeclaredStaticField("byteField", "B");
187   ASSERT_TRUE(byteField != nullptr);
188   ASSERT_EQ(byteField->GetTypeAsPrimitiveType(), Primitive::kPrimByte);
189   ASSERT_EQ(byteField->GetByte(h_klass.Get()), 0);
190 
191   ArtField* charField = h_klass->FindDeclaredStaticField("charField", "C");
192   ASSERT_TRUE(charField != nullptr);
193   ASSERT_EQ(charField->GetTypeAsPrimitiveType(), Primitive::kPrimChar);
194   ASSERT_EQ(charField->GetChar(h_klass.Get()), 0u);
195 
196   ArtField* shortField = h_klass->FindDeclaredStaticField("shortField", "S");
197   ASSERT_TRUE(shortField != nullptr);
198   ASSERT_EQ(shortField->GetTypeAsPrimitiveType(), Primitive::kPrimShort);
199   ASSERT_EQ(shortField->GetShort(h_klass.Get()), 0);
200 
201   ArtField* intField = h_klass->FindDeclaredStaticField("intField", "I");
202   ASSERT_TRUE(intField != nullptr);
203   ASSERT_EQ(intField->GetTypeAsPrimitiveType(), Primitive::kPrimInt);
204   ASSERT_EQ(intField->GetInt(h_klass.Get()), 0);
205 
206   ArtField* longField = h_klass->FindDeclaredStaticField("longField", "J");
207   ASSERT_TRUE(longField != nullptr);
208   ASSERT_EQ(longField->GetTypeAsPrimitiveType(), Primitive::kPrimLong);
209   ASSERT_EQ(longField->GetLong(h_klass.Get()), static_cast<int64_t>(0));
210 
211   ArtField* floatField = h_klass->FindDeclaredStaticField("floatField", "F");
212   ASSERT_TRUE(floatField != nullptr);
213   ASSERT_EQ(floatField->GetTypeAsPrimitiveType(), Primitive::kPrimFloat);
214   ASSERT_FLOAT_EQ(floatField->GetFloat(h_klass.Get()), static_cast<float>(0.0f));
215 
216   ArtField* doubleField = h_klass->FindDeclaredStaticField("doubleField", "D");
217   ASSERT_TRUE(doubleField != nullptr);
218   ASSERT_EQ(doubleField->GetTypeAsPrimitiveType(), Primitive::kPrimDouble);
219   ASSERT_DOUBLE_EQ(doubleField->GetDouble(h_klass.Get()), static_cast<double>(0.0));
220 
221   ArtField* objectField = h_klass->FindDeclaredStaticField("objectField",
222                                                                    "Ljava/lang/Object;");
223   ASSERT_TRUE(objectField != nullptr);
224   ASSERT_EQ(objectField->GetTypeAsPrimitiveType(), Primitive::kPrimNot);
225   ASSERT_EQ(objectField->GetObject(h_klass.Get()), nullptr);
226 
227   // Create a java.lang.Object instance to set objectField.
228   Handle<mirror::Class> object_klass(
229       hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
230   ASSERT_TRUE(object_klass != nullptr);
231   Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self())));
232   ASSERT_TRUE(h_obj != nullptr);
233   ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
234 
235   // Modify fields inside transaction then rollback changes.
236   EnterTransactionMode();
237   booleanField->SetBoolean<true>(h_klass.Get(), true);
238   byteField->SetByte<true>(h_klass.Get(), 1);
239   charField->SetChar<true>(h_klass.Get(), 1u);
240   shortField->SetShort<true>(h_klass.Get(), 1);
241   intField->SetInt<true>(h_klass.Get(), 1);
242   longField->SetLong<true>(h_klass.Get(), 1);
243   floatField->SetFloat<true>(h_klass.Get(), 1.0);
244   doubleField->SetDouble<true>(h_klass.Get(), 1.0);
245   objectField->SetObject<true>(h_klass.Get(), h_obj.Get());
246   RollbackAndExitTransactionMode();
247 
248   // Check values have properly been restored to their original (default) value.
249   EXPECT_EQ(booleanField->GetBoolean(h_klass.Get()), false);
250   EXPECT_EQ(byteField->GetByte(h_klass.Get()), 0);
251   EXPECT_EQ(charField->GetChar(h_klass.Get()), 0u);
252   EXPECT_EQ(shortField->GetShort(h_klass.Get()), 0);
253   EXPECT_EQ(intField->GetInt(h_klass.Get()), 0);
254   EXPECT_EQ(longField->GetLong(h_klass.Get()), static_cast<int64_t>(0));
255   EXPECT_FLOAT_EQ(floatField->GetFloat(h_klass.Get()), static_cast<float>(0.0f));
256   EXPECT_DOUBLE_EQ(doubleField->GetDouble(h_klass.Get()), static_cast<double>(0.0));
257   EXPECT_EQ(objectField->GetObject(h_klass.Get()), nullptr);
258 }
259 
260 // Tests instance fields are reset to their default value after transaction rollback.
TEST_F(TransactionTest,InstanceFieldsTest)261 TEST_F(TransactionTest, InstanceFieldsTest) {
262   ScopedObjectAccess soa(Thread::Current());
263   StackHandleScope<5> hs(soa.Self());
264   Handle<mirror::ClassLoader> class_loader(
265       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction"))));
266   ASSERT_TRUE(class_loader != nullptr);
267 
268   Handle<mirror::Class> h_klass = hs.NewHandle(FindClass("LInstanceFieldsTest;", class_loader));
269   ASSERT_TRUE(h_klass != nullptr);
270   bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true);
271   ASSERT_TRUE(success);
272   ASSERT_TRUE(h_klass->IsInitialized());
273   ASSERT_FALSE(soa.Self()->IsExceptionPending());
274 
275   // Allocate an InstanceFieldTest object.
276   Handle<mirror::Object> h_instance(hs.NewHandle(h_klass->AllocObject(soa.Self())));
277   ASSERT_TRUE(h_instance != nullptr);
278 
279   // Lookup fields.
280   ArtField* booleanField = h_klass->FindDeclaredInstanceField("booleanField", "Z");
281   ASSERT_TRUE(booleanField != nullptr);
282   ASSERT_EQ(booleanField->GetTypeAsPrimitiveType(), Primitive::kPrimBoolean);
283   ASSERT_EQ(booleanField->GetBoolean(h_instance.Get()), false);
284 
285   ArtField* byteField = h_klass->FindDeclaredInstanceField("byteField", "B");
286   ASSERT_TRUE(byteField != nullptr);
287   ASSERT_EQ(byteField->GetTypeAsPrimitiveType(), Primitive::kPrimByte);
288   ASSERT_EQ(byteField->GetByte(h_instance.Get()), 0);
289 
290   ArtField* charField = h_klass->FindDeclaredInstanceField("charField", "C");
291   ASSERT_TRUE(charField != nullptr);
292   ASSERT_EQ(charField->GetTypeAsPrimitiveType(), Primitive::kPrimChar);
293   ASSERT_EQ(charField->GetChar(h_instance.Get()), 0u);
294 
295   ArtField* shortField = h_klass->FindDeclaredInstanceField("shortField", "S");
296   ASSERT_TRUE(shortField != nullptr);
297   ASSERT_EQ(shortField->GetTypeAsPrimitiveType(), Primitive::kPrimShort);
298   ASSERT_EQ(shortField->GetShort(h_instance.Get()), 0);
299 
300   ArtField* intField = h_klass->FindDeclaredInstanceField("intField", "I");
301   ASSERT_TRUE(intField != nullptr);
302   ASSERT_EQ(intField->GetTypeAsPrimitiveType(), Primitive::kPrimInt);
303   ASSERT_EQ(intField->GetInt(h_instance.Get()), 0);
304 
305   ArtField* longField = h_klass->FindDeclaredInstanceField("longField", "J");
306   ASSERT_TRUE(longField != nullptr);
307   ASSERT_EQ(longField->GetTypeAsPrimitiveType(), Primitive::kPrimLong);
308   ASSERT_EQ(longField->GetLong(h_instance.Get()), static_cast<int64_t>(0));
309 
310   ArtField* floatField = h_klass->FindDeclaredInstanceField("floatField", "F");
311   ASSERT_TRUE(floatField != nullptr);
312   ASSERT_EQ(floatField->GetTypeAsPrimitiveType(), Primitive::kPrimFloat);
313   ASSERT_FLOAT_EQ(floatField->GetFloat(h_instance.Get()), static_cast<float>(0.0f));
314 
315   ArtField* doubleField = h_klass->FindDeclaredInstanceField("doubleField", "D");
316   ASSERT_TRUE(doubleField != nullptr);
317   ASSERT_EQ(doubleField->GetTypeAsPrimitiveType(), Primitive::kPrimDouble);
318   ASSERT_DOUBLE_EQ(doubleField->GetDouble(h_instance.Get()), static_cast<double>(0.0));
319 
320   ArtField* objectField = h_klass->FindDeclaredInstanceField("objectField",
321                                                                         "Ljava/lang/Object;");
322   ASSERT_TRUE(objectField != nullptr);
323   ASSERT_EQ(objectField->GetTypeAsPrimitiveType(), Primitive::kPrimNot);
324   ASSERT_EQ(objectField->GetObject(h_instance.Get()), nullptr);
325 
326   // Create a java.lang.Object instance to set objectField.
327   Handle<mirror::Class> object_klass(
328       hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
329   ASSERT_TRUE(object_klass != nullptr);
330   Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self())));
331   ASSERT_TRUE(h_obj != nullptr);
332   ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
333 
334   // Modify fields inside transaction then rollback changes.
335   EnterTransactionMode();
336   booleanField->SetBoolean<true>(h_instance.Get(), true);
337   byteField->SetByte<true>(h_instance.Get(), 1);
338   charField->SetChar<true>(h_instance.Get(), 1u);
339   shortField->SetShort<true>(h_instance.Get(), 1);
340   intField->SetInt<true>(h_instance.Get(), 1);
341   longField->SetLong<true>(h_instance.Get(), 1);
342   floatField->SetFloat<true>(h_instance.Get(), 1.0);
343   doubleField->SetDouble<true>(h_instance.Get(), 1.0);
344   objectField->SetObject<true>(h_instance.Get(), h_obj.Get());
345   RollbackAndExitTransactionMode();
346 
347   // Check values have properly been restored to their original (default) value.
348   EXPECT_EQ(booleanField->GetBoolean(h_instance.Get()), false);
349   EXPECT_EQ(byteField->GetByte(h_instance.Get()), 0);
350   EXPECT_EQ(charField->GetChar(h_instance.Get()), 0u);
351   EXPECT_EQ(shortField->GetShort(h_instance.Get()), 0);
352   EXPECT_EQ(intField->GetInt(h_instance.Get()), 0);
353   EXPECT_EQ(longField->GetLong(h_instance.Get()), static_cast<int64_t>(0));
354   EXPECT_FLOAT_EQ(floatField->GetFloat(h_instance.Get()), static_cast<float>(0.0f));
355   EXPECT_DOUBLE_EQ(doubleField->GetDouble(h_instance.Get()), static_cast<double>(0.0));
356   EXPECT_EQ(objectField->GetObject(h_instance.Get()), nullptr);
357 
358   // Fail to modify fields with strong CAS inside transaction, then rollback changes.
359   EnterTransactionMode();
360   bool cas_success = h_instance->CasField32</*kTransactionActive=*/ true>(
361       intField->GetOffset(),
362       /*old_value=*/ 1,
363       /*new_value=*/ 2,
364       CASMode::kStrong,
365       std::memory_order_seq_cst);
366   EXPECT_FALSE(cas_success);
367   cas_success = h_instance->CasFieldStrongSequentiallyConsistent64</*kTransactionActive=*/ true>(
368       longField->GetOffset(), /*old_value=*/ INT64_C(1), /*new_value=*/ INT64_C(2));
369   EXPECT_FALSE(cas_success);
370   cas_success = h_instance->CasFieldObject</*kTransactionActive=*/ true>(
371       objectField->GetOffset(),
372       /*old_value=*/ h_instance.Get(),
373       /*new_value=*/ nullptr,
374       CASMode::kStrong,
375       std::memory_order_seq_cst);
376   EXPECT_FALSE(cas_success);
377   RollbackAndExitTransactionMode();
378 
379   // Check values have properly been restored to their original (default) value.
380   EXPECT_EQ(intField->GetInt(h_instance.Get()), 0);
381   EXPECT_EQ(longField->GetLong(h_instance.Get()), static_cast<int64_t>(0));
382   EXPECT_EQ(objectField->GetObject(h_instance.Get()), nullptr);
383 
384   // Fail to modify fields with weak CAS inside transaction, then rollback changes.
385   EnterTransactionMode();
386   cas_success = h_instance->CasField32</*kTransactionActive=*/ true>(
387       intField->GetOffset(),
388       /*old_value=*/ 3,
389       /*new_value=*/ 4,
390       CASMode::kWeak,
391       std::memory_order_seq_cst);
392   EXPECT_FALSE(cas_success);
393   cas_success = h_instance->CasFieldWeakSequentiallyConsistent64</*kTransactionActive=*/ true>(
394       longField->GetOffset(), /*old_value=*/ INT64_C(3), /*new_value=*/ INT64_C(4));
395   EXPECT_FALSE(cas_success);
396   cas_success = h_instance->CasFieldObject</*kTransactionActive=*/ true>(
397       objectField->GetOffset(),
398       /*old_value=*/ h_klass.Get(),
399       /*new_value=*/ nullptr,
400       CASMode::kWeak,
401       std::memory_order_seq_cst);
402   EXPECT_FALSE(cas_success);
403   RollbackAndExitTransactionMode();
404 
405   // Check values have properly been restored to their original (default) value.
406   EXPECT_EQ(intField->GetInt(h_instance.Get()), 0);
407   EXPECT_EQ(longField->GetLong(h_instance.Get()), static_cast<int64_t>(0));
408   EXPECT_EQ(objectField->GetObject(h_instance.Get()), nullptr);
409 }
410 
411 // Tests static array fields are reset to their default value after transaction rollback.
TEST_F(TransactionTest,StaticArrayFieldsTest)412 TEST_F(TransactionTest, StaticArrayFieldsTest) {
413   ScopedObjectAccess soa(Thread::Current());
414   StackHandleScope<13> hs(soa.Self());
415   Handle<mirror::ClassLoader> class_loader(
416       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction"))));
417   ASSERT_TRUE(class_loader != nullptr);
418 
419   Handle<mirror::Class> h_klass = hs.NewHandle(FindClass("LStaticArrayFieldsTest;", class_loader));
420   ASSERT_TRUE(h_klass != nullptr);
421   bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true);
422   ASSERT_TRUE(success);
423   ASSERT_TRUE(h_klass->IsInitialized());
424   ASSERT_FALSE(soa.Self()->IsExceptionPending());
425 
426   // Lookup fields.
427   ArtField* booleanArrayField = h_klass->FindDeclaredStaticField("booleanArrayField", "[Z");
428   ASSERT_TRUE(booleanArrayField != nullptr);
429   Handle<mirror::BooleanArray> booleanArray = hs.NewHandle(
430       booleanArrayField->GetObject(h_klass.Get())->AsBooleanArray());
431   ASSERT_TRUE(booleanArray != nullptr);
432   ASSERT_EQ(booleanArray->GetLength(), 1);
433   ASSERT_EQ(booleanArray->GetWithoutChecks(0), false);
434 
435   ArtField* byteArrayField = h_klass->FindDeclaredStaticField("byteArrayField", "[B");
436   ASSERT_TRUE(byteArrayField != nullptr);
437   Handle<mirror::ByteArray> byteArray =
438       hs.NewHandle(byteArrayField->GetObject(h_klass.Get())->AsByteArray());
439   ASSERT_TRUE(byteArray != nullptr);
440   ASSERT_EQ(byteArray->GetLength(), 1);
441   ASSERT_EQ(byteArray->GetWithoutChecks(0), 0);
442 
443   ArtField* charArrayField = h_klass->FindDeclaredStaticField("charArrayField", "[C");
444   ASSERT_TRUE(charArrayField != nullptr);
445   Handle<mirror::CharArray> charArray =
446       hs.NewHandle(charArrayField->GetObject(h_klass.Get())->AsCharArray());
447   ASSERT_TRUE(charArray != nullptr);
448   ASSERT_EQ(charArray->GetLength(), 1);
449   ASSERT_EQ(charArray->GetWithoutChecks(0), 0u);
450 
451   ArtField* shortArrayField = h_klass->FindDeclaredStaticField("shortArrayField", "[S");
452   ASSERT_TRUE(shortArrayField != nullptr);
453   Handle<mirror::ShortArray> shortArray =
454       hs.NewHandle(shortArrayField->GetObject(h_klass.Get())->AsShortArray());
455   ASSERT_TRUE(shortArray != nullptr);
456   ASSERT_EQ(shortArray->GetLength(), 1);
457   ASSERT_EQ(shortArray->GetWithoutChecks(0), 0);
458 
459   ArtField* intArrayField = h_klass->FindDeclaredStaticField("intArrayField", "[I");
460   ASSERT_TRUE(intArrayField != nullptr);
461   Handle<mirror::IntArray> intArray =
462       hs.NewHandle(intArrayField->GetObject(h_klass.Get())->AsIntArray());
463   ASSERT_TRUE(intArray != nullptr);
464   ASSERT_EQ(intArray->GetLength(), 1);
465   ASSERT_EQ(intArray->GetWithoutChecks(0), 0);
466 
467   ArtField* longArrayField = h_klass->FindDeclaredStaticField("longArrayField", "[J");
468   ASSERT_TRUE(longArrayField != nullptr);
469   Handle<mirror::LongArray> longArray =
470       hs.NewHandle(longArrayField->GetObject(h_klass.Get())->AsLongArray());
471   ASSERT_TRUE(longArray != nullptr);
472   ASSERT_EQ(longArray->GetLength(), 1);
473   ASSERT_EQ(longArray->GetWithoutChecks(0), static_cast<int64_t>(0));
474 
475   ArtField* floatArrayField = h_klass->FindDeclaredStaticField("floatArrayField", "[F");
476   ASSERT_TRUE(floatArrayField != nullptr);
477   Handle<mirror::FloatArray> floatArray =
478       hs.NewHandle(floatArrayField->GetObject(h_klass.Get())->AsFloatArray());
479   ASSERT_TRUE(floatArray != nullptr);
480   ASSERT_EQ(floatArray->GetLength(), 1);
481   ASSERT_FLOAT_EQ(floatArray->GetWithoutChecks(0), static_cast<float>(0.0f));
482 
483   ArtField* doubleArrayField = h_klass->FindDeclaredStaticField("doubleArrayField", "[D");
484   ASSERT_TRUE(doubleArrayField != nullptr);
485   Handle<mirror::DoubleArray> doubleArray =
486       hs.NewHandle(doubleArrayField->GetObject(h_klass.Get())->AsDoubleArray());
487   ASSERT_TRUE(doubleArray != nullptr);
488   ASSERT_EQ(doubleArray->GetLength(), 1);
489   ASSERT_DOUBLE_EQ(doubleArray->GetWithoutChecks(0), static_cast<double>(0.0f));
490 
491   ArtField* objectArrayField =
492       h_klass->FindDeclaredStaticField("objectArrayField", "[Ljava/lang/Object;");
493   ASSERT_TRUE(objectArrayField != nullptr);
494   Handle<mirror::ObjectArray<mirror::Object>> objectArray =
495       hs.NewHandle(objectArrayField->GetObject(h_klass.Get())->AsObjectArray<mirror::Object>());
496   ASSERT_TRUE(objectArray != nullptr);
497   ASSERT_EQ(objectArray->GetLength(), 1);
498   ASSERT_EQ(objectArray->GetWithoutChecks(0), nullptr);
499 
500   // Create a java.lang.Object instance to set objectField.
501   Handle<mirror::Class> object_klass(
502       hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
503   ASSERT_TRUE(object_klass != nullptr);
504   Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self())));
505   ASSERT_TRUE(h_obj != nullptr);
506   ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
507 
508   // Modify fields inside transaction then rollback changes.
509   EnterTransactionMode();
510   booleanArray->SetWithoutChecks<true>(0, true);
511   byteArray->SetWithoutChecks<true>(0, 1);
512   charArray->SetWithoutChecks<true>(0, 1u);
513   shortArray->SetWithoutChecks<true>(0, 1);
514   intArray->SetWithoutChecks<true>(0, 1);
515   longArray->SetWithoutChecks<true>(0, 1);
516   floatArray->SetWithoutChecks<true>(0, 1.0);
517   doubleArray->SetWithoutChecks<true>(0, 1.0);
518   objectArray->SetWithoutChecks<true>(0, h_obj.Get());
519   RollbackAndExitTransactionMode();
520 
521   // Check values have properly been restored to their original (default) value.
522   EXPECT_EQ(booleanArray->GetWithoutChecks(0), false);
523   EXPECT_EQ(byteArray->GetWithoutChecks(0), 0);
524   EXPECT_EQ(charArray->GetWithoutChecks(0), 0u);
525   EXPECT_EQ(shortArray->GetWithoutChecks(0), 0);
526   EXPECT_EQ(intArray->GetWithoutChecks(0), 0);
527   EXPECT_EQ(longArray->GetWithoutChecks(0), static_cast<int64_t>(0));
528   EXPECT_FLOAT_EQ(floatArray->GetWithoutChecks(0), static_cast<float>(0.0f));
529   EXPECT_DOUBLE_EQ(doubleArray->GetWithoutChecks(0), static_cast<double>(0.0f));
530   EXPECT_EQ(objectArray->GetWithoutChecks(0), nullptr);
531 }
532 
533 // Tests rolling back interned strings and resolved strings.
TEST_F(TransactionTest,ResolveString)534 TEST_F(TransactionTest, ResolveString) {
535   ScopedObjectAccess soa(Thread::Current());
536   StackHandleScope<3> hs(soa.Self());
537   Handle<mirror::ClassLoader> class_loader(
538       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction"))));
539   ASSERT_TRUE(class_loader != nullptr);
540 
541   Handle<mirror::Class> h_klass =
542       hs.NewHandle(FindClass("LTransaction$ResolveString;", class_loader));
543   ASSERT_TRUE(h_klass != nullptr);
544 
545   Handle<mirror::DexCache> h_dex_cache(hs.NewHandle(h_klass->GetDexCache()));
546   ASSERT_TRUE(h_dex_cache != nullptr);
547   const DexFile* const dex_file = h_dex_cache->GetDexFile();
548   ASSERT_TRUE(dex_file != nullptr);
549 
550   // Go search the dex file to find the string id of our string.
551   static const char* kResolvedString = "ResolvedString";
552   const dex::StringId* string_id = dex_file->FindStringId(kResolvedString);
553   ASSERT_TRUE(string_id != nullptr);
554   dex::StringIndex string_idx = dex_file->GetIndexForStringId(*string_id);
555   ASSERT_TRUE(string_idx.IsValid());
556   // String should only get resolved by the initializer.
557   EXPECT_TRUE(class_linker_->LookupString(string_idx, h_dex_cache.Get()) == nullptr);
558   EXPECT_TRUE(h_dex_cache->GetResolvedString(string_idx) == nullptr);
559   // Do the transaction, then roll back.
560   EnterTransactionMode();
561   bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true);
562   ASSERT_TRUE(success);
563   ASSERT_TRUE(h_klass->IsInitialized());
564   // Make sure the string got resolved by the transaction.
565   {
566     ObjPtr<mirror::String> s =
567         class_linker_->LookupString(string_idx, h_dex_cache.Get());
568     ASSERT_TRUE(s != nullptr);
569     EXPECT_STREQ(s->ToModifiedUtf8().c_str(), kResolvedString);
570     EXPECT_OBJ_PTR_EQ(s, h_dex_cache->GetResolvedString(string_idx));
571   }
572   RollbackAndExitTransactionMode();
573   // Check that the string did not stay resolved.
574   EXPECT_TRUE(class_linker_->LookupString(string_idx, h_dex_cache.Get()) == nullptr);
575   EXPECT_TRUE(h_dex_cache->GetResolvedString(string_idx) == nullptr);
576   ASSERT_FALSE(h_klass->IsInitialized());
577   ASSERT_FALSE(soa.Self()->IsExceptionPending());
578 }
579 
580 class MethodTypeTransactionTest : public TransactionTest {
581  protected:
MethodTypeTransactionTest()582   MethodTypeTransactionTest() {
583     // java.lang.invoke.MethodType factory methods and mirror::MethodType::Create
584     // are backed by the same cache, which is in the primary boot image. As as a
585     // result, MethodType creation can lead to writes to the map under a
586     // transaction, which is forbidden.
587     this->use_boot_image_ = false;
588   }
589 };
590 
591 // Tests rolling back resolved method types in dex cache.
TEST_F(MethodTypeTransactionTest,ResolveMethodType)592 TEST_F(MethodTypeTransactionTest, ResolveMethodType) {
593   ScopedObjectAccess soa(Thread::Current());
594   StackHandleScope<3> hs(soa.Self());
595   Handle<mirror::ClassLoader> class_loader(
596       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction"))));
597   ASSERT_TRUE(class_loader != nullptr);
598 
599   MutableHandle<mirror::Class> h_klass(hs.NewHandle(
600       class_linker_->FindSystemClass(soa.Self(), "Ljava/util/concurrent/ConcurrentHashMap$Node;")));
601   ASSERT_TRUE(h_klass != nullptr);
602 
603   class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true);
604   ASSERT_TRUE(h_klass->IsInitialized());
605 
606   h_klass.Assign(FindClass("LTransaction;", class_loader));
607   ASSERT_TRUE(h_klass != nullptr);
608 
609   Handle<mirror::DexCache> h_dex_cache(hs.NewHandle(h_klass->GetDexCache()));
610   ASSERT_TRUE(h_dex_cache != nullptr);
611   const DexFile* const dex_file = h_dex_cache->GetDexFile();
612   ASSERT_TRUE(dex_file != nullptr);
613 
614   ASSERT_NE(dex_file->NumProtoIds(), 0u);
615   dex::ProtoIndex proto_index(0u);
616   ASSERT_TRUE(h_dex_cache->GetResolvedMethodType(proto_index) == nullptr);
617 
618   // Do the transaction, then roll back.
619   EnterTransactionMode();
620   ObjPtr<mirror::MethodType> method_type =
621       class_linker_->ResolveMethodType(soa.Self(), proto_index, h_dex_cache, class_loader);
622   ASSERT_TRUE(method_type != nullptr);
623   // Make sure the method type was recorded in the dex cache.
624   ASSERT_TRUE(h_dex_cache->GetResolvedMethodType(proto_index) == method_type);
625   RollbackAndExitTransactionMode();
626   // Check that the method type was removed from the dex cache.
627   ASSERT_TRUE(h_dex_cache->GetResolvedMethodType(proto_index) == nullptr);
628 }
629 
630 // Tests successful class initialization without class initializer.
TEST_F(TransactionTest,EmptyClass)631 TEST_F(TransactionTest, EmptyClass) {
632   ScopedObjectAccess soa(Thread::Current());
633   StackHandleScope<2> hs(soa.Self());
634   Handle<mirror::ClassLoader> class_loader(
635       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction"))));
636   ASSERT_TRUE(class_loader != nullptr);
637 
638   Handle<mirror::Class> h_klass =
639       hs.NewHandle(FindClass("LTransaction$EmptyStatic;", class_loader));
640   ASSERT_TRUE(h_klass != nullptr);
641   class_linker_->VerifyClass(soa.Self(), /* verifier_deps= */ nullptr, h_klass);
642   ASSERT_TRUE(h_klass->IsVerified());
643 
644   EnterTransactionMode();
645   bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true);
646   ExitTransactionMode();
647   ASSERT_TRUE(success);
648   ASSERT_TRUE(h_klass->IsInitialized());
649   ASSERT_FALSE(soa.Self()->IsExceptionPending());
650 }
651 
652 // Tests successful class initialization with class initializer.
TEST_F(TransactionTest,StaticFieldClass)653 TEST_F(TransactionTest, StaticFieldClass) {
654   ScopedObjectAccess soa(Thread::Current());
655   StackHandleScope<2> hs(soa.Self());
656   Handle<mirror::ClassLoader> class_loader(
657       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction"))));
658   ASSERT_TRUE(class_loader != nullptr);
659 
660   Handle<mirror::Class> h_klass =
661       hs.NewHandle(FindClass("LTransaction$StaticFieldClass;", class_loader));
662   ASSERT_TRUE(h_klass != nullptr);
663   class_linker_->VerifyClass(soa.Self(), /* verifier_deps= */ nullptr, h_klass);
664   ASSERT_TRUE(h_klass->IsVerified());
665 
666   EnterTransactionMode();
667   bool success = class_linker_->EnsureInitialized(soa.Self(), h_klass, true, true);
668   ExitTransactionMode();
669   ASSERT_TRUE(success);
670   ASSERT_TRUE(h_klass->IsInitialized());
671   ASSERT_FALSE(soa.Self()->IsExceptionPending());
672 }
673 
674 // Tests failing class initialization due to native call.
TEST_F(TransactionTest,NativeCallAbortClass)675 TEST_F(TransactionTest, NativeCallAbortClass) {
676   testTransactionAbort("LTransaction$NativeCallAbortClass;");
677 }
678 
679 // Tests failing class initialization due to native call in a "synchronized" statement
680 // (which must catch any exception, do the monitor-exit then re-throw the caught exception).
TEST_F(TransactionTest,SynchronizedNativeCallAbortClass)681 TEST_F(TransactionTest, SynchronizedNativeCallAbortClass) {
682   testTransactionAbort("LTransaction$SynchronizedNativeCallAbortClass;");
683 }
684 
685 // Tests failing class initialization due to native call, even if an "all" catch handler
686 // catches the exception thrown when aborting the transaction.
TEST_F(TransactionTest,CatchNativeCallAbortClass)687 TEST_F(TransactionTest, CatchNativeCallAbortClass) {
688   testTransactionAbort("LTransaction$CatchNativeCallAbortClass;");
689 }
690 
691 // Tests failing class initialization with multiple transaction aborts.
TEST_F(TransactionTest,MultipleNativeCallAbortClass)692 TEST_F(TransactionTest, MultipleNativeCallAbortClass) {
693   testTransactionAbort("LTransaction$MultipleNativeCallAbortClass;");
694 }
695 
696 // Tests failing class initialization due to Class.forName() not finding the class,
697 // even if an "all" catch handler catches the exception thrown when aborting the transaction.
TEST_F(TransactionTest,CatchClassForNameAbortClass)698 TEST_F(TransactionTest, CatchClassForNameAbortClass) {
699   testTransactionAbort("LTransaction$CatchClassForNameAbortClass;");
700 }
701 
702 // Same as CatchClassForNameAbortClass but the class initializer tries to do the work twice.
703 // This would trigger a DCHECK() if we continued executing bytecode with an aborted transaction.
TEST_F(TransactionTest,CatchClassForNameAbortClassTwice)704 TEST_F(TransactionTest, CatchClassForNameAbortClassTwice) {
705   testTransactionAbort("LTransaction$CatchClassForNameAbortClassTwice;");
706 }
707 
708 // Tests failing class initialization due to allocating instance of finalizable class.
TEST_F(TransactionTest,FinalizableAbortClass)709 TEST_F(TransactionTest, FinalizableAbortClass) {
710   testTransactionAbort("LTransaction$FinalizableAbortClass;");
711 }
712 
TEST_F(TransactionTest,Constraints)713 TEST_F(TransactionTest, Constraints) {
714   ScopedObjectAccess soa(Thread::Current());
715   StackHandleScope<11> hs(soa.Self());
716   Handle<mirror::ClassLoader> class_loader(
717       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Transaction"))));
718 
719   gc::Heap* heap = Runtime::Current()->GetHeap();
720   Handle<mirror::Class> boolean_class =
721       hs.NewHandle(FindClass("Ljava/lang/Boolean;", class_loader));
722   ASSERT_TRUE(boolean_class != nullptr);
723   ASSERT_TRUE(heap->ObjectIsInBootImageSpace(boolean_class.Get()));
724   ArtField* true_field = boolean_class->FindDeclaredStaticField("TRUE", "Ljava/lang/Boolean;");
725   ASSERT_TRUE(true_field != nullptr);
726   ASSERT_TRUE(true_field->IsStatic());
727   Handle<mirror::Object> true_value = hs.NewHandle(true_field->GetObject(boolean_class.Get()));
728   ASSERT_TRUE(true_value != nullptr);
729   ASSERT_TRUE(heap->ObjectIsInBootImageSpace(true_value.Get()));
730   ArtField* value_field = boolean_class->FindDeclaredInstanceField("value", "Z");
731   ASSERT_TRUE(value_field != nullptr);
732   ASSERT_FALSE(value_field->IsStatic());
733 
734   Handle<mirror::Class> static_field_class =
735       hs.NewHandle(FindClass("LTransaction$StaticFieldClass;", class_loader));
736   ASSERT_TRUE(static_field_class != nullptr);
737   ASSERT_FALSE(heap->ObjectIsInBootImageSpace(static_field_class.Get()));
738   ArtField* int_field = static_field_class->FindDeclaredStaticField("intField", "I");
739   ASSERT_TRUE(int_field != nullptr);
740 
741   Handle<mirror::Class> static_fields_test_class =
742       hs.NewHandle(FindClass("LStaticFieldsTest;", class_loader));
743   ASSERT_TRUE(static_fields_test_class != nullptr);
744   ASSERT_FALSE(heap->ObjectIsInBootImageSpace(static_fields_test_class.Get()));
745   ArtField* static_fields_test_int_field =
746       static_fields_test_class->FindDeclaredStaticField("intField", "I");
747   ASSERT_TRUE(static_fields_test_int_field != nullptr);
748 
749   Handle<mirror::Class> instance_fields_test_class =
750       hs.NewHandle(FindClass("LInstanceFieldsTest;", class_loader));
751   ASSERT_TRUE(instance_fields_test_class != nullptr);
752   ASSERT_FALSE(heap->ObjectIsInBootImageSpace(instance_fields_test_class.Get()));
753   ArtField* instance_fields_test_int_field =
754       instance_fields_test_class->FindDeclaredInstanceField("intField", "I");
755   ASSERT_TRUE(instance_fields_test_int_field != nullptr);
756   Handle<mirror::Object> instance_fields_test_object = hs.NewHandle(
757       instance_fields_test_class->Alloc(soa.Self(), heap->GetCurrentAllocator()));
758   ASSERT_TRUE(instance_fields_test_object != nullptr);
759   ASSERT_FALSE(heap->ObjectIsInBootImageSpace(instance_fields_test_object.Get()));
760 
761   // The `long[].class` should be in the boot image but `long[][][].class` should not.
762   // (We have seen `long[][].class` both present and missing from the boot image,
763   // depending on the libcore code, so we do not use it for this test.)
764   Handle<mirror::Class> long_array_dim3_class = hs.NewHandle(FindClass("[[[J", class_loader));
765   ASSERT_TRUE(long_array_dim3_class != nullptr);
766   ASSERT_FALSE(heap->ObjectIsInBootImageSpace(long_array_dim3_class.Get()));
767   ASSERT_TRUE(heap->ObjectIsInBootImageSpace(
768       long_array_dim3_class->GetComponentType()->GetComponentType()));
769   Handle<mirror::Array> long_array_dim3 = hs.NewHandle(mirror::Array::Alloc(
770       soa.Self(),
771       long_array_dim3_class.Get(),
772       /*component_count=*/ 1,
773       long_array_dim3_class->GetComponentSizeShift(),
774       heap->GetCurrentAllocator()));
775   ASSERT_TRUE(long_array_dim3 != nullptr);
776   ASSERT_FALSE(heap->ObjectIsInBootImageSpace(long_array_dim3.Get()));
777   Handle<mirror::Array> long_array = hs.NewHandle(mirror::Array::Alloc(
778       soa.Self(),
779       long_array_dim3_class->GetComponentType()->GetComponentType(),
780       /*component_count=*/ 1,
781       long_array_dim3_class->GetComponentType()->GetComponentType()->GetComponentSizeShift(),
782       heap->GetCurrentAllocator()));
783   ASSERT_TRUE(long_array != nullptr);
784   ASSERT_FALSE(heap->ObjectIsInBootImageSpace(long_array.Get()));
785 
786   // Use the Array's IfTable as an array from the boot image.
787   Handle<mirror::ObjectArray<mirror::Object>> array_iftable =
788       hs.NewHandle(long_array_dim3_class->GetIfTable());
789   ASSERT_TRUE(array_iftable != nullptr);
790   ASSERT_TRUE(heap->ObjectIsInBootImageSpace(array_iftable.Get()));
791 
792   // Test non-strict transaction.
793   ArenaPool* arena_pool = Runtime::Current()->GetArenaPool();
794   Transaction transaction(
795       /*strict=*/ false, /*root=*/ nullptr, /*arena_stack=*/ nullptr, arena_pool);
796   // Static field in boot image.
797   EXPECT_TRUE(transaction.WriteConstraint(boolean_class.Get()));
798   EXPECT_FALSE(transaction.ReadConstraint(boolean_class.Get()));
799   // Instance field or array element in boot image.
800   // Do not check ReadConstraint(), it expects only static fields (checks for class object).
801   EXPECT_TRUE(transaction.WriteConstraint(true_value.Get()));
802   EXPECT_TRUE(transaction.WriteConstraint(array_iftable.Get()));
803   // Static field not in boot image.
804   EXPECT_FALSE(transaction.WriteConstraint(static_fields_test_class.Get()));
805   EXPECT_FALSE(transaction.ReadConstraint(static_fields_test_class.Get()));
806   // Instance field or array element not in boot image.
807   // Do not check ReadConstraint(), it expects only static fields (checks for class object).
808   EXPECT_FALSE(transaction.WriteConstraint(instance_fields_test_object.Get()));
809   EXPECT_FALSE(transaction.WriteConstraint(long_array_dim3.Get()));
810   // Write value constraints.
811   EXPECT_FALSE(transaction.WriteValueConstraint(static_fields_test_class.Get()));
812   EXPECT_FALSE(transaction.WriteValueConstraint(instance_fields_test_object.Get()));
813   EXPECT_TRUE(transaction.WriteValueConstraint(long_array_dim3->GetClass()));
814   EXPECT_TRUE(transaction.WriteValueConstraint(long_array_dim3.Get()));
815   EXPECT_FALSE(transaction.WriteValueConstraint(long_array->GetClass()));
816   EXPECT_FALSE(transaction.WriteValueConstraint(long_array.Get()));
817 
818   // Test strict transaction.
819   Transaction strict_transaction(
820       /*strict=*/ true, /*root=*/ static_field_class.Get(), /*arena_stack=*/ nullptr, arena_pool);
821   // Static field in boot image.
822   EXPECT_TRUE(strict_transaction.WriteConstraint(boolean_class.Get()));
823   EXPECT_TRUE(strict_transaction.ReadConstraint(boolean_class.Get()));
824   // Instance field or array element in boot image.
825   // Do not check ReadConstraint(), it expects only static fields (checks for class object).
826   EXPECT_TRUE(strict_transaction.WriteConstraint(true_value.Get()));
827   EXPECT_TRUE(strict_transaction.WriteConstraint(array_iftable.Get()));
828   // Static field in another class not in boot image.
829   EXPECT_TRUE(strict_transaction.WriteConstraint(static_fields_test_class.Get()));
830   EXPECT_TRUE(strict_transaction.ReadConstraint(static_fields_test_class.Get()));
831   // Instance field or array element not in boot image.
832   // Do not check ReadConstraint(), it expects only static fields (checks for class object).
833   EXPECT_FALSE(strict_transaction.WriteConstraint(instance_fields_test_object.Get()));
834   EXPECT_FALSE(strict_transaction.WriteConstraint(long_array_dim3.Get()));
835   // Static field in the same class.
836   EXPECT_FALSE(strict_transaction.WriteConstraint(static_field_class.Get()));
837   EXPECT_FALSE(strict_transaction.ReadConstraint(static_field_class.Get()));
838   // Write value constraints.
839   EXPECT_FALSE(strict_transaction.WriteValueConstraint(static_fields_test_class.Get()));
840   EXPECT_FALSE(strict_transaction.WriteValueConstraint(instance_fields_test_object.Get()));
841   // TODO: The following may be revised, see a TODO in Transaction::WriteValueConstraint().
842   EXPECT_FALSE(strict_transaction.WriteValueConstraint(long_array_dim3->GetClass()));
843   EXPECT_FALSE(strict_transaction.WriteValueConstraint(long_array_dim3.Get()));
844   EXPECT_FALSE(strict_transaction.WriteValueConstraint(long_array->GetClass()));
845   EXPECT_FALSE(strict_transaction.WriteValueConstraint(long_array.Get()));
846 }
847 
848 }  // namespace art
849