diff --git a/common_components/heap/allocator/tests/region_manager_test.cpp b/common_components/heap/allocator/tests/region_manager_test.cpp
index 4e1b6c4af38c14522724b6cfa462e33f70fabe93..b075ac4333e06019d1e7aa8c2e80e277a4744f55 100755
--- a/common_components/heap/allocator/tests/region_manager_test.cpp
+++ b/common_components/heap/allocator/tests/region_manager_test.cpp
@@ -14,13 +14,13 @@
  */
 
 #include "common_components/heap/allocator/region_manager.h"
+#include "common_components/heap/allocator/region_manager.cpp"
 #include "common_components/heap/collector/trace_collector.h"
 #include "common_components/heap/heap.cpp"
 #include "common_components/base_runtime/base_runtime_param.h"
 #include "common_components/heap/heap_manager.h"
 #include "common_components/tests/test_helper.h"
 #include <cstdint>
-#include <gtest/gtest.h>
 
 using namespace common;
 
@@ -33,13 +33,57 @@ const uint32_t NUM_TWO = 2;
 const uint32_t NUM_THREE = 3;
 const uint32_t NUM_FIVE = 5;
 
+class SimpleObjectOperator : public BaseObjectOperatorInterfaces {
+public:
+    mutable bool isForEachRefFieldCalled = false;
+    void Reset()
+    {
+        isForEachRefFieldCalled = false;
+    }
+
+    size_t GetSize(const BaseObject *object) const override
+    {
+        return 0;
+    }
+
+    bool IsValidObject(const BaseObject *object) const override
+    {
+        return false;
+    }
+
+    void ForEachRefField(const BaseObject *object, const RefFieldVisitor &visitor) const override
+    {
+        isForEachRefFieldCalled = true;
+    }
+
+    BaseObject *GetForwardingPointer(const BaseObject *object) const override
+    {
+        return nullptr;
+    }
+
+    void SetForwardingPointerAfterExclusive(BaseObject *object, BaseObject *fwdPtr) override
+    {
+        return;
+    }
+};
+
 class RegionManagerTest : public common::test::BaseTestWithScope {
 protected:
     void* regionMemory_;
     size_t totalUnits_ = SIZE_MAX_TEST;
     size_t heapSize_;
     Mutator* mutator_ = nullptr;
-    bool isInit_ = false;
+
+    static void SetUpTestCase()
+    {
+        BaseRuntime::GetInstance()->Init();
+    }
+
+    static void TearDownTestCase()
+    {
+        BaseRuntime::GetInstance()->Fini();
+    }
+
     void SetUp() override
     {
         heapSize_ = totalUnits_ * RegionDesc::UNIT_SIZE;
@@ -58,15 +102,14 @@ protected:
 
     void TearDown() override
     {
-        if (isInit_) {
-            BaseRuntime::GetInstance()->Fini();
+        if (mutator_) {
+            delete mutator_;
+            mutator_ = nullptr;
+        }
+        if (regionMemory_) {
+            free(regionMemory_);
+            regionMemory_ = nullptr;
         }
-    }
-
-    void InitializeBaseRuntime()
-    {
-        BaseRuntime::GetInstance()->Init();
-        isInit_ = true;
     }
 };
 
@@ -284,7 +327,6 @@ HWTEST_F_L0(RegionManagerTest, TakeRegion1)
 {
     ASSERT_NE(mutator_, nullptr);
     mutator_->SetMutatorPhase(GCPhase::GC_PHASE_ENUM);
-    InitializeBaseRuntime();
     RegionManager manager;
     size_t nUnit = 1;
     manager.Initialize(SIZE_MAX_TEST, reinterpret_cast<uintptr_t>(regionMemory_));
@@ -294,4 +336,174 @@ HWTEST_F_L0(RegionManagerTest, TakeRegion1)
     RegionDesc* region = manager.TakeRegion(16, RegionDesc::UnitRole::SMALL_SIZED_UNITS, false, false);
     EXPECT_GT(manager.GetDirtyUnitCount(), 0);
 }
+
+HWTEST_F_L0(RegionManagerTest, VisitRememberSet)
+{
+    bool callbackCalled = false;
+    std::function<void(BaseObject*)> func = [&callbackCalled](BaseObject* obj) {
+        callbackCalled = true;
+    };
+    size_t unitIdx = 0;
+    size_t nUnit = 1;
+    RegionDesc* region = RegionDesc::InitRegion(unitIdx, nUnit, RegionDesc::UnitRole::SMALL_SIZED_UNITS);
+    region->AddLiveByteCount(0);
+    region->VisitRememberSet(func);
+    region->SetUnitRole(RegionDesc::UnitRole::LARGE_SIZED_UNITS);
+    region->VisitRememberSet(func);
+    EXPECT_FALSE(callbackCalled);
+
+    RegionRSet* rSet = region->GetRSet();
+    bool result = rSet->MarkCardTable(0);
+    region->VisitRememberSet(func);
+    EXPECT_FALSE(result);
+    EXPECT_TRUE(callbackCalled);
+}
+
+HWTEST_F_L0(RegionManagerTest, VisitRememberSet2)
+{
+    bool callbackCalled = false;
+    std::function<void(BaseObject*)> func = [&callbackCalled](BaseObject* obj) {
+        callbackCalled = true;
+    };
+    size_t unitIdx = 0;
+    size_t nUnit = 1;
+    RegionDesc* region = RegionDesc::InitRegion(unitIdx, nUnit, RegionDesc::UnitRole::LARGE_SIZED_UNITS);
+    region->AddLiveByteCount(0);
+    RegionManager manager;
+    manager.Initialize(SIZE_MAX_TEST, reinterpret_cast<uintptr_t>(regionMemory_));
+    manager.AddRecentPinnedRegion(region);
+    manager.VisitRememberSet(func);
+    EXPECT_FALSE(callbackCalled);
+
+    RegionRSet* rSet = region->GetRSet();
+    bool result = rSet->MarkCardTable(0);
+    manager.VisitRememberSet(func);
+    EXPECT_FALSE(result);
+    EXPECT_TRUE(callbackCalled);
+}
+
+HWTEST_F_L0(RegionManagerTest, AllocReadOnly1)
+{
+    auto* mutator = common::Mutator::GetMutator();
+    mutator->SetMutatorPhase(GCPhase::GC_PHASE_ENUM);
+    RegionManager manager;
+    manager.ClearAllGCInfo();
+    ThreadLocal::SetThreadType(ThreadType::ARK_PROCESSOR);
+    uintptr_t ret = manager.AllocReadOnly(sizeof(RegionDesc), false);
+    EXPECT_EQ(ret, 0);
+}
+
+HWTEST_F_L0(RegionManagerTest, AllocReadOnly2)
+{
+    auto* mutator = common::Mutator::GetMutator();
+    mutator->SetMutatorPhase(GCPhase::GC_PHASE_MARK);
+    RegionManager manager;
+    manager.Initialize(SIZE_MAX_TEST, reinterpret_cast<uintptr_t>(regionMemory_));
+    manager.ClearAllGCInfo();
+    ThreadLocal::SetThreadType(ThreadType::ARK_PROCESSOR);
+    uintptr_t ret = manager.AllocReadOnly(sizeof(RegionDesc), false);
+    RegionDesc* region = RegionDesc::GetRegionDescAt(ret);
+    EXPECT_NE(ret, 0);
+    EXPECT_EQ(region->GetTraceLine(), region->GetRegionStart());
+    EXPECT_EQ(region->GetCopyLine(), std::numeric_limits<uintptr_t>::max());
+    EXPECT_EQ(region->GetFixLine(), std::numeric_limits<uintptr_t>::max());
+}
+
+HWTEST_F_L0(RegionManagerTest, AllocReadOnly3)
+{
+    auto* mutator = common::Mutator::GetMutator();
+    mutator->SetMutatorPhase(GCPhase::GC_PHASE_POST_MARK);
+    RegionManager manager;
+    manager.Initialize(SIZE_MAX_TEST, reinterpret_cast<uintptr_t>(regionMemory_));
+    manager.ClearAllGCInfo();
+    ThreadLocal::SetThreadType(ThreadType::ARK_PROCESSOR);
+    uintptr_t ret = manager.AllocReadOnly(sizeof(RegionDesc), false);
+    RegionDesc* region = RegionDesc::GetRegionDescAt(ret);
+    EXPECT_NE(ret, 0);
+    EXPECT_EQ(region->GetTraceLine(), region->GetRegionStart());
+    EXPECT_EQ(region->GetCopyLine(), std::numeric_limits<uintptr_t>::max());
+    EXPECT_EQ(region->GetFixLine(), std::numeric_limits<uintptr_t>::max());
+}
+
+HWTEST_F_L0(RegionManagerTest, AllocReadOnly4)
+{
+    auto* mutator = common::Mutator::GetMutator();
+    mutator->SetMutatorPhase(GCPhase::GC_PHASE_PRECOPY);
+    RegionManager manager;
+    manager.Initialize(SIZE_MAX_TEST, reinterpret_cast<uintptr_t>(regionMemory_));
+    manager.ClearAllGCInfo();
+    ThreadLocal::SetThreadType(ThreadType::ARK_PROCESSOR);
+    uintptr_t ret = manager.AllocReadOnly(sizeof(RegionDesc), false);
+    RegionDesc* region = RegionDesc::GetRegionDescAt(ret);
+    EXPECT_NE(ret, 0);
+    EXPECT_EQ(region->GetTraceLine(), std::numeric_limits<uintptr_t>::max());
+    EXPECT_EQ(region->GetCopyLine(), region->GetRegionStart());
+    EXPECT_EQ(region->GetFixLine(), std::numeric_limits<uintptr_t>::max());
+}
+
+HWTEST_F_L0(RegionManagerTest, AllocReadOnly5)
+{
+    auto* mutator = common::Mutator::GetMutator();
+    mutator->SetMutatorPhase(GCPhase::GC_PHASE_COPY);
+    RegionManager manager;
+    manager.Initialize(SIZE_MAX_TEST, reinterpret_cast<uintptr_t>(regionMemory_));
+    manager.ClearAllGCInfo();
+    ThreadLocal::SetThreadType(ThreadType::ARK_PROCESSOR);
+    uintptr_t ret = manager.AllocReadOnly(sizeof(RegionDesc), false);
+    RegionDesc* region = RegionDesc::GetRegionDescAt(ret);
+    EXPECT_NE(ret, 0);
+    EXPECT_EQ(region->GetTraceLine(), std::numeric_limits<uintptr_t>::max());
+    EXPECT_EQ(region->GetCopyLine(), region->GetRegionStart());
+    EXPECT_EQ(region->GetFixLine(), std::numeric_limits<uintptr_t>::max());
+}
+
+HWTEST_F_L0(RegionManagerTest, AllocReadOnly6)
+{
+    auto* mutator = common::Mutator::GetMutator();
+    mutator->SetMutatorPhase(GCPhase::GC_PHASE_FIX);
+    RegionManager manager;
+    manager.Initialize(SIZE_MAX_TEST, reinterpret_cast<uintptr_t>(regionMemory_));
+    manager.ClearAllGCInfo();
+    ThreadLocal::SetThreadType(ThreadType::ARK_PROCESSOR);
+    uintptr_t ret = manager.AllocReadOnly(sizeof(RegionDesc), false);
+    RegionDesc* region = RegionDesc::GetRegionDescAt(ret);
+    EXPECT_NE(ret, 0);
+    EXPECT_EQ(region->GetTraceLine(), std::numeric_limits<uintptr_t>::max());
+    EXPECT_EQ(region->GetCopyLine(), region->GetRegionStart());
+    EXPECT_EQ(region->GetFixLine(), region->GetRegionStart());
+}
+
+HWTEST_F_L0(RegionManagerTest, AllocReadOnly7)
+{
+    auto* mutator = common::Mutator::GetMutator();
+    mutator->SetMutatorPhase(GCPhase::GC_PHASE_UNDEF);
+    RegionManager manager;
+    manager.Initialize(SIZE_MAX_TEST, reinterpret_cast<uintptr_t>(regionMemory_));
+    manager.ClearAllGCInfo();
+    ThreadLocal::SetThreadType(ThreadType::ARK_PROCESSOR);
+    uintptr_t ret = manager.AllocReadOnly(sizeof(RegionDesc), false);
+    RegionDesc* region = RegionDesc::GetRegionDescAt(ret);
+    EXPECT_NE(ret, 0);
+    EXPECT_EQ(region->GetTraceLine(), std::numeric_limits<uintptr_t>::max());
+    EXPECT_EQ(region->GetCopyLine(), std::numeric_limits<uintptr_t>::max());
+    EXPECT_EQ(region->GetFixLine(), std::numeric_limits<uintptr_t>::max());
+}
+
+HWTEST_F_L0(RegionManagerTest, FixOldRegion2)
+{
+    TraceCollector& collector = reinterpret_cast<TraceCollector&>(Heap::GetHeap().GetCollector());
+    size_t unitIdx = 0;
+    size_t nUnit = 1;
+    RegionDesc* region = RegionDesc::InitRegion(unitIdx, nUnit, RegionDesc::UnitRole::LARGE_SIZED_UNITS);
+    SimpleObjectOperator myOperator;
+    region->SetTraceLine();
+    region->SetRegionAllocPtr(region->GetTraceLine()-1);
+    region->SetTraceLine();
+    region->VisitAllObjects([&](BaseObject* object) {
+         object->RegisterStatic(&myOperator);
+         object->SetLanguageType(LanguageType::STATIC);
+    });
+    FixOldRegion(collector, region);
+    EXPECT_TRUE(myOperator.isForEachRefFieldCalled);
+}
 }