1 /*
2 * Copyright (c) 2022 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 #define private public
18 #include "dcamera_source_state.h"
19 #undef private
20
21 #include "dcamera_source_dev.h"
22 #include "dcamera_utils_tools.h"
23 #include "distributed_camera_errno.h"
24 #include "dcamera_source_dev.h"
25 #include "mock_dcamera_source_state_listener.h"
26
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace DistributedHardware {
31 class DCameraSourceDevTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37
38 std::shared_ptr<DCameraSourceDev> camDev_;
39 std::shared_ptr<ICameraStateListener> stateListener_;
40 };
41
42 namespace {
43 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
44 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
45 const std::string TEST_REQID = "";
46 const std::string TEST_VER = "1.0";
47 const std::string TEST_ATTRS = "";
48 const int32_t TEST_WIDTH = 1920;
49 const int32_t TEST_HEIGTH = 1080;
50 const int32_t TEST_SLEEP_SEC = 200000;
51 std::string TEST_EVENT_CMD_JSON = R"({
52 "Type": "MESSAGE",
53 "dhId": "camrea_0",
54 "Command": "STATE_NOTIFY",
55 "Value": {"EventType": 1, "EventResult": 1, "EventContent": "TestContent"}
56 })";
57 }
58
SetUpTestCase(void)59 void DCameraSourceDevTest::SetUpTestCase(void)
60 {
61 }
62
TearDownTestCase(void)63 void DCameraSourceDevTest::TearDownTestCase(void)
64 {
65 }
66
SetUp(void)67 void DCameraSourceDevTest::SetUp(void)
68 {
69 stateListener_ = std::make_shared<MockDCameraSourceStateListener>();
70 camDev_ = std::make_shared<DCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_);
71 }
72
TearDown(void)73 void DCameraSourceDevTest::TearDown(void)
74 {
75 usleep(TEST_SLEEP_SEC);
76 camDev_ = nullptr;
77 stateListener_ = nullptr;
78 }
79
80 /**
81 * @tc.name: dcamera_source_dev_test_001
82 * @tc.desc: Verify source dev InitDCameraSourceDev.
83 * @tc.type: FUNC
84 * @tc.require: Issue Number
85 */
86 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_001, TestSize.Level1)
87 {
88 int32_t ret = camDev_->InitDCameraSourceDev();
89 EXPECT_EQ(DCAMERA_OK, ret);
90 }
91
92 /**
93 * @tc.name: dcamera_source_dev_test_002
94 * @tc.desc: Verify source dev RegisterDistributedHardware.
95 * @tc.type: FUNC
96 * @tc.require: Issue Number
97 */
98 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_002, TestSize.Level1)
99 {
100 camDev_->InitDCameraSourceDev();
101 int32_t ret = camDev_->RegisterDistributedHardware(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID,
102 TEST_VER, TEST_ATTRS);
103 EXPECT_EQ(DCAMERA_OK, ret);
104 }
105
106 /**
107 * @tc.name: dcamera_source_dev_test_003
108 * @tc.desc: Verify source dev UnRegisterDistributedHardware.
109 * @tc.type: FUNC
110 * @tc.require: Issue Number
111 */
112 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_003, TestSize.Level1)
113 {
114 camDev_->InitDCameraSourceDev();
115 int32_t ret = camDev_->UnRegisterDistributedHardware(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID);
116 EXPECT_EQ(DCAMERA_OK, ret);
117 }
118
119 /**
120 * @tc.name: dcamera_source_dev_test_004
121 * @tc.desc: Verify source dev DCameraNotify.
122 * @tc.type: FUNC
123 * @tc.require: Issue Number
124 */
125 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_004, TestSize.Level1)
126 {
127 camDev_->InitDCameraSourceDev();
128 int32_t ret = camDev_->DCameraNotify(TEST_EVENT_CMD_JSON);
129 EXPECT_EQ(DCAMERA_OK, ret);
130 }
131
132 /**
133 * @tc.name: dcamera_source_dev_test_005
134 * @tc.desc: Verify source dev OpenSession.
135 * @tc.type: FUNC
136 * @tc.require: Issue Number
137 */
138 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_005, TestSize.Level1)
139 {
140 DCameraIndex index;
141 index.devId_ = TEST_DEVICE_ID;
142 index.dhId_ = TEST_CAMERA_DH_ID_0;
143 camDev_->InitDCameraSourceDev();
144 int32_t ret = camDev_->OpenSession(index);
145 EXPECT_EQ(DCAMERA_OK, ret);
146 }
147
148 /**
149 * @tc.name: dcamera_source_dev_test_006
150 * @tc.desc: Verify source dev CloseSession.
151 * @tc.type: FUNC
152 * @tc.require: Issue Number
153 */
154 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_006, TestSize.Level1)
155 {
156 DCameraIndex index;
157 index.devId_ = TEST_DEVICE_ID;
158 index.dhId_ = TEST_CAMERA_DH_ID_0;
159 camDev_->InitDCameraSourceDev();
160 int32_t ret = camDev_->CloseSession(index);
161 EXPECT_EQ(DCAMERA_OK, ret);
162 }
163
164 /**
165 * @tc.name: dcamera_source_dev_test_007
166 * @tc.desc: Verify source dev ConfigCameraStreams.
167 * @tc.type: FUNC
168 * @tc.require: Issue Number
169 */
170 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_007, TestSize.Level1)
171 {
172 std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
173 std::shared_ptr<DCStreamInfo> streamInfo = std::make_shared<DCStreamInfo>();
174 streamInfo->streamId_ = 1;
175 streamInfo->width_ = TEST_WIDTH;
176 streamInfo->height_ = TEST_HEIGTH;
177 streamInfo->stride_ = 1;
178 streamInfo->format_ = 1;
179 streamInfo->dataspace_ = 1;
180 streamInfo->encodeType_ = ENCODE_TYPE_JPEG;
181 streamInfo->type_ = SNAPSHOT_FRAME;
182 streamInfos.push_back(streamInfo);
183 camDev_->InitDCameraSourceDev();
184 int32_t ret = camDev_->ConfigCameraStreams(streamInfos);
185 EXPECT_EQ(DCAMERA_OK, ret);
186 }
187
188 /**
189 * @tc.name: dcamera_source_dev_test_008
190 * @tc.desc: Verify source dev ReleaseCameraStreams.
191 * @tc.type: FUNC
192 * @tc.require: Issue Number
193 */
194 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_008, TestSize.Level1)
195 {
196 std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
197 std::vector<int> streamIds;
198 int streamId = 1;
199 streamIds.push_back(streamId);
200 std::shared_ptr<DCStreamInfo> streamInfo = std::make_shared<DCStreamInfo>();
201 streamInfo->streamId_ = 1;
202 streamInfo->width_ = TEST_WIDTH;
203 streamInfo->height_ = TEST_HEIGTH;
204 streamInfo->stride_ = 1;
205 streamInfo->format_ = 1;
206 streamInfo->dataspace_ = 1;
207 streamInfo->encodeType_ = ENCODE_TYPE_JPEG;
208 streamInfo->type_ = SNAPSHOT_FRAME;
209 streamInfos.push_back(streamInfo);
210 camDev_->InitDCameraSourceDev();
211 int32_t ret = camDev_->ConfigCameraStreams(streamInfos);
212 ret = camDev_->ReleaseCameraStreams(streamIds);
213 EXPECT_EQ(DCAMERA_OK, ret);
214 }
215
216 /**
217 * @tc.name: dcamera_source_dev_test_009
218 * @tc.desc: Verify source dev StartCameraCapture.
219 * @tc.type: FUNC
220 * @tc.require: Issue Number
221 */
222 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_009, TestSize.Level1)
223 {
224 std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
225 std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
226 captureInfo->streamIds_.push_back(1);
227 captureInfo->width_ = TEST_WIDTH;
228 captureInfo->height_ = TEST_HEIGTH;
229 captureInfo->stride_ = 1;
230 captureInfo->format_ = 1;
231 captureInfo->dataspace_ = 1;
232 captureInfo->encodeType_ = ENCODE_TYPE_H265;
233 captureInfo->type_ = CONTINUOUS_FRAME;
234 captureInfos.push_back(captureInfo);
235 camDev_->InitDCameraSourceDev();
236 int32_t ret = camDev_->StartCameraCapture(captureInfos);
237 EXPECT_EQ(DCAMERA_OK, ret);
238 }
239
240 /**
241 * @tc.name: dcamera_source_dev_test_010
242 * @tc.desc: Verify source dev StopCameraCapture.
243 * @tc.type: FUNC
244 * @tc.require: Issue Number
245 */
246 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_010, TestSize.Level1)
247 {
248 std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
249 std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
250 int streamId = 1;
251 captureInfo->streamIds_.push_back(streamId);
252 captureInfo->width_ = TEST_WIDTH;
253 captureInfo->height_ = TEST_HEIGTH;
254 captureInfo->stride_ = 1;
255 captureInfo->format_ = 1;
256 captureInfo->dataspace_ = 1;
257 captureInfo->encodeType_ = ENCODE_TYPE_H265;
258 captureInfo->type_ = CONTINUOUS_FRAME;
259 captureInfos.push_back(captureInfo);
260 camDev_->InitDCameraSourceDev();
261 int32_t ret = camDev_->StartCameraCapture(captureInfos);
262 std::vector<int> streamIds;
263 streamIds.push_back(streamId);
264 ret = camDev_->StopCameraCapture(streamIds);
265 EXPECT_EQ(DCAMERA_OK, ret);
266 }
267
268 /**
269 * @tc.name: dcamera_source_dev_test_011
270 * @tc.desc: Verify source dev UpdateCameraSettings.
271 * @tc.type: FUNC
272 * @tc.require: Issue Number
273 */
274 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_011, TestSize.Level1)
275 {
276 std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
277 std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
278 int streamId = 1;
279 captureInfo->streamIds_.push_back(streamId);
280 captureInfo->width_ = TEST_WIDTH;
281 captureInfo->height_ = TEST_HEIGTH;
282 captureInfo->stride_ = 1;
283 captureInfo->format_ = 1;
284 captureInfo->dataspace_ = 1;
285 captureInfo->encodeType_ = ENCODE_TYPE_H265;
286 captureInfo->type_ = CONTINUOUS_FRAME;
287 captureInfos.push_back(captureInfo);
288 camDev_->InitDCameraSourceDev();
289 int32_t ret = camDev_->StartCameraCapture(captureInfos);
290 std::vector<std::shared_ptr<DCameraSettings>> settings;
291 std::shared_ptr<DCameraSettings> setting = std::make_shared<DCameraSettings>();
292 setting->type_ = DCSettingsType::DISABLE_METADATA;
293 setting->value_ = "UpdateSettingsTest";
294 settings.push_back(setting);
295 ret = camDev_->UpdateCameraSettings(settings);
296 std::vector<int> streamIds;
297 streamIds.push_back(streamId);
298 camDev_->StopCameraCapture(streamIds);
299 EXPECT_EQ(DCAMERA_OK, ret);
300 }
301
302 /**
303 * @tc.name: dcamera_source_dev_test_012
304 * @tc.desc: Verify source dev GetStateInfo.
305 * @tc.type: FUNC
306 * @tc.require: Issue Number
307 */
308 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_012, TestSize.Level1)
309 {
310 std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
311 DCameraSourceEvent event(*camDev_, DCAMERA_EVENT_NOFIFY, camEvent);
312 camDev_->InitDCameraSourceDev();
313 camDev_->OnEvent(event);
314 camDev_->GetVersion();
315 int32_t ret = camDev_->GetStateInfo();
316 EXPECT_EQ(DCAMERA_OK, ret);
317 }
318 }
319 }