LXR uboot/lib/efi_selftest/efi_selftest

   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
  15static struct efi_boot_services *boottime;
  16
  17static const efi_guid_t hii_database_protocol_guid =
  18        EFI_HII_DATABASE_PROTOCOL_GUID;
  19static const efi_guid_t hii_string_protocol_guid =
  20        EFI_HII_STRING_PROTOCOL_GUID;
  21
  22static struct efi_hii_database_protocol *hii_database_protocol;
  23static 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 */
  33static 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 */
  74static 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 */
 108static 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
 135out:
 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 */
 157static 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
 320out:
 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 */
 344static 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 */
 357static 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 */
 370static 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 */
 386static 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
 443out:
 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 */
 471static 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
 540out:
 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 */
 565static 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 */
 581static 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
 610out:
 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
 624static 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 */
 683static 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
 712out:
 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 */
 734static 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
 793out:
 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 */
 815static 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
 852out:
 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 */
 874static 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
 919out:
 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 */
 942static 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
 992out:
 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
1006static 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 */
1038static 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
1055EFI_UNIT_TEST(hii) = {
1056        .name = "HII database protocols",
1057        .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
1058        .setup = setup,
1059        .execute = execute,
1060};
1061