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