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 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 #include <string>
18 #include "meta/meta.h"
19 #include "unittest_log.h"
20 #include <cstdlib>
21 #include <string>
22
23 using namespace std;
24 using namespace testing::ext;
25 using namespace OHOS;
26 using namespace OHOS::Media;
27
28 namespace OHOS {
29 namespace Media {
30 namespace MetaFuncUT {
31 class MetaInnerUnitTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34
35 static void TearDownTestCase(void);
36
37 void SetUp(void);
38
39 void TearDown(void);
40
41 std::shared_ptr<Meta> metaIn = nullptr;
42 std::shared_ptr<Meta> metaOut = nullptr;
43 std::shared_ptr<MessageParcel> parcel = nullptr;
44 };
45
SetUpTestCase(void)46 void MetaInnerUnitTest::SetUpTestCase(void) {}
47
TearDownTestCase(void)48 void MetaInnerUnitTest::TearDownTestCase(void) {}
49
SetUp(void)50 void MetaInnerUnitTest::SetUp(void)
51 {
52 std::cout << "[SetUp]: SetUp!!!, test: ";
53 const ::testing::TestInfo *testInfo_ = ::testing::UnitTest::GetInstance()->current_test_info();
54 std::string testName = testInfo_->name();
55 std::cout << testName << std::endl;
56 parcel = std::make_shared<MessageParcel>();
57 metaIn = std::make_shared<Meta>();
58 metaOut = std::make_shared<Meta>();
59 }
60
TearDown(void)61 void MetaInnerUnitTest::TearDown(void)
62 {
63 metaIn->Clear();
64 metaOut->Clear();
65 parcel = nullptr;
66 std::cout << "[TearDown]: over!!!" << std::endl;
67 }
68
69 /**
70 * @tc.name: SetGet_PlainStringKey_Int
71 * @tc.desc: SetGet_PlainStringKey_Int
72 * @tc.type: FUNC
73 */
74 HWTEST_F(MetaInnerUnitTest, SetGet_PlainStringKey_Int, TestSize.Level1)
75 {
76 int32_t valueOut = 0;
77 int32_t valueIn = 141;
78 SetMetaData(*metaIn, "width", valueIn);
79 GetMetaData(*metaIn, "width", valueOut);
80 EXPECT_EQ(valueOut, valueIn);
81 }
82
83 /**
84 * @tc.name: SetGet_Int32
85 * @tc.desc: SetGet_Int32
86 * @tc.type: FUNC
87 */
88 HWTEST_F(MetaInnerUnitTest, SetGet_Int32, TestSize.Level1)
89 {
90 int32_t valueOut = 0;
91 int32_t valueIn = 141;
92 metaIn->Set<Tag::APP_PID>(valueIn);
93 metaIn->Get<Tag::APP_PID>(valueOut);
94 EXPECT_EQ(valueOut, valueIn);
95 }
96
97 /**
98 * @tc.name: SetGet_Double
99 * @tc.desc: SetGet_Double
100 * @tc.type: FUNC
101 */
102 HWTEST_F(MetaInnerUnitTest, SetGet_Double, TestSize.Level1)
103 {
104 double valueOut = 0;
105 double valueIn = 1.59261111;
106 metaIn->Set<Tag::VIDEO_FRAME_RATE>(valueIn);
107 metaIn->Get<Tag::VIDEO_FRAME_RATE>(valueOut);
108 ASSERT_DOUBLE_EQ(valueOut, valueIn);
109 }
110
111 /**
112 * @tc.name: SetGet_Long
113 * @tc.desc: SetGet_Long
114 * @tc.type: FUNC
115 */
116 HWTEST_F(MetaInnerUnitTest, SetGet_Long, TestSize.Level1)
117 {
118 int64_t valueOut = 0;
119 int64_t valueIn = 17592186044673;
120 metaIn->Set<Tag::MEDIA_DURATION>(valueIn);
121 metaIn->Get<Tag::MEDIA_DURATION>(valueOut);
122 EXPECT_EQ(valueOut, valueIn);
123 }
124
125 /**
126 * @tc.name: SetGet_String
127 * @tc.desc: SetGet_String
128 * @tc.type: FUNC
129 */
130 HWTEST_F(MetaInnerUnitTest, SetGet_String, TestSize.Level1)
131 {
132 std::string valueOut = "";
133 std::string valueIn = "STRING_TESTVALUE";
134 metaIn->Set<Tag::MEDIA_FILE_URI>(valueIn);
135 metaIn->Get<Tag::MEDIA_FILE_URI>(valueOut);
136 EXPECT_EQ(valueOut, valueIn);
137 }
138
139 /**
140 * @tc.name: SetGet_Data_Int32
141 * @tc.desc: SetGet_Data_Int32
142 * @tc.type: FUNC
143 */
144 HWTEST_F(MetaInnerUnitTest, SetGet_Data_Int32, TestSize.Level1)
145 {
146 int32_t valueOut = 0;
147 int32_t valueIn = 141;
148 metaIn->SetData(Tag::APP_PID, valueIn);
149 metaIn->GetData(Tag::APP_PID, valueOut);
150 EXPECT_EQ(valueOut, valueIn);
151 }
152
153 /**
154 * @tc.name: SetGet_Data_Int32_PlainInput
155 * @tc.desc: SetGet_Data_Int32_PlainInput
156 * @tc.type: FUNC
157 */
158 HWTEST_F(MetaInnerUnitTest, SetGet_Data_Int32_PlainInput, TestSize.Level1)
159 {
160 int32_t valueOut = 0;
161 std::shared_ptr<Meta> meta_ = std::make_shared<Meta>();
162 metaIn->SetData(Tag::APP_PID, 111);
163 metaIn->GetData(Tag::APP_PID, valueOut);
164 EXPECT_EQ(valueOut, 111);
165 }
166
167 /**
168 * @tc.name: SetGet_Data_String_PlainInput
169 * @tc.desc: SetGet_Data_String_PlainInput
170 * @tc.type: FUNC
171 */
172 HWTEST_F(MetaInnerUnitTest, SetGet_Data_String_PlainInput, TestSize.Level1)
173 {
174 std::string valueOut = "";
175 metaIn->SetData(Tag::MEDIA_LYRICS, "Test Input");
176 metaIn->GetData(Tag::MEDIA_LYRICS, valueOut);
177 EXPECT_EQ(valueOut, "Test Input");
178 }
179
180 /**
181 * @tc.name: SetGet_Data_Int32_Using_Parcel
182 * @tc.desc: SetGet_Data_Int32_Using_Parcel
183 * @tc.type: FUNC
184 */
185 HWTEST_F(MetaInnerUnitTest, SetGet_Int32_Using_Parcel, TestSize.Level1)
186 {
187 int32_t valueOut = 0;
188 int32_t valueIn = 141;
189 metaIn->Set<Tag::APP_PID>(valueIn);
190 ASSERT_TRUE(metaIn->ToParcel(*parcel));
191 ASSERT_TRUE(metaOut->FromParcel(*parcel));
192 metaOut->Get<Tag::APP_PID>(valueOut);
193 EXPECT_EQ(valueOut, valueIn);
194 }
195
196 /**
197 * @tc.name: SetGet_Data_Int32_Using_Parcel
198 * @tc.desc: SetGet_Data_Int32_Using_Parcel
199 * @tc.type: FUNC
200 */
201 HWTEST_F(MetaInnerUnitTest, SetGet_Data_Int32_Using_Parcel, TestSize.Level1)
202 {
203 int32_t valueOut = 0;
204 int32_t valueIn = 141;
205 metaIn->SetData(Tag::APP_PID, valueIn);
206 ASSERT_TRUE(metaIn->ToParcel(*parcel));
207 ASSERT_TRUE(metaOut->FromParcel(*parcel));
208 metaOut->GetData(Tag::APP_PID, valueOut);
209 EXPECT_EQ(valueOut, valueIn);
210 }
211
212 /**
213 * @tc.name: SetGet_MetaData_Int32
214 * @tc.desc: SetGet_MetaData_Int32
215 * @tc.type: FUNC
216 */
217 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Int32, TestSize.Level1)
218 {
219 int32_t valueOut = 0;
220 int32_t valueIn = 141;
221 SetMetaData(*metaIn, Tag::APP_PID, valueIn);
222 GetMetaData(*metaIn, Tag::APP_PID, valueOut);
223 EXPECT_EQ(valueOut, valueIn);
224 }
225
226 /**
227 * @tc.name: SetGet_MetaData_Int32_PlainInput
228 * @tc.desc: SetGet_MetaData_Int32_PlainInput
229 * @tc.type: FUNC
230 */
231 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Int32_PlainInput, TestSize.Level1)
232 {
233 int32_t valueOut = 0;
234 SetMetaData(*metaIn, Tag::APP_PID, 141);
235 GetMetaData(*metaIn, Tag::APP_PID, valueOut);
236 EXPECT_EQ(valueOut, 141);
237 }
238
239 /**
240 * @tc.name: SetGet_MetaData_Enum_As_Int32
241 * @tc.desc: SetGet_MetaData_Enum_As_Int32
242 * @tc.type: FUNC
243 */
244 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Enum_As_Int32, TestSize.Level1)
245 {
246 int32_t valueOut = 0;
247 int32_t valueIn = static_cast<int32_t>(Plugins::VideoRotation::VIDEO_ROTATION_90);
248 SetMetaData(*metaIn, Tag::VIDEO_ROTATION, valueIn);
249 GetMetaData(*metaIn, Tag::VIDEO_ROTATION, valueOut);
250 EXPECT_EQ(valueOut, valueIn);
251 }
252
253 /**
254 * @tc.name: SetGet_MetaData_Int32_Using_Parcel
255 * @tc.desc: SetGet_MetaData_Int32_Using_Parcel
256 * @tc.type: FUNC
257 */
258 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Int32_Using_Parcel, TestSize.Level1)
259 {
260 int32_t valueOut = 0;
261 int32_t valueIn = 141;
262 SetMetaData(*metaIn, Tag::APP_PID, valueIn);
263 ASSERT_TRUE(metaIn->ToParcel(*parcel));
264 ASSERT_TRUE(metaOut->FromParcel(*parcel));
265 metaOut->Get<Tag::APP_PID>(valueOut);
266 EXPECT_EQ(valueOut, valueIn);
267 valueOut = 0;
268 GetMetaData(*metaOut, Tag::APP_PID, valueOut);
269 EXPECT_EQ(valueOut, valueIn);
270 }
271
272 /**
273 * @tc.name: SetGet_MetaData_Enum_As_Int32_Using_Parcel
274 * @tc.desc: SetGet_MetaData_Enum_As_Int32_Using_Parcel
275 * @tc.type: FUNC
276 */
277 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Enum_As_Int32_Using_Parcel, TestSize.Level1)
278 {
279 Plugins::VideoRotation valueOut;
280 int32_t valueIn = static_cast<int32_t>(Plugins::VideoRotation::VIDEO_ROTATION_90);
281 SetMetaData(*metaIn, Tag::VIDEO_ROTATION, valueIn);
282 ASSERT_TRUE(metaIn->ToParcel(*parcel));
283 ASSERT_TRUE(metaOut->FromParcel(*parcel));
284 metaOut->Get<Tag::VIDEO_ROTATION>(valueOut);
285 EXPECT_EQ(static_cast<int32_t>(valueOut), valueIn);
286 int32_t valueIntOut = 0;
287 GetMetaData(*metaOut, Tag::VIDEO_ROTATION, valueIntOut);
288 EXPECT_EQ(valueIntOut, valueIn);
289 }
290
291 /**
292 * @tc.name: SetGet_MetaData_Enum_As_Int64_Using_Parcel
293 * @tc.desc: SetGet_MetaData_Enum_As_Int64_Using_Parcel
294 * @tc.type: FUNC
295 */
296 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Enum_As_Int64_Using_Parcel, TestSize.Level1)
297 {
298 Plugins::AudioChannelLayout valueOut;
299 int64_t valueIn = static_cast<int64_t>(Plugins::AudioChannelLayout::HOA_ORDER1_FUMA);
300 SetMetaData(*metaIn, Tag::AUDIO_CHANNEL_LAYOUT, valueIn);
301 ASSERT_TRUE(metaIn->ToParcel(*parcel));
302 ASSERT_TRUE(metaOut->FromParcel(*parcel));
303 metaOut->Get<Tag::AUDIO_CHANNEL_LAYOUT>(valueOut);
304 EXPECT_EQ(static_cast<int64_t>(valueOut), valueIn);
305 int64_t valueInt64Out = 0;
306 GetMetaData(*metaOut, Tag::AUDIO_CHANNEL_LAYOUT, valueInt64Out);
307 EXPECT_EQ(valueOut, valueIn);
308 }
309
310 map<TagType, int32_t> testInt32Data = {
311 // Int32 or Int32 Enum
312 {Tag::APP_UID, 11},
313 {Tag::APP_PID, 22},
314 {Tag::APP_TOKEN_ID, 33},
315 {Tag::REQUIRED_IN_BUFFER_CNT, 44},
316 {Tag::REQUIRED_IN_BUFFER_SIZE, 11},
317 {Tag::REQUIRED_OUT_BUFFER_CNT, 11},
318 {Tag::REQUIRED_OUT_BUFFER_SIZE, 11},
319 {Tag::BUFFERING_SIZE, 11},
320 {Tag::WATERLINE_HIGH, 11},
321 {Tag::WATERLINE_LOW, 11},
322 {Tag::AUDIO_CHANNEL_COUNT, 11},
323 {Tag::AUDIO_SAMPLE_RATE, 11},
324 {Tag::AUDIO_SAMPLE_PER_FRAME, 22},
325 {Tag::AUDIO_OUTPUT_CHANNELS, 33},
326 {Tag::AUDIO_MPEG_VERSION, 11},
327 {Tag::AUDIO_MPEG_LAYER, 123},
328 {Tag::AUDIO_AAC_LEVEL, 12},
329 {Tag::AUDIO_MAX_INPUT_SIZE, 21},
330 {Tag::AUDIO_MAX_OUTPUT_SIZE, 32},
331 {Tag::VIDEO_WIDTH, 12},
332 {Tag::VIDEO_HEIGHT, 31},
333 {Tag::VIDEO_DELAY, 54},
334 {Tag::VIDEO_MAX_SURFACE_NUM, 45},
335 {Tag::VIDEO_H264_LEVEL, 12},
336 {Tag::AUDIO_AAC_IS_ADTS, 33},
337 {Tag::AUDIO_COMPRESSION_LEVEL, 44},
338 {Tag::AUDIO_BITS_PER_CODED_SAMPLE, 44},
339 {Tag::MEDIA_TRACK_COUNT, 11},
340 {Tag::REGULAR_TRACK_ID, 13},
341 {Tag::VIDEO_SCALE_TYPE, 14},
342 {Tag::VIDEO_I_FRAME_INTERVAL, 11},
343 {Tag::MEDIA_PROFILE, 13},
344 {Tag::VIDEO_ENCODE_QUALITY, 112},
345 {Tag::AUDIO_AAC_SBR, 111},
346 {Tag::AUDIO_OBJECT_NUMBER, 113},
347 {Tag::AUDIO_FLAC_COMPLIANCE_LEVEL, 13},
348 {Tag::MEDIA_LEVEL, 14},
349 {Tag::VIDEO_STRIDE, 17},
350 {Tag::VIDEO_DISPLAY_WIDTH, 19},
351 {Tag::VIDEO_DISPLAY_HEIGHT, 23},
352 {Tag::SRC_INPUT_TYPE, static_cast<int32_t>(Plugins::SrcInputType::AUD_ES)},
353 {Tag::AUDIO_SAMPLE_FORMAT, static_cast<int32_t>(Plugins::AudioSampleFormat::SAMPLE_S16LE)},
354 {Tag::VIDEO_PIXEL_FORMAT, static_cast<int32_t>(Plugins::VideoPixelFormat::YUV411P)},
355 {Tag::MEDIA_TYPE, static_cast<int32_t>(Plugins::MediaType::AUDIO)},
356 {Tag::VIDEO_H264_PROFILE, static_cast<int32_t>(Plugins::VideoH264Profile::BASELINE)},
357 {Tag::VIDEO_ROTATION, static_cast<int32_t>(Plugins::VideoRotation::VIDEO_ROTATION_90)},
358 {Tag::VIDEO_COLOR_PRIMARIES, static_cast<int32_t>(Plugins::ColorPrimary::BT2020)},
359 {Tag::VIDEO_COLOR_TRC, static_cast<int32_t>(Plugins::TransferCharacteristic::BT1361)},
360 {Tag::VIDEO_COLOR_MATRIX_COEFF, static_cast<int32_t>(Plugins::MatrixCoefficient::BT2020_CL)},
361 {Tag::VIDEO_H265_PROFILE, static_cast<int32_t>(Plugins::HEVCProfile::HEVC_PROFILE_MAIN_10_HDR10)},
362 {Tag::VIDEO_H265_LEVEL, static_cast<int32_t>(Plugins::HEVCLevel::HEVC_LEVEL_41)},
363 {Tag::VIDEO_CHROMA_LOCATION, static_cast<int32_t>(Plugins::ChromaLocation::BOTTOM)},
364 {Tag::MEDIA_FILE_TYPE, static_cast<int32_t>(Plugins::FileType::AMR)},
365 {Tag::VIDEO_ENCODE_BITRATE_MODE, static_cast<int32_t>(Plugins::VideoEncodeBitrateMode::CBR)},
366 // UINT8_T
367 {Tag::AUDIO_AAC_PROFILE, static_cast<int32_t>(Plugins::AudioAacProfile::ELD)},
368 {Tag::AUDIO_AAC_STREAM_FORMAT, static_cast<int32_t>(Plugins::AudioAacStreamFormat::ADIF)},
369 // Bool
370 {Tag::VIDEO_COLOR_RANGE, 1},
371 {Tag::VIDEO_REQUEST_I_FRAME, 0},
372 {Tag::MEDIA_HAS_VIDEO, 1},
373 {Tag::MEDIA_HAS_AUDIO, 0},
374 {Tag::MEDIA_END_OF_STREAM, 1},
375 {Tag::VIDEO_IS_HDR_VIVID, 1},
376 {Tag::VIDEO_FRAME_RATE_ADAPTIVE_MODE, 1}
377 };
378
379 /**
380 * @tc.name: SetGet_MetaData_All_As_Int32_Using_Parcel
381 * @tc.desc: SetGet_MetaData_All_As_Int32_Using_Parcel
382 * @tc.type: FUNC
383 */
384 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Int32_Using_ParcelPackage, TestSize.Level1)
385 {
386 for (auto item : testInt32Data) {
387 int32_t valueIn = item.second;
388 SetMetaData(*metaIn, item.first, valueIn);
389 }
390 ASSERT_TRUE(metaIn->ToParcel(*parcel));
391 ASSERT_TRUE(metaOut->FromParcel(*parcel));
392 for (auto item : testInt32Data) {
393 int32_t valueIn = item.second;
394 int32_t valueOut = 0;
395 ASSERT_TRUE(GetMetaData(*metaOut, item.first, valueOut));
396 std::cout << item.first << " , " << valueOut << " , " << valueIn << std::endl;
397 EXPECT_EQ(valueOut, valueIn);
398 }
399 }
400
401 map<TagType, int64_t> testInt64Data = {
402 // Int64 or Int64 Enum
403 {Tag::APP_FULL_TOKEN_ID, 1234567890001},
404 {Tag::MEDIA_DURATION, 1234567890002},
405 {Tag::MEDIA_BITRATE, 1234567890003},
406 {Tag::MEDIA_START_TIME, 1234567890004},
407 {Tag::USER_FRAME_PTS, 1234567890005},
408 {Tag::USER_PUSH_DATA_TIME, 1234567890006},
409 {Tag::MEDIA_FILE_SIZE, 1234567890007},
410 {Tag::MEDIA_POSITION, 1234567890008},
411 {Tag::MEDIA_TIME_STAMP, 1234567890009},
412 {Tag::AUDIO_CHANNEL_LAYOUT, static_cast<int64_t>(Plugins::AudioChannelLayout::CH_10POINT2)},
413 {Tag::AUDIO_OUTPUT_CHANNEL_LAYOUT, static_cast<int64_t>(Plugins::AudioChannelLayout::HOA_ORDER3_FUMA)}
414 };
415
416 /**
417 * @tc.name: SetGet_MetaData_All_As_Int64_Using_ParcelPackage
418 * @tc.desc: SetGet_MetaData_All_As_Int64_Using_ParcelPackage
419 * @tc.type: FUNC
420 */
421 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Int64_Using_ParcelPackage, TestSize.Level1)
422 {
423 for (auto item : testInt64Data) {
424 int64_t valueIn = item.second;
425 SetMetaData(*metaIn, item.first, valueIn);
426 }
427 ASSERT_TRUE(metaIn->ToParcel(*parcel));
428 ASSERT_TRUE(metaOut->FromParcel(*parcel));
429 for (auto item : testInt64Data) {
430 int64_t valueIn = item.second;
431 int64_t valueOut = 0;
432 GetMetaData(*metaOut, item.first, valueOut);
433 std::cout << item.first << " , " << valueOut << " , " << valueIn << std::endl;
434 EXPECT_EQ(valueOut, valueIn);
435 }
436 }
437
438 map<TagType, float> testFloatData = {
439 // Float
440 {Tag::MEDIA_LATITUDE, 1.01f},
441 {Tag::MEDIA_LONGITUDE, 1.02f}
442 };
443
444 /**
445 * @tc.name: SetGet_MetaData_All_As_Float_Using_ParcelPackage
446 * @tc.desc: SetGet_MetaData_All_As_Float_Using_ParcelPackage
447 * @tc.type: FUNC
448 */
449 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Float_Using_ParcelPackage, TestSize.Level1)
450 {
451 for (auto item : testFloatData) {
452 float valueIn = item.second;
453 metaIn->SetData(item.first, valueIn);
454 }
455 ASSERT_TRUE(metaIn->ToParcel(*parcel));
456 ASSERT_TRUE(metaOut->FromParcel(*parcel));
457 for (auto item : testFloatData) {
458 float valueIn = item.second;
459 float valueOut = 0.0f;
460 metaOut->GetData(item.first, valueOut);
461 ASSERT_FLOAT_EQ(valueOut, valueIn);
462 }
463 }
464
465 map<TagType, double> testDoubleData = {
466 // Double
467 {Tag::VIDEO_FRAME_RATE, 1.01},
468 {Tag::VIDEO_CAPTURE_RATE, 1.02}
469 };
470
471 /**
472 * @tc.name: SetGet_MetaData_All_As_Double_Using_ParcelPackage
473 * @tc.desc: SetGet_MetaData_All_As_Double_Using_ParcelPackage
474 * @tc.type: FUNC
475 */
476 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Double_Using_ParcelPackage, TestSize.Level1)
477 {
478 for (auto item : testDoubleData) {
479 double valueIn = item.second;
480 metaIn->SetData(item.first, valueIn);
481 }
482 ASSERT_TRUE(metaIn->ToParcel(*parcel));
483 ASSERT_TRUE(metaOut->FromParcel(*parcel));
484 for (auto item : testDoubleData) {
485 double valueIn = item.second;
486 double valueOut = 0.0;
487 metaOut->GetData(item.first, valueOut);
488 ASSERT_DOUBLE_EQ(valueOut, valueIn);
489 }
490 }
491
492 map<TagType, std::string> testStringData = {
493 // String
494 {Tag::MIME_TYPE, "String MIME_TYPE"},
495 {Tag::MEDIA_FILE_URI, "String MEDIA_FILE_URI"},
496 {Tag::MEDIA_TITLE, "String MEDIA_TITLE"},
497 {Tag::MEDIA_ARTIST, "String MEDIA_ARTIST"},
498 {Tag::MEDIA_LYRICIST, "String MEDIA_LYRICIST"},
499 {Tag::MEDIA_ALBUM, "String MEDIA_ALBUM"},
500 {Tag::MEDIA_ALBUM_ARTIST, "String MEDIA_ALBUM_ARTIST"},
501 {Tag::MEDIA_DATE, "String MEDIA_DATE"},
502 {Tag::MEDIA_COMMENT, "String MEDIA_COMMENT"},
503 {Tag::MEDIA_GENRE, "String MEDIA_GENRE"},
504 {Tag::MEDIA_COPYRIGHT, "String MEDIA_COPYRIGHT"},
505 {Tag::MEDIA_LANGUAGE, "String MEDIA_LANGUAGE"},
506 {Tag::MEDIA_DESCRIPTION, "String MEDIA_DESCRIPTION"},
507 {Tag::USER_TIME_SYNC_RESULT, "String USER_TIME_SYNC_RESULT"},
508 {Tag::USER_AV_SYNC_GROUP_INFO, "String USER_AV_SYNC_GROUP_INFO"},
509 {Tag::USER_SHARED_MEMORY_FD, "String USER_SHARED_MEMORY_FD"},
510 {Tag::MEDIA_AUTHOR, "String MEDIA_AUTHOR"},
511 {Tag::MEDIA_COMPOSER, "String MEDIA_COMPOSER"},
512 {Tag::MEDIA_LYRICS, "String MEDIA_LYRICS"},
513 {Tag::MEDIA_CODEC_NAME, "String MEDIA_CODEC_NAME"},
514 {Tag::PROCESS_NAME, "String PROCESS_NAME"},
515 {Tag::MEDIA_CREATION_TIME, "String MEDIA_CREATION_TIME"},
516 };
517
518 /**
519 * @tc.name: SetGet_MetaData_All_As_String_Using_ParcelPackage
520 * @tc.desc: SetGet_MetaData_All_As_String_Using_ParcelPackage
521 * @tc.type: FUNC
522 */
523 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_String_Using_ParcelPackage, TestSize.Level1)
524 {
525 for (auto item : testStringData) {
526 std::string valueIn = item.second;
527 metaIn->SetData(item.first, valueIn);
528 }
529 ASSERT_TRUE(metaIn->ToParcel(*parcel));
530 ASSERT_TRUE(metaOut->FromParcel(*parcel));
531 for (auto item : testStringData) {
532 std::string valueIn = item.second;
533 std::string valueOut = "String Value";
534 metaOut->GetData(item.first, valueOut);
535 std::cout << item.first << " , " << valueOut << " , " << valueIn << std::endl;
536 EXPECT_EQ(valueOut, valueIn);
537 }
538 }
539
540 std::vector<uint8_t> vectorUint8MediaCodec{1, 2, 3};
541 std::vector<uint8_t> vectorUint8MediaCover{1, 2, 3, 4};
542 map<TagType, std::vector<uint8_t>> testVetcorInt8Data = {
543 // vector<uint8_t>
544 {Tag::MEDIA_CODEC_CONFIG, vectorUint8MediaCodec},
545 {Tag::MEDIA_COVER, vectorUint8MediaCover},
546 {Tag::AUDIO_VORBIS_IDENTIFICATION_HEADER, vectorUint8MediaCover},
547 {Tag::AUDIO_VORBIS_SETUP_HEADER, vectorUint8MediaCover},
548 {Tag::AUDIO_VIVID_METADATA, vectorUint8MediaCover},
549 };
550
551 /**
552 * @tc.name: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
553 * @tc.desc: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
554 * @tc.type: FUNC
555 */
556 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage, TestSize.Level1)
557 {
558 for (auto item : testVetcorInt8Data) {
559 std::vector<uint8_t> valueIn = item.second;
560 metaIn->SetData(item.first, valueIn);
561 }
562 ASSERT_TRUE(metaIn->ToParcel(*parcel));
563 ASSERT_TRUE(metaOut->FromParcel(*parcel));
564 for (auto item : testVetcorInt8Data) {
565 std::vector<uint8_t> valueIn = item.second;
566 std::vector<uint8_t> valueOut;
567 metaOut->GetData(item.first, valueOut);
568 EXPECT_EQ(valueOut, valueIn);
569 }
570 }
571
PrepareInMeta(std::shared_ptr<Meta> & inMeta)572 void PrepareInMeta(std::shared_ptr<Meta>& inMeta)
573 {
574 for (auto item : testVetcorInt8Data) {
575 std::vector<uint8_t> valueInVecInt8 = item.second;
576 inMeta->SetData(item.first, valueInVecInt8);
577 }
578 for (auto item : testFloatData) {
579 float valueInFloat = item.second;
580 inMeta->SetData(item.first, valueInFloat);
581 }
582 for (auto item : testDoubleData) {
583 double valueInDouble = item.second;
584 inMeta->SetData(item.first, valueInDouble);
585 }
586 for (auto item : testStringData) {
587 std::string valueInStr = item.second;
588 inMeta->SetData(item.first, valueInStr);
589 }
590 for (auto item : testInt32Data) {
591 int32_t valueInInt32 = item.second;
592 SetMetaData(*inMeta, item.first, valueInInt32);
593 }
594 }
595
CheckOutMeta(const std::shared_ptr<Meta> & outMeta)596 void CheckOutMeta(const std::shared_ptr<Meta>& outMeta)
597 {
598 for (auto item : testInt32Data) {
599 int32_t valueInInt32 = item.second;
600 int32_t valueOutInt32 = 0;
601 GetMetaData(*outMeta, item.first, valueOutInt32);
602 EXPECT_EQ(valueOutInt32, valueInInt32);
603 }
604 for (auto item : testStringData) {
605 std::string valueInStr = item.second;
606 std::string valueOutStr = "String Value";
607 outMeta->GetData(item.first, valueOutStr);
608 EXPECT_EQ(valueOutStr, valueInStr);
609 }
610 for (auto item : testFloatData) {
611 float valueInFloat = item.second;
612 float valueOutFloat = 0.0f;
613 outMeta->GetData(item.first, valueOutFloat);
614 ASSERT_FLOAT_EQ(valueOutFloat, valueInFloat);
615 }
616 for (auto item : testDoubleData) {
617 double valueInDouble = item.second;
618 double valueOutDouble = 0.0;
619 outMeta->GetData(item.first, valueOutDouble);
620 ASSERT_DOUBLE_EQ(valueOutDouble, valueInDouble);
621 }
622 for (auto item : testVetcorInt8Data) {
623 std::vector<uint8_t> valueInVecInt8 = item.second;
624 std::vector<uint8_t> valueOutVecInt8;
625 outMeta->GetData(item.first, valueOutVecInt8);
626 EXPECT_EQ(valueOutVecInt8, valueInVecInt8);
627 }
628 }
629
630 /**
631 * @tc.name: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
632 * @tc.desc: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
633 * @tc.type: FUNC
634 */
635 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Mix_Using_ParcelPackage, TestSize.Level1)
636 {
637 PrepareInMeta(metaIn);
638 ASSERT_TRUE(metaIn->ToParcel(*parcel));
639 ASSERT_TRUE(metaOut->FromParcel(*parcel));
640 CheckOutMeta(metaOut);
641 }
642
643 /**
644 * @tc.name: SetGet_MetaData_All_As_Mix_Using_AssignCopy
645 * @tc.desc: SetGet_MetaData_All_As_Mix_Using_AssignCopy
646 * @tc.type: FUNC
647 */
648 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Mix_Using_AssignCopy, TestSize.Level1)
649 {
650 PrepareInMeta(metaIn);
651 Meta metaCopy = std::move(*metaIn);
652 for (auto item : testInt32Data) {
653 int32_t valueOutInt32 = 0;
654 ASSERT_FALSE(GetMetaData(*metaIn, item.first, valueOutInt32));
655 }
656 CheckOutMeta(make_shared<Meta>(metaCopy));
657 }
658
659 /**
660 * @tc.name: SetGet_MetaData_All_As_Mix_Using_SwapCopy
661 * @tc.desc: SetGet_MetaData_All_As_Mix_Using_SwapCopy
662 * @tc.type: FUNC
663 */
664 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Mix_Using_SwapCopy, TestSize.Level1)
665 {
666 PrepareInMeta(metaIn);
667 Meta metaCopy(std::move(*metaIn));
668 for (auto item : testInt32Data) {
669 int32_t valueOutInt32 = 0;
670 ASSERT_FALSE(GetMetaData(*metaIn, item.first, valueOutInt32));
671 }
672 CheckOutMeta(make_shared<Meta>(metaCopy));
673 }
674
675 /**
676 * @tc.name: SetGet_Data_DrmStruct_Using_Parcel
677 * @tc.desc: SetGet_Data_DrmStruct_Using_Parcel
678 * @tc.type: FUNC
679 */
680 HWTEST_F(MetaInnerUnitTest, SetGet_Data_DrmStruct_Using_Parcel, TestSize.Level1)
681 {
682 uint8_t iv[META_DRM_IV_SIZE] = {
683 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43, 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2c
684 };
685 uint8_t keyId[META_DRM_KEY_ID_SIZE] = {
686 0x3a, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43, 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2a
687 };
688 Plugins::MetaDrmCencInfo *drmCencInfoIn = (Plugins::MetaDrmCencInfo *)malloc(sizeof(Plugins::MetaDrmCencInfo));
689 drmCencInfoIn->algo = Plugins::MetaDrmCencAlgorithm::META_DRM_ALG_CENC_SM4_CBC;
690 drmCencInfoIn->keyIdLen = META_DRM_KEY_ID_SIZE;
691 auto error = memcpy_s(drmCencInfoIn->keyId, sizeof(drmCencInfoIn->keyId), keyId, META_DRM_KEY_ID_SIZE);
692 ASSERT_EQ(error, EOK);
693 drmCencInfoIn->ivLen = META_DRM_IV_SIZE;
694 error = memcpy_s(drmCencInfoIn->iv, sizeof(drmCencInfoIn->iv), iv, META_DRM_IV_SIZE);
695 ASSERT_EQ(error, EOK);
696 drmCencInfoIn->encryptBlocks = 0;
697 drmCencInfoIn->skipBlocks = 0;
698 drmCencInfoIn->firstEncryptOffset = 0;
699 drmCencInfoIn->subSampleNum = 1;
700 for (uint32_t i = 0; i < drmCencInfoIn->subSampleNum; i++) {
701 drmCencInfoIn->subSample[i].clearHeaderLen = 0x10;
702 drmCencInfoIn->subSample[i].payLoadLen = 0;
703 }
704 std::vector<uint8_t> drmCencVecIn((uint8_t *)drmCencInfoIn,
705 ((uint8_t *)drmCencInfoIn) + sizeof(Plugins::MetaDrmCencInfo));
706 std::shared_ptr<Meta> metaIn = nullptr;
707 std::shared_ptr<Meta> metaOut = nullptr;
708 std::shared_ptr<MessageParcel> parcel = nullptr;
709 parcel = std::make_shared<MessageParcel>();
710 metaIn = std::make_shared<Meta>();
711 metaOut = std::make_shared<Meta>();
712 metaIn->SetData(Tag::DRM_CENC_INFO, drmCencVecIn);
713 ASSERT_TRUE(metaIn->ToParcel(*parcel));
714 ASSERT_TRUE(metaOut->FromParcel(*parcel));
715
716 std::vector<uint8_t> drmCencVecOut;
717 metaOut->GetData(Tag::DRM_CENC_INFO, drmCencVecOut);
718 Plugins::MetaDrmCencInfo *drmCencInfoOut = reinterpret_cast<Plugins::MetaDrmCencInfo *>(&drmCencVecOut[0]);
719
720 EXPECT_EQ(drmCencInfoIn->keyIdLen, drmCencInfoOut->keyIdLen);
721 free(drmCencInfoIn);
722 }
723 } // namespace MetaFuncUT
724 } // namespace Media
725 } // namespace OHOS
726