Skeleton of TestCase done.

diff --git a/.gitignore b/.gitignore
index f5450b7..8a7ad71 100644 (file)
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 NOTES
 *.o
 *~
+test

diff --git a/Makefile b/Makefile
index e69de29..f4e4a18 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -0,0 +1,21 @@
+SOURCES = cppu.cpp test.cpp
+HEADERS = cppu.h
+OBJS = cppu.o
+
+
+GCC = g++
+CXXFLAGS = -pedantic -Wall
+DEBUGFLAGS = -g
+
+all: test
+
+test: $(OBJS) test.cpp
+       $(GCC) $(CXXFLAGS) $(DEBUGFLAGS) -o test $(OBJS) test.cpp
+
+cppu.o: cppu.cpp cppu.h
+       $(GCC) $(CXXFLAGS) $(DEBUGFLAGS) -c -o $@ $<
+
+clean:
+       rm *.o
+
+.PHONY: clean

diff --git a/c++unit.cpp b/c++unit.cpp
deleted file mode 100644 (file)
index e69de29..0000000

diff --git a/c++unit.h b/c++unit.h
deleted file mode 100644 (file)
index e69de29..0000000

diff --git a/cppu.cpp b/cppu.cpp
new file mode 100644 (file)
index 0000000..140989a
--- /dev/null
+++ b/cppu.cpp
@@ -0,0 +1,98 @@
+#include <iostream>
+#include "cppu.h"
+using namespace std;
+
+
+int TestCase::run(void)
+{
+    setUp();
+    run_tests();
+    tearDown();
+
+    /*
+    vector<t_error_message>::iterator itError;
+
+    vector<t_test_state>::iterator it = tests_states.begin();
+    for (;it != tests_states.end(); it++){
+        cout << "name:         " << it->test_name << endl;
+        cout << "assertations: " << it->assertations << endl;
+        cout << "fails:        " << it->fails << endl;
+        cout << "successes:    " << it->successes << endl;
+
+        itError = it->error_messages.begin();
+        for (;itError != it->error_messages.end(); itError++){
+            cout << "  :::  " << itError->file << ":" << itError->line <<
+                ": " << itError->message << endl;
+        }
+    }
+    */
+
+    return fails;
+}
+
+void TestCase::summary(void)
+{
+    // Printing error messages:
+    vector<t_error_message>::iterator error_it;
+    vector<t_error_message>::iterator error_it_end;
+    vector<t_test_state>::iterator it = tests_states.begin();
+    vector<t_test_state>::iterator it_end = tests_states.end();
+    for (;it != it_end; ++it){
+        if (it->error_messages.size() > 0){
+            error_it = it->error_messages.begin();
+            error_it_end = it->error_messages.end();
+            for (;error_it != error_it_end; ++error_it){
+                cout << error_it->file << ":" << error_it->line << ": " <<
+                    it->test_name << " :: " << error_it->message << endl;
+            }
+            //cout << endl;
+        }
+    }
+
+    cout << endl;
+    cout << "===================" << endl;
+    cout << "tests:     " << numTests() << endl;
+    cout << "successes: " << numSuccesses() << endl;
+    cout << "fails:     " << numFails() << endl;
+}
+
+
+//private:
+void TestCase::prepareTest(string name)
+{
+    tests++;
+
+    current_test.clean();
+    current_test.test_name = name;
+}
+
+void TestCase::finishTest(void)
+{
+    if (current_test.fails > 0){
+        fails++;
+    }else{
+        successes++;
+    }
+    tests_states.push_back(current_test);
+}
+
+
+void TestCase::recordSuccessAssertation(void)
+{
+    current_test.assertations++;
+    current_test.successes++;
+}
+
+void TestCase::recordFailAssertation(string file, int line,
+        string error_message)
+{
+    t_error_message tmp;
+
+    current_test.assertations++;
+    current_test.fails++;
+
+    tmp.file = file;
+    tmp.line = line;
+    tmp.message = error_message;
+    current_test.error_messages.push_back(tmp);
+}

diff --git a/cppu.h b/cppu.h
new file mode 100644 (file)
index 0000000..ab071ca
--- /dev/null
+++ b/cppu.h
@@ -0,0 +1,128 @@
+#ifndef _CPPU_H_
+#define _CPPU_H_
+
+#include <string>
+#include <vector>
+/**
+ * TODO: Copyright, license...
+ * TODO: Udelat to tak, aby se vse vypisovalo za behu a nemuselo se cekat
+ * na dobehnuti celeho testu
+ *
+ * TODO: TestSuite a to i takova, ktera muze obsahovat TestSuity
+ *
+ * TODO: Dopsat vsechny aserce
+ */
+
+/**
+ * Struct describing error message.
+ */
+struct t_error_message{
+    std::string file;
+    int line;
+    std::string message;
+};
+
+/**
+ * Struct describing state after run test.
+ */
+struct t_test_state{
+    std::string test_name;
+    int assertations;
+    int fails;
+    int successes;
+    std::vector<t_error_message> error_messages;
+
+    inline void clean(void){assertations=0;fails=0;successes=0;error_messages.clear();}
+};
+
+
+
+/**
+ * Main class
+ */
+class TestCase{
+  protected:
+    int tests;
+    int fails;
+    int successes;
+
+    /**
+     * Name of current test case
+     */
+    std::string name;
+
+    /**
+     * List of states of all ran tests.
+     */
+    std::vector<t_test_state> tests_states;
+
+    /**
+     * State of currently running test.
+     * This struct must be empty before running next test method.
+     */
+    t_test_state current_test;
+
+
+    void prepareTest(std::string test_name);
+    void finishTest(void);
+
+    void recordSuccessAssertation(void);
+    void recordFailAssertation(std::string file, int line,
+            std::string error_message);
+
+  public:
+    explicit TestCase(std::string n) : fails(0), successes(0), name(n){}
+
+    virtual void setUp(void){}
+    virtual void tearDown(void){}
+
+    /**
+     * Method describing tests.
+     * This must be redeclared in extended class.
+     */
+    virtual void run_tests() = 0;
+
+    /**
+     * This run the test case.
+     * Returns number of failed tests or 255 (lesser number)
+     */
+    int run(void);
+
+
+    int numTests(){return tests;}
+    int numFails(void){return fails;}
+    int numSuccesses(void){return successes;}
+    void summary(void);
+};
+
+
+/***** TestCase MACROS *****/
+#define assertEquals(a,b) \
+    if ((a) == (b)){ \
+        recordSuccessAssertation(); \
+    }else{ \
+        recordFailAssertation(__FILE__, __LINE__, #a " not equals " #b); \
+    }
+#define assertEqualsM(a,b,message) \
+    if ((a) == (b)){ \
+        recordSuccessAssertation(); \
+    }else{ \
+        recordFailAssertation(__FILE__, __LINE__, message); \
+    }
+
+#define assertNotEquals(a,b) \
+    if ((a) != (b)){ \
+        recordSuccessAssertation(); \
+    }else{ \
+        recordFailAssertation(__FILE__, __LINE__, #a " equals " #b); \
+    }
+#define assertNotEqualsM(a,b,message) \
+    if ((a) != (b)){ \
+        recordSuccessAssertation(); \
+    }else{ \
+        recordFailAssertation(__FILE__, __LINE__, message); \
+    }
+
+
+#endif
+/* vim: set sw=4 ts=4 et ft=cpp tw=75 cindent: */

diff --git a/test.cpp b/test.cpp
new file mode 100644 (file)
index 0000000..adc49da
--- /dev/null
+++ b/test.cpp
@@ -0,0 +1,76 @@
+#include <iostream>
+using namespace std;
+
+#include "cppu.h"
+
+
+class MyTestCase : public TestCase{
+  public:
+       MyTestCase(string n) : TestCase(n){}
+
+
+       void testMethod(void)
+       {
+        assertEquals(1,1);
+        assertEquals(2,1);
+       }
+
+       void testMethod2(void)
+       {
+        assertEquals(1,1);
+        assertEquals(2,1);
+       }
+       void testMethod3(void)
+       {
+        assertEquals(1,1);
+       }
+
+       void testMethod4(void)
+       {
+        assertEquals(1,1);
+        assertEqualsM(2,1,"2 not equals 1, dude");
+       }
+       void testMethod5(void)
+       {
+        assertEquals(1,1);
+       }
+
+       void testMethod6(void)
+       {
+        assertEquals(1,1);
+        assertNotEquals(2,1);
+       }
+       void run_tests()
+       {
+        prepareTest("testMethod");
+        this->testMethod();
+        finishTest();
+
+        prepareTest("testMethod2");
+        this->testMethod2();
+        finishTest();
+        prepareTest("testMethod3");
+        this->testMethod3();
+        finishTest();
+        prepareTest("testMethod4");
+        this->testMethod4();
+        finishTest();
+        prepareTest("testMethod5");
+        this->testMethod5();
+        finishTest();
+        prepareTest("testMethod6");
+        this->testMethod6();
+        finishTest();
+       }
+};
+
+int main(int argc, char *argv[])
+{
+       int ret = 0;
+       TestCase *t = new MyTestCase("name");
+       ret = t->run();
+    t->summary();
+    delete t;
+
+       return ret;
+}