Merged extension headers back in from Micheal Feathers version.

1 files changed, 95 insertions, 0 deletions

diff --git a/include/cppunit/extensions/Orthodox.h b/include/cppunit/extensions/Orthodox.h
new file mode 100644
index 0000000..a7778e3
--- /dev/null
+++ b/include/cppunit/extensions/Orthodox.h
@@ -0,0 +1,95 @@
+
+#ifndef CPPUNIT_ORTHODOX_H
+#define CPPUNIT_ORTHODOX_H
+
+#ifndef CPPUNIT_TESTCASE_H
+#include "TestCase.h"
+#endif
+
+namespace CppUnit {
+
+/*
+ * Orthodox performs a simple set of tests on an arbitary
+ * class to make sure that it supports at least the
+ * following operations:
+ *
+ *      default construction    - constructor
+ *      equality/inequality     - operator== && operator!=
+ *      assignment              - operator=
+ *      negation                - operator!
+ *      safe passage            - copy construction
+ *
+ * If operations for each of these are not declared
+ * the template will not instantiate.  If it does 
+ * instantiate, tests are performed to make sure
+ * that the operations have correct semantics.
+ *      
+ * Adding an orthodox test to a suite is very 
+ * easy: 
+ * 
+ * public: Test *suite ()  {
+ *     TestSuite *suiteOfTests = new TestSuite;
+ *     suiteOfTests->addTest (new ComplexNumberTest ("testAdd");
+ *     suiteOfTests->addTest (new TestCaller<Orthodox<Complex> > ());
+ *     return suiteOfTests;
+ *  }
+ *
+ * Templated test cases be very useful when you are want to
+ * make sure that a group of classes have the same form.
+ *
+ * see TestSuite
+ */
+
+
+template <class ClassUnderTest> class Orthodox : public TestCase
+{
+public:
+                    Orthodox () : TestCase ("Orthodox") {}
+
+protected:
+    ClassUnderTest  call (ClassUnderTest object);
+    void            runTest ();
+
+
+};
+
+
+// Run an orthodoxy test
+template <class ClassUnderTest> void Orthodox<ClassUnderTest>::runTest ()
+{
+    // make sure we have a default constructor
+    ClassUnderTest   a, b, c;
+
+    // make sure we have an equality operator
+    assert (a == b);
+
+    // check the inverse
+    b.operator= (a.operator! ());
+    assert (a != b);
+
+    // double inversion
+    b = !!a;
+    assert (a == b);
+
+    // invert again
+    b = !a;
+
+    // check calls
+    c = a;
+    assert (c == call (a));
+
+    c = b;
+    assert (c == call (b));
+
+}
+
+
+// Exercise a call
+template <class ClassUnderTest> ClassUnderTest Orthodox<ClassUnderTest>::call (ClassUnderTest object)
+{
+    return object;
+}
+
+} // namespace CppUnit
+
+#endif
\ No newline at end of file