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_screen_capture_test.h"
17 #include "mock_media_channel.h"
18 #include "screen_capture_def.h"
19 #include "common/const_def.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23 using namespace OHOS::Sharing;
24
25 namespace OHOS {
26 namespace Sharing {
27
SetUpTestCase(void)28 void WfdScreenCaptureTest::SetUpTestCase(void)
29 {
30 consumer_ = std::make_shared<MockScreenCaptureConsumer>();
31 consumer_->Initialize();
32 }
33
TearDownTestCase(void)34 void WfdScreenCaptureTest::TearDownTestCase(void)
35 {
36 consumer_->DeInitialize();
37 consumer_ = nullptr;
38 }
39
SetUp(void)40 void WfdScreenCaptureTest::SetUp(void)
41 {
42 }
43
TearDown(void)44 void WfdScreenCaptureTest::TearDown(void)
45 {
46 }
47
48 HWTEST_F(WfdScreenCaptureTest, HandleSpsFrame_001, TestSize.Level1)
49 {
50 ASSERT_TRUE(consumer_ != nullptr);
51 ASSERT_TRUE(consumer_->dispatcher_ != nullptr);
52
53 Frame::Ptr frame = FrameImpl::Create();
54 consumer_->HandleSpsFrame(consumer_->dispatcher_, frame);
55 }
56
57 HWTEST_F(WfdScreenCaptureTest, HandleSpsFrame_002, TestSize.Level1)
58 {
59 ASSERT_TRUE(consumer_ != nullptr);
60 ASSERT_TRUE(consumer_->dispatcher_ != nullptr);
61
62 Frame::Ptr frame = FrameImpl::Create();
63 consumer_->HandleSpsFrame(consumer_->dispatcher_, frame);
64 }
65
66 HWTEST_F(WfdScreenCaptureTest, HandlePpsFrame_001, TestSize.Level1)
67 {
68 ASSERT_TRUE(consumer_ != nullptr);
69 ASSERT_TRUE(consumer_->dispatcher_ != nullptr);
70
71 Frame::Ptr frame = FrameImpl::Create();
72 consumer_->HandlePpsFrame(consumer_->dispatcher_, frame);
73 }
74
75 HWTEST_F(WfdScreenCaptureTest, HandlePpsFrame_002, TestSize.Level1)
76 {
77 ASSERT_TRUE(consumer_ != nullptr);
78 ASSERT_TRUE(consumer_->dispatcher_ != nullptr);
79
80 Frame::Ptr frame = FrameImpl::Create();
81 consumer_->HandlePpsFrame(consumer_->dispatcher_, frame);
82 }
83
84 HWTEST_F(WfdScreenCaptureTest, OnFrame_001, TestSize.Level1)
85 {
86 ASSERT_TRUE(consumer_ != nullptr);
87
88 consumer_->OnFrame(nullptr, FRAME_TYPE::SPS_FRAME, false);
89 }
90
91 HWTEST_F(WfdScreenCaptureTest, OnFrame_002, TestSize.Level1)
92 {
93 ASSERT_TRUE(consumer_ != nullptr);
94
95 Frame::Ptr frame = FrameImpl::Create();
96 consumer_->OnFrame(frame, FRAME_TYPE::SPS_FRAME, false);
97 }
98
99 HWTEST_F(WfdScreenCaptureTest, OnFrame_003, TestSize.Level1)
100 {
101 ASSERT_TRUE(consumer_ != nullptr);
102
103 Frame::Ptr frame = FrameImpl::Create();
104 consumer_->OnFrame(frame, FRAME_TYPE::PPS_FRAME, false);
105 }
106
107 HWTEST_F(WfdScreenCaptureTest, OnFrame_004, TestSize.Level1)
108 {
109 ASSERT_TRUE(consumer_ != nullptr);
110
111 Frame::Ptr frame = FrameImpl::Create();
112 frame->SetCapacity(100);
113 frame->SetSize(100);
114 consumer_->OnFrame(frame, FRAME_TYPE::IDR_FRAME, false);
115 }
116
117 HWTEST_F(WfdScreenCaptureTest, HandleProsumerInitState_001, TestSize.Level1)
118 {
119 ASSERT_TRUE(consumer_ != nullptr);
120 ASSERT_TRUE(consumer_->mediaChannel_ != nullptr);
121
122 EXPECT_CALL(*consumer_->mediaChannel_, OnConsumerNotify(_)).Times(1);
123
124 SharingEvent event;
125 auto msg = std::make_shared<ScreenCaptureConsumerEventMsg>();
126 msg->audioTrack.codecId = CodecId::CODEC_AAC;
127 msg->videoTrack.codecId = CodecId::CODEC_H264;
128 event.eventMsg = msg;
129 consumer_->HandleProsumerInitState(event);
130 }
131
132 HWTEST_F(WfdScreenCaptureTest, HandleEvent_001, TestSize.Level1)
133 {
134 ASSERT_TRUE(consumer_ != nullptr);
135
136 SharingEvent event;
137 auto msg = std::make_shared<ScreenCaptureConsumerEventMsg>();
138 msg->audioTrack.codecId = CodecId::CODEC_AAC;
139 msg->videoTrack.codecId = CodecId::CODEC_H264;
140 msg->type = EVENT_SCREEN_CAPTURE_BASE;
141 event.eventMsg = msg;
142 int32_t ret = consumer_->HandleEvent(event);
143 EXPECT_EQ(ret, 0);
144 }
145
146 HWTEST_F(WfdScreenCaptureTest, HandleEvent_002, TestSize.Level1)
147 {
148 ASSERT_TRUE(consumer_ != nullptr);
149 ASSERT_TRUE(consumer_->mediaChannel_ != nullptr);
150
151 EXPECT_CALL(*consumer_->mediaChannel_, OnConsumerNotify(_)).Times(1);
152
153 SharingEvent event;
154 auto msg = std::make_shared<ScreenCaptureConsumerEventMsg>();
155 msg->audioTrack.codecId = CodecId::CODEC_AAC;
156 msg->videoTrack.codecId = CodecId::CODEC_H264;
157 msg->type = EVENT_SCREEN_CAPTURE_INIT;
158 event.eventMsg = msg;
159 int32_t ret = consumer_->HandleEvent(event);
160 EXPECT_EQ(ret, 0);
161 }
162
163 HWTEST_F(WfdScreenCaptureTest, UpdateOperation_001, TestSize.Level1)
164 {
165 ASSERT_TRUE(consumer_ != nullptr);
166 ASSERT_TRUE(consumer_->mediaChannel_ != nullptr);
167
168 EXPECT_CALL(*consumer_->mediaChannel_, OnConsumerNotify(_)).Times(1);
169
170 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
171 statusMsg->status = ProsumerOptRunningStatus::PROSUMER_INIT;
172 consumer_->UpdateOperation(statusMsg);
173 }
174
175 HWTEST_F(WfdScreenCaptureTest, UpdateOperation_002, TestSize.Level1)
176 {
177 ASSERT_TRUE(consumer_ != nullptr);
178 ASSERT_TRUE(consumer_->mediaChannel_ != nullptr);
179
180 EXPECT_CALL(*consumer_->mediaChannel_, OnConsumerNotify(_)).Times(1);
181
182 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
183 statusMsg->status = ProsumerOptRunningStatus::PROSUMER_START;
184 consumer_->UpdateOperation(statusMsg);
185 }
186
187 HWTEST_F(WfdScreenCaptureTest, UpdateOperation_003, TestSize.Level1)
188 {
189 ASSERT_TRUE(consumer_ != nullptr);
190 ASSERT_TRUE(consumer_->mediaChannel_ != nullptr);
191
192 EXPECT_CALL(*consumer_->mediaChannel_, OnConsumerNotify(_)).Times(1);
193
194 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
195 statusMsg->status = ProsumerOptRunningStatus::PROSUMER_PAUSE;
196 consumer_->UpdateOperation(statusMsg);
197 }
198
199 HWTEST_F(WfdScreenCaptureTest, UpdateOperation_004, TestSize.Level1)
200 {
201 ASSERT_TRUE(consumer_ != nullptr);
202 ASSERT_TRUE(consumer_->mediaChannel_ != nullptr);
203
204 EXPECT_CALL(*consumer_->mediaChannel_, OnConsumerNotify(_)).Times(1);
205
206 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
207 statusMsg->status = ProsumerOptRunningStatus::PROSUMER_RESUME;
208 consumer_->UpdateOperation(statusMsg);
209 }
210
211 HWTEST_F(WfdScreenCaptureTest, UpdateOperation_005, TestSize.Level1)
212 {
213 ASSERT_TRUE(consumer_ != nullptr);
214 ASSERT_TRUE(consumer_->mediaChannel_ != nullptr);
215
216 EXPECT_CALL(*consumer_->mediaChannel_, OnConsumerNotify(_)).Times(1);
217
218 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
219 statusMsg->status = ProsumerOptRunningStatus::PROSUMER_STOP;
220 consumer_->UpdateOperation(statusMsg);
221 }
222
223 HWTEST_F(WfdScreenCaptureTest, UpdateOperation_006, TestSize.Level1)
224 {
225 ASSERT_TRUE(consumer_ != nullptr);
226
227 EXPECT_CALL(*consumer_->mediaChannel_, OnConsumerNotify(_)).Times(1);
228
229 auto statusMsg = std::make_shared<ProsumerStatusMsg>();
230 statusMsg->status = ProsumerOptRunningStatus::PROSUMER_DESTROY;
231 consumer_->UpdateOperation(statusMsg);
232 }
233
234 HWTEST_F(WfdScreenCaptureTest, Capture_001, TestSize.Level1)
235 {
236 ASSERT_TRUE(consumer_ != nullptr);
237
238 consumer_->Init(0);
239 consumer_->StartCapture();
240 consumer_->StopCapture();
241 }
242
243 HWTEST_F(WfdScreenCaptureTest, OnInitVideoCaptureError_001, TestSize.Level1)
244 {
245 ASSERT_TRUE(consumer_ != nullptr);
246 ASSERT_TRUE(consumer_->mediaChannel_ != nullptr);
247
248 EXPECT_CALL(*consumer_->mediaChannel_, OnConsumerNotify(_)).Times(1);
249 consumer_->OnInitVideoCaptureError();
250 }
251
252 } // namespace Sharing
253 } // namespace OHOS
254