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