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 "avformat_unit_test.h"
17 #include <cmath>
18 #include <gtest/gtest.h>
19 #include <iostream>
20 #include <sstream>
21 #include "common/status.h"
22 #include "meta/format.h"
23 #include "meta/meta.h"
24 #include "securec.h"
25 
26 using namespace std;
27 using namespace OHOS;
28 using namespace OHOS::Media;
29 using namespace testing::ext;
30 namespace {
31 
32 constexpr float EPSINON_FLOAT = 0.0001;
33 constexpr double EPSINON_DOUBLE = 0.0001;
34 
35 constexpr int32_t INT_VALUE = 124;
36 constexpr int64_t LONG_VALUE = 12435;
37 constexpr double DOUBLE_VALUE = 666.625;
38 const std::string STRING_VALUE = "STRING_VALUE";
39 const std::vector<uint8_t> BUFFER_VALUE{1, 2, 3, 4, 255, 0, 255};
40 
41 #define INT_TESTKEY Tag::APP_PID
42 #define INT_ENUM_TESTKEY Tag::VIDEO_ROTATION
43 #define LONG_TESTKEY Tag::MEDIA_DURATION
44 #define LONG_ENUM_TESTKEY Tag::AUDIO_CHANNEL_LAYOUT
45 #define DOUBLE_TESTKEY Tag::VIDEO_CAPTURE_RATE
46 #define STRING_TESTKEY Tag::MEDIA_FILE_URI
47 #define BUFFER_TESTKEY Tag::MEDIA_COVER
48 } // namespace
49 
50 namespace OHOS {
51 namespace Media {
52 
SetUpTestCase(void)53 void AVFormatUnitTest::SetUpTestCase(void) {}
54 
TearDownTestCase(void)55 void AVFormatUnitTest::TearDownTestCase(void) {}
56 
SetUp(void)57 void AVFormatUnitTest::SetUp(void)
58 {
59     format_ = FormatMockFactory::CreateFormat();
60     ASSERT_NE(nullptr, format_);
61 }
62 
TearDown(void)63 void AVFormatUnitTest::TearDown(void)
64 {
65     if (format_ != nullptr) {
66         format_->Destroy();
67     }
68 }
69 
70 /**
71  * @tc.name: Format_Value_001
72  * @tc.desc: format put and get value
73  * @tc.type: FUNC
74  * @tc.require: issueI5OX06 issueI5P8N0
75  */
76 HWTEST_F(AVFormatUnitTest, Format_Value_001, TestSize.Level1)
77 {
78     const std::string_view floatKey = "FloatKey";
79     float floatValue = 1.0;
80 
81     int32_t getIntValue = 0;
82     int64_t getLongValue = 0;
83     float getFloatValue = 0.0;
84     double getDoubleValue = 0.0;
85     std::string getStringValue = "";
86 
87     EXPECT_TRUE(format_->PutIntValue(INT_TESTKEY, INT_VALUE));
88     EXPECT_TRUE(format_->GetIntValue(INT_TESTKEY, getIntValue));
89     EXPECT_TRUE(getIntValue == INT_VALUE);
90     EXPECT_FALSE(format_->GetLongValue(INT_TESTKEY, getLongValue));
91 
92     EXPECT_TRUE(format_->PutLongValue(LONG_TESTKEY, LONG_VALUE));
93     EXPECT_TRUE(format_->GetLongValue(LONG_TESTKEY, getLongValue));
94     EXPECT_TRUE(getLongValue == LONG_VALUE);
95     EXPECT_FALSE(format_->GetIntValue(LONG_TESTKEY, getIntValue));
96 
97     EXPECT_TRUE(format_->PutFloatValue(floatKey, floatValue));
98     EXPECT_TRUE(format_->GetFloatValue(floatKey, getFloatValue));
99     EXPECT_TRUE(fabs(floatValue - getFloatValue) < EPSINON_FLOAT);
100     EXPECT_FALSE(format_->GetDoubleValue(floatKey, getDoubleValue));
101 
102     EXPECT_TRUE(format_->PutDoubleValue(DOUBLE_TESTKEY, DOUBLE_VALUE));
103     EXPECT_TRUE(format_->GetDoubleValue(DOUBLE_TESTKEY, getDoubleValue));
104     EXPECT_TRUE(fabs(DOUBLE_VALUE - getDoubleValue) < EPSINON_DOUBLE);
105     EXPECT_FALSE(format_->GetFloatValue(DOUBLE_TESTKEY, getFloatValue));
106 
107     EXPECT_TRUE(format_->PutStringValue(STRING_TESTKEY, STRING_VALUE.c_str()));
108     EXPECT_TRUE(format_->GetStringValue(STRING_TESTKEY, getStringValue));
109     EXPECT_TRUE(STRING_VALUE == getStringValue);
110 }
111 
112 /**
113  * @tc.name: Format_Buffer_001
114  * @tc.desc: format put and get buffer
115  * @tc.type: FUNC
116  * @tc.require: issueI5OWXY issueI5OXCD
117  */
118 HWTEST_F(AVFormatUnitTest, Format_Buffer_001, TestSize.Level1)
119 {
120     constexpr size_t size = 3;
121     const std::string_view key = "BufferKey";
122     uint8_t buffer[size] = {'a', 'b', 'b'};
123 
124     EXPECT_TRUE(format_->PutBuffer(key, buffer, size));
125     uint8_t *getBuffer;
126     size_t getSize;
127     EXPECT_TRUE(format_->GetBuffer(key, &getBuffer, getSize));
128     EXPECT_TRUE(getSize == size);
129     for (size_t i = 0; i < size; i++) {
130         EXPECT_TRUE(buffer[i] == getBuffer[i]);
131     }
132 
133     std::string getString;
134     EXPECT_FALSE(format_->GetStringValue(key, getString));
135 }
136 
137 /**
138  * @tc.name: Format_DumpInfo_001
139  * @tc.desc:
140  *     1. set format;
141  *     2. dmpinfo;
142  * @tc.type: FUNC
143  * @tc.require: issueI5OWXY issueI5OXCD
144  */
145 HWTEST_F(AVFormatUnitTest, Format_DumpInfo_001, TestSize.Level1)
146 {
147     const std::string_view floatKey = "FloatKey";
148     float floatValue = 1.0;
149 
150     EXPECT_TRUE(format_->PutIntValue(INT_TESTKEY, INT_VALUE));
151     EXPECT_TRUE(format_->PutLongValue(LONG_TESTKEY, LONG_VALUE));
152     EXPECT_TRUE(format_->PutFloatValue(floatKey, floatValue));
153     EXPECT_TRUE(format_->PutDoubleValue(DOUBLE_TESTKEY, DOUBLE_VALUE));
154     EXPECT_TRUE(format_->PutStringValue(STRING_TESTKEY, STRING_VALUE.c_str()));
155 
156     std::string dumpInfo = format_->DumpInfo();
157     std::cout << "dumpInfo: [" << dumpInfo << "]\n";
158 
159     std::stringstream dumpStream;
160     dumpStream << floatKey << " = " << floatValue;
161     EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
162                                                              << "dumpInfo: [" << dumpInfo << "]\n";
163 
164     dumpStream.str("");
165     dumpStream << DOUBLE_TESTKEY << " = " << DOUBLE_VALUE;
166     EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
167                                                              << "dumpInfo: [" << dumpInfo << "]\n";
168 
169     dumpStream.str("");
170     dumpStream << INT_TESTKEY << " = " << INT_VALUE;
171     EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
172                                                              << "dumpInfo: [" << dumpInfo << "]\n";
173 
174     dumpStream.str("");
175     dumpStream << LONG_TESTKEY << " = " << LONG_VALUE;
176     EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
177                                                              << "dumpInfo: [" << dumpInfo << "]\n";
178 
179     dumpStream.str("");
180     dumpStream << STRING_TESTKEY << " = " << STRING_VALUE;
181     EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
182                                                              << "dumpInfo: [" << dumpInfo << "]\n";
183 }
184 
185 #ifndef AVFORMAT_CAPI_UNIT_TEST
186 /**
187  * @tc.name: Format_DumpInfo_002
188  * @tc.desc:
189  *     1. set format;
190  *     2. meta trans by parcel;
191  *     3. dmpinfo;
192  * @tc.type: FUNC
193  * @tc.require: issueI5OWXY issueI5OXCD
194  */
195 HWTEST_F(AVFormatUnitTest, Format_DumpInfo_002, TestSize.Level1)
196 {
197     std::shared_ptr<Format> format = std::make_shared<Format>();
198     EXPECT_TRUE(format->PutIntValue(INT_TESTKEY, INT_VALUE));
199     EXPECT_TRUE(format->PutLongValue(LONG_TESTKEY, LONG_VALUE));
200     EXPECT_TRUE(format->PutDoubleValue(DOUBLE_TESTKEY, DOUBLE_VALUE));
201     EXPECT_TRUE(format->PutStringValue(STRING_TESTKEY, STRING_VALUE.c_str()));
202 
203     std::string dumpInfo = format->Stringify();
204     std::cout << "dumpInfo: [" << dumpInfo << "]\n";
205     std::stringstream dumpStream;
__anonf32ef11e0202() 206     auto checkFunc = [&dumpStream, &dumpInfo]() {
207         dumpStream.str("");
208         dumpStream << DOUBLE_TESTKEY << " = " << DOUBLE_VALUE;
209         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
210                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
211 
212         dumpStream.str("");
213         dumpStream << INT_TESTKEY << " = " << INT_VALUE;
214         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
215                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
216 
217         dumpStream.str("");
218         dumpStream << LONG_TESTKEY << " = " << LONG_VALUE;
219         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
220                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
221 
222         dumpStream.str("");
223         dumpStream << STRING_TESTKEY << " = " << STRING_VALUE;
224         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
225                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
226     };
227     std::cout << "before trans by parcel:\n";
228     checkFunc();
229 
230     MessageParcel parcel;
231     std::shared_ptr<Meta> meta = std::make_shared<Meta>();
232 
233     meta = format->GetMeta();
234     ASSERT_TRUE(meta->ToParcel(parcel));
235     ASSERT_TRUE(meta->FromParcel(parcel));
236 
237     format->SetMeta(std::move(meta));
238     dumpInfo = format->Stringify();
239     std::cout << "after trans by parcel:\n";
240     checkFunc();
241 }
242 
243 /**
244  * @tc.name: Format_DumpInfo_003
245  * @tc.desc:
246  *     1. set meta to format;
247  *     2. meta trans by parcel;
248  *     3. dmpinfo;
249  * @tc.type: FUNC
250  * @tc.require: issueI5OWXY issueI5OXCD
251  */
252 HWTEST_F(AVFormatUnitTest, Format_DumpInfo_003, TestSize.Level1)
253 {
254     MessageParcel parcel;
255     std::shared_ptr<Format> format = std::make_shared<Format>();
256     std::shared_ptr<Meta> meta = std::make_shared<Meta>();
257     meta->SetData(INT_TESTKEY, INT_VALUE);
258     meta->SetData(LONG_TESTKEY, LONG_VALUE);
259     meta->SetData(DOUBLE_TESTKEY, DOUBLE_VALUE);
260     meta->SetData(STRING_TESTKEY, STRING_VALUE);
261 
262     format->SetMeta(meta);
263     std::string dumpInfo = format->Stringify();
264     std::cout << "dumpInfo: [" << dumpInfo << "]\n";
265     std::stringstream dumpStream;
__anonf32ef11e0302() 266     auto checkFunc = [&dumpStream, &dumpInfo]() {
267         dumpStream.str("");
268         dumpStream << DOUBLE_TESTKEY << " = " << DOUBLE_VALUE;
269         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
270                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
271 
272         dumpStream.str("");
273         dumpStream << INT_TESTKEY << " = " << INT_VALUE;
274         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
275                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
276 
277         dumpStream.str("");
278         dumpStream << LONG_TESTKEY << " = " << LONG_VALUE;
279         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
280                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
281 
282         dumpStream.str("");
283         dumpStream << STRING_TESTKEY << " = " << STRING_VALUE;
284         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
285                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
286     };
287     std::cout << "before trans by parcel:\n";
288     checkFunc();
289 
290     meta = format->GetMeta();
291     ASSERT_TRUE(meta->ToParcel(parcel));
292     ASSERT_TRUE(meta->FromParcel(parcel));
293 
294     format = std::make_shared<Format>();
295     format->SetMeta(std::move(meta));
296     dumpInfo = format->Stringify();
297     std::cout << "after trans by parcel:\n";
298     checkFunc();
299 }
300 
301 /**
302  * @tc.name: Format_DumpInfo_004
303  * @tc.desc:
304  *     1. set buffer to format;
305  *     2. meta trans by parcel;
306  *     3. dmpinfo;
307  * @tc.type: FUNC
308  * @tc.require: issueI5OWXY issueI5OXCD
309  */
310 HWTEST_F(AVFormatUnitTest, Format_DumpInfo_004, TestSize.Level1)
311 {
312     MessageParcel parcel;
313     std::shared_ptr<Format> format = std::make_shared<Format>();
314     std::shared_ptr<Meta> meta = std::make_shared<Meta>();
315 
316     format->PutBuffer(BUFFER_TESTKEY, BUFFER_VALUE.data(), BUFFER_VALUE.size());
317     std::string dumpInfo = format->Stringify();
318     std::cout << "dumpInfo: [" << dumpInfo << "]\n";
319     std::stringstream dumpStream;
__anonf32ef11e0402() 320     auto checkFunc = [&dumpStream, &dumpInfo]() {
321         dumpStream.str("");
322         dumpStream << BUFFER_TESTKEY << ", bufferSize = " << BUFFER_VALUE.size();
323         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
324                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
325     };
326     std::cout << "before trans by parcel:\n";
327     checkFunc();
328 
329     meta = format->GetMeta();
330     ASSERT_TRUE(meta->ToParcel(parcel));
331     ASSERT_TRUE(meta->FromParcel(parcel));
332 
333     format = std::make_shared<Format>();
334     format->SetMeta(std::move(meta));
335     dumpInfo = format->Stringify();
336     std::cout << "after trans by parcel:\n";
337     checkFunc();
338 }
339 
340 /**
341  * @tc.name: Format_DumpInfo_005
342  * @tc.desc:
343  *     1. set buffer to meta;
344  *     2. meta trans by parcel;
345  *     3. dmpinfo;
346  * @tc.type: FUNC
347  * @tc.require: issueI5OWXY issueI5OXCD
348  */
349 HWTEST_F(AVFormatUnitTest, Format_DumpInfo_005, TestSize.Level1)
350 {
351     MessageParcel parcel;
352     std::shared_ptr<Format> format = std::make_shared<Format>();
353     std::shared_ptr<Meta> meta = std::make_shared<Meta>();
354     meta->SetData(BUFFER_TESTKEY, BUFFER_VALUE);
355     format->SetMeta(meta);
356 
357     std::string dumpInfo = format->Stringify();
358     std::cout << "dumpInfo: [" << dumpInfo << "]\n";
359     std::stringstream dumpStream;
__anonf32ef11e0502() 360     auto checkFunc = [&dumpStream, &dumpInfo]() {
361         dumpStream.str("");
362         dumpStream << BUFFER_TESTKEY << ", bufferSize = " << BUFFER_VALUE.size();
363         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
364                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
365     };
366     std::cout << "before trans by parcel:\n";
367     checkFunc();
368 
369     meta = format->GetMeta();
370     ASSERT_TRUE(meta->ToParcel(parcel));
371     ASSERT_TRUE(meta->FromParcel(parcel));
372 
373     format = std::make_shared<Format>();
374     format->SetMeta(std::move(meta));
375     dumpInfo = format->Stringify();
376     std::cout << "after trans by parcel:\n";
377     checkFunc();
378 }
379 
380 /**
381  * @tc.name: Format_DumpInfo_006
382  * @tc.desc:
383  *     1. set enum to format;
384  *     2. meta trans by parcel;
385  *     3. dmpinfo;
386  * @tc.type: FUNC
387  * @tc.require: issueI5OWXY issueI5OXCD
388  */
389 HWTEST_F(AVFormatUnitTest, Format_DumpInfo_006, TestSize.Level1)
390 {
391     MessageParcel parcel;
392     std::shared_ptr<Format> format = std::make_shared<Format>();
393     std::shared_ptr<Meta> meta = std::make_shared<Meta>();
394     EXPECT_TRUE(format->PutIntValue(INT_ENUM_TESTKEY, INT_VALUE));
395     EXPECT_TRUE(format->PutLongValue(LONG_ENUM_TESTKEY, LONG_VALUE));
396 
397     std::string dumpInfo = format->Stringify();
398     std::cout << "dumpInfo: [" << dumpInfo << "]\n";
399     std::stringstream dumpStream;
__anonf32ef11e0602() 400     auto checkFunc = [&dumpStream, &dumpInfo]() {
401         dumpStream.str("");
402         dumpStream << INT_ENUM_TESTKEY << " = " << INT_VALUE;
403         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
404                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
405 
406         dumpStream.str("");
407         dumpStream << LONG_ENUM_TESTKEY << " = " << LONG_VALUE;
408         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
409                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
410     };
411     std::cout << "before trans by parcel:\n";
412     checkFunc();
413 
414     meta = format->GetMeta();
415     ASSERT_TRUE(meta->ToParcel(parcel));
416     ASSERT_TRUE(meta->FromParcel(parcel));
417 
418     format = std::make_shared<Format>();
419     format->SetMeta(std::move(meta));
420     dumpInfo = format->Stringify();
421     std::cout << "after trans by parcel:\n";
422     checkFunc();
423 }
424 
425 /**
426  * @tc.name: Format_DumpInfo_007
427  * @tc.desc:
428  *     1. set enum to meta;
429  *     2. meta trans by parcel;
430  *     3. dmpinfo;
431  * @tc.type: FUNC
432  * @tc.require: issueI5OWXY issueI5OXCD
433  */
434 HWTEST_F(AVFormatUnitTest, Format_DumpInfo_007, TestSize.Level1)
435 {
436     MessageParcel parcel;
437     std::shared_ptr<Format> format = std::make_shared<Format>();
438     std::shared_ptr<Meta> meta = std::make_shared<Meta>();
439     meta->SetData(INT_ENUM_TESTKEY, INT_VALUE);
440     meta->SetData(LONG_ENUM_TESTKEY, LONG_VALUE);
441 
442     format->SetMeta(meta);
443     std::string dumpInfo = format->Stringify();
444     std::cout << "dumpInfo: [" << dumpInfo << "]\n";
445     std::stringstream dumpStream;
__anonf32ef11e0702() 446     auto checkFunc = [&dumpStream, &dumpInfo]() {
447         dumpStream.str("");
448         dumpStream << INT_ENUM_TESTKEY << " = " << INT_VALUE;
449         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
450                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
451 
452         dumpStream.str("");
453         dumpStream << LONG_ENUM_TESTKEY << " = " << LONG_VALUE;
454         EXPECT_NE(dumpInfo.find(dumpStream.str()), string::npos) << "dumpStream: [" << dumpStream.str() << "]\n"
455                                                                  << "dumpInfo: [" << dumpInfo << "]\n";
456     };
457     std::cout << "before trans by parcel:\n";
458     checkFunc();
459 
460     meta = format->GetMeta();
461     ASSERT_TRUE(meta->ToParcel(parcel));
462     ASSERT_TRUE(meta->FromParcel(parcel));
463 
464     format = std::make_shared<Format>();
465     format->SetMeta(std::move(meta));
466     dumpInfo = format->Stringify();
467     std::cout << "after trans by parcel:\n";
468     checkFunc();
469 }
470 
CheckFormatMap(Format::FormatDataMap & formatMap)471 void CheckFormatMap(Format::FormatDataMap &formatMap)
472 {
473     const std::string floatKey = "FloatKey";
474     float floatValue = 1.0;
475     auto iter = formatMap.find(INT_TESTKEY);
476     ASSERT_NE(iter, formatMap.end());
477     EXPECT_EQ(iter->second.type, FORMAT_TYPE_INT32);
478     EXPECT_EQ(iter->second.val.int32Val, INT_VALUE);
479 
480     iter = formatMap.find(LONG_TESTKEY);
481     ASSERT_NE(iter, formatMap.end());
482     EXPECT_EQ(iter->second.type, FORMAT_TYPE_INT64);
483     EXPECT_EQ(iter->second.val.int64Val, LONG_VALUE);
484 
485     iter = formatMap.find(floatKey);
486     ASSERT_NE(iter, formatMap.end());
487     EXPECT_EQ(iter->second.type, FORMAT_TYPE_FLOAT);
488     EXPECT_EQ(iter->second.val.floatVal, floatValue);
489 
490     iter = formatMap.find(DOUBLE_TESTKEY);
491     ASSERT_NE(iter, formatMap.end());
492     EXPECT_EQ(iter->second.type, FORMAT_TYPE_DOUBLE);
493     EXPECT_EQ(iter->second.val.doubleVal, DOUBLE_VALUE);
494 
495     iter = formatMap.find(STRING_TESTKEY);
496     ASSERT_NE(iter, formatMap.end());
497     EXPECT_EQ(iter->second.type, FORMAT_TYPE_STRING);
498     EXPECT_EQ(iter->second.stringVal, STRING_VALUE);
499 
500     iter = formatMap.find(BUFFER_TESTKEY);
501     ASSERT_NE(iter, formatMap.end());
502     EXPECT_EQ(iter->second.type, FORMAT_TYPE_ADDR);
503     EXPECT_EQ(iter->second.size, BUFFER_VALUE.size());
504     for (size_t i = 0; i < iter->second.size; ++i) {
505         EXPECT_EQ(iter->second.addr[i], BUFFER_VALUE[i]);
506     }
507 
508     iter = formatMap.find(INT_ENUM_TESTKEY);
509     ASSERT_NE(iter, formatMap.end());
510     EXPECT_EQ(iter->second.type, FORMAT_TYPE_INT32);
511     EXPECT_EQ(iter->second.val.int32Val, static_cast<int32_t>(Plugins::VideoRotation::VIDEO_ROTATION_90));
512 
513     iter = formatMap.find(LONG_ENUM_TESTKEY);
514     ASSERT_NE(iter, formatMap.end());
515     EXPECT_EQ(iter->second.type, FORMAT_TYPE_INT64);
516     EXPECT_EQ(iter->second.val.int64Val, static_cast<int64_t>(Plugins::AudioChannelLayout::STEREO));
517 }
518 /**
519  * @tc.name: Format_GetFormatMap_001
520  * @tc.desc:
521  *     1. set values to meta;
522  *     2. get formatMap;
523  * @tc.type: FUNC
524  * @tc.require: issueI5OWXY issueI5OXCD
525  */
526 HWTEST_F(AVFormatUnitTest, Format_GetFormatMap_001, TestSize.Level1)
527 {
528     MessageParcel parcel;
529     std::shared_ptr<Format> format = std::make_shared<Format>();
530     std::shared_ptr<Meta> meta = std::make_shared<Meta>();
531     const std::string floatKey = "FloatKey";
532     float floatValue = 1.0;
533 
534     meta->SetData(INT_TESTKEY, INT_VALUE);
535     meta->SetData(LONG_TESTKEY, LONG_VALUE);
536     meta->SetData(floatKey, floatValue);
537     meta->SetData(DOUBLE_TESTKEY, DOUBLE_VALUE);
538     meta->SetData(STRING_TESTKEY, STRING_VALUE);
539     meta->SetData(BUFFER_TESTKEY, BUFFER_VALUE);
540     meta->SetData(INT_ENUM_TESTKEY, Plugins::VideoRotation::VIDEO_ROTATION_90);
541     meta->SetData(LONG_ENUM_TESTKEY, Plugins::AudioChannelLayout::STEREO);
542 
543     format->SetMeta(meta);
544     Format::FormatDataMap formatMap = format->GetFormatMap();
545     CheckFormatMap(formatMap);
546 }
547 
548 /**
549  * @tc.name: Format_GetFormatMap_002
550  * @tc.desc:
551  *     1. set values to meta;
552  *     2. meta trans by parcel;
553  *     3. get formatMap;
554  * @tc.type: FUNC
555  * @tc.require: issueI5OWXY issueI5OXCD
556  */
557 HWTEST_F(AVFormatUnitTest, Format_GetFormatMap_002, TestSize.Level1)
558 {
559     MessageParcel parcel;
560     std::shared_ptr<Format> format = std::make_shared<Format>();
561     std::shared_ptr<Meta> meta = std::make_shared<Meta>();
562     const std::string floatKey = "FloatKey";
563     float floatValue = 1.0;
564 
565     meta->SetData(INT_TESTKEY, INT_VALUE);
566     meta->SetData(LONG_TESTKEY, LONG_VALUE);
567     meta->SetData(floatKey, floatValue);
568     meta->SetData(DOUBLE_TESTKEY, DOUBLE_VALUE);
569     meta->SetData(STRING_TESTKEY, STRING_VALUE);
570     meta->SetData(BUFFER_TESTKEY, BUFFER_VALUE);
571     meta->SetData(INT_ENUM_TESTKEY, Plugins::VideoRotation::VIDEO_ROTATION_90);
572     meta->SetData(LONG_ENUM_TESTKEY, Plugins::AudioChannelLayout::STEREO);
573 
574     format->SetMeta(meta);
575     meta = format->GetMeta();
576     ASSERT_TRUE(meta->ToParcel(parcel));
577     ASSERT_TRUE(meta->FromParcel(parcel));
578 
579     format = std::make_shared<Format>();
580     format->SetMeta(std::move(meta));
581     Format::FormatDataMap formatMap = format->GetFormatMap();
582     CheckFormatMap(formatMap);
583 }
584 
CheckValueType(std::shared_ptr<Format> & format)585 void CheckValueType(std::shared_ptr<Format> &format)
586 {
587     const std::string floatKey = "FloatKey";
588 
589     EXPECT_EQ(format->GetValueType(INT_TESTKEY), FORMAT_TYPE_INT32);
590 
591     EXPECT_EQ(format->GetValueType(LONG_TESTKEY), FORMAT_TYPE_INT64);
592 
593     EXPECT_EQ(format->GetValueType(floatKey), FORMAT_TYPE_FLOAT);
594 
595     EXPECT_EQ(format->GetValueType(DOUBLE_TESTKEY), FORMAT_TYPE_DOUBLE);
596 
597     EXPECT_EQ(format->GetValueType(STRING_TESTKEY), FORMAT_TYPE_STRING);
598 
599     EXPECT_EQ(format->GetValueType(BUFFER_TESTKEY), FORMAT_TYPE_ADDR);
600 
601     EXPECT_EQ(format->GetValueType(INT_ENUM_TESTKEY), FORMAT_TYPE_INT32);
602 
603     EXPECT_EQ(format->GetValueType(LONG_ENUM_TESTKEY), FORMAT_TYPE_INT64);
604 }
605 
606 /**
607  * @tc.name: Format_GetValueType_001
608  * @tc.desc:
609  *     1. set values to meta;
610  *     2. get format value type;
611  * @tc.type: FUNC
612  * @tc.require: issueI5OWXY issueI5OXCD
613  */
614 HWTEST_F(AVFormatUnitTest, Format_GetValueType_001, TestSize.Level1)
615 {
616     MessageParcel parcel;
617     std::shared_ptr<Format> format = std::make_shared<Format>();
618     std::shared_ptr<Meta> meta = std::make_shared<Meta>();
619     const std::string floatKey = "FloatKey";
620     float floatValue = 1.0;
621 
622     meta->SetData(INT_TESTKEY, INT_VALUE);
623     meta->SetData(LONG_TESTKEY, LONG_VALUE);
624     meta->SetData(floatKey, floatValue);
625     meta->SetData(DOUBLE_TESTKEY, DOUBLE_VALUE);
626     meta->SetData(STRING_TESTKEY, STRING_VALUE);
627     meta->SetData(BUFFER_TESTKEY, BUFFER_VALUE);
628     meta->SetData(INT_ENUM_TESTKEY, Plugins::VideoRotation::VIDEO_ROTATION_90);
629     meta->SetData(LONG_ENUM_TESTKEY, Plugins::AudioChannelLayout::STEREO);
630 
631     format->SetMeta(std::move(meta));
632     CheckValueType(format);
633 }
634 
635 /**
636  * @tc.name: Format_GetValueType_002
637  * @tc.desc:
638  *     1. set values to meta;
639  *     2. meta trans by parcel;
640  *     3. get format value type;
641  * @tc.type: FUNC
642  * @tc.require: issueI5OWXY issueI5OXCD
643  */
644 HWTEST_F(AVFormatUnitTest, Format_GetValueType_002, TestSize.Level1)
645 {
646     MessageParcel parcel;
647     std::shared_ptr<Format> format = std::make_shared<Format>();
648     std::shared_ptr<Meta> meta = std::make_shared<Meta>();
649     const std::string floatKey = "FloatKey";
650     float floatValue = 1.0;
651 
652     meta->SetData(INT_TESTKEY, INT_VALUE);
653     meta->SetData(LONG_TESTKEY, LONG_VALUE);
654     meta->SetData(floatKey, floatValue);
655     meta->SetData(DOUBLE_TESTKEY, DOUBLE_VALUE);
656     meta->SetData(STRING_TESTKEY, STRING_VALUE);
657     meta->SetData(BUFFER_TESTKEY, BUFFER_VALUE);
658     meta->SetData(INT_ENUM_TESTKEY, Plugins::VideoRotation::VIDEO_ROTATION_90);
659     meta->SetData(LONG_ENUM_TESTKEY, Plugins::AudioChannelLayout::STEREO);
660 
661     format->SetMeta(meta);
662     meta = format->GetMeta();
663     ASSERT_TRUE(meta->ToParcel(parcel));
664     ASSERT_TRUE(meta->FromParcel(parcel));
665 
666     format = std::make_shared<Format>();
667     format->SetMeta(std::move(meta));
668     CheckValueType(format);
669 }
670 #endif
671 } // namespace Media
672 } // namespace OHOS