1 // SPDX-License-Identifier: BSD-2-Clause-Patent
3 * test-mock-variables.c - test our mock variable implementation (irony)
4 * Copyright Peter Jones <pjones@redhat.com>
8 #include "mock-variables.h"
11 #include <efivar/efivar.h>
13 #include <sys/types.h>
16 #include "test-data-efivars-0.h"
18 #pragma GCC diagnostic ignored "-Wunused-label"
20 static const size_t guidstr_size
= sizeof("8be4df61-93ca-11d2-aa0d-00e098032b8c");
22 void mock_print_guidname(EFI_GUID
*guid
, CHAR16
*name
);
23 void mock_print_var_list(list_t
*head
);
26 test_filter_out_helper(size_t nvars
, const CHAR16
*varnames
[nvars
],
27 bool filter_out
, UINTN expected_count
)
29 const char *mok_rt_vars
[n_mok_state_variables
];
31 EFI_GUID guid
= SHIM_LOCK_GUID
;
32 CHAR16 name
[1024] = L
"";
39 for (size_t i
= 0; i
< n_mok_state_variables
; i
++) {
40 mok_rt_vars
[i
] = mok_state_variables
[i
].rtname8
;
44 status
= RT
->GetNextVariableName(&sz
, name
, &guid
);
45 assert_equal_return(status
, EFI_NOT_FOUND
, -1, "got %lx, expected %lx");
47 mock_load_variables("test-data/efivars-1", mok_rt_vars
, filter_out
);
53 status
= RT
->GetNextVariableName(&sz
, name
, &guid
);
54 if (status
== EFI_NOT_FOUND
)
56 if (EFI_ERROR(status
))
60 SetMem(asciiname
, sizeof(asciiname
), 0);
61 for (UINTN i
= 0; i
< sizeof(asciiname
); i
++)
62 asciiname
[i
] = name
[i
];
63 for (UINTN i
= 0; varnames
[i
] != NULL
; i
++) {
64 if (sz
== 0 || StrLen(varnames
[i
]) != sz
-1)
66 if (StrCmp(name
, varnames
[i
]) == 0) {
69 rc
= assert_false_as_expr(found
, -1,
70 "found=%u for undesired variable \"%s\"\n",
77 rc
= assert_true_as_expr(found
, -1,
78 "found=%u for undesired variable \"%s\"\n",
80 if (ret
>= 0 && rc
< 0)
84 mock_reset_variables();
85 assert_equal_return(count
, expected_count
, -1, "%lu != %lu\n");
86 assert_true_return(list_empty(&mock_variables
), -1, "%lu != %lu\n");
92 test_filter_out_true(void)
94 const CHAR16
*varnames
[] = {
100 size_t nvars
= sizeof(varnames
) / sizeof(varnames
[0]);
102 return test_filter_out_helper(nvars
, varnames
, true, 3);
106 test_filter_out_false(void)
108 const CHAR16
*varnames
[] = {
114 size_t nvars
= sizeof(varnames
) / sizeof(varnames
[0]);
116 return test_filter_out_helper(nvars
, varnames
, false, 3);
120 test_gnvn_buf_size_0(void)
123 CHAR16 buf
[6] = { 0, };
125 EFI_GUID empty_guid
= { 0, };
128 status
= RT
->GetNextVariableName(&size
, &buf
[0], &GV_GUID
);
129 assert_equal_return(status
, EFI_INVALID_PARAMETER
, -1, "0x%lx != 0x%lx\n");
132 status
= RT
->GetNextVariableName(&size
, &buf
[0], &GV_GUID
);
133 assert_equal_return(status
, EFI_NOT_FOUND
, -1, "0x%lx != 0x%lx\n");
135 status
= RT
->SetVariable(L
"test", &GV_GUID
,
136 EFI_VARIABLE_BOOTSERVICE_ACCESS
, 5, "test");
137 assert_equal_return(status
, EFI_SUCCESS
, -1, "0x%lx != 0x%lx\n");
140 status
= RT
->GetNextVariableName(&size
, &buf
[0], &empty_guid
);
141 assert_equal_goto(status
, EFI_NOT_FOUND
, err
, "0x%lx != 0x%lx\n");
144 status
= RT
->GetNextVariableName(&size
, &buf
[0], &GV_GUID
);
145 assert_equal_goto(status
, EFI_BUFFER_TOO_SMALL
, err
, "0x%lx != 0x%lx\n");
146 assert_equal_goto(size
, StrSize(L
"test"), err
, "%zu != %zu\n");
148 size
= StrSize(L
"test");
149 status
= RT
->GetNextVariableName(&size
, &buf
[0], &GV_GUID
);
150 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
152 status
= RT
->SetVariable(L
"testa", &GV_GUID
,
153 EFI_VARIABLE_BOOTSERVICE_ACCESS
, 5, "test");
154 assert_equal_return(status
, EFI_SUCCESS
, -1, "0x%lx != 0x%lx\n");
158 status
= RT
->GetNextVariableName(&size
, &buf
[0], &empty_guid
);
159 assert_equal_goto(status
, EFI_NOT_FOUND
, err
, "0x%lx != 0x%lx\n");
161 size
= StrSize(L
"test");
162 StrCpy(buf
, L
"test");
163 status
= RT
->GetNextVariableName(&size
, &buf
[0], &GV_GUID
);
164 switch (mock_variable_sort_policy
) {
165 case MOCK_SORT_DESCENDING
:
166 case MOCK_SORT_PREPEND
:
167 assert_equal_goto(status
, EFI_NOT_FOUND
, err
, "0x%lx != 0x%lx\n");
169 case MOCK_SORT_APPEND
:
170 case MOCK_SORT_ASCENDING
:
171 assert_equal_goto(status
, EFI_BUFFER_TOO_SMALL
, err
, "0x%lx != 0x%lx\n");
177 size
= StrSize(L
"testa");
178 StrCpy(buf
, L
"test");
179 status
= RT
->GetNextVariableName(&size
, &buf
[0], &GV_GUID
);
180 switch (mock_variable_sort_policy
) {
181 case MOCK_SORT_DESCENDING
:
182 case MOCK_SORT_PREPEND
:
183 assert_equal_goto(status
, EFI_NOT_FOUND
, err
, "0x%lx != 0x%lx\n");
185 case MOCK_SORT_APPEND
:
186 case MOCK_SORT_ASCENDING
:
187 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
195 mock_reset_variables();
200 test_gnvn_helper(char *testvars
)
203 CHAR16 buf
[8192] = { 0, };
205 EFI_GUID empty_guid
= { 0, };
207 const char *mok_rt_vars
[n_mok_state_variables
];
209 for (size_t i
= 0; i
< n_mok_state_variables
; i
++) {
210 mok_rt_vars
[i
] = mok_state_variables
[i
].rtname8
;
213 mock_load_variables(testvars
, mok_rt_vars
, true);
217 status
= RT
->GetNextVariableName(&size
, buf
, &GV_GUID
);
218 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
220 #if defined(SHIM_DEBUG) && SHIM_DEBUG != 0
221 dump_mock_variables(__FILE__
, __LINE__
, __func__
);
223 switch (mock_variable_sort_policy
) {
224 case MOCK_SORT_DESCENDING
:
225 dump_mock_variables_if_wrong(__FILE__
, __LINE__
, __func__
,
226 &GV_GUID
, L
"dbxDefault");
227 assert_zero_goto(StrCmp(buf
, L
"dbxDefault"), err
, "0x%lx != 0x%lx\n");
229 case MOCK_SORT_ASCENDING
:
230 dump_mock_variables_if_wrong(__FILE__
, __LINE__
, __func__
,
231 &GV_GUID
, L
"Boot0000");
232 assert_zero_goto(StrCmp(buf
, L
"Boot0000"), err
, "0x%lx != 0x%lx buf:\"%s\"\n",
241 status
= RT
->GetNextVariableName(&size
, buf
, &EFI_SECURE_BOOT_DB_GUID
);
242 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
243 switch (mock_variable_sort_policy
) {
244 case MOCK_SORT_DESCENDING
:
245 assert_zero_goto(StrCmp(buf
, L
"dbx"), err
, "0x%lx != 0x%lx\n");
247 case MOCK_SORT_ASCENDING
:
248 assert_zero_goto(StrCmp(buf
, L
"db"), err
, "0x%lx != 0x%lx\n");
257 mock_print_var_list(&mock_variables
);
258 mock_reset_variables();
265 return test_gnvn_helper("test-data/efivars-0");
271 return test_gnvn_helper("test-data/efivars-1");
275 test_get_variable_0(void)
278 uint8_t buf
[8192] = { 0, };
280 EFI_GUID empty_guid
= { 0, };
284 const char *mok_rt_vars
[n_mok_state_variables
];
286 for (size_t i
= 0; i
< n_mok_state_variables
; i
++) {
287 mok_rt_vars
[i
] = mok_state_variables
[i
].rtname8
;
290 mock_load_variables("test-data/efivars-1", mok_rt_vars
, true);
293 status
= RT
->GetVariable(L
"Boot0000", &GV_GUID
, &attrs
, &size
, buf
);
294 assert_equal_goto(status
, EFI_BUFFER_TOO_SMALL
, err
, "0x%lx != 0x%lx\n");
297 status
= RT
->GetVariable(L
"Boot0000", &GV_GUID
, &attrs
, &size
, buf
);
298 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
299 assert_equal_goto(size
, sizeof(test_data_efivars_0_Boot0000
), err
, "%zu != %zu\n");
300 assert_zero_goto(memcmp(buf
, test_data_efivars_0_Boot0000
, size
), err
, "%zu != %zu\n");
305 mock_print_var_list(&mock_variables
);
306 mock_reset_variables();
311 test_set_variable_0(void)
314 uint8_t buf
[8192] = { 0, };
316 EFI_GUID empty_guid
= { 0, };
319 UINT32 bs_rt_nv
= EFI_VARIABLE_BOOTSERVICE_ACCESS
|
320 EFI_VARIABLE_RUNTIME_ACCESS
|
321 EFI_VARIABLE_NON_VOLATILE
;
325 status
= RT
->SetVariable(L
"tmp", &GV_GUID
, bs_rt_nv
, size
, buf
);
326 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
329 SetMem(buf
, sizeof(buf
), 0);
330 status
= RT
->GetVariable(L
"tmp", &GV_GUID
, &attrs
, &size
, buf
);
331 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
332 assert_equal_goto(size
, 4, err
, "%zu != %zu\n");
333 assert_zero_goto(memcmp(buf
, "foo", 4), err
, "0x%lx != 0x%lx\n");
337 status
= RT
->SetVariable(L
"tmp", &GV_GUID
,
338 EFI_VARIABLE_NON_VOLATILE
|
339 EFI_VARIABLE_BOOTSERVICE_ACCESS
|
340 EFI_VARIABLE_RUNTIME_ACCESS
,
343 SetMem(buf
, sizeof(buf
), 0);
344 status
= RT
->GetVariable(L
"tmp", &GV_GUID
, &attrs
, &size
, buf
);
345 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
346 assert_equal_goto(size
, 5, err
, "%zu != %zu\n");
347 assert_zero_goto(memcmp(buf
, "bang", 5), err
, "%d != %d\n");
351 status
= RT
->SetVariable(L
"tmp", &GV_GUID
, bs_rt_nv
, size
, buf
);
352 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
355 SetMem(buf
, sizeof(buf
), 0);
356 status
= RT
->GetVariable(L
"tmp", &GV_GUID
, &attrs
, &size
, buf
);
357 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
358 assert_equal_goto(size
, 5, err
, "%zu != %zu\n");
359 assert_zero_goto(memcmp(buf
, "foop", 5), err
, "%d != %d\n");
363 status
= RT
->SetVariable(L
"tmp", &GV_GUID
, bs_rt_nv
| EFI_VARIABLE_APPEND_WRITE
, size
, buf
);
364 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
367 SetMem(buf
, sizeof(buf
), 0);
368 status
= RT
->GetVariable(L
"tmp", &GV_GUID
, &attrs
, &size
, buf
);
369 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
370 assert_equal_goto(size
, 5, err
, "%zu != %zu\n");
371 assert_zero_goto(memcmp(buf
, "foop", 5), err
, "%d != %d\n");
375 status
= RT
->SetVariable(L
"tmp", &GV_GUID
, bs_rt_nv
| EFI_VARIABLE_APPEND_WRITE
, size
, buf
);
376 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
379 SetMem(buf
, sizeof(buf
), 0);
380 status
= RT
->GetVariable(L
"tmp", &GV_GUID
, &attrs
, &size
, buf
);
381 assert_equal_goto(status
, EFI_SUCCESS
, err
, "0x%lx != 0x%lx\n");
382 assert_equal_goto(size
, 10, err
, "%zu != %zu\n");
383 assert_zero_goto(memcmp(buf
, "foop\0poof", 10), err
, "%d != %d\n");
387 mock_print_var_list(&mock_variables
);
388 mock_reset_variables();
393 dump_config_table_if_wrong(const char * const func
, int line
, ...)
395 va_list alist
, blist
;
399 va_start(alist
, line
);
400 va_copy(blist
, alist
);
402 int idx
= va_arg(alist
, int);
403 EFI_GUID
*guid
= va_arg(alist
, EFI_GUID
*);
404 while (idx
>= 0 && guid
!= NULL
) {
405 EFI_CONFIGURATION_TABLE
*entry
;
410 if (idx
>= (int)ST
->NumberOfTableEntries
) {
415 entry
= &ST
->ConfigurationTable
[idx
];
416 if (CompareGuid(guid
, &entry
->VendorGuid
) != 0)
420 idx
= va_arg(alist
, int);
421 guid
= va_arg(alist
, EFI_GUID
*);
428 printf("%s:%d:%s(): %d entries:\n", __FILE__
, line
, func
, ST
->NumberOfTableEntries
);
429 idx
= va_arg(blist
, int);
430 guid
= va_arg(blist
, EFI_GUID
*);
431 while (idx
>= 0 && guid
!= NULL
) {
432 EFI_CONFIGURATION_TABLE
*entry
;
434 if (idx
>= (int)ST
->NumberOfTableEntries
) {
435 printf("\t[%d]: invalid index for " GUID_FMT
"\n",
436 idx
, GUID_ARGS(*guid
));
441 printf("\t[%d]: " GUID_FMT
"\n", idx
, GUID_ARGS(*guid
));
443 entry
= &ST
->ConfigurationTable
[idx
];
444 printf("\t[%d]: %p ", idx
, entry
);
445 printf("{.VendorGuid:" GUID_FMT
",", GUID_ARGS(entry
->VendorGuid
));
446 printf("&.VendorTable:%p}\n", entry
->VendorTable
);
447 if (CompareGuid(guid
, &entry
->VendorGuid
) != 0)
448 printf("\t\t\t expected:" GUID_FMT
"\n", GUID_ARGS(*guid
));
451 idx
= va_arg(blist
, int);
452 guid
= va_arg(blist
, EFI_GUID
*);
456 if ((int)ST
->NumberOfTableEntries
- n
== 0)
459 printf("%d extra table entries:\n", ST
->NumberOfTableEntries
- n
);
460 for (m
= n
; m
< ST
->NumberOfTableEntries
; m
++) {
461 EFI_CONFIGURATION_TABLE
*entry
;
463 entry
= &ST
->ConfigurationTable
[m
];
465 printf("\t[%d]: %p ", m
, entry
);
466 printf("{.VendorGuid:" GUID_FMT
",", GUID_ARGS(entry
->VendorGuid
));
467 printf("&.VendorTable:%p}\n", entry
->VendorTable
);
472 test_install_config_table_0(void)
478 * These three guids are chosen on purpose: they start with "a",
479 * "b", and "c", respective to their variable names, so you can
480 * identify them when dumped.
482 EFI_GUID aguid
= SECURITY_PROTOCOL_GUID
;
483 char astr
[guidstr_size
];
484 void *astrp
= &astr
[0];
487 EFI_GUID bguid
= EFI_HTTP_BINDING_GUID
;
488 char bstr
[guidstr_size
];
489 void *bstrp
= &bstr
[0];
492 EFI_GUID cguid
= MOK_VARIABLE_STORE
;
493 char cstr
[guidstr_size
];
494 void *cstrp
= &cstr
[0];
497 EFI_GUID lip
= LOADED_IMAGE_PROTOCOL
;
501 char tmpstr
[guidstr_size
];
503 sprintf(astrp
, GUID_FMT
, GUID_ARGS(aguid
));
504 sprintf(bstrp
, GUID_FMT
, GUID_ARGS(bguid
));
505 sprintf(cstrp
, GUID_FMT
, GUID_ARGS(cguid
));
507 assert_equal_return(ST
->NumberOfTableEntries
, 0, -1, "%lu != %lu\n");
510 * test installing one
512 status
= BS
->InstallConfigurationTable(&bguid
, bstrp
);
513 assert_equal_return(status
, EFI_SUCCESS
, -1, "%lx != %lx\n");
514 assert_equal_goto(ST
->NumberOfTableEntries
, 1, err
, "%lu != %lu\n");
516 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[0].VendorGuid
));
517 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[0].VendorGuid
, &bguid
),
518 err
, "%d != 0 (%s != %s)\n", tmpstr
, bstr
);
519 assert_equal_goto(ST
->ConfigurationTable
[0].VendorTable
,
520 bstrp
, err
, "%p != %p\n");
523 * test re-installing the same one
525 status
= BS
->InstallConfigurationTable(&bguid
, bstrp
);
526 assert_equal_goto(status
, EFI_SUCCESS
, err
, "%lx != %lx\n");
527 assert_equal_goto(ST
->NumberOfTableEntries
, 1, err
, "%lu != %lu\n");
529 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[0].VendorGuid
));
530 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[0].VendorGuid
, &bguid
),
531 err
, "%d != 0 (%s != %s)\n", tmpstr
, bstr
);
532 assert_equal_goto(ST
->ConfigurationTable
[0].VendorTable
,
533 bstrp
, err
, "%p != %p\n");
536 * Test installing a second one
538 status
= BS
->InstallConfigurationTable(&aguid
, astrp
);
539 assert_equal_goto(status
, EFI_SUCCESS
, err
, "%lx != %lx\n");
540 assert_equal_goto(ST
->NumberOfTableEntries
, 2, err
, "%lu != %lu\n");
542 switch (mock_config_table_sort_policy
) {
543 case MOCK_SORT_DESCENDING
:
547 case MOCK_SORT_PREPEND
:
551 case MOCK_SORT_APPEND
:
555 case MOCK_SORT_ASCENDING
:
563 dump_config_table_if_wrong(__func__
, __LINE__
,
569 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[aidx
].VendorGuid
));
570 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[aidx
].VendorGuid
, &aguid
),
571 err
, "%d != 0 (%s != %s)\n", tmpstr
, astr
);
572 assert_equal_goto(ST
->ConfigurationTable
[aidx
].VendorTable
, astrp
,
575 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[bidx
].VendorGuid
));
576 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[bidx
].VendorGuid
, &bguid
),
577 err
, "%d != 0 (%s != %s)\n", tmpstr
, bstr
);
578 assert_equal_goto(ST
->ConfigurationTable
[bidx
].VendorTable
, bstrp
,
582 * Test installing a third one
584 status
= BS
->InstallConfigurationTable(&cguid
, cstrp
);
585 assert_equal_goto(status
, EFI_SUCCESS
, err
, "%lx != %lx\n");
586 assert_equal_goto(ST
->NumberOfTableEntries
, 3, err
, "%lu != %lu\n");
588 switch (mock_config_table_sort_policy
) {
589 case MOCK_SORT_DESCENDING
:
594 case MOCK_SORT_PREPEND
:
599 case MOCK_SORT_APPEND
:
604 case MOCK_SORT_ASCENDING
:
613 dump_config_table_if_wrong(__func__
, __LINE__
,
619 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[aidx
].VendorGuid
));
620 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[aidx
].VendorGuid
, &aguid
),
621 err
, "%d != 0 (%s != %s)\n", tmpstr
, astr
);
622 assert_equal_goto(ST
->ConfigurationTable
[aidx
].VendorTable
, astrp
,
624 memcpy(&guids
[aidx
], &aguid
, sizeof(EFI_GUID
));
626 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[bidx
].VendorGuid
));
627 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[bidx
].VendorGuid
, &bguid
),
628 err
, "%d != 0 (%s != %s)\n", tmpstr
, bstr
);
629 assert_equal_goto(ST
->ConfigurationTable
[bidx
].VendorTable
, bstrp
,
631 memcpy(&guids
[bidx
], &bguid
, sizeof(EFI_GUID
));
633 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[cidx
].VendorGuid
));
634 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[cidx
].VendorGuid
, &cguid
),
635 err
, "%d != 0 (%s != %s)\n", tmpstr
, cstr
);
636 assert_equal_goto(ST
->ConfigurationTable
[cidx
].VendorTable
, cstrp
,
638 memcpy(&guids
[cidx
], &cguid
, sizeof(EFI_GUID
));
641 * Test removing NULL guid
643 status
= BS
->InstallConfigurationTable(NULL
, NULL
);
644 assert_equal_goto(status
, EFI_INVALID_PARAMETER
, err
, "%lx != %lx\n");
645 assert_equal_goto(ST
->NumberOfTableEntries
, 3, err
, "%lu != %lu\n");
648 * Test removing a guid that's not present
650 status
= BS
->InstallConfigurationTable(&lip
, NULL
);
651 assert_equal_goto(status
, EFI_NOT_FOUND
, err
, "%lx != %lx\n");
652 assert_equal_goto(ST
->NumberOfTableEntries
, 3, err
, "%lu != %lu\n");
655 * Test removing the middle one
657 status
= BS
->InstallConfigurationTable(&guids
[1], NULL
);
658 assert_equal_goto(status
, EFI_SUCCESS
, err
, "%lx != %lx\n");
659 assert_equal_goto(ST
->NumberOfTableEntries
, 2, err
, "%lu != %lu\n");
661 switch (mock_config_table_sort_policy
) {
662 case MOCK_SORT_DESCENDING
:
667 case MOCK_SORT_PREPEND
:
672 case MOCK_SORT_APPEND
:
677 case MOCK_SORT_ASCENDING
:
686 dump_config_table_if_wrong(__func__
, __LINE__
,
693 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[aidx
].VendorGuid
));
694 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[aidx
].VendorGuid
, &aguid
),
695 err
, "%d != 0 (%s != %s)\n", tmpstr
, astr
);
696 assert_equal_goto(ST
->ConfigurationTable
[aidx
].VendorTable
, astrp
,
698 memcpy(&guids
[aidx
], &aguid
, sizeof(EFI_GUID
));
702 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[bidx
].VendorGuid
));
703 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[bidx
].VendorGuid
, &bguid
),
704 err
, "%d != 0 (%s != %s)\n", tmpstr
, bstr
);
705 assert_equal_goto(ST
->ConfigurationTable
[bidx
].VendorTable
, bstrp
,
707 memcpy(&guids
[bidx
], &bguid
, sizeof(EFI_GUID
));
711 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[cidx
].VendorGuid
));
712 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[cidx
].VendorGuid
, &cguid
),
713 err
, "%d != 0 (%s != %s)\n", tmpstr
, cstr
);
714 assert_equal_goto(ST
->ConfigurationTable
[cidx
].VendorTable
, cstrp
,
716 memcpy(&guids
[cidx
], &cguid
, sizeof(EFI_GUID
));
720 * Test removing the lowest one
722 status
= BS
->InstallConfigurationTable(&guids
[0], NULL
);
723 assert_equal_goto(status
, EFI_SUCCESS
, err
, "%lx != %lx\n");
724 assert_equal_goto(ST
->NumberOfTableEntries
, 1, err
, "%lu != %lu\n");
726 switch (mock_config_table_sort_policy
) {
727 case MOCK_SORT_DESCENDING
:
732 case MOCK_SORT_PREPEND
:
737 case MOCK_SORT_APPEND
:
742 case MOCK_SORT_ASCENDING
:
751 dump_config_table_if_wrong(__func__
, __LINE__
,
758 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[aidx
].VendorGuid
));
759 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[aidx
].VendorGuid
, &aguid
),
760 err
, "%d != 0 (%s != %s)\n", tmpstr
, astr
);
761 assert_equal_goto(ST
->ConfigurationTable
[aidx
].VendorTable
, astrp
,
763 memcpy(&guids
[aidx
], &aguid
, sizeof(EFI_GUID
));
767 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[bidx
].VendorGuid
));
768 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[bidx
].VendorGuid
, &bguid
),
769 err
, "%d != 0 (%s != %s)\n", tmpstr
, bstr
);
770 assert_equal_goto(ST
->ConfigurationTable
[bidx
].VendorTable
, bstrp
,
772 memcpy(&guids
[bidx
], &bguid
, sizeof(EFI_GUID
));
776 sprintf(tmpstr
, GUID_FMT
, GUID_ARGS(ST
->ConfigurationTable
[cidx
].VendorGuid
));
777 assert_zero_goto(CompareGuid(&ST
->ConfigurationTable
[cidx
].VendorGuid
, &cguid
),
778 err
, "%d != 0 (%s != %s)\n", tmpstr
, cstr
);
779 assert_equal_goto(ST
->ConfigurationTable
[cidx
].VendorTable
, cstrp
,
781 memcpy(&guids
[cidx
], &cguid
, sizeof(EFI_GUID
));
785 * Test removing the last one
787 status
= BS
->InstallConfigurationTable(&guids
[0], NULL
);
788 assert_equal_goto(status
, EFI_SUCCESS
, err
, "%lx != %lx\n");
789 assert_equal_goto(ST
->NumberOfTableEntries
, 0, err
, "%lu != %lu\n");
792 * Test removing it again
794 status
= BS
->InstallConfigurationTable(&guids
[0], NULL
);
795 assert_equal_goto(status
, EFI_NOT_FOUND
, err
, "%lx != %lx\n");
796 assert_equal_goto(ST
->NumberOfTableEntries
, 0, err
, "%lu != %lu\n");
800 while (ST
->NumberOfTableEntries
)
801 BS
->InstallConfigurationTable(&ST
->ConfigurationTable
[0].VendorGuid
, NULL
);
802 mock_reset_config_table();
811 setbuf(stdout
, NULL
);
813 const char *policies
[] = {
814 "MOCK_SORT_DESCENDING",
817 "MOCK_SORT_ASCENDING",
818 "MOCK_SORT_MAX_SENTINEL"
821 test(test_filter_out_true
);
822 test(test_filter_out_false
);
824 for (int i
= 0; i
< MOCK_SORT_MAX_SENTINEL
; i
++) {
825 mock_variable_sort_policy
= i
;
826 mock_config_table_sort_policy
= i
;
827 printf("%s: setting variable sort policy to %s\n",
828 program_invocation_short_name
, policies
[i
]);
830 test(test_gnvn_buf_size_0
);
834 test(test_install_config_table_0
);
837 test(test_get_variable_0
);
838 test(test_set_variable_0
);
842 // vim:fenc=utf-8:tw=75:noet