1 /*
2 * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "avmeta_data.h"
19 #include "avsession_log.h"
20 #include "avsession_manager.h"
21 #include "av_session.h"
22 #include "avsession_errors.h"
23 #include "avsession_pixel_map_adapter.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::Media;
27
28 namespace OHOS {
29 namespace AVSession {
30 namespace {
31 constexpr int64_t DURATION = 40000;
32 constexpr int64_t DURATION_PLAYBACK_SCENE_LIVE = -1;
33 constexpr int64_t DURATION_PLAYBACK_SCENE_INVALID = -2;
34 constexpr double PUBLISHDATE = 886291200000;
35 constexpr double PUBLISHDATE_INVALID_DATE = -1;
36 }
37
38 static AVMetaData g_metaDataCloneTest;
39 static AVMetaData g_metaData;
40 static OHOS::Parcel g_parcel;
41
42 class AVMetaDataTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp() override;
47 void TearDown() override;
48 std::shared_ptr<OHOS::Media::PixelMap> CreatePixelMap();
49 };
50
SetUpTestCase()51 void AVMetaDataTest::SetUpTestCase()
52 {
53 }
54
TearDownTestCase()55 void AVMetaDataTest::TearDownTestCase()
56 {
57 }
58
SetUp()59 void AVMetaDataTest::SetUp()
60 {
61 g_metaData.Reset();
62 g_metaData.SetAssetId("123");
63 g_metaData.SetTitle("Black Humor");
64 g_metaData.SetArtist("zhoujielun");
65 g_metaData.SetAuthor("zhoujielun");
66 g_metaData.SetAlbum("Jay");
67 g_metaData.SetWriter("zhoujielun");
68 g_metaData.SetComposer("zhoujielun");
69 g_metaData.SetDuration(DURATION);
70 g_metaData.SetMediaImage(AVSessionPixelMapAdapter::ConvertToInner(CreatePixelMap()));
71 g_metaData.SetMediaImageUri("xxxxx");
72 g_metaData.SetPublishDate(PUBLISHDATE);
73 g_metaData.SetSubTitle("fac");
74 g_metaData.SetDescription("for friends");
75 g_metaData.SetLyric("xxxxx");
76 }
77
TearDown()78 void AVMetaDataTest::TearDown()
79 {
80 }
81
CreatePixelMap()82 std::shared_ptr<OHOS::Media::PixelMap> AVMetaDataTest::CreatePixelMap()
83 {
84 int32_t pixelMapWidth = 4;
85 int32_t pixelMapHeight = 3;
86 const std::shared_ptr<OHOS::Media::PixelMap>& pixelMap = std::make_shared<OHOS::Media::PixelMap>();
87 ImageInfo info;
88 info.size.width = pixelMapWidth;
89 info.size.height = pixelMapHeight;
90 info.pixelFormat = PixelFormat::RGB_888;
91 info.colorSpace = ColorSpace::SRGB;
92 pixelMap->SetImageInfo(info);
93 int32_t rowDataSize = pixelMapWidth;
94 uint32_t bufferSize = rowDataSize * pixelMapHeight;
95 if (bufferSize <= 0) {
96 return pixelMap;
97 }
98
99 std::vector<std::uint8_t> buffer(bufferSize, 0x03);
100 pixelMap->SetPixelsAddr(buffer.data(), nullptr, bufferSize, AllocatorType::CUSTOM_ALLOC, nullptr);
101
102 return pixelMap;
103 }
104
105 /**
106 * @tc.name: SetAVMetaData001
107 * @tc.desc: set av meta data
108 * @tc.type: FUNC
109 * @tc.require: AR000H31JO
110 */
111 HWTEST_F(AVMetaDataTest, SetAVMetaData001, TestSize.Level0)
112 {
113 SLOGI("SetAVMetaData001 Begin");
114 AVMetaData metaData;
115 metaData.Reset();
116 metaData.SetAssetId("123");
117 metaData.SetTitle("Black Humor");
118 metaData.SetArtist("zhoujielun");
119 metaData.SetAuthor("zhoujielun");
120 metaData.SetAlbum("Jay");
121 metaData.SetWriter("zhoujielun");
122 metaData.SetComposer("zhoujielun");
123 metaData.SetDuration(DURATION);
124 metaData.SetMediaImage(AVSessionPixelMapAdapter::ConvertToInner(CreatePixelMap()));
125 metaData.SetMediaImageUri("xxxxx");
126 metaData.SetPublishDate(PUBLISHDATE);
127 metaData.SetSubTitle("fac");
128 metaData.SetDescription("for friends");
129 metaData.SetLyric("xxxxx");
130
131 EXPECT_EQ("123", metaData.GetAssetId());
132 EXPECT_EQ("Black Humor", metaData.GetTitle());
133 EXPECT_EQ("zhoujielun", metaData.GetArtist());
134 EXPECT_EQ("zhoujielun", metaData.GetAuthor());
135 EXPECT_EQ("Jay", metaData.GetAlbum());
136 EXPECT_EQ("zhoujielun", metaData.GetWriter());
137 EXPECT_EQ("zhoujielun", metaData.GetComposer());
138 EXPECT_EQ("xxxxx", metaData.GetMediaImageUri());
139
140 EXPECT_EQ(DURATION, metaData.GetDuration());
141 EXPECT_EQ(PUBLISHDATE, metaData.GetPublishDate());
142
143 EXPECT_NE(nullptr, metaData.GetMediaImage());
144
145 EXPECT_EQ("fac", metaData.GetSubTitle());
146 EXPECT_EQ("for friends", metaData.GetDescription());
147 EXPECT_EQ("xxxxx", metaData.GetLyric());
148
149 SLOGI("SetAVMetaData001 End");
150 }
151
152 /**
153 * @tc.name: SetAVMetaData002
154 * @tc.desc: set av meta data boundary duration
155 * @tc.type: FUNC
156 * @tc.require: AR000H31JO
157 */
158 HWTEST_F(AVMetaDataTest, SetAVMetaData002, TestSize.Level0)
159 {
160 SLOGI("SetAVMetaData002 Begin");
161 AVMetaData metaData;
162 metaData.Reset();
163 metaData.SetAssetId("123");
164 metaData.SetDuration(DURATION_PLAYBACK_SCENE_LIVE);
165 EXPECT_EQ(DURATION_PLAYBACK_SCENE_LIVE, metaData.GetDuration());
166 SLOGI("SetAVMetaData002 End");
167 }
168
169 /**
170 * @tc.name: SetAVMetaData003
171 * @tc.desc: set av meta data error duration
172 * @tc.type: FUNC
173 * @tc.require: AR000H31JO
174 */
175 HWTEST_F(AVMetaDataTest, SetAVMetaData003, TestSize.Level0)
176 {
177 SLOGI("SetAVMetaData003 Begin");
178 AVMetaData metaData;
179 metaData.Reset();
180 metaData.SetAssetId("123");
181 metaData.SetDuration(DURATION_PLAYBACK_SCENE_INVALID);
182 EXPECT_EQ(DURATION_PLAYBACK_SCENE_INVALID, metaData.GetDuration());
183 SLOGI("SetAVMetaData003 End");
184 }
185
186 /**
187 * @tc.name: SetAVMetaData004
188 * @tc.desc: set av meta data error publish date
189 * @tc.type: FUNC
190 * @tc.require: AR000H31JO
191 */
192 HWTEST_F(AVMetaDataTest, SetAVMetaData004, TestSize.Level0)
193 {
194 SLOGI("SetAVMetaData004 Begin");
195 AVMetaData metaData;
196 metaData.Reset();
197 metaData.SetAssetId("123");
198 metaData.SetPublishDate(PUBLISHDATE_INVALID_DATE);
199 EXPECT_EQ(PUBLISHDATE_INVALID_DATE, metaData.GetPublishDate());
200 SLOGI("SetAVMetaData004 End");
201 }
202 /**
203 * @tc.name: GetAVMetaData001
204 * @tc.desc: get av meta data result
205 * @tc.type: FUNC
206 * @tc.require: AR000H31JO
207 */
208 HWTEST_F(AVMetaDataTest, GetAVMetaData001, TestSize.Level0)
209 {
210 SLOGI("GetAVMetaData001 Begin");
211 AVMetaData metaData;
212 metaData.Reset();
213 metaData.CopyFrom(g_metaData);
214 EXPECT_EQ(metaData.GetAssetId(), g_metaData.GetAssetId());
215 std::string title1 = metaData.GetTitle();
216 SLOGI("title1 %{public}s", title1.c_str());
217 std::string title2 = g_metaData.GetTitle();
218 SLOGI("title2 %{public}s", title2.c_str());
219 EXPECT_EQ(title1, title2);
220 EXPECT_EQ(metaData.GetTitle(), g_metaData.GetTitle());
221 EXPECT_EQ(metaData.GetArtist(), g_metaData.GetArtist());
222 EXPECT_EQ(metaData.GetAuthor(), g_metaData.GetAuthor());
223 EXPECT_EQ(metaData.GetAlbum(), g_metaData.GetAlbum());
224 EXPECT_EQ(metaData.GetWriter(), g_metaData.GetWriter());
225 EXPECT_EQ(metaData.GetComposer(), g_metaData.GetComposer());
226 EXPECT_EQ(metaData.GetDuration(), g_metaData.GetDuration());
227 EXPECT_EQ(metaData.GetMediaImage(), g_metaData.GetMediaImage());
228 EXPECT_EQ(metaData.GetMediaImageUri(), g_metaData.GetMediaImageUri());
229 EXPECT_EQ(metaData.GetPublishDate(), g_metaData.GetPublishDate());
230 EXPECT_EQ(metaData.GetSubTitle(), g_metaData.GetSubTitle());
231 EXPECT_EQ(metaData.GetDescription(), g_metaData.GetDescription());
232 EXPECT_EQ(metaData.GetLyric(), g_metaData.GetLyric());
233 SLOGI("GetAVMetaData001 End");
234 }
235
236 /**
237 * @tc.name: AVMetaDataMarshalling001
238 * @tc.desc: metadata marshalling test
239 * @tc.type: FUNC
240 * @tc.require:AR000H31JO
241 */
242 HWTEST_F(AVMetaDataTest, AVMetaDataMarshalling001, TestSize.Level0)
243 {
244 SLOGI("AVMetaDataMarshalling001 Begin");
245 OHOS::Parcel& parcel = g_parcel;
246 auto ret = g_metaData.Marshalling(parcel);
247 EXPECT_EQ(ret, false);
248 SLOGI("AVMetaDataMarshalling001 End");
249 }
250
251 /**
252 * @tc.name: AVMetaDataMarshalling002
253 * @tc.desc: metadata marshalling test
254 * @tc.type: FUNC
255 * @tc.require:AR000H31JO
256 */
257 HWTEST_F(AVMetaDataTest, AVMetaDataMarshalling002, TestSize.Level0)
258 {
259 SLOGI("AVMetaDataMarshalling002 Begin");
260 OHOS::Parcel& parcel = g_parcel;
261 g_metaData.SetAVQueueImage(nullptr);
262 auto ret = g_metaData.Marshalling(parcel);
263 EXPECT_EQ(ret, false);
264 OHOS::MessageParcel& m_parcel = static_cast<MessageParcel&>(g_parcel);
265 g_metaData.WriteDrmSchemes(m_parcel);
266 g_metaData.ReadDrmSchemes(m_parcel);
267 SLOGI("AVMetaDataMarshalling002 End");
268 }
269
270 /**
271 * @tc.name: AVMetaDataMarshalling003
272 * @tc.desc: metadata marshalling test
273 * @tc.type: FUNC
274 * @tc.require:AR000H31JO
275 */
276 HWTEST_F(AVMetaDataTest, AVMetaDataMarshalling003, TestSize.Level0)
277 {
278 SLOGI("AVMetaDataMarshalling003 Begin");
279 OHOS::Parcel& parcel = g_parcel;
280 auto pixelMap = std::make_shared<AVSessionPixelMap>();
281 g_metaData.SetAVQueueImage(pixelMap);
282 auto ret = g_metaData.Marshalling(parcel);
283 EXPECT_EQ(ret, false);
284 OHOS::MessageParcel& m_parcel = static_cast<MessageParcel&>(g_parcel);
285 g_metaData.WriteDrmSchemes(m_parcel);
286 g_metaData.ReadDrmSchemes(m_parcel);
287 SLOGI("AVMetaDataMarshalling002 End");
288 }
289
290 /**
291 * @tc.name: AVMetaDataMarshalling004
292 * @tc.desc: metadata marshalling test
293 * @tc.type: FUNC
294 * @tc.require:AR000H31JO
295 */
296 HWTEST_F(AVMetaDataTest, AVMetaDataMarshalling004, TestSize.Level0)
297 {
298 SLOGI("AVMetaDataMarshalling004 Begin");
299 OHOS::Parcel& parcel = g_parcel;
300 auto pixelMap = std::make_shared<AVSessionPixelMap>();
301 std::vector<uint8_t> vec = {0, 1, 0, 1};
302 pixelMap->SetInnerImgBuffer(vec);
303 g_metaData.SetMediaImage(pixelMap);
304 g_metaData.SetAVQueueImage(pixelMap);
305 auto ret = g_metaData.Marshalling(parcel);
306 EXPECT_EQ(ret, false);
307 SLOGI("AVMetaDataMarshalling004 End");
308 }
309
310 /**
311 * @tc.name: AVMetaDataMarshalling005
312 * @tc.desc: metadata marshalling test
313 * @tc.type: FUNC
314 * @tc.require:AR000H31JO
315 */
316 HWTEST_F(AVMetaDataTest, AVMetaDataMarshalling005, TestSize.Level0)
317 {
318 SLOGI("AVMetaDataMarshalling005 Begin");
319 OHOS::Parcel& parcel = g_parcel;
320 auto pixelMap = std::make_shared<AVSessionPixelMap>();
321 std::vector<uint8_t> vec = {0, 1, 0, 1};
322 pixelMap->SetInnerImgBuffer(vec);
323 g_metaData.SetMediaImage(pixelMap);
324 g_metaData.SetAVQueueImage(nullptr);
325 auto ret = g_metaData.Marshalling(parcel);
326 EXPECT_EQ(ret, false);
327 SLOGI("AVMetaDataMarshalling005 End");
328 }
329
330 /**
331 * @tc.name: AVMetaDataMarshalling006
332 * @tc.desc: metadata marshalling test
333 * @tc.type: FUNC
334 * @tc.require:AR000H31JO
335 */
336 HWTEST_F(AVMetaDataTest, AVMetaDataMarshalling006, TestSize.Level0)
337 {
338 SLOGI("AVMetaDataMarshalling006 Begin");
339 OHOS::Parcel& parcel = g_parcel;
340 auto pixelMap = std::make_shared<AVSessionPixelMap>();
341 std::vector<uint8_t> vec = {0, 1, 0, 1};
342 pixelMap->SetInnerImgBuffer(vec);
343 g_metaData.SetMediaImage(nullptr);
344 g_metaData.SetAVQueueImage(pixelMap);
345 auto ret = g_metaData.Marshalling(parcel);
346 EXPECT_EQ(ret, false);
347 SLOGI("AVMetaDataMarshalling006 End");
348 }
349
350 /**
351 * @tc.name: AVMetaDataUnmarshalling001
352 * @tc.desc: metadata unmarshalling test
353 * @tc.type: FUNC
354 * @tc.require:AR000H31JO
355 */
356 HWTEST_F(AVMetaDataTest, AVMetaDataUnmarshalling001, TestSize.Level0)
357 {
358 SLOGI("AVMetaDataUnmarshalling001 Begin");
359 OHOS::Parcel& parcel = g_parcel;
360 auto unmarshallingPtr = g_metaData.Unmarshalling(parcel);
361 EXPECT_NE(unmarshallingPtr, nullptr);
362 SLOGI("AVMetaDataUnmarshalling001 End");
363 }
364
365 /**
366 * @tc.name: AVMetaDataReadFromParcel001
367 * @tc.desc: metadata ReadFromParcel test
368 * @tc.type: FUNC
369 * @tc.require:AR000H31JO
370 */
371 HWTEST_F(AVMetaDataTest, AVMetaDataReadFromParcel001, TestSize.Level0)
372 {
373 SLOGI("AVMetaDataReadFromParcel001 Begin");
374 OHOS::MessageParcel& parcel = static_cast<MessageParcel&>(g_parcel);
375 int32_t twoImageLength = 10;
376 g_metaData.SetMediaLength(5);
377 bool ret = g_metaData.ReadFromParcel(parcel, twoImageLength);
378 EXPECT_EQ(ret, false);
379 SLOGI("AVMetaDataReadFromParcel001 End");
380 }
381
382 /**
383 * @tc.name: AVMetaDataReadFromParcel002
384 * @tc.desc: metadata ReadFromParcel test
385 * @tc.type: FUNC
386 * @tc.require:AR000H31JO
387 */
388 HWTEST_F(AVMetaDataTest, AVMetaDataReadFromParcel002, TestSize.Level0)
389 {
390 SLOGI("AVMetaDataReadFromParcel002 Begin");
391 OHOS::MessageParcel& parcel = static_cast<MessageParcel&>(g_parcel);
392 int32_t twoImageLength = 10;
393 g_metaData.SetMediaLength(10);
394 bool ret = g_metaData.ReadFromParcel(parcel, twoImageLength);
395 EXPECT_EQ(ret, false);
396 SLOGI("AVMetaDataReadFromParcel002 End");
397 }
398
399 /**
400 * @tc.name: AVMetaDataGetMask001
401 * @tc.desc: get meta mask
402 * @tc.type: FUNC
403 * @tc.require:AR000H31JO
404 */
405 HWTEST_F(AVMetaDataTest, AVMetaDataGetMask001, TestSize.Level0)
406 {
407 SLOGI("AVMetaDataGetMask001 Begin");
408 AVMetaData metaData;
409 metaData.Reset();
410 metaData.SetAssetId("123");
411 EXPECT_NE(metaData.GetMetaMask().to_string(), "");
412 SLOGI("AVMetaDataGetMask001 End");
413 }
414
415 /**
416 * @tc.name: AVMetaDataCopyDataFrom001
417 * @tc.desc: copy meta item from @metaIn according to set bit of @metaIn meta mask
418 * @tc.type: FUNC
419 * @tc.require:AR000H31JO
420 */
421 HWTEST_F(AVMetaDataTest, AVMetaDataCopyDataFromMetaIn001, TestSize.Level0)
422 {
423 SLOGI("AVMetaDataCopyDataFromMetaIn001 Begin");
424 AVMetaData metaData;
425 g_metaDataCloneTest.SetAssetId("1118");
426 g_metaDataCloneTest.SetWriter("Jay Chou");
427 g_metaDataCloneTest.SetDuration(DURATION);
428 auto ret = metaData.CopyFrom(g_metaDataCloneTest);
429
430 EXPECT_EQ(ret, true);
431 EXPECT_EQ(metaData.GetAssetId(), g_metaDataCloneTest.GetAssetId());
432 EXPECT_EQ(metaData.GetWriter(), g_metaDataCloneTest.GetWriter());
433 EXPECT_EQ(metaData.GetDuration(), g_metaDataCloneTest.GetDuration());
434 SLOGI("AVMetaDataCopyDataFromMetaIn001 End");
435 }
436
437 /**
438 * @tc.name: AVMetaDataCopyDataByMask001
439 * @tc.desc: copy meta item to @metaOut according to intersection of meta mask.
440 * @tc.type: FUNC
441 * @tc.require:AR000H31JO
442 */
443 HWTEST_F(AVMetaDataTest, AVMetaDataCopyDataByMask001, TestSize.Level0)
444 {
445 SLOGI("AVMetaDataCopyDataByMask001 Begin");
446 AVMetaData metaOut;
447 metaOut.SetAssetId("a");
448 metaOut.SetWriter("b");
449 metaOut.SetDuration(0);
450 AVMetaData::MetaMaskType mask = metaOut.GetMetaMask();
451
452 auto ret = g_metaDataCloneTest.CopyToByMask(mask, metaOut);
453 EXPECT_EQ(ret, true);
454
455 EXPECT_EQ(metaOut.GetAssetId(), g_metaDataCloneTest.GetAssetId());
456 EXPECT_EQ(metaOut.GetWriter(), g_metaDataCloneTest.GetWriter());
457 EXPECT_EQ(metaOut.GetDuration(), g_metaDataCloneTest.GetDuration());
458 SLOGI("AVMetaDataCopyDataByMask001 End");
459 }
460
461 /**
462 * @tc.name: SetPreviousAssetId001
463 * @tc.desc: set previous asset id.
464 * @tc.type: FUNC
465 * @tc.require: I5YMXD
466 */
467 HWTEST_F(AVMetaDataTest, SetPreviousAssetId001, TestSize.Level0)
468 {
469 SLOGI("SetPreviousAssetId001 Begin");
470 AVMetaData metaOut;
471 metaOut.SetPreviousAssetId("123");
472
473 EXPECT_EQ("123", metaOut.GetPreviousAssetId());
474 SLOGI("SetPreviousAssetId001 End");
475 }
476
477 /**
478 * @tc.name: SetNextAssetId001
479 * @tc.desc: set next asset id.
480 * @tc.type: FUNC
481 * @tc.require: I5YMXD
482 */
483 HWTEST_F(AVMetaDataTest, SetNextAssetId001, TestSize.Level0)
484 {
485 SLOGI("SetNextAssetId001 Begin");
486 AVMetaData metaOut;
487 metaOut.SetNextAssetId("123");
488
489 EXPECT_EQ("123", metaOut.GetNextAssetId());
490 SLOGI("SetNextAssetId001 End");
491 }
492
493 /**
494 * @tc.name: IsValid001
495 * @tc.desc: Return is avmetadata IsValid success
496 * @tc.type: FUNC
497 * @tc.require: I5YMXD
498 */
499 HWTEST_F(AVMetaDataTest, IsValid001, TestSize.Level0)
500 {
501 SLOGI("IsValid001 Begin");
502 AVMetaData metaOut;
503 metaOut.SetAssetId("a");
504 metaOut.SetWriter("b");
505 metaOut.SetDuration(0);
506 metaOut.SetPublishDate(0);
507
508 EXPECT_EQ(metaOut.IsValid(), true);
509 SLOGI("IsValid001 End");
510 }
511
512 /**
513 * @tc.name: IsValid002
514 * @tc.desc: Return is avmetadata IsValid failed
515 * @tc.type: FUNC
516 * @tc.require: I5YMXD
517 */
518 HWTEST_F(AVMetaDataTest, IsValid002, TestSize.Level0)
519 {
520 SLOGI("IsValid002 Begin");
521 AVMetaData metaOut;
522 metaOut.SetAssetId("a");
523 metaOut.SetWriter("b");
524 metaOut.SetDuration(-2);
525 metaOut.SetPublishDate(0);
526
527 EXPECT_EQ(metaOut.IsValid(), false);
528 SLOGI("IsValid002 End");
529 }
530
531 /**
532 * @tc.name: UnmarshallingExceptImg001
533 * @tc.desc: the size of string is zero
534 * @tc.type: FUNC
535 * @tc.require: NA
536 */
537 static HWTEST_F(AVMetaDataTest, UnmarshallingExceptImg001, TestSize.Level0)
538 {
539 MessageParcel data;
540 data.WriteString("");
541 AVMetaData metaOut;
542 bool ret = metaOut.UnmarshallingExceptImg(data);
543 EXPECT_EQ(ret, false);
544 }
545
546 /**
547 * @tc.name: UnmarshallingExceptImg002
548 * @tc.desc: the size of string bigger than META_KEY_MAX
549 * @tc.type: FUNC
550 * @tc.require: NA
551 */
552 static HWTEST_F(AVMetaDataTest, UnmarshallingExceptImg002, TestSize.Level0)
553 {
554 std::string test = std::string(30, '*');
555 MessageParcel data;
556 data.WriteString(test);
557 AVMetaData metaOut;
558 bool ret = metaOut.UnmarshallingExceptImg(data);
559 EXPECT_EQ(ret, false);
560 }
561
562 /**
563 * @tc.name: UnmarshallingExceptImg003
564 * @tc.desc: the size of string is valid but metaOut.metaMask_ is empty
565 * @tc.type: FUNC
566 * @tc.require: NA
567 */
568 static HWTEST_F(AVMetaDataTest, UnmarshallingExceptImg003, TestSize.Level0)
569 {
570 std::string test = "test1111";
571 MessageParcel data;
572 data.WriteString(test);
573 OHOS::sptr pixelMap = new AVSessionPixelMap();
574 std::vector<uint8_t> vec = {0, 1, 0, 1};
575 pixelMap->SetInnerImgBuffer(vec);
576 data.WriteParcelable(pixelMap);
577 AVMetaData metaOut;
578 bool ret = metaOut.UnmarshallingExceptImg(data);
579 EXPECT_EQ(ret, true);
580 }
581
582 /**
583 * @tc.name: UnmarshallingExceptImg004
584 * @tc.desc: the size of string is valid but metaOut.bundleIcon_ is nullptr
585 * @tc.type: FUNC
586 * @tc.require: NA
587 */
588 static HWTEST_F(AVMetaDataTest, UnmarshallingExceptImg004, TestSize.Level0)
589 {
590 std::string test = "test1111";
591 MessageParcel data;
592 data.WriteString(test);
593 AVMetaData metaOut;
594 std::string bitStr = std::string(26, '1');
595 std::bitset<26> bits(bitStr);
596 metaOut.metaMask_ = bits;
597 bool ret = metaOut.UnmarshallingExceptImg(data);
598 EXPECT_EQ(ret, false);
599 }
600
601 /**
602 * @tc.name: UnmarshallingExceptImg005
603 * @tc.desc: the size of string is valid and metaOut is valid
604 * @tc.type: FUNC
605 * @tc.require: NA
606 */
607 static HWTEST_F(AVMetaDataTest, UnmarshallingExceptImg005, TestSize.Level0)
608 {
609 std::string test = "test1111";
610 MessageParcel data;
611 data.WriteString(test);
612 OHOS::sptr pixelMap = new AVSessionPixelMap();
613 std::vector<uint8_t> vec = {0, 1, 0, 1};
614 pixelMap->SetInnerImgBuffer(vec);
615 data.WriteParcelable(pixelMap);
616 AVMetaData metaOut;
617 std::string bitStr = std::string(26, '1');
618 std::bitset<26> bits(bitStr);
619 metaOut.metaMask_ = bits;
620 bool ret = metaOut.UnmarshallingExceptImg(data);
621 EXPECT_TRUE(ret != false);
622 }
623 } // namespace AVSession
624 } // namespace OHOS