ceedling 0.20.3 → 0.21.0

data/vendor/c_exception/vendor/unity/src/unity.h

@@ -18,50 +18,54 @@ extern "C"
 void setUp(void);
 void tearDown(void);
 
-//-------------------------------------------------------
-// Configuration Options
-//-------------------------------------------------------
-// All options described below should be passed as a compiler flag to all files using Unity. If you must add #defines, place them BEFORE the #include above.
-
-// Integers/longs/pointers
-//     - Unity attempts to automatically discover your integer sizes
-//       - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in <stdint.h>
-//       - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in <limits.h>
-//       - define UNITY_EXCLUDE_SIZEOF to stop attempting to use sizeof in macros
-//     - If you cannot use the automatic methods above, you can force Unity by using these options:
-//       - define UNITY_SUPPORT_64
-//       - define UNITY_INT_WIDTH
-//       - UNITY_LONG_WIDTH
-//       - UNITY_POINTER_WIDTH
-
-// Floats
-//     - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons
-//     - define UNITY_FLOAT_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_FLOAT
-//     - define UNITY_FLOAT_TYPE to specify doubles instead of single precision floats
-//     - define UNITY_FLOAT_VERBOSE to print floating point values in errors (uses sprintf)
-//     - define UNITY_INCLUDE_DOUBLE to allow double floating point comparisons
-//     - define UNITY_EXCLUDE_DOUBLE to disallow double floating point comparisons (default)
-//     - define UNITY_DOUBLE_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_DOUBLE
-//     - define UNITY_DOUBLE_TYPE to specify something other than double
-//     - define UNITY_DOUBLE_VERBOSE to print floating point values in errors (uses sprintf)
-//     - define UNITY_VERBOSE_NUMBER_MAX_LENGTH to change maximum length of printed numbers (used by sprintf)
-
-// Output
-//     - by default, Unity prints to standard out with putchar.  define UNITY_OUTPUT_CHAR(a) with a different function if desired
-
-// Optimization
-//     - by default, line numbers are stored in unsigned shorts.  Define UNITY_LINE_TYPE with a different type if your files are huge
-//     - by default, test and failure counters are unsigned shorts.  Define UNITY_COUNTER_TYPE with a different type if you want to save space or have more than 65535 Tests.
-
-// Test Cases
-//     - define UNITY_SUPPORT_TEST_CASES to include the TEST_CASE macro, though really it's mostly about the runner generator script
-
-// Parameterized Tests
-//     - you'll want to create a define of TEST_CASE(...) which basically evaluates to nothing
-
-//-------------------------------------------------------
-// Basic Fail and Ignore
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Configuration Options
+ *-------------------------------------------------------
+ * All options described below should be passed as a compiler flag to all files using Unity. If you must add #defines, place them BEFORE the #include above.
+
+ * Integers/longs/pointers
+ *     - Unity attempts to automatically discover your integer sizes
+ *       - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in <stdint.h>
+ *       - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in <limits.h>
+ *       - define UNITY_EXCLUDE_SIZEOF to stop attempting to use sizeof in macros
+ *     - If you cannot use the automatic methods above, you can force Unity by using these options:
+ *       - define UNITY_SUPPORT_64
+ *       - define UNITY_INT_WIDTH
+ *       - UNITY_LONG_WIDTH
+ *       - UNITY_POINTER_WIDTH
+
+ * Floats
+ *     - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons
+ *     - define UNITY_FLOAT_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_FLOAT
+ *     - define UNITY_FLOAT_TYPE to specify doubles instead of single precision floats
+ *     - define UNITY_FLOAT_VERBOSE to print floating point values in errors (uses sprintf)
+ *     - define UNITY_INCLUDE_DOUBLE to allow double floating point comparisons
+ *     - define UNITY_EXCLUDE_DOUBLE to disallow double floating point comparisons (default)
+ *     - define UNITY_DOUBLE_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_DOUBLE
+ *     - define UNITY_DOUBLE_TYPE to specify something other than double
+ *     - define UNITY_DOUBLE_VERBOSE to print floating point values in errors (uses sprintf)
+ *     - define UNITY_VERBOSE_NUMBER_MAX_LENGTH to change maximum length of printed numbers (used by sprintf)
+
+ * Output
+ *     - by default, Unity prints to standard out with putchar.  define UNITY_OUTPUT_CHAR(a) with a different function if desired
+ *     - define UNITY_DIFFERENTIATE_FINAL_FAIL to print FAILED (vs. FAIL) at test end summary - for automated search for failure
+
+ * Optimization
+ *     - by default, line numbers are stored in unsigned shorts.  Define UNITY_LINE_TYPE with a different type if your files are huge
+ *     - by default, test and failure counters are unsigned shorts.  Define UNITY_COUNTER_TYPE with a different type if you want to save space or have more than 65535 Tests.
+
+ * Test Cases
+ *     - define UNITY_SUPPORT_TEST_CASES to include the TEST_CASE macro, though really it's mostly about the runner generator script
+
+ * Parameterized Tests
+ *     - you'll want to create a define of TEST_CASE(...) which basically evaluates to nothing
+
+ * Tests with Arguments
+ *     - you'll want to define UNITY_USE_COMMAND_LINE_ARGS if you have the test runner passing arguments to Unity
+
+ *-------------------------------------------------------
+ * Basic Fail and Ignore
+ *-------------------------------------------------------*/
 
 #define TEST_FAIL_MESSAGE(message)                                                                 UNITY_TEST_FAIL(__LINE__, (message))
 #define TEST_FAIL()                                                                                UNITY_TEST_FAIL(__LINE__, NULL)
@@ -69,15 +73,15 @@ void tearDown(void);
 #define TEST_IGNORE()                                                                              UNITY_TEST_IGNORE(__LINE__, NULL)
 #define TEST_ONLY()
 
-//It is not necessary for you to call PASS. A PASS condition is assumed if nothing fails.
-//This method allows you to abort a test immediately with a PASS state, ignoring the remainder of the test.
+/* It is not necessary for you to call PASS. A PASS condition is assumed if nothing fails.
+ * This method allows you to abort a test immediately with a PASS state, ignoring the remainder of the test. */
 #define TEST_PASS()                                                                                longjmp(Unity.AbortFrame, 1)
 
-//-------------------------------------------------------
-// Test Asserts (simple)
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Test Asserts (simple)
+ *-------------------------------------------------------*/
 
-//Boolean
+/* Boolean */
 #define TEST_ASSERT(condition)                                                                     UNITY_TEST_ASSERT(       (condition), __LINE__, " Expression Evaluated To FALSE")
 #define TEST_ASSERT_TRUE(condition)                                                                UNITY_TEST_ASSERT(       (condition), __LINE__, " Expected TRUE Was FALSE")
 #define TEST_ASSERT_UNLESS(condition)                                                              UNITY_TEST_ASSERT(      !(condition), __LINE__, " Expression Evaluated To TRUE")
@@ -85,7 +89,7 @@ void tearDown(void);
 #define TEST_ASSERT_NULL(pointer)                                                                  UNITY_TEST_ASSERT_NULL(    (pointer), __LINE__, " Expected NULL")
 #define TEST_ASSERT_NOT_NULL(pointer)                                                              UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, " Expected Non-NULL")
 
-//Integers (of all sizes)
+/* Integers (of all sizes) */
 #define TEST_ASSERT_EQUAL_INT(expected, actual)                                                    UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_INT8(expected, actual)                                                   UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_INT16(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, NULL)
@@ -109,7 +113,7 @@ void tearDown(void);
 #define TEST_ASSERT_BIT_HIGH(bit, actual)                                                          UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(-1), (actual), __LINE__, NULL)
 #define TEST_ASSERT_BIT_LOW(bit, actual)                                                           UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(0), (actual), __LINE__, NULL)
 
-//Integer Ranges (of all sizes)
+/* Integer Ranges (of all sizes) */
 #define TEST_ASSERT_INT_WITHIN(delta, expected, actual)                                            UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_INT8_WITHIN(delta, expected, actual)                                           UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_INT16_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, NULL)
@@ -126,13 +130,13 @@ void tearDown(void);
 #define TEST_ASSERT_HEX32_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_HEX64_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 
-//Structs and Strings
+/* Structs and Strings */
 #define TEST_ASSERT_EQUAL_PTR(expected, actual)                                                    UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_STRING(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len)                                        UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_MEMORY(expected, actual, len)                                            UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, NULL)
 
-//Arrays
+/* 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_INT8_ARRAY(expected, actual, num_elements)                               UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
@@ -152,7 +156,7 @@ void tearDown(void);
 #define TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_STRING_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)
 
-//Floating Point (If Enabled)
+/* 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)                              UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
@@ -165,7 +169,7 @@ void tearDown(void);
 #define TEST_ASSERT_FLOAT_IS_NOT_NAN(actual)                                                       UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, NULL)
 #define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual)                                               UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, NULL)
 
-//Double (If Enabled)
+/* Double (If Enabled) */
 #define TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual)                                         UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_DOUBLE(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
@@ -178,11 +182,11 @@ void tearDown(void);
 #define TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual)                                                      UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, NULL)
 #define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual)                                              UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, NULL)
 
-//-------------------------------------------------------
-// Test Asserts (with additional messages)
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Test Asserts (with additional messages)
+ *-------------------------------------------------------*/
 
-//Boolean
+/* Boolean */
 #define TEST_ASSERT_MESSAGE(condition, message)                                                    UNITY_TEST_ASSERT(       (condition), __LINE__, (message))
 #define TEST_ASSERT_TRUE_MESSAGE(condition, message)                                               UNITY_TEST_ASSERT(       (condition), __LINE__, (message))
 #define TEST_ASSERT_UNLESS_MESSAGE(condition, message)                                             UNITY_TEST_ASSERT(      !(condition), __LINE__, (message))
@@ -190,7 +194,7 @@ void tearDown(void);
 #define TEST_ASSERT_NULL_MESSAGE(pointer, message)                                                 UNITY_TEST_ASSERT_NULL(    (pointer), __LINE__, (message))
 #define TEST_ASSERT_NOT_NULL_MESSAGE(pointer, message)                                             UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, (message))
 
-//Integers (of all sizes)
+/* Integers (of all sizes) */
 #define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_INT8_MESSAGE(expected, actual, message)                                  UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_INT16_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, (message))
@@ -214,7 +218,7 @@ void tearDown(void);
 #define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message)                                         UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(-1), (actual), __LINE__, (message))
 #define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message)                                          UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(0), (actual), __LINE__, (message))
 
-//Integer Ranges (of all sizes)
+/* Integer Ranges (of all sizes) */
 #define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message)                           UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_INT8_WITHIN_MESSAGE(delta, expected, actual, message)                          UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_INT16_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, (message))
@@ -231,13 +235,13 @@ void tearDown(void);
 #define TEST_ASSERT_HEX32_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_HEX64_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, (message))
 
-//Structs and Strings
+/* Structs and Strings */
 #define TEST_ASSERT_EQUAL_PTR_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message)                 UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_MEMORY_MESSAGE(expected, actual, len, message)                     UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, (message))
+#define TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message)                       UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, (message))
+#define TEST_ASSERT_EQUAL_MEMORY_MESSAGE(expected, actual, len, message)                           UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, (message))
 
-//Arrays
+/* 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_INT8_ARRAY_MESSAGE(expected, actual, num_elements, message)              UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_INT16_ARRAY_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
@@ -257,7 +261,7 @@ void tearDown(void);
 #define TEST_ASSERT_EQUAL_STRING_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_STRING_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))
 
-//Floating Point (If Enabled)
+/* 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))
@@ -270,7 +274,7 @@ void tearDown(void);
 #define TEST_ASSERT_FLOAT_IS_NOT_NAN_MESSAGE(actual, message)                                      UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, (message))
 #define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE_MESSAGE(actual, message)                              UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, (message))
 
-//Double (If Enabled)
+/* Double (If Enabled) */
 #define TEST_ASSERT_DOUBLE_WITHIN_MESSAGE(delta, expected, actual, message)                        UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_DOUBLE_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_DOUBLE_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
@@ -283,7 +287,7 @@ void tearDown(void);
 #define TEST_ASSERT_DOUBLE_IS_NOT_NAN_MESSAGE(actual, message)                                     UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, (message))
 #define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE_MESSAGE(actual, message)                             UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, (message))
 
-//end of UNITY_FRAMEWORK_H
+/* end of UNITY_FRAMEWORK_H */
 #ifdef __cplusplus
 }
 #endif

data/vendor/c_exception/vendor/unity/src/unity_internals.h

@@ -13,10 +13,10 @@
 
 #include <setjmp.h>
 
-// Unity Attempts to Auto-Detect Integer Types
-// Attempt 1: UINT_MAX, ULONG_MAX, etc in <stdint.h>
-// Attempt 2: UINT_MAX, ULONG_MAX, etc in <limits.h>
-// Attempt 3: Deduced from sizeof() macros
+/* Unity Attempts to Auto-Detect Integer Types
+ * Attempt 1: UINT_MAX, ULONG_MAX, etc in <stdint.h>
+ * Attempt 2: UINT_MAX, ULONG_MAX, etc in <limits.h>
+ * Attempt 3: Deduced from sizeof() macros */
 #ifndef UNITY_EXCLUDE_STDINT_H
 #include <stdint.h>
 #endif
@@ -33,7 +33,7 @@
 #define ULONG_MAX    (sizeof(unsigned long) * 256 - 1)
 #endif
 #ifndef UINTPTR_MAX
-//apparently this is not a constant expression: (sizeof(unsigned int *) * 256 - 1) so we have to just let this fall through
+/* apparently this is not a constant expression: (sizeof(unsigned int *) * 256 - 1) so we have to just let this fall through */
 #endif
 #endif
 
@@ -41,14 +41,14 @@
 #include <math.h>
 #endif
 
-//-------------------------------------------------------
-// Guess Widths If Not Specified
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Guess Widths If Not Specified
+ *-------------------------------------------------------*/
 
-// Determine the size of an int, if not already specificied.
-// We cannot use sizeof(int), because it is not yet defined
-// at this stage in the trnslation of the C program.
-// Therefore, infer it from UINT_MAX if possible.
+/* Determine the size of an int, if not already specificied.
+ * We cannot use sizeof(int), because it is not yet defined
+ * at this stage in the trnslation of the C program.
+ * Therefore, infer it from UINT_MAX if possible. */
 #ifndef UNITY_INT_WIDTH
   #ifdef UINT_MAX
     #if (UINT_MAX == 0xFFFF)
@@ -64,9 +64,9 @@
   #define UNITY_INT_WIDTH (32)
 #endif
 
-// Determine the size of a long, if not already specified,
-// by following the process used above to define
-// UNITY_INT_WIDTH.
+/* Determine the size of a long, if not already specified,
+ * by following the process used above to define
+ * UNITY_INT_WIDTH. */
 #ifndef UNITY_LONG_WIDTH
   #ifdef ULONG_MAX
     #if (ULONG_MAX == 0xFFFF)
@@ -82,9 +82,9 @@
   #define UNITY_LONG_WIDTH (32)
 #endif
 
-// Determine the size of a pointer, if not already specified,
-// by following the process used above to define
-// UNITY_INT_WIDTH.
+/* Determine the size of a pointer, if not already specified,
+ * by following the process used above to define
+ * UNITY_INT_WIDTH. */
 #ifndef UNITY_POINTER_WIDTH
   #ifdef UINTPTR_MAX
     #if (UINTPTR_MAX+0 <= 0xFFFF)
@@ -111,9 +111,9 @@
   #define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH
 #endif
 
-//-------------------------------------------------------
-// Int Support (Define types based on detected sizes)
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Int Support (Define types based on detected sizes)
+ *-------------------------------------------------------*/
 
 #if (UNITY_INT_WIDTH == 32)
     typedef unsigned char   _UU8;
@@ -133,9 +133,9 @@
     #error Invalid UNITY_INT_WIDTH specified! (16 or 32 are supported)
 #endif
 
-//-------------------------------------------------------
-// 64-bit Support
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * 64-bit Support
+ *-------------------------------------------------------*/
 
 #ifndef UNITY_SUPPORT_64
 #if UNITY_LONG_WIDTH > 32
@@ -150,13 +150,13 @@
 
 #ifndef UNITY_SUPPORT_64
 
-//No 64-bit Support
+/* No 64-bit Support */
 typedef _UU32 _U_UINT;
 typedef _US32 _U_SINT;
 
 #else
 
-//64-bit Support
+/* 64-bit Support */
 #if (UNITY_LONG_WIDTH == 32)
     typedef unsigned long long _UU64;
     typedef signed long long   _US64;
@@ -171,9 +171,9 @@ typedef _US64 _U_SINT;
 
 #endif
 
-//-------------------------------------------------------
-// Pointer Support
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Pointer Support
+ *-------------------------------------------------------*/
 
 #if (UNITY_POINTER_WIDTH == 32)
     typedef _UU32 _UP;
@@ -194,16 +194,16 @@ typedef _US64 _U_SINT;
 
 #ifndef UNITY_INTERNAL_PTR
 #define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const void*
-//#define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const _UU8*
+/* #define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const _UU8* */
 #endif
 
-//-------------------------------------------------------
-// Float Support
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Float Support
+ *-------------------------------------------------------*/
 
 #ifdef UNITY_EXCLUDE_FLOAT
 
-//No Floating Point Support
+/* No Floating Point Support */
 #undef UNITY_INCLUDE_FLOAT
 #undef UNITY_FLOAT_PRECISION
 #undef UNITY_FLOAT_TYPE
@@ -215,7 +215,7 @@ typedef _US64 _U_SINT;
 #define UNITY_INCLUDE_FLOAT
 #endif
 
-//Floating Point Support
+/* Floating Point Support */
 #ifndef UNITY_FLOAT_PRECISION
 #define UNITY_FLOAT_PRECISION (0.00001f)
 #endif
@@ -243,11 +243,11 @@ typedef UNITY_FLOAT_TYPE _UF;
 
 #endif
 
-//-------------------------------------------------------
-// Double Float Support
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Double Float Support
+ *-------------------------------------------------------*/
 
-//unlike FLOAT, we DON'T include by default
+/* unlike FLOAT, we DON'T include by default */
 #ifndef UNITY_EXCLUDE_DOUBLE
 #ifndef UNITY_INCLUDE_DOUBLE
 #define UNITY_EXCLUDE_DOUBLE
@@ -256,7 +256,7 @@ typedef UNITY_FLOAT_TYPE _UF;
 
 #ifdef UNITY_EXCLUDE_DOUBLE
 
-//No Floating Point Support
+/* No Floating Point Support */
 #undef UNITY_DOUBLE_PRECISION
 #undef UNITY_DOUBLE_TYPE
 #undef UNITY_DOUBLE_VERBOSE
@@ -267,7 +267,7 @@ typedef UNITY_FLOAT_TYPE _UF;
 
 #else
 
-//Double Floating Point Support
+/* Double Floating Point Support */
 #ifndef UNITY_DOUBLE_PRECISION
 #define UNITY_DOUBLE_PRECISION (1e-12f)
 #endif
@@ -284,16 +284,35 @@ typedef UNITY_DOUBLE_TYPE _UD;
 #endif
 #endif
 
-//-------------------------------------------------------
-// Output Method: stdout (DEFAULT)
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Output Method: stdout (DEFAULT)
+ *-------------------------------------------------------*/
 #ifndef UNITY_OUTPUT_CHAR
-//Default to using putchar, which is defined in stdio.h
+/* Default to using putchar, which is defined in stdio.h */
 #include <stdio.h>
-#define UNITY_OUTPUT_CHAR(a) putchar(a)
+#define UNITY_OUTPUT_CHAR(a) (void)putchar(a)
 #else
-//If defined as something else, make sure we declare it here so it's ready for use
-extern int UNITY_OUTPUT_CHAR(int);
+  /* If defined as something else, make sure we declare it here so it's ready for use */
+  #ifndef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION
+extern void UNITY_OUTPUT_CHAR(int);
+  #endif
+#endif
+
+#ifndef UNITY_OUTPUT_FLUSH
+/* Default to using fflush, which is defined in stdio.h */
+#include <stdio.h>
+#define UNITY_OUTPUT_FLUSH (void)fflush(stdout)
+#else
+  /* If defined as something else, make sure we declare it here so it's ready for use */
+  #ifndef UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION
+extern void UNITY_OUTPUT_FLUSH(void);
+  #endif
+#endif
+
+#ifndef UNITY_OUTPUT_FLUSH
+#define UNITY_FLUSH_CALL()
+#else
+#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH
 #endif
 
 #ifndef UNITY_PRINT_EOL
@@ -308,9 +327,9 @@ extern int UNITY_OUTPUT_CHAR(int);
 #define UNITY_OUTPUT_COMPLETE()
 #endif
 
-//-------------------------------------------------------
-// Footprint
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Footprint
+ *-------------------------------------------------------*/
 
 #ifndef UNITY_LINE_TYPE
 #define UNITY_LINE_TYPE _U_UINT
@@ -320,12 +339,12 @@ extern int UNITY_OUTPUT_CHAR(int);
 #define UNITY_COUNTER_TYPE _U_UINT
 #endif
 
-//-------------------------------------------------------
-// Language Features Available
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Language Features Available
+ *-------------------------------------------------------*/
 #if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA)
-#   ifdef __GNUC__ // includes clang
-#       if !(defined(__WIN32__) && defined(__clang__))
+#   ifdef __GNUC__ /* includes clang */
+#       if !(defined(__WIN32__) && defined(__clang__)) && !defined(__TMS470__)
 #           define UNITY_WEAK_ATTRIBUTE __attribute__((weak))
 #       endif
 #   endif
@@ -337,9 +356,9 @@ extern int UNITY_OUTPUT_CHAR(int);
 #endif
 
 
-//-------------------------------------------------------
-// Internal Structs Needed
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Internal Structs Needed
+ *-------------------------------------------------------*/
 
 typedef void (*UnityTestFunction)(void);
 
@@ -397,6 +416,7 @@ typedef enum _UNITY_FLOAT_TRAIT_T
     UNITY_FLOAT_IS_NAN,
     UNITY_FLOAT_IS_NOT_DET,
     UNITY_FLOAT_IS_DET,
+    UNITY_FLOAT_INVALID_TRAIT
 } UNITY_FLOAT_TRAIT_T;
 #endif
 
@@ -419,18 +439,18 @@ struct _Unity
 
 extern struct _Unity Unity;
 
-//-------------------------------------------------------
-// Test Suite Management
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Test Suite Management
+ *-------------------------------------------------------*/
 
 void UnityBegin(const char* filename);
 int  UnityEnd(void);
 void UnityConcludeTest(void);
 void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum);
 
-//-------------------------------------------------------
-// Details Support
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Details Support
+ *-------------------------------------------------------*/
 
 #ifdef UNITY_EXCLUDE_DETAILS
 #define UNITY_CLR_DETAILS()
@@ -450,9 +470,9 @@ void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int
 #endif
 #endif
 
-//-------------------------------------------------------
-// Test Output
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Test Output
+ *-------------------------------------------------------*/
 
 void UnityPrint(const char* string);
 void UnityPrintMask(const _U_UINT mask, const _U_UINT number);
@@ -465,13 +485,13 @@ void UnityPrintNumberHex(const _U_UINT number, const char nibbles);
 void UnityPrintFloat(const _UF number);
 #endif
 
-//-------------------------------------------------------
-// Test Assertion Fuctions
-//-------------------------------------------------------
-//  Use the macros below this section instead of calling
-//  these directly. The macros have a consistent naming
-//  convention and will pull in file and line information
-//  for you.
+/*-------------------------------------------------------
+ * Test Assertion Fuctions
+ *-------------------------------------------------------
+ *  Use the macros below this section instead of calling
+ *  these directly. The macros have a consistent naming
+ *  convention and will pull in file and line information
+ *  for you. */
 
 void UnityAssertEqualNumber(const _U_SINT expected,
                             const _U_SINT actual,
@@ -565,23 +585,23 @@ void UnityAssertDoubleSpecial(const _UD actual,
                               const UNITY_FLOAT_TRAIT_T style);
 #endif
 
-//-------------------------------------------------------
-// Error Strings We Might Need
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Error Strings We Might Need
+ *-------------------------------------------------------*/
 
 extern const char UnityStrErrFloat[];
 extern const char UnityStrErrDouble[];
 extern const char UnityStrErr64[];
 
-//-------------------------------------------------------
-// Test Running Macros
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Test Running Macros
+ *-------------------------------------------------------*/
 
 #define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0)
 
 #define TEST_ABORT() {longjmp(Unity.AbortFrame, 1);}
 
-//This tricky series of macros gives us an optional line argument to treat it as RUN_TEST(func, num=__LINE__)
+/* This tricky series of macros gives us an optional line argument to treat it as RUN_TEST(func, num=__LINE__) */
 #ifndef RUN_TEST
 #ifdef __STDC_VERSION__
 #if __STDC_VERSION__ >= 199901L
@@ -594,7 +614,7 @@ extern const char UnityStrErr64[];
 #endif
 #endif
 
-//If we can't do the tricky version, we'll just have to require them to always include the line number
+/* If we can't do the tricky version, we'll just have to require them to always include the line number */
 #ifndef RUN_TEST
 #ifdef CMOCK
 #define RUN_TEST(func, num) UnityDefaultTestRun(func, #func, num)
@@ -620,16 +640,25 @@ extern const char UnityStrErr64[];
 
 #define UNITY_UNUSED(x) (void)(sizeof(x))
 
-//-------------------------------------------------------
-// Basic Fail and Ignore
-//-------------------------------------------------------
+/*-----------------------------------------------
+ * Command Line Argument Support
+ *-----------------------------------------------*/
+
+#ifdef UNITY_USE_COMMAND_LINE_ARGS
+int UnityParseOptions(int argc, char** argv);
+int UnityTestMatches(void);
+#endif
+
+/*-------------------------------------------------------
+ * Basic Fail and Ignore
+ *-------------------------------------------------------*/
 
 #define UNITY_TEST_FAIL(line, message)   UnityFail(   (message), (UNITY_LINE_TYPE)(line))
 #define UNITY_TEST_IGNORE(line, message) UnityIgnore( (message), (UNITY_LINE_TYPE)(line))
 
-//-------------------------------------------------------
-// Test Asserts
-//-------------------------------------------------------
+/*-------------------------------------------------------
+ * Test Asserts
+ *-------------------------------------------------------*/
 
 #define UNITY_TEST_ASSERT(condition, line, message)                                              if (condition) {} else {UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), (message));}
 #define UNITY_TEST_ASSERT_NULL(pointer, line, message)                                           UNITY_TEST_ASSERT(((pointer) == NULL),  (UNITY_LINE_TYPE)(line), (message))
@@ -754,5 +783,5 @@ extern const char UnityStrErr64[];
 #define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message)                       UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET)
 #endif
 
-//End of UNITY_INTERNALS_H
+/* End of UNITY_INTERNALS_H */
 #endif