Added functionality to MockCheckedActualCall and MockActualCallsQueue…

… to generate a representation of their contents as a string, in preparation implementing an actual calls log.
cpputest · jgonzalezdr · Jun 21, 2016 · Jun 26, 2016 · Jun 26, 2016 · Jun 26, 2016
commit bc331818188cbb2a5f49ec21ecb0c5156132fc60
diff --git a/include/CppUTest/SimpleString.h b/include/CppUTest/SimpleString.h
@@ -173,8 +173,9 @@ SimpleString BracketsFormattedHexStringFrom(cpputest_longlong value);
 SimpleString BracketsFormattedHexStringFrom(cpputest_ulonglong value);
 SimpleString BracketsFormattedHexStringFrom(signed char value);
 SimpleString BracketsFormattedHexString(SimpleString hexString);
-
-
+SimpleString AppendStringOnANewLine(const SimpleString& inputString, const SimpleString& stringToAppend,
+                                    const SimpleString& linePrefix = "");
+SimpleString ReplaceWithTextNoneWhenEmpty(const SimpleString& inputString, const SimpleString& linePrefix);
 
 #if CPPUTEST_USE_STD_CPP_LIB
 

diff --git a/include/CppUTestExt/MockActualCallsQueue.h b/include/CppUTestExt/MockActualCallsQueue.h
@@ -127,6 +127,24 @@ class MockActualCallsQueue
      */
     virtual void setMaxSize(unsigned int maxSize);
 
+    /**
+     * Returns a string representation of the queue as a list with the description of all its stored calls, each on a new line.
+     *
+     * @param linePrefix String to be added before each individual call description
+     * @return String representation of the queue
+     */
+    virtual SimpleString toString(const SimpleString& linePrefix) const;
+
+    /**
+     * Returns a string representation of the queue as a list with the description of its stored calls for function @c functionName,
+     * each on a new line.
+     *
+     * @param functionName Name of the function to be filtered through
+     * @param linePrefix String to be added before each individual call description
+     * @return String representation of the queue
+     */
+    virtual SimpleString toStringFilterByFunction(const SimpleString& functionName, const SimpleString& linePrefix) const;
+
 protected:
     class MockActualCallsQueueNode
     {

diff --git a/include/CppUTestExt/MockCheckedActualCall.h b/include/CppUTestExt/MockCheckedActualCall.h
@@ -96,9 +96,13 @@ class MockCheckedActualCall : public MockActualCall
     virtual void checkExpectations();
 
     virtual void setMockFailureReporter(MockFailureReporter* reporter);
+
+    virtual SimpleString toString() const;
+
+    const SimpleString& getName() const;
+
 protected:
     void setName(const SimpleString& name);
-    SimpleString getName() const;
     virtual UtestShell* getTest() const;
     virtual void callHasSucceeded();
     virtual void finalizeOutputParameters(MockCheckedExpectedCall* call);
@@ -115,6 +119,10 @@ class MockCheckedActualCall : public MockActualCall
     };
     virtual void setState(ActualCallState state);
 
+    virtual const SimpleString& getScopeName() const;
+
+    void setMatchingExpectedCall(MockCheckedExpectedCall* call);
+
 private:
     SimpleString functionName_;
     unsigned int callOrder_;

diff --git a/include/CppUTestExt/MockCheckedExpectedCall.h b/include/CppUTestExt/MockCheckedExpectedCall.h
@@ -74,7 +74,7 @@ class MockCheckedExpectedCall : public MockExpectedCall
     virtual MockNamedValue getInputParameter(const SimpleString& name);
     virtual MockNamedValue getOutputParameter(const SimpleString& name);
     virtual SimpleString getInputParameterType(const SimpleString& name);
-    virtual SimpleString getInputParameterValueString(const SimpleString& name);
+    virtual SimpleString getInputParameterValueString(const SimpleString& name) const;
 
     virtual bool hasInputParameterWithName(const SimpleString& name);
     virtual bool hasInputParameter(const MockNamedValue& parameter);
@@ -97,16 +97,17 @@ class MockCheckedExpectedCall : public MockExpectedCall
     virtual void wasPassedToObject();
     virtual void resetActualCallMatchingState();
 
-    virtual SimpleString callToString();
+    virtual SimpleString callToString(bool asActualCall) const;
     virtual SimpleString missingParametersToString();
 
     enum { NO_EXPECTED_CALL_ORDER = 0 };
 
     virtual unsigned int getActualCallsFulfilled() const;
 
+    const SimpleString& getName() const;
+
 protected:
     void setName(const SimpleString& name);
-    SimpleString getName() const;
 
 private:
     SimpleString functionName_;

diff --git a/include/CppUTestExt/MockExpectedCallsList.h b/include/CppUTestExt/MockExpectedCallsList.h
@@ -75,7 +75,7 @@ class MockExpectedCallsList
 
     virtual SimpleString unfulfilledCallsToString(const SimpleString& linePrefix = "") const;
     virtual SimpleString fulfilledCallsToString(const SimpleString& linePrefix = "") const;
-    virtual SimpleString missingParametersToString() const;
+    virtual SimpleString missingParametersToString(const SimpleString& linePrefix = "") const;
 
 protected:
     virtual void pruneEmptyNodeFromList();

diff --git a/include/CppUTestExt/MockSupport.h b/include/CppUTestExt/MockSupport.h
@@ -32,6 +32,7 @@
 #include "CppUTestExt/MockCheckedActualCall.h"
 #include "CppUTestExt/MockCheckedExpectedCall.h"
 #include "CppUTestExt/MockExpectedCallsList.h"
+#include "CppUTestExt/MockActualCallsQueue.h"
 
 class UtestShell;
 class MockSupport;
@@ -125,6 +126,8 @@ class MockSupport
 
     virtual const MockExpectedCallsList& getExpectedCalls() const;
 
+    const SimpleString& getName() const;
+
 protected:
     MockSupport* clone(const SimpleString& mockName);
     virtual MockCheckedActualCall *createActualFunctionCall();

diff --git a/src/CppUTest/SimpleString.cpp b/src/CppUTest/SimpleString.cpp
@@ -808,6 +808,25 @@ SimpleString StringFromOrdinalNumber(unsigned int number)
     return StringFromFormat("%u%s", number, suffix);
 }
 
+SimpleString AppendStringOnANewLine(const SimpleString& inputString, const SimpleString& stringToAppend, const SimpleString& linePrefix)
+{
+    SimpleString str = inputString;
+    if (!str.isEmpty()) str += "\n";
+    str += linePrefix;
+    str += stringToAppend;
+    return str;
+}
+
+SimpleString ReplaceWithTextNoneWhenEmpty(const SimpleString& inputString, const SimpleString& linePrefix)
+{
+    SimpleString str = inputString;
+    if (str == "") {
+        str += linePrefix;
+        str += "<none>";
+    }
+    return str;
+}
+
 SimpleStringCollection::SimpleStringCollection()
 {
     collection_ = 0;

diff --git a/src/CppUTestExt/MockActualCall.cpp b/src/CppUTestExt/MockActualCall.cpp
@@ -45,7 +45,7 @@ void MockCheckedActualCall::setName(const SimpleString& name)
     functionName_ = name;
 }
 
-SimpleString MockCheckedActualCall::getName() const
+const SimpleString& MockCheckedActualCall::getName() const
 {
     return functionName_;
 }
@@ -568,6 +568,36 @@ void MockCheckedActualCall::cleanUpOutputParameterList()
     }
 }
 
+const SimpleString& MockCheckedActualCall::getScopeName() const
+{
+    return mockSupport_.getName();
+}
+
+SimpleString MockCheckedActualCall::toString() const
+{
+    SimpleString str;
+    const SimpleString& scopeName = getScopeName();
+
+    if (scopeName.isEmpty()) {
+        str += StringFromFormat("(%u) ", callOrder_);
+    } else {
+        str += StringFromFormat("(%s::%u) ", scopeName.asCharString(), callOrder_);
+    }
+
+    if (matchingExpectation_) {
+        str += matchingExpectation_->callToString(true);
+    } else {
+        str += functionName_;
+        str += " (NOT matching any expected call)";
+    }
+
+    return str;
+}
+
+void MockCheckedActualCall::setMatchingExpectedCall(MockCheckedExpectedCall* call)
+{
+    matchingExpectation_ = call;
+}
 
 MockActualCallTrace::MockActualCallTrace()
 {

diff --git a/src/CppUTestExt/MockActualCallsQueue.cpp b/src/CppUTestExt/MockActualCallsQueue.cpp
@@ -126,3 +126,24 @@ void MockActualCallsQueue::deleteFromFront()
         delete frontCall;
     }
 }
+
+SimpleString MockActualCallsQueue::toString(const SimpleString& linePrefix) const
+{
+    SimpleString str;
+    for (MockActualCallsQueueNode* p = head_; p; p = p->next_) {
+        str = AppendStringOnANewLine(str, p->call_->toString(), linePrefix);
+    }
+    return ReplaceWithTextNoneWhenEmpty(str, linePrefix);
+}
+
+SimpleString MockActualCallsQueue::toStringFilterByFunction(const SimpleString& functionName, const SimpleString& linePrefix) const
+{
+    SimpleString str;
+    for (MockActualCallsQueueNode* p = head_; p; p = p->next_) {
+        if (p->call_->getName() == functionName) {
+            str = AppendStringOnANewLine(str, p->call_->toString(), linePrefix);
+        }
+    }
+    return ReplaceWithTextNoneWhenEmpty(str, linePrefix);
+}
+
diff --git a/src/CppUTestExt/MockExpectedCall.cpp b/src/CppUTestExt/MockExpectedCall.cpp
@@ -46,7 +46,7 @@ void MockCheckedExpectedCall::setName(const SimpleString& name)
     functionName_ = name;
 }
 
-SimpleString MockCheckedExpectedCall::getName() const
+const SimpleString& MockCheckedExpectedCall::getName() const
 {
     return functionName_;
 }
@@ -308,7 +308,7 @@ void MockCheckedExpectedCall::outputParameterWasPassed(const SimpleString& name)
     }
 }
 
-SimpleString MockCheckedExpectedCall::getInputParameterValueString(const SimpleString& name)
+SimpleString MockCheckedExpectedCall::getInputParameterValueString(const SimpleString& name) const
 {
     MockNamedValue * p = inputParameters_->getValueByName(name);
     return (p) ? StringFrom(*p) : "failed";
@@ -326,14 +326,15 @@ bool MockCheckedExpectedCall::hasOutputParameter(const MockNamedValue& parameter
     return (p) ? p->compatibleForCopying(parameter) : ignoreOtherParameters_;
 }
 
-SimpleString MockCheckedExpectedCall::callToString()
+SimpleString MockCheckedExpectedCall::callToString(bool asActualCall) const
 {
     SimpleString str;
     if (objectPtr_)
         str = StringFromFormat("(object address: %p)::", objectPtr_);
 
     str += getName();
     str += " -> ";
+
     if (initialExpectedCallOrder_ != NO_EXPECTED_CALL_ORDER) {
         if (initialExpectedCallOrder_ == finalExpectedCallOrder_) {
             str += StringFromFormat("expected call order: <%u> -> ", initialExpectedCallOrder_);
@@ -368,23 +369,25 @@ SimpleString MockCheckedExpectedCall::callToString()
             str += ", other parameters are ignored";
     }
 
-    if (actualCalls_ < minCalls_)
-    {
-        if (minCalls_ == maxCalls_)
+    if (!asActualCall) {
+        if (actualCalls_ < minCalls_)
         {
-            str += StringFromFormat(" (expected %d call%s, but was called %d time%s)",
-                                    minCalls_, (minCalls_ == 1) ? "" : "s", actualCalls_, (actualCalls_ == 1) ? "" : "s" );
+            if (minCalls_ == maxCalls_)
+            {
+                str += StringFromFormat(" (expected %d call%s, but was called %d time%s)",
+                                        minCalls_, (minCalls_ == 1) ? "" : "s", actualCalls_, (actualCalls_ == 1) ? "" : "s" );
+            }
+            else
+            {
+                str += StringFromFormat(" (expected at least %d call%s, but was called %d time%s)",
+                                        minCalls_, (minCalls_ == 1) ? "" : "s", actualCalls_, (actualCalls_ == 1) ? "" : "s" );
+            }
         }
         else
         {
-            str += StringFromFormat(" (expected at least %d call%s, but was called %d time%s)",
-                                    minCalls_, (minCalls_ == 1) ? "" : "s", actualCalls_, (actualCalls_ == 1) ? "" : "s" );
+            str += StringFromFormat(" (called %d time%s)", actualCalls_, (actualCalls_ == 1) ? "" : "s");
         }
     }
-    else
-    {
-        str += StringFromFormat(" (called %d time%s)", actualCalls_, (actualCalls_ == 1) ? "" : "s");
-    }
 
     return str;
 }

diff --git a/src/CppUTestExt/MockExpectedCallsList.cpp b/src/CppUTestExt/MockExpectedCallsList.cpp
@@ -314,32 +314,14 @@ void MockExpectedCallsList::outputParameterWasPassed(const SimpleString& paramet
         p->expectedCall_->outputParameterWasPassed(parameterName);
 }
 
-static SimpleString stringOrNoneTextWhenEmpty(const SimpleString& inputString, const SimpleString& linePrefix)
-{
-    SimpleString str = inputString;
-    if (str == "") {
-        str += linePrefix;
-        str += "<none>";
-    }
-    return str;
-}
-
-static SimpleString appendStringOnANewLine(const SimpleString& inputString, const SimpleString& linePrefix, const SimpleString& stringToAppend)
-{
-    SimpleString str = inputString;
-    if (str != "") str += "\n";
-    str += linePrefix;
-    str += stringToAppend;
-    return str;
-}
-
 SimpleString MockExpectedCallsList::unfulfilledCallsToString(const SimpleString& linePrefix) const
 {
     SimpleString str;
     for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
         if (!p->expectedCall_->isFulfilled())
-            str = appendStringOnANewLine(str, linePrefix, p->expectedCall_->callToString());
-    return stringOrNoneTextWhenEmpty(str, linePrefix);
+            str = AppendStringOnANewLine(str, p->expectedCall_->callToString(false), linePrefix);
+
+    return ReplaceWithTextNoneWhenEmpty(str, linePrefix);
 }
 
 SimpleString MockExpectedCallsList::fulfilledCallsToString(const SimpleString& linePrefix) const
@@ -348,19 +330,19 @@ SimpleString MockExpectedCallsList::fulfilledCallsToString(const SimpleString& l
 
     for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
         if (p->expectedCall_->isFulfilled())
-            str = appendStringOnANewLine(str, linePrefix, p->expectedCall_->callToString());
+            str = AppendStringOnANewLine(str, p->expectedCall_->callToString(false), linePrefix);
 
-    return stringOrNoneTextWhenEmpty(str, linePrefix);
+    return ReplaceWithTextNoneWhenEmpty(str, linePrefix);
 }
 
-SimpleString MockExpectedCallsList::missingParametersToString() const
+SimpleString MockExpectedCallsList::missingParametersToString(const SimpleString& linePrefix) const
 {
     SimpleString str;
     for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
-        if (! p->expectedCall_->isMatchingActualCall())
-            str = appendStringOnANewLine(str, "", p->expectedCall_->missingParametersToString());
+        if (p->expectedCall_->canMatchActualCalls())
+            str = AppendStringOnANewLine(str, p->expectedCall_->missingParametersToString(), linePrefix);
 
-    return stringOrNoneTextWhenEmpty(str, "");
+    return ReplaceWithTextNoneWhenEmpty(str, linePrefix);
 }
 
 bool MockExpectedCallsList::hasUnmatchingExpectationsBecauseOfMissingParameters() const

diff --git a/src/CppUTestExt/MockSupport.cpp b/src/CppUTestExt/MockSupport.cpp
@@ -643,3 +643,8 @@ const MockExpectedCallsList& MockSupport::getExpectedCalls() const
     return expectations_;
 }
 
+const SimpleString&  MockSupport::getName() const
+{
+    return mockName_;
+}
+