1 /*
2  * Copyright (c) 2023-2024 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 #include "screen_decision_center_test.h"
16 #include "dscreen_errcode.h"
17 #include "surface_type.h"
18 #include "iconsumer_surface.h"
19 #include "iimage_source_processor.h"
20 #include "iimage_source_processor_listener.h"
21 #include "jpeg_image_processor.h"
22 #include "screen_source_trans.h"
23 using namespace testing;
24 using namespace testing::ext;
25 
26 namespace OHOS {
27 namespace DistributedHardware {
SetUpTestCase(void)28 void ScreenDecisionCenterTest::SetUpTestCase(void) {}
29 
TearDownTestCase(void)30 void ScreenDecisionCenterTest::TearDownTestCase(void) {}
31 
SetUp(void)32 void ScreenDecisionCenterTest::SetUp(void)
33 {
34     param_.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
35     param_.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
36     param_.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
37     param_.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
38     param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
39     param_.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
40     decision = std::make_shared<ScreenDecisionCenter>(param_);
41 }
42 
TearDown(void)43 void ScreenDecisionCenterTest::TearDown(void)
44 {
45     if (decision != nullptr) {
46         decision = nullptr;
47     }
48 }
49 
50 /**
51  * @tc.name: IsDirtyRectValid_001
52  * @tc.desc: Verify the IsDirtyRectValid function.
53  * @tc.type: FUNC
54  * @tc.require: Issue Number
55  */
56 HWTEST_F(ScreenDecisionCenterTest, IsDirtyRectValid_001, TestSize.Level1)
57 {
58     std::vector<OHOS::Rect> damages;
59     int32_t ret = decision->IsDirtyRectValid(damages);
60     EXPECT_EQ(false, ret);
61 }
62 
63 /**
64  * @tc.name: IsDirtyRectValid_002
65  * @tc.desc: Verify the IsDirtyRectValid function.
66  * @tc.type: FUNC
67  * @tc.require: Issue Number
68  */
69 HWTEST_F(ScreenDecisionCenterTest, IsDirtyRectValid_002, TestSize.Level1)
70 {
71     std::vector<OHOS::Rect> damages;
72     OHOS::Rect damage = {-1, 0, 0, 0};
73     damages.push_back(damage);
74     int32_t ret = decision->IsDirtyRectValid(damages);
75     EXPECT_EQ(false, ret);
76 
77     damages.clear();
78     decision->configParam_.SetScreenWidth(1);
79     damage = {2, 0, 0, 0};
80     damages.push_back(damage);
81     ret = decision->IsDirtyRectValid(damages);
82     EXPECT_EQ(false, ret);
83 
84     damages.clear();
85     decision->configParam_.SetScreenHeight(1);
86     damage = {1, -1, 0, 0};
87     damages.push_back(damage);
88     ret = decision->IsDirtyRectValid(damages);
89     EXPECT_EQ(false, ret);
90 
91     damages.clear();
92     damage = {1, 2, 0, 0};
93     damages.push_back(damage);
94     ret = decision->IsDirtyRectValid(damages);
95     EXPECT_EQ(false, ret);
96 
97     damages.clear();
98     damage = {1, 0, 0, 0};
99     damages.push_back(damage);
100     ret = decision->IsDirtyRectValid(damages);
101     EXPECT_EQ(false, ret);
102 
103     damages.clear();
104     damage = {0, 1, 0, 0};
105     damages.push_back(damage);
106     ret = decision->IsDirtyRectValid(damages);
107     EXPECT_EQ(true, ret);
108 }
109 
110 /**
111  * @tc.name: IsDirtyRectValid_003
112  * @tc.desc: Verify the IsDirtyRectValid function.
113  * @tc.type: FUNC
114  * @tc.require: Issue Number
115  */
116 HWTEST_F(ScreenDecisionCenterTest, IsDirtyRectValid_003, TestSize.Level1)
117 {
118     std::vector<OHOS::Rect> damages;
119     decision->configParam_.SetScreenWidth(1);
120     decision->configParam_.SetScreenHeight(1);
121     OHOS::Rect damage = {0, 0, -1, 0};
122     damages.push_back(damage);
123     int32_t ret = decision->IsDirtyRectValid(damages);
124     EXPECT_EQ(false, ret);
125 
126     damages.clear();
127     damage = {0, 0, 10, 0};
128     damages.push_back(damage);
129     ret = decision->IsDirtyRectValid(damages);
130     EXPECT_EQ(false, ret);
131 
132     damages.clear();
133     damage = {0, 0, 0, -1};
134     damages.push_back(damage);
135     ret = decision->IsDirtyRectValid(damages);
136     EXPECT_EQ(false, ret);
137 
138     damages.clear();
139     damage = {0, 0, 0, 10};
140     damages.push_back(damage);
141     ret = decision->IsDirtyRectValid(damages);
142     EXPECT_EQ(false, ret);
143 
144     damages.clear();
145     damage = {0, 0, 0, 0};
146     damages.push_back(damage);
147     ret = decision->IsDirtyRectValid(damages);
148     EXPECT_EQ(true, ret);
149 }
150 
151 /**
152  * @tc.name: IsDirtyRectValid_005
153  * @tc.desc: Verify the IsDirtyRectValid function.
154  * @tc.type: FUNC
155  * @tc.require: Issue Number
156  */
157 HWTEST_F(ScreenDecisionCenterTest, IsDirtyRectValid_004, TestSize.Level1)
158 {
159     std::vector<OHOS::Rect> damages;
160     OHOS::Rect damage = {2, 2, 2, 2};
161     damages.push_back(damage);
162     damages.push_back(damage);
163     int32_t ret = decision->IsDirtyRectValid(damages);
164     EXPECT_EQ(true, ret);
165 }
166 
167 /**
168  * @tc.name: JudgeDirtyThreshold_001
169  * @tc.desc: Verify the JudgeDirtyThreshold function.
170  * @tc.type: FUNC
171  * @tc.require: Issue Number
172  */
173 HWTEST_F(ScreenDecisionCenterTest, JudgeDirtyThreshold_001, TestSize.Level1)
174 {
175     std::vector<OHOS::Rect> damages;
176     int32_t ret = decision->JudgeDirtyThreshold(damages);
177     EXPECT_EQ(true, ret);
178 }
179 
180 /**
181  * @tc.name: JudgeDirtyThreshold_002
182  * @tc.desc: Verify the JudgeDirtyThreshold function.
183  * @tc.type: FUNC
184  * @tc.require: Issue Number
185  */
186 HWTEST_F(ScreenDecisionCenterTest, JudgeDirtyThreshold_002, TestSize.Level1)
187 {
188     std::vector<OHOS::Rect> damages;
189     OHOS::Rect damage = {2, 2, 2, 2};
190     damages.push_back(damage);
191     int32_t ret = decision->JudgeDirtyThreshold(damages);
192     EXPECT_EQ(true, ret);
193 }
194 
195 /**
196  * @tc.name: JudgeDirtyThreshold_003
197  * @tc.desc: Verify the JudgeDirtyThreshold function.
198  * @tc.type: FUNC
199  * @tc.require: Issue Number
200  */
201 HWTEST_F(ScreenDecisionCenterTest, JudgeDirtyThreshold_003, TestSize.Level1)
202 {
203     std::vector<OHOS::Rect> damages;
204     OHOS::Rect damage = {0, 0, 2600, 2780};
205     damages.push_back(damage);
206     int32_t ret = decision->JudgeDirtyThreshold(damages);
207     EXPECT_EQ(false, ret);
208 }
209 
210 /**
211  * @tc.name: LimitTime_001
212  * @tc.desc: Verify the LimitTime function.
213  * @tc.type: FUNC
214  * @tc.require: Issue Number
215  */
216 HWTEST_F(ScreenDecisionCenterTest, LimitTime_001, TestSize.Level1)
217 {
218     decision->sendFullTime_ = time(nullptr);
219     int32_t ret = decision->LimitTime(0);
220     EXPECT_EQ(true, ret);
221 }
222 
223 /**
224  * @tc.name: InputBufferImage_001
225  * @tc.desc: Verify the InputBufferImage function.
226  * @tc.type: FUNC
227  * @tc.require: Issue Number
228  */
229 HWTEST_F(ScreenDecisionCenterTest, InputBufferImage_001, TestSize.Level1)
230 {
231     std::vector<OHOS::Rect> damages;
232     sptr<SurfaceBuffer> surfaceBuffer = nullptr;
233     int32_t ret = decision->InputBufferImage(surfaceBuffer, damages);
234     EXPECT_EQ(ERR_DH_SCREEN_SURFACE_BUFFER_INVALIED, ret);
235 }
236 
237 /**
238  * @tc.name: InputBufferImage_002
239  * @tc.desc: Verify the InputBufferImage function.
240  * @tc.type: FUNC
241  * @tc.require: Issue Number
242  */
243 HWTEST_F(ScreenDecisionCenterTest, InputBufferImage_002, TestSize.Level1)
244 {
245     std::vector<OHOS::Rect> damages;
246     sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
247     decision->imageProcessor_ = std::make_shared<ImageSourceProcessorStub>();
248     decision->imageJpeg_ = std::make_shared<JpegImageProcessorStub>(param_);
249     int32_t ret = decision->InputBufferImage(buffer, damages);
250     EXPECT_EQ(DH_SUCCESS, ret);
251 
252     OHOS::Rect damage = {0, 0, 0, 0};
253     damages.push_back(damage);
254     decision->frameCount_ = ScreenDecisionCenter::MIN_SURPPORT_FRAME_COUNT - 1;
255     ret = decision->InputBufferImage(buffer, damages);
256     EXPECT_EQ(DH_SUCCESS, ret);
257 
258     decision->frameCount_ = ScreenDecisionCenter::MIN_SURPPORT_FRAME_COUNT;
259     decision->sendFullTime_ = time(nullptr) - ScreenDecisionCenter::FORCE_FULL_IMAGE_TIME_INTERAL - 1;
260     ret = decision->InputBufferImage(buffer, damages);
261     EXPECT_EQ(DH_SUCCESS, ret);
262 
263     damages.clear();
264     damage = {-1, 0, 0, 0};
265     damages.push_back(damage);
266     decision->sendFullTime_ = time(nullptr);
267     ret = decision->InputBufferImage(buffer, damages);
268     EXPECT_EQ(DH_SUCCESS, ret);
269 
270     damages.clear();
271     damage = {0, 0, 2600, 2780};
272     damages.push_back(damage);
273     decision->sendFullTime_ = time(nullptr);
274     ret = decision->InputBufferImage(buffer, damages);
275     EXPECT_EQ(DH_SUCCESS, ret);
276 }
277 
278 /**
279  * @tc.name: ConfigureDecisionCenter_001
280  * @tc.desc: Verify the ConfigureDecisionCenter function.
281  * @tc.type: FUNC
282  * @tc.require: Issue Number
283  */
284 HWTEST_F(ScreenDecisionCenterTest, ConfigureDecisionCenter_001, TestSize.Level1)
285 {
286     std::shared_ptr<IImageSourceProcessorListener> listener = nullptr;
287     std::shared_ptr<IImageSourceProcessor> imageProcessor = nullptr;
288     int32_t ret = decision->ConfigureDecisionCenter(listener, imageProcessor);
289     EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret);
290 }
291 
292 /**
293  * @tc.name: ConfigureDecisionCenter_002
294  * @tc.desc: Verify the ConfigureDecisionCenter function.
295  * @tc.type: FUNC
296  * @tc.require: Issue Number
297  */
298 HWTEST_F(ScreenDecisionCenterTest, ConfigureDecisionCenter_002, TestSize.Level1)
299 {
300     std::shared_ptr<IImageSourceProcessorListener> listener = std::make_shared<ScreenSourceTrans>();
301     std::shared_ptr<IImageSourceProcessor> imageProcessor = nullptr;
302     int32_t ret = decision->ConfigureDecisionCenter(listener, imageProcessor);
303     EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret);
304 }
305 
306 /**
307  * @tc.name: ConfigureDecisionCenter_003
308  * @tc.desc: Verify the ConfigureDecisionCenter function.
309  * @tc.type: FUNC
310  * @tc.require: Issue Number
311  */
312 HWTEST_F(ScreenDecisionCenterTest, ConfigureDecisionCenter_003, TestSize.Level1)
313 {
314     std::shared_ptr<IImageSourceProcessorListener> listener = std::make_shared<ScreenSourceTrans>();
315     std::shared_ptr<IImageSourceProcessor> imageProcessor = std::make_shared<ImageSourceProcessor>();
316     int32_t ret = decision->ConfigureDecisionCenter(listener, imageProcessor);
317     EXPECT_EQ(DH_SUCCESS, ret);
318 }
319 
320 /**
321  * @tc.name: SetJpegSurface_001
322  * @tc.desc: Verify the SetJpegSurface function.
323  * @tc.type: FUNC
324  * @tc.require: Issue Number
325  */
326 HWTEST_F(ScreenDecisionCenterTest, SetJpegSurface_001, TestSize.Level1)
327 {
328     decision->imageJpeg_ = std::make_shared<JpegImageProcessor>(param_);
329     sptr<Surface> jpegSurface;
330     int32_t ret = decision->SetJpegSurface(jpegSurface);
331     EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret);
332     jpegSurface = IConsumerSurface::Create();
333     ret = decision->SetJpegSurface(jpegSurface);
334     EXPECT_EQ(DH_SUCCESS, ret);
335 }
336 } // namespace DistributedHardware
337 } // namespace OHOS