From 51af84a727e8cc39fdfdbdf360853c6563abf586 Mon Sep 17 00:00:00 2001 From: Xiaochen Pan Date: Mon, 27 Aug 2012 00:36:51 -0400 Subject: [PATCH 1/6] adding test cases to complete the testing list --- test/testunity.c | 423 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 411 insertions(+), 12 deletions(-) mode change 100644 => 100755 test/testunity.c diff --git a/test/testunity.c b/test/testunity.c old mode 100644 new mode 100755 index 8c42534..a3467d4 --- a/test/testunity.c +++ b/test/testunity.c @@ -398,6 +398,45 @@ void testEqualInt16sWhenThereAreDifferencesOutside16Bits(void) TEST_ASSERT_EQUAL_INT16(0xFFFF4321,0x00004321); } +void testEqualInt32s(void) +{ + _US32 v0, v1; + _US32 *p0, *p1; + + v0 = 0x78760000; + v1 = 0x78760000; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT32(0x78760000, 0x78760000); + TEST_ASSERT_EQUAL_INT32(v0, v1); + TEST_ASSERT_EQUAL_INT32(0x78760000, v1); + TEST_ASSERT_EQUAL_INT32(v0, 0x78760000); + TEST_ASSERT_EQUAL_INT32(*p0, v1); + TEST_ASSERT_EQUAL_INT32(*p0, *p1); + TEST_ASSERT_EQUAL_INT32(*p0, 0x78760000); +} + +void testEqualInt32sNegatives(void) +{ + _US32 v0, v1; + _US32 *p0, *p1; + + v0 = -123456789; + v1 = -123456789; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT32(-123456789, -123456789); + TEST_ASSERT_EQUAL_INT32(v0, v1); + TEST_ASSERT_EQUAL_INT32(-123456789, v1); + TEST_ASSERT_EQUAL_INT32(v0, -123456789); + TEST_ASSERT_EQUAL_INT32(*p0, v1); + TEST_ASSERT_EQUAL_INT32(*p0, *p1); + TEST_ASSERT_EQUAL_INT32(*p0, -123456789); +} + + void testEqualUints(void) { unsigned int v0, v1; @@ -469,6 +508,25 @@ void testEqualUint16sWhenThereAreDifferencesOutside16Bits(void) TEST_ASSERT_EQUAL_UINT16(0xFFFF4321,0x00004321); } +void testEqualUint32s(void) +{ + _UU32 v0, v1; + _UU32 *p0, *p1; + + v0 = 0x98760000; + v1 = 0x98760000; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT32(0x98760000, 0x98760000); + TEST_ASSERT_EQUAL_UINT32(v0, v1); + TEST_ASSERT_EQUAL_UINT32(0x98760000, v1); + TEST_ASSERT_EQUAL_UINT32(v0, 0x98760000); + TEST_ASSERT_EQUAL_UINT32(*p0, v1); + TEST_ASSERT_EQUAL_UINT32(*p0, *p1); + TEST_ASSERT_EQUAL_UINT32(*p0, 0x98760000); +} + void testNotEqual(void) { TEST_ASSERT_NOT_EQUAL(0, 1); @@ -584,6 +642,45 @@ void testEqualBits(void) TEST_ASSERT_BIT_LOW(5, v0); } +void testNotEqualBitHigh(void) +{ + _UU32 v0 = 0x7F55AA00; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BIT_HIGH(31, v0); + VERIFY_FAILS_END +} + +void testNotEqualBitLow(void) +{ + _UU32 v0 = 0xFF55AA00; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BIT_LOW(30, v0); + VERIFY_FAILS_END +} + +void testNotEqualBitsHigh(void) +{ + _UU32 v0 = 0xFF55AA00; + _UU32 v1 = 0x55550000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BITS_HIGH(v0, v1); + VERIFY_FAILS_END + +} + +void testNotEqualBitsLow(void) +{ + _UU32 v0 = 0xFF55AA00; + _UU32 v1 = 0x55550000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BITS_LOW(v0, v1); + VERIFY_FAILS_END + +} void testEqualShorts(void) { short v0, v1; @@ -1145,8 +1242,8 @@ void testEqualInt8Arrays(void) void testNotEqualInt8Arrays(void) { - _US8 p0[] = {1, 8, 127, -2}; - _US8 p1[] = {1, 8, 127, 2}; + _US8 p0[] = {1, 8, 36, -2}; + _US8 p1[] = {1, 8, 36, 2}; EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4); @@ -1199,10 +1296,10 @@ void testNotEqualUIntArrays3(void) void testEqualInt16Arrays(void) { - _UU16 p0[] = {1, 8, 117, 3}; - _UU16 p1[] = {1, 8, 117, 3}; - _UU16 p2[] = {1, 8, 117, 2}; - _UU16 p3[] = {1, 50, 60, 70}; + _US16 p0[] = {1, 8, 117, 3}; + _US16 p1[] = {1, 8, 117, 3}; + _US16 p2[] = {1, 8, 117, 2}; + _US16 p3[] = {1, 50, 60, 70}; TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 1); TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 4); @@ -1213,21 +1310,90 @@ void testEqualInt16Arrays(void) void testNotEqualInt16Arrays(void) { - _UU16 p0[] = {1, 8, 127, 3}; - _UU16 p1[] = {1, 8, 127, 2}; + _US16 p0[] = {1, 8, 127, 3}; + _US16 p1[] = {1, 8, 127, 2}; EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4); VERIFY_FAILS_END } +void testEqualInt32Arrays(void) +{ + _US32 p0[] = {1, 8, 117, 3}; + _US32 p1[] = {1, 8, 117, 3}; + _US32 p2[] = {1, 8, 117, 2}; + _US32 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p3, 1); +} + +void testNotEqualInt32Arrays(void) +{ + _US32 p0[] = {1, 8, 127, 3}; + _US32 p1[] = {1, 8, 127, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualUINT8Arrays(void) +{ + _UU8 p0[] = {1, 8, 100, 127}; + _UU8 p1[] = {1, 8, 100, 127}; + _UU8 p2[] = {1, 8, 100, 2}; + _UU8 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p3, 1); +} + +void testNotEqualUINT8Arrays1(void) +{ + unsigned char p0[] = {1, 8, 100, 127u}; + unsigned char p1[] = {1, 8, 100, 255u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT8Arrays2(void) +{ + unsigned char p0[] = {1, 8, 100, 127u}; + unsigned char p1[] = {1, 8, 100, 255u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT8Arrays3(void) +{ + unsigned char p0[] = {1, 8, 100, 127u}; + unsigned char p1[] = {1, 8, 100, 255u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + + void testEqualUINT16Arrays(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_UINT16_ARRAY(p0, p0, 1); TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 4); TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); @@ -1239,7 +1405,7 @@ void testNotEqualUINT16Arrays1(void) { unsigned short p0[] = {1, 8, 987, 65132u}; unsigned short p1[] = {1, 8, 987, 65131u}; - + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); VERIFY_FAILS_END @@ -1249,7 +1415,7 @@ void testNotEqualUINT16Arrays2(void) { unsigned short p0[] = {1, 8, 987, 65132u}; unsigned short p1[] = {2, 8, 987, 65132u}; - + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); VERIFY_FAILS_END @@ -1259,12 +1425,58 @@ void testNotEqualUINT16Arrays3(void) { unsigned short p0[] = {1, 8, 987, 65132u}; unsigned short p1[] = {1, 8, 986, 65132u}; - + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); VERIFY_FAILS_END } + + +void testEqualUINT32Arrays(void) +{ + _UU32 p0[] = {1, 8, 987, 65132u}; + _UU32 p1[] = {1, 8, 987, 65132u}; + _UU32 p2[] = {1, 8, 987, 2}; + _UU32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p3, 1); +} + +void testNotEqualUINT32Arrays1(void) +{ + _UU32 p0[] = {1, 8, 987, 65132u}; + _UU32 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT32Arrays2(void) +{ + _UU32 p0[] = {1, 8, 987, 65132u}; + _UU32 p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT32Arrays3(void) +{ + _UU32 p0[] = {1, 8, 987, 65132u}; + _UU32 p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + void testEqualHEXArrays(void) { unsigned int p0[] = {1, 8, 987, 65132u}; @@ -1309,6 +1521,50 @@ void testNotEqualHEXArrays3(void) VERIFY_FAILS_END } +void testEqualHEX32Arrays(void) +{ + _UU32 p0[] = {1, 8, 987, 65132u}; + _UU32 p1[] = {1, 8, 987, 65132u}; + _UU32 p2[] = {1, 8, 987, 2}; + _UU32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1); +} + +void testNotEqualHEX32Arrays1(void) +{ + _UU32 p0[] = {1, 8, 987, 65132u}; + _UU32 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX32Arrays2(void) +{ + _UU32 p0[] = {1, 8, 987, 65132u}; + _UU32 p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX32Arrays3(void) +{ + _UU32 p0[] = {1, 8, 987, 65132u}; + _UU32 p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + void testEqualHEX16Arrays(void) { unsigned short p0[] = {1, 8, 987, 65132u}; @@ -1510,6 +1766,53 @@ void testEqualHex64s(void) #endif } +void testEqualUint64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + _UU64 v0, v1; + _UU64 *p0, *p1; + + v0 = 0x9876543201234567; + v1 = 0x9876543201234567; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, 0x9876543201234567); + TEST_ASSERT_EQUAL_UINT64(v0, v1); + TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, v1); + TEST_ASSERT_EQUAL_UINT64(v0, 0x9876543201234567); + TEST_ASSERT_EQUAL_UINT64(*p0, v1); + TEST_ASSERT_EQUAL_UINT64(*p0, *p1); + TEST_ASSERT_EQUAL_UINT64(*p0, 0x9876543201234567); +#endif +} + +void testEqualInt64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + _US64 v0, v1; + _US64 *p0, *p1; + + v0 = 0x9876543201234567; + v1 = 0x9876543201234567; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT64(0x9876543201234567, 0x9876543201234567); + TEST_ASSERT_EQUAL_INT64(v0, v1); + TEST_ASSERT_EQUAL_INT64(0x9876543201234567, v1); + TEST_ASSERT_EQUAL_INT64(v0, 0x9876543201234567); + TEST_ASSERT_EQUAL_INT64(*p0, v1); + TEST_ASSERT_EQUAL_INT64(*p0, *p1); + TEST_ASSERT_EQUAL_INT64(*p0, 0x9876543201234567); +#endif +} + + void testNotEqualHex64s(void) { #ifndef UNITY_SUPPORT_64 @@ -1526,6 +1829,38 @@ void testNotEqualHex64s(void) #endif } +void testNotEqualUint64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + _UU64 v0, v1; + + v0 = 9000000000; + v1 = 9100000000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT64(v0, v1); + VERIFY_FAILS_END +#endif +} + +void testNotEqualInt64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + _US64 v0, v1; + + v0 = -9000000000; + v1 = 9100000000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT64(v0, v1); + VERIFY_FAILS_END +#endif +} + void testNotEqualHex64sIfSigned(void) { #ifndef UNITY_SUPPORT_64 @@ -1593,6 +1928,43 @@ void testEqualHEX64Arrays(void) #endif } +void testEqualUint64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + _UU64 p0[] = {1, 8, 987, 65132u}; + _UU64 p1[] = {1, 8, 987, 65132u}; + _UU64 p2[] = {1, 8, 987, 2}; + _UU64 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p3, 1); +#endif +} + +void testEqualInt64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + _US64 p0[] = {1, 8, 987, -65132}; + _US64 p1[] = {1, 8, 987, -65132}; + _US64 p2[] = {1, 8, 987, -2}; + _US64 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p3, 1); +#endif +} + + void testNotEqualHEX64Arrays1(void) { #ifndef UNITY_SUPPORT_64 @@ -1621,6 +1993,33 @@ void testNotEqualHEX64Arrays2(void) #endif } +void testNotEqualUint64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + _UU64 p0[] = {1, 8, 987, 65132u}; + _UU64 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualInt64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + _US64 p0[] = {1, 8, 987, -65132}; + _US64 p1[] = {1, 8, 987, -65131}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES FLOAT SUPPORT ================== void testFloatsWithinDelta(void) From 3d1f3a5a002344917cf6e583546cb3fc1fa9ccf1 Mon Sep 17 00:00:00 2001 From: John Van Enk Date: Mon, 1 Oct 2012 17:31:40 -0400 Subject: [PATCH 2/6] Fully expand Unity struct. --- src/unity.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/unity.c b/src/unity.c index a8e1476..0219b37 100644 --- a/src/unity.c +++ b/src/unity.c @@ -14,7 +14,7 @@ #define UNITY_SKIP_EXECUTION { if ((Unity.CurrentTestFailed != 0) || (Unity.CurrentTestIgnored != 0)) {return;} } #define UNITY_PRINT_EOL { UNITY_OUTPUT_CHAR('\n'); } -struct _Unity Unity = { 0 }; +struct _Unity Unity = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , { 0 } }; const char* UnityStrNull = "NULL"; const char* UnityStrSpacer = ". "; From aaddd1cd8095abd85f14f1a351aba42e0da554ef Mon Sep 17 00:00:00 2001 From: John Van Enk Date: Wed, 3 Oct 2012 12:44:02 -0400 Subject: [PATCH 3/6] Add test that will break if the _Unity struct ever changes. --- test/testunity.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/test/testunity.c b/test/testunity.c index 8c42534..568234f 100644 --- a/test/testunity.c +++ b/test/testunity.c @@ -50,6 +50,14 @@ void tearDown(void) } } +void testBreadCrumbs(void) +{ + /* This test ensures that sizeof(struct _Unity) doesn't change. If this + * test breaks, go look at the initialization of the Unity global variable + * in unity.c and make sure we're filling in the proper fields. */ + TEST_ASSERT_EQUAL(104, sizeof(Unity)); +} + void testTrue(void) { TEST_ASSERT(1); @@ -2021,4 +2029,4 @@ void testNotEqualDoubleArraysNegative3(void) VERIFY_FAILS_END #endif } - \ No newline at end of file + From b1a991c6c3fb99325ab1b2c04e239eac3721d76b Mon Sep 17 00:00:00 2001 From: John Van Enk Date: Wed, 3 Oct 2012 13:47:18 -0400 Subject: [PATCH 4/6] Use a better message and change the test name. --- test/testunity.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/test/testunity.c b/test/testunity.c index 568234f..d435f95 100644 --- a/test/testunity.c +++ b/test/testunity.c @@ -50,12 +50,15 @@ void tearDown(void) } } -void testBreadCrumbs(void) +void testUnitySizeInitializationReminder(void) { + char * message = "Unexpected size for _Unity struct. Please check that " + "the initialization of the Unity symbol in unity.c is " + "still correct."; /* This test ensures that sizeof(struct _Unity) doesn't change. If this * test breaks, go look at the initialization of the Unity global variable * in unity.c and make sure we're filling in the proper fields. */ - TEST_ASSERT_EQUAL(104, sizeof(Unity)); + TEST_ASSERT_EQUAL_MESSAGE(104, sizeof(Unity), message); } void testTrue(void) From 541fb57a3192957b95fcd9092ca438c3032edf69 Mon Sep 17 00:00:00 2001 From: John Van Enk Date: Wed, 3 Oct 2012 14:17:07 -0400 Subject: [PATCH 5/6] Switch up the testing strategy to handle funny architectural issues. --- test/testunity.c | 27 +++++++++++++++++++++++---- 1 file changed, 23 insertions(+), 4 deletions(-) diff --git a/test/testunity.c b/test/testunity.c index d435f95..c8ca2e6 100644 --- a/test/testunity.c +++ b/test/testunity.c @@ -52,13 +52,32 @@ void tearDown(void) void testUnitySizeInitializationReminder(void) { - char * message = "Unexpected size for _Unity struct. Please check that " - "the initialization of the Unity symbol in unity.c is " - "still correct."; /* This test ensures that sizeof(struct _Unity) doesn't change. If this * test breaks, go look at the initialization of the Unity global variable * in unity.c and make sure we're filling in the proper fields. */ - TEST_ASSERT_EQUAL_MESSAGE(104, sizeof(Unity), message); + char * message = "Unexpected size for _Unity struct. Please check that " + "the initialization of the Unity symbol in unity.c is " + "still correct."; + + /* Define a structure with all the same fields as `struct _Unity`. */ + struct { + const char* TestFile; + const char* CurrentTestName; + UNITY_LINE_TYPE CurrentTestLineNumber; + UNITY_COUNTER_TYPE NumberOfTests; + UNITY_COUNTER_TYPE TestFailures; + UNITY_COUNTER_TYPE TestIgnores; + UNITY_COUNTER_TYPE CurrentTestFailed; + UNITY_COUNTER_TYPE CurrentTestIgnored; + jmp_buf AbortFrame; + } _Expected_Unity; + + /* Compare our fake structure's size to the actual structure's size. They + * should be the same. + * + * This accounts for alignment, padding, and packing issues that might come + * up between different architectures. */ + TEST_ASSERT_EQUAL_MESSAGE(sizeof(_Expected_Unity), sizeof(Unity), message); } void testTrue(void) From 731e0f6b5f96b83adb94c209b582765c14215b2c Mon Sep 17 00:00:00 2001 From: John Van Enk Date: Wed, 3 Oct 2012 15:01:20 -0400 Subject: [PATCH 6/6] Bump version. --- release/version.info | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/release/version.info b/release/version.info index 0d71c08..6b2d349 100644 --- a/release/version.info +++ b/release/version.info @@ -1,2 +1,2 @@ -2.0 +2.1.0