cpputest · KisImre · Oct 15, 2015 · Oct 15, 2015 · Oct 15, 2015 · Oct 15, 2015
diff --git a/include/CppUTestExt/MockActualCall.h b/include/CppUTestExt/MockActualCall.h
@@ -57,6 +57,8 @@ class MockActualCall
    virtual MockActualCall& withParameterOfType(const SimpleString& typeName, const SimpleString& name, const void* value)=0;
    virtual MockActualCall& withOutputParameter(const SimpleString& name, void* output)=0;
    virtual MockActualCall& withOutputParameterOfType(const SimpleString& typeName, const SimpleString& name, void* output)=0;
+    virtual MockActualCall& withInputParameter(const SimpleString& name, const void* output)=0;
+    virtual MockActualCall& withInputParameterOfType(const SimpleString& typeName, const SimpleString& name, const void* output)=0;

    virtual MockActualCall& withBoolParameter(const SimpleString& name, bool value)=0;
    virtual MockActualCall& withIntParameter(const SimpleString& name, int value)=0;

diff --git a/include/CppUTestExt/MockCheckedActualCall.h b/include/CppUTestExt/MockCheckedActualCall.h
@@ -53,6 +53,8 @@ class MockCheckedActualCall : public MockActualCall
    virtual MockActualCall& withParameterOfType(const SimpleString& type, const SimpleString& name, const void* value) _override;
    virtual MockActualCall& withOutputParameter(const SimpleString& name, void* output) _override;
    virtual MockActualCall& withOutputParameterOfType(const SimpleString& type, const SimpleString& name, void* output) _override;
+    virtual MockActualCall& withInputParameter(const SimpleString& name, const void* output) _override;
+    virtual MockActualCall& withInputParameterOfType(const SimpleString& typeName, const SimpleString& name, const void* output) _override;

    virtual bool hasReturnValue() _override;
    virtual MockNamedValue returnValue() _override;
@@ -132,15 +134,20 @@ class MockCheckedActualCall : public MockActualCall
        SimpleString name_;
        SimpleString type_;
        void* ptr_;
+        const void* constPtr_;

        MockOutputParametersListNode* next_;
        MockOutputParametersListNode(const SimpleString& name, const SimpleString& type, void* ptr)
-            : name_(name), type_(type), ptr_(ptr), next_(NULLPTR) {}
+            : name_(name), type_(type), ptr_(ptr), constPtr_(NULLPTR), next_(NULLPTR) {}
+        MockOutputParametersListNode(const SimpleString& name, const SimpleString& type, const void* constPtr)
+            : name_(name), type_(type), ptr_(NULLPTR), constPtr_(constPtr), next_(NULLPTR) {}
    };

    MockOutputParametersListNode* outputParameterExpectations_;

    virtual void addOutputParameter(const SimpleString& name, const SimpleString& type, void* ptr);
+    virtual void addOutputParameter(const SimpleString& name, const SimpleString& type, const void* constPtr);
+    virtual void addOutputParameterNode(MockOutputParametersListNode *newNode);
    virtual void cleanUpOutputParameterList();
 };

@@ -166,6 +173,8 @@ class MockActualCallTrace : public MockActualCall
    virtual MockActualCall& withParameterOfType(const SimpleString& typeName, const SimpleString& name, const void* value) _override;
    virtual MockActualCall& withOutputParameter(const SimpleString& name, void* output) _override;
    virtual MockActualCall& withOutputParameterOfType(const SimpleString& typeName, const SimpleString& name, void* output) _override;
+    virtual MockActualCall& withInputParameter(const SimpleString& name, const void* output) _override;
+    virtual MockActualCall& withInputParameterOfType(const SimpleString& typeName, const SimpleString& name, const void* output) _override;

    virtual bool hasReturnValue() _override;
    virtual MockNamedValue returnValue() _override;
@@ -231,6 +240,8 @@ class MockIgnoredActualCall: public MockActualCall
    virtual MockActualCall& withParameterOfType(const SimpleString&, const SimpleString&, const void*) _override { return *this; }
    virtual MockActualCall& withOutputParameter(const SimpleString&, void*) _override { return *this; }
    virtual MockActualCall& withOutputParameterOfType(const SimpleString&, const SimpleString&, void*) _override { return *this; }
+    virtual MockActualCall& withInputParameter(const SimpleString&, const void*) _override { return *this; }
+    virtual MockActualCall& withInputParameterOfType(const SimpleString&, const SimpleString&, const void*) _override { return *this; }

    virtual bool hasReturnValue() _override { return false; }
    virtual MockNamedValue returnValue() _override { return MockNamedValue(""); }

diff --git a/include/CppUTestExt/MockCheckedExpectedCall.h b/include/CppUTestExt/MockCheckedExpectedCall.h
@@ -56,6 +56,8 @@ class MockCheckedExpectedCall : public MockExpectedCall
    virtual MockExpectedCall& withParameterOfType(const SimpleString& typeName, const SimpleString& name, const void* value) _override;
    virtual MockExpectedCall& withOutputParameterReturning(const SimpleString& name, const void* value, size_t size) _override;
    virtual MockExpectedCall& withOutputParameterOfTypeReturning(const SimpleString& typeName, const SimpleString& name, const void* value) _override;
+    virtual MockExpectedCall& withInputParameterForwarding(const SimpleString& name, void* value, size_t size) _override;
+    virtual MockExpectedCall& withInputParameterOfTypeForwarding(const SimpleString& typeName, const SimpleString& name, void* value) _override;
    virtual MockExpectedCall& ignoreOtherParameters() _override;

    virtual MockExpectedCall& andReturnValue(bool value) _override;
@@ -162,6 +164,8 @@ class MockIgnoredExpectedCall: public MockExpectedCall
    virtual MockExpectedCall& withParameterOfType(const SimpleString&, const SimpleString&, const void*) _override { return *this; }
    virtual MockExpectedCall& withOutputParameterReturning(const SimpleString&, const void*, size_t) _override { return *this; }
    virtual MockExpectedCall& withOutputParameterOfTypeReturning(const SimpleString&, const SimpleString&, const void*) _override { return *this; }
+    virtual MockExpectedCall& withInputParameterForwarding(const SimpleString&, void*, size_t) _override { return *this; }
+    virtual MockExpectedCall& withInputParameterOfTypeForwarding(const SimpleString&, const SimpleString&, void*) _override { return *this; }
    virtual MockExpectedCall& ignoreOtherParameters() _override { return *this;}

    virtual MockExpectedCall& andReturnValue(bool) _override { return *this; }

diff --git a/include/CppUTestExt/MockExpectedCall.h b/include/CppUTestExt/MockExpectedCall.h
@@ -55,6 +55,8 @@ class MockExpectedCall
    virtual MockExpectedCall& withParameterOfType(const SimpleString& typeName, const SimpleString& name, const void* value)=0;
    virtual MockExpectedCall& withOutputParameterReturning(const SimpleString& name, const void* value, size_t size)=0;
    virtual MockExpectedCall& withOutputParameterOfTypeReturning(const SimpleString& typeName, const SimpleString& name, const void* value)=0;
+    virtual MockExpectedCall& withInputParameterForwarding(const SimpleString& name, void* value, size_t size)=0;
+    virtual MockExpectedCall& withInputParameterOfTypeForwarding(const SimpleString& typeName, const SimpleString& name, void* value)=0;
    virtual MockExpectedCall& ignoreOtherParameters()=0;

    virtual MockExpectedCall& withBoolParameter(const SimpleString& name, bool value)=0;

diff --git a/include/CppUTestExt/MockSupport_c.h b/include/CppUTestExt/MockSupport_c.h
@@ -86,6 +86,8 @@ struct SMockActualCall_c
    MockActualCall_c* (*withParameterOfType)(const char* type, const char* name, const void* value);
    MockActualCall_c* (*withOutputParameter)(const char* name, void* value);
    MockActualCall_c* (*withOutputParameterOfType)(const char* type, const char* name, void* value);
+    MockActualCall_c* (*withInputParameter)(const char* name, const void* value);
+    MockActualCall_c* (*withInputParameterOfType)(const char* type, const char* name, const void* value);
    int (*hasReturnValue)(void);
    MockValue_c (*returnValue)(void);
    int (*boolReturnValue)(void);
@@ -127,6 +129,8 @@ struct SMockExpectedCall_c
    MockExpectedCall_c* (*withParameterOfType)(const char* type, const char* name, const void* value);
    MockExpectedCall_c* (*withOutputParameterReturning)(const char* name, const void* value, size_t size);
    MockExpectedCall_c* (*withOutputParameterOfTypeReturning)(const char* type, const char* name, const void* value);
+    MockExpectedCall_c* (*withInputParameterForwarding)(const char* name, void* value, size_t size);
+    MockExpectedCall_c* (*withInputParameterOfTypeForwarding)(const char* type, const char* name, void* value);
    MockExpectedCall_c* (*ignoreOtherParameters)(void);

    MockExpectedCall_c* (*andReturnBoolValue)(int value);

diff --git a/src/CppUTestExt/MockActualCall.cpp b/src/CppUTestExt/MockActualCall.cpp
@@ -87,14 +87,29 @@ void MockCheckedActualCall::copyOutputParameters(MockCheckedExpectedCall* expect
        MockNamedValueCopier* copier = outputParameter.getCopier();
        if (copier)
        {
-            copier->copy(p->ptr_, outputParameter.getConstObjectPointer());
+            if (p->ptr_ != NULLPTR)
+            {
+                // Test to code direction
+                copier->copy(p->ptr_, outputParameter.getConstObjectPointer());
+            }
+            else if (p->constPtr_ != NULLPTR)
+            {
+                // Code to test direction
+                copier->copy(outputParameter.getObjectPointer(), p->constPtr_);
+            }
        }
        else if ((outputParameter.getType() == "const void*") && (p->type_ == "void*"))
        {
            const void* data = outputParameter.getConstPointerValue();
            size_t size = outputParameter.getSize();
            PlatformSpecificMemCpy(p->ptr_, data, size);
        }
+        else if ((outputParameter.getType() == "void*") && (p->type_ == "const void*"))
+        {
+            void* data = outputParameter.getPointerValue();
+            size_t size = outputParameter.getSize();
+            PlatformSpecificMemCpy(data, p->constPtr_, size);
+        }
        else if (outputParameter.getName() != "")
        {
            SimpleString type = expectedCall->getOutputParameter(p->name_).getType();
@@ -325,6 +340,28 @@ MockActualCall& MockCheckedActualCall::withOutputParameterOfType(const SimpleStr
    return *this;
 }

+MockActualCall& MockCheckedActualCall::withInputParameter(const SimpleString& name, const void* output)
+{
+    addOutputParameter(name, "const void*", output);
+
+    MockNamedValue outputParameter(name);
+    outputParameter.setValue(output);
+    checkOutputParameter(outputParameter);
+
+    return *this;
+}
+
+MockActualCall& MockCheckedActualCall::withInputParameterOfType(const SimpleString& typeName, const SimpleString& name, const void* output)
+{
+    addOutputParameter(name, typeName, output);
+
+    MockNamedValue outputParameter(name);
+    outputParameter.setConstObjectPointer(typeName, output);
+    checkOutputParameter(outputParameter);
+
+    return *this;
+}
+
 bool MockCheckedActualCall::isFulfilled() const
 {
    return state_ == CALL_SUCCEED;
@@ -549,8 +586,16 @@ MockActualCall& MockCheckedActualCall::onObject(const void* objectPtr)

 void MockCheckedActualCall::addOutputParameter(const SimpleString& name, const SimpleString& type, void* ptr)
 {
-    MockOutputParametersListNode* newNode = new MockOutputParametersListNode(name, type, ptr);
+    addOutputParameterNode(new MockOutputParametersListNode(name, type, ptr));
+}

+void MockCheckedActualCall::addOutputParameter(const SimpleString& name, const SimpleString& type, const void* constPtr)
+{
+    addOutputParameterNode(new MockOutputParametersListNode(name, type, constPtr));
+}
+
+void MockCheckedActualCall::addOutputParameterNode(MockOutputParametersListNode *newNode)
+{
    if (outputParameterExpectations_ == NULLPTR)
        outputParameterExpectations_ = newNode;
    else {
@@ -704,6 +749,22 @@ MockActualCall& MockActualCallTrace::withOutputParameterOfType(const SimpleStrin
    return *this;
 }

+MockActualCall& MockActualCallTrace::withInputParameter(const SimpleString& name, const void* output)
+{
+    addParameterName(name);
+    traceBuffer_ += StringFrom(output);
+    return *this;
+}
+
+MockActualCall& MockActualCallTrace::withInputParameterOfType(const SimpleString& typeName, const SimpleString& name, const void* output)
+{
+    traceBuffer_ += " ";
+    traceBuffer_ += typeName;
+    addParameterName(name);
+    traceBuffer_ += StringFrom(output);
+    return *this;
+}
+
 bool MockActualCallTrace::hasReturnValue()
 {
    return false;

diff --git a/src/CppUTestExt/MockExpectedCall.cpp b/src/CppUTestExt/MockExpectedCall.cpp
@@ -198,6 +198,23 @@ MockExpectedCall& MockCheckedExpectedCall::withOutputParameterOfTypeReturning(co
    return *this;
 }

+MockExpectedCall& MockCheckedExpectedCall::withInputParameterForwarding(const SimpleString& name, void* value, size_t size)
+{
+    MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
+    outputParameters_->add(newParameter);
+    newParameter->setValue(value);
+    newParameter->setSize(size);
+    return *this;
+}
+
+MockExpectedCall& MockCheckedExpectedCall::withInputParameterOfTypeForwarding(const SimpleString& typeName, const SimpleString& name, void* value)
+{
+    MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
+    outputParameters_->add(newParameter);
+    newParameter->setObjectPointer(typeName, value);
+    return *this;
+}
+
 SimpleString MockCheckedExpectedCall::getInputParameterType(const SimpleString& name)
 {
    MockNamedValue * p = inputParameters_->getValueByName(name);

diff --git a/src/CppUTestExt/MockNamedValue.cpp b/src/CppUTestExt/MockNamedValue.cpp
@@ -337,6 +337,9 @@ bool MockNamedValue::compatibleForCopying(const MockNamedValue& p) const
    if ((type_ == "const void*") && (p.type_ == "void*"))
        return true;

+    if ((type_ == "void*") && (p.type_ == "const void*"))
+        return true;
+
    return false;
 }


diff --git a/src/CppUTestExt/MockSupport_c.cpp b/src/CppUTestExt/MockSupport_c.cpp
@@ -157,6 +157,8 @@ MockExpectedCall_c* withMemoryBufferParameters_c(const char* name, const unsigne
 MockExpectedCall_c* withParameterOfType_c(const char* type, const char* name, const void* value);
 MockExpectedCall_c* withOutputParameterReturning_c(const char* name, const void* value, size_t size);
 MockExpectedCall_c* withOutputParameterOfTypeReturning_c(const char* type, const char* name, const void* value);
+MockExpectedCall_c* withInputParameterForwarding_c(const char* name, void* value, size_t size);
+MockExpectedCall_c* withInputParameterOfTypeForwarding_c(const char* type, const char* name, void* value);
 MockExpectedCall_c* ignoreOtherParameters_c();
 MockExpectedCall_c* andReturnBoolValue_c(int value);
 MockExpectedCall_c* andReturnIntValue_c(int value);
@@ -183,6 +185,8 @@ MockActualCall_c* withActualMemoryBufferParameters_c(const char* name, const uns
 MockActualCall_c* withActualParameterOfType_c(const char* type, const char* name, const void* value);
 MockActualCall_c* withActualOutputParameter_c(const char* name, void* value);
 MockActualCall_c* withActualOutputParameterOfType_c(const char* type, const char* name, void* value);
+MockActualCall_c* withActualInputParameter_c(const char* name, const void* value);
+MockActualCall_c* withActualInputParameterOfType_c(const char* type, const char* name, const void* value);
 MockValue_c returnValue_c();
 int boolReturnValue_c();
 int returnBoolValueOrDefault_c(int defaultValue);
@@ -247,6 +251,8 @@ static MockExpectedCall_c gExpectedCall = {
        withParameterOfType_c,
        withOutputParameterReturning_c,
        withOutputParameterOfTypeReturning_c,
+        withInputParameterForwarding_c,
+        withInputParameterOfTypeForwarding_c,
        ignoreOtherParameters_c,
        andReturnBoolValue_c,
        andReturnUnsignedIntValue_c,
@@ -275,6 +281,8 @@ static MockActualCall_c gActualCall = {
        withActualParameterOfType_c,
        withActualOutputParameter_c,
        withActualOutputParameterOfType_c,
+        withActualInputParameter_c,
+        withActualInputParameterOfType_c,
        hasReturnValue_c,
        returnValue_c,
        boolReturnValue_c,
@@ -434,6 +442,18 @@ MockExpectedCall_c* withOutputParameterOfTypeReturning_c(const char* type, const
    return &gExpectedCall;
 }

+MockExpectedCall_c* withInputParameterForwarding_c(const char* name, void* value, size_t size)
+{
+    expectedCall = &expectedCall->withInputParameterForwarding(name, value, size);
+    return &gExpectedCall;
+}
+
+MockExpectedCall_c* withInputParameterOfTypeForwarding_c(const char* type, const char* name, void* value)
+{
+    expectedCall = &expectedCall->withInputParameterOfTypeForwarding(type, name, value);
+    return &gExpectedCall;
+}
+
 MockExpectedCall_c* ignoreOtherParameters_c()
 {
    expectedCall = &expectedCall->ignoreOtherParameters();
@@ -666,6 +686,18 @@ MockActualCall_c* withActualOutputParameterOfType_c(const char* type, const char
    return &gActualCall;
 }

+MockActualCall_c* withActualInputParameter_c(const char* name, const void* value)
+{
+    actualCall = &actualCall->withInputParameter(name, value);
+    return &gActualCall;
+}
+
+MockActualCall_c* withActualInputParameterOfType_c(const char* type, const char* name, const void* value)
+{
+    actualCall = &actualCall->withInputParameterOfType(type, name, value);
+    return &gActualCall;
+}
+
 MockValue_c returnValue_c()
 {
    return getMockValueCFromNamedValue(actualCall->returnValue());

diff --git a/tests/CppUTestExt/MockExpectedCallTest.cpp b/tests/CppUTestExt/MockExpectedCallTest.cpp
@@ -728,6 +728,8 @@ TEST(MockIgnoredExpectedCall, worksAsItShould)
    ignored.withParameterOfType( "mytype", "top", (const void*) NULLPTR);
    ignored.withOutputParameterReturning("bar", (void*) NULLPTR, 1);
    ignored.withOutputParameterOfTypeReturning("mytype", "bar", (const void*) NULLPTR);
+    ignored.withInputParameterForwarding("fos", (void*) NULLPTR, 1);
+    ignored.withInputParameterOfTypeForwarding("haz", "cso", (void*) NULLPTR);
    ignored.ignoreOtherParameters();
    ignored.andReturnValue(true);
    ignored.andReturnValue((double) 1.0f);