1 /*
2 * Copyright (C) 2022 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, software
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 <memory>
17 #include <gtest/gtest.h>
18 #include "display_resize_controller.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22 using namespace std;
23
24 namespace OHOS {
25 namespace Accessibility {
26 class UnitTestDisplayResizeListener : public DisplayResizeListener {
27 public:
UnitTestDisplayResizeListener()28 UnitTestDisplayResizeListener() {}
~UnitTestDisplayResizeListener()29 virtual ~UnitTestDisplayResizeListener() {}
30
OnDisplayResized(const DisplayResizeController & controller,const Rect & rect,const float scale,const float centerX,const float centerY)31 void OnDisplayResized(const DisplayResizeController& controller, const Rect& rect, const float scale,
32 const float centerX, const float centerY) override
33 {
34 GTEST_LOG_(INFO) << "UnitTestDisplayResizeListener OnDisplayResized";
35 }
36 };
37
38 class DisplayResizeControllerUnitTest : public ::testing::Test {
39 public:
DisplayResizeControllerUnitTest()40 DisplayResizeControllerUnitTest() {}
~DisplayResizeControllerUnitTest()41 ~DisplayResizeControllerUnitTest() {}
42
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp() override;
46 void TearDown() override;
47
48 shared_ptr<DisplayResizeController> displayResizeController_ = nullptr;
49 };
50
SetUpTestCase()51 void DisplayResizeControllerUnitTest::SetUpTestCase()
52 {
53 GTEST_LOG_(INFO) << "###################### DisplayResizeControllerUnitTest Start ######################";
54 }
55
TearDownTestCase()56 void DisplayResizeControllerUnitTest::TearDownTestCase()
57 {
58 GTEST_LOG_(INFO) << "###################### DisplayResizeControllerUnitTest End ######################";
59 }
60
SetUp()61 void DisplayResizeControllerUnitTest::SetUp()
62 {
63 GTEST_LOG_(INFO) << "UT SetUp";
64 displayResizeController_ = make_shared<DisplayResizeController>(0, 0);
65 }
66
TearDown()67 void DisplayResizeControllerUnitTest::TearDown()
68 {
69 GTEST_LOG_(INFO) << "UT TearDown";
70 displayResizeController_ = nullptr;
71 }
72
73 /**
74 * @tc.number: DisplayResizeController_Unittest_AddListener_001
75 * @tc.name: AddListener
76 * @tc.desc: Test function AddListener
77 */
78 HWTEST_F(DisplayResizeControllerUnitTest, DisplayResizeController_Unittest_AddListener_001, TestSize.Level1)
79 {
80 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_AddListener_001 start";
81
82 std::shared_ptr<DisplayResizeListener> listener = make_shared<UnitTestDisplayResizeListener>();
83 displayResizeController_->AddListener(listener);
84
85 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_AddListener_001 end";
86 }
87
88 /**
89 * @tc.number: DisplayResizeController_Unittest_DeleteListener_001
90 * @tc.name: DeleteListener
91 * @tc.desc: Test function DeleteListener
92 * Delete the listener which hasn't been added.
93 */
94 HWTEST_F(DisplayResizeControllerUnitTest, DisplayResizeController_Unittest_DeleteListener_001, TestSize.Level1)
95 {
96 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_DeleteListener_001 start";
97
98 std::shared_ptr<DisplayResizeListener> listener = make_shared<UnitTestDisplayResizeListener>();
99 EXPECT_FALSE(displayResizeController_->DeleteListener(listener));
100
101 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_DeleteListener_001 end";
102 }
103
104 /**
105 * @tc.number: DisplayResizeController_Unittest_DeleteListener_002
106 * @tc.name: DeleteListener
107 * @tc.desc: Test function DeleteListener
108 * Delete the listener which has been added.
109 */
110 HWTEST_F(DisplayResizeControllerUnitTest, DisplayResizeController_Unittest_DeleteListener_002, TestSize.Level1)
111 {
112 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_DeleteListener_002 start";
113
114 std::shared_ptr<DisplayResizeListener> listener = make_shared<UnitTestDisplayResizeListener>();
115 displayResizeController_->AddListener(listener);
116 EXPECT_TRUE(displayResizeController_->DeleteListener(listener));
117
118 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_DeleteListener_002 end";
119 }
120
121 /**
122 * @tc.number: DisplayResizeController_Unittest_GetCenterX_001
123 * @tc.name: GetCenterX
124 * @tc.desc: Test function GetCenterX
125 */
126 HWTEST_F(DisplayResizeControllerUnitTest, DisplayResizeController_Unittest_GetCenterX_001, TestSize.Level1)
127 {
128 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_GetCenterX_001 start";
129
130 EXPECT_EQ(displayResizeController_->GetCenterX(), 0);
131
132 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_GetCenterX_001 end";
133 }
134
135 /**
136 * @tc.number: DisplayResizeController_Unittest_GetCenterY_001
137 * @tc.name: GetCenterY
138 * @tc.desc: Test function GetCenterY
139 */
140 HWTEST_F(DisplayResizeControllerUnitTest, DisplayResizeController_Unittest_GetCenterY_001, TestSize.Level1)
141 {
142 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_GetCenterY_001 start";
143
144 EXPECT_EQ(displayResizeController_->GetCenterY(), 0);
145
146 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_GetCenterY_001 end";
147 }
148
149 /**
150 * @tc.number: DisplayResizeController_Unittest_GetDisplayResizeRect_001
151 * @tc.name: GetDisplayResizeRect
152 * @tc.desc: Test function GetDisplayResizeRect
153 */
154 HWTEST_F(DisplayResizeControllerUnitTest, DisplayResizeController_Unittest_GetDisplayResizeRect_001, TestSize.Level1)
155 {
156 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_GetDisplayResizeRect_001 start";
157
158 Rect rect = displayResizeController_->GetDisplayResizeRect();
159 EXPECT_EQ(rect.GetLeftTopXScreenPostion(), 1);
160 EXPECT_EQ(rect.GetLeftTopYScreenPostion(), 1);
161
162 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_GetDisplayResizeRect_001 end";
163 }
164
165 /**
166 * @tc.number: DisplayResizeController_Unittest_GetScale_001
167 * @tc.name: GetScale
168 * @tc.desc: Test function GetScale
169 */
170 HWTEST_F(DisplayResizeControllerUnitTest, DisplayResizeController_Unittest_GetScale_001, TestSize.Level1)
171 {
172 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_GetScale_001 start";
173
174 EXPECT_EQ(displayResizeController_->GetScale(), 0);
175
176 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_GetScale_001 end";
177 }
178
179 /**
180 * @tc.number: DisplayResizeController_Unittest_Reset_001
181 * @tc.name: Reset
182 * @tc.desc: Test function Reset
183 */
184 HWTEST_F(DisplayResizeControllerUnitTest, DisplayResizeController_Unittest_Reset_001, TestSize.Level1)
185 {
186 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_Reset_001 start";
187
188 EXPECT_TRUE(displayResizeController_->Reset(1));
189
190 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_Reset_001 end";
191 }
192
193 /**
194 * @tc.number: DisplayResizeController_Unittest_SetCenter_001
195 * @tc.name: SetCenter
196 * @tc.desc: Test function SetCenter
197 */
198 HWTEST_F(DisplayResizeControllerUnitTest, DisplayResizeController_Unittest_SetCenter_001, TestSize.Level1)
199 {
200 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_SetCenter_001 start";
201
202 float centerX = 0;
203 float centerY = 0;
204 bool isShouldAnimate = true;
205
206 EXPECT_TRUE(displayResizeController_->SetCenter(centerX, centerY, isShouldAnimate));
207
208 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_SetCenter_001 end";
209 }
210
211 /**
212 * @tc.number: DisplayResizeController_Unittest_SetScale_001
213 * @tc.name: SetScale
214 * @tc.desc: Test function SetScale
215 */
216 HWTEST_F(DisplayResizeControllerUnitTest, DisplayResizeController_Unittest_SetScale_001, TestSize.Level1)
217 {
218 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_SetScale_001 start";
219
220 float scale = 0;
221 bool isShouldAnimate = true;
222
223 EXPECT_TRUE(displayResizeController_->SetScale(scale, isShouldAnimate));
224
225 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_SetScale_001 end";
226 }
227
228 /**
229 * @tc.number: DisplayResizeController_Unittest_DispatchOnDisplayResized_001
230 * @tc.name: DispatchOnDisplayResized
231 * @tc.desc: Test function DispatchOnDisplayResized
232 */
233 HWTEST_F(DisplayResizeControllerUnitTest,
234 DisplayResizeController_Unittest_DispatchOnDisplayResized_001, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_DispatchOnDisplayResized_001 start";
237
238 Rect rect {};
239 float scale = 1;
240 float centerX = 0;
241 float centerY = 0;
242
243 std::shared_ptr<DisplayResizeListener> listener = make_shared<UnitTestDisplayResizeListener>();
244 displayResizeController_->AddListener(listener);
245
246 displayResizeController_->DispatchOnDisplayResized(rect, scale, centerX, centerY);
247
248 displayResizeController_->DeleteListener(listener);
249 GTEST_LOG_(INFO) << "DisplayResizeController_Unittest_DispatchOnDisplayResized_001 end";
250 }
251 } // namespace Accessibility
252 } // namespace OHOS