Refactored the NamedValue for Mocking. This way it will be better to …

…add new features

examples/ApplicationLib/EventDispatcherTest.cpp

@@ -18,7 +18,7 @@ class ObserverMock : public EventObserver
 	}
 };
 
-class EventComparator : public MockParameterComparator
+class EventComparator : public MockNamedValueComparator
 {
 public:
 	virtual bool isEqual(void* object1, void* object2)

include/CppUTestExt/MockActualFunctionCall.h

@@ -33,7 +33,7 @@
 
 class MockFailureReporter;
 class MockFailure;
-class MockFunctionParameter;
+class MockNamedValue;
 
 class MockActualFunctionCall : public MockFunctionCall
 {
@@ -57,7 +57,7 @@ class MockActualFunctionCall : public MockFunctionCall
 	virtual Utest* getTest() const;
 	virtual void callHasSucceeded();
 	virtual void failTest(const MockFailure& failure);
-	virtual void checkActualParameter(const MockFunctionParameter& actualParameter);
+	virtual void checkActualParameter(const MockNamedValue& actualParameter);
 
 	enum ActualCallState {
 		CALL_IN_PROGESS,

include/CppUTestExt/MockExpectedFunctionCall.h

@@ -30,29 +30,7 @@
 
 #include "CppUTestExt/MockFunctionCall.h"
 
-union MockParameterValue{
-	int intValue_;
-	double doubleValue_;
-	const char* stringValue_;
-	void* pointerValue_;
-	void* objectPointerValue_;
-};
-
-struct MockFunctionParameter
-{
-	MockFunctionParameter(const SimpleString& name, const SimpleString& type)
-		: name_(name), type_(type), fulfilled_(false), comparator_(NULL), nextParameter(NULL){}
-
-	SimpleString name_;
-	SimpleString type_;
-	MockParameterValue value_;
-	bool fulfilled_;
-	MockParameterComparator* comparator_;
-	MockFunctionParameter* nextParameter;
-};
-
-
-extern SimpleString StringFrom(const MockFunctionParameter& parameter);
+extern SimpleString StringFrom(const MockNamedValue& parameter);
 
 class MockExpectedFunctionCall : public MockFunctionCall
 {
@@ -73,7 +51,7 @@ class MockExpectedFunctionCall : public MockFunctionCall
 	virtual SimpleString getParameterValueString(const SimpleString& name);
 
 	virtual bool hasParameterWithName(const SimpleString& name);
-	virtual bool hasParameter(const MockFunctionParameter& parameter);
+	virtual bool hasParameter(const MockNamedValue& parameter);
 	virtual bool relatesTo(const SimpleString& functionName);
 
 	virtual bool isFulfilled();
@@ -87,12 +65,29 @@ class MockExpectedFunctionCall : public MockFunctionCall
 	virtual SimpleString missingParametersToString();
 
 private:
+
+	class MockExpectedFunctionParameter : public MockNamedValue
+	{
+	public:
+		MockExpectedFunctionParameter(const SimpleString& name)
+			: MockNamedValue(name), fulfilled_(false) {}
+
+		bool fulfilled_;
+	};
+
+	struct MockFunctionParameterNode
+	{
+		MockFunctionParameterNode(MockExpectedFunctionParameter* data) : data_(data), next_(NULL) {}
+		MockExpectedFunctionParameter* data_;
+		MockFunctionParameterNode* next_;
+	};
+
 	bool wasCallMade_;
-	MockFunctionParameter* parameters_;
+	MockFunctionParameterNode* parameters_;
 
-	MockFunctionParameter* addNewParameter(const SimpleString& name, const SimpleString& type);
-	bool parametersEqual(const MockFunctionParameter& p1, const MockFunctionParameter& p2);
-	MockFunctionParameter* getParameterByName(const SimpleString& name);
+	MockNamedValue* addNewParameter(const SimpleString& name);
+	bool parametersEqual(const MockNamedValue& p1, const MockNamedValue& p2);
+	MockNamedValue* getParameterByName(const SimpleString& name);
 
 };
 

include/CppUTestExt/MockExpectedFunctionsList.h

@@ -29,7 +29,7 @@
 #define D_MockExpectedFunctionsList_h
 
 class MockExpectedFunctionCall;
-class MockFunctionParameter;
+class MockNamedValue;
 
 class MockExpectedFunctionsList
 {
@@ -53,11 +53,11 @@ class MockExpectedFunctionsList
 	virtual void addUnfilfilledExpectations(const MockExpectedFunctionsList& list);
 
 	virtual void onlyKeepExpectationsRelatedTo(const SimpleString& name);
-	virtual void onlyKeepExpectationsWithParameter(const MockFunctionParameter& parameter);
+	virtual void onlyKeepExpectationsWithParameter(const MockNamedValue& parameter);
 	virtual void onlyKeepExpectationsWithParameterName(const SimpleString& name);
 	virtual void onlyKeepUnfulfilledExpectations();
 	virtual void onlyKeepUnfulfilledExpectationsRelatedTo(const SimpleString& name);
-	virtual void onlyKeepUnfulfilledExpectationsWithParameter(const MockFunctionParameter& parameter);
+	virtual void onlyKeepUnfulfilledExpectationsWithParameter(const MockNamedValue& parameter);
 
 	virtual void removeOneFulfilledExpectation();
 

include/CppUTestExt/MockFailure.h

@@ -33,7 +33,7 @@
 
 class MockExpectedFunctionsList;
 class MockActualFunctionCall;
-class MockFunctionParameter;
+class MockNamedValue;
 class MockFailure;
 
 class MockFailureReporter
@@ -77,7 +77,7 @@ class MockUnexpectedCallHappenedFailure : public MockFailure
 class MockUnexpectedParameterFailure : public MockFailure
 {
 public:
-	MockUnexpectedParameterFailure(Utest* test, const SimpleString& functionName, const MockFunctionParameter& parameter, const MockExpectedFunctionsList& expectations);
+	MockUnexpectedParameterFailure(Utest* test, const SimpleString& functionName, const MockNamedValue& parameter, const MockExpectedFunctionsList& expectations);
 	virtual ~MockUnexpectedParameterFailure(){};
 };
 

include/CppUTestExt/MockFunctionCall.h

@@ -30,26 +30,68 @@
 
 /*
  * MockParameterComparator is an interface that needs to be used when creating Comparators.
- * This is needed when comparing parameters of non-native type.
- *
+ * This is needed when comparing values of non-native type.
  */
 
-class MockParameterComparator
+class MockNamedValueComparator
 {
 public:
-	MockParameterComparator() {};
-	virtual ~MockParameterComparator() {};
+	MockNamedValueComparator() {};
+	virtual ~MockNamedValueComparator() {};
 
 	virtual bool isEqual(void* object1, void* object2)=0;
 	virtual SimpleString valueToString(void* object)=0;
 };
 
+
+/*
+ * MockNamedValue is the generic value class used. It encapsulates basic types and can use them "as if one"
+ * Also it enables other types by putting object pointers. They can be compared with comparators.
+ *
+ * Basically this class ties together a Name, a Value, a Type, and a Comparator
+ */
+
+class MockNamedValue
+{
+public:
+	MockNamedValue(const SimpleString& name);
+	virtual ~MockNamedValue();
+
+	virtual void setValue(int value);
+	virtual void setValue(double value);
+	virtual void setValue(void* value);
+	virtual void setValue(const char* value);
+	virtual void setObjectPointer(const SimpleString& type, void* objectPtr);
+
+	virtual void setComparator(MockNamedValueComparator* comparator);
+
+	virtual bool equals(const MockNamedValue& p) const;
+
+	virtual SimpleString toString() const;
+
+	virtual SimpleString getName() const;
+	virtual SimpleString getType() const;
+
+	virtual MockParameterValue getValue();
+private:
+	SimpleString name_;
+	SimpleString type_;
+	union {
+		int intValue_;
+		double doubleValue_;
+		const char* stringValue_;
+		void* pointerValue_;
+		void* objectPointerValue_;
+	} value_;
+	MockNamedValueComparator* comparator_;
+};
+
 /*
  * MockFunctionCall is the main interface for recording and actualizing mock calls.
  *
  */
 
-class MockParameterComparatorRepository;
+class MockNamedValueComparatorRepository;
 class MockFunctionCall
 {
 public:
@@ -63,32 +105,32 @@ class MockFunctionCall
 	virtual MockFunctionCall& withParameter(const SimpleString& name, void* value)=0;
 	virtual MockFunctionCall& withParameterOfType(const SimpleString& typeName, const SimpleString& name, void* value)=0;
 
-	virtual void setComparatorRepository(MockParameterComparatorRepository* repository);
+	virtual void setComparatorRepository(MockNamedValueComparatorRepository* repository);
 
 protected:
 	void setName(const SimpleString& name);
 	SimpleString getName() const;
-	MockParameterComparator* getComparatorForType(const SimpleString& type) const;
+	MockNamedValueComparator* getComparatorForType(const SimpleString& type) const;
 private:
 	SimpleString functionName_;
-	MockParameterComparatorRepository* comparatorRepository_;
+	MockNamedValueComparatorRepository* comparatorRepository_;
 };
 
 /*
  * MockParameterComparatorRepository is a class which stores comparators which can be used for comparing non-native types
  *
  */
 
-struct MockParameterComparatorRepositoryNode;
-class MockParameterComparatorRepository
+struct MockNamedValueComparatorRepositoryNode;
+class MockNamedValueComparatorRepository
 {
-	MockParameterComparatorRepositoryNode* head_;
+	MockNamedValueComparatorRepositoryNode* head_;
 public:
-	MockParameterComparatorRepository();
-	virtual ~MockParameterComparatorRepository();
+	MockNamedValueComparatorRepository();
+	virtual ~MockNamedValueComparatorRepository();
 
-	virtual void installComparator(const SimpleString& name, MockParameterComparator& comparator);
-	virtual MockParameterComparator* getComparatorForType(const SimpleString& name);
+	virtual void installComparator(const SimpleString& name, MockNamedValueComparator& comparator);
+	virtual MockNamedValueComparator* getComparatorForType(const SimpleString& name);
 
 	void clear();
 };

include/CppUTestExt/MockSupport.h

@@ -54,7 +54,7 @@ class MockSupport
 	virtual void checkExpectations();
 
 	virtual void setMockFailureReporter(MockFailureReporter* reporter);
-	virtual void installComparator(const SimpleString& typeName, MockParameterComparator& comparator);
+	virtual void installComparator(const SimpleString& typeName, MockNamedValueComparator& comparator);
 	virtual void removeAllComparators();
 
 	virtual void crashOnFailure();
@@ -70,7 +70,7 @@ class MockSupport
 	bool ignoreOtherCalls_;
 	bool enabled_;
 	MockActualFunctionCall* lastActualFunctionCall_;
-	MockParameterComparatorRepository comparatorRepository_;
+	MockNamedValueComparatorRepository comparatorRepository_;
 };
 
 #endif

src/CppUTestExt/MockActualFunctionCall.cpp

@@ -79,7 +79,7 @@ MockFunctionCall& MockActualFunctionCall::withName(const SimpleString& name)
 	return *this;
 }
 
-void MockActualFunctionCall::checkActualParameter(const MockFunctionParameter& actualParameter)
+void MockActualFunctionCall::checkActualParameter(const MockNamedValue& actualParameter)
 {
 	unfulfilledExpectations_.onlyKeepUnfulfilledExpectationsWithParameter(actualParameter);
 
@@ -89,39 +89,39 @@ void MockActualFunctionCall::checkActualParameter(const MockFunctionParameter& a
 		return;
 	}
 
-	unfulfilledExpectations_.parameterWasPassed(actualParameter.name_);
+	unfulfilledExpectations_.parameterWasPassed(actualParameter.getName());
 	if (unfulfilledExpectations_.hasFulfilledExpectations())
 		callHasSucceeded();
 }
 
 MockFunctionCall& MockActualFunctionCall::withParameter(const SimpleString& name, int value)
 {
-	MockFunctionParameter actualParameter(name, "int");
-	actualParameter.value_.intValue_ = value;
+	MockNamedValue actualParameter(name);
+	actualParameter.setValue(value);
 	checkActualParameter(actualParameter);
 	return *this;
 }
 
 MockFunctionCall& MockActualFunctionCall::withParameter(const SimpleString& name, double value)
 {
-	MockFunctionParameter actualParameter(name, "double");
-	actualParameter.value_.doubleValue_ = value;
+	MockNamedValue actualParameter(name);
+	actualParameter.setValue(value);
 	checkActualParameter(actualParameter);
 	return *this;
 }
 
 MockFunctionCall& MockActualFunctionCall::withParameter(const SimpleString& name, const char* value)
 {
-	MockFunctionParameter actualParameter(name, "char*");
-	actualParameter.value_.stringValue_ = value;
+	MockNamedValue actualParameter(name);
+	actualParameter.setValue(value);
 	checkActualParameter(actualParameter);
 	return *this;
 }
 
 MockFunctionCall& MockActualFunctionCall::withParameter(const SimpleString& name, void* value)
 {
-	MockFunctionParameter actualParameter(name, "void*");
-	actualParameter.value_.pointerValue_ = value;
+	MockNamedValue actualParameter(name);
+	actualParameter.setValue(value);
 	checkActualParameter(actualParameter);
 	return *this;
 }
@@ -133,9 +133,9 @@ MockFunctionCall& MockActualFunctionCall::withParameterOfType(const SimpleString
 		failTest(failure);
 		return *this;
 	}
-	MockFunctionParameter actualParameter(name, type);
-	actualParameter.value_.objectPointerValue_ = value;
-	actualParameter.comparator_ = getComparatorForType(type);
+	MockNamedValue actualParameter(name);
+	actualParameter.setObjectPointer(type, value);
+	actualParameter.setComparator(getComparatorForType(type));
 	checkActualParameter(actualParameter);
 	return *this;
 }