1 /*
2 * Copyright (c) 2021 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 "utest_mpi_device_manager.h"
17 #include <iostream>
18 #include <gtest/gtest.h>
19 #include "mpi_device_manager.h"
20 #include "venc_controller.h"
21 #include "vo_controller.h"
22 #include "vi_controller.h"
23 #include "vpss_controller.h"
24
25 using namespace testing::ext;
26
27 // namespace OHOS::Camera
28 namespace OHOS::Camera {
29 class TestNode {
30 public:
~TestNode()31 ~TestNode() {}
TestNode()32 TestNode() {}
33 public:
CallBack(std::shared_ptr<FrameSpec> buffer)34 void CallBack(std::shared_ptr<FrameSpec> buffer) {}
Init()35 void Init()
36 {
37 std::shared_ptr<IDeviceManager> deviceManager = IDeviceManager::GetInstance();
38 deviceManager->SetNodeCallBack([&](std::shared_ptr<FrameSpec> frameBuffer) {
39 CallBack(frameBuffer);
40 });
41 }
42 };
43
44 class TestDevice {
45 public:
TestDevice()46 TestDevice() {};
~TestDevice()47 ~TestDevice() {};
48 public:
Init()49 void Init()
50 {
51 std::shared_ptr<IDeviceManager> deviceManager = IDeviceManager::GetInstance();
52 deviceManager->SetMetaDataCallBack([&](std::shared_ptr<CameraMetadata> meta) {
53 CallBack(meta);
54 });
55 };
CallBack(std::shared_ptr<CameraMetadata> meta)56 void CallBack(std::shared_ptr<CameraMetadata> meta) {};
57 };
58
59 std::shared_ptr<IDeviceManager> DM = nullptr;
SetUpTestCase(void)60 void UtestMpiDeviceManager::SetUpTestCase(void)
61 {
62 std::cout << "Camera::DeviceManager SetUpTestCase" << std::endl;
63 }
64
TearDownTestCase(void)65 void UtestMpiDeviceManager::TearDownTestCase(void)
66 {
67 std::cout << "Camera::DeviceManager TearDownTestCase" << std::endl;
68 }
69
SetUp(void)70 void UtestMpiDeviceManager::SetUp(void)
71 {
72 std::cout << "Camera::DeviceManager SetUp" << std::endl;
73 }
74
TearDown(void)75 void UtestMpiDeviceManager::TearDown(void)
76 {
77 std::cout << "Camera::DeviceManager TearDown.." << std::endl;
78 }
79
80 HWTEST_F(UtestMpiDeviceManager, Init_Success, TestSize.Level0)
81 {
82 DM = IDeviceManager::GetInstance();
83 RetCode rc = RC_OK;
84 if (DM != nullptr) {
85 rc = DM->Init();
86 }
87 EXPECT_EQ(RC_OK, rc);
88 }
89
90 HWTEST_F(UtestMpiDeviceManager, PowerUp_Failed, TestSize.Level0)
91 {
92 RetCode rc = RC_OK;
93 if (DM != nullptr) {
94 rc = DM->PowerUp(CAMERA_THIRD);
95 }
96 EXPECT_EQ(RC_ERROR, rc);
97 }
98
99 HWTEST_F(UtestMpiDeviceManager, PowerUp_Success, TestSize.Level0)
100 {
101 RetCode rc = RC_OK;
102 if (DM != nullptr) {
103 rc = DM->PowerUp(CAMERA_FIRST);
104 }
105 EXPECT_EQ(RC_OK, rc);
106 }
107
108 HWTEST_F(UtestMpiDeviceManager, GetSensor_Success, TestSize.Level0)
109 {
110 std::shared_ptr<ISensor> sensor;
111 if (DM != nullptr) {
112 sensor = DM->GetSensor(CAMERA_FIRST);
113 }
114 CameraMetadata meta(100, 2000);
115 sensor->Init(meta);
116 EXPECT_EQ(true, sensor != nullptr);
117 }
118
119 HWTEST_F(UtestMpiDeviceManager, GetSensor_Success2, TestSize.Level0)
120 {
121 std::shared_ptr<ISensor> sensor;
122 if (DM != nullptr) {
123 sensor = DM->GetSensor(CAMERA_SECOND);
124 }
125 CameraMetadata meta(100, 2000);
126 sensor->Init(meta);
127 EXPECT_EQ(true, sensor != nullptr);
128 }
129
130
131 HWTEST_F(UtestMpiDeviceManager, GetSensor_Failed, TestSize.Level0)
132 {
133 std::shared_ptr<ISensor> sensor;
134 if (DM != nullptr) {
135 sensor = DM->GetSensor(CAMERA_THIRD);
136 }
137 EXPECT_EQ(true, sensor == nullptr);
138 }
139
140 HWTEST_F(UtestMpiDeviceManager, GetManager_Success, TestSize.Level0)
141 {
142 std::shared_ptr<IManager> manager;
143 if (DM != nullptr) {
144 manager = DM->GetManager(DM_M_VI);
145 }
146 EXPECT_EQ(true, manager != nullptr);
147 }
148
149 HWTEST_F(UtestMpiDeviceManager, GetManager_Failed, TestSize.Level0)
150 {
151 std::shared_ptr<IManager> manager;
152 if (DM != nullptr) {
153 manager = DM->GetManager(DM_M_FLASH);
154 }
155 EXPECT_EQ(true, manager == nullptr);
156 }
157
158 HWTEST_F(UtestMpiDeviceManager, GetController_Success, TestSize.Level0)
159 {
160 std::shared_ptr<IController> controller;
161 if (DM != nullptr) {
162 controller = DM->GetController(DM_M_VI, DM_C_VI);
163 }
164 EXPECT_EQ(true, controller != nullptr);
165 }
166
167 HWTEST_F(UtestMpiDeviceManager, GetController_Failed1, TestSize.Level0)
168 {
169 std::shared_ptr<IController> controller;
170 if (DM != nullptr) {
171 controller = DM->GetController(DM_M_VI, DM_C_SENSOR);
172 }
173 EXPECT_EQ(true, controller == nullptr);
174 }
175
176 HWTEST_F(UtestMpiDeviceManager, GetController_Failed2, TestSize.Level0)
177 {
178 std::shared_ptr<IController> controller;
179 if (DM != nullptr) {
180 controller = DM->GetController(DM_M_VPSS, DM_C_VO);
181 }
182 EXPECT_EQ(true, controller == nullptr);
183 }
184
185 HWTEST_F(UtestMpiDeviceManager, GetCameraId_Success, TestSize.Level0)
186 {
187 std::vector<CameraId> cameraId;
188 if (DM != nullptr) {
189 cameraId = DM->GetCameraId();
190 }
191 for (auto iter = cameraId.cbegin(); iter != cameraId.cend(); iter++) {
192 EXPECT_EQ(true, (*iter) != CAMERA_MAX);
193 }
194 }
195
196 HWTEST_F(UtestMpiDeviceManager, Connect_Success, TestSize.Level0)
197 {
198 std::shared_ptr<IController> controller;
199 controller = DM->GetController(DM_M_VI, DM_C_VI);
200 std::shared_ptr<ViController> vi;
201 vi = std::static_pointer_cast<ViController>(controller);
202 vi->ConfigVi();
203 vi->StartVi();
204 RetCode rc = DM->Connect("vi#0", "out#0", "vpss#0", "in#0");
205 EXPECT_EQ(RC_OK, rc);
206
207 controller = DM->GetController(DM_M_VPSS, DM_C_VPSS);
208 std::shared_ptr<VpssController> vpss;
209 vpss = std::static_pointer_cast<VpssController>(controller);
210 vpss->ConfigVpss();
211 vpss->StartVpss();
212 rc = DM->Connect("vpss#0", "out#0", "vo#0", "in#0");
213 EXPECT_EQ(RC_OK, rc);
214
215 controller = DM->GetController(DM_M_VO, DM_C_VO);
216 std::shared_ptr<VoController> vo;
217 vo = std::static_pointer_cast<VoController>(controller);
218 rc = vo->ConfigVo();
219 EXPECT_EQ(RC_OK, rc);
220 rc = vo->StartVo();
221 EXPECT_EQ(RC_OK, rc);
222 sleep(1);
223 }
224
225 HWTEST_F(UtestMpiDeviceManager, SendFrameBuffer_Success, TestSize.Level0)
226 {
227 std::shared_ptr<FrameSpec> buffer = std::make_shared<FrameSpec>();
228 TestNode node;
229 node.Init();
230 TestDevice device;
231 device.Init();
232 DM->SendFrameBuffer(buffer);
233 }
234
235 HWTEST_F(UtestMpiDeviceManager, Configure_Success, TestSize.Level0)
236 {
237 std::shared_ptr<IController> controller;
238 controller = DM->GetController(DM_M_VI, DM_C_VI);
239 EXPECT_EQ(true, controller != nullptr);
240 std::shared_ptr<CameraMetadata> meta = std::make_shared<CameraMetadata>(100, 2000);
241 int32_t expo = 0;
242 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
243 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_AUTO;
244 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
245 RetCode rc = controller->Configure(meta);
246 EXPECT_EQ(RC_OK, rc);
247 sleep(1);
248 }
249
250 HWTEST_F(UtestMpiDeviceManager, SetAbilityMetaData_Success, TestSize.Level0)
251 {
252 std::vector<int32_t> abilityMetaData;
253 abilityMetaData.push_back(OHOS_SENSOR_EXPOSURE_TIME);
254 abilityMetaData.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
255 std::shared_ptr<IController> iController;
256 iController = DM->GetController(DM_M_VI, DM_C_VI);
257 EXPECT_EQ(true, iController != nullptr);
258 DM->SetAbilityMetaDataTag(abilityMetaData);
259 }
260
261 HWTEST_F(UtestMpiDeviceManager, UnConnect_Success, TestSize.Level0)
262 {
263 RetCode rc = RC_ERROR;
264 std::shared_ptr<IController> controller;
265 controller = DM->GetController(DM_M_VPSS, DM_C_VPSS);
266 std::shared_ptr<VpssController> vpss;
267 vpss = std::static_pointer_cast<VpssController>(controller);
268 rc = DM->UnConnect("vpss#0", "out#0", "vo#0", "in#0");
269 EXPECT_EQ(RC_OK, rc);
270 vpss->StopVpss();
271
272 controller = DM->GetController(DM_M_VO, DM_C_VO);
273 std::shared_ptr<VoController> vo;
274 vo = std::static_pointer_cast<VoController>(controller);
275 rc = vo->StopVo();
276 EXPECT_EQ(RC_OK, rc);
277
278 controller = DM->GetController(DM_M_VI, DM_C_VI);
279 std::shared_ptr<ViController> vi;
280 vi = std::static_pointer_cast<ViController>(controller);
281 rc = DM->UnConnect("vi#0", "out#0", "vpss#0", "in#0");
282 vi->StopVi();
283 EXPECT_EQ(RC_OK, rc);
284 }
285
286 HWTEST_F(UtestMpiDeviceManager, PowerDown_Success, TestSize.Level0)
287 {
288 RetCode rc = RC_OK;
289 if (DM != nullptr) {
290 rc = DM->PowerDown(CAMERA_FIRST);
291 }
292 EXPECT_EQ(RC_OK, rc);
293 }
294
295 HWTEST_F(UtestMpiDeviceManager, Connect_Failed1, TestSize.Level0)
296 {
297 std::shared_ptr<IController> controller;
298 controller = DM->GetController(DM_M_VI, DM_C_VI);
299 std::shared_ptr<ViController> vi;
300 vi = std::static_pointer_cast<ViController>(controller);
301 RetCode rc = DM->Connect("vi#0", "out#1", "venc#0", "in#0");
302 EXPECT_EQ(RC_OK, rc);
303 }
304
305 HWTEST_F(UtestMpiDeviceManager, Connect_Failed2, TestSize.Level0)
306 {
307 std::shared_ptr<IController> controller;
308 controller = DM->GetController(DM_M_VO, DM_C_VO);
309 std::shared_ptr<VoController> vo;
310 vo = std::static_pointer_cast<VoController>(controller);
311 RetCode rc = DM->Connect("vo#0", "out#4", "vi#0", "in#0");
312 EXPECT_EQ(RC_ERROR, rc);
313 }
314
315 HWTEST_F(UtestMpiDeviceManager, UnConnect_Failed1, TestSize.Level0)
316 {
317 RetCode rc = DM->UnConnect("vpss#0", "out#0", "vpss#0", "in#0");
318 EXPECT_EQ(RC_ERROR, rc);
319 }
320
321 HWTEST_F(UtestMpiDeviceManager, UnConnect_Failed2, TestSize.Level0)
322 {
323 RetCode rc = DM->UnConnect("test#0", "out#0", "vpss#0", "in#0");
324 EXPECT_EQ(RC_OK, rc);
325 }
326 }
327