1 /*
2 * Copyright (c) 2021-2025 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 <gtest/gtest.h>
17 #include <memory>
18 #define private public
19 #include "dcamera_sink_output.h"
20 #undef private
21
22 #include "mock_camera_channel.h"
23 #include "mock_camera_operator.h"
24 #include "mock_dcamera_sink_data_process.h"
25
26 #include "dcamera_handler.h"
27 #include "dcamera_sink_access_control.h"
28 #include "dcamera_sink_controller.h"
29 #include "dcamera_sink_data_process.h"
30 #include "dcamera_sink_dev.h"
31 #include "dcamera_sink_output_result_callback.h"
32 #include "dcamera_utils_tools.h"
33 #include "distributed_camera_errno.h"
34
35 using namespace testing::ext;
36
37 namespace OHOS {
38 namespace DistributedHardware {
39 class DCameraSinkOutputTest : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp();
44 void TearDown();
45
46 std::shared_ptr<DCameraSinkOutput> output_;
47 std::shared_ptr<ICameraOperator> operator_;
48 std::shared_ptr<ICameraChannel> channel_;
49 std::shared_ptr<ICameraSinkDataProcess> dataProcess_;
50 };
51
52 const std::string SESSION_FLAG_CONTINUE = "dataContinue";
53 const std::string SESSION_FLAG_SNAPSHOT = "dataSnapshot";
54 const int32_t TEST_WIDTH = 1080;
55 const int32_t TEST_HEIGHT = 1920;
56 const int32_t TEST_TWENTY_MS = 20000;
57
58 std::string g_testDeviceIdOutput;
59 DCameraChannelDetail g_testDetailOutput;
60
61 std::shared_ptr<DCameraCaptureInfo> g_testCaptureInfoOutputContinuousNotEncode;
62 std::shared_ptr<DCameraCaptureInfo> g_testCaptureInfoOutputContinuousNeedEncode;
63 std::shared_ptr<DCameraCaptureInfo> g_testCaptureInfoOutputSnapshot;
64
65 std::shared_ptr<DCameraChannelInfo> g_testChannelInfo;
66
67 std::vector<std::shared_ptr<DCameraCaptureInfo>> g_testCaptureInfosOutput;
68
SetUpTestCase(void)69 void DCameraSinkOutputTest::SetUpTestCase(void)
70 {
71 GetLocalDeviceNetworkId(g_testDeviceIdOutput);
72
73 std::shared_ptr<DCameraSettings> cameraSetting = std::make_shared<DCameraSettings>();
74 cameraSetting->type_ = UPDATE_METADATA;
75 cameraSetting->value_ = "";
76
77 g_testCaptureInfoOutputContinuousNotEncode = std::make_shared<DCameraCaptureInfo>();
78 g_testCaptureInfoOutputContinuousNotEncode->width_ = TEST_WIDTH;
79 g_testCaptureInfoOutputContinuousNotEncode->height_ = TEST_HEIGHT;
80 g_testCaptureInfoOutputContinuousNotEncode->format_ = ENCODE_TYPE_H264;
81 g_testCaptureInfoOutputContinuousNotEncode->dataspace_ = 0;
82 g_testCaptureInfoOutputContinuousNotEncode->encodeType_ = ENCODE_TYPE_H264;
83 g_testCaptureInfoOutputContinuousNotEncode->streamType_ = CONTINUOUS_FRAME;
84 g_testCaptureInfoOutputContinuousNotEncode->captureSettings_.push_back(cameraSetting);
85
86 g_testCaptureInfoOutputContinuousNeedEncode = std::make_shared<DCameraCaptureInfo>();
87 g_testCaptureInfoOutputContinuousNeedEncode->width_ = TEST_WIDTH;
88 g_testCaptureInfoOutputContinuousNeedEncode->height_ = TEST_HEIGHT;
89 g_testCaptureInfoOutputContinuousNeedEncode->format_ = ENCODE_TYPE_H264;
90 g_testCaptureInfoOutputContinuousNeedEncode->dataspace_ = 0;
91 g_testCaptureInfoOutputContinuousNeedEncode->encodeType_ = ENCODE_TYPE_H265;
92 g_testCaptureInfoOutputContinuousNeedEncode->streamType_ = CONTINUOUS_FRAME;
93 g_testCaptureInfoOutputContinuousNeedEncode->captureSettings_.push_back(cameraSetting);
94
95 g_testCaptureInfoOutputSnapshot = std::make_shared<DCameraCaptureInfo>();
96 g_testCaptureInfoOutputSnapshot->width_ = TEST_WIDTH;
97 g_testCaptureInfoOutputSnapshot->height_ = TEST_HEIGHT;
98 g_testCaptureInfoOutputSnapshot->format_ = ENCODE_TYPE_JPEG;
99 g_testCaptureInfoOutputSnapshot->dataspace_ = 0;
100 g_testCaptureInfoOutputSnapshot->encodeType_ = ENCODE_TYPE_JPEG;
101 g_testCaptureInfoOutputSnapshot->streamType_ = SNAPSHOT_FRAME;
102 g_testCaptureInfoOutputSnapshot->captureSettings_.push_back(cameraSetting);
103
104 g_testDetailOutput.dataSessionFlag_ = SESSION_FLAG_CONTINUE;
105 g_testDetailOutput.streamType_ = CONTINUOUS_FRAME;
106
107 g_testChannelInfo = std::make_shared<DCameraChannelInfo>();
108 g_testChannelInfo->sourceDevId_ = g_testDeviceIdOutput;
109 std::vector<DCameraChannelDetail> detail0;
110 detail0.push_back(g_testDetailOutput);
111 g_testChannelInfo->detail_ = detail0;
112 }
113
TearDownTestCase(void)114 void DCameraSinkOutputTest::TearDownTestCase(void)
115 {
116 }
117
SetUp(void)118 void DCameraSinkOutputTest::SetUp(void)
119 {
120 DCameraHandler::GetInstance().Initialize();
121 std::vector<std::string> cameras = DCameraHandler::GetInstance().GetCameras();
122 operator_ = std::make_shared<MockCameraOperator>();
123 output_ = std::make_shared<DCameraSinkOutput>(cameras[0], operator_);
124 }
125
TearDown(void)126 void DCameraSinkOutputTest::TearDown(void)
127 {
128 output_->channels_.clear();
129 output_->dataProcesses_.clear();
130
131 operator_ = nullptr;
132 output_ = nullptr;
133 }
134
135 /**
136 * @tc.name: dcamera_sink_output_test_001
137 * @tc.desc: Verify the UnInit function.
138 * @tc.type: FUNC
139 * @tc.require: I5N1JI
140 */
141 HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_001, TestSize.Level1)
142 {
143 int32_t ret = output_->Init();
144 EXPECT_EQ(DCAMERA_OK, ret);
145 std::shared_ptr<DCameraSinkOutput> output = nullptr;
146 auto callback = std::make_shared<DCameraSinkOutputResultCallback>(output);
147 auto dataBuffer = std::make_shared<DataBuffer>(1);
148 callback->OnPhotoResult(dataBuffer);
149 callback->OnVideoResult(dataBuffer);
150 EXPECT_EQ(true, output_->isInit_);
151 usleep(TEST_TWENTY_MS);
152 ret = output_->UnInit();
153 EXPECT_EQ(DCAMERA_OK, ret);
154 EXPECT_EQ(false, output_->isInit_);
155 }
156
157 /**
158 * @tc.name: dcamera_sink_output_test_002
159 * @tc.desc: Verify the StartCapture function.
160 * @tc.type: FUNC
161 * @tc.require: I5N1JI
162 */
163 HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_002, TestSize.Level1)
164 {
165 channel_ = std::make_shared<MockCameraChannel>();
166 dataProcess_ = std::make_shared<MockDCameraSinkDataProcess>(channel_);
167 output_->channels_.emplace(SNAPSHOT_FRAME, channel_);
168 output_->channels_.emplace(CONTINUOUS_FRAME, channel_);
169 output_->dataProcesses_.emplace(SNAPSHOT_FRAME, dataProcess_);
170 output_->dataProcesses_.emplace(CONTINUOUS_FRAME, dataProcess_);
171 g_testCaptureInfosOutput.push_back(g_testCaptureInfoOutputContinuousNotEncode);
172 int32_t ret = output_->StartCapture(g_testCaptureInfosOutput);
173 EXPECT_EQ(DCAMERA_OK, ret);
174
175 g_testCaptureInfosOutput.clear();
176 }
177
178 /**
179 * @tc.name: dcamera_sink_output_test_003
180 * @tc.desc: Verify the StartCapture function.
181 * @tc.type: FUNC
182 * @tc.require: I5N1JI
183 */
184 HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_003, TestSize.Level1)
185 {
186 channel_ = std::make_shared<MockCameraChannel>();
187 dataProcess_ = std::make_shared<MockDCameraSinkDataProcess>(channel_);
188 output_->channels_.emplace(SNAPSHOT_FRAME, channel_);
189 output_->channels_.emplace(CONTINUOUS_FRAME, channel_);
190 output_->dataProcesses_.emplace(SNAPSHOT_FRAME, dataProcess_);
191 output_->dataProcesses_.emplace(CONTINUOUS_FRAME, dataProcess_);
192 g_testCaptureInfosOutput.push_back(g_testCaptureInfoOutputContinuousNeedEncode);
193 int32_t ret = output_->StartCapture(g_testCaptureInfosOutput);
194 EXPECT_EQ(DCAMERA_OK, ret);
195
196 g_testCaptureInfosOutput.clear();
197 }
198
199 /**
200 * @tc.name: dcamera_sink_output_test_004
201 * @tc.desc: Verify the StartCapture function.
202 * @tc.type: FUNC
203 * @tc.require: I5N1JI
204 */
205 HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_004, TestSize.Level1)
206 {
207 channel_ = std::make_shared<MockCameraChannel>();
208 dataProcess_ = std::make_shared<MockDCameraSinkDataProcess>(channel_);
209 output_->channels_.emplace(SNAPSHOT_FRAME, channel_);
210 output_->channels_.emplace(CONTINUOUS_FRAME, channel_);
211 output_->dataProcesses_.emplace(SNAPSHOT_FRAME, dataProcess_);
212 output_->dataProcesses_.emplace(CONTINUOUS_FRAME, dataProcess_);
213 g_testCaptureInfosOutput.push_back(g_testCaptureInfoOutputSnapshot);
214 int32_t ret = output_->StartCapture(g_testCaptureInfosOutput);
215 EXPECT_EQ(DCAMERA_OK, ret);
216
217 g_testCaptureInfosOutput.clear();
218 }
219
220 /**
221 * @tc.name: dcamera_sink_output_test_005
222 * @tc.desc: Verify the StopCapture function.
223 * @tc.type: FUNC
224 * @tc.require: I5N1JI
225 */
226 HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_005, TestSize.Level1)
227 {
228 channel_ = std::make_shared<MockCameraChannel>();
229 dataProcess_ = std::make_shared<MockDCameraSinkDataProcess>(channel_);
230 output_->channels_.emplace(SNAPSHOT_FRAME, channel_);
231 output_->channels_.emplace(CONTINUOUS_FRAME, channel_);
232 output_->dataProcesses_.emplace(SNAPSHOT_FRAME, dataProcess_);
233 output_->dataProcesses_.emplace(CONTINUOUS_FRAME, dataProcess_);
234 g_testCaptureInfosOutput.push_back(g_testCaptureInfoOutputContinuousNotEncode);
235 int32_t ret = output_->StartCapture(g_testCaptureInfosOutput);
236 EXPECT_EQ(DCAMERA_OK, ret);
237
238 ret = output_->StopCapture();
239 EXPECT_EQ(DCAMERA_OK, ret);
240
241 g_testCaptureInfosOutput.clear();
242 }
243
244 /**
245 * @tc.name: dcamera_sink_output_test_006
246 * @tc.desc: Verify the OpenChannel function.
247 * @tc.type: FUNC
248 * @tc.require: I5N1JI
249 */
250 HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_006, TestSize.Level1)
251 {
252 channel_ = std::make_shared<MockCameraChannel>();
253 output_->channels_.emplace(SNAPSHOT_FRAME, channel_);
254 output_->channels_.emplace(CONTINUOUS_FRAME, channel_);
255 int32_t ret = output_->OpenChannel(g_testChannelInfo);
256 EXPECT_EQ(DCAMERA_OK, ret);
257 }
258
259 /**
260 * @tc.name: dcamera_sink_output_test_007
261 * @tc.desc: Verify the CloseChannel function.
262 * @tc.type: FUNC
263 * @tc.require: I5N1JI
264 */
265 HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_007, TestSize.Level1)
266 {
267 channel_ = std::make_shared<MockCameraChannel>();
268 output_->channels_.emplace(SNAPSHOT_FRAME, channel_);
269 output_->channels_.emplace(CONTINUOUS_FRAME, channel_);
270 int32_t ret = output_->CloseChannel();
271 EXPECT_EQ(DCAMERA_OK, ret);
272 }
273
274 /**
275 * @tc.name: dcamera_sink_output_test_008
276 * @tc.desc: Verify the CloseChannel function.
277 * @tc.type: FUNC
278 * @tc.require: I5N1JI
279 */
280 HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_008, TestSize.Level1)
281 {
282 std::string name = "name";
283 PropertyCarrier propertyCarrier;
284 int32_t ret = output_->GetProperty(name, propertyCarrier);
285 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
286 channel_ = std::make_shared<MockCameraChannel>();
287 dataProcess_ = std::make_shared<MockDCameraSinkDataProcess>(channel_);
288 output_->dataProcesses_.emplace(CONTINUOUS_FRAME, dataProcess_);
289 ret = output_->GetProperty(name, propertyCarrier);
290 EXPECT_NE(DCAMERA_OK, ret);
291 }
292
293 /**
294 * @tc.name: dcamera_sink_output_test_010
295 * @tc.desc: Verify the UnInit function.
296 * @tc.type: FUNC
297 * @tc.require: I5N1JI
298 */
299 HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_010, TestSize.Level1)
300 {
301 auto callback = std::make_shared<DCameraSinkOutputResultCallback>(output_);
302 size_t capacity = 1;
303 auto dataBuffer = std::make_shared<DataBuffer>(capacity);
304 callback->OnPhotoResult(dataBuffer);
305 callback->OnVideoResult(dataBuffer);
306 EXPECT_EQ(true, capacity == 1);
307 }
308 } // namespace DistributedHardware
309 } // namespace OHOS
310