libcpputest-dev 3.4-3 / usr / include / CppUTestExt / MockNamedValue.h

/*
 * Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef D_MockNamedValue_h
#define D_MockNamedValue_h
/*
 * MockParameterComparator is an interface that needs to be used when creating Comparators.
 * This is needed when comparing values of non-native type.
 */

class MockNamedValueComparator
{
public:
	MockNamedValueComparator() {}
	virtual ~MockNamedValueComparator() {}

	virtual bool isEqual(void* object1, void* object2)=0;
	virtual SimpleString valueToString(void* object)=0;
};

class MockFunctionComparator : public MockNamedValueComparator
{
public:
	typedef bool (*isEqualFunction)(void*, void*);
	typedef SimpleString (*valueToStringFunction)(void*);

	MockFunctionComparator(isEqualFunction equal, valueToStringFunction valToString)
		: equal_(equal), valueToString_(valToString) {}
	virtual ~MockFunctionComparator(){}

	virtual bool isEqual(void* object1, void* object2){ return equal_(object1, object2); }
	virtual SimpleString valueToString(void* object) { return valueToString_(object); }
private:
	isEqualFunction equal_;
	valueToStringFunction valueToString_;
};

/*
 * 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 void setName(const char* name);

	virtual bool equals(const MockNamedValue& p) const;

	virtual SimpleString toString() const;

	virtual SimpleString getName() const;
	virtual SimpleString getType() const;

	virtual int getIntValue() const;
	virtual double getDoubleValue() const;
	virtual const char* getStringValue() const;
	virtual void* getPointerValue() const;
	virtual void* getObjectPointer() const;
private:
	SimpleString name_;
	SimpleString type_;
	union {
		int intValue_;
		double doubleValue_;
		const char* stringValue_;
		void* pointerValue_;
		void* objectPointerValue_;
	} value_;
	MockNamedValueComparator* comparator_;
};

class MockNamedValueListNode
{
public:
	MockNamedValueListNode(MockNamedValue* newValue);

	SimpleString getName() const;
	SimpleString getType() const;

	MockNamedValueListNode* next();
	MockNamedValue* item();

	void destroy();
	void setNext(MockNamedValueListNode* node);
private:
	MockNamedValue* data_;
	MockNamedValueListNode* next_;
};

class MockNamedValueList
{
public:
	MockNamedValueList();

	MockNamedValueListNode* begin();

	void add(MockNamedValue* newValue);
	void clear();

	MockNamedValue* getValueByName(const SimpleString& name);

private:
	MockNamedValueListNode* head_;
};

/*
 * MockParameterComparatorRepository is a class which stores comparators which can be used for comparing non-native types
 *
 */

struct MockNamedValueComparatorRepositoryNode;
class MockNamedValueComparatorRepository
{
	MockNamedValueComparatorRepositoryNode* head_;
public:
	MockNamedValueComparatorRepository();
	virtual ~MockNamedValueComparatorRepository();

	virtual void installComparator(const SimpleString& name, MockNamedValueComparator& comparator);
	virtual void installComparators(const MockNamedValueComparatorRepository& repository);
	virtual MockNamedValueComparator* getComparatorForType(const SimpleString& name);

	void clear();
};

#endif