1 /*
2 * Copyright (c) 2022 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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
243 {
244 SLOGI("AVMetaDataMarshalling001 Begin");
245 OHOS::Parcel& parcel = g_parcel;
246 auto ret = g_metaData.Marshalling(parcel);
247 EXPECT_EQ(ret, true);
248 SLOGI("AVMetaDataMarshalling001 End");
249 }
250
251 /**
252 * @tc.name: AVMetaDataUnmarshalling001
253 * @tc.desc: metadata unmarshalling test
254 * @tc.type: FUNC
255 * @tc.require:AR000H31JO
256 */
257 HWTEST_F(AVMetaDataTest, AVMetaDataUnmarshalling001, TestSize.Level1)
258 {
259 SLOGI("AVMetaDataUnmarshalling001 Begin");
260 OHOS::Parcel& parcel = g_parcel;
261 auto unmarshallingPtr = g_metaData.Unmarshalling(parcel);
262 EXPECT_NE(unmarshallingPtr, nullptr);
263 SLOGI("AVMetaDataUnmarshalling001 End");
264 }
265
266 /**
267 * @tc.name: AVMetaDataGetMask001
268 * @tc.desc: get meta mask
269 * @tc.type: FUNC
270 * @tc.require:AR000H31JO
271 */
272 HWTEST_F(AVMetaDataTest, AVMetaDataGetMask001, TestSize.Level1)
273 {
274 SLOGI("AVMetaDataGetMask001 Begin");
275 AVMetaData metaData;
276 metaData.Reset();
277 metaData.SetAssetId("123");
278 EXPECT_NE(metaData.GetMetaMask().to_string(), "");
279 SLOGI("AVMetaDataGetMask001 End");
280 }
281
282 /**
283 * @tc.name: AVMetaDataCopyDataFrom001
284 * @tc.desc: copy meta item from @metaIn according to set bit of @metaIn meta mask
285 * @tc.type: FUNC
286 * @tc.require:AR000H31JO
287 */
288 HWTEST_F(AVMetaDataTest, AVMetaDataCopyDataFromMetaIn001, TestSize.Level1)
289 {
290 SLOGI("AVMetaDataCopyDataFromMetaIn001 Begin");
291 AVMetaData metaData;
292 g_metaDataCloneTest.SetAssetId("1118");
293 g_metaDataCloneTest.SetWriter("Jay Chou");
294 g_metaDataCloneTest.SetDuration(DURATION);
295 auto ret = metaData.CopyFrom(g_metaDataCloneTest);
296
297 EXPECT_EQ(ret, true);
298 EXPECT_EQ(metaData.GetAssetId(), g_metaDataCloneTest.GetAssetId());
299 EXPECT_EQ(metaData.GetWriter(), g_metaDataCloneTest.GetWriter());
300 EXPECT_EQ(metaData.GetDuration(), g_metaDataCloneTest.GetDuration());
301 SLOGI("AVMetaDataCopyDataFromMetaIn001 End");
302 }
303
304 /**
305 * @tc.name: AVMetaDataCopyDataByMask001
306 * @tc.desc: copy meta item to @metaOut according to intersection of meta mask.
307 * @tc.type: FUNC
308 * @tc.require:AR000H31JO
309 */
310 HWTEST_F(AVMetaDataTest, AVMetaDataCopyDataByMask001, TestSize.Level1)
311 {
312 SLOGI("AVMetaDataCopyDataByMask001 Begin");
313 AVMetaData metaOut;
314 metaOut.SetAssetId("a");
315 metaOut.SetWriter("b");
316 metaOut.SetDuration(0);
317 AVMetaData::MetaMaskType mask = metaOut.GetMetaMask();
318
319 auto ret = g_metaDataCloneTest.CopyToByMask(mask, metaOut);
320 EXPECT_EQ(ret, true);
321
322 EXPECT_EQ(metaOut.GetAssetId(), g_metaDataCloneTest.GetAssetId());
323 EXPECT_EQ(metaOut.GetWriter(), g_metaDataCloneTest.GetWriter());
324 EXPECT_EQ(metaOut.GetDuration(), g_metaDataCloneTest.GetDuration());
325 SLOGI("AVMetaDataCopyDataByMask001 End");
326 }
327
328 /**
329 * @tc.name: SetPreviousAssetId001
330 * @tc.desc: set previous asset id.
331 * @tc.type: FUNC
332 * @tc.require: I5YMXD
333 */
334 HWTEST_F(AVMetaDataTest, SetPreviousAssetId001, TestSize.Level1)
335 {
336 SLOGI("SetPreviousAssetId001 Begin");
337 AVMetaData metaOut;
338 metaOut.SetPreviousAssetId("123");
339
340 EXPECT_EQ("123", metaOut.GetPreviousAssetId());
341 SLOGI("SetPreviousAssetId001 End");
342 }
343
344 /**
345 * @tc.name: SetNextAssetId001
346 * @tc.desc: set next asset id.
347 * @tc.type: FUNC
348 * @tc.require: I5YMXD
349 */
350 HWTEST_F(AVMetaDataTest, SetNextAssetId001, TestSize.Level1)
351 {
352 SLOGI("SetNextAssetId001 Begin");
353 AVMetaData metaOut;
354 metaOut.SetNextAssetId("123");
355
356 EXPECT_EQ("123", metaOut.GetNextAssetId());
357 SLOGI("SetNextAssetId001 End");
358 }
359
360 /**
361 * @tc.name: IsValid001
362 * @tc.desc: Return is avmetadata IsValid success
363 * @tc.type: FUNC
364 * @tc.require: I5YMXD
365 */
366 HWTEST_F(AVMetaDataTest, IsValid001, TestSize.Level1)
367 {
368 SLOGI("IsValid001 Begin");
369 AVMetaData metaOut;
370 metaOut.SetAssetId("a");
371 metaOut.SetWriter("b");
372 metaOut.SetDuration(0);
373 metaOut.SetPublishDate(0);
374
375 EXPECT_EQ(metaOut.IsValid(), true);
376 SLOGI("IsValid001 End");
377 }
378
379 /**
380 * @tc.name: IsValid002
381 * @tc.desc: Return is avmetadata IsValid failed
382 * @tc.type: FUNC
383 * @tc.require: I5YMXD
384 */
385 HWTEST_F(AVMetaDataTest, IsValid002, TestSize.Level1)
386 {
387 SLOGI("IsValid002 Begin");
388 AVMetaData metaOut;
389 metaOut.SetAssetId("a");
390 metaOut.SetWriter("b");
391 metaOut.SetDuration(-2);
392 metaOut.SetPublishDate(0);
393
394 EXPECT_EQ(metaOut.IsValid(), false);
395 SLOGI("IsValid002 End");
396 }
397
398 /**
399 * @tc.name: UnmarshallingExceptImg001
400 * @tc.desc: the size of string is zero
401 * @tc.type: FUNC
402 * @tc.require: NA
403 */
404 static HWTEST_F(AVMetaDataTest, UnmarshallingExceptImg001, TestSize.Level1)
405 {
406 MessageParcel data;
407 data.WriteString("");
408 AVMetaData metaOut;
409 bool ret = AVMetaData::UnmarshallingExceptImg(data, metaOut);
410 EXPECT_EQ(ret, false);
411 }
412
413 /**
414 * @tc.name: UnmarshallingExceptImg002
415 * @tc.desc: the size of string bigger than META_KEY_MAX
416 * @tc.type: FUNC
417 * @tc.require: NA
418 */
419 static HWTEST_F(AVMetaDataTest, UnmarshallingExceptImg002, TestSize.Level1)
420 {
421 std::string test = std::string(30, '*');
422 MessageParcel data;
423 data.WriteString(test);
424 AVMetaData metaOut;
425 bool ret = AVMetaData::UnmarshallingExceptImg(data, metaOut);
426 EXPECT_EQ(ret, false);
427 }
428
429 /**
430 * @tc.name: UnmarshallingExceptImg003
431 * @tc.desc: the size of string is valid but metaOut.metaMask_ is empty
432 * @tc.type: FUNC
433 * @tc.require: NA
434 */
435 static HWTEST_F(AVMetaDataTest, UnmarshallingExceptImg003, TestSize.Level1)
436 {
437 std::string test = "test1111";
438 MessageParcel data;
439 data.WriteString(test);
440 OHOS::sptr pixelMap = new AVSessionPixelMap();
441 std::vector<uint8_t> vec = {0, 1, 0, 1};
442 pixelMap->SetInnerImgBuffer(vec);
443 data.WriteParcelable(pixelMap);
444 AVMetaData metaOut;
445 bool ret = AVMetaData::UnmarshallingExceptImg(data, metaOut);
446 EXPECT_EQ(ret, true);
447 }
448
449 /**
450 * @tc.name: UnmarshallingExceptImg004
451 * @tc.desc: the size of string is valid but metaOut.bundleIcon_ is nullptr
452 * @tc.type: FUNC
453 * @tc.require: NA
454 */
455 static HWTEST_F(AVMetaDataTest, UnmarshallingExceptImg004, TestSize.Level1)
456 {
457 std::string test = "test1111";
458 MessageParcel data;
459 data.WriteString(test);
460 AVMetaData metaOut;
461 std::string bitStr = std::string(26, '1');
462 std::bitset<26> bits(bitStr);
463 metaOut.metaMask_ = bits;
464 bool ret = AVMetaData::UnmarshallingExceptImg(data, metaOut);
465 EXPECT_EQ(ret, false);
466 }
467
468 /**
469 * @tc.name: UnmarshallingExceptImg005
470 * @tc.desc: the size of string is valid and metaOut is valid
471 * @tc.type: FUNC
472 * @tc.require: NA
473 */
474 static HWTEST_F(AVMetaDataTest, UnmarshallingExceptImg005, TestSize.Level1)
475 {
476 std::string test = "test1111";
477 MessageParcel data;
478 data.WriteString(test);
479 OHOS::sptr pixelMap = new AVSessionPixelMap();
480 std::vector<uint8_t> vec = {0, 1, 0, 1};
481 pixelMap->SetInnerImgBuffer(vec);
482 data.WriteParcelable(pixelMap);
483 AVMetaData metaOut;
484 std::string bitStr = std::string(26, '1');
485 std::bitset<26> bits(bitStr);
486 metaOut.metaMask_ = bits;
487 bool ret = AVMetaData::UnmarshallingExceptImg(data, metaOut);
488 EXPECT_TRUE(ret != false);
489 }
490
491 /**
492 * @tc.name: UnmarshallingCheckImageTask001
493 * @tc.desc: read PixelMap failed
494 * @tc.type: FUNC
495 * @tc.require: NA
496 */
497 static HWTEST_F(AVMetaDataTest, UnmarshallingCheckImageTask001, TestSize.Level1)
498 {
499 Parcel data;
500 auto result = std::make_shared<AVMetaData>();
501 std::string bitStr = std::string(26, '0');
502 std::bitset<26> bits(bitStr);
503 result->metaMask_ = bits;
504 bool ret = AVMetaData::UnmarshallingCheckImageTask(data, result.get());
505 EXPECT_TRUE(ret == true);
506 }
507
508 /**
509 * @tc.name: UnmarshallingCheckImageTask002
510 * @tc.desc: read PixelMap failed
511 * @tc.type: FUNC
512 * @tc.require: NA
513 */
514 static HWTEST_F(AVMetaDataTest, UnmarshallingCheckImageTask002, TestSize.Level1)
515 {
516 Parcel data;
517 auto result = std::make_shared<AVMetaData>();
518 std::string bitStr = std::string(26, '1');
519 std::bitset<26> bits(bitStr);
520 result->metaMask_ = bits;
521 bool ret = AVMetaData::UnmarshallingCheckImageTask(data, result.get());
522 EXPECT_TRUE(ret == false);
523 }
524
525 /**
526 * @tc.name: UnmarshallingCheckImageTask003
527 * @tc.desc: read avqueue PixelMap failed
528 * @tc.type: FUNC
529 * @tc.require: NA
530 */
531 static HWTEST_F(AVMetaDataTest, UnmarshallingCheckImageTask003, TestSize.Level1)
532 {
533 Parcel data;
534 OHOS::sptr pixelMap = new AVSessionPixelMap();
535 std::vector<uint8_t> vec = {0, 1, 0, 1};
536 pixelMap->SetInnerImgBuffer(vec);
537 data.WriteParcelable(pixelMap);
538 auto result = std::make_shared<AVMetaData>();
539 std::string bitStr = std::string(26, '1');
540 bitStr[6] = '0';
541 std::bitset<26> bits(bitStr);
542 result->metaMask_ = bits;
543 bool ret = AVMetaData::UnmarshallingCheckImageTask(data, result.get());
544 EXPECT_TRUE(ret == false);
545 }
546
547 /**
548 * @tc.name: UnmarshallingCheckImageTask004
549 * @tc.desc: read avqueue PixelMap failed
550 * @tc.type: FUNC
551 * @tc.require: NA
552 */
553 static HWTEST_F(AVMetaDataTest, UnmarshallingCheckImageTask004, TestSize.Level1)
554 {
555 Parcel data;
556 OHOS::sptr pixelMap = new AVSessionPixelMap();
557 std::vector<uint8_t> vec = {0, 1, 0, 1};
558 pixelMap->SetInnerImgBuffer(vec);
559 data.WriteParcelable(pixelMap);
560 auto result = std::make_shared<AVMetaData>();
561 std::string bitStr = std::string(26, '1');
562 std::bitset<26> bits(bitStr);
563 result->metaMask_ = bits;
564 bool ret = AVMetaData::UnmarshallingCheckImageTask(data, result.get());
565 EXPECT_TRUE(ret == false);
566 }
567
568 /**
569 * @tc.name: UnmarshallingCheckImageTask005
570 * @tc.desc: read bundle icon failed
571 * @tc.type: FUNC
572 * @tc.require: NA
573 */
574 static HWTEST_F(AVMetaDataTest, UnmarshallingCheckImageTask005, TestSize.Level1)
575 {
576 Parcel data;
577 OHOS::sptr pixelMap = new AVSessionPixelMap();
578 OHOS::sptr pixelMap2 = new AVSessionPixelMap();
579 data.WriteParcelable(pixelMap);
580 data.WriteParcelable(pixelMap2);
581 auto result = std::make_shared<AVMetaData>();
582 std::string bitStr = std::string(26, '1');
583 bitStr[24] = '0';
584 std::bitset<26> bits(bitStr);
585 result->metaMask_ = bits;
586 bool ret = AVMetaData::UnmarshallingCheckImageTask(data, result.get());
587 EXPECT_TRUE(ret == false);
588 }
589
590 /**
591 * @tc.name: UnmarshallingCheckImageTask006
592 * @tc.desc: success to read data
593 * @tc.type: FUNC
594 * @tc.require: NA
595 */
596 static HWTEST_F(AVMetaDataTest, UnmarshallingCheckImageTask006, TestSize.Level1)
597 {
598 Parcel data;
599 OHOS::sptr pixelMap = new AVSessionPixelMap();
600 OHOS::sptr pixelMap2 = new AVSessionPixelMap();
601 OHOS::sptr pixelMap3 = new AVSessionPixelMap();
602 data.WriteParcelable(pixelMap);
603 data.WriteParcelable(pixelMap2);
604 data.WriteParcelable(pixelMap3);
605 auto result = std::make_shared<AVMetaData>();
606 std::string bitStr = std::string(26, '1');
607 bitStr[24] = '0';
608 std::bitset<26> bits(bitStr);
609 result->metaMask_ = bits;
610 bool ret = AVMetaData::UnmarshallingCheckImageTask(data, result.get());
611 EXPECT_TRUE(ret == true);
612 }
613
614 /**
615 * @tc.name: UnmarshallingCheckParamTask001
616 * @tc.desc: success to read data
617 * @tc.type: FUNC
618 * @tc.require: NA
619 */
620 static HWTEST_F(AVMetaDataTest, UnmarshallingCheckParamTask001, TestSize.Level1)
621 {
622 Parcel data;
623 auto result = std::make_shared<AVMetaData>();
624 bool ret = AVMetaData::UnmarshallingCheckImageTask(data, result.get());
625 EXPECT_TRUE(ret == true);
626 }
627
628 } // namespace AVSession
629 } // namespace OHOS