From 51af84a727e8cc39fdfdbdf360853c6563abf586 Mon Sep 17 00:00:00 2001
From: Xiaochen Pan <xc.panfly@gmail.com>
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 <vanenkj@gmail.com>
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 <vanenkj@gmail.com>
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 <vanenkj@gmail.com>
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 <vanenkj@gmail.com>
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 <vanenkj@gmail.com>
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