1 /*
2 * Copyright (C) 2021 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 "media_errors.h"
18 #include "pixel_map.h"
19 #include "color_space.h"
20
21 using namespace testing::ext;
22 using namespace OHOS::Media;
23
24 namespace OHOS {
25 namespace Multimedia {
26 static constexpr int32_t PIXEL_MAP_TEST_WIDTH = 3;
27 static constexpr int32_t PIXEL_MAP_TEST_HEIGHT = 3;
28 static constexpr int32_t PIXEL_MAP_RGB565_BYTE = 2;
29 static constexpr int32_t PIXEL_MAP_RGB888_BYTE = 3;
30 static constexpr int32_t PIXEL_MAP_ARGB8888_BYTE = 4;
31 constexpr int32_t PIXEL_MAP_BIG_TEST_WIDTH = 4 * 1024;
32 constexpr int32_t PIXEL_MAP_BIG_TEST_HEIGHT = 3 * 100;
33
34 class ImagePixelMapTest : public testing::Test {
35 public:
ImagePixelMapTest()36 ImagePixelMapTest() {}
~ImagePixelMapTest()37 ~ImagePixelMapTest() {}
38 };
39
ConstructPixmap()40 std::unique_ptr<PixelMap> ConstructPixmap()
41 {
42 int32_t pixelMapWidth = 4;
43 int32_t pixelMapHeight = 3;
44 int32_t bytesPerPixel = 3;
45 std::unique_ptr<PixelMap> pixelMap = std::make_unique<PixelMap>();
46 ImageInfo info;
47 info.size.width = pixelMapWidth;
48 info.size.height = pixelMapHeight;
49 info.pixelFormat = PixelFormat::RGB_888;
50 info.colorSpace = ColorSpace::SRGB;
51 pixelMap->SetImageInfo(info);
52
53 int32_t rowDataSize = pixelMapWidth * bytesPerPixel;
54 uint32_t bufferSize = rowDataSize * pixelMapHeight;
55 if (bufferSize <= 0) {
56 return nullptr;
57 }
58 void *buffer = malloc(bufferSize);
59 if (buffer == nullptr) {
60 return nullptr;
61 }
62 char *ch = static_cast<char *>(buffer);
63 for (unsigned int i = 0; i < bufferSize; i++) {
64 *(ch++) = (char)i;
65 }
66
67 pixelMap->SetPixelsAddr(buffer, nullptr, bufferSize, AllocatorType::HEAP_ALLOC, nullptr);
68 return pixelMap;
69 }
70
ConstructBigPixmap()71 std::unique_ptr<PixelMap> ConstructBigPixmap()
72 {
73 int32_t pixelMapWidth = PIXEL_MAP_BIG_TEST_WIDTH;
74 int32_t pixelMapHeight = PIXEL_MAP_BIG_TEST_HEIGHT;
75 std::unique_ptr<PixelMap> pixelMap = std::make_unique<PixelMap>();
76 ImageInfo info;
77 info.size.width = pixelMapWidth;
78 info.size.height = pixelMapHeight;
79 info.pixelFormat = PixelFormat::RGB_888;
80 info.colorSpace = ColorSpace::SRGB;
81 pixelMap->SetImageInfo(info);
82
83 int32_t bufferSize = pixelMap->GetByteCount();
84 if (bufferSize <= 0) {
85 return nullptr;
86 }
87 void *buffer = malloc(bufferSize);
88 if (buffer == nullptr) {
89 return nullptr;
90 }
91 char *ch = reinterpret_cast<char *>(buffer);
92 for (int32_t i = 0; i < bufferSize; i++) {
93 *(ch++) = 'a';
94 }
95
96 pixelMap->SetPixelsAddr(buffer, nullptr, bufferSize, AllocatorType::HEAP_ALLOC, nullptr);
97 return pixelMap;
98 }
99 /**
100 * @tc.name: ImagePixelMap001
101 * @tc.desc: ALPHA_8 pixel format pixel map operation
102 * @tc.type: FUNC
103 */
104 HWTEST_F(ImagePixelMapTest, ImagePixelMap001, TestSize.Level3)
105 {
106 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap001 start";
107 /**
108 * @tc.steps: step1. Set image info and alloc pixel map memory.
109 * @tc.expected: step1. The pixel map info is correct.
110 */
111 PixelMap pixelMap;
112 ImageInfo info;
113 info.size.width = PIXEL_MAP_TEST_WIDTH;
114 info.size.height = PIXEL_MAP_TEST_HEIGHT;
115 info.pixelFormat = PixelFormat::ALPHA_8;
116 info.colorSpace = ColorSpace::SRGB;
117 pixelMap.SetImageInfo(info);
118 int32_t rowDataSize = (PIXEL_MAP_TEST_WIDTH + 3) / 4 * 4;
119 uint32_t bufferSize = rowDataSize * PIXEL_MAP_TEST_HEIGHT;
120 void *buffer = malloc(bufferSize);
121 EXPECT_NE(buffer, nullptr);
122 pixelMap.SetPixelsAddr(buffer, nullptr, bufferSize, AllocatorType::HEAP_ALLOC, nullptr);
123 uint8_t *data = const_cast<uint8_t *>(pixelMap.GetPixels());
124 EXPECT_NE(data, nullptr);
125 EXPECT_EQ(pixelMap.GetHeight(), PIXEL_MAP_TEST_HEIGHT);
126 EXPECT_EQ(pixelMap.GetWidth(), PIXEL_MAP_TEST_WIDTH);
127 EXPECT_EQ(pixelMap.GetPixelFormat(), PixelFormat::ALPHA_8);
128 EXPECT_EQ(pixelMap.GetColorSpace(), ColorSpace::SRGB);
129 EXPECT_EQ(pixelMap.GetPixelBytes(), 1);
130 EXPECT_EQ(pixelMap.GetRowBytes(), rowDataSize);
131 EXPECT_EQ(pixelMap.GetByteCount(), PIXEL_MAP_TEST_HEIGHT * rowDataSize);
132 /**
133 * @tc.steps: step2. Get image info.
134 * @tc.expected: step2. The pixel map info is correct
135 */
136 ImageInfo outInfo;
137 pixelMap.GetImageInfo(outInfo);
138 EXPECT_EQ(outInfo.size.width, info.size.width);
139 EXPECT_EQ(outInfo.size.height, info.size.height);
140 EXPECT_EQ(outInfo.pixelFormat, info.pixelFormat);
141 EXPECT_EQ(outInfo.colorSpace, info.colorSpace);
142 /**
143 * @tc.steps: step3. Set image color data and get image color value.
144 * @tc.expected: step3. The image color value is correct
145 */
146 for (int32_t i = 0; i < rowDataSize * PIXEL_MAP_TEST_HEIGHT; i++) {
147 data[i] = i;
148 }
149 uint32_t color = 0;
150 EXPECT_NE(pixelMap.GetPixel8(1, 1), nullptr);
151 EXPECT_EQ(*pixelMap.GetPixel8(1, 1), 0x05);
152 EXPECT_EQ(pixelMap.GetARGB32Color(1, 1, color), true);
153 EXPECT_EQ(pixelMap.GetARGB32ColorA(color), 5);
154 EXPECT_EQ(pixelMap.GetARGB32ColorR(color), 0);
155 EXPECT_EQ(pixelMap.GetARGB32ColorG(color), 0);
156 EXPECT_EQ(pixelMap.GetARGB32ColorB(color), 0);
157 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap001 end";
158 }
159
160 /**
161 * @tc.name: ImagePixelMap002
162 * @tc.desc: RGB_565 pixel format pixel map operation
163 * @tc.type: FUNC
164 */
165 HWTEST_F(ImagePixelMapTest, ImagePixelMap002, TestSize.Level3)
166 {
167 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap002 start";
168 /**
169 * @tc.steps: step1. Set image info and alloc pixel map memory.
170 * @tc.expected: step1. The pixel map info is correct.
171 */
172 PixelMap pixelMap;
173 int8_t bytesPerPixel = 2;
174 int8_t rowDataSize = PIXEL_MAP_TEST_WIDTH * bytesPerPixel;
175 ImageInfo info;
176 info.size.width = PIXEL_MAP_TEST_WIDTH;
177 info.size.height = PIXEL_MAP_TEST_HEIGHT;
178 info.pixelFormat = PixelFormat::RGB_565;
179 info.colorSpace = ColorSpace::SRGB;
180 pixelMap.SetImageInfo(info);
181 uint32_t bufferSize = rowDataSize * PIXEL_MAP_TEST_HEIGHT;
182 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap002 start" << bufferSize;
183 void *buffer = malloc(bufferSize);
184 EXPECT_NE(buffer, nullptr);
185 pixelMap.SetPixelsAddr(buffer, nullptr, bufferSize, AllocatorType::HEAP_ALLOC, nullptr);
186 uint8_t *data = const_cast<uint8_t *>(pixelMap.GetPixels());
187 EXPECT_NE(data, nullptr);
188 EXPECT_EQ(pixelMap.GetHeight(), PIXEL_MAP_TEST_HEIGHT);
189 EXPECT_EQ(pixelMap.GetWidth(), PIXEL_MAP_TEST_WIDTH);
190 EXPECT_EQ(pixelMap.GetPixelFormat(), PixelFormat::RGB_565);
191 EXPECT_EQ(pixelMap.GetColorSpace(), ColorSpace::SRGB);
192 EXPECT_EQ(pixelMap.GetPixelBytes(), bytesPerPixel);
193 EXPECT_EQ(pixelMap.GetRowBytes(), rowDataSize);
194 EXPECT_EQ(pixelMap.GetByteCount(), PIXEL_MAP_TEST_HEIGHT * rowDataSize);
195 /**
196 * @tc.steps: step2. Set image color data and get image color value.
197 * @tc.expected: step2. The image color value is correct
198 */
199 for (int32_t i = 0; i < PIXEL_MAP_TEST_WIDTH * PIXEL_MAP_RGB565_BYTE * PIXEL_MAP_TEST_HEIGHT; i++) {
200 data[i] = i;
201 }
202 EXPECT_NE(pixelMap.GetPixel16(1, 1), nullptr);
203 EXPECT_EQ(*pixelMap.GetPixel16(1, 1), 0x0908);
204 uint32_t color = 0;
205 uint32_t expect = 0xFF422008;
206 EXPECT_EQ(pixelMap.GetARGB32Color(1, 1, color), true);
207 EXPECT_EQ(color, expect);
208 // RGB565: binary: 0000100100001000
209 // split to : 00001 001000 01000
210 // | | |
211 // B G R
212 // transfer to RGB888:
213 // 1 8 8
214 // multi 256(8bit length)
215 // 256*1/2^5 256*8/2^6 256*8/2^5
216 // another method:
217 // (x<<3 | x>>2) (x<<2 | x>>4)
218 EXPECT_EQ(pixelMap.GetARGB32ColorA(color), 255);
219 EXPECT_EQ(pixelMap.GetARGB32ColorR(color), 66); // (8<<3 | 8 >> 2)
220 EXPECT_EQ(pixelMap.GetARGB32ColorG(color), 32); // (8<<2 | 8 >> 4)
221 EXPECT_EQ(pixelMap.GetARGB32ColorB(color), 8); // (1<<3 | 1 >> 2)
222 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap002 end";
223 }
224
225 /**
226 * @tc.name: ImagePixelMap003
227 * @tc.desc: ARGB_8888 pixel format pixel map operation
228 * @tc.type: FUNC
229 */
230 HWTEST_F(ImagePixelMapTest, ImagePixelMap003, TestSize.Level3)
231 {
232 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap003 start";
233 /**
234 * @tc.steps: step1. Set image info and alloc pixel map memory.
235 * @tc.expected: step1. The pixel map info is correct.
236 */
237 int8_t bytesPerPixel = 4;
238 int8_t rowDataSize = PIXEL_MAP_TEST_WIDTH * bytesPerPixel;
239 ImageInfo info;
240 info.size.width = PIXEL_MAP_TEST_WIDTH;
241 info.size.height = PIXEL_MAP_TEST_HEIGHT;
242 info.pixelFormat = PixelFormat::ARGB_8888;
243 info.colorSpace = ColorSpace::SRGB;
244 PixelMap pixelMap;
245 pixelMap.SetImageInfo(info);
246 uint32_t bufferSize = rowDataSize * PIXEL_MAP_TEST_HEIGHT;
247 void *buffer = malloc(bufferSize);
248 EXPECT_NE(buffer, nullptr);
249 pixelMap.SetPixelsAddr(buffer, nullptr, bufferSize, AllocatorType::HEAP_ALLOC, nullptr);
250 uint8_t *data = const_cast<uint8_t *>(pixelMap.GetPixels());
251 EXPECT_NE(data, nullptr);
252 EXPECT_EQ(pixelMap.GetHeight(), PIXEL_MAP_TEST_HEIGHT);
253 EXPECT_EQ(pixelMap.GetWidth(), PIXEL_MAP_TEST_WIDTH);
254 EXPECT_EQ(pixelMap.GetPixelFormat(), PixelFormat::ARGB_8888);
255 EXPECT_EQ(pixelMap.GetColorSpace(), ColorSpace::SRGB);
256 EXPECT_EQ(pixelMap.GetPixelBytes(), bytesPerPixel);
257 EXPECT_EQ(pixelMap.GetRowBytes(), rowDataSize);
258 EXPECT_EQ(pixelMap.GetByteCount(), PIXEL_MAP_TEST_HEIGHT * rowDataSize);
259 /**
260 * @tc.steps: step2. Set image color data and get image color value.
261 * @tc.expected: step2. The image color value is correct
262 */
263 for (int32_t i = 0; i < PIXEL_MAP_TEST_WIDTH * PIXEL_MAP_ARGB8888_BYTE * PIXEL_MAP_TEST_HEIGHT; i++) {
264 data[i] = i;
265 }
266 EXPECT_NE(pixelMap.GetPixel(1, 1), nullptr);
267 EXPECT_EQ(*pixelMap.GetPixel32(1, 1), static_cast<uint32_t>(0x13121110));
268 uint32_t color = 0;
269 EXPECT_EQ(pixelMap.GetARGB32Color(1, 1, color), true);
270 EXPECT_EQ(pixelMap.GetARGB32ColorA(color), 0x10);
271 EXPECT_EQ(pixelMap.GetARGB32ColorR(color), 0x11);
272 EXPECT_EQ(pixelMap.GetARGB32ColorG(color), 0x12);
273 EXPECT_EQ(pixelMap.GetARGB32ColorB(color), 0x13);
274 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap003 end";
275 }
276
277 /**
278 * @tc.name: ImagePixelMap004
279 * @tc.desc: Get pixel position out of image range
280 * @tc.type: FUNC
281 */
282 HWTEST_F(ImagePixelMapTest, ImagePixelMap004, TestSize.Level3)
283 {
284 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap004 start";
285 /**
286 * @tc.steps: step1. Set image info and alloc pixel map memory.
287 * @tc.expected: step1. The pixel map info is correct.
288 */
289 PixelMap pixelMap;
290 int8_t bytesPerPixel = 4;
291 int8_t rowDataSize = PIXEL_MAP_TEST_WIDTH * bytesPerPixel;
292 ImageInfo info;
293 info.size.width = PIXEL_MAP_TEST_WIDTH;
294 info.size.height = PIXEL_MAP_TEST_HEIGHT;
295 info.pixelFormat = PixelFormat::ARGB_8888;
296 info.colorSpace = ColorSpace::SRGB;
297 pixelMap.SetImageInfo(info);
298 uint32_t bufferSize = rowDataSize * PIXEL_MAP_TEST_HEIGHT;
299 void *buffer = malloc(bufferSize);
300 EXPECT_NE(buffer, nullptr);
301 pixelMap.SetPixelsAddr(buffer, nullptr, bufferSize, AllocatorType::HEAP_ALLOC, nullptr);
302 uint8_t *data = const_cast<uint8_t *>(pixelMap.GetPixels());
303 EXPECT_NE(data, nullptr);
304 EXPECT_EQ(pixelMap.GetHeight(), PIXEL_MAP_TEST_HEIGHT);
305 EXPECT_EQ(pixelMap.GetWidth(), PIXEL_MAP_TEST_WIDTH);
306 EXPECT_EQ(pixelMap.GetPixelFormat(), PixelFormat::ARGB_8888);
307 EXPECT_EQ(pixelMap.GetColorSpace(), ColorSpace::SRGB);
308 EXPECT_EQ(pixelMap.GetByteCount(), PIXEL_MAP_TEST_HEIGHT * rowDataSize);
309 /**
310 * @tc.steps: step2. Set image color data and get image color value.
311 * @tc.expected: step2. Get image color value failed, because of position out of image range.
312 */
313 for (int32_t i = 0; i < PIXEL_MAP_TEST_WIDTH * PIXEL_MAP_ARGB8888_BYTE * PIXEL_MAP_TEST_HEIGHT; i++) {
314 data[i] = i;
315 }
316 EXPECT_EQ(pixelMap.GetPixel32(4, 4), nullptr);
317 EXPECT_EQ(pixelMap.GetPixel(-1, -1), nullptr);
318 uint32_t color = 0;
319 EXPECT_EQ(pixelMap.GetARGB32Color(4, 4, color), false);
320 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap004 end";
321 }
322
323 /**
324 * @tc.name: ImagePixelMap005
325 * @tc.desc: Set error image size
326 * @tc.type: FUNC
327 */
328 HWTEST_F(ImagePixelMapTest, ImagePixelMap005, TestSize.Level3)
329 {
330 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap005 start";
331 /**
332 * @tc.steps: step1. Set image error info include image height and width.
333 * @tc.expected: step1. The pixel map info is default value.
334 */
335 PixelMap pixelMap;
336 ImageInfo info;
337 info.size.width = -10;
338 info.size.height = 10;
339 EXPECT_EQ(pixelMap.SetImageInfo(info), ERR_IMAGE_DATA_ABNORMAL);
340 EXPECT_EQ(pixelMap.GetHeight(), 0);
341 EXPECT_EQ(pixelMap.GetWidth(), 0);
342 EXPECT_EQ(pixelMap.GetPixelFormat(), PixelFormat::UNKNOWN);
343 EXPECT_EQ(pixelMap.GetColorSpace(), ColorSpace::SRGB);
344 EXPECT_EQ(pixelMap.GetByteCount(), 0);
345 uint8_t *data = const_cast<uint8_t *>(pixelMap.GetPixels());
346 EXPECT_EQ(data, nullptr);
347 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap005 end";
348 }
349
350 /**
351 * @tc.name: ImagePixelMap006
352 * @tc.desc: Set unknown pixel format and color space
353 * @tc.type: FUNC
354 */
355 HWTEST_F(ImagePixelMapTest, ImagePixelMap006, TestSize.Level3)
356 {
357 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap006 start";
358 /**
359 * @tc.steps: step1. Set image unknown pixel format and color space info.
360 * @tc.expected: step1. The pixel map info is default value.
361 */
362 PixelMap pixelMap;
363 ImageInfo info;
364 info.size.width = 10;
365 info.size.height = 10;
366 EXPECT_EQ(pixelMap.SetImageInfo(info), ERR_IMAGE_DATA_UNSUPPORT);
367 EXPECT_EQ(pixelMap.GetHeight(), 0);
368 EXPECT_EQ(pixelMap.GetWidth(), 0);
369 EXPECT_EQ(pixelMap.GetPixelFormat(), PixelFormat::UNKNOWN);
370 EXPECT_EQ(pixelMap.GetColorSpace(), ColorSpace::SRGB);
371 EXPECT_EQ(pixelMap.GetByteCount(), 0);
372 uint8_t *data = const_cast<uint8_t *>(pixelMap.GetPixels());
373 EXPECT_EQ(data, nullptr);
374 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap006 end";
375 }
376
377 /**
378 * @tc.name: ImagePixelMap007
379 * @tc.desc: Set pixel map size out of max value
380 * @tc.type: FUNC
381 */
382 HWTEST_F(ImagePixelMapTest, ImagePixelMap007, TestSize.Level3)
383 {
384 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap007 start";
385 /**
386 * @tc.steps: step1. Set image size out of max value (500MB).
387 * @tc.expected: step1. The pixel map info is default value.
388 */
389 PixelMap pixelMap;
390 ImageInfo info;
391 info.size.width = 500 * 1024;
392 info.size.height = 500 * 1024;
393 info.pixelFormat = PixelFormat::ARGB_8888;
394 info.colorSpace = ColorSpace::SRGB;
395 EXPECT_EQ(pixelMap.SetImageInfo(info), SUCCESS);
396 EXPECT_EQ(pixelMap.GetHeight(), info.size.width);
397 EXPECT_EQ(pixelMap.GetWidth(), info.size.width);
398 EXPECT_NE(pixelMap.GetByteCount(), 0);
399 uint8_t *data = const_cast<uint8_t *>(pixelMap.GetPixels());
400 EXPECT_EQ(data, nullptr);
401 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap007 end";
402 }
403
404 /**
405 * @tc.name: ImagePixelMap008
406 * @tc.desc: RGB_888 pixel format pixel map operation
407 * @tc.type: FUNC
408 */
409 HWTEST_F(ImagePixelMapTest, ImagePixelMap008, TestSize.Level3)
410 {
411 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap008 start";
412 /**
413 * @tc.steps: step1. Set image info and alloc pixel map memory.
414 * @tc.expected: step1. The pixel map info is correct.
415 */
416 int8_t bytesPerPixel = 3;
417 int8_t rowDataSize = PIXEL_MAP_TEST_WIDTH * bytesPerPixel;
418 ImageInfo info;
419 info.size.width = PIXEL_MAP_TEST_WIDTH;
420 info.size.height = PIXEL_MAP_TEST_HEIGHT;
421 info.pixelFormat = PixelFormat::RGB_888;
422 info.colorSpace = ColorSpace::SRGB;
423 PixelMap pixelMap;
424 pixelMap.SetImageInfo(info);
425 uint32_t bufferSize = rowDataSize * PIXEL_MAP_TEST_HEIGHT;
426 void *buffer = malloc(bufferSize);
427 EXPECT_NE(buffer, nullptr);
428 pixelMap.SetPixelsAddr(buffer, nullptr, bufferSize, AllocatorType::HEAP_ALLOC, nullptr);
429 uint8_t *data = const_cast<uint8_t *>(pixelMap.GetPixels());
430 EXPECT_NE(data, nullptr);
431 EXPECT_EQ(pixelMap.GetHeight(), PIXEL_MAP_TEST_HEIGHT);
432 EXPECT_EQ(pixelMap.GetWidth(), PIXEL_MAP_TEST_WIDTH);
433 EXPECT_EQ(pixelMap.GetPixelFormat(), PixelFormat::RGB_888);
434 EXPECT_EQ(pixelMap.GetColorSpace(), ColorSpace::SRGB);
435 EXPECT_EQ(pixelMap.GetPixelBytes(), bytesPerPixel);
436 EXPECT_EQ(pixelMap.GetRowBytes(), rowDataSize);
437 EXPECT_EQ(pixelMap.GetByteCount(), PIXEL_MAP_TEST_HEIGHT * rowDataSize);
438 /**
439 * @tc.steps: step2. Set image color data and get image color value.
440 * @tc.expected: step2. The image color value is correct
441 */
442 for (int32_t i = 0; i < PIXEL_MAP_TEST_WIDTH * PIXEL_MAP_RGB888_BYTE * PIXEL_MAP_TEST_HEIGHT; i++) {
443 data[i] = i;
444 }
445 EXPECT_NE(pixelMap.GetPixel(1, 1), nullptr);
446 uint32_t color = 0;
447 EXPECT_EQ(pixelMap.GetARGB32Color(1, 1, color), true);
448 EXPECT_EQ(pixelMap.GetARGB32ColorA(color), 255);
449 EXPECT_EQ(pixelMap.GetARGB32ColorR(color), 12);
450 EXPECT_EQ(pixelMap.GetARGB32ColorG(color), 13);
451 EXPECT_EQ(pixelMap.GetARGB32ColorB(color), 14);
452 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap008 end";
453 }
454
455 /**
456 * @tc.name: ImagePixelMap009
457 * @tc.desc: create pixelmap with wrong source and correct initialization options
458 * @tc.type: FUNC
459 */
460 HWTEST_F(ImagePixelMapTest, ImagePixelMap009, TestSize.Level3)
461 {
462 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap009 start";
463 /**
464 * @tc.steps: step1. set source pixelmap wrong and correct initialization options
465 * @tc.expected: step1. The new pixelmap is null.
466 */
467 PixelMap srcPixelMap;
468 ImageInfo imageInfo;
469 srcPixelMap.SetImageInfo(imageInfo);
470 InitializationOptions opts;
471 opts.size.width = 200;
472 opts.size.height = 300;
473 opts.pixelFormat = PixelFormat::ARGB_8888;
474 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
475 std::unique_ptr<PixelMap> newPixelMap = PixelMap::Create(srcPixelMap, opts);
476 EXPECT_EQ(newPixelMap, nullptr);
477 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap009 end";
478 }
479
480 /**
481 * @tc.name: ImagePixelMap010
482 * @tc.desc: test WriteToParcel
483 * @tc.type: FUNC
484 * @tc.require: AR000FTAMO
485 */
486 HWTEST_F(ImagePixelMapTest, ImagePixelMap010, TestSize.Level3)
487 {
488 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap010 start";
489 Parcel data;
490 std::unique_ptr<PixelMap> pixelmap = ConstructPixmap();
491 bool ret = pixelmap.get()->Marshalling(data);
492 EXPECT_EQ(true, ret);
493
494 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap010 end";
495 }
496
497 /**
498 * @tc.name: ImagePixelMap011
499 * @tc.desc: test CreateFromParcel
500 * @tc.type: FUNC
501 * @tc.require: AR000FTAMO
502 */
503 HWTEST_F(ImagePixelMapTest, ImagePixelMap011, TestSize.Level3)
504 {
505 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap011 start";
506
507 Parcel data;
508 std::unique_ptr<PixelMap> pixelmap1 = ConstructPixmap();
509 bool ret = pixelmap1.get()->Marshalling(data);
510 EXPECT_EQ(true, ret);
511
512 PixelMap *pixelmap2 = PixelMap::Unmarshalling(data);
513 EXPECT_EQ(pixelmap1->GetHeight(), pixelmap2->GetHeight());
514 EXPECT_EQ(pixelmap1->GetWidth(), pixelmap2->GetWidth());
515 EXPECT_EQ(pixelmap1->GetPixelFormat(), pixelmap2->GetPixelFormat());
516 EXPECT_EQ(pixelmap1->GetColorSpace(), pixelmap2->GetColorSpace());
517
518 Parcel data2;
519 pixelmap2->Marshalling(data2);
520 PIXEL_MAP_ERR err;
521 PixelMap *pixelmap3 = PixelMap::Unmarshalling(data2, err);
522 EXPECT_EQ(pixelmap2->GetHeight(), pixelmap3->GetHeight());
523 EXPECT_EQ(pixelmap2->GetWidth(), pixelmap3->GetWidth());
524 EXPECT_EQ(pixelmap2->GetPixelFormat(), pixelmap3->GetPixelFormat());
525 EXPECT_EQ(pixelmap2->GetColorSpace(), pixelmap3->GetColorSpace());
526
527 uint32_t code = 10; // test num.
528 pixelmap3->SetPixelMapError(code, "error");
529 EXPECT_EQ(code, pixelmap3->errorCode);
530 EXPECT_EQ("error", pixelmap3->errorInfo);
531
532 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap011 end";
533 }
534
535 /**
536 * @tc.name: ImagePixelMap012
537 * @tc.desc: create pixelmap with color,colorlength,offset,width and initialization options
538 * @tc.type: FUNC
539 */
540 HWTEST_F(ImagePixelMapTest, ImagePixelMap012, TestSize.Level3)
541 {
542 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap012 start";
543 /**
544 * @tc.steps: step1. set color,colorlength,offset,width and initialization options
545 * @tc.expected: step1. The new pixelmap is not null.
546 */
547 const uint32_t color[8] = { 0x80, 0x02, 0x04, 0x08, 0x40, 0x02, 0x04, 0x08 };
548 uint32_t colorlength = sizeof(color) / sizeof(color[0]);
549 const int32_t offset = 1;
550 InitializationOptions opts;
551 opts.size.width = 200;
552 opts.size.height = 300;
553 opts.pixelFormat = PixelFormat::ARGB_8888;
554 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
555 int32_t width = opts.size.width;
556
557 std::unique_ptr<PixelMap> newPixelMap = PixelMap::Create(color, colorlength, offset, width, opts);
558 EXPECT_EQ(newPixelMap, nullptr);
559 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap012 end";
560 }
561
562
563 /**
564 * @tc.name: ImagePixelMap013
565 * @tc.desc: test CreateFromParcel
566 * @tc.type: FUNC
567 * @tc.require: AR000FTAMO
568 */
569 HWTEST_F(ImagePixelMapTest, ImagePixelMap013, TestSize.Level3)
570 {
571 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap013 start";
572
573 Parcel data;
574 std::unique_ptr<PixelMap> pixelmap1 = ConstructBigPixmap();
575 EXPECT_NE(pixelmap1, nullptr);
576 GTEST_LOG_(INFO) << "ImagePixelMap013 ConstructPixmap success";
577 bool ret = pixelmap1.get()->Marshalling(data);
578 GTEST_LOG_(INFO) << "ImagePixelMap013 Marshalling success";
579 EXPECT_EQ(true, ret);
580
581 PixelMap *pixelmap2 = PixelMap::Unmarshalling(data);
582 GTEST_LOG_(INFO) << "ImagePixelMap013 Unmarshalling success";
583 GTEST_LOG_(INFO) << "ImagePixelMap013 pixelmap1 GetHeight :" << pixelmap1->GetHeight();
584 GTEST_LOG_(INFO) << "ImagePixelMap013 pixelmap2 GetHeight :" << pixelmap2->GetHeight();
585 EXPECT_EQ(pixelmap1->GetHeight(), pixelmap2->GetHeight());
586 GTEST_LOG_(INFO) << "ImagePixelMap013 GetHeight success";
587 EXPECT_EQ(pixelmap1->GetWidth(), pixelmap2->GetWidth());
588 GTEST_LOG_(INFO) << "ImagePixelMap013 GetWidth success";
589 EXPECT_EQ(pixelmap1->GetPixelFormat(), pixelmap2->GetPixelFormat());
590 GTEST_LOG_(INFO) << "ImagePixelMap013 GetPixelFormat success";
591 EXPECT_EQ(pixelmap1->GetColorSpace(), pixelmap2->GetColorSpace());
592 GTEST_LOG_(INFO) << "ImagePixelMap013 GetColorSpace success";
593 EXPECT_EQ(true, pixelmap1->IsSameImage(*pixelmap2));
594 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap013 end";
595 }
596
597
598 /**
599 * @tc.name: ImagePixelMap014
600 * @tc.desc: test GetPixel8
601 * @tc.type: FUNC
602 * @tc.require: AR000FTAMO
603 */
604 HWTEST_F(ImagePixelMapTest, ImagePixelMap014, TestSize.Level3)
605 {
606 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap014 GetPixel8 start";
607 PixelMap pixelMap;
608 int32_t x = 1;
609 int32_t y = 1;
610 uint8_t *ret = 0;
611 EXPECT_EQ(ret, pixelMap.GetPixel8(x, y));
612 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap014 GetPixel8 end";
613 }
614
615 /**
616 * @tc.name: ImagePixelMap015
617 * @tc.desc: test GetPixel16
618 * @tc.type: FUNC
619 * @tc.require: AR000FTAMO
620 */
621 HWTEST_F(ImagePixelMapTest, ImagePixelMap015, TestSize.Level3)
622 {
623 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap015 GetPixel16 start";
624 PixelMap pixelMap;
625 int32_t x = 1;
626 int32_t y = 1;
627 uint16_t *ret = 0;
628 EXPECT_EQ(ret, pixelMap.GetPixel16(x, y));
629 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap015 GetPixel16 end";
630 }
631
632 /**
633 * @tc.name: ImagePixelMap016
634 * @tc.desc: test GetPixelBytes
635 * @tc.type: FUNC
636 * @tc.require: AR000FTAMO
637 */
638 HWTEST_F(ImagePixelMapTest, ImagePixelMap016, TestSize.Level3)
639 {
640 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap016 GetPixelBytes start";
641 PixelMap pixelMap;
642 int32_t ret = 0;
643 EXPECT_EQ(ret, pixelMap.GetPixelBytes());
644 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap016 GetPixelBytes end";
645 }
646
647 /**
648 * @tc.name: ImagePixelMap017
649 * @tc.desc: test GetPixelBytes
650 * @tc.type: FUNC
651 * @tc.require: AR000FTAMO
652 */
653 HWTEST_F(ImagePixelMapTest, ImagePixelMap017, TestSize.Level3)
654 {
655 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap017 scale start";
656 PixelMap pixelMap;
657 ImageInfo info;
658 info.size.width = PIXEL_MAP_TEST_WIDTH;
659 info.size.height = PIXEL_MAP_TEST_HEIGHT;
660 info.pixelFormat = PixelFormat::ALPHA_8;
661 info.colorSpace = ColorSpace::SRGB;
662 pixelMap.SetImageInfo(info);
663 float xAxis = 2.0;
664 float yAxis = 1.0;
665 pixelMap.scale(xAxis, yAxis);
666 ImageInfo outInfo;
667 pixelMap.GetImageInfo(outInfo);
668 int32_t width = PIXEL_MAP_TEST_WIDTH * 2;
669 int32_t height = PIXEL_MAP_TEST_HEIGHT;
670 EXPECT_EQ(width, outInfo.size.width);
671 EXPECT_EQ(height, outInfo.size.height);
672 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap017 scale end";
673 }
674
675 /**
676 * @tc.name: ImagePixelMap018
677 * @tc.desc: test translate
678 * @tc.type: FUNC
679 * @tc.require: AR000FTAMO
680 */
681 HWTEST_F(ImagePixelMapTest, ImagePixelMap018, TestSize.Level3)
682 {
683 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap018 translate start";
684 PixelMap pixelMap;
685 ImageInfo info;
686 info.size.width = PIXEL_MAP_TEST_WIDTH;
687 info.size.height = PIXEL_MAP_TEST_HEIGHT;
688 info.pixelFormat = PixelFormat::ALPHA_8;
689 info.colorSpace = ColorSpace::SRGB;
690 pixelMap.SetImageInfo(info);
691 float xAxis = 2.0;
692 float yAxis = 1.0;
693 pixelMap.translate(xAxis, yAxis);
694 ImageInfo outInfo;
695 pixelMap.GetImageInfo(outInfo);
696 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap018 translate end";
697 }
698
699 /**
700 * @tc.name: ImagePixelMap019
701 * @tc.desc: test rotate
702 * @tc.type: FUNC
703 * @tc.require: AR000FTAMO
704 */
705 HWTEST_F(ImagePixelMapTest, ImagePixelMap019, TestSize.Level3)
706 {
707 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap019 rotate start";
708 PixelMap pixelMap;
709 ImageInfo info;
710 info.size.width = PIXEL_MAP_TEST_WIDTH;
711 info.size.height = PIXEL_MAP_TEST_HEIGHT;
712 info.pixelFormat = PixelFormat::ALPHA_8;
713 info.colorSpace = ColorSpace::SRGB;
714 pixelMap.SetImageInfo(info);
715 float degrees = 90.0;
716 pixelMap.rotate(degrees);
717 ImageInfo outInfo;
718 pixelMap.GetImageInfo(outInfo);
719 int32_t width = PIXEL_MAP_TEST_HEIGHT;
720 int32_t height = PIXEL_MAP_TEST_WIDTH;
721 EXPECT_EQ(width, outInfo.size.width);
722 EXPECT_EQ(height, outInfo.size.height);
723 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap019 rotate end";
724 }
725
726 /**
727 * @tc.name: ImagePixelMap020
728 * @tc.desc: test flip
729 * @tc.type: FUNC
730 * @tc.require: AR000FTAMO
731 */
732 HWTEST_F(ImagePixelMapTest, ImagePixelMap020, TestSize.Level3)
733 {
734 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap020 flip start";
735 PixelMap pixelMap;
736 ImageInfo info;
737 info.size.width = PIXEL_MAP_TEST_WIDTH;
738 info.size.height = PIXEL_MAP_TEST_HEIGHT;
739 info.pixelFormat = PixelFormat::ALPHA_8;
740 info.colorSpace = ColorSpace::SRGB;
741 pixelMap.SetImageInfo(info);
742 pixelMap.flip(false, true);
743 ImageInfo outInfo;
744 pixelMap.GetImageInfo(outInfo);
745 int32_t width = PIXEL_MAP_TEST_WIDTH;
746 int32_t height = PIXEL_MAP_TEST_HEIGHT;
747 EXPECT_EQ(width, outInfo.size.width);
748 EXPECT_EQ(height, outInfo.size.height);
749 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap020 flip end";
750 }
751
752 /**
753 * @tc.name: ImagePixelMap021
754 * @tc.desc: test crop
755 * @tc.type: FUNC
756 * @tc.require: AR000FTAMO
757 */
758 HWTEST_F(ImagePixelMapTest, ImagePixelMap021, TestSize.Level3)
759 {
760 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap021 crop start";
761 PixelMap pixelMap;
762 ImageInfo info;
763 info.size.width = PIXEL_MAP_TEST_WIDTH;
764 info.size.height = PIXEL_MAP_TEST_HEIGHT;
765 info.pixelFormat = PixelFormat::ALPHA_8;
766 info.colorSpace = ColorSpace::SRGB;
767 pixelMap.SetImageInfo(info);
768 Rect rect;
769 rect.left = 0;
770 rect.top = 0;
771 rect.height = 1;
772 rect.width = 1;
773 pixelMap.crop(rect);
774 ImageInfo outInfo;
775 pixelMap.GetImageInfo(outInfo);
776 int32_t width = 3;
777 int32_t height = 3;
778 EXPECT_EQ(width, outInfo.size.width);
779 EXPECT_EQ(height, outInfo.size.height);
780 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap021 crop end";
781 }
782
783 /**
784 * @tc.name: ImagePixelMap022
785 * @tc.desc: test SetAlpha
786 * @tc.type: FUNC
787 * @tc.require: AR000FTAMO
788 */
789 HWTEST_F(ImagePixelMapTest, ImagePixelMap022, TestSize.Level3)
790 {
791 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap022 SetAlpha start";
792 PixelMap pixelMap;
793 ImageInfo info;
794 info.size.width = PIXEL_MAP_TEST_WIDTH;
795 info.size.height = PIXEL_MAP_TEST_HEIGHT;
796 info.pixelFormat = PixelFormat::RGB_888;
797 info.colorSpace = ColorSpace::SRGB;
798 pixelMap.SetImageInfo(info);
799 float percent = 0.5;
800 pixelMap.SetAlpha(percent);
801 ImageInfo outInfo;
802 pixelMap.GetImageInfo(outInfo);
803 bool getAlpha = false;
804 if (outInfo.pixelFormat != info.pixelFormat) {
805 getAlpha = true;
806 }
807 EXPECT_EQ(false, getAlpha);
808 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap022 SetAlpha end";
809 }
810
811 /**
812 * @tc.name: ImagePixelMap023
813 * @tc.desc: test GetARGB32ColorA
814 * @tc.type: FUNC
815 * @tc.require: AR000FTAMO
816 */
817 HWTEST_F(ImagePixelMapTest, ImagePixelMap023, TestSize.Level3)
818 {
819 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap023 GetARGB32ColorA start";
820 PixelMap pixelMap;
821 ImageInfo info;
822 info.size.width = PIXEL_MAP_TEST_WIDTH;
823 info.size.height = PIXEL_MAP_TEST_HEIGHT;
824 info.pixelFormat = PixelFormat::ALPHA_8;
825 info.colorSpace = ColorSpace::SRGB;
826 pixelMap.SetImageInfo(info);
827 uint32_t color = 1;
828 pixelMap.GetARGB32ColorA(color);
829 ImageInfo outInfo;
830 pixelMap.GetImageInfo(outInfo);
831 int32_t width = PIXEL_MAP_TEST_WIDTH;
832 int32_t height = PIXEL_MAP_TEST_HEIGHT;
833 EXPECT_EQ(width, outInfo.size.width);
834 EXPECT_EQ(height, outInfo.size.height);
835 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap023 GetARGB32ColorA end";
836 }
837
838 /**
839 * @tc.name: ImagePixelMap024
840 * @tc.desc: test GetARGB32ColorR
841 * @tc.type: FUNC
842 * @tc.require: AR000FTAMO
843 */
844 HWTEST_F(ImagePixelMapTest, ImagePixelMap024, TestSize.Level3)
845 {
846 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap024 GetARGB32ColorR start";
847 PixelMap pixelMap;
848 ImageInfo info;
849 info.size.width = PIXEL_MAP_TEST_WIDTH;
850 info.size.height = PIXEL_MAP_TEST_HEIGHT;
851 info.pixelFormat = PixelFormat::ALPHA_8;
852 info.colorSpace = ColorSpace::SRGB;
853 pixelMap.SetImageInfo(info);
854 uint32_t color = 1;
855 pixelMap.GetARGB32ColorR(color);
856 ImageInfo outInfo;
857 pixelMap.GetImageInfo(outInfo);
858 int32_t width = PIXEL_MAP_TEST_WIDTH;
859 int32_t height = PIXEL_MAP_TEST_HEIGHT;
860 EXPECT_EQ(width, outInfo.size.width);
861 EXPECT_EQ(height, outInfo.size.height);
862 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap024 GetARGB32ColorR end";
863 }
864
865 /**
866 * @tc.name: ImagePixelMap025
867 * @tc.desc: test GetARGB32ColorG
868 * @tc.type: FUNC
869 * @tc.require: AR000FTAMO
870 */
871 HWTEST_F(ImagePixelMapTest, ImagePixelMap025, TestSize.Level3)
872 {
873 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap025 GetARGB32ColorG start";
874 PixelMap pixelMap;
875 ImageInfo info;
876 info.size.width = PIXEL_MAP_TEST_WIDTH;
877 info.size.height = PIXEL_MAP_TEST_HEIGHT;
878 info.pixelFormat = PixelFormat::ALPHA_8;
879 info.colorSpace = ColorSpace::SRGB;
880 pixelMap.SetImageInfo(info);
881 uint32_t color = 1;
882 pixelMap.GetARGB32ColorG(color);
883 ImageInfo outInfo;
884 pixelMap.GetImageInfo(outInfo);
885 int32_t width = PIXEL_MAP_TEST_WIDTH;
886 int32_t height = PIXEL_MAP_TEST_HEIGHT;
887 EXPECT_EQ(width, outInfo.size.width);
888 EXPECT_EQ(height, outInfo.size.height);
889 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap025 GetARGB32ColorG end";
890 }
891
892 /**
893 * @tc.name: ImagePixelMap026
894 * @tc.desc: test GetARGB32ColorB
895 * @tc.type: FUNC
896 * @tc.require: AR000FTAMO
897 */
898 HWTEST_F(ImagePixelMapTest, ImagePixelMap026, TestSize.Level3)
899 {
900 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap026 GetARGB32ColorB start";
901 PixelMap pixelMap;
902 ImageInfo info;
903 info.size.width = PIXEL_MAP_TEST_WIDTH;
904 info.size.height = PIXEL_MAP_TEST_HEIGHT;
905 info.pixelFormat = PixelFormat::ALPHA_8;
906 info.colorSpace = ColorSpace::SRGB;
907 pixelMap.SetImageInfo(info);
908 uint32_t color = 1;
909 pixelMap.GetARGB32ColorB(color);
910 ImageInfo outInfo;
911 pixelMap.GetImageInfo(outInfo);
912 int32_t width = PIXEL_MAP_TEST_WIDTH;
913 int32_t height = PIXEL_MAP_TEST_HEIGHT;
914 EXPECT_EQ(width, outInfo.size.width);
915 EXPECT_EQ(height, outInfo.size.height);
916 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap026 GetARGB32ColorB end";
917 }
918
919 /**
920 * @tc.name: ImagePixelMap027
921 * @tc.desc: test IsSameImage
922 * @tc.type: FUNC
923 * @tc.require: AR000FTAMO
924 */
925 HWTEST_F(ImagePixelMapTest, ImagePixelMap027, TestSize.Level3)
926 {
927 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap027 IsSameImage start";
928 PixelMap pixelMap, pixelMap1;
929 ImageInfo info;
930 info.size.width = PIXEL_MAP_TEST_WIDTH;
931 info.size.height = PIXEL_MAP_TEST_HEIGHT;
932 info.pixelFormat = PixelFormat::ALPHA_8;
933 info.colorSpace = ColorSpace::SRGB;
934 pixelMap.SetImageInfo(info);
935 pixelMap1.SetImageInfo(info);
936 bool ret = pixelMap.IsSameImage(pixelMap1);
937 EXPECT_EQ(false, ret);
938 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap027 IsSameImage end";
939 }
940
941 /**
942 * @tc.name: ImagePixelMap028
943 * @tc.desc: test ReadPixels
944 * @tc.type: FUNC
945 * @tc.require: AR000FTAMO
946 */
947 HWTEST_F(ImagePixelMapTest, ImagePixelMap028, TestSize.Level3)
948 {
949 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap028 ReadPixels start";
950 PixelMap pixelMap;
951 ImageInfo info;
952 info.size.width = PIXEL_MAP_TEST_WIDTH;
953 info.size.height = PIXEL_MAP_TEST_HEIGHT;
954 info.pixelFormat = PixelFormat::ALPHA_8;
955 info.colorSpace = ColorSpace::SRGB;
956 pixelMap.SetImageInfo(info);
957 uint64_t bufferSize = 96;
958 uint32_t offset = 0;
959 uint32_t stride = 8;
960 Rect rect;
961 rect.left = 0;
962 rect.top = 0;
963 rect.height = 1;
964 rect.width = 2;
965 uint8_t *dst = 0;
966 uint32_t ret = pixelMap.ReadPixels(bufferSize, offset, stride, rect, dst);
967 bool getReadPixels = true;
968 if (ret != SUCCESS) {
969 getReadPixels = false;
970 }
971 EXPECT_EQ(false, getReadPixels);
972 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap028 ReadPixels end";
973 }
974
975 /**
976 * @tc.name: ImagePixelMap029
977 * @tc.desc: test ReadPixels
978 * @tc.type: FUNC
979 * @tc.require: AR000FTAMO
980 */
981 HWTEST_F(ImagePixelMapTest, ImagePixelMap029, TestSize.Level3)
982 {
983 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap029 ReadPixels start";
984 PixelMap pixelMap;
985 ImageInfo info;
986 info.size.width = PIXEL_MAP_TEST_WIDTH;
987 info.size.height = PIXEL_MAP_TEST_HEIGHT;
988 info.pixelFormat = PixelFormat::ALPHA_8;
989 info.colorSpace = ColorSpace::SRGB;
990 pixelMap.SetImageInfo(info);
991 uint64_t bufferSize = 96;
992 uint8_t *dst = 0;
993 uint32_t ret = pixelMap.ReadPixels(bufferSize, dst);
994 bool getReadPixels = true;
995 if (ret != SUCCESS) {
996 getReadPixels = false;
997 }
998 EXPECT_EQ(false, getReadPixels);
999 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap029 ReadPixels end";
1000 }
1001
1002 /**
1003 * @tc.name: ImagePixelMap030
1004 * @tc.desc: test ReadPixel
1005 * @tc.type: FUNC
1006 * @tc.require: AR000FTAMO
1007 */
1008 HWTEST_F(ImagePixelMapTest, ImagePixelMap030, TestSize.Level3)
1009 {
1010 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap030 ReadPixel start";
1011 PixelMap pixelMap;
1012 ImageInfo info;
1013 info.size.width = PIXEL_MAP_TEST_WIDTH;
1014 info.size.height = PIXEL_MAP_TEST_HEIGHT;
1015 info.pixelFormat = PixelFormat::ALPHA_8;
1016 info.colorSpace = ColorSpace::SRGB;
1017 pixelMap.SetImageInfo(info);
1018 int32_t x = 0;
1019 int32_t y = 0;
1020 Position position;
1021 position.x = x;
1022 position.y = y;
1023 uint32_t dst = 0;
1024 uint32_t ret = pixelMap.ReadPixel(position, dst);
1025 bool getReadPixel = true;
1026 if (ret != SUCCESS) {
1027 getReadPixel = false;
1028 }
1029 EXPECT_EQ(false, getReadPixel);
1030 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap030 ReadPixel end";
1031 }
1032
1033 /**
1034 * @tc.name: ImagePixelMap031
1035 * @tc.desc: test ResetConfig
1036 * @tc.type: FUNC
1037 * @tc.require: AR000FTAMO
1038 */
1039 HWTEST_F(ImagePixelMapTest, ImagePixelMap031, TestSize.Level3)
1040 {
1041 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap031 ResetConfig start";
1042 PixelMap pixelMap;
1043 ImageInfo info;
1044 info.size.width = PIXEL_MAP_TEST_WIDTH;
1045 info.size.height = PIXEL_MAP_TEST_HEIGHT;
1046 info.pixelFormat = PixelFormat::ALPHA_8;
1047 info.colorSpace = ColorSpace::SRGB;
1048 pixelMap.SetImageInfo(info);
1049 Size size;
1050 size.width = 2 * PIXEL_MAP_TEST_WIDTH;
1051 size.height = 2 * PIXEL_MAP_TEST_HEIGHT;
1052 PixelFormat pixelFormat = PixelFormat::RGBA_8888;
1053 uint32_t ret = pixelMap.ResetConfig(size, pixelFormat);
1054 bool getResetConfig = true;
1055 if (ret != SUCCESS) {
1056 getResetConfig = false;
1057 }
1058 EXPECT_EQ(false, getResetConfig);
1059 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap031 ResetConfig end";
1060 }
1061
1062 /**
1063 * @tc.name: ImagePixelMap032
1064 * @tc.desc: test SetAlphaType
1065 * @tc.type: FUNC
1066 * @tc.require: AR000FTAMO
1067 */
1068 HWTEST_F(ImagePixelMapTest, ImagePixelMap032, TestSize.Level3)
1069 {
1070 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap032 SetAlphaType start";
1071 PixelMap pixelMap;
1072 ImageInfo info;
1073 info.size.width = PIXEL_MAP_TEST_WIDTH;
1074 info.size.height = PIXEL_MAP_TEST_HEIGHT;
1075 info.pixelFormat = PixelFormat::ALPHA_8;
1076 info.colorSpace = ColorSpace::SRGB;
1077 pixelMap.SetImageInfo(info);
1078 AlphaType alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1079 bool ret = pixelMap.SetAlphaType(alphaType);
1080 EXPECT_EQ(true, ret);
1081 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap032 SetAlphaType end";
1082 }
1083
1084 /**
1085 * @tc.name: ImagePixelMap033
1086 * @tc.desc: test SetAlphaType
1087 * @tc.type: FUNC
1088 * @tc.require: AR000FTAMO
1089 */
1090 HWTEST_F(ImagePixelMapTest, ImagePixelMap033, TestSize.Level3)
1091 {
1092 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap033 SetAlphaType start";
1093 PixelMap pixelMap;
1094 ImageInfo info;
1095 info.size.width = PIXEL_MAP_TEST_WIDTH;
1096 info.size.height = PIXEL_MAP_TEST_HEIGHT;
1097 info.pixelFormat = PixelFormat::ALPHA_8;
1098 info.colorSpace = ColorSpace::SRGB;
1099 pixelMap.SetImageInfo(info);
1100 AlphaType alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1101 bool ret = pixelMap.SetAlphaType(alphaType);
1102 EXPECT_EQ(true, ret);
1103 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap033 SetAlphaType end";
1104 }
1105
1106 /**
1107 * @tc.name: ImagePixelMap034
1108 * @tc.desc: test WritePixel
1109 * @tc.type: FUNC
1110 * @tc.require: AR000FTAMO
1111 */
1112 HWTEST_F(ImagePixelMapTest, ImagePixelMap034, TestSize.Level3)
1113 {
1114 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap034 WritePixel start";
1115 PixelMap pixelMap;
1116 ImageInfo info;
1117 info.size.width = PIXEL_MAP_TEST_WIDTH;
1118 info.size.height = PIXEL_MAP_TEST_HEIGHT;
1119 info.pixelFormat = PixelFormat::ALPHA_8;
1120 info.colorSpace = ColorSpace::SRGB;
1121 pixelMap.SetImageInfo(info);
1122 int32_t x = 0;
1123 int32_t y = 0;
1124 Position position;
1125 position.x = x;
1126 position.y = y;
1127 uint32_t color = 9;
1128 uint32_t ret = pixelMap.WritePixel(position, color);
1129 bool getWritePixel = true;
1130 if (ret != SUCCESS) {
1131 getWritePixel = false;
1132 }
1133 EXPECT_EQ(false, getWritePixel);
1134 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap034 WritePixel end";
1135 }
1136
1137 /**
1138 * @tc.name: ImagePixelMap035
1139 * @tc.desc: test GetFd
1140 * @tc.type: FUNC
1141 * @tc.require: AR000FTAMO
1142 */
1143 HWTEST_F(ImagePixelMapTest, ImagePixelMap035, TestSize.Level3)
1144 {
1145 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap035 GetFd start";
1146 PixelMap pixelMap;
1147 ImageInfo info;
1148 info.size.width = PIXEL_MAP_TEST_WIDTH;
1149 info.size.height = PIXEL_MAP_TEST_HEIGHT;
1150 info.pixelFormat = PixelFormat::ALPHA_8;
1151 info.colorSpace = ColorSpace::SRGB;
1152 pixelMap.SetImageInfo(info);
1153
1154 void *ret = pixelMap.GetFd();
1155 bool isFd = false;
1156 if (ret != nullptr) {
1157 isFd = true;
1158 }
1159 EXPECT_EQ(false, isFd);
1160 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap035 GetFd end";
1161 }
1162
1163 /**
1164 * @tc.name: ImagePixelMap036
1165 * @tc.desc: test GetCapacity
1166 * @tc.type: FUNC
1167 * @tc.require: AR000FTAMO
1168 */
1169 HWTEST_F(ImagePixelMapTest, ImagePixelMap036, TestSize.Level3)
1170 {
1171 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap036 GetCapacity start";
1172 PixelMap pixelMap;
1173 ImageInfo info;
1174 info.size.width = PIXEL_MAP_TEST_WIDTH;
1175 info.size.height = PIXEL_MAP_TEST_HEIGHT;
1176 info.pixelFormat = PixelFormat::ALPHA_8;
1177 info.colorSpace = ColorSpace::SRGB;
1178 pixelMap.SetImageInfo(info);
1179 uint32_t ret = pixelMap.GetCapacity();
1180 bool getCapacity = false;
1181 if (ret != 0) {
1182 getCapacity = true;
1183 }
1184 EXPECT_EQ(false, getCapacity);
1185 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap036 GetCapacity end";
1186 }
1187
1188 /**
1189 * @tc.name: ImagePixelMap037
1190 * @tc.desc: test IsSourceAsResponse
1191 * @tc.type: FUNC
1192 * @tc.require: AR000FTAMO
1193 */
1194 HWTEST_F(ImagePixelMapTest, ImagePixelMap037, TestSize.Level3)
1195 {
1196 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap037 IsSourceAsResponse start";
1197 PixelMap pixelMap;
1198 ImageInfo info;
1199 info.size.width = PIXEL_MAP_TEST_WIDTH;
1200 info.size.height = PIXEL_MAP_TEST_HEIGHT;
1201 info.pixelFormat = PixelFormat::ALPHA_8;
1202 info.colorSpace = ColorSpace::SRGB;
1203 pixelMap.SetImageInfo(info);
1204 bool ret = pixelMap.IsSourceAsResponse();
1205 EXPECT_EQ(false, ret);
1206 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap037 IsSourceAsResponse end";
1207 }
1208
1209 /**
1210 * @tc.name: ImagePixelMap038
1211 * @tc.desc: test GetWritablePixels
1212 * @tc.type: FUNC
1213 * @tc.require: AR000FTAMO
1214 */
1215 HWTEST_F(ImagePixelMapTest, ImagePixelMap038, TestSize.Level3)
1216 {
1217 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap038 GetWritablePixels start";
1218 PixelMap pixelMap;
1219 ImageInfo info;
1220 info.size.width = PIXEL_MAP_TEST_WIDTH;
1221 info.size.height = PIXEL_MAP_TEST_HEIGHT;
1222 info.pixelFormat = PixelFormat::ALPHA_8;
1223 info.colorSpace = ColorSpace::SRGB;
1224 pixelMap.SetImageInfo(info);
1225 void *ret = pixelMap.GetWritablePixels();
1226 bool getPixels = true;
1227 if (ret == nullptr) {
1228 getPixels = false;
1229 }
1230 EXPECT_EQ(false, getPixels);
1231 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap038 GetWritablePixels end";
1232 }
1233 #ifdef IMAGE_COLORSPACE_FLAG
1234 /**
1235 * @tc.name: ImagePixelMap039
1236 * @tc.desc: test InnerSetColorSpace
1237 * @tc.type: FUNC
1238 * @tc.require: AR000FTAMO
1239 */
1240 HWTEST_F(ImagePixelMapTest, ImagePixelMap039, TestSize.Level3)
1241 {
1242 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap039 InnerSetColorSpace start";
1243 PixelMap pixelMap;
1244 ImageInfo info;
1245 info.size.width = PIXEL_MAP_TEST_WIDTH;
1246 info.size.height = PIXEL_MAP_TEST_HEIGHT;
1247 info.pixelFormat = PixelFormat::ALPHA_8;
1248 info.colorSpace = ColorSpace::SRGB;
1249 pixelMap.SetImageInfo(info);
1250 OHOS::ColorManager::ColorSpace grColorSpace =
1251 OHOS::ColorManager::ColorSpace(OHOS::ColorManager::ColorSpaceName::SRGB);
1252 pixelMap.InnerSetColorSpace(grColorSpace);
1253 OHOS::ColorManager::ColorSpace outColorSpace = pixelMap.InnerGetGrColorSpace();
1254 EXPECT_TRUE(SkColorSpace::Equals(
1255 outColorSpace.ToSkColorSpace().get(), grColorSpace.ToSkColorSpace().get()));
1256 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap039 InnerSetColorSpace end";
1257 }
1258
1259 static constexpr uint32_t PIXEL_MAP_TEST_PIXEL = 0xFF994422;
1260 static constexpr uint32_t PIXEL_MAP_TEST_DISPLAY_P3_PIXEL = 0xFF2B498E;
1261 static constexpr uint32_t PIXEL_MAP_TEST_ADOBE_RGB_PIXEL = 0xFF294686;
1262 static constexpr uint32_t PIXEL_MAP_TEST_DCI_P3_PIXEL = 0xFF3D5A9D;
1263 static constexpr uint32_t PIXEL_MAP_TEST_BT2020_PIXEL = 0xFF1C3E74;
1264 static constexpr int32_t POINT_ZERO = 0;
1265
1266 /**
1267 * @tc.name: ImagePixelMap040
1268 * @tc.desc: test ApplyColorSpace DISPLAY_P3
1269 * @tc.type: FUNC
1270 */
1271 HWTEST_F(ImagePixelMapTest, ImagePixelMap040, TestSize.Level3)
1272 {
1273 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap040 ApplyColorSpace start";
1274 const uint32_t dataLength = PIXEL_MAP_TEST_WIDTH * PIXEL_MAP_TEST_HEIGHT;
1275 vector<uint32_t> data(dataLength, PIXEL_MAP_TEST_PIXEL);
1276 InitializationOptions opts;
1277 opts.pixelFormat = OHOS::Media::PixelFormat::RGBA_8888;
1278 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1279 opts.size.width = PIXEL_MAP_TEST_WIDTH;
1280 opts.size.height = PIXEL_MAP_TEST_HEIGHT;
1281
1282 auto pixelmap = PixelMap::Create(data.data(), dataLength, opts);
1283 auto grColorSpace = OHOS::ColorManager::ColorSpace(OHOS::ColorManager::ColorSpaceName::SRGB);
1284 pixelmap->InnerSetColorSpace(grColorSpace);
1285 auto applyGrColorSpace = OHOS::ColorManager::ColorSpace(OHOS::ColorManager::ColorSpaceName::DISPLAY_P3);
1286 pixelmap->ApplyColorSpace(applyGrColorSpace);
1287
1288 auto pixelZero = pixelmap->GetPixel32(POINT_ZERO, POINT_ZERO);
1289 EXPECT_EQ(*pixelZero, PIXEL_MAP_TEST_DISPLAY_P3_PIXEL);
1290 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap040 ApplyColorSpace end";
1291 }
1292
1293 /**
1294 * @tc.name: ImagePixelMap041
1295 * @tc.desc: test ApplyColorSpace ADOBE_RGB
1296 * @tc.type: FUNC
1297 */
1298 HWTEST_F(ImagePixelMapTest, ImagePixelMap041, TestSize.Level3)
1299 {
1300 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap040 ApplyColorSpace start";
1301 const uint32_t dataLength = PIXEL_MAP_TEST_WIDTH * PIXEL_MAP_TEST_HEIGHT;
1302 vector<uint32_t> data(dataLength, PIXEL_MAP_TEST_PIXEL);
1303 InitializationOptions opts;
1304 opts.pixelFormat = OHOS::Media::PixelFormat::RGBA_8888;
1305 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1306 opts.size.width = PIXEL_MAP_TEST_WIDTH;
1307 opts.size.height = PIXEL_MAP_TEST_HEIGHT;
1308
1309 auto pixelmap = PixelMap::Create(data.data(), dataLength, opts);
1310 auto grColorSpace = OHOS::ColorManager::ColorSpace(OHOS::ColorManager::ColorSpaceName::SRGB);
1311 pixelmap->InnerSetColorSpace(grColorSpace);
1312 auto applyGrColorSpace = OHOS::ColorManager::ColorSpace(OHOS::ColorManager::ColorSpaceName::ADOBE_RGB);
1313 pixelmap->ApplyColorSpace(applyGrColorSpace);
1314
1315 auto pixelZero = pixelmap->GetPixel32(POINT_ZERO, POINT_ZERO);
1316 EXPECT_EQ(*pixelZero, PIXEL_MAP_TEST_ADOBE_RGB_PIXEL);
1317 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap041 ApplyColorSpace end";
1318 }
1319
1320 /**
1321 * @tc.name: ImagePixelMap042
1322 * @tc.desc: test ApplyColorSpace DCI_P3
1323 * @tc.type: FUNC
1324 */
1325 HWTEST_F(ImagePixelMapTest, ImagePixelMap042, TestSize.Level3)
1326 {
1327 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap042 ApplyColorSpace start";
1328 const uint32_t dataLength = PIXEL_MAP_TEST_WIDTH * PIXEL_MAP_TEST_HEIGHT;
1329 vector<uint32_t> data(dataLength, PIXEL_MAP_TEST_PIXEL);
1330 InitializationOptions opts;
1331 opts.pixelFormat = OHOS::Media::PixelFormat::RGBA_8888;
1332 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1333 opts.size.width = PIXEL_MAP_TEST_WIDTH;
1334 opts.size.height = PIXEL_MAP_TEST_HEIGHT;
1335
1336 auto pixelmap = PixelMap::Create(data.data(), dataLength, opts);
1337 auto grColorSpace = OHOS::ColorManager::ColorSpace(OHOS::ColorManager::ColorSpaceName::SRGB);
1338 pixelmap->InnerSetColorSpace(grColorSpace);
1339 auto applyGrColorSpace = OHOS::ColorManager::ColorSpace(OHOS::ColorManager::ColorSpaceName::DCI_P3);
1340 pixelmap->ApplyColorSpace(applyGrColorSpace);
1341
1342 auto pixelZero = pixelmap->GetPixel32(POINT_ZERO, POINT_ZERO);
1343 EXPECT_EQ(*pixelZero, PIXEL_MAP_TEST_DCI_P3_PIXEL);
1344 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap042 ApplyColorSpace end";
1345 }
1346
1347 /**
1348 * @tc.name: ImagePixelMap043
1349 * @tc.desc: test ApplyColorSpace Rec.2020
1350 * @tc.type: FUNC
1351 */
1352 HWTEST_F(ImagePixelMapTest, ImagePixelMap043, TestSize.Level3)
1353 {
1354 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap043 ApplyColorSpace start";
1355 const uint32_t dataLength = PIXEL_MAP_TEST_WIDTH * PIXEL_MAP_TEST_HEIGHT;
1356 vector<uint32_t> data(dataLength, PIXEL_MAP_TEST_PIXEL);
1357 InitializationOptions opts;
1358 opts.pixelFormat = OHOS::Media::PixelFormat::RGBA_8888;
1359 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1360 opts.size.width = PIXEL_MAP_TEST_WIDTH;
1361 opts.size.height = PIXEL_MAP_TEST_HEIGHT;
1362
1363 auto pixelmap = PixelMap::Create(data.data(), dataLength, opts);
1364 auto grColorSpace = OHOS::ColorManager::ColorSpace(OHOS::ColorManager::ColorSpaceName::SRGB);
1365 pixelmap->InnerSetColorSpace(grColorSpace);
1366 auto applyGrColorSpace = OHOS::ColorManager::ColorSpace(OHOS::ColorManager::ColorSpaceName::BT2020);
1367 pixelmap->ApplyColorSpace(applyGrColorSpace);
1368
1369 auto pixelZero = pixelmap->GetPixel32(POINT_ZERO, POINT_ZERO);
1370 EXPECT_EQ(*pixelZero, PIXEL_MAP_TEST_BT2020_PIXEL);
1371 GTEST_LOG_(INFO) << "ImagePixelMapTest: ImagePixelMap043 ApplyColorSpace end";
1372 }
1373 #endif
1374
CreatePixelMapCommon(int32_t width,int32_t height)1375 std::unique_ptr<PixelMap> CreatePixelMapCommon(int32_t width, int32_t height)
1376 {
1377 const uint32_t dataLength = width * height;
1378 uint32_t *data = new uint32_t[dataLength];
1379 for (uint32_t i = 0; i < dataLength; i++) {
1380 data[i] = 0xFFFF0000;
1381 }
1382 InitializationOptions opts;
1383 opts.pixelFormat = OHOS::Media::PixelFormat::ARGB_8888;
1384 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1385 opts.size.width = width;
1386 opts.size.height = height;
1387 std::unique_ptr<PixelMap> pixelmap = PixelMap::Create(data, dataLength, opts);
1388 delete[] data;
1389 return pixelmap;
1390 }
1391
1392 /**
1393 * @tc.name: CheckPixelsInput001
1394 * @tc.desc: test CheckPixelsInput
1395 * @tc.type: FUNC
1396 */
1397 HWTEST_F(ImagePixelMapTest, CheckPixelsInput001, TestSize.Level3)
1398 {
1399 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput001 start";
1400 std::unique_ptr<PixelMap> pixelMap = CreatePixelMapCommon(8, 8);;
1401 ASSERT_NE(pixelMap.get(), nullptr);
1402
1403 uint8_t *source = nullptr;
1404 int32_t bufferSize = 0;
1405 uint32_t stride = 0;
1406 uint32_t offset = 0;
1407 struct Rect region = {0};
1408 uint32_t status = 0;
1409
1410 ImageInfo imageInfo;
1411 pixelMap->GetImageInfo(imageInfo);
1412
1413 // test source is nullptr
1414 ASSERT_EQ(source, nullptr);
1415 status = pixelMap->WritePixels(source, bufferSize, offset, stride, region);
1416 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1417
1418 // test bufferSize is 0
1419 source = static_cast<uint8_t *>(malloc(1));
1420 ASSERT_NE(source, nullptr);
1421
1422 ASSERT_EQ(bufferSize, 0);
1423 status = pixelMap->WritePixels(source, bufferSize, offset, stride, region);
1424 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1425
1426 bufferSize = pixelMap->GetByteCount();
1427 ASSERT_NE(bufferSize, 0);
1428
1429 // test region.left < 0
1430 region = {.left = -1, .top = 0, .width = imageInfo.size.width, .height = imageInfo.size.height};
1431 ASSERT_EQ(region.left < 0 ? 0 : 1, 0);
1432 status = pixelMap->WritePixels(source, bufferSize, offset, stride, region);
1433 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1434
1435 // test region.top < 0
1436 region = {.left = 0, .top = -1, .width = imageInfo.size.width, .height = imageInfo.size.height};
1437 ASSERT_NE(region.left < 0 ? 0 : 1, 0);
1438 ASSERT_EQ(region.top < 0 ? 0 : 1, 0);
1439 status = pixelMap->WritePixels(source, bufferSize, offset, stride, region);
1440 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1441
1442 free(source);
1443 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput001 end";
1444 }
1445
1446 /**
1447 * @tc.name: CheckPixelsInput002
1448 * @tc.desc: test CheckPixelsInput
1449 * @tc.type: FUNC
1450 */
1451 HWTEST_F(ImagePixelMapTest, CheckPixelsInput002, TestSize.Level3)
1452 {
1453 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput002 start";
1454 std::unique_ptr<PixelMap> pixelMap = CreatePixelMapCommon(8, 8);;
1455 ASSERT_NE(pixelMap.get(), nullptr);
1456
1457 uint8_t *source = static_cast<uint8_t *>(malloc(1));
1458 uint64_t bufferSize = static_cast<uint64_t>(pixelMap->GetByteCount());
1459 uint32_t stride = 0;
1460 uint32_t offset = 0;
1461 struct Rect region = {0};
1462 uint32_t status = 0;
1463
1464 ASSERT_NE(source, nullptr);
1465
1466 ImageInfo imageInfo;
1467 pixelMap->GetImageInfo(imageInfo);
1468
1469 region = {.left = 0, .top = 0, .width = imageInfo.size.width, .height = imageInfo.size.height};
1470 ASSERT_NE(region.left < 0 ? 0 : 1, 0);
1471 ASSERT_NE(region.top < 0 ? 0 : 1, 0);
1472
1473 // test stride > numeric_limits<int32_t>::max()
1474 stride = std::numeric_limits<uint32_t>::max();
1475 ASSERT_EQ(stride > std::numeric_limits<int32_t>::max() ? 0 : 1, 0);
1476 status = pixelMap->WritePixels(source, bufferSize, offset, stride, region);
1477 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1478
1479 stride = 0;
1480 ASSERT_NE(stride > std::numeric_limits<int32_t>::max() ? 0 : 1, 0);
1481
1482 // test static_cast<uint64_t>(offset) > bufferSize
1483 offset = static_cast<uint32_t>(bufferSize + 1);
1484 ASSERT_EQ(static_cast<uint64_t>(offset) > bufferSize ? 0 : 1, 0);
1485 status = pixelMap->WritePixels(source, bufferSize, offset, stride, region);
1486 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1487
1488 offset = 0;
1489 ASSERT_NE(static_cast<uint64_t>(offset) > bufferSize ? 0 : 1, 0);
1490 status = pixelMap->WritePixels(source, bufferSize, offset, stride, region);
1491 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1492
1493 free(source);
1494 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput002 end";
1495 }
1496
1497 /**
1498 * @tc.name: CheckPixelsInput003
1499 * @tc.desc: test CheckPixelsInput
1500 * @tc.type: FUNC
1501 */
1502 HWTEST_F(ImagePixelMapTest, CheckPixelsInput003, TestSize.Level3)
1503 {
1504 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput003 start";
1505 std::unique_ptr<PixelMap> pixelMap = CreatePixelMapCommon(8, 8);;
1506 ASSERT_NE(pixelMap.get(), nullptr);
1507 ImageInfo imageInfo;
1508 pixelMap->GetImageInfo(imageInfo);
1509
1510 uint8_t *source = static_cast<uint8_t *>(malloc(1));
1511 uint64_t bufferSize = static_cast<uint64_t>(pixelMap->GetByteCount());
1512 uint32_t stride = 0;
1513 uint32_t offset = 0;
1514 struct Rect region = {.left = 0, .top = 0, .width = imageInfo.size.width, .height = imageInfo.size.height};
1515 uint32_t status = 0;
1516
1517 ASSERT_NE(source, nullptr);
1518 ASSERT_NE(bufferSize, 0);
1519 ASSERT_NE(region.left < 0 ? 0 : 1, 0);
1520 ASSERT_NE(region.top < 0 ? 0 : 1, 0);
1521 ASSERT_NE(stride > std::numeric_limits<int32_t>::max() ? 0 : 1, 0);
1522 ASSERT_NE(static_cast<uint64_t>(offset) > bufferSize ? 0 : 1, 0);
1523 region.width = -1;
1524 ASSERT_EQ(region.width < 0 ? 0 : 1, 0);
1525 status = pixelMap->WritePixels(source, bufferSize, offset, stride, region);
1526 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1527 region.width = imageInfo.size.width;
1528 ASSERT_NE(region.width < 0 ? 0 : 1, 0);
1529 region.height = -1;
1530 ASSERT_EQ(region.height < 0 ? 0 : 1, 0);
1531 status = pixelMap->WritePixels(source, bufferSize, offset, stride, region);
1532 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1533 region.height = imageInfo.size.height;
1534 ASSERT_NE(region.height < 0 ? 0 : 1, 0);
1535 int maxDimension = INT32_MAX >> 2;
1536 region.width = maxDimension + 1;
1537 ASSERT_EQ(region.width > maxDimension ? 0 : 1, 0);
1538 status = pixelMap->WritePixels(source, bufferSize, offset, stride, region);
1539 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1540 region.width = imageInfo.size.width;
1541 ASSERT_NE(region.width > maxDimension ? 0 : 1, 0);
1542 region.height = maxDimension + 1;
1543 ASSERT_EQ(region.height > maxDimension ? 0 : 1, 0);
1544 status = pixelMap->WritePixels(source, bufferSize, offset, stride, region);
1545 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1546 region.height = imageInfo.size.height;
1547 ASSERT_NE(region.height > maxDimension ? 0 : 1, 0);
1548
1549 free(source);
1550 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput003 end";
1551 }
1552
1553 /**
1554 * @tc.name: CheckPixelsInput004
1555 * @tc.desc: test CheckPixelsInput
1556 * @tc.type: FUNC
1557 */
1558 HWTEST_F(ImagePixelMapTest, CheckPixelsInput004, TestSize.Level3)
1559 {
1560 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput004 start";
1561 std::unique_ptr<PixelMap> pixelMap = CreatePixelMapCommon(8, 8);;
1562 ASSERT_NE(pixelMap.get(), nullptr);
1563
1564 ImageInfo info;
1565 pixelMap->GetImageInfo(info);
1566
1567 uint8_t *source4 = static_cast<uint8_t *>(malloc(1));
1568 uint64_t size4 = static_cast<uint64_t>(pixelMap->GetByteCount());
1569 uint32_t stride4 = 0;
1570 uint32_t offset4 = 0;
1571 struct Rect region4 = {.left = 0, .top = 0, .width = info.size.width, .height = info.size.height};
1572 uint32_t status = 0;
1573
1574 ASSERT_NE(source4, nullptr);
1575 ASSERT_NE(size4, 0);
1576 ASSERT_NE(region4.left < 0 ? 0 : 1, 0);
1577 ASSERT_NE(region4.top < 0 ? 0 : 1, 0);
1578 ASSERT_NE(stride4 > std::numeric_limits<int32_t>::max() ? 0 : 1, 0);
1579 ASSERT_NE(static_cast<uint64_t>(offset4) > size4 ? 0 : 1, 0);
1580
1581 int maxDimension = INT32_MAX >> 2;
1582 ASSERT_NE(region4.width < 0 ? 0 : 1, 0);
1583 ASSERT_NE(region4.height < 0 ? 0 : 1, 0);
1584 ASSERT_NE(region4.width > maxDimension ? 0 : 1, 0);
1585 ASSERT_NE(region4.height > maxDimension ? 0 : 1, 0);
1586
1587 int32_t left = pixelMap->GetWidth() - region4.width;
1588 region4.left = left + 1;
1589 ASSERT_EQ(region4.left > left ? 0 : 1, 0);
1590 status = pixelMap->WritePixels(source4, size4, offset4, stride4, region4);
1591 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1592
1593 region4.left = 0;
1594 ASSERT_NE(region4.left > left ? 0 : 1, 0);
1595
1596 int32_t top = pixelMap->GetHeight() - region4.height;
1597 region4.top = top + 1;
1598 ASSERT_EQ(region4.top > top ? 0 : 1, 0);
1599 status = pixelMap->WritePixels(source4, size4, offset4, stride4, region4);
1600 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1601
1602 region4.top = 0;
1603 ASSERT_NE(region4.top > top ? 0 : 1, 0);
1604
1605 free(source4);
1606 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput004 end";
1607 }
1608
1609 /**
1610 * @tc.name: CheckPixelsInput005
1611 * @tc.desc: test CheckPixelsInput
1612 * @tc.type: FUNC
1613 */
1614 HWTEST_F(ImagePixelMapTest, CheckPixelsInput005, TestSize.Level3)
1615 {
1616 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput005 start";
1617 std::unique_ptr<PixelMap> pixelMap = CreatePixelMapCommon(8, 8);;
1618 ASSERT_NE(pixelMap.get(), nullptr);
1619
1620 ImageInfo info;
1621 pixelMap->GetImageInfo(info);
1622
1623 uint8_t *source5 = static_cast<uint8_t *>(malloc(1));
1624 uint64_t size5 = static_cast<uint64_t>(pixelMap->GetByteCount());
1625 uint32_t stride5 = 0;
1626 uint32_t offset5 = 0;
1627 struct Rect region5 = {.left = 0, .top = 0, .width = info.size.width, .height = info.size.height};
1628 uint32_t status = 0;
1629
1630 ASSERT_NE(source5, nullptr);
1631 ASSERT_NE(size5, 0);
1632 ASSERT_NE(region5.left < 0 ? 0 : 1, 0);
1633 ASSERT_NE(region5.top < 0 ? 0 : 1, 0);
1634 ASSERT_NE(stride5 > std::numeric_limits<int32_t>::max() ? 0 : 1, 0);
1635 ASSERT_NE(static_cast<uint64_t>(offset5) > size5 ? 0 : 1, 0);
1636
1637 int maxDimension = INT32_MAX >> 2;
1638 ASSERT_NE(region5.width < 0 ? 0 : 1, 0);
1639 ASSERT_NE(region5.height < 0 ? 0 : 1, 0);
1640 ASSERT_NE(region5.width > maxDimension ? 0 : 1, 0);
1641 ASSERT_NE(region5.height > maxDimension ? 0 : 1, 0);
1642
1643 ASSERT_NE(region5.left > pixelMap->GetWidth() - region5.width ? 0 : 1, 0);
1644 ASSERT_NE(region5.top > pixelMap->GetHeight() - region5.height ? 0 : 1, 0);
1645
1646 uint32_t regionStride = static_cast<uint32_t>(region5.width) * 4;
1647 stride5 = regionStride - 1;
1648 ASSERT_EQ(stride5 < regionStride ? 0 : 1, 0);
1649 status = pixelMap->WritePixels(source5, size5, offset5, stride5, region5);
1650 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1651
1652 stride5 = regionStride;
1653 ASSERT_NE(stride5 < regionStride ? 0 : 1, 0);
1654
1655 size5 = regionStride - 1;
1656 ASSERT_EQ(size5 < regionStride ? 0 : 1, 0);
1657 status = pixelMap->WritePixels(source5, size5, offset5, stride5, region5);
1658 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1659
1660 free(source5);
1661 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput005 end";
1662 }
1663
1664 /**
1665 * @tc.name: CheckPixelsInput006
1666 * @tc.desc: test CheckPixelsInput
1667 * @tc.type: FUNC
1668 */
1669 HWTEST_F(ImagePixelMapTest, CheckPixelsInput006, TestSize.Level3)
1670 {
1671 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput006 start";
1672 std::unique_ptr<PixelMap> pixelMap = CreatePixelMapCommon(8, 8);;
1673 ASSERT_NE(pixelMap.get(), nullptr);
1674 ImageInfo info;
1675 pixelMap->GetImageInfo(info);
1676
1677 uint8_t *source6 = static_cast<uint8_t *>(malloc(1));
1678 uint64_t size6 = static_cast<uint64_t>(pixelMap->GetByteCount());
1679 uint32_t stride6 = 0;
1680 uint32_t offset6 = 0;
1681 struct Rect region6 = {.left = 0, .top = 0, .width = info.size.width, .height = info.size.height};
1682 uint32_t status = 0;
1683 ASSERT_NE(source6, nullptr);
1684 ASSERT_NE(size6, 0);
1685 ASSERT_NE(region6.left < 0 ? 0 : 1, 0);
1686 ASSERT_NE(region6.top < 0 ? 0 : 1, 0);
1687 ASSERT_NE(stride6 > std::numeric_limits<int32_t>::max() ? 0 : 1, 0);
1688 ASSERT_NE(static_cast<uint64_t>(offset6) > size6 ? 0 : 1, 0);
1689
1690 int maxDimension = INT32_MAX >> 2;
1691 ASSERT_NE(region6.width < 0 ? 0 : 1, 0);
1692 ASSERT_NE(region6.height < 0 ? 0 : 1, 0);
1693 ASSERT_NE(region6.width > maxDimension ? 0 : 1, 0);
1694 ASSERT_NE(region6.height > maxDimension ? 0 : 1, 0);
1695 ASSERT_NE(region6.left > pixelMap->GetWidth() - region6.width ? 0 : 1, 0);
1696 ASSERT_NE(region6.top > pixelMap->GetHeight() - region6.height ? 0 : 1, 0);
1697 uint32_t regionStride = static_cast<uint32_t>(region6.width) * 4;
1698 stride6 = regionStride;
1699 ASSERT_NE(stride6 < regionStride ? 0 : 1, 0);
1700 ASSERT_NE(size6 < regionStride ? 0 : 1, 0);
1701 offset6 = static_cast<uint32_t>(size6 - regionStride) + 1;
1702 ASSERT_EQ(static_cast<uint64_t>(offset6) > (size6 - regionStride) ? 0 : 1, 0);
1703 status = pixelMap->WritePixels(source6, size6, offset6, stride6, region6);
1704 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1705 offset6 = 0;
1706 ASSERT_NE(static_cast<uint64_t>(offset6) > (size6 - regionStride) ? 0 : 1, 0);
1707 uint64_t lastLinePos = offset6 + static_cast<uint64_t>(region6.height - 1) * stride6;
1708 size6 = lastLinePos + regionStride - 1;
1709 ASSERT_EQ(lastLinePos > (size6 - regionStride) ? 0 : 1, 0);
1710 status = pixelMap->WritePixels(source6, size6, offset6, stride6, region6);
1711 ASSERT_EQ(status, ERR_IMAGE_INVALID_PARAMETER);
1712 size6 = static_cast<uint64_t>(pixelMap->GetByteCount());
1713 ASSERT_NE(lastLinePos > (size6 - regionStride) ? 0 : 1, 0);
1714 status = pixelMap->WritePixels(source6, size6, offset6, stride6, region6);
1715 ASSERT_NE(status, ERR_IMAGE_INVALID_PARAMETER);
1716 free(source6);
1717 GTEST_LOG_(INFO) << "ImagePixelMapTest: CheckPixelsInput006 end";
1718 }
1719
1720 /**
1721 * @tc.name: SetAlpha001
1722 * @tc.desc: test SetAlpha
1723 * @tc.type: FUNC
1724 */
1725 HWTEST_F(ImagePixelMapTest, SetAlpha001, TestSize.Level3)
1726 {
1727 GTEST_LOG_(INFO) << "ImagePixelMapTest: SetAlpha001 start";
1728 const uint32_t dataLength = 64;
1729 uint32_t data[64] = {0};
1730 InitializationOptions opts;
1731 opts.pixelFormat = OHOS::Media::PixelFormat::RGBA_F16;
1732 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
1733 opts.size.width = 8;
1734 opts.size.height = 8;
1735 std::unique_ptr<PixelMap> pixelmap = PixelMap::Create(data, dataLength, opts);
1736 ASSERT_NE(pixelmap.get(), nullptr);
1737
1738 AlphaType alphaType = pixelmap->GetAlphaType();
1739 ASSERT_NE(alphaType, AlphaType::IMAGE_ALPHA_TYPE_UNKNOWN);
1740 ASSERT_NE(alphaType, AlphaType::IMAGE_ALPHA_TYPE_OPAQUE);
1741
1742 float percent = 0.5f;
1743 ASSERT_NE(percent <= 0 ? 0 : 1, 0);
1744 ASSERT_NE(percent > 1 ? 0 : 1, 0);
1745
1746 ASSERT_EQ(pixelmap->GetPixelFormat(), PixelFormat::RGBA_F16);
1747
1748 int8_t alphaIndex = 3;
1749 ASSERT_NE(alphaIndex, -1);
1750
1751 int32_t pixelByte = pixelmap->GetPixelBytes();
1752 ASSERT_EQ(pixelByte, 8);
1753 ASSERT_NE(pixelmap->GetPixelFormat(), PixelFormat::ALPHA_8);
1754
1755 uint32_t pixelsSize = pixelmap->GetByteCount();
1756 ASSERT_EQ(pixelsSize > 0 ? 0 : 1, 0);
1757
1758 uint32_t status = pixelmap->SetAlpha(percent);
1759 ASSERT_EQ(status, SUCCESS);
1760
1761 ASSERT_EQ(alphaType, AlphaType::IMAGE_ALPHA_TYPE_PREMUL);
1762 GTEST_LOG_(INFO) << "ImagePixelMapTest: SetAlpha001 end";
1763 }
1764
1765 /**
1766 * @tc.name: SetAlpha002
1767 * @tc.desc: test SetAlpha
1768 * @tc.type: FUNC
1769 */
1770 HWTEST_F(ImagePixelMapTest, SetAlpha002, TestSize.Level3)
1771 {
1772 GTEST_LOG_(INFO) << "ImagePixelMapTest: SetAlpha002 start";
1773 const uint32_t dataLength = 64;
1774 uint32_t data[64] = {0};
1775 InitializationOptions opts;
1776 opts.pixelFormat = OHOS::Media::PixelFormat::ALPHA_8;
1777 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
1778 opts.size.width = 8;
1779 opts.size.height = 8;
1780 std::unique_ptr<PixelMap> pixelmap2 = PixelMap::Create(data, dataLength, opts);
1781 ASSERT_NE(pixelmap2.get(), nullptr);
1782
1783 AlphaType alphaType = pixelmap2->GetAlphaType();
1784 ASSERT_NE(alphaType, AlphaType::IMAGE_ALPHA_TYPE_UNKNOWN);
1785 ASSERT_NE(alphaType, AlphaType::IMAGE_ALPHA_TYPE_OPAQUE);
1786
1787 float percent = 0.8f;
1788 ASSERT_NE(percent <= 0 ? 0 : 1, 0);
1789 ASSERT_NE(percent > 1 ? 0 : 1, 0);
1790
1791 ASSERT_EQ(pixelmap2->GetPixelFormat(), PixelFormat::ALPHA_8);
1792
1793 int8_t alphaIndex = 0;
1794 ASSERT_NE(alphaIndex, -1);
1795
1796 int32_t pixelByte = pixelmap2->GetPixelBytes();
1797 ASSERT_EQ(pixelByte, 1);
1798 ASSERT_NE(pixelmap2->GetPixelFormat(), PixelFormat::RGBA_F16);
1799
1800 uint32_t pixelsSize = pixelmap2->GetByteCount();
1801 ASSERT_EQ(pixelsSize > 0 ? 0 : 1, 0);
1802
1803 uint32_t status = pixelmap2->SetAlpha(percent);
1804 ASSERT_EQ(status, 0);
1805 ASSERT_EQ(alphaType, AlphaType::IMAGE_ALPHA_TYPE_PREMUL);
1806 GTEST_LOG_(INFO) << "ImagePixelMapTest: SetAlpha002 end";
1807 }
1808
1809 /**
1810 * @tc.name: TlvEncode001
1811 * @tc.desc: test TlvEncode
1812 * @tc.type: FUNC
1813 */
1814 HWTEST_F(ImagePixelMapTest, TlvEncode001, TestSize.Level3)
1815 {
1816 GTEST_LOG_(INFO) << "ImagePixelMapTest: TlvEncode001 start";
1817 std::unique_ptr<PixelMap> pixelMap = CreatePixelMapCommon(8, 8);;
1818 ASSERT_NE(pixelMap.get(), nullptr);
1819
1820 std::vector<uint8_t> buff;
1821 bool success = pixelMap->EncodeTlv(buff);
1822 ASSERT_EQ(success, true);
1823
1824 PixelMap *pixelMap2 = PixelMap::DecodeTlv(buff);
1825 ASSERT_NE(pixelMap2, nullptr);
1826
1827 GTEST_LOG_(INFO) << "ImagePixelMapTest: TlvEncode001 end";
1828 }
1829
1830 /**
1831 * @tc.name: ImagePixelMap008
1832 * @tc.desc: RGB_888 pixel format pixel map operation
1833 * @tc.type: FUNC
1834 */
1835 HWTEST_F(ImagePixelMapTest, TransformData001, TestSize.Level3)
1836 {
1837 GTEST_LOG_(INFO) << "ImagePixelMapTest: TransformData001 start";
1838 /**
1839 * @tc.steps: step1. Set image info and alloc pixel map memory.
1840 * @tc.expected: step1. The pixel map info is correct.
1841 */
1842 int8_t bytesPerPixel = 3;
1843 int8_t rowDataSize = PIXEL_MAP_TEST_WIDTH * bytesPerPixel;
1844 ImageInfo imgInfo;
1845 imgInfo.size.width = PIXEL_MAP_TEST_WIDTH;
1846 imgInfo.size.height = PIXEL_MAP_TEST_HEIGHT;
1847 imgInfo.pixelFormat = PixelFormat::RGB_888;
1848 imgInfo.colorSpace = ColorSpace::SRGB;
1849 PixelMap pixelMap;
1850 pixelMap.SetImageInfo(imgInfo);
1851 uint32_t pixelsSize = rowDataSize * PIXEL_MAP_TEST_HEIGHT;
1852 void *buffer = malloc(pixelsSize);
1853 EXPECT_NE(buffer, nullptr);
1854 pixelMap.SetPixelsAddr(buffer, nullptr, pixelsSize, AllocatorType::HEAP_ALLOC, nullptr);
1855 TransformData transformDate = {1.5, 1.5, 0, -1, -1, -1, -1, 0, 0, false, false};
1856 pixelMap.SetTransformData(transformDate);
1857 TransformData transformDate2;
1858 pixelMap.GetTransformData(transformDate2);
1859 EXPECT_EQ(transformDate2.scaleX, transformDate.scaleX);
1860 EXPECT_EQ(transformDate2.scaleY, transformDate.scaleY);
1861 EXPECT_EQ(transformDate2.flipX, transformDate.flipX);
1862 EXPECT_EQ(transformDate2.flipY, transformDate.flipY);
1863 GTEST_LOG_(INFO) << "ImagePixelMapTest: TransformData001 end";
1864 }
1865 } // namespace Multimedia
1866 } // namespace OHOS
1867