From: Richard Levitte Date: Fri, 5 Jun 2020 14:55:42 +0000 (+0200) Subject: TESTUTIL: Separate TAP output and other output by BIO filter X-Git-Tag: openssl-3.0.0-alpha4~167 X-Git-Url: https://git.librecmc.org/?a=commitdiff_plain;h=8dce4aa2d974fa357bb3f7d8a77e581d487de732;hp=591315297ec45ada0d31f057c4f6cff7f572bf3e;p=oweals%2Fopenssl.git TESTUTIL: Separate TAP output and other output by BIO filter Output that's supposed to be understood by a TAP parser gets its own BIOs (|tap_out| and |tap_err|), and is only used internally within testutils. |bio_out| and |bio_err| is now only used for output that shouldn't be parsed by the TAP parser, and all output written to those BIOs are therefore always made to look like comments (it gets prefixed with "# "). Indentation and prefixing with "# " is reworked to use BIO_f_prefix(), which allows us to throw away the internal BIO_f_tap(). The indentation level is now adjusted via a special function. Fixes #12054 Reviewed-by: Matt Caswell (Merged from https://github.com/openssl/openssl/pull/12057) --- diff --git a/test/build.info b/test/build.info index 868b8ebefa..6256a34c91 100644 --- a/test/build.info +++ b/test/build.info @@ -20,7 +20,7 @@ IF[{- !$disabled{tests} -}] LIBS{noinst,has_main}=libtestutil.a SOURCE[libtestutil.a]=testutil/basic_output.c testutil/output_helpers.c \ testutil/driver.c testutil/tests.c testutil/cb.c testutil/stanza.c \ - testutil/format_output.c testutil/tap_bio.c \ + testutil/format_output.c \ testutil/test_cleanup.c testutil/main.c testutil/testutil_init.c \ testutil/options.c testutil/test_options.c \ testutil/apps_mem.c testutil/random.c $LIBAPPSSRC diff --git a/test/testutil/basic_output.c b/test/testutil/basic_output.c index 93afcd0fd1..bbed57c55a 100644 --- a/test/testutil/basic_output.c +++ b/test/testutil/basic_output.c @@ -14,27 +14,51 @@ #include #include +/* These are available for any test program */ BIO *bio_out = NULL; BIO *bio_err = NULL; +/* These are available for TAP output only (internally) */ +static BIO *tap_out = NULL; +static BIO *tap_err = NULL; + void test_open_streams(void) { - bio_out = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT); - bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT); + tap_out = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT); + tap_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT); #ifdef __VMS - bio_out = BIO_push(BIO_new(BIO_f_linebuffer()), bio_out); - bio_err = BIO_push(BIO_new(BIO_f_linebuffer()), bio_err); + tap_out = BIO_push(BIO_new(BIO_f_linebuffer()), tap_out); + tap_err = BIO_push(BIO_new(BIO_f_linebuffer()), tap_err); #endif - bio_err = BIO_push(BIO_new(BIO_f_tap()), bio_err); + tap_out = BIO_push(BIO_new(BIO_f_prefix()), tap_out); + tap_err = BIO_push(BIO_new(BIO_f_prefix()), tap_err); + + bio_out = BIO_push(BIO_new(BIO_f_prefix()), tap_out); + bio_err = BIO_push(BIO_new(BIO_f_prefix()), tap_err); + BIO_set_prefix(bio_out, "# "); + BIO_set_prefix(bio_err, "# "); OPENSSL_assert(bio_out != NULL); OPENSSL_assert(bio_err != NULL); } +void test_adjust_streams_tap_level(int level) +{ + BIO_set_indent(tap_out, level); + BIO_set_indent(tap_err, level); +} + void test_close_streams(void) { - BIO_free_all(bio_out); - BIO_free_all(bio_err); + /* + * The rest of the chain is freed by the BIO_free_all() calls below, so + * we only need to free the last one in the bio_out and bio_err chains. + */ + BIO_free(bio_out); + BIO_free(bio_err); + + BIO_free_all(tap_out); + BIO_free_all(tap_err); } int test_vprintf_stdout(const char *fmt, va_list ap) @@ -56,3 +80,23 @@ int test_flush_stderr(void) { return BIO_flush(bio_err); } + +int test_vprintf_tapout(const char *fmt, va_list ap) +{ + return BIO_vprintf(tap_out, fmt, ap); +} + +int test_vprintf_taperr(const char *fmt, va_list ap) +{ + return BIO_vprintf(tap_err, fmt, ap); +} + +int test_flush_tapout(void) +{ + return BIO_flush(tap_out); +} + +int test_flush_taperr(void) +{ + return BIO_flush(tap_err); +} diff --git a/test/testutil/output.h b/test/testutil/output.h index def76af151..8da73e2ac7 100644 --- a/test/testutil/output.h +++ b/test/testutil/output.h @@ -35,20 +35,31 @@ */ void test_open_streams(void); void test_close_streams(void); +void test_adjust_streams_tap_level(int level); /* The following ALL return the number of characters written */ int test_vprintf_stdout(const char *fmt, va_list ap) ossl_test__attr__((__format__(ossl_test__printf__, 1, 0))); +int test_vprintf_tapout(const char *fmt, va_list ap) + ossl_test__attr__((__format__(ossl_test__printf__, 1, 0))); int test_vprintf_stderr(const char *fmt, va_list ap) ossl_test__attr__((__format__(ossl_test__printf__, 1, 0))); +int test_vprintf_taperr(const char *fmt, va_list ap) + ossl_test__attr__((__format__(ossl_test__printf__, 1, 0))); /* These return failure or success */ int test_flush_stdout(void); +int test_flush_tapout(void); int test_flush_stderr(void); +int test_flush_taperr(void); /* Commodity functions. There's no need to override these */ int test_printf_stdout(const char *fmt, ...) ossl_test__attr__((__format__(ossl_test__printf__, 1, 2))); +int test_printf_tapout(const char *fmt, ...) + ossl_test__attr__((__format__(ossl_test__printf__, 1, 2))); int test_printf_stderr(const char *fmt, ...) ossl_test__attr__((__format__(ossl_test__printf__, 1, 2))); +int test_printf_taperr(const char *fmt, ...) + ossl_test__attr__((__format__(ossl_test__printf__, 1, 2))); # undef ossl_test__printf__ # undef ossl_test__attr__ diff --git a/test/testutil/output_helpers.c b/test/testutil/output_helpers.c index eb614f1281..64e99dac62 100644 --- a/test/testutil/output_helpers.c +++ b/test/testutil/output_helpers.c @@ -32,3 +32,27 @@ int test_printf_stderr(const char *fmt, ...) return ret; } + +int test_printf_tapout(const char *fmt, ...) +{ + va_list ap; + int ret; + + va_start(ap, fmt); + ret = test_vprintf_tapout(fmt, ap); + va_end(ap); + + return ret; +} + +int test_printf_taperr(const char *fmt, ...) +{ + va_list ap; + int ret; + + va_start(ap, fmt); + ret = test_vprintf_taperr(fmt, ap); + va_end(ap); + + return ret; +} diff --git a/test/testutil/tap_bio.c b/test/testutil/tap_bio.c deleted file mode 100644 index f3ee2787d2..0000000000 --- a/test/testutil/tap_bio.c +++ /dev/null @@ -1,155 +0,0 @@ -/* - * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved. - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. - * - * Licensed under the Apache License 2.0 (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 -#include "tu_local.h" - -static int tap_write_ex(BIO *b, const char *buf, size_t size, size_t *in_size); -static int tap_read_ex(BIO *b, char *buf, size_t size, size_t *out_size); -static int tap_puts(BIO *b, const char *str); -static int tap_gets(BIO *b, char *str, int size); -static long tap_ctrl(BIO *b, int cmd, long arg1, void *arg2); -static int tap_new(BIO *b); -static int tap_free(BIO *b); -static long tap_callback_ctrl(BIO *h, int cmd, BIO_info_cb *fp); - -const BIO_METHOD *BIO_f_tap(void) -{ - static BIO_METHOD *tap = NULL; - - if (tap == NULL) { - tap = BIO_meth_new(BIO_TYPE_START | BIO_TYPE_FILTER, "tap"); - if (tap != NULL) { - BIO_meth_set_write_ex(tap, tap_write_ex); - BIO_meth_set_read_ex(tap, tap_read_ex); - BIO_meth_set_puts(tap, tap_puts); - BIO_meth_set_gets(tap, tap_gets); - BIO_meth_set_ctrl(tap, tap_ctrl); - BIO_meth_set_create(tap, tap_new); - BIO_meth_set_destroy(tap, tap_free); - BIO_meth_set_callback_ctrl(tap, tap_callback_ctrl); - } - } - return tap; -} - -static int tap_new(BIO *b) -{ - BIO_set_data(b, NULL); - BIO_set_init(b, 1); - return 1; -} - -static int tap_free(BIO *b) -{ - if (b == NULL) - return 0; - BIO_set_data(b, NULL); - BIO_set_init(b, 0); - return 1; -} - -static int tap_read_ex(BIO *b, char *buf, size_t size, size_t *out_size) -{ - BIO *next = BIO_next(b); - int ret = 0; - - ret = BIO_read_ex(next, buf, size, out_size); - BIO_clear_retry_flags(b); - BIO_copy_next_retry(b); - return ret; -} - -/* - * Output a string to the specified bio and return 1 if successful. - */ -static int write_string(BIO *b, const char *buf, size_t n) -{ - size_t m; - - return BIO_write_ex(b, buf, n, &m) != 0 && m == n; -} - -/* - * Write some data. - * - * This function implements a simple state machine that detects new lines. - * It indents the output and prefixes it with a '#' character. - * - * It returns the number of input characters that were output in in_size. - * More characters than this will likely have been output however any calling - * code will be unable to correctly assess the actual number of characters - * emitted and would be prone to failure if the actual number were returned. - * - * The BIO_data field is used as our state. If it is NULL, we've just - * seen a new line. If it is not NULL, we're processing characters in a line. - */ -static int tap_write_ex(BIO *b, const char *buf, size_t size, size_t *in_size) -{ - static char empty[] = ""; - BIO *next = BIO_next(b); - size_t i; - int j; - - for (i = 0; i < size; i++) { - if (BIO_get_data(b) == NULL) { - BIO_set_data(b, empty); - for (j = 0; j < subtest_level(); j++) - if (!write_string(next, " ", 1)) - goto err; - if (!write_string(next, "# ", 2)) - goto err; - } - if (!write_string(next, buf + i, 1)) - goto err; - if (buf[i] == '\n') - BIO_set_data(b, NULL); - } - *in_size = i; - return 1; - -err: - *in_size = i; - return 0; -} - -static long tap_ctrl(BIO *b, int cmd, long num, void *ptr) -{ - BIO *next = BIO_next(b); - - switch (cmd) { - case BIO_CTRL_RESET: - BIO_set_data(b, NULL); - break; - - default: - break; - } - return BIO_ctrl(next, cmd, num, ptr); -} - -static long tap_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp) -{ - return BIO_callback_ctrl(BIO_next(b), cmd, fp); -} - -static int tap_gets(BIO *b, char *buf, int size) -{ - return BIO_gets(BIO_next(b), buf, size); -} - -static int tap_puts(BIO *b, const char *str) -{ - size_t m; - - if (!tap_write_ex(b, str, strlen(str), &m)) - return 0; - return m; -}