From 4fc9cf594ae9cd4844826cf7e0d0ff253bfe1202 Mon Sep 17 00:00:00 2001 From: mvandervoord Date: Tue, 30 Mar 2010 03:34:09 +0000 Subject: [PATCH] - added array handling for smaller integer types - added array handling for floats - cleaned up filename handling in scripts git-svn-id: http://unity.svn.sourceforge.net/svnroot/unity/trunk@67 e7d17a6e-8845-0410-bbbc-c8efb4fdad7e --- auto/generate_test_runner.rb | 8 +-- auto/unity_test_summary.rb | 2 +- src/unity.c | 95 ++++++++++++++++++++++--- src/unity.h | 7 +- src/unity_internals.h | 10 +++ test/testunity.c | 131 ++++++++++++++++++++++++++++++++++- 6 files changed, 237 insertions(+), 16 deletions(-) diff --git a/auto/generate_test_runner.rb b/auto/generate_test_runner.rb index c486661..0655a3d 100644 --- a/auto/generate_test_runner.rb +++ b/auto/generate_test_runner.rb @@ -41,7 +41,7 @@ class UnityTestRunnerGenerator used_mocks = find_mocks(includes) end - puts "Creating test runner for #{File.basename(input_file)}..." + puts "Creating test runner for #{module_name}..." #build runner file File.open(output_file, 'w') do |output| @@ -50,7 +50,7 @@ class UnityTestRunnerGenerator create_mock_management(output, used_mocks) create_runtest(output, used_mocks) create_reset(output, used_mocks) - create_main(output, module_name, tests) + create_main(output, input_file, tests) end all_files_used = [input_file, output_file] @@ -208,12 +208,12 @@ class UnityTestRunnerGenerator output.puts("}") end - def create_main(output, module_name, tests) + def create_main(output, filename, tests) output.puts() output.puts() output.puts("int main(void)") output.puts("{") - output.puts(" Unity.TestFile = \"#{module_name}\";") + output.puts(" Unity.TestFile = \"#{filename}\";") output.puts(" UnityBegin();") output.puts() diff --git a/auto/unity_test_summary.rb b/auto/unity_test_summary.rb index d167d27..9c3fe1b 100644 --- a/auto/unity_test_summary.rb +++ b/auto/unity_test_summary.rb @@ -88,8 +88,8 @@ class UnityTestSummary def get_details(result_file, lines) results = { :failures => [], :ignores => [], :successes => [] } lines.each do |line| - line_out = line.gsub(/\//, "\\") src_file,src_line,test_name,status,msg = line.split(/:/) + line_out = ((@root and (@root != 0)) ? "#{@root}#{line}" : line ).gsub(/\//, "\\") case(status) when 'IGNORE' then results[:ignores] << line_out when 'FAIL' then results[:failures] << line_out diff --git a/src/unity.c b/src/unity.c index bbf844b..08e3cd0 100644 --- a/src/unity.c +++ b/src/unity.c @@ -11,9 +11,9 @@ const char* UnityStrExpected = " Expected "; const char* UnityStrWas = " Was "; const char* UnityStrTo = " To "; const char* UnityStrElement = " Element "; -const char* UnityStrMemory = " Memory Mismatch "; +const char* UnityStrMemory = " Memory Mismatch."; const char* UnityStrDelta = " Values Not Within Delta "; -const char* UnityStrPointless= " You Asked Me To Compare Nothing, Which Was Pointless"; +const char* UnityStrPointless= " You Asked Me To Compare Nothing, Which Was Pointless."; const char* UnityStrSpacer = ". "; void UnityAddMsgIfSpecified(const char* msg); @@ -244,8 +244,86 @@ void UnityAssertEqualIntArray(const int* expected, const UNITY_DISPLAY_STYLE_T style) { unsigned long elements = num_elements; - const int* ptr_expected = expected; - const int* ptr_actual = actual; + const _US32* ptr_exp32 = (_US32*)expected; + const _US16* ptr_exp16 = (_US16*)expected; + const _US8* ptr_exp8 = (_US8*)expected; + const _US32* ptr_act32 = (_US32*)actual; + const _US16* ptr_act16 = (_US16*)actual; + const _US8* ptr_act8 = (_US8*)actual; + + if (elements == 0) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrPointless); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + + switch(style) + { + case UNITY_DISPLAY_STYLE_HEX8: + while (elements--) + { + if (*ptr_exp8++ != *ptr_act8++) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(*--ptr_exp8, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(*--ptr_act8, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + } + break; + case UNITY_DISPLAY_STYLE_HEX16: + while (elements--) + { + if (*ptr_exp16++ != *ptr_act16++) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(*--ptr_exp16, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(*--ptr_act16, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + } + break; + default: + while (elements--) + { + if (*ptr_exp32++ != *ptr_act32++) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(*--ptr_exp32, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(*--ptr_act32, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + } + break; + } +} + +void UnityAssertEqualFloatArray(const _UF* expected, + const _UF* actual, + const unsigned long num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + unsigned long elements = num_elements; + const _UF* ptr_expected = expected; + const _UF* ptr_actual = actual; if (elements == 0) { @@ -257,18 +335,17 @@ void UnityAssertEqualIntArray(const int* expected, while (elements--) { - if (*ptr_expected++ != *ptr_actual++) + if ((*ptr_expected - *ptr_actual) > (UNITY_FLOAT_PRECISION * *ptr_expected)) { UnityTestResultsFailBegin(lineNumber); UnityPrint(UnityStrElement); UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); - UnityPrint(UnityStrExpected); - UnityPrintNumberByStyle(*--ptr_expected, style); - UnityPrint(UnityStrWas); - UnityPrintNumberByStyle(*--ptr_actual, style); + UnityPrint(UnityStrDelta); UnityAddMsgIfSpecified(msg); UNITY_FAIL_AND_BAIL; } + ptr_expected++; + ptr_actual++; } } diff --git a/src/unity.h b/src/unity.h index 9e0d783..1c5015e 100644 --- a/src/unity.h +++ b/src/unity.h @@ -92,6 +92,8 @@ //Arrays #define TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, __LINE__, NULL) #define TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, __LINE__, NULL) #define TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, __LINE__, NULL) #define TEST_ASSERT_EQUAL_HEX_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, __LINE__, NULL) #define TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, __LINE__, NULL) @@ -99,6 +101,7 @@ //Floating Point (If Enabled) #define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, __LINE__, NULL) #define TEST_ASSERT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, __LINE__, NULL) +#define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, __LINE__, NULL) //------------------------------------------------------- // Test Asserts (with additional messages) @@ -142,6 +145,8 @@ //Arrays #define TEST_ASSERT_EQUAL_INT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, __LINE__, message) #define TEST_ASSERT_EQUAL_UINT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, __LINE__, message) +#define TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, __LINE__, message) +#define TEST_ASSERT_EQUAL_HEX16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, __LINE__, message) #define TEST_ASSERT_EQUAL_HEX32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, __LINE__, message) #define TEST_ASSERT_EQUAL_HEX_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, __LINE__, message) #define TEST_ASSERT_EQUAL_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, __LINE__, message) @@ -149,5 +154,5 @@ //Floating Point (If Enabled) #define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, __LINE__, message) #define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, __LINE__, message) - +#define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, __LINE__, message) #endif diff --git a/src/unity_internals.h b/src/unity_internals.h index ec2668c..667c948 100644 --- a/src/unity_internals.h +++ b/src/unity_internals.h @@ -166,6 +166,12 @@ void UnityAssertFloatsWithin(const _UF delta, const _UF actual, const char* msg, const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualFloatArray(const _UF* expected, + const _UF* actual, + const unsigned long num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber); #endif //------------------------------------------------------- @@ -201,15 +207,19 @@ void UnityAssertFloatsWithin(const _UF delta, #define UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const int*)(expected), (const int*)(actual), (unsigned long)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT) #define UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const int*)(expected), (const int*)(actual), (unsigned long)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const int*)(expected), (const int*)(actual), (unsigned long)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const int*)(expected), (const int*)(actual), (unsigned long)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16) #define UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const int*)(expected), (const int*)(actual), (unsigned long)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32) #define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((void*)(expected), (void*)(actual), (unsigned long)(len), (unsigned long)(num_elements), (message), (UNITY_LINE_TYPE)line) #ifdef UNITY_EXCLUDE_FLOAT #define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled") #define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled") +#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled") #else #define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsWithin((_UF)(delta), (_UF)(expected), (_UF)(actual), (message), (UNITY_LINE_TYPE)line) #define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((_UF)(expected) * (_UF)UNITY_FLOAT_PRECISION, (_UF)expected, (_UF)actual, (UNITY_LINE_TYPE)line, message) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray((_UF*)(expected), (_UF*)(actual), (unsigned long)(num_elements), (message), (UNITY_LINE_TYPE)line) #endif #endif diff --git a/test/testunity.c b/test/testunity.c index bd57416..6095aa9 100644 --- a/test/testunity.c +++ b/test/testunity.c @@ -1055,7 +1055,6 @@ void testNotEqualUIntArrays3(void) VERIFY_FAILURE_WAS_CAUGHT } - void testEqualHEXArrays(void) { unsigned int p0[] = {1, 8, 987, 65132u}; @@ -1121,6 +1120,136 @@ void testNotEqualHEXArrays3(void) VERIFY_FAILURE_WAS_CAUGHT } +void testEqualHEX16Arrays(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 987, 65132u}; + unsigned short p2[] = {1, 8, 987, 2}; + unsigned short p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p3, 1); +} + +void testNotEqualHEX16Arrays1(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 987, 65131u}; + + int failed; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + EXPECT_ABORT_END + + failed = Unity.CurrentTestFailed; + Unity.CurrentTestFailed = 0; + + VERIFY_FAILURE_WAS_CAUGHT +} + +void testNotEqualHEX16Arrays2(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {2, 8, 987, 65132u}; + + int failed; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + EXPECT_ABORT_END + + failed = Unity.CurrentTestFailed; + Unity.CurrentTestFailed = 0; + + VERIFY_FAILURE_WAS_CAUGHT +} + +void testNotEqualHEX16Arrays3(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 986, 65132u}; + + int failed; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + EXPECT_ABORT_END + + failed = Unity.CurrentTestFailed; + Unity.CurrentTestFailed = 0; + + VERIFY_FAILURE_WAS_CAUGHT +} + +void testEqualHEX8Arrays(void) +{ + unsigned short p0[] = {1, 8, 254u, 123}; + unsigned short p1[] = {1, 8, 254u, 123}; + unsigned short p2[] = {1, 8, 254u, 2}; + unsigned short p3[] = {1, 23, 25, 26}; + + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p3, 1); +} + +void testNotEqualHEX8Arrays1(void) +{ + unsigned char p0[] = {1, 8, 254u, 253u}; + unsigned char p1[] = {1, 8, 254u, 252u}; + + int failed; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + EXPECT_ABORT_END + + failed = Unity.CurrentTestFailed; + Unity.CurrentTestFailed = 0; + + VERIFY_FAILURE_WAS_CAUGHT +} + +void testNotEqualHEX8Arrays2(void) +{ + unsigned char p0[] = {1, 8, 254u, 253u}; + unsigned char p1[] = {2, 8, 254u, 253u}; + + int failed; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + EXPECT_ABORT_END + + failed = Unity.CurrentTestFailed; + Unity.CurrentTestFailed = 0; + + VERIFY_FAILURE_WAS_CAUGHT +} + +void testNotEqualHEX8Arrays3(void) +{ + unsigned char p0[] = {1, 8, 254u, 253u}; + unsigned char p1[] = {1, 8, 255u, 253u}; + + int failed; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + EXPECT_ABORT_END + + failed = Unity.CurrentTestFailed; + Unity.CurrentTestFailed = 0; + + VERIFY_FAILURE_WAS_CAUGHT +} + void testEqualMemoryArrays(void) { int p0[] = {1, 8, 987, -2};