6 files changed, 622 insertions, 0 deletions
diff --git a/FreeRTOS-Plus/Test/CMock/test/c/TestCMockC.c b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockC.c
new file mode 100644
index 000000000..769a2b31d
--- /dev/null
+++ b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockC.c
@@ -0,0 +1,333 @@
+/* ==========================================
+    CMock Project - Automatic Mock Generation for C
+    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+    [Released under MIT License. Please refer to license.txt for details]
+========================================== */
+
+#include "unity.h"
+#include "cmock.h"
+
+#define TEST_MEM_INDEX_SIZE  (sizeof(CMOCK_MEM_INDEX_TYPE))
+
+void setUp(void)
+{
+  CMock_Guts_MemFreeAll();
+}
+
+void tearDown(void)
+{
+}
+
+void test_MemNewWillReturnNullIfGivenIllegalSizes(void)
+{
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNew(0) );
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNew(CMOCK_MEM_SIZE - TEST_MEM_INDEX_SIZE + 1) );
+  TEST_ASSERT_NULL( CMock_Guts_GetAddressFor(CMOCK_GUTS_NONE) );
+
+  //verify we're cleared still
+  TEST_ASSERT_LESS_OR_EQUAL_UINT32(CMOCK_MEM_SIZE, CMock_Guts_MemBytesCapacity());
+  TEST_ASSERT_EQUAL_UINT32(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_LESS_OR_EQUAL_UINT32(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
+}
+
+void test_MemShouldProtectAgainstMemoryOverflow(void)
+{
+  (void)CMock_Guts_MemNew(CMOCK_MEM_SIZE - TEST_MEM_INDEX_SIZE);
+
+  //verify we've used all the memory
+  TEST_ASSERT_LESS_OR_EQUAL_UINT32(TEST_MEM_INDEX_SIZE, CMock_Guts_MemBytesFree());
+  TEST_ASSERT_GREATER_OR_EQUAL_UINT32(CMOCK_MEM_SIZE, CMock_Guts_MemBytesUsed());
+}
+
+void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void)
+{
+  CMOCK_MEM_INDEX_TYPE next = CMock_Guts_MemNew(4);
+  TEST_ASSERT_EQUAL(4 + TEST_MEM_INDEX_SIZE, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 4 - TEST_MEM_INDEX_SIZE, CMock_Guts_MemBytesFree());
+
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemChain(next + CMOCK_MEM_SIZE, next) );
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemChain(next, next + CMOCK_MEM_SIZE) );
+
+  //verify we're still the same
+  TEST_ASSERT_EQUAL(4 + TEST_MEM_INDEX_SIZE, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 4 - TEST_MEM_INDEX_SIZE, CMock_Guts_MemBytesFree());
+}
+
+void test_MemNextWillReturnNullIfGivenABadRoot(void)
+{
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext(0) );
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext(2) );
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext(CMOCK_MEM_SIZE - 4) );
+
+  //verify we're cleared still
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
+}
+
+void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
+{
+  unsigned int  i;
+  CMOCK_MEM_INDEX_TYPE next;
+  CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
+  CMOCK_MEM_INDEX_TYPE element[4];
+
+  //verify we're cleared first
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
+
+  //first element
+  element[0] = CMock_Guts_MemNew(sizeof(unsigned int));
+  TEST_ASSERT_MESSAGE(element[0] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+  first = CMock_Guts_MemChain(first, element[0]);
+  TEST_ASSERT_EQUAL(element[0], first);
+  *((unsigned int*)CMock_Guts_GetAddressFor(element[0])) = 0;
+
+  //verify we're using the right amount of memory
+  TEST_ASSERT_EQUAL(1 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 1 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesFree());
+
+  //second element
+  element[1] = CMock_Guts_MemNew(sizeof(unsigned int));
+  TEST_ASSERT_MESSAGE(element[1] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+  TEST_ASSERT_NOT_EQUAL(element[0], element[1]);
+  TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[1]));
+  *((unsigned int*)CMock_Guts_GetAddressFor(element[1])) = 1;
+
+  //verify we're using the right amount of memory
+  TEST_ASSERT_EQUAL(2 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 2 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesFree());
+
+  //third element
+  element[2] = CMock_Guts_MemNew(sizeof(unsigned int));
+  TEST_ASSERT_MESSAGE(element[2] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+  TEST_ASSERT_NOT_EQUAL(element[0], element[2]);
+  TEST_ASSERT_NOT_EQUAL(element[1], element[2]);
+  TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[2]));
+  *((unsigned int*)CMock_Guts_GetAddressFor(element[2])) = 2;
+
+  //verify we're using the right amount of memory
+  TEST_ASSERT_EQUAL(3 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 3 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesFree());
+
+  //fourth element
+  element[3] = CMock_Guts_MemNew(sizeof(unsigned int));
+  TEST_ASSERT_MESSAGE(element[3] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+  TEST_ASSERT_NOT_EQUAL(element[0], element[3]);
+  TEST_ASSERT_NOT_EQUAL(element[1], element[3]);
+  TEST_ASSERT_NOT_EQUAL(element[2], element[3]);
+  TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[3]));
+  *((unsigned int*)CMock_Guts_GetAddressFor(element[3])) = 3;
+
+  //verify we're using the right amount of memory
+  TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 4 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesFree());
+
+  //traverse list
+  next = first;
+  for (i = 0; i < 4; i++)
+  {
+    TEST_ASSERT_EQUAL(element[i], next);
+    TEST_ASSERT_EQUAL(i, *((unsigned int*)CMock_Guts_GetAddressFor(element[i])));
+    next = CMock_Guts_MemNext(next);
+  }
+
+  //verify we get a null at the end of the list
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
+
+  //verify we're using the right amount of memory
+  TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 4 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesFree());
+
+  //Free it all
+  CMock_Guts_MemFreeAll();
+
+  //verify we're cleared
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
+}
+
+void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void)
+{
+  unsigned int  i;
+  CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
+  CMOCK_MEM_INDEX_TYPE next;
+
+  //even though we are asking for one byte, we've told it to align to closest CMOCK_MEM_ALIGN_SIZE bytes, therefore it will waste a byte each time
+  //so each call will use (CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE) bytes (CMOCK_MEM_INDEX_SIZE for the index, 1 for the data, and (CMOCK_MEM_ALIGN_SIZE - 1) wasted).
+  //therefore we can safely allocated total/(CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE) times.
+  for (i = 0; i < (CMOCK_MEM_SIZE / (CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE)); i++)
+  {
+    TEST_ASSERT_EQUAL(i*(CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE), CMock_Guts_MemBytesUsed());
+    TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*(CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE), CMock_Guts_MemBytesFree());
+
+    next = CMock_Guts_MemNew(1);
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+
+    first = CMock_Guts_MemChain(first, next);
+    TEST_ASSERT_MESSAGE(first != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+  }
+
+  //verify we're at top of memory
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesFree());
+
+  //The very next call will return a NULL, and any after that
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(1));
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(1));
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(1));
+
+  //verify nothing has changed
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesFree());
+
+  //verify we can still walk through the elements allocated
+  next = first;
+  for (i = 0; i < (CMOCK_MEM_SIZE / (CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE)); i++)
+  {
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+    next = CMock_Guts_MemNext(next);
+  }
+
+  //there aren't any after that
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, (UNITY_UINT32)next);
+}
+
+void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd(void)
+{
+  unsigned int  i;
+  CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
+  CMOCK_MEM_INDEX_TYPE next;
+
+  //we're asking for (CMOCK_MEM_INDEX_SIZE + 8) bytes each time now (CMOCK_MEM_INDEX_SIZE for index, 8 for data).
+  //CMOCK_MEM_SIZE/(CMOCK_MEM_INDEX_SIZE + 8) requests will request as much data as possible, while ensuring that there isn't enough
+  //memory for the next request
+  for (i = 0; i < CMOCK_MEM_SIZE/(CMOCK_MEM_INDEX_SIZE + 8); i++)
+  {
+    TEST_ASSERT_EQUAL(i*(CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesUsed());
+    TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*(CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesFree());
+
+    next = CMock_Guts_MemNew(8);
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+
+    first = CMock_Guts_MemChain(first, next);
+    TEST_ASSERT_MESSAGE(first != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+
+    //verify writing data won't screw us up
+    *((unsigned int*)CMock_Guts_GetAddressFor(next)) = i;
+  }
+
+  //verify we're at top of memory
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - CMOCK_MEM_SIZE % (CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE % (CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesFree());
+
+  //The very next call will return a NONE, and any after that
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(8));
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(5));
+
+  //verify nothing has changed
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - CMOCK_MEM_SIZE % (CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE % (CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesFree());
+
+  //verify we can still walk through the elements allocated
+  next = first;
+  for (i = 0; i < CMOCK_MEM_SIZE/(CMOCK_MEM_INDEX_SIZE + 8); i++)
+  {
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+    TEST_ASSERT_EQUAL(i, *((unsigned int*)CMock_Guts_GetAddressFor(next)));
+    next = CMock_Guts_MemNext(next);
+  }
+
+  //there aren't any after that
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
+}
+
+void test_ThatWeCanAskForAllSortsOfSizes(void)
+{
+#if CMOCK_MEM_ALIGN != 2
+  TEST_IGNORE_MESSAGE("Test relies on a particular environmental setup, which is not present");
+#else
+
+  unsigned int  i;
+  CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
+  CMOCK_MEM_INDEX_TYPE next;
+  CMOCK_MEM_INDEX_TYPE sizes[5] = {3, 1, 80, 5, 4};
+  CMOCK_MEM_INDEX_TYPE sizes_buffered[5] = {4, 4, 80, 8, 4};
+  CMOCK_MEM_INDEX_TYPE sum = 0;
+
+  for (i = 0; i < 5; i++)
+  {
+    next = CMock_Guts_MemNew(sizes[i]);
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+
+    first = CMock_Guts_MemChain(first, next);
+    TEST_ASSERT_MESSAGE(first != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+
+    sum += sizes_buffered[i] + 4;
+    TEST_ASSERT_EQUAL(sum, CMock_Guts_MemBytesUsed());
+    TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - sum, CMock_Guts_MemBytesFree());
+  }
+
+  //show that we can't ask for too much memory
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(CMOCK_MEM_SIZE - sum + 8));
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(CMOCK_MEM_SIZE - sum + 1));
+
+  //but we CAN ask for something that will still fit
+  next = CMock_Guts_MemNew(CMOCK_MEM_SIZE - sum - 4);
+  TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+
+  first = CMock_Guts_MemChain(first, next);
+  TEST_ASSERT_MESSAGE(first != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+
+  //verify we're used up now
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesFree());
+
+  //verify we can still walk through the elements allocated
+  next = first;
+  for (i = 0; i < 6; i++)
+  {
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+    next = CMock_Guts_MemNext(next);
+  }
+
+  //there aren't any after that
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
+#endif
+}
+
+void test_MemEndOfChain(void)
+{
+  CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
+  CMOCK_MEM_INDEX_TYPE element[4];
+
+  //verify we're cleared first
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
+
+  //first element
+  element[0] = CMock_Guts_MemNew(sizeof(unsigned int));
+  first = CMock_Guts_MemChain(first, element[0]);
+  TEST_ASSERT_MESSAGE(element[0] == CMock_Guts_MemEndOfChain(first), "Should have returned element[0]");
+
+  //second element
+  element[1] = CMock_Guts_MemNew(sizeof(unsigned int));
+  CMock_Guts_MemChain(first, element[1]);
+  TEST_ASSERT_MESSAGE(element[1] == CMock_Guts_MemEndOfChain(first), "Should have returned element[1]");
+
+  //third element
+  element[2] = CMock_Guts_MemNew(sizeof(unsigned int));
+  CMock_Guts_MemChain(first, element[2]);
+  TEST_ASSERT_MESSAGE(element[2] == CMock_Guts_MemEndOfChain(first), "Should have returned element[2]");
+
+  //fourth element
+  element[3] = CMock_Guts_MemNew(sizeof(unsigned int));
+  CMock_Guts_MemChain(first, element[3]);
+  TEST_ASSERT_MESSAGE(element[3] == CMock_Guts_MemEndOfChain(first), "Should have returned element[3]");
+
+  //Free it all
+  CMock_Guts_MemFreeAll();
+
+  //verify we're cleared
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
+}
diff --git a/FreeRTOS-Plus/Test/CMock/test/c/TestCMockC.yml b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockC.yml
new file mode 100644
index 000000000..06067b161
--- /dev/null
+++ b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockC.yml
@@ -0,0 +1,14 @@
+---
+:files:
+  - '../src/cmock.c'
+  - './c/TestCMockC.c'
+  - './c/TestCMockC_Runner.c'
+  - '../vendor/unity/src/unity.c'
+:options:
+  - 'TEST'
+  - 'CMOCK_MEM_STATIC'
+  - 'CMOCK_MEM_SIZE=128'
+  #- 'CMOCK_MEM_SIZE=40000'
+  - 'CMOCK_MEM_ALIGN=2'
+  - 'CMOCK_MEM_INDEX_TYPE=int'
+
diff --git a/FreeRTOS-Plus/Test/CMock/test/c/TestCMockCDynamic.c b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockCDynamic.c
new file mode 100644
index 000000000..b81d9d0b2
--- /dev/null
+++ b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockCDynamic.c
@@ -0,0 +1,186 @@
+/* ==========================================
+    CMock Project - Automatic Mock Generation for C
+    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+    [Released under MIT License. Please refer to license.txt for details]
+========================================== */
+
+#include "unity.h"
+#include "cmock.h"
+
+#define TEST_MEM_INDEX_SIZE  (CMOCK_MEM_INDEX_TYPE)(sizeof(CMOCK_MEM_INDEX_TYPE))
+#define TEST_MEM_INDEX_PAD   (CMOCK_MEM_INDEX_TYPE)(((CMOCK_MEM_INDEX_TYPE)sizeof(CMOCK_MEM_INDEX_TYPE) + 7) & ~7) //round up to nearest 4 byte boundary
+
+CMOCK_MEM_INDEX_TYPE StartingSize;
+
+void setUp(void)
+{
+  CMock_Guts_MemFreeAll();
+  StartingSize = CMock_Guts_MemBytesFree();
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+}
+
+void tearDown(void)
+{
+}
+
+void test_MemNewWillReturnNullIfGivenIllegalSizes(void)
+{
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNew(0) );
+
+  //verify we're cleared still
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesFree());
+}
+
+void test_MemNewWillNowSupportSizesGreaterThanTheDefinesCMockSize(void)
+{
+    TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesFree());
+
+    TEST_ASSERT_MESSAGE(CMock_Guts_MemNew(CMOCK_MEM_SIZE - TEST_MEM_INDEX_SIZE + 1) != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+
+    TEST_ASSERT_EQUAL(((CMOCK_MEM_INDEX_TYPE)CMOCK_MEM_SIZE + TEST_MEM_INDEX_PAD), CMock_Guts_MemBytesUsed());
+    TEST_ASSERT_EQUAL((CMOCK_MEM_INDEX_TYPE)CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
+}
+
+void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void)
+{
+  CMOCK_MEM_INDEX_TYPE next = CMock_Guts_MemNew(8);
+  TEST_ASSERT_EQUAL(8 + TEST_MEM_INDEX_PAD, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(StartingSize - 8 - TEST_MEM_INDEX_PAD, CMock_Guts_MemBytesFree());
+
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemChain(next + CMOCK_MEM_SIZE, next) );
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemChain(next, next + CMOCK_MEM_SIZE) );
+
+  //verify we're still the same
+  TEST_ASSERT_EQUAL(8 + TEST_MEM_INDEX_PAD, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(StartingSize - 8 - TEST_MEM_INDEX_PAD, CMock_Guts_MemBytesFree());
+}
+
+void test_MemNextWillReturnNullIfGivenABadRoot(void)
+{
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext(0) );
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext(2) );
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext( CMOCK_MEM_SIZE - 4 ) );
+
+  //verify we're cleared still
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(StartingSize, CMock_Guts_MemBytesFree());
+}
+
+void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
+{
+  unsigned int  i;
+  CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
+  CMOCK_MEM_INDEX_TYPE next;
+  CMOCK_MEM_INDEX_TYPE element[4];
+
+  //verify we're cleared first
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(StartingSize, CMock_Guts_MemBytesFree());
+
+  //first element
+  element[0] = CMock_Guts_MemNew(sizeof(unsigned int));
+  TEST_ASSERT_MESSAGE(element[0] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+  first = CMock_Guts_MemChain(first, element[0]);
+  TEST_ASSERT_EQUAL(element[0], first);
+  *((unsigned int*)CMock_Guts_GetAddressFor(element[0])) = 0;
+
+  //verify we're using the right amount of memory
+  TEST_ASSERT_EQUAL(1 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(StartingSize - 1 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree());
+
+  //second element
+  element[1] = CMock_Guts_MemNew(sizeof(unsigned int));
+  TEST_ASSERT_MESSAGE(element[1] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+  TEST_ASSERT_NOT_EQUAL(element[0], element[1]);
+  TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[1]));
+  *((unsigned int*)CMock_Guts_GetAddressFor(element[1])) = 1;
+
+  //verify we're using the right amount of memory
+  TEST_ASSERT_EQUAL(2 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(StartingSize - 2 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree());
+
+  //third element
+  element[2] = CMock_Guts_MemNew(sizeof(unsigned int));
+  TEST_ASSERT_MESSAGE(element[2] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+  TEST_ASSERT_NOT_EQUAL(element[0], element[2]);
+  TEST_ASSERT_NOT_EQUAL(element[1], element[2]);
+  TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[2]));
+  *((unsigned int*)CMock_Guts_GetAddressFor(element[2])) = 2;
+
+  //verify we're using the right amount of memory
+  TEST_ASSERT_EQUAL(3 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(StartingSize - 3 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree());
+
+  //fourth element
+  element[3] = CMock_Guts_MemNew(sizeof(unsigned int));
+  TEST_ASSERT_MESSAGE(element[3] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+  TEST_ASSERT_NOT_EQUAL(element[0], element[3]);
+  TEST_ASSERT_NOT_EQUAL(element[1], element[3]);
+  TEST_ASSERT_NOT_EQUAL(element[2], element[3]);
+  TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[3]));
+  *((unsigned int*)CMock_Guts_GetAddressFor(element[3])) = 3;
+
+  //verify we're using the right amount of memory
+  TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(StartingSize - 4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree());
+
+  //traverse list
+  next = first;
+  for (i = 0; i < 4; i++)
+  {
+    TEST_ASSERT_EQUAL(element[i], next);
+    TEST_ASSERT_EQUAL(i, *((unsigned int*)CMock_Guts_GetAddressFor(element[i])));
+    next = CMock_Guts_MemNext(next);
+  }
+
+  //verify we get a null at the end of the list
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, next);
+
+  //verify we're using the right amount of memory
+  TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(StartingSize - 4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree());
+
+  //Free it all
+  CMock_Guts_MemFreeAll();
+
+  //verify we're cleared
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(StartingSize, CMock_Guts_MemBytesFree());
+}
+
+void test_ThatWeCanAskForAllSortsOfSizes(void)
+{
+  CMOCK_MEM_INDEX_TYPE i;
+  CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
+  CMOCK_MEM_INDEX_TYPE next;
+  CMOCK_MEM_INDEX_TYPE sizes[10]          = {3,  1,  80,  5,  8,  31, 7,  911, 2,  80};
+  CMOCK_MEM_INDEX_TYPE sizes_buffered[10] = {16, 16, 88,  16, 16, 40, 16, 920, 16, 88}; //includes counter
+  CMOCK_MEM_INDEX_TYPE sum = 0;
+  CMOCK_MEM_INDEX_TYPE cap;
+
+  for (i = 0; i < 10; i++)
+  {
+    next = CMock_Guts_MemNew(sizes[i]);
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+
+    first = CMock_Guts_MemChain(first, next);
+    TEST_ASSERT_MESSAGE(first != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+
+    sum += sizes_buffered[i];
+    cap = (StartingSize > (sum + CMOCK_MEM_SIZE)) ? StartingSize : (sum + CMOCK_MEM_SIZE);
+    TEST_ASSERT_EQUAL(sum, CMock_Guts_MemBytesUsed());
+    TEST_ASSERT(cap >= CMock_Guts_MemBytesFree());
+  }
+
+  //verify we can still walk through the elements allocated
+  next = first;
+  for (i = 0; i < 10; i++)
+  {
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+    next = CMock_Guts_MemNext(next);
+  }
+
+  //there aren't any after that
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, next);
+}
diff --git a/FreeRTOS-Plus/Test/CMock/test/c/TestCMockCDynamic.yml b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockCDynamic.yml
new file mode 100644
index 000000000..393d8dd86
--- /dev/null
+++ b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockCDynamic.yml
@@ -0,0 +1,12 @@
+---
+:files:
+  - '../src/cmock.c'
+  - './c/TestCMockCDynamic.c'
+  - './c/TestCMockCDynamic_Runner.c'
+  - '../vendor/unity/src/unity.c'
+:options:
+  - 'TEST'
+  - 'CMOCK_MEM_DYNAMIC'
+  - 'CMOCK_MEM_SIZE=64'
+  - 'CMOCK_MEM_ALIGN=3'
+  - 'CMOCK_MEM_INDEX_TYPE=short'
diff --git a/FreeRTOS-Plus/Test/CMock/test/c/TestCMockCDynamic_Runner.c b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockCDynamic_Runner.c
new file mode 100644
index 000000000..d68608091
--- /dev/null
+++ b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockCDynamic_Runner.c
@@ -0,0 +1,36 @@
+/* ==========================================
+    CMock Project - Automatic Mock Generation for C
+    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+    [Released under MIT License. Please refer to license.txt for details]
+========================================== */
+
+#include "unity.h"
+#include "cmock.h"
+#include <setjmp.h>
+#include <stdio.h>
+
+extern void setUp(void);
+extern void tearDown(void);
+
+extern void test_MemNewWillReturnNullIfGivenIllegalSizes(void);
+extern void test_MemNewWillNowSupportSizesGreaterThanTheDefinesCMockSize(void);
+extern void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void);
+extern void test_MemNextWillReturnNullIfGivenABadRoot(void);
+extern void test_ThatWeCanClaimAndChainAFewElementsTogether(void);
+extern void test_ThatWeCanAskForAllSortsOfSizes(void);
+
+int main(void)
+{
+  UnityBegin("TestCMockDynamic.c");
+
+  RUN_TEST(test_MemNewWillReturnNullIfGivenIllegalSizes, 26);
+  RUN_TEST(test_MemNewWillNowSupportSizesGreaterThanTheDefinesCMockSize, 35);
+  RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 45);
+  RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 59);
+  RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 70);
+  RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 152);
+
+  UnityEnd();
+  CMock_Guts_MemFreeFinal();
+  return 0;
+}
diff --git a/FreeRTOS-Plus/Test/CMock/test/c/TestCMockC_Runner.c b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockC_Runner.c
new file mode 100644
index 000000000..af559d8f4
--- /dev/null
+++ b/FreeRTOS-Plus/Test/CMock/test/c/TestCMockC_Runner.c
@@ -0,0 +1,41 @@
+/* ==========================================
+    CMock Project - Automatic Mock Generation for C
+    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+    [Released under MIT License. Please refer to license.txt for details]
+========================================== */
+
+#include "unity.h"
+#include <setjmp.h>
+#include <stdio.h>
+
+extern void setUp(void);
+extern void tearDown(void);
+
+extern void test_MemNewWillReturnNullIfGivenIllegalSizes(void);
+extern void test_MemShouldProtectAgainstMemoryOverflow(void);
+extern void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void);
+extern void test_MemNextWillReturnNullIfGivenABadRoot(void);
+extern void test_ThatWeCanClaimAndChainAFewElementsTogether(void);
+extern void test_MemEndOfChain(void);
+extern void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void);
+extern void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd(void);
+extern void test_ThatWeCanAskForAllSortsOfSizes(void);
+
+int main(void)
+{
+  Unity.TestFile = "TestCMock.c";
+  UnityBegin(Unity.TestFile);
+
+  RUN_TEST(test_MemNewWillReturnNullIfGivenIllegalSizes, 21);
+  RUN_TEST(test_MemShouldProtectAgainstMemoryOverflow, 33);
+  RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 42);
+  RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 56);
+  RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 67);
+  RUN_TEST(test_MemEndOfChain, 149);
+  RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory, 195);
+  RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd, 244);
+  RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 298);
+
+  UnityEnd();
+  return 0;
+}