iPXE
settings_test.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301, USA.
18  *
19  * You can also choose to distribute this program under the terms of
20  * the Unmodified Binary Distribution Licence (as given in the file
21  * COPYING.UBDL), provided that you have satisfied its requirements.
22  */
23 
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25 
26 /** @file
27  *
28  * Settings self-tests
29  *
30  */
31 
32 /* Forcibly enable assertions */
33 #undef NDEBUG
34 
35 #include <string.h>
36 #include <ipxe/settings.h>
37 #include <ipxe/test.h>
38 
39 /** Define inline raw data */
40 #define RAW(...) { __VA_ARGS__ }
41 
42 /**
43  * Report a formatted-store test result
44  *
45  * @v _settings Settings block
46  * @v _setting Setting
47  * @v _formatted Formatted value
48  * @v _raw_array Expected raw value
49  */
50 #define storef_ok( _settings, _setting, _formatted, _raw_array ) do { \
51  const uint8_t expected[] = _raw_array; \
52  uint8_t actual[ sizeof ( expected ) ]; \
53  int len; \
54  \
55  ok ( storef_setting ( _settings, _setting, _formatted ) == 0 ); \
56  len = fetch_setting ( _settings, _setting, NULL, NULL, actual, \
57  sizeof ( actual ) ); \
58  if ( len >= 0 ) { \
59  DBGC ( _settings, "Stored %s \"%s\", got:\n", \
60  (_setting)->type->name, _formatted ); \
61  DBGC_HDA ( _settings, 0, actual, len ); \
62  } else { \
63  DBGC ( _settings, "Stored %s \"%s\", got error %s\n", \
64  (_setting)->type->name, _formatted, \
65  strerror ( len ) ); \
66  } \
67  ok ( len == ( int ) sizeof ( actual ) ); \
68  ok ( memcmp ( actual, expected, sizeof ( actual ) ) == 0 ); \
69  } while ( 0 )
70 
71 /**
72  * Report a formatted-fetch test result
73  *
74  * @v _settings Settings block
75  * @v _setting Setting
76  * @v _raw_array Raw value
77  * @v _formatted Expected formatted value
78  */
79 #define fetchf_ok( _settings, _setting, _raw_array, _formatted ) do { \
80  const uint8_t raw[] = _raw_array; \
81  char actual[ strlen ( _formatted ) + 1 ]; \
82  int len; \
83  \
84  ok ( store_setting ( _settings, _setting, raw, \
85  sizeof ( raw ) ) == 0 ); \
86  len = fetchf_setting ( _settings, _setting, NULL, NULL, actual, \
87  sizeof ( actual ) ); \
88  DBGC ( _settings, "Fetched %s \"%s\" from:\n", \
89  (_setting)->type->name, actual ); \
90  DBGC_HDA ( _settings, 0, raw, sizeof ( raw ) ); \
91  ok ( len == ( int ) ( sizeof ( actual ) - 1 ) ); \
92  ok ( strcmp ( actual, _formatted ) == 0 ); \
93  } while ( 0 )
94 
95 /**
96  * Report a numeric-store test result
97  *
98  * @v _settings Settings block
99  * @v _setting Setting
100  * @v _numeric Numeric value
101  * @v _raw_array Expected raw value
102  */
103 #define storen_ok( _settings, _setting, _numeric, _raw_array ) do { \
104  const uint8_t expected[] = _raw_array; \
105  uint8_t actual[ sizeof ( expected ) ]; \
106  int len; \
107  \
108  ok ( storen_setting ( _settings, _setting, _numeric ) == 0 ); \
109  len = fetch_setting ( _settings, _setting, NULL, NULL, actual, \
110  sizeof ( actual ) ); \
111  if ( len >= 0 ) { \
112  DBGC ( _settings, "Stored %s %#lx, got:\n", \
113  (_setting)->type->name, \
114  ( unsigned long ) _numeric ); \
115  DBGC_HDA ( _settings, 0, actual, len ); \
116  } else { \
117  DBGC ( _settings, "Stored %s %#lx, got error %s\n", \
118  (_setting)->type->name, \
119  ( unsigned long ) _numeric, strerror ( len ) ); \
120  } \
121  ok ( len == ( int ) sizeof ( actual ) ); \
122  ok ( memcmp ( actual, expected, sizeof ( actual ) ) == 0 ); \
123  } while ( 0 )
124 
125 /**
126  * Report a numeric-fetch test result
127  *
128  * @v _settings Settings block
129  * @v _setting Setting
130  * @v _raw_array Raw array
131  * @v _numeric Expected numeric value
132  */
133 #define fetchn_ok( _settings, _setting, _raw_array, _numeric ) do { \
134  const uint8_t raw[] = _raw_array; \
135  unsigned long actual; \
136  \
137  ok ( store_setting ( _settings, _setting, raw, \
138  sizeof ( raw ) ) == 0 ); \
139  ok ( fetchn_setting ( _settings, _setting, NULL, NULL, \
140  &actual ) == 0 ); \
141  DBGC ( _settings, "Fetched %s %#lx from:\n", \
142  (_setting)->type->name, actual ); \
143  DBGC_HDA ( _settings, 0, raw, sizeof ( raw ) ); \
144  ok ( actual == ( unsigned long ) _numeric ); \
145  } while ( 0 )
146 
147 /** Test generic settings block */
149  .settings = {
150  .refcnt = NULL,
151  .siblings =
153  .children =
156  },
158 };
159 
160 /** Test settings block */
161 #define test_settings test_generic_settings.settings
162 
163 /** Test string setting */
164 static struct setting test_string_setting = {
165  .name = "test_string",
166  .type = &setting_type_string,
167 };
168 
169 /** Test URI-encoded string setting */
171  .name = "test_uristring",
172  .type = &setting_type_uristring,
173 };
174 
175 /** Test IPv4 address setting type */
176 static struct setting test_ipv4_setting = {
177  .name = "test_ipv4",
178  .type = &setting_type_ipv4,
179 };
180 
181 /** Test IPv6 address setting type */
182 static struct setting test_ipv6_setting = {
183  .name = "test_ipv6",
184  .type = &setting_type_ipv6,
185 };
186 
187 /** Test signed 8-bit integer setting type */
188 static struct setting test_int8_setting = {
189  .name = "test_int8",
190  .type = &setting_type_int8,
191 };
192 
193 /** Test signed 16-bit integer setting type */
194 static struct setting test_int16_setting = {
195  .name = "test_int16",
196  .type = &setting_type_int16,
197 };
198 
199 /** Test signed 32-bit integer setting type */
200 static struct setting test_int32_setting = {
201  .name = "test_int32",
202  .type = &setting_type_int32,
203 };
204 
205 /** Test unsigned 8-bit integer setting type */
206 static struct setting test_uint8_setting = {
207  .name = "test_uint8",
208  .type = &setting_type_uint8,
209 };
210 
211 /** Test unsigned 16-bit integer setting type */
212 static struct setting test_uint16_setting = {
213  .name = "test_uint16",
214  .type = &setting_type_uint16,
215 };
216 
217 /** Test unsigned 32-bit integer setting type */
218 static struct setting test_uint32_setting = {
219  .name = "test_uint32",
220  .type = &setting_type_uint32,
221 };
222 
223 /** Test colon-separated hex string setting type */
224 static struct setting test_hex_setting = {
225  .name = "test_hex",
226  .type = &setting_type_hex,
227 };
228 
229 /** Test hyphen-separated hex string setting type */
230 static struct setting test_hexhyp_setting = {
231  .name = "test_hexhyp",
232  .type = &setting_type_hexhyp,
233 };
234 
235 /** Test raw hex string setting type */
236 static struct setting test_hexraw_setting = {
237  .name = "test_hexraw",
238  .type = &setting_type_hexraw,
239 };
240 
241 /** Test Base64 setting type */
242 static struct setting test_base64_setting = {
243  .name = "test_base64",
244  .type = &setting_type_base64,
245 };
246 
247 /** Test UUID setting type */
248 static struct setting test_uuid_setting = {
249  .name = "test_uuid",
250  .type = &setting_type_uuid,
251 };
252 
253 /** Test PCI bus:dev.fn setting type */
255  .name = "test_busdevfn",
256  .type = &setting_type_busdevfn,
257 };
258 
259 /**
260  * Perform settings self-tests
261  *
262  */
263 static void settings_test_exec ( void ) {
264 
265  /* Register test settings block */
266  ok ( register_settings ( &test_settings, NULL, "test" ) == 0 );
267 
268  /* "string" setting type */
270  RAW ( 'h', 'e', 'l', 'l', 'o' ) );
272  RAW ( 'w', 'o', 'r', 'l', 'd' ), "world" );
273 
274  /* "uristring" setting type */
275  storef_ok ( &test_settings, &test_uristring_setting, "hello%20world",
276  RAW ( 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l',
277  'd' ) );
279  RAW ( 1, 2, 3, 4, 5 ), "%01%02%03%04%05" );
281  RAW ( 0, ' ', '%', '/', '#', ':', '@', '?', '=', '&' ),
282  "%00%20%25%2F%23%3A%40%3F%3D%26" );
283 
284  /* "ipv4" setting type */
285  storef_ok ( &test_settings, &test_ipv4_setting, "192.168.0.1",
286  RAW ( 192, 168, 0, 1 ) );
288  RAW ( 212, 13, 204, 60 ), "212.13.204.60" );
289 
290  /* "ipv6" setting type */
292  "2001:ba8:0:1d4::6950:5845",
293  RAW ( 0x20, 0x01, 0x0b, 0xa8, 0x00, 0x00, 0x01, 0xd4,
294  0x00, 0x00, 0x00, 0x00, 0x69, 0x50, 0x58, 0x45 ) );
296  RAW ( 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
297  0x02, 0x0c, 0x29, 0xff, 0xfe, 0xc5, 0x39, 0xa1 ),
298  "fe80::20c:29ff:fec5:39a1" );
299 
300  /* Integer setting types (as formatted strings) */
302  "54", RAW ( 54 ) );
304  "0x7f", RAW ( 0x7f ) );
306  "0x1234", RAW ( 0x34 ) );
308  "-32", RAW ( -32 ) );
310  RAW ( -9 ), "-9" );
312  RAW ( 106 ), "106" );
314  "129", RAW ( 129 ) );
316  "0x3421", RAW ( 0x21 ) );
318  RAW ( 0x54 ), "0x54" );
320  "29483", RAW ( 0x73, 0x2b ) );
322  RAW ( 0x82, 0x14 ), "-32236" );
324  RAW ( 0x12, 0x78 ), "4728" );
326  "48727", RAW ( 0xbe, 0x57 ) );
328  RAW ( 0x9a, 0x24 ), "0x9a24" );
330  "2901274", RAW ( 0x00, 0x2c, 0x45, 0x1a ) );
332  RAW ( 0xff, 0x34, 0x2d, 0xaf ), "-13357649" );
334  RAW ( 0x01, 0x00, 0x34, 0xab ), "16790699" );
336  "0xb598d21", RAW ( 0x0b, 0x59, 0x8d, 0x21 ) );
338  RAW ( 0xf2, 0x37, 0xb2, 0x18 ), "0xf237b218" );
339 
340  /* Integer setting types (as numeric values) */
342  72, RAW ( 72 ) );
344  0xabcd, RAW ( 0xcd ) );
346  RAW ( 0xfe ), -2 );
348  84, RAW ( 84 ) );
350  RAW ( 0xfe ), 0xfe );
352  0x87bd, RAW ( 0x87, 0xbd ) );
354  RAW ( 0x3d, 0x14 ), 0x3d14 );
356  RAW ( 0x80 ), -128 );
358  1, RAW ( 0x00, 0x01 ) );
360  RAW ( 0xbd, 0x87 ), 0xbd87 );
362  RAW ( 0x80 ), 0x0080 );
364  0x0812bfd2, RAW ( 0x08, 0x12, 0xbf, 0xd2 ) );
366  RAW ( 0x43, 0x87, 0x91, 0xb4 ), 0x438791b4 );
368  RAW ( 0xff, 0xff, 0xfe ), -2 );
370  0xb5927ab8, RAW ( 0xb5, 0x92, 0x7a, 0xb8 ) );
372  RAW ( 0x98, 0xab, 0x41, 0x81 ), 0x98ab4181 );
374  RAW ( 0xff, 0xff, 0xfe ), 0x00fffffe );
376  RAW ( 0, 0, 0, 0x12, 0x34, 0x56, 0x78 ), 0x12345678 );
378  RAW ( 0, 0, 0, 0x12, 0x34, 0x56, 0x78 ), 0x12345678 );
380  RAW ( 0xff, 0xff, 0x87, 0x65, 0x43, 0x21 ), -0x789abcdf );
381 
382  /* "hex" setting type */
384  "08:12:f5:22:90:1b:4b:47:a8:30:cb:4d:67:4c:d6:76",
385  RAW ( 0x08, 0x12, 0xf5, 0x22, 0x90, 0x1b, 0x4b, 0x47, 0xa8,
386  0x30, 0xcb, 0x4d, 0x67, 0x4c, 0xd6, 0x76 ) );
388  RAW ( 0x62, 0xd9, 0xd4, 0xc4, 0x7e, 0x3b, 0x41, 0x46, 0x91,
389  0xc6, 0xfd, 0x0c, 0xbf ),
390  "62:d9:d4:c4:7e:3b:41:46:91:c6:fd:0c:bf" );
391 
392  /* "hexhyp" setting type */
394  "11-33-22", RAW ( 0x11, 0x33, 0x22 ) );
396  RAW ( 0x9f, 0xe5, 0x6d, 0xfb, 0x24, 0x3a, 0x4c, 0xbb, 0xa9,
397  0x09, 0x6c, 0x66, 0x13, 0xc1, 0xa8, 0xec, 0x27 ),
398  "9f-e5-6d-fb-24-3a-4c-bb-a9-09-6c-66-13-c1-a8-ec-27" );
399 
400  /* "hexraw" setting type */
402  "012345abcdef", RAW ( 0x01, 0x23, 0x45, 0xab, 0xcd, 0xef ));
404  RAW ( 0x9e, 0x4b, 0x6e, 0xef, 0x36, 0xb6, 0x46, 0xfe, 0x8f,
405  0x17, 0x06, 0x39, 0x6b, 0xf4, 0x48, 0x4e ),
406  "9e4b6eef36b646fe8f1706396bf4484e" );
407 
408  /* "base64" setting type */
410  "cGFzc6\nNwaHJhc2U= ",
411  RAW ( 0x70, 0x61, 0x73, 0x73, 0xa3, 0x70, 0x68, 0x72, 0x61,
412  0x73, 0x65 ) );
414  RAW ( 0x80, 0x81, 0x82, 0x83, 0x84, 0x00, 0xff ),
415  "gIGCg4QA/w==" );
416 
417  /* "uuid" setting type (no store capability) */
419  RAW ( 0x1a, 0x6a, 0x74, 0x9d, 0x0e, 0xda, 0x46, 0x1a,0xa8,
420  0x7a, 0x7c, 0xfe, 0x4f, 0xca, 0x4a, 0x57 ),
421  "1a6a749d-0eda-461a-a87a-7cfe4fca4a57" );
422 
423  /* "busdevfn" setting type (no store capability) */
425  RAW ( 0x03, 0x45 ), "0000:03:08.5" );
427  RAW ( 0x00, 0x02, 0x0a, 0x21 ), "0002:0a:04.1" );
428 
429  /* Clear and unregister test settings block */
432 }
433 
434 /** Settings self-test */
435 struct self_test settings_test __self_test = {
436  .name = "settings",
437  .exec = settings_test_exec,
438 };
439 
440 /* Include real IPv6 setting type */
441 REQUIRING_SYMBOL ( settings_test );
442 REQUIRE_OBJECT ( ipv6 );
static struct setting test_ipv4_setting
Test IPv4 address setting type.
#define storef_ok(_settings, _setting, _formatted, _raw_array)
Report a formatted-store test result.
Definition: settings_test.c:50
void unregister_settings(struct settings *settings)
Unregister settings block.
Definition: settings.c:517
#define fetchf_ok(_settings, _setting, _raw_array, _formatted)
Report a formatted-fetch test result.
Definition: settings_test.c:79
REQUIRING_SYMBOL(settings_test)
static struct setting test_busdevfn_setting
Test PCI bus:dev.fn setting type.
static struct setting test_string_setting
Test string setting.
Self-test infrastructure.
const char * name
Test set name.
Definition: test.h:17
struct settings_operations generic_settings_operations
Generic settings operations.
Definition: settings.c:221
A self-test set.
Definition: test.h:15
static struct setting test_int32_setting
Test signed 32-bit integer setting type.
static struct setting test_ipv6_setting
Test IPv6 address setting type.
#define fetchn_ok(_settings, _setting, _raw_array, _numeric)
Report a numeric-fetch test result.
const char * name
Name.
Definition: settings.h:28
static struct setting test_base64_setting
Test Base64 setting type.
static struct setting test_int8_setting
Test signed 8-bit integer setting type.
struct list_head list
List of generic settings.
Definition: settings.h:302
struct self_test settings_test __self_test
Settings self-test.
static struct setting test_int16_setting
Test signed 16-bit integer setting type.
#define RAW(...)
Define inline raw data.
Definition: settings_test.c:40
Configuration settings.
REQUIRE_OBJECT(ipv6)
static struct setting test_uint8_setting
Test unsigned 8-bit integer setting type.
struct list_head siblings
Sibling settings blocks.
Definition: settings.h:140
static struct setting test_uint32_setting
Test unsigned 32-bit integer setting type.
A setting.
Definition: settings.h:23
static struct setting test_uint16_setting
Test unsigned 16-bit integer setting type.
static void settings_test_exec(void)
Perform settings self-tests.
A generic settings block.
Definition: settings.h:298
struct settings settings
Settings block.
Definition: settings.h:300
#define storen_ok(_settings, _setting, _numeric, _raw_array)
Report a numeric-store test result.
static struct setting test_hex_setting
Test colon-separated hex string setting type.
struct generic_settings test_generic_settings
Test generic settings block.
struct list_head children
Child settings blocks.
Definition: settings.h:142
int register_settings(struct settings *settings, struct settings *parent, const char *name)
Register settings block.
Definition: settings.c:478
void clear_settings(struct settings *settings)
Clear settings block.
Definition: settings.c:1106
FILE_LICENCE(GPL2_OR_LATER_OR_UBDL)
#define test_settings
Test settings block.
static struct setting test_hexraw_setting
Test raw hex string setting type.
#define LIST_HEAD_INIT(list)
Initialise a static list head.
Definition: list.h:30
static struct setting test_uuid_setting
Test UUID setting type.
#define ok(success)
Definition: test.h:46
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
String functions.
static struct setting test_uristring_setting
Test URI-encoded string setting.
static struct setting test_hexhyp_setting
Test hyphen-separated hex string setting type.
struct refcnt * refcnt
Reference counter.
Definition: settings.h:134