efi_selftest_hii.c 27 KB

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