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 <errno.h>
  15 #include <string.h>
  16 #include <ctype.h>
  17 #include "internal/nelem.h"
  18
  19 /*
  20  * Output a failed test first line.
  21  * All items are optional are generally not preinted if passed as NULL.
  22  * The special cases are for prefix where "ERROR" is assumed and for left
  23  * and right where a non-failure message is produced if either is NULL.
  24  */
  25 void test_fail_message_prefix(const char *prefix, const char *file,
  26                               int line, const char *type,
  27                               const char *left, const char *right,
  28                               const char *op)
  29 {
  30     test_printf_stderr("%s: ", prefix != NULL ? prefix : "ERROR");
  31     if (type)
  32         test_printf_stderr("(%s) ", type);
  33     if (op != NULL) {
  34         if (left != NULL && right != NULL)
  35             test_printf_stderr("'%s %s %s' failed", left, op, right);
  36         else
  37             test_printf_stderr("'%s'", op);
  38     }
  39     if (file != NULL) {
  40         test_printf_stderr(" @ %s:%d", file, line);
  41     }
  42     test_printf_stderr("\n");
  43 }
  44
  45 /*
  46  * A common routine to output test failure messages.  Generally this should not
  47  * be called directly, rather it should be called by the following functions.
  48  *
  49  * |desc| is a printf formatted description with arguments |args| that is
  50  * supplied by the user and |desc| can be NULL.  |type| is the data type
  51  * that was tested (int, char, ptr, ...).  |fmt| is a system provided
  52  * printf format with following arguments that spell out the failure
  53  * details i.e. the actual values compared and the operator used.
  54  *
  55  * The typical use for this is from an utility test function:
  56  *
  57  * int test6(const char *file, int line, int n) {
  58  *     if (n != 6) {
  59  *         test_fail_message(1, file, line, "int", "value %d is not %d", n, 6);
  60  *         return 0;
  61  *     }
  62  *     return 1;
  63  * }
  64  *
  65  * calling test6(3, "oops") will return 0 and produce out along the lines of:
  66  *      FAIL oops: (int) value 3 is not 6\n
  67  */
  68 static void test_fail_message(const char *prefix, const char *file, int line,
  69                               const char *type, const char *left,
  70                               const char *right, const char *op,
  71                               const char *fmt, ...)
  72             PRINTF_FORMAT(8, 9);
  73
  74 static void test_fail_message_va(const char *prefix, const char *file,
  75                                  int line, const char *type,
  76                                  const char *left, const char *right,
  77                                  const char *op, const char *fmt, va_list ap)
  78 {
  79     test_fail_message_prefix(prefix, file, line, type, left, right, op);
  80     if (fmt != NULL) {
  81         test_vprintf_stderr(fmt, ap);
  82         test_printf_stderr("\n");
  83     }
  84     test_flush_stderr();
  85 }
  86
  87 static void test_fail_message(const char *prefix, const char *file,
  88                               int line, const char *type,
  89                               const char *left, const char *right,
  90                               const char *op, const char *fmt, ...)
  91 {
  92     va_list ap;
  93
  94     va_start(ap, fmt);
  95     test_fail_message_va(prefix, file, line, type, left, right, op, fmt, ap);
  96     va_end(ap);
  97 }
  98
  99 void test_info_c90(const char *desc, ...)
 100 {
 101     va_list ap;
 102
 103     va_start(ap, desc);
 104     test_fail_message_va("INFO", NULL, -1, NULL, NULL, NULL, NULL, desc, ap);
 105     va_end(ap);
 106 }
 107
 108 void test_info(const char *file, int line, const char *desc, ...)
 109 {
 110     va_list ap;
 111
 112     va_start(ap, desc);
 113     test_fail_message_va("INFO", file, line, NULL, NULL, NULL, NULL, desc, ap);
 114     va_end(ap);
 115 }
 116
 117 void test_error_c90(const char *desc, ...)
 118 {
 119     va_list ap;
 120
 121     va_start(ap, desc);
 122     test_fail_message_va(NULL, NULL, -1, NULL, NULL, NULL, NULL, desc, ap);
 123     va_end(ap);
 124     test_printf_stderr("\n");
 125 }
 126
 127 void test_error(const char *file, int line, const char *desc, ...)
 128 {
 129     va_list ap;
 130
 131     va_start(ap, desc);
 132     test_fail_message_va(NULL, file, line, NULL, NULL, NULL, NULL, desc, ap);
 133     va_end(ap);
 134     test_printf_stderr("\n");
 135 }
 136
 137 void test_perror(const char *s)
 138 {
 139     /*
 140      * Using openssl_strerror_r causes linking issues since it isn't
 141      * exported from libcrypto.so
 142      */
 143     TEST_error("%s: %s", s, strerror(errno));
 144 }
 145
 146 void test_note(const char *fmt, ...)
 147 {
 148     if (fmt != NULL) {
 149         va_list ap;
 150
 151         va_start(ap, fmt);
 152         test_vprintf_stderr(fmt, ap);
 153         va_end(ap);
 154         test_printf_stderr("\n");
 155     }
 156     test_flush_stderr();
 157 }
 158
 159 void test_openssl_errors(void)
 160 {
 161     ERR_print_errors_cb(openssl_error_cb, NULL);
 162     ERR_clear_error();
 163 }
 164
 165 /*
 166  * Define some comparisons between pairs of various types.
 167  * These functions return 1 if the test is true.
 168  * Otherwise, they return 0 and pretty-print diagnostics.
 169  *
 170  * In each case the functions produced are:
 171  *  int test_name_eq(const type t1, const type t2, const char *desc, ...);
 172  *  int test_name_ne(const type t1, const type t2, const char *desc, ...);
 173  *  int test_name_lt(const type t1, const type t2, const char *desc, ...);
 174  *  int test_name_le(const type t1, const type t2, const char *desc, ...);
 175  *  int test_name_gt(const type t1, const type t2, const char *desc, ...);
 176  *  int test_name_ge(const type t1, const type t2, const char *desc, ...);
 177  *
 178  * The t1 and t2 arguments are to be compared for equality, inequality,
 179  * less than, less than or equal to, greater than and greater than or
 180  * equal to respectively.  If the specified condition holds, the functions
 181  * return 1.  If the condition does not hold, the functions print a diagnostic
 182  * message and return 0.
 183  *
 184  * The desc argument is a printf format string followed by its arguments and
 185  * this is included in the output if the condition being tested for is false.
 186  */
 187 #define DEFINE_COMPARISON(type, name, opname, op, fmt)                  \
 188     int test_ ## name ## _ ## opname(const char *file, int line,        \
 189                                      const char *s1, const char *s2,    \
 190                                      const type t1, const type t2)      \
 191     {                                                                   \
 192         if (t1 op t2)                                                   \
 193             return 1;                                                   \
 194         test_fail_message(NULL, file, line, #type, s1, s2, #op,         \
 195                           "[" fmt "] compared to [" fmt "]",            \
 196                           t1, t2);                                      \
 197         return 0;                                                       \
 198     }
 199
 200 #define DEFINE_COMPARISONS(type, name, fmt)                             \
 201     DEFINE_COMPARISON(type, name, eq, ==, fmt)                          \
 202     DEFINE_COMPARISON(type, name, ne, !=, fmt)                          \
 203     DEFINE_COMPARISON(type, name, lt, <, fmt)                           \
 204     DEFINE_COMPARISON(type, name, le, <=, fmt)                          \
 205     DEFINE_COMPARISON(type, name, gt, >, fmt)                           \
 206     DEFINE_COMPARISON(type, name, ge, >=, fmt)
 207
 208 DEFINE_COMPARISONS(int, int, "%d")
 209 DEFINE_COMPARISONS(unsigned int, uint, "%u")
 210 DEFINE_COMPARISONS(char, char, "%c")
 211 DEFINE_COMPARISONS(unsigned char, uchar, "%u")
 212 DEFINE_COMPARISONS(long, long, "%ld")
 213 DEFINE_COMPARISONS(unsigned long, ulong, "%lu")
 214 DEFINE_COMPARISONS(size_t, size_t, "%zu")
 215
 216 DEFINE_COMPARISON(void *, ptr, eq, ==, "%p")
 217 DEFINE_COMPARISON(void *, ptr, ne, !=, "%p")
 218
 219 int test_ptr_null(const char *file, int line, const char *s, const void *p)
 220 {
 221     if (p == NULL)
 222         return 1;
 223     test_fail_message(NULL, file, line, "ptr", s, "NULL", "==", "%p", p);
 224     return 0;
 225 }
 226
 227 int test_ptr(const char *file, int line, const char *s, const void *p)
 228 {
 229     if (p != NULL)
 230         return 1;
 231     test_fail_message(NULL, file, line, "ptr", s, "NULL", "!=", "%p", p);
 232     return 0;
 233 }
 234
 235 int test_true(const char *file, int line, const char *s, int b)
 236 {
 237     if (b)
 238         return 1;
 239     test_fail_message(NULL, file, line, "bool", s, "true", "==", "false");
 240     return 0;
 241 }
 242
 243 int test_false(const char *file, int line, const char *s, int b)
 244 {
 245     if (!b)
 246         return 1;
 247     test_fail_message(NULL, file, line, "bool", s, "false", "==", "true");
 248     return 0;
 249 }
 250
 251 int test_str_eq(const char *file, int line, const char *st1, const char *st2,
 252                 const char *s1, const char *s2)
 253 {
 254     if (s1 == NULL && s2 == NULL)
 255       return 1;
 256     if (s1 == NULL || s2 == NULL || strcmp(s1, s2) != 0) {
 257         test_fail_string_message(NULL, file, line, "string", st1, st2, "==",
 258                                  s1, s1 == NULL ? 0 : strlen(s1),
 259                                  s2, s2 == NULL ? 0 : strlen(s2));
 260         return 0;
 261     }
 262     return 1;
 263 }
 264
 265 int test_str_ne(const char *file, int line, const char *st1, const char *st2,
 266                 const char *s1, const char *s2)
 267 {
 268     if ((s1 == NULL) ^ (s2 == NULL))
 269       return 1;
 270     if (s1 == NULL || strcmp(s1, s2) == 0) {
 271         test_fail_string_message(NULL, file, line, "string", st1, st2, "!=",
 272                                  s1, s1 == NULL ? 0 : strlen(s1),
 273                                  s2, s2 == NULL ? 0 : strlen(s2));
 274         return 0;
 275     }
 276     return 1;
 277 }
 278
 279 int test_strn_eq(const char *file, int line, const char *st1, const char *st2,
 280                  const char *s1, const char *s2, size_t len)
 281 {
 282     if (s1 == NULL && s2 == NULL)
 283       return 1;
 284     if (s1 == NULL || s2 == NULL || strncmp(s1, s2, len) != 0) {
 285         test_fail_string_message(NULL, file, line, "string", st1, st2, "==",
 286                                  s1, s1 == NULL ? 0 : OPENSSL_strnlen(s1, len),
 287                                  s2, s2 == NULL ? 0 : OPENSSL_strnlen(s2, len));
 288         return 0;
 289     }
 290     return 1;
 291 }
 292
 293 int test_strn_ne(const char *file, int line, const char *st1, const char *st2,
 294                  const char *s1, const char *s2, size_t len)
 295 {
 296     if ((s1 == NULL) ^ (s2 == NULL))
 297       return 1;
 298     if (s1 == NULL || strncmp(s1, s2, len) == 0) {
 299         test_fail_string_message(NULL, file, line, "string", st1, st2, "!=",
 300                                  s1, s1 == NULL ? 0 : OPENSSL_strnlen(s1, len),
 301                                  s2, s2 == NULL ? 0 : OPENSSL_strnlen(s2, len));
 302         return 0;
 303     }
 304     return 1;
 305 }
 306
 307 int test_mem_eq(const char *file, int line, const char *st1, const char *st2,
 308                 const void *s1, size_t n1, const void *s2, size_t n2)
 309 {
 310     if (s1 == NULL && s2 == NULL)
 311         return 1;
 312     if (n1 != n2 || s1 == NULL || s2 == NULL || memcmp(s1, s2, n1) != 0) {
 313         test_fail_memory_message(NULL, file, line, "memory", st1, st2, "==",
 314                                  s1, n1, s2, n2);
 315         return 0;
 316     }
 317     return 1;
 318 }
 319
 320 int test_mem_ne(const char *file, int line, const char *st1, const char *st2,
 321                 const void *s1, size_t n1, const void *s2, size_t n2)
 322 {
 323     if ((s1 == NULL) ^ (s2 == NULL))
 324         return 1;
 325     if (n1 != n2)
 326         return 1;
 327     if (s1 == NULL || memcmp(s1, s2, n1) == 0) {
 328         test_fail_memory_message(NULL, file, line, "memory", st1, st2, "!=",
 329                                  s1, n1, s2, n2);
 330         return 0;
 331     }
 332     return 1;
 333 }
 334
 335 #define DEFINE_BN_COMPARISONS(opname, op, zero_cond)                    \
 336     int test_BN_ ## opname(const char *file, int line,                  \
 337                            const char *s1, const char *s2,              \
 338                            const BIGNUM *t1, const BIGNUM *t2)          \
 339     {                                                                   \
 340         if (BN_cmp(t1, t2) op 0)                                        \
 341             return 1;                                                   \
 342         test_fail_bignum_message(NULL, file, line, "BIGNUM", s1, s2,    \
 343                                  #op, t1, t2);                          \
 344         return 0;                                                       \
 345     }                                                                   \
 346     int test_BN_ ## opname ## _zero(const char *file, int line,         \
 347                                     const char *s, const BIGNUM *a)     \
 348     {                                                                   \
 349         if (a != NULL &&(zero_cond))                                    \
 350             return 1;                                                   \
 351         test_fail_bignum_mono_message(NULL, file, line, "BIGNUM",       \
 352                                       s, "0", #op, a);                  \
 353         return 0;                                                       \
 354     }
 355
 356 DEFINE_BN_COMPARISONS(eq, ==, BN_is_zero(a))
 357 DEFINE_BN_COMPARISONS(ne, !=, !BN_is_zero(a))
 358 DEFINE_BN_COMPARISONS(gt, >,  !BN_is_negative(a) && !BN_is_zero(a))
 359 DEFINE_BN_COMPARISONS(ge, >=, !BN_is_negative(a) || BN_is_zero(a))
 360 DEFINE_BN_COMPARISONS(lt, <,  BN_is_negative(a) && !BN_is_zero(a))
 361 DEFINE_BN_COMPARISONS(le, <=, BN_is_negative(a) || BN_is_zero(a))
 362
 363 int test_BN_eq_one(const char *file, int line, const char *s, const BIGNUM *a)
 364 {
 365     if (a != NULL && BN_is_one(a))
 366         return 1;
 367     test_fail_bignum_mono_message(NULL, file, line, "BIGNUM", s, "1", "==", a);
 368     return 0;
 369 }
 370
 371 int test_BN_odd(const char *file, int line, const char *s, const BIGNUM *a)
 372 {
 373     if (a != NULL && BN_is_odd(a))
 374         return 1;
 375     test_fail_bignum_mono_message(NULL, file, line, "BIGNUM", "ODD(", ")", s, a);
 376     return 0;
 377 }
 378
 379 int test_BN_even(const char *file, int line, const char *s, const BIGNUM *a)
 380 {
 381     if (a != NULL && !BN_is_odd(a))
 382         return 1;
 383     test_fail_bignum_mono_message(NULL, file, line, "BIGNUM", "EVEN(", ")", s,
 384                                   a);
 385     return 0;
 386 }
 387
 388 int test_BN_eq_word(const char *file, int line, const char *bns, const char *ws,
 389                     const BIGNUM *a, BN_ULONG w)
 390 {
 391     BIGNUM *bw;
 392
 393     if (a != NULL && BN_is_word(a, w))
 394         return 1;
 395     bw = BN_new();
 396     BN_set_word(bw, w);
 397     test_fail_bignum_message(NULL, file, line, "BIGNUM", bns, ws, "==", a, bw);
 398     BN_free(bw);
 399     return 0;
 400 }
 401
 402 int test_BN_abs_eq_word(const char *file, int line, const char *bns,
 403                         const char *ws, const BIGNUM *a, BN_ULONG w)
 404 {
 405     BIGNUM *bw, *aa;
 406
 407     if (a != NULL && BN_abs_is_word(a, w))
 408         return 1;
 409     bw = BN_new();
 410     aa = BN_dup(a);
 411     BN_set_negative(aa, 0);
 412     BN_set_word(bw, w);
 413     test_fail_bignum_message(NULL, file, line, "BIGNUM", bns, ws, "abs==",
 414                              aa, bw);
 415     BN_free(bw);
 416     BN_free(aa);
 417     return 0;
 418 }