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 "meta/format.h"
20 #include "unittest_log.h"
21 #include <cstdlib>
22 #include <string>
23
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::Media;
28
29 namespace OHOS {
30 namespace Media {
31 namespace MetaFuncUT {
32 class MetaInnerUnitTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35
36 static void TearDownTestCase(void);
37
38 void SetUp(void);
39
40 void TearDown(void);
41
42 std::shared_ptr<Meta> metaIn = nullptr;
43 std::shared_ptr<Meta> metaOut = nullptr;
44 std::shared_ptr<MessageParcel> parcel = nullptr;
45 };
46
SetUpTestCase(void)47 void MetaInnerUnitTest::SetUpTestCase(void) {}
48
TearDownTestCase(void)49 void MetaInnerUnitTest::TearDownTestCase(void) {}
50
SetUp(void)51 void MetaInnerUnitTest::SetUp(void)
52 {
53 std::cout << "[SetUp]: SetUp!!!, test: ";
54 const ::testing::TestInfo *testInfo_ = ::testing::UnitTest::GetInstance()->current_test_info();
55 std::string testName = testInfo_->name();
56 std::cout << testName << std::endl;
57 parcel = std::make_shared<MessageParcel>();
58 metaIn = std::make_shared<Meta>();
59 metaOut = std::make_shared<Meta>();
60 }
61
TearDown(void)62 void MetaInnerUnitTest::TearDown(void)
63 {
64 metaIn->Clear();
65 metaOut->Clear();
66 parcel = nullptr;
67 std::cout << "[TearDown]: over!!!" << std::endl;
68 }
69
70 /**
71 * @tc.name: SetGet_PlainStringKey_Int
72 * @tc.desc: SetGet_PlainStringKey_Int
73 * @tc.type: FUNC
74 */
75 HWTEST_F(MetaInnerUnitTest, SetGet_PlainStringKey_Int, TestSize.Level1)
76 {
77 int32_t valueOut = 0;
78 int32_t valueIn = 141;
79 SetMetaData(*metaIn, "width", valueIn);
80 GetMetaData(*metaIn, "width", valueOut);
81 EXPECT_EQ(valueOut, valueIn);
82 }
83
84 /**
85 * @tc.name: SetGet_Int32
86 * @tc.desc: SetGet_Int32
87 * @tc.type: FUNC
88 */
89 HWTEST_F(MetaInnerUnitTest, SetGet_Int32, TestSize.Level1)
90 {
91 int32_t valueOut = 0;
92 int32_t valueIn = 141;
93 metaIn->Set<Tag::APP_PID>(valueIn);
94 metaIn->Get<Tag::APP_PID>(valueOut);
95 EXPECT_EQ(valueOut, valueIn);
96 }
97
98 /**
99 * @tc.name: SetGet_null
100 * @tc.desc: SetGet_null
101 * @tc.type: FUNC
102 */
103 HWTEST_F(MetaInnerUnitTest, SetGet_null, TestSize.Level1)
104 {
105 bool valueOut = false;
106 bool valueIn = true;
107 bool ret = metaIn->Set<Tag::VIDEO_COLOR_RANGE>(nullptr);
108 EXPECT_EQ(ret, false);
109 ret &= metaIn->Set<Tag::MEDIA_TITLE>(nullptr);
110 EXPECT_EQ(ret, false);
111 ret &= metaIn->Set<Tag::USER_PUSH_DATA_TIME>(nullptr);
112 EXPECT_EQ(ret, false);
113 ret &= metaIn->Set<Tag::VIDEO_CROP_LEFT>(nullptr);
114 EXPECT_EQ(ret, false);
115 ret &= metaIn->Set<Tag::VIDEO_BIT_STREAM_FORMAT>(nullptr);
116 EXPECT_EQ(ret, false);
117 ret &= metaIn->Set<Tag::MEDIA_FILE_TYPE>(nullptr);
118 metaIn->Get<Tag::VIDEO_COLOR_RANGE>(valueOut);
119 EXPECT_NE(valueOut, valueIn);
120 EXPECT_EQ(ret, false);
121 }
122
123 /**
124 * @tc.name: SetGet_Bool
125 * @tc.desc: SetGet_Bool
126 * @tc.type: FUNC
127 */
128 HWTEST_F(MetaInnerUnitTest, SetGet_Bool, TestSize.Level1)
129 {
130 bool valueOut = false;
131 bool valueIn = true;
132 metaIn->Set<Tag::VIDEO_COLOR_RANGE>(valueIn);
133 metaIn->Get<Tag::VIDEO_COLOR_RANGE>(valueOut);
134 EXPECT_EQ(valueOut, valueIn);
135 }
136
137 /**
138 * @tc.name: SetGet_Double
139 * @tc.desc: SetGet_Double
140 * @tc.type: FUNC
141 */
142 HWTEST_F(MetaInnerUnitTest, SetGet_Double, TestSize.Level1)
143 {
144 double valueOut = 0;
145 double valueIn = 1.59261111;
146 metaIn->Set<Tag::VIDEO_FRAME_RATE>(valueIn);
147 metaIn->Get<Tag::VIDEO_FRAME_RATE>(valueOut);
148 ASSERT_DOUBLE_EQ(valueOut, valueIn);
149 }
150
151 /**
152 * @tc.name: SetGet_Long
153 * @tc.desc: SetGet_Long
154 * @tc.type: FUNC
155 */
156 HWTEST_F(MetaInnerUnitTest, SetGet_Long, TestSize.Level1)
157 {
158 int64_t valueOut = 0;
159 int64_t valueIn = 17592186044673;
160 metaIn->Set<Tag::MEDIA_DURATION>(valueIn);
161 metaIn->Get<Tag::MEDIA_DURATION>(valueOut);
162 EXPECT_EQ(valueOut, valueIn);
163 }
164
165 /**
166 * @tc.name: SetGet_String
167 * @tc.desc: SetGet_String
168 * @tc.type: FUNC
169 */
170 HWTEST_F(MetaInnerUnitTest, SetGet_String, TestSize.Level1)
171 {
172 std::string valueOut = "";
173 std::string valueIn = "STRING_TESTVALUE";
174 metaIn->Set<Tag::MEDIA_FILE_URI>(valueIn);
175 metaIn->Get<Tag::MEDIA_FILE_URI>(valueOut);
176 EXPECT_EQ(valueOut, valueIn);
177 }
178
179 /**
180 * @tc.name: SetGet_Data_Int32
181 * @tc.desc: SetGet_Data_Int32
182 * @tc.type: FUNC
183 */
184 HWTEST_F(MetaInnerUnitTest, SetGet_Data_Int32, TestSize.Level1)
185 {
186 int32_t valueOut = 0;
187 int32_t valueIn = 141;
188 metaIn->SetData(Tag::APP_PID, valueIn);
189 metaIn->GetData(Tag::APP_PID, valueOut);
190 EXPECT_EQ(valueOut, valueIn);
191 }
192
193 /**
194 * @tc.name: SetGet_Data_Int32_PlainInput
195 * @tc.desc: SetGet_Data_Int32_PlainInput
196 * @tc.type: FUNC
197 */
198 HWTEST_F(MetaInnerUnitTest, SetGet_Data_Int32_PlainInput, TestSize.Level1)
199 {
200 int32_t valueOut = 0;
201 std::shared_ptr<Meta> meta_ = std::make_shared<Meta>();
202 metaIn->SetData(Tag::APP_PID, 111);
203 metaIn->GetData(Tag::APP_PID, valueOut);
204 EXPECT_EQ(valueOut, 111);
205 }
206
207 /**
208 * @tc.name: SetGet_Data_String_PlainInput
209 * @tc.desc: SetGet_Data_String_PlainInput
210 * @tc.type: FUNC
211 */
212 HWTEST_F(MetaInnerUnitTest, SetGet_Data_String_PlainInput, TestSize.Level1)
213 {
214 std::string valueOut = "";
215 metaIn->SetData(Tag::MEDIA_LYRICS, "Test Input");
216 metaIn->GetData(Tag::MEDIA_LYRICS, valueOut);
217 EXPECT_EQ(valueOut, "Test Input");
218 }
219
220 /**
221 * @tc.name: SetGet_Data_Int32_Using_Parcel
222 * @tc.desc: SetGet_Data_Int32_Using_Parcel
223 * @tc.type: FUNC
224 */
225 HWTEST_F(MetaInnerUnitTest, SetGet_Int32_Using_Parcel, TestSize.Level1)
226 {
227 int32_t valueOut = 0;
228 int32_t valueIn = 141;
229 metaIn->Set<Tag::APP_PID>(valueIn);
230 ASSERT_TRUE(metaIn->ToParcel(*parcel));
231 ASSERT_TRUE(metaOut->FromParcel(*parcel));
232 metaOut->Get<Tag::APP_PID>(valueOut);
233 EXPECT_EQ(valueOut, valueIn);
234 }
235
236 /**
237 * @tc.name: SetGet_Data_Int32_Using_Parcel
238 * @tc.desc: SetGet_Data_Int32_Using_Parcel
239 * @tc.type: FUNC
240 */
241 HWTEST_F(MetaInnerUnitTest, SetGet_Data_Int32_Using_Parcel, TestSize.Level1)
242 {
243 int32_t valueOut = 0;
244 int32_t valueIn = 141;
245 metaIn->SetData(Tag::APP_PID, valueIn);
246 ASSERT_TRUE(metaIn->ToParcel(*parcel));
247 ASSERT_TRUE(metaOut->FromParcel(*parcel));
248 metaOut->GetData(Tag::APP_PID, valueOut);
249 EXPECT_EQ(valueOut, valueIn);
250 }
251
252 /**
253 * @tc.name: SetGet_MetaData_Int32
254 * @tc.desc: SetGet_MetaData_Int32
255 * @tc.type: FUNC
256 */
257 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Int32, TestSize.Level1)
258 {
259 int32_t valueOut = 0;
260 int32_t valueIn = 141;
261 SetMetaData(*metaIn, Tag::APP_PID, valueIn);
262 GetMetaData(*metaIn, Tag::APP_PID, valueOut);
263 EXPECT_EQ(valueOut, valueIn);
264 }
265
266 /**
267 * @tc.name: SetGet_MetaData_Int32_PlainInput
268 * @tc.desc: SetGet_MetaData_Int32_PlainInput
269 * @tc.type: FUNC
270 */
271 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Int32_PlainInput, TestSize.Level1)
272 {
273 int32_t valueOut = 0;
274 SetMetaData(*metaIn, Tag::APP_PID, 141);
275 GetMetaData(*metaIn, Tag::APP_PID, valueOut);
276 EXPECT_EQ(valueOut, 141);
277 }
278
279 /**
280 * @tc.name: SetGet_MetaData_Enum_As_Int32
281 * @tc.desc: SetGet_MetaData_Enum_As_Int32
282 * @tc.type: FUNC
283 */
284 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Enum_As_Int32, TestSize.Level1)
285 {
286 int32_t valueOut = 0;
287 int32_t valueIn = static_cast<int32_t>(Plugins::VideoRotation::VIDEO_ROTATION_90);
288 SetMetaData(*metaIn, Tag::VIDEO_ROTATION, valueIn);
289 GetMetaData(*metaIn, Tag::VIDEO_ROTATION, valueOut);
290 EXPECT_EQ(valueOut, valueIn);
291 }
292
293 /**
294 * @tc.name: SetGet_MetaData_Int32_Using_Parcel
295 * @tc.desc: SetGet_MetaData_Int32_Using_Parcel
296 * @tc.type: FUNC
297 */
298 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Int32_Using_Parcel, TestSize.Level1)
299 {
300 int32_t valueOut = 0;
301 int32_t valueIn = 141;
302 SetMetaData(*metaIn, Tag::APP_PID, valueIn);
303 ASSERT_TRUE(metaIn->ToParcel(*parcel));
304 ASSERT_TRUE(metaOut->FromParcel(*parcel));
305 metaOut->Get<Tag::APP_PID>(valueOut);
306 EXPECT_EQ(valueOut, valueIn);
307 valueOut = 0;
308 GetMetaData(*metaOut, Tag::APP_PID, valueOut);
309 EXPECT_EQ(valueOut, valueIn);
310 }
311
312 /**
313 * @tc.name: SetGet_MetaData_Enum_As_Int32_Using_Parcel
314 * @tc.desc: SetGet_MetaData_Enum_As_Int32_Using_Parcel
315 * @tc.type: FUNC
316 */
317 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Enum_As_Int32_Using_Parcel, TestSize.Level1)
318 {
319 Plugins::VideoRotation valueOut;
320 int32_t valueIn = static_cast<int32_t>(Plugins::VideoRotation::VIDEO_ROTATION_90);
321 SetMetaData(*metaIn, Tag::VIDEO_ROTATION, valueIn);
322 ASSERT_TRUE(metaIn->ToParcel(*parcel));
323 ASSERT_TRUE(metaOut->FromParcel(*parcel));
324 metaOut->Get<Tag::VIDEO_ROTATION>(valueOut);
325 EXPECT_EQ(static_cast<int32_t>(valueOut), valueIn);
326 int32_t valueIntOut = 0;
327 GetMetaData(*metaOut, Tag::VIDEO_ROTATION, valueIntOut);
328 EXPECT_EQ(valueIntOut, valueIn);
329 }
330
331 /**
332 * @tc.name: SetGet_MetaData_Enum_As_Int64_Using_Parcel
333 * @tc.desc: SetGet_MetaData_Enum_As_Int64_Using_Parcel
334 * @tc.type: FUNC
335 */
336 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_Enum_As_Int64_Using_Parcel, TestSize.Level1)
337 {
338 Plugins::AudioChannelLayout valueOut;
339 int64_t valueIn = static_cast<int64_t>(Plugins::AudioChannelLayout::HOA_ORDER1_FUMA);
340 SetMetaData(*metaIn, Tag::AUDIO_CHANNEL_LAYOUT, valueIn);
341 ASSERT_TRUE(metaIn->ToParcel(*parcel));
342 ASSERT_TRUE(metaOut->FromParcel(*parcel));
343 metaOut->Get<Tag::AUDIO_CHANNEL_LAYOUT>(valueOut);
344 EXPECT_EQ(static_cast<int64_t>(valueOut), valueIn);
345 int64_t valueInt64Out = 0;
346 GetMetaData(*metaOut, Tag::AUDIO_CHANNEL_LAYOUT, valueInt64Out);
347 EXPECT_EQ(valueOut, valueIn);
348 }
349
350 map<TagType, int32_t> testInt32Data = {
351 // Int32 or Int32 Enum
352 {Tag::APP_UID, 11},
353 {Tag::APP_PID, 22},
354 {Tag::APP_TOKEN_ID, 33},
355 {Tag::REQUIRED_IN_BUFFER_CNT, 44},
356 {Tag::REQUIRED_IN_BUFFER_SIZE, 11},
357 {Tag::REQUIRED_OUT_BUFFER_CNT, 11},
358 {Tag::REQUIRED_OUT_BUFFER_SIZE, 11},
359 {Tag::BUFFERING_SIZE, 11},
360 {Tag::WATERLINE_HIGH, 11},
361 {Tag::WATERLINE_LOW, 11},
362 {Tag::AUDIO_CHANNEL_COUNT, 11},
363 {Tag::AUDIO_SAMPLE_RATE, 11},
364 {Tag::AUDIO_SAMPLE_PER_FRAME, 22},
365 {Tag::AUDIO_OUTPUT_CHANNELS, 33},
366 {Tag::AUDIO_MPEG_VERSION, 11},
367 {Tag::AUDIO_MPEG_LAYER, 123},
368 {Tag::AUDIO_AAC_LEVEL, 12},
369 {Tag::AUDIO_MAX_INPUT_SIZE, 21},
370 {Tag::AUDIO_MAX_OUTPUT_SIZE, 32},
371 {Tag::AUDIO_SOUNDBED_CHANNELS_NUMBER, 6},
372 {Tag::AUDIO_HOA_ORDER, 6},
373 {Tag::VIDEO_WIDTH, 12},
374 {Tag::VIDEO_HEIGHT, 31},
375 {Tag::VIDEO_DELAY, 54},
376 {Tag::VIDEO_MAX_SURFACE_NUM, 45},
377 {Tag::VIDEO_H264_LEVEL, 12},
378 {Tag::AUDIO_AAC_IS_ADTS, 33},
379 {Tag::AUDIO_COMPRESSION_LEVEL, 44},
380 {Tag::AUDIO_BITS_PER_CODED_SAMPLE, 44},
381 {Tag::AUDIO_BITS_PER_RAW_SAMPLE, 44},
382 {Tag::MEDIA_TRACK_COUNT, 11},
383 {Tag::REGULAR_TRACK_ID, 13},
384 {Tag::VIDEO_SCALE_TYPE, 14},
385 {Tag::VIDEO_I_FRAME_INTERVAL, 11},
386 {Tag::MEDIA_PROFILE, 13},
387 {Tag::VIDEO_ENCODE_QUALITY, 112},
388 {Tag::AUDIO_AAC_SBR, 111},
389 {Tag::AUDIO_OBJECT_NUMBER, 113},
390 {Tag::AUDIO_FLAC_COMPLIANCE_LEVEL, 13},
391 {Tag::MEDIA_LEVEL, 14},
392 {Tag::VIDEO_STRIDE, 17},
393 {Tag::VIDEO_DISPLAY_WIDTH, 19},
394 {Tag::VIDEO_DISPLAY_HEIGHT, 23},
395 {Tag::VIDEO_DISPLAY_WIDTH, 24},
396 {Tag::VIDEO_DISPLAY_HEIGHT, 25},
397 {Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 11},
398 {Tag::VIDEO_ENCODER_LTR_FRAME_COUNT, 12},
399 {Tag::VIDEO_PER_FRAME_POC, 13},
400 {Tag::VIDEO_ENCODER_PER_FRAME_USE_LTR, 14},
401 {Tag::VIDEO_CROP_TOP, 15},
402 {Tag::VIDEO_CROP_BOTTOM, 16},
403 {Tag::VIDEO_CROP_LEFT, 17},
404 {Tag::VIDEO_CROP_RIGHT, 18},
405 {Tag::VIDEO_SLICE_HEIGHT, 19},
406 {Tag::VIDEO_ENCODER_QP_MAX, 20},
407 {Tag::VIDEO_ENCODER_QP_MIN, 21},
408 {Tag::VIDEO_ENCODER_QP_START, 20},
409 {Tag::FEATURE_PROPERTY_VIDEO_ENCODER_MAX_LTR_FRAME_COUNT, 22},
410 {Tag::VIDEO_DECODER_RATE_UPPER_LIMIT, 120},
411 {Tag::VIDEO_ENCODER_QP_AVERAGE, 4},
412 {Tag::VIDEO_ENCODER_FRAME_TEMPORAL_ID, 2},
413 {Tag::SCREEN_CAPTURE_ERR_CODE, 3},
414 {Tag::SCREEN_CAPTURE_DURATION, 5},
415 {Tag::SCREEN_CAPTURE_START_LATENCY, 7},
416 {Tag::DRM_ERROR_CODE, 28},
417 {Tag::RECORDER_ERR_CODE, 6},
418 {Tag::RECORDER_DURATION, 8},
419 {Tag::RECORDER_VIDEO_BITRATE, 9},
420 {Tag::RECORDER_AUDIO_SAMPLE_RATE, 4},
421 {Tag::RECORDER_AUDIO_CHANNEL_COUNT, 3},
422 {Tag::RECORDER_AUDIO_BITRATE, 6},
423 {Tag::RECORDER_START_LATENCY, 7},
424 {Tag::AV_PLAYER_ERR_CODE, 1},
425 {Tag::AV_PLAYER_PLAY_DURATION, 2},
426 {Tag::AV_PLAYER_SOURCE_TYPE, 3},
427 {Tag::AV_PLAYER_AVG_DOWNLOAD_RATE, 4},
428 {Tag::AV_PLAYER_VIDEO_BITRATE, 5},
429 {Tag::AV_PLAYER_AUDIO_BITRATE, 6},
430 {Tag::AV_PLAYER_START_LATENCY, 7},
431 {Tag::AV_PLAYER_AVG_DOWNLOAD_SPEED, 8},
432 {Tag::AV_PLAYER_MAX_SEEK_LATENCY, 9},
433 {Tag::AV_PLAYER_MAX_ACCURATE_SEEK_LATENCY, 10},
434 {Tag::AV_PLAYER_LAG_TIMES, 11},
435 {Tag::AV_PLAYER_MAX_LAG_DURATION, 12},
436 {Tag::AV_PLAYER_MAX_SURFACESWAP_LATENCY, 13},
437 {Tag::AV_PLAYER_LAG_TIMES, 14},
438 {Tag::AV_TRANSCODER_ERR_CODE, 1},
439 {Tag::AV_TRANSCODER_SOURCE_DURATION, 2},
440 {Tag::AV_TRANSCODER_TRANSCODER_DURATION, 3},
441 {Tag::AV_TRANSCODER_SRC_VIDEO_BITRATE, 4},
442 {Tag::AV_TRANSCODER_SRC_HDR_TYPE, 7},
443 {Tag::AV_TRANSCODER_SRC_AUDIO_SAMPLE_RATE, 8},
444 {Tag::AV_TRANSCODER_SRC_AUDIO_CHANNEL_COUNT, 9},
445 {Tag::AV_TRANSCODER_SRC_AUDIO_BITRATE, 10},
446 {Tag::AV_TRANSCODER_DST_VIDEO_BITRATE, 11},
447 {Tag::AV_TRANSCODER_DST_HDR_TYPE, 14},
448 {Tag::AV_TRANSCODER_DST_AUDIO_SAMPLE_RATE, 15},
449 {Tag::AV_TRANSCODER_DST_AUDIO_CHANNEL_COUNT, 16},
450 {Tag::AV_TRANSCODER_DST_AUDIO_BITRATE, 17},
451 {Tag::AV_TRANSCODER_VIDEO_DECODER_DURATION, 18},
452 {Tag::AV_TRANSCODER_VIDEO_ENCODER_DURATION, 19},
453 {Tag::AV_TRANSCODER_VIDEO_VPE_DURATION, 20},
454 {Tag::TIMED_METADATA_SRC_TRACK, 1},
455 {Tag::SRC_INPUT_TYPE, static_cast<int32_t>(Plugins::SrcInputType::AUD_ES)},
456 {Tag::AUDIO_SAMPLE_FORMAT, static_cast<int32_t>(Plugins::AudioSampleFormat::SAMPLE_S16LE)},
457 {Tag::VIDEO_PIXEL_FORMAT, static_cast<int32_t>(Plugins::VideoPixelFormat::YUV411P)},
458 {Tag::MEDIA_TYPE, static_cast<int32_t>(Plugins::MediaType::AUDIO)},
459 {Tag::VIDEO_H264_PROFILE, static_cast<int32_t>(Plugins::VideoH264Profile::BASELINE)},
460 {Tag::VIDEO_ROTATION, static_cast<int32_t>(Plugins::VideoRotation::VIDEO_ROTATION_90)},
461 {Tag::VIDEO_ORIENTATION_TYPE, static_cast<int32_t>(Plugins::VideoOrientationType::FLIP_H_ROT90)},
462 {Tag::VIDEO_COLOR_PRIMARIES, static_cast<int32_t>(Plugins::ColorPrimary::BT2020)},
463 {Tag::VIDEO_COLOR_TRC, static_cast<int32_t>(Plugins::TransferCharacteristic::BT1361)},
464 {Tag::VIDEO_COLOR_MATRIX_COEFF, static_cast<int32_t>(Plugins::MatrixCoefficient::BT2020_CL)},
465 {Tag::VIDEO_H265_PROFILE, static_cast<int32_t>(Plugins::HEVCProfile::HEVC_PROFILE_MAIN_10_HDR10)},
466 {Tag::VIDEO_H265_LEVEL, static_cast<int32_t>(Plugins::HEVCLevel::HEVC_LEVEL_41)},
467 {Tag::VIDEO_CHROMA_LOCATION, static_cast<int32_t>(Plugins::ChromaLocation::BOTTOM)},
468 {Tag::MEDIA_FILE_TYPE, static_cast<int32_t>(Plugins::FileType::AMR)},
469 {Tag::VIDEO_ENCODE_BITRATE_MODE, static_cast<int32_t>(Plugins::VideoEncodeBitrateMode::CBR)},
470 {Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
471 static_cast<int32_t>(Plugins::TemporalGopReferenceMode::JUMP_REFERENCE)},
472 {Tag::VIDEO_COORDINATE_X, 10},
473 {Tag::VIDEO_COORDINATE_Y, 10},
474 {Tag::VIDEO_COORDINATE_W, 10},
475 {Tag::VIDEO_COORDINATE_H, 10},
476 {Tag::VIDEO_ENCODER_REPEAT_PREVIOUS_FRAME_AFTER, 10},
477 {Tag::VIDEO_ENCODER_REPEAT_PREVIOUS_MAX_COUNT, 10},
478 {Tag::VIDEO_DECODER_OUTPUT_COLOR_SPACE, 8},
479 {Tag::VIDEO_DECODER_OUTPUT_ENABLE_VRR, 0},
480 // UINT8_T
481 {Tag::AUDIO_AAC_PROFILE, static_cast<int32_t>(Plugins::AudioAacProfile::ELD)},
482 {Tag::AUDIO_AAC_STREAM_FORMAT, static_cast<int32_t>(Plugins::AudioAacStreamFormat::ADIF)}};
483
484 map<TagType, bool> testBoolData = {
485 // Bool
486 {Tag::SCREEN_CAPTURE_USER_AGREE, true},
487 {Tag::SCREEN_CAPTURE_REQURE_MIC, false},
488 {Tag::SCREEN_CAPTURE_ENABLE_MIC, true},
489 {Tag::AV_PLAYER_IS_DRM_PROTECTED, true},
490 {Tag::AV_PLAYER_DOWNLOAD_TIME_OUT, true},
491 {Tag::VIDEO_COLOR_RANGE, true},
492 {Tag::VIDEO_REQUEST_I_FRAME, false},
493 {Tag::MEDIA_HAS_VIDEO, true},
494 {Tag::MEDIA_HAS_AUDIO, false},
495 {Tag::MEDIA_HAS_TIMEDMETA, true},
496 {Tag::MEDIA_END_OF_STREAM, true},
497 {Tag::VIDEO_IS_HDR_VIVID, true},
498 {Tag::VIDEO_FRAME_RATE_ADAPTIVE_MODE, true},
499 {Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, true},
500 {Tag::VIDEO_ENCODER_PER_FRAME_MARK_LTR, true},
501 {Tag::VIDEO_PER_FRAME_IS_LTR, true},
502 {Tag::VIDEO_PER_FRAME_IS_SKIP, true},
503 {Tag::VIDEO_ENCODER_ENABLE_PARAMS_FEEDBACK, true},
504 {Tag::VIDEO_ENABLE_LOW_LATENCY, true},
505 {Tag::VIDEO_ENCODER_ENABLE_SURFACE_INPUT_CALLBACK, true},
506 {Tag::AUDIO_RENDER_SET_FLAG, true},
507 {Tag::VIDEO_BUFFER_CAN_DROP, true},
508 {Tag::VIDEO_ENCODER_PER_FRAME_DISCARD, true},
509 {Tag::VIDEO_ENCODER_ENABLE_WATERMARK, true}};
510
511
512 /**
513 * @tc.name: SetGet_MetaData_All_As_Bool_Using_ParcelPackage
514 * @tc.desc: SetGet_MetaData_All_As_Bool_Using_ParcelPackage
515 * @tc.type: FUNC
516 */
517 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Bool_Using_ParcelPackage, TestSize.Level1)
518 {
519 for (auto item : testBoolData) {
520 int32_t valueIn = item.second;
521 SetMetaData(*metaIn, item.first, valueIn);
522 }
523 ASSERT_TRUE(metaIn->ToParcel(*parcel));
524 ASSERT_TRUE(metaOut->FromParcel(*parcel));
525 for (auto item : testBoolData) {
526 int32_t valueIn = item.second;
527 int32_t valueOut = 0;
528 ASSERT_TRUE(GetMetaData(*metaOut, item.first, valueOut));
529 std::cout << item.first << " , " << valueOut << " , " << valueIn << std::endl;
530 EXPECT_EQ(valueOut, valueIn);
531 }
532 }
533
534 /**
535 * @tc.name: SetGet_MetaData_All_As_Int32_Using_ParcelPackage
536 * @tc.desc: SetGet_MetaData_All_As_Int32_Using_ParcelPackage
537 * @tc.type: FUNC
538 */
539 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Int32_Using_ParcelPackage, TestSize.Level1)
540 {
541 for (auto item : testInt32Data) {
542 int32_t valueIn = item.second;
543 SetMetaData(*metaIn, item.first, valueIn);
544 }
545 ASSERT_TRUE(metaIn->ToParcel(*parcel));
546 ASSERT_TRUE(metaOut->FromParcel(*parcel));
547 for (auto item : testInt32Data) {
548 int32_t valueIn = item.second;
549 int32_t valueOut = 0;
550 ASSERT_TRUE(GetMetaData(*metaOut, item.first, valueOut));
551 std::cout << item.first << " , " << valueOut << " , " << valueIn << std::endl;
552 EXPECT_EQ(valueOut, valueIn);
553 }
554 }
555
556 map<TagType, int64_t> testInt64Data = {
557 // Int64 or Int64 Enum
558 {Tag::APP_FULL_TOKEN_ID, 1234567890001},
559 {Tag::MEDIA_DURATION, 1234567890002},
560 {Tag::MEDIA_BITRATE, 1234567890003},
561 {Tag::MEDIA_START_TIME, 1234567890004},
562 {Tag::USER_FRAME_PTS, 1234567890005},
563 {Tag::USER_PUSH_DATA_TIME, 1234567890006},
564 {Tag::MEDIA_FILE_SIZE, 1234567890007},
565 {Tag::MEDIA_POSITION, 1234567890008},
566 {Tag::MEDIA_TIME_STAMP, 1234567890009},
567 {Tag::MEDIA_CONTAINER_START_TIME, 1234567890010},
568 {Tag::BUFFER_DECODING_TIMESTAMP, 1234567890011},
569 {Tag::BUFFER_DURATION, 1234567890012},
570 {Tag::AUDIO_CHANNEL_LAYOUT, static_cast<int64_t>(Plugins::AudioChannelLayout::CH_10POINT2)},
571 {Tag::AUDIO_OUTPUT_CHANNEL_LAYOUT, static_cast<int64_t>(Plugins::AudioChannelLayout::HOA_ORDER3_FUMA)},
572 {Tag::VIDEO_DECODER_DESIRED_PRESENT_TIMESTAMP, 1234567890013}
573 };
574
575 /**
576 * @tc.name: SetGet_MetaData_All_As_Int64_Using_ParcelPackage
577 * @tc.desc: SetGet_MetaData_All_As_Int64_Using_ParcelPackage
578 * @tc.type: FUNC
579 */
580 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Int64_Using_ParcelPackage, TestSize.Level1)
581 {
582 for (auto item : testInt64Data) {
583 int64_t valueIn = item.second;
584 SetMetaData(*metaIn, item.first, valueIn);
585 }
586 ASSERT_TRUE(metaIn->ToParcel(*parcel));
587 ASSERT_TRUE(metaOut->FromParcel(*parcel));
588 for (auto item : testInt64Data) {
589 int64_t valueIn = item.second;
590 int64_t valueOut = 0;
591 GetMetaData(*metaOut, item.first, valueOut);
592 std::cout << item.first << " , " << valueOut << " , " << valueIn << std::endl;
593 EXPECT_EQ(valueOut, valueIn);
594 }
595 }
596
597 map<TagType, float> testFloatData = {
598 // Float
599 {Tag::MEDIA_LATITUDE, 1.01f},
600 {Tag::MEDIA_LONGITUDE, 1.02f},
601 {Tag::AV_PLAYER_VIDEO_FRAMERATE, 1.03f}
602 };
603
604 /**
605 * @tc.name: SetGet_MetaData_All_As_Float_Using_ParcelPackage
606 * @tc.desc: SetGet_MetaData_All_As_Float_Using_ParcelPackage
607 * @tc.type: FUNC
608 */
609 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Float_Using_ParcelPackage, TestSize.Level1)
610 {
611 for (auto item : testFloatData) {
612 float valueIn = item.second;
613 metaIn->SetData(item.first, valueIn);
614 }
615 ASSERT_TRUE(metaIn->ToParcel(*parcel));
616 ASSERT_TRUE(metaOut->FromParcel(*parcel));
617 for (auto item : testFloatData) {
618 float valueIn = item.second;
619 float valueOut = 0.0f;
620 metaOut->GetData(item.first, valueOut);
621 ASSERT_FLOAT_EQ(valueOut, valueIn);
622 }
623 }
624
625 map<TagType, double> testDoubleData = {
626 // Double
627 {Tag::VIDEO_FRAME_RATE, 1.01},
628 {Tag::VIDEO_CAPTURE_RATE, 1.02},
629 {Tag::VIDEO_SAR, 1.03},
630 {Tag::VIDEO_ENCODER_MSE, 29.01},
631 {Tag::AV_TRANSCODER_SRC_VIDEO_FRAME_RATE, 2.5},
632 {Tag::AV_TRANSCODER_DST_VIDEO_FRAME_RATE, 6.9}
633 };
634
635 /**
636 * @tc.name: SetGet_MetaData_All_As_Double_Using_ParcelPackage
637 * @tc.desc: SetGet_MetaData_All_As_Double_Using_ParcelPackage
638 * @tc.type: FUNC
639 */
640 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Double_Using_ParcelPackage, TestSize.Level1)
641 {
642 for (auto item : testDoubleData) {
643 double valueIn = item.second;
644 metaIn->SetData(item.first, valueIn);
645 }
646 ASSERT_TRUE(metaIn->ToParcel(*parcel));
647 ASSERT_TRUE(metaOut->FromParcel(*parcel));
648 for (auto item : testDoubleData) {
649 double valueIn = item.second;
650 double valueOut = 0.0;
651 metaOut->GetData(item.first, valueOut);
652 ASSERT_DOUBLE_EQ(valueOut, valueIn);
653 }
654 }
655
656 map<TagType, std::string> testStringData = {
657 // String
658 {Tag::MIME_TYPE, "String MIME_TYPE"},
659 {Tag::MEDIA_FILE_URI, "String MEDIA_FILE_URI"},
660 {Tag::MEDIA_TITLE, "String MEDIA_TITLE"},
661 {Tag::MEDIA_ARTIST, "String MEDIA_ARTIST"},
662 {Tag::MEDIA_LYRICIST, "String MEDIA_LYRICIST"},
663 {Tag::MEDIA_ALBUM, "String MEDIA_ALBUM"},
664 {Tag::MEDIA_ALBUM_ARTIST, "String MEDIA_ALBUM_ARTIST"},
665 {Tag::MEDIA_DATE, "String MEDIA_DATE"},
666 {Tag::MEDIA_COMMENT, "String MEDIA_COMMENT"},
667 {Tag::MEDIA_GENRE, "String MEDIA_GENRE"},
668 {Tag::MEDIA_COPYRIGHT, "String MEDIA_COPYRIGHT"},
669 {Tag::MEDIA_LANGUAGE, "String MEDIA_LANGUAGE"},
670 {Tag::MEDIA_DESCRIPTION, "String MEDIA_DESCRIPTION"},
671 {Tag::USER_TIME_SYNC_RESULT, "String USER_TIME_SYNC_RESULT"},
672 {Tag::USER_AV_SYNC_GROUP_INFO, "String USER_AV_SYNC_GROUP_INFO"},
673 {Tag::USER_SHARED_MEMORY_FD, "String USER_SHARED_MEMORY_FD"},
674 {Tag::MEDIA_AUTHOR, "String MEDIA_AUTHOR"},
675 {Tag::MEDIA_COMPOSER, "String MEDIA_COMPOSER"},
676 {Tag::MEDIA_LYRICS, "String MEDIA_LYRICS"},
677 {Tag::MEDIA_CODEC_NAME, "String MEDIA_CODEC_NAME"},
678 {Tag::PROCESS_NAME, "String PROCESS_NAME"},
679 {Tag::MEDIA_CREATION_TIME, "String MEDIA_CREATION_TIME"},
680 {Tag::SCREEN_CAPTURE_ERR_MSG, "String SCREEN_CAPTURE_ERR_MSG"},
681 {Tag::SCREEN_CAPTURE_VIDEO_RESOLUTION, "String SCREEN_CAPTURE_VIDEO_RESOLUTION"},
682 {Tag::RECORDER_ERR_MSG, "String RECORDER_ERR_MSG"},
683 {Tag::RECORDER_CONTAINER_MIME, "String RECORDER_CONTAINER_MIME"},
684 {Tag::RECORDER_VIDEO_MIME, "String RECORDER_VIDEO_MIME"},
685 {Tag::RECORDER_VIDEO_RESOLUTION, "String RECORDER_VIDEO_RESOLUTION"},
686 {Tag::RECORDER_AUDIO_MIME, "String RECORDER_AUDIO_MIME"},
687 {Tag::AV_PLAYER_ERR_MSG, "String AV_PLAYER_ERR_MSG"},
688 {Tag::AV_PLAYER_CONTAINER_MIME, "String AV_PLAYER_CONTAINER_MIME"},
689 {Tag::AV_PLAYER_VIDEO_MIME, "String AV_PLAYER_VIDEO_MIME"},
690 {Tag::AV_PLAYER_VIDEO_RESOLUTION, "String AV_PLAYER_VIDEO_RESOLUTION"},
691 {Tag::AV_PLAYER_AUDIO_MIME, "String AV_PLAYER_AUDIO_MIME"},
692 {Tag::DRM_APP_NAME, "String DRM_APP_NAME"},
693 {Tag::DRM_INSTANCE_ID, "String DRM_INSTANCE_ID"},
694 {Tag::DRM_ERROR_MESG, "String DRM_ERROR_MESG"},
695 {Tag::TIMED_METADATA_SRC_TRACK_MIME, "String TIMED_METADATA_SRC_TRACK_MIME"},
696 {Tag::TIMED_METADATA_KEY, "String TIMED_METADATA_KEY"},
697 {Tag::TIMED_METADATA_LOCALE, "String TIMED_METADATA_LOCALE"},
698 {Tag::TIMED_METADATA_SETUP, "String TIMED_METADATA_SETUP"},
699 {Tag::AV_TRANSCODER_ERR_MSG, "String AV_TRANSCODER_ERR_MSG"},
700 {Tag::AV_TRANSCODER_SRC_FORMAT, "String AV_TRANSCODER_SRC_FORMAT"},
701 {Tag::AV_TRANSCODER_SRC_AUDIO_MIME, "String AV_TRANSCODER_SRC_AUDIO_MIME"},
702 {Tag::AV_TRANSCODER_SRC_VIDEO_MIME, "String AV_TRANSCODER_SRC_VIDEO_MIME"},
703 {Tag::AV_TRANSCODER_DST_FORMAT, "String AV_TRANSCODER_DST_FORMAT"},
704 {Tag::AV_TRANSCODER_DST_AUDIO_MIME, "String AV_TRANSCODER_DST_AUDIO_MIME"},
705 {Tag::AV_TRANSCODER_DST_VIDEO_MIME, "String AV_TRANSCODER_DST_VIDEO_MIME"}
706 };
707
708 /**
709 * @tc.name: SetGet_MetaData_All_As_String_Using_ParcelPackage
710 * @tc.desc: SetGet_MetaData_All_As_String_Using_ParcelPackage
711 * @tc.type: FUNC
712 */
713 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_String_Using_ParcelPackage, TestSize.Level1)
714 {
715 for (auto item : testStringData) {
716 std::string valueIn = item.second;
717 metaIn->SetData(item.first, valueIn);
718 }
719 ASSERT_TRUE(metaIn->ToParcel(*parcel));
720 ASSERT_TRUE(metaOut->FromParcel(*parcel));
721 for (auto item : testStringData) {
722 std::string valueIn = item.second;
723 std::string valueOut = "String Value";
724 metaOut->GetData(item.first, valueOut);
725 std::cout << item.first << " , " << valueOut << " , " << valueIn << std::endl;
726 EXPECT_EQ(valueOut, valueIn);
727 }
728 }
729
730 std::vector<uint8_t> vectorUint8MediaCodec{1, 2, 3};
731 std::vector<uint8_t> vectorUint8MediaCover{1, 2, 3, 4};
732 map<TagType, std::vector<uint8_t>> testVetcorInt8Data = {
733 // vector<uint8_t>
734 {Tag::MEDIA_CODEC_CONFIG, vectorUint8MediaCodec},
735 {Tag::MEDIA_COVER, vectorUint8MediaCover},
736 {Tag::AUDIO_VORBIS_IDENTIFICATION_HEADER, vectorUint8MediaCover},
737 {Tag::AUDIO_VORBIS_SETUP_HEADER, vectorUint8MediaCover},
738 {Tag::AUDIO_VIVID_METADATA, vectorUint8MediaCover},
739 };
740
741 /**
742 * @tc.name: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
743 * @tc.desc: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
744 * @tc.type: FUNC
745 */
746 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage, TestSize.Level1)
747 {
748 for (auto item : testVetcorInt8Data) {
749 std::vector<uint8_t> valueIn = item.second;
750 metaIn->SetData(item.first, valueIn);
751 }
752 ASSERT_TRUE(metaIn->ToParcel(*parcel));
753 ASSERT_TRUE(metaOut->FromParcel(*parcel));
754 for (auto item : testVetcorInt8Data) {
755 std::vector<uint8_t> valueIn = item.second;
756 std::vector<uint8_t> valueOut;
757 metaOut->GetData(item.first, valueOut);
758 EXPECT_EQ(valueOut, valueIn);
759 }
760 }
761
PrepareInMeta(std::shared_ptr<Meta> & inMeta)762 void PrepareInMeta(std::shared_ptr<Meta>& inMeta)
763 {
764 for (auto item : testVetcorInt8Data) {
765 std::vector<uint8_t> valueInVecInt8 = item.second;
766 inMeta->SetData(item.first, valueInVecInt8);
767 }
768 for (auto item : testFloatData) {
769 float valueInFloat = item.second;
770 inMeta->SetData(item.first, valueInFloat);
771 }
772 for (auto item : testDoubleData) {
773 double valueInDouble = item.second;
774 inMeta->SetData(item.first, valueInDouble);
775 }
776 for (auto item : testStringData) {
777 std::string valueInStr = item.second;
778 inMeta->SetData(item.first, valueInStr);
779 }
780 for (auto item : testInt32Data) {
781 int32_t valueInInt32 = item.second;
782 SetMetaData(*inMeta, item.first, valueInInt32);
783 }
784 }
785
CheckOutMeta(const std::shared_ptr<Meta> & outMeta)786 void CheckOutMeta(const std::shared_ptr<Meta>& outMeta)
787 {
788 for (auto item : testInt32Data) {
789 int32_t valueInInt32 = item.second;
790 int32_t valueOutInt32 = 0;
791 GetMetaData(*outMeta, item.first, valueOutInt32);
792 EXPECT_EQ(valueOutInt32, valueInInt32);
793 }
794 for (auto item : testStringData) {
795 std::string valueInStr = item.second;
796 std::string valueOutStr = "String Value";
797 outMeta->GetData(item.first, valueOutStr);
798 EXPECT_EQ(valueOutStr, valueInStr);
799 }
800 for (auto item : testFloatData) {
801 float valueInFloat = item.second;
802 float valueOutFloat = 0.0f;
803 outMeta->GetData(item.first, valueOutFloat);
804 ASSERT_FLOAT_EQ(valueOutFloat, valueInFloat);
805 }
806 for (auto item : testDoubleData) {
807 double valueInDouble = item.second;
808 double valueOutDouble = 0.0;
809 outMeta->GetData(item.first, valueOutDouble);
810 ASSERT_DOUBLE_EQ(valueOutDouble, valueInDouble);
811 }
812 for (auto item : testVetcorInt8Data) {
813 std::vector<uint8_t> valueInVecInt8 = item.second;
814 std::vector<uint8_t> valueOutVecInt8;
815 outMeta->GetData(item.first, valueOutVecInt8);
816 EXPECT_EQ(valueOutVecInt8, valueInVecInt8);
817 }
818 }
819
820 /**
821 * @tc.name: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
822 * @tc.desc: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
823 * @tc.type: FUNC
824 */
825 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Mix_Using_ParcelPackage, TestSize.Level1)
826 {
827 PrepareInMeta(metaIn);
828 ASSERT_TRUE(metaIn->ToParcel(*parcel));
829 ASSERT_TRUE(metaOut->FromParcel(*parcel));
830 CheckOutMeta(metaOut);
831 }
832
833 /**
834 * @tc.name: SetGet_MetaData_All_As_Mix_Using_AssignCopy
835 * @tc.desc: SetGet_MetaData_All_As_Mix_Using_AssignCopy
836 * @tc.type: FUNC
837 */
838 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Mix_Using_AssignCopy, TestSize.Level1)
839 {
840 PrepareInMeta(metaIn);
841 Meta metaCopy = std::move(*metaIn);
842 for (auto item : testInt32Data) {
843 int32_t valueOutInt32 = 0;
844 ASSERT_FALSE(GetMetaData(*metaIn, item.first, valueOutInt32));
845 }
846 CheckOutMeta(make_shared<Meta>(metaCopy));
847 }
848
849 /**
850 * @tc.name: SetGet_MetaData_All_As_Mix_Using_SwapCopy
851 * @tc.desc: SetGet_MetaData_All_As_Mix_Using_SwapCopy
852 * @tc.type: FUNC
853 */
854 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Mix_Using_SwapCopy, TestSize.Level1)
855 {
856 PrepareInMeta(metaIn);
857 Meta metaCopy(std::move(*metaIn));
858 for (auto item : testInt32Data) {
859 int32_t valueOutInt32 = 0;
860 ASSERT_FALSE(GetMetaData(*metaIn, item.first, valueOutInt32));
861 }
862 CheckOutMeta(make_shared<Meta>(metaCopy));
863 }
864
865 /**
866 * @tc.name: SetGet_Data_DrmStruct_Using_Parcel
867 * @tc.desc: SetGet_Data_DrmStruct_Using_Parcel
868 * @tc.type: FUNC
869 */
870 HWTEST_F(MetaInnerUnitTest, SetGet_Data_DrmStruct_Using_Parcel, TestSize.Level1)
871 {
872 uint8_t iv[META_DRM_IV_SIZE] = {
873 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43, 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2c
874 };
875 uint8_t keyId[META_DRM_KEY_ID_SIZE] = {
876 0x3a, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43, 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2a
877 };
878 Plugins::MetaDrmCencInfo *drmCencInfoIn = (Plugins::MetaDrmCencInfo *)malloc(sizeof(Plugins::MetaDrmCencInfo));
879 drmCencInfoIn->algo = Plugins::MetaDrmCencAlgorithm::META_DRM_ALG_CENC_SM4_CBC;
880 drmCencInfoIn->keyIdLen = META_DRM_KEY_ID_SIZE;
881 auto error = memcpy_s(drmCencInfoIn->keyId, sizeof(drmCencInfoIn->keyId), keyId, META_DRM_KEY_ID_SIZE);
882 ASSERT_EQ(error, EOK);
883 drmCencInfoIn->ivLen = META_DRM_IV_SIZE;
884 error = memcpy_s(drmCencInfoIn->iv, sizeof(drmCencInfoIn->iv), iv, META_DRM_IV_SIZE);
885 ASSERT_EQ(error, EOK);
886 drmCencInfoIn->encryptBlocks = 0;
887 drmCencInfoIn->skipBlocks = 0;
888 drmCencInfoIn->firstEncryptOffset = 0;
889 drmCencInfoIn->subSampleNum = 1;
890 for (uint32_t i = 0; i < drmCencInfoIn->subSampleNum; i++) {
891 drmCencInfoIn->subSamples[i].clearHeaderLen = 0x10;
892 drmCencInfoIn->subSamples[i].payLoadLen = 0;
893 }
894 std::vector<uint8_t> drmCencVecIn((uint8_t *)drmCencInfoIn,
895 ((uint8_t *)drmCencInfoIn) + sizeof(Plugins::MetaDrmCencInfo));
896 std::shared_ptr<Meta> metaIn = nullptr;
897 std::shared_ptr<Meta> metaOut = nullptr;
898 std::shared_ptr<MessageParcel> parcel = nullptr;
899 parcel = std::make_shared<MessageParcel>();
900 metaIn = std::make_shared<Meta>();
901 metaOut = std::make_shared<Meta>();
902 metaIn->SetData(Tag::DRM_CENC_INFO, drmCencVecIn);
903 ASSERT_TRUE(metaIn->ToParcel(*parcel));
904 ASSERT_TRUE(metaOut->FromParcel(*parcel));
905
906 std::vector<uint8_t> drmCencVecOut;
907 metaOut->GetData(Tag::DRM_CENC_INFO, drmCencVecOut);
908 Plugins::MetaDrmCencInfo *drmCencInfoOut = reinterpret_cast<Plugins::MetaDrmCencInfo *>(&drmCencVecOut[0]);
909
910 EXPECT_EQ(drmCencInfoIn->keyIdLen, drmCencInfoOut->keyIdLen);
911 free(drmCencInfoIn);
912 }
913
914 /**
915 * @tc.name: SetGet_self_Data_String_Using_Parcel
916 * @tc.desc: SetGet_self_Data_String_Using_Parcel
917 * @tc.type: FUNC
918 */
919 HWTEST_F(MetaInnerUnitTest, SetGet_self_Data_String_Using_Parcel, TestSize.Level1)
920 {
921 std::string valueOut = "123";
922 std::string valueIn = "123abc";
923 std::string key = "myself";
924 metaIn->SetData(key, valueIn);
925 ASSERT_TRUE(metaIn->ToParcel(*parcel));
926 ASSERT_TRUE(metaOut->FromParcel(*parcel));
927 metaOut->GetData(key, valueOut);
928 EXPECT_EQ(valueOut, valueIn);
929 }
930
931 /**
932 * @tc.name: SetGet_self_Data_float_Using_Parcel
933 * @tc.desc: SetGet_self_Data_float_Using_Parcel
934 * @tc.type: FUNC
935 */
936 HWTEST_F(MetaInnerUnitTest, SetGet_self_Data_float_Using_Parcel, TestSize.Level1)
937 {
938 float valueOut = 0.0f;
939 float valueIn = 1.01f;
940 std::string key = "myself";
941 metaIn->SetData(key, valueIn);
942 ASSERT_TRUE(metaIn->ToParcel(*parcel));
943 ASSERT_TRUE(metaOut->FromParcel(*parcel));
944 metaOut->GetData(key, valueOut);
945 EXPECT_EQ(valueOut, valueIn);
946 }
947
948 /**
949 * @tc.name: GetValueType_Data_Boolean
950 * @tc.desc: GetValueType_Data_Boolean
951 * @tc.type: FUNC
952 */
953 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_Boolean, TestSize.Level1)
954 {
955 bool valueOut = true;
956 bool valueIn = false;
957 std::string key = "test";
958 metaIn->SetData(key, valueIn);
959 AnyValueType type = metaIn->GetValueType(key);
960 ASSERT_TRUE(type == AnyValueType::BOOL);
961 metaIn->GetData(key, valueOut);
962 EXPECT_EQ(valueOut, valueIn);
963 }
964
965 /**
966 * @tc.name: GetValueType_Data_Int32
967 * @tc.desc: GetValueType_Data_Int32
968 * @tc.type: FUNC
969 */
970 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_Int32, TestSize.Level1)
971 {
972 int32_t valueOut = 0;
973 int32_t valueIn = 141;
974 std::string key = "test";
975 metaIn->SetData(key, valueIn);
976 AnyValueType type = metaIn->GetValueType(key);
977 ASSERT_TRUE(type == AnyValueType::INT32_T);
978 metaIn->GetData(key, valueOut);
979 EXPECT_EQ(valueOut, valueIn);
980 }
981
982 /**
983 * @tc.name: GetValueType_Data_Int64
984 * @tc.desc: GetValueType_Data_Int64
985 * @tc.type: FUNC
986 */
987 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_Int64, TestSize.Level1)
988 {
989 int64_t valueOut = 0;
990 int64_t valueIn = 141;
991 std::string key = "test";
992 metaIn->SetData(key, valueIn);
993 AnyValueType type = metaIn->GetValueType(key);
994 ASSERT_TRUE(type == AnyValueType::INT64_T);
995 metaIn->GetData(key, valueOut);
996 EXPECT_EQ(valueOut, valueIn);
997 }
998
999 /**
1000 * @tc.name: GetValueType_Data_FLOAT
1001 * @tc.desc: GetValueType_Data_FLOAT
1002 * @tc.type: FUNC
1003 */
1004 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_FLOAT, TestSize.Level1)
1005 {
1006 float valueOut = 0;
1007 float valueIn = 1.01;
1008 std::string key = "test";
1009 metaIn->SetData(key, valueIn);
1010 AnyValueType type = metaIn->GetValueType(key);
1011 ASSERT_TRUE(type == AnyValueType::FLOAT);
1012 metaIn->GetData(key, valueOut);
1013 EXPECT_EQ(valueOut, valueIn);
1014 }
1015
1016 /**
1017 * @tc.name: GetValueType_Data_DOUBLE
1018 * @tc.desc: GetValueType_Data_DOUBLE
1019 * @tc.type: FUNC
1020 */
1021 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_DOUBLE, TestSize.Level1)
1022 {
1023 double valueOut = 0;
1024 double valueIn = 1.01;
1025 std::string key = "test";
1026 metaIn->SetData(key, valueIn);
1027 AnyValueType type = metaIn->GetValueType(key);
1028 ASSERT_TRUE(type == AnyValueType::DOUBLE);
1029 metaIn->GetData(key, valueOut);
1030 EXPECT_EQ(valueOut, valueIn);
1031 }
1032
1033 /**
1034 * @tc.name: GetValueType_Data_VECTOR_UINT8
1035 * @tc.desc: GetValueType_Data_VECTOR_UINT8
1036 * @tc.type: FUNC
1037 */
1038 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_VECTOR_UINT8, TestSize.Level1)
1039 {
1040 vector<uint8_t> valueOut{1, 2, 3};
1041 vector<uint8_t> valueIn{1, 2, 3, 4};
1042 std::string key = "test";
1043 metaIn->SetData(key, valueIn);
1044 AnyValueType type = metaIn->GetValueType(key);
1045 ASSERT_TRUE(type == AnyValueType::VECTOR_UINT8);
1046 metaIn->GetData(key, valueOut);
1047 EXPECT_EQ(valueOut, valueIn);
1048 }
1049
1050 /**
1051 * @tc.name: Meta_GetData_All_As_Bool_Using_ParcelPackage
1052 * @tc.desc:
1053 * 1. set bool to format;
1054 * 2. meta trans by parcel;
1055 * 3. get meta value type;
1056 * @tc.type: FUNC
1057 */
1058 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_Bool_Using_ParcelPackage, TestSize.Level1)
1059 {
1060 for (auto item : testBoolData) {
1061 bool valueIn = item.second;
1062 MessageParcel parcel;
1063 std::shared_ptr<Format> format = std::make_shared<Format>();
1064 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1065
1066 EXPECT_TRUE(format->PutIntValue(item.first, valueIn));
1067 meta = format->GetMeta();
1068 ASSERT_TRUE(meta->ToParcel(parcel));
1069 ASSERT_TRUE(meta->FromParcel(parcel));
1070
1071 bool valueOut = !valueIn;
1072 int32_t intValue = -1;
1073 EXPECT_FALSE(meta->GetData(item.first, intValue));
1074 EXPECT_TRUE(meta->GetData(item.first, valueOut));
1075 EXPECT_EQ(valueIn, valueOut);
1076 }
1077 }
1078
1079 /**
1080 * @tc.name: Meta_GetData_All_As_Int32_Using_ParcelPackage
1081 * @tc.desc:
1082 * 1. set int32_t to format;
1083 * 2. meta trans by parcel;
1084 * 3. get meta value type;
1085 * @tc.type: FUNC
1086 */
1087 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_Int32_Using_ParcelPackage, TestSize.Level1)
1088 {
1089 std::vector<TagType> skipList = {Tag::AUDIO_AAC_PROFILE, Tag::AUDIO_AAC_STREAM_FORMAT};
1090 for (auto item : testInt32Data) {
1091 auto iter = std::find(skipList.begin(), skipList.end(), item.first);
1092 if (iter != skipList.end()) {
1093 continue;
1094 }
1095
1096 int32_t valueIn = item.second;
1097 MessageParcel parcel;
1098 std::shared_ptr<Format> format = std::make_shared<Format>();
1099 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1100
1101 EXPECT_TRUE(format->PutIntValue(item.first, valueIn));
1102 meta = format->GetMeta();
1103 ASSERT_TRUE(meta->ToParcel(parcel));
1104 ASSERT_TRUE(meta->FromParcel(parcel));
1105
1106 int32_t valueOut = -1;
1107 EXPECT_TRUE(GetMetaData(*meta, item.first, valueOut));
1108 EXPECT_EQ(valueIn, valueOut);
1109 }
1110 }
1111
1112 /**
1113 * @tc.name: Meta_GetData_All_As_Int64_Using_ParcelPackage
1114 * @tc.desc:
1115 * 1. set int64_t to format;
1116 * 2. meta trans by parcel;
1117 * 3. get meta value type;
1118 * @tc.type: FUNC
1119 */
1120 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_Int64_Using_ParcelPackage, TestSize.Level1)
1121 {
1122 std::vector<TagType> skipList = {Tag::MEDIA_FILE_SIZE, Tag::MEDIA_POSITION};
1123 for (auto item : testInt64Data) {
1124 auto iter = std::find(skipList.begin(), skipList.end(), item.first);
1125 if (iter != skipList.end()) {
1126 continue;
1127 }
1128
1129 int64_t valueIn = item.second;
1130 MessageParcel parcel;
1131 std::shared_ptr<Format> format = std::make_shared<Format>();
1132 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1133
1134 EXPECT_TRUE(format->PutLongValue(item.first, valueIn));
1135 meta = format->GetMeta();
1136 ASSERT_TRUE(meta->ToParcel(parcel));
1137 ASSERT_TRUE(meta->FromParcel(parcel));
1138
1139 int64_t valueOut = -1;
1140 EXPECT_TRUE(GetMetaData(*meta, item.first, valueOut));
1141 EXPECT_EQ(valueIn, valueOut);
1142 }
1143 }
1144
1145 /**
1146 * @tc.name: Meta_GetData_All_As_Float_Using_ParcelPackage
1147 * @tc.desc:
1148 * 1. set float to format;
1149 * 2. meta trans by parcel;
1150 * 3. get meta value type;
1151 * @tc.type: FUNC
1152 */
1153 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_Float_Using_ParcelPackage, TestSize.Level1)
1154 {
1155 for (auto item : testFloatData) {
1156 float valueIn = item.second;
1157 MessageParcel parcel;
1158 std::shared_ptr<Format> format = std::make_shared<Format>();
1159 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1160
1161 EXPECT_TRUE(format->PutFloatValue(item.first, valueIn));
1162 meta = format->GetMeta();
1163 ASSERT_TRUE(meta->ToParcel(parcel));
1164 ASSERT_TRUE(meta->FromParcel(parcel));
1165
1166 float valueOut = 0.0f;
1167 ASSERT_TRUE(meta->GetData(item.first, valueOut));
1168 EXPECT_EQ(valueIn, valueOut);
1169 }
1170 }
1171
1172 /**
1173 * @tc.name: Meta_GetData_All_As_Double_Using_ParcelPackage
1174 * @tc.desc:
1175 * 1. set double to format;
1176 * 2. meta trans by parcel;
1177 * 3. get meta value type;
1178 * @tc.type: FUNC
1179 */
1180 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_Double_Using_ParcelPackage, TestSize.Level1)
1181 {
1182 for (auto item : testDoubleData) {
1183 double valueIn = item.second;
1184 MessageParcel parcel;
1185 std::shared_ptr<Format> format = std::make_shared<Format>();
1186 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1187
1188 EXPECT_TRUE(format->PutDoubleValue(item.first, valueIn));
1189 meta = format->GetMeta();
1190 ASSERT_TRUE(meta->ToParcel(parcel));
1191 ASSERT_TRUE(meta->FromParcel(parcel));
1192
1193 double valueOut = 0.0;
1194 ASSERT_TRUE(meta->GetData(item.first, valueOut));
1195 EXPECT_EQ(valueIn, valueOut);
1196 }
1197 }
1198
1199 /**
1200 * @tc.name: Meta_GetData_All_As_String_Using_ParcelPackage
1201 * @tc.desc:
1202 * 1. set string to format;
1203 * 2. meta trans by parcel;
1204 * 3. get meta value type;
1205 * @tc.type: FUNC
1206 */
1207 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_String_Using_ParcelPackage, TestSize.Level1)
1208 {
1209 for (auto item : testStringData) {
1210 string valueIn = item.second;
1211 MessageParcel parcel;
1212 std::shared_ptr<Format> format = std::make_shared<Format>();
1213 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1214
1215 EXPECT_TRUE(format->PutStringValue(item.first, valueIn));
1216 meta = format->GetMeta();
1217 ASSERT_TRUE(meta->ToParcel(parcel));
1218 ASSERT_TRUE(meta->FromParcel(parcel));
1219
1220 string valueOut = "String Value";
1221 EXPECT_TRUE(meta->GetData(item.first, valueOut));
1222 EXPECT_EQ(valueIn, valueOut);
1223 }
1224 }
1225
1226 /**
1227 * @tc.name: Meta_GetData_All_As_VectorUint8_Using_ParcelPackage
1228 * @tc.desc:
1229 * 1. set vectorUint8 to format;
1230 * 2. meta trans by parcel;
1231 * 3. get meta value type;
1232 * @tc.type: FUNC
1233 */
1234 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_VectorUint8_Using_ParcelPackage, TestSize.Level1)
1235 {
1236 for (auto item : testVetcorInt8Data) {
1237 std::vector<uint8_t> valueIn = item.second;
1238 MessageParcel parcel;
1239 std::shared_ptr<Format> format = std::make_shared<Format>();
1240 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1241
1242 EXPECT_TRUE(format->PutBuffer(item.first, valueIn.data(), valueIn.size()));
1243 meta = format->GetMeta();
1244 ASSERT_TRUE(meta->ToParcel(parcel));
1245 ASSERT_TRUE(meta->FromParcel(parcel));
1246
1247 std::vector<uint8_t> valueOut;
1248 EXPECT_TRUE(meta->GetData(item.first, valueOut));
1249 EXPECT_EQ(valueIn, valueOut);
1250 }
1251 }
1252 } // namespace MetaFuncUT
1253 } // namespace Media
1254 } // namespace OHOS
1255