diff --git a/frameworks/core/interfaces/native/implementation/render_node_accessor.cpp b/frameworks/core/interfaces/native/implementation/render_node_accessor.cpp
index c191566032b97e9a53a8cfeefc38e621b98e29fb..74d535336b8feccb7b58b9968e58e2d2a7f320a3 100644
--- a/frameworks/core/interfaces/native/implementation/render_node_accessor.cpp
+++ b/frameworks/core/interfaces/native/implementation/render_node_accessor.cpp
@@ -23,11 +23,36 @@
 #include "core/components_ng/base/frame_node.h"
 #include "core/components_ng/pattern/render_node/render_node_pattern.h"
 #include "core/interfaces/native/implementation/render_node_peer_impl.h"
+#include "core/interfaces/native/implementation/shape_clip_peer.h"
+#include "core/interfaces/native/implementation/shape_mask_peer.h"
 #include "core/interfaces/native/utility/callback_helper.h"
 #include "core/interfaces/native/utility/converter.h"
+#include "core/interfaces/native/utility/reverse_converter.h"
 #include "core/components_ng/base/view_abstract_model_static.h"
 
 namespace OHOS::Ace::NG {
+namespace Converter {
+template<>
+void AssignCast(std::optional<LengthMetricsUnit>& dst, const Ark_LengthMetricsUnit& src)
+{
+    switch (src) {
+        case ARK_LENGTH_METRICS_UNIT_DEFAULT: dst = LengthMetricsUnit::DEFAULT; break;
+        case ARK_LENGTH_METRICS_UNIT_PX: dst = LengthMetricsUnit::PX; break;
+        default: LOGE("Unexpected enum value in Ark_LengthMetricsUnit: %{public}d", src);
+    }
+}
+
+void AssignArkValue(Ark_LengthMetricsUnit& dst, const LengthMetricsUnit& src, ConvContext *ctx)
+{
+    switch (src) {
+        case LengthMetricsUnit::DEFAULT: dst = ARK_LENGTH_METRICS_UNIT_DEFAULT; break;
+        case LengthMetricsUnit::PX: dst = ARK_LENGTH_METRICS_UNIT_PX; break;
+        default: dst = static_cast<Ark_LengthMetricsUnit>(-1);
+            LOGE("Unexpected enum value in LengthMetricsUnit: %{public}d", src);
+    }
+}
+}
+
 namespace GeneratedModifier {
 namespace {
 constexpr int32_t ARK_UNION_UNDEFINED = 1;
@@ -44,6 +69,11 @@ DimensionUnit ConvertLengthMetricsUnitToDimensionUnit(Ark_Int32 unitValue, Dimen
     }
     return defaultUnit;
 }
+
+RefPtr<OHOS::Ace::BasicShape> GetBasicShape(Ark_BaseShape peer)
+{
+    return peer ? peer->shape : nullptr;
+}
 } // namespace
 namespace RenderNodeAccessor {
 void DestroyPeerImpl(Ark_RenderNode peer)
@@ -868,17 +898,46 @@ void SetBorderRadiusImpl(Ark_RenderNode peer, const Ark_BorderRadiuses_graphics*
 }
 Ark_ShapeMask GetShapeMaskImpl(Ark_RenderNode peer)
 {
-    return {};
+    CHECK_NULL_RETURN(peer, nullptr);
+    auto frameNode = peer->GetFrameNode();
+    CHECK_NULL_RETURN(frameNode, nullptr);
+    auto value = ViewAbstract::GetMask(Referenced::RawPtr(frameNode));
+    return PeerUtils::CreatePeer<ShapeMaskPeer>(value);
+}
+void SetShapeMaskImpl(Ark_RenderNode peer, Ark_ShapeMask shapeMask)
+{
+    CHECK_NULL_VOID(peer && shapeMask);
+    auto frameNode = peer->GetFrameNode();
+    CHECK_NULL_VOID(frameNode);
+    CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode");
+    auto value = GetBasicShape(shapeMask);
+    ViewAbstract::SetMask(Referenced::RawPtr(frameNode), value);
 }
-void SetShapeMaskImpl(Ark_RenderNode peer, Ark_ShapeMask shapeMask) {}
 Ark_ShapeClip GetShapeClipImpl(Ark_RenderNode peer)
 {
-    return {};
+    CHECK_NULL_RETURN(peer, nullptr);
+    auto frameNode = peer->GetFrameNode();
+    CHECK_NULL_RETURN(frameNode, nullptr);
+    auto value = ViewAbstract::GetClipShape(Referenced::RawPtr(frameNode));
+    return PeerUtils::CreatePeer<ShapeClipPeer>(value);
+}
+void SetShapeClipImpl(Ark_RenderNode peer, Ark_ShapeClip shapeClip)
+{
+    CHECK_NULL_VOID(peer && shapeClip);
+    auto frameNode = peer->GetFrameNode();
+    CHECK_NULL_VOID(frameNode);
+    CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode");
+    auto value = GetBasicShape(shapeClip);
+    ViewAbstract::SetClipShape(Referenced::RawPtr(frameNode), value);
 }
-void SetShapeClipImpl(Ark_RenderNode peer, Ark_ShapeClip shapeClip) {}
 Ark_Boolean GetMarkNodeGroupImpl(Ark_RenderNode peer)
 {
-    return {};
+    auto errorValue = Converter::ArkValue<Ark_Boolean>(false);
+    CHECK_NULL_RETURN(peer, errorValue);
+    auto frameNode = peer->GetFrameNode();
+    CHECK_NULL_RETURN(frameNode, errorValue);
+    auto isRenderGroup = ViewAbstract::GetRenderGroup(Referenced::RawPtr(frameNode));
+    return Converter::ArkValue<Ark_Boolean>(isRenderGroup);
 }
 void SetMarkNodeGroupImpl(Ark_RenderNode peer, Ark_Boolean markNodeGroup)
 {
@@ -890,17 +949,25 @@ void SetMarkNodeGroupImpl(Ark_RenderNode peer, Ark_Boolean markNodeGroup)
 
     auto frameNode = peer->GetFrameNode();
     CHECK_NULL_VOID(frameNode);
-    auto renderContext = frameNode->GetRenderContext();
-    CHECK_NULL_VOID(renderContext);
-    renderContext->SetMarkNodeGroup(isNodeGroup);
-    frameNode->SetApplicationRenderGroupMarked(true);
-    renderContext->RequestNextFrame();
+    CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode");
+
+    frameNode->SetApplicationRenderGroupMarked(isNodeGroup);
+    ViewAbstract::SetRenderGroup(Referenced::RawPtr(frameNode), isNodeGroup);
 }
 Ark_LengthMetricsUnit GetLengthMetricsUnitImpl(Ark_RenderNode peer)
 {
-    return {};
+    auto errorValue = Converter::ArkValue<Ark_LengthMetricsUnit>(OHOS::Ace::NG::LengthMetricsUnit::DEFAULT);
+    CHECK_NULL_RETURN(peer, errorValue);
+    auto frameNode = peer->GetFrameNode();
+    CHECK_NULL_RETURN(frameNode, errorValue);
+    return Converter::ArkValue<Ark_LengthMetricsUnit>(peer->lengthMetricsUnit);
+}
+void SetLengthMetricsUnitImpl(Ark_RenderNode peer, Ark_LengthMetricsUnit lengthMetricsUnit)
+{
+    CHECK_NULL_VOID(peer);
+    auto value = Converter::OptConvert<OHOS::Ace::NG::LengthMetricsUnit>(lengthMetricsUnit);
+    peer->lengthMetricsUnit = value.has_value() ? value.value() : OHOS::Ace::NG::LengthMetricsUnit::DEFAULT;
 }
-void SetLengthMetricsUnitImpl(Ark_RenderNode peer, Ark_LengthMetricsUnit lengthMetricsUnit) {}
 } // namespace RenderNodeAccessor
 const GENERATED_ArkUIRenderNodeAccessor* GetRenderNodeAccessor()
 {
diff --git a/frameworks/core/interfaces/native/implementation/shape_clip_accessor.cpp b/frameworks/core/interfaces/native/implementation/shape_clip_accessor.cpp
index 5f85c1799a3c5827814be36abce2959594545228..d0f8696116ceb4d9aba2881ad303eab42aa6d1a3 100644
--- a/frameworks/core/interfaces/native/implementation/shape_clip_accessor.cpp
+++ b/frameworks/core/interfaces/native/implementation/shape_clip_accessor.cpp
@@ -37,35 +37,37 @@ void SetRectShapeImpl(Ark_ShapeClip peer,
                       const Ark_Rect* rect)
 {
     if (peer && rect) {
-        peer->SetRectShape(Converter::Convert<RefPtr<Ace::ShapeRect>>(*rect));
+        peer->shape = Converter::Convert<RefPtr<Ace::ShapeRect>>(*rect);
     }
 }
 void SetRoundRectShapeImpl(Ark_ShapeClip peer,
                            const Ark_RoundRect* roundRect)
 {
     if (peer && roundRect) {
-        peer->SetRoundRectShape(Converter::Convert<RefPtr<Ace::ShapeRect>>(*roundRect));
+        peer->shape = Converter::Convert<RefPtr<Ace::ShapeRect>>(*roundRect);
     }
 }
 void SetCircleShapeImpl(Ark_ShapeClip peer,
                         const Ark_Circle* circle)
 {
     if (peer && circle) {
-        peer->SetCircleShape(Converter::Convert<RefPtr<Ace::Circle>>(*circle));
+        peer->shape = Converter::Convert<RefPtr<Ace::Circle>>(*circle);
     }
 }
 void SetOvalShapeImpl(Ark_ShapeClip peer,
                       const Ark_Rect* oval)
 {
     if (peer && oval) {
-        peer->SetOvalShape(Converter::Convert<RefPtr<Ace::ShapeRect>>(*oval));
+        peer->shape = Converter::Convert<RefPtr<Ace::Ellipse>>(*oval);
     }
 }
 void SetCommandPathImpl(Ark_ShapeClip peer,
                         const Ark_CommandPath* path)
 {
     if (peer && path) {
-        peer->SetCommandPath(Converter::Convert<std::string>(*path));
+        auto pathShape = OHOS::Ace::AceType::MakeRefPtr<OHOS::Ace::Path>();
+        pathShape->SetValue(Converter::Convert<std::string>(*path));
+        peer->shape = pathShape;
     }
 }
 } // ShapeClipAccessor
diff --git a/frameworks/core/interfaces/native/implementation/shape_clip_peer.h b/frameworks/core/interfaces/native/implementation/shape_clip_peer.h
index 072bd72ee2294d2b97bbf6432878003f912d570d..d09e6b78953dd9d02dc54ddcc63da9ce638de857 100644
--- a/frameworks/core/interfaces/native/implementation/shape_clip_peer.h
+++ b/frameworks/core/interfaces/native/implementation/shape_clip_peer.h
@@ -20,6 +20,7 @@
 struct ShapeClipPeer final : public BaseShapePeer {
 protected:
     ShapeClipPeer() = default;
+    explicit ShapeClipPeer(const RefPtr<OHOS::Ace::BasicShape>& src) : BaseShapePeer(src) {}
     ~ShapeClipPeer() override = default;
     friend OHOS::Ace::NG::PeerUtils;
 };
diff --git a/frameworks/core/interfaces/native/implementation/shape_mask_accessor.cpp b/frameworks/core/interfaces/native/implementation/shape_mask_accessor.cpp
index ec6a787c67fe8eb5cb6eabcc0307911632720d0f..ffe361954de58c5df4e26e04fa5b52dc7cd68dbb 100644
--- a/frameworks/core/interfaces/native/implementation/shape_mask_accessor.cpp
+++ b/frameworks/core/interfaces/native/implementation/shape_mask_accessor.cpp
@@ -41,35 +41,42 @@ void SetRectShapeImpl(Ark_ShapeMask peer,
                       const Ark_Rect* rect)
 {
     if (peer && rect) {
-        peer->SetRectShape(Converter::Convert<RefPtr<Ace::ShapeRect>>(*rect));
+        peer->shape = Converter::Convert<RefPtr<Ace::ShapeRect>>(*rect);
+        peer->SetBasicProperties();
     }
 }
 void SetRoundRectShapeImpl(Ark_ShapeMask peer,
                            const Ark_RoundRect* roundRect)
 {
     if (peer && roundRect) {
-        peer->SetRoundRectShape(Converter::Convert<RefPtr<Ace::ShapeRect>>(*roundRect));
+        peer->shape = Converter::Convert<RefPtr<Ace::ShapeRect>>(*roundRect);
+        peer->SetBasicProperties();
     }
 }
 void SetCircleShapeImpl(Ark_ShapeMask peer,
                         const Ark_Circle* circle)
 {
     if (peer && circle) {
-        peer->SetCircleShape(Converter::Convert<RefPtr<Ace::Circle>>(*circle));
+        peer->shape = Converter::Convert<RefPtr<Ace::Circle>>(*circle);
+        peer->SetBasicProperties();
     }
 }
 void SetOvalShapeImpl(Ark_ShapeMask peer,
                       const Ark_Rect* oval)
 {
     if (peer && oval) {
-        peer->SetOvalShape(Converter::Convert<RefPtr<Ace::ShapeRect>>(*oval));
+        peer->shape = Converter::Convert<RefPtr<Ace::Ellipse>>(*oval);
+        peer->SetBasicProperties();
     }
 }
 void SetCommandPathImpl(Ark_ShapeMask peer,
                         const Ark_CommandPath* path)
 {
     if (peer && path) {
-        peer->SetCommandPath(Converter::Convert<std::string>(*path));
+        auto pathShape = OHOS::Ace::AceType::MakeRefPtr<OHOS::Ace::Path>();
+        pathShape->SetValue(Converter::Convert<std::string>(*path));
+        peer->shape = pathShape;
+        peer->SetBasicProperties();
     }
 }
 Ark_Number GetFillColorImpl(Ark_ShapeMask peer)
@@ -82,6 +89,9 @@ void SetFillColorImpl(Ark_ShapeMask peer,
 {
     CHECK_NULL_VOID(peer && fillColor);
     peer->fillColor = Converter::Convert<int32_t>(*fillColor);
+    if (peer->shape) {
+        peer->shape->SetColor(OHOS::Ace::Color(peer->fillColor));
+    }
 }
 Ark_Number GetStrokeColorImpl(Ark_ShapeMask peer)
 {
@@ -93,6 +103,9 @@ void SetStrokeColorImpl(Ark_ShapeMask peer,
 {
     CHECK_NULL_VOID(peer && strokeColor);
     peer->strokeColor = Converter::Convert<int32_t>(*strokeColor);
+    if (peer->shape) {
+        peer->shape->SetStrokeColor(peer->strokeColor);
+    }
 }
 Ark_Number GetStrokeWidthImpl(Ark_ShapeMask peer)
 {
@@ -104,6 +117,9 @@ void SetStrokeWidthImpl(Ark_ShapeMask peer,
 {
     CHECK_NULL_VOID(peer && strokeWidth);
     peer->strokeWidth = Converter::Convert<float>(*strokeWidth);
+    if (peer->shape) {
+        peer->shape->SetStrokeWidth(peer->strokeWidth);
+    }
 }
 } // ShapeMaskAccessor
 const GENERATED_ArkUIShapeMaskAccessor* GetShapeMaskAccessor()
diff --git a/frameworks/core/interfaces/native/implementation/shape_mask_peer.h b/frameworks/core/interfaces/native/implementation/shape_mask_peer.h
index 843e0e59f999558d4fcd7b5044f5d15cfa5c818d..ead767d5438e8cfde1e6d2712528d461038ecc72 100644
--- a/frameworks/core/interfaces/native/implementation/shape_mask_peer.h
+++ b/frameworks/core/interfaces/native/implementation/shape_mask_peer.h
@@ -27,59 +27,27 @@ const float DEFAULT_WIDTH = 0.0f;
 
 struct BaseShapePeer {
     BaseShapePeer() = default;
+    explicit BaseShapePeer(const RefPtr<OHOS::Ace::BasicShape>& src) : shape(src) {}
     virtual ~BaseShapePeer() = default;
 
-    void SetRectShape(const RefPtr<OHOS::Ace::ShapeRect>& value)
-    {
-        ResetAll();
-        rect = value;
-    }
-    void SetRoundRectShape(const RefPtr<OHOS::Ace::ShapeRect>& value)
-    {
-        ResetAll();
-        roundRect = value;
-    }
-    void SetCircleShape(const RefPtr<OHOS::Ace::Circle>& value)
-    {
-        ResetAll();
-        circle = value;
-    }
-    void SetOvalShape(const RefPtr<OHOS::Ace::ShapeRect>& value)
-    {
-        ResetAll();
-        oval = value;
-    }
-    void SetCommandPath(const std::string& value)
-    {
-        ResetAll();
-        path = value;
-    }
-
-private:
-    void ResetAll()
-    {
-        rect = nullptr;
-        roundRect = nullptr;
-        circle = nullptr;
-        oval = nullptr;
-        path = std::nullopt;
-    }
-
-public:
-    RefPtr<OHOS::Ace::ShapeRect> rect = nullptr;
-    RefPtr<OHOS::Ace::ShapeRect> roundRect = nullptr;
-    RefPtr<OHOS::Ace::Circle> circle = nullptr;
-    RefPtr<OHOS::Ace::ShapeRect> oval = nullptr;
-    std::optional<std::string> path = std::nullopt;
+    RefPtr<OHOS::Ace::BasicShape> shape = nullptr;
 };
 
 struct ShapeMaskPeer final : public BaseShapePeer {
 protected:
     ShapeMaskPeer() = default;
+    explicit ShapeMaskPeer(const RefPtr<OHOS::Ace::BasicShape>& src) : BaseShapePeer(src) {}
     ~ShapeMaskPeer() override = default;
     friend OHOS::Ace::NG::PeerUtils;
 
 public:
+    void SetBasicProperties()
+    {
+        shape->SetColor(OHOS::Ace::Color(fillColor));
+        shape->SetStrokeColor(strokeColor);
+        shape->SetStrokeWidth(strokeWidth);
+    }
+
     uint32_t fillColor = DEFAULT_COLOR;
     uint32_t strokeColor = DEFAULT_COLOR;
     float strokeWidth = DEFAULT_WIDTH;
diff --git a/frameworks/core/interfaces/native/utility/converter.cpp b/frameworks/core/interfaces/native/utility/converter.cpp
index e08b719251fe9f602b1443ce3c71e7007d6f9d93..de4bf81e85d49e38f77e9fc531b045e2e7f30fd0 100644
--- a/frameworks/core/interfaces/native/utility/converter.cpp
+++ b/frameworks/core/interfaces/native/utility/converter.cpp
@@ -1135,6 +1135,30 @@ Gradient Convert(const Ark_LinearGradient& value)
     return gradient;
 }
 
+template<>
+RefPtr<Ellipse> Convert(const Ark_Rect& src)
+{
+    const auto two = 2;
+    auto dst = AceType::MakeRefPtr<Ellipse>();
+    float left = Converter::Convert<float>(src.left);
+    float top = Converter::Convert<float>(src.top);
+    float right = Converter::Convert<float>(src.right);
+    float bottom = Converter::Convert<float>(src.bottom);
+    auto width = Dimension(right - left);
+    auto height = Dimension(bottom - top);
+    auto deltaX = Dimension(left);
+    auto deltaY = Dimension(top);
+    auto position = DimensionOffset(deltaX, deltaY);
+    dst->SetWidth(width);
+    dst->SetHeight(height);
+    dst->SetPosition(position);
+    dst->SetRadiusX(Dimension((right - left) / two));
+    dst->SetRadiusY(Dimension((bottom - top) / two));
+    dst->SetAxisX(Dimension(left + (right - left) / two));
+    dst->SetAxisY(Dimension(top + (bottom - top) / two));
+    return dst;
+}
+
 template<>
 void AssignCast (std::optional<Gradient>& dst, const Ark_LinearGradient& src)
 {
diff --git a/frameworks/core/interfaces/native/utility/converter.h b/frameworks/core/interfaces/native/utility/converter.h
index 48a06ec4b9a0b27d6820a30c9864d0d6e25a1b17..5a2cffbb09bfbbf4f518eec6e587df967a4b6803 100644
--- a/frameworks/core/interfaces/native/utility/converter.h
+++ b/frameworks/core/interfaces/native/utility/converter.h
@@ -588,6 +588,7 @@ namespace Converter {
     template<> RefPtr<Curve> Convert(const Ark_Curve& src);
     template<> RefPtr<Curve> Convert(const Ark_ICurve& src);
     template<> RefPtr<Curve> Convert(const Ark_String& src);
+    template<> RefPtr<Ellipse> Convert(const Ark_Rect& src);
     template<> RefPtr<FrameRateRange> Convert(const Ark_ExpectedFrameRateRange& src);
     template<> RefPtr<Gesture> Convert(const Ark_GestureGroupInterface& src);
     template<> RefPtr<Gesture> Convert(const Ark_LongPressGestureInterface& src);
diff --git a/test/unittest/capi/accessors/shape_clip_accessor_test.cpp b/test/unittest/capi/accessors/shape_clip_accessor_test.cpp
index f97535e62e61416a82d96b75ec6bef6e84587af8..1eaed6cee9f0d495810f9b317c9dba9c74be0519 100755
--- a/test/unittest/capi/accessors/shape_clip_accessor_test.cpp
+++ b/test/unittest/capi/accessors/shape_clip_accessor_test.cpp
@@ -64,15 +64,11 @@ HWTEST_F(ShapeClipAccessorTest, setRectShapeTopLeftTest, TestSize.Level1)
 
             auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value());
             auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value());
-            ASSERT_NE(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->rect->GetPosition().GetX(), expectedX);
-            EXPECT_EQ(peer_->rect->GetPosition().GetY(), expectedY);
-            EXPECT_EQ(peer_->rect->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->rect->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
         }
     }
 }
@@ -100,15 +96,11 @@ HWTEST_F(ShapeClipAccessorTest, setRectShapeRightBottomTest, TestSize.Level1)
             auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-            ASSERT_NE(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->rect->GetPosition().GetX(), expectedD);
-            EXPECT_EQ(peer_->rect->GetPosition().GetY(), expectedD);
-            EXPECT_EQ(peer_->rect->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->rect->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
         }
     }
 }
@@ -146,24 +138,21 @@ HWTEST_F(ShapeClipAccessorTest, setRoundRectShapeTopLeftTest, TestSize.Level1)
             auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value());
             auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value());
             auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-            ASSERT_NE(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->roundRect->GetPosition().GetX(), expectedX);
-            EXPECT_EQ(peer_->roundRect->GetPosition().GetY(), expectedY);
-            EXPECT_EQ(peer_->roundRect->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->roundRect->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetX(), expectedX);
-            EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetY(), expectedY);
-            EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetX(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetY(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetX(), expectedX);
-            EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetY(), expectedY);
-            EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetX(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetY(), expectedD);
-
-            EXPECT_EQ(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
+            auto roundShapeRect = AceType::DynamicCast<ShapeRect>(peer_->shape);
+            ASSERT_NE(roundShapeRect, nullptr);
+            EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetX(), expectedX);
+            EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetY(), expectedY);
+            EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetX(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetY(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetX(), expectedX);
+            EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetY(), expectedY);
+            EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetX(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetY(), expectedD);
         }
     }
 }
@@ -201,24 +190,21 @@ HWTEST_F(ShapeClipAccessorTest, setRoundRectShapeRightBottomTest, TestSize.Level
             auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-            ASSERT_NE(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->roundRect->GetPosition().GetX(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetPosition().GetY(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->roundRect->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetX(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetY(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetX(), expectedX);
-            EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetY(), expectedY);
-            EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetX(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetY(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetX(), expectedX);
-            EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetY(), expectedY);
-
-            EXPECT_EQ(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
+            auto roundShapeRect = AceType::DynamicCast<ShapeRect>(peer_->shape);
+            ASSERT_NE(roundShapeRect, nullptr);
+            EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetX(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetY(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetX(), expectedX);
+            EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetY(), expectedY);
+            EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetX(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetY(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetX(), expectedX);
+            EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetY(), expectedY);
         }
     }
 }
@@ -243,14 +229,12 @@ HWTEST_F(ShapeClipAccessorTest, setCircleShapeXYTest, TestSize.Level1)
             accessor_->setCircleShape(peer_, &circle);
 
             auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-            ASSERT_NE(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->circle->GetPosition().GetX(), expectedX);
-            EXPECT_EQ(peer_->circle->GetPosition().GetY(), expectedY);
-            EXPECT_EQ(peer_->circle->GetRadius(), expectedD);
-            EXPECT_EQ(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY);
+            auto circleShape = AceType::DynamicCast<Circle>(peer_->shape);
+            ASSERT_NE(circleShape, nullptr);
+            EXPECT_EQ(circleShape->GetRadius(), expectedD);
         }
     }
 }
@@ -274,16 +258,14 @@ HWTEST_F(ShapeClipAccessorTest, setCircleShapeRadiusTest, TestSize.Level1)
         accessor_->setCircleShape(peer_, &circle);
 
         auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-        ASSERT_NE(peer_->circle, nullptr);
-        EXPECT_EQ(peer_->circle->GetPosition().GetX(), expectedD);
-        EXPECT_EQ(peer_->circle->GetPosition().GetY(), expectedD);
+        ASSERT_NE(peer_->shape, nullptr);
+        EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD);
+        EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD);
         if (expectedR.IsValid()) {
-            EXPECT_EQ(peer_->circle->GetRadius(), expectedR);
+            auto circleShape = AceType::DynamicCast<Circle>(peer_->shape);
+            ASSERT_NE(circleShape, nullptr);
+            EXPECT_EQ(circleShape->GetRadius(), expectedR);
         }
-        EXPECT_EQ(peer_->rect, nullptr);
-        EXPECT_EQ(peer_->roundRect, nullptr);
-        EXPECT_EQ(peer_->oval, nullptr);
-        EXPECT_EQ(peer_->path, std::nullopt);
     }
 }
 
@@ -309,15 +291,11 @@ HWTEST_F(ShapeClipAccessorTest, setOvalShapeTopLeftTest, TestSize.Level1)
 
             auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value());
             auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value());
-            ASSERT_NE(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->oval->GetPosition().GetX(), expectedX);
-            EXPECT_EQ(peer_->oval->GetPosition().GetY(), expectedY);
-            EXPECT_EQ(peer_->oval->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->oval->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
         }
     }
 }
@@ -345,15 +323,11 @@ HWTEST_F(ShapeClipAccessorTest, setOvalShapeRightBottomTest, TestSize.Level1)
             auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-            ASSERT_NE(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->oval->GetPosition().GetX(), expectedD);
-            EXPECT_EQ(peer_->oval->GetPosition().GetY(), expectedD);
-            EXPECT_EQ(peer_->oval->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->oval->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
         }
     }
 }
@@ -373,12 +347,10 @@ HWTEST_F(ShapeClipAccessorTest, setCommandPathTest, TestSize.Level1)
         };
         accessor_->setCommandPath(peer_, &path);
 
-        ASSERT_NE(peer_->path, std::nullopt);
-        EXPECT_EQ(peer_->path.value(), expectedP);
-        EXPECT_EQ(peer_->rect, nullptr);
-        EXPECT_EQ(peer_->roundRect, nullptr);
-        EXPECT_EQ(peer_->circle, nullptr);
-        EXPECT_EQ(peer_->oval, nullptr);
+        ASSERT_NE(peer_->shape, nullptr);
+        auto pathShape = AceType::DynamicCast<Path>(peer_->shape);
+        ASSERT_NE(pathShape, nullptr);
+        EXPECT_EQ(pathShape->GetValue(), expectedP);
     }
 }
 } // namespace OHOS::Ace::NG
\ No newline at end of file
diff --git a/test/unittest/capi/accessors/shape_mask_accessor_test.cpp b/test/unittest/capi/accessors/shape_mask_accessor_test.cpp
index a7c80c21ebf40afcd929f15e8eb0dfa8e4717fec..d38a8a8772e76d371355d96d23cbe11d7d8b76a2 100644
--- a/test/unittest/capi/accessors/shape_mask_accessor_test.cpp
+++ b/test/unittest/capi/accessors/shape_mask_accessor_test.cpp
@@ -82,15 +82,11 @@ HWTEST_F(ShapeMaskAccessorTest, setRectShapeTopLeftTest, TestSize.Level1)
 
             auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value());
             auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value());
-            ASSERT_NE(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->rect->GetPosition().GetX(), expectedX);
-            EXPECT_EQ(peer_->rect->GetPosition().GetY(), expectedY);
-            EXPECT_EQ(peer_->rect->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->rect->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
         }
     }
 }
@@ -118,15 +114,11 @@ HWTEST_F(ShapeMaskAccessorTest, setRectShapeRightBottomTest, TestSize.Level1)
             auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-            ASSERT_NE(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->rect->GetPosition().GetX(), expectedD);
-            EXPECT_EQ(peer_->rect->GetPosition().GetY(), expectedD);
-            EXPECT_EQ(peer_->rect->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->rect->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
         }
     }
 }
@@ -164,24 +156,21 @@ HWTEST_F(ShapeMaskAccessorTest, setRoundRectShapeTopLeftTest, TestSize.Level1)
             auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value());
             auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value());
             auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-            ASSERT_NE(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->roundRect->GetPosition().GetX(), expectedX);
-            EXPECT_EQ(peer_->roundRect->GetPosition().GetY(), expectedY);
-            EXPECT_EQ(peer_->roundRect->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->roundRect->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetX(), expectedX);
-            EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetY(), expectedY);
-            EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetX(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetY(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetX(), expectedX);
-            EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetY(), expectedY);
-            EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetX(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetY(), expectedD);
-
-            EXPECT_EQ(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
+            auto roundShapeRect = AceType::DynamicCast<ShapeRect>(peer_->shape);
+            ASSERT_NE(roundShapeRect, nullptr);
+            EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetX(), expectedX);
+            EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetY(), expectedY);
+            EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetX(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetY(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetX(), expectedX);
+            EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetY(), expectedY);
+            EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetX(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetY(), expectedD);
         }
     }
 }
@@ -219,24 +208,21 @@ HWTEST_F(ShapeMaskAccessorTest, setRoundRectShapeRightBottomTest, TestSize.Level
             auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-            ASSERT_NE(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->roundRect->GetPosition().GetX(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetPosition().GetY(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->roundRect->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetX(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetY(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetX(), expectedX);
-            EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetY(), expectedY);
-            EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetX(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetY(), expectedD);
-            EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetX(), expectedX);
-            EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetY(), expectedY);
-
-            EXPECT_EQ(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
+            auto roundShapeRect = AceType::DynamicCast<ShapeRect>(peer_->shape);
+            ASSERT_NE(roundShapeRect, nullptr);
+            EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetX(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetY(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetX(), expectedX);
+            EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetY(), expectedY);
+            EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetX(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetY(), expectedD);
+            EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetX(), expectedX);
+            EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetY(), expectedY);
         }
     }
 }
@@ -261,14 +247,12 @@ HWTEST_F(ShapeMaskAccessorTest, setCircleShapeXYTest, TestSize.Level1)
             accessor_->setCircleShape(peer_, &circle);
 
             auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-            ASSERT_NE(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->circle->GetPosition().GetX(), expectedX);
-            EXPECT_EQ(peer_->circle->GetPosition().GetY(), expectedY);
-            EXPECT_EQ(peer_->circle->GetRadius(), expectedD);
-            EXPECT_EQ(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY);
+            auto circleShape = AceType::DynamicCast<Circle>(peer_->shape);
+            ASSERT_NE(circleShape, nullptr);
+            EXPECT_EQ(circleShape->GetRadius(), expectedD);
         }
     }
 }
@@ -292,16 +276,14 @@ HWTEST_F(ShapeMaskAccessorTest, setCircleShapeRadiusTest, TestSize.Level1)
         accessor_->setCircleShape(peer_, &circle);
 
         auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-        ASSERT_NE(peer_->circle, nullptr);
-        EXPECT_EQ(peer_->circle->GetPosition().GetX(), expectedD);
-        EXPECT_EQ(peer_->circle->GetPosition().GetY(), expectedD);
+        ASSERT_NE(peer_->shape, nullptr);
+        EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD);
+        EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD);
+        auto circleShape = AceType::DynamicCast<Circle>(peer_->shape);
+        ASSERT_NE(circleShape, nullptr);
         if (expectedR.IsValid()) {
-            EXPECT_EQ(peer_->circle->GetRadius(), expectedR);
+            EXPECT_EQ(circleShape->GetRadius(), expectedR);
         }
-        EXPECT_EQ(peer_->rect, nullptr);
-        EXPECT_EQ(peer_->roundRect, nullptr);
-        EXPECT_EQ(peer_->oval, nullptr);
-        EXPECT_EQ(peer_->path, std::nullopt);
     }
 }
 
@@ -327,15 +309,11 @@ HWTEST_F(ShapeMaskAccessorTest, setOvalShapeTopLeftTest, TestSize.Level1)
 
             auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value());
             auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value());
-            ASSERT_NE(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->oval->GetPosition().GetX(), expectedX);
-            EXPECT_EQ(peer_->oval->GetPosition().GetY(), expectedY);
-            EXPECT_EQ(peer_->oval->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->oval->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
         }
     }
 }
@@ -363,15 +341,11 @@ HWTEST_F(ShapeMaskAccessorTest, setOvalShapeRightBottomTest, TestSize.Level1)
             auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE);
             auto expectedD = Dimension(DEFAULT_FLOAT_VALUE);
-            ASSERT_NE(peer_->oval, nullptr);
-            EXPECT_EQ(peer_->oval->GetPosition().GetX(), expectedD);
-            EXPECT_EQ(peer_->oval->GetPosition().GetY(), expectedD);
-            EXPECT_EQ(peer_->oval->GetWidth(), expectedW);
-            EXPECT_EQ(peer_->oval->GetHeight(), expectedH);
-            EXPECT_EQ(peer_->rect, nullptr);
-            EXPECT_EQ(peer_->roundRect, nullptr);
-            EXPECT_EQ(peer_->circle, nullptr);
-            EXPECT_EQ(peer_->path, std::nullopt);
+            ASSERT_NE(peer_->shape, nullptr);
+            EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD);
+            EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD);
+            EXPECT_EQ(peer_->shape->GetWidth(), expectedW);
+            EXPECT_EQ(peer_->shape->GetHeight(), expectedH);
         }
     }
 }
@@ -391,12 +365,10 @@ HWTEST_F(ShapeMaskAccessorTest, setCommandPathTest, TestSize.Level1)
         };
         accessor_->setCommandPath(peer_, &path);
 
-        ASSERT_NE(peer_->path, std::nullopt);
-        EXPECT_EQ(peer_->path.value(), expectedP);
-        EXPECT_EQ(peer_->rect, nullptr);
-        EXPECT_EQ(peer_->roundRect, nullptr);
-        EXPECT_EQ(peer_->circle, nullptr);
-        EXPECT_EQ(peer_->oval, nullptr);
+        ASSERT_NE(peer_->shape, nullptr);
+        auto pathShape = AceType::DynamicCast<Path>(peer_->shape);
+        ASSERT_NE(pathShape, nullptr);
+        EXPECT_EQ(pathShape->GetValue(), expectedP);
     }
 }