blob: a4a5a8265fbbc89ec864f4af2f62a28b36f1836e [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/**
4 * \brief Varifies that string is in string parameter format i.e. "<str>"
5 * 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{
13 if( (*str)[0] != '"' ||
14 (*str)[strlen( *str ) - 1] != '"' )
15 {
16 mbedtls_fprintf( stderr,
17 "Expected string (with \"\") for parameter and got: %s\n", *str );
18 return( -1 );
19 }
20
21 (*str)++;
22 (*str)[strlen( *str ) - 1] = '\0';
23
24 return( 0 );
25}
26
27/**
28 * \brief Varifies that string is an integer. Also gives the converted
29 * 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 */
36int verify_int( char *str, int *value )
37{
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 ) ) &&
52 str[i - 1] == '0' && str[i] == 'x' )
53 {
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" \
90 " files... One or more test data file. If no file is specified\n" \
91 " the followimg default test case is used:\n" \
92 " %s\n\n" \
93 " Options:\n" \
94 " -v | --verbose Display full information about each test\n" \
95 " -h | --help Display this information\n\n", \
96 argv[0], \
97 "TESTCASE_FILENAME"
98
99
100/**
101 * \brief Read a line from the passed file pointer.
102 *
103 * \param f FILE pointer
104 * \param buf Pointer to memory to hold read line.
105 * \param len Length of the buf.
106 *
107 * \return 0 if success else -1
108 */
109int get_line( FILE *f, char *buf, size_t len )
110{
111 char *ret;
112 int i = 0, str_len = 0, has_string = 0;
113
114 /* Read until we get a valid line */
115 do
116 {
117 ret = fgets( buf, len, f );
118 if( ret == NULL )
119 return( -1 );
120
121 str_len = strlen( buf );
122
123 /* Skip empty line and comment */
124 if ( str_len == 0 || buf[0] == '#' )
125 continue;
126 has_string = 0;
127 for ( i = 0; i < str_len; i++ )
128 {
129 char c = buf[i];
130 if ( c != ' ' && c != '\t' && c != '\n' &&
131 c != '\v' && c != '\f' && c != '\r' )
132 {
133 has_string = 1;
134 break;
135 }
136 }
137 } while( !has_string );
138
139 /* Strip new line and carriage return */
140 ret = buf + strlen( buf );
141 if( ret-- > buf && *ret == '\n' )
142 *ret = '\0';
143 if( ret-- > buf && *ret == '\r' )
144 *ret = '\0';
145
146 return( 0 );
147}
148
149/**
150 * \brief Splits string delimited by ':'. Ignores '\:'.
151 *
152 * \param buf Input string
153 * \param len Input string length
154 * \param params Out params found
155 * \param params_len Out params array len
156 *
157 * \return Count of strings found.
158 */
159static int parse_arguments( char *buf, size_t len, char **params,
160 size_t params_len )
161{
162 size_t cnt = 0, i;
163 char *cur = buf;
164 char *p = buf, *q;
165
166 params[cnt++] = cur;
167
168 while( *p != '\0' && p < buf + len )
169 {
170 if( *p == '\\' )
171 {
172 p++;
173 p++;
174 continue;
175 }
176 if( *p == ':' )
177 {
178 if( p + 1 < buf + len )
179 {
180 cur = p + 1;
181 assert( cnt < params_len );
182 params[cnt++] = cur;
183 }
184 *p = '\0';
185 }
186
187 p++;
188 }
189
190 /* Replace newlines, question marks and colons in strings */
191 for( i = 0; i < cnt; i++ )
192 {
193 p = params[i];
194 q = params[i];
195
196 while( *p != '\0' )
197 {
198 if( *p == '\\' && *(p + 1) == 'n' )
199 {
200 p += 2;
201 *(q++) = '\n';
202 }
203 else if( *p == '\\' && *(p + 1) == ':' )
204 {
205 p += 2;
206 *(q++) = ':';
207 }
208 else if( *p == '\\' && *(p + 1) == '?' )
209 {
210 p += 2;
211 *(q++) = '?';
212 }
213 else
214 *(q++) = *(p++);
215 }
216 *q = '\0';
217 }
218
219 return( cnt );
220}
221
222/**
223 * \brief Converts parameters into test function consumable parameters.
224 * Example: Input: {"int", "0", "char*", "Hello",
225 * "hex", "abef", "exp", "1"}
226 * Output: {
227 * 0, // Verified int
228 * "Hello", // Verified string
229 * 2, { 0xab, 0xef },// Converted len,hex pair
230 * 9600 // Evaluated expression
231 * }
232 *
233 *
234 * \param cnt Input string.
235 * \param params Out array of found strings.
236 * \param int_params_store Memory for storing processed integer parameters.
237 *
238 * \return 0 for success else 1
239 */
240static int convert_params( size_t cnt , char ** params , int * int_params_store )
241{
242 char ** cur = params;
243 char ** out = params;
244 int ret = ( DISPATCH_TEST_SUCCESS );
245
246 while ( cur - params < (int) cnt )
247 {
248 char * type = *cur++;
249 char * val = *cur++;
250
251 if ( strcmp( type, "char*" ) == 0 )
252 {
253 if ( verify_string( &val ) == 0 )
254 {
255 *out++ = val;
256 }
257 else
258 {
259 ret = ( DISPATCH_INVALID_TEST_DATA );
260 break;
261 }
262 }
263 else if ( strcmp( type, "int" ) == 0 )
264 {
265 if ( verify_int ( val, int_params_store ) == 0 )
266 {
267 *out++ = (char *) int_params_store++;
268 }
269 else
270 {
271 ret = ( DISPATCH_INVALID_TEST_DATA );
272 break;
273 }
274 }
275 else if ( strcmp( type, "hex" ) == 0 )
276 {
Azim Khan184447e2017-05-31 20:29:36 +0100277 if ( verify_string( &val ) == 0 )
278 {
279 int j;
280 *int_params_store = unhexify( (unsigned char *) val, val );
281 printf ("\n");
282 for (j = 0; j < *int_params_store; j++)
283 printf ("%02x ", (uint8_t)val[j]);
284 printf ("\n len %d\n", *int_params_store);
285 *out++ = val;
286 *out++ = (char *)(int_params_store++);
287 }
288 else
289 {
290 ret = ( DISPATCH_INVALID_TEST_DATA );
291 break;
292 }
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100293 }
294 else if ( strcmp( type, "exp" ) == 0 )
295 {
296 int exp_id = strtol( val, NULL, 10 );
297 if ( get_expression ( exp_id, int_params_store ) == 0 )
298 {
299 *out++ = (char *)int_params_store++;
300 }
301 else
302 {
303 ret = ( DISPATCH_INVALID_TEST_DATA );
304 break;
305 }
306 }
307 else
308 {
309 ret = ( DISPATCH_INVALID_TEST_DATA );
310 break;
311 }
312 }
313 return( ret );
314}
315
316/**
317 * \brief Tests snprintf implementation with test input.
318 *
Azim Khan191e9042017-06-09 12:39:00 +0100319 * \note
320 * At high optimization levels (e.g. gcc -O3), this function may be
321 * inlined in run_test_snprintf. This can trigger a spurious warning about
322 * potential misuse of snprintf from gcc -Wformat-truncation (observed with
323 * gcc 7.2). This warning makes tests in run_test_snprintf redundant on gcc
324 * only. They are still valid for other compilers. Avoid this warning by
325 * forbidding inlining of this function by gcc.
326 *
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100327 * \param n Buffer test length.
328 * \param ref_buf Expected buffer.
329 * \param ref_ret Expected snprintf return value.
330 *
331 * \return 0 for success else 1
332 */
Azim Khan191e9042017-06-09 12:39:00 +0100333#if defined(__GNUC__)
334__attribute__((__noinline__))
335#endif
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100336static int test_snprintf( size_t n, const char ref_buf[10], int ref_ret )
337{
338 int ret;
339 char buf[10] = "xxxxxxxxx";
340 const char ref[10] = "xxxxxxxxx";
341
342 ret = mbedtls_snprintf( buf, n, "%s", "123" );
343 if( ret < 0 || (size_t) ret >= n )
344 ret = -1;
345
346 if( strncmp( ref_buf, buf, sizeof( buf ) ) != 0 ||
347 ref_ret != ret ||
348 memcmp( buf + n, ref + n, sizeof( buf ) - n ) != 0 )
349 {
350 return( 1 );
351 }
352
353 return( 0 );
354}
355
356/**
357 * \brief Tests snprintf implementation.
358 *
359 * \param none
360 *
361 * \return 0 for success else 1
362 */
363static int run_test_snprintf( void )
364{
365 return( test_snprintf( 0, "xxxxxxxxx", -1 ) != 0 ||
366 test_snprintf( 1, "", -1 ) != 0 ||
367 test_snprintf( 2, "1", -1 ) != 0 ||
368 test_snprintf( 3, "12", -1 ) != 0 ||
369 test_snprintf( 4, "123", 3 ) != 0 ||
370 test_snprintf( 5, "123", 3 ) != 0 );
371}
372
373
374/**
375 * \brief Desktop implementation of execute_tests().
376 * Parses command line and executes tests from
377 * supplied or default data file.
378 *
379 * \param argc Command line argument count.
380 * \param argv Argument array.
381 *
382 * \return Program exit status.
383 */
384int execute_tests( int argc , const char ** argv )
385{
386 /* Local Configurations and options */
387 const char *default_filename = "DATA_FILE";
388 const char *test_filename = NULL;
389 const char **test_files = NULL;
390 int testfile_count = 0;
391 int option_verbose = 0;
Azim Khan13c6bfb2017-06-15 14:45:56 +0100392 int function_id = 0;
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100393
394 /* Other Local variables */
395 int arg_index = 1;
396 const char *next_arg;
397 int testfile_index, ret, i, cnt;
398 int total_errors = 0, total_tests = 0, total_skipped = 0;
399 FILE *file;
400 char buf[5000];
401 char *params[50];
402 int int_params[50]; // Store for proccessed integer params.
403 void *pointer;
404#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
405 int stdout_fd = -1;
406#endif /* __unix__ || __APPLE__ __MACH__ */
407
408#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && \
409 !defined(TEST_SUITE_MEMORY_BUFFER_ALLOC)
410 unsigned char alloc_buf[1000000];
411 mbedtls_memory_buffer_alloc_init( alloc_buf, sizeof( alloc_buf ) );
412#endif
413
414 /*
415 * The C standard doesn't guarantee that all-bits-0 is the representation
416 * of a NULL pointer. We do however use that in our code for initializing
417 * structures, which should work on every modern platform. Let's be sure.
418 */
419 memset( &pointer, 0, sizeof( void * ) );
420 if( pointer != NULL )
421 {
422 mbedtls_fprintf( stderr, "all-bits-zero is not a NULL pointer\n" );
423 return( 1 );
424 }
425
426 /*
427 * Make sure we have a snprintf that correctly zero-terminates
428 */
429 if( run_test_snprintf() != 0 )
430 {
431 mbedtls_fprintf( stderr, "the snprintf implementation is broken\n" );
Azim Khan191e9042017-06-09 12:39:00 +0100432 return( 1 );
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100433 }
434
435 while( arg_index < argc )
436 {
437 next_arg = argv[ arg_index ];
438
439 if( strcmp(next_arg, "--verbose" ) == 0 ||
440 strcmp(next_arg, "-v" ) == 0 )
441 {
442 option_verbose = 1;
443 }
444 else if( strcmp(next_arg, "--help" ) == 0 ||
445 strcmp(next_arg, "-h" ) == 0 )
446 {
447 mbedtls_fprintf( stdout, USAGE );
448 mbedtls_exit( EXIT_SUCCESS );
449 }
450 else
451 {
452 /* Not an option, therefore treat all further arguments as the file
453 * list.
454 */
455 test_files = &argv[ arg_index ];
456 testfile_count = argc - arg_index;
457 }
458
459 arg_index++;
460 }
461
462 /* If no files were specified, assume a default */
463 if ( test_files == NULL || testfile_count == 0 )
464 {
465 test_files = &default_filename;
466 testfile_count = 1;
467 }
468
469 /* Initialize the struct that holds information about the last test */
470 memset( &test_info, 0, sizeof( test_info ) );
471
472 /* Now begin to execute the tests in the testfiles */
473 for ( testfile_index = 0;
474 testfile_index < testfile_count;
475 testfile_index++ )
476 {
477 int unmet_dep_count = 0;
478 char *unmet_dependencies[20];
479
480 test_filename = test_files[ testfile_index ];
481
482 file = fopen( test_filename, "r" );
483 if( file == NULL )
484 {
485 mbedtls_fprintf( stderr, "Failed to open test file: %s\n",
486 test_filename );
487 return( 1 );
488 }
489
490 while( !feof( file ) )
491 {
492 if( unmet_dep_count > 0 )
493 {
494 mbedtls_fprintf( stderr,
495 "FATAL: Dep count larger than zero at start of loop\n" );
496 mbedtls_exit( MBEDTLS_EXIT_FAILURE );
497 }
498 unmet_dep_count = 0;
499
500 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
501 break;
502 mbedtls_fprintf( stdout, "%s%.66s", test_info.failed ? "\n" : "", buf );
503 mbedtls_fprintf( stdout, " " );
504 for( i = strlen( buf ) + 1; i < 67; i++ )
505 mbedtls_fprintf( stdout, "." );
506 mbedtls_fprintf( stdout, " " );
507 fflush( stdout );
508
509 total_tests++;
510
511 if( ( ret = get_line( file, buf, sizeof( buf ) ) ) != 0 )
512 break;
513 cnt = parse_arguments( buf, strlen( buf ), params,
514 sizeof( params ) / sizeof( params[0] ) );
515
516 if( strcmp( params[0], "depends_on" ) == 0 )
517 {
518 for( i = 1; i < cnt; i++ )
519 {
520 int dep_id = strtol( params[i], NULL, 10 );
521 if( dep_check( dep_id ) != DEPENDENCY_SUPPORTED )
522 {
523 if( 0 == option_verbose )
524 {
525 /* Only one count is needed if not verbose */
526 unmet_dep_count++;
527 break;
528 }
529
530 unmet_dependencies[ unmet_dep_count ] = strdup( params[i] );
531 if( unmet_dependencies[ unmet_dep_count ] == NULL )
532 {
533 mbedtls_fprintf( stderr, "FATAL: Out of memory\n" );
534 mbedtls_exit( MBEDTLS_EXIT_FAILURE );
535 }
536 unmet_dep_count++;
537 }
538 }
539
540 if( ( ret = get_line( file, buf, sizeof( buf ) ) ) != 0 )
541 break;
542 cnt = parse_arguments( buf, strlen( buf ), params,
543 sizeof( params ) / sizeof( params[0] ) );
544 }
545
546 // If there are no unmet dependencies execute the test
547 if( unmet_dep_count == 0 )
548 {
549 test_info.failed = 0;
550
551#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
552 /* Suppress all output from the library unless we're verbose
553 * mode
554 */
555 if( !option_verbose )
556 {
557 stdout_fd = redirect_output( &stdout, "/dev/null" );
558 if( stdout_fd == -1 )
559 {
560 /* Redirection has failed with no stdout so exit */
561 exit( 1 );
562 }
563 }
564#endif /* __unix__ || __APPLE__ __MACH__ */
565
Azim Khan13c6bfb2017-06-15 14:45:56 +0100566 function_id = strtol( params[0], NULL, 10 );
567 if ( (ret = check_test( function_id )) == DISPATCH_TEST_SUCCESS )
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100568 {
Azim Khan13c6bfb2017-06-15 14:45:56 +0100569 ret = convert_params( cnt - 1, params + 1, int_params );
570 if ( DISPATCH_TEST_SUCCESS == ret )
571 {
572 ret = dispatch_test( function_id, (void **)( params + 1 ) );
573 }
Mohammad Azim Khanfff49042017-03-28 01:48:31 +0100574 }
575
576#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
577 if( !option_verbose && restore_output( &stdout, stdout_fd ) )
578 {
579 /* Redirection has failed with no stdout so exit */
580 exit( 1 );
581 }
582#endif /* __unix__ || __APPLE__ __MACH__ */
583
584 }
585
586 if( unmet_dep_count > 0 || ret == DISPATCH_UNSUPPORTED_SUITE )
587 {
588 total_skipped++;
589 mbedtls_fprintf( stdout, "----" );
590
591 if( 1 == option_verbose && ret == DISPATCH_UNSUPPORTED_SUITE )
592 {
593 mbedtls_fprintf( stdout, "\n Test Suite not enabled" );
594 }
595
596 if( 1 == option_verbose && unmet_dep_count > 0 )
597 {
598 mbedtls_fprintf( stdout, "\n Unmet dependencies: " );
599 for( i = 0; i < unmet_dep_count; i++ )
600 {
601 mbedtls_fprintf( stdout, "%s ",
602 unmet_dependencies[i] );
603 free( unmet_dependencies[i] );
604 }
605 }
606 mbedtls_fprintf( stdout, "\n" );
607 fflush( stdout );
608
609 unmet_dep_count = 0;
610 }
611 else if( ret == DISPATCH_TEST_SUCCESS )
612 {
613 if( test_info.failed == 0 )
614 {
615 mbedtls_fprintf( stdout, "PASS\n" );
616 }
617 else
618 {
619 total_errors++;
620 mbedtls_fprintf( stdout, "FAILED\n" );
621 mbedtls_fprintf( stdout, " %s\n at line %d, %s\n",
622 test_info.test, test_info.line_no,
623 test_info.filename );
624 }
625 fflush( stdout );
626 }
627 else if( ret == DISPATCH_INVALID_TEST_DATA )
628 {
629 mbedtls_fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
630 fclose( file );
631 mbedtls_exit( 2 );
632 }
633 else if( ret == DISPATCH_TEST_FN_NOT_FOUND )
634 {
635 mbedtls_fprintf( stderr, "FAILED: FATAL TEST FUNCTION NOT FUND\n" );
636 fclose( file );
637 mbedtls_exit( 2 );
638 }
639 else
640 total_errors++;
641 }
642 fclose( file );
643
644 /* In case we encounter early end of file */
645 for( i = 0; i < unmet_dep_count; i++ )
646 free( unmet_dependencies[i] );
647 }
648
649 mbedtls_fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
650 if( total_errors == 0 )
651 mbedtls_fprintf( stdout, "PASSED" );
652 else
653 mbedtls_fprintf( stdout, "FAILED" );
654
655 mbedtls_fprintf( stdout, " (%d / %d tests (%d skipped))\n",
656 total_tests - total_errors, total_tests, total_skipped );
657
658#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && \
659 !defined(TEST_SUITE_MEMORY_BUFFER_ALLOC)
660#if defined(MBEDTLS_MEMORY_DEBUG)
661 mbedtls_memory_buffer_alloc_status();
662#endif
663 mbedtls_memory_buffer_alloc_free();
664#endif
665
666#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
667 if( stdout_fd != -1 )
668 close_output( stdout );
669#endif /* __unix__ || __APPLE__ __MACH__ */
670
671 return( total_errors != 0 );
672}