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_metadata_utils_uttest.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 CameraMetadataUtilsTest::SetUpTestCase(void) {}
TearDownTestCase(void)23 void CameraMetadataUtilsTest::TearDownTestCase(void) {}
SetUp(void)24 void CameraMetadataUtilsTest::SetUp(void)
25 {
26     printf("CameraMetadataUtilsTest start\r\n");
27 }
28 
TearDown(void)29 void CameraMetadataUtilsTest::TearDown(void)
30 {
31     printf("CameraMetadataUtilsTest end\r\n");
32 }
33 
PrintMetaDataInfo(const shared_ptr<CameraMetadata> & metadata)34 static void PrintMetaDataInfo(const shared_ptr<CameraMetadata> &metadata)
35 {
36     if (metadata == nullptr) {
37         cout << "metadata is nullptr" <<endl;
38         return;
39     }
40     common_metadata_header_t *header = metadata->get();
41     if (header == nullptr) {
42         cout << "header is nullptr" <<endl;
43         return;
44     }
45     cout << "PrintMetaDataInfo begin++++++++++" << endl;
46     cout << "version       : " << header->version << endl;
47     cout << "size          : " << header->size << endl;
48     cout << "item_count    : " << header->item_count << endl;
49     cout << "item_capacity : " << header->item_capacity << endl;
50     cout << "data_count    : " << header->data_count << endl;
51     cout << "data_capacity : " << header->data_capacity << endl;
52     cout << "PrintMetaDataInfo end-----------" << endl;
53 }
54 
55 /**
56  * @tc.name: Metadata_Utils_001
57  * @tc.desc: metadata = nullptr
58  * @tc.size: MediumTest
59  * @tc.type: Function
60  */
61 HWTEST_F(CameraMetadataUtilsTest, Metadata_Utils_001, TestSize.Level1)
62 {
63     int32_t ret;
64     auto metaData = make_shared<CameraMetadata>(100, 200);
65     int8_t cameraType[] = {10, 30};
66     int32_t cameraFpsRange[] = {10, 30};
67     uint32_t cameraMesureExposureTime[] = {10};
68     int64_t sensorExposeTime[] = {30};
69     float sensorInfoPhysicalSize[] = {0.1};
70     float jpegGpsCoordinates[] = {0.1, 0.1};
71 
72     camera_rational_t controlAeCompenstationStep[] = {{1, 3}};
73     metaData->addEntry(OHOS_ABILITY_CAMERA_TYPE, cameraType, 1);
74     metaData->addEntry(OHOS_ABILITY_FPS_RANGES, cameraFpsRange, 2);
75     metaData->addEntry(OHOS_CONTROL_MANUAL_EXPOSURE_TIME, cameraMesureExposureTime, 1);
76     metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, sensorExposeTime, 1);
77     metaData->addEntry(OHOS_SENSOR_INFO_PHYSICAL_SIZE, sensorInfoPhysicalSize, 1);
78     metaData->addEntry(OHOS_JPEG_GPS_COORDINATES, jpegGpsCoordinates, 1);
79     metaData->addEntry(OHOS_CONTROL_AE_COMPENSATION_STEP, controlAeCompenstationStep, 1);
80 
81     vector<uint8_t> metaVec;
82     ret = MetadataUtils::ConvertMetadataToVec(metaData, metaVec);
83     EXPECT_EQ(ret, true);
84     shared_ptr<CameraMetadata> metaDataBack1;
85     MetadataUtils::ConvertVecToMetadata(metaVec, metaDataBack1);
86     EXPECT_NE(metaDataBack1, nullptr);
87 
88     MessageParcel messageParcel;
89     ret = MetadataUtils::EncodeCameraMetadata(metaData, messageParcel);
90     EXPECT_EQ(ret, true);
91     shared_ptr<CameraMetadata> metaDataBack2;
92     MetadataUtils::DecodeCameraMetadata(messageParcel, metaDataBack2);
93     EXPECT_NE(metaDataBack2, nullptr);
94 
95     string metaString = MetadataUtils::EncodeToString(metaData);
96     std::cout << "metaString: " << metaString << std::endl;
97     auto metaDataBack3 = MetadataUtils::DecodeFromString(metaString);
98     EXPECT_NE(metaDataBack3, nullptr);
99 }
100 /**
101  * @tc.name: Metadata_Utils_002
102  * @tc.desc: metadata = nullptr
103  * @tc.size: MediumTest
104  * @tc.type: Function
105  */
106 HWTEST_F(CameraMetadataUtilsTest, Metadata_Utils_002, TestSize.Level1)
107 {
108     int32_t ret;
109     auto metaData = nullptr;
110     vector<uint8_t> metaVec;
111     ret = MetadataUtils::ConvertMetadataToVec(metaData, metaVec);
112     EXPECT_EQ(ret, false);
113 
114     MessageParcel messageParcel;
115     ret = MetadataUtils::EncodeCameraMetadata(metaData, messageParcel);
116     EXPECT_EQ(ret, false);
117 
118     string metaString = MetadataUtils::EncodeToString(metaData);
119     std::cout << "metaString: " << metaString << std::endl;
120     EXPECT_EQ(metaString, "");
121 }
122 
123 /**
124  * @tc.name: Metadata_Utils_003
125  * @tc.desc: metadata is empty
126  * @tc.size: MediumTest
127  * @tc.type: Function
128  */
129 HWTEST_F(CameraMetadataUtilsTest, Metadata_Utils_003, TestSize.Level1)
130 {
131     int32_t ret;
132     auto metaData = make_shared<CameraMetadata>(100, 200);
133     vector<uint8_t> metaVec;
134     ret = MetadataUtils::ConvertMetadataToVec(metaData, metaVec);
135     EXPECT_EQ(ret, true);
136 
137     MessageParcel messageParcel;
138     ret = MetadataUtils::EncodeCameraMetadata(metaData, messageParcel);
139     EXPECT_EQ(ret, true);
140 
141     string metaString = MetadataUtils::EncodeToString(metaData);
142     std::cout << "metaString: " << metaString << std::endl;
143 }
144 
145 /**
146  * @tc.name: Metadata_Utils_004
147  * @tc.desc: metadata is invalid
148  * @tc.size: MediumTest
149  * @tc.type: Function
150  */
151 HWTEST_F(CameraMetadataUtilsTest, Metadata_Utils_004, TestSize.Level1)
152 {
153     int32_t ret;
154     uint8_t temp[20] = {0};
155     vector<uint8_t> metaVec;
156 
157     auto metaData0 = make_shared<CameraMetadata>(MAX_ITEM_CAPACITY, MAX_DATA_CAPACITY);
158     for (int i = 0; i < MAX_SUPPORTED_TAGS + 1; i++) {
159         metaData0->addEntry(OHOS_ABILITY_CAMERA_TYPE, temp, 1);
160     }
161     PrintMetaDataInfo(metaData0);
162     ret = MetadataUtils::ConvertMetadataToVec(metaData0, metaVec);
163     EXPECT_EQ(ret, false);
164 
165     auto metaData1 = make_shared<CameraMetadata>(MAX_ITEM_CAPACITY, MAX_DATA_CAPACITY);
166     auto meta1 = metaData1->get();
167     meta1->item_capacity = MAX_ITEM_CAPACITY + 1;
168     PrintMetaDataInfo(metaData1);
169     ret = MetadataUtils::ConvertMetadataToVec(metaData1, metaVec);
170     EXPECT_EQ(ret, false);
171 
172     meta1->item_capacity = MAX_ITEM_CAPACITY;
173     meta1->data_capacity = MAX_DATA_CAPACITY + 1;
174     PrintMetaDataInfo(metaData1);
175     ret = MetadataUtils::ConvertMetadataToVec(metaData1, metaVec);
176     EXPECT_EQ(ret, false);
177 
178     meta1->data_capacity = MAX_DATA_CAPACITY;
179     auto itemData0 = new uint8_t[MAX_SUPPORTED_ITEMS + 1];
180     metaData1->addEntry(OHOS_ABILITY_CAMERA_TYPE, itemData0, MAX_SUPPORTED_ITEMS + 1);
181     delete [] itemData0;
182     PrintMetaDataInfo(metaData1);
183     ret = MetadataUtils::ConvertMetadataToVec(metaData1, metaVec);
184     EXPECT_EQ(ret, false);
185 }
186 
187 /**
188  * @tc.name: Metadata_Utils_005
189  * @tc.desc: ConvertVecToMetadata
190  * @tc.size: MediumTest
191  * @tc.type: Function
192  */
193 HWTEST_F(CameraMetadataUtilsTest, Metadata_Utils_005, TestSize.Level1)
194 {
195     //item.count = MAX_SUPPORTED_ITEMS + 1
196     uint32_t exceedMaxSupportedItem = MAX_SUPPORTED_ITEMS + 1;
197     vector<uint8_t> metaVec = {232, 3, 0, 0, 16, 39, 0, 0, 160, 134, 1, 0};
198     metaVec.resize(28);
199     metaVec[24] = exceedMaxSupportedItem >> 24;
200     metaVec[25] = exceedMaxSupportedItem >> 16;
201     metaVec[26] = exceedMaxSupportedItem >> 8;
202     metaVec[27] = exceedMaxSupportedItem;
203     auto metaData = make_shared<CameraMetadata>(MAX_ITEM_CAPACITY, MAX_DATA_CAPACITY);
204     MetadataUtils::ConvertVecToMetadata(metaVec, metaData);
205 
206     //dataCapacity = MAX_DATA_CAPACITY + 1
207     uint32_t exceedMaxDataCapacity = MAX_DATA_CAPACITY +1;
208     metaVec[8] = exceedMaxDataCapacity >> 24;
209     metaVec[9] = exceedMaxDataCapacity >> 16;
210     metaVec[10] = exceedMaxDataCapacity >> 8;
211     metaVec[11] = exceedMaxDataCapacity;
212     MetadataUtils::ConvertVecToMetadata(metaVec, metaData);
213 
214     //itemCapacity = MAX_ITEM_CAPACITY + 1
215     uint32_t exceedMaxItemCapacity = MAX_ITEM_CAPACITY + 1;
216     metaVec[4] = exceedMaxItemCapacity >> 24;
217     metaVec[5] = exceedMaxItemCapacity >> 16;
218     metaVec[6] = exceedMaxItemCapacity >> 8;
219     metaVec[7] = exceedMaxItemCapacity;
220     MetadataUtils::ConvertVecToMetadata(metaVec, metaData);
221 
222     //tagCount = MAX_SUPPORTED_TAGS + 1
223     uint32_t exceedMaxSupportedTags = MAX_SUPPORTED_TAGS + 1;
224     metaVec[0] = exceedMaxSupportedTags >> 24;
225     metaVec[1] = exceedMaxSupportedTags >> 16;
226     metaVec[2] = exceedMaxSupportedTags >> 8;
227     metaVec[3] = exceedMaxSupportedTags;
228     MetadataUtils::ConvertVecToMetadata(metaVec, metaData);
229 }
230 
231 /**
232  * @tc.name: Metadata_Utils_006
233  * @tc.desc: DecodeFromString
234  * @tc.size: MediumTest
235  * @tc.type: Function
236  */
237 HWTEST_F(CameraMetadataUtilsTest, Metadata_Utils_006, TestSize.Level1)
238 {
239     //DecodeFromString::totalLen < headerLength
240     std::string str = "test";
241     auto metaData = MetadataUtils::DecodeFromString(str);
242 
243     //DecodeFromString::totalLen < ((decodeData - &setting[0]) + itemLen)
244     str = "CameraMetadataUtilsTest.Metadata_Utils_006";
245     metaData = MetadataUtils::DecodeFromString(str);
246 }
247