1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file expected 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 #include "camera_hdi_uttest_v1_1.h"
16
17 using namespace OHOS;
18 using namespace std;
19 using namespace testing::ext;
20 using namespace OHOS::Camera;
21
SetUpTestCase(void)22 void CameraHdiTestV1_1::SetUpTestCase(void) {}
TearDownTestCase(void)23 void CameraHdiTestV1_1::TearDownTestCase(void) {}
SetUp(void)24 void CameraHdiTestV1_1::SetUp(void)
25 {
26 cameraTest = std::make_shared<OHOS::Camera::Test>();
27 }
28
TearDown(void)29 void CameraHdiTestV1_1::TearDown(void)
30 {
31 cameraTest->Close();
32 }
33
34 /**
35 * @tc.name: Prelaunch
36 * @tc.desc: Prelaunch cameraId:device/0
37 * @tc.size: MediumTest
38 * @tc.type: Function
39 */
40 HWTEST_F(CameraHdiTestV1_1, SUB_DriverSystem_CameraHdiMg_0620, TestSize.Level1)
41 {
42 cameraTest->Init();
43 if (cameraTest->serviceV1_1 == nullptr) {
44 return;
45 }
46 cameraTest->Open();
47 if (cameraTest->cameraDeviceV1_1 == nullptr) {
48 return;
49 }
50 cameraTest->prelaunchConfig = std::make_shared<OHOS::HDI::Camera::V1_1::PrelaunchConfig>();
51 cameraTest->prelaunchConfig->cameraId = "device/0";
52 cameraTest->prelaunchConfig->streamInfos_V1_1 = {};
53 cameraTest->prelaunchConfig->setting = {};
54
55 cameraTest->rc = cameraTest->serviceV1_1->Prelaunch(*cameraTest->prelaunchConfig);
56 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
57 }
58
59 /**
60 * @tc.name: Prelaunch
61 * @tc.desc: Prelaunch cameraId:{}
62 * @tc.size: MediumTest
63 * @tc.type: Function
64 */
65 HWTEST_F(CameraHdiTestV1_1, SUB_DriverSystem_CameraHdiMg_0630, TestSize.Level1)
66 {
67 cameraTest->Init();
68 if (cameraTest->serviceV1_1 == nullptr) {
69 return;
70 }
71 cameraTest->Open();
72 if (cameraTest->cameraDeviceV1_1 == nullptr) {
73 return;
74 }
75 cameraTest->prelaunchConfig = std::make_shared<OHOS::HDI::Camera::V1_1::PrelaunchConfig>();
76 cameraTest->prelaunchConfig->cameraId = {};
77 cameraTest->prelaunchConfig->streamInfos_V1_1 = {};
78 cameraTest->prelaunchConfig->setting = {};
79
80 cameraTest->rc = cameraTest->serviceV1_1->Prelaunch(*cameraTest->prelaunchConfig);
81 EXPECT_EQ(true, cameraTest->rc == INVALID_ARGUMENT);
82 }
83
84 /**
85 * @tc.name: Prelaunch
86 * @tc.desc: Prelaunch cameraId:device/10
87 * @tc.size: MediumTest
88 * @tc.type: Function
89 */
90 HWTEST_F(CameraHdiTestV1_1, SUB_DriverSystem_CameraHdiMg_0640, TestSize.Level1)
91 {
92 cameraTest->Init();
93 if (cameraTest->serviceV1_1 == nullptr) {
94 return;
95 }
96 cameraTest->Open();
97 if (cameraTest->cameraDeviceV1_1 == nullptr) {
98 return;
99 }
100 cameraTest->prelaunchConfig = std::make_shared<OHOS::HDI::Camera::V1_1::PrelaunchConfig>();
101 cameraTest->prelaunchConfig->cameraId = "device/10";
102 cameraTest->prelaunchConfig->streamInfos_V1_1 = {};
103 cameraTest->prelaunchConfig->setting = {};
104
105 cameraTest->rc = cameraTest->serviceV1_1->Prelaunch(*cameraTest->prelaunchConfig);
106 EXPECT_EQ(true, cameraTest->rc == INVALID_ARGUMENT);
107 }
108
109 /**
110 * @tc.name: Prelaunch
111 * @tc.desc: Prelaunch cameraId:ABC
112 * @tc.size: MediumTest
113 * @tc.type: Function
114 */
115 HWTEST_F(CameraHdiTestV1_1, SUB_DriverSystem_CameraHdiMg_0650, TestSize.Level1)
116 {
117 cameraTest->Init();
118 if (cameraTest->serviceV1_1 == nullptr) {
119 return;
120 }
121 cameraTest->Open();
122 if (cameraTest->cameraDeviceV1_1 == nullptr) {
123 return;
124 }
125 cameraTest->prelaunchConfig = std::make_shared<OHOS::HDI::Camera::V1_1::PrelaunchConfig>();
126 cameraTest->prelaunchConfig->cameraId = "ABC123";
127 cameraTest->prelaunchConfig->streamInfos_V1_1 = {};
128 cameraTest->prelaunchConfig->setting = {};
129
130 cameraTest->rc = cameraTest->serviceV1_1->Prelaunch(*cameraTest->prelaunchConfig);
131 EXPECT_EQ(true, cameraTest->rc == INVALID_ARGUMENT);
132 }
133
134 /**
135 * @tc.name: SUB_DriverSystem_CameraHdiMg_0660
136 * @tc.desc: OHOS_ABILITY_PRELAUNCH_AVAILABLE
137 * @tc.size: MediumTest
138 * @tc.type: Function
139 */
140 HWTEST_F(CameraHdiTestV1_1, SUB_DriverSystem_CameraHdiMg_0660, TestSize.Level1)
141 {
142 cameraTest->Init();
143 if (cameraTest->serviceV1_1 == nullptr) {
144 return;
145 }
146 cameraTest->Open();
147 if (cameraTest->cameraDeviceV1_1 == nullptr) {
148 return;
149 }
150 EXPECT_NE(cameraTest->ability, nullptr);
151 common_metadata_header_t* data = cameraTest->ability->get();
152 EXPECT_NE(data, nullptr);
153 camera_metadata_item_t entry;
154 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_PRELAUNCH_AVAILABLE, &entry);
155 EXPECT_EQ(ret, CAM_META_SUCCESS);
156 std::cout << "OHOS_ABILITY_PRELAUNCH_AVAILABLE value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
157 }
158
159 /**
160 * @tc.name: GetDefaultSettings
161 * @tc.desc: GetDefaultSettings
162 * @tc.size: MediumTest
163 * @tc.type: Function
164 */
165 HWTEST_F(CameraHdiTestV1_1, SUB_DriverSystem_CameraHdiMg_0670, TestSize.Level1)
166 {
167 cameraTest->Init();
168 if (cameraTest->serviceV1_1 == nullptr) {
169 return;
170 }
171 cameraTest->Open();
172 if (cameraTest->cameraDeviceV1_1 == nullptr) {
173 return;
174 }
175 EXPECT_EQ(true, cameraTest->cameraDevice != nullptr);
176 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetDefaultSettings(cameraTest->abilityVec);
177 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
178 }
179
180 /**
181 * @tc.name: GetDefaultSettings
182 * @tc.desc: GetDefaultSettings
183 * @tc.size: MediumTest
184 * @tc.type: Function
185 */
186 HWTEST_F(CameraHdiTestV1_1, SUB_DriverSystem_CameraHdiMg_0680, TestSize.Level1)
187 {
188 cameraTest->Init();
189 if (cameraTest->serviceV1_1 == nullptr) {
190 return;
191 }
192 cameraTest->Open();
193 if (cameraTest->cameraDeviceV1_1 == nullptr) {
194 return;
195 }
196 std::shared_ptr<CameraAbility> ability;
197 std::shared_ptr<CameraAbility> abilitys;
198 EXPECT_EQ(true, cameraTest->cameraDevice != nullptr);
199 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetDefaultSettings(cameraTest->abilityVec);
200 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
201 MetadataUtils::ConvertVecToMetadata(cameraTest->abilityVec, ability);
202 common_metadata_header_t* data = ability->get();
203 std::string metastring = FormatCameraMetadataToString(data);
204 if (!metastring.empty()) {
205 std::cout << "DefaultSettings = " << metastring << std::endl;
206 }
207
208 std::shared_ptr<CameraMetadata> modeSetting = std::make_shared<CameraMetadata>(2, 128);
209 int64_t expoTime = 0;
210 modeSetting->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &expoTime, 1);
211 std::vector<uint8_t> metaVec;
212 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
213 cameraTest->rc = cameraTest->cameraDevice->UpdateSettings(metaVec);
214 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
215
216 cameraTest->abilityVec.clear();
217 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetDefaultSettings(cameraTest->abilityVec);
218 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
219 MetadataUtils::ConvertVecToMetadata(cameraTest->abilityVec, abilitys);
220 common_metadata_header_t* datas = abilitys->get();
221 std::string metastrings = FormatCameraMetadataToString(datas);
222 if (!metastrings.empty()) {
223 std::cout << "DefaultSettings1 = " << metastrings << std::endl;
224 }
225 }