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/tests/test_helper.h"
17
18 #include "common_components/heap/ark_collector/ark_collector.h"
19 #include "common_components/heap/ark_collector/ark_collector.cpp"
20 #include "common_components/heap/collector/collector_proxy.h"
21 #include "common_components/heap/heap_manager.h"
22 #include "common_components/heap/allocator/region_desc.h"
23 #include "common_components/mutator/mutator_manager-inl.h"
24
25 using namespace common;
26
27 namespace common::test {
28 using SuspensionType = MutatorBase::SuspensionType;
29 class ArkCollectorTest : public common::test::BaseTestWithScope {
30 protected:
SetUpTestCase()31 static void SetUpTestCase()
32 {
33 BaseRuntime::GetInstance()->Init();
34 }
35
TearDownTestCase()36 static void TearDownTestCase()
37 {}
38
SetUp()39 void SetUp() override
40 {
41 MutatorManager::Instance().CreateRuntimeMutator(ThreadType::ARK_PROCESSOR);
42 }
43
TearDown()44 void TearDown() override
45 {
46 MutatorManager::Instance().DestroyRuntimeMutator(ThreadType::ARK_PROCESSOR);
47 }
48 };
49
GetArkCollector()50 std::unique_ptr<ArkCollector> GetArkCollector()
51 {
52 CollectorResources &resources = Heap::GetHeap().GetCollectorResources();
53 Allocator &allocator = Heap::GetHeap().GetAllocator();
54
55 return std::make_unique<ArkCollector>(allocator, resources);
56 }
57
HWTEST_F_L0(ArkCollectorTest,IsUnmovableFromObjectTest0)58 HWTEST_F_L0(ArkCollectorTest, IsUnmovableFromObjectTest0)
59 {
60 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
61 ASSERT_TRUE(arkCollector != nullptr);
62
63 BaseObject *obj = nullptr;
64 EXPECT_FALSE(arkCollector->IsUnmovableFromObject(obj));
65 }
66
HWTEST_F_L0(ArkCollectorTest,IsUnmovableFromObjectTest1)67 HWTEST_F_L0(ArkCollectorTest, IsUnmovableFromObjectTest1)
68 {
69 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
70 ASSERT_TRUE(arkCollector != nullptr);
71
72 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
73 BaseObject *obj = reinterpret_cast<BaseObject *>(addr);
74
75 new (obj) BaseObject();
76
77 EXPECT_FALSE(arkCollector->IsUnmovableFromObject(obj));
78 }
79
HWTEST_F_L0(ArkCollectorTest,IsUnmovableFromObjectTest2)80 HWTEST_F_L0(ArkCollectorTest, IsUnmovableFromObjectTest2)
81 {
82 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
83 ASSERT_TRUE(arkCollector != nullptr);
84
85 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::PINNED_OBJECT, true);
86 BaseObject *obj = reinterpret_cast<BaseObject *>(addr);
87
88 new (obj) BaseObject();
89
90 RegionDesc *region = RegionDesc::GetAliveRegionDescAt(addr);
91
92 bool isMarked = region->GetOrAllocResurrectBitmap()->MarkBits(0);
93 region->SetResurrectedRegionFlag(1);
94 region->SetRegionType(RegionDesc::RegionType::EXEMPTED_FROM_REGION);
95
96 EXPECT_FALSE(isMarked);
97
98 EXPECT_TRUE(arkCollector->IsUnmovableFromObject(obj));
99 }
100
HWTEST_F_L0(ArkCollectorTest,ForwardUpdateRawRefTest0)101 HWTEST_F_L0(ArkCollectorTest, ForwardUpdateRawRefTest0)
102 {
103 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
104 ASSERT_TRUE(arkCollector != nullptr);
105
106 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
107 BaseObject *obj = reinterpret_cast<BaseObject *>(addr);
108
109 new (obj) BaseObject();
110
111 common::ObjectRef root = {obj};
112
113 BaseObject *oldObj = arkCollector->ForwardUpdateRawRef(root);
114 EXPECT_EQ(oldObj, obj);
115 }
116
FlipTest()117 void FlipTest()
118 {
119 MutatorManager &mutatorManager = MutatorManager::Instance();
120 ThreadHolder::CreateAndRegisterNewThreadHolder(nullptr);
121 bool stwCallbackExecuted = false;
122 auto stwTest = [&mutatorManager, &stwCallbackExecuted]() {
123 EXPECT_TRUE(mutatorManager.WorldStopped());
124 stwCallbackExecuted = true;
125 };
126 FlipFunction mutatorTest = [&mutatorManager, &stwCallbackExecuted](Mutator &mutator) {
127 EXPECT_TRUE(mutator.HasSuspensionRequest(SuspensionType::SUSPENSION_FOR_RUNNING_CALLBACK));
128 EXPECT_FALSE(mutatorManager.WorldStopped());
129 EXPECT_TRUE(stwCallbackExecuted);
130 };
131 STWParam param;
132 param.stwReason = "flip-test";
133 mutatorManager.FlipMutators(param, stwTest, &mutatorTest);
134 }
135
HWTEST_F_L0(ArkCollectorTest,FlipTest)136 HWTEST_F_L0(ArkCollectorTest, FlipTest)
137 {
138 std::thread t1(FlipTest);
139 t1.join();
140 }
141
HWTEST_F_L0(ArkCollectorTest,IsUnmovableFromObject_ReturnsFalseForNullptr)142 HWTEST_F_L0(ArkCollectorTest, IsUnmovableFromObject_ReturnsFalseForNullptr)
143 {
144 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
145 ASSERT_TRUE(arkCollector != nullptr);
146
147 BaseObject* obj = nullptr;
148 EXPECT_FALSE(arkCollector->IsUnmovableFromObject(obj));
149 }
150
151 class TestableArkCollector : public ArkCollector {
152 public:
153 using ArkCollector::ForwardObject;
154
TestableArkCollector(Allocator & allocator,CollectorResources & resources)155 explicit TestableArkCollector(Allocator& allocator, CollectorResources& resources)
156 : ArkCollector(allocator, resources), currentGCPhase_(GCPhase::GC_PHASE_COPY) {}
157
SetCurrentGCPhaseForTest(GCPhase phase)158 void SetCurrentGCPhaseForTest(GCPhase phase)
159 {
160 currentGCPhase_ = phase;
161 }
162
GetCurrentGCPhaseForTest() const163 GCPhase GetCurrentGCPhaseForTest() const
164 {
165 return currentGCPhase_;
166 }
167
168 private:
169 GCPhase currentGCPhase_;
170 };
171
172
173 class DummyObject : public BaseObject {
174 public:
GetTypeInfo() const175 const common::TypeInfo* GetTypeInfo() const { return nullptr; }
GetSize() const176 size_t GetSize() const { return sizeof(DummyObject); }
177
SetClass(uintptr_t cls)178 void SetClass(uintptr_t cls)
179 {
180 stateWord_.StoreStateWord(static_cast<StateWordType>(cls));
181 }
182
183 private:
184 class BaseStateWord {
185 public:
186 using StateWordType = uint64_t;
187
StoreStateWord(StateWordType word)188 void StoreStateWord(StateWordType word)
189 {
190 stateWord_ = word;
191 }
192
LoadStateWord() const193 StateWordType LoadStateWord() const
194 {
195 return stateWord_;
196 }
197
198 private:
199 StateWordType stateWord_{0};
200 };
201
202 BaseStateWord stateWord_;
203 };
204
HWTEST_F_L0(ArkCollectorTest,ForwardObject_WithUnmovedObject_ReturnsSameAddress)205 HWTEST_F_L0(ArkCollectorTest, ForwardObject_WithUnmovedObject_ReturnsSameAddress)
206 {
207 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
208 ASSERT_TRUE(arkCollector != nullptr);
209
210 TestableArkCollector* testableCollector = reinterpret_cast<TestableArkCollector*>(arkCollector.get());
211
212 testableCollector->SetCurrentGCPhaseForTest(GCPhase::GC_PHASE_COPY);
213 EXPECT_EQ(testableCollector->GetCurrentGCPhaseForTest(), GCPhase::GC_PHASE_COPY);
214 }
215
HWTEST_F_L0(ArkCollectorTest,MarkingRefField_TEST1)216 HWTEST_F_L0(ArkCollectorTest, MarkingRefField_TEST1)
217 {
218 constexpr uint64_t TAG_BITS_SHIFT = 48;
219 constexpr uint64_t TAG_MARK = 0xFFFFULL << TAG_BITS_SHIFT;
220 constexpr uint64_t TAG_SPECIAL = 0x02ULL;
221 constexpr uint64_t TAG_BOOLEAN = 0x04ULL;
222 constexpr uint64_t TAG_HEAP_OBJECT_MASK = TAG_MARK | TAG_SPECIAL | TAG_BOOLEAN;
223 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
224 BaseObject *obj = reinterpret_cast<BaseObject *>(addr | TAG_HEAP_OBJECT_MASK);
225 RefField<> field(obj);
226
227 MarkStack<BaseObject*> workStack;
228 WeakStack weakStack;
229 MarkingRefField(nullptr, field, workStack, weakStack, GCReason::GC_REASON_YOUNG);
230 EXPECT_FALSE(Heap::IsTaggedObject(field.GetFieldValue()));
231 }
232
HWTEST_F_L0(ArkCollectorTest,MarkingRefField_TEST2)233 HWTEST_F_L0(ArkCollectorTest, MarkingRefField_TEST2)
234 {
235 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
236 RegionDesc* region = RegionDesc::GetRegionDescAt(addr);
237 region->SetRegionType(RegionDesc::RegionType::ALIVE_REGION_FIRST);
238 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
239 RefField<false> field(obj);
240
241 MarkStack<BaseObject*> workStack;
242 WeakStack weakStack;
243 MarkingRefField(nullptr, field, workStack, weakStack, GCReason::GC_REASON_APPSPAWN);
244 EXPECT_FALSE(region->IsInOldSpace());
245 workStack.pop_back();
246 }
247
HWTEST_F_L0(ArkCollectorTest,MarkingRefField_TEST3)248 HWTEST_F_L0(ArkCollectorTest, MarkingRefField_TEST3)
249 {
250 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
251 RegionDesc* region = RegionDesc::GetRegionDescAt(addr);
252 region->SetRegionType(RegionDesc::RegionType::OLD_REGION);
253 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
254 RefField<false> field(obj);
255
256 MarkStack<BaseObject*> workStack;
257 WeakStack weakStack;
258 MarkingRefField(nullptr, field, workStack, weakStack, GCReason::GC_REASON_APPSPAWN);
259 EXPECT_TRUE(region->IsInOldSpace());
260 workStack.pop_back();
261 }
262
HWTEST_F_L0(ArkCollectorTest,MarkingRefField_TEST4)263 HWTEST_F_L0(ArkCollectorTest, MarkingRefField_TEST4)
264 {
265 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
266 RegionDesc* region = RegionDesc::GetRegionDescAt(addr);
267 region->SetRegionType(RegionDesc::RegionType::ALIVE_REGION_FIRST);
268 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
269 RefField<false> field(obj);
270
271 MarkStack<BaseObject*> workStack;
272 WeakStack weakStack;
273 MarkingRefField(nullptr, field, workStack, weakStack, GCReason::GC_REASON_YOUNG);
274 EXPECT_FALSE(region->IsInOldSpace());
275 workStack.pop_back();
276 }
277
HWTEST_F_L0(ArkCollectorTest,MarkingRefField_TEST5)278 HWTEST_F_L0(ArkCollectorTest, MarkingRefField_TEST5)
279 {
280 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
281 RegionDesc* region = RegionDesc::GetRegionDescAt(addr);
282 region->SetRegionType(RegionDesc::RegionType::OLD_REGION);
283 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
284 RefField<false> field(obj);
285
286 MarkStack<BaseObject*> workStack;
287 WeakStack weakStack;
288 MarkingRefField(nullptr, field, workStack, weakStack, GCReason::GC_REASON_YOUNG);
289 EXPECT_TRUE(region->IsInOldSpace());
290 }
291
HWTEST_F_L0(ArkCollectorTest,MarkingRefField_TEST6)292 HWTEST_F_L0(ArkCollectorTest, MarkingRefField_TEST6)
293 {
294 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
295 RegionDesc* region = RegionDesc::GetRegionDescAt(addr);
296 region->SetRegionAllocPtr(addr - 1);
297 region->SetMarkingLine();
298 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
299 RefField<false> field(obj);
300
301 MarkStack<BaseObject*> workStack;
302 MarkingRefField(obj, obj, field, workStack, region);
303 EXPECT_TRUE(region->IsNewObjectSinceMarking(obj));
304 }
305 class TestCreateMarkingArkCollector : public MarkingCollector {
306 public:
307 using MarkingCollector::SetGCReason;
TestCreateMarkingArkCollector(Allocator & allocator,CollectorResources & resources)308 explicit TestCreateMarkingArkCollector(Allocator& allocator, CollectorResources& resources)
309 : MarkingCollector(allocator, resources) {}
ForwardObject(BaseObject *)310 BaseObject* ForwardObject(BaseObject*) override { return nullptr; }
IsFromObject(BaseObject *) const311 bool IsFromObject(BaseObject*) const override { return false; }
IsUnmovableFromObject(BaseObject *) const312 bool IsUnmovableFromObject(BaseObject*) const override { return false; }
FindToVersion(BaseObject * obj) const313 BaseObject* FindToVersion(BaseObject* obj) const override { return nullptr; }
TryUpdateRefField(BaseObject *,RefField<> &,BaseObject * &) const314 bool TryUpdateRefField(BaseObject*, RefField<>&, BaseObject*&) const override { return false; }
TryForwardRefField(BaseObject *,RefField<> &,BaseObject * &) const315 bool TryForwardRefField(BaseObject*, RefField<>&, BaseObject*&) const override { return false; }
TryUntagRefField(BaseObject *,RefField<> &,BaseObject * &) const316 bool TryUntagRefField(BaseObject*, RefField<>&, BaseObject*&) const override { return false; }
GetAndTryTagRefField(BaseObject *) const317 RefField<> GetAndTryTagRefField(BaseObject*) const override { return RefField<>(nullptr); }
IsOldPointer(RefField<> &) const318 bool IsOldPointer(RefField<>&) const override { return false; }
AddRawPointerObject(BaseObject *)319 void AddRawPointerObject(BaseObject*) override {}
RemoveRawPointerObject(BaseObject *)320 void RemoveRawPointerObject(BaseObject*) override {}
MarkObject(BaseObject * obj) const321 bool MarkObject(BaseObject* obj) const override { return false; }
MarkingObjectRefFields(BaseObject * obj,MarkingRefFieldVisitor * data)322 void MarkingObjectRefFields(BaseObject *obj, MarkingRefFieldVisitor *data) override {}
CopyObjectAfterExclusive(BaseObject * obj)323 BaseObject* CopyObjectAfterExclusive(BaseObject* obj) override { return nullptr; }
DoGarbageCollection()324 void DoGarbageCollection() override {}
IsCurrentPointer(RefField<> &) const325 bool IsCurrentPointer(RefField<>&) const override { return false; }
CreateMarkingObjectRefFieldsVisitor(WorkStack * workStack,WeakStack * weakStack)326 MarkingRefFieldVisitor CreateMarkingObjectRefFieldsVisitor(WorkStack *workStack, WeakStack *weakStack) override
327 {
328 return MarkingRefFieldVisitor();
329 }
330 };
331
HWTEST_F_L0(ArkCollectorTest,CreateMarkingObjectRefFieldsVisitor_TEST1)332 HWTEST_F_L0(ArkCollectorTest, CreateMarkingObjectRefFieldsVisitor_TEST1)
333 {
334 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
335 ASSERT_TRUE(arkCollector != nullptr);
336
337 MarkStack<BaseObject*> workStack;
338 WeakStack weakStack;
339 TestCreateMarkingArkCollector* collector = reinterpret_cast<TestCreateMarkingArkCollector*>(arkCollector.get());
340 collector->SetGCReason(GCReason::GC_REASON_YOUNG);
341 auto visitor = arkCollector->CreateMarkingObjectRefFieldsVisitor(&workStack, &weakStack);
342 EXPECT_TRUE(visitor.GetRefFieldVisitor() != nullptr);
343 }
344
HWTEST_F_L0(ArkCollectorTest,FixRefField_TEST1)345 HWTEST_F_L0(ArkCollectorTest, FixRefField_TEST1)
346 {
347 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
348 ASSERT_TRUE(arkCollector != nullptr);
349
350 constexpr uint64_t TAG_BITS_SHIFT = 48;
351 constexpr uint64_t TAG_MARK = 0xFFFFULL << TAG_BITS_SHIFT;
352 constexpr uint64_t TAG_SPECIAL = 0x02ULL;
353 constexpr uint64_t TAG_BOOLEAN = 0x04ULL;
354 constexpr uint64_t TAG_HEAP_OBJECT_MASK = TAG_MARK | TAG_SPECIAL | TAG_BOOLEAN;
355 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
356 BaseObject *obj = reinterpret_cast<BaseObject *>(addr | TAG_HEAP_OBJECT_MASK);
357 RefField<> field(obj);
358 arkCollector->FixRefField(obj, field);
359 EXPECT_FALSE(Heap::IsTaggedObject(field.GetFieldValue()));
360 }
361
HWTEST_F_L0(ArkCollectorTest,FixRefField_TEST2)362 HWTEST_F_L0(ArkCollectorTest, FixRefField_TEST2)
363 {
364 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
365 ASSERT_TRUE(arkCollector != nullptr);
366
367 BaseObject* obj = reinterpret_cast<BaseObject*>(0);
368 RefField<> field(obj);
369 arkCollector->FixRefField(obj, field);
370 EXPECT_FALSE(Heap::IsHeapAddress(obj));
371 }
372
373 class TestStaticObject : public BaseObjectOperatorInterfaces {
374 public:
GetSize(const BaseObject * object) const375 size_t GetSize(const BaseObject *object) const override { return 0; }
IsValidObject(const BaseObject * object) const376 bool IsValidObject(const BaseObject *object) const override { return false; }
ForEachRefField(const BaseObject * object,const RefFieldVisitor & visitor) const377 void ForEachRefField(const BaseObject *object, const RefFieldVisitor &visitor) const override {}
SetForwardingPointerAfterExclusive(BaseObject * object,BaseObject * fwdPtr)378 void SetForwardingPointerAfterExclusive(BaseObject *object, BaseObject *fwdPtr) override {}
GetForwardingPointer(const BaseObject * object) const379 BaseObject *GetForwardingPointer(const BaseObject *object) const override
380 {
381 return const_cast<BaseObject*>(object);
382 }
383 };
384
HWTEST_F_L0(ArkCollectorTest,ForwardUpdateRawRef_TEST1)385 HWTEST_F_L0(ArkCollectorTest, ForwardUpdateRawRef_TEST1)
386 {
387 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
388 ASSERT_TRUE(arkCollector != nullptr);
389
390 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
391 RegionDesc* region = RegionDesc::GetRegionDescAt(addr);
392 region->SetRegionType(RegionDesc::RegionType::FROM_REGION);
393 Mutator::GetMutator()->SetMutatorPhase(GCPhase::GC_PHASE_PRECOPY);
394 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
395 EXPECT_FALSE(obj->IsForwarded());
396 obj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
397 obj->SetLanguageType(LanguageType::STATIC);
398 EXPECT_TRUE(obj->IsForwarded());
399 TestStaticObject staticObject;
400 obj->RegisterStatic(&staticObject);
401
402 alignas(RefField<>) char rootBuffer[sizeof(RefField<>)] = {0};
403 ObjectRef& root = *new (rootBuffer) ObjectRef();
404 root.object = obj;
405 auto ret = arkCollector->ForwardUpdateRawRef(root);
406 EXPECT_TRUE(arkCollector->IsFromObject(obj));
407 EXPECT_EQ(ret, obj);
408 }
409
410 class TestForwardNullObject : public TestStaticObject {
411 public:
GetForwardingPointer(const BaseObject * object) const412 BaseObject *GetForwardingPointer(const BaseObject *object) const override { return nullptr; }
413 };
414
HWTEST_F_L0(ArkCollectorTest,ForwardObject_TEST1)415 HWTEST_F_L0(ArkCollectorTest, ForwardObject_TEST1)
416 {
417 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
418 ASSERT_TRUE(arkCollector != nullptr);
419
420 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
421 RegionDesc* region = RegionDesc::GetRegionDescAt(addr);
422 region->SetRegionType(RegionDesc::RegionType::FROM_REGION);
423 Mutator::GetMutator()->SetMutatorPhase(GCPhase::GC_PHASE_PRECOPY);
424 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
425 EXPECT_FALSE(obj->IsForwarded());
426 obj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
427 obj->SetLanguageType(LanguageType::STATIC);
428 EXPECT_TRUE(obj->IsForwarded());
429 TestForwardNullObject staticObject;
430 obj->RegisterStatic(&staticObject);
431
432 auto ret = arkCollector->ForwardObject(obj);
433 EXPECT_EQ(ret, obj);
434 }
435
HWTEST_F_L0(ArkCollectorTest,CopyObjectImpl_TEST1)436 HWTEST_F_L0(ArkCollectorTest, CopyObjectImpl_TEST1)
437 {
438 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
439 ASSERT_TRUE(arkCollector != nullptr);
440
441 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
442 RegionDesc* region = RegionDesc::GetRegionDescAt(addr);
443 region->SetRegionType(RegionDesc::RegionType::FROM_REGION);
444 Mutator::GetMutator()->SetMutatorPhase(GCPhase::GC_PHASE_PRECOPY);
445 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
446 EXPECT_FALSE(obj->IsForwarded());
447 obj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
448 obj->SetLanguageType(LanguageType::STATIC);
449 EXPECT_TRUE(obj->IsForwarded());
450 TestForwardNullObject staticObject;
451 obj->RegisterStatic(&staticObject);
452
453 auto ret = arkCollector->CopyObjectImpl(obj);
454 EXPECT_TRUE(ret == nullptr);
455 }
456
HWTEST_F_L0(ArkCollectorTest,TryUpdateRefFieldImpl_TEST1)457 HWTEST_F_L0(ArkCollectorTest, TryUpdateRefFieldImpl_TEST1)
458 {
459 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
460 ASSERT_TRUE(arkCollector != nullptr);
461
462 RefField<> field(nullptr);
463 BaseObject* obj = nullptr;
464 bool ret = arkCollector->TryUpdateRefField(nullptr, field, obj);
465 EXPECT_FALSE(ret);
466 }
467
HWTEST_F_L0(ArkCollectorTest,TryUpdateRefFieldImpl_TEST2)468 HWTEST_F_L0(ArkCollectorTest, TryUpdateRefFieldImpl_TEST2)
469 {
470 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
471 ASSERT_TRUE(arkCollector != nullptr);
472
473 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
474 RegionDesc* region = RegionDesc::GetRegionDescAt(addr);
475 region->SetRegionType(RegionDesc::RegionType::FROM_REGION);
476 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
477 RefField<false> field(obj);
478 bool ret = arkCollector->TryUpdateRefField(nullptr, field, obj);
479 EXPECT_FALSE(ret);
480 }
481
HWTEST_F_L0(ArkCollectorTest,TryUpdateRefFieldImpl_TEST3)482 HWTEST_F_L0(ArkCollectorTest, TryUpdateRefFieldImpl_TEST3)
483 {
484 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
485 ASSERT_TRUE(arkCollector != nullptr);
486
487 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
488 RegionDesc* region = RegionDesc::GetRegionDescAt(addr);
489 region->SetRegionType(RegionDesc::RegionType::FROM_REGION);
490 Mutator::GetMutator()->SetMutatorPhase(GCPhase::GC_PHASE_PRECOPY);
491 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
492 EXPECT_FALSE(obj->IsForwarded());
493 obj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
494 obj->SetLanguageType(LanguageType::STATIC);
495 EXPECT_TRUE(obj->IsForwarded());
496 TestForwardNullObject staticObject;
497 obj->RegisterStatic(&staticObject);
498
499 RefField<false> field(obj);
500 bool ret = arkCollector->TryForwardRefField(nullptr, field, obj);
501 EXPECT_FALSE(ret);
502 }
503
HWTEST_F_L0(ArkCollectorTest,TryUpdateRefFieldImpl_TEST4)504 HWTEST_F_L0(ArkCollectorTest, TryUpdateRefFieldImpl_TEST4)
505 {
506 std::unique_ptr<ArkCollector> arkCollector = GetArkCollector();
507 ASSERT_TRUE(arkCollector != nullptr);
508
509 HeapAddress addr = HeapManager::Allocate(sizeof(BaseObject), AllocType::MOVEABLE_OBJECT, true);
510 RegionDesc* region = RegionDesc::GetRegionDescAt(addr);
511 region->SetRegionType(RegionDesc::RegionType::FROM_REGION);
512 Mutator::GetMutator()->SetMutatorPhase(GCPhase::GC_PHASE_PRECOPY);
513 BaseObject* obj = reinterpret_cast<BaseObject*>(addr);
514 EXPECT_FALSE(obj->IsForwarded());
515 obj->SetForwardState(BaseStateWord::ForwardState::FORWARDED);
516 obj->SetLanguageType(LanguageType::STATIC);
517 EXPECT_TRUE(obj->IsForwarded());
518 TestStaticObject staticObject;
519 obj->RegisterStatic(&staticObject);
520
521 RefField<false> field(obj);
522 bool ret = arkCollector->TryForwardRefField(nullptr, field, obj);
523 EXPECT_TRUE(ret);
524 }
525 } // namespace common::test
526