1 // SPDX-License-Identifier: GPL-2.0+
5 * Copyright (c) 2018 AKASHI Takahiro, Linaro Limited
7 * Test HII database protocols
10 #include <efi_selftest.h>
11 #include "efi_selftest_hii_data.c"
13 #define PRINT_TESTNAME efi_st_printf("%s:\n", __func__)
15 static struct efi_boot_services *boottime;
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;
22 static struct efi_hii_database_protocol *hii_database_protocol;
23 static struct efi_hii_string_protocol *hii_string_protocol;
28 * @handle: handle of the loaded image
29 * @systable: system table
31 * @return: EFI_ST_SUCCESS for success
33 static int setup(const efi_handle_t handle,
34 const struct efi_system_table *systable)
38 boottime = systable->boottime;
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;
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;
58 return EFI_ST_SUCCESS;
62 * HII database protocol tests
66 * test_hii_database_new_package_list() - test creation and removal of
69 * This test adds a new package list and then tries to remove it using
70 * the provided handle.
72 * @Return: status code
74 static int test_hii_database_new_package_list(void)
76 efi_hii_handle_t handle;
80 ret = hii_database_protocol->new_package_list(hii_database_protocol,
81 (struct efi_hii_package_list_header *)packagelist1,
83 if (ret != EFI_SUCCESS || !handle) {
84 efi_st_error("new_package_list returned %u\n",
86 return EFI_ST_FAILURE;
89 ret = hii_database_protocol->remove_package_list(hii_database_protocol,
91 if (ret != EFI_SUCCESS) {
92 efi_st_error("remove_package_list returned %u\n",
94 return EFI_ST_FAILURE;
97 return EFI_ST_SUCCESS;
101 * test_hii_database_update_package_list() - test update of package list
103 * This test adds a new package list and then tries to update it using
104 * another package list.
106 * @Return: status code
108 static int test_hii_database_update_package_list(void)
110 efi_hii_handle_t handle = NULL;
112 int result = EFI_ST_FAILURE;
115 ret = hii_database_protocol->new_package_list(hii_database_protocol,
116 (struct efi_hii_package_list_header *)packagelist1,
118 if (ret != EFI_SUCCESS || !handle) {
119 efi_st_error("new_package_list returned %u\n",
121 return EFI_ST_FAILURE;
124 ret = hii_database_protocol->update_package_list(hii_database_protocol,
126 (struct efi_hii_package_list_header *)packagelist2);
127 if (ret != EFI_SUCCESS || !handle) {
128 efi_st_error("new_package_list returned %u\n",
133 result = EFI_ST_SUCCESS;
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",
142 return EFI_ST_FAILURE;
150 * test_hii_database_list_package_lists() - test listing of package lists
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.
155 * @Return: status code
157 static int test_hii_database_list_package_lists(void)
159 efi_hii_handle_t handle1 = NULL, handle2 = NULL, *handles;
160 efi_uintn_t handles_size;
162 int result = EFI_ST_FAILURE;
165 ret = hii_database_protocol->new_package_list(hii_database_protocol,
166 (struct efi_hii_package_list_header *)packagelist1,
168 if (ret != EFI_SUCCESS || !handle1) {
169 efi_st_error("new_package_list returned %u\n",
174 ret = hii_database_protocol->new_package_list(hii_database_protocol,
175 (struct efi_hii_package_list_header *)packagelist2,
177 if (ret != EFI_SUCCESS || !handle2) {
178 efi_st_error("new_package_list returned %u\n",
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",
194 ret = boottime->allocate_pool(EFI_LOADER_DATA, handles_size,
196 if (ret != EFI_SUCCESS) {
197 efi_st_error("AllocatePool failed\n");
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",
208 ret = boottime->free_pool(handles);
209 if (ret != EFI_SUCCESS) {
210 efi_st_error("FreePool failed\n");
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",
223 ret = EFI_ST_FAILURE;
226 ret = boottime->allocate_pool(EFI_LOADER_DATA, handles_size,
228 if (ret != EFI_SUCCESS) {
229 efi_st_error("AllocatePool failed\n");
230 ret = EFI_ST_FAILURE;
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",
239 ret = EFI_ST_FAILURE;
242 ret = boottime->free_pool(handles);
243 if (ret != EFI_SUCCESS) {
244 efi_st_error("FreePool failed\n");
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",
257 ret = EFI_ST_FAILURE;
260 ret = boottime->allocate_pool(EFI_LOADER_DATA, handles_size,
262 if (ret != EFI_SUCCESS) {
263 efi_st_error("AllocatePool failed\n");
264 ret = EFI_ST_FAILURE;
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",
273 ret = EFI_ST_FAILURE;
276 ret = boottime->free_pool(handles);
277 if (ret != EFI_SUCCESS) {
278 efi_st_error("FreePool failed\n");
279 ret = EFI_ST_FAILURE;
283 /* KEYBOARD_LAYOUT */
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",
292 ret = EFI_ST_FAILURE;
295 ret = boottime->allocate_pool(EFI_LOADER_DATA, handles_size,
297 if (ret != EFI_SUCCESS) {
298 efi_st_error("AllocatePool failed\n");
299 ret = EFI_ST_FAILURE;
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",
308 ret = EFI_ST_FAILURE;
311 ret = boottime->free_pool(handles);
312 if (ret != EFI_SUCCESS) {
313 efi_st_error("FreePool failed\n");
314 ret = EFI_ST_FAILURE;
318 result = EFI_ST_SUCCESS;
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",
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",
340 * test_hii_database_export_package_lists() - test export of package lists
342 * @Return: status code
344 static int test_hii_database_export_package_lists(void)
347 /* export_package_lists() not implemented yet */
348 return EFI_ST_SUCCESS;
352 * test_hii_database_register_package_notify() - test registration of
353 * notification function
355 * @Return: status code
357 static int test_hii_database_register_package_notify(void)
360 /* register_package_notify() not implemented yet */
361 return EFI_ST_SUCCESS;
365 * test_hii_database_unregister_package_notify() - test removal of
366 * notification function
368 * @Return: status code
370 static int test_hii_database_unregister_package_notify(void)
373 /* unregsiter_package_notify() not implemented yet */
374 return EFI_ST_SUCCESS;
378 * test_hii_database_find_keyboard_layouts() - test listing of
379 * all the keyboard layouts in the system
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.
384 * @Return: status code
386 static int test_hii_database_find_keyboard_layouts(void)
388 efi_hii_handle_t handle1 = NULL, handle2 = NULL;
392 int result = EFI_ST_FAILURE;
395 ret = hii_database_protocol->new_package_list(hii_database_protocol,
396 (struct efi_hii_package_list_header *)packagelist1,
398 if (ret != EFI_SUCCESS || !handle1) {
399 efi_st_error("new_package_list returned %u\n",
404 ret = hii_database_protocol->new_package_list(hii_database_protocol,
405 (struct efi_hii_package_list_header *)packagelist2,
407 if (ret != EFI_SUCCESS || !handle2) {
408 efi_st_error("new_package_list returned %u\n",
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",
422 ret = boottime->allocate_pool(EFI_LOADER_DATA, guids_size,
424 if (ret != EFI_SUCCESS) {
425 efi_st_error("AllocatePool failed\n");
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",
435 ret = boottime->free_pool(guids);
436 if (ret != EFI_SUCCESS) {
437 efi_st_error("FreePool failed\n");
441 result = EFI_ST_SUCCESS;
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",
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",
463 * test_hii_database_get_keyboard_layout() - test retrieval of keyboard layout
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.
469 * @Return: status code
471 static int test_hii_database_get_keyboard_layout(void)
473 efi_hii_handle_t handle1 = NULL, handle2 = NULL;
474 struct efi_hii_keyboard_layout *kb_layout;
477 int result = EFI_ST_FAILURE;
480 ret = hii_database_protocol->new_package_list(hii_database_protocol,
481 (struct efi_hii_package_list_header *)packagelist1,
483 if (ret != EFI_SUCCESS || !handle1) {
484 efi_st_error("new_package_list returned %u\n",
489 ret = hii_database_protocol->new_package_list(hii_database_protocol,
490 (struct efi_hii_package_list_header *)packagelist2,
492 if (ret != EFI_SUCCESS || !handle2) {
493 efi_st_error("new_package_list returned %u\n",
498 /* specific keyboard_layout(guid11) */
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",
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");
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",
521 ret = boottime->free_pool(kb_layout);
522 if (ret != EFI_SUCCESS) {
523 efi_st_error("FreePool failed\n");
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",
538 result = EFI_ST_SUCCESS;
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",
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",
560 * test_hii_database_set_keyboard_layout() - test change of
561 * current keyboard layout
563 * @Return: status code
565 static int test_hii_database_set_keyboard_layout(void)
568 /* set_keyboard_layout() not implemented yet */
569 return EFI_ST_SUCCESS;
573 * test_hii_database_get_package_list_handle() - test retrieval of
574 * driver associated with a package list
576 * This test adds a package list, and then tries to get a handle to driver
577 * which is associated with a package list.
579 * @Return: status code
581 static int test_hii_database_get_package_list_handle(void)
583 efi_hii_handle_t handle = NULL;
584 efi_handle_t driver_handle;
586 int result = EFI_ST_FAILURE;
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",
596 return EFI_ST_FAILURE;
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);
608 result = EFI_ST_SUCCESS;
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",
617 return EFI_ST_FAILURE;
624 static int test_hii_database_protocol(void)
628 ret = test_hii_database_new_package_list();
629 if (ret != EFI_ST_SUCCESS)
630 return EFI_ST_FAILURE;
632 ret = test_hii_database_update_package_list();
633 if (ret != EFI_ST_SUCCESS)
634 return EFI_ST_FAILURE;
636 ret = test_hii_database_list_package_lists();
637 if (ret != EFI_ST_SUCCESS)
638 return EFI_ST_FAILURE;
640 ret = test_hii_database_export_package_lists();
641 if (ret != EFI_ST_SUCCESS)
642 return EFI_ST_FAILURE;
644 ret = test_hii_database_register_package_notify();
645 if (ret != EFI_ST_SUCCESS)
646 return EFI_ST_FAILURE;
648 ret = test_hii_database_unregister_package_notify();
649 if (ret != EFI_ST_SUCCESS)
650 return EFI_ST_FAILURE;
652 ret = test_hii_database_find_keyboard_layouts();
653 if (ret != EFI_ST_SUCCESS)
654 return EFI_ST_FAILURE;
656 ret = test_hii_database_get_keyboard_layout();
657 if (ret != EFI_ST_SUCCESS)
658 return EFI_ST_FAILURE;
660 ret = test_hii_database_set_keyboard_layout();
661 if (ret != EFI_ST_SUCCESS)
662 return EFI_ST_FAILURE;
664 ret = test_hii_database_get_package_list_handle();
665 if (ret != EFI_ST_SUCCESS)
666 return EFI_ST_FAILURE;
668 return EFI_ST_SUCCESS;
672 * HII string protocol tests
676 * test_hii_string_new_string() - test creation of a new string entry
678 * This test adds a package list, and then tries to add a new string
679 * entry for a specific language.
681 * @Return: status code
683 static int test_hii_string_new_string(void)
685 efi_hii_handle_t handle = NULL;
688 int result = EFI_ST_FAILURE;
691 ret = hii_database_protocol->new_package_list(hii_database_protocol,
692 (struct efi_hii_package_list_header *)packagelist1,
694 if (ret != EFI_SUCCESS || !handle) {
695 efi_st_error("new_package_list returned %u\n",
697 return EFI_ST_FAILURE;
700 ret = hii_string_protocol->new_string(hii_string_protocol, handle,
702 L"Japanese", L"Japanese", NULL);
703 if (ret != EFI_SUCCESS) {
704 efi_st_error("new_string returned %u\n",
708 efi_st_printf("new string id is %u\n", id);
710 result = EFI_ST_SUCCESS;
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",
719 return EFI_ST_FAILURE;
727 * test_hii_string_get_string() - test retrieval of a string entry
729 * This test adds a package list, create a new string entry and then tries
730 * to get it with its string id.
732 * @Return: status code
734 static int test_hii_string_get_string(void)
736 efi_hii_handle_t handle = NULL;
739 efi_uintn_t string_len;
741 int result = EFI_ST_FAILURE;
744 ret = hii_database_protocol->new_package_list(hii_database_protocol,
745 (struct efi_hii_package_list_header *)packagelist1,
747 if (ret != EFI_SUCCESS || !handle) {
748 efi_st_error("new_package_list returned %u\n",
750 return EFI_ST_FAILURE;
753 ret = hii_string_protocol->new_string(hii_string_protocol, handle,
755 L"Japanese", L"Japanese", NULL);
756 if (ret != EFI_SUCCESS) {
757 efi_st_error("new_string returned %u\n",
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",
771 string_len += sizeof(u16);
772 ret = boottime->allocate_pool(EFI_LOADER_DATA, string_len,
774 if (ret != EFI_SUCCESS) {
775 efi_st_error("AllocatePool failed\n");
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",
789 for (c1 = string, c2 = L"Japanese"; *c1 == *c2; c1++, c2++)
792 result = EFI_ST_SUCCESS;
794 result = EFI_ST_FAILURE;
797 efi_st_printf("got string is %s (can be wrong)\n", string);
800 result = EFI_ST_SUCCESS;
804 ret = hii_database_protocol->remove_package_list(
805 hii_database_protocol, handle);
806 if (ret != EFI_SUCCESS) {
807 efi_st_error("remove_package_list returned %u\n",
809 return EFI_ST_FAILURE;
817 * test_hii_string_set_string() - test change of a string entry
819 * This test adds a package list, create a new string entry and then tries
822 * @Return: status code
824 static int test_hii_string_set_string(void)
826 efi_hii_handle_t handle = NULL;
829 int result = EFI_ST_FAILURE;
832 ret = hii_database_protocol->new_package_list(hii_database_protocol,
833 (struct efi_hii_package_list_header *)packagelist1,
835 if (ret != EFI_SUCCESS || !handle) {
836 efi_st_error("new_package_list returned %u\n",
838 return EFI_ST_FAILURE;
841 ret = hii_string_protocol->new_string(hii_string_protocol, handle,
843 L"Japanese", L"Japanese", NULL);
844 if (ret != EFI_SUCCESS) {
845 efi_st_error("new_string returned %u\n",
850 ret = hii_string_protocol->set_string(hii_string_protocol, handle,
853 if (ret != EFI_SUCCESS) {
854 efi_st_error("set_string returned %u\n",
859 result = EFI_ST_SUCCESS;
863 ret = hii_database_protocol->remove_package_list(
864 hii_database_protocol, handle);
865 if (ret != EFI_SUCCESS) {
866 efi_st_error("remove_package_list returned %u\n",
868 return EFI_ST_FAILURE;
876 * test_hii_string_get_languages() - test listing of languages
878 * This test adds a package list, and then tries to enumerate languages
879 * in it. We will get an string of language names.
881 * @Return: status code
883 static int test_hii_string_get_languages(void)
885 efi_hii_handle_t handle = NULL;
887 efi_uintn_t languages_len;
889 int result = EFI_ST_FAILURE;
892 ret = hii_database_protocol->new_package_list(hii_database_protocol,
893 (struct efi_hii_package_list_header *)packagelist1,
895 if (ret != EFI_SUCCESS || !handle) {
896 efi_st_error("new_package_list returned %u\n",
898 return EFI_ST_FAILURE;
903 ret = hii_string_protocol->get_languages(hii_string_protocol, handle,
904 languages, &languages_len);
905 if (ret != EFI_BUFFER_TOO_SMALL) {
906 efi_st_error("get_languages returned %u\n",
910 ret = boottime->allocate_pool(EFI_LOADER_DATA, languages_len,
911 (void **)&languages);
912 if (ret != EFI_SUCCESS) {
913 efi_st_error("AllocatePool failed\n");
916 ret = hii_string_protocol->get_languages(hii_string_protocol, handle,
917 languages, &languages_len);
918 if (ret != EFI_SUCCESS) {
919 efi_st_error("get_languages returned %u\n",
924 efi_st_printf("got languages are %s\n", languages);
926 result = EFI_ST_SUCCESS;
930 ret = hii_database_protocol->remove_package_list(
931 hii_database_protocol, handle);
932 if (ret != EFI_SUCCESS) {
933 efi_st_error("remove_package_list returned %u\n",
935 return EFI_ST_FAILURE;
943 * test_hii_string_get_secondary_languages() - test listing of secondary
946 * This test adds a package list, and then tries to enumerate secondary
947 * languages with a specific language. We will get an string of language names.
949 * @Return: status code
951 static int test_hii_string_get_secondary_languages(void)
953 efi_hii_handle_t handle = NULL;
955 efi_uintn_t languages_len;
957 int result = EFI_ST_FAILURE;
960 ret = hii_database_protocol->new_package_list(hii_database_protocol,
961 (struct efi_hii_package_list_header *)packagelist1,
963 if (ret != EFI_SUCCESS || !handle) {
964 efi_st_error("new_package_list returned %u\n",
966 return EFI_ST_FAILURE;
971 ret = hii_string_protocol->get_secondary_languages(hii_string_protocol,
972 handle, (u8 *)"en-US", languages, &languages_len);
973 if (ret == EFI_NOT_FOUND) {
974 efi_st_printf("no secondary languages\n");
975 result = EFI_ST_SUCCESS;
978 if (ret != EFI_BUFFER_TOO_SMALL) {
979 efi_st_error("get_secondary_languages returned %u\n",
983 ret = boottime->allocate_pool(EFI_LOADER_DATA, languages_len,
984 (void **)&languages);
985 if (ret != EFI_SUCCESS) {
986 efi_st_error("AllocatePool failed\n");
989 ret = hii_string_protocol->get_secondary_languages(hii_string_protocol,
990 handle, (u8 *)"en-US", languages, &languages_len);
991 if (ret != EFI_SUCCESS) {
992 efi_st_error("get_secondary_languages returned %u\n",
997 efi_st_printf("got secondary languages are %s\n", languages);
999 result = EFI_ST_SUCCESS;
1003 ret = hii_database_protocol->remove_package_list(
1004 hii_database_protocol, handle);
1005 if (ret != EFI_SUCCESS) {
1006 efi_st_error("remove_package_list returned %u\n",
1008 return EFI_ST_FAILURE;
1015 static int test_hii_string_protocol(void)
1019 ret = test_hii_string_new_string();
1020 if (ret != EFI_ST_SUCCESS)
1021 return EFI_ST_FAILURE;
1023 ret = test_hii_string_get_string();
1024 if (ret != EFI_ST_SUCCESS)
1025 return EFI_ST_FAILURE;
1027 ret = test_hii_string_set_string();
1028 if (ret != EFI_ST_SUCCESS)
1029 return EFI_ST_FAILURE;
1031 ret = test_hii_string_get_languages();
1032 if (ret != EFI_ST_SUCCESS)
1033 return EFI_ST_FAILURE;
1035 ret = test_hii_string_get_secondary_languages();
1036 if (ret != EFI_ST_SUCCESS)
1037 return EFI_ST_FAILURE;
1039 return EFI_ST_SUCCESS;
1043 * Execute unit test.
1045 * @return: EFI_ST_SUCCESS for success, EFI_ST_FAILURE for failure
1047 static int execute(void)
1051 /* HII database protocol */
1052 ret = test_hii_database_protocol();
1053 if (ret != EFI_ST_SUCCESS)
1054 return EFI_ST_FAILURE;
1056 /* HII string protocol */
1057 ret = test_hii_string_protocol();
1058 if (ret != EFI_ST_SUCCESS)
1059 return EFI_ST_FAILURE;
1061 return EFI_ST_SUCCESS;
1064 EFI_UNIT_TEST(hii) = {
1065 .name = "HII database protocols",
1066 .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,