Use common STANZA for bn and exp tests
authorRich Salz <rsalz@openssl.org>
Mon, 5 Jun 2017 17:32:05 +0000 (13:32 -0400)
committerRich Salz <rsalz@openssl.org>
Mon, 5 Jun 2017 17:41:30 +0000 (13:41 -0400)
Standardize file:line messages
Reduce buff size; move to end of STANZA
Add some Title entries (with blank line after)
Add Title to some BN test files.

Reviewed-by: Andy Polyakov <appro@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3608)

test/bnmod.txt
test/bnmul.txt
test/bnshift.txt
test/bntest.c
test/build.info
test/evp_test.c
test/evpciph.txt
test/evppkey.txt
test/testutil.h
test/testutil/stanza.c [new file with mode: 0644]

index ad4dd3d..5ea4d03 100644 (file)
@@ -5,12 +5,11 @@
 # in the file LICENSE in the source distribution or at
 # https://www.openssl.org/source/license.html
 
 # in the file LICENSE in the source distribution or at
 # https://www.openssl.org/source/license.html
 
-# Modulus tests.
-
-# ModMul tests.
-#
 # These test vectors satisfy A * B = ModMul (mod M) and 0 <= ModMul < M.
 
 # These test vectors satisfy A * B = ModMul (mod M) and 0 <= ModMul < M.
 
+Title = ModMul tests
+
+
 ModMul = ae2ca2ce7addaee2e2b7752e286b2bb6a58b51cfbed5c924f00398e59ec36fe6341cd83da43a33a12410f45f6228079c4aeb3912be87e2e81fa1799151bfa0fea29873097475b2c3efa312145d0bf7e51b2a7c9bc961a4f4dcf0c883ff90b919b87c21099fba40257645be31f95a3a277
 A = 6b18497fed9befdf22a01d988d34213f6687d8a96e86c188dea4172e7c6095a0d18d3c86c0f5a1af9c6e3aaeb6baac2a510930b3ed06ec78ec2e12b
 B = 1a058d99397db0d209f01212dd4023ae01b15da04fe62d1f76f21622b2695558c67d706c535ca7f19b36f8ef2d508ffd6cf6fcf25e5
 ModMul = ae2ca2ce7addaee2e2b7752e286b2bb6a58b51cfbed5c924f00398e59ec36fe6341cd83da43a33a12410f45f6228079c4aeb3912be87e2e81fa1799151bfa0fea29873097475b2c3efa312145d0bf7e51b2a7c9bc961a4f4dcf0c883ff90b919b87c21099fba40257645be31f95a3a277
 A = 6b18497fed9befdf22a01d988d34213f6687d8a96e86c188dea4172e7c6095a0d18d3c86c0f5a1af9c6e3aaeb6baac2a510930b3ed06ec78ec2e12b
 B = 1a058d99397db0d209f01212dd4023ae01b15da04fe62d1f76f21622b2695558c67d706c535ca7f19b36f8ef2d508ffd6cf6fcf25e5
@@ -2012,10 +2011,10 @@ B = 8bdfa8fe5ef3b2ad02bc63c4d
 M = 84daecf412b8c50ad6dfdb546c3eb783dcc6f32003eda914bb
 
 
 M = 84daecf412b8c50ad6dfdb546c3eb783dcc6f32003eda914bb
 
 
-# ModExp tests.
-#
 # These test vectors satisfy A ^ E = ModExp (mod M) and 0 <= ModExp < M.
 
 # These test vectors satisfy A ^ E = ModExp (mod M) and 0 <= ModExp < M.
 
+Title = ModExp tests
+
 # Regression test for carry propagation bug in sqr8x_reduction.
 ModExp = 19324b647d967d644b3219
 A = 050505050505
 # Regression test for carry propagation bug in sqr8x_reduction.
 ModExp = 19324b647d967d644b3219
 A = 050505050505
@@ -2476,11 +2475,11 @@ E = d7e6df5d755284929b986cd9b61c9c2c8843f24c711fbdbae1a468edcae15940094372557072
 M = e4e784aa1fa88625a43ba0185a153a929663920be7fe674a4d33c943d3b898cff051482e7050a070cede53be5e89f31515772c7aea637576f99f82708f89d9e244f6ad3a24a02cbe5c0ff7bcf2dad5491f53db7c3f2698a7c41b44f086652f17bb05fe4c5c0a92433c34086b49d7e1825b28bab6c5a9bd0bc95b53d659afa0d7
 
 
 M = e4e784aa1fa88625a43ba0185a153a929663920be7fe674a4d33c943d3b898cff051482e7050a070cede53be5e89f31515772c7aea637576f99f82708f89d9e244f6ad3a24a02cbe5c0ff7bcf2dad5491f53db7c3f2698a7c41b44f086652f17bb05fe4c5c0a92433c34086b49d7e1825b28bab6c5a9bd0bc95b53d659afa0d7
 
 
-# ModSqrt tests.
-#
 # These test vectors satisfy (ModSqrt * ModSqrt) mod P = A mod P with P a prime.
 # ModSqrt is in [0, (P-1)/2].
 
 # These test vectors satisfy (ModSqrt * ModSqrt) mod P = A mod P with P a prime.
 # ModSqrt is in [0, (P-1)/2].
 
+Title = ModSqrt
+
 ModSqrt = 1
 A = 1
 P = 2
 ModSqrt = 1
 A = 1
 P = 2
index c2d02b0..dc13a92 100644 (file)
@@ -5,10 +5,10 @@
 # in the file LICENSE in the source distribution or at
 # https://www.openssl.org/source/license.html
 
 # in the file LICENSE in the source distribution or at
 # https://www.openssl.org/source/license.html
 
-# Square tests.
-#
 # These test vectors satisfy A^2 = Square.
 
 # These test vectors satisfy A^2 = Square.
 
+Title = Square tests.
+
 # Regression test for a BN_sqr overflow bug.
 Square = 4000000000000000800000000000000240000000000000000000000000000001fffffffffffffff8000000000000000400000000000000000000000000000000
 A = 80000000000000008000000000000001fffffffffffffffe0000000000000000
 # Regression test for a BN_sqr overflow bug.
 Square = 4000000000000000800000000000000240000000000000000000000000000001fffffffffffffff8000000000000000400000000000000000000000000000000
 A = 80000000000000008000000000000001fffffffffffffffe0000000000000000
@@ -318,10 +318,10 @@ Square = eea8028b26e0df090504d54da714a6f5f2695202e53cff479c78aedd47a8dc676243ec5
 A = -3dcb44be1e54c5a5d7db48055ca9afa1ebe2ae648aa6e16ac497502a7deee09ffa124720fad0ab163ce8b3ea6a90f110ea52b67dbc424d0cf1e8c9726dfd9e45bebcefaa5cd5706edeed27896525f31c6bbea3d67ee97badefabf3e2532470b66e3ae3100f66ddf50cf02fc3a8e3f44c304251d3b6a7ca3a6e4bd5d16a41bd97a4
 
 
 A = -3dcb44be1e54c5a5d7db48055ca9afa1ebe2ae648aa6e16ac497502a7deee09ffa124720fad0ab163ce8b3ea6a90f110ea52b67dbc424d0cf1e8c9726dfd9e45bebcefaa5cd5706edeed27896525f31c6bbea3d67ee97badefabf3e2532470b66e3ae3100f66ddf50cf02fc3a8e3f44c304251d3b6a7ca3a6e4bd5d16a41bd97a4
 
 
-# Product tests.
-#
 # These test vectors satisfy A * B = Product.
 
 # These test vectors satisfy A * B = Product.
 
+Title = Product tests
+
 Product = 5befab3320f8f90542f3120235abd926aac3805a19e343f690
 A = b057af553afb120db6b7764f8
 B = 857734c4c27a1d17f7cf59dee
 Product = 5befab3320f8f90542f3120235abd926aac3805a19e343f690
 A = b057af553afb120db6b7764f8
 B = 857734c4c27a1d17f7cf59dee
index c6c1da4..db30a24 100644 (file)
@@ -5,10 +5,10 @@
 # in the file LICENSE in the source distribution or at
 # https://www.openssl.org/source/license.html
 
 # in the file LICENSE in the source distribution or at
 # https://www.openssl.org/source/license.html
 
-# LShift1 tests.
-#
 # These test vectors satisfy A * 2 = LShift1
 
 # These test vectors satisfy A * 2 = LShift1
 
+Title = Lshift1 tests
+
 LShift1 = 0
 A = 0
 
 LShift1 = 0
 A = 0
 
@@ -1213,10 +1213,10 @@ LShift1 = -ab4e80e4b56556d99108eb3cb35f17d1ae83da33b4138619070000000000000000000
 A = -55a740725ab2ab6cc884759e59af8be8d741ed19da09c30c838000000000000000000000000
 
 
 A = -55a740725ab2ab6cc884759e59af8be8d741ed19da09c30c838000000000000000000000000
 
 
-# LShift tests
-#
 # These test vectors satisfy A * 2^N = LShift.
 
 # These test vectors satisfy A * 2^N = LShift.
 
+Title = LShift tests
+
 LShift = 18c9e860855d594dcb06d00b7d1933608ba906d85fa2d92c9e0
 A = c64f43042aeaca6e5836805be8c99b045d4836c2fd16c964f0
 N = 1
 LShift = 18c9e860855d594dcb06d00b7d1933608ba906d85fa2d92c9e0
 A = c64f43042aeaca6e5836805be8c99b045d4836c2fd16c964f0
 N = 1
@@ -2018,10 +2018,10 @@ A = e8e7c5ae65d7333de82bcbfdd7cea60ffb11e600aa3088ec8e
 N = 64
 
 
 N = 64
 
 
-# RShift tests
-#
 # These test vectors satisfy A / 2^N = RShift, rounding towards zero.
 
 # These test vectors satisfy A / 2^N = RShift, rounding towards zero.
 
+Title = RShift tests
+
 Rshift = 0
 A = -1
 N = 1
 Rshift = 0
 A = -1
 N = 1
index ccedd7a..00bdf3f 100644 (file)
@@ -35,26 +35,12 @@ BIGNUM *bn_expand2(BIGNUM *b, int words);
 BIGNUM *bn_expand2(BIGNUM *b, int words) { return NULL; }
 #include "../crypto/bn/bn_lcl.h"
 
 BIGNUM *bn_expand2(BIGNUM *b, int words) { return NULL; }
 #include "../crypto/bn/bn_lcl.h"
 
-#define MAXPAIRS        20
-
 /*
  * Things in boring, not in openssl.  TODO we should add them.
  */
 #define HAVE_BN_PADDED 0
 #define HAVE_BN_SQRT 0
 
 /*
  * Things in boring, not in openssl.  TODO we should add them.
  */
 #define HAVE_BN_PADDED 0
 #define HAVE_BN_SQRT 0
 
-typedef struct pair_st {
-    char *key;
-    char *value;
-} PAIR;
-
-typedef struct stanza_st {
-    int curr;                           /* Current line in file */
-    int start;                          /* Line where test starts */
-    int numpairs;
-    PAIR pairs[MAXPAIRS];
-} STANZA;
-
 typedef struct filetest_st {
     const char *name;
     int (*func)(STANZA *s);
 typedef struct filetest_st {
     const char *name;
     int (*func)(STANZA *s);
@@ -68,7 +54,6 @@ typedef struct mpitest_st {
 
 static const int NUM0 = 100;           /* number of tests */
 static const int NUM1 = 50;            /* additional tests for some functions */
 
 static const int NUM0 = 100;           /* number of tests */
 static const int NUM1 = 50;            /* additional tests for some functions */
-static BIO *fp;
 static BN_CTX *ctx;
 
 /*
 static BN_CTX *ctx;
 
 /*
@@ -113,7 +98,7 @@ static BIGNUM *getBN(STANZA *s, const char *attribute)
     BIGNUM *ret = NULL;
 
     if ((hex = findattr(s, attribute)) == NULL) {
     BIGNUM *ret = NULL;
 
     if ((hex = findattr(s, attribute)) == NULL) {
-        TEST_error("Can't find %s in test at line %d", attribute, s->start);
+        TEST_error("%s:%d: Can't find %s", s->test_file, s->start, attribute);
         return NULL;
     }
 
         return NULL;
     }
 
@@ -1986,85 +1971,6 @@ err:
     return ret;
 }
 
     return ret;
 }
 
-
-/* Delete leading and trailing spaces from a string */
-static char *strip_spaces(char *p)
-{
-    char *q;
-
-    /* Skip over leading spaces */
-    while (*p && isspace(*p))
-        p++;
-    if (!*p)
-        return NULL;
-
-    for (q = p + strlen(p) - 1; q != p && isspace(*q); )
-        *q-- = '\0';
-    return *p ? p : NULL;
-}
-
-/*
- * Read next test stanza; return 1 if found, 0 on EOF or error.
- */
-static int readstanza(STANZA *s)
-{
-    PAIR *pp = s->pairs;
-    char *p, *equals, *key, *value;
-    char buff[1024];
-
-    while (BIO_gets(fp, buff, sizeof(buff))) {
-        s->curr++;
-        if (!TEST_ptr(p = strchr(buff, '\n'))) {
-            TEST_info("Line %d too long", s->curr);
-            return 0;
-        }
-        *p = '\0';
-
-        /* Blank line marks end of tests. */
-        if (buff[0] == '\0')
-            break;
-
-        /* Lines starting with a pound sign are ignored. */
-        if (buff[0] == '#')
-            continue;
-
-        if (!TEST_ptr(equals = strchr(buff, '='))) {
-            TEST_info("Missing = at line %d\n", s->curr);
-            return 0;
-        }
-        *equals++ = '\0';
-        if (s->numpairs == 0)
-            s->start = s->curr;
-
-        if (!TEST_ptr(key = strip_spaces(buff))
-                || !TEST_ptr(value = strip_spaces(equals))
-                || !TEST_int_lt(s->numpairs++, MAXPAIRS)
-                || !TEST_ptr(pp->key = OPENSSL_strdup(key))
-                || !TEST_ptr(pp->value = OPENSSL_strdup(value)))
-            return 0;
-        pp++;
-    }
-
-    /* If we read anything, return ok. */
-    return 1;
-}
-
-static void clearstanza(STANZA *s)
-{
-    PAIR *pp = s->pairs;
-    int i = s->numpairs;
-    int start = s->start;
-    int curr = s->curr;
-
-    for ( ; --i >= 0; pp++) {
-        OPENSSL_free(pp->key);
-        OPENSSL_free(pp->value);
-    }
-    memset(s, 0, sizeof(*s));
-    s->curr = curr;
-    s->start = start;
-}
-
 static int file_test_run(STANZA *s)
 {
     static const FILETEST filetests[] = {
 static int file_test_run(STANZA *s)
 {
     static const FILETEST filetests[] = {
@@ -2086,13 +1992,14 @@ static int file_test_run(STANZA *s)
     for ( ; --numtests >= 0; tp++) {
         if (findattr(s, tp->name) != NULL) {
             if (!tp->func(s)) {
     for ( ; --numtests >= 0; tp++) {
         if (findattr(s, tp->name) != NULL) {
             if (!tp->func(s)) {
-                TEST_info("Failed %s test at %d", tp->name, s->start);
+                TEST_info("%s:%d: Failed %s test",
+                          s->test_file, s->start, tp->name);
                 return 0;
             }
             return 1;
         }
     }
                 return 0;
             }
             return 1;
         }
     }
-    TEST_info("Unknown test at %d", s->start);
+    TEST_info("%s:%d: Unknown test", s->test_file, s->start);
     return 0;
 }
 
     return 0;
 }
 
@@ -2100,26 +2007,30 @@ static char * const *testfiles;
 
 static int run_file_tests(int i)
 {
 
 static int run_file_tests(int i)
 {
-    STANZA s;
-    int errcnt = 0;
+    STANZA *s = NULL;
+    int c;
 
 
-    if (!TEST_ptr(fp = BIO_new_file(testfiles[i], "rb")))
+    if (!TEST_ptr(s = OPENSSL_zalloc(sizeof(*s))))
         return 0;
         return 0;
+    if (!test_start_file(s, testfiles[i])) {
+        OPENSSL_free(s);
+        return 0;
+    }
 
     /* Read test file. */
 
     /* Read test file. */
-    set_test_title(testfiles[i]);
-    memset(&s, 0, sizeof(s));
-    while (!BIO_eof(fp) && readstanza(&s)) {
-        if (s.numpairs == 0)
+    while (!BIO_eof(s->fp) && test_readstanza(s)) {
+        if (s->numpairs == 0)
             continue;
             continue;
-        if (!file_test_run(&s)) {
-            errcnt++;
-        }
-        clearstanza(&s);
+        if (!file_test_run(s))
+            s->errors++;
+        s->numtests++;
+        test_clearstanza(s);
     }
     }
-    BIO_free(fp);
+    test_end_file(s);
+    c = s->errors;
+    OPENSSL_free(s);
 
 
-    return errcnt == 0;
+    return c == 0;
 }
 
 
 }
 
 
index 8e94dca..3dd7590 100644 (file)
@@ -10,7 +10,7 @@
 IF[{- !$disabled{tests} -}]
   LIBS_NO_INST=libtestutil.a
   SOURCE[libtestutil.a]=testutil/basic_output.c testutil/output_helpers.c \
 IF[{- !$disabled{tests} -}]
   LIBS_NO_INST=libtestutil.a
   SOURCE[libtestutil.a]=testutil/basic_output.c testutil/output_helpers.c \
-          testutil/driver.c testutil/tests.c testutil/cb.c \
+          testutil/driver.c testutil/tests.c testutil/cb.c testutil/stanza.c \
           {- rebase_files("../apps", $target{apps_aux_src}) -} \
           testutil/test_main.c testutil/main.c
   INCLUDE[libtestutil.a]=.. ../include
           {- rebase_files("../apps", $target{apps_aux_src}) -} \
           testutil/test_main.c testutil/main.c
   INCLUDE[libtestutil.a]=.. ../include
index 501a9fd..81232ed 100644 (file)
@@ -28,15 +28,9 @@ typedef struct evp_test_method_st EVP_TEST_METHOD;
  * Structure holding test information
  */
 typedef struct evp_test_st {
  * Structure holding test information
  */
 typedef struct evp_test_st {
-    BIO *in;                      /* file being read */
-    int line;                     /* current line being processed */
-    int start_line;               /* start line of current test */
-    int ntests;                   /* Number of tests */
-    int errors;                   /* Error count */
+    STANZA s;                     /* Common test stanza */
+    char *name;
     int skip;                     /* Current test should be skipped */
     int skip;                     /* Current test should be skipped */
-    int nskip;                    /* Number of tests skipped */
-    char buf[10240];              /* Input buffer */
-    BIO *key;                     /* temp memory BIO for reading in keys */
     const EVP_TEST_METHOD *meth;  /* method for this test */
     const char *err, *aux_err;    /* Error string for test */
     char *expected_err;           /* Expected error value of test */
     const EVP_TEST_METHOD *meth;  /* method for this test */
     const char *err, *aux_err;    /* Error string for test */
     char *expected_err;           /* Expected error value of test */
@@ -80,8 +74,6 @@ static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst);
 
 static int parse_bin(const char *value, unsigned char **buf, size_t *buflen);
 
 
 static int parse_bin(const char *value, unsigned char **buf, size_t *buflen);
 
-static const char *current_test_file = "???";
-
 /*
  * Structure used to hold a list of blocks of memory to test
  * calls to "update" like functions.
 /*
  * Structure used to hold a list of blocks of memory to test
  * calls to "update" like functions.
@@ -2110,6 +2102,7 @@ static const EVP_TEST_METHOD *find_test(const char *name)
 
 static void clear_test(EVP_TEST *t)
 {
 
 static void clear_test(EVP_TEST *t)
 {
+    test_clearstanza(&t->s);
     ERR_clear_error();
     if (t->data != NULL) {
         if (t->meth != NULL)
     ERR_clear_error();
     if (t->data != NULL) {
         if (t->meth != NULL)
@@ -2123,6 +2116,7 @@ static void clear_test(EVP_TEST *t)
     t->func = NULL;
     OPENSSL_free(t->reason);
     t->reason = NULL;
     t->func = NULL;
     OPENSSL_free(t->reason);
     t->reason = NULL;
+
     /* Text literal. */
     t->err = NULL;
     t->skip = 0;
     /* Text literal. */
     t->err = NULL;
     t->skip = 0;
@@ -2142,25 +2136,23 @@ static int check_test_error(EVP_TEST *t)
         return 1;
     if (t->err != NULL && t->expected_err == NULL) {
         if (t->aux_err != NULL) {
         return 1;
     if (t->err != NULL && t->expected_err == NULL) {
         if (t->aux_err != NULL) {
-            TEST_info("Above error from the test at %s:%d "
-                      "(%s) unexpected error %s",
-                      current_test_file, t->start_line, t->aux_err, t->err);
+            TEST_info("%s:%d: Source of above error (%s); unexpected error %s",
+                      t->s.test_file, t->s.start, t->aux_err, t->err);
         } else {
         } else {
-            TEST_info("Above error from the test at %s:%d "
-                      "unexpected error %s",
-                      current_test_file, t->start_line, t->err);
+            TEST_info("%s:%d: Source of above error; unexpected error %s",
+                      t->s.test_file, t->s.start, t->err);
         }
         return 0;
     }
     if (t->err == NULL && t->expected_err != NULL) {
         }
         return 0;
     }
     if (t->err == NULL && t->expected_err != NULL) {
-        TEST_info("Test line %d: succeeded but was expecting %s",
-                  t->start_line, t->expected_err);
+        TEST_info("%s:%d: Succeeded but was expecting %s",
+                  t->s.test_file, t->s.start, t->expected_err);
         return 0;
     }
 
     if (strcmp(t->err, t->expected_err) != 0) {
         return 0;
     }
 
     if (strcmp(t->err, t->expected_err) != 0) {
-        TEST_info("Test line %d: expecting %s got %s",
-                  t->start_line, t->expected_err, t->err);
+        TEST_info("%s:%d: Expected %s got %s",
+                  t->s.test_file, t->s.start, t->expected_err, t->err);
         return 0;
     }
 
         return 0;
     }
 
@@ -2168,32 +2160,32 @@ static int check_test_error(EVP_TEST *t)
         return 1;
 
     if (t->func == NULL || t->reason == NULL) {
         return 1;
 
     if (t->func == NULL || t->reason == NULL) {
-        TEST_info("Test line %d: missing function or reason code",
-                  t->start_line);
+        TEST_info("%s:%d: Test is missing function or reason code",
+                  t->s.test_file, t->s.start);
         return 0;
     }
 
     err = ERR_peek_error();
     if (err == 0) {
         return 0;
     }
 
     err = ERR_peek_error();
     if (err == 0) {
-        TEST_info("Test line %d, expected error \"%s:%s\" not set",
-                  t->start_line, t->func, t->reason);
+        TEST_info("%s:%d: Expected error \"%s:%s\" not set",
+                  t->s.test_file, t->s.start, t->func, t->reason);
         return 0;
     }
 
     func = ERR_func_error_string(err);
     reason = ERR_reason_error_string(err);
     if (func == NULL && reason == NULL) {
         return 0;
     }
 
     func = ERR_func_error_string(err);
     reason = ERR_reason_error_string(err);
     if (func == NULL && reason == NULL) {
-        TEST_info("Test line %d: expected error \"%s:%s\","
-                  " no strings available.  Skipping...\n",
-                  t->start_line, t->func, t->reason);
+        TEST_info("%s:%d: Expected error \"%s:%s\", no strings available."
+                  " Assuming ok.",
+                  t->s.test_file, t->s.start, t->func, t->reason);
         return 1;
     }
 
     if (strcmp(func, t->func) == 0 && strcmp(reason, t->reason) == 0)
         return 1;
 
         return 1;
     }
 
     if (strcmp(func, t->func) == 0 && strcmp(reason, t->reason) == 0)
         return 1;
 
-    TEST_info("Test line %d: expected error \"%s:%s\", got \"%s:%s\"",
-              t->start_line, t->func, t->reason, func, reason);
+    TEST_info("%s:%d: Expected error \"%s:%s\", got \"%s:%s\"",
+              t->s.test_file, t->s.start, t->func, t->reason, func, reason);
 
     return 0;
 }
 
     return 0;
 }
@@ -2205,18 +2197,19 @@ static int run_test(EVP_TEST *t)
 {
     if (t->meth == NULL)
         return 1;
 {
     if (t->meth == NULL)
         return 1;
-    t->ntests++;
+    t->s.numtests++;
     if (t->skip) {
     if (t->skip) {
-        t->nskip++;
+        t->s.numskip++;
     } else {
         /* run the test */
         if (t->err == NULL && t->meth->run_test(t) != 1) {
     } else {
         /* run the test */
         if (t->err == NULL && t->meth->run_test(t) != 1) {
-            TEST_info("Line %d error %s", t->start_line, t->meth->name);
+            TEST_info("%s:%d %s error",
+                      t->s.test_file, t->s.start, t->meth->name);
             return 0;
         }
         if (!check_test_error(t)) {
             test_openssl_errors();
             return 0;
         }
         if (!check_test_error(t)) {
             test_openssl_errors();
-            t->errors++;
+            t->s.errors++;
         }
     }
 
         }
     }
 
@@ -2248,90 +2241,6 @@ static void free_key_list(KEY_LIST *lst)
     }
 }
 
     }
 }
 
-
-/*
- * Read a line, remove the newline, return EOF or first char.
- * Comment lines are treated like empty lines.
- */
-static int read_line(EVP_TEST *t)
-{
-    char *p;
-
-    if (!BIO_gets(t->in, t->buf, sizeof(t->buf)))
-        return EOF;
-    t->line++;
-    if ((p = strchr(t->buf, '\n')) != NULL)
-        *p = '\0';
-    if (t->buf[0] == '#')
-        t->buf[0] = '\0';
-    return t->buf[0];
-}
-
-/*
- * Skip leading spaces and remove trailing spaces from string.
- */
-static char *strip_spaces(char *pval)
-{
-    char *p, *start;
-
-    for (start = pval; isspace(*start); )
-        start++;
-    if (*start == '\0')
-        return start;
-
-    for (p = start + strlen(start); --p >= start && isspace(*p); )
-        *p = '\0';
-    return start;
-}
-
-/*
- * Split line into 'key = value'; return 1 if okay, 0 on error.
- */
-static int split_line(EVP_TEST *t, char **keyword, char **value)
-{
-    char *p;
-
-    /* Look for = sign */
-    if ((p = strchr(t->buf, '=')) == NULL) {
-        TEST_error("Line %d: Missing '=' in test file", t->line);
-        return 0;
-    }
-    *p++ = '\0';
-    *keyword = strip_spaces(t->buf);
-    *value = strip_spaces(p);
-    if (**keyword == '\0') {
-        TEST_error("Line %d: Missing key; malformed input line", t->line);
-        return 0;
-    }
-    return 1;
-}
-
-/*
- * Read a PEM block.  Return 1 if okay, 0 on error.
- */
-static int read_key(EVP_TEST *t)
-{
-    char tmpbuf[128];
-
-    if (t->key == NULL) {
-        if (!TEST_ptr(t->key = BIO_new(BIO_s_mem())))
-            return 0;
-    } else if (!TEST_int_gt(BIO_reset(t->key), 0)) {
-        return 0;
-    }
-
-    /* Read to PEM end line and place content in memory BIO */
-    while (BIO_gets(t->in, tmpbuf, sizeof(tmpbuf))) {
-        t->line++;
-        if (!TEST_int_gt(BIO_puts(t->key, tmpbuf), 0))
-            return 0;
-        if (strncmp(tmpbuf, "-----END", 8) == 0)
-            return 1;
-    }
-    TEST_error("Can't find key end");
-    return 0;
-}
-
 /*
  * Is the key type an unsupported algorithm?
  */
 /*
  * Is the key type an unsupported algorithm?
  */
@@ -2360,54 +2269,52 @@ static int key_unsupported()
 }
 
 /*
 }
 
 /*
- * Read, parse, and execute one test.  Return EOF; 0 if failure, 1 if okay.
+ * NULL out the value from |pp| but return it.  This "steals" a pointer.
  */
  */
-static int read_stanza(EVP_TEST *t)
+static char *take_value(PAIR *pp)
 {
 {
-    int c;
-    char *keyword, *value;
-    KEY_LIST **klist, *key;
+    char *p = pp->value;
+
+    pp->value = NULL;
+    return p;
+}
+
+/*
+ * Read and parse one test.  Return 0 if failure, 1 if okay.
+ */
+static int parse(EVP_TEST *t)
+{
+    KEY_LIST *key, **klist;
     EVP_PKEY *pkey;
     EVP_PKEY *pkey;
+    PAIR *pp;
+    int i;
 
 
-    clear_test(t);
 top:
 top:
-    /* Find the first line of a stanza. */
-    for ( ; ; ) {
-        c = read_line(t);
-        if (c == EOF)
+    do {
+        if (BIO_eof(t->s.fp))
             return EOF;
             return EOF;
-        if (c == '\0')
-            continue;
-        break;
-    }
-    if (!split_line(t, &keyword, &value))
-        return 0;
-
-    /* Handle a few special cases here. */
-    if (strcmp(keyword, "Title") == 0) {
-        TEST_info("Starting \"%s\" tests", value);
-        goto top;
-    }
+        clear_test(t);
+        if (!test_readstanza(&t->s))
+            return 0;
+    } while (t->s.numpairs == 0);
+    pp = &t->s.pairs[0];
 
 
+    /* Are we adding a key? */
     klist = NULL;
     pkey = NULL;
     klist = NULL;
     pkey = NULL;
-    if (strcmp(keyword, "PrivateKey") == 0) {
-        if (!read_key(t))
-            return 0;
-        pkey = PEM_read_bio_PrivateKey(t->key, NULL, 0, NULL);
+    if (strcmp(pp->key, "PrivateKey") == 0) {
+        pkey = PEM_read_bio_PrivateKey(t->s.key, NULL, 0, NULL);
         if (pkey == NULL && !key_unsupported()) {
         if (pkey == NULL && !key_unsupported()) {
-            TEST_info("Can't read private key %s", value);
+            TEST_info("Can't read private key %s", pp->value);
             ERR_print_errors_fp(stderr);
             return 0;
         }
         klist = &private_keys;
     }
             ERR_print_errors_fp(stderr);
             return 0;
         }
         klist = &private_keys;
     }
-    else if (strcmp(keyword, "PublicKey") == 0) {
-        if (!read_key(t))
-            return 0;
-        pkey = PEM_read_bio_PUBKEY(t->key, NULL, 0, NULL);
+    else if (strcmp(pp->key, "PublicKey") == 0) {
+        pkey = PEM_read_bio_PUBKEY(t->s.key, NULL, 0, NULL);
         if (pkey == NULL && !key_unsupported()) {
         if (pkey == NULL && !key_unsupported()) {
-            TEST_info("Can't read public key %s", value);
+            TEST_info("Can't read public key %s", pp->value);
             ERR_print_errors_fp(stderr);
             return 0;
         }
             ERR_print_errors_fp(stderr);
             return 0;
         }
@@ -2416,135 +2323,105 @@ top:
 
     /* If we have a key add to list */
     if (klist != NULL) {
 
     /* If we have a key add to list */
     if (klist != NULL) {
-        if (find_key(NULL, value, *klist)) {
-            TEST_info("Duplicate key %s", value);
+        if (find_key(NULL, pp->value, *klist)) {
+            TEST_info("Duplicate key %s", pp->value);
             return 0;
         }
             return 0;
         }
-        if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key)))
-                || !TEST_ptr(key->name = OPENSSL_strdup(value)))
+        if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key))))
             return 0;
             return 0;
+        key->name = take_value(pp);
         key->key = pkey;
         key->next = *klist;
         *klist = key;
 
         /* Go back and start a new stanza. */
         key->key = pkey;
         key->next = *klist;
         *klist = key;
 
         /* Go back and start a new stanza. */
+        if (t->s.numpairs != 1)
+            TEST_info("Line %d: missing blank line\n", t->s.curr);
         goto top;
     }
 
         goto top;
     }
 
-    /* Start of a new text.  Look it up. */
-    if (!TEST_ptr(t->meth = find_test(keyword)))
-        goto skiptoend;
-    t->start_line = t->line;
-    if (!t->meth->init(t, value)) {
-        TEST_error("unknown %s: %s\n", keyword, value);
-        goto skiptoend;
+    /* Find the test, based on first keyword. */
+    if (!TEST_ptr(t->meth = find_test(pp->key)))
+        return 0;
+    if (!t->meth->init(t, pp->value)) {
+        TEST_error("unknown %s: %s\n", pp->key, pp->value);
+        return 0;
     }
     if (t->skip == 1) {
     }
     if (t->skip == 1) {
-        /* TEST_info("skipping %s %s", keyword, value); */
-        goto skiptoend;
+        /* TEST_info("skipping %s %s", pp->key, pp->value); */
+        return 0;
     }
 
     }
 
-    /* Read rest of stanza. */
-    for ( ; ; ) {
-        c = read_line(t);
-        if (c == EOF)
-            return c;
-        if (c == '\0')
-            break;
-        if (!split_line(t, &keyword, &value))
-            goto skiptoend;
-        if (strcmp(keyword, "Result") == 0) {
+    for (pp++, i = 1; i < t->s.numpairs; pp++, i++) {
+        if (strcmp(pp->key, "Result") == 0) {
             if (t->expected_err != NULL) {
             if (t->expected_err != NULL) {
-                TEST_info("Line %d: multiple result lines", t->line);
-                goto skiptoend;
+                TEST_info("Line %d: multiple result lines", t->s.curr);
+                return 0;
             }
             }
-            if (!TEST_ptr(t->expected_err = OPENSSL_strdup(value)))
-                goto skiptoend;
-        } else if (strcmp(keyword, "Function") == 0) {
+            t->expected_err = take_value(pp);
+        } else if (strcmp(pp->key, "Function") == 0) {
             if (t->func != NULL) {
             if (t->func != NULL) {
-                TEST_info("Line %d: multiple function lines\n", t->line);
-                goto skiptoend;
+                TEST_info("Line %d: multiple function lines\n", t->s.curr);
+                return 0;
             }
             }
-            if (!TEST_ptr(t->func = OPENSSL_strdup(value)))
-                goto skiptoend;
-        } else if (strcmp(keyword, "Reason") == 0) {
+            t->func = take_value(pp);
+        } else if (strcmp(pp->key, "Reason") == 0) {
             if (t->reason != NULL) {
             if (t->reason != NULL) {
-                TEST_info("Line %d: multiple reason lines", t->line);
-                goto skiptoend;
+                TEST_info("Line %d: multiple reason lines", t->s.curr);
+                return 0;
             }
             }
-            if (!TEST_ptr(t->reason = OPENSSL_strdup(value)))
-                goto skiptoend;
+            t->reason = take_value(pp);
         } else {
             /* Must be test specific line: try to parse it */
         } else {
             /* Must be test specific line: try to parse it */
-            int rv = t->meth->parse(t, keyword, value);
+            int rv = t->meth->parse(t, pp->key, pp->value);
 
             if (rv == 0) {
 
             if (rv == 0) {
-                TEST_info("Line %d: unknown keyword %s", t->line, keyword);
-                goto skiptoend;
+                TEST_info("Line %d: unknown keyword %s", t->s.curr, pp->key);
+                return 0;
             }
             if (rv < 0) {
                 TEST_info("Line %d: error processing keyword %s\n",
             }
             if (rv < 0) {
                 TEST_info("Line %d: error processing keyword %s\n",
-                        t->line, keyword);
-                goto skiptoend;
+                        t->s.curr, pp->key);
+                return 0;
             }
         }
     }
 
     return 1;
             }
         }
     }
 
     return 1;
-
-skiptoend:
-    /* Read to end of stanza and return failure */
-    for ( ; ; ) {
-        c = read_line(t);
-        if (c == EOF)
-            return EOF;
-        if (c == '\0')
-            break;
-    }
-    return 0;
 }
 
 }
 
-static int do_test_file(const char *testfile)
+static char * const *testfiles;
+
+static int run_file_tests(int i)
 {
 {
-    BIO *in;
-    EVP_TEST t;
+    EVP_TEST *t;
     int c;
 
     int c;
 
-    set_test_title(testfile);
-    current_test_file = testfile;
-    if (!TEST_ptr(in = BIO_new_file(testfile, "rb")))
+    if (!TEST_ptr(t = OPENSSL_zalloc(sizeof(*t))))
         return 0;
         return 0;
-    memset(&t, 0, sizeof(t));
-    t.in = in;
+    if (!test_start_file(&t->s, testfiles[i])) {
+        OPENSSL_free(t);
+        return 0;
+    }
 
 
-    TEST_info("Reading %s", testfile);
-    for ( ; ; ) {
-        c = read_stanza(&t);
-        if (t.skip)
+    while (!BIO_eof(t->s.fp)) {
+        c = parse(t);
+        if (t->skip)
             continue;
             continue;
-        if (c == 0 || !run_test(&t)) {
-            t.errors++;
+        if (c == 0 || !run_test(t)) {
+            t->s.errors++;
             break;
         }
             break;
         }
-        if (c == EOF)
-            break;
     }
     }
-    clear_test(&t);
+    test_end_file(&t->s);
+    clear_test(t);
 
 
-    TEST_info("Completed %d tests with %d errors and %d skipped",
-              t.ntests, t.errors, t.nskip);
     free_key_list(public_keys);
     free_key_list(private_keys);
     free_key_list(public_keys);
     free_key_list(private_keys);
-    BIO_free(t.key);
-    BIO_free(in);
-    return t.errors == 0;
-}
-
-static char * const *testfiles;
-
-static int run_file_tests(int i)
-{
-    return do_test_file(testfiles[i]);
+    BIO_free(t->s.key);
+    c = t->s.errors;
+    OPENSSL_free(t);
+    return c == 0;
 }
 
 int test_main(int argc, char *argv[])
 }
 
 int test_main(int argc, char *argv[])
index a662cd4..33eede2 100644 (file)
@@ -1178,6 +1178,7 @@ Operation = DECRYPT
 Result = CIPHERFINAL_ERROR
 
 Title = AES XTS test vectors from IEEE Std 1619-2007
 Result = CIPHERFINAL_ERROR
 
 Title = AES XTS test vectors from IEEE Std 1619-2007
+
 Cipher = aes-128-xts
 Key = 0000000000000000000000000000000000000000000000000000000000000000
 IV = 00000000000000000000000000000000
 Cipher = aes-128-xts
 Key = 0000000000000000000000000000000000000000000000000000000000000000
 IV = 00000000000000000000000000000000
index 6a69fab..3c3d090 100644 (file)
@@ -708,6 +708,7 @@ PrivateKey=Alice-25519
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VuBCIEIHcHbQpzGKV9PBbBclGyZkXfTC+H68CZKrF3+6UduSwq
 -----END PRIVATE KEY-----
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VuBCIEIHcHbQpzGKV9PBbBclGyZkXfTC+H68CZKrF3+6UduSwq
 -----END PRIVATE KEY-----
+
 PublicKey=Alice-25519-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VuAyEAhSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo=
 PublicKey=Alice-25519-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VuAyEAhSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo=
@@ -719,6 +720,7 @@ PrivateKey=Bob-25519
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VuBCIEIF2rCH5iSopLeeF/i4OADuZvO7EpJhi2/Rwviyf/iODr
 -----END PRIVATE KEY-----
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VuBCIEIF2rCH5iSopLeeF/i4OADuZvO7EpJhi2/Rwviyf/iODr
 -----END PRIVATE KEY-----
+
 PublicKey=Bob-25519-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VuAyEA3p7bfXt9wbTTW2HC7OQ1Nz+DQ8hbeGdNrfx+FG+IK08=
 PublicKey=Bob-25519-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VuAyEA3p7bfXt9wbTTW2HC7OQ1Nz+DQ8hbeGdNrfx+FG+IK08=
@@ -747,9 +749,9 @@ Function = EVP_PKEY_verify_init
 Reason = operation not supported for this keytype
 
 
 Reason = operation not supported for this keytype
 
 
-Title = RSA PSS/OAEP (from RSASecurity FTP)
 # Additional RSA-PSS and RSA-OAEP tests converted from
 # ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
 # Additional RSA-PSS and RSA-OAEP tests converted from
 # ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
+Title = RSA PSS/OAEP (from RSASecurity FTP)
 
 PublicKey=RSA-PSS-1
 -----BEGIN PUBLIC KEY-----
 
 PublicKey=RSA-PSS-1
 -----BEGIN PUBLIC KEY-----
@@ -5811,7 +5813,6 @@ SharedSecret=A7927098655F1F9976FA50A9D566865DC530331846381C87256BAF3226244B76D36
 #     456068d3f8aad8ac62a03d19ed3173f00ad51f42b51aeab4753c20f30c01cf23 #
 Title = ECDH KATs (from NIST SP800-56A co-factor ECDH KATs
 
 #     456068d3f8aad8ac62a03d19ed3173f00ad51f42b51aeab4753c20f30c01cf23 #
 Title = ECDH KATs (from NIST SP800-56A co-factor ECDH KATs
 
-
 PrivateKey=KAS-ECC-CDH_P-192_C0
 -----BEGIN PRIVATE KEY-----
 MG8CAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQEEVTBTAgEBBBjxfT/qNnt000CFHKQn
 PrivateKey=KAS-ECC-CDH_P-192_C0
 -----BEGIN PRIVATE KEY-----
 MG8CAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQEEVTBTAgEBBBjxfT/qNnt000CFHKQn
@@ -17327,18 +17328,22 @@ PrivateKey=ED25519-1
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VwBCIEIJ1hsZ3v/VpguoRK9JLsLMREScVpezJpGXA7rAMcrn9g
 -----END PRIVATE KEY-----
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VwBCIEIJ1hsZ3v/VpguoRK9JLsLMREScVpezJpGXA7rAMcrn9g
 -----END PRIVATE KEY-----
+
 PrivateKey=ED25519-2
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VwBCIEIEzNCJso/5banbbDRuwRTg9bijGfNaumJNqM9u1PuKb7
 -----END PRIVATE KEY-----
 PrivateKey=ED25519-2
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VwBCIEIEzNCJso/5banbbDRuwRTg9bijGfNaumJNqM9u1PuKb7
 -----END PRIVATE KEY-----
+
 PrivateKey=ED25519-3
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VwBCIEIMWqjfQ/n4N77bdELzHct7Fm04U1B28JS4XOOi4LRFj3
 -----END PRIVATE KEY-----
 PrivateKey=ED25519-3
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VwBCIEIMWqjfQ/n4N77bdELzHct7Fm04U1B28JS4XOOi4LRFj3
 -----END PRIVATE KEY-----
+
 PrivateKey=ED25519-4
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VwBCIEIPXldnzxUzGVF2MPImh2uGyBYMxYO8ATdExr8lX1zA7l
 -----END PRIVATE KEY-----
 PrivateKey=ED25519-4
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VwBCIEIPXldnzxUzGVF2MPImh2uGyBYMxYO8ATdExr8lX1zA7l
 -----END PRIVATE KEY-----
+
 PrivateKey=ED25519-5
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VwBCIEIIM/5iQJI3udYux3WHUgkR6adZzsHRl1W32pAbltyj1C
 PrivateKey=ED25519-5
 -----BEGIN PRIVATE KEY-----
 MC4CAQAwBQYDK2VwBCIEIIM/5iQJI3udYux3WHUgkR6adZzsHRl1W32pAbltyj1C
@@ -17348,18 +17353,22 @@ PublicKey=ED25519-1-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEA11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo=
 -----END PUBLIC KEY-----
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEA11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo=
 -----END PUBLIC KEY-----
+
 PublicKey=ED25519-2-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEAPUAXw+hDiVqStwqnTRt+vJyYLM8uxJaMwM1V8Sr0Zgw=
 -----END PUBLIC KEY-----
 PublicKey=ED25519-2-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEAPUAXw+hDiVqStwqnTRt+vJyYLM8uxJaMwM1V8Sr0Zgw=
 -----END PUBLIC KEY-----
+
 PublicKey=ED25519-3-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEA/FHNjmIYoaONpH7QAjDwWAgW7RO6MwOsXeuRFUiQgCU=
 -----END PUBLIC KEY-----
 PublicKey=ED25519-3-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEA/FHNjmIYoaONpH7QAjDwWAgW7RO6MwOsXeuRFUiQgCU=
 -----END PUBLIC KEY-----
+
 PublicKey=ED25519-4-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEAJ4EX/BRMcjQPZ9DyMW6Dhs7/vyskKMnFH+98WX8dQm4=
 -----END PUBLIC KEY-----
 PublicKey=ED25519-4-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEAJ4EX/BRMcjQPZ9DyMW6Dhs7/vyskKMnFH+98WX8dQm4=
 -----END PUBLIC KEY-----
+
 PublicKey=ED25519-5-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEA7Bcrk61eVjv0kyxw4SRQNMNUZ+8u/U1k6/gZaDRn4r8=
 PublicKey=ED25519-5-PUBLIC
 -----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEA7Bcrk61eVjv0kyxw4SRQNMNUZ+8u/U1k6/gZaDRn4r8=
index d8acd73..48c4eb3 100644 (file)
@@ -402,4 +402,48 @@ void test_openssl_errors(void);
 extern BIO *bio_out;
 extern BIO *bio_err;
 
 extern BIO *bio_out;
 extern BIO *bio_err;
 
+/*
+ * Utilities to parse a test file.
+ */
+#define TESTMAXPAIRS        20
+
+typedef struct pair_st {
+    char *key;
+    char *value;
+} PAIR;
+
+typedef struct stanza_st {
+    const char *test_file;      /* Input file name */
+    BIO *fp;                    /* Input file */
+    int curr;                   /* Current line in file */
+    int start;                  /* Line where test starts */
+    int errors;                 /* Error count */
+    int numtests;               /* Number of tests */
+    int numskip;                /* Number of skipped tests */
+    int numpairs;
+    PAIR pairs[TESTMAXPAIRS];
+    BIO *key;                   /* temp memory BIO for reading in keys */
+    char buff[4096];            /* Input buffer for a single key/value */
+} STANZA;
+
+/*
+ * Prepare to start reading the file |testfile| as input.
+ */
+int test_start_file(STANZA *s, const char *testfile);
+int test_end_file(STANZA *s);
+
+/*
+ * Read a stanza from the test file.  A stanza consists of a block
+ * of lines of the form 
+ *      key = value
+ * The block is terminated by EOF or a blank line.
+ * Return 1 if found, 0 on EOF or error.
+ */
+int test_readstanza(STANZA *s);
+
+/*
+ * Clear a stanza, release all allocated memory.
+ */
+void test_clearstanza(STANZA *s);
+
 #endif                          /* HEADER_TESTUTIL_H */
 #endif                          /* HEADER_TESTUTIL_H */
diff --git a/test/testutil/stanza.c b/test/testutil/stanza.c
new file mode 100644 (file)
index 0000000..46b1e77
--- /dev/null
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2017 The OpenSSL Project Authors. 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
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "e_os.h"
+#include "../testutil.h"
+
+int test_start_file(STANZA *s, const char *testfile)
+{
+    TEST_info("Reading %s", testfile);
+    set_test_title(testfile);
+    memset(s, 0, sizeof(*s));
+    if (!TEST_ptr(s->fp = BIO_new_file(testfile, "rb")))
+        return 0;
+    s->test_file = testfile;
+    return 1;
+}
+
+int test_end_file(STANZA *s)
+{
+    TEST_info("Completed %d tests with %d errors and %d skipped",
+              s->numtests, s->errors, s->numskip);
+    BIO_free(s->fp);
+    return 1;
+}
+
+/*
+ * Read a PEM block.  Return 1 if okay, 0 on error.
+ */
+static int read_key(STANZA *s)
+{
+    char tmpbuf[128];
+
+    if (s->key == NULL) {
+        if (!TEST_ptr(s->key = BIO_new(BIO_s_mem())))
+            return 0;
+    } else if (!TEST_int_gt(BIO_reset(s->key), 0)) {
+        return 0;
+    }
+
+    /* Read to PEM end line and place content in memory BIO */
+    while (BIO_gets(s->fp, tmpbuf, sizeof(tmpbuf))) {
+        s->curr++;
+        if (!TEST_int_gt(BIO_puts(s->key, tmpbuf), 0))
+            return 0;
+        if (strncmp(tmpbuf, "-----END", 8) == 0)
+            return 1;
+    }
+    TEST_error("Can't find key end");
+    return 0;
+}
+
+
+/*
+ * Delete leading and trailing spaces from a string
+ */
+static char *strip_spaces(char *p)
+{
+    char *q;
+
+    /* Skip over leading spaces */
+    while (*p && isspace(*p))
+        p++;
+    if (!*p)
+        return NULL;
+
+    for (q = p + strlen(p) - 1; q != p && isspace(*q); )
+        *q-- = '\0';
+    return *p ? p : NULL;
+}
+
+/*
+ * Read next test stanza; return 1 if found, 0 on EOF or error.
+ */
+int test_readstanza(STANZA *s)
+{
+    PAIR *pp = s->pairs;
+    char *p, *equals, *key, *value;
+
+    for (s->numpairs = 0; BIO_gets(s->fp, s->buff, sizeof(s->buff)); ) {
+        s->curr++;
+        if (!TEST_ptr(p = strchr(s->buff, '\n'))) {
+            TEST_info("Line %d too long", s->curr);
+            return 0;
+        }
+        *p = '\0';
+
+        /* Blank line marks end of tests. */
+        if (s->buff[0] == '\0')
+            break;
+
+        /* Lines starting with a pound sign are ignored. */
+        if (s->buff[0] == '#')
+            continue;
+
+        /* Parse into key=value */
+        if (!TEST_ptr(equals = strchr(s->buff, '='))) {
+            TEST_info("Missing = at line %d\n", s->curr);
+            return 0;
+        }
+        *equals++ = '\0';
+        if (!TEST_ptr(key = strip_spaces(s->buff))) {
+            TEST_info("Empty field at line %d\n", s->curr);
+            return 0;
+        }
+        if ((value = strip_spaces(equals)) == NULL)
+            value = "";
+
+        if (strcmp(key, "Title") == 0) {
+            TEST_info("Starting \"%s\" tests at line %d", value, s->curr);
+            continue;
+        }
+
+        if (s->numpairs == 0)
+            s->start = s->curr;
+
+        if (strcmp(key, "PrivateKey") == 0) {
+            if (!read_key(s))
+                return 0;
+        }
+        if (strcmp(key, "PublicKey") == 0) {
+            if (!read_key(s))
+                return 0;
+        }
+
+        if (!TEST_int_lt(s->numpairs++, TESTMAXPAIRS)
+                || !TEST_ptr(pp->key = OPENSSL_strdup(key))
+                || !TEST_ptr(pp->value = OPENSSL_strdup(value)))
+            return 0;
+        pp++;
+    }
+
+    /* If we read anything, return ok. */
+    return 1;
+}
+
+void test_clearstanza(STANZA *s)
+{
+    PAIR *pp = s->pairs;
+    int i = s->numpairs;
+
+    for ( ; --i >= 0; pp++) {
+        OPENSSL_free(pp->key);
+        OPENSSL_free(pp->value);
+    }
+    s->numpairs = 0;
+}