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",
213 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
214 EFI_HII_PACKAGE_STRINGS, NULL,
215 &handles_size, handles);
216 if (ret != EFI_BUFFER_TOO_SMALL) {
217 efi_st_error("list_package_lists returned %u\n",
219 ret = EFI_ST_FAILURE;
222 handles = malloc(handles_size);
224 efi_st_error("malloc failed\n");
225 ret = EFI_ST_FAILURE;
228 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
229 EFI_HII_PACKAGE_STRINGS, NULL,
230 &handles_size, handles);
231 if (ret != EFI_SUCCESS) {
232 efi_st_error("list_package_lists returned %u\n",
234 ret = EFI_ST_FAILURE;
242 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
243 EFI_HII_PACKAGE_TYPE_GUID, &package_guid,
244 &handles_size, handles);
245 if (ret != EFI_BUFFER_TOO_SMALL) {
246 efi_st_error("list_package_lists returned %u\n",
248 ret = EFI_ST_FAILURE;
251 handles = malloc(handles_size);
253 efi_st_error("malloc failed\n");
254 ret = EFI_ST_FAILURE;
257 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
258 EFI_HII_PACKAGE_TYPE_GUID, &package_guid,
259 &handles_size, handles);
260 if (ret != EFI_SUCCESS) {
261 efi_st_error("list_package_lists returned %u\n",
263 ret = EFI_ST_FAILURE;
268 /* KEYBOARD_LAYOUT */
271 ret = hii_database_protocol->list_package_lists(hii_database_protocol,
272 EFI_HII_PACKAGE_KEYBOARD_LAYOUT, NULL,
273 &handles_size, handles);
274 if (ret != EFI_BUFFER_TOO_SMALL) {
275 efi_st_error("list_package_lists returned %u\n",
277 ret = EFI_ST_FAILURE;
280 handles = malloc(handles_size);
282 efi_st_error("malloc failed\n");
283 ret = EFI_ST_FAILURE;
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_SUCCESS) {
290 efi_st_error("list_package_lists returned %u\n",
292 ret = EFI_ST_FAILURE;
297 result = EFI_ST_SUCCESS;
301 ret = hii_database_protocol->remove_package_list(
302 hii_database_protocol, handle1);
303 if (ret != EFI_SUCCESS)
304 efi_st_error("remove_package_list returned %u\n",
308 ret = hii_database_protocol->remove_package_list(
309 hii_database_protocol, handle2);
310 if (ret != EFI_SUCCESS)
311 efi_st_error("remove_package_list returned %u\n",
319 * test_hii_database_export_package_lists() - test export of package lists
321 * @Return: status code
323 static int test_hii_database_export_package_lists(void)
326 /* export_package_lists() not implemented yet */
327 return EFI_ST_SUCCESS;
331 * test_hii_database_register_package_notify() - test registration of
332 * notification function
334 * @Return: status code
336 static int test_hii_database_register_package_notify(void)
339 /* register_package_notify() not implemented yet */
340 return EFI_ST_SUCCESS;
344 * test_hii_database_unregister_package_notify() - test removal of
345 * notification function
347 * @Return: status code
349 static int test_hii_database_unregister_package_notify(void)
352 /* unregsiter_package_notify() not implemented yet */
353 return EFI_ST_SUCCESS;
357 * test_hii_database_find_keyboard_layouts() - test listing of
358 * all the keyboard layouts in the system
360 * This test adds two package lists, each of which has two keyboard layouts
361 * and then tries to enumerate them. We will get an array of handles.
363 * @Return: status code
365 static int test_hii_database_find_keyboard_layouts(void)
367 efi_hii_handle_t handle1 = NULL, handle2 = NULL;
371 int result = EFI_ST_FAILURE;
374 ret = hii_database_protocol->new_package_list(hii_database_protocol,
375 (struct efi_hii_package_list_header *)packagelist1,
377 if (ret != EFI_SUCCESS || !handle1) {
378 efi_st_error("new_package_list returned %u\n",
383 ret = hii_database_protocol->new_package_list(hii_database_protocol,
384 (struct efi_hii_package_list_header *)packagelist2,
386 if (ret != EFI_SUCCESS || !handle2) {
387 efi_st_error("new_package_list returned %u\n",
394 ret = hii_database_protocol->find_keyboard_layouts(
395 hii_database_protocol, &guids_size, guids);
396 if (ret != EFI_BUFFER_TOO_SMALL) {
397 efi_st_error("find_keyboard_layouts returned %u\n",
401 guids = malloc(guids_size);
403 efi_st_error("malloc failed\n");
406 ret = hii_database_protocol->find_keyboard_layouts(
407 hii_database_protocol, &guids_size, guids);
408 if (ret != EFI_SUCCESS) {
409 efi_st_error("find_keyboard_layouts returned %u\n",
415 result = EFI_ST_SUCCESS;
419 ret = hii_database_protocol->remove_package_list(
420 hii_database_protocol, handle1);
421 if (ret != EFI_SUCCESS)
422 efi_st_error("remove_package_list returned %u\n",
426 ret = hii_database_protocol->remove_package_list(
427 hii_database_protocol, handle2);
428 if (ret != EFI_SUCCESS)
429 efi_st_error("remove_package_list returned %u\n",
437 * test_hii_database_get_keyboard_layout() - test retrieval of keyboard layout
439 * This test adds two package lists, each of which has two keyboard layouts
440 * and then tries to get a handle to keyboard layout with a specific guid
441 * and the current one.
443 * @Return: status code
445 static int test_hii_database_get_keyboard_layout(void)
447 efi_hii_handle_t handle1 = NULL, handle2 = NULL;
448 struct efi_hii_keyboard_layout *kb_layout;
451 int result = EFI_ST_FAILURE;
454 ret = hii_database_protocol->new_package_list(hii_database_protocol,
455 (struct efi_hii_package_list_header *)packagelist1,
457 if (ret != EFI_SUCCESS || !handle1) {
458 efi_st_error("new_package_list returned %u\n",
463 ret = hii_database_protocol->new_package_list(hii_database_protocol,
464 (struct efi_hii_package_list_header *)packagelist2,
466 if (ret != EFI_SUCCESS || !handle2) {
467 efi_st_error("new_package_list returned %u\n",
472 /* specific keyboard_layout(guid11) */
475 ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol,
476 &kb_layout_guid11, &kb_layout_size, kb_layout);
477 if (ret != EFI_BUFFER_TOO_SMALL) {
478 efi_st_error("get_keyboard_layout returned %u\n",
482 kb_layout = malloc(kb_layout_size);
484 efi_st_error("malloc failed\n");
487 ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol,
488 &kb_layout_guid11, &kb_layout_size, kb_layout);
489 if (ret != EFI_SUCCESS) {
490 efi_st_error("get_keyboard_layout returned %u\n",
499 ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol,
500 NULL, &kb_layout_size, kb_layout);
501 if (ret != EFI_INVALID_PARAMETER) {
502 efi_st_error("get_keyboard_layout returned %u\n",
507 result = EFI_ST_SUCCESS;
511 ret = hii_database_protocol->remove_package_list(
512 hii_database_protocol, handle1);
513 if (ret != EFI_SUCCESS)
514 efi_st_error("remove_package_list returned %u\n",
518 ret = hii_database_protocol->remove_package_list(
519 hii_database_protocol, handle2);
520 if (ret != EFI_SUCCESS)
521 efi_st_error("remove_package_list returned %u\n",
529 * test_hii_database_set_keyboard_layout() - test change of
530 * current keyboard layout
532 * @Return: status code
534 static int test_hii_database_set_keyboard_layout(void)
537 /* set_keyboard_layout() not implemented yet */
538 return EFI_ST_SUCCESS;
542 * test_hii_database_get_package_list_handle() - test retrieval of
543 * driver associated with a package list
545 * This test adds a package list, and then tries to get a handle to driver
546 * which is associated with a package list.
548 * @Return: status code
550 static int test_hii_database_get_package_list_handle(void)
552 efi_hii_handle_t handle = NULL;
553 efi_handle_t driver_handle;
555 int result = EFI_ST_FAILURE;
558 driver_handle = (efi_handle_t)0x12345678; /* dummy */
559 ret = hii_database_protocol->new_package_list(hii_database_protocol,
560 (struct efi_hii_package_list_header *)packagelist1,
561 driver_handle, &handle);
562 if (ret != EFI_SUCCESS || !handle) {
563 efi_st_error("new_package_list returned %u\n",
565 return EFI_ST_FAILURE;
568 driver_handle = NULL;
569 ret = hii_database_protocol->get_package_list_handle(
570 hii_database_protocol, handle, &driver_handle);
571 if (ret != EFI_SUCCESS || driver_handle != (efi_handle_t)0x12345678) {
572 efi_st_error("get_package_list_handle returned %u, driver:%p\n",
573 (unsigned int)ret, driver_handle);
577 result = EFI_ST_SUCCESS;
581 ret = hii_database_protocol->remove_package_list(
582 hii_database_protocol, handle);
583 if (ret != EFI_SUCCESS) {
584 efi_st_error("remove_package_list returned %u\n",
586 return EFI_ST_FAILURE;
593 static int test_hii_database_protocol(void)
597 ret = test_hii_database_new_package_list();
598 if (ret != EFI_ST_SUCCESS)
599 return EFI_ST_FAILURE;
601 ret = test_hii_database_update_package_list();
602 if (ret != EFI_ST_SUCCESS)
603 return EFI_ST_FAILURE;
605 ret = test_hii_database_list_package_lists();
606 if (ret != EFI_ST_SUCCESS)
607 return EFI_ST_FAILURE;
609 ret = test_hii_database_export_package_lists();
610 if (ret != EFI_ST_SUCCESS)
611 return EFI_ST_FAILURE;
613 ret = test_hii_database_register_package_notify();
614 if (ret != EFI_ST_SUCCESS)
615 return EFI_ST_FAILURE;
617 ret = test_hii_database_unregister_package_notify();
618 if (ret != EFI_ST_SUCCESS)
619 return EFI_ST_FAILURE;
621 ret = test_hii_database_find_keyboard_layouts();
622 if (ret != EFI_ST_SUCCESS)
623 return EFI_ST_FAILURE;
625 ret = test_hii_database_get_keyboard_layout();
626 if (ret != EFI_ST_SUCCESS)
627 return EFI_ST_FAILURE;
629 ret = test_hii_database_set_keyboard_layout();
630 if (ret != EFI_ST_SUCCESS)
631 return EFI_ST_FAILURE;
633 ret = test_hii_database_get_package_list_handle();
634 if (ret != EFI_ST_SUCCESS)
635 return EFI_ST_FAILURE;
637 return EFI_ST_SUCCESS;
641 * HII string protocol tests
645 * test_hii_string_new_string() - test creation of a new string entry
647 * This test adds a package list, and then tries to add a new string
648 * entry for a specific language.
650 * @Return: status code
652 static int test_hii_string_new_string(void)
654 efi_hii_handle_t handle = NULL;
657 int result = EFI_ST_FAILURE;
660 ret = hii_database_protocol->new_package_list(hii_database_protocol,
661 (struct efi_hii_package_list_header *)packagelist1,
663 if (ret != EFI_SUCCESS || !handle) {
664 efi_st_error("new_package_list returned %u\n",
666 return EFI_ST_FAILURE;
669 ret = hii_string_protocol->new_string(hii_string_protocol, handle,
671 L"Japanese", L"Japanese", NULL);
672 if (ret != EFI_SUCCESS) {
673 efi_st_error("new_string returned %u\n",
677 efi_st_printf("new string id is %u\n", id);
679 result = EFI_ST_SUCCESS;
683 ret = hii_database_protocol->remove_package_list(
684 hii_database_protocol, handle);
685 if (ret != EFI_SUCCESS) {
686 efi_st_error("remove_package_list returned %u\n",
688 return EFI_ST_FAILURE;
696 * test_hii_string_get_string() - test retrieval of a string entry
698 * This test adds a package list, create a new string entry and then tries
699 * to get it with its string id.
701 * @Return: status code
703 static int test_hii_string_get_string(void)
705 efi_hii_handle_t handle = NULL;
708 efi_uintn_t string_len;
710 int result = EFI_ST_FAILURE;
713 ret = hii_database_protocol->new_package_list(hii_database_protocol,
714 (struct efi_hii_package_list_header *)packagelist1,
716 if (ret != EFI_SUCCESS || !handle) {
717 efi_st_error("new_package_list returned %u\n",
719 return EFI_ST_FAILURE;
722 ret = hii_string_protocol->new_string(hii_string_protocol, handle,
724 L"Japanese", L"Japanese", NULL);
725 if (ret != EFI_SUCCESS) {
726 efi_st_error("new_string returned %u\n",
733 ret = hii_string_protocol->get_string(hii_string_protocol,
734 (u8 *)"en-US", handle, id, string, &string_len, NULL);
735 if (ret != EFI_BUFFER_TOO_SMALL) {
736 efi_st_error("get_string returned %u\n",
740 string_len += sizeof(u16);
741 string = malloc(string_len);
743 efi_st_error("malloc failed\n");
746 ret = hii_string_protocol->get_string(hii_string_protocol,
747 (u8 *)"en-US", handle, id, string, &string_len, NULL);
748 if (ret != EFI_SUCCESS) {
749 efi_st_error("get_string returned %u\n",
757 for (c1 = string, c2 = L"Japanese"; *c1 == *c2; c1++, c2++)
760 result = EFI_ST_SUCCESS;
762 result = EFI_ST_FAILURE;
765 efi_st_printf("got string is %s (can be wrong)\n", string);
768 result = EFI_ST_SUCCESS;
772 ret = hii_database_protocol->remove_package_list(
773 hii_database_protocol, handle);
774 if (ret != EFI_SUCCESS) {
775 efi_st_error("remove_package_list returned %u\n",
777 return EFI_ST_FAILURE;
785 * test_hii_string_set_string() - test change of a string entry
787 * This test adds a package list, create a new string entry and then tries
790 * @Return: status code
792 static int test_hii_string_set_string(void)
794 efi_hii_handle_t handle = NULL;
797 int result = EFI_ST_FAILURE;
800 ret = hii_database_protocol->new_package_list(hii_database_protocol,
801 (struct efi_hii_package_list_header *)packagelist1,
803 if (ret != EFI_SUCCESS || !handle) {
804 efi_st_error("new_package_list returned %u\n",
806 return EFI_ST_FAILURE;
809 ret = hii_string_protocol->new_string(hii_string_protocol, handle,
811 L"Japanese", L"Japanese", NULL);
812 if (ret != EFI_SUCCESS) {
813 efi_st_error("new_string returned %u\n",
818 ret = hii_string_protocol->set_string(hii_string_protocol, handle,
821 if (ret != EFI_SUCCESS) {
822 efi_st_error("set_string returned %u\n",
827 result = EFI_ST_SUCCESS;
831 ret = hii_database_protocol->remove_package_list(
832 hii_database_protocol, handle);
833 if (ret != EFI_SUCCESS) {
834 efi_st_error("remove_package_list returned %u\n",
836 return EFI_ST_FAILURE;
844 * test_hii_string_get_languages() - test listing of languages
846 * This test adds a package list, and then tries to enumerate languages
847 * in it. We will get an string of language names.
849 * @Return: status code
851 static int test_hii_string_get_languages(void)
853 efi_hii_handle_t handle = NULL;
855 efi_uintn_t languages_len;
857 int result = EFI_ST_FAILURE;
860 ret = hii_database_protocol->new_package_list(hii_database_protocol,
861 (struct efi_hii_package_list_header *)packagelist1,
863 if (ret != EFI_SUCCESS || !handle) {
864 efi_st_error("new_package_list returned %u\n",
866 return EFI_ST_FAILURE;
871 ret = hii_string_protocol->get_languages(hii_string_protocol, handle,
872 languages, &languages_len);
873 if (ret != EFI_BUFFER_TOO_SMALL) {
874 efi_st_error("get_languages returned %u\n",
878 languages = malloc(languages_len);
880 efi_st_error("malloc failed\n");
883 ret = hii_string_protocol->get_languages(hii_string_protocol, handle,
884 languages, &languages_len);
885 if (ret != EFI_SUCCESS) {
886 efi_st_error("get_languages returned %u\n",
891 efi_st_printf("got languages are %s\n", languages);
893 result = EFI_ST_SUCCESS;
897 ret = hii_database_protocol->remove_package_list(
898 hii_database_protocol, handle);
899 if (ret != EFI_SUCCESS) {
900 efi_st_error("remove_package_list returned %u\n",
902 return EFI_ST_FAILURE;
910 * test_hii_string_get_secondary_languages() - test listing of secondary
913 * This test adds a package list, and then tries to enumerate secondary
914 * languages with a specific language. We will get an string of language names.
916 * @Return: status code
918 static int test_hii_string_get_secondary_languages(void)
920 efi_hii_handle_t handle = NULL;
922 efi_uintn_t languages_len;
924 int result = EFI_ST_FAILURE;
927 ret = hii_database_protocol->new_package_list(hii_database_protocol,
928 (struct efi_hii_package_list_header *)packagelist1,
930 if (ret != EFI_SUCCESS || !handle) {
931 efi_st_error("new_package_list returned %u\n",
933 return EFI_ST_FAILURE;
938 ret = hii_string_protocol->get_secondary_languages(hii_string_protocol,
939 handle, (u8 *)"en-US", languages, &languages_len);
940 if (ret == EFI_NOT_FOUND) {
941 efi_st_printf("no secondary languages\n");
942 result = EFI_ST_SUCCESS;
945 if (ret != EFI_BUFFER_TOO_SMALL) {
946 efi_st_error("get_secondary_languages returned %u\n",
950 languages = malloc(languages_len);
952 efi_st_error("malloc failed\n");
955 ret = hii_string_protocol->get_secondary_languages(hii_string_protocol,
956 handle, (u8 *)"en-US", languages, &languages_len);
957 if (ret != EFI_SUCCESS) {
958 efi_st_error("get_secondary_languages returned %u\n",
963 efi_st_printf("got secondary languages are %s\n", languages);
965 result = EFI_ST_SUCCESS;
969 ret = hii_database_protocol->remove_package_list(
970 hii_database_protocol, handle);
971 if (ret != EFI_SUCCESS) {
972 efi_st_error("remove_package_list returned %u\n",
974 return EFI_ST_FAILURE;
981 static int test_hii_string_protocol(void)
985 ret = test_hii_string_new_string();
986 if (ret != EFI_ST_SUCCESS)
987 return EFI_ST_FAILURE;
989 ret = test_hii_string_get_string();
990 if (ret != EFI_ST_SUCCESS)
991 return EFI_ST_FAILURE;
993 ret = test_hii_string_set_string();
994 if (ret != EFI_ST_SUCCESS)
995 return EFI_ST_FAILURE;
997 ret = test_hii_string_get_languages();
998 if (ret != EFI_ST_SUCCESS)
999 return EFI_ST_FAILURE;
1001 ret = test_hii_string_get_secondary_languages();
1002 if (ret != EFI_ST_SUCCESS)
1003 return EFI_ST_FAILURE;
1005 return EFI_ST_SUCCESS;
1009 * Execute unit test.
1011 * @return: EFI_ST_SUCCESS for success, EFI_ST_FAILURE for failure
1013 static int execute(void)
1017 /* HII database protocol */
1018 ret = test_hii_database_protocol();
1019 if (ret != EFI_ST_SUCCESS)
1020 return EFI_ST_FAILURE;
1022 /* HII string protocol */
1023 ret = test_hii_string_protocol();
1024 if (ret != EFI_ST_SUCCESS)
1025 return EFI_ST_FAILURE;
1027 return EFI_ST_SUCCESS;
1030 EFI_UNIT_TEST(hii) = {
1031 .name = "HII database protocols",
1032 .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,