1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, Hardware
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include <test_header.h>
19 
20 #include "platform/ohos/overdraw/rs_canvas_listener.h"
21 #include "platform/ohos/overdraw/rs_overdraw_controller.h"
22 
23 using namespace testing;
24 using namespace testing::ext;
25 
26 namespace OHOS {
27 namespace Rosen {
28 constexpr uint32_t SIZE1 = 5;
29 constexpr uint32_t SIZE2 = 6;
30 const char* SET_KEY = "overdraw-color";
31 const char* SET_VALUE1 = "1 2 3 4";
32 const char* SET_VALUE2 = "true";
33 class RSOverdrawControllerTest : public testing::Test {
34 public:
35     static void SetUpTestCase();
36     static void TearDownTestCase();
37     void SetUp() override;
38     void TearDown() override;
39 };
40 
SetUpTestCase()41 void RSOverdrawControllerTest::SetUpTestCase() {}
TearDownTestCase()42 void RSOverdrawControllerTest::TearDownTestCase() {}
SetUp()43 void RSOverdrawControllerTest::SetUp() {}
TearDown()44 void RSOverdrawControllerTest::TearDown() {}
45 
46 class MockRSPaintFilterCanvas : public RSPaintFilterCanvas {
47 public:
MockRSPaintFilterCanvas(Drawing::Canvas * canvas)48     explicit MockRSPaintFilterCanvas(Drawing::Canvas *canvas) : RSPaintFilterCanvas(canvas) {}
49     MOCK_METHOD1(DrawRect, void(const Drawing::Rect& rect));
50 };
51 
52 class RSDelegateTest : public RSDelegate {
53 public:
Repaint()54     void Repaint()
55     {
56         return;
57     }
58 };
59 
60 /*
61  * Function: Singleton is single
62  * Type: Function
63  * EnvConditions: N/A
64  * CaseDescription: 1. call GetInstance twice
65  *                  2. check instance should be same
66  */
67 HWTEST_F(RSOverdrawControllerTest, Singleton, Function | SmallTest | Level0)
68 {
69     PART("CaseDescription") {
70         STEP("1. call GetInstance twice") {
71             auto &instance1 = RSOverdrawController::GetInstance();
72             auto &instance2 = RSOverdrawController::GetInstance();
73             STEP("2. check instance should be same") {
74                 STEP_ASSERT_EQ(&instance1, &instance2);
75             }
76         }
77     }
78 }
79 
80 /*
81  * Function: IsEnabled/SetEnable
82  * Type: Function
83  * EnvConditions: N/A
84  * CaseDescription: 1. save IsEnabled as e
85  *                  2. SetEnable !e
86  *                  3. check IsEnabled is !e
87  */
88 HWTEST_F(RSOverdrawControllerTest, Enable, Function | SmallTest | Level0)
89 {
90     PART("CaseDescription") {
91         bool e = false;
92         STEP("1. set enable as fasle") {
93             RSOverdrawController::GetInstance().SetEnable(false);
94             e = RSOverdrawController::GetInstance().IsEnabled();
95             STEP_ASSERT_EQ(e, false);
96         }
97 
98         STEP("2. set enable as false when enable is false") {
99             RSOverdrawController::GetInstance().SetEnable(false);
100             e = RSOverdrawController::GetInstance().IsEnabled();
101             STEP_ASSERT_EQ(e, false);
102         }
103 
104         STEP("3. set enable as true when enable is false") {
105             RSOverdrawController::GetInstance().SetEnable(true);
106             e = RSOverdrawController::GetInstance().IsEnabled();
107             STEP_ASSERT_EQ(e, true);
108         }
109 
110         STEP("4. set enable as true when enable is true") {
111             RSOverdrawController::GetInstance().SetEnable(true);
112             e = RSOverdrawController::GetInstance().IsEnabled();
113             STEP_ASSERT_EQ(e, true);
114         }
115 
116         STEP("5. set enable as false when enable is true") {
117             RSOverdrawController::GetInstance().SetEnable(false);
118             e = RSOverdrawController::GetInstance().IsEnabled();
119             STEP_ASSERT_EQ(e, false);
120         }
121     }
122 }
123 
124 class RSValidCanvasListener : public RSCanvasListener {
125 public:
RSValidCanvasListener(Drawing::Canvas & canvas)126     explicit RSValidCanvasListener(Drawing::Canvas &canvas) : RSCanvasListener(canvas) {}
IsValid() const127     bool IsValid() const override
128     {
129         return true;
130     }
131 
Name() const132     const char *Name() const override
133     {
134         return "RSValidCanvasListener";
135     }
136 };
137 
138 /*
139  * Function: CreateListener in disabled
140  * Type: Function
141  * EnvConditions: RSOverdrawController disabled
142  * CaseDescription: 1. CreateListener<RSCanvasListener>(MockRSPaintFilterCanvas) == nullptr
143  *                  2. CreateListener<RSCanvasListener>(nullptr) == nullptr
144  *                  3. CreateListener<RSValidCanvasListener>(MockRSPaintFilterCanvas) == nullptr
145  */
146 HWTEST_F(RSOverdrawControllerTest, CreateListenerDisable, Function | SmallTest | Level2)
147 {
148     auto &controller = RSOverdrawController::GetInstance();
149     PART("EnvConditions") {
150         controller.SetEnable(false);
151     }
152 
153     PART("CaseDescription") {
154         auto tmpCanvas = std::make_unique<Drawing::Canvas>();
155         std::shared_ptr<RSPaintFilterCanvas> canvas = nullptr;
156         STEP("1. CreateListener<RSCanvasListener>(MockRSPaintFilterCanvas) == nullptr") {
157             auto mockRSPaintFilterCanvas = std::make_shared<MockRSPaintFilterCanvas>(tmpCanvas.get());
158             canvas = mockRSPaintFilterCanvas;
159             auto listener = controller.CreateListener<RSCanvasListener>(canvas.get());
160             STEP_ASSERT_EQ(listener, nullptr);
161         }
162 
163         STEP("2. CreateListener<RSCanvasListener>(nullptr) == nullptr") {
164             canvas = nullptr;
165             auto listener = controller.CreateListener<RSCanvasListener>(canvas.get());
166             STEP_ASSERT_EQ(listener, nullptr);
167         }
168 
169         STEP("3. CreateListener<RSValidCanvasListener>(MockRSPaintFilterCanvas) == nullptr") {
170             auto mockRSPaintFilterCanvas = std::make_shared<MockRSPaintFilterCanvas>(tmpCanvas.get());
171             canvas = mockRSPaintFilterCanvas;
172             auto listener = controller.CreateListener<RSValidCanvasListener>(canvas.get());
173             STEP_ASSERT_EQ(listener, nullptr);
174         }
175     }
176 }
177 
178 /*
179  * Function: CreateListener in enabled
180  * Type: Function
181  * EnvConditions: RSOverdrawController enabled
182  * CaseDescription: 1. CreateListener<RSCanvasListener>(nullptr) == nullptr
183  *                  2. CreateListener<RSCanvasListener>(MockRSPaintFilterCanvas) == nullptr
184  *                  3. CreateListener<RSValidCanvasListener>(MockRSPaintFilterCanvas) != nullptr
185  */
186 HWTEST_F(RSOverdrawControllerTest, CreateListenerEnable, Function | SmallTest | Level2)
187 {
188     auto &controller = RSOverdrawController::GetInstance();
189     PART("EnvConditions") {
190         controller.SetEnable(true);
191     }
192 
193     PART("CaseDescription") {
194         auto tmpCanvas = std::make_unique<Drawing::Canvas>();
195         std::shared_ptr<RSPaintFilterCanvas> canvas = nullptr;
196         STEP("1. CreateListener<RSCanvasListener>(nullptr) == nullptr") {
197             canvas = nullptr;
198             auto listener = controller.CreateListener<RSCanvasListener>(canvas.get());
199             STEP_ASSERT_EQ(listener, nullptr);
200         }
201 
202         STEP("2. CreateListener<RSCanvasListener>(MockRSPaintFilterCanvas) == nullptr") {
203             auto mockRSPaintFilterCanvas = std::make_shared<MockRSPaintFilterCanvas>(tmpCanvas.get());
204             canvas = mockRSPaintFilterCanvas;
205             auto listener = controller.CreateListener<RSCanvasListener>(canvas.get());
206             STEP_ASSERT_EQ(listener, nullptr);
207         }
208 
209         STEP("3. CreateListener<RSValidCanvasListener>(MockRSPaintFilterCanvas) != nullptr") {
210             auto mockRSPaintFilterCanvas = std::make_shared<MockRSPaintFilterCanvas>(tmpCanvas.get());
211             canvas = mockRSPaintFilterCanvas;
212             auto listener = controller.CreateListener<RSValidCanvasListener>(canvas.get());
213             STEP_ASSERT_NE(listener, nullptr);
214         }
215     }
216 }
217 /**
218  * @tc.name: OnColorChangeTest001
219  * @tc.desc: OnColorChange Test
220  * @tc.type:FUNC
221  * @tc.require:issueI9NDED
222  */
223 HWTEST_F(RSOverdrawControllerTest, OnColorChangeTest001, TestSize.Level1)
224 {
225     auto& controller = RSOverdrawController::GetInstance();
226     controller.SetEnable(false);
227     EXPECT_FALSE(controller.IsEnabled());
228     controller.OnColorChange(SET_KEY, SET_VALUE1, &controller);
229 
230     auto colorArrayTest = controller.GetColorArray();
231     auto ColorMap = controller.GetColorMap();
232     EXPECT_EQ(ColorMap.size(), SIZE1);
233     EXPECT_EQ(colorArrayTest.size(), SIZE2);
234 }
235 
236 /**
237  * @tc.name: SwitchFunctionTest002
238  * @tc.desc: SwitchFunctio Test
239  * @tc.type:FUNC
240  * @tc.require:issueI9NDED
241  */
242 HWTEST_F(RSOverdrawControllerTest, SwitchFunctionTest002, TestSize.Level1)
243 {
244     auto& controller = RSOverdrawController::GetInstance();
245     controller.SetEnable(true);
246     EXPECT_TRUE(controller.IsEnabled());
247 
248     std::shared_ptr<RSDelegateTest> delegate = std::make_shared<RSDelegateTest>();
249     EXPECT_TRUE(delegate);
250 
251     controller.SetDelegate(delegate);
252     EXPECT_TRUE(controller.delegate_);
253     controller.SwitchFunction(SET_KEY, SET_VALUE2, &controller);
254     EXPECT_TRUE(controller.IsEnabled());
255     controller.SwitchFunction(SET_KEY, "", &controller);
256     EXPECT_FALSE(controller.IsEnabled());
257 }
258 } // namespace Rosen
259 } // namespace OHOS
260