[openssl-commits] [openssl] master update

Matt Caswell matt at openssl.org
Fri May 27 09:33:26 UTC 2016


The branch master has been updated
       via  f8f686ec1cda6a077ec9d5c2ab540cf202059279 (commit)
       via  1b62d880b5190de8c49a01837d96501cecf2a111 (commit)
       via  d6056f085dc0d53663433d98eb105cb5f26624e7 (commit)
       via  242073bdbc0bcca8fa7d193f9dc43c53a482c829 (commit)
      from  5e0dc5c9992ad53d12b07eb5d12a0e23dd5be670 (commit)


- Log -----------------------------------------------------------------
commit f8f686ec1cda6a077ec9d5c2ab540cf202059279
Author: Matt Caswell <matt at openssl.org>
Date:   Thu May 26 13:47:47 2016 +0100

    Add a test for printing floating point format specifiers
    
    Previous commits fixed the implementation of the %e and %g format
    specifiers as well as other issues. This commit adds a test.
    
    Reviewed-by: Richard Levitte <levitte at openssl.org>

commit 1b62d880b5190de8c49a01837d96501cecf2a111
Author: Matt Caswell <matt at openssl.org>
Date:   Wed May 25 16:20:48 2016 +0100

    Prevent an overflow when trying to print excessively big floats
    
    We convert the integer part of the float to a long. We should check it
    fits first.
    
    Issue reported by Guido Vranken.
    
    GitHub Issue #1102
    
    Reviewed-by: Richard Levitte <levitte at openssl.org>

commit d6056f085dc0d53663433d98eb105cb5f26624e7
Author: Matt Caswell <matt at openssl.org>
Date:   Wed May 25 15:33:15 2016 +0100

    Fix implementation of "e" and "g" formats for printing floating points
    
    The previous commit which "fixed" the "e" and "g" floating point formats
    just printed them in the same way as "f". This is wrong. This commit
    provides the correct formatting.
    
    Reviewed-by: Richard Levitte <levitte at openssl.org>

commit 242073bdbc0bcca8fa7d193f9dc43c53a482c829
Author: Matt Caswell <matt at openssl.org>
Date:   Wed May 25 15:37:11 2016 +0100

    Fix some issues in b_print.c code
    
    Convert assert to OPENSSL_assert(), add some documentation, add the calls
    to fmtfp() for the "e" and "g" floating point formats which were missing.
    
    Based on a patch provided by Ger Hobbelt <ger at hobbelt.com>.
    
    RT#2270
    
    Reviewed-by: Richard Levitte <levitte at openssl.org>

-----------------------------------------------------------------------

Summary of changes:
 crypto/bio/b_print.c                               | 177 ++++++++++++++--
 test/bioprinttest.c                                | 225 +++++++++++++++++++++
 test/build.info                                    |   7 +-
 .../recipes/{05-test_hmac.t => 90-test_bioprint.t} |   4 +-
 4 files changed, 394 insertions(+), 19 deletions(-)
 create mode 100644 test/bioprinttest.c
 copy test/recipes/{05-test_hmac.t => 90-test_bioprint.t} (72%)

diff --git a/crypto/bio/b_print.c b/crypto/bio/b_print.c
index 8c574e1..d52ad7c 100644
--- a/crypto/bio/b_print.c
+++ b/crypto/bio/b_print.c
@@ -10,7 +10,6 @@
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
-#include <assert.h>
 #include <limits.h>
 #include "internal/cryptlib.h"
 #ifndef NO_SYS_TYPES_H
@@ -53,7 +52,7 @@ static int fmtstr(char **, char **, size_t *, size_t *,
 static int fmtint(char **, char **, size_t *, size_t *,
                   LLONG, int, int, int, int);
 static int fmtfp(char **, char **, size_t *, size_t *,
-                 LDOUBLE, int, int, int);
+                 LDOUBLE, int, int, int, int);
 static int doapr_outch(char **, char **, size_t *, size_t *, int);
 static int _dopr(char **sbuffer, char **buffer,
                  size_t *maxlen, size_t *retlen, int *truncated,
@@ -70,12 +69,19 @@ static int _dopr(char **sbuffer, char **buffer,
 #define DP_S_DONE       7
 
 /* format flags - Bits */
+/* left-aligned padding */
 #define DP_F_MINUS      (1 << 0)
+/* print an explicit '+' for a value with positive sign */
 #define DP_F_PLUS       (1 << 1)
+/* print an explicit ' ' for a value with positive sign */
 #define DP_F_SPACE      (1 << 2)
+/* print 0/0x prefix for octal/hex and decimal point for floating point */
 #define DP_F_NUM        (1 << 3)
+/* print leading zeroes */
 #define DP_F_ZERO       (1 << 4)
+/* print HEX in UPPPERcase */
 #define DP_F_UP         (1 << 5)
+/* treat value as unsigned */
 #define DP_F_UNSIGNED   (1 << 6)
 
 /* conversion flags */
@@ -84,6 +90,11 @@ static int _dopr(char **sbuffer, char **buffer,
 #define DP_C_LDOUBLE    3
 #define DP_C_LLONG      4
 
+/* Floating point formats */
+#define F_FORMAT        0
+#define E_FORMAT        1
+#define G_FORMAT        2
+
 /* some handy macros */
 #define char_to_int(p) (p - '0')
 #define OSSL_MAX(p,q) ((p >= q) ? p : q)
@@ -262,7 +273,7 @@ _dopr(char **sbuffer,
                 else
                     fvalue = va_arg(args, double);
                 if (!fmtfp(sbuffer, buffer, &currlen, maxlen, fvalue, min, max,
-                           flags))
+                           flags, F_FORMAT))
                     return 0;
                 break;
             case 'E':
@@ -272,6 +283,9 @@ _dopr(char **sbuffer,
                     fvalue = va_arg(args, LDOUBLE);
                 else
                     fvalue = va_arg(args, double);
+                if (!fmtfp(sbuffer, buffer, &currlen, maxlen, fvalue, min, max,
+                           flags, E_FORMAT))
+                    return 0;
                 break;
             case 'G':
                 flags |= DP_F_UP;
@@ -280,6 +294,9 @@ _dopr(char **sbuffer,
                     fvalue = va_arg(args, LDOUBLE);
                 else
                     fvalue = va_arg(args, double);
+                if (!fmtfp(sbuffer, buffer, &currlen, maxlen, fvalue, min, max,
+                           flags, G_FORMAT))
+                    return 0;
                 break;
             case 'c':
                 if(!doapr_outch(sbuffer, buffer, &currlen, maxlen,
@@ -530,23 +547,28 @@ static int
 fmtfp(char **sbuffer,
       char **buffer,
       size_t *currlen,
-      size_t *maxlen, LDOUBLE fvalue, int min, int max, int flags)
+      size_t *maxlen, LDOUBLE fvalue, int min, int max, int flags, int style)
 {
     int signvalue = 0;
     LDOUBLE ufvalue;
+    LDOUBLE tmpvalue;
     char iconvert[20];
     char fconvert[20];
+    char econvert[20];
     int iplace = 0;
     int fplace = 0;
+    int eplace = 0;
     int padlen = 0;
     int zpadlen = 0;
-    long intpart;
-    long fracpart;
-    long max10;
+    long exp = 0;
+    unsigned long intpart;
+    unsigned long fracpart;
+    unsigned long max10;
+    int realstyle;
 
     if (max < 0)
         max = 6;
-    ufvalue = abs_val(fvalue);
+
     if (fvalue < 0)
         signvalue = '-';
     else if (flags & DP_F_PLUS)
@@ -554,7 +576,73 @@ fmtfp(char **sbuffer,
     else if (flags & DP_F_SPACE)
         signvalue = ' ';
 
-    intpart = (long)ufvalue;
+    /*
+     * G_FORMAT sometimes prints like E_FORMAT and sometimes like F_FORMAT
+     * depending on the number to be printed. Work out which one it is and use
+     * that from here on.
+     */
+    if (style == G_FORMAT) {
+        if (fvalue == 0.0) {
+            realstyle = F_FORMAT;
+        } else if (fvalue < 0.0001) {
+            realstyle = E_FORMAT;
+        } else if ((max == 0 && fvalue >= 10)
+                    || (max > 0 && fvalue >= pow_10(max))) {
+            realstyle = E_FORMAT;
+        } else {
+            realstyle = F_FORMAT;
+        }
+    } else {
+        realstyle = style;
+    }
+
+    if (style != F_FORMAT) {
+        tmpvalue = fvalue;
+        /* Calculate the exponent */
+        if (fvalue != 0.0) {
+            while (tmpvalue < 1) {
+                tmpvalue *= 10;
+                exp--;
+            }
+            while (tmpvalue > 10) {
+                tmpvalue /= 10;
+                exp++;
+            }
+        }
+        if (style == G_FORMAT) {
+            /*
+             * In G_FORMAT the "precision" represents significant digits. We
+             * always have at least 1 significant digit.
+             */
+            if (max == 0)
+                max = 1;
+            /* Now convert significant digits to decimal places */
+            if (realstyle == F_FORMAT) {
+                max -= (exp + 1);
+                if (max < 0) {
+                    /*
+                     * Should not happen. If we're in F_FORMAT then exp < max?
+                     */
+                    return 0;
+                }
+            } else {
+                /*
+                 * In E_FORMAT there is always one significant digit in front
+                 * of the decimal point, so:
+                 * significant digits == 1 + decimal places
+                 */
+                max--;
+            }
+        }
+        if (realstyle == E_FORMAT)
+            fvalue = tmpvalue;
+    }
+    ufvalue = abs_val(fvalue);
+    if (ufvalue > ULONG_MAX) {
+        /* Number too big */
+        return 0;
+    }
+    intpart = (unsigned long)ufvalue;
 
     /*
      * sorry, we only support 9 digits past the decimal because of our
@@ -585,16 +673,51 @@ fmtfp(char **sbuffer,
     iconvert[iplace] = 0;
 
     /* convert fractional part */
-    do {
+    while (fplace < max) {
+        if (style == G_FORMAT && fplace == 0 && (fracpart % 10) == 0) {
+            /* We strip trailing zeros in G_FORMAT */
+            max--;
+            fracpart = fracpart / 10;
+            if (fplace < max)
+                continue;
+            break;
+        }
         fconvert[fplace++] = "0123456789"[fracpart % 10];
         fracpart = (fracpart / 10);
-    } while (fplace < max);
+    }
+
     if (fplace == sizeof fconvert)
         fplace--;
     fconvert[fplace] = 0;
 
-    /* -1 for decimal point, another -1 if we are printing a sign */
-    padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
+    /* convert exponent part */
+    if (realstyle == E_FORMAT) {
+        int tmpexp;
+        if (exp < 0)
+            tmpexp = -exp;
+        else
+            tmpexp = exp;
+
+        do {
+            econvert[eplace++] = "0123456789"[tmpexp % 10];
+            tmpexp = (tmpexp / 10);
+        } while (tmpexp > 0 && eplace < (int)sizeof(econvert));
+        /* Exponent is huge!! Too big to print */
+        if (tmpexp > 0)
+            return 0;
+        /* Add a leading 0 for single digit exponents */
+        if (eplace == 1)
+            econvert[eplace++] = '0';
+    }
+
+    /*
+     * -1 for decimal point (if we have one, i.e. max > 0),
+     * another -1 if we are printing a sign
+     */
+    padlen = min - iplace - max - (max > 0 ? 1 : 0) - ((signvalue) ? 1 : 0);
+    /* Take some off for exponent prefix "+e" and exponent */
+    if (realstyle == E_FORMAT)
+        padlen -= 2 + eplace;
     zpadlen = max - fplace;
     if (zpadlen < 0)
         zpadlen = 0;
@@ -648,6 +771,28 @@ fmtfp(char **sbuffer,
             return 0;
         --zpadlen;
     }
+    if (realstyle == E_FORMAT) {
+        char ech;
+
+        if ((flags & DP_F_UP) == 0)
+            ech = 'e';
+        else
+            ech = 'E';
+        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ech))
+                return 0;
+        if (exp < 0) {
+            if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '-'))
+                    return 0;
+        } else {
+            if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '+'))
+                    return 0;
+        }
+        while (eplace > 0) {
+            if (!doapr_outch(sbuffer, buffer, currlen, maxlen,
+                             econvert[--eplace]))
+                return 0;
+        }
+    }
 
     while (padlen < 0) {
         if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
@@ -664,10 +809,10 @@ doapr_outch(char **sbuffer,
             char **buffer, size_t *currlen, size_t *maxlen, int c)
 {
     /* If we haven't at least one buffer, someone has doe a big booboo */
-    assert(*sbuffer != NULL || buffer != NULL);
+    OPENSSL_assert(*sbuffer != NULL || buffer != NULL);
 
     /* |currlen| must always be <= |*maxlen| */
-    assert(*currlen <= *maxlen);
+    OPENSSL_assert(*currlen <= *maxlen);
 
     if (buffer && *currlen == *maxlen) {
         if (*maxlen > INT_MAX - BUFFER_INC)
@@ -679,7 +824,7 @@ doapr_outch(char **sbuffer,
             if (*buffer == NULL)
                 return 0;
             if (*currlen > 0) {
-                assert(*sbuffer != NULL);
+                OPENSSL_assert(*sbuffer != NULL);
                 memcpy(*buffer, *sbuffer, *currlen);
             }
             *sbuffer = NULL;
diff --git a/test/bioprinttest.c b/test/bioprinttest.c
new file mode 100644
index 0000000..d376cfb
--- /dev/null
+++ b/test/bioprinttest.c
@@ -0,0 +1,225 @@
+/*
+ * Copyright 2016 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 <stdio.h>
+#include <string.h>
+#include <openssl/bio.h>
+
+static int justprint = 0;
+
+static char *fpexpected[][5] = {
+    /*   0 */ { "0.0000e+00", "0.0000", "0", "0.0000E+00", "0" },
+    /*   1 */ { "6.7000e-01", "0.6700", "0.67", "6.7000E-01", "0.67" },
+    /*   2 */ { "6.6667e-01", "0.6667", "0.6667", "6.6667E-01", "0.6667" },
+    /*   3 */ { "6.6667e-04", "0.0007", "0.0006667", "6.6667E-04", "0.0006667" },
+    /*   4 */ { "6.6667e-05", "0.0001", "6.667e-05", "6.6667E-05", "6.667E-05" },
+    /*   5 */ { "6.6667e+00", "6.6667", "6.667", "6.6667E+00", "6.667" },
+    /*   6 */ { "6.6667e+01", "66.6667", "66.67", "6.6667E+01", "66.67" },
+    /*   7 */ { "6.6667e+02", "666.6667", "666.7", "6.6667E+02", "666.7" },
+    /*   8 */ { "6.6667e+03", "6666.6667", "6667", "6.6667E+03", "6667" },
+    /*   9 */ { "6.6667e+04", "66666.6667", "6.667e+04", "6.6667E+04", "6.667E+04" },
+    /*  10 */ { "0.00000e+00", "0.00000", "0", "0.00000E+00", "0" },
+    /*  11 */ { "6.70000e-01", "0.67000", "0.67", "6.70000E-01", "0.67" },
+    /*  12 */ { "6.66667e-01", "0.66667", "0.66667", "6.66667E-01", "0.66667" },
+    /*  13 */ { "6.66667e-04", "0.00067", "0.00066667", "6.66667E-04", "0.00066667" },
+    /*  14 */ { "6.66667e-05", "0.00007", "6.6667e-05", "6.66667E-05", "6.6667E-05" },
+    /*  15 */ { "6.66667e+00", "6.66667", "6.6667", "6.66667E+00", "6.6667" },
+    /*  16 */ { "6.66667e+01", "66.66667", "66.667", "6.66667E+01", "66.667" },
+    /*  17 */ { "6.66667e+02", "666.66667", "666.67", "6.66667E+02", "666.67" },
+    /*  18 */ { "6.66667e+03", "6666.66667", "6666.7", "6.66667E+03", "6666.7" },
+    /*  19 */ { "6.66667e+04", "66666.66667", "66667", "6.66667E+04", "66667" },
+    /*  20 */ { "  0.0000e+00", "      0.0000", "           0", "  0.0000E+00", "           0" },
+    /*  21 */ { "  6.7000e-01", "      0.6700", "        0.67", "  6.7000E-01", "        0.67" },
+    /*  22 */ { "  6.6667e-01", "      0.6667", "      0.6667", "  6.6667E-01", "      0.6667" },
+    /*  23 */ { "  6.6667e-04", "      0.0007", "   0.0006667", "  6.6667E-04", "   0.0006667" },
+    /*  24 */ { "  6.6667e-05", "      0.0001", "   6.667e-05", "  6.6667E-05", "   6.667E-05" },
+    /*  25 */ { "  6.6667e+00", "      6.6667", "       6.667", "  6.6667E+00", "       6.667" },
+    /*  26 */ { "  6.6667e+01", "     66.6667", "       66.67", "  6.6667E+01", "       66.67" },
+    /*  27 */ { "  6.6667e+02", "    666.6667", "       666.7", "  6.6667E+02", "       666.7" },
+    /*  28 */ { "  6.6667e+03", "   6666.6667", "        6667", "  6.6667E+03", "        6667" },
+    /*  29 */ { "  6.6667e+04", "  66666.6667", "   6.667e+04", "  6.6667E+04", "   6.667E+04" },
+    /*  30 */ { " 0.00000e+00", "     0.00000", "           0", " 0.00000E+00", "           0" },
+    /*  31 */ { " 6.70000e-01", "     0.67000", "        0.67", " 6.70000E-01", "        0.67" },
+    /*  32 */ { " 6.66667e-01", "     0.66667", "     0.66667", " 6.66667E-01", "     0.66667" },
+    /*  33 */ { " 6.66667e-04", "     0.00067", "  0.00066667", " 6.66667E-04", "  0.00066667" },
+    /*  34 */ { " 6.66667e-05", "     0.00007", "  6.6667e-05", " 6.66667E-05", "  6.6667E-05" },
+    /*  35 */ { " 6.66667e+00", "     6.66667", "      6.6667", " 6.66667E+00", "      6.6667" },
+    /*  36 */ { " 6.66667e+01", "    66.66667", "      66.667", " 6.66667E+01", "      66.667" },
+    /*  37 */ { " 6.66667e+02", "   666.66667", "      666.67", " 6.66667E+02", "      666.67" },
+    /*  38 */ { " 6.66667e+03", "  6666.66667", "      6666.7", " 6.66667E+03", "      6666.7" },
+    /*  39 */ { " 6.66667e+04", " 66666.66667", "       66667", " 6.66667E+04", "       66667" },
+    /*  40 */ { "0e+00", "0", "0", "0E+00", "0" },
+    /*  41 */ { "7e-01", "1", "0.7", "7E-01", "0.7" },
+    /*  42 */ { "7e-01", "1", "0.7", "7E-01", "0.7" },
+    /*  43 */ { "7e-04", "0", "0.0007", "7E-04", "0.0007" },
+    /*  44 */ { "7e-05", "0", "7e-05", "7E-05", "7E-05" },
+    /*  45 */ { "7e+00", "7", "7", "7E+00", "7" },
+    /*  46 */ { "7e+01", "67", "7e+01", "7E+01", "7E+01" },
+    /*  47 */ { "7e+02", "667", "7e+02", "7E+02", "7E+02" },
+    /*  48 */ { "7e+03", "6667", "7e+03", "7E+03", "7E+03" },
+    /*  49 */ { "7e+04", "66667", "7e+04", "7E+04", "7E+04" },
+    /*  50 */ { "0.000000e+00", "0.000000", "0", "0.000000E+00", "0" },
+    /*  51 */ { "6.700000e-01", "0.670000", "0.67", "6.700000E-01", "0.67" },
+    /*  52 */ { "6.666667e-01", "0.666667", "0.666667", "6.666667E-01", "0.666667" },
+    /*  53 */ { "6.666667e-04", "0.000667", "0.000666667", "6.666667E-04", "0.000666667" },
+    /*  54 */ { "6.666667e-05", "0.000067", "6.66667e-05", "6.666667E-05", "6.66667E-05" },
+    /*  55 */ { "6.666667e+00", "6.666667", "6.66667", "6.666667E+00", "6.66667" },
+    /*  56 */ { "6.666667e+01", "66.666667", "66.6667", "6.666667E+01", "66.6667" },
+    /*  57 */ { "6.666667e+02", "666.666667", "666.667", "6.666667E+02", "666.667" },
+    /*  58 */ { "6.666667e+03", "6666.666667", "6666.67", "6.666667E+03", "6666.67" },
+    /*  59 */ { "6.666667e+04", "66666.666667", "66666.7", "6.666667E+04", "66666.7" },
+    /*  60 */ { "0.0000e+00", "000.0000", "00000000", "0.0000E+00", "00000000" },
+    /*  61 */ { "6.7000e-01", "000.6700", "00000.67", "6.7000E-01", "00000.67" },
+    /*  62 */ { "6.6667e-01", "000.6667", "000.6667", "6.6667E-01", "000.6667" },
+    /*  63 */ { "6.6667e-04", "000.0007", "0.0006667", "6.6667E-04", "0.0006667" },
+    /*  64 */ { "6.6667e-05", "000.0001", "6.667e-05", "6.6667E-05", "6.667E-05" },
+    /*  65 */ { "6.6667e+00", "006.6667", "0006.667", "6.6667E+00", "0006.667" },
+    /*  66 */ { "6.6667e+01", "066.6667", "00066.67", "6.6667E+01", "00066.67" },
+    /*  67 */ { "6.6667e+02", "666.6667", "000666.7", "6.6667E+02", "000666.7" },
+    /*  68 */ { "6.6667e+03", "6666.6667", "00006667", "6.6667E+03", "00006667" },
+    /*  69 */ { "6.6667e+04", "66666.6667", "6.667e+04", "6.6667E+04", "6.667E+04" },
+};
+
+static void dofptest(int test, double val, char *width, int prec, int *fail)
+{
+    char format[80], result[80];
+    int i;
+
+    for (i = 0; i < 5; i++) {
+        char *fspec;
+        switch (i) {
+        case 0:
+            fspec = "e";
+            break;
+        case 1:
+            fspec = "f";
+            break;
+        case 2:
+            fspec = "g";
+            break;
+        case 3:
+            fspec = "E";
+            break;
+        case 4:
+            fspec = "G";
+            break;
+        }
+
+        if (prec >= 0)
+            BIO_snprintf(format, sizeof(format), "%%%s.%d%s", width, prec,
+                         fspec);
+        else
+            BIO_snprintf(format, sizeof(format), "%%%s%s", width, fspec);
+        BIO_snprintf(result, sizeof(result), format, val);
+
+        if (justprint) {
+            if (i == 0) {
+                printf("    /* %3d */ { \"%s\"", test, result);
+            } else {
+                printf(", \"%s\"", result);
+            }
+        } else {
+            if (strcmp(fpexpected[test][i], result) != 0) {
+                printf("Test %d(%d) failed. Expected \"%s\". Got \"%s\". "
+                       "Format \"%s\"\n", test, i, fpexpected[test][i], result,
+                       format);
+                *fail = 1;
+            }
+        }
+    }
+    if (justprint) {
+        printf(" },\n");
+    }
+}
+
+int main(int argc, char **argv)
+{
+    int test = 0;
+    int i;
+    int fail = 0;
+    int prec;
+    char *width;
+    const double frac = 2.0/3.0;
+    char buf[80];
+
+    if (argc == 2 && strcmp(argv[1], "-expected") == 0) {
+        justprint = 1;
+    }
+
+    CRYPTO_set_mem_debug(1);
+    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
+
+    /* Tests for floating point format specifiers */
+    for (i = 0; i < 7; i++) {
+        switch (i) {
+        case 0:
+            prec = 4;
+            width = "";
+            break;
+        case 1:
+            prec = 5;
+            width = "";
+            break;
+        case 2:
+            prec = 4;
+            width = "12";
+            break;
+        case 3:
+            prec = 5;
+            width = "12";
+            break;
+        case 4:
+            prec = 0;
+            width = "";
+            break;
+        case 5:
+            prec = -1;
+            width = "";
+            break;
+        case 6:
+            prec = 4;
+            width = "08";
+            break;
+        }
+
+        dofptest(test++, 0.0, width, prec, &fail);
+        dofptest(test++, 0.67, width, prec, &fail);
+        dofptest(test++, frac, width, prec, &fail);
+        dofptest(test++, frac / 1000, width, prec, &fail);
+        dofptest(test++, frac / 10000, width, prec, &fail);
+        dofptest(test++, 6.0 + frac, width, prec, &fail);
+        dofptest(test++, 66.0 + frac, width, prec, &fail);
+        dofptest(test++, 666.0 + frac, width, prec, &fail);
+        dofptest(test++, 6666.0 + frac, width, prec, &fail);
+        dofptest(test++, 66666.0 + frac, width, prec, &fail); 
+    }
+
+    /* Test excessively big number. Should fail */
+    if (BIO_snprintf(buf, sizeof(buf), "%f\n", 2 * (double)ULONG_MAX) != -1) {
+        printf("Test %d failed. Unexecpted success return from "
+               "BIO_snprintf()\n", test);
+        fail = 1;
+    }
+
+#ifndef OPENSSL_NO_CRYPTO_MDEBUG
+    if (CRYPTO_mem_leaks_fp(stderr) <= 0)
+        return 1;
+# endif
+
+    if (!justprint) {
+        if (fail) {
+            printf("FAIL\n");
+            return 1;
+        }
+        printf ("PASS\n");
+    }
+    return 0;
+}
+
+
diff --git a/test/build.info b/test/build.info
index c369267..84c881e 100644
--- a/test/build.info
+++ b/test/build.info
@@ -16,7 +16,8 @@ IF[{- !$disabled{tests} -}]
           constant_time_test verify_extra_test clienthellotest \
           packettest asynctest secmemtest srptest memleaktest \
           dtlsv1listentest ct_test threadstest afalgtest d2i_test \
-          ssl_test_ctx_test ssl_test x509aux cipherlist_test asynciotest
+          ssl_test_ctx_test ssl_test x509aux cipherlist_test asynciotest \
+          bioprinttest
 
   SOURCE[aborttest]=aborttest.c
   INCLUDE[aborttest]="{- rel2abs(catdir($builddir,"../include")) -}" ../include
@@ -249,4 +250,8 @@ IF[{- !$disabled{tests} -}]
   SOURCE[asynciotest]=asynciotest.c
   INCLUDE[asynciotest]="{- rel2abs(catdir($builddir,"../include")) -}" ../include
   DEPEND[asynciotest]=../libcrypto ../libssl
+
+  SOURCE[bioprinttest]=bioprinttest.c
+  INCLUDE[bioprinttest]={- rel2abs(catdir($builddir,"../include")) -} ../include
+  DEPEND[bioprinttest]=../libcrypto
 ENDIF
diff --git a/test/recipes/05-test_hmac.t b/test/recipes/90-test_bioprint.t
similarity index 72%
copy from test/recipes/05-test_hmac.t
copy to test/recipes/90-test_bioprint.t
index 2059bcc..b86e828 100644
--- a/test/recipes/05-test_hmac.t
+++ b/test/recipes/90-test_bioprint.t
@@ -1,5 +1,5 @@
 #! /usr/bin/env perl
-# Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
+# Copyright 2016 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
@@ -9,4 +9,4 @@
 
 use OpenSSL::Test::Simple;
 
-simple_test("test_hmac", "hmactest");
+simple_test("test_bioprint", "bioprinttest");


More information about the openssl-commits mailing list