1 /*
2 * Copyright (C) 2023-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
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::BUFFER_INDEX, 13},
385 {Tag::VIDEO_SCALE_TYPE, 14},
386 {Tag::VIDEO_I_FRAME_INTERVAL, 11},
387 {Tag::MEDIA_PROFILE, 13},
388 {Tag::VIDEO_ENCODE_QUALITY, 112},
389 {Tag::AUDIO_AAC_SBR, 111},
390 {Tag::AUDIO_OBJECT_NUMBER, 113},
391 {Tag::AUDIO_FLAC_COMPLIANCE_LEVEL, 13},
392 {Tag::MEDIA_LEVEL, 14},
393 {Tag::VIDEO_STRIDE, 17},
394 {Tag::VIDEO_DISPLAY_WIDTH, 19},
395 {Tag::VIDEO_DISPLAY_HEIGHT, 23},
396 {Tag::VIDEO_DISPLAY_WIDTH, 24},
397 {Tag::VIDEO_DISPLAY_HEIGHT, 25},
398 {Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 11},
399 {Tag::VIDEO_ENCODER_LTR_FRAME_COUNT, 12},
400 {Tag::VIDEO_PER_FRAME_POC, 13},
401 {Tag::VIDEO_ENCODER_PER_FRAME_USE_LTR, 14},
402 {Tag::VIDEO_CROP_TOP, 15},
403 {Tag::VIDEO_CROP_BOTTOM, 16},
404 {Tag::VIDEO_CROP_LEFT, 17},
405 {Tag::VIDEO_CROP_RIGHT, 18},
406 {Tag::VIDEO_SLICE_HEIGHT, 19},
407 {Tag::VIDEO_ENCODER_QP_MAX, 20},
408 {Tag::VIDEO_ENCODER_QP_MIN, 21},
409 {Tag::VIDEO_ENCODER_QP_START, 20},
410 {Tag::VIDEO_ENCODER_TARGET_QP, 20},
411 {Tag::FEATURE_PROPERTY_VIDEO_ENCODER_MAX_LTR_FRAME_COUNT, 22},
412 {Tag::VIDEO_DECODER_RATE_UPPER_LIMIT, 120},
413 {Tag::VIDEO_ENCODER_FRAME_I_RATIO, 10},
414 {Tag::VIDEO_ENCODER_FRAME_MADI, 10},
415 {Tag::VIDEO_ENCODER_FRAME_MADP, 10},
416 {Tag::VIDEO_ENCODER_SUM_MADI, 30},
417 {Tag::VIDEO_ENCODER_REAL_BITRATE, 10000000},
418 {Tag::VIDEO_ENCODER_FRAME_QP, 30},
419 {Tag::VIDEO_ENCODER_QP_AVERAGE, 4},
420 {Tag::VIDEO_ENCODER_FRAME_TEMPORAL_ID, 2},
421 {Tag::SCREEN_CAPTURE_ERR_CODE, 3},
422 {Tag::SCREEN_CAPTURE_DURATION, 5},
423 {Tag::SCREEN_CAPTURE_START_LATENCY, 7},
424 {Tag::DRM_ERROR_CODE, 28},
425 {Tag::RECORDER_ERR_CODE, 6},
426 {Tag::RECORDER_DURATION, 8},
427 {Tag::RECORDER_VIDEO_BITRATE, 9},
428 {Tag::RECORDER_AUDIO_SAMPLE_RATE, 4},
429 {Tag::RECORDER_AUDIO_CHANNEL_COUNT, 3},
430 {Tag::RECORDER_AUDIO_BITRATE, 6},
431 {Tag::RECORDER_START_LATENCY, 7},
432 {Tag::AV_PLAYER_ERR_CODE, 1},
433 {Tag::AV_PLAYER_PLAY_DURATION, 2},
434 {Tag::AV_PLAYER_SOURCE_TYPE, 3},
435 {Tag::AV_PLAYER_AVG_DOWNLOAD_RATE, 4},
436 {Tag::AV_PLAYER_VIDEO_BITRATE, 5},
437 {Tag::AV_PLAYER_AUDIO_BITRATE, 6},
438 {Tag::AV_PLAYER_START_LATENCY, 7},
439 {Tag::AV_PLAYER_AVG_DOWNLOAD_SPEED, 8},
440 {Tag::AV_PLAYER_MAX_SEEK_LATENCY, 9},
441 {Tag::AV_PLAYER_MAX_ACCURATE_SEEK_LATENCY, 10},
442 {Tag::AV_PLAYER_LAG_TIMES, 11},
443 {Tag::AV_PLAYER_MAX_LAG_DURATION, 12},
444 {Tag::AV_PLAYER_MAX_SURFACESWAP_LATENCY, 13},
445 {Tag::AV_PLAYER_LAG_TIMES, 14},
446 {Tag::AV_TRANSCODER_ERR_CODE, 1},
447 {Tag::AV_TRANSCODER_SOURCE_DURATION, 2},
448 {Tag::AV_TRANSCODER_TRANSCODER_DURATION, 3},
449 {Tag::AV_TRANSCODER_SRC_VIDEO_BITRATE, 4},
450 {Tag::AV_TRANSCODER_SRC_HDR_TYPE, 7},
451 {Tag::AV_TRANSCODER_SRC_AUDIO_SAMPLE_RATE, 8},
452 {Tag::AV_TRANSCODER_SRC_AUDIO_CHANNEL_COUNT, 9},
453 {Tag::AV_TRANSCODER_SRC_AUDIO_BITRATE, 10},
454 {Tag::AV_TRANSCODER_DST_VIDEO_BITRATE, 11},
455 {Tag::AV_TRANSCODER_DST_HDR_TYPE, 14},
456 {Tag::AV_TRANSCODER_DST_COLOR_SPACE, 8},
457 {Tag::AV_TRANSCODER_DST_AUDIO_SAMPLE_RATE, 15},
458 {Tag::AV_TRANSCODER_DST_AUDIO_CHANNEL_COUNT, 16},
459 {Tag::AV_TRANSCODER_DST_AUDIO_BITRATE, 17},
460 {Tag::AV_TRANSCODER_VIDEO_DECODER_DURATION, 18},
461 {Tag::AV_TRANSCODER_VIDEO_ENCODER_DURATION, 19},
462 {Tag::AV_TRANSCODER_VIDEO_VPE_DURATION, 20},
463 {Tag::TIMED_METADATA_SRC_TRACK, 1},
464 {Tag::SRC_INPUT_TYPE, static_cast<int32_t>(Plugins::SrcInputType::AUD_ES)},
465 {Tag::AUDIO_SAMPLE_FORMAT, static_cast<int32_t>(Plugins::AudioSampleFormat::SAMPLE_S16LE)},
466 {Tag::AUDIO_RAW_SAMPLE_FORMAT, static_cast<int32_t>(Plugins::AudioSampleFormat::SAMPLE_S16LE)},
467 {Tag::VIDEO_PIXEL_FORMAT, static_cast<int32_t>(Plugins::VideoPixelFormat::YUV411P)},
468 {Tag::MEDIA_TYPE, static_cast<int32_t>(Plugins::MediaType::AUDIO)},
469 {Tag::VIDEO_H264_PROFILE, static_cast<int32_t>(Plugins::VideoH264Profile::BASELINE)},
470 {Tag::VIDEO_ROTATION, static_cast<int32_t>(Plugins::VideoRotation::VIDEO_ROTATION_90)},
471 {Tag::VIDEO_ORIENTATION_TYPE, static_cast<int32_t>(Plugins::VideoOrientationType::FLIP_H_ROT90)},
472 {Tag::VIDEO_COLOR_PRIMARIES, static_cast<int32_t>(Plugins::ColorPrimary::BT2020)},
473 {Tag::VIDEO_COLOR_TRC, static_cast<int32_t>(Plugins::TransferCharacteristic::BT1361)},
474 {Tag::VIDEO_COLOR_MATRIX_COEFF, static_cast<int32_t>(Plugins::MatrixCoefficient::BT2020_CL)},
475 {Tag::VIDEO_H265_PROFILE, static_cast<int32_t>(Plugins::HEVCProfile::HEVC_PROFILE_MAIN_10_HDR10)},
476 {Tag::VIDEO_H265_LEVEL, static_cast<int32_t>(Plugins::HEVCLevel::HEVC_LEVEL_41)},
477 {Tag::VIDEO_CHROMA_LOCATION, static_cast<int32_t>(Plugins::ChromaLocation::BOTTOM)},
478 {Tag::MEDIA_FILE_TYPE, static_cast<int32_t>(Plugins::FileType::AMR)},
479 {Tag::VIDEO_ENCODE_BITRATE_MODE, static_cast<int32_t>(Plugins::VideoEncodeBitrateMode::CBR)},
480 {Tag::VIDEO_ENCODE_B_FRAME_GOP_MODE,
481 static_cast<int32_t>(Plugins::VideoEncodeBFrameGopMode::VIDEO_ENCODE_GOP_ADAPTIVE_B_MODE)},
482 {Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
483 static_cast<int32_t>(Plugins::TemporalGopReferenceMode::JUMP_REFERENCE)},
484 {Tag::VIDEO_COORDINATE_X, 10},
485 {Tag::VIDEO_COORDINATE_Y, 10},
486 {Tag::VIDEO_COORDINATE_W, 10},
487 {Tag::VIDEO_COORDINATE_H, 10},
488 {Tag::VIDEO_ENCODER_REPEAT_PREVIOUS_FRAME_AFTER, 10},
489 {Tag::VIDEO_ENCODER_REPEAT_PREVIOUS_MAX_COUNT, 10},
490 {Tag::VIDEO_DECODER_OUTPUT_COLOR_SPACE, 8},
491 {Tag::VIDEO_DECODER_OUTPUT_ENABLE_VRR, 0},
492 {Tag::AUDIO_ENCODE_PTS_MODE, 1},
493 {Tag::AUDIO_BITRATE_MODE, Plugins::AudioEncodeBitrateMode::AUDIO_CBR},
494 {Tag::AUDIO_L2HC_VERSION, 1},
495 {Tag::VIDEO_ENCODER_ENABLE_PTS_BASED_RATECONTROL, 1},
496 {Tag::VIDEO_DECODER_INPUT_STREAM_ERROR, 0},
497 // UINT8_T
498 {Tag::AUDIO_AAC_PROFILE, static_cast<int32_t>(Plugins::AudioAacProfile::ELD)},
499 {Tag::AUDIO_AAC_STREAM_FORMAT, static_cast<int32_t>(Plugins::AudioAacStreamFormat::ADIF)}};
500
501 map<TagType, bool> testBoolData = {
502 // Bool
503 {Tag::SCREEN_CAPTURE_USER_AGREE, true},
504 {Tag::SCREEN_CAPTURE_REQURE_MIC, false},
505 {Tag::SCREEN_CAPTURE_ENABLE_MIC, true},
506 {Tag::AV_PLAYER_IS_DRM_PROTECTED, true},
507 {Tag::AV_PLAYER_DOWNLOAD_TIME_OUT, true},
508 {Tag::VIDEO_COLOR_RANGE, true},
509 {Tag::VIDEO_REQUEST_I_FRAME, false},
510 {Tag::MEDIA_HAS_VIDEO, true},
511 {Tag::MEDIA_HAS_AUDIO, false},
512 {Tag::MEDIA_HAS_TIMEDMETA, true},
513 {Tag::MEDIA_HAS_AUXILIARY, true},
514 {Tag::MEDIA_END_OF_STREAM, true},
515 {Tag::VIDEO_IS_HDR_VIVID, true},
516 {Tag::VIDEO_FRAME_RATE_ADAPTIVE_MODE, true},
517 {Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, true},
518 {Tag::AV_CODEC_ENABLE_SYNC_MODE, true},
519 {Tag::VIDEO_ENCODER_PER_FRAME_MARK_LTR, true},
520 {Tag::VIDEO_PER_FRAME_IS_LTR, true},
521 {Tag::VIDEO_PER_FRAME_IS_SKIP, true},
522 {Tag::VIDEO_ENCODER_ENABLE_PARAMS_FEEDBACK, true},
523 {Tag::VIDEO_ENABLE_LOW_LATENCY, true},
524 {Tag::VIDEO_ENCODER_ENABLE_SURFACE_INPUT_CALLBACK, true},
525 {Tag::AUDIO_RENDER_SET_FLAG, true},
526 {Tag::VIDEO_BUFFER_CAN_DROP, true},
527 {Tag::VIDEO_ENCODER_PER_FRAME_DISCARD, true},
528 {Tag::VIDEO_ENCODER_ENABLE_WATERMARK, true},
529 {Tag::VIDEO_ENCODER_ENABLE_QP_MAP, true},
530 {Tag::VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, true},
531 };
532
533
534 /**
535 * @tc.name: SetGet_MetaData_All_As_Bool_Using_ParcelPackage
536 * @tc.desc: SetGet_MetaData_All_As_Bool_Using_ParcelPackage
537 * @tc.type: FUNC
538 */
539 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Bool_Using_ParcelPackage, TestSize.Level1)
540 {
541 for (auto item : testBoolData) {
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 : testBoolData) {
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 /**
557 * @tc.name: SetGet_MetaData_All_As_Int32_Using_ParcelPackage
558 * @tc.desc: SetGet_MetaData_All_As_Int32_Using_ParcelPackage
559 * @tc.type: FUNC
560 */
561 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Int32_Using_ParcelPackage, TestSize.Level1)
562 {
563 for (auto item : testInt32Data) {
564 int32_t valueIn = item.second;
565 SetMetaData(*metaIn, item.first, valueIn);
566 }
567 ASSERT_TRUE(metaIn->ToParcel(*parcel));
568 ASSERT_TRUE(metaOut->FromParcel(*parcel));
569 for (auto item : testInt32Data) {
570 int32_t valueIn = item.second;
571 int32_t valueOut = 0;
572 ASSERT_TRUE(GetMetaData(*metaOut, item.first, valueOut));
573 std::cout << item.first << " , " << valueOut << " , " << valueIn << std::endl;
574 EXPECT_EQ(valueOut, valueIn);
575 }
576 }
577
578 map<TagType, int64_t> testInt64Data = {
579 // Int64 or Int64 Enum
580 {Tag::APP_FULL_TOKEN_ID, 1234567890001},
581 {Tag::MEDIA_DURATION, 1234567890002},
582 {Tag::MEDIA_BITRATE, 1234567890003},
583 {Tag::MEDIA_START_TIME, 1234567890004},
584 {Tag::USER_FRAME_PTS, 1234567890005},
585 {Tag::USER_PUSH_DATA_TIME, 1234567890006},
586 {Tag::MEDIA_FILE_SIZE, 1234567890007},
587 {Tag::MEDIA_POSITION, 1234567890008},
588 {Tag::MEDIA_TIME_STAMP, 1234567890009},
589 {Tag::MEDIA_CONTAINER_START_TIME, 1234567890010},
590 {Tag::BUFFER_DECODING_TIMESTAMP, 1234567890011},
591 {Tag::BUFFER_DURATION, 1234567890012},
592 {Tag::AUDIO_CHANNEL_LAYOUT, static_cast<int64_t>(Plugins::AudioChannelLayout::CH_10POINT2)},
593 {Tag::AUDIO_OUTPUT_CHANNEL_LAYOUT, static_cast<int64_t>(Plugins::AudioChannelLayout::HOA_ORDER3_FUMA)},
594 {Tag::VIDEO_DECODER_DESIRED_PRESENT_TIMESTAMP, 1234567890013},
595 {Tag::VIDEO_ENCODE_SET_FRAME_PTS, 1234567890014},
596 {Tag::VIDEO_SCENE_TYPE, 1234567890015},
597 {Tag::VIDEO_ENCODER_ENABLE_B_FRAME, 1234567890016},
598 {Tag::VIDEO_ENCODER_MAX_B_FRAME, 1234567890017},
599 };
600
601 /**
602 * @tc.name: SetGet_MetaData_All_As_Int64_Using_ParcelPackage
603 * @tc.desc: SetGet_MetaData_All_As_Int64_Using_ParcelPackage
604 * @tc.type: FUNC
605 */
606 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Int64_Using_ParcelPackage, TestSize.Level1)
607 {
608 for (auto item : testInt64Data) {
609 int64_t valueIn = item.second;
610 SetMetaData(*metaIn, item.first, valueIn);
611 }
612 ASSERT_TRUE(metaIn->ToParcel(*parcel));
613 ASSERT_TRUE(metaOut->FromParcel(*parcel));
614 for (auto item : testInt64Data) {
615 int64_t valueIn = item.second;
616 int64_t valueOut = 0;
617 GetMetaData(*metaOut, item.first, valueOut);
618 std::cout << item.first << " , " << valueOut << " , " << valueIn << std::endl;
619 EXPECT_EQ(valueOut, valueIn);
620 }
621 }
622
623 map<TagType, float> testFloatData = {
624 // Float
625 {Tag::MEDIA_LATITUDE, 1.01f},
626 {Tag::MEDIA_LONGITUDE, 1.02f},
627 {Tag::AV_PLAYER_VIDEO_FRAMERATE, 1.03f}
628 };
629
630 /**
631 * @tc.name: SetGet_MetaData_All_As_Float_Using_ParcelPackage
632 * @tc.desc: SetGet_MetaData_All_As_Float_Using_ParcelPackage
633 * @tc.type: FUNC
634 */
635 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Float_Using_ParcelPackage, TestSize.Level1)
636 {
637 for (auto item : testFloatData) {
638 float valueIn = item.second;
639 metaIn->SetData(item.first, valueIn);
640 }
641 ASSERT_TRUE(metaIn->ToParcel(*parcel));
642 ASSERT_TRUE(metaOut->FromParcel(*parcel));
643 for (auto item : testFloatData) {
644 float valueIn = item.second;
645 float valueOut = 0.0f;
646 metaOut->GetData(item.first, valueOut);
647 ASSERT_FLOAT_EQ(valueOut, valueIn);
648 }
649 }
650
651 map<TagType, double> testDoubleData = {
652 // Double
653 {Tag::VIDEO_FRAME_RATE, 1.01},
654 {Tag::VIDEO_CAPTURE_RATE, 1.02},
655 {Tag::VIDEO_SAR, 1.03},
656 {Tag::VIDEO_ENCODER_MSE, 29.01},
657 {Tag::AV_TRANSCODER_SRC_VIDEO_FRAME_RATE, 2.5},
658 {Tag::AV_TRANSCODER_DST_VIDEO_FRAME_RATE, 6.9}
659 };
660
661 /**
662 * @tc.name: SetGet_MetaData_All_As_Double_Using_ParcelPackage
663 * @tc.desc: SetGet_MetaData_All_As_Double_Using_ParcelPackage
664 * @tc.type: FUNC
665 */
666 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Double_Using_ParcelPackage, TestSize.Level1)
667 {
668 for (auto item : testDoubleData) {
669 double valueIn = item.second;
670 metaIn->SetData(item.first, valueIn);
671 }
672 ASSERT_TRUE(metaIn->ToParcel(*parcel));
673 ASSERT_TRUE(metaOut->FromParcel(*parcel));
674 for (auto item : testDoubleData) {
675 double valueIn = item.second;
676 double valueOut = 0.0;
677 metaOut->GetData(item.first, valueOut);
678 ASSERT_DOUBLE_EQ(valueOut, valueIn);
679 }
680 }
681
682 map<TagType, std::string> testStringData = {
683 // String
684 {Tag::MIME_TYPE, "String MIME_TYPE"},
685 {Tag::MEDIA_FILE_URI, "String MEDIA_FILE_URI"},
686 {Tag::MEDIA_TITLE, "String MEDIA_TITLE"},
687 {Tag::MEDIA_ARTIST, "String MEDIA_ARTIST"},
688 {Tag::MEDIA_LYRICIST, "String MEDIA_LYRICIST"},
689 {Tag::MEDIA_ALBUM, "String MEDIA_ALBUM"},
690 {Tag::MEDIA_ALBUM_ARTIST, "String MEDIA_ALBUM_ARTIST"},
691 {Tag::MEDIA_DATE, "String MEDIA_DATE"},
692 {Tag::MEDIA_COMMENT, "String MEDIA_COMMENT"},
693 {Tag::MEDIA_GENRE, "String MEDIA_GENRE"},
694 {Tag::MEDIA_COPYRIGHT, "String MEDIA_COPYRIGHT"},
695 {Tag::MEDIA_LANGUAGE, "String MEDIA_LANGUAGE"},
696 {Tag::MEDIA_DESCRIPTION, "String MEDIA_DESCRIPTION"},
697 {Tag::USER_TIME_SYNC_RESULT, "String USER_TIME_SYNC_RESULT"},
698 {Tag::USER_AV_SYNC_GROUP_INFO, "String USER_AV_SYNC_GROUP_INFO"},
699 {Tag::USER_SHARED_MEMORY_FD, "String USER_SHARED_MEMORY_FD"},
700 {Tag::MEDIA_AUTHOR, "String MEDIA_AUTHOR"},
701 {Tag::MEDIA_COMPOSER, "String MEDIA_COMPOSER"},
702 {Tag::MEDIA_LYRICS, "String MEDIA_LYRICS"},
703 {Tag::MEDIA_CODEC_NAME, "String MEDIA_CODEC_NAME"},
704 {Tag::PROCESS_NAME, "String PROCESS_NAME"},
705 {Tag::MEDIA_CREATION_TIME, "String MEDIA_CREATION_TIME"},
706 {Tag::SCREEN_CAPTURE_ERR_MSG, "String SCREEN_CAPTURE_ERR_MSG"},
707 {Tag::SCREEN_CAPTURE_VIDEO_RESOLUTION, "String SCREEN_CAPTURE_VIDEO_RESOLUTION"},
708 {Tag::DRM_APP_NAME, "String DRM_APP_NAME"},
709 {Tag::DRM_INSTANCE_ID, "String DRM_INSTANCE_ID"},
710 {Tag::DRM_ERROR_MESG, "String DRM_ERROR_MESG"},
711 {Tag::RECORDER_ERR_MSG, "String RECORDER_ERR_MSG"},
712 {Tag::RECORDER_CONTAINER_MIME, "String RECORDER_CONTAINER_MIME"},
713 {Tag::RECORDER_VIDEO_MIME, "String RECORDER_VIDEO_MIME"},
714 {Tag::RECORDER_VIDEO_RESOLUTION, "String RECORDER_VIDEO_RESOLUTION"},
715 {Tag::RECORDER_AUDIO_MIME, "String RECORDER_AUDIO_MIME"},
716 {Tag::AV_PLAYER_ERR_MSG, "String AV_PLAYER_ERR_MSG"},
717 {Tag::AV_PLAYER_CONTAINER_MIME, "String AV_PLAYER_CONTAINER_MIME"},
718 {Tag::AV_PLAYER_VIDEO_MIME, "String AV_PLAYER_VIDEO_MIME"},
719 {Tag::AV_PLAYER_VIDEO_RESOLUTION, "String AV_PLAYER_VIDEO_RESOLUTION"},
720 {Tag::AV_PLAYER_AUDIO_MIME, "String AV_PLAYER_AUDIO_MIME"},
721 {Tag::TIMED_METADATA_SRC_TRACK_MIME, "String TIMED_METADATA_SRC_TRACK_MIME"},
722 {Tag::TIMED_METADATA_KEY, "String TIMED_METADATA_KEY"},
723 {Tag::TIMED_METADATA_LOCALE, "String TIMED_METADATA_LOCALE"},
724 {Tag::TIMED_METADATA_SETUP, "String TIMED_METADATA_SETUP"},
725 {Tag::AV_TRANSCODER_ERR_MSG, "String AV_TRANSCODER_ERR_MSG"},
726 {Tag::AV_TRANSCODER_SRC_FORMAT, "String AV_TRANSCODER_SRC_FORMAT"},
727 {Tag::AV_TRANSCODER_SRC_AUDIO_MIME, "String AV_TRANSCODER_SRC_AUDIO_MIME"},
728 {Tag::AV_TRANSCODER_SRC_VIDEO_MIME, "String AV_TRANSCODER_SRC_VIDEO_MIME"},
729 {Tag::AV_TRANSCODER_DST_FORMAT, "String AV_TRANSCODER_DST_FORMAT"},
730 {Tag::AV_TRANSCODER_DST_AUDIO_MIME, "String AV_TRANSCODER_DST_AUDIO_MIME"},
731 {Tag::AV_TRANSCODER_DST_VIDEO_MIME, "String AV_TRANSCODER_DST_VIDEO_MIME"},
732 {Tag::TRACK_REFERENCE_TYPE, "String TRACK_REFERENCE_TYPE"},
733 {Tag::TRACK_DESCRIPTION, "String TRACK_DESCRIPTION"},
734 };
735
736 /**
737 * @tc.name: SetGet_MetaData_All_As_String_Using_ParcelPackage
738 * @tc.desc: SetGet_MetaData_All_As_String_Using_ParcelPackage
739 * @tc.type: FUNC
740 */
741 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_String_Using_ParcelPackage, TestSize.Level1)
742 {
743 for (auto item : testStringData) {
744 std::string valueIn = item.second;
745 metaIn->SetData(item.first, valueIn);
746 }
747 ASSERT_TRUE(metaIn->ToParcel(*parcel));
748 ASSERT_TRUE(metaOut->FromParcel(*parcel));
749 for (auto item : testStringData) {
750 std::string valueIn = item.second;
751 std::string valueOut = "String Value";
752 metaOut->GetData(item.first, valueOut);
753 std::cout << item.first << " , " << valueOut << " , " << valueIn << std::endl;
754 EXPECT_EQ(valueOut, valueIn);
755 }
756 }
757
758 std::vector<uint8_t> vectorUint8MediaCodec{1, 2, 3};
759 std::vector<uint8_t> vectorUint8MediaCover{1, 2, 3, 4};
760 map<TagType, std::vector<uint8_t>> testVetcorInt8Data = {
761 // vector<uint8_t>
762 {Tag::MEDIA_CODEC_CONFIG, vectorUint8MediaCodec},
763 {Tag::MEDIA_COVER, vectorUint8MediaCover},
764 {Tag::AUDIO_VORBIS_IDENTIFICATION_HEADER, vectorUint8MediaCover},
765 {Tag::AUDIO_VORBIS_SETUP_HEADER, vectorUint8MediaCover},
766 {Tag::AUDIO_VIVID_METADATA, vectorUint8MediaCover},
767 {Tag::VIDEO_ENCODER_PER_FRAME_QP_MAP, vectorUint8MediaCover},
768 };
769
770 /**
771 * @tc.name: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
772 * @tc.desc: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
773 * @tc.type: FUNC
774 */
775 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage, TestSize.Level1)
776 {
777 for (auto item : testVetcorInt8Data) {
778 std::vector<uint8_t> valueIn = item.second;
779 metaIn->SetData(item.first, valueIn);
780 }
781 ASSERT_TRUE(metaIn->ToParcel(*parcel));
782 ASSERT_TRUE(metaOut->FromParcel(*parcel));
783 for (auto item : testVetcorInt8Data) {
784 std::vector<uint8_t> valueIn = item.second;
785 std::vector<uint8_t> valueOut;
786 metaOut->GetData(item.first, valueOut);
787 EXPECT_EQ(valueOut, valueIn);
788 }
789 }
790
791 std::vector<int32_t> vectorInt32{1, 2, 3, 4};
792 map<TagType, std::vector<int32_t>> testVetcorInt32Data = {
793 // vector<int32_t>
794 {Tag::REFERENCE_TRACK_IDS, vectorInt32},
795 };
796
797 /**
798 * @tc.name: SetGet_MetaData_All_As_VectorInt32_Using_ParcelPackage
799 * @tc.desc: SetGet_MetaData_All_As_VectorInt32_Using_ParcelPackage
800 * @tc.type: FUNC
801 */
802 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_VectorInt32_Using_ParcelPackage, TestSize.Level1)
803 {
804 for (auto item : testVetcorInt32Data) {
805 std::vector<int32_t> valueIn = item.second;
806 metaIn->SetData(item.first, valueIn);
807 }
808 ASSERT_TRUE(metaIn->ToParcel(*parcel));
809 ASSERT_TRUE(metaOut->FromParcel(*parcel));
810 for (auto item : testVetcorInt32Data) {
811 std::vector<int32_t> valueIn = item.second;
812 std::vector<int32_t> valueOut;
813 metaOut->GetData(item.first, valueOut);
814 EXPECT_EQ(valueOut, valueIn);
815 }
816 }
817
PrepareInMeta(std::shared_ptr<Meta> & inMeta)818 void PrepareInMeta(std::shared_ptr<Meta>& inMeta)
819 {
820 for (auto item : testVetcorInt8Data) {
821 std::vector<uint8_t> valueInVecInt8 = item.second;
822 inMeta->SetData(item.first, valueInVecInt8);
823 }
824 for (auto item : testVetcorInt32Data) {
825 std::vector<int32_t> valueInVecInt32 = item.second;
826 inMeta->SetData(item.first, valueInVecInt32);
827 }
828 for (auto item : testFloatData) {
829 float valueInFloat = item.second;
830 inMeta->SetData(item.first, valueInFloat);
831 }
832 for (auto item : testDoubleData) {
833 double valueInDouble = item.second;
834 inMeta->SetData(item.first, valueInDouble);
835 }
836 for (auto item : testStringData) {
837 std::string valueInStr = item.second;
838 inMeta->SetData(item.first, valueInStr);
839 }
840 for (auto item : testInt32Data) {
841 int32_t valueInInt32 = item.second;
842 SetMetaData(*inMeta, item.first, valueInInt32);
843 }
844 }
845
CheckOutMeta(const std::shared_ptr<Meta> & outMeta)846 void CheckOutMeta(const std::shared_ptr<Meta>& outMeta)
847 {
848 for (auto item : testInt32Data) {
849 int32_t valueInInt32 = item.second;
850 int32_t valueOutInt32 = 0;
851 GetMetaData(*outMeta, item.first, valueOutInt32);
852 EXPECT_EQ(valueOutInt32, valueInInt32);
853 }
854 for (auto item : testStringData) {
855 std::string valueInStr = item.second;
856 std::string valueOutStr = "String Value";
857 outMeta->GetData(item.first, valueOutStr);
858 EXPECT_EQ(valueOutStr, valueInStr);
859 }
860 for (auto item : testFloatData) {
861 float valueInFloat = item.second;
862 float valueOutFloat = 0.0f;
863 outMeta->GetData(item.first, valueOutFloat);
864 ASSERT_FLOAT_EQ(valueOutFloat, valueInFloat);
865 }
866 for (auto item : testDoubleData) {
867 double valueInDouble = item.second;
868 double valueOutDouble = 0.0;
869 outMeta->GetData(item.first, valueOutDouble);
870 ASSERT_DOUBLE_EQ(valueOutDouble, valueInDouble);
871 }
872 for (auto item : testVetcorInt8Data) {
873 std::vector<uint8_t> valueInVecInt8 = item.second;
874 std::vector<uint8_t> valueOutVecInt8;
875 outMeta->GetData(item.first, valueOutVecInt8);
876 EXPECT_EQ(valueOutVecInt8, valueInVecInt8);
877 }
878 for (auto item : testVetcorInt32Data) {
879 std::vector<int32_t> valueInVecInt32 = item.second;
880 std::vector<int32_t> valueOutVecInt32;
881 outMeta->GetData(item.first, valueOutVecInt32);
882 EXPECT_EQ(valueOutVecInt32, valueInVecInt32);
883 }
884 }
885
886 /**
887 * @tc.name: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
888 * @tc.desc: SetGet_MetaData_All_As_VectorUint8_Using_ParcelPackage
889 * @tc.type: FUNC
890 */
891 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Mix_Using_ParcelPackage, TestSize.Level1)
892 {
893 PrepareInMeta(metaIn);
894 ASSERT_TRUE(metaIn->ToParcel(*parcel));
895 ASSERT_TRUE(metaOut->FromParcel(*parcel));
896 CheckOutMeta(metaOut);
897 }
898
899 /**
900 * @tc.name: SetGet_MetaData_All_As_Mix_Using_AssignCopy
901 * @tc.desc: SetGet_MetaData_All_As_Mix_Using_AssignCopy
902 * @tc.type: FUNC
903 */
904 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Mix_Using_AssignCopy, TestSize.Level1)
905 {
906 PrepareInMeta(metaIn);
907 Meta metaCopy = std::move(*metaIn);
908 for (auto item : testInt32Data) {
909 int32_t valueOutInt32 = 0;
910 ASSERT_FALSE(GetMetaData(*metaIn, item.first, valueOutInt32));
911 }
912 CheckOutMeta(make_shared<Meta>(metaCopy));
913 }
914
915 /**
916 * @tc.name: SetGet_MetaData_All_As_Mix_Using_SwapCopy
917 * @tc.desc: SetGet_MetaData_All_As_Mix_Using_SwapCopy
918 * @tc.type: FUNC
919 */
920 HWTEST_F(MetaInnerUnitTest, SetGet_MetaData_All_As_Mix_Using_SwapCopy, TestSize.Level1)
921 {
922 PrepareInMeta(metaIn);
923 Meta metaCopy(std::move(*metaIn));
924 for (auto item : testInt32Data) {
925 int32_t valueOutInt32 = 0;
926 ASSERT_FALSE(GetMetaData(*metaIn, item.first, valueOutInt32));
927 }
928 CheckOutMeta(make_shared<Meta>(metaCopy));
929 }
930
931 /**
932 * @tc.name: SetGet_Data_DrmStruct_Using_Parcel
933 * @tc.desc: SetGet_Data_DrmStruct_Using_Parcel
934 * @tc.type: FUNC
935 */
936 HWTEST_F(MetaInnerUnitTest, SetGet_Data_DrmStruct_Using_Parcel, TestSize.Level1)
937 {
938 uint8_t iv[META_DRM_IV_SIZE] = {
939 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43, 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2c
940 };
941 uint8_t keyId[META_DRM_KEY_ID_SIZE] = {
942 0x3a, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43, 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2a
943 };
944 Plugins::MetaDrmCencInfo *drmCencInfoIn = (Plugins::MetaDrmCencInfo *)malloc(sizeof(Plugins::MetaDrmCencInfo));
945 drmCencInfoIn->algo = Plugins::MetaDrmCencAlgorithm::META_DRM_ALG_CENC_SM4_CBC;
946 drmCencInfoIn->keyIdLen = META_DRM_KEY_ID_SIZE;
947 auto error = memcpy_s(drmCencInfoIn->keyId, sizeof(drmCencInfoIn->keyId), keyId, META_DRM_KEY_ID_SIZE);
948 ASSERT_EQ(error, EOK);
949 drmCencInfoIn->ivLen = META_DRM_IV_SIZE;
950 error = memcpy_s(drmCencInfoIn->iv, sizeof(drmCencInfoIn->iv), iv, META_DRM_IV_SIZE);
951 ASSERT_EQ(error, EOK);
952 drmCencInfoIn->encryptBlocks = 0;
953 drmCencInfoIn->skipBlocks = 0;
954 drmCencInfoIn->firstEncryptOffset = 0;
955 drmCencInfoIn->subSampleNum = 1;
956 for (uint32_t i = 0; i < drmCencInfoIn->subSampleNum; i++) {
957 drmCencInfoIn->subSamples[i].clearHeaderLen = 0x10;
958 drmCencInfoIn->subSamples[i].payLoadLen = 0;
959 }
960 std::vector<uint8_t> drmCencVecIn((uint8_t *)drmCencInfoIn,
961 ((uint8_t *)drmCencInfoIn) + sizeof(Plugins::MetaDrmCencInfo));
962 std::shared_ptr<Meta> metaIn = nullptr;
963 std::shared_ptr<Meta> metaOut = nullptr;
964 std::shared_ptr<MessageParcel> parcel = nullptr;
965 parcel = std::make_shared<MessageParcel>();
966 metaIn = std::make_shared<Meta>();
967 metaOut = std::make_shared<Meta>();
968 metaIn->SetData(Tag::DRM_CENC_INFO, drmCencVecIn);
969 ASSERT_TRUE(metaIn->ToParcel(*parcel));
970 ASSERT_TRUE(metaOut->FromParcel(*parcel));
971
972 std::vector<uint8_t> drmCencVecOut;
973 metaOut->GetData(Tag::DRM_CENC_INFO, drmCencVecOut);
974 Plugins::MetaDrmCencInfo *drmCencInfoOut = reinterpret_cast<Plugins::MetaDrmCencInfo *>(&drmCencVecOut[0]);
975
976 EXPECT_EQ(drmCencInfoIn->keyIdLen, drmCencInfoOut->keyIdLen);
977 free(drmCencInfoIn);
978 }
979
980 /**
981 * @tc.name: SetGet_self_Data_String_Using_Parcel
982 * @tc.desc: SetGet_self_Data_String_Using_Parcel
983 * @tc.type: FUNC
984 */
985 HWTEST_F(MetaInnerUnitTest, SetGet_self_Data_String_Using_Parcel, TestSize.Level1)
986 {
987 std::string valueOut = "123";
988 std::string valueIn = "123abc";
989 std::string key = "myself";
990 metaIn->SetData(key, valueIn);
991 ASSERT_TRUE(metaIn->ToParcel(*parcel));
992 ASSERT_TRUE(metaOut->FromParcel(*parcel));
993 metaOut->GetData(key, valueOut);
994 EXPECT_EQ(valueOut, valueIn);
995 }
996
997 /**
998 * @tc.name: SetGet_self_Data_float_Using_Parcel
999 * @tc.desc: SetGet_self_Data_float_Using_Parcel
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(MetaInnerUnitTest, SetGet_self_Data_float_Using_Parcel, TestSize.Level1)
1003 {
1004 float valueOut = 0.0f;
1005 float valueIn = 1.01f;
1006 std::string key = "myself";
1007 metaIn->SetData(key, valueIn);
1008 ASSERT_TRUE(metaIn->ToParcel(*parcel));
1009 ASSERT_TRUE(metaOut->FromParcel(*parcel));
1010 metaOut->GetData(key, valueOut);
1011 EXPECT_EQ(valueOut, valueIn);
1012 }
1013
1014 /**
1015 * @tc.name: GetValueType_Data_Boolean
1016 * @tc.desc: GetValueType_Data_Boolean
1017 * @tc.type: FUNC
1018 */
1019 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_Boolean, TestSize.Level1)
1020 {
1021 bool valueOut = true;
1022 bool valueIn = false;
1023 std::string key = "test";
1024 metaIn->SetData(key, valueIn);
1025 AnyValueType type = metaIn->GetValueType(key);
1026 ASSERT_TRUE(type == AnyValueType::BOOL);
1027 metaIn->GetData(key, valueOut);
1028 EXPECT_EQ(valueOut, valueIn);
1029 }
1030
1031 /**
1032 * @tc.name: GetValueType_Data_Int32
1033 * @tc.desc: GetValueType_Data_Int32
1034 * @tc.type: FUNC
1035 */
1036 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_Int32, TestSize.Level1)
1037 {
1038 int32_t valueOut = 0;
1039 int32_t valueIn = 141;
1040 std::string key = "test";
1041 metaIn->SetData(key, valueIn);
1042 AnyValueType type = metaIn->GetValueType(key);
1043 ASSERT_TRUE(type == AnyValueType::INT32_T);
1044 metaIn->GetData(key, valueOut);
1045 EXPECT_EQ(valueOut, valueIn);
1046 }
1047
1048 /**
1049 * @tc.name: GetValueType_Data_Int64
1050 * @tc.desc: GetValueType_Data_Int64
1051 * @tc.type: FUNC
1052 */
1053 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_Int64, TestSize.Level1)
1054 {
1055 int64_t valueOut = 0;
1056 int64_t valueIn = 141;
1057 std::string key = "test";
1058 metaIn->SetData(key, valueIn);
1059 AnyValueType type = metaIn->GetValueType(key);
1060 ASSERT_TRUE(type == AnyValueType::INT64_T);
1061 metaIn->GetData(key, valueOut);
1062 EXPECT_EQ(valueOut, valueIn);
1063 }
1064
1065 /**
1066 * @tc.name: GetValueType_Data_FLOAT
1067 * @tc.desc: GetValueType_Data_FLOAT
1068 * @tc.type: FUNC
1069 */
1070 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_FLOAT, TestSize.Level1)
1071 {
1072 float valueOut = 0;
1073 float valueIn = 1.01;
1074 std::string key = "test";
1075 metaIn->SetData(key, valueIn);
1076 AnyValueType type = metaIn->GetValueType(key);
1077 ASSERT_TRUE(type == AnyValueType::FLOAT);
1078 metaIn->GetData(key, valueOut);
1079 EXPECT_EQ(valueOut, valueIn);
1080 }
1081
1082 /**
1083 * @tc.name: GetValueType_Data_DOUBLE
1084 * @tc.desc: GetValueType_Data_DOUBLE
1085 * @tc.type: FUNC
1086 */
1087 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_DOUBLE, TestSize.Level1)
1088 {
1089 double valueOut = 0;
1090 double valueIn = 1.01;
1091 std::string key = "test";
1092 metaIn->SetData(key, valueIn);
1093 AnyValueType type = metaIn->GetValueType(key);
1094 ASSERT_TRUE(type == AnyValueType::DOUBLE);
1095 metaIn->GetData(key, valueOut);
1096 EXPECT_EQ(valueOut, valueIn);
1097 }
1098
1099 /**
1100 * @tc.name: GetValueType_Data_VECTOR_UINT8
1101 * @tc.desc: GetValueType_Data_VECTOR_UINT8
1102 * @tc.type: FUNC
1103 */
1104 HWTEST_F(MetaInnerUnitTest, GetValueType_Data_VECTOR_UINT8, TestSize.Level1)
1105 {
1106 vector<uint8_t> valueOut{1, 2, 3};
1107 vector<uint8_t> valueIn{1, 2, 3, 4};
1108 std::string key = "test";
1109 metaIn->SetData(key, valueIn);
1110 AnyValueType type = metaIn->GetValueType(key);
1111 ASSERT_TRUE(type == AnyValueType::VECTOR_UINT8);
1112 metaIn->GetData(key, valueOut);
1113 EXPECT_EQ(valueOut, valueIn);
1114 }
1115
1116 /**
1117 * @tc.name: Meta_GetData_All_As_Bool_Using_ParcelPackage
1118 * @tc.desc:
1119 * 1. set bool to format;
1120 * 2. meta trans by parcel;
1121 * 3. get meta value type;
1122 * @tc.type: FUNC
1123 */
1124 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_Bool_Using_ParcelPackage, TestSize.Level1)
1125 {
1126 for (auto item : testBoolData) {
1127 bool valueIn = item.second;
1128 MessageParcel parcel;
1129 std::shared_ptr<Format> format = std::make_shared<Format>();
1130 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1131
1132 EXPECT_TRUE(format->PutIntValue(item.first, valueIn));
1133 meta = format->GetMeta();
1134 ASSERT_TRUE(meta->ToParcel(parcel));
1135 ASSERT_TRUE(meta->FromParcel(parcel));
1136
1137 bool valueOut = !valueIn;
1138 int32_t intValue = -1;
1139 EXPECT_FALSE(meta->GetData(item.first, intValue));
1140 EXPECT_TRUE(meta->GetData(item.first, valueOut));
1141 EXPECT_EQ(valueIn, valueOut);
1142 }
1143 }
1144
1145 /**
1146 * @tc.name: Meta_GetData_All_As_Int32_Using_ParcelPackage
1147 * @tc.desc:
1148 * 1. set int32_t 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_Int32_Using_ParcelPackage, TestSize.Level1)
1154 {
1155 std::vector<TagType> skipList = {Tag::AUDIO_AAC_PROFILE, Tag::AUDIO_AAC_STREAM_FORMAT};
1156 for (auto item : testInt32Data) {
1157 auto iter = std::find(skipList.begin(), skipList.end(), item.first);
1158 if (iter != skipList.end()) {
1159 continue;
1160 }
1161
1162 int32_t valueIn = item.second;
1163 MessageParcel parcel;
1164 std::shared_ptr<Format> format = std::make_shared<Format>();
1165 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1166
1167 EXPECT_TRUE(format->PutIntValue(item.first, valueIn));
1168 meta = format->GetMeta();
1169 ASSERT_TRUE(meta->ToParcel(parcel));
1170 ASSERT_TRUE(meta->FromParcel(parcel));
1171
1172 int32_t valueOut = -1;
1173 EXPECT_TRUE(GetMetaData(*meta, item.first, valueOut));
1174 EXPECT_EQ(valueIn, valueOut);
1175 }
1176 }
1177
1178 /**
1179 * @tc.name: Meta_GetData_All_As_Int64_Using_ParcelPackage
1180 * @tc.desc:
1181 * 1. set int64_t to format;
1182 * 2. meta trans by parcel;
1183 * 3. get meta value type;
1184 * @tc.type: FUNC
1185 */
1186 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_Int64_Using_ParcelPackage, TestSize.Level1)
1187 {
1188 std::vector<TagType> skipList = {Tag::MEDIA_FILE_SIZE, Tag::MEDIA_POSITION};
1189 for (auto item : testInt64Data) {
1190 auto iter = std::find(skipList.begin(), skipList.end(), item.first);
1191 if (iter != skipList.end()) {
1192 continue;
1193 }
1194
1195 int64_t valueIn = item.second;
1196 MessageParcel parcel;
1197 std::shared_ptr<Format> format = std::make_shared<Format>();
1198 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1199
1200 EXPECT_TRUE(format->PutLongValue(item.first, valueIn));
1201 meta = format->GetMeta();
1202 ASSERT_TRUE(meta->ToParcel(parcel));
1203 ASSERT_TRUE(meta->FromParcel(parcel));
1204
1205 int64_t valueOut = -1;
1206 EXPECT_TRUE(GetMetaData(*meta, item.first, valueOut));
1207 EXPECT_EQ(valueIn, valueOut);
1208 }
1209 }
1210
1211 /**
1212 * @tc.name: Meta_GetData_All_As_Float_Using_ParcelPackage
1213 * @tc.desc:
1214 * 1. set float to format;
1215 * 2. meta trans by parcel;
1216 * 3. get meta value type;
1217 * @tc.type: FUNC
1218 */
1219 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_Float_Using_ParcelPackage, TestSize.Level1)
1220 {
1221 for (auto item : testFloatData) {
1222 float valueIn = item.second;
1223 MessageParcel parcel;
1224 std::shared_ptr<Format> format = std::make_shared<Format>();
1225 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1226
1227 EXPECT_TRUE(format->PutFloatValue(item.first, valueIn));
1228 meta = format->GetMeta();
1229 ASSERT_TRUE(meta->ToParcel(parcel));
1230 ASSERT_TRUE(meta->FromParcel(parcel));
1231
1232 float valueOut = 0.0f;
1233 ASSERT_TRUE(meta->GetData(item.first, valueOut));
1234 EXPECT_EQ(valueIn, valueOut);
1235 }
1236 }
1237
1238 /**
1239 * @tc.name: Meta_GetData_All_As_Double_Using_ParcelPackage
1240 * @tc.desc:
1241 * 1. set double to format;
1242 * 2. meta trans by parcel;
1243 * 3. get meta value type;
1244 * @tc.type: FUNC
1245 */
1246 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_Double_Using_ParcelPackage, TestSize.Level1)
1247 {
1248 for (auto item : testDoubleData) {
1249 double valueIn = item.second;
1250 MessageParcel parcel;
1251 std::shared_ptr<Format> format = std::make_shared<Format>();
1252 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1253
1254 EXPECT_TRUE(format->PutDoubleValue(item.first, valueIn));
1255 meta = format->GetMeta();
1256 ASSERT_TRUE(meta->ToParcel(parcel));
1257 ASSERT_TRUE(meta->FromParcel(parcel));
1258
1259 double valueOut = 0.0;
1260 ASSERT_TRUE(meta->GetData(item.first, valueOut));
1261 EXPECT_EQ(valueIn, valueOut);
1262 }
1263 }
1264
1265 /**
1266 * @tc.name: Meta_GetData_All_As_String_Using_ParcelPackage
1267 * @tc.desc:
1268 * 1. set string to format;
1269 * 2. meta trans by parcel;
1270 * 3. get meta value type;
1271 * @tc.type: FUNC
1272 */
1273 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_String_Using_ParcelPackage, TestSize.Level1)
1274 {
1275 for (auto item : testStringData) {
1276 string valueIn = item.second;
1277 MessageParcel parcel;
1278 std::shared_ptr<Format> format = std::make_shared<Format>();
1279 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1280
1281 EXPECT_TRUE(format->PutStringValue(item.first, valueIn));
1282 meta = format->GetMeta();
1283 ASSERT_TRUE(meta->ToParcel(parcel));
1284 ASSERT_TRUE(meta->FromParcel(parcel));
1285
1286 string valueOut = "String Value";
1287 EXPECT_TRUE(meta->GetData(item.first, valueOut));
1288 EXPECT_EQ(valueIn, valueOut);
1289 }
1290 }
1291
1292 /**
1293 * @tc.name: Meta_GetData_All_As_VectorUint8_Using_ParcelPackage
1294 * @tc.desc:
1295 * 1. set vectorUint8 to format;
1296 * 2. meta trans by parcel;
1297 * 3. get meta value type;
1298 * @tc.type: FUNC
1299 */
1300 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_VectorUint8_Using_ParcelPackage, TestSize.Level1)
1301 {
1302 for (auto item : testVetcorInt8Data) {
1303 std::vector<uint8_t> valueIn = item.second;
1304 MessageParcel parcel;
1305 std::shared_ptr<Format> format = std::make_shared<Format>();
1306 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1307
1308 EXPECT_TRUE(format->PutBuffer(item.first, valueIn.data(), valueIn.size()));
1309 meta = format->GetMeta();
1310 ASSERT_TRUE(meta->ToParcel(parcel));
1311 ASSERT_TRUE(meta->FromParcel(parcel));
1312
1313 std::vector<uint8_t> valueOut;
1314 EXPECT_TRUE(meta->GetData(item.first, valueOut));
1315 EXPECT_EQ(valueIn, valueOut);
1316 }
1317 }
1318
1319 /**
1320 * @tc.name: Meta_GetData_All_As_VectorInt32_Using_ParcelPackage
1321 * @tc.desc:
1322 * 1. set vectorInt32 to format;
1323 * 2. meta trans by parcel;
1324 * 3. get meta value type;
1325 * @tc.type: FUNC
1326 */
1327 HWTEST_F(MetaInnerUnitTest, Meta_GetData_All_As_VectorInt32_Using_ParcelPackage, TestSize.Level1)
1328 {
1329 for (auto item : testVetcorInt32Data) {
1330 std::vector<int32_t> valueIn = item.second;
1331 MessageParcel parcel;
1332 std::shared_ptr<Format> format = std::make_shared<Format>();
1333 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1334
1335 EXPECT_TRUE(format->PutIntBuffer(item.first, valueIn.data(), valueIn.size()));
1336 meta = format->GetMeta();
1337 ASSERT_TRUE(meta->ToParcel(parcel));
1338 ASSERT_TRUE(meta->FromParcel(parcel));
1339
1340 std::vector<int32_t> valueOut;
1341 EXPECT_TRUE(meta->GetData(item.first, valueOut));
1342 EXPECT_EQ(valueIn, valueOut);
1343 }
1344 }
1345 } // namespace MetaFuncUT
1346 } // namespace Media
1347 } // namespace OHOS
1348