cpputest · sjstraw · Dec 22, 2014
diff --git a/include/CppUTestExt/MockCheckedActualCall.h b/include/CppUTestExt/MockCheckedActualCall.h
@@ -103,6 +103,10 @@ class MockCheckedActualCall : public MockActualCall
     };
     virtual const char* stringFromState(ActualCallState state);
     virtual void setState(ActualCallState state);
+    ActualCallState getState() { return state_; }
+    void setFulfilledExpectation( MockCheckedExpectedCall *expectation ) { fulfilledExpectation_ = expectation; }
+    MockExpectedCallsList *getUnfulfilledExpectations() { return &unfulfilledExpectations_; }
+    const MockExpectedCallsList& getAllExpectations() { return allExpectations_; }
 
 private:
     SimpleString functionName_;
@@ -190,6 +194,42 @@ class MockActualCallTrace : public MockActualCall
     void addParameterName(const SimpleString& name);
 };
 
+class MockCheckedActualCallTrace : public MockCheckedActualCall
+{
+public:
+	MockCheckedActualCallTrace(int callOrder, MockFailureReporter* reporter, const MockExpectedCallsList& expectations);
+    virtual ~MockCheckedActualCallTrace();
+
+    virtual MockActualCall& withName(const SimpleString&) _override;
+    virtual MockActualCall& withCallOrder(int) _override;
+    virtual MockActualCall& withIntParameter(const SimpleString&, int) _override;
+    virtual MockActualCall& withUnsignedIntParameter(const SimpleString&, unsigned int) _override;
+    virtual MockActualCall& withLongIntParameter(const SimpleString&, long int) _override;
+    virtual MockActualCall& withUnsignedLongIntParameter(const SimpleString&, unsigned long int) _override;
+    virtual MockActualCall& withDoubleParameter(const SimpleString&, double) _override;
+    virtual MockActualCall& withStringParameter(const SimpleString&, const char*) _override;
+    virtual MockActualCall& withPointerParameter(const SimpleString& , void*) _override;
+    virtual MockActualCall& withConstPointerParameter(const SimpleString& , const void*) _override;
+    virtual MockActualCall& withParameterOfType(const SimpleString&, const SimpleString&, const void*) _override;
+    virtual MockActualCall& withOutputParameter(const SimpleString&, void*) _override;
+
+    static const char* getTraceOutput();
+    static void clearTraceOutput();
+
+    virtual void checkExpectations();
+
+protected:
+    virtual void failTest(const MockFailure& failure);
+
+private:
+    static SimpleString traceBuffer_;
+    static SimpleString testName_;
+    MockFailureReporter* reporter_; // Need own copy to use for generating trace messages.
+
+    void addParameterName(const SimpleString& name);
+    void announceTestIfNew();
+};
+
 class MockIgnoredActualCall: public MockActualCall
 {
 public:

diff --git a/src/CppUTestExt/MockActualCall.cpp b/src/CppUTestExt/MockActualCall.cpp
@@ -684,3 +684,230 @@ MockIgnoredActualCall& MockIgnoredActualCall::instance()
     return call;
 }
 
+//
+// MockCheckedActualCallTrace
+//
+// As a descendant of MockCheckedActualCall, it exercises the function call and parameter checking that its ancestor does.
+// However, due to its use for tracing, unexpected calls are reported but the unit test does not abort.
+//
+// Trace output collects in the static member traceBuffer_, which may be accessed via MockCheckedActualCallTrace::getTraceOutput().
+// This trace output is cleared by a direct call to MockCheckedActualCallTrace::clearTraceOutput(), or as one effect of calling mock().clear().
+
+
+// Static class attributes:
+SimpleString MockCheckedActualCallTrace::traceBuffer_;
+SimpleString MockCheckedActualCallTrace::testName_;
+
+MockCheckedActualCallTrace::MockCheckedActualCallTrace(int callOrder, MockFailureReporter* reporter, const MockExpectedCallsList& expectations) :
+		MockCheckedActualCall(callOrder, reporter, expectations), reporter_(reporter)
+{
+	// Nothing more to do here.
+}
+
+MockCheckedActualCallTrace::~MockCheckedActualCallTrace()
+{
+	// A MockCheckedActualCallTrace object is not responsible for any allocated memory.
+}
+
+const char *MockCheckedActualCallTrace::getTraceOutput()
+{
+	return traceBuffer_.asCharString();
+}
+
+void MockCheckedActualCallTrace::clearTraceOutput()
+{
+    traceBuffer_ = "";
+}
+
+void MockCheckedActualCallTrace::checkExpectations()
+{
+    if (getState() != CALL_IN_PROGESS) return;
+
+    // When tracing, it is possible for there to be no unfulfilled expectations.
+    if (! getUnfulfilledExpectations()->hasUnfullfilledExpectations())
+    	return;
+
+    MockCheckedExpectedCall* expectation = getUnfulfilledExpectations()->removeOneFulfilledExpectationWithIgnoredParameters();
+    setFulfilledExpectation(expectation);
+    if (expectation) {
+        callHasSucceeded();
+        return;
+    }
+
+    if (getUnfulfilledExpectations()->hasUnfulfilledExpectationsBecauseOfMissingParameters()) {
+        MockExpectedParameterDidntHappenFailure failure(getTest(), getName(), getAllExpectations());
+        failTest(failure);
+    }
+    else {
+        MockExpectedObjectDidntHappenFailure failure(getTest(), getName(), getAllExpectations());
+        failTest(failure);
+    }
+}
+
+
+
+void MockCheckedActualCallTrace::failTest(const MockFailure& failure)
+{
+	// When tracing, what usually causes a failure
+	// is only reported, and test execution continues.
+
+	SimpleString traceMessage = failure.getMessage();
+
+	// Remove the word, 'Failure' from the message.
+	traceMessage.replace("Failure", "Trace");
+
+    reporter_->getTestToFail()->print(traceMessage,failure.getFileName().asCharString(), failure.getFailureLineNumber());
+}
+
+/**
+ * Adds a line to the trace buffer to announce the new test name.
+ */
+void MockCheckedActualCallTrace::announceTestIfNew()
+{
+	SimpleString currentTestName = UtestShell::getCurrent()->getFormattedName();
+	if ( currentTestName != testName_)
+	{
+		testName_ = currentTestName;
+		traceBuffer_ += "\nTRACE of ";
+		traceBuffer_ += testName_;
+		traceBuffer_ += ":";
+	}
+}
+
+MockActualCall& MockCheckedActualCallTrace::withName(const SimpleString& name)
+{
+	// Update trace buffer
+	announceTestIfNew();
+    traceBuffer_ += "\nFunction name: ";
+    traceBuffer_ += name;
+
+    // Call base class functionality
+    return MockCheckedActualCall::withName(name);
+}
+
+MockActualCall& MockCheckedActualCallTrace::withCallOrder(int callOrder)
+{
+	// Update trace buffer
+    traceBuffer_ += " withCallOrder:";
+    traceBuffer_ += StringFrom(callOrder);
+
+    // Call base class functionality
+    return MockCheckedActualCall::withCallOrder(callOrder);
+}
+
+/**
+ * Helper function for withXxxxParameter() functions.
+ *
+ * Adds the parameter name to the trace buffer.
+ *
+ * @param name Parameter name
+ */
+void MockCheckedActualCallTrace::addParameterName(const SimpleString& name)
+{
+    traceBuffer_ += " ";
+    traceBuffer_ += name;
+    traceBuffer_ += ":";
+}
+
+MockActualCall& MockCheckedActualCallTrace::withIntParameter(const SimpleString& name, int value)
+{
+	// Update trace buffer
+    addParameterName(name);
+    traceBuffer_ += StringFrom(value);
+
+    // Call base class functionality
+    return MockCheckedActualCall::withIntParameter(name, value);
+}
+
+MockActualCall& MockCheckedActualCallTrace::withUnsignedIntParameter(const SimpleString& name, unsigned int value)
+{
+	// Update trace buffer
+    addParameterName(name);
+    traceBuffer_ += StringFrom(value);
+
+    // Call base class functionality
+    return MockCheckedActualCall::withUnsignedIntParameter(name, value);
+}
+
+MockActualCall& MockCheckedActualCallTrace::withLongIntParameter(const SimpleString& name, long int value)
+{
+	// Update trace buffer
+    addParameterName(name);
+    traceBuffer_ += StringFrom(value);
+
+    // Call base class functionality
+    return MockCheckedActualCall::withLongIntParameter(name, value);
+}
+
+MockActualCall& MockCheckedActualCallTrace::withUnsignedLongIntParameter(const SimpleString& name, unsigned long int value)
+{
+	// Update trace buffer
+    addParameterName(name);
+    traceBuffer_ += StringFrom(value);
+
+    // Call base class functionality
+    return MockCheckedActualCall::withUnsignedLongIntParameter(name, value);
+}
+
+MockActualCall& MockCheckedActualCallTrace::withDoubleParameter(const SimpleString& name, double value)
+{
+	// Update trace buffer
+    addParameterName(name);
+    traceBuffer_ += StringFrom(value);
+
+    // Call base class functionality
+    return MockCheckedActualCall::withDoubleParameter(name, value);
+}
+
+MockActualCall& MockCheckedActualCallTrace::withStringParameter(const SimpleString& name, const char *value)
+{
+	// Update trace buffer
+    addParameterName(name);
+    traceBuffer_ += StringFrom(value);
+
+    // Call base class functionality
+    return MockCheckedActualCall::withStringParameter(name, value);
+}
+
+MockActualCall& MockCheckedActualCallTrace::withPointerParameter(const SimpleString& name, void *value)
+{
+	// Update trace buffer
+    addParameterName(name);
+    traceBuffer_ += StringFrom(value);
+
+    // Call base class functionality
+    return MockCheckedActualCall::withPointerParameter(name, value);
+}
+
+MockActualCall& MockCheckedActualCallTrace::withConstPointerParameter(const SimpleString& name, const void *value)
+{
+	// Update trace buffer
+    addParameterName(name);
+    traceBuffer_ += StringFrom(value);
+
+    // Call base class functionality
+    return MockCheckedActualCall::withConstPointerParameter(name, value);
+}
+
+MockActualCall& MockCheckedActualCallTrace::withParameterOfType(const SimpleString& typeName, const SimpleString& name, const void* value)
+{
+	// Update trace buffer
+    traceBuffer_ += " ";
+    traceBuffer_ += typeName;
+    addParameterName(name);
+    traceBuffer_ += StringFrom(value);
+
+    // Call base class functionality
+    return MockCheckedActualCall::withParameterOfType(typeName, name, value);
+}
+
+MockActualCall& MockCheckedActualCallTrace::withOutputParameter(const SimpleString& name, void* output)
+{
+	// Update trace buffer
+	traceBuffer_ += " (out)";
+    addParameterName(name);
+    traceBuffer_ += StringFrom(output);
+
+    // Call base class functionality
+    return MockCheckedActualCall::withOutputParameter(name, output);
+}
diff --git a/src/CppUTestExt/MockNamedValue.cpp b/src/CppUTestExt/MockNamedValue.cpp
@@ -37,7 +37,7 @@ void MockNamedValue::setDefaultComparatorRepository(MockNamedValueComparatorRepo
     defaultRepository_ = repository;
 }
 
-MockNamedValue::MockNamedValue(const SimpleString& name) : name_(name), type_("int"), comparator_(NULL)
+MockNamedValue::MockNamedValue(const SimpleString& name) : name_(name), type_("int"), size_(sizeof(int)), comparator_(NULL)
 {
     value_.intValue_ = 0;
 }

diff --git a/src/CppUTestExt/MockSupport.cpp b/src/CppUTestExt/MockSupport.cpp
@@ -111,6 +111,7 @@ void MockSupport::clear()
 
     tracing_ = false;
     MockActualCallTrace::instance().clear();
+    MockCheckedActualCallTrace::clearTraceOutput();
 
     expectations_.deleteAllExpectationsAndClearList();
     compositeCalls_.clear();
@@ -158,7 +159,11 @@ MockExpectedCall& MockSupport::expectNCalls(int amount, const SimpleString& func
 
 MockCheckedActualCall* MockSupport::createActualFunctionCall()
 {
-    lastActualFunctionCall_ = new MockCheckedActualCall(++callOrder_, activeReporter_, expectations_);
+	if (tracing_)
+		lastActualFunctionCall_ = new MockCheckedActualCallTrace(++callOrder_, activeReporter_, expectations_);
+	else
+		lastActualFunctionCall_ = new MockCheckedActualCall(++callOrder_, activeReporter_, expectations_);
+
     return lastActualFunctionCall_;
 }
 
@@ -171,8 +176,6 @@ MockActualCall& MockSupport::actualCall(const SimpleString& functionName)
     }
 
     if (!enabled_) return MockIgnoredActualCall::instance();
-    if (tracing_) return MockActualCallTrace::instance().withName(functionName);
-
 
     if (!expectations_.hasExpectationWithName(functionName) && ignoreOtherCalls_) {
         return MockIgnoredActualCall::instance();
@@ -217,7 +220,7 @@ void MockSupport::tracing(bool enabled)
 
 const char* MockSupport::getTraceOutput()
 {
-    return MockActualCallTrace::instance().getTraceOutput();
+    return MockCheckedActualCallTrace::getTraceOutput();
 }
 
 bool MockSupport::expectedCallsLeft()