Added actual calls reporting to MockFailure, and preliminary non-func…

…tional addition of actual calls registry to MockSupport.
cpputest · jgonzalezdr · Jun 21, 2016 · Jun 26, 2016 · Jun 26, 2016 · Jun 26, 2016
commit 044a69359b4ccb172f140d5b1286b6fa97eda050
diff --git a/include/CppUTestExt/MockFailure.h b/include/CppUTestExt/MockFailure.h
@@ -32,6 +32,7 @@
 #include "CppUTest/TestFailure.h"
 
 class MockExpectedCallsList;
+class MockActualCallsQueue;
 class MockCheckedActualCall;
 class MockNamedValue;
 class MockFailure;
@@ -56,44 +57,50 @@ class MockFailure : public TestFailure
     MockFailure(UtestShell* test);
     virtual ~MockFailure(){}
 protected:
-    void addExpectationsAndCallHistory(const MockExpectedCallsList& expectations);
-    void addExpectationsAndCallHistoryRelatedTo(const SimpleString& function, const MockExpectedCallsList& expectations);
+    void addExpectationsAndCallHistory(const MockExpectedCallsList& expectedCalls, const MockActualCallsQueue& actualCalls);
+    void addExpectationsAndCallHistoryRelatedTo(const SimpleString& function, const MockExpectedCallsList& expectedCalls,
+                                                const MockActualCallsQueue& actualCalls);
 };
 
 class MockExpectedCallsNotFulfilledFailure : public MockFailure
 {
 public:
-    MockExpectedCallsNotFulfilledFailure(UtestShell* test, const MockExpectedCallsList& expectations);
+    MockExpectedCallsNotFulfilledFailure(UtestShell* test, const MockExpectedCallsList& expectations,
+                                         const MockActualCallsQueue& actualCalls);
 };
 
 class MockUnexpectedCallHappenedFailure : public MockFailure
 {
 public:
-    MockUnexpectedCallHappenedFailure(UtestShell* test, const SimpleString& name, const MockExpectedCallsList& expectations);
+    MockUnexpectedCallHappenedFailure(UtestShell* test, const SimpleString& name, const MockExpectedCallsList& expectations,
+                                      const MockActualCallsQueue& actualCalls);
 };
 
 class MockCallOrderFailure : public MockFailure
 {
 public:
-    MockCallOrderFailure(UtestShell* test, const MockExpectedCallsList& expectations);
+    MockCallOrderFailure(UtestShell* test, const MockExpectedCallsList& expectations, const MockActualCallsQueue& actualCalls);
 };
 
 class MockUnexpectedInputParameterFailure : public MockFailure
 {
 public:
-    MockUnexpectedInputParameterFailure(UtestShell* test, const SimpleString& functionName, const MockNamedValue& parameter, const MockExpectedCallsList& expectations);
+    MockUnexpectedInputParameterFailure(UtestShell* test, const SimpleString& functionName, const MockNamedValue& parameter,
+                                        const MockExpectedCallsList& expectations, const MockActualCallsQueue& actualCalls);
 };
 
 class MockUnexpectedOutputParameterFailure : public MockFailure
 {
 public:
-    MockUnexpectedOutputParameterFailure(UtestShell* test, const SimpleString& functionName, const MockNamedValue& parameter, const MockExpectedCallsList& expectations);
+    MockUnexpectedOutputParameterFailure(UtestShell* test, const SimpleString& functionName, const MockNamedValue& parameter,
+                                         const MockExpectedCallsList& expectations, const MockActualCallsQueue& actualCalls);
 };
 
 class MockExpectedParameterDidntHappenFailure : public MockFailure
 {
 public:
-    MockExpectedParameterDidntHappenFailure(UtestShell* test, const SimpleString& functionName, const MockExpectedCallsList& expectations);
+    MockExpectedParameterDidntHappenFailure(UtestShell* test, const SimpleString& functionName, const MockExpectedCallsList& expectations,
+                                            const MockActualCallsQueue& actualCalls);
 };
 
 class MockNoWayToCompareCustomTypeFailure : public MockFailure
@@ -111,13 +118,15 @@ class MockNoWayToCopyCustomTypeFailure : public MockFailure
 class MockUnexpectedObjectFailure : public MockFailure
 {
 public:
-    MockUnexpectedObjectFailure(UtestShell* test, const SimpleString& functionName, const void* expected, const MockExpectedCallsList& expectations);
+    MockUnexpectedObjectFailure(UtestShell* test, const SimpleString& functionName, const void* expected,
+                                const MockExpectedCallsList& expectations, const MockActualCallsQueue& actualCalls);
 };
 
 class MockExpectedObjectDidntHappenFailure : public MockFailure
 {
 public:
-    MockExpectedObjectDidntHappenFailure(UtestShell* test, const SimpleString& functionName, const MockExpectedCallsList& expectations);
+    MockExpectedObjectDidntHappenFailure(UtestShell* test, const SimpleString& functionName, const MockExpectedCallsList& expectations,
+                                         const MockActualCallsQueue& actualCalls);
 };
 
 class MockStrictOrderingIncompatibleWithOptionalCallsFailure : public MockFailure

diff --git a/include/CppUTestExt/MockSupport.h b/include/CppUTestExt/MockSupport.h
@@ -125,6 +125,7 @@ class MockSupport
     virtual void removeAllComparatorsAndCopiers();
 
     virtual const MockExpectedCallsList& getExpectedCalls() const;
+    virtual const MockActualCallsQueue& getActualCalls() const;
 
     const SimpleString& getName() const;
 
@@ -148,7 +149,7 @@ class MockSupport
     MockNamedValueComparatorsAndCopiersRepository comparatorsAndCopiersRepository_;
     MockNamedValueList data_;
     const SimpleString mockName_;
-
+    MockActualCallsQueue actualCalls_;
     bool tracing_;
 
     void checkExpectationsOfLastActualCall();

diff --git a/src/CppUTestExt/MockActualCall.cpp b/src/CppUTestExt/MockActualCall.cpp
@@ -142,7 +142,7 @@ MockActualCall& MockCheckedActualCall::withName(const SimpleString& name)
 
     potentiallyMatchingExpectations_.onlyKeepExpectationsRelatedTo(name);
     if (potentiallyMatchingExpectations_.isEmpty()) {
-        MockUnexpectedCallHappenedFailure failure(getTest(), name, mockSupport_.getExpectedCalls());
+        MockUnexpectedCallHappenedFailure failure(getTest(), name, mockSupport_.getExpectedCalls(), mockSupport_.getActualCalls());
         failTest(failure);
         return *this;
     }
@@ -165,7 +165,8 @@ void MockCheckedActualCall::checkInputParameter(const MockNamedValue& actualPara
     potentiallyMatchingExpectations_.onlyKeepExpectationsWithInputParameter(actualParameter);
 
     if (potentiallyMatchingExpectations_.isEmpty()) {
-        MockUnexpectedInputParameterFailure failure(getTest(), getName(), actualParameter, mockSupport_.getExpectedCalls());
+        MockUnexpectedInputParameterFailure failure(getTest(), getName(), actualParameter, mockSupport_.getExpectedCalls(),
+                                                    mockSupport_.getActualCalls());
         failTest(failure);
         return;
     }
@@ -187,7 +188,8 @@ void MockCheckedActualCall::checkOutputParameter(const MockNamedValue& outputPar
     potentiallyMatchingExpectations_.onlyKeepExpectationsWithOutputParameter(outputParameter);
 
     if (potentiallyMatchingExpectations_.isEmpty()) {
-        MockUnexpectedOutputParameterFailure failure(getTest(), getName(), outputParameter, mockSupport_.getExpectedCalls());
+        MockUnexpectedOutputParameterFailure failure(getTest(), getName(), outputParameter, mockSupport_.getExpectedCalls(),
+                                                     mockSupport_.getActualCalls());
         failTest(failure);
         return;
     }
@@ -362,11 +364,11 @@ void MockCheckedActualCall::checkExpectations()
     }
 
     if (potentiallyMatchingExpectations_.hasUnmatchingExpectationsBecauseOfMissingParameters()) {
-        MockExpectedParameterDidntHappenFailure failure(getTest(), getName(), mockSupport_.getExpectedCalls());
+        MockExpectedParameterDidntHappenFailure failure(getTest(), getName(), mockSupport_.getExpectedCalls(), mockSupport_.getActualCalls());
         failTest(failure);
     }
     else {
-        MockExpectedObjectDidntHappenFailure failure(getTest(), getName(), mockSupport_.getExpectedCalls());
+        MockExpectedObjectDidntHappenFailure failure(getTest(), getName(), mockSupport_.getExpectedCalls(), mockSupport_.getActualCalls());
         failTest(failure);
     }
 }
@@ -532,7 +534,7 @@ MockActualCall& MockCheckedActualCall::onObject(const void* objectPtr)
     potentiallyMatchingExpectations_.onlyKeepExpectationsOnObject(objectPtr);
 
     if (potentiallyMatchingExpectations_.isEmpty()) {
-        MockUnexpectedObjectFailure failure(getTest(), getName(), objectPtr, mockSupport_.getExpectedCalls());
+        MockUnexpectedObjectFailure failure(getTest(), getName(), objectPtr, mockSupport_.getExpectedCalls(), mockSupport_.getActualCalls());
         failTest(failure);
         return *this;
     }

diff --git a/src/CppUTestExt/MockFailure.cpp b/src/CppUTestExt/MockFailure.cpp
@@ -29,6 +29,8 @@
 #include "CppUTestExt/MockFailure.h"
 #include "CppUTestExt/MockExpectedCall.h"
 #include "CppUTestExt/MockExpectedCallsList.h"
+#include "CppUTestExt/MockActualCallsQueue.h"
+#include "CppUTestExt/MockCheckedActualCall.h"
 #include "CppUTestExt/MockNamedValue.h"
 
 class MockFailureReporterTestTerminator : public NormalTestTerminator
@@ -69,15 +71,18 @@ MockFailure::MockFailure(UtestShell* test) : TestFailure(test, "Test failed with
 {
 }
 
-void MockFailure::addExpectationsAndCallHistory(const MockExpectedCallsList& expectations)
+void MockFailure::addExpectationsAndCallHistory(const MockExpectedCallsList& expectations, const MockActualCallsQueue& actualCalls)
 {
     message_ += "\tEXPECTED calls that WERE NOT fulfilled:\n";
     message_ += expectations.unfulfilledCallsToString("\t\t");
     message_ += "\n\tEXPECTED calls that WERE fulfilled:\n";
     message_ += expectations.fulfilledCallsToString("\t\t");
+    message_ += "\n\tACTUAL calls that were expected (in call order):\n";
+    message_ += actualCalls.toString("\t\t");
 }
 
-void MockFailure::addExpectationsAndCallHistoryRelatedTo(const SimpleString& name, const MockExpectedCallsList& expectations)
+void MockFailure::addExpectationsAndCallHistoryRelatedTo(const SimpleString& name, const MockExpectedCallsList& expectations,
+                                                         const MockActualCallsQueue& actualCalls)
 {
     MockExpectedCallsList expectationsForFunction;
     expectationsForFunction.addExpectationsRelatedTo(name, expectations);
@@ -93,40 +98,53 @@ void MockFailure::addExpectationsAndCallHistoryRelatedTo(const SimpleString& nam
     message_ += "\n";
 
     message_ += expectationsForFunction.fulfilledCallsToString("\t\t");
+
+    message_ += "\n\tACTUAL calls that were expected (in call order) for function: ";
+    message_ += name;
+    message_ += "\n";
+
+    message_ += actualCalls.toStringFilterByFunction(name, "\t\t");
 }
 
-MockExpectedCallsNotFulfilledFailure::MockExpectedCallsNotFulfilledFailure(UtestShell* test, const MockExpectedCallsList& expectations) : MockFailure(test)
+MockExpectedCallsNotFulfilledFailure::MockExpectedCallsNotFulfilledFailure(UtestShell* test, const MockExpectedCallsList& expectations,
+                                                                           const MockActualCallsQueue& actualCalls)
+: MockFailure(test)
 {
     message_ = "Mock Failure: Expected call WAS NOT fulfilled.\n";
-    addExpectationsAndCallHistory(expectations);
+    addExpectationsAndCallHistory(expectations, actualCalls);
 }
 
-MockUnexpectedCallHappenedFailure::MockUnexpectedCallHappenedFailure(UtestShell* test, const SimpleString& name, const MockExpectedCallsList& expectations) : MockFailure(test)
+MockUnexpectedCallHappenedFailure::MockUnexpectedCallHappenedFailure(UtestShell* test, const SimpleString& name, const MockExpectedCallsList& expectations,
+                                                                     const MockActualCallsQueue& actualCalls)
+: MockFailure(test)
 {
     if (expectations.hasExpectationWithName(name)) {
-        unsigned int actualCalls = expectations.amountOfActualCallsFulfilledFor(name);
-        SimpleString ordinalNumber = StringFromOrdinalNumber(actualCalls + 1);
+        unsigned int actualCallsForFunction = expectations.amountOfActualCallsFulfilledFor(name);
+        SimpleString ordinalNumber = StringFromOrdinalNumber(actualCallsForFunction + 1);
         message_ = StringFromFormat("Mock Failure: Unexpected additional (%s) call to function: ", ordinalNumber.asCharString());
     } else {
         message_ = "Mock Failure: Unexpected call to function: ";
     }
     message_ += name;
     message_ += "\n";
-    addExpectationsAndCallHistory(expectations);
+    addExpectationsAndCallHistory(expectations, actualCalls);
 }
 
-MockCallOrderFailure::MockCallOrderFailure(UtestShell* test, const MockExpectedCallsList& expectations) : MockFailure(test)
+MockCallOrderFailure::MockCallOrderFailure(UtestShell* test, const MockExpectedCallsList& expectations, const MockActualCallsQueue& actualCalls)
+: MockFailure(test)
 {
     MockExpectedCallsList expectationsForOutOfOrder;
     expectationsForOutOfOrder.addExpectations(expectations);
     expectationsForOutOfOrder.onlyKeepOutOfOrderExpectations();
 
     message_ = "Mock Failure: Out of order calls";
     message_ += "\n";
-    addExpectationsAndCallHistory(expectationsForOutOfOrder);
+    addExpectationsAndCallHistory(expectationsForOutOfOrder, actualCalls);
 }
 
-MockUnexpectedInputParameterFailure::MockUnexpectedInputParameterFailure(UtestShell* test, const SimpleString& functionName, const MockNamedValue& parameter, const MockExpectedCallsList& expectations)  : MockFailure(test)
+MockUnexpectedInputParameterFailure::MockUnexpectedInputParameterFailure(UtestShell* test, const SimpleString& functionName, const MockNamedValue& parameter,
+                                                                         const MockExpectedCallsList& expectations, const MockActualCallsQueue& actualCalls)
+: MockFailure(test)
 {
     MockExpectedCallsList expectationsForFunctionWithParameterName;
     expectationsForFunctionWithParameterName.addExpectationsRelatedTo(functionName, expectations);
@@ -149,7 +167,7 @@ MockUnexpectedInputParameterFailure::MockUnexpectedInputParameterFailure(UtestSh
     }
 
     message_ += "\n";
-    addExpectationsAndCallHistoryRelatedTo(functionName, expectations);
+    addExpectationsAndCallHistoryRelatedTo(functionName, expectations, actualCalls);
 
     message_ += "\n\tACTUAL unexpected parameter passed to function: ";
     message_ += functionName;
@@ -164,7 +182,9 @@ MockUnexpectedInputParameterFailure::MockUnexpectedInputParameterFailure(UtestSh
     message_ += ">";
 }
 
-MockUnexpectedOutputParameterFailure::MockUnexpectedOutputParameterFailure(UtestShell* test, const SimpleString& functionName, const MockNamedValue& parameter, const MockExpectedCallsList& expectations)  : MockFailure(test)
+MockUnexpectedOutputParameterFailure::MockUnexpectedOutputParameterFailure(UtestShell* test, const SimpleString& functionName, const MockNamedValue& parameter,
+                                                                           const MockExpectedCallsList& expectations, const MockActualCallsQueue& actualCalls)
+: MockFailure(test)
 {
     MockExpectedCallsList expectationsForFunctionWithParameterName;
     expectationsForFunctionWithParameterName.addExpectationsRelatedTo(functionName, expectations);
@@ -187,7 +207,7 @@ MockUnexpectedOutputParameterFailure::MockUnexpectedOutputParameterFailure(Utest
     }
 
     message_ += "\n";
-    addExpectationsAndCallHistoryRelatedTo(functionName, expectations);
+    addExpectationsAndCallHistoryRelatedTo(functionName, expectations, actualCalls);
 
     message_ += "\n\tACTUAL unexpected output parameter passed to function: ";
     message_ += functionName;
@@ -199,7 +219,9 @@ MockUnexpectedOutputParameterFailure::MockUnexpectedOutputParameterFailure(Utest
     message_ += parameter.getName();
 }
 
-MockExpectedParameterDidntHappenFailure::MockExpectedParameterDidntHappenFailure(UtestShell* test, const SimpleString& functionName, const MockExpectedCallsList& expectations) : MockFailure(test)
+MockExpectedParameterDidntHappenFailure::MockExpectedParameterDidntHappenFailure(UtestShell* test, const SimpleString& functionName,
+                                                                                 const MockExpectedCallsList& expectations, const MockActualCallsQueue& actualCalls)
+: MockFailure(test)
 {
     MockExpectedCallsList expectationsForFunction;
     expectationsForFunction.addExpectationsRelatedTo(functionName, expectations);
@@ -208,11 +230,10 @@ MockExpectedParameterDidntHappenFailure::MockExpectedParameterDidntHappenFailure
     message_ += functionName;
     message_ += "\" did not happen.\n";
 
-    addExpectationsAndCallHistoryRelatedTo(functionName, expectations);
+    addExpectationsAndCallHistoryRelatedTo(functionName, expectations, actualCalls);
 
     message_ += "\n\tMISSING parameters that didn't happen:\n";
-    message_ += "\t\t";
-    message_ += expectationsForFunction.missingParametersToString();
+    message_ += expectationsForFunction.missingParametersToString("\t\t");
 }
 
 MockNoWayToCompareCustomTypeFailure::MockNoWayToCompareCustomTypeFailure(UtestShell* test, const SimpleString& typeName) : MockFailure(test)
@@ -225,17 +246,21 @@ MockNoWayToCopyCustomTypeFailure::MockNoWayToCopyCustomTypeFailure(UtestShell* t
     message_ = StringFromFormat("MockFailure: No way to copy type <%s>. Please install a MockNamedValueCopier.", typeName.asCharString());
 }
 
-MockUnexpectedObjectFailure::MockUnexpectedObjectFailure(UtestShell* test, const SimpleString& functionName, const void* actual, const MockExpectedCallsList& expectations) : MockFailure(test)
+MockUnexpectedObjectFailure::MockUnexpectedObjectFailure(UtestShell* test, const SimpleString& functionName, const void* actual,
+                                                         const MockExpectedCallsList& expectations, const MockActualCallsQueue& actualCalls)
+: MockFailure(test)
 {
     message_ = StringFromFormat ("MockFailure: Function called on an unexpected object: %s\n"
                                  "\tActual object for call has address: <%p>\n", functionName.asCharString(),actual);
-    addExpectationsAndCallHistoryRelatedTo(functionName, expectations);
+    addExpectationsAndCallHistoryRelatedTo(functionName, expectations, actualCalls);
 }
 
-MockExpectedObjectDidntHappenFailure::MockExpectedObjectDidntHappenFailure(UtestShell* test, const SimpleString& functionName, const MockExpectedCallsList& expectations) : MockFailure(test)
+MockExpectedObjectDidntHappenFailure::MockExpectedObjectDidntHappenFailure(UtestShell* test, const SimpleString& functionName,
+                                                                           const MockExpectedCallsList& expectations, const MockActualCallsQueue& actualCalls)
+: MockFailure(test)
 {
     message_ = StringFromFormat("Mock Failure: Expected call on object for function \"%s\" but it did not happen.\n", functionName.asCharString());
-    addExpectationsAndCallHistoryRelatedTo(functionName, expectations);
+    addExpectationsAndCallHistoryRelatedTo(functionName, expectations, actualCalls);
 }
 
 MockStrictOrderingIncompatibleWithOptionalCallsFailure::MockStrictOrderingIncompatibleWithOptionalCallsFailure(UtestShell* test, const SimpleString& functionName, unsigned int minCalls, unsigned int maxCalls) : MockFailure(test)