1 /*
2 * Copyright (c) 2022-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
16 #include "screen_sink_trans_test.h"
17
18 #include <chrono>
19
20 #include "dscreen_errcode.h"
21 #include "iconsumer_surface.h"
22 #include "image_sink_processor.h"
23 #include "screen_data_channel_impl.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace DistributedHardware {
29 constexpr static uint32_t VIDEO_DATA_NUM = 480;
SetUpTestCase(void)30 void ScreenSinkTransTest::SetUpTestCase(void) {}
31
TearDownTestCase(void)32 void ScreenSinkTransTest::TearDownTestCase(void) {}
33
SetUp(void)34 void ScreenSinkTransTest::SetUp(void)
35 {
36 peerDevId_ = "test";
37 sptr<IConsumerSurface> cSurface = IConsumerSurface::Create("test");
38 sptr<IBufferProducer> bp = cSurface->GetProducer();
39 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(bp);
40 trans_ = std::make_shared<ScreenSinkTrans>();
41 trans_->imageProcessor_ = std::make_shared<ImageSinkProcessor>();
42 trans_->screenChannel_ = std::make_shared<ScreenDataChannelImpl>(peerDevId_);
43 trans_->decoderSurface_ = pSurface;
44 trans_->transCallback_ = std::make_shared<MockIScreenSinkTransCallback>();
45
46 param_.screenWidth_ = VIDEO_DATA_NUM;
47 param_.screenHeight_ = VIDEO_DATA_NUM;
48 param_.videoWidth_ = VIDEO_DATA_NUM;
49 param_.videoHeight_ = VIDEO_DATA_NUM;
50 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
51 param_.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
52 param_.fps_ = FPS;
53 }
54
TearDown(void)55 void ScreenSinkTransTest::TearDown(void)
56 {
57 if (trans_ != nullptr) {
58 trans_->Stop();
59 trans_->Release();
60 }
61 }
62
63 /**
64 * @tc.name: setup_test_001
65 * @tc.desc: Verify the SetUp function failed.
66 * @tc.type: FUNC
67 * @tc.require: Issue Number
68 */
69 HWTEST_F(ScreenSinkTransTest, setup_test_001, TestSize.Level1)
70 {
71 param_.screenWidth_ = WIDTH_INVALID;
72 param_.screenHeight_ = HEIGHT_INVALID;
73 param_.videoWidth_ = WIDTH_INVALID;
74 param_.videoHeight_ = HEIGHT_INVALID;
75
76 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, trans_->SetUp(param_, param_, peerDevId_));
77 }
78
79 /**
80 * @tc.name: register_processor_listener_001
81 * @tc.desc: Verify the RegisterChannelListener function success.
82 * @tc.type: FUNC
83 * @tc.require: Issue Number
84 */
85 HWTEST_F(ScreenSinkTransTest, register_processor_listener_001, TestSize.Level1)
86 {
87 EXPECT_EQ(DH_SUCCESS, trans_->RegisterProcessorListener(param_, param_, peerDevId_));
88 }
89
90 /**
91 * @tc.name: register_processor_listener_002
92 * @tc.desc: Verify the RegisterChannelListener function success.
93 * @tc.type: FUNC
94 * @tc.require: Issue Number
95 */
96 HWTEST_F(ScreenSinkTransTest, register_processor_listener_002, TestSize.Level1)
97 {
98 trans_->imageProcessor_ = nullptr;
99 int32_t ret = trans_->RegisterProcessorListener(param_, param_, peerDevId_);
100 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret);
101 }
102
103 /**
104 * @tc.name: release_test_001
105 * @tc.desc: Verify the Release function success.
106 * @tc.type: FUNC
107 * @tc.require: Issue Number
108 */
109 HWTEST_F(ScreenSinkTransTest, release_test_001, TestSize.Level1)
110 {
111 EXPECT_EQ(DH_SUCCESS, trans_->Release());
112 }
113
114 /**
115 * @tc.name: release_test_002
116 * @tc.desc: Verify the Release function fail.
117 * @tc.type: FUNC
118 * @tc.require: Issue Number
119 */
120 HWTEST_F(ScreenSinkTransTest, release_test_002, TestSize.Level1)
121 {
122 trans_->imageProcessor_ = nullptr;
123 EXPECT_EQ(DH_SUCCESS, trans_->Release());
124 }
125
126 /**
127 * @tc.name: start_test_002
128 * @tc.desc: Verify the Start function fail.
129 * @tc.type: FUNC
130 * @tc.require: Issue Number
131 */
132 HWTEST_F(ScreenSinkTransTest, start_test_002, TestSize.Level1)
133 {
134 trans_->imageProcessor_ = nullptr;
135 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, trans_->Start());
136 }
137
138 /**
139 * @tc.name: stop_test_002
140 * @tc.desc: Verify the Stop function success.
141 * @tc.type: FUNC
142 * @tc.require: Issue Number
143 */
144 HWTEST_F(ScreenSinkTransTest, stop_test_002, TestSize.Level1)
145 {
146 EXPECT_EQ(DH_SUCCESS, trans_->Stop());
147 }
148
149 /**
150 * @tc.name: register_state_callback_test_001
151 * @tc.desc: Verify the RegisterStateCallback function success.
152 * @tc.type: FUNC
153 * @tc.require: Issue Number
154 */
155 HWTEST_F(ScreenSinkTransTest, register_state_callback_test_001, TestSize.Level1)
156 {
157 std::shared_ptr<IScreenSinkTransCallback> callback =
158 std::make_shared<MockIScreenSinkTransCallback>();
159 EXPECT_EQ(DH_SUCCESS, trans_->RegisterStateCallback(callback));
160 }
161
162 /**
163 * @tc.name: register_state_callback_test_002
164 * @tc.desc: Verify the RegisterStateCallback function fail.
165 * @tc.type: FUNC
166 * @tc.require: Issue Number
167 */
168 HWTEST_F(ScreenSinkTransTest, register_state_callback_test_002, TestSize.Level1)
169 {
170 std::shared_ptr<IScreenSinkTransCallback> callback = nullptr;
171 trans_->transCallback_ = callback;
172 trans_->OnProcessorStateNotify(DH_SUCCESS);
173 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, trans_->RegisterStateCallback(callback));
174 }
175
176 /**
177 * @tc.name: set_image_surface_test_001
178 * @tc.desc: Verify the SetImageSurface function success.
179 * @tc.type: FUNC
180 * @tc.require: Issue Number
181 */
182 HWTEST_F(ScreenSinkTransTest, set_image_surface_test_001, TestSize.Level1)
183 {
184 sptr<IConsumerSurface> surface = IConsumerSurface::Create("test");
185 sptr<IBufferProducer> bufferProducer = surface->GetProducer();
186 sptr<Surface> producerSurface = Surface::CreateSurfaceAsProducer(bufferProducer);
187 EXPECT_EQ(DH_SUCCESS, trans_->SetImageSurface(producerSurface));
188 }
189
190 /**
191 * @tc.name: set_image_surface_test_002
192 * @tc.desc: Verify the SetImageSurface function fail.
193 * @tc.type: FUNC
194 * @tc.require: Issue Number
195 */
196 HWTEST_F(ScreenSinkTransTest, set_image_surface_test_002, TestSize.Level1)
197 {
198 trans_->transCallback_ = std::make_shared<MockIScreenSinkTransCallback>();
199 trans_->OnSessionClosed();
200 trans_->OnProcessorStateNotify(DH_SUCCESS);
201 trans_->OnDataReceived(nullptr);
202 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, trans_->SetImageSurface(nullptr));
203 }
204
205 /**
206 * @tc.name: check_trans_param_test_001
207 * @tc.desc: Verify the CheckTransParam function.
208 * @tc.type: FUNC
209 * @tc.require: Issue Number
210 */
211 HWTEST_F(ScreenSinkTransTest, check_trans_param_test_001, TestSize.Level1)
212 {
213 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, trans_->CheckTransParam(param_, param_, ""));
214
215 param_.codecType_ = VIDEO_CODEC_TYPE_INVALID;
216 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, trans_->CheckTransParam(param_, param_, peerDevId_));
217
218 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
219 param_.videoFormat_ = VIDEO_DATA_FORMAT_INVALID;
220 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, trans_->CheckTransParam(param_, param_, peerDevId_));
221
222 param_.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
223 param_.videoWidth_ = WIDTH_INVALID;
224 param_.videoHeight_ = HEIGHT_INVALID;
225 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, trans_->CheckTransParam(param_, param_, peerDevId_));
226
227 param_.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
228 param_.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
229 param_.screenWidth_ = WIDTH_INVALID;
230 param_.screenHeight_ = HEIGHT_INVALID;
231 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, trans_->CheckTransParam(param_, param_, peerDevId_));
232
233 param_.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
234 param_.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
235 EXPECT_EQ(DH_SUCCESS, trans_->CheckTransParam(param_, param_, peerDevId_));
236 }
237 } // namespace DistributedHardware
238 } // namespace OHOS
239