Test framework output improvement.
[openssl.git] / test / testutil / tests.c
1 /*
2  * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include "../testutil.h"
11 #include "output.h"
12 #include "tu_local.h"
13
14 #include <string.h>
15 #include <ctype.h>
16 #include "../../e_os.h"
17
18 /* The size of memory buffers to display on failure */
19 #define MEM_BUFFER_SIZE     (33)
20 #define MAX_STRING_WIDTH    (80)
21
22 /* Output a failed test first line */
23 static void test_fail_message_prefix(const char *prefix, const char *file,
24                                      int line, const char *type,
25                                      const char *left, const char *right,
26                                      const char *op)
27 {
28     test_printf_stderr("%*s# %s: ", subtest_level(), "",
29                        prefix != NULL ? prefix : "ERROR");
30     if (type)
31         test_printf_stderr("(%s) ", type);
32     if (op != NULL)
33         test_printf_stderr("%s %s %s", left, op, right);
34     if (file != NULL) {
35         test_printf_stderr(" @ %s:%d", file, line);
36     }
37     test_printf_stderr("\n");
38 }
39
40 /*
41  * A common routine to output test failure messages.  Generally this should not
42  * be called directly, rather it should be called by the following functions.
43  *
44  * |desc| is a printf formatted description with arguments |args| that is
45  * supplied by the user and |desc| can be NULL.  |type| is the data type
46  * that was tested (int, char, ptr, ...).  |fmt| is a system provided
47  * printf format with following arguments that spell out the failure
48  * details i.e. the actual values compared and the operator used.
49  *
50  * The typical use for this is from an utility test function:
51  *
52  * int test6(const char *file, int line, int n) {
53  *     if (n != 6) {
54  *         test_fail_message(1, file, line, "int", "value %d is not %d", n, 6);
55  *         return 0;
56  *     }
57  *     return 1;
58  * }
59  *
60  * calling test6(3, "oops") will return 0 and produce out along the lines of:
61  *      FAIL oops: (int) value 3 is not 6\n
62  */
63 static void test_fail_message(const char *prefix, const char *file, int line,
64                               const char *type, const char *left,
65                               const char *right, const char *op,
66                               const char *fmt, ...)
67             PRINTF_FORMAT(8, 9);
68
69 static void test_fail_message_va(const char *prefix, const char *file,
70                                  int line, const char *type,
71                                  const char *left, const char *right,
72                                  const char *op, const char *fmt, va_list ap)
73 {
74     test_fail_message_prefix(prefix, file, line, type, left, right, op);
75     if (fmt != NULL) {
76         test_printf_stderr("%*s# ", subtest_level(), "");
77         test_vprintf_stderr(fmt, ap);
78         test_printf_stderr("\n");
79     }
80     test_printf_stderr("\n");
81     test_flush_stderr();
82 }
83
84 static void test_fail_string_message(const char *prefix, const char *file,
85                                      int line, const char *type,
86                                      const char *left, const char *right,
87                                      const char *op, const char *m1, size_t l1,
88                                      const char *m2, size_t l2)
89 {
90     const int indent = subtest_level();
91     const size_t width = (MAX_STRING_WIDTH - indent - 12) / 16 * 16;
92     char b1[MAX_STRING_WIDTH + 1], b2[MAX_STRING_WIDTH + 1];
93     char bdiff[MAX_STRING_WIDTH + 1];
94     size_t n1, n2, i;
95     unsigned int cnt = 0, diff;
96
97     test_fail_message_prefix(prefix, file, line, type, left, right, op);
98     if (m1 == NULL)
99         l1 = 0;
100     if (m2 == NULL)
101         l2 = 0;
102     if (l1 == 0 && l2 == 0) {
103         if ((m1 == NULL) == (m2 == NULL)) {
104             test_printf_stderr("%*s# % 4s   %s\n", indent, "", "",
105                                m1 == NULL ? "NULL" : "''");
106         } else {
107             test_printf_stderr("%*s# % 4s - %s\n", indent, "", "",
108                                m1 == NULL ? "NULL" : "''");
109             test_printf_stderr("%*s# % 4s + %s\n", indent, "", "",
110                                m2 == NULL ? "NULL" : "''");
111         }
112         goto fin;
113     }
114
115     while (l1 > 0 || l2 > 0) {
116         n1 = n2 = 0;
117         if (l1 > 0) {
118             b1[n1 = l1 > width ? width : l1] = 0;
119             for (i = 0; i < n1; i++)
120                 b1[i] = isprint(m1[i]) ? m1[i] : '.';
121         }
122         if (l2 > 0) {
123             b2[n2 = l2 > width ? width : l2] = 0;
124             for (i = 0; i < n2; i++)
125                 b2[i] = isprint(m2[i]) ? m2[i] : '.';
126         }
127         diff = n1 != n2;
128         i = 0;
129         if (n1 > 0 && n2 > 0) {
130             const size_t j = n1 < n2 ? n1 : n2;
131             const size_t k = n1 > n2 ? n1 : n2;
132
133             for (; i < j; i++)
134                 if (m1[i] == m2[i]) {
135                     bdiff[i] = ' ';
136                 } else {
137                     bdiff[i] = '^';
138                     diff = 1;
139                 }
140             for (; i < k; i++)
141                 bdiff[i] = '^';
142             bdiff[i] = '\0';
143         }
144         if (!diff) {
145             test_printf_stderr("%*s# % 4u:  '%s'\n", indent, "", cnt, b1);
146         } else {
147             if (cnt == 0 && m1 == NULL)
148                 test_printf_stderr("%*s# % 4s - NULL\n", indent, "", "");
149             else if (cnt == 0 && *m1 == '\0')
150                 test_printf_stderr("%*s# % 4s - ''\n", indent, "", "");
151             else if (n1 > 0)
152                 test_printf_stderr("%*s# % 4u:- '%s'\n", indent, "", cnt, b1);
153             if (cnt == 0 && m2 == NULL)
154                 test_printf_stderr("%*s# % 4s + NULL\n", indent, "", "");
155             else if (cnt == 0 && *m2 == '\0')
156                 test_printf_stderr("%*s# % 4s + ''\n", indent, "", "");
157             else if (n2 > 0)
158                 test_printf_stderr("%*s# % 4u:+ '%s'\n", indent, "", cnt, b2);
159             if (i > 0)
160                 test_printf_stderr("%*s# % 4s    %s\n", indent, "", "", bdiff);
161         }
162         m1 += n1;
163         m2 += n2;
164         l1 -= n1;
165         l2 -= n2;
166         cnt += width;
167     }
168 fin:
169     test_printf_stderr("\n");
170     test_flush_stderr();
171 }
172
173 static void hex_convert_memory(const char *m, size_t n, char *b)
174 {
175     size_t i;
176
177     for (i = 0; i < n; i++) {
178         const unsigned char c = *m++;
179
180         *b++ = "0123456789abcdef"[c >> 4];
181         *b++ = "0123456789abcdef"[c & 15];
182         if ((i % 8) == 7 && i != n - 1)
183             *b++ = ' ';
184     }
185     *b = '\0';
186 }
187
188 static void test_fail_memory_message(const char *prefix, const char *file,
189                                      int line, const char *type,
190                                      const char *left, const char *right,
191                                      const char *op, const char *m1, size_t l1,
192                                      const char *m2, size_t l2)
193 {
194     const int indent = subtest_level();
195     const size_t bytes = (MAX_STRING_WIDTH - 9) / 17 * 8;
196     char b1[MAX_STRING_WIDTH + 1], b2[MAX_STRING_WIDTH + 1];
197     char *p, bdiff[MAX_STRING_WIDTH + 1];
198     size_t n1, n2, i;
199     unsigned int cnt = 0, diff;
200
201     test_fail_message_prefix(prefix, file, line, type, left, right, op);
202     if (m1 == NULL)
203         l1 = 0;
204     if (m2 == NULL)
205         l2 = 0;
206     if (l1 == 0 && l2 == 0) {
207         if ((m1 == NULL) == (m2 == NULL)) {
208             test_printf_stderr("%*s# %04s  %s\n", indent, "", "",
209                                m1 == NULL ? "NULL" : "empty");
210         } else {
211             test_printf_stderr("%*s# %04s -%s\n", indent, "", "",
212                                m1 == NULL ? "NULL" : "empty");
213             test_printf_stderr("%*s# %04s +%s\n", indent, "", "",
214                                m2 == NULL ? "NULL" : "empty");
215         }
216         goto fin;
217     }
218
219     while (l1 > 0 || l2 > 0) {
220         n1 = n2 = 0;
221         if (l1 > 0) {
222             n1 = l1 > bytes ? bytes : l1;
223             hex_convert_memory(m1, n1, b1);
224         }
225         if (l2 > 0) {
226             n2 = l2 > bytes ? bytes : l2;
227             hex_convert_memory(m2, n2, b2);
228         }
229
230         diff = n1 != n2;
231         i = 0;
232         p = bdiff;
233         if (n1 > 0 && n2 > 0) {
234             const size_t j = n1 < n2 ? n1 : n2;
235             const size_t k = n1 > n2 ? n1 : n2;
236
237             for (; i < j; i++) {
238                 if (m1[i] == m2[i]) {
239                     *p++ = ' ';
240                     *p++ = ' ';
241                 } else {
242                     *p++ = '^';
243                     *p++ = '^';
244                     diff = 1;
245                 }
246                 if ((i % 8) == 7 && (i != j - 1 || j != k))
247                     *p++ = ' ';
248             }
249
250             for (; i < k; i++) {
251                 *p++ = '^';
252                 *p++ = '^';
253                 if ((i % 8) == 7 && i != k - 1)
254                     *p++ = ' ';
255             }
256             *p++ = '\0';
257         }
258
259         if (!diff) {
260             test_printf_stderr("%*s# %04x: %s\n", indent, "", cnt, b1);
261         } else {
262             if (cnt == 0 && m1 == NULL)
263                 test_printf_stderr("%*s# %04s -NULL\n", indent, "", "");
264             else if (cnt == 0 && l1 == 0)
265                 test_printf_stderr("%*s# %04s -empty\n", indent, "", "");
266             else if (n1 > 0)
267                 test_printf_stderr("%*s# %04x:-%s\n", indent, "", cnt, b1);
268             if (cnt == 0 && m2 == NULL)
269                 test_printf_stderr("%*s# %04s +NULL\n", indent, "", "");
270             else if (cnt == 0 && l2 == 0)
271                 test_printf_stderr("%*s# %04s +empty\n", indent, "", "");
272             else if (n2 > 0)
273                 test_printf_stderr("%*s# %04x:+%s\n", indent, "", cnt, b2);
274             if (i > 0)
275                 test_printf_stderr("%*s# % 4s  %s\n", indent, "", "", bdiff);
276         }
277         m1 += n1;
278         m2 += n2;
279         l1 -= n1;
280         l2 -= n2;
281         cnt += bytes;
282     }
283 fin:
284     test_printf_stderr("\n");
285     test_flush_stderr();
286 }
287
288 static void test_fail_message(const char *prefix, const char *file,
289                               int line, const char *type,
290                               const char *left, const char *right,
291                               const char *op, const char *fmt, ...)
292 {
293     va_list ap;
294
295     va_start(ap, fmt);
296     test_fail_message_va(prefix, file, line, type, left, right, op, fmt, ap);
297     va_end(ap);
298 }
299
300 void test_info_c90(const char *desc, ...)
301 {
302     va_list ap;
303
304     va_start(ap, desc);
305     test_fail_message_va("INFO", NULL, -1, NULL, NULL, NULL, NULL, desc, ap);
306     va_end(ap);
307 }
308
309 void test_info(const char *file, int line, const char *desc, ...)
310 {
311     va_list ap;
312
313     va_start(ap, desc);
314     test_fail_message_va("INFO", file, line, NULL, NULL, NULL, NULL, desc, ap);
315     va_end(ap);
316 }
317
318 void test_error_c90(const char *desc, ...)
319 {
320     va_list ap;
321
322     va_start(ap, desc);
323     test_fail_message(NULL, NULL, -1, NULL, NULL, NULL, NULL, desc, ap);
324     va_end(ap);
325 }
326
327 void test_error(const char *file, int line, const char *desc, ...)
328 {
329     va_list ap;
330
331     va_start(ap, desc);
332     test_fail_message_va(NULL, file, line, NULL, NULL, NULL, NULL, desc, ap);
333     va_end(ap);
334 }
335
336 void test_openssl_errors(void)
337 {
338     ERR_print_errors_cb(openssl_error_cb, NULL);
339 }
340
341 /*
342  * Define some comparisons between pairs of various types.
343  * These functions return 1 if the test is true.
344  * Otherwise, they return 0 and pretty-print diagnostics.
345  *
346  * In each case the functions produced are:
347  *  int test_name_eq(const type t1, const type t2, const char *desc, ...);
348  *  int test_name_ne(const type t1, const type t2, const char *desc, ...);
349  *  int test_name_lt(const type t1, const type t2, const char *desc, ...);
350  *  int test_name_le(const type t1, const type t2, const char *desc, ...);
351  *  int test_name_gt(const type t1, const type t2, const char *desc, ...);
352  *  int test_name_ge(const type t1, const type t2, const char *desc, ...);
353  *
354  * The t1 and t2 arguments are to be compared for equality, inequality,
355  * less than, less than or equal to, greater than and greater than or
356  * equal to respectively.  If the specified condition holds, the functions
357  * return 1.  If the condition does not hold, the functions print a diagnostic
358  * message and return 0.
359  *
360  * The desc argument is a printf format string followed by its arguments and
361  * this is included in the output if the condition being tested for is false.
362  */
363 #define DEFINE_COMPARISON(type, name, opname, op, fmt)                  \
364     int test_ ## name ## _ ## opname(const char *file, int line,        \
365                                      const char *s1, const char *s2,    \
366                                      const type t1, const type t2)      \
367     {                                                                   \
368         if (t1 op t2)                                                   \
369             return 1;                                                   \
370         test_fail_message(NULL, file, line, #type, s1, s2, #op,         \
371                           "[" fmt "] compared to [" fmt "]",            \
372                           t1, t2);                                      \
373         return 0;                                                       \
374     }
375
376 #define DEFINE_COMPARISONS(type, name, fmt)                             \
377     DEFINE_COMPARISON(type, name, eq, ==, fmt)                          \
378     DEFINE_COMPARISON(type, name, ne, !=, fmt)                          \
379     DEFINE_COMPARISON(type, name, lt, <, fmt)                           \
380     DEFINE_COMPARISON(type, name, le, <=, fmt)                          \
381     DEFINE_COMPARISON(type, name, gt, >, fmt)                           \
382     DEFINE_COMPARISON(type, name, ge, >=, fmt)
383
384 DEFINE_COMPARISONS(int, int, "%d")
385 DEFINE_COMPARISONS(unsigned int, uint, "%u")
386 DEFINE_COMPARISONS(char, char, "%c")
387 DEFINE_COMPARISONS(unsigned char, uchar, "%u")
388 DEFINE_COMPARISONS(long, long, "%ld")
389 DEFINE_COMPARISONS(unsigned long, ulong, "%lu")
390 DEFINE_COMPARISONS(size_t, size_t, "%zu")
391
392 DEFINE_COMPARISON(void *, ptr, eq, ==, "%p")
393 DEFINE_COMPARISON(void *, ptr, ne, !=, "%p")
394
395 int test_ptr_null(const char *file, int line, const char *s, const void *p)
396 {
397     if (p == NULL)
398         return 1;
399     test_fail_message(NULL, file, line, "ptr", s, "NULL", "==", "%p", p);
400     return 0;
401 }
402
403 int test_ptr(const char *file, int line, const char *s, const void *p)
404 {
405     if (p != NULL)
406         return 1;
407     test_fail_message(NULL, file, line, "ptr", s, "NULL", "!=", "%p", p);
408     return 0;
409 }
410
411 int test_true(const char *file, int line, const char *s, int b)
412 {
413     if (b)
414         return 1;
415     test_fail_message(NULL, file, line, "bool", s, "true", "==", "false");
416     return 0;
417 }
418
419 int test_false(const char *file, int line, const char *s, int b)
420 {
421     if (!b)
422         return 1;
423     test_fail_message(NULL, file, line, "bool", s, "false", "==", "true");
424     return 0;
425 }
426
427 int test_str_eq(const char *file, int line, const char *st1, const char *st2,
428                 const char *s1, const char *s2)
429 {
430     if (s1 == NULL && s2 == NULL)
431       return 1;
432     if (s1 == NULL || s2 == NULL || strcmp(s1, s2) != 0) {
433         test_fail_string_message(NULL, file, line, "string", st1, st2, "==",
434                                  s1, s1 == NULL ? 0 : strlen(s1),
435                                  s2, s2 == NULL ? 0 : strlen(s2));
436         return 0;
437     }
438     return 1;
439 }
440
441 int test_str_ne(const char *file, int line, const char *st1, const char *st2,
442                 const char *s1, const char *s2)
443 {
444     if ((s1 == NULL) ^ (s2 == NULL))
445       return 1;
446     if (s1 == NULL || strcmp(s1, s2) == 0) {
447         test_fail_string_message(NULL, file, line, "string", st1, st2, "!=",
448                                  s1, s1 == NULL ? 0 : strlen(s1),
449                                  s2, s2 == NULL ? 0 : strlen(s2));
450         return 0;
451     }
452     return 1;
453 }
454
455 int test_strn_eq(const char *file, int line, const char *st1, const char *st2,
456                  const char *s1, const char *s2, size_t len)
457 {
458     if (s1 == NULL && s2 == NULL)
459       return 1;
460     if (s1 == NULL || s2 == NULL || strncmp(s1, s2, len) != 0) {
461         test_fail_string_message(NULL, file, line, "string", st1, st2, "==",
462                                  s1, s1 == NULL ? 0 : OPENSSL_strnlen(s1, len),
463                                  s2, s2 == NULL ? 0 : OPENSSL_strnlen(s2, len));
464         return 0;
465     }
466     return 1;
467 }
468
469 int test_strn_ne(const char *file, int line, const char *st1, const char *st2,
470                  const char *s1, const char *s2, size_t len)
471 {
472     if ((s1 == NULL) ^ (s2 == NULL))
473       return 1;
474     if (s1 == NULL || strncmp(s1, s2, len) == 0) {
475         test_fail_string_message(NULL, file, line, "string", st1, st2, "!=",
476                                  s1, s1 == NULL ? 0 : OPENSSL_strnlen(s1, len),
477                                  s2, s2 == NULL ? 0 : OPENSSL_strnlen(s2, len));
478         return 0;
479     }
480     return 1;
481 }
482
483 int test_mem_eq(const char *file, int line, const char *st1, const char *st2,
484                 const void *s1, size_t n1, const void *s2, size_t n2)
485 {
486     if (s1 == NULL && s2 == NULL)
487         return 1;
488     if (n1 != n2 || s1 == NULL || s2 == NULL || memcmp(s1, s2, n1) != 0) {
489         test_fail_memory_message(NULL, file, line, "memory", st1, st2, "==",
490                                  s1, n1, s2, n2);
491         return 0;
492     }
493     return 1;
494 }
495
496 int test_mem_ne(const char *file, int line, const char *st1, const char *st2,
497                 const void *s1, size_t n1, const void *s2, size_t n2)
498 {
499     if ((s1 == NULL) ^ (s2 == NULL))
500         return 1;
501     if (n1 != n2)
502         return 1;
503     if (s1 == NULL || memcmp(s1, s2, n1) == 0) {
504         test_fail_memory_message(NULL, file, line, "memory", st1, st2, "!=",
505                                  s1, n1, s2, n2);
506         return 0;
507     }
508     return 1;
509 }