Changeset 6816 for trunk/UNIT_TESTER/test_unit.h

Timestamp:

09/09/10 22:40:57 (21 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/UNIT_TESTER

Files:

• . (modified) (1 prop)
• test_unit.h (modified) (14 diffs)

trunk/UNIT_TESTER

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

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

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