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>
12 #include "efi_selftest_hii_data.c"
14 #define PRINT_TESTNAME efi_st_printf("%s:\n", __func__)
16 static struct efi_boot_services *boottime;
18 static const efi_guid_t hii_database_protocol_guid =
19 EFI_HII_DATABASE_PROTOCOL_GUID;
20 static const efi_guid_t hii_string_protocol_guid =
21 EFI_HII_STRING_PROTOCOL_GUID;
23 static struct efi_hii_database_protocol *hii_database_protocol;
24 static struct efi_hii_string_protocol *hii_string_protocol;
29 * @handle: handle of the loaded image
30 * @systable: system table
32 * @return: EFI_ST_SUCCESS for success
34 static int setup(const efi_handle_t handle,
35 const struct efi_system_table *systable)
39 boottime = systable->boottime;
41 /* HII database protocol */
42 ret = boottime->locate_protocol(&hii_database_protocol_guid, NULL,
43 (void **)&hii_database_protocol);
44 if (ret != EFI_SUCCESS) {
45 hii_database_protocol = NULL;
46 efi_st_error("HII database protocol is not available.\n");
47 return EFI_ST_FAILURE;
50 /* HII string protocol */
51 ret = boottime->locate_protocol(&hii_string_protocol_guid, NULL,
52 (void **)&hii_string_protocol);
53 if (ret != EFI_SUCCESS) {
54 hii_string_protocol = NULL;
55 efi_st_error("HII string protocol is not available.\n");
56 return EFI_ST_FAILURE;
59 return EFI_ST_SUCCESS;
63 * HII database protocol tests
67 * test_hii_database_new_package_list() - test creation and removal of
70 * This test adds a new package list and then tries to remove it using
71 * the provided handle.
73 * @Return: status code
75 static int test_hii_database_new_package_list(void)
77 efi_hii_handle_t handle;
81 ret = hii_database_protocol->new_package_list(hii_database_protocol,
82 (struct efi_hii_package_list_header *)packagelist1,
84 if (ret != EFI_SUCCESS || !handle) {
85 efi_st_error("new_package_list returned %u\n",
87 return EFI_ST_FAILURE;
90 ret = hii_database_protocol->remove_package_list(hii_database_protocol,
92 if (ret != EFI_SUCCESS) {
93 efi_st_error("remove_package_list returned %u\n",
95 return EFI_ST_FAILURE;
98 return EFI_ST_SUCCESS;
102 * test_hii_database_update_package_list() - test update of package list
104 * This test adds a new package list and then tries to update it using
105 * another package list.
107 * @Return: status code
109 static int test_hii_database_update_package_list(void)
111 efi_hii_handle_t handle = NULL;
113 int result = EFI_ST_FAILURE;
116 ret = hii_database_protocol->new_package_list(hii_database_protocol,
117 (struct efi_hii_package_list_header *)packagelist1,
119 if (ret != EFI_SUCCESS || !handle) {
120 efi_st_error("new_package_list returned %u\n",
122 return EFI_ST_FAILURE;
125 ret = hii_database_protocol->update_package_list(hii_database_protocol,
127 (struct efi_hii_package_list_header *)packagelist2);
128 if (ret != EFI_SUCCESS || !handle) {
129 efi_st_error("new_package_list returned %u\n",
134 result = EFI_ST_SUCCESS;
138 ret = hii_database_protocol->remove_package_list(
139 hii_database_protocol, handle);
140 if (ret != EFI_SUCCESS) {
141 efi_st_error("remove_package_list returned %u\n",
143 return EFI_ST_FAILURE;
151 * test_hii_database_list_package_lists() - test listing of package lists
153 * This test adds two package lists and then tries to enumerate them
154 * against different package types. We will get an array of handles.
156 * @Return: status code
158 static int test_hii_database_list_package_lists(void)
160 efi_hii_handle_t handle1 = NULL, handle2 = NULL, *handles;
161 efi_uintn_t handles_size;
163 int result = EFI_ST_FAILURE;
166 ret = hii_database_protocol->new_package_list(hii_database_protocol,
167 (struct efi_hii_package_list_header *)packagelist1,
169 if (ret != EFI_SUCCESS || !handle1) {
170 efi_st_error("new_package_list returned %u\n",
175 ret = hii_database_protocol->new_package_list(hii_database_protocol,
176 (struct efi_hii_package_list_header *)packagelist2,
178 if (ret != EFI_SUCCESS || !handle2) {
179 efi_st_error("new_package_list returned %u\n",
187 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
188 EFI_HII_PACKAGE_TYPE_ALL, NULL,
189 &handles_size, handles);
190 if (ret != EFI_BUFFER_TOO_SMALL) {
191 efi_st_error("list_package_lists returned %u\n",
195 handles = malloc(handles_size);
197 efi_st_error("malloc 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 efi_st_printf("list_package_lists returned %ld handles\n",
209 handles_size / sizeof(*handles));
215 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
216 EFI_HII_PACKAGE_STRINGS, NULL,
217 &handles_size, handles);
218 if (ret != EFI_BUFFER_TOO_SMALL) {
219 efi_st_error("list_package_lists returned %u\n",
221 ret = EFI_ST_FAILURE;
224 handles = malloc(handles_size);
226 efi_st_error("malloc failed\n");
227 ret = EFI_ST_FAILURE;
230 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
231 EFI_HII_PACKAGE_STRINGS, NULL,
232 &handles_size, handles);
233 if (ret != EFI_SUCCESS) {
234 efi_st_error("list_package_lists returned %u\n",
236 ret = EFI_ST_FAILURE;
239 efi_st_printf("list_package_lists returned %ld strings handles\n",
240 handles_size / sizeof(*handles));
246 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
247 EFI_HII_PACKAGE_TYPE_GUID, &package_guid,
248 &handles_size, handles);
249 if (ret != EFI_BUFFER_TOO_SMALL) {
250 efi_st_error("list_package_lists returned %u\n",
252 ret = EFI_ST_FAILURE;
255 handles = malloc(handles_size);
257 efi_st_error("malloc failed\n");
258 ret = EFI_ST_FAILURE;
261 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
262 EFI_HII_PACKAGE_TYPE_GUID, &package_guid,
263 &handles_size, handles);
264 if (ret != EFI_SUCCESS) {
265 efi_st_error("list_package_lists returned %u\n",
267 ret = EFI_ST_FAILURE;
270 efi_st_printf("list_package_lists returned %ld guid handles\n",
271 handles_size / sizeof(*handles));
274 /* KEYBOARD_LAYOUT */
277 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
278 EFI_HII_PACKAGE_KEYBOARD_LAYOUT, NULL,
279 &handles_size, handles);
280 if (ret != EFI_BUFFER_TOO_SMALL) {
281 efi_st_error("list_package_lists returned %u\n",
283 ret = EFI_ST_FAILURE;
286 handles = malloc(handles_size);
288 efi_st_error("malloc failed\n");
289 ret = EFI_ST_FAILURE;
292 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
293 EFI_HII_PACKAGE_KEYBOARD_LAYOUT, NULL,
294 &handles_size, handles);
295 if (ret != EFI_SUCCESS) {
296 efi_st_error("list_package_lists returned %u\n",
298 ret = EFI_ST_FAILURE;
301 efi_st_printf("list_package_lists returned %ld keyboard layout handles\n",
302 handles_size / sizeof(*handles));
305 result = EFI_ST_SUCCESS;
309 ret = hii_database_protocol->remove_package_list(
310 hii_database_protocol, handle1);
311 if (ret != EFI_SUCCESS)
312 efi_st_error("remove_package_list returned %u\n",
316 ret = hii_database_protocol->remove_package_list(
317 hii_database_protocol, handle2);
318 if (ret != EFI_SUCCESS)
319 efi_st_error("remove_package_list returned %u\n",
327 * test_hii_database_export_package_lists() - test export of package lists
329 * @Return: status code
331 static int test_hii_database_export_package_lists(void)
334 /* export_package_lists() not implemented yet */
335 return EFI_ST_SUCCESS;
339 * test_hii_database_register_package_notify() - test registration of
340 * notification function
342 * @Return: status code
344 static int test_hii_database_register_package_notify(void)
347 /* register_package_notify() not implemented yet */
348 return EFI_ST_SUCCESS;
352 * test_hii_database_unregister_package_notify() - test removal of
353 * notification function
355 * @Return: status code
357 static int test_hii_database_unregister_package_notify(void)
360 /* unregsiter_package_notify() not implemented yet */
361 return EFI_ST_SUCCESS;
365 * test_hii_database_find_keyboard_layouts() - test listing of
366 * all the keyboard layouts in the system
368 * This test adds two package lists, each of which has two keyboard layouts
369 * and then tries to enumerate them. We will get an array of handles.
371 * @Return: status code
373 static int test_hii_database_find_keyboard_layouts(void)
375 efi_hii_handle_t handle1 = NULL, handle2 = NULL;
379 int result = EFI_ST_FAILURE;
382 ret = hii_database_protocol->new_package_list(hii_database_protocol,
383 (struct efi_hii_package_list_header *)packagelist1,
385 if (ret != EFI_SUCCESS || !handle1) {
386 efi_st_error("new_package_list returned %u\n",
391 ret = hii_database_protocol->new_package_list(hii_database_protocol,
392 (struct efi_hii_package_list_header *)packagelist2,
394 if (ret != EFI_SUCCESS || !handle2) {
395 efi_st_error("new_package_list returned %u\n",
402 ret = hii_database_protocol->find_keyboard_layouts(
403 hii_database_protocol, &guids_size, guids);
404 if (ret != EFI_BUFFER_TOO_SMALL) {
405 efi_st_error("find_keyboard_layouts returned %u\n",
409 guids = malloc(guids_size);
411 efi_st_error("malloc failed\n");
414 ret = hii_database_protocol->find_keyboard_layouts(
415 hii_database_protocol, &guids_size, guids);
416 if (ret != EFI_SUCCESS) {
417 efi_st_error("find_keyboard_layouts returned %u\n",
423 efi_st_printf("find_keyboard_layouts returned %ld guids\n",
424 guids_size / sizeof(*guids));
426 result = EFI_ST_SUCCESS;
430 ret = hii_database_protocol->remove_package_list(
431 hii_database_protocol, handle1);
432 if (ret != EFI_SUCCESS)
433 efi_st_error("remove_package_list returned %u\n",
437 ret = hii_database_protocol->remove_package_list(
438 hii_database_protocol, handle2);
439 if (ret != EFI_SUCCESS)
440 efi_st_error("remove_package_list returned %u\n",
448 * test_hii_database_get_keyboard_layout() - test retrieval of keyboard layout
450 * This test adds two package lists, each of which has two keyboard layouts
451 * and then tries to get a handle to keyboard layout with a specific guid
452 * and the current one.
454 * @Return: status code
456 static int test_hii_database_get_keyboard_layout(void)
458 efi_hii_handle_t handle1 = NULL, handle2 = NULL;
459 struct efi_hii_keyboard_layout *kb_layout;
462 int result = EFI_ST_FAILURE;
465 ret = hii_database_protocol->new_package_list(hii_database_protocol,
466 (struct efi_hii_package_list_header *)packagelist1,
468 if (ret != EFI_SUCCESS || !handle1) {
469 efi_st_error("new_package_list returned %u\n",
474 ret = hii_database_protocol->new_package_list(hii_database_protocol,
475 (struct efi_hii_package_list_header *)packagelist2,
477 if (ret != EFI_SUCCESS || !handle2) {
478 efi_st_error("new_package_list returned %u\n",
483 /* specific keyboard_layout(guid11) */
486 ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol,
487 &kb_layout_guid11, &kb_layout_size, kb_layout);
488 if (ret != EFI_BUFFER_TOO_SMALL) {
489 efi_st_error("get_keyboard_layout returned %u\n",
493 kb_layout = malloc(kb_layout_size);
495 efi_st_error("malloc failed\n");
498 ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol,
499 &kb_layout_guid11, &kb_layout_size, kb_layout);
500 if (ret != EFI_SUCCESS) {
501 efi_st_error("get_keyboard_layout returned %u\n",
510 ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol,
511 NULL, &kb_layout_size, kb_layout);
512 if (ret != EFI_INVALID_PARAMETER) {
513 efi_st_error("get_keyboard_layout returned %u\n",
518 result = EFI_ST_SUCCESS;
522 ret = hii_database_protocol->remove_package_list(
523 hii_database_protocol, handle1);
524 if (ret != EFI_SUCCESS)
525 efi_st_error("remove_package_list returned %u\n",
529 ret = hii_database_protocol->remove_package_list(
530 hii_database_protocol, handle2);
531 if (ret != EFI_SUCCESS)
532 efi_st_error("remove_package_list returned %u\n",
540 * test_hii_database_set_keyboard_layout() - test change of
541 * current keyboard layout
543 * @Return: status code
545 static int test_hii_database_set_keyboard_layout(void)
548 /* set_keyboard_layout() not implemented yet */
549 return EFI_ST_SUCCESS;
553 * test_hii_database_get_package_list_handle() - test retrieval of
554 * driver associated with a package list
556 * This test adds a package list, and then tries to get a handle to driver
557 * which is associated with a package list.
559 * @Return: status code
561 static int test_hii_database_get_package_list_handle(void)
563 efi_hii_handle_t handle = NULL;
564 efi_handle_t driver_handle;
566 int result = EFI_ST_FAILURE;
569 driver_handle = (efi_handle_t)0x12345678; /* dummy */
570 ret = hii_database_protocol->new_package_list(hii_database_protocol,
571 (struct efi_hii_package_list_header *)packagelist1,
572 driver_handle, &handle);
573 if (ret != EFI_SUCCESS || !handle) {
574 efi_st_error("new_package_list returned %u\n",
576 return EFI_ST_FAILURE;
579 driver_handle = NULL;
580 ret = hii_database_protocol->get_package_list_handle(
581 hii_database_protocol, handle, &driver_handle);
582 if (ret != EFI_SUCCESS || driver_handle != (efi_handle_t)0x12345678) {
583 efi_st_error("get_package_list_handle returned %u, driver:%p\n",
584 (unsigned int)ret, driver_handle);
588 result = EFI_ST_SUCCESS;
592 ret = hii_database_protocol->remove_package_list(
593 hii_database_protocol, handle);
594 if (ret != EFI_SUCCESS) {
595 efi_st_error("remove_package_list returned %u\n",
597 return EFI_ST_FAILURE;
604 static int test_hii_database_protocol(void)
608 ret = test_hii_database_new_package_list();
609 if (ret != EFI_ST_SUCCESS)
610 return EFI_ST_FAILURE;
612 ret = test_hii_database_update_package_list();
613 if (ret != EFI_ST_SUCCESS)
614 return EFI_ST_FAILURE;
616 ret = test_hii_database_list_package_lists();
617 if (ret != EFI_ST_SUCCESS)
618 return EFI_ST_FAILURE;
620 ret = test_hii_database_export_package_lists();
621 if (ret != EFI_ST_SUCCESS)
622 return EFI_ST_FAILURE;
624 ret = test_hii_database_register_package_notify();
625 if (ret != EFI_ST_SUCCESS)
626 return EFI_ST_FAILURE;
628 ret = test_hii_database_unregister_package_notify();
629 if (ret != EFI_ST_SUCCESS)
630 return EFI_ST_FAILURE;
632 ret = test_hii_database_find_keyboard_layouts();
633 if (ret != EFI_ST_SUCCESS)
634 return EFI_ST_FAILURE;
636 ret = test_hii_database_get_keyboard_layout();
637 if (ret != EFI_ST_SUCCESS)
638 return EFI_ST_FAILURE;
640 ret = test_hii_database_set_keyboard_layout();
641 if (ret != EFI_ST_SUCCESS)
642 return EFI_ST_FAILURE;
644 ret = test_hii_database_get_package_list_handle();
645 if (ret != EFI_ST_SUCCESS)
646 return EFI_ST_FAILURE;
648 return EFI_ST_SUCCESS;
652 * HII string protocol tests
656 * test_hii_string_new_string() - test creation of a new string entry
658 * This test adds a package list, and then tries to add a new string
659 * entry for a specific language.
661 * @Return: status code
663 static int test_hii_string_new_string(void)
665 efi_hii_handle_t handle = NULL;
668 int result = EFI_ST_FAILURE;
671 ret = hii_database_protocol->new_package_list(hii_database_protocol,
672 (struct efi_hii_package_list_header *)packagelist1,
674 if (ret != EFI_SUCCESS || !handle) {
675 efi_st_error("new_package_list returned %u\n",
677 return EFI_ST_FAILURE;
680 ret = hii_string_protocol->new_string(hii_string_protocol, handle,
682 L"Japanese", L"Japanese", NULL);
683 if (ret != EFI_SUCCESS) {
684 efi_st_error("new_string returned %u\n",
688 efi_st_printf("new string id is %u\n", id);
690 result = EFI_ST_SUCCESS;
694 ret = hii_database_protocol->remove_package_list(
695 hii_database_protocol, handle);
696 if (ret != EFI_SUCCESS) {
697 efi_st_error("remove_package_list returned %u\n",
699 return EFI_ST_FAILURE;
707 * test_hii_string_get_string() - test retrieval of a string entry
709 * This test adds a package list, create a new string entry and then tries
710 * to get it with its string id.
712 * @Return: status code
714 static int test_hii_string_get_string(void)
716 efi_hii_handle_t handle = NULL;
719 efi_uintn_t string_len;
721 int result = EFI_ST_FAILURE;
724 ret = hii_database_protocol->new_package_list(hii_database_protocol,
725 (struct efi_hii_package_list_header *)packagelist1,
727 if (ret != EFI_SUCCESS || !handle) {
728 efi_st_error("new_package_list returned %u\n",
730 return EFI_ST_FAILURE;
733 ret = hii_string_protocol->new_string(hii_string_protocol, handle,
735 L"Japanese", L"Japanese", NULL);
736 if (ret != EFI_SUCCESS) {
737 efi_st_error("new_string returned %u\n",
744 ret = hii_string_protocol->get_string(hii_string_protocol,
745 (u8 *)"en-US", handle, id, string, &string_len, NULL);
746 if (ret != EFI_BUFFER_TOO_SMALL) {
747 efi_st_error("get_string returned %u\n",
751 string_len += sizeof(u16);
752 string = malloc(string_len);
754 efi_st_error("malloc failed\n");
757 ret = hii_string_protocol->get_string(hii_string_protocol,
758 (u8 *)"en-US", handle, id, string, &string_len, NULL);
759 if (ret != EFI_SUCCESS) {
760 efi_st_error("get_string returned %u\n",
768 for (c1 = string, c2 = L"Japanese"; *c1 == *c2; c1++, c2++)
771 result = EFI_ST_SUCCESS;
773 result = EFI_ST_FAILURE;
776 efi_st_printf("got string is %s (can be wrong)\n", string);
779 result = EFI_ST_SUCCESS;
783 ret = hii_database_protocol->remove_package_list(
784 hii_database_protocol, handle);
785 if (ret != EFI_SUCCESS) {
786 efi_st_error("remove_package_list returned %u\n",
788 return EFI_ST_FAILURE;
796 * test_hii_string_set_string() - test change of a string entry
798 * This test adds a package list, create a new string entry and then tries
801 * @Return: status code
803 static int test_hii_string_set_string(void)
805 efi_hii_handle_t handle = NULL;
808 int result = EFI_ST_FAILURE;
811 ret = hii_database_protocol->new_package_list(hii_database_protocol,
812 (struct efi_hii_package_list_header *)packagelist1,
814 if (ret != EFI_SUCCESS || !handle) {
815 efi_st_error("new_package_list returned %u\n",
817 return EFI_ST_FAILURE;
820 ret = hii_string_protocol->new_string(hii_string_protocol, handle,
822 L"Japanese", L"Japanese", NULL);
823 if (ret != EFI_SUCCESS) {
824 efi_st_error("new_string returned %u\n",
829 ret = hii_string_protocol->set_string(hii_string_protocol, handle,
832 if (ret != EFI_SUCCESS) {
833 efi_st_error("set_string returned %u\n",
838 result = EFI_ST_SUCCESS;
842 ret = hii_database_protocol->remove_package_list(
843 hii_database_protocol, handle);
844 if (ret != EFI_SUCCESS) {
845 efi_st_error("remove_package_list returned %u\n",
847 return EFI_ST_FAILURE;
855 * test_hii_string_get_languages() - test listing of languages
857 * This test adds a package list, and then tries to enumerate languages
858 * in it. We will get an string of language names.
860 * @Return: status code
862 static int test_hii_string_get_languages(void)
864 efi_hii_handle_t handle = NULL;
866 efi_uintn_t languages_len;
868 int result = EFI_ST_FAILURE;
871 ret = hii_database_protocol->new_package_list(hii_database_protocol,
872 (struct efi_hii_package_list_header *)packagelist1,
874 if (ret != EFI_SUCCESS || !handle) {
875 efi_st_error("new_package_list returned %u\n",
877 return EFI_ST_FAILURE;
882 ret = hii_string_protocol->get_languages(hii_string_protocol, handle,
883 languages, &languages_len);
884 if (ret != EFI_BUFFER_TOO_SMALL) {
885 efi_st_error("get_languages returned %u\n",
889 languages = malloc(languages_len);
891 efi_st_error("malloc failed\n");
894 ret = hii_string_protocol->get_languages(hii_string_protocol, handle,
895 languages, &languages_len);
896 if (ret != EFI_SUCCESS) {
897 efi_st_error("get_languages returned %u\n",
902 efi_st_printf("got languages are %s\n", languages);
904 result = EFI_ST_SUCCESS;
908 ret = hii_database_protocol->remove_package_list(
909 hii_database_protocol, handle);
910 if (ret != EFI_SUCCESS) {
911 efi_st_error("remove_package_list returned %u\n",
913 return EFI_ST_FAILURE;
921 * test_hii_string_get_secondary_languages() - test listing of secondary
924 * This test adds a package list, and then tries to enumerate secondary
925 * languages with a specific language. We will get an string of language names.
927 * @Return: status code
929 static int test_hii_string_get_secondary_languages(void)
931 efi_hii_handle_t handle = NULL;
933 efi_uintn_t languages_len;
935 int result = EFI_ST_FAILURE;
938 ret = hii_database_protocol->new_package_list(hii_database_protocol,
939 (struct efi_hii_package_list_header *)packagelist1,
941 if (ret != EFI_SUCCESS || !handle) {
942 efi_st_error("new_package_list returned %u\n",
944 return EFI_ST_FAILURE;
949 ret = hii_string_protocol->get_secondary_languages(hii_string_protocol,
950 handle, (u8 *)"en-US", languages, &languages_len);
951 if (ret == EFI_NOT_FOUND) {
952 efi_st_printf("no secondary languages\n");
953 result = EFI_ST_SUCCESS;
956 if (ret != EFI_BUFFER_TOO_SMALL) {
957 efi_st_error("get_secondary_languages returned %u\n",
961 languages = malloc(languages_len);
963 efi_st_error("malloc failed\n");
966 ret = hii_string_protocol->get_secondary_languages(hii_string_protocol,
967 handle, (u8 *)"en-US", languages, &languages_len);
968 if (ret != EFI_SUCCESS) {
969 efi_st_error("get_secondary_languages returned %u\n",
974 efi_st_printf("got secondary languages are %s\n", languages);
976 result = EFI_ST_SUCCESS;
980 ret = hii_database_protocol->remove_package_list(
981 hii_database_protocol, handle);
982 if (ret != EFI_SUCCESS) {
983 efi_st_error("remove_package_list returned %u\n",
985 return EFI_ST_FAILURE;
992 static int test_hii_string_protocol(void)
996 ret = test_hii_string_new_string();
997 if (ret != EFI_ST_SUCCESS)
998 return EFI_ST_FAILURE;
1000 ret = test_hii_string_get_string();
1001 if (ret != EFI_ST_SUCCESS)
1002 return EFI_ST_FAILURE;
1004 ret = test_hii_string_set_string();
1005 if (ret != EFI_ST_SUCCESS)
1006 return EFI_ST_FAILURE;
1008 ret = test_hii_string_get_languages();
1009 if (ret != EFI_ST_SUCCESS)
1010 return EFI_ST_FAILURE;
1012 ret = test_hii_string_get_secondary_languages();
1013 if (ret != EFI_ST_SUCCESS)
1014 return EFI_ST_FAILURE;
1016 return EFI_ST_SUCCESS;
1020 * Execute unit test.
1022 * @return: EFI_ST_SUCCESS for success, EFI_ST_FAILURE for failure
1024 static int execute(void)
1028 /* HII database protocol */
1029 ret = test_hii_database_protocol();
1030 if (ret != EFI_ST_SUCCESS)
1031 return EFI_ST_FAILURE;
1033 /* HII string protocol */
1034 ret = test_hii_string_protocol();
1035 if (ret != EFI_ST_SUCCESS)
1036 return EFI_ST_FAILURE;
1038 return EFI_ST_SUCCESS;
1041 EFI_UNIT_TEST(hii) = {
1042 .name = "HII database protocols",
1043 .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,