- Reworked memory handling to avoid realloc problems if it decides to relocate the block.

git-svn-id: http://cmock.svn.sourceforge.net/svnroot/cmock/trunk@202 bf332499-1b4d-0410-844d-d2d48d5cc64c

lib/cmock_generator.rb

@@ -118,7 +118,7 @@ class CMockGenerator
     end
     functions.each do |function|
       file << @plugins.run(:instance_structure, function)
-      file << "  CMOCK_#{function[:name]}_CALL_INSTANCE* #{function[:name]}_CallInstance;\n"
+      file << "  CMOCK_MEM_INDEX_TYPE #{function[:name]}_CallInstance;\n"
     end
     file << "} Mock;\n\n"
   end
@@ -179,8 +179,8 @@ class CMockGenerator
     file << "#{function_mod_and_rettype} #{function[:name]}(#{args_string})\n"
     file << "{\n"
     file << "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n"
-    file << "  CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance = Mock.#{function[:name]}_CallInstance;\n"
-    file << "  Mock.#{function[:name]}_CallInstance = (CMOCK_#{function[:name]}_CALL_INSTANCE*)CMock_Guts_MemNext(Mock.#{function[:name]}_CallInstance);\n"
+    file << "  CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance = (CMOCK_#{function[:name]}_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.#{function[:name]}_CallInstance);\n"
+    file << "  Mock.#{function[:name]}_CallInstance = CMock_Guts_MemNext(Mock.#{function[:name]}_CallInstance);\n"
     file << @plugins.run(:mock_implementation_precheck, function)
     file << "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"Function '#{function[:name]}' called more times than expected.\");\n"
     file << "  cmock_line = cmock_call_instance->LineNumber;\n"

lib/cmock_generator_plugin_callback.rb

@@ -72,7 +72,7 @@ class CMockGeneratorPluginCallback
   
   def mock_verify(function)
     func_name = function[:name]
-    "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n    Mock.#{func_name}_CallInstance = NULL;\n"
+    "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n    Mock.#{func_name}_CallInstance = CMOCK_GUTS_NONE;\n"
   end
 
 end

lib/cmock_generator_plugin_expect.rb

@@ -80,7 +80,7 @@ class CMockGeneratorPluginExpect
   
   def mock_verify(function)
     func_name = function[:name]
-    "  UNITY_TEST_ASSERT_NULL(Mock.#{func_name}_CallInstance, cmock_line, \"Function '#{func_name}' called less times than expected.\");\n"
+    "  UNITY_TEST_ASSERT(CMOCK_GUTS_NONE == Mock.#{func_name}_CallInstance, cmock_line, \"Function '#{func_name}' called less times than expected.\");\n"
   end
 
 end

lib/cmock_generator_plugin_ignore.rb

@@ -74,7 +74,7 @@ class CMockGeneratorPluginIgnore
 
   def mock_verify(function)
     func_name = function[:name]
-    "  if (Mock.#{func_name}_IgnoreBool)\n    Mock.#{func_name}_CallInstance = NULL;\n"
+    "  if (Mock.#{func_name}_IgnoreBool)\n    Mock.#{func_name}_CallInstance = CMOCK_GUTS_NONE;\n"
   end
   
   def nothing(function)

lib/cmock_generator_utils.rb

@@ -28,10 +28,11 @@ class CMockGeneratorUtils
     end
   end
   
-  def code_add_base_expectation(func_name, global_ordering_supported=true)
-    lines =  "  CMOCK_#{func_name}_CALL_INSTANCE* cmock_call_instance = (CMOCK_#{func_name}_CALL_INSTANCE*)CMock_Guts_MemNew(sizeof(CMOCK_#{func_name}_CALL_INSTANCE));\n"
+  def code_add_base_expectation(func_name, global_ordering_supported=true)
+    lines =  "  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_#{func_name}_CALL_INSTANCE));\n"
+    lines << "  CMOCK_#{func_name}_CALL_INSTANCE* cmock_call_instance = (CMOCK_#{func_name}_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);\n"
     lines << "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"CMock has run out of memory. Please allocate more.\");\n"
-    lines << "  Mock.#{func_name}_CallInstance = (CMOCK_#{func_name}_CALL_INSTANCE*)CMock_Guts_MemChain((void*)Mock.#{func_name}_CallInstance, (void*)cmock_call_instance);\n"
+    lines << "  Mock.#{func_name}_CallInstance = CMock_Guts_MemChain(Mock.#{func_name}_CallInstance, cmock_guts_index);\n"
     lines << "  cmock_call_instance->LineNumber = cmock_line;\n"
     lines << "  cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" if (@ordered and global_ordering_supported)
     lines << "  cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n" if (@cexception)

src/cmock.c

@@ -17,11 +17,6 @@
 #include <stdlib.h>
 #endif
 
-//should be big enough to index full range of CMOCK_MEM_MAX
-#ifndef CMOCK_MEM_INDEX_TYPE
-#define CMOCK_MEM_INDEX_TYPE  unsigned int
-#endif
-
 //this is used internally during pointer arithmetic. make sure this type is the same size as the target's pointer type
 #ifndef CMOCK_MEM_PTR_AS_INT
 #define CMOCK_MEM_PTR_AS_INT unsigned long
@@ -44,24 +39,24 @@
 
 //private variables
 #ifdef CMOCK_MEM_DYNAMIC
-static unsigned char* CMock_Guts_Buffer = NULL;
-static unsigned int   CMock_Guts_BufferSize = 0;
-static unsigned int   CMock_Guts_FreePtr;
+static unsigned char*         CMock_Guts_Buffer = NULL;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_ALIGN_SIZE;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr;
 #else
-static unsigned char  CMock_Guts_Buffer[CMOCK_MEM_SIZE];
-static unsigned int   CMock_Guts_BufferSize = CMOCK_MEM_SIZE;
-static unsigned int   CMock_Guts_FreePtr;
+static unsigned char          CMock_Guts_Buffer[CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE];
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr;
 #endif
 //-------------------------------------------------------
 // CMock_Guts_MemNew
 //-------------------------------------------------------
-void* CMock_Guts_MemNew(unsigned int size)
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size)
 {
-  unsigned int index;
+  CMOCK_MEM_INDEX_TYPE index;
 
   //verify arguments valid (we must be allocating space for at least 1 byte, and the existing chain must be in memory somewhere)
   if (size < 1)
-    return NULL;
+    return CMOCK_GUTS_NONE;
 
   //verify we have enough room
   size = size + CMOCK_MEM_INDEX_SIZE;
@@ -74,75 +69,102 @@ void* CMock_Guts_MemNew(unsigned int size)
     CMock_Guts_Buffer = realloc(CMock_Guts_Buffer, CMock_Guts_BufferSize);
     if (CMock_Guts_Buffer == NULL)
 #endif //yes that if will continue to the return below if TRUE
-      return NULL;
+      return CMOCK_GUTS_NONE;
   }
 
   //determine where we're putting this new block, and init its pointer to be the end of the line
   index = CMock_Guts_FreePtr + CMOCK_MEM_INDEX_SIZE;
-  *(CMOCK_MEM_INDEX_TYPE*)(&CMock_Guts_Buffer[CMock_Guts_FreePtr]) = 0;
+  *(CMOCK_MEM_INDEX_TYPE*)(&CMock_Guts_Buffer[CMock_Guts_FreePtr]) = CMOCK_GUTS_NONE;
   CMock_Guts_FreePtr += size;
 
-  return (&CMock_Guts_Buffer[index]);
+  return index;
 }
 
 //-------------------------------------------------------
 // CMock_Guts_MemChain
 //-------------------------------------------------------
-void* CMock_Guts_MemChain(void* root, void* obj)
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemChain(CMOCK_MEM_INDEX_TYPE root_index, CMOCK_MEM_INDEX_TYPE obj_index)
 {
-  unsigned int index;
+  CMOCK_MEM_INDEX_TYPE index;
+  void* root;
+  void* obj;
   void* next;
 
-  if (root == NULL)
+  if (root_index == CMOCK_GUTS_NONE)
   {
     //if there is no root currently, we return this object as the root of the chain
-    return obj;
+    return obj_index;
   }
   else
   {
     //reject illegal nodes
-    if ((root < (void*)CMock_Guts_Buffer) || (root >= (void*)(&CMock_Guts_Buffer[CMock_Guts_FreePtr])))
-      return NULL;
-    if ((obj  < (void*)CMock_Guts_Buffer) || (obj  >= (void*)(&CMock_Guts_Buffer[CMock_Guts_FreePtr])))
-      return NULL;
+    if ((root_index < CMOCK_MEM_ALIGN_SIZE) || (root_index >= CMock_Guts_FreePtr))
+    {
+      return CMOCK_GUTS_NONE;
+    }
+    if ((obj_index < CMOCK_MEM_ALIGN_SIZE) || (obj_index >= CMock_Guts_FreePtr))
+    {
+      return CMOCK_GUTS_NONE;
+    }
+    
+    root = (void*)(&CMock_Guts_Buffer[root_index]);
+    obj  = (void*)(&CMock_Guts_Buffer[obj_index]);
 
     //find the end of the existing chain and add us
     next = root;
     do {
       index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE);
       if (index >= CMock_Guts_FreePtr)
-        return NULL;
+        return CMOCK_GUTS_NONE;
       if (index > 0)
         next = (void*)(&CMock_Guts_Buffer[index]);
     } while (index > 0);
     *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE) = ((CMOCK_MEM_PTR_AS_INT)obj - (CMOCK_MEM_PTR_AS_INT)CMock_Guts_Buffer);
-    return root;
+    return root_index;
   }
 }
 
 //-------------------------------------------------------
 // CMock_Guts_MemNext
 //-------------------------------------------------------
-void* CMock_Guts_MemNext(void* previous_item)
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNext(CMOCK_MEM_INDEX_TYPE previous_item_index)
 {
-  CMOCK_MEM_INDEX_TYPE index;
+  CMOCK_MEM_INDEX_TYPE index;
+  void* previous_item;
 
   //There is nothing "next" if the pointer isn't from our buffer
-  if ((previous_item < (void*)CMock_Guts_Buffer) || (previous_item >= (void*)(&CMock_Guts_Buffer[CMock_Guts_FreePtr])))
-    return NULL;
+  if ((previous_item_index < CMOCK_MEM_ALIGN_SIZE) || (previous_item_index  >= CMock_Guts_FreePtr))
+    return CMOCK_GUTS_NONE;
+  previous_item = (void*)(&CMock_Guts_Buffer[previous_item_index]);
 
-  //if the pointer is good, then use it to look up the next index (we know the first element always goes in zero, so NEXT must always be > 1)
+  //if the pointer is good, then use it to look up the next index
+  //(we know the first element always goes in zero, so NEXT must always be > 1)
   index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)previous_item - CMOCK_MEM_INDEX_SIZE);
   if ((index > 1) && (index < CMock_Guts_FreePtr))
-    return (void*)(&CMock_Guts_Buffer[index]);
+    return index;
   else
-    return NULL;
-}
+    return CMOCK_GUTS_NONE;
+}
+
+//-------------------------------------------------------
+// CMock_GetAddressFor
+//-------------------------------------------------------
+void* CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index)
+{
+  if ((index >= CMOCK_MEM_ALIGN_SIZE) && (index < CMock_Guts_FreePtr))
+  {
+    return (void*)(&CMock_Guts_Buffer[index]);
+  }
+  else
+  {
+    return NULL;
+  }
+}
 
 //-------------------------------------------------------
 // CMock_Guts_MemBytesFree
 //-------------------------------------------------------
-unsigned int CMock_Guts_MemBytesFree(void)
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesFree(void)
 {
   return CMock_Guts_BufferSize - CMock_Guts_FreePtr;
 }
@@ -150,9 +172,9 @@ unsigned int CMock_Guts_MemBytesFree(void)
 //-------------------------------------------------------
 // CMock_Guts_MemBytesUsed
 //-------------------------------------------------------
-unsigned int CMock_Guts_MemBytesUsed(void)
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesUsed(void)
 {
-  return CMock_Guts_FreePtr;
+  return CMock_Guts_FreePtr - CMOCK_MEM_ALIGN_SIZE;
 }
 
 //-------------------------------------------------------
@@ -160,5 +182,5 @@ unsigned int CMock_Guts_MemBytesUsed(void)
 //-------------------------------------------------------
 void CMock_Guts_MemFreeAll(void)
 {
-  CMock_Guts_FreePtr = 0;
+  CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE; //skip the very beginning
 }

src/cmock.h

@@ -5,16 +5,26 @@
 ========================================== */
 
 #ifndef CMOCK_FRAMEWORK_H
-#define CMOCK_FRAMEWORK_H
+#define CMOCK_FRAMEWORK_H
+
+//should be big enough to index full range of CMOCK_MEM_MAX
+#ifndef CMOCK_MEM_INDEX_TYPE
+#define CMOCK_MEM_INDEX_TYPE  unsigned int
+#endif
+
+#define CMOCK_GUTS_NONE (0)
 
 //-------------------------------------------------------
 // Memory API
 //-------------------------------------------------------
-void*         CMock_Guts_MemNew(unsigned int size);
-void*         CMock_Guts_MemChain(void* root, void* obj);
-void*         CMock_Guts_MemNext(void* previous_item);
-unsigned int  CMock_Guts_MemBytesFree(void);
-unsigned int  CMock_Guts_MemBytesUsed(void);
-void          CMock_Guts_MemFreeAll(void);
+CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size);
+CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemChain(CMOCK_MEM_INDEX_TYPE root_index, CMOCK_MEM_INDEX_TYPE obj_index);
+CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemNext(CMOCK_MEM_INDEX_TYPE previous_item_index);
+
+void*                 CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index);
+
+CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemBytesFree(void);
+CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemBytesUsed(void);
+void                  CMock_Guts_MemFreeAll(void);
 
 #endif //CMOCK_FRAMEWORK

targets/gcc_64.yml

@@ -25,7 +25,8 @@ compiler:
   defines:
     prefix: '-D'
     items:
-      - 'UNITY_SUPPORT_64'
+      - 'UNITY_SUPPORT_64'
+      - 'UNITY_LONG_WIDTH=64'
       - 'UNITY_POINTER_WIDTH=64'
       - 'CMOCK_MEM_PTR_AS_INT=long'
   object_files:

test/c/TestCMockC.c

@@ -20,8 +20,9 @@ void tearDown(void)
 
 void test_MemNewWillReturnNullIfGivenIllegalSizes(void)
 {
-  TEST_ASSERT_NULL( CMock_Guts_MemNew(0) );
-  TEST_ASSERT_NULL( CMock_Guts_MemNew(CMOCK_MEM_SIZE - TEST_MEM_INDEX_SIZE + 1) );
+  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());
@@ -29,13 +30,13 @@ void test_MemNewWillReturnNullIfGivenIllegalSizes(void)
 }
 
 void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void)
-{
-  unsigned int* next = CMock_Guts_MemNew(4);
+{
+  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_NULL( CMock_Guts_MemChain((void*)((unsigned int)next + CMOCK_MEM_SIZE), next) );
-  TEST_ASSERT_NULL( CMock_Guts_MemChain(next, (void*)((unsigned int)next + CMOCK_MEM_SIZE)) );
+  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());
@@ -44,9 +45,9 @@ void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void)
 
 void test_MemNextWillReturnNullIfGivenABadRoot(void)
 {
-  TEST_ASSERT_NULL( CMock_Guts_MemNext(NULL) );
-  TEST_ASSERT_NULL( CMock_Guts_MemNext((void*)2) );
-  TEST_ASSERT_NULL( CMock_Guts_MemNext((void*)0xFFFFFFFE) );
+  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());
@@ -56,9 +57,9 @@ void test_MemNextWillReturnNullIfGivenABadRoot(void)
 void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 {
   unsigned int  i;
-  unsigned int* first = NULL;
-  unsigned int* next;
-  unsigned int* element[4];
+  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());
@@ -66,10 +67,10 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 
   //first element
   element[0] = CMock_Guts_MemNew(sizeof(unsigned int));
-  TEST_ASSERT_NOT_NULL(element[0]);
+  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_PTR(element[0], first);
-  *element[0] = 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());
@@ -77,10 +78,10 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 
   //second element
   element[1] = CMock_Guts_MemNew(sizeof(unsigned int));
-  TEST_ASSERT_NOT_NULL(element[1]);
+  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_PTR(first, CMock_Guts_MemChain(first, element[1]));
-  *element[1] = 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());
@@ -88,11 +89,11 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 
   //third element
   element[2] = CMock_Guts_MemNew(sizeof(unsigned int));
-  TEST_ASSERT_NOT_NULL(element[2]);
+  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_PTR(first, CMock_Guts_MemChain(first, element[2]));
-  *element[2] = 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());
@@ -100,12 +101,12 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 
   //fourth element
   element[3] = CMock_Guts_MemNew(sizeof(unsigned int));
-  TEST_ASSERT_NOT_NULL(element[3]);
+  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_PTR(first, CMock_Guts_MemChain(first, element[3]));
-  *element[3] = 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());
@@ -115,13 +116,13 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
   next = first;
   for (i = 0; i < 4; i++)
   {
-    TEST_ASSERT_EQUAL_PTR(element[i], next);
-    TEST_ASSERT_EQUAL(i, *next);
+    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_NULL(next);
+  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());
@@ -137,9 +138,9 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 
 void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void)
 {
-  unsigned int  i;
-  unsigned int* first = NULL;
-  unsigned int* next;
+  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).
@@ -150,10 +151,10 @@ void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void)
     TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*8, CMock_Guts_MemBytesFree());
 
     next = CMock_Guts_MemNew(1);
-    TEST_ASSERT_NOT_NULL(next);
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
 
     first = CMock_Guts_MemChain(first, next);
-    TEST_ASSERT_NOT_NULL(first);
+    TEST_ASSERT_MESSAGE(first != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
   }
 
   //verify we're at top of memory
@@ -161,9 +162,9 @@ void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void)
   TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesFree());
 
   //The very next call will return a NULL, and any after that
-  TEST_ASSERT_NULL(CMock_Guts_MemNew(1));
-  TEST_ASSERT_NULL(CMock_Guts_MemNew(1));
-  TEST_ASSERT_NULL(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));
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(1));
 
   //verify nothing has changed
   TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesUsed());
@@ -173,19 +174,19 @@ void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void)
   next = first;
   for (i = 0; i < (CMOCK_MEM_SIZE / 8); i++)
   {
-    TEST_ASSERT_NOT_NULL(next);
+    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_NULL(next);
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
 }
 
 void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd(void)
 {
-  unsigned int  i;
-  unsigned int* first = NULL;
-  unsigned int* next;
+  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
@@ -195,22 +196,22 @@ void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtE
     TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*12, CMock_Guts_MemBytesFree());
 
     next = CMock_Guts_MemNew(8);
-    TEST_ASSERT_NOT_NULL(next);
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
 
     first = CMock_Guts_MemChain(first, next);
-    TEST_ASSERT_NOT_NULL(first);
+    TEST_ASSERT_MESSAGE(first != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
 
     //verify writing data won't screw us up
-    *(unsigned int*)next = i;
+    *((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 NULL, and any after that
-  TEST_ASSERT_NULL(CMock_Guts_MemNew(8));
-  TEST_ASSERT_NULL(CMock_Guts_MemNew(5));
+  //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());
@@ -220,19 +221,20 @@ void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtE
   next = first;
   for (i = 0; i < 10; i++)
   {
-    TEST_ASSERT_NOT_NULL(next);
+    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_NULL(next);
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
 }
 
 void test_ThatWeCanAskForAllSortsOfSizes(void)
 {
-  unsigned int  i;
-  unsigned int* first = NULL;
-  unsigned int* next;
+  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;
@@ -240,10 +242,10 @@ void test_ThatWeCanAskForAllSortsOfSizes(void)
   for (i = 0; i < 5; i++)
   {
     next = CMock_Guts_MemNew(sizes[i]);
-    TEST_ASSERT_NOT_NULL(next);
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
 
     first = CMock_Guts_MemChain(first, next);
-    TEST_ASSERT_NOT_NULL(first);
+    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());
@@ -251,15 +253,15 @@ void test_ThatWeCanAskForAllSortsOfSizes(void)
   }
 
   //show that we can't ask for too much memory
-  TEST_ASSERT_NULL(CMock_Guts_MemNew(12));
-  TEST_ASSERT_NULL(CMock_Guts_MemNew(5));
+  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_NOT_NULL(next);
+  TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
 
   first = CMock_Guts_MemChain(first, next);
-  TEST_ASSERT_NOT_NULL(first);
+  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());
@@ -269,10 +271,10 @@ void test_ThatWeCanAskForAllSortsOfSizes(void)
   next = first;
   for (i = 0; i < 6; i++)
   {
-    TEST_ASSERT_NOT_NULL(next);
+    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_NULL(next);
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
 }

test/c/TestCMockCDynamic.c

@@ -25,7 +25,7 @@ void tearDown(void)
 
 void test_MemNewWillReturnNullIfGivenIllegalSizes(void)
 {
-  TEST_ASSERT_NULL( CMock_Guts_MemNew(0) );
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNew(0) );
 
   //verify we're cleared still
   TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
@@ -36,7 +36,7 @@ void test_MemNewWillNowSupportSizesGreaterThanTheDefinesCMockSize(void)
 {
     TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesFree());
 	
-    TEST_ASSERT_NOT_NULL(CMock_Guts_MemNew(CMOCK_MEM_SIZE - TEST_MEM_INDEX_SIZE + 1) );
+    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());
@@ -44,12 +44,12 @@ void test_MemNewWillNowSupportSizesGreaterThanTheDefinesCMockSize(void)
 
 void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void)
 {
-  unsigned int* next = CMock_Guts_MemNew(8);
+  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_NULL( CMock_Guts_MemChain((void*)((unsigned int)next + CMOCK_MEM_SIZE), next) );
-  TEST_ASSERT_NULL( CMock_Guts_MemChain(next, (void*)((unsigned int)next + CMOCK_MEM_SIZE)) );
+  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());
@@ -58,9 +58,9 @@ void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void)
 
 void test_MemNextWillReturnNullIfGivenABadRoot(void)
 {
-  TEST_ASSERT_NULL( CMock_Guts_MemNext(NULL) );
-  TEST_ASSERT_NULL( CMock_Guts_MemNext((void*)2) );
-  TEST_ASSERT_NULL( CMock_Guts_MemNext((void*)0xFFFFFFFE) );
+  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());
@@ -70,9 +70,9 @@ void test_MemNextWillReturnNullIfGivenABadRoot(void)
 void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 {
   unsigned int  i;
-  unsigned int* first = NULL;
-  unsigned int* next;
-  unsigned int* element[4];
+  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());
@@ -80,10 +80,10 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 
   //first element
   element[0] = CMock_Guts_MemNew(sizeof(unsigned int));
-  TEST_ASSERT_NOT_NULL(element[0]);
+  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_PTR(element[0], first);
-  *element[0] = 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());
@@ -91,10 +91,10 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 
   //second element
   element[1] = CMock_Guts_MemNew(sizeof(unsigned int));
-  TEST_ASSERT_NOT_NULL(element[1]);
+  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_PTR(first, CMock_Guts_MemChain(first, element[1]));
-  *element[1] = 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());
@@ -102,11 +102,11 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 
   //third element
   element[2] = CMock_Guts_MemNew(sizeof(unsigned int));
-  TEST_ASSERT_NOT_NULL(element[2]);
+  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_PTR(first, CMock_Guts_MemChain(first, element[2]));
-  *element[2] = 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());
@@ -114,12 +114,12 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 
   //fourth element
   element[3] = CMock_Guts_MemNew(sizeof(unsigned int));
-  TEST_ASSERT_NOT_NULL(element[3]);
+  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_PTR(first, CMock_Guts_MemChain(first, element[3]));
-  *element[3] = 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());
@@ -129,13 +129,13 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
   next = first;
   for (i = 0; i < 4; i++)
   {
-    TEST_ASSERT_EQUAL_PTR(element[i], next);
-    TEST_ASSERT_EQUAL(i, *next);
+    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_NULL(next);
+  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());
@@ -152,8 +152,8 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 void test_ThatWeCanAskForAllSortsOfSizes(void)
 {
   unsigned int  i;
-  unsigned int* first = NULL;
-  unsigned int* next;
+  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;
@@ -162,10 +162,10 @@ void test_ThatWeCanAskForAllSortsOfSizes(void)
   for (i = 0; i < 10; i++)
   {
     next = CMock_Guts_MemNew(sizes[i]);
-    TEST_ASSERT_NOT_NULL(next);
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
 
     first = CMock_Guts_MemChain(first, next);
-    TEST_ASSERT_NOT_NULL(first);
+    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);
@@ -177,10 +177,10 @@ void test_ThatWeCanAskForAllSortsOfSizes(void)
   next = first;
   for (i = 0; i < 10; i++)
   {
-    TEST_ASSERT_NOT_NULL(next);
+    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_NULL(next);
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, next);
 }

test/c/TestCMockCDynamic_Runner.c

@@ -23,12 +23,12 @@ int main(void)
   Unity.TestFile = "TestCMockDynamic.c";
   UnityBegin();
   
-  RUN_TEST(test_MemNewWillReturnNullIfGivenIllegalSizes, 20);
-  RUN_TEST(test_MemNewWillNowSupportSizesGreaterThanTheDefinesCMockSize, 29);
-  RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 39);
-  RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 53);
-  RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 64);
-  RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 146);
+  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();
   return 0;

test/c/TestCMockC_Runner.c

@@ -24,13 +24,13 @@ int main(void)
   Unity.TestFile = "TestCMock.c";
   UnityBegin();
 
-  RUN_TEST(test_MemNewWillReturnNullIfGivenIllegalSizes, 15);
-  RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 25);
-  RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 39);
-  RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 50);
-  RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory, 132);
-  RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd, 178);
-  RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 225);
+  RUN_TEST(test_MemNewWillReturnNullIfGivenIllegalSizes, 21);
+  RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 32);
+  RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 46);
+  RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 57);
+  RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory, 139);
+  RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd, 185);
+  RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 233);
 
   UnityEnd();
   return 0;

test/unit/cmock_generator_main_test.rb

@@ -231,9 +231,9 @@ class CMockGeneratorTest < Test::Unit::TestCase
                  "\n} CMOCK_Second_CALL_INSTANCE;\n\n",
                  "static struct MockPoutPoutFishInstance\n{\n",
                  "  d1",
-                 "  CMOCK_First_CALL_INSTANCE* First_CallInstance;\n",
+                 "  CMOCK_MEM_INDEX_TYPE First_CallInstance;\n",
                  "  e1  e2  e3",
-                 "  CMOCK_Second_CALL_INSTANCE* Second_CallInstance;\n",
+                 "  CMOCK_MEM_INDEX_TYPE Second_CallInstance;\n",
                  "} Mock;\n\n"
                ].join
     @plugins.expect.run(:instance_typedefs, functions[0]).returns(["  b1","  b2"])
@@ -368,8 +368,8 @@ class CMockGeneratorTest < Test::Unit::TestCase
     expected = [ "static int SupaFunction(uint32 sandwiches, const char* named)\n",
                  "{\n",
                  "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n",
-                 "  CMOCK_SupaFunction_CALL_INSTANCE* cmock_call_instance = Mock.SupaFunction_CallInstance;\n",
-                 "  Mock.SupaFunction_CallInstance = (CMOCK_SupaFunction_CALL_INSTANCE*)CMock_Guts_MemNext(Mock.SupaFunction_CallInstance);\n",
+                 "  CMOCK_SupaFunction_CALL_INSTANCE* cmock_call_instance = (CMOCK_SupaFunction_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.SupaFunction_CallInstance);\n",
+                 "  Mock.SupaFunction_CallInstance = CMock_Guts_MemNext(Mock.SupaFunction_CallInstance);\n",
                  "  uno",
                  "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"Function 'SupaFunction' called more times than expected.\");\n",
                  "  cmock_line = cmock_call_instance->LineNumber;\n",
@@ -399,8 +399,8 @@ class CMockGeneratorTest < Test::Unit::TestCase
     expected = [ "int SupaFunction(uint32 sandwiches, corn ...)\n",
                  "{\n",
                  "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n",
-                 "  CMOCK_SupaFunction_CALL_INSTANCE* cmock_call_instance = Mock.SupaFunction_CallInstance;\n",
-                 "  Mock.SupaFunction_CallInstance = (CMOCK_SupaFunction_CALL_INSTANCE*)CMock_Guts_MemNext(Mock.SupaFunction_CallInstance);\n",
+                 "  CMOCK_SupaFunction_CALL_INSTANCE* cmock_call_instance = (CMOCK_SupaFunction_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.SupaFunction_CallInstance);\n",
+                 "  Mock.SupaFunction_CallInstance = CMock_Guts_MemNext(Mock.SupaFunction_CallInstance);\n",
                  "  uno",
                  "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"Function 'SupaFunction' called more times than expected.\");\n",
                  "  cmock_line = cmock_call_instance->LineNumber;\n",

test/unit/cmock_generator_plugin_expect_test.rb

@@ -198,7 +198,7 @@ class CMockGeneratorPluginExpectTest < Test::Unit::TestCase
   
   should "add mock verify lines" do
     function = {:name => "Banana" }
-    expected = "  UNITY_TEST_ASSERT_NULL(Mock.Banana_CallInstance, cmock_line, \"Function 'Banana' called less times than expected.\");\n"
+    expected = "  UNITY_TEST_ASSERT(CMOCK_GUTS_NONE == Mock.Banana_CallInstance, cmock_line, \"Function 'Banana' called less times than expected.\");\n"
     returned = @cmock_generator_plugin_expect.mock_verify(function)
     assert_equal(expected, returned)
   end

test/unit/cmock_generator_utils_test.rb

@@ -44,10 +44,11 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
   end
   
   should "add code for a base expectation with no plugins" do
-    expected =
-      "  CMOCK_Apple_CALL_INSTANCE* cmock_call_instance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_MemNew(sizeof(CMOCK_Apple_CALL_INSTANCE));\n" +
+    expected =
+      "  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Apple_CALL_INSTANCE));\n" +
+      "  CMOCK_Apple_CALL_INSTANCE* cmock_call_instance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);\n" +
       "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"CMock has run out of memory. Please allocate more.\");\n" +
-      "  Mock.Apple_CallInstance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_MemChain((void*)Mock.Apple_CallInstance, (void*)cmock_call_instance);\n" +
+      "  Mock.Apple_CallInstance = CMock_Guts_MemChain(Mock.Apple_CallInstance, cmock_guts_index);\n" +
       "  cmock_call_instance->LineNumber = cmock_line;\n"
     output = @cmock_generator_utils_simple.code_add_base_expectation("Apple")
     assert_equal(expected, output)
@@ -55,9 +56,10 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
         
   should "add code for a base expectation with all plugins" do
     expected =
-      "  CMOCK_Apple_CALL_INSTANCE* cmock_call_instance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_MemNew(sizeof(CMOCK_Apple_CALL_INSTANCE));\n" +
+      "  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Apple_CALL_INSTANCE));\n" +
+      "  CMOCK_Apple_CALL_INSTANCE* cmock_call_instance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);\n" +
       "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"CMock has run out of memory. Please allocate more.\");\n" +
-      "  Mock.Apple_CallInstance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_MemChain((void*)Mock.Apple_CallInstance, (void*)cmock_call_instance);\n" +
+      "  Mock.Apple_CallInstance = CMock_Guts_MemChain(Mock.Apple_CallInstance, cmock_guts_index);\n" +
       "  cmock_call_instance->LineNumber = cmock_line;\n" + 
       "  cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" +
       "  cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n"
@@ -67,9 +69,10 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
         
   should "add code for a base expectation with all plugins and ordering not supported" do
     expected =
-      "  CMOCK_Apple_CALL_INSTANCE* cmock_call_instance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_MemNew(sizeof(CMOCK_Apple_CALL_INSTANCE));\n" +
+      "  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Apple_CALL_INSTANCE));\n" +
+      "  CMOCK_Apple_CALL_INSTANCE* cmock_call_instance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);\n" +
       "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"CMock has run out of memory. Please allocate more.\");\n" +
-      "  Mock.Apple_CallInstance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_MemChain((void*)Mock.Apple_CallInstance, (void*)cmock_call_instance);\n" +
+      "  Mock.Apple_CallInstance = CMock_Guts_MemChain(Mock.Apple_CallInstance, cmock_guts_index);\n" +
       "  cmock_call_instance->LineNumber = cmock_line;\n" +
       "  cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n"
     output = @cmock_generator_utils_complex.code_add_base_expectation("Apple", false)