1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * efi_selftest_hii 4 * 5 * Copyright (c) 2018 AKASHI Takahiro, Linaro Limited 6 * 7 * Test HII database protocols 8 */ 9 10 #include <efi_selftest.h> 11 #include "efi_selftest_hii_data.c" 12 13 #define PRINT_TESTNAME efi_st_printf("%s:\n", __func__) 14 15 static struct efi_boot_services *boottime; 16 17 static const efi_guid_t hii_database_protocol_guid = 18 EFI_HII_DATABASE_PROTOCOL_GUID; 19 static const efi_guid_t hii_string_protocol_guid = 20 EFI_HII_STRING_PROTOCOL_GUID; 21 22 static struct efi_hii_database_protocol *hii_database_protocol; 23 static struct efi_hii_string_protocol *hii_string_protocol; 24 25 /* 26 * Setup unit test. 27 * 28 * @handle: handle of the loaded image 29 * @systable: system table 30 * 31 * @return: EFI_ST_SUCCESS for success 32 */ 33 static int setup(const efi_handle_t handle, 34 const struct efi_system_table *systable) 35 { 36 efi_status_t ret; 37 38 boottime = systable->boottime; 39 40 /* HII database protocol */ 41 ret = boottime->locate_protocol(&hii_database_protocol_guid, NULL, 42 (void **)&hii_database_protocol); 43 if (ret != EFI_SUCCESS) { 44 hii_database_protocol = NULL; 45 efi_st_error("HII database protocol is not available.\n"); 46 return EFI_ST_FAILURE; 47 } 48 49 /* HII string protocol */ 50 ret = boottime->locate_protocol(&hii_string_protocol_guid, NULL, 51 (void **)&hii_string_protocol); 52 if (ret != EFI_SUCCESS) { 53 hii_string_protocol = NULL; 54 efi_st_error("HII string protocol is not available.\n"); 55 return EFI_ST_FAILURE; 56 } 57 58 return EFI_ST_SUCCESS; 59 } 60 61 /* 62 * HII database protocol tests 63 */ 64 65 /** 66 * test_hii_database_new_package_list() - test creation and removal of 67 * package list 68 * 69 * This test adds a new package list and then tries to remove it using 70 * the provided handle. 71 * 72 * @Return: status code 73 */ 74 static int test_hii_database_new_package_list(void) 75 { 76 efi_hii_handle_t handle; 77 efi_status_t ret; 78 79 PRINT_TESTNAME; 80 ret = hii_database_protocol->new_package_list(hii_database_protocol, 81 (struct efi_hii_package_list_header *)packagelist1, 82 NULL, &handle); 83 if (ret != EFI_SUCCESS || !handle) { 84 efi_st_error("new_package_list returned %u\n", 85 (unsigned int)ret); 86 return EFI_ST_FAILURE; 87 } 88 89 ret = hii_database_protocol->remove_package_list(hii_database_protocol, 90 handle); 91 if (ret != EFI_SUCCESS) { 92 efi_st_error("remove_package_list returned %u\n", 93 (unsigned int)ret); 94 return EFI_ST_FAILURE; 95 } 96 97 return EFI_ST_SUCCESS; 98 } 99 100 /** 101 * test_hii_database_update_package_list() - test update of package list 102 * 103 * This test adds a new package list and then tries to update it using 104 * another package list. 105 * 106 * @Return: status code 107 */ 108 static int test_hii_database_update_package_list(void) 109 { 110 efi_hii_handle_t handle = NULL; 111 efi_status_t ret; 112 int result = EFI_ST_FAILURE; 113 114 PRINT_TESTNAME; 115 ret = hii_database_protocol->new_package_list(hii_database_protocol, 116 (struct efi_hii_package_list_header *)packagelist1, 117 NULL, &handle); 118 if (ret != EFI_SUCCESS || !handle) { 119 efi_st_error("new_package_list returned %u\n", 120 (unsigned int)ret); 121 return EFI_ST_FAILURE; 122 } 123 124 ret = hii_database_protocol->update_package_list(hii_database_protocol, 125 handle, 126 (struct efi_hii_package_list_header *)packagelist2); 127 if (ret != EFI_SUCCESS || !handle) { 128 efi_st_error("new_package_list returned %u\n", 129 (unsigned int)ret); 130 goto out; 131 } 132 133 result = EFI_ST_SUCCESS; 134 135 out: 136 if (handle) { 137 ret = hii_database_protocol->remove_package_list( 138 hii_database_protocol, handle); 139 if (ret != EFI_SUCCESS) { 140 efi_st_error("remove_package_list returned %u\n", 141 (unsigned int)ret); 142 return EFI_ST_FAILURE; 143 } 144 } 145 146 return result; 147 } 148 149 /** 150 * test_hii_database_list_package_lists() - test listing of package lists 151 * 152 * This test adds two package lists and then tries to enumerate them 153 * against different package types. We will get an array of handles. 154 * 155 * @Return: status code 156 */ 157 static int test_hii_database_list_package_lists(void) 158 { 159 efi_hii_handle_t handle1 = NULL, handle2 = NULL, *handles; 160 efi_uintn_t handles_size; 161 efi_status_t ret; 162 int result = EFI_ST_FAILURE; 163 164 PRINT_TESTNAME; 165 ret = hii_database_protocol->new_package_list(hii_database_protocol, 166 (struct efi_hii_package_list_header *)packagelist1, 167 NULL, &handle1); 168 if (ret != EFI_SUCCESS || !handle1) { 169 efi_st_error("new_package_list returned %u\n", 170 (unsigned int)ret); 171 goto out; 172 } 173 174 ret = hii_database_protocol->new_package_list(hii_database_protocol, 175 (struct efi_hii_package_list_header *)packagelist2, 176 NULL, &handle2); 177 if (ret != EFI_SUCCESS || !handle2) { 178 efi_st_error("new_package_list returned %u\n", 179 (unsigned int)ret); 180 goto out; 181 } 182 183 /* TYPE_ALL */ 184 handles = NULL; 185 handles_size = 0; 186 ret = hii_database_protocol->list_package_lists(hii_database_protocol, 187 EFI_HII_PACKAGE_TYPE_ALL, NULL, 188 &handles_size, handles); 189 if (ret != EFI_BUFFER_TOO_SMALL) { 190 efi_st_error("list_package_lists returned %u\n", 191 (unsigned int)ret); 192 goto out; 193 } 194 ret = boottime->allocate_pool(EFI_LOADER_DATA, handles_size, 195 (void **)&handles); 196 if (ret != EFI_SUCCESS) { 197 efi_st_error("AllocatePool failed\n"); 198 goto out; 199 } 200 ret = hii_database_protocol->list_package_lists(hii_database_protocol, 201 EFI_HII_PACKAGE_TYPE_ALL, NULL, 202 &handles_size, handles); 203 if (ret != EFI_SUCCESS) { 204 efi_st_error("list_package_lists returned %u\n", 205 (unsigned int)ret); 206 goto out; 207 } 208 ret = boottime->free_pool(handles); 209 if (ret != EFI_SUCCESS) { 210 efi_st_error("FreePool failed\n"); 211 goto out; 212 } 213 214 /* STRINGS */ 215 handles = NULL; 216 handles_size = 0; 217 ret = hii_database_protocol->list_package_lists(hii_database_protocol, 218 EFI_HII_PACKAGE_STRINGS, NULL, 219 &handles_size, handles); 220 if (ret != EFI_BUFFER_TOO_SMALL) { 221 efi_st_error("list_package_lists returned %u\n", 222 (unsigned int)ret); 223 ret = EFI_ST_FAILURE; 224 goto out; 225 } 226 ret = boottime->allocate_pool(EFI_LOADER_DATA, handles_size, 227 (void **)&handles); 228 if (ret != EFI_SUCCESS) { 229 efi_st_error("AllocatePool failed\n"); 230 ret = EFI_ST_FAILURE; 231 goto out; 232 } 233 ret = hii_database_protocol->list_package_lists(hii_database_protocol, 234 EFI_HII_PACKAGE_STRINGS, NULL, 235 &handles_size, handles); 236 if (ret != EFI_SUCCESS) { 237 efi_st_error("list_package_lists returned %u\n", 238 (unsigned int)ret); 239 ret = EFI_ST_FAILURE; 240 goto out; 241 } 242 ret = boottime->free_pool(handles); 243 if (ret != EFI_SUCCESS) { 244 efi_st_error("FreePool failed\n"); 245 goto out; 246 } 247 248 /* GUID */ 249 handles = NULL; 250 handles_size = 0; 251 ret = hii_database_protocol->list_package_lists(hii_database_protocol, 252 EFI_HII_PACKAGE_TYPE_GUID, &package_guid, 253 &handles_size, handles); 254 if (ret != EFI_BUFFER_TOO_SMALL) { 255 efi_st_error("list_package_lists returned %u\n", 256 (unsigned int)ret); 257 ret = EFI_ST_FAILURE; 258 goto out; 259 } 260 ret = boottime->allocate_pool(EFI_LOADER_DATA, handles_size, 261 (void **)&handles); 262 if (ret != EFI_SUCCESS) { 263 efi_st_error("AllocatePool failed\n"); 264 ret = EFI_ST_FAILURE; 265 goto out; 266 } 267 ret = hii_database_protocol->list_package_lists(hii_database_protocol, 268 EFI_HII_PACKAGE_TYPE_GUID, &package_guid, 269 &handles_size, handles); 270 if (ret != EFI_SUCCESS) { 271 efi_st_error("list_package_lists returned %u\n", 272 (unsigned int)ret); 273 ret = EFI_ST_FAILURE; 274 goto out; 275 } 276 ret = boottime->free_pool(handles); 277 if (ret != EFI_SUCCESS) { 278 efi_st_error("FreePool failed\n"); 279 ret = EFI_ST_FAILURE; 280 goto out; 281 } 282 283 /* KEYBOARD_LAYOUT */ 284 handles = NULL; 285 handles_size = 0; 286 ret = hii_database_protocol->list_package_lists(hii_database_protocol, 287 EFI_HII_PACKAGE_KEYBOARD_LAYOUT, NULL, 288 &handles_size, handles); 289 if (ret != EFI_BUFFER_TOO_SMALL) { 290 efi_st_error("list_package_lists returned %u\n", 291 (unsigned int)ret); 292 ret = EFI_ST_FAILURE; 293 goto out; 294 } 295 ret = boottime->allocate_pool(EFI_LOADER_DATA, handles_size, 296 (void **)&handles); 297 if (ret != EFI_SUCCESS) { 298 efi_st_error("AllocatePool failed\n"); 299 ret = EFI_ST_FAILURE; 300 goto out; 301 } 302 ret = hii_database_protocol->list_package_lists(hii_database_protocol, 303 EFI_HII_PACKAGE_KEYBOARD_LAYOUT, NULL, 304 &handles_size, handles); 305 if (ret != EFI_SUCCESS) { 306 efi_st_error("list_package_lists returned %u\n", 307 (unsigned int)ret); 308 ret = EFI_ST_FAILURE; 309 goto out; 310 } 311 ret = boottime->free_pool(handles); 312 if (ret != EFI_SUCCESS) { 313 efi_st_error("FreePool failed\n"); 314 ret = EFI_ST_FAILURE; 315 goto out; 316 } 317 318 result = EFI_ST_SUCCESS; 319 320 out: 321 if (handle1) { 322 ret = hii_database_protocol->remove_package_list( 323 hii_database_protocol, handle1); 324 if (ret != EFI_SUCCESS) 325 efi_st_error("remove_package_list returned %u\n", 326 (unsigned int)ret); 327 } 328 if (handle2) { 329 ret = hii_database_protocol->remove_package_list( 330 hii_database_protocol, handle2); 331 if (ret != EFI_SUCCESS) 332 efi_st_error("remove_package_list returned %u\n", 333 (unsigned int)ret); 334 } 335 336 return result; 337 } 338 339 /** 340 * test_hii_database_export_package_lists() - test export of package lists 341 * 342 * @Return: status code 343 */ 344 static int test_hii_database_export_package_lists(void) 345 { 346 PRINT_TESTNAME; 347 /* export_package_lists() not implemented yet */ 348 return EFI_ST_SUCCESS; 349 } 350 351 /** 352 * test_hii_database_register_package_notify() - test registration of 353 * notification function 354 * 355 * @Return: status code 356 */ 357 static int test_hii_database_register_package_notify(void) 358 { 359 PRINT_TESTNAME; 360 /* register_package_notify() not implemented yet */ 361 return EFI_ST_SUCCESS; 362 } 363 364 /** 365 * test_hii_database_unregister_package_notify() - test removal of 366 * notification function 367 * 368 * @Return: status code 369 */ 370 static int test_hii_database_unregister_package_notify(void) 371 { 372 PRINT_TESTNAME; 373 /* unregsiter_package_notify() not implemented yet */ 374 return EFI_ST_SUCCESS; 375 } 376 377 /** 378 * test_hii_database_find_keyboard_layouts() - test listing of 379 * all the keyboard layouts in the system 380 * 381 * This test adds two package lists, each of which has two keyboard layouts 382 * and then tries to enumerate them. We will get an array of handles. 383 * 384 * @Return: status code 385 */ 386 static int test_hii_database_find_keyboard_layouts(void) 387 { 388 efi_hii_handle_t handle1 = NULL, handle2 = NULL; 389 efi_guid_t *guids; 390 u16 guids_size; 391 efi_status_t ret; 392 int result = EFI_ST_FAILURE; 393 394 PRINT_TESTNAME; 395 ret = hii_database_protocol->new_package_list(hii_database_protocol, 396 (struct efi_hii_package_list_header *)packagelist1, 397 NULL, &handle1); 398 if (ret != EFI_SUCCESS || !handle1) { 399 efi_st_error("new_package_list returned %u\n", 400 (unsigned int)ret); 401 goto out; 402 } 403 404 ret = hii_database_protocol->new_package_list(hii_database_protocol, 405 (struct efi_hii_package_list_header *)packagelist2, 406 NULL, &handle2); 407 if (ret != EFI_SUCCESS || !handle2) { 408 efi_st_error("new_package_list returned %u\n", 409 (unsigned int)ret); 410 goto out; 411 } 412 413 guids = NULL; 414 guids_size = 0; 415 ret = hii_database_protocol->find_keyboard_layouts( 416 hii_database_protocol, &guids_size, guids); 417 if (ret != EFI_BUFFER_TOO_SMALL) { 418 efi_st_error("find_keyboard_layouts returned %u\n", 419 (unsigned int)ret); 420 goto out; 421 } 422 ret = boottime->allocate_pool(EFI_LOADER_DATA, guids_size, 423 (void **)&guids); 424 if (ret != EFI_SUCCESS) { 425 efi_st_error("AllocatePool failed\n"); 426 goto out; 427 } 428 ret = hii_database_protocol->find_keyboard_layouts( 429 hii_database_protocol, &guids_size, guids); 430 if (ret != EFI_SUCCESS) { 431 efi_st_error("find_keyboard_layouts returned %u\n", 432 (unsigned int)ret); 433 goto out; 434 } 435 ret = boottime->free_pool(guids); 436 if (ret != EFI_SUCCESS) { 437 efi_st_error("FreePool failed\n"); 438 goto out; 439 } 440 441 result = EFI_ST_SUCCESS; 442 443 out: 444 if (handle1) { 445 ret = hii_database_protocol->remove_package_list( 446 hii_database_protocol, handle1); 447 if (ret != EFI_SUCCESS) 448 efi_st_error("remove_package_list returned %u\n", 449 (unsigned int)ret); 450 } 451 if (handle2) { 452 ret = hii_database_protocol->remove_package_list( 453 hii_database_protocol, handle2); 454 if (ret != EFI_SUCCESS) 455 efi_st_error("remove_package_list returned %u\n", 456 (unsigned int)ret); 457 } 458 459 return result; 460 } 461 462 /** 463 * test_hii_database_get_keyboard_layout() - test retrieval of keyboard layout 464 * 465 * This test adds two package lists, each of which has two keyboard layouts 466 * and then tries to get a handle to keyboard layout with a specific guid 467 * and the current one. 468 * 469 * @Return: status code 470 */ 471 static int test_hii_database_get_keyboard_layout(void) 472 { 473 efi_hii_handle_t handle1 = NULL, handle2 = NULL; 474 struct efi_hii_keyboard_layout *kb_layout; 475 u16 kb_layout_size; 476 efi_status_t ret; 477 int result = EFI_ST_FAILURE; 478 479 PRINT_TESTNAME; 480 ret = hii_database_protocol->new_package_list(hii_database_protocol, 481 (struct efi_hii_package_list_header *)packagelist1, 482 NULL, &handle1); 483 if (ret != EFI_SUCCESS || !handle1) { 484 efi_st_error("new_package_list returned %u\n", 485 (unsigned int)ret); 486 goto out; 487 } 488 489 ret = hii_database_protocol->new_package_list(hii_database_protocol, 490 (struct efi_hii_package_list_header *)packagelist2, 491 NULL, &handle2); 492 if (ret != EFI_SUCCESS || !handle2) { 493 efi_st_error("new_package_list returned %u\n", 494 (unsigned int)ret); 495 goto out; 496 } 497 498 /* specific keyboard_layout(guid11) */ 499 kb_layout = NULL; 500 kb_layout_size = 0; 501 ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol, 502 &kb_layout_guid11, &kb_layout_size, kb_layout); 503 if (ret != EFI_BUFFER_TOO_SMALL) { 504 efi_st_error("get_keyboard_layout returned %u\n", 505 (unsigned int)ret); 506 goto out; 507 } 508 ret = boottime->allocate_pool(EFI_LOADER_DATA, kb_layout_size, 509 (void **)&kb_layout); 510 if (ret != EFI_SUCCESS) { 511 efi_st_error("AllocatePool failed\n"); 512 goto out; 513 } 514 ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol, 515 &kb_layout_guid11, &kb_layout_size, kb_layout); 516 if (ret != EFI_SUCCESS) { 517 efi_st_error("get_keyboard_layout returned %u\n", 518 (unsigned int)ret); 519 goto out; 520 } 521 ret = boottime->free_pool(kb_layout); 522 if (ret != EFI_SUCCESS) { 523 efi_st_error("FreePool failed\n"); 524 goto out; 525 } 526 527 /* current */ 528 kb_layout = NULL; 529 kb_layout_size = 0; 530 ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol, 531 NULL, &kb_layout_size, kb_layout); 532 if (ret != EFI_INVALID_PARAMETER) { 533 efi_st_error("get_keyboard_layout returned %u\n", 534 (unsigned int)ret); 535 goto out; 536 } 537 538 result = EFI_ST_SUCCESS; 539 540 out: 541 if (handle1) { 542 ret = hii_database_protocol->remove_package_list( 543 hii_database_protocol, handle1); 544 if (ret != EFI_SUCCESS) 545 efi_st_error("remove_package_list returned %u\n", 546 (unsigned int)ret); 547 } 548 if (handle2) { 549 ret = hii_database_protocol->remove_package_list( 550 hii_database_protocol, handle2); 551 if (ret != EFI_SUCCESS) 552 efi_st_error("remove_package_list returned %u\n", 553 (unsigned int)ret); 554 } 555 556 return result; 557 } 558 559 /** 560 * test_hii_database_set_keyboard_layout() - test change of 561 * current keyboard layout 562 * 563 * @Return: status code 564 */ 565 static int test_hii_database_set_keyboard_layout(void) 566 { 567 PRINT_TESTNAME; 568 /* set_keyboard_layout() not implemented yet */ 569 return EFI_ST_SUCCESS; 570 } 571 572 /** 573 * test_hii_database_get_package_list_handle() - test retrieval of 574 * driver associated with a package list 575 * 576 * This test adds a package list, and then tries to get a handle to driver 577 * which is associated with a package list. 578 * 579 * @Return: status code 580 */ 581 static int test_hii_database_get_package_list_handle(void) 582 { 583 efi_hii_handle_t handle = NULL; 584 efi_handle_t driver_handle; 585 efi_status_t ret; 586 int result = EFI_ST_FAILURE; 587 588 PRINT_TESTNAME; 589 driver_handle = (efi_handle_t)0x12345678; /* dummy */ 590 ret = hii_database_protocol->new_package_list(hii_database_protocol, 591 (struct efi_hii_package_list_header *)packagelist1, 592 driver_handle, &handle); 593 if (ret != EFI_SUCCESS || !handle) { 594 efi_st_error("new_package_list returned %u\n", 595 (unsigned int)ret); 596 return EFI_ST_FAILURE; 597 } 598 599 driver_handle = NULL; 600 ret = hii_database_protocol->get_package_list_handle( 601 hii_database_protocol, handle, &driver_handle); 602 if (ret != EFI_SUCCESS || driver_handle != (efi_handle_t)0x12345678) { 603 efi_st_error("get_package_list_handle returned %u, driver:%p\n", 604 (unsigned int)ret, driver_handle); 605 goto out; 606 } 607 608 result = EFI_ST_SUCCESS; 609 610 out: 611 if (handle) { 612 ret = hii_database_protocol->remove_package_list( 613 hii_database_protocol, handle); 614 if (ret != EFI_SUCCESS) { 615 efi_st_error("remove_package_list returned %u\n", 616 (unsigned int)ret); 617 return EFI_ST_FAILURE; 618 } 619 } 620 621 return result; 622 } 623 624 static int test_hii_database_protocol(void) 625 { 626 int ret; 627 628 ret = test_hii_database_new_package_list(); 629 if (ret != EFI_ST_SUCCESS) 630 return EFI_ST_FAILURE; 631 632 ret = test_hii_database_update_package_list(); 633 if (ret != EFI_ST_SUCCESS) 634 return EFI_ST_FAILURE; 635 636 ret = test_hii_database_list_package_lists(); 637 if (ret != EFI_ST_SUCCESS) 638 return EFI_ST_FAILURE; 639 640 ret = test_hii_database_export_package_lists(); 641 if (ret != EFI_ST_SUCCESS) 642 return EFI_ST_FAILURE; 643 644 ret = test_hii_database_register_package_notify(); 645 if (ret != EFI_ST_SUCCESS) 646 return EFI_ST_FAILURE; 647 648 ret = test_hii_database_unregister_package_notify(); 649 if (ret != EFI_ST_SUCCESS) 650 return EFI_ST_FAILURE; 651 652 ret = test_hii_database_find_keyboard_layouts(); 653 if (ret != EFI_ST_SUCCESS) 654 return EFI_ST_FAILURE; 655 656 ret = test_hii_database_get_keyboard_layout(); 657 if (ret != EFI_ST_SUCCESS) 658 return EFI_ST_FAILURE; 659 660 ret = test_hii_database_set_keyboard_layout(); 661 if (ret != EFI_ST_SUCCESS) 662 return EFI_ST_FAILURE; 663 664 ret = test_hii_database_get_package_list_handle(); 665 if (ret != EFI_ST_SUCCESS) 666 return EFI_ST_FAILURE; 667 668 return EFI_ST_SUCCESS; 669 } 670 671 /* 672 * HII string protocol tests 673 */ 674 675 /** 676 * test_hii_string_new_string() - test creation of a new string entry 677 * 678 * This test adds a package list, and then tries to add a new string 679 * entry for a specific language. 680 * 681 * @Return: status code 682 */ 683 static int test_hii_string_new_string(void) 684 { 685 efi_hii_handle_t handle = NULL; 686 efi_string_id_t id; 687 efi_status_t ret; 688 int result = EFI_ST_FAILURE; 689 690 PRINT_TESTNAME; 691 ret = hii_database_protocol->new_package_list(hii_database_protocol, 692 (struct efi_hii_package_list_header *)packagelist1, 693 NULL, &handle); 694 if (ret != EFI_SUCCESS || !handle) { 695 efi_st_error("new_package_list returned %u\n", 696 (unsigned int)ret); 697 return EFI_ST_FAILURE; 698 } 699 700 ret = hii_string_protocol->new_string(hii_string_protocol, handle, 701 &id, (u8 *)"en-US", 702 L"Japanese", L"Japanese", NULL); 703 if (ret != EFI_SUCCESS) { 704 efi_st_error("new_string returned %u\n", 705 (unsigned int)ret); 706 goto out; 707 } 708 efi_st_printf("new string id is %u\n", id); 709 710 result = EFI_ST_SUCCESS; 711 712 out: 713 if (handle) { 714 ret = hii_database_protocol->remove_package_list( 715 hii_database_protocol, handle); 716 if (ret != EFI_SUCCESS) { 717 efi_st_error("remove_package_list returned %u\n", 718 (unsigned int)ret); 719 return EFI_ST_FAILURE; 720 } 721 } 722 723 return result; 724 } 725 726 /** 727 * test_hii_string_get_string() - test retrieval of a string entry 728 * 729 * This test adds a package list, create a new string entry and then tries 730 * to get it with its string id. 731 * 732 * @Return: status code 733 */ 734 static int test_hii_string_get_string(void) 735 { 736 efi_hii_handle_t handle = NULL; 737 efi_string_id_t id; 738 efi_string_t string; 739 efi_uintn_t string_len; 740 efi_status_t ret; 741 int result = EFI_ST_FAILURE; 742 743 PRINT_TESTNAME; 744 ret = hii_database_protocol->new_package_list(hii_database_protocol, 745 (struct efi_hii_package_list_header *)packagelist1, 746 NULL, &handle); 747 if (ret != EFI_SUCCESS || !handle) { 748 efi_st_error("new_package_list returned %u\n", 749 (unsigned int)ret); 750 return EFI_ST_FAILURE; 751 } 752 753 ret = hii_string_protocol->new_string(hii_string_protocol, handle, 754 &id, (u8 *)"en-US", 755 L"Japanese", L"Japanese", NULL); 756 if (ret != EFI_SUCCESS) { 757 efi_st_error("new_string returned %u\n", 758 (unsigned int)ret); 759 goto out; 760 } 761 762 string = NULL; 763 string_len = 0; 764 ret = hii_string_protocol->get_string(hii_string_protocol, 765 (u8 *)"en-US", handle, id, string, &string_len, NULL); 766 if (ret != EFI_BUFFER_TOO_SMALL) { 767 efi_st_error("get_string returned %u\n", 768 (unsigned int)ret); 769 goto out; 770 } 771 string_len += sizeof(u16); 772 ret = boottime->allocate_pool(EFI_LOADER_DATA, string_len, 773 (void **)&string); 774 if (ret != EFI_SUCCESS) { 775 efi_st_error("AllocatePool failed\n"); 776 goto out; 777 } 778 ret = hii_string_protocol->get_string(hii_string_protocol, 779 (u8 *)"en-US", handle, id, string, &string_len, NULL); 780 if (ret != EFI_SUCCESS) { 781 efi_st_error("get_string returned %u\n", 782 (unsigned int)ret); 783 goto out; 784 } 785 786 if (efi_st_strcmp_16_8(string, "Japanese")) { 787 efi_st_error("get_string returned incorrect string\n"); 788 goto out; 789 } 790 791 result = EFI_ST_SUCCESS; 792 793 out: 794 if (handle) { 795 ret = hii_database_protocol->remove_package_list( 796 hii_database_protocol, handle); 797 if (ret != EFI_SUCCESS) { 798 efi_st_error("remove_package_list returned %u\n", 799 (unsigned int)ret); 800 return EFI_ST_FAILURE; 801 } 802 } 803 804 return result; 805 } 806 807 /** 808 * test_hii_string_set_string() - test change of a string entry 809 * 810 * This test adds a package list, create a new string entry and then tries 811 * to modify it. 812 * 813 * @Return: status code 814 */ 815 static int test_hii_string_set_string(void) 816 { 817 efi_hii_handle_t handle = NULL; 818 efi_string_id_t id; 819 efi_status_t ret; 820 int result = EFI_ST_FAILURE; 821 822 PRINT_TESTNAME; 823 ret = hii_database_protocol->new_package_list(hii_database_protocol, 824 (struct efi_hii_package_list_header *)packagelist1, 825 NULL, &handle); 826 if (ret != EFI_SUCCESS || !handle) { 827 efi_st_error("new_package_list returned %u\n", 828 (unsigned int)ret); 829 return EFI_ST_FAILURE; 830 } 831 832 ret = hii_string_protocol->new_string(hii_string_protocol, handle, 833 &id, (u8 *)"en-US", 834 L"Japanese", L"Japanese", NULL); 835 if (ret != EFI_SUCCESS) { 836 efi_st_error("new_string returned %u\n", 837 (unsigned int)ret); 838 goto out; 839 } 840 841 ret = hii_string_protocol->set_string(hii_string_protocol, handle, 842 id, (u8 *)"en-US", 843 L"Nihongo", NULL); 844 if (ret != EFI_SUCCESS) { 845 efi_st_error("set_string returned %u\n", 846 (unsigned int)ret); 847 goto out; 848 } 849 850 result = EFI_ST_SUCCESS; 851 852 out: 853 if (handle) { 854 ret = hii_database_protocol->remove_package_list( 855 hii_database_protocol, handle); 856 if (ret != EFI_SUCCESS) { 857 efi_st_error("remove_package_list returned %u\n", 858 (unsigned int)ret); 859 return EFI_ST_FAILURE; 860 } 861 } 862 863 return result; 864 } 865 866 /** 867 * test_hii_string_get_languages() - test listing of languages 868 * 869 * This test adds a package list, and then tries to enumerate languages 870 * in it. We will get an string of language names. 871 * 872 * @Return: status code 873 */ 874 static int test_hii_string_get_languages(void) 875 { 876 efi_hii_handle_t handle = NULL; 877 u8 *languages; 878 efi_uintn_t languages_len; 879 efi_status_t ret; 880 int result = EFI_ST_FAILURE; 881 882 PRINT_TESTNAME; 883 ret = hii_database_protocol->new_package_list(hii_database_protocol, 884 (struct efi_hii_package_list_header *)packagelist1, 885 NULL, &handle); 886 if (ret != EFI_SUCCESS || !handle) { 887 efi_st_error("new_package_list returned %u\n", 888 (unsigned int)ret); 889 return EFI_ST_FAILURE; 890 } 891 892 languages = NULL; 893 languages_len = 0; 894 ret = hii_string_protocol->get_languages(hii_string_protocol, handle, 895 languages, &languages_len); 896 if (ret != EFI_BUFFER_TOO_SMALL) { 897 efi_st_error("get_languages returned %u\n", 898 (unsigned int)ret); 899 goto out; 900 } 901 ret = boottime->allocate_pool(EFI_LOADER_DATA, languages_len, 902 (void **)&languages); 903 if (ret != EFI_SUCCESS) { 904 efi_st_error("AllocatePool failed\n"); 905 goto out; 906 } 907 ret = hii_string_protocol->get_languages(hii_string_protocol, handle, 908 languages, &languages_len); 909 if (ret != EFI_SUCCESS) { 910 efi_st_error("get_languages returned %u\n", 911 (unsigned int)ret); 912 goto out; 913 } 914 915 efi_st_printf("got languages are %s\n", languages); 916 917 result = EFI_ST_SUCCESS; 918 919 out: 920 if (handle) { 921 ret = hii_database_protocol->remove_package_list( 922 hii_database_protocol, handle); 923 if (ret != EFI_SUCCESS) { 924 efi_st_error("remove_package_list returned %u\n", 925 (unsigned int)ret); 926 return EFI_ST_FAILURE; 927 } 928 } 929 930 return result; 931 } 932 933 /** 934 * test_hii_string_get_secondary_languages() - test listing of secondary 935 * languages 936 * 937 * This test adds a package list, and then tries to enumerate secondary 938 * languages with a specific language. We will get an string of language names. 939 * 940 * @Return: status code 941 */ 942 static int test_hii_string_get_secondary_languages(void) 943 { 944 efi_hii_handle_t handle = NULL; 945 u8 *languages; 946 efi_uintn_t languages_len; 947 efi_status_t ret; 948 int result = EFI_ST_FAILURE; 949 950 PRINT_TESTNAME; 951 ret = hii_database_protocol->new_package_list(hii_database_protocol, 952 (struct efi_hii_package_list_header *)packagelist1, 953 NULL, &handle); 954 if (ret != EFI_SUCCESS || !handle) { 955 efi_st_error("new_package_list returned %u\n", 956 (unsigned int)ret); 957 return EFI_ST_FAILURE; 958 } 959 960 languages = NULL; 961 languages_len = 0; 962 ret = hii_string_protocol->get_secondary_languages(hii_string_protocol, 963 handle, (u8 *)"en-US", languages, &languages_len); 964 if (ret == EFI_NOT_FOUND) { 965 efi_st_printf("no secondary languages\n"); 966 result = EFI_ST_SUCCESS; 967 goto out; 968 } 969 if (ret != EFI_BUFFER_TOO_SMALL) { 970 efi_st_error("get_secondary_languages returned %u\n", 971 (unsigned int)ret); 972 goto out; 973 } 974 ret = boottime->allocate_pool(EFI_LOADER_DATA, languages_len, 975 (void **)&languages); 976 if (ret != EFI_SUCCESS) { 977 efi_st_error("AllocatePool failed\n"); 978 goto out; 979 } 980 ret = hii_string_protocol->get_secondary_languages(hii_string_protocol, 981 handle, (u8 *)"en-US", languages, &languages_len); 982 if (ret != EFI_SUCCESS) { 983 efi_st_error("get_secondary_languages returned %u\n", 984 (unsigned int)ret); 985 goto out; 986 } 987 988 efi_st_printf("got secondary languages are %s\n", languages); 989 990 result = EFI_ST_SUCCESS; 991 992 out: 993 if (handle) { 994 ret = hii_database_protocol->remove_package_list( 995 hii_database_protocol, handle); 996 if (ret != EFI_SUCCESS) { 997 efi_st_error("remove_package_list returned %u\n", 998 (unsigned int)ret); 999 return EFI_ST_FAILURE; 1000 } 1001 } 1002 1003 return result; 1004 } 1005 1006 static int test_hii_string_protocol(void) 1007 { 1008 int ret; 1009 1010 ret = test_hii_string_new_string(); 1011 if (ret != EFI_ST_SUCCESS) 1012 return EFI_ST_FAILURE; 1013 1014 ret = test_hii_string_get_string(); 1015 if (ret != EFI_ST_SUCCESS) 1016 return EFI_ST_FAILURE; 1017 1018 ret = test_hii_string_set_string(); 1019 if (ret != EFI_ST_SUCCESS) 1020 return EFI_ST_FAILURE; 1021 1022 ret = test_hii_string_get_languages(); 1023 if (ret != EFI_ST_SUCCESS) 1024 return EFI_ST_FAILURE; 1025 1026 ret = test_hii_string_get_secondary_languages(); 1027 if (ret != EFI_ST_SUCCESS) 1028 return EFI_ST_FAILURE; 1029 1030 return EFI_ST_SUCCESS; 1031 } 1032 1033 /* 1034 * Execute unit test. 1035 * 1036 * @return: EFI_ST_SUCCESS for success, EFI_ST_FAILURE for failure 1037 */ 1038 static int execute(void) 1039 { 1040 int ret; 1041 1042 /* HII database protocol */ 1043 ret = test_hii_database_protocol(); 1044 if (ret != EFI_ST_SUCCESS) 1045 return EFI_ST_FAILURE; 1046 1047 /* HII string protocol */ 1048 ret = test_hii_string_protocol(); 1049 if (ret != EFI_ST_SUCCESS) 1050 return EFI_ST_FAILURE; 1051 1052 return EFI_ST_SUCCESS; 1053 } 1054 1055 EFI_UNIT_TEST(hii) = { 1056 .name = "HII database protocols", 1057 .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT, 1058 .setup = setup, 1059 .execute = execute, 1060 }; 1061