diff --git a/common_components/heap/w_collector/tests/post_trace_barrier_test.cpp b/common_components/heap/w_collector/tests/post_trace_barrier_test.cpp
index d51db25d4009a8b687b06b53fbaccd958bdf7367..fe2d2bfa438881aac499ec75f1628aa554f6c41c 100755
--- a/common_components/heap/w_collector/tests/post_trace_barrier_test.cpp
+++ b/common_components/heap/w_collector/tests/post_trace_barrier_test.cpp
@@ -74,21 +74,15 @@ HWTEST_F_L0(PostTraceBarrierTest, WriteRefField_TEST1)
 {
     ASSERT_TRUE(postTraceBarrier_ != nullptr);
 
-    BaseObject oldObj;
-    constexpr size_t oldSize = 100;
-    oldObj.SetSizeForwarded(oldSize);
-    EXPECT_EQ(oldObj.GetSizeForwarded(), oldSize);
+    BaseObject oldObj, newObj;
     RefField<false> field(&oldObj);
-    MAddress oldAddress = field.GetFieldValue();
 
-    BaseObject newObj;
-    constexpr size_t newSize = 200;
-    newObj.SetSizeForwarded(newSize);
-    EXPECT_EQ(newObj.GetSizeForwarded(), newSize);
+    MAddress oldAddr = field.GetFieldValue();
     postTraceBarrier_->WriteRefField(&oldObj, field, &newObj);
-    postTraceBarrier_->WriteBarrier(&oldObj, field, &newObj);
-    MAddress newAddress = field.GetFieldValue();
-    EXPECT_NE(newAddress, oldAddress);
+    MAddress newAddr = field.GetFieldValue();
+
+    EXPECT_NE(oldAddr, newAddr);
+    EXPECT_EQ(newAddr, reinterpret_cast<MAddress>(&newObj));
 }
 
 HWTEST_F_L0(PostTraceBarrierTest, ReadStruct_TEST1)
@@ -148,14 +142,10 @@ HWTEST_F_L0(PostTraceBarrierTest, AtomicReadRefField_TEST1)
     ASSERT_TRUE(postTraceBarrier_ != nullptr);
 
     BaseObject obj;
-    constexpr size_t size = 100;
-    obj.SetSizeForwarded(size);
-    EXPECT_EQ(obj.GetSizeForwarded(), size);
     RefField<true> field(&obj);
 
-    BaseObject *resultObj = nullptr;
-    resultObj = postTraceBarrier_->AtomicReadRefField(&obj, field, std::memory_order_seq_cst);
-    ASSERT_TRUE(resultObj != nullptr);
+    BaseObject* result = postTraceBarrier_->AtomicReadRefField(&obj, field, std::memory_order_seq_cst);
+    EXPECT_EQ(result, &obj);
 }
 
 HWTEST_F_L0(PostTraceBarrierTest, AtomicWriteRefField_TEST1)
@@ -173,12 +163,11 @@ HWTEST_F_L0(PostTraceBarrierTest, AtomicWriteRefField_TEST1)
     constexpr size_t newSize = 200;
     newObj.SetSizeForwarded(newSize);
     EXPECT_EQ(newObj.GetSizeForwarded(), newSize);
-    RefField<true> newField(&newObj);
-    MAddress neWAddress = newField.GetFieldValue();
-    EXPECT_NE(oldAddress, neWAddress);
 
     postTraceBarrier_->AtomicWriteRefField(&oldObj, oldField, &newObj, std::memory_order_relaxed);
-    EXPECT_EQ(oldField.GetFieldValue(), neWAddress);
+
+    EXPECT_NE(oldField.GetFieldValue(), oldAddress);
+    EXPECT_EQ(oldField.GetFieldValue(), reinterpret_cast<MAddress>(&newObj));
 }
 
 HWTEST_F_L0(PostTraceBarrierTest, AtomicWriteRefField_TEST2)
@@ -196,37 +185,24 @@ HWTEST_F_L0(PostTraceBarrierTest, AtomicWriteRefField_TEST2)
     constexpr size_t newSize = 200;
     newObj.SetSizeForwarded(newSize);
     EXPECT_EQ(newObj.GetSizeForwarded(), newSize);
-    RefField<true> newField(&newObj);
-    MAddress neWAddress = newField.GetFieldValue();
-    EXPECT_NE(oldAddress, neWAddress);
 
     postTraceBarrier_->AtomicWriteRefField(nullptr, oldField, &newObj, std::memory_order_relaxed);
-    EXPECT_EQ(oldField.GetFieldValue(), neWAddress);
+
+    EXPECT_NE(oldField.GetFieldValue(), oldAddress);
+    EXPECT_EQ(oldField.GetFieldValue(), reinterpret_cast<MAddress>(&newObj));
 }
 
 HWTEST_F_L0(PostTraceBarrierTest, AtomicSwapRefField_TEST1)
 {
     ASSERT_TRUE(postTraceBarrier_ != nullptr);
 
-    BaseObject oldObj;
-    constexpr size_t oldSize = 100;
-    oldObj.SetSizeForwarded(oldSize);
-    EXPECT_EQ(oldObj.GetSizeForwarded(), oldSize);
-    RefField<true> oldField(&oldObj);
-    MAddress oldAddress = oldField.GetFieldValue();
+    BaseObject oldObj, newObj;
+    RefField<true> field(&oldObj);
 
-    BaseObject newObj;
-    constexpr size_t newSize = 200;
-    newObj.SetSizeForwarded(newSize);
-    EXPECT_EQ(newObj.GetSizeForwarded(), newSize);
-    RefField<true> newField(&newObj);
-    MAddress neWAddress = newField.GetFieldValue();
-    EXPECT_NE(oldAddress, neWAddress);
-
-    BaseObject *resultObj = nullptr;
-    resultObj = postTraceBarrier_->AtomicSwapRefField(&oldObj, oldField, &newObj, std::memory_order_relaxed);
-    ASSERT_TRUE(resultObj != nullptr);
-    EXPECT_EQ(oldField.GetFieldValue(), newField.GetFieldValue());
+    BaseObject* result = postTraceBarrier_->AtomicSwapRefField(
+        &oldObj, field, &newObj, std::memory_order_relaxed);
+    EXPECT_EQ(result, &oldObj);
+    EXPECT_EQ(field.GetFieldValue(), reinterpret_cast<MAddress>(&newObj));
 }
 
 HWTEST_F_L0(PostTraceBarrierTest, CompareAndSwapRefField_TEST1)
@@ -251,6 +227,7 @@ HWTEST_F_L0(PostTraceBarrierTest, CompareAndSwapRefField_TEST1)
     bool result = postTraceBarrier_->CompareAndSwapRefField(
         &oldObj, oldField, &oldObj, &newObj, std::memory_order_seq_cst, std::memory_order_seq_cst);
     ASSERT_TRUE(result);
+    EXPECT_EQ(oldField.GetFieldValue(), neWAddress);
 }
 
 HWTEST_F_L0(PostTraceBarrierTest, CompareAndSwapRefField_TEST2)
@@ -263,33 +240,12 @@ HWTEST_F_L0(PostTraceBarrierTest, CompareAndSwapRefField_TEST2)
     EXPECT_EQ(oldObj.GetSizeForwarded(), oldSize);
     RefField<true> oldField(&oldObj);
 
+    MAddress initialAddress = oldField.GetFieldValue();
+
     bool result = postTraceBarrier_->CompareAndSwapRefField(
         &oldObj, oldField, &oldObj, &oldObj, std::memory_order_seq_cst, std::memory_order_seq_cst);
     ASSERT_TRUE(result);
-}
-
-HWTEST_F_L0(PostTraceBarrierTest, CompareAndSwapRefField_TEST3)
-{
-    ASSERT_TRUE(postTraceBarrier_ != nullptr);
-
-    BaseObject oldObj;
-    constexpr size_t oldSize = 100;
-    oldObj.SetSizeForwarded(oldSize);
-    EXPECT_EQ(oldObj.GetSizeForwarded(), oldSize);
-    RefField<true> oldField(&oldObj);
-    MAddress oldAddress = oldField.GetFieldValue();
-
-    BaseObject newObj;
-    constexpr size_t newSize = 200;
-    newObj.SetSizeForwarded(newSize);
-    EXPECT_EQ(newObj.GetSizeForwarded(), newSize);
-    RefField<true> newField(&newObj);
-    MAddress neWAddress = newField.GetFieldValue();
-    EXPECT_NE(oldAddress, neWAddress);
-
-    bool result = postTraceBarrier_->CompareAndSwapRefField(
-        &oldObj, newField, &oldObj, &newObj, std::memory_order_seq_cst, std::memory_order_seq_cst);
-    ASSERT_FALSE(result);
+    EXPECT_EQ(oldField.GetFieldValue(), initialAddress);
 }
 
 HWTEST_F_L0(PostTraceBarrierTest, CopyStructArray_TEST1)
diff --git a/common_components/heap/w_collector/tests/preforward_barrier_test.cpp b/common_components/heap/w_collector/tests/preforward_barrier_test.cpp
index fef53006cc022feda0664a530a122f7361accc7e..db53fbc84b24a143e5d698ad620b86ef6ea68458 100755
--- a/common_components/heap/w_collector/tests/preforward_barrier_test.cpp
+++ b/common_components/heap/w_collector/tests/preforward_barrier_test.cpp
@@ -20,13 +20,23 @@
 using namespace common;
 
 namespace common::test {
-class PreforwardBarrierTest : public BaseTestWithScope {};
+class PreforwardBarrierTest : public BaseTestWithScope {
+protected:
+    void SetUp() override
+    {
+        Collector &collector = Heap::GetHeap().GetCollector();
+        preforwardBarrier_ = std::make_unique<PreforwardBarrier>(collector);
+    }
+
+    void TearDown() override
+    {}
+
+    std::unique_ptr<PreforwardBarrier> preforwardBarrier_{nullptr};
+};
 
 HWTEST_F_L0(PreforwardBarrierTest, AtomicWriteRefField_TEST1)
 {
-    Collector &collector = Heap::GetHeap().GetCollector();
-    auto preforwardBarrier = std::make_unique<PreforwardBarrier>(collector);
-    ASSERT_TRUE(preforwardBarrier != nullptr);
+    ASSERT_TRUE(preforwardBarrier_ != nullptr);
 
     BaseObject oldObj;
     constexpr size_t oldSize = 100;
@@ -43,15 +53,13 @@ HWTEST_F_L0(PreforwardBarrierTest, AtomicWriteRefField_TEST1)
     MAddress neWAddress = newField.GetFieldValue();
     EXPECT_NE(oldAddress, neWAddress);
 
-    preforwardBarrier->AtomicWriteRefField(&oldObj, oldField, &newObj, std::memory_order_relaxed);
+    preforwardBarrier_->AtomicWriteRefField(&oldObj, oldField, &newObj, std::memory_order_relaxed);
     EXPECT_EQ(oldField.GetFieldValue(), neWAddress);
 }
 
 HWTEST_F_L0(PreforwardBarrierTest, AtomicWriteRefField_TEST2)
 {
-    Collector &collector = Heap::GetHeap().GetCollector();
-    auto preforwardBarrier = std::make_unique<PreforwardBarrier>(collector);
-    ASSERT_TRUE(preforwardBarrier != nullptr);
+    ASSERT_TRUE(preforwardBarrier_ != nullptr);
 
     BaseObject oldObj;
     constexpr size_t oldSize = 100;
@@ -68,7 +76,7 @@ HWTEST_F_L0(PreforwardBarrierTest, AtomicWriteRefField_TEST2)
     MAddress neWAddress = newField.GetFieldValue();
     EXPECT_NE(oldAddress, neWAddress);
 
-    preforwardBarrier->AtomicWriteRefField(nullptr, oldField, &newObj, std::memory_order_relaxed);
+    preforwardBarrier_->AtomicWriteRefField(nullptr, oldField, &newObj, std::memory_order_relaxed);
     EXPECT_EQ(oldField.GetFieldValue(), neWAddress);
 }
 }  // namespace common::test
diff --git a/common_components/heap/w_collector/tests/trace_barrier_test.cpp b/common_components/heap/w_collector/tests/trace_barrier_test.cpp
index 1e046cbcdc41e86c5fdca2fbde7eed12de3f1aaf..96bcd26f977b32484e5bbfb02c45ca228f8f118c 100755
--- a/common_components/heap/w_collector/tests/trace_barrier_test.cpp
+++ b/common_components/heap/w_collector/tests/trace_barrier_test.cpp
@@ -42,7 +42,6 @@ HWTEST_F_L0(TraceBarrierTest, ReadRefField_TEST1)
     RefField<false> field(&obj);
 
     BaseObject *resultObj = traceBarrier_->ReadRefField(&obj, field);
-    ASSERT_TRUE(resultObj != nullptr);
     EXPECT_EQ(resultObj, &obj);
 }
 
@@ -54,7 +53,6 @@ HWTEST_F_L0(TraceBarrierTest, ReadRefField_TEST2)
     RefField<false> field(&obj);
 
     BaseObject *resultObj = traceBarrier_->ReadRefField(nullptr, field);
-    ASSERT_TRUE(resultObj != nullptr);
     EXPECT_EQ(resultObj, &obj);
 }
 
@@ -66,7 +64,6 @@ HWTEST_F_L0(TraceBarrierTest, ReadStaticRef_TEST1)
     RefField<false> field(&obj);
 
     BaseObject *resultObj = traceBarrier_->ReadStaticRef(field);
-    ASSERT_TRUE(resultObj != nullptr);
     EXPECT_EQ(resultObj, &obj);
 }
 
@@ -94,29 +91,31 @@ HWTEST_F_L0(TraceBarrierTest, WriteRefField_TEST1)
     constexpr size_t oldSize = 100;
     oldObj.SetSizeForwarded(oldSize);
     EXPECT_EQ(oldObj.GetSizeForwarded(), oldSize);
+
     RefField<false> field(&oldObj);
     BaseObject *target = field.GetTargetObject();
     EXPECT_TRUE(target != nullptr);
-    MAddress oldAddress = field.GetFieldValue();
 
     BaseObject newObj;
     constexpr size_t newSize = 200;
     newObj.SetSizeForwarded(newSize);
     EXPECT_EQ(newObj.GetSizeForwarded(), newSize);
+
     traceBarrier_->WriteRefField(&oldObj, field, &newObj);
+
     MAddress newAddress = field.GetFieldValue();
-    EXPECT_NE(newAddress, oldAddress);
+    MAddress expectedAddress = RefField<>(&newObj).GetFieldValue();
+    EXPECT_EQ(newAddress, expectedAddress);
 }
 
 HWTEST_F_L0(TraceBarrierTest, WriteRefField_TEST2)
 {
-    ASSERT_TRUE(traceBarrier_ != nullptr);
-
     BaseObject oldObj;
     constexpr size_t oldSize = 100;
     oldObj.SetSizeForwarded(oldSize);
     EXPECT_EQ(oldObj.GetSizeForwarded(), oldSize);
-    RefField<> field(MAddress(0));
+
+    RefField<false> field(MAddress(0));
     BaseObject *target = field.GetTargetObject();
     EXPECT_TRUE(target == nullptr);
 
@@ -124,10 +123,12 @@ HWTEST_F_L0(TraceBarrierTest, WriteRefField_TEST2)
     constexpr size_t newSize = 200;
     newObj.SetSizeForwarded(newSize);
     EXPECT_EQ(newObj.GetSizeForwarded(), newSize);
-    RefField<false> newField(&newObj);
+
     traceBarrier_->WriteRefField(&oldObj, field, &newObj);
+
     MAddress newAddress = field.GetFieldValue();
-    EXPECT_EQ(newField.GetFieldValue(), newAddress);
+    MAddress expectedAddress = RefField<>(&newObj).GetFieldValue();
+    EXPECT_EQ(newAddress, expectedAddress);
 }
 
 HWTEST_F_L0(TraceBarrierTest, WriteBarrier_TEST1)
@@ -149,6 +150,28 @@ HWTEST_F_L0(TraceBarrierTest, WriteBarrier_TEST1)
 #endif
 }
 
+HWTEST_F_L0(TraceBarrierTest, WriteBarrier_TEST2)
+{
+    ASSERT_TRUE(traceBarrier_ != nullptr);
+
+#ifdef ARK_USE_SATB_BARRIER
+    BaseObject obj;
+    RefField<false> normalField(&obj);
+    traceBarrier_->WriteBarrier(&obj, normalField, &obj);
+    EXPECT_TRUE(obj != nullptr);
+
+    BaseObject weakObj;
+    RefField<false> weakField(MAddress(0)); // 假设这是弱引用表示方式
+    traceBarrier_->WriteBarrier(&weakObj, weakField, &weakObj);
+    EXPECT_TRUE(weakObj != nullptr);
+
+    BaseObject nonTaggedObj;
+    RefField<false> nonTaggedField(&nonTaggedObj);
+    traceBarrier_->WriteBarrier(nullptr, nonTaggedField, &nonTaggedObj);
+    EXPECT_TRUE(nonTaggedObj != nullptr);
+#endif
+}
+
 HWTEST_F_L0(TraceBarrierTest, WriteStaticRef_TEST1)
 {
     ASSERT_TRUE(traceBarrier_ != nullptr);
@@ -169,6 +192,30 @@ HWTEST_F_L0(TraceBarrierTest, WriteStaticRef_TEST1)
     EXPECT_NE(newAddress, oldAddress);
 }
 
+HWTEST_F_L0(TraceBarrierTest, WriteStruct_TEST1)
+{
+    ASSERT_TRUE(traceBarrier_ != nullptr);
+
+    BaseObject* obj = new BaseObject();
+    constexpr size_t size = 16;
+    uint8_t* dstBuffer = new uint8_t[size];
+    uint8_t* srcBuffer = new uint8_t[size];
+
+    srcBuffer[0] = 1;
+
+    HeapAddress src = reinterpret_cast<HeapAddress>(srcBuffer);
+    HeapAddress dst = reinterpret_cast<HeapAddress>(dstBuffer);
+
+    traceBarrier_->WriteStruct(obj, dst, size, src, size);
+
+    EXPECT_EQ(dstBuffer[0], 1);
+    EXPECT_EQ(srcBuffer[0], dstBuffer[0]);
+
+    delete obj;
+    delete[] dstBuffer;
+    delete[] srcBuffer;
+}
+
 HWTEST_F_L0(TraceBarrierTest, AtomicReadRefField_TEST1)
 {
     ASSERT_TRUE(traceBarrier_ != nullptr);
@@ -251,7 +298,6 @@ HWTEST_F_L0(TraceBarrierTest, AtomicSwapRefField_TEST1)
 
     BaseObject *resultObj = nullptr;
     resultObj = traceBarrier_->AtomicSwapRefField(&oldObj, oldField, &newObj, std::memory_order_relaxed);
-    ASSERT_TRUE(resultObj != nullptr);
     EXPECT_EQ(oldField.GetFieldValue(), newField.GetFieldValue());
 }