incubator-celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From abroekh...@apache.org
Subject svn commit: r1528380 [3/5] - in /incubator/celix/trunk: ./ cmake/ cmake/cmock/ cmake/cmock/config/ cmake/cmock/lib/ cmake/cmock/src/ cmake/cpputest/ cmake/cpputest/include/ cmake/cpputest/include/CppUTest/ cmake/cpputest/include/CppUTestExt/ cmake/cppu...
Date Wed, 02 Oct 2013 09:01:23 GMT
Added: incubator/celix/trunk/cmake/cpputest/include/CppUTest/VirtualCall.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTest/VirtualCall.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTest/VirtualCall.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTest/VirtualCall.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,24 @@
+#ifndef D_VirtualCall_H
+#define D_VirtualCall_H
+
+#define send(obj,msg)\
+              ((obj)->msg(obj))
+
+#define send1(obj,msg,arg0)\
+              ((obj)->msg((obj),(arg0)))
+
+#define send2(obj,msg,arg0,arg1)\
+              ((obj)->msg((obj),(arg0),(arg1)))
+
+#define send3(obj,msg,arg0,arg1,arg2)\
+              ((obj)->msg((obj),(arg0),(arg1),(arg2)))
+
+#define send4(obj,msg,arg0,arg1,arg2,arg3)\
+              ((obj)->msg((obj),(arg0),(arg1),(arg2),(arg3)))
+
+#define vBind(obj,msg,newMethod)\
+              (obj->msg=&newMethod)
+
+#define castToDestroyer(Class) (Class* (*)(Class*))
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/CodeMemoryReportFormatter.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/CodeMemoryReportFormatter.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/CodeMemoryReportFormatter.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/CodeMemoryReportFormatter.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,67 @@
+/*
+ * 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_CodeMemoryReportFormatter_h
+#define D_CodeMemoryReportFormatter_h
+
+#include "CppUTestExt/MemoryReportFormatter.h"
+
+class CodeReportingAllocationNode;
+class CodeMemoryReportFormatter : public MemoryReportFormatter
+{
+private:
+	CodeReportingAllocationNode* codeReportingList_;
+	MemoryLeakAllocator* internalAllocator_;
+
+public:
+    CodeMemoryReportFormatter(MemoryLeakAllocator* internalAllocator);
+	virtual ~CodeMemoryReportFormatter();
+
+	virtual void report_testgroup_start(TestResult* result, Utest& test);
+	virtual void report_testgroup_end(TestResult* /*result*/, Utest& /*test*/){};
+
+	virtual void report_test_start(TestResult* result, Utest& test);
+	virtual void report_test_end(TestResult* result, Utest& test);
+
+	virtual void report_alloc_memory(TestResult* result, MemoryLeakAllocator* allocator, size_t size, char* memory, const char* file, int line);
+	virtual void report_free_memory(TestResult* result, MemoryLeakAllocator* allocator, char* memory, const char* file, int line);
+
+private:
+
+	void addNodeToList(const char* variableName, void* memory, CodeReportingAllocationNode* next);
+	CodeReportingAllocationNode* findNode(void* memory);
+    bool variableExists(const SimpleString& variableName);
+    void clearReporting();
+
+    bool isNewAllocator(MemoryLeakAllocator* allocator);
+	SimpleString createVariableNameFromFileLineInfo(const char *file, int line);
+
+    SimpleString getAllocationString(MemoryLeakAllocator* allocator, const SimpleString& variableName, size_t size);
+    SimpleString getDeallocationString(MemoryLeakAllocator* allocator, const SimpleString& variableName, const char* file, int line);
+};
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReportAllocator.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReportAllocator.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReportAllocator.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReportAllocator.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,60 @@
+/*
+ * 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_MemoryReportAllocator_h
+#define D_MemoryReportAllocator_h
+
+#include "CppUTest/MemoryLeakAllocator.h"
+
+class MemoryReportFormatter;
+
+class MemoryReportAllocator : public MemoryLeakAllocator
+{
+protected:
+	TestResult* result_;
+	MemoryLeakAllocator* realAllocator_;
+	MemoryReportFormatter* formatter_;
+public:
+	MemoryReportAllocator();
+	virtual ~MemoryReportAllocator();
+
+	virtual void setFormatter(MemoryReportFormatter* formatter);
+	virtual void setTestResult(TestResult* result);
+	virtual void setRealAllocator(MemoryLeakAllocator* allocator);
+
+	virtual bool allocateMemoryLeakNodeSeparately();
+	virtual MemoryLeakAllocator* getRealAllocator();
+
+	virtual char* alloc_memory(size_t size, const char* file, int line);
+	virtual void free_memory(char* memory, const char* file, int line);
+
+	virtual const char* name();
+	virtual const char* alloc_name();
+	virtual const char* free_name();
+};
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReportFormatter.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReportFormatter.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReportFormatter.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReportFormatter.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,65 @@
+/*
+ * 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_MemoryReportFormatter_h
+#define D_MemoryReportFormatter_h
+
+class TestOutput;
+class Utest;
+
+class MemoryReportFormatter
+{
+public:
+	virtual ~MemoryReportFormatter(){}
+
+	virtual void report_testgroup_start(TestResult* result, Utest& test)=0;
+	virtual void report_testgroup_end(TestResult* result, Utest& test)=0;
+
+	virtual void report_test_start(TestResult* result, Utest& test)=0;
+	virtual void report_test_end(TestResult* result, Utest& test)=0;
+
+	virtual void report_alloc_memory(TestResult* result, MemoryLeakAllocator* allocator, size_t size, char* memory, const char* file, int line)=0;
+	virtual void report_free_memory(TestResult* result, MemoryLeakAllocator* allocator, char* memory, const char* file, int line)=0;
+};
+
+class NormalMemoryReportFormatter : public MemoryReportFormatter
+{
+public:
+	NormalMemoryReportFormatter();
+	virtual ~NormalMemoryReportFormatter();
+
+	virtual void report_testgroup_start(TestResult* /*result*/, Utest& /*test*/);
+	virtual void report_testgroup_end(TestResult* /*result*/, Utest& /*test*/){};
+
+	virtual void report_test_start(TestResult* result, Utest& test);
+	virtual void report_test_end(TestResult* result, Utest& test);
+
+	virtual void report_alloc_memory(TestResult* result, MemoryLeakAllocator* allocator, size_t size, char* memory, const char* file, int line);
+	virtual void report_free_memory(TestResult* result, MemoryLeakAllocator* allocator, char* memory, const char* file, int line);
+};
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReporterPlugin.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReporterPlugin.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReporterPlugin.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReporterPlugin.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,65 @@
+/*
+ * 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_MemoryReporterPlugin_h
+#define D_MemoryReporterPlugin_h
+
+#include "CppUTest/TestPlugin.h"
+#include "CppUTestExt/MemoryReportAllocator.h"
+
+class MemoryReportFormatter;
+
+class MemoryReporterPlugin : public TestPlugin
+{
+	MemoryReportFormatter* formatter_;
+
+	MemoryReportAllocator mallocAllocator;
+	MemoryReportAllocator newAllocator;
+	MemoryReportAllocator newArrayAllocator;
+
+	SimpleString currentTestGroup_;
+public:
+    MemoryReporterPlugin();
+    virtual ~MemoryReporterPlugin();
+
+    virtual void preTestAction(Utest & test, TestResult & result);
+    virtual void postTestAction(Utest & test, TestResult & result);
+    virtual bool parseArguments(int, const char**, int);
+
+protected:
+    virtual MemoryReportFormatter* createMemoryFormatter(const SimpleString& type);
+
+private:
+    void destroyMemoryFormatter(MemoryReportFormatter* formatter);
+
+    void setGlobalMemoryReportAllocators();
+    void removeGlobalMemoryReportAllocators();
+
+    void initializeAllocator(MemoryReportAllocator* allocator, TestResult & result);
+};
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockActualFunctionCall.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockActualFunctionCall.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockActualFunctionCall.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockActualFunctionCall.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,92 @@
+/*
+ * 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_MockActualFunctionCall_h
+#define D_MockActualFunctionCall_h
+
+#include "CppUTestExt/MockFunctionCall.h"
+#include "CppUTestExt/MockExpectedFunctionsList.h"
+
+class MockFailureReporter;
+class MockFailure;
+class MockNamedValue;
+
+class MockActualFunctionCall : public MockFunctionCall
+{
+public:
+	MockActualFunctionCall(MockFailureReporter* reporter, const MockExpectedFunctionsList& expectations);
+	virtual ~MockActualFunctionCall();
+
+	virtual MockFunctionCall& withName(const SimpleString& name);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, int value);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, double value);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, const char* value);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, void* value);
+	virtual MockFunctionCall& withParameterOfType(const SimpleString& type, const SimpleString& name, void* value);
+
+	virtual MockFunctionCall& andReturnValue(int value);
+	virtual MockFunctionCall& andReturnValue(double value);
+	virtual MockFunctionCall& andReturnValue(const char* value);
+	virtual MockFunctionCall& andReturnValue(void* value);
+	virtual bool hasReturnValue();
+	virtual MockNamedValue returnValue();
+
+	virtual MockFunctionCall& onObject(void* objectPtr);
+
+	virtual bool isFulfilled() const;
+	virtual bool hasFailed() const;
+
+	virtual void checkExpectations();
+
+	virtual void setMockFailureReporter(MockFailureReporter* reporter);
+protected:
+	virtual Utest* getTest() const;
+	virtual void callHasSucceeded();
+	virtual void finnalizeCallWhenFulfilled();
+	virtual void failTest(const MockFailure& failure);
+	virtual void checkActualParameter(const MockNamedValue& actualParameter);
+
+	enum ActualCallState {
+		CALL_IN_PROGESS,
+		CALL_FAILED,
+		CALL_SUCCEED
+	};
+	virtual const char* stringFromState(ActualCallState state);
+	virtual void setState(ActualCallState state);
+	virtual void checkStateConsistency(ActualCallState oldState, ActualCallState newState);
+
+private:
+	MockFailureReporter* reporter_;
+
+	ActualCallState state_;
+	MockExpectedFunctionCall* _fulfilledExpectation;
+
+	MockExpectedFunctionsList unfulfilledExpectations_;
+	const MockExpectedFunctionsList& allExpectations_;
+};
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockExpectedFunctionCall.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockExpectedFunctionCall.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockExpectedFunctionCall.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockExpectedFunctionCall.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,107 @@
+/*
+ * 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_MockExpectedFunctionCall_h
+#define D_MockExpectedFunctionCall_h
+
+#include "CppUTestExt/MockFunctionCall.h"
+#include "CppUTestExt/MockNamedValue.h"
+
+extern SimpleString StringFrom(const MockNamedValue& parameter);
+
+class MockExpectedFunctionCall : public MockFunctionCall
+{
+
+public:
+	MockExpectedFunctionCall();
+	virtual ~MockExpectedFunctionCall();
+
+	virtual MockFunctionCall& withName(const SimpleString& name);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, int value);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, double value);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, const char* value);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, void* value);
+	virtual MockFunctionCall& withParameterOfType(const SimpleString& typeName, const SimpleString& name, void* value);
+	virtual MockFunctionCall& ignoreOtherParameters();
+
+	virtual MockFunctionCall& andReturnValue(int value);
+	virtual MockFunctionCall& andReturnValue(double value);
+	virtual MockFunctionCall& andReturnValue(const char* value);
+	virtual MockFunctionCall& andReturnValue(void* value);
+	virtual bool hasReturnValue();
+	virtual MockNamedValue returnValue();
+
+	virtual MockFunctionCall& onObject(void* objectPtr);
+
+	virtual MockNamedValue getParameter(const SimpleString& name);
+	virtual SimpleString getParameterType(const SimpleString& name);
+	virtual SimpleString getParameterValueString(const SimpleString& name);
+
+	virtual bool hasParameterWithName(const SimpleString& name);
+	virtual bool hasParameter(const MockNamedValue& parameter);
+	virtual bool relatesTo(const SimpleString& functionName);
+	virtual bool relatesToObject(void*objectPtr) const;
+
+	virtual bool isFulfilled();
+	virtual bool isFulfilledWithoutIgnoredParameters();
+	virtual bool areParametersFulfilled();
+	virtual bool areIgnoredParametersFulfilled();
+
+	virtual void callWasMade();
+	virtual void parameterWasPassed(const SimpleString& name);
+	virtual void parametersWereIgnored();
+	virtual void wasPassedToObject();
+	virtual void resetExpectation();
+
+	virtual SimpleString callToString();
+	virtual SimpleString missingParametersToString();
+
+private:
+
+	class MockExpectedFunctionParameter : public MockNamedValue
+	{
+	public:
+		MockExpectedFunctionParameter(const SimpleString& name);
+		void setFulfilled(bool b);
+		bool isFulfilled() const;
+
+	private:
+		bool fulfilled_;
+	};
+
+	MockExpectedFunctionParameter* item(MockNamedValueListNode* node);
+
+	bool ignoreOtherParameters_;
+	bool parametersWereIgnored_;
+	bool wasCallMade_;
+	MockNamedValueList* parameters_;
+	MockNamedValue returnValue_;
+	void* objectPtr_;
+	bool wasPassedToObject_;
+};
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockExpectedFunctionsList.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockExpectedFunctionsList.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockExpectedFunctionsList.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockExpectedFunctionsList.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,96 @@
+/*
+ * 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_MockExpectedFunctionsList_h
+#define D_MockExpectedFunctionsList_h
+
+class MockExpectedFunctionCall;
+class MockNamedValue;
+
+class MockExpectedFunctionsList
+{
+
+public:
+	MockExpectedFunctionsList();
+	virtual ~MockExpectedFunctionsList();
+	virtual void deleteAllExpectationsAndClearList();
+
+	virtual int size() const;
+	virtual int amountOfExpectationsFor(const SimpleString& name) const;
+	virtual int amountOfUnfulfilledExpectations() const;
+	virtual bool hasUnfullfilledExpectations() const;
+	virtual bool hasFulfilledExpectations() const;
+	virtual bool hasUnfulfilledExpectationsBecauseOfMissingParameters() const;
+	virtual bool hasExpectationWithName(const SimpleString& name) const;
+	virtual bool isEmpty() const;
+
+	virtual void addExpectedCall(MockExpectedFunctionCall* call);
+	virtual void addExpectations(const MockExpectedFunctionsList& list);
+	virtual void addExpectationsRelatedTo(const SimpleString& name, const MockExpectedFunctionsList& list);
+	virtual void addUnfilfilledExpectations(const MockExpectedFunctionsList& list);
+
+	virtual void onlyKeepExpectationsRelatedTo(const SimpleString& name);
+	virtual void onlyKeepExpectationsWithParameter(const MockNamedValue& parameter);
+	virtual void onlyKeepExpectationsWithParameterName(const SimpleString& name);
+	virtual void onlyKeepExpectationsOnObject(void* objectPtr);
+	virtual void onlyKeepUnfulfilledExpectations();
+	virtual void onlyKeepUnfulfilledExpectationsRelatedTo(const SimpleString& name);
+	virtual void onlyKeepUnfulfilledExpectationsWithParameter(const MockNamedValue& parameter);
+	virtual void onlyKeepUnfulfilledExpectationsOnObject(void* objectPtr);
+
+	virtual MockExpectedFunctionCall* removeOneFulfilledExpectation();
+	virtual MockExpectedFunctionCall* removeOneFulfilledExpectationWithIgnoredParameters();
+
+	virtual void resetExpectations();
+	virtual void callWasMade();
+	virtual void wasPassedToObject();
+	virtual void parameterWasPassed(const SimpleString& parameterName);
+
+	virtual SimpleString unfulfilledFunctionsToString(const SimpleString& linePrefix = "") const;
+	virtual SimpleString fulfilledFunctionsToString(const SimpleString& linePrefix = "") const;
+	virtual SimpleString missingParametersToString() const;
+
+protected:
+	virtual void pruneEmptyNodeFromList();
+	virtual SimpleString functionsToString(const SimpleString& linePrefix, bool wasFulfilled) const;
+
+	class MockExpectedFunctionsListNode
+	{
+	public:
+		MockExpectedFunctionCall* expectedCall_;
+
+		MockExpectedFunctionsListNode* next_;
+		MockExpectedFunctionsListNode(MockExpectedFunctionCall* expectedCall)
+			: expectedCall_(expectedCall), next_(NULL) {};
+	};
+private:
+	MockExpectedFunctionsListNode* head_;
+
+	MockExpectedFunctionsList(const MockExpectedFunctionsList&);
+};
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockFailure.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockFailure.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockFailure.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockFailure.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,112 @@
+/*
+ * 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_MockFailure_h
+#define D_MockFailure_h
+
+#include "CppUTest/TestFailure.h"
+
+class MockExpectedFunctionsList;
+class MockActualFunctionCall;
+class MockNamedValue;
+class MockFailure;
+
+class MockFailureReporter
+{
+protected:
+	bool crashOnFailure_;
+public:
+	MockFailureReporter() : crashOnFailure_(false){};
+	virtual ~MockFailureReporter() {};
+
+	virtual void failTest(const MockFailure& failure);
+	virtual Utest* getTestToFail();
+
+	virtual void crashOnFailure() {crashOnFailure_ = true; }
+};
+
+class MockFailure : public TestFailure
+{
+public:
+	MockFailure(Utest* test);
+	virtual ~MockFailure(){};
+protected:
+	void addExpectationsAndCallHistory(const MockExpectedFunctionsList& expectations);
+	void addExpectationsAndCallHistoryRelatedTo(const SimpleString& function, const MockExpectedFunctionsList& expectations);
+};
+
+class MockExpectedCallsDidntHappenFailure : public MockFailure
+{
+public:
+	MockExpectedCallsDidntHappenFailure(Utest* test, const MockExpectedFunctionsList& expectations);
+	virtual ~MockExpectedCallsDidntHappenFailure(){};
+};
+
+class MockUnexpectedCallHappenedFailure : public MockFailure
+{
+public:
+	MockUnexpectedCallHappenedFailure(Utest* test, const SimpleString& name, const MockExpectedFunctionsList& expectations);
+	virtual ~MockUnexpectedCallHappenedFailure(){};
+};
+
+class MockUnexpectedParameterFailure : public MockFailure
+{
+public:
+	MockUnexpectedParameterFailure(Utest* test, const SimpleString& functionName, const MockNamedValue& parameter, const MockExpectedFunctionsList& expectations);
+	virtual ~MockUnexpectedParameterFailure(){};
+};
+
+class MockExpectedParameterDidntHappenFailure : public MockFailure
+{
+public:
+	MockExpectedParameterDidntHappenFailure(Utest* test, const SimpleString& functionName, const MockExpectedFunctionsList& expectations);
+	virtual ~MockExpectedParameterDidntHappenFailure(){};
+};
+
+class MockNoWayToCompareCustomTypeFailure : public MockFailure
+{
+public:
+	MockNoWayToCompareCustomTypeFailure(Utest* test, const SimpleString& typeName);
+	virtual ~MockNoWayToCompareCustomTypeFailure(){};
+};
+
+class MockUnexpectedObjectFailure : public MockFailure
+{
+public:
+	MockUnexpectedObjectFailure(Utest* test, const SimpleString& functionName, void* expected, const MockExpectedFunctionsList& expectations);
+	virtual ~MockUnexpectedObjectFailure(){}
+};
+
+class MockExpectedObjectDidntHappenFailure : public MockFailure
+{
+public:
+	MockExpectedObjectDidntHappenFailure(Utest* test, const SimpleString& functionName, const MockExpectedFunctionsList& expectations);
+	virtual ~MockExpectedObjectDidntHappenFailure(){}
+};
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockFunctionCall.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockFunctionCall.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockFunctionCall.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockFunctionCall.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,157 @@
+/*
+ * 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_MockFunctionCall_h
+#define D_MockFunctionCall_h
+
+/*
+ * MockFunctionCall is the main interface for recording and actualizing mock calls.
+ *
+ */
+class MockNamedValueComparator;
+class MockNamedValueComparatorRepository;
+
+#include "CppUTestExt/MockNamedValue.h"
+
+class MockFunctionCall
+{
+public:
+	MockFunctionCall();
+	virtual ~MockFunctionCall();
+
+	virtual MockFunctionCall& withName(const SimpleString& name)=0;
+	virtual MockFunctionCall& withParameter(const SimpleString& name, int value)=0;
+	virtual MockFunctionCall& withParameter(const SimpleString& name, double value)=0;
+	virtual MockFunctionCall& withParameter(const SimpleString& name, const char* value)=0;
+	virtual MockFunctionCall& withParameter(const SimpleString& name, void* value)=0;
+	virtual MockFunctionCall& withParameterOfType(const SimpleString& typeName, const SimpleString& name, void* value)=0;
+	virtual MockFunctionCall& ignoreOtherParameters() { return *this;};
+
+	virtual MockFunctionCall& andReturnValue(int value)=0;
+	virtual MockFunctionCall& andReturnValue(double value)=0;
+	virtual MockFunctionCall& andReturnValue(const char* value)=0;
+	virtual MockFunctionCall& andReturnValue(void* value)=0;
+	virtual bool hasReturnValue()=0;
+	virtual MockNamedValue returnValue()=0;
+
+	virtual MockFunctionCall& onObject(void* objectPtr)=0;
+
+	virtual void setComparatorRepository(MockNamedValueComparatorRepository* repository);
+
+protected:
+	void setName(const SimpleString& name);
+	SimpleString getName() const;
+	MockNamedValueComparator* getComparatorForType(const SimpleString& type) const;
+private:
+	SimpleString functionName_;
+	MockNamedValueComparatorRepository* comparatorRepository_;
+};
+
+struct MockFunctionCallCompositeNode;
+class MockFunctionCallComposite : public MockFunctionCall
+{
+public:
+	MockFunctionCallComposite();
+	virtual ~MockFunctionCallComposite();
+
+	virtual MockFunctionCall& withName(const SimpleString&);
+	virtual MockFunctionCall& withParameter(const SimpleString&, int);
+	virtual MockFunctionCall& withParameter(const SimpleString&, double);
+	virtual MockFunctionCall& withParameter(const SimpleString&, const char*);
+	virtual MockFunctionCall& withParameter(const SimpleString& , void*);
+	virtual MockFunctionCall& withParameterOfType(const SimpleString&, const SimpleString&, void*);
+	virtual MockFunctionCall& ignoreOtherParameters();
+
+	virtual MockFunctionCall& andReturnValue(int);
+	virtual MockFunctionCall& andReturnValue(double);
+	virtual MockFunctionCall& andReturnValue(const char*);
+	virtual MockFunctionCall& andReturnValue(void*);
+	virtual bool hasReturnValue();
+	virtual MockNamedValue returnValue();
+
+	virtual MockFunctionCall& onObject(void* );
+
+	virtual void add(MockFunctionCall& call);
+	virtual void clear();
+private:
+	MockFunctionCallCompositeNode* head_;
+};
+
+class MockIgnoredCall : public MockFunctionCall
+{
+public:
+	virtual MockFunctionCall& withName(const SimpleString&) { return *this;}
+	virtual MockFunctionCall& withParameter(const SimpleString&, int) { return *this; }
+	virtual MockFunctionCall& withParameter(const SimpleString&, double) { return *this; }
+	virtual MockFunctionCall& withParameter(const SimpleString&, const char*) { return *this; }
+	virtual MockFunctionCall& withParameter(const SimpleString& , void*) { return *this; }
+	virtual MockFunctionCall& withParameterOfType(const SimpleString&, const SimpleString&, void*) { return *this; }
+
+	virtual MockFunctionCall& andReturnValue(int) { return *this; }
+	virtual MockFunctionCall& andReturnValue(double) { return *this;}
+	virtual MockFunctionCall& andReturnValue(const char*) { return *this; }
+	virtual MockFunctionCall& andReturnValue(void*) { return *this; }
+	virtual bool hasReturnValue() { return false; }
+	virtual MockNamedValue returnValue() { return MockNamedValue(""); }
+
+	virtual MockFunctionCall& onObject(void* ) { return *this; }
+
+	static MockFunctionCall& instance() { static MockIgnoredCall call; return call; };
+};
+
+class MockFunctionCallTrace : public MockFunctionCall
+{
+public:
+	MockFunctionCallTrace();
+	virtual ~MockFunctionCallTrace();
+
+	virtual MockFunctionCall& withName(const SimpleString& name);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, int value);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, double value);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, const char* value);
+	virtual MockFunctionCall& withParameter(const SimpleString& name, void* value);
+	virtual MockFunctionCall& withParameterOfType(const SimpleString& typeName, const SimpleString& name, void* value);
+	virtual MockFunctionCall& ignoreOtherParameters();
+
+	virtual MockFunctionCall& andReturnValue(int value);
+	virtual MockFunctionCall& andReturnValue(double value);
+	virtual MockFunctionCall& andReturnValue(const char* value);
+	virtual MockFunctionCall& andReturnValue(void* value);
+	virtual bool hasReturnValue();
+	virtual MockNamedValue returnValue();
+
+	virtual MockFunctionCall& onObject(void* objectPtr);
+
+	const char* getTraceOutput();
+	void clear();
+	static MockFunctionCallTrace& instance();
+
+private:
+	SimpleString traceBuffer_;
+};
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockNamedValue.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockNamedValue.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockNamedValue.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockNamedValue.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,163 @@
+/*
+ * 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

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupport.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupport.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupport.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupport.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,116 @@
+/*
+ * 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_MockSupport_h
+#define D_MockSupport_h
+
+#include "CppUTestExt/MockFailure.h"
+#include "CppUTestExt/MockFunctionCall.h"
+#include "CppUTestExt/MockExpectedFunctionCall.h"
+#include "CppUTestExt/MockExpectedFunctionsList.h"
+
+class Utest;
+class MockSupport;
+
+/* This allows access to "the global" mocking support for easier testing */
+MockSupport& mock(const SimpleString& mockName = "");
+
+class MockSupport
+{
+public:
+	MockSupport();
+	virtual ~MockSupport();
+
+	virtual MockFunctionCall& expectOneCall(const SimpleString& functionName);
+	virtual MockFunctionCall& expectNCalls(int amount, const SimpleString& functionName);
+	virtual MockFunctionCall& actualCall(const SimpleString& functionName);
+	virtual bool hasReturnValue();
+	virtual MockNamedValue returnValue();
+	virtual int intReturnValue();
+	virtual const char* stringReturnValue();
+	virtual double doubleReturnValue();
+	virtual void* pointerReturnValue();
+
+	bool hasData(const SimpleString& name);
+	void setData(const SimpleString& name, int value);
+	void setData(const SimpleString& name, const char* value);
+	void setData(const SimpleString& name, double value);
+	void setData(const SimpleString& name, void* value);
+	void setDataObject(const SimpleString& name, const SimpleString& type, void* value);
+	MockNamedValue getData(const SimpleString& name);
+
+	MockSupport* getMockSupportScope(const SimpleString& name);
+
+	const char* getTraceOutput();
+	/*
+	 * The following functions are recursively through the lower MockSupports scopes
+	 * This means, if you do mock().disable() it will disable *all* mocking scopes, including mock("myScope").
+  	 */
+
+	virtual void disable();
+    virtual void enable();
+    virtual void tracing(bool enabled);
+	virtual void ignoreOtherCalls();
+
+    virtual void checkExpectations();
+    virtual bool expectedCallsLeft();
+
+    virtual void clear();
+	virtual void setMockFailureReporter(MockFailureReporter* reporter);
+	virtual void crashOnFailure();
+
+	virtual void installComparator(const SimpleString& typeName, MockNamedValueComparator& comparator);
+	virtual void installComparators(const MockNamedValueComparatorRepository& repository);
+	virtual void removeAllComparators();
+
+protected:
+    virtual MockActualFunctionCall *createActualFunctionCall();
+private:
+
+    MockFailureReporter *reporter_;
+    MockFailureReporter defaultReporter_;
+    MockExpectedFunctionsList expectations_;
+    bool ignoreOtherCalls_;
+    bool enabled_;
+    MockActualFunctionCall *lastActualFunctionCall_;
+	MockFunctionCallComposite compositeCalls_;
+    MockNamedValueComparatorRepository comparatorRepository_;
+    MockNamedValueList data_;
+
+    bool tracing_;
+
+    void checkExpectationsOfLastCall();
+    bool wasLastCallFulfilled();
+    void failTestWithForUnexpectedCalls();
+
+	MockNamedValue* createAndStoreData(const SimpleString& name);
+
+	MockSupport* getMockSupport(MockNamedValueListNode* node);
+};
+
+#endif
+

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupportPlugin.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupportPlugin.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupportPlugin.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupportPlugin.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,48 @@
+/*
+ * 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_MockSupportPlugin_h
+#define D_MockSupportPlugin_h
+
+#include "CppUTest/TestPlugin.h"
+#include "CppUTestExt/MockNamedValue.h"
+
+class MockSupportPlugin : public TestPlugin
+{
+public:
+	MockSupportPlugin(const SimpleString& name = "MockSupportPLugin");
+	virtual ~MockSupportPlugin();
+
+	virtual void preTestAction(Utest&, TestResult&);
+	virtual void postTestAction(Utest&, TestResult&);
+
+	virtual void installComparator(const SimpleString& name, MockNamedValueComparator& comparator);
+private:
+	MockNamedValueComparatorRepository repository_;
+};
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupport_c.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupport_c.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupport_c.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupport_c.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,99 @@
+/*
+ * 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_MockSupport_c_h
+#define D_MockSupport_c_h
+
+typedef enum {
+	MOCKVALUETYPE_INTEGER,
+	MOCKVALUETYPE_DOUBLE,
+	MOCKVALUETYPE_STRING,
+	MOCKVALUETYPE_POINTER,
+	MOCKVALUETYPE_OBJECT
+} MockValueType_c;
+
+typedef struct SMockValue_c
+{
+	MockValueType_c type;
+	union  {
+		int intValue;
+		double doubleValue;
+		const char* stringValue;
+		void* pointerValue;
+		void* objectValue;
+	} value;
+} MockValue_c;
+
+typedef struct SMockFunctionCall_c MockFunctionCall_c;
+struct SMockFunctionCall_c
+{
+	MockFunctionCall_c* (*withIntParameters)(const char* name, int value);
+	MockFunctionCall_c* (*withDoubleParameters)(const char* name, double value);
+	MockFunctionCall_c* (*withStringParameters)(const char* name, const char* value);
+	MockFunctionCall_c* (*withPointerParameters)(const char* name, void* value);
+	MockFunctionCall_c* (*withParameterOfType)(const char* type, const char* name, void* value);
+
+	MockFunctionCall_c* (*andReturnIntValue)(int value);
+	MockFunctionCall_c* (*andReturnDoubleValue)(double value);
+	MockFunctionCall_c* (*andReturnStringValue)(const char* value);
+	MockFunctionCall_c* (*andReturnPointerValue)(void* value);
+
+	MockValue_c (*returnValue)();
+
+};
+
+typedef int (*MockTypeEqualFunction_c)(void* object1, void* object2);
+typedef char* (*MockTypeValueToStringFunction_c)(void* object1);
+
+typedef struct SMockSupport_c MockSupport_c;
+struct SMockSupport_c
+{
+	MockFunctionCall_c* (*expectOneCall)(const char* name);
+	MockFunctionCall_c* (*actualCall)(const char* name);
+	MockValue_c (*returnValue)();
+
+	void (*setIntData) (const char* name, int value);
+	void (*setDoubleData) (const char* name, double value);
+	void (*setStringData) (const char* name, const char* value);
+	void (*setPointerData) (const char* name, void* value);
+	void (*setDataObject) (const char* name, const char* type, void* value);
+	MockValue_c (*getData)(const char* name);
+
+	void (*checkExpectations)();
+	int (*expectedCallsLeft)();
+
+	void (*clear)();
+
+	void (*installComparator) (const char* typeName, MockTypeEqualFunction_c isEqual, MockTypeValueToStringFunction_c valueToString);
+	void (*removeAllComparators)();
+};
+
+
+MockSupport_c* mock_c();
+MockSupport_c* mock_scope_c(const char* scope);
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/OrderedTest.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/OrderedTest.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/OrderedTest.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/OrderedTest.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,77 @@
+/*
+ * 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_OrderedTest_h
+#define D_OrderedTest_h
+
+class OrderedTest : public Utest
+{
+public:
+   OrderedTest();
+   virtual ~OrderedTest();
+
+   virtual OrderedTest* addOrderedTest(OrderedTest* test);
+   virtual OrderedTest* getNextOrderedTest();
+
+   int getLevel();
+   void setLevel(int level);
+
+   static void addOrderedTestToHead(OrderedTest* test);
+   static OrderedTest* getOrderedTestHead();
+   static bool firstOrderedTest();
+
+   static void setOrderedTestHead(OrderedTest* test);
+private:
+   static OrderedTest* _orderedTestsHead;
+   OrderedTest* _nextOrderedTest;
+
+   int _level;
+
+};
+
+class OrderedTestInstaller
+{
+  public:
+    explicit OrderedTestInstaller(OrderedTest* test, const char* groupName, const char* testName, const char* fileName, int lineNumber, int level);
+    virtual ~OrderedTestInstaller();
+
+  private:
+     void addOrderedTestInOrder(OrderedTest* test);
+	void addOrderedTestInOrderNotAtHeadPosition(OrderedTest* test);
+
+};
+
+#define TEST_ORDERED(testGroup, testName, testLevel) \
+  class TEST_##testGroup##_##testName##_Test : public TEST_GROUP_##CppUTestGroup##testGroup \
+{ public: TEST_##testGroup##_##testName##_Test () : TEST_GROUP_##CppUTestGroup##testGroup () {} \
+       void testBody(); } \
+    TEST_##testGroup##_##testName##_Instance; \
+  OrderedTestInstaller TEST_##testGroup##_##testName##_Installer(&TEST_##testGroup##_##testName##_Instance, #testGroup, #testName, __FILE__,__LINE__, testLevel); \
+   void TEST_##testGroup##_##testName##_Test::testBody()
+
+#endif
+

Added: incubator/celix/trunk/cmake/cpputest/include/Platforms/Gcc/Platform.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/Platforms/Gcc/Platform.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/Platforms/Gcc/Platform.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/Platforms/Gcc/Platform.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,31 @@
+/*
+ * 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_Gcc_Platform_H
+#define D_Gcc_Platform_H
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/Platforms/StarterKit/Platform.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/Platforms/StarterKit/Platform.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/Platforms/StarterKit/Platform.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/Platforms/StarterKit/Platform.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,31 @@
+/*
+ * 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_Gcc_Platform_H
+#define D_Gcc_Platform_H
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/Platforms/Symbian/Platform.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/Platforms/Symbian/Platform.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/Platforms/Symbian/Platform.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/Platforms/Symbian/Platform.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,6 @@
+
+#ifndef PLATFORM_H_
+#define PLATFORM_H_
+
+#endif /*PLATFORM_H_*/
+

Added: incubator/celix/trunk/cmake/cpputest/include/Platforms/VisualCpp/Platform.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/Platforms/VisualCpp/Platform.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/Platforms/VisualCpp/Platform.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/Platforms/VisualCpp/Platform.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,39 @@
+/*
+ * 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.
+ */
+
+#ifdef _MSC_VER
+#pragma warning(disable:4786)
+#endif
+
+#ifdef WIN32
+    #ifdef _VC80_UPGRADE
+        #pragma warning(disable:4996)
+        #pragma warning(disable:4290)
+    #else
+        #define vsnprintf _vsnprintf
+    #endif
+#endif

Added: incubator/celix/trunk/cmake/cpputest/include/Platforms/VisualCpp/stdint.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/include/Platforms/VisualCpp/stdint.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cpputest/include/Platforms/VisualCpp/stdint.h (added)
+++ incubator/celix/trunk/cmake/cpputest/include/Platforms/VisualCpp/stdint.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,206 @@
+/* ISO C9x  7.18  Integer types <stdint.h>
+ * Based on ISO/IEC SC22/WG14 9899 Committee draft (SC22 N2794)
+ *
+ *  THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ *  Contributor: Danny Smith <danny_r_smith_2001@yahoo.co.nz>
+ *
+ *  This source code is offered for use in the public domain. You may
+ *  use, modify or distribute it freely.
+ *
+ *  This code is distributed in the hope that it will be useful but
+ *  WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ *  DISCLAIMED. This includes but is not limited to warranties of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *  Date: 2000-12-02
+ */
+
+
+#ifndef _STDINT_H
+#define _STDINT_H
+#define __need_wint_t
+#define __need_wchar_t
+#include <stddef.h>
+
+/* 7.18.1.1  Exact-width integer types */
+typedef signed char int8_t;
+typedef unsigned char   uint8_t;
+typedef short  int16_t;
+typedef unsigned short  uint16_t;
+typedef int  int32_t;
+typedef unsigned   uint32_t;
+//typedef long long  int64_t;
+//typedef unsigned long long   uint64_t;
+
+/* 7.18.1.2  Minimum-width integer types */
+typedef signed char int_least8_t;
+typedef unsigned char   uint_least8_t;
+typedef short  int_least16_t;
+typedef unsigned short  uint_least16_t;
+typedef int  int_least32_t;
+typedef unsigned   uint_least32_t;
+//typedef long long  int_least64_t;
+//typedef unsigned long long   uint_least64_t;
+
+/*  7.18.1.3  Fastest minimum-width integer types 
+ *  Not actually guaranteed to be fastest for all purposes
+ *  Here we use the exact-width types for 8 and 16-bit ints. 
+ */
+typedef signed char int_fast8_t;
+typedef unsigned char uint_fast8_t;
+typedef short  int_fast16_t;
+typedef unsigned short  uint_fast16_t;
+typedef int  int_fast32_t;
+typedef unsigned  int  uint_fast32_t;
+//typedef long long  int_fast64_t;
+//typedef unsigned long long   uint_fast64_t;
+
+/* 7.18.1.4  Integer types capable of holding object pointers */
+
+#ifndef _INTPTR_T_DEFINED
+#define _INTPTR_T_DEFINED
+#ifdef _WIN64
+  typedef __int64 intptr_t;
+#else
+  typedef int intptr_t;
+#endif
+#endif
+
+#ifndef _UINTPTR_T_DEFINED
+#define _UINTPTR_T_DEFINED
+#ifdef _WIN64
+  typedef unsigned __int64 uintptr_t;
+#else
+  typedef unsigned int uintptr_t;
+#endif
+#endif
+
+/* 7.18.1.5  Greatest-width integer types */
+//typedef long long  intmax_t;
+//typedef unsigned long long uintmax_t;
+
+/* 7.18.2  Limits of specified-width integer types */
+#if !defined ( __cplusplus) || defined (__STDC_LIMIT_MACROS)
+
+/* 7.18.2.1  Limits of exact-width integer types */
+#define INT8_MIN (-128) 
+#define INT16_MIN (-32768)
+#define INT32_MIN (-2147483647 - 1)
+#define INT64_MIN  (-9223372036854775807LL - 1)
+
+#define INT8_MAX 127
+#define INT16_MAX 32767
+#define INT32_MAX 2147483647
+#define INT64_MAX 9223372036854775807LL
+
+#define UINT8_MAX 0xff /* 255U */
+#define UINT16_MAX 0xffff /* 65535U */
+#define UINT32_MAX 0xffffffff  /* 4294967295U */
+#define UINT64_MAX 0xffffffffffffffffULL /* 18446744073709551615ULL */
+
+/* 7.18.2.2  Limits of minimum-width integer types */
+#define INT_LEAST8_MIN INT8_MIN
+#define INT_LEAST16_MIN INT16_MIN
+#define INT_LEAST32_MIN INT32_MIN
+#define INT_LEAST64_MIN INT64_MIN
+
+#define INT_LEAST8_MAX INT8_MAX
+#define INT_LEAST16_MAX INT16_MAX
+#define INT_LEAST32_MAX INT32_MAX
+#define INT_LEAST64_MAX INT64_MAX
+
+#define UINT_LEAST8_MAX UINT8_MAX
+#define UINT_LEAST16_MAX UINT16_MAX
+#define UINT_LEAST32_MAX UINT32_MAX
+#define UINT_LEAST64_MAX UINT64_MAX
+
+/* 7.18.2.3  Limits of fastest minimum-width integer types */
+#define INT_FAST8_MIN INT8_MIN
+#define INT_FAST16_MIN INT16_MIN
+#define INT_FAST32_MIN INT32_MIN
+#define INT_FAST64_MIN INT64_MIN
+
+#define INT_FAST8_MAX INT8_MAX
+#define INT_FAST16_MAX INT16_MAX
+#define INT_FAST32_MAX INT32_MAX
+#define INT_FAST64_MAX INT64_MAX
+
+#define UINT_FAST8_MAX UINT8_MAX
+#define UINT_FAST16_MAX UINT16_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+#define UINT_FAST64_MAX UINT64_MAX
+
+/* 7.18.2.4  Limits of integer types capable of holding
+    object pointers */
+#ifdef _WIN64
+#define INTPTR_MIN INT64_MIN
+#define INTPTR_MAX INT64_MAX
+#define UINTPTR_MAX UINT64_MAX
+#else
+#define INTPTR_MIN INT32_MIN
+#define INTPTR_MAX INT32_MAX
+#define UINTPTR_MAX UINT32_MAX
+#endif
+
+/* 7.18.2.5  Limits of greatest-width integer types */
+#define INTMAX_MIN INT64_MIN
+#define INTMAX_MAX INT64_MAX
+#define UINTMAX_MAX UINT64_MAX
+
+/* 7.18.3  Limits of other integer types */
+#define PTRDIFF_MIN INTPTR_MIN
+#define PTRDIFF_MAX INTPTR_MAX
+
+#define SIG_ATOMIC_MIN INTPTR_MIN
+#define SIG_ATOMIC_MAX INTPTR_MAX
+
+#define SIZE_MAX UINTPTR_MAX
+
+#ifndef WCHAR_MIN  /* also in wchar.h */ 
+#define WCHAR_MIN 0
+#define WCHAR_MAX 0xffff /* UINT16_MAX */
+#endif
+
+/*
+ * wint_t is unsigned short for compatibility with MS runtime
+ */
+#define WINT_MIN 0
+#define WINT_MAX 0xffff /* UINT16_MAX */
+
+#endif /* !defined ( __cplusplus) || defined __STDC_LIMIT_MACROS */
+
+
+/* 7.18.4  Macros for integer constants */
+#if !defined ( __cplusplus) || defined (__STDC_CONSTANT_MACROS)
+
+/* 7.18.4.1  Macros for minimum-width integer constants
+
+    Accoding to Douglas Gwyn <gwyn@arl.mil>:
+	"This spec was changed in ISO/IEC 9899:1999 TC1; in ISO/IEC
+	9899:1999 as initially published, the expansion was required
+	to be an integer constant of precisely matching type, which
+	is impossible to accomplish for the shorter types on most
+	platforms, because C99 provides no standard way to designate
+	an integer constant with width less than that of type int.
+	TC1 changed this to require just an integer constant
+	*expression* with *promoted* type."
+*/
+
+#define INT8_C(val) val
+#define UINT8_C(val) val
+#define INT16_C(val) val
+#define UINT16_C(val) val
+
+#define INT32_C(val) val
+#define UINT32_C(val) val##U
+#define INT64_C(val) val##LL
+#define UINT64_C(val) val##ULL
+
+/* 7.18.4.2  Macros for greatest-width integer constants */
+#define INTMAX_C(val)  INT64_C(val)
+#define UINTMAX_C(val) UINT64_C(val)
+
+#endif  /* !defined ( __cplusplus) || defined __STDC_CONSTANT_MACROS */
+
+#endif

Added: incubator/celix/trunk/cmake/cpputest/lib/libCppUTest.a
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/lib/libCppUTest.a?rev=1528380&view=auto
==============================================================================
Files incubator/celix/trunk/cmake/cpputest/lib/libCppUTest.a (added) and incubator/celix/trunk/cmake/cpputest/lib/libCppUTest.a Wed Oct  2 09:01:20 2013 differ

Added: incubator/celix/trunk/cmake/cpputest/lib/libCppUTestExt.a
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cpputest/lib/libCppUTestExt.a?rev=1528380&view=auto
==============================================================================
Files incubator/celix/trunk/cmake/cpputest/lib/libCppUTestExt.a (added) and incubator/celix/trunk/cmake/cpputest/lib/libCppUTestExt.a Wed Oct  2 09:01:20 2013 differ

Added: incubator/celix/trunk/cmake/unity/colour_prompt.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/unity/colour_prompt.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/unity/colour_prompt.rb (added)
+++ incubator/celix/trunk/cmake/unity/colour_prompt.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,94 @@
+# ==========================================
+#   Unity Project - A Test Framework for C
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   [Released under MIT License. Please refer to license.txt for details]
+# ========================================== 
+
+if RUBY_PLATFORM =~/(win|w)32$/
+	begin
+		require 'Win32API'
+	rescue LoadError
+		puts "ERROR! \"Win32API\" library not found"
+		puts "\"Win32API\" is required for colour on a windows machine"
+		puts "  try => \"gem install Win32API\" on the command line"
+		puts
+	end
+	# puts
+  # puts 'Windows Environment Detected...'
+	# puts 'Win32API Library Found.'
+	# puts
+end
+
+class ColourCommandLine
+  def initialize
+    if RUBY_PLATFORM =~/(win|w)32$/  
+      get_std_handle = Win32API.new("kernel32", "GetStdHandle", ['L'], 'L')
+      @set_console_txt_attrb =
+      Win32API.new("kernel32","SetConsoleTextAttribute",['L','N'], 'I')
+      @hout = get_std_handle.call(-11)
+    end
+  end
+  
+  def change_to(new_colour)
+    if RUBY_PLATFORM =~/(win|w)32$/
+      @set_console_txt_attrb.call(@hout,self.win32_colour(new_colour))
+    else
+	  	"\033[30;#{posix_colour(new_colour)};22m"
+	 	end
+  end
+  
+  def win32_colour(colour)
+    case colour
+      when :black then 0  
+      when :dark_blue then 1
+      when :dark_green then 2
+      when :dark_cyan then 3
+      when :dark_red then 4
+      when :dark_purple then 5
+      when :dark_yellow, :narrative then 6
+      when :default_white, :default, :dark_white then 7
+      when :silver then 8
+      when :blue then 9
+      when :green, :success then 10
+      when :cyan, :output then 11
+      when :red, :failure then 12
+      when :purple then 13
+      when :yellow then 14
+      when :white then 15
+      else
+        0
+    end
+  end
+	
+	def posix_colour(colour)
+	  case colour
+      when :black then 30  
+      when :red, :failure then 31
+      when :green, :success then 32
+			when :yellow then 33
+      when :blue, :narrative then 34
+      when :purple, :magenta then 35
+      when :cyan, :output then 36
+      when :white, :default_white, :default then 37
+      else
+        30
+    end
+  end
+	
+  def out_c(mode, colour, str)
+    case RUBY_PLATFORM
+			when /(win|w)32$/
+			  change_to(colour)
+				 $stdout.puts str if mode == :puts
+				 $stdout.print str if mode == :print
+			  change_to(:default_white)
+			else
+				$stdout.puts("#{change_to(colour)}#{str}\033[0m") if mode == :puts
+				$stdout.print("#{change_to(colour)}#{str}\033[0m") if mode == :print
+		end			
+  end
+end # ColourCommandLine
+
+def colour_puts(role,str)  ColourCommandLine.new.out_c(:puts, role, str)  end
+def colour_print(role,str) ColourCommandLine.new.out_c(:print, role, str) end
+

Added: incubator/celix/trunk/cmake/unity/colour_reporter.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/unity/colour_reporter.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/unity/colour_reporter.rb (added)
+++ incubator/celix/trunk/cmake/unity/colour_reporter.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,39 @@
+# ==========================================
+#   Unity Project - A Test Framework for C
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   [Released under MIT License. Please refer to license.txt for details]
+# ========================================== 
+
+require "#{File.expand_path(File.dirname(__FILE__))}/colour_prompt"
+
+$colour_output = true
+
+def report(message)
+  if not $colour_output
+    $stdout.puts(message)
+  else
+    message = message.join('\n') if (message.class == Array)
+    message.each_line do |line|
+      line.chomp!
+      colour = case(line)
+        when /(?:total\s+)?tests:?\s+(\d+)\s+(?:total\s+)?failures:?\s+\d+\s+Ignored:?/i
+          ($1.to_i == 0) ? :green : :red
+        when /PASS/
+          :green
+        when /^OK$/
+          :green
+        when /(?:FAIL|ERROR)/
+          :red
+        when /IGNORE/
+          :yellow
+        when /^(?:Creating|Compiling|Linking)/
+          :white
+        else
+          :silver
+      end
+      colour_puts(colour, line)
+    end
+  end
+  $stdout.flush
+  $stderr.flush
+end
\ No newline at end of file

Added: incubator/celix/trunk/cmake/unity/generate_config.yml
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/unity/generate_config.yml?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/unity/generate_config.yml (added)
+++ incubator/celix/trunk/cmake/unity/generate_config.yml Wed Oct  2 09:01:20 2013
@@ -0,0 +1,36 @@
+#this is a sample configuration file for generate_module
+#you would use it by calling generate_module with the -ygenerate_config.yml option
+#files like this are useful for customizing generate_module to your environment
+:generate_module:
+  :defaults:
+    #these defaults are used in place of any missing options at the command line
+    :path_src: ../src/
+    :path_inc: ../src/
+    :path_tst: ../test/
+    :update_svn: true
+  :includes:
+    #use [] for no additional includes, otherwise list the includes on separate lines
+    :src:
+      - Defs.h
+      - Board.h
+    :inc: []
+    :tst:
+      - Defs.h
+      - Board.h
+      - Exception.h
+  :boilerplates: 
+    #these are inserted at the top of generated files.
+    #just comment out or remove if not desired.
+    #use %1$s where you would like the file name to appear (path/extension not included)
+    :src: |
+      //-------------------------------------------
+      // %1$s.c
+      //-------------------------------------------
+    :inc: |
+      //-------------------------------------------
+      // %1$s.h
+      //-------------------------------------------
+    :tst: |
+      //-------------------------------------------
+      // Test%1$s.c : Units tests for %1$s.c
+      //-------------------------------------------



Mime
View raw message