blob: 17926ebb3c38a257a76129b29edc12087831b129 [file] [log] [blame]
Mohammad Azim Khan95402612017-07-19 10:15:54 +01001#line 2 "suites/host_test.function"
Mohammad Azim Khanfff49042017-03-28 01:48:31 +01002
3/**
Azim Khan8d686bf2018-07-04 23:29:46 +01004 * \brief Verifies that string is in string parameter format i.e. "<str>"
Mohammad Azim Khanfff49042017-03-28 01:48:31 +01005 * It also strips enclosing '"' from the input string.
6 *
7 * \param str String parameter.
8 *
9 * \return 0 if success else 1
10 */
11int verify_string( char **str )
12{
Mohammad Azim Khand2d01122018-07-18 17:48:37 +010013 if( ( *str )[0] != '"' ||
14 ( *str )[strlen( *str ) - 1] != '"' )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +010015 {
16 mbedtls_fprintf( stderr,
17 "Expected string (with \"\") for parameter and got: %s\n", *str );
18 return( -1 );
19 }
20
Azim Khan8d686bf2018-07-04 23:29:46 +010021 ( *str )++;
22 ( *str )[strlen( *str ) - 1] = '\0';
Mohammad Azim Khanfff49042017-03-28 01:48:31 +010023
24 return( 0 );
25}
26
27/**
Azim Khan8d686bf2018-07-04 23:29:46 +010028 * \brief Verifies that string is an integer. Also gives the converted
Mohammad Azim Khanfff49042017-03-28 01:48:31 +010029 * integer value.
30 *
31 * \param str Input string.
32 * \param value Pointer to int for output value.
33 *
34 * \return 0 if success else 1
35 */
Gilles Peskinea7a43062021-05-18 16:39:33 +020036int verify_int( char *str, int32_t *value )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +010037{
38 size_t i;
39 int minus = 0;
40 int digits = 1;
41 int hex = 0;
42
43 for( i = 0; i < strlen( str ); i++ )
44 {
45 if( i == 0 && str[i] == '-' )
46 {
47 minus = 1;
48 continue;
49 }
50
51 if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
Mohammad Azim Khand2d01122018-07-18 17:48:37 +010052 str[i - 1] == '0' && ( str[i] == 'x' || str[i] == 'X' ) )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +010053 {
54 hex = 1;
55 continue;
56 }
57
58 if( ! ( ( str[i] >= '0' && str[i] <= '9' ) ||
59 ( hex && ( ( str[i] >= 'a' && str[i] <= 'f' ) ||
60 ( str[i] >= 'A' && str[i] <= 'F' ) ) ) ) )
61 {
62 digits = 0;
63 break;
64 }
65 }
66
67 if( digits )
68 {
69 if( hex )
70 *value = strtol( str, NULL, 16 );
71 else
72 *value = strtol( str, NULL, 10 );
73
74 return( 0 );
75 }
76
77 mbedtls_fprintf( stderr,
78 "Expected integer for parameter and got: %s\n", str );
79 return( KEY_VALUE_MAPPING_NOT_FOUND );
80}
81
82
83/**
84 * \brief Usage string.
85 *
86 */
87#define USAGE \
88 "Usage: %s [OPTIONS] files...\n\n" \
89 " Command line arguments:\n" \
Mohammad Azim Khand2d01122018-07-18 17:48:37 +010090 " files... One or more test data files. If no file is\n" \
91 " specified the following default test case\n" \
92 " file is used:\n" \
Mohammad Azim Khanfff49042017-03-28 01:48:31 +010093 " %s\n\n" \
94 " Options:\n" \
95 " -v | --verbose Display full information about each test\n" \
96 " -h | --help Display this information\n\n", \
97 argv[0], \
98 "TESTCASE_FILENAME"
99
100
101/**
102 * \brief Read a line from the passed file pointer.
103 *
104 * \param f FILE pointer
105 * \param buf Pointer to memory to hold read line.
106 * \param len Length of the buf.
107 *
108 * \return 0 if success else -1
109 */
110int get_line( FILE *f, char *buf, size_t len )
111{
112 char *ret;
113 int i = 0, str_len = 0, has_string = 0;
114
115 /* Read until we get a valid line */
116 do
117 {
118 ret = fgets( buf, len, f );
119 if( ret == NULL )
120 return( -1 );
121
122 str_len = strlen( buf );
123
124 /* Skip empty line and comment */
125 if ( str_len == 0 || buf[0] == '#' )
126 continue;
127 has_string = 0;
128 for ( i = 0; i < str_len; i++ )
129 {
130 char c = buf[i];
131 if ( c != ' ' && c != '\t' && c != '\n' &&
132 c != '\v' && c != '\f' && c != '\r' )
133 {
134 has_string = 1;
135 break;
136 }
137 }
138 } while( !has_string );
139
140 /* Strip new line and carriage return */
141 ret = buf + strlen( buf );
142 if( ret-- > buf && *ret == '\n' )
143 *ret = '\0';
144 if( ret-- > buf && *ret == '\r' )
145 *ret = '\0';
146
147 return( 0 );
148}
149
150/**
151 * \brief Splits string delimited by ':'. Ignores '\:'.
152 *
153 * \param buf Input string
154 * \param len Input string length
155 * \param params Out params found
156 * \param params_len Out params array len
157 *
158 * \return Count of strings found.
159 */
160static int parse_arguments( char *buf, size_t len, char **params,
161 size_t params_len )
162{
163 size_t cnt = 0, i;
164 char *cur = buf;
165 char *p = buf, *q;
166
167 params[cnt++] = cur;
168
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100169 while( *p != '\0' && p < ( buf + len ) )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100170 {
171 if( *p == '\\' )
172 {
173 p++;
174 p++;
175 continue;
176 }
177 if( *p == ':' )
178 {
179 if( p + 1 < buf + len )
180 {
181 cur = p + 1;
Gilles Peskinee7655df2019-06-07 14:52:07 +0200182 TEST_HELPER_ASSERT( cnt < params_len );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100183 params[cnt++] = cur;
184 }
185 *p = '\0';
186 }
187
188 p++;
189 }
190
191 /* Replace newlines, question marks and colons in strings */
192 for( i = 0; i < cnt; i++ )
193 {
194 p = params[i];
195 q = params[i];
196
197 while( *p != '\0' )
198 {
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100199 if( *p == '\\' && *( p + 1 ) == 'n' )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100200 {
201 p += 2;
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100202 *( q++ ) = '\n';
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100203 }
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100204 else if( *p == '\\' && *( p + 1 ) == ':' )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100205 {
206 p += 2;
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100207 *( q++ ) = ':';
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100208 }
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100209 else if( *p == '\\' && *( p + 1 ) == '?' )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100210 {
211 p += 2;
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100212 *( q++ ) = '?';
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100213 }
214 else
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100215 *( q++ ) = *( p++ );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100216 }
217 *q = '\0';
218 }
219
220 return( cnt );
221}
222
223/**
224 * \brief Converts parameters into test function consumable parameters.
225 * Example: Input: {"int", "0", "char*", "Hello",
226 * "hex", "abef", "exp", "1"}
227 * Output: {
228 * 0, // Verified int
229 * "Hello", // Verified string
230 * 2, { 0xab, 0xef },// Converted len,hex pair
231 * 9600 // Evaluated expression
232 * }
233 *
234 *
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100235 * \param cnt Parameter array count.
236 * \param params Out array of found parameters.
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100237 * \param int_params_store Memory for storing processed integer parameters.
238 *
239 * \return 0 for success else 1
240 */
Gilles Peskinea7a43062021-05-18 16:39:33 +0200241static int convert_params( size_t cnt , char ** params , int32_t * int_params_store )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100242{
243 char ** cur = params;
244 char ** out = params;
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100245 int ret = DISPATCH_TEST_SUCCESS;
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100246
Azim Khan8d686bf2018-07-04 23:29:46 +0100247 while ( cur < params + cnt )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100248 {
249 char * type = *cur++;
250 char * val = *cur++;
251
252 if ( strcmp( type, "char*" ) == 0 )
253 {
254 if ( verify_string( &val ) == 0 )
255 {
256 *out++ = val;
257 }
258 else
259 {
260 ret = ( DISPATCH_INVALID_TEST_DATA );
261 break;
262 }
263 }
264 else if ( strcmp( type, "int" ) == 0 )
265 {
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100266 if ( verify_int( val, int_params_store ) == 0 )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100267 {
268 *out++ = (char *) int_params_store++;
269 }
270 else
271 {
272 ret = ( DISPATCH_INVALID_TEST_DATA );
273 break;
274 }
275 }
276 else if ( strcmp( type, "hex" ) == 0 )
277 {
Azim Khan184447e2017-05-31 20:29:36 +0100278 if ( verify_string( &val ) == 0 )
279 {
Ronald Crona0c25392020-06-18 10:10:46 +0200280 size_t len;
281
282 TEST_HELPER_ASSERT(
283 mbedtls_test_unhexify( (unsigned char *) val, strlen( val ),
284 val, &len ) == 0 );
285
286 *int_params_store = len;
Azim Khan184447e2017-05-31 20:29:36 +0100287 *out++ = val;
288 *out++ = (char *)(int_params_store++);
289 }
290 else
291 {
292 ret = ( DISPATCH_INVALID_TEST_DATA );
293 break;
294 }
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100295 }
296 else if ( strcmp( type, "exp" ) == 0 )
297 {
298 int exp_id = strtol( val, NULL, 10 );
299 if ( get_expression ( exp_id, int_params_store ) == 0 )
300 {
301 *out++ = (char *)int_params_store++;
302 }
303 else
304 {
305 ret = ( DISPATCH_INVALID_TEST_DATA );
306 break;
307 }
308 }
309 else
310 {
311 ret = ( DISPATCH_INVALID_TEST_DATA );
312 break;
313 }
314 }
315 return( ret );
316}
317
318/**
319 * \brief Tests snprintf implementation with test input.
320 *
Azim Khan191e9042017-06-09 12:39:00 +0100321 * \note
322 * At high optimization levels (e.g. gcc -O3), this function may be
323 * inlined in run_test_snprintf. This can trigger a spurious warning about
324 * potential misuse of snprintf from gcc -Wformat-truncation (observed with
325 * gcc 7.2). This warning makes tests in run_test_snprintf redundant on gcc
326 * only. They are still valid for other compilers. Avoid this warning by
327 * forbidding inlining of this function by gcc.
328 *
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100329 * \param n Buffer test length.
330 * \param ref_buf Expected buffer.
331 * \param ref_ret Expected snprintf return value.
332 *
333 * \return 0 for success else 1
334 */
Azim Khan191e9042017-06-09 12:39:00 +0100335#if defined(__GNUC__)
336__attribute__((__noinline__))
337#endif
Rodrigo Dias Correa80448aa2020-11-10 02:28:50 -0300338static int test_snprintf( size_t n, const char *ref_buf, int ref_ret )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100339{
340 int ret;
341 char buf[10] = "xxxxxxxxx";
342 const char ref[10] = "xxxxxxxxx";
343
Mohammad Azim Khan76135342018-04-12 13:23:01 +0100344 if( n >= sizeof( buf ) )
345 return( -1 );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100346 ret = mbedtls_snprintf( buf, n, "%s", "123" );
347 if( ret < 0 || (size_t) ret >= n )
348 ret = -1;
349
350 if( strncmp( ref_buf, buf, sizeof( buf ) ) != 0 ||
351 ref_ret != ret ||
352 memcmp( buf + n, ref + n, sizeof( buf ) - n ) != 0 )
353 {
354 return( 1 );
355 }
356
357 return( 0 );
358}
359
360/**
361 * \brief Tests snprintf implementation.
362 *
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100363 * \return 0 for success else 1
364 */
365static int run_test_snprintf( void )
366{
367 return( test_snprintf( 0, "xxxxxxxxx", -1 ) != 0 ||
368 test_snprintf( 1, "", -1 ) != 0 ||
369 test_snprintf( 2, "1", -1 ) != 0 ||
370 test_snprintf( 3, "12", -1 ) != 0 ||
371 test_snprintf( 4, "123", 3 ) != 0 ||
372 test_snprintf( 5, "123", 3 ) != 0 );
373}
374
Gilles Peskine51dcc242019-09-16 15:13:48 +0200375/** \brief Write the description of the test case to the outcome CSV file.
376 *
377 * \param outcome_file The file to write to.
378 * If this is \c NULL, this function does nothing.
379 * \param argv0 The test suite name.
380 * \param test_case The test case description.
381 */
382static void write_outcome_entry( FILE *outcome_file,
383 const char *argv0,
384 const char *test_case )
385{
386 /* The non-varying fields are initialized on first use. */
387 static const char *platform = NULL;
388 static const char *configuration = NULL;
389 static const char *test_suite = NULL;
390
391 if( outcome_file == NULL )
392 return;
393
394 if( platform == NULL )
395 {
396 platform = getenv( "MBEDTLS_TEST_PLATFORM" );
397 if( platform == NULL )
398 platform = "unknown";
399 }
400 if( configuration == NULL )
401 {
402 configuration = getenv( "MBEDTLS_TEST_CONFIGURATION" );
403 if( configuration == NULL )
404 configuration = "unknown";
405 }
406 if( test_suite == NULL )
407 {
408 test_suite = strrchr( argv0, '/' );
409 if( test_suite != NULL )
410 test_suite += 1; // skip the '/'
411 else
412 test_suite = argv0;
413 }
414
415 /* Write the beginning of the outcome line.
416 * Ignore errors: writing the outcome file is on a best-effort basis. */
417 mbedtls_fprintf( outcome_file, "%s;%s;%s;%s;",
418 platform, configuration, test_suite, test_case );
419}
420
421/** \brief Write the result of the test case to the outcome CSV file.
422 *
423 * \param outcome_file The file to write to.
424 * If this is \c NULL, this function does nothing.
Ronald Cron67a8a372020-04-01 16:04:41 +0200425 * \param unmet_dep_count The number of unmet dependencies.
426 * \param unmet_dependencies The array of unmet dependencies.
427 * \param missing_unmet_dependencies Non-zero if there was a problem tracking
428 * all unmet dependencies, 0 otherwise.
Gilles Peskine5a7702e2021-02-23 13:40:19 +0100429 * \param ret The test dispatch status (DISPATCH_xxx).
430 * \param info A pointer to the test info structure.
Gilles Peskine51dcc242019-09-16 15:13:48 +0200431 */
432static void write_outcome_result( FILE *outcome_file,
433 size_t unmet_dep_count,
Gilles Peskine06725c92020-03-30 21:39:09 +0200434 int unmet_dependencies[],
Ronald Cron67a8a372020-04-01 16:04:41 +0200435 int missing_unmet_dependencies,
Gilles Peskine51dcc242019-09-16 15:13:48 +0200436 int ret,
Chris Jonese60e2ae2021-01-20 17:51:47 +0000437 const mbedtls_test_info_t *info )
Gilles Peskine51dcc242019-09-16 15:13:48 +0200438{
439 if( outcome_file == NULL )
440 return;
441
442 /* Write the end of the outcome line.
443 * Ignore errors: writing the outcome file is on a best-effort basis. */
444 switch( ret )
445 {
446 case DISPATCH_TEST_SUCCESS:
447 if( unmet_dep_count > 0 )
448 {
449 size_t i;
450 mbedtls_fprintf( outcome_file, "SKIP" );
451 for( i = 0; i < unmet_dep_count; i++ )
452 {
Gilles Peskine06725c92020-03-30 21:39:09 +0200453 mbedtls_fprintf( outcome_file, "%c%d",
Gilles Peskine51dcc242019-09-16 15:13:48 +0200454 i == 0 ? ';' : ':',
455 unmet_dependencies[i] );
456 }
Ronald Cron67a8a372020-04-01 16:04:41 +0200457 if( missing_unmet_dependencies )
458 mbedtls_fprintf( outcome_file, ":..." );
Gilles Peskine51dcc242019-09-16 15:13:48 +0200459 break;
460 }
461 switch( info->result )
462 {
Chris Jonese60e2ae2021-01-20 17:51:47 +0000463 case MBEDTLS_TEST_RESULT_SUCCESS:
Gilles Peskine51dcc242019-09-16 15:13:48 +0200464 mbedtls_fprintf( outcome_file, "PASS;" );
465 break;
Chris Jonese60e2ae2021-01-20 17:51:47 +0000466 case MBEDTLS_TEST_RESULT_SKIPPED:
Gilles Peskine51dcc242019-09-16 15:13:48 +0200467 mbedtls_fprintf( outcome_file, "SKIP;Runtime skip" );
468 break;
469 default:
470 mbedtls_fprintf( outcome_file, "FAIL;%s:%d:%s",
471 info->filename, info->line_no,
472 info->test );
473 break;
474 }
475 break;
476 case DISPATCH_TEST_FN_NOT_FOUND:
477 mbedtls_fprintf( outcome_file, "FAIL;Test function not found" );
478 break;
479 case DISPATCH_INVALID_TEST_DATA:
480 mbedtls_fprintf( outcome_file, "FAIL;Invalid test data" );
481 break;
482 case DISPATCH_UNSUPPORTED_SUITE:
483 mbedtls_fprintf( outcome_file, "SKIP;Unsupported suite" );
484 break;
485 default:
486 mbedtls_fprintf( outcome_file, "FAIL;Unknown cause" );
487 break;
488 }
489 mbedtls_fprintf( outcome_file, "\n" );
490 fflush( outcome_file );
491}
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100492
493/**
494 * \brief Desktop implementation of execute_tests().
495 * Parses command line and executes tests from
496 * supplied or default data file.
497 *
498 * \param argc Command line argument count.
499 * \param argv Argument array.
500 *
501 * \return Program exit status.
502 */
503int execute_tests( int argc , const char ** argv )
504{
505 /* Local Configurations and options */
506 const char *default_filename = "DATA_FILE";
507 const char *test_filename = NULL;
508 const char **test_files = NULL;
Gilles Peskine3c1c8ea2019-09-16 15:10:47 +0200509 size_t testfile_count = 0;
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100510 int option_verbose = 0;
k-stachowiak03954f22019-09-16 10:23:10 +0200511 size_t function_id = 0;
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100512
513 /* Other Local variables */
514 int arg_index = 1;
515 const char *next_arg;
Gilles Peskine3c1c8ea2019-09-16 15:10:47 +0200516 size_t testfile_index, i, cnt;
517 int ret;
518 unsigned total_errors = 0, total_tests = 0, total_skipped = 0;
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100519 FILE *file;
520 char buf[5000];
521 char *params[50];
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100522 /* Store for proccessed integer params. */
Gilles Peskinea7a43062021-05-18 16:39:33 +0200523 int32_t int_params[50];
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100524 void *pointer;
525#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
526 int stdout_fd = -1;
527#endif /* __unix__ || __APPLE__ __MACH__ */
Gilles Peskine51dcc242019-09-16 15:13:48 +0200528 const char *outcome_file_name = getenv( "MBEDTLS_TEST_OUTCOME_FILE" );
529 FILE *outcome_file = NULL;
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100530
531#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && \
532 !defined(TEST_SUITE_MEMORY_BUFFER_ALLOC)
533 unsigned char alloc_buf[1000000];
534 mbedtls_memory_buffer_alloc_init( alloc_buf, sizeof( alloc_buf ) );
535#endif
536
Gilles Peskine1061ec62021-01-29 21:17:11 +0100537#if defined(MBEDTLS_TEST_MUTEX_USAGE)
538 mbedtls_test_mutex_usage_init( );
539#endif
540
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100541 /*
542 * The C standard doesn't guarantee that all-bits-0 is the representation
543 * of a NULL pointer. We do however use that in our code for initializing
544 * structures, which should work on every modern platform. Let's be sure.
545 */
546 memset( &pointer, 0, sizeof( void * ) );
547 if( pointer != NULL )
548 {
549 mbedtls_fprintf( stderr, "all-bits-zero is not a NULL pointer\n" );
550 return( 1 );
551 }
552
553 /*
554 * Make sure we have a snprintf that correctly zero-terminates
555 */
556 if( run_test_snprintf() != 0 )
557 {
558 mbedtls_fprintf( stderr, "the snprintf implementation is broken\n" );
Azim Khan191e9042017-06-09 12:39:00 +0100559 return( 1 );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100560 }
561
gabor-mezei-arm88d7eee2020-04-22 11:07:34 +0200562 if( outcome_file_name != NULL && *outcome_file_name != '\0' )
Gilles Peskine9c673232020-01-21 18:03:56 +0100563 {
564 outcome_file = fopen( outcome_file_name, "a" );
565 if( outcome_file == NULL )
566 {
567 mbedtls_fprintf( stderr, "Unable to open outcome file. Continuing anyway.\n" );
568 }
569 }
570
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100571 while( arg_index < argc )
572 {
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100573 next_arg = argv[arg_index];
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100574
Mohammad Azim Khand2d01122018-07-18 17:48:37 +0100575 if( strcmp( next_arg, "--verbose" ) == 0 ||
576 strcmp( next_arg, "-v" ) == 0 )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100577 {
578 option_verbose = 1;
579 }
580 else if( strcmp(next_arg, "--help" ) == 0 ||
581 strcmp(next_arg, "-h" ) == 0 )
582 {
583 mbedtls_fprintf( stdout, USAGE );
584 mbedtls_exit( EXIT_SUCCESS );
585 }
586 else
587 {
588 /* Not an option, therefore treat all further arguments as the file
589 * list.
590 */
591 test_files = &argv[ arg_index ];
592 testfile_count = argc - arg_index;
593 }
594
595 arg_index++;
596 }
597
598 /* If no files were specified, assume a default */
599 if ( test_files == NULL || testfile_count == 0 )
600 {
601 test_files = &default_filename;
602 testfile_count = 1;
603 }
604
605 /* Initialize the struct that holds information about the last test */
Chris Jones567e0ad2021-02-03 12:07:01 +0000606 mbedtls_test_info_reset( );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100607
608 /* Now begin to execute the tests in the testfiles */
609 for ( testfile_index = 0;
610 testfile_index < testfile_count;
611 testfile_index++ )
612 {
Gilles Peskine3c1c8ea2019-09-16 15:10:47 +0200613 size_t unmet_dep_count = 0;
Gilles Peskine06725c92020-03-30 21:39:09 +0200614 int unmet_dependencies[20];
Ronald Cron67a8a372020-04-01 16:04:41 +0200615 int missing_unmet_dependencies = 0;
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100616
617 test_filename = test_files[ testfile_index ];
618
619 file = fopen( test_filename, "r" );
620 if( file == NULL )
621 {
622 mbedtls_fprintf( stderr, "Failed to open test file: %s\n",
623 test_filename );
Gilles Peskine9c673232020-01-21 18:03:56 +0100624 if( outcome_file != NULL )
625 fclose( outcome_file );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100626 return( 1 );
627 }
628
629 while( !feof( file ) )
630 {
631 if( unmet_dep_count > 0 )
632 {
633 mbedtls_fprintf( stderr,
634 "FATAL: Dep count larger than zero at start of loop\n" );
635 mbedtls_exit( MBEDTLS_EXIT_FAILURE );
636 }
637 unmet_dep_count = 0;
Ronald Cron67a8a372020-04-01 16:04:41 +0200638 missing_unmet_dependencies = 0;
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100639
640 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
641 break;
Hanno Beckere69d0152019-07-05 13:31:30 +0100642 mbedtls_fprintf( stdout, "%s%.66s",
Chris Jonese60e2ae2021-01-20 17:51:47 +0000643 mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED ?
644 "\n" : "", buf );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100645 mbedtls_fprintf( stdout, " " );
646 for( i = strlen( buf ) + 1; i < 67; i++ )
647 mbedtls_fprintf( stdout, "." );
648 mbedtls_fprintf( stdout, " " );
649 fflush( stdout );
Gilles Peskine51dcc242019-09-16 15:13:48 +0200650 write_outcome_entry( outcome_file, argv[0], buf );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100651
652 total_tests++;
653
654 if( ( ret = get_line( file, buf, sizeof( buf ) ) ) != 0 )
655 break;
656 cnt = parse_arguments( buf, strlen( buf ), params,
657 sizeof( params ) / sizeof( params[0] ) );
658
659 if( strcmp( params[0], "depends_on" ) == 0 )
660 {
661 for( i = 1; i < cnt; i++ )
662 {
663 int dep_id = strtol( params[i], NULL, 10 );
664 if( dep_check( dep_id ) != DEPENDENCY_SUPPORTED )
665 {
Ronald Crone1a05a52020-04-01 15:52:06 +0200666 if( unmet_dep_count <
667 ARRAY_LENGTH( unmet_dependencies ) )
668 {
669 unmet_dependencies[unmet_dep_count] = dep_id;
670 unmet_dep_count++;
671 }
Ronald Cron67a8a372020-04-01 16:04:41 +0200672 else
673 {
674 missing_unmet_dependencies = 1;
675 }
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100676 }
677 }
678
679 if( ( ret = get_line( file, buf, sizeof( buf ) ) ) != 0 )
680 break;
681 cnt = parse_arguments( buf, strlen( buf ), params,
682 sizeof( params ) / sizeof( params[0] ) );
683 }
684
685 // If there are no unmet dependencies execute the test
686 if( unmet_dep_count == 0 )
687 {
Chris Jones567e0ad2021-02-03 12:07:01 +0000688 mbedtls_test_info_reset( );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100689
690#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
691 /* Suppress all output from the library unless we're verbose
692 * mode
693 */
694 if( !option_verbose )
695 {
gufe44067f6e02020-07-30 09:02:27 +0200696 stdout_fd = redirect_output( stdout, "/dev/null" );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100697 if( stdout_fd == -1 )
698 {
699 /* Redirection has failed with no stdout so exit */
700 exit( 1 );
701 }
702 }
703#endif /* __unix__ || __APPLE__ __MACH__ */
704
k-stachowiak03954f22019-09-16 10:23:10 +0200705 function_id = strtoul( params[0], NULL, 10 );
Azim Khan13c6bfb2017-06-15 14:45:56 +0100706 if ( (ret = check_test( function_id )) == DISPATCH_TEST_SUCCESS )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100707 {
Azim Khan13c6bfb2017-06-15 14:45:56 +0100708 ret = convert_params( cnt - 1, params + 1, int_params );
709 if ( DISPATCH_TEST_SUCCESS == ret )
710 {
711 ret = dispatch_test( function_id, (void **)( params + 1 ) );
712 }
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100713 }
714
715#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
gufe44067f6e02020-07-30 09:02:27 +0200716 if( !option_verbose && restore_output( stdout, stdout_fd ) )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100717 {
718 /* Redirection has failed with no stdout so exit */
719 exit( 1 );
720 }
721#endif /* __unix__ || __APPLE__ __MACH__ */
722
723 }
724
Gilles Peskine51dcc242019-09-16 15:13:48 +0200725 write_outcome_result( outcome_file,
726 unmet_dep_count, unmet_dependencies,
Ronald Cron67a8a372020-04-01 16:04:41 +0200727 missing_unmet_dependencies,
Chris Jonese60e2ae2021-01-20 17:51:47 +0000728 ret, &mbedtls_test_info );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100729 if( unmet_dep_count > 0 || ret == DISPATCH_UNSUPPORTED_SUITE )
730 {
731 total_skipped++;
732 mbedtls_fprintf( stdout, "----" );
733
734 if( 1 == option_verbose && ret == DISPATCH_UNSUPPORTED_SUITE )
735 {
736 mbedtls_fprintf( stdout, "\n Test Suite not enabled" );
737 }
738
739 if( 1 == option_verbose && unmet_dep_count > 0 )
740 {
741 mbedtls_fprintf( stdout, "\n Unmet dependencies: " );
742 for( i = 0; i < unmet_dep_count; i++ )
743 {
Gilles Peskine06725c92020-03-30 21:39:09 +0200744 mbedtls_fprintf( stdout, "%d ",
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100745 unmet_dependencies[i] );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100746 }
Ronald Cron67a8a372020-04-01 16:04:41 +0200747 if( missing_unmet_dependencies )
748 mbedtls_fprintf( stdout, "..." );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100749 }
750 mbedtls_fprintf( stdout, "\n" );
751 fflush( stdout );
752
753 unmet_dep_count = 0;
Ronald Cron67a8a372020-04-01 16:04:41 +0200754 missing_unmet_dependencies = 0;
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100755 }
756 else if( ret == DISPATCH_TEST_SUCCESS )
757 {
Chris Jonese60e2ae2021-01-20 17:51:47 +0000758 if( mbedtls_test_info.result == MBEDTLS_TEST_RESULT_SUCCESS )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100759 {
760 mbedtls_fprintf( stdout, "PASS\n" );
761 }
Chris Jonese60e2ae2021-01-20 17:51:47 +0000762 else if( mbedtls_test_info.result == MBEDTLS_TEST_RESULT_SKIPPED )
Hanno Beckere69d0152019-07-05 13:31:30 +0100763 {
764 mbedtls_fprintf( stdout, "----\n" );
765 total_skipped++;
766 }
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100767 else
768 {
769 total_errors++;
770 mbedtls_fprintf( stdout, "FAILED\n" );
Gilles Peskine56055912019-03-01 14:26:30 +0100771 mbedtls_fprintf( stdout, " %s\n at ",
Chris Jonese60e2ae2021-01-20 17:51:47 +0000772 mbedtls_test_info.test );
773 if( mbedtls_test_info.step != (unsigned long)( -1 ) )
Gilles Peskine56055912019-03-01 14:26:30 +0100774 {
775 mbedtls_fprintf( stdout, "step %lu, ",
Chris Jonese60e2ae2021-01-20 17:51:47 +0000776 mbedtls_test_info.step );
Gilles Peskine56055912019-03-01 14:26:30 +0100777 }
778 mbedtls_fprintf( stdout, "line %d, %s",
Chris Jonese60e2ae2021-01-20 17:51:47 +0000779 mbedtls_test_info.line_no,
780 mbedtls_test_info.filename );
Gilles Peskine89615ee2021-04-29 20:28:54 +0200781 if( mbedtls_test_info.line1[0] != 0 )
782 mbedtls_fprintf( stdout, "\n %s",
783 mbedtls_test_info.line1 );
784 if( mbedtls_test_info.line2[0] != 0 )
785 mbedtls_fprintf( stdout, "\n %s",
786 mbedtls_test_info.line2 );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100787 }
788 fflush( stdout );
789 }
790 else if( ret == DISPATCH_INVALID_TEST_DATA )
791 {
792 mbedtls_fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
793 fclose( file );
794 mbedtls_exit( 2 );
795 }
796 else if( ret == DISPATCH_TEST_FN_NOT_FOUND )
797 {
Gilles Peskine31fccc82019-09-16 15:12:37 +0200798 mbedtls_fprintf( stderr, "FAILED: FATAL TEST FUNCTION NOT FOUND\n" );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100799 fclose( file );
800 mbedtls_exit( 2 );
801 }
802 else
803 total_errors++;
804 }
805 fclose( file );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100806 }
807
Gilles Peskine51dcc242019-09-16 15:13:48 +0200808 if( outcome_file != NULL )
809 fclose( outcome_file );
810
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100811 mbedtls_fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
812 if( total_errors == 0 )
813 mbedtls_fprintf( stdout, "PASSED" );
814 else
815 mbedtls_fprintf( stdout, "FAILED" );
816
Gilles Peskine3c1c8ea2019-09-16 15:10:47 +0200817 mbedtls_fprintf( stdout, " (%u / %u tests (%u skipped))\n",
818 total_tests - total_errors, total_tests, total_skipped );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100819
820#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && \
821 !defined(TEST_SUITE_MEMORY_BUFFER_ALLOC)
822#if defined(MBEDTLS_MEMORY_DEBUG)
823 mbedtls_memory_buffer_alloc_status();
824#endif
825 mbedtls_memory_buffer_alloc_free();
826#endif
827
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100828 return( total_errors != 0 );
829}