cpputest · jgonzalezdr · Jun 21, 2016 · Jun 26, 2016 · Jun 26, 2016 · Jun 26, 2016
diff --git a/CppUTest.dsp b/CppUTest.dsp
diff --git a/CppUTest.vcproj b/CppUTest.vcproj
@@ -384,6 +384,28 @@
 					/>
 				</FileConfiguration>
 			</File>
+			<File
+				RelativePath="src\CppUTestExt\MockActualCallsQueue.cpp"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories=""
+						PreprocessorDefinitions=""
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories=""
+						PreprocessorDefinitions=""
+					/>
+				</FileConfiguration>
+			</File>
 			<File
 				RelativePath="src\CppUTestExt\MockExpectedCall.cpp"
 				>
@@ -927,6 +949,10 @@
 				RelativePath=".\include\CppUTestExt\MockActualCall.h"
 				>
 			</File>
+			<File
+				RelativePath="include\CppUTestExt\MockActualCallsQueue.h"
+				>
+			</File>
 			<File
 				RelativePath="include\CppUTestExt\MockCheckedActualCall.h"
 				>

diff --git a/CppUTest.vcxproj b/CppUTest.vcxproj
@@ -117,6 +117,7 @@
     <ClCompile Include="src\CppUTestExt\MemoryReporterPlugin.cpp" />
     <ClCompile Include="src\CppUTestExt\MemoryReportFormatter.cpp" />
     <ClCompile Include="src\CppUTestExt\MockActualCall.cpp" />
+    <ClCompile Include="src\CppUTestExt\MockActualCallsQueue.cpp" />
     <ClCompile Include="src\CppUTestExt\MockExpectedCall.cpp" />
     <ClCompile Include="src\CppUTestExt\MockExpectedCallsList.cpp" />
     <ClCompile Include="src\CppUTestExt\MockFailure.cpp" />
@@ -159,6 +160,7 @@
     <ClInclude Include="include\CppUTestExt\MemoryReporterPlugin.h" />
     <ClInclude Include="include\CppUTestExt\MemoryReportFormatter.h" />
     <ClInclude Include="include\CppUTestExt\MockActualCall.h" />
+    <ClInclude Include="include\CppUTestExt\MockActualCallsQueue.h" />
     <ClInclude Include="include\CppUTestExt\MockCheckedActualCall.h" />
     <ClInclude Include="include\CppUTestExt\MockCheckedExpectedCall.h" />
     <ClInclude Include="include\CppUTestExt\MockExpectedCall.h" />

diff --git a/Makefile.am b/Makefile.am
@@ -95,6 +95,7 @@ lib_libCppUTestExt_a_SOURCES = \
    src/CppUTestExt/MemoryReporterPlugin.cpp \
    src/CppUTestExt/MemoryReportFormatter.cpp \
    src/CppUTestExt/MockActualCall.cpp \
+   src/CppUTestExt/MockActualCallsQueue.cpp \
    src/CppUTestExt/MockExpectedCall.cpp \
    src/CppUTestExt/MockExpectedCallsList.cpp \
    src/CppUTestExt/MockFailure.cpp \
@@ -118,6 +119,7 @@ include_cpputestext_HEADERS = \
 	include/CppUTestExt/MockActualCall.h \
 	include/CppUTestExt/MockCheckedActualCall.h \
 	include/CppUTestExt/MockCheckedExpectedCall.h \
+	include/CppUTestExt/MockActualCallsQueue.h \
 	include/CppUTestExt/MockExpectedCall.h \
 	include/CppUTestExt/MockExpectedCallsList.h \
 	include/CppUTestExt/MockFailure.h \
@@ -192,6 +194,7 @@ CppUTestExtTests_SOURCES = \
 	tests/CppUTestExt/MockComparatorCopierTest.cpp \
 	tests/CppUTestExt/MockExpectedCallTest.cpp \
 	tests/CppUTestExt/ExpectedFunctionsListTest.cpp \
+	tests/CppUTestExt/ActualCallsQueueTest.cpp \
 	tests/CppUTestExt/MockFailureReporterForTest.cpp \
 	tests/CppUTestExt/MockFailureTest.cpp \
 	tests/CppUTestExt/MockHierarchyTest.cpp \

diff --git a/include/CppUTest/SimpleString.h b/include/CppUTest/SimpleString.h
@@ -173,8 +173,9 @@ SimpleString BracketsFormattedHexStringFrom(cpputest_longlong value);
 SimpleString BracketsFormattedHexStringFrom(cpputest_ulonglong value);
 SimpleString BracketsFormattedHexStringFrom(signed char value);
 SimpleString BracketsFormattedHexString(SimpleString hexString);
-
-
+SimpleString AppendStringOnANewLine(const SimpleString& inputString, const SimpleString& stringToAppend,
+                                    const SimpleString& linePrefix = "");
+SimpleString ReplaceWithTextNoneWhenEmpty(const SimpleString& inputString, const SimpleString& linePrefix);
 
 #if CPPUTEST_USE_STD_CPP_LIB
 

diff --git a/include/CppUTestExt/MockActualCall.h b/include/CppUTestExt/MockActualCall.h
@@ -42,7 +42,6 @@ class MockActualCall
     virtual ~MockActualCall();
 
     virtual MockActualCall& withName(const SimpleString& name)=0;
-    virtual MockActualCall& withCallOrder(int callOrder)=0;
     MockActualCall& withParameter(const SimpleString& name, bool value) { return withBoolParameter(name, value); }
     MockActualCall& withParameter(const SimpleString& name, int value) { return withIntParameter(name, value); }
     MockActualCall& withParameter(const SimpleString& name, unsigned int value) { return withUnsignedIntParameter(name, value); }

diff --git a/include/CppUTestExt/MockActualCallsQueue.h b/include/CppUTestExt/MockActualCallsQueue.h
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2016, Jesus Gonzalez
+ * 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_MockActualCallsQueue_h
+#define D_MockActualCallsQueue_h
+
+class MockCheckedActualCall;
+class SimpleString;
+
+/**
+ * This class implements a FIFO queue of MockCheckedActualCall calls.
+ *
+ * @note The queue can be created as owner of its stored calls or not. If the queue is the owner, then the ownership of the calls added
+ * to the queue is transferred to the queue, and therefore it's responsible for managing their life cycle (i.e. deleting them).
+ *
+ * @note The queue has a size limit. When the queue reaches its maximum size, adding new calls on the back will remove calls from the front.
+ */
+class MockActualCallsQueue
+{
+
+public:
+    /**
+     * Constructor.
+     *
+     * Creates an empty queue.
+     *
+     * @param owner [in] Indicates if the ownership of the calls added to the queue shall be transferred to the queue
+     * @param maxSize [in] Maximum size for the queue
+     */
+    MockActualCallsQueue(bool owner, unsigned int maxSize = (unsigned int) -1);
+
+    /**
+     * Destructor.
+     *
+     * Discards all items, and if the queue is the owner of the calls, then deletes their associated calls.
+     */
+    virtual ~MockActualCallsQueue();
+
+    /**
+     * Returns the number of calls stored in the queue.
+     *
+     * @return Size of the queue
+     */
+    virtual unsigned int size() const;
+
+    /**
+     * Checks if the queue is empty.
+     *
+     * @return @c true if the queue is empty, @c false otherwise
+     */
+    virtual bool isEmpty() const;
+
+    /**
+     * Clears the queue, discarding all items, and if the queue is the owner of its calls, then also deleting their associated calls.
+     */
+    virtual void clear();
+
+    /**
+     * Appends the call to the back of the queue.
+     *
+     * @note If the queue is the owner of its calls, then it becomes the owner of the passed object.
+     *
+     * @note If the queue is at its size limit, then the first item is discarded, and if the queue is the owner of its calls, then the
+     * associated call is also deleted.
+     *
+     * @param call [in] Pointer to the call to be appended
+     */
+    virtual void pushBack(MockCheckedActualCall* call);
+
+    /**
+     * Removes a call from the front of the queue, and returns it.
+     *
+     * @note If the queue is the owner of its calls, then the caller becomes the owner of the returned object.
+     *
+     * @return Pointer to the call that was in front of the queue, or NULL if the queue was empty
+     */
+    virtual MockCheckedActualCall* popFront();
+
+    /**
+     * Appends all the calls from @c otherQueue to the back of this queue.
+     *
+     * @note If this queue is the owner of calls, then it becomes the owner all the calls from @c otherQueue. This means that either
+     * this queue shall not be owner of calls, or that it's owner of calls and the calls from @c otherQueue do not have an owner
+     * yet (i.e. @c otherQueue is not owner of calls).
+     *
+     * @param otherQueue [in] Another queue
+     */
+    virtual void pushBackAll(const MockActualCallsQueue& otherQueue);
+
+    /**
+     * Gets the maximum size for the queue.
+     * @return Maximum size
+     */
+    virtual unsigned int getMaxSize();
+
+    /**
+     * Sets the maximum size for the queue.
+     *
+     * @note If the current size is greater than @c maxSize, then calls are removed in order from the front of the queue until the
+     * current size is equal to the maximum size.
+     *
+     * @param maxSize [in] Maximum size
+     */
+    virtual void setMaxSize(unsigned int maxSize);
+
+    /**
+     * Returns a string representation of the queue as a list with the description of all its stored calls, each on a new line.
+     *
+     * @param linePrefix String to be added before each individual call description
+     * @return String representation of the queue
+     */
+    virtual SimpleString toString(const SimpleString& linePrefix) const;
+
+    /**
+     * Returns a string representation of the queue as a list with the description of its stored calls for function @c functionName,
+     * each on a new line.
+     *
+     * @param functionName Name of the function to be filtered through
+     * @param linePrefix String to be added before each individual call description
+     * @return String representation of the queue
+     */
+    virtual SimpleString toStringFilterByFunction(const SimpleString& functionName, const SimpleString& linePrefix) const;
+
+protected:
+    class MockActualCallsQueueNode
+    {
+    public:
+        MockCheckedActualCall* call_;
+
+        MockActualCallsQueueNode* next_;
+        MockActualCallsQueueNode(MockCheckedActualCall* call) : call_(call), next_(NULL) {}
+    };
+
+private:
+    MockActualCallsQueueNode* head_;
+    MockActualCallsQueueNode* tail_;
+
+    unsigned int currentSize_;
+    unsigned int maxSize_;
+
+    bool owner_;
+
+    virtual void deleteFromFront();
+};
+
+#endif
diff --git a/include/CppUTestExt/MockCheckedActualCall.h b/include/CppUTestExt/MockCheckedActualCall.h
@@ -31,14 +31,15 @@
 #include "CppUTestExt/MockActualCall.h"
 #include "CppUTestExt/MockExpectedCallsList.h"
 
+class MockSupport;
+
 class MockCheckedActualCall : public MockActualCall
 {
 public:
-    MockCheckedActualCall(int callOrder, MockFailureReporter* reporter, const MockExpectedCallsList& expectations);
+    MockCheckedActualCall(unsigned int callOrder, MockFailureReporter* reporter, const MockSupport& mockSupport);
     virtual ~MockCheckedActualCall();
 
     virtual MockActualCall& withName(const SimpleString& name) _override;
-    virtual MockActualCall& withCallOrder(int) _override;
     virtual MockActualCall& withBoolParameter(const SimpleString& name, bool value) _override;
     virtual MockActualCall& withIntParameter(const SimpleString& name, int value) _override;
     virtual MockActualCall& withUnsignedIntParameter(const SimpleString& name, unsigned int value) _override;
@@ -95,17 +96,21 @@ class MockCheckedActualCall : public MockActualCall
     virtual void checkExpectations();
 
     virtual void setMockFailureReporter(MockFailureReporter* reporter);
+
+    virtual SimpleString toString() const;
+
+    const SimpleString& getName() const;
+
 protected:
     void setName(const SimpleString& name);
-    SimpleString getName() const;
     virtual UtestShell* getTest() const;
     virtual void callHasSucceeded();
     virtual void finalizeOutputParameters(MockCheckedExpectedCall* call);
-    virtual void finalizeCallWhenFulfilled();
+    virtual void finalizeCallWhenMatchIsFound();
     virtual void failTest(const MockFailure& failure);
     virtual void checkInputParameter(const MockNamedValue& actualParameter);
     virtual void checkOutputParameter(const MockNamedValue& outputParameter);
-    virtual void callIsInProgress();
+    virtual void discardCurrentlyMatchingExpectations();
 
     enum ActualCallState {
         CALL_IN_PROGRESS,
@@ -114,16 +119,21 @@ class MockCheckedActualCall : public MockActualCall
     };
     virtual void setState(ActualCallState state);
 
+    virtual const SimpleString& getScopeName() const;
+
+    void setMatchingExpectedCall(MockCheckedExpectedCall* call);
+
 private:
     SimpleString functionName_;
-    int callOrder_;
+    unsigned int callOrder_;
     MockFailureReporter* reporter_;
 
     ActualCallState state_;
-    MockCheckedExpectedCall* fulfilledExpectation_;
+    bool expectationsChecked_;
+    MockCheckedExpectedCall* matchingExpectation_;
 
-    MockExpectedCallsList unfulfilledExpectations_;
-    const MockExpectedCallsList& allExpectations_;
+    MockExpectedCallsList potentiallyMatchingExpectations_;
+    const MockSupport& mockSupport_;
 
     class MockOutputParametersListNode
     {
@@ -150,7 +160,6 @@ class MockActualCallTrace : public MockActualCall
     virtual ~MockActualCallTrace();
 
     virtual MockActualCall& withName(const SimpleString& name) _override;
-    virtual MockActualCall& withCallOrder(int) _override;
     virtual MockActualCall& withBoolParameter(const SimpleString& name, bool value) _override;
     virtual MockActualCall& withIntParameter(const SimpleString& name, int value) _override;
     virtual MockActualCall& withUnsignedIntParameter(const SimpleString& name, unsigned int value) _override;
@@ -201,6 +210,8 @@ class MockActualCallTrace : public MockActualCall
 
     virtual MockActualCall& onObject(const void* objectPtr) _override;
 
+    MockActualCall& withCallOrder(unsigned int callOrder);
+
     const char* getTraceOutput();
     void clear();
     static MockActualCallTrace& instance();
@@ -215,7 +226,6 @@ class MockIgnoredActualCall: public MockActualCall
 {
 public:
     virtual MockActualCall& withName(const SimpleString&) _override { return *this;}
-    virtual MockActualCall& withCallOrder(int) _override { return *this; }
     virtual MockActualCall& withBoolParameter(const SimpleString&, bool) _override { return *this; }
     virtual MockActualCall& withIntParameter(const SimpleString&, int) _override { return *this; }
     virtual MockActualCall& withUnsignedIntParameter(const SimpleString&, unsigned int) _override { return *this; }