ThrowTheSwitch/CMock
1
0
Fork 0
mirror of https://github.com/ThrowTheSwitch/CMock.git synced 2026-10-02 06:57:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
git-svn-id: http://cmock.svn.sourceforge.net/svnroot/cmock/trunk@202 bf332499-1b4d-0410-844d-d2d48d5cc64c
This commit is contained in:
mvandervoord
2011-01-13 18:10:57 +00:00
parent 1504d71f77
commit e9a7151241
15 changed files with 213 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/cmock_generator.rb
+3 -3
View File
@@ -118,7 +118,7 @@ class CMockGenerator
end end
functions.each do |function| functions.each do |function|
file << @plugins.run(:instance_structure, 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 end
file << "} Mock;\n\n" file << "} Mock;\n\n"
end end
@@ -179,8 +179,8 @@ class CMockGenerator
file << "#{function_mod_and_rettype} #{function[:name]}(#{args_string})\n" file << "#{function_mod_and_rettype} #{function[:name]}(#{args_string})\n"
file << "{\n" file << "{\n"
file << " UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\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 << " 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_#{function[:name]}_CALL_INSTANCE*)CMock_Guts_MemNext(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 << @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 << " 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" file << " cmock_line = cmock_call_instance->LineNumber;\n"
lib/cmock_generator_plugin_callback.rb
+1 -1
View File
@@ -72,7 +72,7 @@ class CMockGeneratorPluginCallback
def mock_verify(function) def mock_verify(function)
func_name = function[:name] 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
end end
lib/cmock_generator_plugin_expect.rb
+1 -1
View File
@@ -80,7 +80,7 @@ class CMockGeneratorPluginExpect
def mock_verify(function) def mock_verify(function)
func_name = function[:name] 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
end end
lib/cmock_generator_plugin_ignore.rb
+1 -1
View File
@@ -74,7 +74,7 @@ class CMockGeneratorPluginIgnore
def mock_verify(function) def mock_verify(function)
func_name = function[:name] 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 end
def nothing(function) def nothing(function)
lib/cmock_generator_utils.rb
+4 -3
View File
@@ -28,10 +28,11 @@ class CMockGeneratorUtils
end end
end end
def code_add_base_expectation(func_name, global_ordering_supported=true) 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" 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 << " 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->LineNumber = cmock_line;\n"
lines << " cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" if (@ordered and global_ordering_supported) lines << " cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" if (@ordered and global_ordering_supported)
lines << " cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n" if (@cexception) lines << " cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n" if (@cexception)
src/cmock.c
+61 -39
View File
@@ -17,11 +17,6 @@
#include <stdlib.h> #include <stdlib.h>
#endif #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 //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 #ifndef CMOCK_MEM_PTR_AS_INT
#define CMOCK_MEM_PTR_AS_INT unsigned long #define CMOCK_MEM_PTR_AS_INT unsigned long
@@ -44,24 +39,24 @@
//private variables //private variables
#ifdef CMOCK_MEM_DYNAMIC #ifdef CMOCK_MEM_DYNAMIC
static unsigned char* CMock_Guts_Buffer = NULL; static unsigned char* CMock_Guts_Buffer = NULL;
static unsigned int CMock_Guts_BufferSize = 0; static CMOCK_MEM_INDEX_TYPE CMock_Guts_BufferSize = CMOCK_MEM_ALIGN_SIZE;
static unsigned int CMock_Guts_FreePtr; static CMOCK_MEM_INDEX_TYPE CMock_Guts_FreePtr;
#else #else
static unsigned char CMock_Guts_Buffer[CMOCK_MEM_SIZE]; static unsigned char CMock_Guts_Buffer[CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE];
static unsigned int CMock_Guts_BufferSize = CMOCK_MEM_SIZE; static CMOCK_MEM_INDEX_TYPE CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;
static unsigned int CMock_Guts_FreePtr; static CMOCK_MEM_INDEX_TYPE CMock_Guts_FreePtr;
#endif #endif
//------------------------------------------------------- //-------------------------------------------------------
// CMock_Guts_MemNew // 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) //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) if (size < 1)
return NULL; return CMOCK_GUTS_NONE;
//verify we have enough room //verify we have enough room
size = size + CMOCK_MEM_INDEX_SIZE; 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); CMock_Guts_Buffer = realloc(CMock_Guts_Buffer, CMock_Guts_BufferSize);
if (CMock_Guts_Buffer == NULL) if (CMock_Guts_Buffer == NULL)
#endif //yes that if will continue to the return below if TRUE #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 //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; 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; CMock_Guts_FreePtr += size;
return (&CMock_Guts_Buffer[index]); return index;
} }
//------------------------------------------------------- //-------------------------------------------------------
// CMock_Guts_MemChain // 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; 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 //if there is no root currently, we return this object as the root of the chain
return obj; return obj_index;
} }
else else
{ {
//reject illegal nodes //reject illegal nodes
if ((root < (void*)CMock_Guts_Buffer) || (root >= (void*)(&CMock_Guts_Buffer[CMock_Guts_FreePtr]))) if ((root_index < CMOCK_MEM_ALIGN_SIZE) || (root_index >= CMock_Guts_FreePtr))
return NULL; {
if ((obj < (void*)CMock_Guts_Buffer) || (obj >= (void*)(&CMock_Guts_Buffer[CMock_Guts_FreePtr]))) return CMOCK_GUTS_NONE;
return NULL; }
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 //find the end of the existing chain and add us
next = root; next = root;
do { do {
index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE); index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE);
if (index >= CMock_Guts_FreePtr) if (index >= CMock_Guts_FreePtr)
return NULL; return CMOCK_GUTS_NONE;
if (index > 0) if (index > 0)
next = (void*)(&CMock_Guts_Buffer[index]); next = (void*)(&CMock_Guts_Buffer[index]);
} while (index > 0); } 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); *(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 // 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 //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]))) if ((previous_item_index < CMOCK_MEM_ALIGN_SIZE) || (previous_item_index >= CMock_Guts_FreePtr))
return NULL; 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); index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)previous_item - CMOCK_MEM_INDEX_SIZE);
if ((index > 1) && (index < CMock_Guts_FreePtr)) if ((index > 1) && (index < CMock_Guts_FreePtr))
return (void*)(&CMock_Guts_Buffer[index]); return index;
else 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 // CMock_Guts_MemBytesFree
//------------------------------------------------------- //-------------------------------------------------------
unsigned int CMock_Guts_MemBytesFree(void) CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesFree(void)
{ {
return CMock_Guts_BufferSize - CMock_Guts_FreePtr; return CMock_Guts_BufferSize - CMock_Guts_FreePtr;
} }
@@ -150,9 +172,9 @@ unsigned int CMock_Guts_MemBytesFree(void)
//------------------------------------------------------- //-------------------------------------------------------
// CMock_Guts_MemBytesUsed // 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) void CMock_Guts_MemFreeAll(void)
{ {
CMock_Guts_FreePtr = 0; CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE; //skip the very beginning
} }
src/cmock.h
+17 -7
View File
@@ -5,16 +5,26 @@
========================================== */ ========================================== */
#ifndef CMOCK_FRAMEWORK_H #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 // Memory API
//------------------------------------------------------- //-------------------------------------------------------
void* CMock_Guts_MemNew(unsigned int size); CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size);
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);
void* CMock_Guts_MemNext(void* previous_item); CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNext(CMOCK_MEM_INDEX_TYPE previous_item_index);
unsigned int CMock_Guts_MemBytesFree(void);
unsigned int CMock_Guts_MemBytesUsed(void); void* CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index);
void CMock_Guts_MemFreeAll(void);
CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesFree(void);
CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesUsed(void);
void CMock_Guts_MemFreeAll(void);
#endif //CMOCK_FRAMEWORK #endif //CMOCK_FRAMEWORK
targets/gcc_64.yml
+2 -1
View File
@@ -25,7 +25,8 @@ compiler:
defines: defines:
prefix: '-D' prefix: '-D'
items: items:
- 'UNITY_SUPPORT_64' - 'UNITY_SUPPORT_64'
- 'UNITY_LONG_WIDTH=64'
- 'UNITY_POINTER_WIDTH=64' - 'UNITY_POINTER_WIDTH=64'
- 'CMOCK_MEM_PTR_AS_INT=long' - 'CMOCK_MEM_PTR_AS_INT=long'
object_files: object_files:
test/c/TestCMockC.c
+61 -59
View File
@@ -20,8 +20,9 @@ void tearDown(void)
void test_MemNewWillReturnNullIfGivenIllegalSizes(void) void test_MemNewWillReturnNullIfGivenIllegalSizes(void)
{ {
TEST_ASSERT_NULL( CMock_Guts_MemNew(0) ); TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, 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(CMOCK_MEM_SIZE - TEST_MEM_INDEX_SIZE + 1) );
TEST_ASSERT_NULL( CMock_Guts_GetAddressFor(CMOCK_GUTS_NONE) );
//verify we're cleared still //verify we're cleared still
TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
@@ -29,13 +30,13 @@ void test_MemNewWillReturnNullIfGivenIllegalSizes(void)
} }
void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(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(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(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_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemChain(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, next + CMOCK_MEM_SIZE) );
//verify we're still the same //verify we're still the same
TEST_ASSERT_EQUAL(4 + TEST_MEM_INDEX_SIZE, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(4 + TEST_MEM_INDEX_SIZE, CMock_Guts_MemBytesUsed());
@@ -44,9 +45,9 @@ void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void)
void test_MemNextWillReturnNullIfGivenABadRoot(void) void test_MemNextWillReturnNullIfGivenABadRoot(void)
{ {
TEST_ASSERT_NULL( CMock_Guts_MemNext(NULL) ); TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext(0) );
TEST_ASSERT_NULL( CMock_Guts_MemNext((void*)2) ); TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext(2) );
TEST_ASSERT_NULL( CMock_Guts_MemNext((void*)0xFFFFFFFE) ); TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext(CMOCK_MEM_SIZE - 4) );
//verify we're cleared still //verify we're cleared still
TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
@@ -56,9 +57,9 @@ void test_MemNextWillReturnNullIfGivenABadRoot(void)
void test_ThatWeCanClaimAndChainAFewElementsTogether(void) void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
{ {
unsigned int i; unsigned int i;
unsigned int* first = NULL; CMOCK_MEM_INDEX_TYPE next;
unsigned int* next; CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
unsigned int* element[4]; CMOCK_MEM_INDEX_TYPE element[4];
//verify we're cleared first //verify we're cleared first
TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
@@ -66,10 +67,10 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
//first element //first element
element[0] = CMock_Guts_MemNew(sizeof(unsigned int)); 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]); first = CMock_Guts_MemChain(first, element[0]);
TEST_ASSERT_EQUAL_PTR(element[0], first); TEST_ASSERT_EQUAL(element[0], first);
*element[0] = 0; *((unsigned int*)CMock_Guts_GetAddressFor(element[0])) = 0;
//verify we're using the right amount of memory //verify we're using the right amount of memory
TEST_ASSERT_EQUAL(1 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(1 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed());
@@ -77,10 +78,10 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
//second element //second element
element[1] = CMock_Guts_MemNew(sizeof(unsigned int)); 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_NOT_EQUAL(element[0], element[1]);
TEST_ASSERT_EQUAL_PTR(first, CMock_Guts_MemChain(first, element[1])); TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[1]));
*element[1] = 1; *((unsigned int*)CMock_Guts_GetAddressFor(element[1])) = 1;
//verify we're using the right amount of memory //verify we're using the right amount of memory
TEST_ASSERT_EQUAL(2 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(2 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed());
@@ -88,11 +89,11 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
//third element //third element
element[2] = CMock_Guts_MemNew(sizeof(unsigned int)); 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[0], element[2]);
TEST_ASSERT_NOT_EQUAL(element[1], element[2]); TEST_ASSERT_NOT_EQUAL(element[1], element[2]);
TEST_ASSERT_EQUAL_PTR(first, CMock_Guts_MemChain(first, element[2])); TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[2]));
*element[2] = 2; *((unsigned int*)CMock_Guts_GetAddressFor(element[2])) = 2;
//verify we're using the right amount of memory //verify we're using the right amount of memory
TEST_ASSERT_EQUAL(3 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(3 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed());
@@ -100,12 +101,12 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
//fourth element //fourth element
element[3] = CMock_Guts_MemNew(sizeof(unsigned int)); 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[0], element[3]);
TEST_ASSERT_NOT_EQUAL(element[1], element[3]); TEST_ASSERT_NOT_EQUAL(element[1], element[3]);
TEST_ASSERT_NOT_EQUAL(element[2], element[3]); TEST_ASSERT_NOT_EQUAL(element[2], element[3]);
TEST_ASSERT_EQUAL_PTR(first, CMock_Guts_MemChain(first, element[3])); TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[3]));
*element[3] = 3; *((unsigned int*)CMock_Guts_GetAddressFor(element[3])) = 3;
//verify we're using the right amount of memory //verify we're using the right amount of memory
TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed());
@@ -115,13 +116,13 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
next = first; next = first;
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
{ {
TEST_ASSERT_EQUAL_PTR(element[i], next); TEST_ASSERT_EQUAL(element[i], next);
TEST_ASSERT_EQUAL(i, *next); TEST_ASSERT_EQUAL(i, *((unsigned int*)CMock_Guts_GetAddressFor(element[i])));
next = CMock_Guts_MemNext(next); next = CMock_Guts_MemNext(next);
} }
//verify we get a null at the end of the list //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 //verify we're using the right amount of memory
TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed());
@@ -137,9 +138,9 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void) void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void)
{ {
unsigned int i; unsigned int i;
unsigned int* first = NULL; CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
unsigned int* next; 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 //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). //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()); TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*8, CMock_Guts_MemBytesFree());
next = CMock_Guts_MemNew(1); 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); 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 //verify we're at top of memory
@@ -161,9 +162,9 @@ void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void)
TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesFree()); TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesFree());
//The very next call will return a NULL, and any after that //The very next call will return a NULL, and any after that
TEST_ASSERT_NULL(CMock_Guts_MemNew(1)); TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(1));
TEST_ASSERT_NULL(CMock_Guts_MemNew(1)); TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(1));
TEST_ASSERT_NULL(CMock_Guts_MemNew(1)); TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(1));
//verify nothing has changed //verify nothing has changed
TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesUsed());
@@ -173,19 +174,19 @@ void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void)
next = first; next = first;
for (i = 0; i < (CMOCK_MEM_SIZE / 8); i++) 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); next = CMock_Guts_MemNext(next);
} }
//there aren't any after that //there aren't any after that
TEST_ASSERT_NULL(next); TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
} }
void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd(void) void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd(void)
{ {
unsigned int i; unsigned int i;
unsigned int* first = NULL; CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
unsigned int* next; CMOCK_MEM_INDEX_TYPE next;
//we're asking for 12 bytes each time now (4 for index, 8 for data). //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 //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()); TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*12, CMock_Guts_MemBytesFree());
next = CMock_Guts_MemNew(8); 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); 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 //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 //verify we're at top of memory
TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 8, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 8, CMock_Guts_MemBytesUsed());
TEST_ASSERT_EQUAL(8, CMock_Guts_MemBytesFree()); TEST_ASSERT_EQUAL(8, CMock_Guts_MemBytesFree());
//The very next call will return a NULL, and any after that //The very next call will return a NONE, and any after that
TEST_ASSERT_NULL(CMock_Guts_MemNew(8)); TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(8));
TEST_ASSERT_NULL(CMock_Guts_MemNew(5)); TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(5));
//verify nothing has changed //verify nothing has changed
TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 8, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 8, CMock_Guts_MemBytesUsed());
@@ -220,19 +221,20 @@ void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtE
next = first; next = first;
for (i = 0; i < 10; i++) 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); next = CMock_Guts_MemNext(next);
} }
//there aren't any after that //there aren't any after that
TEST_ASSERT_NULL(next); TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
} }
void test_ThatWeCanAskForAllSortsOfSizes(void) void test_ThatWeCanAskForAllSortsOfSizes(void)
{ {
unsigned int i; unsigned int i;
unsigned int* first = NULL; CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
unsigned int* next; CMOCK_MEM_INDEX_TYPE next;
unsigned int sizes[5] = {3, 1, 80, 5, 4}; unsigned int sizes[5] = {3, 1, 80, 5, 4};
unsigned int sizes_buffered[5] = {4, 4, 80, 8, 4}; unsigned int sizes_buffered[5] = {4, 4, 80, 8, 4};
unsigned int sum = 0; unsigned int sum = 0;
@@ -240,10 +242,10 @@ void test_ThatWeCanAskForAllSortsOfSizes(void)
for (i = 0; i < 5; i++) for (i = 0; i < 5; i++)
{ {
next = CMock_Guts_MemNew(sizes[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); 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; sum += sizes_buffered[i] + 4;
TEST_ASSERT_EQUAL(sum, CMock_Guts_MemBytesUsed()); 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 //show that we can't ask for too much memory
TEST_ASSERT_NULL(CMock_Guts_MemNew(12)); TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(12));
TEST_ASSERT_NULL(CMock_Guts_MemNew(5)); TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(5));
//but we CAN ask for something that will still fit //but we CAN ask for something that will still fit
next = CMock_Guts_MemNew(4); 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); 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 //verify we're used up now
TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesUsed());
@@ -269,10 +271,10 @@ void test_ThatWeCanAskForAllSortsOfSizes(void)
next = first; next = first;
for (i = 0; i < 6; i++) 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); next = CMock_Guts_MemNext(next);
} }
//there aren't any after that //there aren't any after that
TEST_ASSERT_NULL(next); TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
} }
test/c/TestCMockCDynamic.c
+32 -32
View File
@@ -25,7 +25,7 @@ void tearDown(void)
void test_MemNewWillReturnNullIfGivenIllegalSizes(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 //verify we're cleared still
TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
@@ -36,7 +36,7 @@ void test_MemNewWillNowSupportSizesGreaterThanTheDefinesCMockSize(void)
{ {
TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesFree()); 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 + TEST_MEM_INDEX_PAD, CMock_Guts_MemBytesUsed());
TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree()); TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
@@ -44,12 +44,12 @@ void test_MemNewWillNowSupportSizesGreaterThanTheDefinesCMockSize(void)
void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(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(8 + TEST_MEM_INDEX_PAD, CMock_Guts_MemBytesUsed());
TEST_ASSERT_EQUAL(StartingSize - 8 - TEST_MEM_INDEX_PAD, CMock_Guts_MemBytesFree()); 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_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemChain(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, next + CMOCK_MEM_SIZE) );
//verify we're still the same //verify we're still the same
TEST_ASSERT_EQUAL(8 + TEST_MEM_INDEX_PAD, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(8 + TEST_MEM_INDEX_PAD, CMock_Guts_MemBytesUsed());
@@ -58,9 +58,9 @@ void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void)
void test_MemNextWillReturnNullIfGivenABadRoot(void) void test_MemNextWillReturnNullIfGivenABadRoot(void)
{ {
TEST_ASSERT_NULL( CMock_Guts_MemNext(NULL) ); TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext(0) );
TEST_ASSERT_NULL( CMock_Guts_MemNext((void*)2) ); TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext(2) );
TEST_ASSERT_NULL( CMock_Guts_MemNext((void*)0xFFFFFFFE) ); TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNext( CMOCK_MEM_SIZE - 4 ) );
//verify we're cleared still //verify we're cleared still
TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
@@ -70,9 +70,9 @@ void test_MemNextWillReturnNullIfGivenABadRoot(void)
void test_ThatWeCanClaimAndChainAFewElementsTogether(void) void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
{ {
unsigned int i; unsigned int i;
unsigned int* first = NULL; CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
unsigned int* next; CMOCK_MEM_INDEX_TYPE next;
unsigned int* element[4]; CMOCK_MEM_INDEX_TYPE element[4];
//verify we're cleared first //verify we're cleared first
TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
@@ -80,10 +80,10 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
//first element //first element
element[0] = CMock_Guts_MemNew(sizeof(unsigned int)); 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]); first = CMock_Guts_MemChain(first, element[0]);
TEST_ASSERT_EQUAL_PTR(element[0], first); TEST_ASSERT_EQUAL(element[0], first);
*element[0] = 0; *((unsigned int*)CMock_Guts_GetAddressFor(element[0])) = 0;
//verify we're using the right amount of memory //verify we're using the right amount of memory
TEST_ASSERT_EQUAL(1 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(1 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
@@ -91,10 +91,10 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
//second element //second element
element[1] = CMock_Guts_MemNew(sizeof(unsigned int)); 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_NOT_EQUAL(element[0], element[1]);
TEST_ASSERT_EQUAL_PTR(first, CMock_Guts_MemChain(first, element[1])); TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[1]));
*element[1] = 1; *((unsigned int*)CMock_Guts_GetAddressFor(element[1])) = 1;
//verify we're using the right amount of memory //verify we're using the right amount of memory
TEST_ASSERT_EQUAL(2 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(2 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
@@ -102,11 +102,11 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
//third element //third element
element[2] = CMock_Guts_MemNew(sizeof(unsigned int)); 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[0], element[2]);
TEST_ASSERT_NOT_EQUAL(element[1], element[2]); TEST_ASSERT_NOT_EQUAL(element[1], element[2]);
TEST_ASSERT_EQUAL_PTR(first, CMock_Guts_MemChain(first, element[2])); TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[2]));
*element[2] = 2; *((unsigned int*)CMock_Guts_GetAddressFor(element[2])) = 2;
//verify we're using the right amount of memory //verify we're using the right amount of memory
TEST_ASSERT_EQUAL(3 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(3 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
@@ -114,12 +114,12 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
//fourth element //fourth element
element[3] = CMock_Guts_MemNew(sizeof(unsigned int)); 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[0], element[3]);
TEST_ASSERT_NOT_EQUAL(element[1], element[3]); TEST_ASSERT_NOT_EQUAL(element[1], element[3]);
TEST_ASSERT_NOT_EQUAL(element[2], element[3]); TEST_ASSERT_NOT_EQUAL(element[2], element[3]);
TEST_ASSERT_EQUAL_PTR(first, CMock_Guts_MemChain(first, element[3])); TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[3]));
*element[3] = 3; *((unsigned int*)CMock_Guts_GetAddressFor(element[3])) = 3;
//verify we're using the right amount of memory //verify we're using the right amount of memory
TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
@@ -129,13 +129,13 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
next = first; next = first;
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
{ {
TEST_ASSERT_EQUAL_PTR(element[i], next); TEST_ASSERT_EQUAL(element[i], next);
TEST_ASSERT_EQUAL(i, *next); TEST_ASSERT_EQUAL(i, *((unsigned int*)CMock_Guts_GetAddressFor(element[i])));
next = CMock_Guts_MemNext(next); next = CMock_Guts_MemNext(next);
} }
//verify we get a null at the end of the list //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 //verify we're using the right amount of memory
TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
@@ -152,8 +152,8 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
void test_ThatWeCanAskForAllSortsOfSizes(void) void test_ThatWeCanAskForAllSortsOfSizes(void)
{ {
unsigned int i; unsigned int i;
unsigned int* first = NULL; CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
unsigned int* next; CMOCK_MEM_INDEX_TYPE next;
unsigned int sizes[10] = {3, 1, 80, 5, 8, 31, 7, 911, 2, 80}; 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 sizes_buffered[10] = {16, 16, 88, 16, 16, 40, 16, 920, 16, 88}; //includes counter
unsigned int sum = 0; unsigned int sum = 0;
@@ -162,10 +162,10 @@ void test_ThatWeCanAskForAllSortsOfSizes(void)
for (i = 0; i < 10; i++) for (i = 0; i < 10; i++)
{ {
next = CMock_Guts_MemNew(sizes[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); 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]; sum += sizes_buffered[i];
cap = (StartingSize > (sum + CMOCK_MEM_SIZE)) ? StartingSize : (sum + CMOCK_MEM_SIZE); cap = (StartingSize > (sum + CMOCK_MEM_SIZE)) ? StartingSize : (sum + CMOCK_MEM_SIZE);
@@ -177,10 +177,10 @@ void test_ThatWeCanAskForAllSortsOfSizes(void)
next = first; next = first;
for (i = 0; i < 10; i++) 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); next = CMock_Guts_MemNext(next);
} }
//there aren't any after that //there aren't any after that
TEST_ASSERT_NULL(next); TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, next);
} }
test/c/TestCMockCDynamic_Runner.c
+6 -6
View File
@@ -23,12 +23,12 @@ int main(void)
Unity.TestFile = "TestCMockDynamic.c"; Unity.TestFile = "TestCMockDynamic.c";
UnityBegin(); UnityBegin();
RUN_TEST(test_MemNewWillReturnNullIfGivenIllegalSizes, 20); RUN_TEST(test_MemNewWillReturnNullIfGivenIllegalSizes, 26);
RUN_TEST(test_MemNewWillNowSupportSizesGreaterThanTheDefinesCMockSize, 29); RUN_TEST(test_MemNewWillNowSupportSizesGreaterThanTheDefinesCMockSize, 35);
RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 39); RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 45);
RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 53); RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 59);
RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 64); RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 70);
RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 146); RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 152);
UnityEnd(); UnityEnd();
return 0; return 0;
test/c/TestCMockC_Runner.c
+7 -7
View File
@@ -24,13 +24,13 @@ int main(void)
Unity.TestFile = "TestCMock.c"; Unity.TestFile = "TestCMock.c";
UnityBegin(); UnityBegin();
RUN_TEST(test_MemNewWillReturnNullIfGivenIllegalSizes, 15); RUN_TEST(test_MemNewWillReturnNullIfGivenIllegalSizes, 21);
RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 25); RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 32);
RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 39); RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 46);
RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 50); RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 57);
RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory, 132); RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory, 139);
RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd, 178); RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd, 185);
RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 225); RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 233);
UnityEnd(); UnityEnd();
return 0; return 0;
test/unit/cmock_generator_main_test.rb
+6 -6
View File
@@ -231,9 +231,9 @@ class CMockGeneratorTest < Test::Unit::TestCase
"\n} CMOCK_Second_CALL_INSTANCE;\n\n", "\n} CMOCK_Second_CALL_INSTANCE;\n\n",
"static struct MockPoutPoutFishInstance\n{\n", "static struct MockPoutPoutFishInstance\n{\n",
" d1", " d1",
" CMOCK_First_CALL_INSTANCE* First_CallInstance;\n", " CMOCK_MEM_INDEX_TYPE First_CallInstance;\n",
" e1 e2 e3", " e1 e2 e3",
" CMOCK_Second_CALL_INSTANCE* Second_CallInstance;\n", " CMOCK_MEM_INDEX_TYPE Second_CallInstance;\n",
"} Mock;\n\n" "} Mock;\n\n"
].join ].join
@plugins.expect.run(:instance_typedefs, functions[0]).returns([" b1"," b2"]) @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", expected = [ "static int SupaFunction(uint32 sandwiches, const char* named)\n",
"{\n", "{\n",
" UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n", " UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n",
" CMOCK_SupaFunction_CALL_INSTANCE* cmock_call_instance = 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_SupaFunction_CALL_INSTANCE*)CMock_Guts_MemNext(Mock.SupaFunction_CallInstance);\n", " Mock.SupaFunction_CallInstance = CMock_Guts_MemNext(Mock.SupaFunction_CallInstance);\n",
" uno", " uno",
" UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"Function 'SupaFunction' called more times than expected.\");\n", " 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", " cmock_line = cmock_call_instance->LineNumber;\n",
@@ -399,8 +399,8 @@ class CMockGeneratorTest < Test::Unit::TestCase
expected = [ "int SupaFunction(uint32 sandwiches, corn ...)\n", expected = [ "int SupaFunction(uint32 sandwiches, corn ...)\n",
"{\n", "{\n",
" UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n", " UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n",
" CMOCK_SupaFunction_CALL_INSTANCE* cmock_call_instance = 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_SupaFunction_CALL_INSTANCE*)CMock_Guts_MemNext(Mock.SupaFunction_CallInstance);\n", " Mock.SupaFunction_CallInstance = CMock_Guts_MemNext(Mock.SupaFunction_CallInstance);\n",
" uno", " uno",
" UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"Function 'SupaFunction' called more times than expected.\");\n", " 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", " cmock_line = cmock_call_instance->LineNumber;\n",
test/unit/cmock_generator_plugin_expect_test.rb
+1 -1
View File
@@ -198,7 +198,7 @@ class CMockGeneratorPluginExpectTest < Test::Unit::TestCase
should "add mock verify lines" do should "add mock verify lines" do
function = {:name => "Banana" } 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) returned = @cmock_generator_plugin_expect.mock_verify(function)
assert_equal(expected, returned) assert_equal(expected, returned)
end end
test/unit/cmock_generator_utils_test.rb
+10 -7
View File
@@ -44,10 +44,11 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
end end
should "add code for a base expectation with no plugins" do should "add code for a base expectation with no plugins" do
expected = 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" + " 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->LineNumber = cmock_line;\n"
output = @cmock_generator_utils_simple.code_add_base_expectation("Apple") output = @cmock_generator_utils_simple.code_add_base_expectation("Apple")
assert_equal(expected, output) assert_equal(expected, output)
@@ -55,9 +56,10 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
should "add code for a base expectation with all plugins" do should "add code for a base expectation with all plugins" do
expected = 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" + " 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->LineNumber = cmock_line;\n" +
" cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" + " cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" +
" cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\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 should "add code for a base expectation with all plugins and ordering not supported" do
expected = 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" + " 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->LineNumber = cmock_line;\n" +
" cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n" " cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n"
output = @cmock_generator_utils_complex.code_add_base_expectation("Apple", false) output = @cmock_generator_utils_complex.code_add_base_expectation("Apple", false)