Removed the failure formatting from Utest

include/CppUTest/SimpleString.h

@@ -117,6 +117,7 @@ SimpleString StringFrom(bool value);
 SimpleString StringFrom(void* value);
 SimpleString StringFrom(char value);
 SimpleString StringFrom(const char *value);
+SimpleString StringFromOrNull(const char * value);
 SimpleString StringFrom(long value);
 SimpleString StringFrom(int value);
 SimpleString HexStringFrom(long value);

include/CppUTest/TestFailure.h

@@ -72,25 +72,45 @@ class TestFailure
 class EqualsFailure: public TestFailure
 {
 public:
+	EqualsFailure(Utest*, const char* fileName, int lineNumber, const char* expected, const char* actual);
+	EqualsFailure(Utest*, const char* fileName, int lineNumber, const SimpleString& expected, const SimpleString& actual);
+};
 
-	EqualsFailure(Utest*, const char* fileName, int lineNumber,
-			const SimpleString& expected, const SimpleString& actual);
+class ContainsFailure: public TestFailure
+{
+public:
+	ContainsFailure(Utest*, const char* fileName, int lineNumber, const SimpleString& expected, const SimpleString& actual);
 
-private:
-	EqualsFailure(const EqualsFailure&);
-	EqualsFailure& operator=(const EqualsFailure&);
 };
 
-class ContainsFailure: public TestFailure
+class CheckFailure : public TestFailure
 {
 public:
+	CheckFailure(Utest* test, const char* fileName, int lineNumber, const SimpleString& conditionString);
+};
 
-	ContainsFailure(Utest*, const char* fileName, int lineNumber,
-			const SimpleString& expected, const SimpleString& actual);
+class FailFailure : public TestFailure
+{
+public:
+	FailFailure(Utest* test, const char* fileName, int lineNumber, const SimpleString& message);
+};
 
-private:
-	ContainsFailure(const ContainsFailure&);
-	ContainsFailure& operator=(const ContainsFailure&);
+class LongsEqualFailure : public TestFailure
+{
+public:
+	LongsEqualFailure(Utest* test, const char* fileName, int lineNumber, long expected, long actual);
+};
+
+class StringEqualFailure : public TestFailure
+{
+public:
+	StringEqualFailure(Utest* test, const char* fileName, int lineNumber, const char* expected, const char* actual);
+};
+
+class StringEqualNoCaseFailure : public TestFailure
+{
+public:
+	StringEqualNoCaseFailure(Utest* test, const char* fileName, int lineNumber, const char* expected, const char* actual);
 };
 
 #endif

include/CppUTest/Utest.h

@@ -49,16 +49,10 @@ class TestFailure;
 class Utest
 {
 public:
-
 	Utest(const char* groupName, const char* testName, const char* fileName,
 			int lineNumber);
-
 	virtual ~Utest();
 
-	virtual void testBody()
-	{
-	}
-
 	virtual void run(TestResult& result);
 	virtual void runOneTestWithPlugins(TestPlugin* plugin, TestResult& result);
 	virtual SimpleString getFormattedName() const;
@@ -68,17 +62,20 @@ class Utest
 	virtual bool isNull() const;
 	virtual int countTests();
 
-	bool shouldRun(const SimpleString& groupFilter,
-			const SimpleString& nameFilter) const;
+	bool shouldRun(const SimpleString& groupFilter, const SimpleString& nameFilter) const;
 	const SimpleString getName() const;
 	const SimpleString getGroup() const;
 	const SimpleString getFile() const;
 	int getLineNumber() const;
     const virtual char *getProgressIndicator() const;
+
     virtual void setup();
     virtual void teardown();
-    static TestResult *getTestResult();
+	virtual void testBody();
+
+	static TestResult *getTestResult();
     static Utest *getCurrent();
+
     virtual void assertTrue(bool condition, const char *conditionString, const char *fileName, int lineNumber);
     virtual void assertCstrEqual(const char *expected, const char *actual, const char *fileName, int lineNumber);
     virtual void assertCstrNoCaseEqual(const char *expected, const char *actual, const char *fileName, int lineNumber);
@@ -88,12 +85,15 @@ class Utest
     virtual void assertPointersEqual(void *expected, void *actual, const char *fileName, int lineNumber);
     virtual void assertDoublesEqual(double expected, double actual, double threshold, const char *fileName, int lineNumber);
     virtual void fail(const char *text, const char *fileName, int lineNumber);
+
     virtual void print(const char *text, const char *fileName, int lineNumber);
     virtual void print(const SimpleString & text, const char *fileName, int lineNumber);
+
     void setFileName(const char *fileName);
     void setLineNumber(int lineNumber);
     void setGroupName(const char *groupName);
     void setTestName(const char *testName);
+
     virtual void exitCurrentTest();
 protected:
     virtual void runOneTest(TestPlugin *plugin, TestResult & result);
@@ -102,8 +102,10 @@ class Utest
     virtual void executePlatformSpecificTestBody();
     virtual void executePlatformSpecificTeardown();
     virtual void executePlatformSpecificExitCurrentTest();
+
     Utest();
     Utest(const char *groupName, const char *testName, const char *fileName, int lineNumber, Utest *nextTest);
+
     virtual SimpleString getMacroName() const;
 private:
     const char *group_;
@@ -118,16 +120,7 @@ class Utest
 	static Utest* currentTest_;
 	static TestResult* testResult_;
 
-    SimpleString stringFromOrNull(const char * expected);
-    void failEqualsTest(const char * expected, const char* actual, const char * fileName, int lineNumber);
-    void failCstrEqualsTest(const char * expected, const char* actual, const char * fileName, int lineNumber);
-    void failCstrEqualsTestNoCase(const char * expected, const char* actual, const char * fileName, int lineNumber);
-    void failContainsTest(const char * expected, const char* actual, const char * fileName, int lineNumber);
-    int findStartOfCstrEqualsFailNoCase(const char * expected, const char* actual);
-    int findStartOfCstrEqualsFail(const char * expected, const char* actual);
-    char * newCstrEqualsFailMessage(const char * expected, const char* actual);
-	char * newCstrEqualsFailNoCaseMessage(const char * expected, const char* actual);
-    char* formCStrEqualsFailMessage(const char* actual, int failStart);
+    void failWith(const TestFailure& failure);
 };
 
 //////////////////// NulLTest

src/CppUTest/SimpleString.cpp

@@ -299,6 +299,11 @@ SimpleString StringFrom(const char *value)
 	return SimpleString(value);
 }
 
+SimpleString StringFromOrNull(const char * expected)
+{
+    return (expected) ? StringFrom(expected) : "(null)";
+}
+
 SimpleString StringFrom(int value)
 {
 	return StringFromFormat("%d", value);

src/CppUTest/TestFailure.cpp

@@ -28,6 +28,7 @@
 #include "CppUTest/TestHarness.h"
 #include "CppUTest/TestFailure.h"
 #include "CppUTest/TestOutput.h"
+#include "CppUTest/PlatformSpecificFunctions.h"
 
 TestFailure::TestFailure(Utest* test, const char* fileName, int lineNumber, const SimpleString& theMessage) :
 	testName_(test->getFormattedName()), fileName_(fileName), lineNumber_(lineNumber), message_(theMessage)
@@ -73,10 +74,16 @@ SimpleString TestFailure::getMessage() const
 	return message_;
 }
 
-EqualsFailure::EqualsFailure(Utest* test, const char* fileName, int lineNumber, const SimpleString& expected, const SimpleString& actual) :
+EqualsFailure::EqualsFailure(Utest* test, const char* fileName, int lineNumber, const char* expected, const char* actual) :
 	TestFailure(test, fileName, lineNumber)
 {
+	const char* format = "expected <%s>\n\tbut was  <%s>";
+	message_ = StringFromFormat(format, StringFromOrNull(expected).asCharString(), StringFromOrNull(actual).asCharString());
+}
 
+EqualsFailure::EqualsFailure(Utest* test, const char* fileName, int lineNumber, const SimpleString& expected, const SimpleString& actual)
+	: TestFailure(test, fileName, lineNumber)
+{
 	const char* format = "expected <%s>\n\tbut was  <%s>";
 	message_ = StringFromFormat(format, expected.asCharString(), actual.asCharString());
 }
@@ -88,3 +95,88 @@ ContainsFailure::ContainsFailure(Utest* test, const char* fileName, int lineNumb
 	const char* format = "actual <%s>\n\tdid not contain  <%s>";
 	message_ = StringFromFormat(format, actual.asCharString(), expected.asCharString());
 }
+
+CheckFailure::CheckFailure(Utest* test, const char* fileName, int lineNumber, const SimpleString& conditionString) : TestFailure(test, fileName, lineNumber)
+{
+	message_ = "CHECK(";
+	message_ += conditionString;
+	message_ += ") failed";
+}
+
+FailFailure::FailFailure(Utest* test, const char* fileName, int lineNumber, const SimpleString& message) : TestFailure(test, fileName, lineNumber)
+{
+	message_ = message;
+}
+
+LongsEqualFailure::LongsEqualFailure(Utest* test, const char* fileName, int lineNumber, long expected, long actual) : TestFailure(test, fileName, lineNumber)
+{
+	SimpleString aDecimal = StringFrom(actual);
+	SimpleString aHex = HexStringFrom(actual);
+	SimpleString eDecimal = StringFrom(expected);
+	SimpleString eHex = HexStringFrom(expected);
+
+	SimpleString::padStringsToSameLength(aDecimal, eDecimal, ' ');
+	SimpleString::padStringsToSameLength(aHex, eHex, '0');
+
+	SimpleString actualReported = aDecimal + " 0x" + aHex;
+	SimpleString expectedReported = eDecimal + " 0x" + eHex;
+	message_ = StringFromFormat("expected <%s>\n\tbut was  <%s>", expectedReported.asCharString(), actualReported.asCharString());
+}
+
+StringEqualFailure::StringEqualFailure(Utest* test, const char* fileName, int lineNumber, const char* expected, const char* actual) : TestFailure(test, fileName, lineNumber)
+{
+	int failStart;
+    for (failStart = 0; actual[failStart] == expected[failStart]; failStart++)
+    	;
+
+    const char * error = "<!>";
+	char * message;
+
+	//cpputest_malloc is needed instead of new[] for vc6 compatibility
+	message = (char*)cpputest_malloc(PlatformSpecificStrLen(actual) + PlatformSpecificStrLen(error) + 10);
+
+	int j;
+	for (j = 0; j < failStart; j++)
+		message[j] = actual[j];
+
+	for (int k = 0; k < (int)PlatformSpecificStrLen(error); j++, k++)
+		message[j] = error[k];
+
+	for (int i = failStart; actual[i]; i++, j++)
+		message[j] = actual[i];
+
+	message[j] = '\0';
+
+	message_ = StringFromFormat("expected <%s>\n\tbut was  <%s>", expected, message);
+	cpputest_free(message);
+}
+
+StringEqualNoCaseFailure::StringEqualNoCaseFailure(Utest* test, const char* fileName, int lineNumber, const char* expected, const char* actual) : TestFailure(test, fileName, lineNumber)
+{
+	int failStart;
+    for (failStart = 0; PlatformSpecificToLower(actual[failStart]) == PlatformSpecificToLower(expected[failStart]); failStart++)
+    	;
+
+    const char * error = "<!>";
+	char * message;
+
+	//cpputest_malloc is needed instead of new[] for vc6 compatibility
+	message = (char*)cpputest_malloc(PlatformSpecificStrLen(actual) + PlatformSpecificStrLen(error) + 10);
+
+	int j;
+	for (j = 0; j < failStart; j++)
+		message[j] = actual[j];
+
+	for (int k = 0; k < (int)PlatformSpecificStrLen(error); j++, k++)
+		message[j] = error[k];
+
+	for (int i = failStart; actual[i]; i++, j++)
+		message[j] = actual[i];
+
+	message[j] = '\0';
+
+	message_ = StringFromFormat("expected <%s>\n\tbut was  <%s>", expected, message);
+	cpputest_free(message);
+}
+
+