ceedling 0.13.0.rc1 → 0.13.0

data/vendor/cmock/targets/iar_arm_v5.yml

@@ -0,0 +1,93 @@
+tools_root: &tools_root 'C:\Program Files\IAR Systems\Embedded Workbench 5.3\'
+compiler:
+  path:             [*tools_root, 'arm\bin\iccarm.exe']
+  source_path:     &systest_generated_path 'test/system/generated/'
+  unit_tests_path: &unit_tests_path 'examples/test/'
+  mocks_path:      &systest_mocks_path 'test/system/generated/'
+  build_path:      &systest_build_path 'test/system/build/'
+  options:
+    - --dlib_config
+    - [*tools_root, 'arm\inc\DLib_Config_Normal.h']
+    - --no_cse
+    - --no_unroll
+    - --no_inline
+    - --no_code_motion
+    - --no_tbaa
+    - --no_clustering
+    - --no_scheduling 
+    - --debug
+    - --cpu_mode thumb
+    - --endian=little
+    - --cpu=ARM7TDMI
+    - --interwork
+    - --warnings_are_errors
+    - --fpu=None
+    - -e
+    - -On
+    #We are supressing some warnings here because we test CMock against some questionable code to make sure it still works
+    - --diag_suppress=Pa050
+    - --diag_suppress=Pe191
+    - --diag_suppress=Pe494
+    - --diag_suppress=Pe083
+  includes:
+    prefix: '-I'
+    items:
+      - [*tools_root, 'arm\inc\']
+      - *systest_generated_path
+      - *unit_tests_path
+      - *systest_mocks_path
+      - 'src/'
+      - 'vendor/unity/src/'
+      - 'vendor/c_exception/lib/'
+      - 'iar\iar_v5\incIAR\'
+      - 'test\system\test_compilation\'
+      - 'test\'
+  defines:
+    prefix: '-D'
+    items:
+  object_files:
+    prefix: '-o'
+    extension: '.r79'
+    destination: *systest_build_path
+    
+linker:
+  path: [*tools_root, 'arm\bin\ilinkarm.exe']
+  options:
+    - --redirect _Printf=_PrintfLarge
+    - --redirect _Scanf=_ScanfSmall
+    - --semihosting
+    - --entry __iar_program_start
+    - --config iar\iar_v5\Resource\at91SAM7X256_RAM.icf
+  object_files:
+    path: *systest_build_path
+    extension: '.o'
+  bin_files:
+    prefix: '-o'
+    extension: '.out'
+    destination: *systest_build_path
+    
+simulator:
+  path: [*tools_root, 'common\bin\CSpyBat.exe']
+  pre_support:
+    - --silent
+    - [*tools_root, 'arm\bin\armproc.dll']
+    - [*tools_root, 'arm\bin\armsim.dll']
+  post_support:
+    - --plugin
+    - [*tools_root, 'arm\bin\armbat.dll']
+    - --macro
+    - 'iar\iar_v5\Resource\SAM7_SIM.mac'
+    - --backend
+    - -B
+    - -p
+    - [*tools_root, 'arm\config\debugger\Atmel\ioat91sam7X256.ddf']
+    - -d
+    - sim
+
+unsupported:
+  - nonstandard_parsed_stuff_1
+  - const
+  - callingconv
+  - unity_64bit_support
+
+colour: true

data/vendor/cmock/test/c/TestCMockC.c

@@ -0,0 +1,280 @@
+/* ==========================================
+    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_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
+}
+
+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 + 4), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 1 * (TEST_MEM_INDEX_SIZE + 4), 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 + 4), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 2 * (TEST_MEM_INDEX_SIZE + 4), 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 + 4), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 3 * (TEST_MEM_INDEX_SIZE + 4), 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 + 4), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 4 * (TEST_MEM_INDEX_SIZE + 4), 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 + 4), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 4 * (TEST_MEM_INDEX_SIZE + 4), 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 4 bytes, therefore it will waste a byte each time
+  //so each call will use 8 bytes (4 for the index, 1 for the data, and 3 wasted).
+  //therefore we can safely allocated total/8 times.
+  for (i = 0; i < (CMOCK_MEM_SIZE / 8); i++)
+  {
+    TEST_ASSERT_EQUAL(i*8, CMock_Guts_MemBytesUsed());
+    TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*8, 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 / 8); 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);
+}
+
+void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd(void)
+{
+  unsigned int  i;
+  CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
+  CMOCK_MEM_INDEX_TYPE next;
+
+  //we're asking for 12 bytes each time now (4 for index, 8 for data).
+  //10 requests will give us 120 bytes used, which isn't enough for another 12 bytes if total memory is 128
+  for (i = 0; i < 10; i++)
+  {
+    TEST_ASSERT_EQUAL(i*12, CMock_Guts_MemBytesUsed());
+    TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*12, 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 - 8, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(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 - 8, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(8, 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");
+    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)
+{
+  unsigned int  i;
+  CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
+  CMOCK_MEM_INDEX_TYPE next;
+  unsigned int  sizes[5] = {3, 1, 80, 5, 4};
+  unsigned int  sizes_buffered[5] = {4, 4, 80, 8, 4};
+  unsigned int  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(12));
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(5));
+
+  //but we CAN ask for something that will still fit
+  next = CMock_Guts_MemNew(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);
+}

data/vendor/cmock/test/c/TestCMockC.yml

@@ -0,0 +1,12 @@
+---
+:files:
+  - 'src/cmock.c'
+  - 'test/c/TestCMockC.c'
+  - 'test/c/TestCMockC_Runner.c'
+  - 'vendor/unity/src/unity.c'
+:options:
+  - 'TEST'
+  - 'CMOCK_MEM_SIZE=128'
+  - 'CMOCK_MEM_ALIGN=2'
+  - 'CMOCK_MEM_INDEX_TYPE=int'
+

data/vendor/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  (sizeof(CMOCK_MEM_INDEX_TYPE)) 
+#define TEST_MEM_INDEX_PAD   ((sizeof(CMOCK_MEM_INDEX_TYPE) + 7) & ~7) //round up to nearest 4 byte boundary
+
+unsigned int 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_SIZE + TEST_MEM_INDEX_PAD, CMock_Guts_MemBytesUsed());
+    TEST_ASSERT_EQUAL(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)
+{
+  unsigned int  i;
+  CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
+  CMOCK_MEM_INDEX_TYPE next;
+  unsigned int  sizes[10]          = {3,  1,  80,  5,  8,  31, 7,  911, 2,  80};
+  unsigned int  sizes_buffered[10] = {16, 16, 88,  16, 16, 40, 16, 920, 16, 88}; //includes counter
+  unsigned int  sum = 0;
+  unsigned int  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);
+}