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_consumer_test.h"
17 #include "wfd_media_def.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21 using namespace OHOS::Sharing;
22
23 namespace OHOS {
24 namespace Sharing {
25
SetUpTestCase(void)26 void WfdRtpConsumerTest::SetUpTestCase(void)
27 {
28 mockRtpServer_ = std::make_shared<MockRtpServer>();
29 mockRtpUnpack_ = std::make_shared<MockRtpUnpack>();
30 consumer_ = std::make_shared<MockWfdRtpConsumer>();
31 listener_ = std::make_shared<MockConsumerListener>();
32 }
33
TearDownTestCase(void)34 void WfdRtpConsumerTest::TearDownTestCase(void)
35 {
36 if (mockRtpServer_ != nullptr) {
37 EXPECT_CALL(*mockRtpServer_, Stop());
38 }
39 if (mockRtpUnpack_ != nullptr) {
40 EXPECT_CALL(*mockRtpUnpack_, Release());
41 }
42 mockRtpServer_ = nullptr;
43 mockRtpUnpack_ = nullptr;
44 consumer_ = nullptr;
45 listener_ = nullptr;
46 }
47
SetUp(void)48 void WfdRtpConsumerTest::SetUp(void)
49 {
50 consumer_->SetConsumerListener(listener_);
51 if (mockRtpServer_ == nullptr) {
52 mockRtpServer_ = std::make_shared<MockRtpServer>();
53 }
54 if (mockRtpUnpack_ == nullptr) {
55 mockRtpUnpack_ = std::make_shared<MockRtpUnpack>();
56 }
57 consumer_->rtpUnpacker_ = mockRtpUnpack_;
58 consumer_->rtpServer_ = std::make_pair(consumer_->rtpServer_.first, mockRtpServer_);
59 }
60
TearDown(void)61 void WfdRtpConsumerTest::TearDown(void)
62 {
63 }
64
65 HWTEST_F(WfdRtpConsumerTest, HandleEvent_001, TestSize.Level1)
66 {
67 ASSERT_TRUE(consumer_ != nullptr);
68 ASSERT_TRUE(listener_ != nullptr);
69
70 SharingEvent event;
71 auto msg = std::make_shared<WfdConsumerEventMsg>();
72 msg->type = EVENT_WFD_BASE;
73 event.eventMsg = msg;
74 int32_t ret = consumer_->HandleEvent(event);
75 EXPECT_EQ(ret, 0);
76 }
77
78 HWTEST_F(WfdRtpConsumerTest, HandleEvent_002, TestSize.Level1)
79 {
80 ASSERT_TRUE(consumer_ != nullptr);
81 ASSERT_TRUE(listener_ != nullptr);
82
83 EXPECT_CALL(*listener_, OnConsumerNotify(_));
84
85 SharingEvent event;
86 auto msg = std::make_shared<WfdConsumerEventMsg>();
87 msg->type = EVENT_WFD_MEDIA_INIT;
88 msg->audioTrack.codecId = CodecId::CODEC_AAC;
89 msg->videoTrack.codecId = CodecId::CODEC_H264;
90 event.eventMsg = msg;
91 int32_t ret = consumer_->HandleEvent(event);
92 EXPECT_EQ(ret, 0);
93 }
94
95 HWTEST_F(WfdRtpConsumerTest, HandleProsumerInitState_001, TestSize.Level1)
96 {
97 ASSERT_TRUE(consumer_ != nullptr);
98 ASSERT_TRUE(listener_ != nullptr);
99
100 auto listener = std::make_shared<MockConsumerListener>();
101 consumer_->SetConsumerListener(listener);
102 EXPECT_CALL(*listener, OnConsumerNotify(_));
103
104 SharingEvent event;
105 auto msg = std::make_shared<WfdConsumerEventMsg>();
106 msg->audioTrack.codecId = CodecId::CODEC_AAC;
107 msg->videoTrack.codecId = CodecId::CODEC_H264;
108 event.eventMsg = msg;
109 consumer_->HandleProsumerInitState(event);
110 }
111
112 HWTEST_F(WfdRtpConsumerTest, UpdateOperation_001, TestSize.Level1)
113 {
114 ASSERT_TRUE(consumer_ != nullptr);
115 ASSERT_TRUE(listener_ != nullptr);
116
117 EXPECT_CALL(*listener_, OnConsumerNotify(_));
118
119 ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
120 statusMsg->status = PROSUMER_INIT;
121 consumer_->UpdateOperation(statusMsg);
122 }
123
124 HWTEST_F(WfdRtpConsumerTest, UpdateOperation_002, TestSize.Level1)
125 {
126 ASSERT_TRUE(consumer_ != nullptr);
127 ASSERT_TRUE(listener_ != nullptr);
128
129 EXPECT_CALL(*listener_, OnConsumerNotify(_));
130
131 ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
132 statusMsg->status = PROSUMER_START;
133 consumer_->UpdateOperation(statusMsg);
134 }
135
136 HWTEST_F(WfdRtpConsumerTest, UpdateOperation_003, TestSize.Level1)
137 {
138 ASSERT_TRUE(consumer_ != nullptr);
139 ASSERT_TRUE(listener_ != nullptr);
140
141 EXPECT_CALL(*listener_, OnConsumerNotify(_));
142
143 ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
144 statusMsg->status = PROSUMER_PAUSE;
145 consumer_->UpdateOperation(statusMsg);
146 }
147
148 HWTEST_F(WfdRtpConsumerTest, UpdateOperation_004, TestSize.Level1)
149 {
150 ASSERT_TRUE(consumer_ != nullptr);
151 ASSERT_TRUE(listener_ != nullptr);
152
153 EXPECT_CALL(*listener_, OnConsumerNotify(_));
154
155 ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
156 statusMsg->status = PROSUMER_RESUME;
157 consumer_->UpdateOperation(statusMsg);
158 }
159
160 HWTEST_F(WfdRtpConsumerTest, UpdateOperation_005, TestSize.Level1)
161 {
162 ASSERT_TRUE(consumer_ != nullptr);
163 ASSERT_TRUE(listener_ != nullptr);
164 ASSERT_TRUE(consumer_->rtpUnpacker_ != nullptr);
165
166 EXPECT_CALL(*listener_, OnConsumerNotify(_));
167 EXPECT_CALL(*mockRtpUnpack_, Release());
168 EXPECT_CALL(*mockRtpServer_, Stop());
169
170 ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
171 statusMsg->status = PROSUMER_STOP;
172 consumer_->UpdateOperation(statusMsg);
173 }
174
175 HWTEST_F(WfdRtpConsumerTest, UpdateOperation_006, TestSize.Level1)
176 {
177 ASSERT_TRUE(consumer_ != nullptr);
178 ASSERT_TRUE(listener_ != nullptr);
179 ASSERT_TRUE(consumer_->rtpUnpacker_ != nullptr);
180
181 EXPECT_CALL(*listener_, OnConsumerNotify(_));
182 EXPECT_CALL(*mockRtpUnpack_, Release());
183 EXPECT_CALL(*mockRtpServer_, Stop());
184
185 ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
186 statusMsg->status = PROSUMER_DESTROY;
187 consumer_->UpdateOperation(statusMsg);
188 }
189
190 HWTEST_F(WfdRtpConsumerTest, OnRtpUnpackCallback_001, TestSize.Level1)
191 {
192 ASSERT_TRUE(consumer_ != nullptr);
193 ASSERT_TRUE(listener_ != nullptr);
194
195 auto dispatcher = std::make_shared<BufferDispatcher>();
196 EXPECT_CALL(*listener_, GetDispatcher()).WillOnce(Return(dispatcher));
197 EXPECT_CALL(*listener_, OnConsumerNotify(_));
198
199 ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
200 statusMsg->status = PROSUMER_PAUSE;
201 consumer_->UpdateOperation(statusMsg);
202
203 FrameImpl::Ptr frame = std::make_shared<FrameImpl>();
204 frame->codecId_ = CODEC_AAC;
205 consumer_->OnRtpUnpackCallback(0, frame);
206 }
207
208 HWTEST_F(WfdRtpConsumerTest, OnRtpUnpackCallback_002, TestSize.Level1)
209 {
210 ASSERT_TRUE(consumer_ != nullptr);
211 ASSERT_TRUE(listener_ != nullptr);
212
213 auto dispatcher = std::make_shared<BufferDispatcher>();
214 EXPECT_CALL(*listener_, GetDispatcher()).WillOnce(Return(dispatcher));
215 EXPECT_CALL(*listener_, OnConsumerNotify(_));
216
217 ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
218 statusMsg->status = PROSUMER_PAUSE;
219 consumer_->UpdateOperation(statusMsg);
220
221 FrameImpl::Ptr frame = std::make_shared<FrameImpl>();
222 frame->codecId_ = CODEC_H264;
223 consumer_->OnRtpUnpackCallback(0, frame);
224 }
225
226 HWTEST_F(WfdRtpConsumerTest, OnRtpUnpackCallback_003, TestSize.Level1)
227 {
228 ASSERT_TRUE(consumer_ != nullptr);
229 ASSERT_TRUE(listener_ != nullptr);
230
231 auto dispatcher = std::make_shared<BufferDispatcher>();
232 EXPECT_CALL(*listener_, GetDispatcher()).WillOnce(Return(dispatcher));
233 EXPECT_CALL(*listener_, OnConsumerNotify(_));
234
235 ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
236 statusMsg->status = PROSUMER_RESUME;
237 consumer_->UpdateOperation(statusMsg);
238
239 FrameImpl::Ptr frame = std::make_shared<FrameImpl>();
240 frame->codecId_ = CODEC_AAC;
241 consumer_->OnRtpUnpackCallback(0, frame);
242 }
243
244 HWTEST_F(WfdRtpConsumerTest, OnRtpUnpackCallback_004, TestSize.Level1)
245 {
246 ASSERT_TRUE(consumer_ != nullptr);
247 ASSERT_TRUE(listener_ != nullptr);
248
249 auto dispatcher = std::make_shared<BufferDispatcher>();
250 EXPECT_CALL(*listener_, GetDispatcher()).WillOnce(Return(dispatcher));
251 EXPECT_CALL(*listener_, OnConsumerNotify(_));
252
253 ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
254 statusMsg->status = PROSUMER_RESUME;
255 consumer_->UpdateOperation(statusMsg);
256
257 FrameImpl::Ptr frame = std::make_shared<FrameImpl>();
258 frame->codecId_ = CODEC_H264;
259 char data[100];
260 frame->Assign(data, 100);
261 consumer_->OnRtpUnpackCallback(0, frame);
262 }
263
264 HWTEST_F(WfdRtpConsumerTest, OnServerReadData_001, TestSize.Level1)
265 {
266 ASSERT_TRUE(consumer_ != nullptr);
267 ASSERT_TRUE(consumer_->rtpUnpacker_ != nullptr);
268
269 EXPECT_CALL(*mockRtpUnpack_, ParseRtp(_, _));
270
271 DataBuffer::Ptr buf = std::make_shared<DataBuffer>();
272 char data[100];
273 buf->Assign(data, 100);
274 consumer_->SetRunningState(true);
275 consumer_->OnServerReadData(0, buf, nullptr);
276 }
277
278 } // namespace Sharing
279 } // namespace OHOS
280