acpc_dealer 2.4.1 → 3.0.0

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/unity/docs/Unity Summary.txt

@@ -1,216 +0,0 @@
-==============
-Unity Test API
-==============
-
-[Copyright (c) 2007 - 2012 Unity Project by Mike Karlesky, Mark VanderVoord, and Greg Williams]
-
--------------
-Running Tests 
-------------- 
-
-RUN_TEST(func, linenum)
-
-Each Test is run within the macro RUN_TEST.  This macro performs necessary setup before the test is called and handles cleanup and result tabulation afterwards.
-
---------------
-Ignoring Tests
---------------
-
-There are times when a test is incomplete or not valid for some reason.  At these times, TEST_IGNORE can be called.  Control will immediately be returned to the caller of the test, and no failures will be returned.
-
-TEST_IGNORE()
-
-Ignore this test and return immediately
-
-TEST_IGNORE_MESSAGE (message)
-
-Ignore this test and return immediately.  Output a message stating why the test was ignored.
-
---------------
-Aborting Tests
---------------
-
-There are times when a test will contain an infinite loop on error conditions, or there may be reason to escape from the test early without executing the rest of the test.  A pair of macros support this functionality in Unity.  The first (TEST_PROTECT) sets up the feature, and handles emergency abort cases.  TEST_ABORT can then be used at any time within the tests to return to the last TEST_PROTECT call.
-
-TEST_PROTECT()
-
-Setup and Catch macro
-
-TEST_ABORT()
-
-Abort Test macro
-
-Example:
-
-main()
-{
-    if (TEST_PROTECT() == 0)
-    {
-        MyTest();
-    }
-}
-
-If MyTest calls TEST_ABORT, program control will immediately return to TEST_PROTECT with a non-zero return value.
-
-
-=======================
-Unity Assertion Summary
-=======================
-
---------------------
-Basic Validity Tests
---------------------
-
-TEST_ASSERT_TRUE(condition)
-
-Evaluates whatever code is in condition and fails if it evaluates to false
-
-TEST_ASSERT_FALSE(condition)
-
-Evaluates whatever code is in condition and fails if it evaluates to true
-
-TEST_ASSERT(condition)
-
-Another way of calling TEST_ASSERT_TRUE
-
-TEST_ASSERT_UNLESS(condition)
-
-Another way of calling TEST_ASSERT_FALSE
-
-TEST_FAIL()
-TEST_FAIL_MESSAGE(message)
-
-This test is automatically marked as a failure.  The message is output stating why.
-
-------------------------------
-Numerical Assertions: Integers
-------------------------------
-
-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)
-
-Compare two integers for equality and display errors as signed integers. A cast will be performed
-to your natural integer size so often this can just be used.  When you need to specify the exact size,
-like when comparing arrays, you can use a specific version:
-
-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)
-
-Compare two integers for equality and display errors as unsigned integers.  Like INT, there are 
-variants for different sizes also.
-
-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)
-
-Compares two integers for equality and display errors as hexadecimal.  Like the other integer comparisons,
-you can specify the size... here the size will also effect how many nibbles are shown (for example, HEX16 
-will show 4 nibbles).
-
-_ARRAY
-
-You can append _ARRAY to any of these macros to make an array comparison of that type.  Here you will
-need to care a bit more about the actual size of the value being checked.  You will also specify an
-additional argument which is the number of elements to compare.  For example:
-
-TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, elements)
-
-TEST_ASSERT_EQUAL(expected, actual)
-
-Another way of calling TEST_ASSERT_EQUAL_INT
-
-TEST_ASSERT_INT_WITHIN(delta, expected, actual)
-
-Asserts that the actual value is within plus or minus delta of the expected value.  This also comes in 
-size specific variants.
-
-
------------------------------
-Numerical Assertions: Bitwise
------------------------------
-
-TEST_ASSERT_BITS(mask, expected, actual)
-
-Use an integer mask to specify which bits should be compared between two other integers.  High bits in the mask are compared, low bits ignored.
-
-TEST_ASSERT_BITS_HIGH(mask, actual)
-
-Use an integer mask to specify which bits should be inspected to determine if they are all set high.  High bits in the mask are compared, low bits ignored.
-
-TEST_ASSERT_BITS_LOW(mask, actual)
-
-Use an integer mask to specify which bits should be inspected to determine if they are all set low.  High bits in the mask are compared, low bits ignored.
-
-TEST_ASSERT_BIT_HIGH(bit, actual)
-
-Test a single bit and verify that it is high.  The bit is specified 0-31 for a 32-bit integer.
-
-TEST_ASSERT_BIT_LOW(bit, actual)
-
-Test a single bit and verify that it is low.  The bit is specified 0-31 for a 32-bit integer.
-
-----------------------------
-Numerical Assertions: Floats
-----------------------------
-
-TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual)
-
-Asserts that the actual value is within plus or minus delta of the expected value.
-
-TEST_ASSERT_EQUAL_FLOAT(expected, actual)
-TEST_ASSERT_EQUAL_DOUBLE(expected, actual)
-
-Asserts that two floating point values are "equal" within a small % delta of the expected value.
-
------------------
-String Assertions
------------------
-
-TEST_ASSERT_EQUAL_STRING(expected, actual)
-
-Compare two null-terminate strings.  Fail if any character is different or if the lengths are different.
-
-TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message)
-
-Compare two null-terminate strings.  Fail if any character is different or if the lengths are different. Output a custom message on failure.
-
-------------------
-Pointer Assertions
-------------------
-
-Most pointer operations can be performed by simply using the integer comparisons above.  However, a couple of special cases are added for clarity.
-
-TEST_ASSERT_NULL(pointer)
-
-Fails if the pointer is not equal to NULL
-
-TEST_ASSERT_NOT_NULL(pointer)
-
-Fails if the pointer is equal to NULL
-
-
------------------
-Memory Assertions
------------------
-
-TEST_ASSERT_EQUAL_MEMORY(expected, actual, len)
-
-Compare two blocks of memory.  This is a good generic assertion for types that can't be coerced into acting like
-standard types... but since it's a memory compare, you have to be careful that your data types are packed.
-
---------
-_MESSAGE
---------
-
-you can append _MESSAGE to any of the macros to make them take an additional argument.  This argument
-is a string that will be printed at the end of the failure strings.  This is useful for specifying more
-information about the problem.
-

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/unity/docs/license.txt

@@ -1,31 +0,0 @@
- Copyright (c) 2007-2010 Mike Karlesky, Mark VanderVoord, Greg Williams
-
- Permission is hereby granted, free of charge, to any person
- obtaining a copy of this software and associated documentation
- files (the "Software"), to deal in the Software without
- restriction, including without limitation the rights to use,
- copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the
- Software is furnished to do so, subject to the following
- conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- The end-user documentation included with the redistribution, if 
- any, must include the following acknowledgment: "This product 
- includes software developed for the Unity Project, by Mike Karlesky,
- Mark VanderVoord, and Greg Williams and other contributors", in 
- the same place and form as other third-party acknowledgments. 
- Alternately, this acknowledgment may appear in the software 
- itself, in the same form and location as other such third-party 
- acknowledgments.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- OTHER DEALINGS IN THE SOFTWARE.

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/unity/release/build.info

@@ -1,2 +0,0 @@
-118
-

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/unity/release/version.info

@@ -1,2 +0,0 @@
-2.1.0
-

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/unity/src/unity.c

@@ -1,1146 +0,0 @@
-/* ==========================================
-    Unity Project - A Test Framework for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
-#include "unity.h"
-#include <stdio.h>
-#include <string.h>
-
-#define UNITY_FAIL_AND_BAIL   { Unity.CurrentTestFailed  = 1; UNITY_OUTPUT_CHAR('\n'); longjmp(Unity.AbortFrame, 1); }
-#define UNITY_IGNORE_AND_BAIL { Unity.CurrentTestIgnored = 1; UNITY_OUTPUT_CHAR('\n'); longjmp(Unity.AbortFrame, 1); }
-/// return prematurely if we are already in failure or ignore state
-#define UNITY_SKIP_EXECUTION  { if ((Unity.CurrentTestFailed != 0) || (Unity.CurrentTestIgnored != 0)) {return;} }
-#define UNITY_PRINT_EOL       { UNITY_OUTPUT_CHAR('\n'); }
-
-struct _Unity Unity = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , { 0 } };
-
-const char* UnityStrNull     = "NULL";
-const char* UnityStrSpacer   = ". ";
-const char* UnityStrExpected = " Expected ";
-const char* UnityStrWas      = " Was ";
-const char* UnityStrTo       = " To ";
-const char* UnityStrElement  = " Element ";
-const char* UnityStrByte     = " Byte ";
-const char* UnityStrMemory   = " Memory Mismatch.";
-const char* UnityStrDelta    = " Values Not Within Delta ";
-const char* UnityStrPointless= " You Asked Me To Compare Nothing, Which Was Pointless.";
-const char* UnityStrNullPointerForExpected= " Expected pointer to be NULL";
-const char* UnityStrNullPointerForActual  = " Actual pointer was NULL";
-const char* UnityStrInf      = "Infinity";
-const char* UnityStrNegInf   = "Negative Infinity";
-const char* UnityStrNaN      = "NaN";
-
-#ifndef UNITY_EXCLUDE_FLOAT
-// Dividing by these constants produces +/- infinity.
-// The rationale is given in UnityAssertFloatIsInf's body.
-static const _UF f_zero = 0.0f;
-#ifndef UNITY_EXCLUDE_DOUBLE
-static const _UD d_zero = 0.0;
-#endif
-#endif
-
-// compiler-generic print formatting masks
-const _U_UINT UnitySizeMask[] = 
-{
-    255u,         // 0xFF
-    65535u,       // 0xFFFF
-    65535u,
-    4294967295u,  // 0xFFFFFFFF
-    4294967295u,
-    4294967295u,
-    4294967295u
-#ifdef UNITY_SUPPORT_64
-    ,0xFFFFFFFFFFFFFFFF
-#endif
-};
-
-void UnityPrintFail(void);
-void UnityPrintOk(void);
-
-//-----------------------------------------------
-// Pretty Printers & Test Result Output Handlers
-//-----------------------------------------------
-
-void UnityPrint(const char* string)
-{
-    const char* pch = string;
-
-    if (pch != NULL)
-    {
-        while (*pch)
-        {
-            // printable characters plus CR & LF are printed
-            if ((*pch <= 126) && (*pch >= 32))
-            {
-                UNITY_OUTPUT_CHAR(*pch);
-            }
-            //write escaped carriage returns
-            else if (*pch == 13)
-            {
-                UNITY_OUTPUT_CHAR('\\');
-                UNITY_OUTPUT_CHAR('r');
-            }
-            //write escaped line feeds
-            else if (*pch == 10)
-            {
-                UNITY_OUTPUT_CHAR('\\');
-                UNITY_OUTPUT_CHAR('n');
-            }
-            // unprintable characters are shown as codes
-            else
-            {
-                UNITY_OUTPUT_CHAR('\\');
-                UnityPrintNumberHex((_U_SINT)*pch, 2);
-            }
-            pch++;
-        }
-    }
-}
-
-//-----------------------------------------------
-void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style)
-{
-    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
-    {
-        UnityPrintNumber(number);
-    }
-    else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
-    {
-        UnityPrintNumberUnsigned(  (_U_UINT)number  &  UnitySizeMask[((_U_UINT)style & (_U_UINT)0x0F) - 1]  );
-    }
-    else
-    {
-        UnityPrintNumberHex((_U_UINT)number, (style & 0x000F) << 1);
-    }
-}
-
-//-----------------------------------------------
-/// basically do an itoa using as little ram as possible
-void UnityPrintNumber(const _U_SINT number_to_print)
-{
-    _U_SINT divisor = 1;
-    _U_SINT next_divisor;
-    _U_SINT number = number_to_print;
-
-    if (number < 0)
-    {
-        UNITY_OUTPUT_CHAR('-');
-        number = -number;
-    }
-
-    // figure out initial divisor
-    while (number / divisor > 9)
-    {
-        next_divisor = divisor * 10;
-        if (next_divisor > divisor)
-            divisor = next_divisor;
-        else
-            break;
-    }
-
-    // now mod and print, then divide divisor
-    do
-    {
-        UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
-        divisor /= 10;
-    }
-    while (divisor > 0);
-}
-
-//-----------------------------------------------
-/// basically do an itoa using as little ram as possible
-void UnityPrintNumberUnsigned(const _U_UINT number)
-{
-    _U_UINT divisor = 1;
-    _U_UINT next_divisor;
-
-    // figure out initial divisor
-    while (number / divisor > 9)
-    {
-        next_divisor = divisor * 10;
-        if (next_divisor > divisor)
-            divisor = next_divisor;
-        else
-            break;
-    }
-
-    // now mod and print, then divide divisor
-    do
-    {
-        UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
-        divisor /= 10;
-    }
-    while (divisor > 0);
-}
-
-//-----------------------------------------------
-void UnityPrintNumberHex(const _U_UINT number, const char nibbles_to_print)
-{
-    _U_UINT nibble;
-    char nibbles = nibbles_to_print;
-    UNITY_OUTPUT_CHAR('0');
-    UNITY_OUTPUT_CHAR('x');
-
-    while (nibbles > 0)
-    {
-        nibble = (number >> (--nibbles << 2)) & 0x0000000F;
-        if (nibble <= 9)
-        {
-            UNITY_OUTPUT_CHAR((char)('0' + nibble));
-        }
-        else
-        {
-            UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble));
-        }
-    }
-}
-
-//-----------------------------------------------
-void UnityPrintMask(const _U_UINT mask, const _U_UINT number)
-{
-    _U_UINT current_bit = (_U_UINT)1 << (UNITY_INT_WIDTH - 1);
-    _US32 i;
-
-    for (i = 0; i < UNITY_INT_WIDTH; i++)
-    {
-        if (current_bit & mask)
-        {
-            if (current_bit & number)
-            {
-                UNITY_OUTPUT_CHAR('1');
-            }
-            else
-            {
-                UNITY_OUTPUT_CHAR('0');
-            }
-        }
-        else
-        {
-            UNITY_OUTPUT_CHAR('X');
-        }
-        current_bit = current_bit >> 1;
-    }
-}
-
-//-----------------------------------------------
-#ifdef UNITY_FLOAT_VERBOSE
-void UnityPrintFloat(_UF number)
-{
-    char TempBuffer[32];
-    sprintf(TempBuffer, "%.6f", number);
-    UnityPrint(TempBuffer);
-}
-#endif
-
-//-----------------------------------------------
-
-void UnityPrintFail(void)
-{
-    UnityPrint("FAIL");
-}
-
-void UnityPrintOk(void)
-{
-    UnityPrint("OK");
-}
-
-//-----------------------------------------------
-void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line)
-{
-    UnityPrint(file);
-    UNITY_OUTPUT_CHAR(':');
-    UnityPrintNumber(line);
-    UNITY_OUTPUT_CHAR(':');
-    UnityPrint(Unity.CurrentTestName);
-    UNITY_OUTPUT_CHAR(':');
-}
-
-//-----------------------------------------------
-void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line)
-{
-    UnityTestResultsBegin(Unity.TestFile, line);
-    UnityPrint("FAIL:");
-}
-
-//-----------------------------------------------
-void UnityConcludeTest(void)
-{
-    if (Unity.CurrentTestIgnored)
-    {
-        Unity.TestIgnores++;
-    }
-    else if (!Unity.CurrentTestFailed)
-    {
-        UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber);
-        UnityPrint("PASS");
-        UNITY_PRINT_EOL;
-    }
-    else
-    {
-        Unity.TestFailures++;
-    }
-
-    Unity.CurrentTestFailed = 0;
-    Unity.CurrentTestIgnored = 0;
-}
-
-//-----------------------------------------------
-void UnityAddMsgIfSpecified(const char* msg)
-{
-    if (msg)
-    {
-        UnityPrint(UnityStrSpacer);
-        UnityPrint(msg);
-    }
-}
-
-//-----------------------------------------------
-void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual)
-{
-    UnityPrint(UnityStrExpected);
-    if (expected != NULL)
-    {
-        UNITY_OUTPUT_CHAR('\'');
-        UnityPrint(expected);
-        UNITY_OUTPUT_CHAR('\'');
-    }
-    else
-    {
-      UnityPrint(UnityStrNull);          
-    }
-    UnityPrint(UnityStrWas);
-    if (actual != NULL)
-    {
-        UNITY_OUTPUT_CHAR('\'');
-        UnityPrint(actual);
-        UNITY_OUTPUT_CHAR('\'');
-    }
-    else
-    {
-      UnityPrint(UnityStrNull);          
-    }
-}
-
-//-----------------------------------------------
-// Assertion & Control Helpers
-//-----------------------------------------------
-
-int UnityCheckArraysForNull(const void* expected, const void* actual, const UNITY_LINE_TYPE lineNumber, const char* msg)
-{
-    //return true if they are both NULL
-    if ((expected == NULL) && (actual == NULL))
-        return 1;
-        
-    //throw error if just expected is NULL
-    if (expected == NULL)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-        UnityPrint(UnityStrNullPointerForExpected);
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-
-    //throw error if just actual is NULL
-    if (actual == NULL)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-        UnityPrint(UnityStrNullPointerForActual);
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-    
-    //return false if neither is NULL
-    return 0;
-}
-
-//-----------------------------------------------
-// Assertion Functions
-//-----------------------------------------------
-
-void UnityAssertBits(const _U_SINT mask,
-                     const _U_SINT expected,
-                     const _U_SINT actual,
-                     const char* msg,
-                     const UNITY_LINE_TYPE lineNumber)
-{
-    UNITY_SKIP_EXECUTION;
-  
-    if ((mask & expected) != (mask & actual))
-    {
-        UnityTestResultsFailBegin(lineNumber);
-        UnityPrint(UnityStrExpected);
-        UnityPrintMask(mask, expected);
-        UnityPrint(UnityStrWas);
-        UnityPrintMask(mask, actual);
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertEqualNumber(const _U_SINT expected,
-                            const _U_SINT actual,
-                            const char* msg,
-                            const UNITY_LINE_TYPE lineNumber,
-                            const UNITY_DISPLAY_STYLE_T style)
-{
-    UNITY_SKIP_EXECUTION;
-
-    if (expected != actual)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-        UnityPrint(UnityStrExpected);
-        UnityPrintNumberByStyle(expected, style);
-        UnityPrint(UnityStrWas);
-        UnityPrintNumberByStyle(actual, style);
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertEqualIntArray(const _U_SINT* expected,
-                              const _U_SINT* actual,
-                              const _UU32 num_elements,
-                              const char* msg,
-                              const UNITY_LINE_TYPE lineNumber,
-                              const UNITY_DISPLAY_STYLE_T style)
-{
-    _UU32 elements = num_elements;
-    const _US8* ptr_exp = (_US8*)expected;
-    const _US8* ptr_act = (_US8*)actual;
-
-    UNITY_SKIP_EXECUTION;
-  
-    if (elements == 0)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-        UnityPrint(UnityStrPointless);
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-    
-    if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
-        return;
-
-    // If style is UNITY_DISPLAY_STYLE_INT, we'll fall into the default case rather than the INT16 or INT32 (etc) case
-    // as UNITY_DISPLAY_STYLE_INT includes a flag for UNITY_DISPLAY_RANGE_AUTO, which the width-specific
-    // variants do not. Therefore remove this flag.
-    switch(style & ~UNITY_DISPLAY_RANGE_AUTO)
-    {
-        case UNITY_DISPLAY_STYLE_HEX8:
-        case UNITY_DISPLAY_STYLE_INT8:
-        case UNITY_DISPLAY_STYLE_UINT8:
-            while (elements--)
-            {
-                if (*ptr_exp != *ptr_act)
-                {
-                    UnityTestResultsFailBegin(lineNumber);
-                    UnityPrint(UnityStrElement);
-                    UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
-                    UnityPrint(UnityStrExpected);
-                    UnityPrintNumberByStyle(*ptr_exp, style);
-                    UnityPrint(UnityStrWas);
-                    UnityPrintNumberByStyle(*ptr_act, style);
-                    UnityAddMsgIfSpecified(msg);
-                    UNITY_FAIL_AND_BAIL;
-                }
-                ptr_exp += 1;
-                ptr_act += 1;
-            }
-            break;
-        case UNITY_DISPLAY_STYLE_HEX16:
-        case UNITY_DISPLAY_STYLE_INT16:
-        case UNITY_DISPLAY_STYLE_UINT16:
-            while (elements--)
-            {
-                if (*(_US16*)ptr_exp != *(_US16*)ptr_act)
-                {
-                    UnityTestResultsFailBegin(lineNumber);
-                    UnityPrint(UnityStrElement);
-                    UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
-                    UnityPrint(UnityStrExpected);
-                    UnityPrintNumberByStyle(*(_US16*)ptr_exp, style);
-                    UnityPrint(UnityStrWas);
-                    UnityPrintNumberByStyle(*(_US16*)ptr_act, style);
-                    UnityAddMsgIfSpecified(msg);
-                    UNITY_FAIL_AND_BAIL;
-                }
-                ptr_exp += 2;
-                ptr_act += 2;
-            }
-            break;
-#ifdef UNITY_SUPPORT_64
-        case UNITY_DISPLAY_STYLE_HEX64:
-        case UNITY_DISPLAY_STYLE_INT64:
-        case UNITY_DISPLAY_STYLE_UINT64:
-            while (elements--)
-            {
-                if (*(_US64*)ptr_exp != *(_US64*)ptr_act)
-                {
-                    UnityTestResultsFailBegin(lineNumber);
-                    UnityPrint(UnityStrElement);
-                    UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
-                    UnityPrint(UnityStrExpected);
-                    UnityPrintNumberByStyle(*(_US64*)ptr_exp, style);
-                    UnityPrint(UnityStrWas);
-                    UnityPrintNumberByStyle(*(_US64*)ptr_act, style);
-                    UnityAddMsgIfSpecified(msg);
-                    UNITY_FAIL_AND_BAIL;
-                }
-                ptr_exp += 8;
-                ptr_act += 8;
-            }
-            break;
-#endif
-        default:
-            while (elements--)
-            {
-                if (*(_US32*)ptr_exp != *(_US32*)ptr_act)
-                {
-                    UnityTestResultsFailBegin(lineNumber);
-                    UnityPrint(UnityStrElement);
-                    UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
-                    UnityPrint(UnityStrExpected);
-                    UnityPrintNumberByStyle(*(_US32*)ptr_exp, style);
-                    UnityPrint(UnityStrWas);
-                    UnityPrintNumberByStyle(*(_US32*)ptr_act, style);
-                    UnityAddMsgIfSpecified(msg);
-                    UNITY_FAIL_AND_BAIL;
-                }
-                ptr_exp += 4;
-                ptr_act += 4;
-            }
-            break;
-    }
-}
-
-//-----------------------------------------------
-#ifndef UNITY_EXCLUDE_FLOAT
-void UnityAssertEqualFloatArray(const _UF* expected,
-                                const _UF* actual,
-                                const _UU32 num_elements,
-                                const char* msg,
-                                const UNITY_LINE_TYPE lineNumber)
-{
-    _UU32 elements = num_elements;
-    const _UF* ptr_expected = expected;
-    const _UF* ptr_actual = actual;
-    _UF diff, tol;
-
-    UNITY_SKIP_EXECUTION;
-  
-    if (elements == 0)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-        UnityPrint(UnityStrPointless);
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-    
-    if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
-        return;
-
-    while (elements--)
-    {
-        diff = *ptr_expected - *ptr_actual;
-        if (diff < 0.0f)
-          diff = 0.0f - diff;
-        tol = UNITY_FLOAT_PRECISION * *ptr_expected;
-        if (tol < 0.0f)
-            tol = 0.0f - tol;
-        
-        //This first part of this condition will catch any NaN or Infinite values
-        if ((diff * 0.0f != 0.0f) || (diff > tol))
-        {
-            UnityTestResultsFailBegin(lineNumber);
-            UnityPrint(UnityStrElement);
-            UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
-#ifdef UNITY_FLOAT_VERBOSE
-            UnityPrint(UnityStrExpected);
-            UnityPrintFloat(*ptr_expected);
-            UnityPrint(UnityStrWas);
-            UnityPrintFloat(*ptr_actual);
-#else
-            UnityPrint(UnityStrDelta);
-#endif
-            UnityAddMsgIfSpecified(msg);
-            UNITY_FAIL_AND_BAIL;
-        }
-        ptr_expected++;
-        ptr_actual++;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertFloatsWithin(const _UF delta,
-                             const _UF expected,
-                             const _UF actual,
-                             const char* msg,
-                             const UNITY_LINE_TYPE lineNumber)
-{
-    _UF diff = actual - expected;
-    _UF pos_delta = delta;
-
-    UNITY_SKIP_EXECUTION;
-  
-    if (diff < 0.0f)
-    {
-        diff = 0.0f - diff;
-    }
-    if (pos_delta < 0.0f)
-    {
-        pos_delta = 0.0f - pos_delta;
-    }
-
-    //This first part of this condition will catch any NaN or Infinite values
-    if ((diff * 0.0f != 0.0f) || (pos_delta < diff))
-    {
-        UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_FLOAT_VERBOSE
-        UnityPrint(UnityStrExpected);
-        UnityPrintFloat(expected);
-        UnityPrint(UnityStrWas);
-        UnityPrintFloat(actual);
-#else
-        UnityPrint(UnityStrDelta);
-#endif
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertFloatIsInf(const _UF actual,
-                           const char* msg,
-                           const UNITY_LINE_TYPE lineNumber)
-{
-    UNITY_SKIP_EXECUTION;
-
-    // In Microsoft Visual C++ Express Edition 2008,
-    //   if ((1.0f / f_zero) != actual)
-    // produces
-    //   error C2124: divide or mod by zero
-    // As a workaround, place 0 into a variable.
-    if ((1.0f / f_zero) != actual)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_FLOAT_VERBOSE
-        UnityPrint(UnityStrExpected);
-        UnityPrint(UnityStrInf);
-        UnityPrint(UnityStrWas);
-        UnityPrintFloat(actual);
-#else
-        UnityPrint(UnityStrDelta);
-#endif
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertFloatIsNegInf(const _UF actual,
-                              const char* msg,
-                              const UNITY_LINE_TYPE lineNumber)
-{
-    UNITY_SKIP_EXECUTION;
-
-    // The rationale for not using 1.0f/0.0f is given in UnityAssertFloatIsInf's body.
-    if ((-1.0f / f_zero) != actual)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_FLOAT_VERBOSE
-        UnityPrint(UnityStrExpected);
-        UnityPrint(UnityStrNegInf);
-        UnityPrint(UnityStrWas);
-        UnityPrintFloat(actual);
-#else
-        UnityPrint(UnityStrDelta);
-#endif
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertFloatIsNaN(const _UF actual,
-                           const char* msg,
-                           const UNITY_LINE_TYPE lineNumber)
-{
-    UNITY_SKIP_EXECUTION;
-
-    if (actual == actual)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_FLOAT_VERBOSE
-        UnityPrint(UnityStrExpected);
-        UnityPrint(UnityStrNaN);
-        UnityPrint(UnityStrWas);
-        UnityPrintFloat(actual);
-#else
-        UnityPrint(UnityStrDelta);
-#endif
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-}
-
-#endif //not UNITY_EXCLUDE_FLOAT
-
-//-----------------------------------------------
-#ifndef UNITY_EXCLUDE_DOUBLE
-void UnityAssertEqualDoubleArray(const _UD* expected,
-                                 const _UD* actual,
-                                 const _UU32 num_elements,
-                                 const char* msg,
-                                 const UNITY_LINE_TYPE lineNumber)
-{
-    _UU32 elements = num_elements;
-    const _UD* ptr_expected = expected;
-    const _UD* ptr_actual = actual;
-    _UD diff, tol;
-
-    UNITY_SKIP_EXECUTION;
-  
-    if (elements == 0)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-        UnityPrint(UnityStrPointless);
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-    
-    if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
-        return;
-
-    while (elements--)
-    {
-        diff = *ptr_expected - *ptr_actual;
-        if (diff < 0.0)
-          diff = 0.0 - diff;
-        tol = UNITY_DOUBLE_PRECISION * *ptr_expected;
-        if (tol < 0.0)
-            tol = 0.0 - tol;
-        
-        //This first part of this condition will catch any NaN or Infinite values
-        if ((diff * 0.0 != 0.0) || (diff > tol))
-        {
-            UnityTestResultsFailBegin(lineNumber);
-            UnityPrint(UnityStrElement);
-            UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
-#ifdef UNITY_DOUBLE_VERBOSE
-            UnityPrint(UnityStrExpected);
-            UnityPrintFloat((float)(*ptr_expected));
-            UnityPrint(UnityStrWas);
-            UnityPrintFloat((float)(*ptr_actual));
-#else
-            UnityPrint(UnityStrDelta);
-#endif
-            UnityAddMsgIfSpecified(msg);
-            UNITY_FAIL_AND_BAIL;
-        }
-        ptr_expected++;
-        ptr_actual++;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertDoublesWithin(const _UD delta,
-                              const _UD expected,
-                              const _UD actual,
-                              const char* msg,
-                              const UNITY_LINE_TYPE lineNumber)
-{
-    _UD diff = actual - expected;
-    _UD pos_delta = delta;
-
-    UNITY_SKIP_EXECUTION;
-  
-    if (diff < 0.0)
-    {
-        diff = 0.0 - diff;
-    }
-    if (pos_delta < 0.0)
-    {
-        pos_delta = 0.0 - pos_delta;
-    }
-
-    //This first part of this condition will catch any NaN or Infinite values
-    if ((diff * 0.0 != 0.0) || (pos_delta < diff))
-    {
-        UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_DOUBLE_VERBOSE
-        UnityPrint(UnityStrExpected);
-        UnityPrintFloat((float)expected);
-        UnityPrint(UnityStrWas);
-        UnityPrintFloat((float)actual);
-#else
-        UnityPrint(UnityStrDelta);
-#endif
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertDoubleIsInf(const _UD actual,
-                            const char* msg,
-                            const UNITY_LINE_TYPE lineNumber)
-{
-    UNITY_SKIP_EXECUTION;
-
-    // The rationale for not using 1.0/0.0 is given in UnityAssertFloatIsInf's body.
-    if ((1.0 / d_zero) != actual)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_DOUBLE_VERBOSE
-        UnityPrint(UnityStrExpected);
-        UnityPrint(UnityStrInf);
-        UnityPrint(UnityStrWas);
-        UnityPrintFloat((float)actual);
-#else
-        UnityPrint(UnityStrDelta);
-#endif
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertDoubleIsNegInf(const _UD actual,
-                               const char* msg,
-                               const UNITY_LINE_TYPE lineNumber)
-{
-    UNITY_SKIP_EXECUTION;
-
-    // The rationale for not using 1.0/0.0 is given in UnityAssertFloatIsInf's body.
-    if ((-1.0 / d_zero) != actual)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_DOUBLE_VERBOSE
-        UnityPrint(UnityStrExpected);
-        UnityPrint(UnityStrNegInf);
-        UnityPrint(UnityStrWas);
-        UnityPrintFloat((float)actual);
-#else
-        UnityPrint(UnityStrDelta);
-#endif
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertDoubleIsNaN(const _UD actual,
-                            const char* msg,
-                            const UNITY_LINE_TYPE lineNumber)
-{
-    UNITY_SKIP_EXECUTION;
-
-    if (actual == actual)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_DOUBLE_VERBOSE
-        UnityPrint(UnityStrExpected);
-        UnityPrint(UnityStrNaN);
-        UnityPrint(UnityStrWas);
-        UnityPrintFloat((float)actual);
-#else
-        UnityPrint(UnityStrDelta);
-#endif
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-}
-
-#endif // not UNITY_EXCLUDE_DOUBLE
-
-//-----------------------------------------------
-void UnityAssertNumbersWithin( const _U_SINT delta,
-                               const _U_SINT expected,
-                               const _U_SINT actual,
-                               const char* msg,
-                               const UNITY_LINE_TYPE lineNumber,
-                               const UNITY_DISPLAY_STYLE_T style)
-{
-    UNITY_SKIP_EXECUTION;
-    
-    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
-    {
-        if (actual > expected)
-          Unity.CurrentTestFailed = ((actual - expected) > delta);
-        else
-          Unity.CurrentTestFailed = ((expected - actual) > delta);
-    }
-    else
-    {
-        if ((_U_UINT)actual > (_U_UINT)expected)
-            Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > (_U_UINT)delta);
-        else
-            Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > (_U_UINT)delta);
-    }
-
-    if (Unity.CurrentTestFailed)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-        UnityPrint(UnityStrDelta);
-        UnityPrintNumberByStyle(delta, style);
-        UnityPrint(UnityStrExpected);
-        UnityPrintNumberByStyle(expected, style);
-        UnityPrint(UnityStrWas);
-        UnityPrintNumberByStyle(actual, style);
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertEqualString(const char* expected,
-                            const char* actual,
-                            const char* msg,
-                            const UNITY_LINE_TYPE lineNumber)
-{
-    _UU32 i;
-
-    UNITY_SKIP_EXECUTION;
-  
-    // if both pointers not null compare the strings
-    if (expected && actual)
-    {
-        for (i = 0; expected[i] || actual[i]; i++)
-        {
-            if (expected[i] != actual[i])
-            {
-                Unity.CurrentTestFailed = 1;
-                break;
-            }
-        }
-    }
-    else
-    { // handle case of one pointers being null (if both null, test should pass)
-        if (expected != actual)
-        {
-            Unity.CurrentTestFailed = 1;
-        }
-    }
-
-    if (Unity.CurrentTestFailed)
-    {
-      UnityTestResultsFailBegin(lineNumber);
-      UnityPrintExpectedAndActualStrings(expected, actual);
-      UnityAddMsgIfSpecified(msg);
-      UNITY_FAIL_AND_BAIL;
-    }
-}
-
-//-----------------------------------------------
-void UnityAssertEqualStringArray( const char** expected,
-                                  const char** actual,
-                                  const _UU32 num_elements,
-                                  const char* msg,
-                                  const UNITY_LINE_TYPE lineNumber)
-{
-    _UU32 i, j = 0;
-    
-    UNITY_SKIP_EXECUTION;
-  
-    // if no elements, it's an error
-    if (num_elements == 0)
-    {
-        UnityTestResultsFailBegin(lineNumber);
-        UnityPrint(UnityStrPointless);
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-
-    if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
-        return;
-    
-    do
-    {
-        // if both pointers not null compare the strings
-        if (expected[j] && actual[j])
-        {
-            for (i = 0; expected[j][i] || actual[j][i]; i++)
-            {
-                if (expected[j][i] != actual[j][i])
-                {
-                    Unity.CurrentTestFailed = 1;
-                    break;
-                }
-            }
-        }
-        else
-        { // handle case of one pointers being null (if both null, test should pass)
-            if (expected[j] != actual[j])
-            {
-                Unity.CurrentTestFailed = 1;
-            }
-        }
-
-        if (Unity.CurrentTestFailed)
-        {
-            UnityTestResultsFailBegin(lineNumber);
-            if (num_elements > 1)
-            {
-                UnityPrint(UnityStrElement);
-                UnityPrintNumberByStyle((j), UNITY_DISPLAY_STYLE_UINT);
-            }
-            UnityPrintExpectedAndActualStrings((const char*)(expected[j]), (const char*)(actual[j]));
-            UnityAddMsgIfSpecified(msg);
-            UNITY_FAIL_AND_BAIL;
-        } 
-    } while (++j < num_elements);
-}
-
-//-----------------------------------------------
-void UnityAssertEqualMemory( const void* expected,
-                             const void* actual,
-                             const _UU32 length,
-                             const _UU32 num_elements,
-                             const char* msg,
-                             const UNITY_LINE_TYPE lineNumber)
-{
-    unsigned char* ptr_exp = (unsigned char*)expected;
-    unsigned char* ptr_act = (unsigned char*)actual;
-    _UU32 elements = num_elements;
-    _UU32 bytes;
-
-    UNITY_SKIP_EXECUTION;
-  
-    if ((elements == 0) || (length == 0))
-    {
-        UnityTestResultsFailBegin(lineNumber);
-        UnityPrint(UnityStrPointless);
-        UnityAddMsgIfSpecified(msg);
-        UNITY_FAIL_AND_BAIL;
-    }
-
-    if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
-        return;
-        
-    while (elements--)
-    {
-        /////////////////////////////////////
-        bytes = length;
-        while (bytes--)
-        {
-            if (*ptr_exp != *ptr_act)
-            {
-                UnityTestResultsFailBegin(lineNumber);
-                UnityPrint(UnityStrMemory);
-                if (num_elements > 1)
-                {
-                    UnityPrint(UnityStrElement);
-                    UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
-                }
-                UnityPrint(UnityStrByte);
-                UnityPrintNumberByStyle((length - bytes - 1), UNITY_DISPLAY_STYLE_UINT);
-                UnityPrint(UnityStrExpected);
-                UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8);
-                UnityPrint(UnityStrWas);
-                UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8);
-                UnityAddMsgIfSpecified(msg);
-                UNITY_FAIL_AND_BAIL;
-            }
-            ptr_exp += 1;
-            ptr_act += 1;
-        }
-        /////////////////////////////////////
-        
-    }
-}
-
-//-----------------------------------------------
-// Control Functions
-//-----------------------------------------------
-
-void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
-{
-    UNITY_SKIP_EXECUTION;
-
-    UnityTestResultsBegin(Unity.TestFile, line);
-    UnityPrintFail();
-    if (msg != NULL)
-    {
-      UNITY_OUTPUT_CHAR(':');
-      if (msg[0] != ' ')
-      {
-        UNITY_OUTPUT_CHAR(' ');  
-      }
-      UnityPrint(msg);
-    }
-    UNITY_FAIL_AND_BAIL;
-}
-
-//-----------------------------------------------
-void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line)
-{
-    UNITY_SKIP_EXECUTION;
-
-    UnityTestResultsBegin(Unity.TestFile, line);
-    UnityPrint("IGNORE");
-    if (msg != NULL)
-    {
-      UNITY_OUTPUT_CHAR(':');
-      UNITY_OUTPUT_CHAR(' ');
-      UnityPrint(msg);
-    }
-    UNITY_IGNORE_AND_BAIL;
-}
-
-//-----------------------------------------------
-void setUp(void);
-void tearDown(void);
-void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum)
-{
-    Unity.CurrentTestName = FuncName;
-    Unity.CurrentTestLineNumber = FuncLineNum;
-    Unity.NumberOfTests++; 
-    if (TEST_PROTECT())
-    {
-        setUp();
-        Func();
-    }
-    if (TEST_PROTECT() && !(Unity.CurrentTestIgnored))
-    {
-        tearDown();
-    }
-    UnityConcludeTest();
-}
-
-//-----------------------------------------------
-void UnityBegin(void)
-{
-    Unity.NumberOfTests = 0;
-    Unity.TestFailures = 0;
-    Unity.TestIgnores = 0;
-    Unity.CurrentTestFailed = 0;
-    Unity.CurrentTestIgnored = 0;
-}
-
-//-----------------------------------------------
-int UnityEnd(void)
-{
-    UnityPrint("-----------------------");
-    UNITY_PRINT_EOL;
-    UnityPrintNumber(Unity.NumberOfTests);
-    UnityPrint(" Tests ");
-    UnityPrintNumber(Unity.TestFailures);
-    UnityPrint(" Failures ");
-    UnityPrintNumber(Unity.TestIgnores);
-    UnityPrint(" Ignored");
-    UNITY_PRINT_EOL;
-    if (Unity.TestFailures == 0U)
-    {
-        UnityPrintOk();
-    }
-    else
-    {
-        UnityPrintFail();
-    }
-    UNITY_PRINT_EOL;
-    return Unity.TestFailures;
-}