RubyGems - ceedling - Versions diffs - 0.28.1 → 0.28.2 - Mend

ceedling 0.28.1 → 0.28.2

Files changed (467) hide show

data/vendor/cmock/vendor/unity/auto/unity_to_junit.py DELETED

@@ -1,146 +0,0 @@
-import sys
-import os
-from glob import glob
-from pyparsing import *
-from junit_xml import TestSuite, TestCase
-class UnityTestSummary:
-    def __init__(self):
-        self.report = ''
-        self.total_tests = 0
-        self.failures = 0
-        self.ignored = 0
-        self.targets = 0
-        self.root = None
-        self.test_suites = dict()
-    def run(self):
-        # Clean up result file names
-        results = []
-        for target in self.targets:
-            results.append(target.replace('\\', '/'))
-        # Dig through each result file, looking for details on pass/fail:
-        for result_file in results:
-            lines = list(map(lambda line: line.rstrip(), open(result_file, "r").read().split('\n')))
-            if len(lines) == 0:
-                raise Exception("Empty test result file: %s" % result_file)
-            # define an expression for your file reference
-            entry_one = Combine(
-                oneOf(list(alphas)) + ':/' +
-                Word(alphanums + '_-./'))
-            entry_two = Word(printables + ' ', excludeChars=':')
-            entry = entry_one | entry_two
-            delimiter = Literal(':').suppress()
-            tc_result_line = Group(entry.setResultsName('tc_file_name') + delimiter + entry.setResultsName(
-                'tc_line_nr') + delimiter + entry.setResultsName('tc_name') + delimiter + entry.setResultsName(
-                'tc_status') + Optional(
-                delimiter + entry.setResultsName('tc_msg'))).setResultsName("tc_line")
-            eol = LineEnd().suppress()
-            sol = LineStart().suppress()
-            blank_line = sol + eol
-            tc_summary_line = Group(Word(nums).setResultsName("num_of_tests") + "Tests" + Word(nums).setResultsName(
-                "num_of_fail") + "Failures" + Word(nums).setResultsName("num_of_ignore") + "Ignored").setResultsName(
-                "tc_summary")
-            tc_end_line = Or(Literal("FAIL"), Literal('Ok')).setResultsName("tc_result")
-            # run it and see...
-            pp1 = tc_result_line | Optional(tc_summary_line | tc_end_line)
-            pp1.ignore(blank_line | OneOrMore("-"))
-            result = list()
-            for l in lines:
-                result.append((pp1.parseString(l)).asDict())
-            # delete empty results
-            result = filter(None, result)
-            tc_list = list()
-            for r in result:
-                if 'tc_line' in r:
-                    tmp_tc_line = r['tc_line']
-                    # get only the file name which will be used as the classname
-                    file_name = tmp_tc_line['tc_file_name'].split('\\').pop().split('/').pop().rsplit('.', 1)[0]
-                    tmp_tc = TestCase(name=tmp_tc_line['tc_name'], classname=file_name)
-                    if 'tc_status' in tmp_tc_line:
-                        if str(tmp_tc_line['tc_status']) == 'IGNORE':
-                            if 'tc_msg' in tmp_tc_line:
-                                tmp_tc.add_skipped_info(message=tmp_tc_line['tc_msg'],
-                                                        output=r'[File]={0}, [Line]={1}'.format(
-                                                            tmp_tc_line['tc_file_name'], tmp_tc_line['tc_line_nr']))
-                            else:
-                                tmp_tc.add_skipped_info(message=" ")
-                        elif str(tmp_tc_line['tc_status']) == 'FAIL':
-                            if 'tc_msg' in tmp_tc_line:
-                                tmp_tc.add_failure_info(message=tmp_tc_line['tc_msg'],
-                                                        output=r'[File]={0}, [Line]={1}'.format(
-                                                            tmp_tc_line['tc_file_name'], tmp_tc_line['tc_line_nr']))
-                            else:
-                                tmp_tc.add_failure_info(message=" ")
-                    tc_list.append((str(result_file), tmp_tc))
-            for k, v in tc_list:
-                try:
-                    self.test_suites[k].append(v)
-                except KeyError:
-                    self.test_suites[k] = [v]
-        ts = []
-        for suite_name in self.test_suites:
-            ts.append(TestSuite(suite_name, self.test_suites[suite_name]))
-        with open('result.xml', 'w') as f:
-            TestSuite.to_file(f, ts, prettyprint='True', encoding='utf-8')
-        return self.report
-    def set_targets(self, target_array):
-        self.targets = target_array
-    def set_root_path(self, path):
-        self.root = path
-    @staticmethod
-    def usage(err_msg=None):
-        print("\nERROR: ")
-        if err_msg:
-            print(err_msg)
-        print("\nUsage: unity_test_summary.py result_file_directory/ root_path/")
-        print("     result_file_directory - The location of your results files.")
-        print("                             Defaults to current directory if not specified.")
-        print("                             Should end in / if specified.")
-        print("     root_path - Helpful for producing more verbose output if using relative paths.")
-        sys.exit(1)
-if __name__ == '__main__':
-    uts = UnityTestSummary()
-    try:
-        # look in the specified or current directory for result files
-        if len(sys.argv) > 1:
-            targets_dir = sys.argv[1]
-        else:
-            targets_dir = './'
-        targets = list(map(lambda x: x.replace('\\', '/'), glob(targets_dir + '*.test*')))
-        if len(targets) == 0:
-            raise Exception("No *.testpass or *.testfail files found in '%s'" % targets_dir)
-        uts.set_targets(targets)
-        # set the root path
-        if len(sys.argv) > 2:
-            root_path = sys.argv[2]
-        else:
-            root_path = os.path.split(__file__)[0]
-        uts.set_root_path(root_path)
-        # run the summarizer
-        print(uts.run())
-    except Exception as e:
-        UnityTestSummary.usage(e)

data/vendor/cmock/vendor/unity/docs/ThrowTheSwitchCodingStandard.md DELETED

@@ -1,207 +0,0 @@
-# ThrowTheSwitch.org Coding Standard
-Hi. Welcome to the coding standard for ThrowTheSwitch.org. For the most part,
-we try to follow these standards to unify our contributors' code into a cohesive
-unit (puns intended). You might find places where these standards aren't
-followed. We're not perfect. Please be polite where you notice these discrepancies
-and we'll try to be polite when we notice yours.
-;)
-## Why Have A Coding Standard?
-Being consistent makes code easier to understand. We've made an attempt to keep
-our standard simple because we also believe that we can only expect someone to
-follow something that is understandable. Please do your best.
-## Our Philosophy
-Before we get into details on syntax, let's take a moment to talk about our
-vision for these tools. We're C developers and embedded software developers.
-These tools are great to test any C code, but catering to embedded software has
-made us more tolerant of compiler quirks. There are a LOT of quirky compilers
-out there. By quirky I mean "doesn't follow standards because they feel like
-they have a license to do as they wish."
-Our philosophy is "support every compiler we can". Most often, this means that
-we aim for writing C code that is standards compliant (often C89... that seems
-to be a sweet spot that is almost always compatible). But it also means these
-tools are tolerant of things that aren't common. Some that aren't even
-compliant. There are configuration options to override the size of standard
-types. There are configuration options to force Unity to not use certain
-standard library functions. A lot of Unity is configurable and we have worked
-hard to make it not TOO ugly in the process.
-Similarly, our tools that parse C do their best. They aren't full C parsers
-(yet) and, even if they were, they would still have to accept non-standard
-additions like gcc extensions or specifying `@0x1000` to force a variable to
-compile to a particular location. It's just what we do, because we like
-everything to Just Work™.
-Speaking of having things Just Work™, that's our second philosophy. By that, we
-mean that we do our best to have EVERY configuration option have a logical
-default. We believe that if you're working with a simple compiler and target,
-you shouldn't need to configure very much... we try to make the tools guess as
-much as they can, but give the user the power to override it when it's wrong.
-## Naming Things
-Let's talk about naming things. Programming is all about naming things. We name
-files, functions, variables, and so much more. While we're not always going to
-find the best name for something, we actually put quite a bit of effort into
-finding *What Something WANTS to be Called*™.
-When naming things, we more or less follow this hierarchy, the first being the
-most important to us (but we do all four whenever possible):
-1. Readable
-2. Descriptive
-3. Consistent
-4. Memorable
-#### Readable
-We want to read our code. This means we like names and flow that are more
-naturally read. We try to avoid double negatives. We try to avoid cryptic
-abbreviations (sticking to ones we feel are common).
-#### Descriptive
-We like descriptive names for things, especially functions and variables.
-Finding the right name for something is an important endeavor. You might notice
-from poking around our code that this often results in names that are a little
-longer than the average. Guilty. We're okay with a tiny bit more typing if it
-means our code is easier to understand.
-There are two exceptions to this rule that we also stick to as religiously as
-possible:
-First, while we realize hungarian notation (and similar systems for encoding
-type information into variable names) is providing a more descriptive name, we
-feel that (for the average developer) it takes away from readability and
-therefore is to be avoided.
-Second, loop counters and other local throw-away variables often have a purpose
-which is obvious. There's no need, therefore, to get carried away with complex
-naming. We find i, j, and k are better loop counters than loopCounterVar or
-whatnot. We only break this rule when we see that more description could improve
-understanding of an algorithm.
-#### Consistent
-We like consistency, but we're not really obsessed with it. We try to name our
-configuration macros in a consistent fashion... you'll notice a repeated use of
-UNITY_EXCLUDE_BLAH or UNITY_USES_BLAH macros. This helps users avoid having to
-remember each macro's details.
-#### Memorable
-Where ever it doesn't violate the above principles, we try to apply memorable
-names. Sometimes this means using something that is simply descriptive, but
-often we strive for descriptive AND unique... we like quirky names that stand
-out in our memory and are easier to search for. Take a look through the file
-names in Ceedling and you'll get a good idea of what we are talking about here.
-Why use preprocess when you can use preprocessinator? Or what better describes a
-module in charge of invoking tasks during releases than release_invoker? Don't
-get carried away. The names are still descriptive and fulfill the above
-requirements, but they don't feel stale.
-## C and C++ Details
-We don't really want to add to the style battles out there. Tabs or spaces?
-How many spaces? Where do the braces go? These are age-old questions that will
-never be answered... or at least not answered in a way that will make everyone
-happy.
-We've decided on our own style preferences. If you'd like to contribute to these
-projects (and we hope that you do), then we ask if you do your best to follow
-the same. It will only hurt a little. We promise.
-#### Whitespace
-Our C-style is to use spaces and to use 4 of them per indent level. It's a nice
-power-of-2 number that looks decent on a wide screen. We have no more reason
-than that. We break that rule when we have lines that wrap (macros or function
-arguments or whatnot). When that happens, we like to indent further to line
-things up in nice tidy columns.
-```C
-    if (stuff_happened)
-    {
-        do_something();
-    }
-```
-#### Case
-- Files - all lower case with underscores.
-- Variables - all lower case with underscores
-- Macros - all caps with underscores.
-- Typedefs - all caps with underscores. (also ends with _T).
-- Functions - camel cased. Usually named ModuleName_FuncName
-- Constants and Globals - camel cased.
-#### Braces
-The left brace is on the next line after the declaration. The right brace is
-directly below that. Everything in between in indented one level. If you're
-catching an error and you have a one-line, go ahead and to it on the same line.
-```C
-    while (blah)
-    {
-        //Like so. Even if only one line, we use braces.
-    }
-```
-#### Comments
-Do you know what we hate? Old-school C block comments. BUT, we're using them
-anyway. As we mentioned, our goal is to support every compiler we can,
-especially embedded compilers. There are STILL C compilers out there that only
-support old-school block comments. So that is what we're using. We apologize. We
-think they are ugly too.
-## Ruby Details
-Is there really such thing as a Ruby coding standard? Ruby is such a free form
-language, it seems almost sacrilegious to suggest that people should comply to
-one method! We'll keep it really brief!
-#### Whitespace
-Our Ruby style is to use spaces and to use 2 of them per indent level. It's a
-nice power-of-2 number that really grooves with Ruby's compact style. We have no
-more reason than that. We break that rule when we have lines that wrap. When
-that happens, we like to indent further to line things up in nice tidy columns.
-#### Case
-- Files - all lower case with underscores.
-- Variables - all lower case with underscores
-- Classes, Modules, etc - Camel cased.
-- Functions - all lower case with underscores
-- Constants - all upper case with underscores
-## Documentation
-Egad. Really? We use markdown and we like pdf files because they can be made to
-look nice while still being portable. Good enough?
-*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)*

data/vendor/cmock/vendor/unity/docs/UnityAssertionsCheatSheetSuitableforPrintingandPossiblyFraming.pdf DELETED

Binary file

data/vendor/cmock/vendor/unity/docs/UnityAssertionsReference.md DELETED

@@ -1,716 +0,0 @@
-# Unity Assertions Reference
-## Background and Overview
-### Super Condensed Version
-- An assertion establishes truth (i.e. boolean True) for a single condition.
-Upon boolean False, an assertion stops execution and reports the failure.
-- Unity is mainly a rich collection of assertions and the support to gather up
-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
-free.
-### 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?
-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).
-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](http://en.wikipedia.org/en/wiki/Assert.h)
-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
-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
-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
-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
-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
-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
-tests pass, you have a detailed, up-to-date view of the intent and mechanisms in
-your source code. And due to a wondrous mystery, well-tested code usually tends
-to be well designed code.
-## Assertion Conventions and Configurations
-### Naming and Parameter Conventions
-The convention of assertion parameters generally follows this order:
-    TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} )
-The very simplest assertion possible uses only a single "actual" parameter (e.g.
-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
-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 apparent 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.
-#### TEST_ASSERT_X_MESSAGE Variants
-_All_ assertions are complemented with a variant that includes a simple string
-message as a final parameter. The string you specify is appended to an assertion
-failure message in Unity output.
-For brevity, the assertion variants with a message parameter are not listed
-below. Just tack on `_MESSAGE` as the final component to any assertion name in
-the reference list below and add a string as the final parameter.
-_Example:_
-    TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} )
-becomes messageified like thus...
-    TEST_ASSERT_X_MESSAGE( {modifiers}, {expected}, actual, {size/count}, message )
-#### TEST_ASSERT_X_ARRAY Variants
-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
-type assertion you can tack on `_ARRAY` and run assertions on an entire block of
-memory.
-    TEST_ASSERT_EQUAL_TYPEX_ARRAY( expected, actual, {size/count} )
-"Expected" is an array itself.
-"Size/count" is one or two parameters necessary to establish the number of array
-elements and perhaps the length of elements within the array.
-Notes:
-- The `_MESSAGE` variant convention still applies here to array assertions. The
-`_MESSAGE` variants of the `_ARRAY` assertions have names ending with
-`_ARRAY_MESSAGE`.
-- Assertions for handling arrays of floating point values are grouped with float
-and double assertions (see immediately following section).
-### TEST_ASSERT_EACH_EQUAL_X Variants
-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
-can inject _EACH_EQUAL and run assertions on an entire block of memory.
-    TEST_ASSERT_EACH_EQUAL_TYPEX( expected, actual, {size/count} )
-"Expected" is a single value to compare to.
-"Actual" is an array where each element will be compared to the expected value.
-"Size/count" is one of two parameters necessary to establish the number of array
-elements and perhaps the length of elements within the array.
-Notes:
-- The `_MESSAGE` variant convention still applies here to Each Equal assertions.
-- Assertions for handling Each Equal of floating point values are grouped with
-float and double assertions (see immediately following section).
-### Configuration
-#### Floating Point Support Is Optional
-Support for floating point types is configurable. That is, by defining the
-appropriate preprocessor symbols, floats and doubles can be individually enabled
-or disabled in Unity code. This is useful for embedded targets with no floating
-point math support (i.e. Unity compiles free of errors for fixed point only
-platforms). See Unity documentation for specifics.
-#### Maximum Data Type Width Is Configurable
-Not all targets support 64 bit wide types or even 32 bit wide types. Define the
-appropriate preprocessor symbols and Unity will omit all operations from
-compilation that exceed the maximum width of your target. See Unity
-documentation for specifics.
-## The Assertions in All Their Blessed Glory
-### Basic Fail and Ignore
-##### `TEST_FAIL()`
-This fella is most often used in special conditions where your test code is
-performing logic beyond a simple assertion. That is, in practice, `TEST_FAIL()`
-will always be found inside a conditional code block.
-_Examples:_
-- Executing a state machine multiple times that increments a counter your test
-code then verifies as a final step.
-- Triggering an exception and verifying it (as in Try / Catch / Throw - see the
-[CException](https://github.com/ThrowTheSwitch/CException) project).
-##### `TEST_IGNORE()`
-Marks a test case (i.e. function meant to contain test assertions) as ignored.
-Usually this is employed as a breadcrumb to come back and implement a test case.
-An ignored test case has effects if other assertions are in the enclosing test
-case (see Unity documentation for more).
-### Boolean
-##### `TEST_ASSERT (condition)`
-##### `TEST_ASSERT_TRUE (condition)`
-##### `TEST_ASSERT_FALSE (condition)`
-##### `TEST_ASSERT_UNLESS (condition)`
-A simple wording variation on `TEST_ASSERT_FALSE`.The semantics of
-`TEST_ASSERT_UNLESS` aid readability in certain test constructions or
-conditional statements.
-##### `TEST_ASSERT_NULL (pointer)`
-##### `TEST_ASSERT_NOT_NULL (pointer)`
-### Signed and Unsigned Integers (of all sizes)
-Large integer sizes can be disabled for build targets that do not support them.
-For example, if your target only supports up to 16 bit types, by defining the
-appropriate symbols Unity can be configured to omit 32 and 64 bit operations
-that would break compilation (see Unity documentation for more). Refer to
-Advanced Asserting later in this document for advice on dealing with other word
-sizes.
-##### `TEST_ASSERT_EQUAL_INT (expected, actual)`
-##### `TEST_ASSERT_EQUAL_INT8 (expected, actual)`
-##### `TEST_ASSERT_EQUAL_INT16 (expected, actual)`
-##### `TEST_ASSERT_EQUAL_INT32 (expected, actual)`
-##### `TEST_ASSERT_EQUAL_INT64 (expected, actual)`
-##### `TEST_ASSERT_EQUAL (expected, actual)`
-##### `TEST_ASSERT_NOT_EQUAL (expected, actual)`
-##### `TEST_ASSERT_EQUAL_UINT (expected, actual)`
-##### `TEST_ASSERT_EQUAL_UINT8 (expected, actual)`
-##### `TEST_ASSERT_EQUAL_UINT16 (expected, actual)`
-##### `TEST_ASSERT_EQUAL_UINT32 (expected, actual)`
-##### `TEST_ASSERT_EQUAL_UINT64 (expected, actual)`
-### Unsigned Integers (of all sizes) in Hexadecimal
-All `_HEX` assertions are identical in function to unsigned integer assertions
-but produce failure messages with the `expected` and `actual` values formatted
-in hexadecimal. Unity output is big endian.
-##### `TEST_ASSERT_EQUAL_HEX (expected, actual)`
-##### `TEST_ASSERT_EQUAL_HEX8 (expected, actual)`
-##### `TEST_ASSERT_EQUAL_HEX16 (expected, actual)`
-##### `TEST_ASSERT_EQUAL_HEX32 (expected, actual)`
-##### `TEST_ASSERT_EQUAL_HEX64 (expected, actual)`
-### Masked and Bit-level Assertions
-Masked and bit-level assertions produce output formatted in hexadecimal. Unity
-output is big endian.
-##### `TEST_ASSERT_BITS (mask, expected, actual)`
-Only compares the masked (i.e. high) bits of `expected` and `actual` parameters.
-##### `TEST_ASSERT_BITS_HIGH (mask, actual)`
-Asserts the masked bits of the `actual` parameter are high.
-##### `TEST_ASSERT_BITS_LOW (mask, actual)`
-Asserts the masked bits of the `actual` parameter are low.
-##### `TEST_ASSERT_BIT_HIGH (bit, actual)`
-Asserts the specified bit of the `actual` parameter is high.
-##### `TEST_ASSERT_BIT_LOW (bit, actual)`
-Asserts the specified bit of the `actual` parameter is low.
-### Integer Ranges (of all sizes)
-These assertions verify that the `expected` parameter is within +/- `delta`
-(inclusive) of the `actual` parameter. For example, if the expected value is 10
-and the delta is 3 then the assertion will fail for any value outside the range
-of 7 - 13.
-##### `TEST_ASSERT_INT_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_INT8_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_INT16_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_INT32_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_INT64_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_UINT_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_UINT8_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_UINT16_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_UINT32_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_UINT64_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_HEX_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_HEX8_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_HEX16_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_HEX32_WITHIN (delta, expected, actual)`
-##### `TEST_ASSERT_HEX64_WITHIN (delta, expected, actual)`
-### Structs and Strings
-##### `TEST_ASSERT_EQUAL_PTR (expected, actual)`
-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
-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.
-##### `TEST_ASSERT_EQUAL_MEMORY (expected, actual, len)`
-Asserts that the contents of the memory specified by the `expected` and `actual`
-pointers is identical. The size of the memory blocks in bytes is specified by
-the `len` parameter.
-### Arrays
-`expected` and `actual` parameters are both arrays. `num_elements` specifies the
-number of elements in the arrays to compare.
-`_HEX` assertions produce failure messages with expected and actual array
-contents formatted in hexadecimal.
-For array of strings comparison behavior, see comments for
-`TEST_ASSERT_EQUAL_STRING` in the preceding section.
-Assertions fail upon the first element in the compared arrays found not to
-match. Failure messages specify the array index of the failed comparison.
-##### `TEST_ASSERT_EQUAL_INT_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_INT8_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_INT16_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_INT32_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_INT64_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_UINT_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_UINT8_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_UINT16_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_UINT32_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_UINT64_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_HEX_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_HEX8_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_HEX16_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_HEX32_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_HEX64_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_PTR_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_STRING_ARRAY (expected, actual, num_elements)`
-##### `TEST_ASSERT_EQUAL_MEMORY_ARRAY (expected, actual, len, num_elements)`
-`len` is the memory in bytes to be compared at each array element.
-### Each Equal (Arrays to Single Value)
-`expected` are single values and `actual` are arrays. `num_elements` specifies
-the number of elements in the arrays to compare.
-`_HEX` assertions produce failure messages with expected and actual array
-contents formatted in hexadecimal.
-Assertions fail upon the first element in the compared arrays found not to
-match. Failure messages specify the array index of the failed comparison.
-#### `TEST_ASSERT_EACH_EQUAL_INT (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_INT8 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_INT16 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_INT32 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_INT64 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_UINT (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_UINT8 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_UINT16 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_UINT32 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_UINT64 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_HEX (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_HEX8 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_HEX16 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_HEX32 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_HEX64 (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_PTR (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_STRING (expected, actual, num_elements)`
-#### `TEST_ASSERT_EACH_EQUAL_MEMORY (expected, actual, len, num_elements)`
-`len` is the memory in bytes to be compared at each array element.
-### Floating Point (If enabled)
-##### `TEST_ASSERT_FLOAT_WITHIN (delta, expected, actual)`
-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_EQUAL_FLOAT (expected, actual)`
-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_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
-specified delta comparison values requires a custom-implemented floating point
-array assertion.
-##### `TEST_ASSERT_FLOAT_IS_INF (actual)`
-Asserts that `actual` parameter is equivalent to positive infinity floating
-point representation.
-##### `TEST_ASSERT_FLOAT_IS_NEG_INF (actual)`
-Asserts that `actual` parameter is equivalent to negative infinity floating
-point representation.
-##### `TEST_ASSERT_FLOAT_IS_NAN (actual)`
-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
-mathematical operations. That is, the `actual` parameter is neither positive
-infinity nor negative infinity nor Not A Number floating point representations.
-##### `TEST_ASSERT_FLOAT_IS_NOT_INF (actual)`
-Asserts that `actual` parameter is a value other than positive infinity floating
-point representation.
-##### `TEST_ASSERT_FLOAT_IS_NOT_NEG_INF (actual)`
-Asserts that `actual` parameter is a value other than negative infinity floating
-point representation.
-##### `TEST_ASSERT_FLOAT_IS_NOT_NAN (actual)`
-Asserts that `actual` parameter is a value other than Not A Number floating
-point representation.
-##### `TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE (actual)`
-Asserts that `actual` parameter is not usable for mathematical operations. That
-is, the `actual` parameter is either positive infinity or negative infinity or
-Not A Number floating point representations.
-### Double (If enabled)
-##### `TEST_ASSERT_DOUBLE_WITHIN (delta, expected, actual)`
-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_EQUAL_DOUBLE (expected, actual)`
-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_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
-specified delta comparison values requires a custom implemented double array
-assertion.
-##### `TEST_ASSERT_DOUBLE_IS_INF (actual)`
-Asserts that `actual` parameter is equivalent to positive infinity floating
-point representation.
-##### `TEST_ASSERT_DOUBLE_IS_NEG_INF (actual)`
-Asserts that `actual` parameter is equivalent to negative infinity floating point
-representation.
-##### `TEST_ASSERT_DOUBLE_IS_NAN (actual)`
-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
-infinity nor negative infinity nor Not A Number floating point representations.
-##### `TEST_ASSERT_DOUBLE_IS_NOT_INF (actual)`
-Asserts that `actual` parameter is a value other than positive infinity floating
-point representation.
-##### `TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF (actual)`
-Asserts that `actual` parameter is a value other than negative infinity floating
-point representation.
-##### `TEST_ASSERT_DOUBLE_IS_NOT_NAN (actual)`
-Asserts that `actual` parameter is a value other than Not A Number floating
-point representation.
-##### `TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE (actual)`
-Asserts that `actual` parameter is not usable for mathematical operations. That
-is, the `actual` parameter is either positive infinity or negative infinity or
-Not A Number floating point representations.
-## Advanced Asserting: Details On Tricky Assertions
-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
-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.
-### How do the EQUAL assertions work for FLOAT and DOUBLE?
-As you may know, directly checking for equality between a pair of floats or a
-pair of doubles is sloppy at best and an outright no-no at worst. Floating point
-values can often be represented in multiple ways, particularly after a series of
-operations on a value. Initializing a variable to the value of 2.0 is likely to
-result in a floating point representation of 2 x 20,but a series of
-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."
-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
-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
-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 20or 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!
-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
-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
-natural register size, and it should be at least 16-bits and a multiple of a
-byte. It also guarantees an order of sizes:
-```C
-char <= short <= int <= long <= long long
-```
-Most often, `int` is 32-bits. In many cases in the embedded world, `int` is
-16-bits. There are rare microcontrollers out there that have 24-bit integers,
-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
-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:
-```C
-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
-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
-use the C99 types (Sometimes because they have weird register sizes as described
-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
-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.
-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.
-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
-24-bit `int`, configure Unity to use 32-bit integers. If you have a 12-bit
-`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.
-*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)*