lib/efi_selftest/efi_selftest_unicode_collation.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * efi_selftest_unicode_collation
   4  *
   5  * Copyright (c) 2018 Heinrich Schuchardt <xypron.glpk@gmx.de>
   6  *
   7  * Test unicode collation protocol.
   8  */
   9
  10 #include <efi_selftest.h>
  11
  12 static const efi_guid_t unicode_collation_protocol_guid =
  13         EFI_UNICODE_COLLATION_PROTOCOL2_GUID;
  14
  15 static struct efi_boot_services *boottime;
  16
  17 static struct efi_unicode_collation_protocol *unicode_collation_protocol;
  18
  19 /**
  20  * setup() - setup unit test.
  21  *
  22  * @handle:     handle of the loaded image
  23  * @systable:   system table
  24  * ReturnValue: EFI_ST_SUCCESS for success
  25  */
  26 static int setup(const efi_handle_t handle,
  27                  const struct efi_system_table *systable)
  28 {
  29         efi_status_t ret;
  30
  31         boottime = systable->boottime;
  32
  33         ret = boottime->locate_protocol(&unicode_collation_protocol_guid, NULL,
  34                                         (void **)&unicode_collation_protocol);
  35         if (ret != EFI_SUCCESS) {
  36                 unicode_collation_protocol = NULL;
  37                 efi_st_error("Unicode collation protocol is not available.\n");
  38                 return EFI_ST_FAILURE;
  39         }
  40
  41         return EFI_ST_SUCCESS;
  42 }
  43
  44 static int test_stri_coll(void)
  45 {
  46         efi_intn_t ret;
  47         u16 c1[] = L"first";
  48         u16 c2[] = L"FIRST";
  49         u16 c3[] = L"second";
  50
  51         ret = unicode_collation_protocol->stri_coll(unicode_collation_protocol,
  52                                                     c1, c2);
  53         if (ret) {
  54                 efi_st_error(
  55                         "stri_coll(\"%ps\", \"%ps\") = %d\n", c1, c2, (int)ret);
  56                 return EFI_ST_FAILURE;
  57         }
  58
  59         ret = unicode_collation_protocol->stri_coll(unicode_collation_protocol,
  60                                                     c1, c3);
  61         if (ret >= 0) {
  62                 efi_st_error(
  63                         "stri_coll(\"%ps\", \"%ps\") = %d\n", c1, c3, (int)ret);
  64                 return EFI_ST_FAILURE;
  65         }
  66
  67         ret = unicode_collation_protocol->stri_coll(unicode_collation_protocol,
  68                                                     c3, c1);
  69         if (ret <= 0) {
  70                 efi_st_error(
  71                         "stri_coll(\"%ps\", \"%ps\") = %d\n", c3, c1, (int)ret);
  72                 return EFI_ST_FAILURE;
  73         }
  74
  75         return EFI_ST_SUCCESS;
  76 }
  77
  78 static int test_metai_match(void)
  79 {
  80         bool ret;
  81         const u16 c[] = L"Das U-Boot";
  82
  83         ret = unicode_collation_protocol->metai_match(
  84                 unicode_collation_protocol, c, L"*");
  85         if (!ret) {
  86                 efi_st_error("metai_match returned %u\n", ret);
  87                 return EFI_ST_FAILURE;
  88         }
  89
  90         ret = unicode_collation_protocol->metai_match(
  91                 unicode_collation_protocol, c, L"Da[rstu] U-Boot");
  92         if (!ret) {
  93                 efi_st_error("metai_match returned %u\n", ret);
  94                 return EFI_ST_FAILURE;
  95         }
  96
  97         ret = unicode_collation_protocol->metai_match(
  98                 unicode_collation_protocol, c, L"Da[q-v] U-Boot");
  99         if (!ret) {
 100                 efi_st_error("metai_match returned %u\n", ret);
 101                 return EFI_ST_FAILURE;
 102         }
 103
 104         ret = unicode_collation_protocol->metai_match(
 105                 unicode_collation_protocol, c, L"Da? U-Boot");
 106         if (!ret) {
 107                 efi_st_error("metai_match returned %u\n", ret);
 108                 return EFI_ST_FAILURE;
 109         }
 110
 111         ret = unicode_collation_protocol->metai_match(
 112                 unicode_collation_protocol, c, L"D*Bo*t");
 113         if (!ret) {
 114                 efi_st_error("metai_match returned %u\n", ret);
 115                 return EFI_ST_FAILURE;
 116         }
 117
 118         ret = unicode_collation_protocol->metai_match(
 119                 unicode_collation_protocol, c, L"Da[xyz] U-Boot");
 120         if (ret) {
 121                 efi_st_error("metai_match returned %u\n", ret);
 122                 return EFI_ST_FAILURE;
 123         }
 124
 125         ret = unicode_collation_protocol->metai_match(
 126                 unicode_collation_protocol, c, L"Da[a-d] U-Boot");
 127         if (ret) {
 128                 efi_st_error("metai_match returned %u\n", ret);
 129                 return EFI_ST_FAILURE;
 130         }
 131
 132         ret = unicode_collation_protocol->metai_match(
 133                 unicode_collation_protocol, c, L"Da?? U-Boot");
 134         if (ret) {
 135                 efi_st_error("metai_match returned %u\n", ret);
 136                 return EFI_ST_FAILURE;
 137         }
 138
 139         ret = unicode_collation_protocol->metai_match(
 140                 unicode_collation_protocol, c, L"D*Bo*tt");
 141         if (ret) {
 142                 efi_st_error("metai_match returned %u\n", ret);
 143                 return EFI_ST_FAILURE;
 144         }
 145
 146         return EFI_ST_SUCCESS;
 147 }
 148
 149 static int test_str_lwr(void)
 150 {
 151         u16 c[] = L"U-Boot";
 152
 153         unicode_collation_protocol->str_lwr(unicode_collation_protocol, c);
 154         if (efi_st_strcmp_16_8(c, "u-boot")) {
 155                 efi_st_error("str_lwr returned \"%ps\"\n", c);
 156                 return EFI_ST_FAILURE;
 157         }
 158
 159         return EFI_ST_SUCCESS;
 160 }
 161
 162 static int test_str_upr(void)
 163 {
 164         u16 c[] = L"U-Boot";
 165
 166         unicode_collation_protocol->str_upr(unicode_collation_protocol, c);
 167         if (efi_st_strcmp_16_8(c, "U-BOOT")) {
 168                 efi_st_error("str_lwr returned \"%ps\"\n", c);
 169                 return EFI_ST_FAILURE;
 170         }
 171
 172         return EFI_ST_SUCCESS;
 173 }
 174
 175 static int test_fat_to_str(void)
 176 {
 177         u16 str[16];
 178
 179         boottime->set_mem(str, sizeof(str), 0);
 180         unicode_collation_protocol->fat_to_str(unicode_collation_protocol, 6,
 181                                                "U-BOOT", str);
 182         if (efi_st_strcmp_16_8(str, "U-BOOT")) {
 183                 efi_st_error("fat_to_str returned \"%ps\"\n", str);
 184                 return EFI_ST_FAILURE;
 185         }
 186
 187         return EFI_ST_SUCCESS;
 188 }
 189
 190 static int test_str_to_fat(void)
 191 {
 192         char fat[16];
 193         bool ret;
 194
 195         boottime->set_mem(fat, sizeof(fat), 0);
 196         ret = unicode_collation_protocol->str_to_fat(unicode_collation_protocol,
 197                                                      L"U -Boo.t", 6, fat);
 198         if (ret || efi_st_strcmp_16_8(L"U-BOOT", fat)) {
 199                 efi_st_error("str_to_fat returned %u, \"%s\"\n", ret, fat);
 200                 return EFI_ST_FAILURE;
 201         }
 202
 203         boottime->set_mem(fat, 16, 0);
 204         ret = unicode_collation_protocol->str_to_fat(unicode_collation_protocol,
 205                                                      L"U\\Boot", 6, fat);
 206         if (!ret || efi_st_strcmp_16_8(L"U_BOOT", fat)) {
 207                 efi_st_error("str_to_fat returned %u, \"%s\"\n", ret, fat);
 208                 return EFI_ST_FAILURE;
 209         }
 210
 211         return EFI_ST_SUCCESS;
 212 }
 213
 214 /**
 215  * execute() - Execute unit test.
 216  *
 217  * ReturnValue: EFI_ST_SUCCESS for success
 218  */
 219 static int execute(void)
 220 {
 221         int ret;
 222
 223         if (!unicode_collation_protocol) {
 224                 efi_st_printf("Unicode collation protocol missing\n");
 225                 return EFI_ST_FAILURE;
 226         }
 227
 228         ret = test_stri_coll();
 229         if (ret != EFI_ST_SUCCESS)
 230                 return ret;
 231
 232         ret = test_metai_match();
 233         if (ret != EFI_ST_SUCCESS)
 234                 return ret;
 235
 236         ret = test_str_lwr();
 237         if (ret != EFI_ST_SUCCESS)
 238                 return ret;
 239
 240         ret = test_str_upr();
 241         if (ret != EFI_ST_SUCCESS)
 242                 return ret;
 243
 244         ret = test_fat_to_str();
 245         if (ret != EFI_ST_SUCCESS)
 246                 return ret;
 247
 248         ret = test_str_to_fat();
 249         if (ret != EFI_ST_SUCCESS)
 250                 return ret;
 251
 252         return EFI_ST_SUCCESS;
 253 }
 254
 255 EFI_UNIT_TEST(unicoll) = {
 256         .name = "unicode collation",
 257         .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
 258         .execute = execute,
 259         .setup = setup,
 260 };