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