1 /*
2 * Copyright (c) 2024 Shenzhen Kaihong Digital Industry Development 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 "wfd_rtp_producer_test.h"
17 #include "mock_rtp_pack.h"
18 #include "wfd_media_def.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22 using namespace OHOS::Sharing;
23
24 namespace OHOS {
25 namespace Sharing {
26
SetUpTestCase(void)27 void WfdRtpProducerTest::SetUpTestCase(void)
28 {
29 producer_ = std::make_shared<MockWfdRtpProducer>();
30 listener_ = std::make_shared<MockProducerListener>();
31 }
32
TearDownTestCase(void)33 void WfdRtpProducerTest::TearDownTestCase(void)
34 {
35 producer_ = nullptr;
36 listener_ = nullptr;
37 }
38
SetUp(void)39 void WfdRtpProducerTest::SetUp(void)
40 {
41 producer_->SetProducerListener(listener_);
42 producer_->ValidateUdpClient();
43 }
44
TearDown(void)45 void WfdRtpProducerTest::TearDown(void)
46 {
47 }
48
49 HWTEST_F(WfdRtpProducerTest, SetUdpDataListener_001, TestSize.Level1)
50 {
51 ASSERT_TRUE(producer_ != nullptr);
52
53 producer_->udpClient = std::make_shared<WfdRtpProducer::UdpClient>(true);
54 producer_->udpClient->SetUdpDataListener(producer_);
55 }
56
57 HWTEST_F(WfdRtpProducerTest, OnClientReadData_001, TestSize.Level1)
58 {
59 ASSERT_TRUE(producer_ != nullptr);
60
61 DataBuffer::Ptr buf = std::make_shared<DataBuffer>();
62 char data[100];
63 buf->Assign(data, 100);
64 producer_->udpClient = std::make_shared<WfdRtpProducer::UdpClient>(true);
65 producer_->udpClient->SetUdpDataListener(producer_);
66 producer_->udpClient->OnClientReadData(0, buf);
67 }
68
69 HWTEST_F(WfdRtpProducerTest, OnClientConnect_001, TestSize.Level1)
70 {
71 ASSERT_TRUE(producer_ != nullptr);
72
73 producer_->udpClient = std::make_shared<WfdRtpProducer::UdpClient>(true);
74 producer_->udpClient->OnClientConnect(true);
75 }
76
77 HWTEST_F(WfdRtpProducerTest, ClientSendDataBuffer_001, TestSize.Level1)
78 {
79 ASSERT_TRUE(producer_ != nullptr);
80
81 DataBuffer::Ptr buf = std::make_shared<DataBuffer>();
82 char data[100];
83 buf->Assign(data, 100);
84 producer_->udpClient = std::make_shared<WfdRtpProducer::UdpClient>(true);
85 producer_->udpClient->SendDataBuffer(buf);
86 }
87
88 HWTEST_F(WfdRtpProducerTest, OnClientWriteable_001, TestSize.Level1)
89 {
90 ASSERT_TRUE(producer_ != nullptr);
91
92 producer_->udpClient = std::make_shared<WfdRtpProducer::UdpClient>(true);
93 producer_->udpClient->OnClientWriteable(0);
94 }
95
96 HWTEST_F(WfdRtpProducerTest, OnClientException_001, TestSize.Level1)
97 {
98 ASSERT_TRUE(producer_ != nullptr);
99
100 producer_->udpClient = std::make_shared<WfdRtpProducer::UdpClient>(true);
101 producer_->udpClient->OnClientException(0);
102 }
103
104 HWTEST_F(WfdRtpProducerTest, OnClientClose_001, TestSize.Level1)
105 {
106 ASSERT_TRUE(producer_ != nullptr);
107
108 producer_->udpClient = std::make_shared<WfdRtpProducer::UdpClient>(true);
109 producer_->udpClient->OnClientClose(0);
110 }
111
112 HWTEST_F(WfdRtpProducerTest, ClientStop_001, TestSize.Level1)
113 {
114 ASSERT_TRUE(producer_ != nullptr);
115
116 producer_->udpClient = std::make_shared<WfdRtpProducer::UdpClient>(true);
117 producer_->udpClient->Stop();
118 }
119
120 HWTEST_F(WfdRtpProducerTest, ClientRelease_001, TestSize.Level1)
121 {
122 ASSERT_TRUE(producer_ != nullptr);
123
124 producer_->udpClient = std::make_shared<WfdRtpProducer::UdpClient>(true);
125 producer_->udpClient->Release();
126 }
127
128 HWTEST_F(WfdRtpProducerTest, UpdateOperation_001, TestSize.Level1)
129 {
130 ASSERT_TRUE(producer_ != nullptr);
131 ASSERT_TRUE(listener_ != nullptr);
132
133 EXPECT_CALL(*listener_, OnProducerNotify(_));
134
135 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
136 statusMsg->status = PROSUMER_INIT;
137 producer_->UpdateOperation(statusMsg);
138 }
139
140 HWTEST_F(WfdRtpProducerTest, UpdateOperation_002, TestSize.Level1)
141 {
142 ASSERT_TRUE(producer_ != nullptr);
143 ASSERT_TRUE(listener_ != nullptr);
144
145 EXPECT_CALL(*listener_, OnProducerNotify(_));
146
147 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
148 statusMsg->status = PROSUMER_START;
149 producer_->SetInitState(false);
150 producer_->UpdateOperation(statusMsg);
151 }
152
153 HWTEST_F(WfdRtpProducerTest, UpdateOperation_003, TestSize.Level1)
154 {
155 ASSERT_TRUE(producer_ != nullptr);
156 ASSERT_TRUE(listener_ != nullptr);
157
158 EXPECT_CALL(*listener_, OnProducerNotify(_));
159
160 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
161 statusMsg->status = PROSUMER_PAUSE;
162 producer_->UpdateOperation(statusMsg);
163 }
164
165 HWTEST_F(WfdRtpProducerTest, UpdateOperation_004, TestSize.Level1)
166 {
167 ASSERT_TRUE(producer_ != nullptr);
168 ASSERT_TRUE(listener_ != nullptr);
169
170 EXPECT_CALL(*listener_, OnProducerNotify(_));
171
172 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
173 statusMsg->status = PROSUMER_RESUME;
174 producer_->UpdateOperation(statusMsg);
175 }
176
177 HWTEST_F(WfdRtpProducerTest, UpdateOperation_005, TestSize.Level1)
178 {
179 ASSERT_TRUE(producer_ != nullptr);
180 ASSERT_TRUE(listener_ != nullptr);
181
182 EXPECT_CALL(*listener_, OnProducerNotify(_));
183
184 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
185 statusMsg->status = PROSUMER_STOP;
186 producer_->UpdateOperation(statusMsg);
187 }
188
189 HWTEST_F(WfdRtpProducerTest, UpdateOperation_006, TestSize.Level1)
190 {
191 ASSERT_TRUE(producer_ != nullptr);
192 ASSERT_TRUE(listener_ != nullptr);
193
194 EXPECT_CALL(*listener_, OnProducerNotify(_));
195
196 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
197 statusMsg->status = PROSUMER_DESTROY;
198 producer_->UpdateOperation(statusMsg);
199 }
200
201 HWTEST_F(WfdRtpProducerTest, PublishOneFrame_001, TestSize.Level1)
202 {
203 ASSERT_TRUE(producer_ != nullptr);
204
205 auto tsPacker = std::make_shared<MockRtpPack>();
206 EXPECT_CALL(*tsPacker, InputFrame(_));
207
208 auto mediaData = std::make_shared<MediaData>();
209 DataBuffer::Ptr buf = std::make_shared<DataBuffer>();
210 char data[100];
211 buf->Assign(data, 100);
212 mediaData->buff = buf;
213 mediaData->mediaType = MEDIA_TYPE_AUDIO;
214 producer_->tsPacker_ = tsPacker;
215 producer_->SetRunningState(true);
216 producer_->SetPauseState(false);
217 producer_->PublishOneFrame(mediaData);
218 }
219
220 HWTEST_F(WfdRtpProducerTest, PublishOneFrame_002, TestSize.Level1)
221 {
222 ASSERT_TRUE(producer_ != nullptr);
223
224 auto tsPacker = std::make_shared<MockRtpPack>();
225 EXPECT_CALL(*tsPacker, InputFrame(_));
226
227 auto mediaData = std::make_shared<MediaData>();
228 DataBuffer::Ptr buf = std::make_shared<DataBuffer>();
229 char data[100];
230 buf->Assign(data, 100);
231 mediaData->buff = buf;
232 mediaData->mediaType = MEDIA_TYPE_VIDEO;
233 producer_->tsPacker_ = tsPacker;
234 producer_->SetRunningState(true);
235 producer_->SetPauseState(false);
236 producer_->PublishOneFrame(mediaData);
237 }
238
239 HWTEST_F(WfdRtpProducerTest, HandleEvent_001, TestSize.Level1)
240 {
241 ASSERT_TRUE(producer_ != nullptr);
242 ASSERT_TRUE(listener_ != nullptr);
243
244 EXPECT_CALL(*listener_, OnProducerNotify(_));
245
246 SharingEvent event;
247 auto msg = std::make_shared<WfdProducerEventMsg>();
248 msg->type = EVENT_WFD_MEDIA_INIT;
249 event.eventMsg = msg;
250 producer_->HandleEvent(event);
251 }
252
253 HWTEST_F(WfdRtpProducerTest, SendDataBuffer_001, TestSize.Level1)
254 {
255 ASSERT_TRUE(producer_ != nullptr);
256
257 DataBuffer::Ptr buf = std::make_shared<DataBuffer>();
258 char data[100];
259 buf->Assign(data, 100);
260 producer_->SendDataBuffer(buf, false);
261 }
262
263 HWTEST_F(WfdRtpProducerTest, Connect_001, TestSize.Level1)
264 {
265 ASSERT_TRUE(producer_ != nullptr);
266
267 producer_->tsUdpClient_ = nullptr;
268 producer_->Connect();
269 }
270
271 HWTEST_F(WfdRtpProducerTest, OnRtcpReadData_001, TestSize.Level1)
272 {
273 ASSERT_TRUE(producer_ != nullptr);
274
275 DataBuffer::Ptr buf = std::make_shared<DataBuffer>();
276 char data[100];
277 buf->Assign(data, 100);
278 producer_->OnRtcpReadData(0, buf);
279 }
280
281 HWTEST_F(WfdRtpProducerTest, OnRtcpTimeOut_001, TestSize.Level1)
282 {
283 ASSERT_TRUE(producer_ != nullptr);
284 ASSERT_TRUE(listener_ != nullptr);
285
286 EXPECT_CALL(*listener_, OnProducerNotify(_));
287
288 producer_->rtcpOvertimes_ = 3; // 3 : DEFAULT_RTCP_OVERTIMES
289 producer_->OnRtcpTimeOut();
290 }
291
292 } // namespace Sharing
293 } // namespace OHOS
294