Changeset 6816

Timestamp:

09/09/10 22:40:57 (17 months ago)

Author:

westram

Message:

• unit-test improvements (merged [6757] [6758] [6759] [6760] [6761] [6762] [6764] [6791] [6795] [6798] [6799] [6800] [6801] [6802] [6809] [6810])
  • moved file compare to test_unit.h
  • fake report for skipped tests
  • added templates for char compare
  • perform minihexdump
  • flush output
  • added
    • TEST_ASSERT_FILES_EQUAL__BROKEN
    • TEST_ASSERT_ZERO_OR_SHOW_ERRNO
  • create a fake.patch if there are no changes
  • all code affecting assertions in UNIT_TESTS-mode went to test_global.h
    • overwrites arb_assert()
  • undefine UNIT_TESTS for GDE submakefiles (foreign code there)
  • arb_test::FlushedOutput::errorf raises assertion itself
  • test against I/O errors
  • moved test code
    • into class StaticCode?: class w/o functionality, only holds global static code.
    • assertfailmsg -> GlobalTestData?
  • refactored message printing
  • unit-tester switches to run directory itself
    • eliminates path hack for valgrind
  • control leak-check by variable
  • added global test-environment (does nothing yet)

Location:

trunk

Files:

• ARBDB/ad_save_load.cxx (modified) (3 diffs)
• ARBDB/arb_assert.h (modified) (1 diff)
• GDE/Makefile (modified) (1 diff)
• SOURCE_TOOLS/arb_create_patch.sh (modified) (2 diffs)
• SOURCE_TOOLS/generate_all_links.sh (modified) (1 diff)
• UNIT_TESTER (modified) (1 prop)
• UNIT_TESTER/Makefile (modified) (2 diffs)
• UNIT_TESTER/Makefile.test (modified) (6 diffs)
• UNIT_TESTER/TestEnvironment.cxx (copied) (copied from branches/refactor/UNIT_TESTER/TestEnvironment.cxx)
• UNIT_TESTER/UnitTester.cxx (modified) (4 diffs)
• UNIT_TESTER/UnitTester.hxx (modified) (2 diffs)
• UNIT_TESTER/test_global.h (copied) (copied from branches/refactor/UNIT_TESTER/test_global.h) (2 diffs)
• UNIT_TESTER/test_unit.h (modified) (14 diffs)

trunk/ARBDB/ad_save_load.cxx

@@ -1293 +1293 @@
 #include <test_unit.h>
 
-static bool files_are_equal(const char *file1, const char *file2) {
-    GB_ERROR   error     = NULL;
-    FILE      *fp1       = fopen(file1, "rb");
-
-    // @@@ FIXME:  use GB_IO_error() here later
-    if (!fp1) error = GBS_global_string("can't open '%s'", file1);
-    else {
-        FILE *fp2 = fopen(file2, "rb");
-        if (!fp2) error = GBS_global_string("can't open '%s'", file2);
-        else {
-            const int BLOCKSIZE = 4096;
-            char *buf1 = (char*)malloc(BLOCKSIZE);
-            char *buf2 = (char*)malloc(BLOCKSIZE);
-
-            while (!error) {
-                int read1 = fread(buf1, 1, BLOCKSIZE, fp1);
-                int read2 = fread(buf2, 1, BLOCKSIZE, fp2);
-
-                if (read1 != read2) error = "filesizes differ";
-                else {
-                    if (!read1) break; // done
-                    if (memcmp(buf1, buf2, read1) != 0) error = "content differs";
-                }
-            }
-            free(buf2);
-            free(buf1);
-            fclose(fp2);
-        }
-        fclose(fp1);
-    }
-
-    if (error) TEST_WARNING("%s", GBS_global_string("files_are_equal(%s, %s): %s", file1, file2, error));
-    return !error;
-}
-
 #define SAVE_AND_COMPARE(gbd, save_as, savetype, compare_with) \
     TEST_ASSERT_NO_ERROR(GB_save_as(gbd, save_as, savetype));  \
-    TEST_ASSERT(files_are_equal(save_as, compare_with))
+    TEST_ASSERT_FILES_EQUAL(save_as, compare_with)
 
 static GB_ERROR modify_db(GBDATA *gb_main) {
@@ -1342 +1307 @@
         if (!gb_entry) error = GB_await_error();
         else    error        = GB_write_string(gb_entry, "text");
+        // else    error        = GB_write_string(gb_entry, "bla"); // provoke error in file compare
     }
     return error;
@@ -1425 +1391 @@
 #endif // TEST_AUTO_UPDATE
 
-        TEST_ASSERT(files_are_equal("TEST_loadsave_quick.a00", "a2b.a00"));
-        TEST_ASSERT(files_are_equal("a2b.a00", "b2b.a00"));
+        TEST_ASSERT_FILES_EQUAL("TEST_loadsave_quick.a00", "a2b.a00");
+        TEST_ASSERT_FILES_EQUAL("a2b.a00", "b2b.a00");
 
         TEST_ASSERT_NO_ERROR(GB_save_quick_as(gb_a2b, "a2b.arb"));

trunk/ARBDB/arb_assert.h

@@ -180 +180 @@
 
 #if (UNIT_TESTS == 1)
-# if defined(DEVEL_RELEASE)
-#  error Unit testing not allowed in release
-# else
-
-#  ifdef __cplusplus
-
-#ifndef _CPP_CSTDLIB
-#include <cstdlib>
-#endif
-
-namespace arb_test {
-    class GlobalTestData {
-        GlobalTestData()
-            : show_warnings(true),
-              assertion_failed(false),
-              warnings(0)
-        {}
-
-        static GlobalTestData *instance(bool erase) {
-            static GlobalTestData *data = 0; // singleton
-            if (erase) {
-                delete data;
-                data = 0;
-            }
-            else {
-                if (!data) data = new GlobalTestData;
-            }
-            return data;
-        }
-
-    public:
-        bool show_warnings;
-        bool assertion_failed;
-
-        // counters
-        size_t warnings;
-
-        static GlobalTestData& get_instance() { return *instance(false); }
-        static void erase_instance() { instance(true); }
-    };
-
-    inline GlobalTestData& test_data() { return GlobalTestData::get_instance(); }
-};
-
-#   define ASSERTION_HAS_FAILED() arb_test::test_data().assertion_failed = true  
-
-#  else
-#   define ASSERTION_HAS_FAILED() // impossible in C
-#  endif
-
-#  define test_assert(cond)                                     \
-    do {                                                        \
-        if (!(cond)) {                                          \
-            fflush(stdout);                                     \
-            fflush(stderr);                                     \
-            fprintf(stderr, "%s:%i: Assertion '%s' failed\n",   \
-                    __FILE__, __LINE__, #cond);                 \
-            fflush(stderr);                                     \
-            ASSERTION_HAS_FAILED();                             \
-            ARB_SIGSEGV(0);                                     \
-        }                                                       \
-    } while(0)
-
-#  if defined(ASSERTION_USED)
-#   undef arb_assert
-#   define arb_assert(cond) test_assert(cond)
-#  endif
-
-# endif
+#ifndef TEST_GLOBAL_H
+#include <test_global.h> // overrides arb_assert()!
+#endif
 #endif
 

trunk/GDE/Makefile

@@ -39 +39 @@
 
 # --------------------------------------------------------------------------------
-# no warnings in this subtree
+# modify cflags for submakefiles 
 
-RAISE_WARNINGS=0
+RAISE_WARNINGS=0# no warnings in this subtree
+UNIT_TESTS=0# no warnings in this subtree
+
+sub_cflags:=$(cflags)
 
 ifeq ('$(RAISE_WARNINGS)','0')
-sub_cflags:=$(subst -W -Wall,-w,$(cflags))
-else
-sub_cflags:=$(cflags)
+sub_cflags:=$(subst -W -Wall,-w,$(sub_cflags))
+endif
+ifeq ('$(UNIT_TESTS)','0')
+sub_cflags:=$(subst -DUNIT_TESTS,,$(sub_cflags))
 endif
 

trunk/SOURCE_TOOLS/arb_create_patch.sh

@@ -17 +17 @@
             PATCHNAME=${NAME}_$DATE
             PATCH=$PATCHDIR/$PATCHNAME.patch
+            FAKEPATCH=$PATCHDIR/fake.patch
+            RECENT_PATCH=$ARBHOME/latest.patch
 
             cd $ARBHOME
@@ -24 +26 @@
                 if [ ! -s $PATCH ]; then
                     rm $PATCH
+                    if [ ! -e $FAKEPATCH ]; then
+                        echo "Index: No changes" > $FAKEPATCH
+                        echo "===================================================================" >> $FAKEPATCH
+                    fi
+                    ln --force $FAKEPATCH $RECENT_PATCH
+                    touch $FAKEPATCH
                     echo "No patch generated (no diff)"
                 else
-                    RECENT_PATCH=$ARBHOME/latest.patch
                     ln --force $PATCH $RECENT_PATCH
                     ls -alh $PATCH $RECENT_PATCH

trunk/SOURCE_TOOLS/generate_all_links.sh

@@ -254 +254 @@
 symlink_file ../STAT/st_window.hxx INCLUDE/st_window.hxx &&
 symlink_file ../UNIT_TESTER/test_unit.h INCLUDE/test_unit.h &&
+symlink_file ../UNIT_TESTER/test_global.h INCLUDE/test_global.h &&
 symlink_file ../WINDOW/aw_advice.hxx INCLUDE/aw_advice.hxx &&
 symlink_file ../WINDOW/aw_awars.hxx INCLUDE/aw_awars.hxx &&

trunk/UNIT_TESTER

@@ -5 +5 @@
 *.gcno
 logs
+test_environment

@@ -5 +5 @@
 *.gcno
 logs
+test_environment

trunk/UNIT_TESTER/Makefile

@@ -2 +2 @@
 .SUFFIXES: .o .cxx .depend
 
-CPP_OBJECTS = \
+TESTER_OBJECTS = \
         UnitTester.o \
 
+GLOBAL_OBJECTS = \
+        TestEnvironment.o \
 
-$(MAIN): $(CPP_OBJECTS)
-        $(LINK_STATIC_LIB) $(MAIN) $(CPP_OBJECTS)
+CPP_OBJECTS = $(TESTER_OBJECTS) $(GLOBAL_OBJECTS)
+
+$(MAIN): $(TESTER_OBJECTS) test_environment
+        $(LINK_STATIC_LIB) $(MAIN) $(TESTER_OBJECTS)
+
+test_environment: $(GLOBAL_OBJECTS) $(TESTER_OBJECTS)
+        $(LINK_EXECUTABLE) test_environment $(GLOBAL_OBJECTS) $(TESTER_OBJECTS) $(LIBPATH) $(ARBDB_LIB)  
+
 .cxx.o:
         $(CPP) $(cflags) -c $<  $(CPPINCLUDES)
 
 clean:
-        rm -f $(CPP_OBJECTS) 
+        rm -f $(CPP_OBJECTS) *.a test_environment 
         $(MAKE) -f Makefile.test clean
+
 
 DEPENDS = $(CPP_OBJECTS:.o=.depend)
@@ -32 +41 @@
 # For formatting issues see SOURCE_TOOLS/fix_depends.pl
 
+TestEnvironment.o: test_global.h
+TestEnvironment.o: test_unit.h
+TestEnvironment.o: UnitTester.hxx
+TestEnvironment.o: $(ARBHOME)/INCLUDE/ad_k_prot.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/ad_prot.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/arb_assert.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/arb_core.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/arb_defs.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/arb_error.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/arb_str.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/arbdb.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/arbdb_base.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/arbtools.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/attributes.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/dupstr.h
+TestEnvironment.o: $(ARBHOME)/INCLUDE/smartptr.h
+
+UnitTester.o: test_global.h
 UnitTester.o: test_unit.h
 UnitTester.o: UnitTester.hxx

trunk/UNIT_TESTER/Makefile.test

@@ -15 +15 @@
 # ----------------------------------------------------------
 
+# @@@ valgrind makes tests fail atm
+# (most likely two pt-servers try to start parallel on the same port)
+
 VALGRIND=0# only test
 #VALGRIND=1# run valgrind after sucessful test
 #VALGRIND=2# run valgrind before test (useful if test traps w/o any helpful information)
+
+#CHECK_LEAKS=0# check no leaks
+CHECK_LEAKS=1# check definite leaks
+#CHECK_LEAKS=2# check reachable leaks
 
 # ----------------------------------------------------------
@@ -29 +36 @@
 #
 RESTRICT_LIB=# run all tests
+#RESTRICT_LIB=AWTC# test only this library
 #RESTRICT_LIB=mkptypes# test only these libraries
 #RESTRICT_LIB=client:arb_probe:AWTC# test only these libraries
@@ -81 +89 @@
 
 DESTDIR=tests
-RUNDIR=run
-RUN2HERE=..# prefix from RUNDIR to here (UNIT_TESTER)
+RUNDIR=run# see also UnitTester.cxx@chdir
 
 SYMLIST=$(DESTDIR)/$(UNIQUE_NAME).sym
@@ -152 +159 @@
         @echo "LINKDEPS       ='$(LINKDEPS)'"
 
+ifeq ($(CHECK_LEAKS),0)
+        LEAKS:=
+else
+ifeq ($(CHECK_LEAKS),1)
+        LEAKS:=-l
+else
+        LEAKS:=-l -r
+endif
+endif
+
 valgrind:
         echo "Valgrinding.."
-        cd $(RUNDIR);$(ARBHOME)/SOURCE_TOOLS/arb_valgrind -q -l -r -c 15 $(RUN2HERE)/$(TEST_EXE)
+        $(ARBHOME)/SOURCE_TOOLS/arb_valgrind -q $(LEAKS) -c 15 $(TEST_EXE)
 
 perform_test: $(TEST_EXE)
@@ -161 +178 @@
         $(MAKE) -f Makefile.test valgrind
 endif
-        cd $(RUNDIR);$(RUN2HERE)/$(TEST_EXE)
+        $(TEST_EXE) 
 ifeq ($(COVERAGE),1)
         @echo "-------------------- test-coverage for $(UNITLIBNAME)"
@@ -173 +190 @@
 
 skip_test:
-        @echo "unit-tests completely skipped for '$(UNITLIBNAME)'"
+        @echo "UnitTester: $(UNITLIBNAME) tests=0 (skipped via RESTRICT_LIB)"
 
 # --------------------

trunk/UNIT_TESTER/UnitTester.cxx

@@ -51 +51 @@
 // --------------------------------------------------------------------------------
 
-enum UnitTestResult {
-    TEST_OK,
-    TEST_TRAPPED,
-};
-
 static const char *readable_result[] = {
     "OK",
@@ -79 +74 @@
 #define SECOND 1000000
 
-static UnitTestResult execute_guarded(UnitTest_function fun, long *duration_usec) {
+UnitTestResult execute_guarded(UnitTest_function fun, long *duration_usec) {
     SigHandler old_handler = INSTALL_SIGHANDLER(SIGSEGV, UNITTEST_sigsegv_handler, "execute_guarded");
     
@@ -215 +210 @@
     // it is invoked from code generated by sym2testcode.pl@InvokeUnitTester
 
+    TEST_ASSERT_ZERO_OR_SHOW_ERRNO(chdir("run"));
+    
     size_t tests  = 0;
     size_t passed = 0;
@@ -238 +235 @@
                              duration_ms, global.warnings));
     }
-    
+
     arb_test::GlobalTestData::erase_instance();
     exit(tests == passed ? EXIT_SUCCESS : EXIT_FAILURE);

trunk/UNIT_TESTER/UnitTester.hxx

@@ -24 +24 @@
     const char        *location;
 };
+enum UnitTestResult {
+    TEST_OK,
+    TEST_TRAPPED,
+};
 
 struct UnitTester {
@@ -29 +33 @@
 };
 
+UnitTestResult execute_guarded(UnitTest_function fun, long *duration_usec);
+
 #else
 #error UnitTester.hxx included twice

trunk/UNIT_TESTER/test_global.h

@@ -20 +20 @@
 #include <cstdio>
 #endif
+#ifndef _CPP_CERRNO
+#include <cerrno>
+#endif
+#ifndef _CPP_CSTRING
+#include <cstring>
+#endif
 
+#if (UNIT_TESTS == 1)
+
+# if defined(DEVEL_RELEASE)
+#  error Unit testing not allowed in release
+# endif
+
+# ifdef __cplusplus
+
+#  define SET_ASSERTION_FAILED_FLAG() arb_test::test_data().assertion_failed = true  
+#  define PRINT_ASSERTION_FAILED_MSG(cond) arb_test::GlobalTestData::assertfailmsg(__FILE__, __LINE__, #cond)  
+
+# else
+#  define SET_ASSERTION_FAILED_FLAG() // impossible in C (assertions in C code will be handled like normal SEGV)
+#  define PRINT_ASSERTION_FAILED_MSG(cond)                      \
+    do {                                                        \
+        fflush(stdout);                                         \
+        fflush(stderr);                                         \
+        fprintf(stderr, "%s:%i: Assertion '%s' failed [C]\n",   \
+                __FILE__, __LINE__, #cond);                     \
+        fflush(stderr);                                         \
+    } while(0)
+# endif
+
+# define TRIGGER_ASSERTION()                            \
+    do {                                                \
+        SET_ASSERTION_FAILED_FLAG();                    \
+        ARB_SIGSEGV(0);                                 \
+    } while(0)
 
 namespace arb_test {
+    class FlushedOutputNoLF {
+        inline void flushall() { fflush(stdout); fflush(stderr); }
+    public:
+        FlushedOutputNoLF() { flushall(); }
+        ~FlushedOutputNoLF() { flushall(); }
+    };
+    struct FlushedOutput : public FlushedOutputNoLF {
+        ~FlushedOutput() { fputc('\n', stderr); }
+    };
+
     class GlobalTestData {
         GlobalTestData()
@@ -51 +95 @@
         static GlobalTestData& get_instance() { return *instance(false); }
         static void erase_instance() { instance(true); }
+        
+        static void assertfailmsg(const char *filename, int lineno, const char *condition) {
+            FlushedOutput yes;
+            fprintf(stderr, "%s:%i: Assertion '%s' failed", filename, lineno, condition);
+        }
     };
 
     inline GlobalTestData& test_data() { return GlobalTestData::get_instance(); }
+};
 
-    
-    class FlushedOutput {
-        inline void flushall() { fflush(stdout); fflush(stderr); }
-    public:
-        FlushedOutput() { flushall(); }
-        ~FlushedOutput() { flushall(); }
-        
-#define VPRINTFORMAT(format) do { va_list parg; va_start(parg, format); vfprintf(stderr, format, parg); va_end(parg); } while(0)
-    
-        static void printf(const char *format, ...) __attribute__((format(printf, 1, 2))) {
-            FlushedOutput yes;
-            VPRINTFORMAT(format);
-        }
-        static void messagef(const char *filename, int lineno, const char *format, ...) __attribute__((format(printf, 3, 4))) {
-            FlushedOutput yes;
-            fprintf(stderr, "%s:%i: ", filename, lineno);
-            fputc('\n', stderr);
-            VPRINTFORMAT(format);
-        }
-        static void warningf(const char *filename, int lineno, const char *format, ...) __attribute__((format(printf, 3, 4))) {
-            GlobalTestData& global = test_data();
-            if (global.show_warnings) {
-                FlushedOutput yes;
-                fprintf(stderr, "%s:%i: Warning: ", filename, lineno);
-                VPRINTFORMAT(format);
-                fputc('\n', stderr);
-                global.warnings++;
-            }
-        }
-        static void errorf(const char *filename, int lineno, const char *format, ...) __attribute__((format(printf, 3, 4))) {
-            FlushedOutput yes;
-            fprintf(stderr, "%s:%i: Error: ", filename, lineno);
-            VPRINTFORMAT(format);
-            fputc('\n', stderr);
-        }
-#undef VPRINTFORMAT
-    };
+// --------------------------------------------------------------------------------
 
-};
+// special assert for unit tests (additionally to SEGV it sets a global flag)
+# define test_assert(cond)                      \
+    do {                                        \
+        if (!(cond)) {                          \
+            PRINT_ASSERTION_FAILED_MSG(cond);   \
+            TRIGGER_ASSERTION();                \
+        }                                       \
+    } while(0)
+
+
+// redefine arb_assert with test_assert when compiling for unit tests
+# if defined(ASSERTION_USED)
+#  undef arb_assert
+#  define arb_assert(cond) test_assert(cond)
+# endif
+
+#else // UNIT_TESTS != 1
+#error test_global.h may only be included if UNIT_TESTS is 1
+#endif
 
 #else

trunk/UNIT_TESTER/test_unit.h

@@ -19 +19 @@
 #include <cstdarg>
 #endif
+#ifndef ERRNO_H
+#include <errno.h>
+#endif
 
 #define ENABLE_CRASH_TESTS // comment out this line to get rid of provoked SEGVs (e.g. while debugging test-code)
@@ -33 +36 @@
 
 namespace arb_test {
-    class FlushedOutput {
-        inline void flushall() { fflush(stdout); fflush(stderr); }
+
+    class StaticCode {
+        static void vcompiler_msg(const char *filename, int lineno, const char *message_type, const char *format, va_list parg) {
+            fprintf(stderr, "%s:%i: ", filename, lineno);
+            if (message_type) fprintf(stderr, "%s: ", message_type);
+            vfprintf(stderr, format, parg);
+        }
+
+#define WITHVALISTFROM(format,CODE)             do { va_list parg; va_start(parg, format); CODE; va_end(parg); } while(0)
+#define VPRINTFORMAT(format)                    WITHVALISTFROM(format, vfprintf(stderr, format, parg))
+#define VCOMPILERMSG(file,line,msgtype,format)  WITHVALISTFROM(format, vcompiler_msg(file, line, msgtype, format, parg))
+        
     public:
-        FlushedOutput() { flushall(); }
-        ~FlushedOutput() { flushall(); }
-        
-#define VPRINTFORMAT(format) do { va_list parg; va_start(parg, format); vfprintf(stderr, format, parg); va_end(parg); } while(0)
-    
+
         static void printf(const char *format, ...) __attribute__((format(printf, 1, 2))) {
-            FlushedOutput yes;
-            VPRINTFORMAT(format);
-        }
-        static void messagef(const char *filename, int lineno, const char *format, ...) __attribute__((format(printf, 3, 4))) {
-            FlushedOutput yes;
-            fprintf(stderr, "%s:%i: ", filename, lineno);
+            FlushedOutputNoLF yes;
             VPRINTFORMAT(format);
         }
@@ -54 +58 @@
             if (global.show_warnings) {
                 FlushedOutput yes;
-                fprintf(stderr, "%s:%i: Warning: ", filename, lineno);
-                VPRINTFORMAT(format);
+                VCOMPILERMSG(filename, lineno, "Warning", format);
                 global.warnings++;
             }
@@ -61 +64 @@
         static void errorf(const char *filename, int lineno, const char *format, ...) __attribute__((format(printf, 3, 4))) {
             FlushedOutput yes;
-            fprintf(stderr, "%s:%i: Error: ", filename, lineno);
-            VPRINTFORMAT(format);
+            VCOMPILERMSG(filename, lineno, "Error", format);
+            TRIGGER_ASSERTION(); // fake an assertion failure
+        }
+        static void ioerrorf(const char *filename, int lineno, const char *format, ...) __attribute__((format(printf, 3, 4))) {
+            FlushedOutput yes;
+            VCOMPILERMSG(filename, lineno, "Error", format);
+            fprintf(stderr, " (errno=%i='%s')", errno, strerror(errno));
+            TRIGGER_ASSERTION(); // fake an assertion failure
         }
 #undef VPRINTFORMAT
+#undef VCOMPILERMSG
+#undef WITHVALISTFROM
     };
 
@@ -75 +86 @@
     inline void print(size_t z)              { fprintf(stderr, "%zu", z); }
     inline void print_hex(size_t z)          { fprintf(stderr, "0x%zx", z); }
+    
+    inline void print(unsigned char c)       { fprintf(stderr, "'%c'", c); }
+    inline void print_hex(unsigned char c)   { print_hex(size_t(c)); }
+
+    inline void print(char c)                { print((unsigned char)c); }
+    inline void print_hex(char c)            { print_hex((unsigned char)c); }
+
+    // dont dup size_t:
 #ifdef ARB_64
     inline void print(unsigned u)            { fprintf(stderr, "%u", u); }
@@ -82 +101 @@
     inline void print_hex(long unsigned u)   { fprintf(stderr, "0x%lux", u); }
 #endif
-    
+
     template <typename T1, typename T2> void print_pair(T1 t1, T2 t2) {
         print(t1);
@@ -94 +113 @@
     }
     template <typename T1, typename T2> void print_failed_equal(T1 t1, T2 t2) {
-        FlushedOutput yes;
+        FlushedOutputNoLF yes;
         fputs("is_equal(", stderr);
         print_pair(t1, t2);
@@ -108 +127 @@
 #define NAMEOFTYPE(type) template <> inline const char * nameoftype<>(type) { return #type; }
     NAMEOFTYPE(bool);
+    NAMEOFTYPE(char);
+    NAMEOFTYPE(unsigned char);
     NAMEOFTYPE(int);
     NAMEOFTYPE(unsigned int);
@@ -135 +156 @@
         bool equal = strnullequal(s1, s2);
         if (!equal) {
-            FlushedOutput::printf("str_equal('%s',\n"
-                                  "          '%s') returns false\n", s1, s2);
+            StaticCode::printf("str_equal('%s',\n"
+                               "          '%s') returns false\n", s1, s2);
         }
         return equal;
@@ -158 +179 @@
         bool different = !strnullequal(s1, s2);
         if (!different) {
-            FlushedOutput::printf("str_different('%s', ..) returns false\n", s1);
+            StaticCode::printf("str_different('%s', ..) returns false\n", s1);
         }
         return different;
@@ -169 +190 @@
         bool in_epsilon_range = diff < epsilon;
         if (!in_epsilon_range) {
-            FlushedOutput::printf("is_similar(%f,%f,%f) returns false\n", d1, d2, epsilon);
+            StaticCode::printf("is_similar(%f,%f,%f) returns false\n", d1, d2, epsilon);
         }
         return in_epsilon_range;
@@ -178 +199 @@
     }
 
+
+
+    inline bool files_are_equal(const char *file1, const char *file2) {
+        const char        *error = NULL;
+        FILE              *fp1   = fopen(file1, "rb");
+        FlushedOutputNoLF  yes;
+
+        if (!fp1) {
+            StaticCode::printf("can't open '%s'", file1);
+            error = "i/o error";
+        }
+        else {
+            FILE *fp2 = fopen(file2, "rb");
+            if (!fp2) {
+                StaticCode::printf("can't open '%s'", file2);
+                error = "i/o error";
+            }
+            else {
+                const int      BLOCKSIZE    = 4096;
+                unsigned char *buf1         = (unsigned char*)malloc(BLOCKSIZE);
+                unsigned char *buf2         = (unsigned char*)malloc(BLOCKSIZE);
+                int            equal_bytes  = 0;
+                bool           repositioned = false;
+
+                while (!error) {
+                    int read1  = fread(buf1, 1, BLOCKSIZE, fp1);
+                    int read2  = fread(buf2, 1, BLOCKSIZE, fp2);
+                    int common = read1<read2 ? read1 : read2;
+
+                    if (!common) {
+                        if (read1 != read2) error = "filesize differs";
+                        break;
+                    }
+
+                    if (memcmp(buf1, buf2, common) == 0) {
+                        equal_bytes += common;
+                    }
+                    else {
+                        int x = 0;
+                        while (buf1[x] == buf2[x]) {
+                            x++;
+                            equal_bytes++;
+                        }
+                        error = "content differs";
+
+                        // x is the position inside the current block
+                        const int DUMP       = 7;
+                        int       y1         = x >= DUMP ? x-DUMP : 0;
+                        int       y2         = (x+DUMP)>common ? common : (x+DUMP);
+                        int       blockstart = equal_bytes-x;
+
+                        for (int y = y1; y <= y2; y++) {
+                            fprintf(stderr, "[0x%04x]", blockstart+y);
+                            print_pair(buf1[y], buf2[y]);
+                            fputc(' ', stderr);
+                            print_hex_pair(buf1[y], buf2[y]);
+                            if (x == y) fputs("                     <- diff", stderr);
+                            fputc('\n', stderr);
+                        }
+                        if (y2 == common) {
+                            fputs("[end of block - truncated]\n", stderr);
+                        }
+                    }
+                }
+
+                if (error) StaticCode::printf("files_are_equal: equal_bytes=%i\n", equal_bytes);
+                test_assert(error || equal_bytes); // comparing empty files is nonsense
+
+                free(buf2);
+                free(buf1);
+                fclose(fp2);
+            }
+            fclose(fp1);
+        }
+
+        if (error) StaticCode::printf("files_are_equal(%s, %s) fails: %s\n", file1, file2, error);
+        return !error;
+    }
+    
 };
 
 // --------------------------------------------------------------------------------
 
-#define TEST_MSG(format,strarg)           arb_test::FlushedOutput::messagef(__FILE__, __LINE__, format, (strarg))
-#define TEST_MSG2(format,strarg1,strarg2) arb_test::FlushedOutput::messagef(__FILE__, __LINE__, format, (strarg1), (strarg2))
-
-#define TEST_WARNING(format,strarg)           arb_test::FlushedOutput::warningf(__FILE__, __LINE__, format, (strarg))
-#define TEST_WARNING2(format,strarg1,strarg2) arb_test::FlushedOutput::warningf(__FILE__, __LINE__, format, (strarg1), (strarg2))
-
-#define TEST_ERROR(format,strarg)           do { arb_test::FlushedOutput::errorf(__FILE__, __LINE__, format, (strarg)); TEST_ASSERT(0); } while(0)
-#define TEST_ERROR2(format,strarg1,strarg2) do { arb_test::FlushedOutput::errorf(__FILE__, __LINE__, format, (strarg1), (strarg2)); TEST_ASSERT(0); } while(0)
+#define TEST_WARNING(format,strarg)           arb_test::StaticCode::warningf(__FILE__, __LINE__, format, (strarg))
+#define TEST_WARNING2(format,strarg1,strarg2) arb_test::StaticCode::warningf(__FILE__, __LINE__, format, (strarg1), (strarg2))
+
+#define TEST_ERROR(format,strarg)           arb_test::StaticCode::errorf(__FILE__, __LINE__, format, (strarg))
+#define TEST_ERROR2(format,strarg1,strarg2) arb_test::StaticCode::errorf(__FILE__, __LINE__, format, (strarg1), (strarg2))
+#define TEST_IOERROR(format,strarg)         arb_test::StaticCode::ioerrorf(__FILE__, __LINE__, format, (strarg))
 
 // --------------------------------------------------------------------------------
@@ -206 +304 @@
 #define TEST_ASSERT_ZERO(cond)         TEST_ASSERT((cond)         == 0)
 #define TEST_ASSERT_ZERO__BROKEN(cond) TEST_ASSERT__BROKEN((cond) == 0)
+
+#define TEST_ASSERT_ZERO_OR_SHOW_ERRNO(iocond)                  \
+    do {                                                        \
+        if ((iocond))                                           \
+            TEST_IOERROR("I/O-failure in '%s'", #iocond);       \
+    } while(0)
 
 // --------------------------------------------------------------------------------
@@ -350 +454 @@
 #define TEST_ASSERT_SIMILAR__BROKEN(t1,t2,epsilon) TEST_ASSERT__BROKEN(arb_test::is_similar(t1, t2, epsilon))
 
+#define TEST_ASSERT_FILES_EQUAL(f1,f2)         TEST_ASSERT(arb_test::files_are_equal(f1,f2))
+#define TEST_ASSERT_FILES_EQUAL__BROKEN(f1,f2) TEST_ASSERT__BROKEN(arb_test::files_are_equal(f1,f2))
+
 #else
 #error test_unit.h included twice

@@ -5 +5 @@
 *.gcno
 logs
+test_environment