diff --git a/window_scene/test/unittest/BUILD.gn b/window_scene/test/unittest/BUILD.gn
index 8a78b73dbb3a05b77d8779bb247515ad72f03674..3bfeff8c06872b929ffb7b9dd89f0ba511c767d5 100644
--- a/window_scene/test/unittest/BUILD.gn
+++ b/window_scene/test/unittest/BUILD.gn
@@ -21,6 +21,7 @@ group("unittest") {
   deps = [
     ":ws_ability_info_manager_test",
     ":ws_anomaly_detection_test",
+    ":ws_compatible_mode_property_new_test",
     ":ws_compatible_mode_property_test",
     ":ws_dfx_hisysevent_test",
     ":ws_distributed_client_test",
@@ -960,6 +961,16 @@ ohos_unittest("ws_window_session_property_test") {
   external_deps = test_external_deps
 }
 
+ohos_unittest("ws_compatible_mode_property_new_test") {
+  module_out_path = module_out_path
+
+  sources = [ "compatible_mode_property_new_test.cpp" ]
+
+  deps = [ ":ws_unittest_common" ]
+
+  external_deps = test_external_deps
+}
+
 ohos_unittest("ws_compatible_mode_property_test") {
   module_out_path = module_out_path
 
diff --git a/window_scene/test/unittest/compatible_mode_property_new_test.cpp b/window_scene/test/unittest/compatible_mode_property_new_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..71cf997dc69cd11bdf3e21b9f37360fab430ddc4
--- /dev/null
+++ b/window_scene/test/unittest/compatible_mode_property_new_test.cpp
@@ -0,0 +1,688 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "window_session_property.h"
+
+using namespace testing;
+using namespace testing::ext;
+
+namespace OHOS {
+namespace Rosen {
+
+class CompatibleModePropertyNewTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+};
+
+void CompatibleModePropertyNewTest::SetUpTestCase() {}
+
+void CompatibleModePropertyNewTest::TearDownTestCase() {}
+
+namespace {
+/**
+ * @tc.name: SetIsAdaptToImmersive01
+ * @tc.desc: SetIsAdaptToImmersive01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToImmersive01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToImmersive(true);
+    EXPECT_EQ(property->isAdaptToImmersive_, true);
+}
+
+/**
+ * @tc.name: SetIsAdaptToImmersive02
+ * @tc.desc: SetIsAdaptToImmersive02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToImmersive02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToImmersive(false);
+    EXPECT_EQ(property->isAdaptToImmersive_, false);
+}
+
+/**
+ * @tc.name: IsAdaptToImmersive01
+ * @tc.desc: IsAdaptToImmersive01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToImmersive01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToImmersive_ = false;
+    EXPECT_EQ(property->IsAdaptToImmersive(), false);
+}
+
+/**
+ * @tc.name: IsAdaptToImmersive02
+ * @tc.desc: IsAdaptToImmersive02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToImmersive02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToImmersive_ = true;
+    EXPECT_EQ(property->IsAdaptToImmersive(), true);
+}
+
+/**
+ * @tc.name: SetIsAdaptToEventMapping01
+ * @tc.desc: SetIsAdaptToEventMapping01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToEventMapping01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToEventMapping(false);
+    EXPECT_EQ(property->isAdaptToEventMapping_, false);
+}
+
+/**
+ * @tc.name: SetIsAdaptToEventMapping02
+ * @tc.desc: SetIsAdaptToEventMapping02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToEventMapping02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToEventMapping(true);
+    EXPECT_EQ(property->isAdaptToEventMapping_, true);
+}
+
+/**
+ * @tc.name: IsAdaptToEventMapping01
+ * @tc.desc: IsAdaptToEventMapping01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToEventMapping01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToEventMapping_ = false;
+    EXPECT_EQ(property->IsAdaptToEventMapping(), false);
+}
+
+/**
+ * @tc.name: IsAdaptToEventMapping02
+ * @tc.desc: IsAdaptToEventMapping02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToEventMapping02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToEventMapping_ = true;
+    EXPECT_EQ(property->IsAdaptToEventMapping(), true);
+}
+
+/**
+ * @tc.name: SetIsAdaptToProportionalScale01
+ * @tc.desc: SetIsAdaptToProportionalScale01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToProportionalScale01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToProportionalScale(true);
+    EXPECT_EQ(property->isAdaptToProportionalScale_, true);
+}
+
+/**
+ * @tc.name: SetIsAdaptToProportionalScale02
+ * @tc.desc: SetIsAdaptToProportionalScale02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToProportionalScale02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToProportionalScale(false);
+    EXPECT_EQ(property->isAdaptToProportionalScale_, false);
+}
+
+/**
+ * @tc.name: IsAdaptToProportionalScale01
+ * @tc.desc: IsAdaptToProportionalScale01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToProportionalScale01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToProportionalScale_ = false;
+    EXPECT_EQ(property->IsAdaptToProportionalScale(), false);
+}
+
+/**
+ * @tc.name: IsAdaptToProportionalScale02
+ * @tc.desc: IsAdaptToProportionalScale02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToProportionalScale02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToProportionalScale_ = true;
+    EXPECT_EQ(property->IsAdaptToProportionalScale(), true);
+}
+
+/**
+ * @tc.name: SetIsAdaptToBackButton01
+ * @tc.desc: SetIsAdaptToBackButton01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToBackButton01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToBackButton(true);
+    EXPECT_EQ(property->isAdaptToBackButton_, true);
+}
+
+/**
+ * @tc.name: SetIsAdaptToBackButton02
+ * @tc.desc: SetIsAdaptToBackButton02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToBackButton02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToBackButton(false);
+    EXPECT_EQ(property->isAdaptToBackButton_, false);
+}
+
+/**
+ * @tc.name: IsAdaptToBackButton01
+ * @tc.desc: IsAdaptToBackButton01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToBackButton01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToBackButton_ = false;
+    EXPECT_EQ(property->IsAdaptToBackButton(), false);
+}
+
+/**
+ * @tc.name: IsAdaptToBackButton02
+ * @tc.desc: IsAdaptToBackButton02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToBackButton02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToBackButton_ = true;
+    EXPECT_EQ(property->IsAdaptToBackButton(), true);
+}
+
+/**
+*@tc.name: SetIsAdaptToDragScale01
+*@tc.desc: SetIsAdaptToDragScale01
+*@tc.type: FUNC
+*/
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToDragScale01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToDragScale(true);
+    EXPECT_EQ(property->IsAdaptToDragScale(), true);
+}
+
+/**
+*@tc.name: SetIsAdaptToDragScale02
+*@tc.desc: SetIsAdaptToDragScale02
+*@tc.type: FUNC
+*/
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToDragScale02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToDragScale(false);
+    EXPECT_EQ(property->IsAdaptToDragScale(), false);
+}
+
+/**
+*@tc.name: IsAdaptToDragScale01
+*@tc.desc: IsAdaptToDragScale01
+*@tc.type: FUNC
+*/
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToDragScale01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToDragScale(false);
+    EXPECT_EQ(property->IsAdaptToDragScale(), false);
+}
+
+/**
+*@tc.name: IsAdaptToDragScale02
+*@tc.desc: IsAdaptToDragScale02
+*@tc.type: FUNC
+*/
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToDragScale02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToDragScale(true);
+    EXPECT_EQ(property->IsAdaptToDragScale(), true);
+}
+
+/**
+ * @tc.name: SetDisableDragResize01
+ * @tc.desc: SetDisableDragResize01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetDisableDragResize01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetDisableDragResize(true);
+    EXPECT_EQ(property->disableDragResize_, true);
+}
+
+/**
+ * @tc.name: SetDisableDragResize02
+ * @tc.desc: SetDisableDragResize02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetDisableDragResize02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetDisableDragResize(false);
+    EXPECT_EQ(property->disableDragResize_, false);
+}
+
+/**
+ * @tc.name: IsDragResizeDisabled01
+ * @tc.desc: IsDragResizeDisabled01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsDragResizeDisabled01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->disableDragResize_ = false;
+    EXPECT_EQ(property->IsDragResizeDisabled(), false);
+}
+
+/**
+ * @tc.name: IsDragResizeDisabled02
+ * @tc.desc: IsDragResizeDisabled02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsDragResizeDisabled02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->disableDragResize_ = true;
+    EXPECT_EQ(property->IsDragResizeDisabled(), true);
+}
+
+/**
+ * @tc.name: SetDisableResizeWithDpi01
+ * @tc.desc: SetDisableResizeWithDpi01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetDisableResizeWithDpi01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetDisableResizeWithDpi(true);
+    EXPECT_EQ(property->disableResizeWithDpi_, true);
+}
+
+/**
+ * @tc.name: SetDisableResizeWithDpi02
+ * @tc.desc: SetDisableResizeWithDpi02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetDisableResizeWithDpi02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetDisableResizeWithDpi(false);
+    EXPECT_EQ(property->disableResizeWithDpi_, false);
+}
+
+/**
+ * @tc.name: IsResizeWithDpiDisabled01
+ * @tc.desc: IsResizeWithDpiDisabled01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsResizeWithDpiDisabled01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->disableResizeWithDpi_ = false;
+    EXPECT_EQ(property->IsResizeWithDpiDisabled(), false);
+}
+
+/**
+ * @tc.name: IsResizeWithDpiDisabled02
+ * @tc.desc: IsResizeWithDpiDisabled02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsResizeWithDpiDisabled02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->disableResizeWithDpi_ = true;
+    EXPECT_EQ(property->IsResizeWithDpiDisabled(), true);
+}
+
+/**
+ * @tc.name: SetDisableFullScreen01
+ * @tc.desc: SetDisableFullScreen01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetDisableFullScreen01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetDisableFullScreen(true);
+    EXPECT_EQ(property->disableFullScreen_, true);
+}
+
+/**
+ * @tc.name: SetDisableFullScreen02
+ * @tc.desc: SetDisableFullScreen02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetDisableFullScreen02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetDisableFullScreen(false);
+    EXPECT_EQ(property->disableFullScreen_, false);
+}
+
+/**
+ * @tc.name: IsFullScreenDisabled01
+ * @tc.desc: IsFullScreenDisabled01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsFullScreenDisabled01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->disableFullScreen_ = false;
+    EXPECT_EQ(property->IsFullScreenDisabled(), false);
+}
+
+/**
+ * @tc.name: IsFullScreenDisabled02
+ * @tc.desc: IsFullScreenDisabled02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsFullScreenDisabled02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->disableFullScreen_ = true;
+    EXPECT_EQ(property->IsFullScreenDisabled(), true);
+}
+
+/**
+ * @tc.name: SetDisableWindowLimit01
+ * @tc.desc: SetDisableWindowLimit01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetDisableWindowLimit01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetDisableWindowLimit(true);
+    EXPECT_EQ(property->disableWindowLimit_, true);
+}
+
+/**
+ * @tc.name: SetDisableWindowLimit02
+ * @tc.desc: SetDisableWindowLimit02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetDisableWindowLimit02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetDisableWindowLimit(false);
+    EXPECT_EQ(property->disableWindowLimit_, false);
+}
+
+/**
+ * @tc.name: IsWindowLimitDisabled01
+ * @tc.desc: IsWindowLimitDisabled01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsWindowLimitDisabled01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->disableWindowLimit_ = false;
+    EXPECT_EQ(property->IsWindowLimitDisabled(), false);
+}
+
+/**
+ * @tc.name: IsWindowLimitDisabled02
+ * @tc.desc: IsWindowLimitDisabled02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsWindowLimitDisabled02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->disableWindowLimit_ = true;
+    EXPECT_EQ(property->IsWindowLimitDisabled(), true);
+}
+
+/**
+ * @tc.name: SetDisableDecorFullscreen01
+ * @tc.desc: SetDisableDecorFullscreen01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetDisableDecorFullscreen01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetDisableDecorFullscreen(false);
+    EXPECT_EQ(property->disableDecorFullscreen_, false);
+}
+
+/**
+ * @tc.name: SetDisableDecorFullscreen02
+ * @tc.desc: SetDisableDecorFullscreen02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetDisableDecorFullscreen02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetDisableDecorFullscreen(true);
+    EXPECT_EQ(property->disableDecorFullscreen_, true);
+}
+
+/**
+ * @tc.name: IsDecorFullscreenDisabled01
+ * @tc.desc: IsDecorFullscreenDisabled01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsDecorFullscreenDisabled01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->disableDecorFullscreen_ = true;
+    EXPECT_EQ(property->IsDecorFullscreenDisabled(), true);
+}
+
+/**
+ * @tc.name: IsDecorFullscreenDisabled02
+ * @tc.desc: IsDecorFullscreenDisabled02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsDecorFullscreenDisabled02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->disableDecorFullscreen_ = false;
+    EXPECT_EQ(property->IsDecorFullscreenDisabled(), false);
+}
+
+/**
+ * @tc.name: SetIsAdaptToSimulationScale01
+ * @tc.desc: SetIsAdaptToSimulationScale01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToSimulationScale01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToSimulationScale(true);
+    EXPECT_EQ(property->isAdaptToSimulationScale_, true);
+}
+
+/**
+ * @tc.name: SetIsAdaptToSimulationScale02
+ * @tc.desc: SetIsAdaptToSimulationScale02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToSimulationScale02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToSimulationScale(false);
+    EXPECT_EQ(property->isAdaptToSimulationScale_, false);
+}
+
+/**
+ * @tc.name: IsAdaptToSimulationScale01
+ * @tc.desc: IsAdaptToSimulationScale01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToSimulationScale01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToSimulationScale_ = false;
+    EXPECT_EQ(property->IsAdaptToSimulationScale(), false);
+}
+
+/**
+ * @tc.name: IsAdaptToSimulationScale02
+ * @tc.desc: IsAdaptToSimulationScale02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToSimulationScale02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToSimulationScale_ = true;
+    EXPECT_EQ(property->IsAdaptToSimulationScale(), true);
+}
+
+/**
+ * @tc.name: CopyFrom01
+ * @tc.desc: CopyFrom01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, CopyFrom01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    sptr<CompatibleModeProperty> copyProperty = nullptr;
+    property->CopyFrom(copyProperty);
+    EXPECT_EQ(property->IsAdaptToSimulationScale(), false);
+}
+
+/**
+ * @tc.name: CopyFrom02
+ * @tc.desc: CopyFrom02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, CopyFrom02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    copyProperty = sptr<CompatibleModeProperty>::MakeSptr();
+    copyProperty->SetIsAdaptToSimulationScale(true);
+    property->CopyFrom(copyProperty);
+    EXPECT_EQ(property->IsAdaptToSimulationScale(), true);
+}
+
+/**
+ * @tc.name: SetIsSupportRotateFullScreen01
+ * @tc.desc: SetIsSupportRotateFullScreen01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsSupportRotateFullScreen01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsSupportRotateFullScreen(true);
+    EXPECT_EQ(property->isSupportRotateFullScreen_, true);
+}
+
+/**
+ * @tc.name: SetIsSupportRotateFullScreen02
+ * @tc.desc: SetIsSupportRotateFullScreen02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsSupportRotateFullScreen02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsSupportRotateFullScreen(false);
+    EXPECT_EQ(property->isSupportRotateFullScreen_, false);
+}
+
+/**
+ * @tc.name: IsSupportRotateFullScreen01
+ * @tc.desc: IsSupportRotateFullScreen01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsSupportRotateFullScreen01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isSupportRotateFullScreen_ = false;
+    EXPECT_EQ(property->IsSupportRotateFullScreen(), false);
+}
+
+/**
+ * @tc.name: IsSupportRotateFullScreen02
+ * @tc.desc: IsSupportRotateFullScreen02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsSupportRotateFullScreen02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isSupportRotateFullScreen_ = true;
+    EXPECT_EQ(property->IsSupportRotateFullScreen(), true);
+}
+
+/**
+ * @tc.name: SetIsAdaptToSubWindow01
+ * @tc.desc: SetIsAdaptToSubWindow01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToSubWindow01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToSubWindow(true);
+    EXPECT_EQ(property->isAdaptToSubWindow_, true);
+}
+
+/**
+ * @tc.name: SetIsAdaptToSubWindow02
+ * @tc.desc: SetIsAdaptToSubWindow02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, SetIsAdaptToSubWindow02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->SetIsAdaptToSubWindow(false);
+    EXPECT_EQ(property->isAdaptToSubWindow_, false);
+}
+
+/**
+ * @tc.name: IsAdaptToSubWindow01
+ * @tc.desc: IsAdaptToSubWindow01
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToSubWindow01, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToSubWindow_ = false;
+    EXPECT_EQ(property->IsAdaptToSubWindow(), false);
+}
+
+/**
+ * @tc.name: IsAdaptToSubWindow02
+ * @tc.desc: IsAdaptToSubWindow02
+ * @tc.type: FUNC
+ */
+HWTEST_F(CompatibleModePropertyNewTest, IsAdaptToSubWindow02, TestSize.Level1)
+{
+    sptr<CompatibleModeProperty> property = sptr<CompatibleModeProperty>::MakeSptr();
+    property->isAdaptToSubWindow_ = true;
+    EXPECT_EQ(property->IsAdaptToSubWindow(), true);
+}
+} // namespace
+} // namespace Rosen
+} // namespace OHOS