ceedling 0.31.1 → 1.0.1

data/vendor/unity/docs/UnityAssertionsReference.md

@@ -10,46 +10,46 @@ Upon boolean False, an assertion stops execution and reports the failure.
 and easily execute those assertions.
 - The structure of Unity allows you to easily separate test assertions from
 source code in, well, test code.
-- Unity's assertions:
-- Come in many, many flavors to handle different C types and assertion cases.
-- Use context to provide detailed and helpful failure messages.
-- Document types, expected values, and basic behavior in your source code for
+- Unity’s assertions:
+  - Come in many, many flavors to handle different C types and assertion cases.
+  - Use context to provide detailed and helpful failure messages.
+  - Document types, expected values, and basic behavior in your source code for
 free.
 
-### Unity Is Several Things But Mainly It's Assertions
+### Unity Is Several Things But Mainly It’s Assertions
 
 One way to think of Unity is simply as a rich collection of assertions you can
 use to establish whether your source code behaves the way you think it does.
 Unity provides a framework to easily organize and execute those assertions in
 test code separate from your source code.
 
-### What's an Assertion?
+### What’s an Assertion?
 
 At their core, assertions are an establishment of truth - boolean truth. Was this
 thing equal to that thing? Does that code doohickey have such-and-such property
-or not? You get the idea. Assertions are executable code (to appreciate the big
-picture on this read up on the difference between
-[link:Dynamic Verification and Static Analysis]). A failing assertion stops
-execution and reports an error through some appropriate I/O channel (e.g.
-stdout, GUI, file, blinky light).
+or not? You get the idea. Assertions are executable code. Static analysis is a 
+valuable approach to improving code quality, but it is not executing your code
+in the way an assertion can. A failing assertion stops execution and reports an 
+error through some appropriate I/O channel (e.g. stdout, GUI, output file, 
+blinky light).
 
 Fundamentally, for dynamic verification all you need is a single assertion
-mechanism. In fact, that's what the [assert() macro][] in C's standard library
+mechanism. In fact, that’s what the [assert() macro][] in C’s standard library
 is for. So why not just use it? Well, we can do far better in the reporting
-department. C's `assert()` is pretty dumb as-is and is particularly poor for
+department. C’s `assert()` is pretty dumb as-is and is particularly poor for
 handling common data types like arrays, structs, etc. And, without some other
-support, it's far too tempting to litter source code with C's `assert()`'s. It's
+support, it’s far too tempting to litter source code with C’s `assert()`’s. It’s
 generally much cleaner, manageable, and more useful to separate test and source
 code in the way Unity facilitates.
 
-### Unity's Assertions: Helpful Messages _and_ Free Source Code Documentation
+### Unity’s Assertions: Helpful Messages _and_ Free Source Code Documentation
 
 Asserting a simple truth condition is valuable, but using the context of the
-assertion is even more valuable. For instance, if you know you're comparing bit
+assertion is even more valuable. For instance, if you know you’re comparing bit
 flags and not just integers, then why not use that context to give explicit,
 readable, bit-level feedback when an assertion fails?
 
-That's what Unity's collection of assertions do - capture context to give you
+That’s what Unity’s collection of assertions do - capture context to give you
 helpful, meaningful assertion failure messages. In fact, the assertions
 themselves also serve as executable documentation about types and values in your
 source code. So long as your tests remain current with your source and all those
@@ -73,12 +73,12 @@ a simple null check).
 - `Actual` is the value being tested and unlike the other parameters in an
   assertion construction is the only parameter present in all assertion variants.
 - `Modifiers` are masks, ranges, bit flag specifiers, floating point deltas.
-- `Expected` is your expected value (duh) to compare to an `actual` value; it's
+- `Expected` is your expected value (duh) to compare to an `actual` value; it’s
   marked as an optional parameter because some assertions only need a single
   `actual` parameter (e.g. null check).
 - `Size/count` refers to string lengths, number of array elements, etc.
 
-Many of Unity's assertions are clear duplications in that the same data type
+Many of Unity’s assertions are clear duplications in that the same data type
 is handled by several assertions. The differences among these are in how failure
 messages are presented. For instance, a `_HEX` variant of an assertion prints
 the expected and actual values of that assertion formatted as hexadecimal.
@@ -99,7 +99,7 @@ _Example:_
 TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} )
 ```
 
-becomes messageified like thus...
+becomes messageified like thus…
 
 ```c
 TEST_ASSERT_X_MESSAGE( {modifiers}, {expected}, actual, {size/count}, message )
@@ -108,7 +108,7 @@ TEST_ASSERT_X_MESSAGE( {modifiers}, {expected}, actual, {size/count}, message )
 Notes:
 
 - The `_MESSAGE` variants intentionally do not support `printf` style formatting
-  since many embedded projects don't support or avoid `printf` for various reasons.
+  since many embedded projects don’t support or avoid `printf` for various reasons.
   It is possible to use `sprintf` before the assertion to assemble a complex fail
   message, if necessary.
 - If you want to output a counter value within an assertion fail message (e.g. from
@@ -119,7 +119,7 @@ Notes:
 
 Unity provides a collection of assertions for arrays containing a variety of
 types. These are documented in the Array section below. These are almost on par
-with the `_MESSAGE`variants of Unity's Asserts in that for pretty much any Unity
+with the `_MESSAGE`variants of Unity’s Asserts in that for pretty much any Unity
 type assertion you can tack on `_ARRAY` and run assertions on an entire block of
 memory.
 
@@ -144,7 +144,7 @@ Notes:
 Unity provides a collection of assertions for arrays containing a variety of
 types which can be compared to a single value as well. These are documented in
 the Each Equal section below. these are almost on par with the `_MESSAGE`
-variants of Unity's Asserts in that for pretty much any Unity type assertion you
+variants of Unity’s Asserts in that for pretty much any Unity type assertion you
 can inject `_EACH_EQUAL` and run assertions on an entire block of memory.
 
 ```c
@@ -203,7 +203,7 @@ code then verifies as a final step.
 #### `TEST_PASS_MESSAGE("message")`
 
 This will abort the remainder of the test, but count the test as a pass. Under
-normal circumstances, it is not necessary to include this macro in your tests...
+normal circumstances, it is not necessary to include this macro in your tests…
 a lack of failure will automatically be counted as a `PASS`. It is occasionally
 useful for tests with `#ifdef`s and such.
 
@@ -392,7 +392,7 @@ Asserts that the pointers point to the same memory location.
 
 #### `TEST_ASSERT_EQUAL_STRING (expected, actual)`
 
-Asserts that the null terminated (`'\0'`)strings are identical. If strings are
+Asserts that the null terminated (`’\0’`)strings are identical. If strings are
 of different lengths or any portion of the strings before their terminators
 differ, the assertion fails. Two NULL strings (i.e. zero length) are considered
 equivalent.
@@ -555,21 +555,58 @@ Asserts that the `actual` value is within +/- `delta` of the `expected` value.
 The nature of floating point representation is such that exact evaluations of
 equality are not guaranteed.
 
+#### `TEST_ASSERT_FLOAT_NOT_WITHIN (delta, expected, actual)`
+
+Asserts that the `actual` value is NOT within +/- `delta` of the `expected` value.
+
 #### `TEST_ASSERT_EQUAL_FLOAT (expected, actual)`
 
-Asserts that the ?actual?value is "close enough to be considered equal" to the
+Asserts that the `actual` value is “close enough to be considered equal” to the
 `expected` value. If you are curious about the details, refer to the Advanced
 Asserting section for more details on this. Omitting a user-specified delta in a
 floating point assertion is both a shorthand convenience and a requirement of
 code generation conventions for CMock.
 
+#### `TEST_ASSERT_NOT_EQUAL_FLOAT (expected, actual)`
+
+Asserts that the `actual` value is NOT “close enough to be considered equal” to the
+`expected` value.
+
+#### `TEST_ASSERT_FLOAT_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+See Array assertion section for details. Note that individual array element
+uses user-provided delta plus default comparison delta for checking
+and is based on `TEST_ASSERT_FLOAT_WITHIN` comparison.
+
 #### `TEST_ASSERT_EQUAL_FLOAT_ARRAY (expected, actual, num_elements)`
 
 See Array assertion section for details. Note that individual array element
-float comparisons are executed using T?EST_ASSERT_EQUAL_FLOAT?.That is, user
+float comparisons are executed using `TEST_ASSERT_EQUAL_FLOAT`. That is, user
 specified delta comparison values requires a custom-implemented floating point
 array assertion.
 
+#### `TEST_ASSERT_LESS_THAN_FLOAT (threshold, actual)`
+
+Asserts that the `actual` parameter is less than `threshold` (exclusive).
+For example, if the threshold value is 1.0f, the assertion will fail if it is
+greater than 1.0f.
+
+#### `TEST_ASSERT_GREATER_THAN_FLOAT (threshold, actual)`
+
+Asserts that the `actual` parameter is greater than `threshold` (exclusive).
+For example, if the threshold value is 1.0f, the assertion will fail if it is
+less than 1.0f.
+
+#### `TEST_ASSERT_LESS_OR_EQUAL_FLOAT (threshold, actual)`
+
+Asserts that the `actual` parameter is less than or equal to `threshold`.
+The rules for equality are the same as for `TEST_ASSERT_EQUAL_FLOAT`.
+
+#### `TEST_ASSERT_GREATER_OR_EQUAL_FLOAT (threshold, actual)`
+
+Asserts that the `actual` parameter is greater than `threshold`.
+The rules for equality are the same as for `TEST_ASSERT_EQUAL_FLOAT`.
+
 #### `TEST_ASSERT_FLOAT_IS_INF (actual)`
 
 Asserts that `actual` parameter is equivalent to positive infinity floating
@@ -586,7 +623,7 @@ Asserts that `actual` parameter is a Not A Number floating point representation.
 
 #### `TEST_ASSERT_FLOAT_IS_DETERMINATE (actual)`
 
-Asserts that ?actual?parameter is a floating point representation usable for
+Asserts that `actual` parameter is a floating point representation usable for
 mathematical operations. That is, the `actual` parameter is neither positive
 infinity nor negative infinity nor Not A Number floating point representations.
 
@@ -619,21 +656,58 @@ Asserts that the `actual` value is within +/- `delta` of the `expected` value.
 The nature of floating point representation is such that exact evaluations of
 equality are not guaranteed.
 
+#### `TEST_ASSERT_DOUBLE_NOT_WITHIN (delta, expected, actual)`
+
+Asserts that the `actual` value is NOT within +/- `delta` of the `expected` value.
+
 #### `TEST_ASSERT_EQUAL_DOUBLE (expected, actual)`
 
-Asserts that the `actual` value is "close enough to be considered equal" to the
+Asserts that the `actual` value is “close enough to be considered equal” to the
 `expected` value. If you are curious about the details, refer to the Advanced
 Asserting section for more details. Omitting a user-specified delta in a
 floating point assertion is both a shorthand convenience and a requirement of
 code generation conventions for CMock.
 
+#### `TEST_ASSERT_NOT_EQUAL_DOUBLE (expected, actual)`
+
+Asserts that the `actual` value is NOT “close enough to be considered equal” to the
+`expected` value.
+
+#### `TEST_ASSERT_DOUBLE_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+See Array assertion section for details. Note that individual array element
+uses user-provided delta plus default comparison delta  for checking
+and is based on `TEST_ASSERT_DOUBLE_WITHIN` comparison.
+
 #### `TEST_ASSERT_EQUAL_DOUBLE_ARRAY (expected, actual, num_elements)`
 
 See Array assertion section for details. Note that individual array element
-double comparisons are executed using `TEST_ASSERT_EQUAL_DOUBLE`.That is, user
+double comparisons are executed using `TEST_ASSERT_EQUAL_DOUBLE`. That is, user
 specified delta comparison values requires a custom implemented double array
 assertion.
 
+#### `TEST_ASSERT_LESS_THAN_DOUBLE (threshold, actual)`
+
+Asserts that the `actual` parameter is less than `threshold` (exclusive).
+For example, if the threshold value is 1.0, the assertion will fail if it is
+greater than 1.0.
+
+#### `TEST_ASSERT_LESS_OR_EQUAL_DOUBLE (threshold, actual)`
+
+Asserts that the `actual` parameter is less than or equal to `threshold`.
+The rules for equality are the same as for `TEST_ASSERT_EQUAL_DOUBLE`.
+
+#### `TEST_ASSERT_GREATER_THAN_DOUBLE (threshold, actual)`
+
+Asserts that the `actual` parameter is greater than `threshold` (exclusive).
+For example, if the threshold value is 1.0, the assertion will fail if it is
+less than 1.0.
+
+#### `TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE (threshold, actual)`
+
+Asserts that the `actual` parameter is greater than or equal to `threshold`.
+The rules for equality are the same as for `TEST_ASSERT_EQUAL_DOUBLE`.
+
 #### `TEST_ASSERT_DOUBLE_IS_INF (actual)`
 
 Asserts that `actual` parameter is equivalent to positive infinity floating
@@ -651,7 +725,7 @@ Asserts that `actual` parameter is a Not A Number floating point representation.
 #### `TEST_ASSERT_DOUBLE_IS_DETERMINATE (actual)`
 
 Asserts that `actual` parameter is a floating point representation usable for
-mathematical operations. That is, the ?actual?parameter is neither positive
+mathematical operations. That is, the `actual` parameter is neither positive
 infinity nor negative infinity nor Not A Number floating point representations.
 
 #### `TEST_ASSERT_DOUBLE_IS_NOT_INF (actual)`
@@ -679,7 +753,7 @@ Not A Number floating point representations.
 
 This section helps you understand how to deal with some of the trickier
 assertion situations you may run into. It will give you a glimpse into some of
-the under-the-hood details of Unity's assertion mechanisms. If you're one of
+the under-the-hood details of Unity’s assertion mechanisms. If you’re one of
 those people who likes to know what is going on in the background, read on. If
 not, feel free to ignore the rest of this document until you need it.
 
@@ -694,9 +768,9 @@ mathematical operations might result in a representation of 8 x 2-2
 that also evaluates to a value of 2. At some point repeated operations cause
 equality checks to fail.
 
-So Unity doesn't do direct floating point comparisons for equality. Instead, it
-checks if two floating point values are "really close." If you leave Unity
-running with defaults, "really close" means "within a significant bit or two."
+So Unity doesn’t do direct floating point comparisons for equality. Instead, it
+checks if two floating point values are “really close.” If you leave Unity
+running with defaults, “really close” means “within a significant bit or two.”
 Under the hood, `TEST_ASSERT_EQUAL_FLOAT` is really `TEST_ASSERT_FLOAT_WITHIN`
 with the `delta` parameter calculated on the fly. For single precision, delta is
 the expected value multiplied by 0.00001, producing a very small proportional
@@ -705,28 +779,27 @@ range around the expected value.
 If you are expecting a value of 20,000.0 the delta is calculated to be 0.2. So
 any value between 19,999.8 and 20,000.2 will satisfy the equality check. This
 works out to be roughly a single bit of range for a single-precision number, and
-that's just about as tight a tolerance as you can reasonably get from a floating
+that’s just about as tight a tolerance as you can reasonably get from a floating
 point value.
 
-So what happens when it's zero? Zero - even more than other floating point
-values - can be represented many different ways. It doesn't matter if you have
-0 x 20 or 0 x 263.It's still zero, right? Luckily, if you
-subtract these values from each other, they will always produce a difference of
-zero, which will still fall between 0 plus or minus a delta of 0. So it still
-works!
+So what happens when it’s zero? Zero - even more than other floating point
+values - can be represented many different ways. It doesn’t matter if you have
+0x20 or 0x263. It’s still zero, right? Luckily, if you subtract these 
+values from each other, they will always produce a difference of zero, which 
+will still fall between 0 plus or minus a delta of 0. So it still works!
 
 Double precision floating point numbers use a much smaller multiplier, again
 approximating a single bit of error.
 
-If you don't like these ranges and you want to make your floating point equality
+If you don’t like these ranges and you want to make your floating point equality
 assertions less strict, you can change these multipliers to whatever you like by
 defining UNITY_FLOAT_PRECISION and UNITY_DOUBLE_PRECISION. See Unity
 documentation for more.
 
 ### How do we deal with targets with non-standard int sizes?
 
-It's "fun" that C is a standard where something as fundamental as an integer
-varies by target. According to the C standard, an `int` is to be the target's
+It’s “fun” that C is a standard where something as fundamental as an integer
+varies by target. According to the C standard, an `int` is to be the target’s
 natural register size, and it should be at least 16-bits and a multiple of a
 byte. It also guarantees an order of sizes:
 
@@ -740,7 +813,7 @@ and this remains perfectly standard C.
 
 To make things even more interesting, there are compilers and targets out there
 that have a hard choice to make. What if their natural register size is 10-bits
-or 12-bits? Clearly they can't fulfill _both_ the requirement to be at least
+or 12-bits? Clearly they can’t fulfill _both_ the requirement to be at least
 16-bits AND the requirement to match the natural register size. In these
 situations, they often choose the natural register size, leaving us with
 something like this:
@@ -749,24 +822,24 @@ something like this:
 char (8 bit) <= short (12 bit) <= int (12 bit) <= long (16 bit)
 ```
 
-Um... yikes. It's obviously breaking a rule or two... but they had to break SOME
+Um… yikes. It’s obviously breaking a rule or two… but they had to break SOME
 rules, so they made a choice.
 
 When the C99 standard rolled around, it introduced alternate standard-size types.
 It also introduced macros for pulling in MIN/MAX values for your integer types.
-It's glorious! Unfortunately, many embedded compilers can't be relied upon to
+It’s glorious! Unfortunately, many embedded compilers can’t be relied upon to
 use the C99 types (Sometimes because they have weird register sizes as described
-above. Sometimes because they don't feel like it?).
+above. Sometimes because they don’t feel like it?).
 
 A goal of Unity from the beginning was to support every combination of
-microcontroller or microprocessor and C compiler. Over time, we've gotten really
+microcontroller or microprocessor and C compiler. Over time, we’ve gotten really
 close to this. There are a few tricks that you should be aware of, though, if
-you're going to do this effectively on some of these more idiosyncratic targets.
+you’re going to do this effectively on some of these more idiosyncratic targets.
 
-First, when setting up Unity for a new target, you're going to want to pay
+First, when setting up Unity for a new target, you’re going to want to pay
 special attention to the macros for automatically detecting types
 (where available) or manually configuring them yourself. You can get information
-on both of these in Unity's documentation.
+on both of these in Unity’s documentation.
 
 What about the times where you suddenly need to deal with something odd, like a
 24-bit `int`? The simplest solution is to use the next size up. If you have a
@@ -774,14 +847,14 @@ What about the times where you suddenly need to deal with something odd, like a
 `int`, configure Unity to use 16 bits. There are two ways this is going to
 affect you:
 
-1. When Unity displays errors for you, it's going to pad the upper unused bits
-with zeros.
-2. You're going to have to be careful of assertions that perform signed
-operations, particularly `TEST_ASSERT_INT_WITHIN`.Such assertions might wrap
-your `int` in the wrong place, and you could experience false failures. You can
-always back down to a simple `TEST_ASSERT` and do the operations yourself.
+1. When Unity displays errors for you, it’s going to pad the upper unused bits
+   with zeros.
+2. You’re going to have to be careful of assertions that perform signed
+   operations, particularly `TEST_ASSERT_INT_WITHIN`. Such assertions might wrap
+   your `int` in the wrong place, and you could experience false failures. You can
+   always back down to a simple `TEST_ASSERT` and do the operations yourself.
 
 *Find The Latest of This And More at [ThrowTheSwitch.org][]*
 
-[assert() macro]: http://en.wikipedia.org/en/wiki/Assert.h
+[assert() macro]: http://en.wikipedia.org/wiki/Assert.h
 [ThrowTheSwitch.org]: https://throwtheswitch.org

data/vendor/unity/docs/UnityChangeLog.md

@@ -0,0 +1,110 @@
+# Unity Test - Change Log
+
+## A Note
+
+This document captures significant features and fixes to the Unity project core source files 
+and scripts. More detail can be found in the history on Github. 
+
+This project is now tracking changes in more detail. Previous releases get less detailed as
+we move back in histroy. 
+
+Prior to 2012, the project was hosted on SourceForge.net
+Prior to 2008, the project was an internal project and not released to the public.
+
+## Log
+
+### Unity 2.6.1 (Jan 2025)
+
+New Features:
+  
+  - Add `-n` comand line option as strict matcher again
+
+Significant Bugfixes:
+
+  - Protect against problems when mis-matched command line options selected
+
+Other:
+
+  - Protect against Conversion warnings in gcc
+  - Remove Redundant line-casts
+  - Make more internal functions static
+
+### Unity 2.6.0 (Mar 2024)
+
+New Features:
+
+  - Fill out missing variations of arrays, within, etc. 
+  - Add `TEST_PRINTF()`
+  - Add `TEST_MATRIX()` and `TEST_RANGE()` options and documentation
+  - Add support for searching `TEST_SOURCE_FILE()` for determining test dependencies
+  - Add Unity BDD plugin
+  - Add `UNITY_INCLUDE_EXEC_TIME` option to report test times
+  - Allow user to override test abort underlying mechanism
+  - Add `NOT_EQUAL*` and `NOT_WITHIN*` checks for floats and doubles 
+
+Significant Bugfixes:
+
+  - More portable validation of NaN and Infinity. Added `UNITY_IS_NAN` and `UNITY_IS_INF` options
+  - Add `UNITY_PROGMEM` configuration option
+  - Fix overflow detection of hex values when using arrays
+  - Fix scripts broken by Ruby standard changes
+
+Other:
+
+  - Avoid pointer comparison when one is null to avoid compiler warnings
+  - Significant improvements to documentation
+  - Updates to match latest Ruby style specification
+  - Meson, CMake, PlatformIO builds
+
+### Unity 2.5.2 (January 2021)
+
+  - improvements to RUN_TEST macro and generated RUN_TEST
+  - Fix `UNITY_TEST_ASSERT_BIT(S)_HIGH`
+  - Cleaner handling of details tracking by CMock
+
+### Unity 2.5.1 (May 2020)
+
+Mostly a bugfix and stability release.
+Bonus Features:
+
+  - Optional TEST_PRINTF macro
+  - Improve self-testing procedures.
+
+### Unity 2.5.0 (October 2019)
+
+It's been a LONG time since the last release of Unity. Finally, here it is!
+There are too many updates to list here, so some highlights:
+
+  - more standards compliant (without giving up on supporting ALL compilers, no matter how quirky)
+  - many more specialized assertions for better test feedback
+  - more examples for integrating into your world
+  - many many bugfixes and tweaks
+
+### Unity 2.4.3 (November 2017)
+
+  - Allow suiteSetUp() and suiteTearDown() to be povided as normal C functions
+  - Fix & Expand Greater Than / Less Than assertions for integers
+  - Built-in option to colorize test results
+  - Documentation updates
+
+### Unity 2.4.2 (September 2017)
+
+  - Fixed bug in UNTY_TEST_ASSERT_EACH_EQUAL_*
+  - Added TEST_ASSERT_GREATER_THAN and TEST_ASSERT_LESS_THAN
+  - Updated Module Generator to stop changing names when no style given
+  - Cleanup to custom float printing for accuracy
+  - Cleanup incorrect line numbers are partial name matching
+  - Reduce warnings from using popular function names as variable names
+
+### Unity 2.4.1 (April 2017)
+
+  - test runner generator can inject defines as well as headers
+  - added a built-in floating point print routine instead of relying on printf
+  - updated to new coding and naming standard
+  - updated documentation to be markdown instead of pdf
+  - fixed many many little bugs, most of which were supplied by the community (you people are awesome!)
+  - coding standard actually enforced in CI
+
+### Unity 2.4.0 (October, 2016)
+
+  - port from SourceForge and numerous bugfixes