1 /*
2 * Copyright 2016 The Chromium OS Authors. All rights reserved.
3 * Use of this source code is governed by a BSD-style license that can be
4 * found in the LICENSE file.
5 */
6
7 #define _GNU_SOURCE
8 #include <stdio.h>
9 #include <stdlib.h>
10
11 #include <hardware/gralloc.h>
12 #include <system/graphics.h>
13 #include <cutils/native_handle.h>
14 #include "sw_sync.h"
15
16 #define ARRAY_SIZE(A) (sizeof(A)/sizeof(*(A)))
17
18 #define CHECK(cond) do {\
19 if (!(cond)) {\
20 printf("CHECK failed in %s() %s:%d\n", __func__, __FILE__, __LINE__);\
21 return 0;\
22 }\
23 } while(0)
24
25 #define CHECK_NO_MSG(cond) do {\
26 if (!(cond)) {\
27 return 0;\
28 }\
29 } while(0)
30
31 /* Private API enumeration -- see <gralloc_drm.h> */
32 enum {
33 GRALLOC_DRM_GET_STRIDE,
34 GRALLOC_DRM_GET_FORMAT,
35 GRALLOC_DRM_GET_DIMENSIONS,
36 };
37
38 /* See <system/graphics.h> for definitions. */
39 static const uint32_t format_list[] = {
40 HAL_PIXEL_FORMAT_BGRA_8888,
41 HAL_PIXEL_FORMAT_BLOB,
42 HAL_PIXEL_FORMAT_FLEX_RGB_888,
43 HAL_PIXEL_FORMAT_FLEX_RGBA_8888,
44 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
45 HAL_PIXEL_FORMAT_RAW10,
46 HAL_PIXEL_FORMAT_RAW12,
47 HAL_PIXEL_FORMAT_RAW16,
48 HAL_PIXEL_FORMAT_RAW_OPAQUE,
49 HAL_PIXEL_FORMAT_RGB_565,
50 HAL_PIXEL_FORMAT_RGB_888,
51 HAL_PIXEL_FORMAT_RGBA_8888,
52 HAL_PIXEL_FORMAT_RGBX_8888,
53 HAL_PIXEL_FORMAT_Y16,
54 HAL_PIXEL_FORMAT_Y8,
55 HAL_PIXEL_FORMAT_YCbCr_420_888,
56 HAL_PIXEL_FORMAT_YCbCr_422_888,
57 HAL_PIXEL_FORMAT_YCbCr_422_I,
58 HAL_PIXEL_FORMAT_YCbCr_422_SP,
59 HAL_PIXEL_FORMAT_YCbCr_444_888,
60 HAL_PIXEL_FORMAT_YCrCb_420_SP,
61 HAL_PIXEL_FORMAT_YV12,
62 };
63
64 /* See <hardware/gralloc.h> for descriptions. */
65 static const uint32_t usage_list[] = {
66 GRALLOC_USAGE_CURSOR,
67 GRALLOC_USAGE_HW_RENDER,
68 GRALLOC_USAGE_HW_TEXTURE,
69 GRALLOC_USAGE_SW_READ_OFTEN,
70 GRALLOC_USAGE_SW_WRITE_OFTEN,
71 GRALLOC_USAGE_SW_READ_RARELY,
72 GRALLOC_USAGE_SW_WRITE_RARELY,
73 };
74
75 struct gralloctest {
76 buffer_handle_t handle; /* handle to the buffer */
77 int w; /* width of buffer */
78 int h; /* height of buffer */
79 int format; /* format of the buffer */
80 int usage; /* bitfield indicating usage */
81 int fence_fd; /* fence file descriptor */
82 void *vaddr; /* buffer virtual memory address */
83 int stride; /* stride in pixels */
84 struct android_ycbcr ycbcr; /* sw access for yuv buffers */
85 };
86
87 /* This function is meant to initialize the test to commonly used defaults. */
gralloctest_init(struct gralloctest * test,int w,int h,int format,int usage)88 void gralloctest_init(struct gralloctest* test, int w, int h, int format,
89 int usage)
90 {
91 test->w = w;
92 test->h = h;
93 test->format = format;
94 test->usage = usage;
95 test->fence_fd = -1;
96 test->vaddr = NULL;
97 test->ycbcr.y = NULL;
98 test->ycbcr.cb = NULL;
99 test->ycbcr.cr = NULL;
100 test->stride = 0;
101 }
102
duplicate_buffer_handle(buffer_handle_t handle)103 static native_handle_t *duplicate_buffer_handle(buffer_handle_t handle)
104 {
105 native_handle_t *hnd =
106 native_handle_create(handle->numFds, handle->numInts);
107
108 if (hnd == NULL)
109 return NULL;
110
111 const int *old_data = handle->data;
112 int *new_data = hnd->data;
113
114 int i;
115 for (i = 0; i < handle->numFds; i++) {
116 *new_data = dup(*old_data);
117 old_data++;
118 new_data++;
119 }
120
121 memcpy(new_data, old_data, sizeof(int) * handle->numInts);
122
123 return hnd;
124 }
125
126 /****************************************************************
127 * Wrappers around gralloc_module_t and alloc_device_t functions.
128 * GraphicBufferMapper/GraphicBufferAllocator could replace this
129 * in theory.
130 ***************************************************************/
131
allocate(struct alloc_device_t * device,struct gralloctest * test)132 static int allocate(struct alloc_device_t* device, struct gralloctest* test)
133 {
134 int ret;
135
136 ret = device->alloc(device, test->w, test->h, test->format, test->usage,
137 &test->handle, &test->stride);
138
139 CHECK_NO_MSG(ret == 0);
140 CHECK_NO_MSG(test->handle->version > 0);
141 CHECK_NO_MSG(test->handle->numInts >= 0);
142 CHECK_NO_MSG(test->handle->numFds >= 0);
143 CHECK_NO_MSG(test->stride >= 0);
144
145 return 1;
146 }
147
deallocate(struct alloc_device_t * device,struct gralloctest * test)148 static int deallocate(struct alloc_device_t* device, struct gralloctest* test)
149 {
150 int ret;
151 ret = device->free(device, test->handle);
152 CHECK(ret == 0);
153 return 1;
154 }
155
register_buffer(struct gralloc_module_t * module,struct gralloctest * test)156 static int register_buffer(struct gralloc_module_t* module,
157 struct gralloctest* test)
158 {
159 int ret;
160 ret = module->registerBuffer(module, test->handle);
161 return (ret == 0);
162 }
163
unregister_buffer(struct gralloc_module_t * module,struct gralloctest * test)164 static int unregister_buffer(struct gralloc_module_t* module,
165 struct gralloctest* test)
166 {
167 int ret;
168 ret = module->unregisterBuffer(module, test->handle);
169 return (ret == 0);
170 }
171
lock(struct gralloc_module_t * module,struct gralloctest * test)172 static int lock(struct gralloc_module_t* module, struct gralloctest* test)
173 {
174 int ret;
175
176 ret = module->lock(module, test->handle, test->usage, 0, 0, (test->w)/2,
177 (test->h)/2, &test->vaddr);
178
179 return (ret == 0);
180 }
181
unlock(struct gralloc_module_t * module,struct gralloctest * test)182 static int unlock(struct gralloc_module_t* module, struct gralloctest* test)
183 {
184 int ret;
185 ret = module->unlock(module, test->handle);
186 return (ret == 0);
187 }
188
lock_ycbcr(struct gralloc_module_t * module,struct gralloctest * test)189 static int lock_ycbcr(struct gralloc_module_t* module, struct gralloctest* test)
190 {
191 int ret;
192
193 ret = module->lock_ycbcr(module, test->handle, test->usage, 0, 0,
194 (test->w)/2, (test->h)/2, &test->ycbcr);
195
196 return (ret == 0);
197 }
198
lock_async(struct gralloc_module_t * module,struct gralloctest * test)199 static int lock_async(struct gralloc_module_t* module, struct gralloctest* test)
200 {
201 int ret;
202
203 ret = module->lockAsync(module, test->handle, test->usage, 0, 0,
204 (test->w)/2, (test->h)/2, &test->vaddr, test->fence_fd);
205
206 return (ret == 0);
207 }
208
unlock_async(struct gralloc_module_t * module,struct gralloctest * test)209 static int unlock_async(struct gralloc_module_t* module,
210 struct gralloctest* test)
211 {
212 int ret;
213
214 ret = module->unlockAsync(module, test->handle, &test->fence_fd);
215
216 return (ret == 0);
217 }
218
lock_async_ycbcr(struct gralloc_module_t * module,struct gralloctest * test)219 static int lock_async_ycbcr(struct gralloc_module_t* module,
220 struct gralloctest* test)
221 {
222 int ret;
223
224 ret = module->lockAsync_ycbcr(module, test->handle, test->usage,
225 0, 0, (test->w)/2, (test->h)/2, &test->ycbcr, test->fence_fd);
226
227 return (ret == 0);
228 }
229
230 /**************************************************************
231 * END WRAPPERS *
232 **************************************************************/
233
234 /* This function tests initialization of gralloc module and allocator. */
test_init_gralloc(gralloc_module_t ** module,alloc_device_t ** device)235 static int test_init_gralloc(gralloc_module_t** module, alloc_device_t** device)
236 {
237 hw_module_t const* hw_module;
238 int err;
239
240 err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &hw_module);
241 CHECK(err == 0);
242
243 gralloc_open(hw_module, device);
244 *module = (gralloc_module_t *) hw_module;
245
246 CHECK(*module);
247 CHECK(*device);
248
249 return 1;
250 }
251
test_close_allocator(alloc_device_t * device)252 static int test_close_allocator(alloc_device_t* device)
253 {
254 CHECK(gralloc_close(device) == 0);
255 return 1;
256 }
257
258 /* This function tests allocation with varying buffer dimensions. */
test_alloc_varying_sizes(struct alloc_device_t * device)259 static int test_alloc_varying_sizes(struct alloc_device_t* device)
260 {
261 struct gralloctest test;
262 int i;
263
264 gralloctest_init(&test, 0, 0, HAL_PIXEL_FORMAT_BGRA_8888,
265 GRALLOC_USAGE_SW_READ_OFTEN);
266
267 for (i = 1; i < 1920; i++) {
268 test.w = i;
269 test.h = i;
270 CHECK(allocate(device, &test));
271 CHECK(deallocate(device, &test));
272 }
273
274 test.w = 1;
275 for (i = 1; i < 1920; i++) {
276 test.h = i;
277 CHECK(allocate(device, &test));
278 CHECK(deallocate(device, &test));
279 }
280
281 test.h = 1;
282 for (i = 1; i < 1920; i++) {
283 test.w = i;
284 CHECK(allocate(device, &test));
285 CHECK(deallocate(device, &test));
286 }
287
288 return 1;
289 }
290
291 /*
292 * This function tests that we find at least one working format for each
293 * usage which we consider important.
294 */
test_alloc_usage(struct alloc_device_t * device)295 static int test_alloc_usage(struct alloc_device_t* device)
296 {
297 int i, j;
298
299 struct gralloctest test;
300 gralloctest_init(&test, 512, 512, HAL_PIXEL_FORMAT_BGRA_8888,
301 GRALLOC_USAGE_SW_READ_OFTEN);
302
303 for (i = 0; i < ARRAY_SIZE(usage_list); i++) {
304 test.usage = usage_list[i];
305 int found = 0;
306 for (j = 0; j < ARRAY_SIZE(format_list); j++) {
307 test.format = format_list[j];
308 if (allocate(device, &test))
309 if (deallocate(device, &test))
310 found = 1;
311 }
312 CHECK(found);
313 }
314
315 return 1;
316 }
317
318 /*
319 * This function tests the advertised API version.
320 * Version_0_2 added (*lock_ycbcr)() method.
321 * Version_0_3 added fence passing to/from lock/unlock.
322 */
test_api(struct gralloc_module_t * module)323 static int test_api(struct gralloc_module_t* module)
324 {
325
326 CHECK(module->registerBuffer);
327 CHECK(module->unregisterBuffer);
328 CHECK(module->lock);
329 CHECK(module->unlock);
330
331 switch (module->common.module_api_version) {
332 case GRALLOC_MODULE_API_VERSION_0_3:
333 CHECK(module->lock_ycbcr);
334 CHECK(module->lockAsync);
335 CHECK(module->unlockAsync);
336 CHECK(module->lockAsync_ycbcr);
337 break;
338 case GRALLOC_MODULE_API_VERSION_0_2:
339 CHECK(module->lock_ycbcr);
340 CHECK(module->lockAsync == NULL);
341 CHECK(module->unlockAsync == NULL);
342 CHECK(module->lockAsync_ycbcr == NULL);
343 break;
344 case GRALLOC_MODULE_API_VERSION_0_1:
345 CHECK(module->lockAsync == NULL);
346 CHECK(module->unlockAsync == NULL);
347 CHECK(module->lockAsync_ycbcr == NULL);
348 CHECK(module->lock_ycbcr == NULL);
349 break;
350 default:
351 return 0;
352 }
353
354 return 1;
355 }
356
357 /*
358 * This function registers, unregisters, locks and unlocks the buffer in
359 * various orders.
360 */
test_gralloc_order(struct gralloc_module_t * module,struct alloc_device_t * device)361 static int test_gralloc_order(struct gralloc_module_t* module,
362 struct alloc_device_t* device)
363 {
364 struct gralloctest test, duplicate;
365
366 gralloctest_init(&test, 512, 512, HAL_PIXEL_FORMAT_BGRA_8888,
367 GRALLOC_USAGE_SW_READ_OFTEN);
368
369 gralloctest_init(&duplicate, 512, 512, HAL_PIXEL_FORMAT_BGRA_8888,
370 GRALLOC_USAGE_SW_READ_OFTEN);
371
372 CHECK(allocate(device, &test));
373
374 /*
375 * Duplicate the buffer handle to simulate an additional reference
376 * in same process.
377 */
378 native_handle_t *native_handle = duplicate_buffer_handle(test.handle);
379 duplicate.handle = native_handle;
380
381 CHECK(unregister_buffer(module, &duplicate) == 0);
382 CHECK(register_buffer(module, &duplicate));
383
384 /* This should be a no-op when the buffer wasn't previously locked. */
385 CHECK(unlock(module, &duplicate));
386
387 CHECK(lock(module, &duplicate));
388 CHECK(duplicate.vaddr);
389 CHECK(unlock(module, &duplicate));
390
391 CHECK(unregister_buffer(module, &duplicate));
392
393 CHECK(register_buffer(module, &duplicate));
394 CHECK(unregister_buffer(module, &duplicate));
395 CHECK(unregister_buffer(module, &duplicate) == 0);
396
397 CHECK(register_buffer(module, &duplicate));
398 CHECK(deallocate(device, &test));
399
400 CHECK(lock(module, &duplicate));
401 CHECK(unlock(module, &duplicate));
402 CHECK(unregister_buffer(module, &duplicate));
403
404 CHECK(native_handle_close(duplicate.handle) == 0);
405 CHECK(native_handle_delete(native_handle) == 0);
406
407 return 1;
408 }
409
410 /* This function tests uninitialized buffer handles. */
test_uninitialized_handle(struct gralloc_module_t * module)411 static int test_uninitialized_handle(struct gralloc_module_t* module)
412 {
413 struct gralloctest test;
414 buffer_handle_t handle = (buffer_handle_t)(intptr_t)0xdeadbeef;
415
416 gralloctest_init(&test, 512, 512, HAL_PIXEL_FORMAT_BGRA_8888,
417 GRALLOC_USAGE_SW_READ_OFTEN);
418
419 test.handle = handle;
420
421 CHECK(register_buffer(module, &test) == 0);
422 CHECK(lock(module, &test) == 0);
423 CHECK(unlock(module, &test) == 0);
424 CHECK(unregister_buffer(module, &test) == 0);
425
426 return 1;
427 }
428
429 /* This function tests that deallocated buffer handles are invalid. */
test_freed_handle(struct gralloc_module_t * module,struct alloc_device_t * device)430 static int test_freed_handle(struct gralloc_module_t* module,
431 struct alloc_device_t* device)
432 {
433 struct gralloctest test;
434
435 gralloctest_init(&test, 512, 512, HAL_PIXEL_FORMAT_BGRA_8888,
436 GRALLOC_USAGE_SW_READ_OFTEN);
437
438 CHECK(allocate(device, &test));
439 CHECK(deallocate(device, &test));
440
441 CHECK(lock(module, &test) == 0);
442 CHECK(unlock(module, &test) == 0);
443
444 return 1;
445 }
446
447 /* This function tests CPU reads and writes. */
test_mapping(struct gralloc_module_t * module,struct alloc_device_t * device)448 static int test_mapping(struct gralloc_module_t* module,
449 struct alloc_device_t* device)
450 {
451 struct gralloctest test;
452 uint32_t* ptr = NULL;
453 uint32_t magic_number = 0x000ABBA;
454
455 gralloctest_init(&test, 512, 512, HAL_PIXEL_FORMAT_BGRA_8888,
456 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
457
458 CHECK(allocate(device, &test));
459 CHECK(lock(module, &test));
460
461 ptr = (uint32_t *) test.vaddr;
462 CHECK(ptr);
463 ptr[(test.w)/2] = magic_number;
464
465 CHECK(unlock(module, &test));
466 test.vaddr = NULL;
467 ptr = NULL;
468
469 CHECK(lock(module, &test));
470 ptr = (uint32_t *) test.vaddr;
471 CHECK(ptr);
472 CHECK(ptr[test.w/2] == magic_number);
473
474 CHECK(unlock(module, &test));
475 CHECK(deallocate(device, &test));
476
477 return 1;
478 }
479
480 /* This function tests the private API we use in ARC++ -- not part of official gralloc. */
test_perform(struct gralloc_module_t * module,struct alloc_device_t * device)481 static int test_perform(struct gralloc_module_t* module,
482 struct alloc_device_t* device)
483 {
484 struct gralloctest test;
485 uint32_t stride, width, height;
486 int32_t format;
487
488 gralloctest_init(&test, 650, 408, HAL_PIXEL_FORMAT_BGRA_8888,
489 GRALLOC_USAGE_SW_READ_OFTEN);
490
491 CHECK(allocate(device, &test));
492
493 CHECK(module->perform(module, GRALLOC_DRM_GET_STRIDE, test.handle,
494 &stride) == 0);
495 CHECK(stride == test.stride);
496
497 CHECK(module->perform(module, GRALLOC_DRM_GET_FORMAT, test.handle,
498 &format) == 0);
499 CHECK(format == test.format);
500
501 CHECK(module->perform(module, GRALLOC_DRM_GET_DIMENSIONS, test.handle,
502 &width, &height)== 0);
503 CHECK(width == test.w);
504 CHECK(height == test.h);
505
506 CHECK(deallocate(device, &test));
507
508 return 1;
509 }
510
511 /* This function tests that only YUV buffers work with *lock_ycbcr. */
test_ycbcr(struct gralloc_module_t * module,struct alloc_device_t * device)512 static int test_ycbcr(struct gralloc_module_t* module,
513 struct alloc_device_t* device)
514
515 {
516 struct gralloctest test;
517 gralloctest_init(&test, 512, 512, HAL_PIXEL_FORMAT_YCbCr_420_888,
518 GRALLOC_USAGE_SW_READ_OFTEN);
519
520 CHECK(allocate(device, &test));
521
522 CHECK(lock(module, &test) == 0);
523 CHECK(lock_ycbcr(module, &test));
524 CHECK(test.ycbcr.y);
525 CHECK(test.ycbcr.cb);
526 CHECK(test.ycbcr.cr);
527 CHECK(unlock(module, &test));
528
529 CHECK(deallocate(device, &test));
530
531 test.format = HAL_PIXEL_FORMAT_BGRA_8888;
532 CHECK(allocate(device, &test));
533
534 CHECK(lock_ycbcr(module, &test) == 0);
535 CHECK(lock(module, &test));
536 CHECK(unlock(module, &test));
537
538 CHECK(deallocate(device, &test));
539
540 return 1;
541 }
542
543 /* This function tests asynchronous locking and unlocking of buffers. */
test_async(struct gralloc_module_t * module,struct alloc_device_t * device)544 static int test_async(struct gralloc_module_t* module,
545 struct alloc_device_t* device)
546
547 {
548 struct gralloctest rgba_test, ycbcr_test;
549 int fd;
550
551 gralloctest_init(&rgba_test, 512, 512,
552 HAL_PIXEL_FORMAT_BGRA_8888, GRALLOC_USAGE_SW_READ_OFTEN);
553
554 gralloctest_init(&ycbcr_test, 512, 512,
555 HAL_PIXEL_FORMAT_YCbCr_420_888, GRALLOC_USAGE_SW_READ_OFTEN);
556
557 fd = sw_sync_timeline_create();
558 rgba_test.fence_fd = sw_sync_fence_create(fd, "fence", 1);
559 ycbcr_test.fence_fd = sw_sync_fence_create(fd, "ycbcr_fence", 2);
560
561 CHECK(allocate(device, &rgba_test));
562 CHECK(allocate(device, &ycbcr_test));
563
564 /*
565 * Buffer data should only be available after the fence has been
566 * signaled.
567 */
568 CHECK(lock_async(module, &rgba_test));
569 CHECK(lock_async_ycbcr(module, &ycbcr_test));
570
571 CHECK(rgba_test.vaddr == NULL);
572 CHECK(sw_sync_timeline_inc(fd, 1));
573 CHECK(rgba_test.vaddr);
574 CHECK(ycbcr_test.ycbcr.y == NULL);
575 CHECK(ycbcr_test.ycbcr.cb == NULL);
576 CHECK(ycbcr_test.ycbcr.cr == NULL);
577
578 CHECK(sw_sync_timeline_inc(fd, 1));
579 CHECK(ycbcr_test.ycbcr.y);
580 CHECK(ycbcr_test.ycbcr.cb);
581 CHECK(ycbcr_test.ycbcr.cr);
582
583 /*
584 * Wait on the fence returned from unlock_async and check it doesn't
585 * return an error.
586 */
587 CHECK(unlock_async(module, &rgba_test));
588 CHECK(unlock_async(module, &ycbcr_test));
589
590 CHECK(rgba_test.fence_fd > 0);
591 CHECK(ycbcr_test.fence_fd > 0);
592 CHECK(sync_wait(rgba_test.fence_fd, 10000) >= 0);
593 CHECK(sync_wait(ycbcr_test.fence_fd, 10000) >= 0);
594
595 CHECK(close(rgba_test.fence_fd) == 0);
596 CHECK(close(ycbcr_test.fence_fd) == 0);
597
598 CHECK(deallocate(device, &rgba_test));
599 CHECK(deallocate(device, &ycbcr_test));
600
601 close(fd);
602
603 return 1;
604 }
605
print_help(const char * argv0)606 static void print_help(const char* argv0)
607 {
608 printf("usage: %s <test_name>\n\n", argv0);
609 printf("A valid test is one the following:\n");
610 printf("alloc_varying_sizes\nalloc_usage\napi\ngralloc_order\n");
611 printf("uninitialized_handle\nfreed_handle\nmapping\nperform\n");
612 printf("ycbcr\nasync\n");
613 }
614
main(int argc,char * argv[])615 int main(int argc, char *argv[])
616 {
617 gralloc_module_t* module = NULL;
618 alloc_device_t* device = NULL;
619
620 setbuf(stdout, NULL);
621
622 if (argc == 2) {
623 char* name = argv[1];
624 int api;
625
626 if(!test_init_gralloc(&module, &device))
627 goto fail;
628
629 switch (module->common.module_api_version) {
630 case GRALLOC_MODULE_API_VERSION_0_3:
631 api = 3;
632 break;
633 case GRALLOC_MODULE_API_VERSION_0_2:
634 api = 2;
635 break;
636 default:
637 api = 1;
638 }
639
640 printf("[ RUN ] gralloctest.%s\n", name);
641
642 if (strcmp(name, "alloc_varying_sizes") == 0) {
643 if (!test_alloc_varying_sizes(device))
644 goto fail;
645 } else if (strcmp(name, "alloc_usage") == 0) {
646 if (!test_alloc_usage(device))
647 goto fail;
648 } else if (strcmp(name, "api") == 0) {
649 if (!test_api(module))
650 goto fail;
651 } else if (strcmp(name, "gralloc_order") == 0) {
652 if (!test_gralloc_order(module, device))
653 goto fail;
654 } else if (strcmp(name, "uninitialized_handle") == 0) {
655 if (!test_uninitialized_handle(module))
656 goto fail;
657 } else if (strcmp(name, "freed_handle") == 0) {
658 if (!test_freed_handle(module, device))
659 goto fail;
660 } else if (strcmp(name, "mapping") == 0) {
661 if (!test_mapping(module, device))
662 goto fail;
663 } else if (strcmp(name, "perform") == 0) {
664 if (!test_perform(module, device))
665 goto fail;
666 } else if (strcmp(name, "ycbcr") == 0) {
667 if (api >= 2 && !test_ycbcr(module, device))
668 goto fail;
669 } else if (strcmp(name, "async") == 0) {
670 if (api >= 3 && !test_async(module, device))
671 goto fail;
672 } else {
673 print_help(argv[0]);
674 goto fail;
675 }
676
677 if(!test_close_allocator(device))
678 goto fail;
679
680 printf("[ PASSED ] gralloctest.%s\n", name);
681 return 0;
682
683 fail:
684 printf("[ FAILED ] gralloctest.%s\n", name);
685
686 } else {
687 print_help(argv[0]);
688 }
689
690 return 0;
691 }
692