1 /*
2 * Copyright (c) 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 #include <gtest/gtest.h>
16 #include <atomic>
17 #include <memory>
18 #include <thread>
19 #include "metadata_utils.h"
20 #include "dmetadata_processor.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace DistributedHardware {
26
27 class DMetadataProcessorTest : public testing::Test {
28 public:
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp(void);
32 void TearDown(void);
33
34 std::shared_ptr<DMetadataProcessor> processor_ = nullptr;
35 };
36
37 constexpr const char* VALID_ABILITY_JSON = R"({
38 "ProtocolVer": "1.0",
39 "Position": "BACK",
40 "MetaData": "",
41 "Photo": {
42 "OutputFormat": [2],
43 "Resolution": { "2": ["1920*1080"] }
44 },
45 "Preview": {
46 "OutputFormat": [3],
47 "Resolution": { "3": ["1280*720"] }
48 }
49 })";
50
51 constexpr const char* INVALID_ABILITY_JSON = R"({ "ProtocolVer": "1.0", "Position": "BACK" )";
52
SetUpTestCase(void)53 void DMetadataProcessorTest::SetUpTestCase(void)
54 {
55 }
56
TearDownTestCase(void)57 void DMetadataProcessorTest::TearDownTestCase(void)
58 {
59 }
60
SetUp(void)61 void DMetadataProcessorTest::SetUp(void)
62 {
63 processor_ = std::make_shared<DMetadataProcessor>();
64 }
65
TearDown(void)66 void DMetadataProcessorTest::TearDown(void)
67 {
68 processor_ = nullptr;
69 }
70
71 /**
72 * @tc.name: dcamera_metadata_processor_test_001
73 * @tc.desc: Verify InitDCameraAbility with valid JSON
74 * @tc.type: FUNC
75 * @tc.require: AR
76 */
77 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_001, TestSize.Level1)
78 {
79 ASSERT_NE(processor_, nullptr);
80 DCamRetCode rc = processor_->InitDCameraAbility(VALID_ABILITY_JSON);
81 EXPECT_EQ(rc, DCamRetCode::SUCCESS);
82 }
83
84 /**
85 * @tc.name: dcamera_metadata_processor_test_002
86 * @tc.desc: Verify InitDCameraAbility with invalid JSON
87 * @tc.type: FUNC
88 * @tc.require: AR
89 */
90 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_002, TestSize.Level1)
91 {
92 ASSERT_NE(processor_, nullptr);
93
94 // Invalid JSON syntax -> FAILED
95 DCamRetCode rc = processor_->InitDCameraAbility(INVALID_ABILITY_JSON);
96 EXPECT_EQ(rc, DCamRetCode::FAILED);
97
98 // Empty string -> FAILED
99 rc = processor_->InitDCameraAbility("");
100 EXPECT_EQ(rc, DCamRetCode::FAILED);
101 }
102
103 /**
104 * @tc.name: dcamera_metadata_processor_test_003
105 * @tc.desc: Verify SetMetadataResultMode
106 * @tc.type: FUNC
107 * @tc.require: AR
108 */
109 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_003, TestSize.Level1)
110 {
111 ASSERT_NE(processor_, nullptr);
112 DCamRetCode rc = processor_->SetMetadataResultMode(ResultCallbackMode::PER_FRAME);
113 EXPECT_EQ(rc, DCamRetCode::SUCCESS);
114 rc = processor_->SetMetadataResultMode(ResultCallbackMode::ON_CHANGED);
115 EXPECT_EQ(rc, DCamRetCode::SUCCESS);
116
117 ResultCallbackMode invalidMode = static_cast<ResultCallbackMode>(99);
118 rc = processor_->SetMetadataResultMode(invalidMode);
119 EXPECT_EQ(rc, DCamRetCode::INVALID_ARGUMENT);
120 }
121
122 /**
123 * @tc.name: dcamera_metadata_processor_test_004
124 * @tc.desc: Verify Enable/Disable/Get metadata results
125 * @tc.type: FUNC
126 * @tc.require: AR
127 */
128 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_004, TestSize.Level1)
129 {
130 ASSERT_NE(processor_, nullptr);
131 processor_->InitDCameraAbility(VALID_ABILITY_JSON);
132
133 std::vector<MetaType> resultsToEnable = { OHOS_CONTROL_AE_AVAILABLE_MODES };
134 DCamRetCode rc = processor_->EnableMetadataResult(resultsToEnable);
135 EXPECT_EQ(rc, DCamRetCode::SUCCESS);
136
137 std::vector<MetaType> enabledResults;
138 processor_->GetEnabledMetadataResults(enabledResults);
139 EXPECT_EQ(enabledResults.size(), 1);
140 EXPECT_EQ(enabledResults[0], OHOS_CONTROL_AE_AVAILABLE_MODES);
141
142 std::vector<MetaType> resultsToDisable = { OHOS_CONTROL_AE_AVAILABLE_MODES };
143 rc = processor_->DisableMetadataResult(resultsToDisable);
144 EXPECT_EQ(rc, DCamRetCode::SUCCESS);
145
146 enabledResults.clear();
147 processor_->GetEnabledMetadataResults(enabledResults);
148 EXPECT_EQ(enabledResults.size(), 0);
149 }
150
151 /**
152 * @tc.name: dcamera_metadata_processor_test_005
153 * @tc.desc: Verify SaveResultMetadata with invalid arguments
154 * @tc.type: FUNC
155 * @tc.require: AR
156 */
157 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_005, TestSize.Level1)
158 {
159 ASSERT_NE(processor_, nullptr);
160 DCamRetCode rc = processor_->SaveResultMetadata("");
161 EXPECT_EQ(rc, DCamRetCode::INVALID_ARGUMENT);
162
163 rc = processor_->SaveResultMetadata("this is not base64");
164 EXPECT_EQ(rc, DCamRetCode::INVALID_ARGUMENT);
165 }
166
167 /**
168 * @tc.name: dcamera_metadata_processor_test_006
169 * @tc.desc: Verify result callback in ON_CHANGED mode
170 * @tc.type: FUNC
171 * @tc.require: AR
172 */
173 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_006, TestSize.Level1)
174 {
175 ASSERT_NE(processor_, nullptr);
176 processor_->SetMetadataResultMode(ResultCallbackMode::ON_CHANGED);
177
178 std::atomic<int> callbackCount = 0;
179 std::function<void(uint64_t, std::shared_ptr<OHOS::Camera::CameraMetadata>)> cb =
__anonc2730e570102(uint64_t timestamp, std::shared_ptr<OHOS::Camera::CameraMetadata> result) 180 [&](uint64_t timestamp, std::shared_ptr<OHOS::Camera::CameraMetadata> result) {
181 callbackCount++;
182 };
183 processor_->SetResultCallback(cb);
184
185 std::shared_ptr<CameraAbility> ability = std::make_shared<CameraAbility>(10, 10);
186 uint8_t aeMode = OHOS_CAMERA_AE_MODE_ON;
187 ability->addEntry(OHOS_CONTROL_AE_MODE, &aeMode, 1);
188 std::string metadataStr = OHOS::Camera::MetadataUtils::EncodeToString(ability);
189 std::string encodedResult = Base64Encode(reinterpret_cast<const unsigned char*>(metadataStr.c_str()),
190 metadataStr.length());
191
192 processor_->SaveResultMetadata(encodedResult);
193 EXPECT_EQ(callbackCount, 1);
194
195 processor_->SaveResultMetadata(encodedResult);
196 EXPECT_EQ(callbackCount, 1);
197
198 uint8_t newAeMode = OHOS_CAMERA_AE_MODE_OFF;
199 ability->updateEntry(OHOS_CONTROL_AE_MODE, &newAeMode, 1);
200 metadataStr = OHOS::Camera::MetadataUtils::EncodeToString(ability);
201 std::string newEncodedResult = Base64Encode(reinterpret_cast<const unsigned char*>(metadataStr.c_str()),
202 metadataStr.length());
203
204 processor_->SaveResultMetadata(newEncodedResult);
205 EXPECT_EQ(callbackCount, 2);
206 }
207
208 /**
209 * @tc.name: dcamera_metadata_processor_test_007
210 * @tc.desc: Verify result callback in PER_FRAME mode
211 * @tc.type: FUNC
212 * @tc.require: AR
213 */
214 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_007, TestSize.Level1)
215 {
216 ASSERT_NE(processor_, nullptr);
217 processor_->SetMetadataResultMode(ResultCallbackMode::PER_FRAME);
218
219 std::atomic<int> callbackCount = 0;
220 std::function<void(uint64_t, std::shared_ptr<OHOS::Camera::CameraMetadata>)> cb =
__anonc2730e570202(uint64_t timestamp, std::shared_ptr<OHOS::Camera::CameraMetadata> result) 221 [&](uint64_t timestamp, std::shared_ptr<OHOS::Camera::CameraMetadata> result) {
222 callbackCount++;
223 };
224 processor_->SetResultCallback(cb);
225
226 std::shared_ptr<CameraAbility> ability = std::make_shared<CameraAbility>(10, 10);
227 uint8_t aeMode = OHOS_CAMERA_AE_MODE_ON;
228 ability->addEntry(OHOS_CONTROL_AE_MODE, &aeMode, 1);
229 std::string metadataStr = OHOS::Camera::MetadataUtils::EncodeToString(ability);
230 std::string encodedResult = Base64Encode(reinterpret_cast<const unsigned char*>(metadataStr.c_str()),
231 metadataStr.length());
232
233 processor_->SaveResultMetadata(encodedResult);
234 EXPECT_EQ(callbackCount, 0);
235
236 processor_->UpdateResultMetadata(0);
237 EXPECT_EQ(callbackCount, 1);
238
239 processor_->UpdateResultMetadata(1);
240 EXPECT_EQ(callbackCount, 2);
241 }
242
243 /**
244 * @tc.name: dcamera_metadata_processor_test_008
245 * @tc.desc: Verify InitDCameraAbility with valid JSON containing Base64 metadata (Main Path)
246 * @tc.type: FUNC
247 * @tc.require: AR
248 */
249 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_008, TestSize.Level1)
250 {
251 ASSERT_NE(processor_, nullptr);
252
253 std::shared_ptr<CameraAbility> tempAbility = std::make_shared<CameraAbility>(10, 50);
254 const uint8_t cameraType = OHOS_CAMERA_TYPE_LOGICAL;
255 tempAbility->addEntry(OHOS_ABILITY_CAMERA_TYPE, &cameraType, 1);
256 std::string metadataStr = OHOS::Camera::MetadataUtils::EncodeToString(tempAbility);
257
258 std::string encodedMetadata = Base64Encode(reinterpret_cast<const unsigned char*>
259 (metadataStr.c_str()), metadataStr.length());
260
261 const std::string validAbilityWithMetadataJson =
262 std::string("{\n") +
263 " \"ProtocolVer\": \"1.0\",\n" +
264 " \"Position\": \"BACK\",\n" +
265 " \"MetaData\": \"" + encodedMetadata + "\",\n" +
266 " \"Photo\": { \"OutputFormat\": [2], \"Resolution\": { \"2\": [\"1920*1080\"] } },\n" +
267 " \"Preview\": { \"OutputFormat\": [3], \"Resolution\": { \"3\": [\"1280*720\"] } }\n" +
268 " }";
269
270 DCamRetCode rc = processor_->InitDCameraAbility(validAbilityWithMetadataJson);
271 EXPECT_EQ(rc, DCamRetCode::SUCCESS);
272
273 std::shared_ptr<CameraAbility> ability;
274 processor_->GetDCameraAbility(ability);
275 ASSERT_NE(ability, nullptr);
276
277 camera_metadata_item_t item;
278 int32_t ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CAMERA_TYPE, &item);
279 EXPECT_EQ(ret, CAM_META_SUCCESS);
280 EXPECT_EQ(item.data.u8[0], OHOS_CAMERA_TYPE_LOGICAL);
281 }
282
283 /**
284 * @tc.name: dcamera_metadata_processor_test_009
285 * @tc.desc: Verify ResetEnableResults actually enables all results
286 * @tc.type: FUNC
287 * @tc.require: AR
288 */
289 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_009, TestSize.Level1)
290 {
291 ASSERT_NE(processor_, nullptr);
292 processor_->InitDCameraAbility(VALID_ABILITY_JSON);
293
294 // Initially, disable one of the default results
295 std::vector<MetaType> resultsToDisable = { OHOS_CONTROL_AE_AVAILABLE_MODES };
296 processor_->DisableMetadataResult(resultsToDisable);
297
298 std::vector<MetaType> enabledResults;
299 processor_->GetEnabledMetadataResults(enabledResults);
300 // Assuming there are more than 1 default results, the size should be less than total
301 // (This part needs knowledge of all default keys to be perfectly asserted)
302
303 // Call the function under test
304 DCamRetCode rc = processor_->ResetEnableResults();
305 EXPECT_EQ(rc, DCamRetCode::SUCCESS);
306
307 // Assert that all results are now enabled.
308 enabledResults.clear();
309 processor_->GetEnabledMetadataResults(enabledResults);
310 // The exact number depends on default keys, but it should be greater than before.
311 // A better assertion would be to get ALL possible keys and check if sizes match.
312 EXPECT_GT(enabledResults.size(), 0);
313 }
314
315 /**
316 * @tc.name: dcamera_metadata_processor_test_010
317 * @tc.desc: Verify Enable/Disable with invalid/boundary inputs
318 * @tc.type: FUNC
319 * @tc.require: AR
320 */
321 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_010, TestSize.Level1)
322 {
323 ASSERT_NE(processor_, nullptr);
324 processor_->InitDCameraAbility(VALID_ABILITY_JSON);
325
326 std::vector<MetaType> invalidResults = { static_cast<MetaType>(99999) };
327 DCamRetCode rc = processor_->EnableMetadataResult(invalidResults);
328 EXPECT_EQ(rc, DCamRetCode::SUCCESS);
329
330 std::vector<MetaType> enabledResults;
331 processor_->GetEnabledMetadataResults(enabledResults);
332 EXPECT_EQ(enabledResults.size(), 0);
333
334 std::vector<MetaType> resultsToDisable = { OHOS_CONTROL_AE_AVAILABLE_MODES };
335 rc = processor_->DisableMetadataResult(resultsToDisable);
336 EXPECT_EQ(rc, DCamRetCode::SUCCESS);
337 processor_->GetEnabledMetadataResults(enabledResults);
338 EXPECT_EQ(enabledResults.size(), 0);
339 }
340
341 /**
342 * @tc.name: dcamera_metadata_processor_test_011
343 * @tc.desc: Verify concurrent access to processor does not cause crashes or deadlocks
344 * @tc.type: FUNC
345 * @tc.require: AR
346 */
347 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_011, TestSize.Level1)
348 {
349 ASSERT_NE(processor_, nullptr);
350 processor_->InitDCameraAbility(VALID_ABILITY_JSON);
351 processor_->SetMetadataResultMode(ResultCallbackMode::ON_CHANGED);
352
353 std::atomic<bool> stopFlag = false;
354 std::atomic<int> callbackCount = 0;
355
356 std::function<void(uint64_t, std::shared_ptr<OHOS::Camera::CameraMetadata>)> cb =
__anonc2730e570302(uint64_t ts, std::shared_ptr<OHOS::Camera::CameraMetadata> res) 357 [&](uint64_t ts, std::shared_ptr<OHOS::Camera::CameraMetadata> res) {
358 callbackCount++;
359 };
360 processor_->SetResultCallback(cb);
361
362 // Thread 1: Continuously saves new metadata
__anonc2730e570402() 363 std::thread producerThread([&stopFlag, this]() {
364 int i = 0;
365 while (!stopFlag) {
366 std::shared_ptr<CameraAbility> ability = std::make_shared<CameraAbility>(10, 50);
367 ability->addEntry(OHOS_CONTROL_ZOOM_RATIO, &i, 1); // Use changing data
368 std::string metaStr = OHOS::Camera::MetadataUtils::EncodeToString(ability);
369 std::string encoded = Base64Encode(reinterpret_cast<const unsigned char*>
370 (metaStr.c_str()), metaStr.length());
371 processor_->SaveResultMetadata(encoded);
372 i++;
373 std::this_thread::sleep_for(std::chrono::milliseconds(5));
374 }
375 });
376
377 // Thread 2: Continuously changes configuration
__anonc2730e570502() 378 std::thread configThread([&stopFlag, this]() {
379 std::vector<MetaType> enable = { OHOS_CONTROL_AE_AVAILABLE_MODES };
380 std::vector<MetaType> disable = { OHOS_CONTROL_AWB_AVAILABLE_MODES };
381 while (!stopFlag) {
382 processor_->EnableMetadataResult(enable);
383 processor_->DisableMetadataResult(disable);
384 processor_->ResetEnableResults();
385 std::this_thread::sleep_for(std::chrono::milliseconds(10));
386 }
387 });
388
389 // Let the threads run for a short period
390 std::this_thread::sleep_for(std::chrono::seconds(1));
391 stopFlag = true;
392
393 producerThread.join();
394 configThread.join();
395
396 // The main assertion is that the test completes without crashing or deadlocking.
397 // We can also check if callbacks were fired.
398 EXPECT_GT(callbackCount, 0);
399 SUCCEED();
400 }
401
402 /**
403 * @tc.name: dcamera_metadata_processor_test_012
404 * @tc.desc: Verify all branches of function GetMetadataItemData
405 * @tc.type: FUNC
406 * @tc.require: AR
407 */
408 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_012, TestSize.Level1)
409 {
410 ASSERT_NE(processor_, nullptr);
411 camera_metadata_item_t item;
412
413 // Test META_TYPE_BYTE
414 item.data_type = META_TYPE_BYTE;
415 uint8_t byteVal = 123;
416 item.data.u8 = &byteVal;
417 void* dataPtr = processor_->GetMetadataItemData(item);
418 ASSERT_NE(dataPtr, nullptr);
419 EXPECT_EQ(*(static_cast<uint8_t*>(dataPtr)), byteVal);
420
421 // Test META_TYPE_INT32
422 item.data_type = META_TYPE_INT32;
423 int32_t i32Val = -12345;
424 item.data.i32 = &i32Val;
425 dataPtr = processor_->GetMetadataItemData(item);
426 ASSERT_NE(dataPtr, nullptr);
427 EXPECT_EQ(*(static_cast<int32_t*>(dataPtr)), i32Val);
428
429 // Test META_TYPE_FLOAT
430 item.data_type = META_TYPE_FLOAT;
431 float fVal = 123.45f;
432 item.data.f = &fVal;
433 dataPtr = processor_->GetMetadataItemData(item);
434 ASSERT_NE(dataPtr, nullptr);
435 EXPECT_FLOAT_EQ(*(static_cast<float*>(dataPtr)), fVal);
436
437 // Test META_TYPE_INT64
438 item.data_type = META_TYPE_INT64;
439 int64_t i64Val = -1234567890;
440 item.data.i64 = &i64Val;
441 dataPtr = processor_->GetMetadataItemData(item);
442 ASSERT_NE(dataPtr, nullptr);
443 EXPECT_EQ(*(static_cast<int64_t*>(dataPtr)), i64Val);
444
445 // Test META_TYPE_DOUBLE
446 item.data_type = META_TYPE_DOUBLE;
447 double dVal = 12345.6789;
448 item.data.d = &dVal;
449 dataPtr = processor_->GetMetadataItemData(item);
450 ASSERT_NE(dataPtr, nullptr);
451 EXPECT_DOUBLE_EQ(*(static_cast<double*>(dataPtr)), dVal);
452
453 // Test META_TYPE_RATIONAL
454 item.data_type = META_TYPE_RATIONAL;
455 camera_rational_t r_val = {1, 2};
456 item.data.r = &r_val;
457 dataPtr = processor_->GetMetadataItemData(item);
458 ASSERT_NE(dataPtr, nullptr);
459 camera_rational_t* r_ptr = static_cast<camera_rational_t*>(dataPtr);
460 EXPECT_EQ(r_ptr->numerator, 1);
461 EXPECT_EQ(r_ptr->denominator, 2);
462 }
463
464 /**
465 * @tc.name: dcamera_metadata_processor_test_013
466 * @tc.desc: Verify functions ResizeMetadataHeader and ConvertToCameraMetadata
467 * @tc.type: FUNC
468 * @tc.require: AR
469 */
470 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_013, TestSize.Level1)
471 {
472 ASSERT_NE(processor_, nullptr);
473 common_metadata_header_t* header = nullptr;
474
475 processor_->ResizeMetadataHeader(header, 10, 50);
476 ASSERT_NE(header, nullptr);
477
478 common_metadata_header_t* old_header_ptr = header;
479 processor_->ResizeMetadataHeader(header, 20, 100);
480 ASSERT_NE(header, nullptr);
481 EXPECT_NE(header, old_header_ptr);
482
483 if (header != nullptr) {
484 OHOS::Camera::FreeCameraMetadataBuffer(header);
485 header = nullptr;
486 }
487
488 std::shared_ptr<CameraAbility> sourceAbility = std::make_shared<CameraAbility>(10, 50);
489 const uint8_t cameraType = OHOS_CAMERA_TYPE_LOGICAL;
490 ASSERT_EQ(sourceAbility->addEntry(OHOS_ABILITY_CAMERA_TYPE, &cameraType, 1), true);
491
492 common_metadata_header_t* sourceHeader = sourceAbility->get();
493 ASSERT_NE(sourceHeader, nullptr);
494
495 std::shared_ptr<OHOS::Camera::CameraMetadata> destMetadata =
496 std::make_shared<OHOS::Camera::CameraMetadata>(20, 100);
497
498 processor_->ConvertToCameraMetadata(sourceHeader, destMetadata);
499 ASSERT_NE(destMetadata, nullptr);
500
501 camera_metadata_item_t item;
502 int ret = OHOS::Camera::FindCameraMetadataItem(destMetadata->get(), OHOS_ABILITY_CAMERA_TYPE, &item);
503 EXPECT_EQ(ret, CAM_META_SUCCESS);
504 EXPECT_EQ(item.data.u8[0], cameraType);
505 }
506
507 /**
508 * @tc.name: dcamera_metadata_processor_test_014
509 * @tc.desc: Verify function PrintDCameraMetadata doesn't crash on various inputs
510 * @tc.type: FUNC
511 * @tc.require: AR
512 */
513 HWTEST_F(DMetadataProcessorTest, dcamera_metadata_processor_test_014, TestSize.Level1)
514 {
515 ASSERT_NE(processor_, nullptr);
516 std::shared_ptr<CameraAbility> retrievedAbility;
517 processor_->PrintDCameraMetadata(nullptr);
518 processor_->GetDCameraAbility(retrievedAbility);
519 EXPECT_EQ(retrievedAbility, nullptr);
520 DCamRetCode rc = processor_->InitDCameraAbility(VALID_ABILITY_JSON);
521 ASSERT_EQ(rc, DCamRetCode::SUCCESS);
522 processor_->GetDCameraAbility(retrievedAbility);
523 ASSERT_NE(retrievedAbility, nullptr);
524 processor_->PrintDCameraMetadata(retrievedAbility->get());
525
526 std::shared_ptr<CameraAbility> empty_ability = std::make_shared<CameraAbility>(10, 10);
527 processor_->PrintDCameraMetadata(empty_ability->get());
528 SUCCEED();
529 }
530
531 } // namespace DistributedHardware
532 } // namespace OHOS