Updates following review of SSL_stateless() code
[openssl.git] / test / test_test.c
index 0094c1c..c45bf8d 100644 (file)
@@ -1,5 +1,6 @@
 /*
  * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2017, Oracle and/or its affiliates.  All rights reserved.
  *
  * Licensed under the OpenSSL license (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -7,10 +8,6 @@
  * https://www.openssl.org/source/license.html
  */
 
-/*
- * Copyright (c) 2017 Oracle and/or its affiliates.  All rights reserved.
- */
-
 #include <stdio.h>
 #include <string.h>
 
@@ -19,7 +16,7 @@
 #include <openssl/crypto.h>
 #include <openssl/bn.h>
 
-#include "e_os.h"
+#include "internal/nelem.h"
 #include "testutil.h"
 
 #define TEST(expected, test) test_case((expected), #test, (test))
@@ -173,20 +170,43 @@ err:
 
 static int test_size_t(void)
 {
-    if (!TEST(1, TEST_int_eq((size_t)10, (size_t)10))
-        | !TEST(0, TEST_int_eq((size_t)10, (size_t)12))
-        | !TEST(1, TEST_int_ne((size_t)10, (size_t)12))
-        | !TEST(0, TEST_int_ne((size_t)24, (size_t)24))
-        | !TEST(1, TEST_int_lt((size_t)30, (size_t)88))
-        | !TEST(0, TEST_int_lt((size_t)88, (size_t)30))
-        | !TEST(1, TEST_int_le((size_t)30, (size_t)88))
-        | !TEST(1, TEST_int_le((size_t)33, (size_t)33))
-        | !TEST(0, TEST_int_le((size_t)88, (size_t)30))
-        | !TEST(1, TEST_int_gt((size_t)52, (size_t)33))
-        | !TEST(0, TEST_int_gt((size_t)33, (size_t)52))
-        | !TEST(1, TEST_int_ge((size_t)52, (size_t)33))
-        | !TEST(1, TEST_int_ge((size_t)38, (size_t)38))
-        | !TEST(0, TEST_int_ge((size_t)33, (size_t)52)))
+    if (!TEST(1, TEST_size_t_eq((size_t)10, (size_t)10))
+        | !TEST(0, TEST_size_t_eq((size_t)10, (size_t)12))
+        | !TEST(1, TEST_size_t_ne((size_t)10, (size_t)12))
+        | !TEST(0, TEST_size_t_ne((size_t)24, (size_t)24))
+        | !TEST(1, TEST_size_t_lt((size_t)30, (size_t)88))
+        | !TEST(0, TEST_size_t_lt((size_t)88, (size_t)30))
+        | !TEST(1, TEST_size_t_le((size_t)30, (size_t)88))
+        | !TEST(1, TEST_size_t_le((size_t)33, (size_t)33))
+        | !TEST(0, TEST_size_t_le((size_t)88, (size_t)30))
+        | !TEST(1, TEST_size_t_gt((size_t)52, (size_t)33))
+        | !TEST(0, TEST_size_t_gt((size_t)33, (size_t)52))
+        | !TEST(1, TEST_size_t_ge((size_t)52, (size_t)33))
+        | !TEST(1, TEST_size_t_ge((size_t)38, (size_t)38))
+        | !TEST(0, TEST_size_t_ge((size_t)33, (size_t)52)))
+        goto err;
+    return 1;
+
+err:
+    return 0;
+}
+
+static int test_time_t(void)
+{
+    if (!TEST(1, TEST_time_t_eq((time_t)10, (time_t)10))
+        | !TEST(0, TEST_time_t_eq((time_t)10, (time_t)12))
+        | !TEST(1, TEST_time_t_ne((time_t)10, (time_t)12))
+        | !TEST(0, TEST_time_t_ne((time_t)24, (time_t)24))
+        | !TEST(1, TEST_time_t_lt((time_t)30, (time_t)88))
+        | !TEST(0, TEST_time_t_lt((time_t)88, (time_t)30))
+        | !TEST(1, TEST_time_t_le((time_t)30, (time_t)88))
+        | !TEST(1, TEST_time_t_le((time_t)33, (time_t)33))
+        | !TEST(0, TEST_time_t_le((time_t)88, (time_t)30))
+        | !TEST(1, TEST_time_t_gt((time_t)52, (time_t)33))
+        | !TEST(0, TEST_time_t_gt((time_t)33, (time_t)52))
+        | !TEST(1, TEST_time_t_ge((time_t)52, (time_t)33))
+        | !TEST(1, TEST_time_t_ge((time_t)38, (time_t)38))
+        | !TEST(0, TEST_time_t_ge((time_t)33, (time_t)52)))
         goto err;
     return 1;
 
@@ -249,7 +269,8 @@ static int test_string(void)
         | !TEST(0, TEST_str_eq("\1\2\3\4\5", "\1x\3\6\5"))
         | !TEST(0, TEST_str_ne("abc", buf))
         | !TEST(1, TEST_str_ne("abc", NULL))
-        | !TEST(1, TEST_str_ne(NULL, buf)))
+        | !TEST(1, TEST_str_ne(NULL, buf))
+        | !TEST(0, TEST_str_eq("abcdef", "abcdefghijk")))
         goto err;
     return 1;
 
@@ -306,6 +327,9 @@ static int test_bignum(void)
         | !TEST(0, TEST_BN_gt_zero(a))
         | !TEST(1, TEST_BN_even(a))
         | !TEST(0, TEST_BN_odd(a))
+        | !TEST(1, TEST_BN_eq(b, c))
+        | !TEST(0, TEST_BN_eq(a, b))
+        | !TEST(0, TEST_BN_ne(NULL, c))
         | !TEST(1, TEST_int_eq(BN_dec2bn(&b, "1"), 1))
         | !TEST(1, TEST_BN_eq_word(b, 1))
         | !TEST(1, TEST_BN_eq_one(b))
@@ -374,6 +398,46 @@ static int test_long_output(void)
            & TEST(0, TEST_mem_eq(r, strlen(r), s, strlen(s)));
 }
 
+static int test_long_bignum(void)
+{
+    int r;
+    BIGNUM *a = NULL, *b = NULL, *c = NULL, *d = NULL;
+    const char as[] = "1234567890123456789012345678901234567890123456789012"
+                      "1234567890123456789012345678901234567890123456789012"
+                      "1234567890123456789012345678901234567890123456789012"
+                      "1234567890123456789012345678901234567890123456789012"
+                      "1234567890123456789012345678901234567890123456789012"
+                      "1234567890123456789012345678901234567890123456789012"
+                      "FFFFFF";
+    const char bs[] = "1234567890123456789012345678901234567890123456789012"
+                      "1234567890123456789012345678901234567890123456789013"
+                      "987657";
+    const char cs[] = "-"        /* 64 characters plus sign */
+                      "123456789012345678901234567890"
+                      "123456789012345678901234567890"
+                      "ABCD";
+    const char ds[] = "-"        /* 63 characters plus sign */
+                      "23456789A123456789B123456789C"
+                      "123456789D123456789E123456789F"
+                      "ABCD";
+
+    r = TEST_true(BN_hex2bn(&a, as))
+        && TEST_true(BN_hex2bn(&b, bs))
+        && TEST_true(BN_hex2bn(&c, cs))
+        && TEST_true(BN_hex2bn(&d, ds))
+        && (TEST(0, TEST_BN_eq(a, b))
+            & TEST(0, TEST_BN_eq(b, a))
+            & TEST(0, TEST_BN_eq(b, NULL))
+            & TEST(0, TEST_BN_eq(NULL, a))
+            & TEST(1, TEST_BN_ne(a, NULL))
+            & TEST(0, TEST_BN_eq(c, d)));
+    BN_free(a);
+    BN_free(b);
+    BN_free(c);
+    BN_free(d);
+    return r;
+}
+
 static int test_messages(void)
 {
     TEST_info("This is an %s message.", "info");
@@ -436,7 +500,39 @@ static int test_single_eval(void)
            && TEST_mem_eq(p--, sizeof("456"), "456", sizeof("456"));
 }
 
-void register_tests(void)
+static int test_output(void)
+{
+    const char s[] = "1234567890123456789012345678901234567890123456789012"
+                     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+    test_output_string("test", s, sizeof(s) - 1);
+    test_output_memory("test", (const unsigned char *)s, sizeof(s));
+    return 1;
+}
+
+static const char *bn_output_tests[] = {
+    NULL,
+    "0",
+    "-12345678",
+    "1234567890123456789012345678901234567890123456789012"
+    "1234567890123456789012345678901234567890123456789013"
+    "987657"
+};
+
+static int test_bn_output(int n)
+{
+    BIGNUM *b = NULL;
+
+    if (bn_output_tests[n] != NULL
+            && !TEST_true(BN_hex2bn(&b, bn_output_tests[n])))
+        return 0;
+    test_output_bignum(bn_output_tests[n], b);
+    BN_free(b);
+    return 1;
+}
+
+
+int setup_tests(void)
 {
     ADD_TEST(test_int);
     ADD_TEST(test_uint);
@@ -445,13 +541,18 @@ void register_tests(void)
     ADD_TEST(test_long);
     ADD_TEST(test_ulong);
     ADD_TEST(test_size_t);
+    ADD_TEST(test_time_t);
     ADD_TEST(test_pointer);
     ADD_TEST(test_bool);
     ADD_TEST(test_string);
     ADD_TEST(test_memory);
     ADD_TEST(test_memory_overflow);
     ADD_TEST(test_bignum);
+    ADD_TEST(test_long_bignum);
     ADD_TEST(test_long_output);
     ADD_TEST(test_messages);
     ADD_TEST(test_single_eval);
+    ADD_TEST(test_output);
+    ADD_ALL_TESTS(test_bn_output, OSSL_NELEM(bn_output_tests));
+    return 1;
 }