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