tests: added the macros test_fail() and test_success()

These macros allow test programs which run multiple checks,
to report the name of the check failed. Modified mini-server-name
and x509-dn-decode to use the macro.

diff --git a/tests/mini-server-name.c b/tests/mini-server-name.c
index bfd46d5e629935072557ccc1966d6824f88a344c..69d1c41bc1acc693b09ce26e9429366ddaace83a 100644 (file)
--- a/tests/mini-server-name.c
+++ b/tests/mini-server-name.c
@@ -111,7 +111,7 @@ int _gnutls_server_name_set_raw(gnutls_session_t session,
                                gnutls_server_name_type_t type,
                                const void *name, size_t name_length);
 
-static void client(int fd, unsigned raw, const char *name, unsigned name_len)
+static void client(const char *test_name, int fd, unsigned raw, const char *name, unsigned name_len)
 {
        int ret;
        gnutls_anon_client_credentials_t anoncred;
@@ -155,16 +155,16 @@ static void client(int fd, unsigned raw, const char *name, unsigned name_len)
        while (ret < 0 && gnutls_error_is_fatal(ret) == 0);
 
        if (ret < 0) {
-               fail("client: Handshake failed\n");
+               test_fail("Handshake failed\n");
                gnutls_perror(ret);
                exit(1);
        } else {
                if (debug)
-                       success("client: Handshake was completed\n");
+                       test_success("Handshake was completed\n");
        }
 
        if (debug)
-               success("client: TLS version is: %s\n",
+               test_success("TLS version is: %s\n",
                        gnutls_protocol_get_name
                        (gnutls_protocol_get_version(session)));
 
@@ -190,7 +190,7 @@ static void terminate(void)
        exit(1);
 }
 
-static void server(int fd, const char *name, unsigned name_len)
+static void server(const char *test_name, int fd, const char *name, unsigned name_len)
 {
        int ret;
        char buffer[MAX_BUF + 1];
@@ -236,15 +236,15 @@ static void server(int fd, const char *name, unsigned name_len)
        if (ret < 0) {
                close(fd);
                gnutls_deinit(session);
-               fail("server: Handshake has failed (%s)\n\n",
+               test_fail("Handshake has failed (%s)\n\n",
                     gnutls_strerror(ret));
                terminate();
        }
        if (debug)
-               success("server: Handshake was completed\n");
+               test_success("Handshake was completed\n");
 
        if (debug)
-               success("server: TLS version is: %s\n",
+               test_success("TLS version is: %s\n",
                        gnutls_protocol_get_name
                        (gnutls_protocol_get_version(session)));
 
@@ -254,24 +254,24 @@ static void server(int fd, const char *name, unsigned name_len)
        if ((name == NULL || name[0] == 0) && (ret == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE || ret == GNUTLS_E_IDNA_ERROR)) {
                /* expected */
                if (debug)
-                       success("server: empty name matches\n");
+                       test_success("empty name matches\n");
        } else if (ret < 0) {
-               fail("server: server_name: %s/%d\n", gnutls_strerror(ret), ret);
+               test_fail("server_name: %s/%d\n", gnutls_strerror(ret), ret);
        } else {
                if (name == NULL || name[0] == 0) {
-                       fail("server: did not received expected name\n");
+                       test_fail("did not received expected name\n");
                        exit(1);
                }
                if (buffer_size != strlen(buffer)) {
-                       fail("server: received name '%s/%d/%d', with embedded null\n", buffer, (int)buffer_size, (int)strlen(buffer));
+                       test_fail("received name '%s/%d/%d', with embedded null\n", buffer, (int)buffer_size, (int)strlen(buffer));
                        exit(1);
                }
                if (name_len != buffer_size || memcmp(name, buffer, name_len) != 0) {
-                       fail("server: received name '%s/%d', expected '%s/%d'\n", buffer, (int)buffer_size, name, (int)name_len);
+                       test_fail("received name '%s/%d', expected '%s/%d'\n", buffer, (int)buffer_size, name, (int)name_len);
                        exit(1);
                }
                if (debug)
-                       success("server: name matches (%s/%s)\n", buffer, name);
+                       test_success("name matches (%s/%s)\n", buffer, name);
        }
 
 
@@ -288,13 +288,13 @@ static void server(int fd, const char *name, unsigned name_len)
        gnutls_global_deinit();
 
        if (debug)
-               success("server: finished\n");
+               test_success("finished\n");
 }
 
 /* name: the name sent by client
  * server_exp: the name which should be expected by the server to see
  */
-static void start(unsigned raw, const char *name, unsigned len, const char *server_exp, unsigned server_exp_len)
+static void start(const char *test_name, unsigned raw, const char *name, unsigned len, const char *server_exp, unsigned server_exp_len)
 {
        int fd[2];
        int ret;
@@ -308,18 +308,18 @@ static void start(unsigned raw, const char *name, unsigned len, const char *serv
        child = fork();
        if (child < 0) {
                perror("fork");
-               fail("fork");
+               test_fail("fork");
                exit(1);
        }
 
        if (child) {
                /* parent */
                close(fd[1]);
-               server(fd[0], server_exp, server_exp_len);
+               server(test_name, fd[0], server_exp, server_exp_len);
                kill(child, SIGTERM);
        } else {
                close(fd[0]);
-               client(fd[1], raw, name, len);
+               client(test_name, fd[1], raw, name, len);
                exit(0);
        }
 }
@@ -337,14 +337,14 @@ void doit(void)
        signal(SIGCHLD, ch_handler);
        signal(SIGPIPE, SIG_IGN);
 
-       start(0, NULL, 0, NULL, 0);
-       start(0, "", 0, "", 0);
-       start(0, "test.example.com", strlen("test.example.com"), "test.example.com", strlen("test.example.com"));
-       start(0, "longtest.example.com.", strlen("longtest.example.com"), "longtest.example.com.", strlen("longtest.example.com"));
+       start("NULL", 0, NULL, 0, NULL, 0);
+       start("empty", 0, "", 0, "", 0);
+       start("test.example.com", 0, "test.example.com", strlen("test.example.com"), "test.example.com", strlen("test.example.com"));
+       start("longtest.example.com", 0, "longtest.example.com.", strlen("longtest.example.com"), "longtest.example.com.", strlen("longtest.example.com"));
        /* test invalid UTF8 */
-       start(1, "invalid\xff.example.com.", sizeof("invalid\xff.example.com")-1, NULL, 0);
+       start("invalid-utf8", 1, "invalid\xff.example.com.", sizeof("invalid\xff.example.com")-1, NULL, 0);
        /* test embedded NULL */
-       start(1, "invalid\x00.example.com.", sizeof("invalid\x00.example.com")-1, NULL, 0);
+       start("embedded-NULL", 1, "invalid\x00.example.com.", sizeof("invalid\x00.example.com")-1, NULL, 0);
 }
 
 #endif                         /* _WIN32 */

diff --git a/tests/mini-session-verify-function.c b/tests/mini-session-verify-function.c
index 30baf4b4c1837de52b875462abe3ffc1deecce69..791481a7fb070ddc34834e11c2636d20eccbaffd 100644 (file)
--- a/tests/mini-session-verify-function.c
+++ b/tests/mini-session-verify-function.c
@@ -112,7 +112,7 @@ const gnutls_datum_t server_key = { server_key_pem,
 };
 
 static
-void test_success(void)
+void test_success1(void)
 {
        /* Server stuff. */
        gnutls_certificate_credentials_t serverx509cred;
@@ -307,7 +307,7 @@ void doit(void)
 
        test_failure_client();
        test_failure_server();
-       test_success();
+       test_success1();
 
        gnutls_global_deinit();
 }

diff --git a/tests/utils.h b/tests/utils.h
index 213f5834c1ff96c0d92f62d140c9b5d9d4a8c33b..c8efe49b3a8a7c37bb62c9185803515e7ffdf3c7 100644 (file)
--- a/tests/utils.h
+++ b/tests/utils.h
@@ -63,6 +63,13 @@ extern void fail_ignore(const char *format, ...)
 extern void success(const char *format, ...)
     __attribute__ ((format(printf, 1, 2)));
 
+/* assumes test_name is defined */
+#define test_fail(fmt, ...) \
+       fail("%s: "fmt, test_name, ##__VA_ARGS__)
+
+#define test_success(fmt, ...) \
+       success("%s: "fmt, test_name, ##__VA_ARGS__)
+
 extern void c_print(const unsigned char *str, size_t len);
 extern void escapeprint(const char *str, size_t len);
 extern void hexprint(const void *str, size_t len);

diff --git a/tests/x509-dn-decode.c b/tests/x509-dn-decode.c
index b89ef6a32eeced45b6c48a0776b964777db3f5a6..6d47dcc174427472d8a9ad8f674c5e7c5d464c30 100644 (file)
--- a/tests/x509-dn-decode.c
+++ b/tests/x509-dn-decode.c
@@ -34,9 +34,6 @@
 
 #include "utils.h"
 
-#define myfail(fmt, ...) \
-       fail("%s: "fmt, test_name, ##__VA_ARGS__)
-
 static void decode(const char *test_name, const gnutls_datum_t *raw, const char *expected)
 {
        int ret;
@@ -45,29 +42,29 @@ static void decode(const char *test_name, const gnutls_datum_t *raw, const char
 
        ret = gnutls_x509_dn_init(&dn);
        if (ret < 0) {
-               myfail("%s\n", gnutls_strerror(ret));
+               test_fail("%s\n", gnutls_strerror(ret));
        }
 
        ret = gnutls_x509_dn_import(dn, raw);
        if (ret < 0) {
-               myfail("%s\n", gnutls_strerror(ret));
+               test_fail("%s\n", gnutls_strerror(ret));
        }
 
        ret = gnutls_x509_dn_get_str(dn, &out);
        if (ret < 0) {
-               myfail("%s\n", gnutls_strerror(ret));
+               test_fail("%s\n", gnutls_strerror(ret));
        }
 
        if (out.size != strlen(expected)) {
-               myfail("The length of the output (%d) doesn't match the expected (%d)\n", (int)out.size, (int)strlen(expected));
+               test_fail("The length of the output (%d) doesn't match the expected (%d)\n", (int)out.size, (int)strlen(expected));
        }
 
        if (memcmp(out.data, expected, out.size) != 0) {
-               myfail("The string output (%s) doesn't match the expected (%s)\n", (char*)out.data, expected);
+               test_fail("The string output (%s) doesn't match the expected (%s)\n", (char*)out.data, expected);
        }
 
        if (out.data[out.size] != 0) {
-               myfail("The string output isn't null terminated\n");
+               test_fail("The string output isn't null terminated\n");
        }
 
        gnutls_free(out.data);
@@ -85,7 +82,7 @@ static void encode(const char *test_name, const gnutls_datum_t *raw, const char
 
        ret = gnutls_x509_dn_init(&dn);
        if (ret < 0) {
-               myfail("%s\n", gnutls_strerror(ret));
+               test_fail("%s\n", gnutls_strerror(ret));
        }
 
        ret = gnutls_x509_dn_set_str(dn, str, &err);
@@ -95,18 +92,18 @@ static void encode(const char *test_name, const gnutls_datum_t *raw, const char
                        goto cleanup;
 
                if (ret == GNUTLS_E_PARSING_ERROR)
-                       myfail("error: %s: %s\n", gnutls_strerror(ret), err);
+                       test_fail("error: %s: %s\n", gnutls_strerror(ret), err);
                else
-                       myfail("%s\n", gnutls_strerror(ret));
+                       test_fail("%s\n", gnutls_strerror(ret));
        }
 
        if (ret != exp_error) {
-               myfail("unexpected success in encoding (got: %d, exp: %d)\n", ret, exp_error);
+               test_fail("unexpected success in encoding (got: %d, exp: %d)\n", ret, exp_error);
        }
 
        ret = gnutls_x509_dn_export2(dn, GNUTLS_X509_FMT_DER, &out);
        if (ret < 0) {
-               myfail("%s\n", gnutls_strerror(ret));
+               test_fail("%s\n", gnutls_strerror(ret));
        }
 
        if (out.size != raw->size) {
@@ -117,7 +114,7 @@ static void encode(const char *test_name, const gnutls_datum_t *raw, const char
                                fprintf(stderr, "\\x%.2x", (unsigned)out.data[i]);
                        fprintf(stderr, "\n");
                }
-               myfail("The length of the output (%d) doesn't match the expected (%d)\n", (int)out.size, (int)raw->size);
+               test_fail("The length of the output (%d) doesn't match the expected (%d)\n", (int)out.size, (int)raw->size);
        }
 
        if (memcmp(out.data, raw->data, out.size) != 0) {
@@ -128,7 +125,7 @@ static void encode(const char *test_name, const gnutls_datum_t *raw, const char
                                fprintf(stderr, "\\x%.2x", (unsigned)out.data[i]);
                        fprintf(stderr, "\n");
                }
-               myfail("The raw output doesn't match the expected\n");
+               test_fail("The raw output doesn't match the expected\n");
        }
 
        gnutls_free(out.data);