espressif/Unity
1
0
Fork 0
mirror of https://github.com/ThrowTheSwitch/Unity.git synced 2025-05-20 17:07:32 +08:00
Code Issues Packages Projects Releases Wiki Activity

- added array handling for smaller integer types

Browse Source 
- 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
This commit is contained in:
mvandervoord
2010-03-30 03:34:09 +00:00
parent 3a2595ceb6
commit 4fc9cf594a
6 changed files with 237 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
auto/generate_test_runner.rb
View File

@ -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()

2
auto/unity_test_summary.rb
View File

@ -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

95
src/unity.c
View File

@ -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++;
}
}

7
src/unity.h
View File

@ -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

10
src/unity_internals.h
View File

@ -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

131
test/testunity.c
View File

@ -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};