diff --git a/common_components/base/tests/BUILD.gn b/common_components/base/tests/BUILD.gn
index 39e86f58d2ed0cbdc56ec3a7cdcd8f967e4197f8..3670facd9b023976cb98cf0685d368b8d2b735cb 100755
--- a/common_components/base/tests/BUILD.gn
+++ b/common_components/base/tests/BUILD.gn
@@ -34,7 +34,7 @@ host_unittest_action("C_String_Test") {
   external_deps = [
     "icu:shared_icui18n",
     "icu:shared_icuuc",
-    "runtime_core:libarkassembler_static",
+    "zlib:libz",
   ]
 }
 
diff --git a/common_components/base/tests/c_string_test.cpp b/common_components/base/tests/c_string_test.cpp
index 56b0436ac55873a17bfd6cd19d706b945a9fa16b..6d15a40c67d6aed9cd64101a41d3d8868aa78dd6 100755
--- a/common_components/base/tests/c_string_test.cpp
+++ b/common_components/base/tests/c_string_test.cpp
@@ -15,7 +15,6 @@
 
 #include "common_components/base/c_string.h"
 #include "common_components/tests/test_helper.h"
-#include <gtest/gtest.h>
 
 using namespace common;
 namespace common::test {
@@ -274,4 +273,128 @@ HWTEST_F_L0(CStringTest, ConstructTest)
     EXPECT_EQ(nonEmptyStr.Length(), static_cast<size_t>(0));
     EXPECT_EQ(nonEmptyStr.Str()[0], '\0');
 }
+
+HWTEST_F_L0(CStringTest, FormatStringBasicTest)
+{
+    CString result = CString::FormatString("Hello, %s!", "World");
+    EXPECT_STREQ(result.Str(), "Hello, World!");
+}
+
+HWTEST_F_L0(CStringTest, FormatString_InvalidArguments_ReturnsError)
+{
+    CString result = CString::FormatString("%n", nullptr); 
+    EXPECT_STREQ(result.Str(), "invalid arguments for FormatString");
+}
+
+HWTEST_F_L0(CStringTest, InsertMiddle_Success)
+{
+    CString str("helloworld");
+    EXPECT_STREQ(str.Insert(5, ", ").Str(), "hello, world");
+}
+
+HWTEST_F_L0(CStringTest, TruncateValidIndex_Success)
+{
+    CString str("hello world");
+    EXPECT_STREQ(str.Truncate(5).Str(), "hello");
+    EXPECT_EQ(str.Length(), static_cast<size_t>(5));
+}
+
+HWTEST_F_L0(CStringTest, GetStr_NonEmptyString_ReturnsCorrect)
+{
+    CString str("test string");
+    EXPECT_STREQ(str.GetStr(), "test string");
+}
+
+HWTEST_F_L0(CStringTest, CombineWithEmptyString_ReturnsOriginal)
+{
+    CString str("original");
+    CString emptyStr;
+    CString combined = str.Combine(emptyStr);
+    EXPECT_STREQ(combined.Str(), "original");
+    EXPECT_EQ(combined.Length(), str.Length());
+}
+
+HWTEST_F_L0(CStringTest, CombineWithEmptyCStr_ReturnsOriginal)
+{
+    CString str("original");
+    const char* emptyCStr = "";
+    CString combined = str.Combine(emptyCStr);
+    EXPECT_STREQ(combined.Str(), "original");
+    EXPECT_EQ(combined.Length(), str.Length());
+}
+
+HWTEST_F_L0(CStringTest, AppendNullptr_NoChange)
+{
+    CString str("original");
+    str.Append(nullptr, 5);
+    EXPECT_STREQ(str.Str(), "original");
+    EXPECT_EQ(str.Length(), strlen("original"));
+}
+
+HWTEST_F_L0(CStringTest, AppendZeroLength_NoChange)
+{
+    CString str("test");
+    CString emptyStr;
+
+    str.Append(emptyStr, 0);
+
+    EXPECT_STREQ(str.Str(), "test");
+    EXPECT_EQ(str.Length(), strlen("test"));
+}
+
+HWTEST_F_L0(CStringTest, AppendSelf_ValidResult)
+{
+    CString str("abc");
+    str.Append(str.Str(), str.Length());
+    EXPECT_STREQ(str.Str(), "abcabc");
+    EXPECT_EQ(str.Length(), strlen("abcabc"));
+}
+
+HWTEST_F_L0(CStringTest, AppendEmptyCString_NoChange)
+{
+    CString str("original");
+    CString emptyStr;
+    str.Append(emptyStr);
+    EXPECT_STREQ(str.Str(), "original");
+    EXPECT_EQ(str.Length(), strlen("original"));
+}
+
+HWTEST_F_L0(CStringTest, AppendEmptyCStringZeroLength_NoChange)
+{
+    CString str("test");
+    CString emptyStr;
+
+    str.Append(emptyStr, 0);
+
+    EXPECT_STREQ(str.Str(), "test");
+    EXPECT_EQ(str.Length(), strlen("test"));
+}
+
+HWTEST_F_L0(CStringTest, AppendValidCString_CorrectResult)
+{
+    CString str("hello");
+    CString addStr(" world!");
+    str.Append(addStr, strlen(addStr.Str()));
+    EXPECT_STREQ(str.Str(), "hello world!");
+    EXPECT_EQ(str.Length(), strlen("hello world!"));
+}
+
+HWTEST_F_L0(CStringTest, EnsureMultipleCalls_CapacityGrowsCorrectly)
+{
+    CString str("initial");
+    char* firstPtr = str.GetStr();
+
+    str.EnsureSpace(16);
+    char* secondPtr = str.GetStr();
+
+    EXPECT_NE(firstPtr, secondPtr);
+
+    str.EnsureSpace(100);
+    char* thirdPtr = str.GetStr();
+
+    EXPECT_NE(secondPtr, thirdPtr);
+    EXPECT_EQ(str.Length(), strlen("initial"));
+    EXPECT_STREQ(str.Str(), "initial");
+}
+
 }
\ No newline at end of file
diff --git a/common_components/heap/collector/tests/finalizer_processor_test.cpp b/common_components/heap/collector/tests/finalizer_processor_test.cpp
index 746a5744ae4fe2cfb6b8f5160e775b5d902a56df..524ab7719961a7b39c39bd1d223678f05d027088 100755
--- a/common_components/heap/collector/tests/finalizer_processor_test.cpp
+++ b/common_components/heap/collector/tests/finalizer_processor_test.cpp
@@ -142,4 +142,10 @@ HWTEST_F_L0(FinalizerProcessorTest, Run_TEST1)
     finalizerProcessor.Stop();
     EXPECT_NE(buffer2->GetPreparedRegion(), nullptr);
 }
+
+HWTEST_F_L0(FinalizerProcessorTest, Stop_BeforeStart_NoException) {
+    FinalizerProcessor unstartedProcessor;
+    EXPECT_NO_THROW(unstartedProcessor.Stop());
+}
+
 } // namespace common::test
\ No newline at end of file
diff --git a/common_components/heap/w_collector/tests/w_collector_test.cpp b/common_components/heap/w_collector/tests/w_collector_test.cpp
index 1534f3d9b1343e990960dce124f1e02db7fa09fc..5d9d40143b0f165108ab5acc94c9034c212a8175 100644
--- a/common_components/heap/w_collector/tests/w_collector_test.cpp
+++ b/common_components/heap/w_collector/tests/w_collector_test.cpp
@@ -25,7 +25,7 @@ using namespace common;
 
 namespace common::test {
 using SuspensionType = MutatorBase::SuspensionType;
-class WCollectorTest : public BaseTestWithScope {
+class WCollectorTest : public common::test::BaseTestWithScope {
 protected:
     static void SetUpTestCase()
     {
@@ -135,4 +135,79 @@ HWTEST_F_L0(WCollectorTest, FlipTest)
     std::thread t1(FlipTest);
     t1.join();
 }
+
+HWTEST_F_L0(WCollectorTest, IsUnmovableFromObject_ReturnsFalseForNullptr)
+{
+    std::unique_ptr<WCollector> wcollector = GetWCollector();
+    ASSERT_TRUE(wcollector != nullptr);
+
+    BaseObject* obj = nullptr;
+    EXPECT_FALSE(wcollector->IsUnmovableFromObject(obj));
+}
+
+class TestableWCollector : public WCollector {
+public:
+    using WCollector::ForwardObject;
+
+    explicit TestableWCollector(Allocator& allocator, CollectorResources& resources)
+        : WCollector(allocator, resources), currentGCPhase_(GCPhase::GC_PHASE_COPY) {}
+
+    void SetCurrentGCPhaseForTest(GCPhase phase)
+    {
+        currentGCPhase_ = phase;
+    }
+
+    GCPhase GetCurrentGCPhaseForTest() const
+    {
+        return currentGCPhase_;
+    }
+
+private:
+    GCPhase currentGCPhase_;
+};
+
+
+class DummyObject : public BaseObject {
+public:
+    const common::TypeInfo* GetTypeInfo() const { return nullptr; }
+    size_t GetSize() const { return sizeof(DummyObject); }
+
+    void SetClass(uintptr_t cls)
+    {
+        stateWord_.StoreStateWord(static_cast<StateWordType>(cls));
+    }
+
+private:
+    class BaseStateWord {
+    public:
+        using StateWordType = uint64_t;
+
+        void StoreStateWord(StateWordType word)
+        {
+            stateWord_ = word;
+        }
+
+        StateWordType LoadStateWord() const
+        {
+            return stateWord_;
+        }
+
+    private:
+        StateWordType stateWord_{0};
+    };
+
+    BaseStateWord stateWord_;
+};
+
+HWTEST_F_L0(WCollectorTest, ForwardObject_WithUnmovedObject_ReturnsSameAddress)
+{
+    std::unique_ptr<WCollector> wcollector = GetWCollector();
+    ASSERT_TRUE(wcollector != nullptr);
+
+    TestableWCollector* testableCollector = reinterpret_cast<TestableWCollector*>(wcollector.get());
+
+    testableCollector->SetCurrentGCPhaseForTest(GCPhase::GC_PHASE_COPY);
+    EXPECT_EQ(testableCollector->GetCurrentGCPhaseForTest(), GCPhase::GC_PHASE_COPY);
+}
+
 }  // namespace common::test