1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "common_components/heap/ark_collector/enum_barrier.h"
17 #include "common_components/heap/ark_collector/tests/mock_barrier_collector.h"
18 #include "common_components/mutator/mutator_manager.h"
19 #include "common_components/tests/test_helper.h"
20 #include "common_components/heap/heap_manager.h"
21 #include "common_interfaces/base_runtime.h"
22
23 using namespace common;
24
25 namespace common::test {
26 class EnumBarrierTest : public common::test::BaseTestWithScope {
27 protected:
SetUpTestCase()28 static void SetUpTestCase()
29 {
30 BaseRuntime::GetInstance()->Init();
31 }
32
TearDownTestCase()33 static void TearDownTestCase() {}
34
SetUp()35 void SetUp() override
36 {
37 MutatorManager::Instance().CreateRuntimeMutator(ThreadType::ARK_PROCESSOR);
38 }
39
TearDown()40 void TearDown() override
41 {
42 MutatorManager::Instance().DestroyRuntimeMutator(ThreadType::ARK_PROCESSOR);
43 }
44 };
45
HWTEST_F_L0(EnumBarrierTest,ReadRefField_TEST1)46 HWTEST_F_L0(EnumBarrierTest, ReadRefField_TEST1)
47 {
48 MockCollector collector;
49 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
50 ASSERT_TRUE(enumBarrier != nullptr);
51
52 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
53 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
54 RefField<false> field(obj);
55
56 BaseObject* resultObj = enumBarrier->ReadRefField(obj, field);
57 ASSERT_TRUE(resultObj != nullptr);
58 EXPECT_EQ(resultObj, obj);
59 }
60
HWTEST_F_L0(EnumBarrierTest,ReadRefField_TEST2)61 HWTEST_F_L0(EnumBarrierTest, ReadRefField_TEST2)
62 {
63 MockCollector collector;
64 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
65 ASSERT_TRUE(enumBarrier != nullptr);
66
67 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
68 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
69 RefField<false> field(obj);
70
71 BaseObject* resultObj = enumBarrier->ReadRefField(nullptr, field);
72 ASSERT_TRUE(resultObj != nullptr);
73 EXPECT_EQ(resultObj, obj);
74 }
75
HWTEST_F_L0(EnumBarrierTest,ReadStaticRef_TEST1)76 HWTEST_F_L0(EnumBarrierTest, ReadStaticRef_TEST1)
77 {
78 MockCollector collector;
79 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
80 ASSERT_TRUE(enumBarrier != nullptr);
81
82 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
83 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
84 RefField<false> field(obj);
85
86 BaseObject* resultObj = enumBarrier->ReadStaticRef(field);
87 ASSERT_TRUE(resultObj != nullptr);
88 EXPECT_EQ(resultObj, obj);
89 }
90
HWTEST_F_L0(EnumBarrierTest,WriteRefField_TEST1)91 HWTEST_F_L0(EnumBarrierTest, WriteRefField_TEST1)
92 {
93 MockCollector collector;
94 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
95 ASSERT_TRUE(enumBarrier != nullptr);
96
97 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
98 BaseObject* oldObj = reinterpret_cast<BaseObject*>(addr);
99 constexpr size_t oldSize = 100;
100 oldObj->SetSizeForwarded(oldSize);
101 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
102 RefField<false> field(oldObj);
103 MAddress oldAddress = field.GetFieldValue();
104
105 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
106 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
107 constexpr size_t newSize = 200;
108 newObj->SetSizeForwarded(newSize);
109 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
110 enumBarrier->WriteRefField(oldObj, field, newObj);
111 MAddress newAddress = field.GetFieldValue();
112 EXPECT_NE(newAddress, oldAddress);
113 }
114
HWTEST_F_L0(EnumBarrierTest,WriteRefField_TEST2)115 HWTEST_F_L0(EnumBarrierTest, WriteRefField_TEST2)
116 {
117 MockCollector collector;
118 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
119 ASSERT_TRUE(enumBarrier != nullptr);
120
121 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
122 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
123 constexpr size_t oldSize = 100;
124 oldObj->SetSizeForwarded(oldSize);
125 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
126 RefField<false> field(nullptr);
127 MAddress oldAddress = field.GetFieldValue();
128
129 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
130 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
131 constexpr size_t newSize = 200;
132 newObj->SetSizeForwarded(newSize);
133 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
134 enumBarrier->WriteRefField(oldObj, field, newObj);
135 MAddress newAddress = field.GetFieldValue();
136 EXPECT_NE(newAddress, oldAddress);
137 }
138
HWTEST_F_L0(EnumBarrierTest,WriteBarrier_TEST1)139 HWTEST_F_L0(EnumBarrierTest, WriteBarrier_TEST1)
140 {
141 MockCollector collector;
142 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
143 ASSERT_TRUE(enumBarrier != nullptr);
144
145 #ifndef ARK_USE_SATB_BARRIER
146 constexpr uint64_t TAG_BITS_SHIFT = 48;
147 constexpr uint64_t TAG_MARK = 0xFFFFULL << TAG_BITS_SHIFT;
148 constexpr uint64_t TAG_SPECIAL = 0x02ULL;
149 constexpr uint64_t TAG_BOOLEAN = 0x04ULL;
150 constexpr uint64_t TAG_HEAP_OBJECT_MASK = TAG_MARK | TAG_SPECIAL | TAG_BOOLEAN;
151
152 RefField<> field(MAddress(0));
153 enumBarrier->WriteBarrier(nullptr, field, nullptr);
154 BaseObject *obj = reinterpret_cast<BaseObject *>(TAG_HEAP_OBJECT_MASK);
155 enumBarrier->WriteBarrier(obj, field, obj);
156 EXPECT_TRUE(obj != nullptr);
157 #endif
158 }
159
HWTEST_F_L0(EnumBarrierTest,WriteBarrier_TEST2)160 HWTEST_F_L0(EnumBarrierTest, WriteBarrier_TEST2)
161 {
162 MockCollector collector;
163 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
164 ASSERT_TRUE(enumBarrier != nullptr);
165
166 #ifdef ARK_USE_SATB_BARRIER
167 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
168 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
169 RefField<false> normalField(obj);
170 enumBarrier->WriteBarrier(obj, normalField, obj);
171 EXPECT_TRUE(obj != nullptr);
172
173 HeapAddress weakAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
174 BaseObject* weakObj = reinterpret_cast<BaseObject*>(weakAddr);
175 RefField<false> weakField(MAddress(0));
176 enumBarrier->WriteBarrier(&weakObj, weakField, &weakObj);
177 EXPECT_TRUE(weakObj != nullptr);
178
179 HeapAddress nonTaggedAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
180 BaseObject* nonTaggedObj = reinterpret_cast<BaseObject*>(nonTaggedAddr);
181 RefField<false> nonTaggedField(&nonTaggedObj);
182 enumBarrier->WriteBarrier(nullptr, nonTaggedField, &nonTaggedObj);
183 EXPECT_TRUE(nonTaggedObj != nullptr);
184 #endif
185 }
186
HWTEST_F_L0(EnumBarrierTest,WriteBarrier_TEST3)187 HWTEST_F_L0(EnumBarrierTest, WriteBarrier_TEST3)
188 {
189 MockCollector collector;
190 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
191 ASSERT_TRUE(enumBarrier != nullptr);
192
193 #ifndef ARK_USE_SATB_BARRIER
194 constexpr uint64_t TAG_BITS_SHIFT = 48;
195 constexpr uint64_t TAG_MARK = 0xFFFFULL << TAG_BITS_SHIFT;
196 constexpr uint64_t TAG_SPECIAL = 0x02ULL;
197 constexpr uint64_t TAG_BOOLEAN = 0x04ULL;
198 constexpr uint64_t TAG_HEAP_OBJECT_MASK = TAG_MARK | TAG_SPECIAL | TAG_BOOLEAN;
199
200 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
201 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
202 RefField<> field(obj);
203 Heap::GetHeap().SetGCReason(GC_REASON_YOUNG);
204 enumBarrier->WriteBarrier(obj, field, obj);
205 EXPECT_TRUE(obj != nullptr);
206 #endif
207 }
208
HWTEST_F_L0(EnumBarrierTest,ReadStruct_TEST1)209 HWTEST_F_L0(EnumBarrierTest, ReadStruct_TEST1)
210 {
211 MockCollector collector;
212 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
213 ASSERT_TRUE(enumBarrier != nullptr);
214
215 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
216 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
217 HeapAddress src = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
218 BaseObject* srcObj = reinterpret_cast<BaseObject*>(src);
219 srcObj->SetForwardState(BaseStateWord::ForwardState::FORWARDING);
220 HeapAddress dst = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
221 BaseObject* dstObj = reinterpret_cast<BaseObject*>(dst);
222 dstObj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
223 EXPECT_NE(dstObj->IsForwarding(), srcObj->IsForwarding());
224 enumBarrier->ReadStruct(dst, obj, src, sizeof(BaseObject));
225 EXPECT_EQ(dstObj->IsForwarding(), srcObj->IsForwarding());
226 }
227
HWTEST_F_L0(EnumBarrierTest,WriteStruct_TEST1)228 HWTEST_F_L0(EnumBarrierTest, WriteStruct_TEST1)
229 {
230 MockCollector collector;
231 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
232 ASSERT_TRUE(enumBarrier != nullptr);
233
234 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
235 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
236 HeapAddress src = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
237 BaseObject* srcObj = reinterpret_cast<BaseObject*>(src);
238 srcObj->SetForwardState(BaseStateWord::ForwardState::FORWARDING);
239 HeapAddress dst = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
240 BaseObject* dstObj = reinterpret_cast<BaseObject*>(dst);
241 dstObj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
242 EXPECT_NE(dstObj->IsForwarding(), srcObj->IsForwarding());
243 enumBarrier->WriteStruct(obj, dst, sizeof(BaseObject), src, sizeof(BaseObject));
244 EXPECT_EQ(dstObj->IsForwarding(), srcObj->IsForwarding());
245 }
246
HWTEST_F_L0(EnumBarrierTest,WriteStruct_TEST2)247 HWTEST_F_L0(EnumBarrierTest, WriteStruct_TEST2)
248 {
249 MockCollector collector;
250 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
251 ASSERT_TRUE(enumBarrier != nullptr);
252
253 HeapAddress src = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
254 BaseObject* srcObj = reinterpret_cast<BaseObject*>(src);
255 srcObj->SetForwardState(BaseStateWord::ForwardState::FORWARDING);
256 HeapAddress dst = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
257 BaseObject* dstObj = reinterpret_cast<BaseObject*>(dst);
258 dstObj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
259 EXPECT_NE(dstObj->IsForwarding(), srcObj->IsForwarding());
260 enumBarrier->WriteStruct(nullptr, dst, sizeof(BaseObject), src, sizeof(BaseObject));
261 EXPECT_EQ(dstObj->IsForwarding(), srcObj->IsForwarding());
262 }
263
HWTEST_F_L0(EnumBarrierTest,AtomicReadRefField_TEST1)264 HWTEST_F_L0(EnumBarrierTest, AtomicReadRefField_TEST1)
265 {
266 MockCollector collector;
267 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
268 ASSERT_TRUE(enumBarrier != nullptr);
269
270 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
271 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
272 constexpr size_t size = 100;
273 obj->SetSizeForwarded(size);
274 EXPECT_EQ(obj->GetSizeForwarded(), size);
275 RefField<true> field(obj);
276
277 BaseObject* resultObj = nullptr;
278 resultObj = enumBarrier->AtomicReadRefField(obj, field, std::memory_order_seq_cst);
279 ASSERT_TRUE(resultObj != nullptr);
280 }
281
HWTEST_F_L0(EnumBarrierTest,AtomicWriteRefField_TEST1)282 HWTEST_F_L0(EnumBarrierTest, AtomicWriteRefField_TEST1)
283 {
284 MockCollector collector;
285 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
286 ASSERT_TRUE(enumBarrier != nullptr);
287
288 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
289 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
290 constexpr size_t oldSize = 100;
291 oldObj->SetSizeForwarded(oldSize);
292 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
293 RefField<true> oldField(oldObj);
294 MAddress oldAddress = oldField.GetFieldValue();
295
296 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
297 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
298 constexpr size_t newSize = 200;
299 newObj->SetSizeForwarded(newSize);
300 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
301 RefField<true> newField(newObj);
302 MAddress neWAddress = newField.GetFieldValue();
303 EXPECT_NE(oldAddress, neWAddress);
304
305 enumBarrier->AtomicWriteRefField(oldObj, oldField, newObj, std::memory_order_relaxed);
306 EXPECT_EQ(oldField.GetFieldValue(), neWAddress);
307 }
308
HWTEST_F_L0(EnumBarrierTest,AtomicWriteRefField_TEST2)309 HWTEST_F_L0(EnumBarrierTest, AtomicWriteRefField_TEST2)
310 {
311 MockCollector collector;
312 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
313 ASSERT_TRUE(enumBarrier != nullptr);
314
315 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
316 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
317 constexpr size_t oldSize = 100;
318 oldObj->SetSizeForwarded(oldSize);
319 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
320 RefField<true> oldField(oldObj);
321 MAddress oldAddress = oldField.GetFieldValue();
322
323 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
324 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
325 constexpr size_t newSize = 200;
326 newObj->SetSizeForwarded(newSize);
327 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
328 RefField<true> newField(newObj);
329 MAddress neWAddress = newField.GetFieldValue();
330 EXPECT_NE(oldAddress, neWAddress);
331
332 enumBarrier->AtomicWriteRefField(nullptr, oldField, newObj, std::memory_order_relaxed);
333 EXPECT_EQ(oldField.GetFieldValue(), neWAddress);
334 }
335
HWTEST_F_L0(EnumBarrierTest,AtomicSwapRefField_TEST1)336 HWTEST_F_L0(EnumBarrierTest, AtomicSwapRefField_TEST1)
337 {
338 MockCollector collector;
339 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
340 ASSERT_TRUE(enumBarrier != nullptr);
341
342 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
343 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
344 constexpr size_t oldSize = 100;
345 oldObj->SetSizeForwarded(oldSize);
346 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
347 RefField<true> oldField(oldObj);
348 MAddress oldAddress = oldField.GetFieldValue();
349
350 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
351 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
352 constexpr size_t newSize = 200;
353 newObj->SetSizeForwarded(newSize);
354 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
355 RefField<true> newField(newObj);
356 MAddress neWAddress = newField.GetFieldValue();
357 EXPECT_NE(oldAddress, neWAddress);
358
359 BaseObject* resultObj = nullptr;
360 resultObj = enumBarrier->AtomicSwapRefField(oldObj, oldField, newObj, std::memory_order_relaxed);
361 ASSERT_TRUE(resultObj != nullptr);
362 EXPECT_EQ(oldField.GetFieldValue(), newField.GetFieldValue());
363 }
364
HWTEST_F_L0(EnumBarrierTest,CompareAndSwapRefField_TEST1)365 HWTEST_F_L0(EnumBarrierTest, CompareAndSwapRefField_TEST1)
366 {
367 MockCollector collector;
368 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
369 ASSERT_TRUE(enumBarrier != nullptr);
370
371 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
372 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
373 constexpr size_t oldSize = 100;
374 oldObj->SetSizeForwarded(oldSize);
375 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
376 RefField<true> oldField(oldObj);
377 MAddress oldAddress = oldField.GetFieldValue();
378 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
379 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
380 constexpr size_t newSize = 200;
381 newObj->SetSizeForwarded(newSize);
382 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
383 RefField<true> newField(newObj);
384 MAddress neWAddress = newField.GetFieldValue();
385 EXPECT_NE(oldAddress, neWAddress);
386 bool result = enumBarrier->CompareAndSwapRefField(oldObj, oldField, oldObj, newObj,
387 std::memory_order_seq_cst, std::memory_order_seq_cst);
388 ASSERT_TRUE(result);
389 }
390
HWTEST_F_L0(EnumBarrierTest,CompareAndSwapRefField_TEST2)391 HWTEST_F_L0(EnumBarrierTest, CompareAndSwapRefField_TEST2)
392 {
393 MockCollector collector;
394 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
395 ASSERT_TRUE(enumBarrier != nullptr);
396
397 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
398 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
399 constexpr size_t oldSize = 100;
400 oldObj->SetSizeForwarded(oldSize);
401 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
402 RefField<true> oldField(oldObj);
403
404 bool result = enumBarrier->CompareAndSwapRefField(oldObj, oldField, oldObj, oldObj,
405 std::memory_order_seq_cst, std::memory_order_seq_cst);
406 ASSERT_TRUE(result);
407 }
408
HWTEST_F_L0(EnumBarrierTest,CompareAndSwapRefField_TEST3)409 HWTEST_F_L0(EnumBarrierTest, CompareAndSwapRefField_TEST3)
410 {
411 MockCollector collector;
412 auto enumBarrier = std::make_unique<EnumBarrier>(collector);
413 ASSERT_TRUE(enumBarrier != nullptr);
414
415 HeapAddress oldAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
416 BaseObject* oldObj = reinterpret_cast<BaseObject*>(oldAddr);
417 constexpr size_t oldSize = 100;
418 oldObj->SetSizeForwarded(oldSize);
419 EXPECT_EQ(oldObj->GetSizeForwarded(), oldSize);
420 RefField<true> oldField(oldObj);
421 MAddress oldAddress = oldField.GetFieldValue();
422
423 HeapAddress newAddr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
424 BaseObject* newObj = reinterpret_cast<BaseObject*>(newAddr);
425 constexpr size_t newSize = 200;
426 newObj->SetSizeForwarded(newSize);
427 EXPECT_EQ(newObj->GetSizeForwarded(), newSize);
428 RefField<true> newField(newObj);
429 MAddress neWAddress = newField.GetFieldValue();
430 EXPECT_NE(oldAddress, neWAddress);
431
432 bool result = enumBarrier->CompareAndSwapRefField(oldObj, newField, oldObj, newObj,
433 std::memory_order_seq_cst, std::memory_order_seq_cst);
434 ASSERT_FALSE(result);
435 }
436
437 } // namespace common::test
438