Upgrade to the latest version of tinytest

diff --git a/src/test/test.h b/src/test/test.h
index f7ae46ce6d9f7bebd9f1fa60d1348a566011d899..a053a7ac43d9eeaee66a12a4a938d61399134066 100644 (file)
--- a/src/test/test.h
+++ b/src/test/test.h
@@ -45,7 +45,8 @@
                             _print = tor_malloc(printlen);              \
                             base16_encode(_print, printlen, _value,     \
                                           (len)); },                    \
-                          { tor_free(_print); }                         \
+                          { tor_free(_print); },                        \
+                          TT_EXIT_TEST_FUNCTION                         \
                           );
 
 #define test_memeq(expr1, expr2, len) test_mem_op((expr1), ==, (expr2), len)

diff --git a/src/test/test_addr.c b/src/test/test_addr.c
index 6db4ee24831347945276f74aba46f317fe6c846d..7629d957327140c6e3f085edb3b034af9c1eeed3 100644 (file)
--- a/src/test/test_addr.c
+++ b/src/test/test_addr.c
@@ -74,7 +74,9 @@ test_addr_basic(void)
         cp += 2;                                                 \
         if (i != 15) *cp++ = ':';                                \
       }                                                          \
-    }, { tor_free(_print); }                                     \
+    },                                                           \
+    { tor_free(_print); },                                       \
+    TT_EXIT_TEST_FUNCTION                                        \
   );                                                             \
   STMT_END
 

diff --git a/src/test/test_dir.c b/src/test/test_dir.c
index 4bbf7680cad36e4bc53c5a69620223049b8b223e..04ca29a9fb5a6f512aab2da0ec0f8b39a4b68fd0 100644 (file)
--- a/src/test/test_dir.c
+++ b/src/test/test_dir.c
@@ -298,7 +298,7 @@ test_dir_versions(void)
 
 #define tt_versionstatus_op(vs1, op, vs2)                               \
   tt_assert_test_type(vs1,vs2,#vs1" "#op" "#vs2,version_status_t,       \
-                      (_val1 op _val2),"%d")
+                      (_val1 op _val2),"%d",TT_EXIT_TEST_FUNCTION)
 #define test_v_i_o(val, ver, lst)                                       \
   tt_versionstatus_op(val, ==, tor_version_is_obsolete(ver, lst))
 

diff --git a/src/test/tinytest.c b/src/test/tinytest.c
index 11ffc2fe564e86f8e583160165605ce0e648ac90..8caa4f5453dc5ce6a682e3a898b67267e4f5962c 100644 (file)
--- a/src/test/tinytest.c
+++ b/src/test/tinytest.c
@@ -28,7 +28,11 @@
 #include <string.h>
 #include <assert.h>
 
-#ifdef WIN32
+#ifdef TINYTEST_LOCAL
+#include "tinytest_local.h"
+#endif
+
+#ifdef _WIN32
 #include <windows.h>
 #else
 #include <sys/types.h>
@@ -40,9 +44,6 @@
 #define __attribute__(x)
 #endif
 
-#ifdef TINYTEST_LOCAL
-#include "tinytest_local.h"
-#endif
 #include "tinytest.h"
 #include "tinytest_macros.h"
 
@@ -64,7 +65,7 @@ const char *cur_test_prefix = NULL; /**< prefix of the current test group */
 /** Name of the current test, if we haven't logged is yet. Used for --quiet */
 const char *cur_test_name = NULL;
 
-#ifdef WIN32
+#ifdef _WIN32
 /** Pointer to argv[0] for win32. */
 static const char *commandname = NULL;
 #endif
@@ -103,7 +104,7 @@ static enum outcome
 _testcase_run_forked(const struct testgroup_t *group,
                     const struct testcase_t *testcase)
 {
-#ifdef WIN32
+#ifdef _WIN32
        /* Fork? On Win32?  How primitive!  We'll do what the smart kids do:
           we'll invoke our own exe (whose name we recall from the command
           line) with a command line that tells it to run just the test we
@@ -174,6 +175,7 @@ _testcase_run_forked(const struct testgroup_t *group,
                        exit(1);
                }
                exit(0);
+               return FAIL; /* unreachable */
        } else {
                /* parent */
                int status, r;
@@ -239,6 +241,7 @@ testcase_run_one(const struct testgroup_t *group,
 
        if (opt_forked) {
                exit(outcome==OK ? 0 : (outcome==SKIP?MAGIC_EXITCODE : 1));
+               return 1; /* unreachable */
        } else {
                return (int)outcome;
        }
@@ -287,7 +290,7 @@ tinytest_main(int c, const char **v, struct testgroup_t *groups)
 {
        int i, j, n=0;
 
-#ifdef WIN32
+#ifdef _WIN32
        commandname = v[0];
 #endif
        for (i=1; i<c; ++i) {

diff --git a/src/test/tinytest_demo.c b/src/test/tinytest_demo.c
index bd33cc37facd0c75a53ef88784e8b58259f1806e..8838459bd6c019f53bd5d9073eda55b98b283f7e 100644 (file)
--- a/src/test/tinytest_demo.c
+++ b/src/test/tinytest_demo.c
@@ -1,4 +1,4 @@
-/* tinytest_demo.c -- Copyright 2009 Nick Mathewson
+/* tinytest_demo.c -- Copyright 2009-2010 Nick Mathewson
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -53,7 +53,7 @@ test_strcmp(void *data)
        }
 
        /* Pretty often, calling tt_abort_msg to indicate failure is more
-          heavy-weight than you want.  Instead, just say: */
+          heavy-weight than you want.  Instead, just say: */
        tt_assert(strcmp("testcase", "testcase") == 0);
 
        /* Occasionally, you don't want to stop the current testcase just
@@ -91,7 +91,7 @@ test_strcmp(void *data)
 /* First you declare a type to hold the environment info, and functions to
    set it up and tear it down. */
 struct data_buffer {
-       /* We're just going to have couple of character buffer.  Using
+       /* We're just going to have couple of character buffer.  Using
           setup/teardown functions is probably overkill for this case.
 
           You could also do file descriptors, complicated handles, temporary
@@ -164,7 +164,7 @@ test_memcpy(void *ptr)
 
 /* ============================================================ */
 
-/* Now we need to make sure that our tests get invoked.   First, you take
+/* Now we need to make sure that our tests get invoked.          First, you take
    a bunch of related tests and put them into an array of struct testcase_t.
 */
 
@@ -189,15 +189,15 @@ struct testgroup_t groups[] = {
        /* Every group has a 'prefix', and an array of tests.  That's it. */
        { "demo/", demo_tests },
 
-        END_OF_GROUPS
+       END_OF_GROUPS
 };
 
 
 int
 main(int c, const char **v)
 {
-       /* Finally, just call tinytest_main().  It lets you specify verbose
-          or quiet output with --verbose and --quiet.  You can list
+       /* Finally, just call tinytest_main().  It lets you specify verbose
+          or quiet output with --verbose and --quiet.  You can list
           specific tests:
 
               tinytest-demo demo/memcpy

diff --git a/src/test/tinytest_macros.h b/src/test/tinytest_macros.h
index a7fa64a824531d9d041df7bf1fe11d3a7602508a..032393ccf762500228c6f9647e123cf8a7cec0fa 100644 (file)
--- a/src/test/tinytest_macros.h
+++ b/src/test/tinytest_macros.h
@@ -90,10 +90,10 @@
        TT_STMT_BEGIN                                   \
        if (!(b)) {                                     \
                _tinytest_set_test_failed();            \
-               TT_GRIPE((msg));                        \
+               TT_GRIPE(("%s",msg));                   \
                fail;                                   \
        } else {                                        \
-               TT_BLATHER((msg));                      \
+               TT_BLATHER(("%s",msg));                 \
        }                                               \
        TT_STMT_END
 
@@ -111,7 +111,7 @@
 #define tt_assert(b) tt_assert_msg((b), "assert("#b")")
 
 #define tt_assert_test_fmt_type(a,b,str_test,type,test,printf_type,printf_fmt, \
-                               setup_block,cleanup_block)              \
+    setup_block,cleanup_block,die_on_fail)                             \
        TT_STMT_BEGIN                                                   \
        type _val1 = (type)(a);                                         \
        type _val2 = (type)(b);                                         \
@@ -135,33 +135,50 @@
                cleanup_block;                                          \
                if (!_tt_status) {                                      \
                        _tinytest_set_test_failed();                    \
-                       TT_EXIT_TEST_FUNCTION;                          \
+                       die_on_fail ;                                   \
                }                                                       \
        }                                                               \
        TT_STMT_END
 
-#define tt_assert_test_type(a,b,str_test,type,test,fmt)                        \
+#define tt_assert_test_type(a,b,str_test,type,test,fmt,die_on_fail)    \
        tt_assert_test_fmt_type(a,b,str_test,type,test,type,fmt,        \
-                               {_print=_value;},{})
+           {_print=_value;},{},die_on_fail)
 
 /* Helper: assert that a op b, when cast to type.  Format the values with
  * printf format fmt on failure. */
 #define tt_assert_op_type(a,op,b,type,fmt)                             \
-       tt_assert_test_type(a,b,#a" "#op" "#b,type,(_val1 op _val2),fmt)
+       tt_assert_test_type(a,b,#a" "#op" "#b,type,(_val1 op _val2),fmt, \
+           TT_EXIT_TEST_FUNCTION)
 
 #define tt_int_op(a,op,b)                      \
-       tt_assert_test_type(a,b,#a" "#op" "#b,long,(_val1 op _val2),"%ld")
+       tt_assert_test_type(a,b,#a" "#op" "#b,long,(_val1 op _val2), \
+           "%ld",TT_EXIT_TEST_FUNCTION)
 
 #define tt_uint_op(a,op,b)                                             \
        tt_assert_test_type(a,b,#a" "#op" "#b,unsigned long,            \
-                           (_val1 op _val2),"%lu")
+           (_val1 op _val2),"%lu",TT_EXIT_TEST_FUNCTION)
 
 #define tt_ptr_op(a,op,b)                                              \
        tt_assert_test_type(a,b,#a" "#op" "#b,void*,                    \
-                           (_val1 op _val2),"%p")
+           (_val1 op _val2),"%p",TT_EXIT_TEST_FUNCTION)
 
 #define tt_str_op(a,op,b)                                              \
        tt_assert_test_type(a,b,#a" "#op" "#b,const char *,             \
-                           (strcmp(_val1,_val2) op 0),"<%s>")
+           (strcmp(_val1,_val2) op 0),"<%s>",TT_EXIT_TEST_FUNCTION)
+
+#define tt_want_int_op(a,op,b)                                         \
+       tt_assert_test_type(a,b,#a" "#op" "#b,long,(_val1 op _val2),"%ld",(void)0)
+
+#define tt_want_uint_op(a,op,b)                                                \
+       tt_assert_test_type(a,b,#a" "#op" "#b,unsigned long,            \
+           (_val1 op _val2),"%lu",(void)0)
+
+#define tt_want_ptr_op(a,op,b)                                         \
+       tt_assert_test_type(a,b,#a" "#op" "#b,void*,                    \
+           (_val1 op _val2),"%p",(void)0)
+
+#define tt_want_str_op(a,op,b)                                         \
+       tt_assert_test_type(a,b,#a" "#op" "#b,const char *,             \
+           (strcmp(_val1,_val2) op 0),"<%s>",(void)0)
 
 #endif