ceedling 0.0.2 → 0.0.3

data/new_project_template/vendor/ceedling/vendor/unity/test/test_generate_test_runner.rb

@@ -1,94 +0,0 @@
-# ==========================================
-#   CMock Project - Automatic Mock Generation for C
-#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-#   [Released under MIT License. Please refer to license.txt for details]
-# ========================================== 
-
-ruby_version = RUBY_VERSION.split('.')
-if (ruby_version[1].to_i == 9) and (ruby_version[2].to_i > 1)
-  require 'rubygems'
-  gem 'test-unit'
-end
-require 'test/unit'
-require './auto/generate_test_runner.rb'
-
-TEST_FILE = 'test/testdata/testsample.c'
-TEST_MOCK = 'test/testdata/mocksample.c'
-OUT_FILE  = 'build/testsample_'
-EXP_FILE  = 'test/expectdata/testsample_'
-
-class TestGenerateTestRunner < Test::Unit::TestCase
-  def setup
-  end
-
-  def teardown
-  end
-  
-  def verify_output_equal(subtest)
-    expected = File.read(EXP_FILE + subtest + '.c').gsub(/\r\n/,"\n")
-    actual   = File.read(OUT_FILE + subtest + '.c').gsub(/\r\n/,"\n")
-    assert_equal(expected, actual, "Generated File Sub-Test '#{subtest}' Failed")
-  end
-  
-  def test_ShouldGenerateARunnerByCreatingRunnerWithOptions
-    sets = { 'def'  => nil,
-             'new1' => { :plugins => [:cexception], :includes => ['one.h', 'two.h'], :enforce_strict_ordering => true },
-             'new2' => { :plugins => [:ignore], :suite_setup => "a_custom_setup();", :suite_teardown => "a_custom_teardown();" }   
-    }
-    
-    sets.each_pair do |subtest, options|
-      UnityTestRunnerGenerator.new(options).run(TEST_FILE, OUT_FILE + subtest + '.c')
-      verify_output_equal(subtest)
-      UnityTestRunnerGenerator.new(options).run(TEST_MOCK, OUT_FILE + 'mock_' + subtest + '.c')
-      verify_output_equal('mock_' + subtest)
-    end
-  end
-  
-  def test_ShouldGenerateARunnerByRunningRunnerWithOptions
-    sets = { 'run1' => { :plugins => [:cexception], :includes => ['one.h', 'two.h'], :enforce_strict_ordering => true },
-             'run2' => { :plugins => [:ignore], :suite_setup => "a_custom_setup();", :suite_teardown => "a_custom_teardown();" }   
-    }
-    
-    sets.each_pair do |subtest, options|
-      UnityTestRunnerGenerator.new.run(TEST_FILE, OUT_FILE + subtest + '.c', options)
-      verify_output_equal(subtest)
-      UnityTestRunnerGenerator.new.run(TEST_MOCK, OUT_FILE + 'mock_' + subtest + '.c', options)
-      verify_output_equal('mock_' + subtest)
-    end
-  end
-  
-  def test_ShouldGenerateARunnerByPullingYamlOptions
-    subtest = 'yaml'
-    cmdstr = "ruby auto/generate_test_runner.rb test/testdata/sample.yml \"#{TEST_FILE}\" \"#{OUT_FILE + subtest + '.c'}\""
-    `#{cmdstr}`
-    verify_output_equal(subtest)
-    
-    cmdstr = "ruby auto/generate_test_runner.rb test/testdata/sample.yml \"#{TEST_MOCK}\" \"#{OUT_FILE + 'mock_' + subtest + '.c'}\""
-    `#{cmdstr}`
-    verify_output_equal('mock_' + subtest)
-  end
-  
-  def test_ShouldGenerateARunnerByPullingCommandlineOptions
-    subtest = 'cmd'
-    cmdstr = "ruby auto/generate_test_runner.rb -cexception \"#{TEST_FILE}\" \"#{OUT_FILE + subtest + '.c'}\""
-    `#{cmdstr}`
-    verify_output_equal(subtest)
-    
-    cmdstr = "ruby auto/generate_test_runner.rb -cexception \"#{TEST_MOCK}\" \"#{OUT_FILE + 'mock_' + subtest + '.c'}\""
-    `#{cmdstr}`
-    verify_output_equal('mock_' + subtest)
-  end
-  
-  def test_ShouldGenerateARunnerThatUsesParameterizedTests
-    sets = { 'param'  => { :plugins => [:ignore], :use_param_tests => true }   
-    }
-    
-    sets.each_pair do |subtest, options|
-      UnityTestRunnerGenerator.new(options).run(TEST_FILE, OUT_FILE + subtest + '.c')
-      verify_output_equal(subtest)
-      UnityTestRunnerGenerator.new(options).run(TEST_MOCK, OUT_FILE + 'mock_' + subtest + '.c')
-      verify_output_equal('mock_' + subtest)
-    end
-  end
-  
-end

data/new_project_template/vendor/ceedling/vendor/unity/test/testdata/mocksample.c

@@ -1,51 +0,0 @@
-// This is just a sample test file to be used to test the generator script
-#ifndef TEST_SAMPLE_H
-#define TEST_SAMPLE_H
-
-#include <setjmp.h>
-#include "unity.h"
-#include "funky.h"
-#include "Mockstanky.h"
-
-void setUp(void)
-{
-  CustomSetupStuff();
-}
-
-void tearDown(void)
-{
-  CustomTeardownStuff
-}
-
-//Yup, nice comment
-void test_TheFirstThingToTest(void)
-{
-    TEST_ASSERT(1);
-
-    TEST_ASSERT_TRUE(1);
-}
-
-/*
-void test_ShouldBeIgnored(void)
-{
-    DoesStuff();
-}
-*/
-
-//void test_ShouldAlsoNotBeTested(void)
-//{
-//    Call_An_Expect();
-//    
-//    CallAFunction();
-//    test_CallAFunctionThatLooksLikeATest();
-//}
-
-void test_TheSecondThingToTest(void)
-{
-    Call_An_Expect();
-    
-    CallAFunction();
-    test_CallAFunctionThatLooksLikeATest();
-}
-
-#endif //TEST_SAMPLE_H

data/new_project_template/vendor/ceedling/vendor/unity/test/testdata/sample.yml

@@ -1,9 +0,0 @@
-:unity:
-  :includes:
-    - two.h
-    - three.h
-    - <four.h>
-  :plugins:
-    - :cexception
-  :suite_setup: |
-    a_yaml_setup();

data/new_project_template/vendor/ceedling/vendor/unity/test/testdata/testsample.c

@@ -1,51 +0,0 @@
-// This is just a sample test file to be used to test the generator script
-#ifndef TEST_SAMPLE_H
-#define TEST_SAMPLE_H
-
-#include <setjmp.h>
-#include "unity.h"
-#include "funky.h"
-#include "stanky.h"
-
-void setUp(void)
-{
-  CustomSetupStuff();
-}
-
-void tearDown(void)
-{
-  CustomTeardownStuff
-}
-
-//Yup, nice comment
-void test_TheFirstThingToTest(void)
-{
-    TEST_ASSERT(1);
-
-    TEST_ASSERT_TRUE(1);
-}
-
-/*
-void test_ShouldBeIgnored(void)
-{
-    DoesStuff();
-}
-*/
-
-//void test_ShouldAlsoNotBeTested(void)
-//{
-//    Call_An_Expect();
-//    
-//    CallAFunction();
-//    test_CallAFunctionThatLooksLikeATest();
-//}
-
-void test_TheSecondThingToTest(void)
-{
-    Call_An_Expect();
-    
-    CallAFunction();
-    test_CallAFunctionThatLooksLikeATest();
-}
-
-#endif //TEST_SAMPLE_H

data/new_project_template/vendor/ceedling/vendor/unity/test/testparameterized.c

@@ -1,101 +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 <setjmp.h>
-#include "unity.h"
-
-#define TEST_CASE(...)
-
-#define EXPECT_ABORT_BEGIN \
-    if (TEST_PROTECT())    \
-    {
-    
-#define VERIFY_FAILS_END                                                       \
-    }                                                                          \
-    Unity.CurrentTestFailed = (Unity.CurrentTestFailed == 1) ? 0 : 1;          \
-    if (Unity.CurrentTestFailed == 1) {                                        \
-      SetToOneMeanWeAlreadyCheckedThisGuy = 1;                                 \
-      UnityPrint("[[[[ Previous Test Should Have Failed But Did Not ]]]]");    \
-      UNITY_OUTPUT_CHAR('\n');                                                 \
-    }
-    
-#define VERIFY_IGNORES_END                                                     \
-    }                                                                          \
-    Unity.CurrentTestFailed = (Unity.CurrentTestIgnored == 1) ? 0 : 1;         \
-    Unity.CurrentTestIgnored = 0;                                              \
-    if (Unity.CurrentTestFailed == 1) {                                        \
-      SetToOneMeanWeAlreadyCheckedThisGuy = 1;                                 \
-      UnityPrint("[[[[ Previous Test Should Have Ignored But Did Not ]]]]");   \
-      UNITY_OUTPUT_CHAR('\n');                                                 \
-    }
-
-int SetToOneToFailInTearDown;
-int SetToOneMeanWeAlreadyCheckedThisGuy;
-
-void setUp(void)
-{
-  SetToOneToFailInTearDown = 0;
-  SetToOneMeanWeAlreadyCheckedThisGuy = 0;
-}
-
-void tearDown(void)
-{
-  if (SetToOneToFailInTearDown == 1)
-    TEST_FAIL_MESSAGE("<= Failed in tearDown");
-  if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
-  {
-    UnityPrint("[[[[ Previous Test Should Have Passed But Did Not ]]]]");
-    UNITY_OUTPUT_CHAR('\n');
-  }
-}
-
-TEST_CASE(0)
-TEST_CASE(44)
-TEST_CASE((90)+9)
-void test_TheseShouldAllPass(int Num)
-{
-    TEST_ASSERT_TRUE(Num < 100);
-}
-
-TEST_CASE(3)
-TEST_CASE(77)
-TEST_CASE( (99) + 1 - (1))
-void test_TheseShouldAllFail(int Num)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_TRUE(Num > 100);
-    VERIFY_FAILS_END
-}
-
-TEST_CASE(1)
-TEST_CASE(44)
-TEST_CASE(99)
-TEST_CASE(98)
-void test_TheseAreEveryOther(int Num)
-{
-    if (Num & 1)
-    {
-        EXPECT_ABORT_BEGIN
-        TEST_ASSERT_TRUE(Num > 100);
-        VERIFY_FAILS_END
-    }
-    else
-    {
-        TEST_ASSERT_TRUE(Num < 100);
-    }
-}
-
-void test_NormalPassesStillWork(void)
-{
-    TEST_ASSERT_TRUE(1);
-}
-
-void test_NormalFailsStillWork(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_TRUE(0);
-    VERIFY_FAILS_END
-}

data/new_project_template/vendor/ceedling/vendor/unity/test/testunity.c

@@ -1,1510 +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 <setjmp.h>
-#include "unity.h"
-
-#define EXPECT_ABORT_BEGIN \
-    if (TEST_PROTECT())    \
-    {
-    
-#define VERIFY_FAILS_END                                                       \
-    }                                                                          \
-    Unity.CurrentTestFailed = (Unity.CurrentTestFailed == 1) ? 0 : 1;          \
-    if (Unity.CurrentTestFailed == 1) {                                        \
-      SetToOneMeanWeAlreadyCheckedThisGuy = 1;                                 \
-      UnityPrint("[[[[ Previous Test Should Have Failed But Did Not ]]]]");    \
-      UNITY_OUTPUT_CHAR('\n');                                                 \
-    }
-    
-#define VERIFY_IGNORES_END                                                     \
-    }                                                                          \
-    Unity.CurrentTestFailed = (Unity.CurrentTestIgnored == 1) ? 0 : 1;         \
-    Unity.CurrentTestIgnored = 0;                                              \
-    if (Unity.CurrentTestFailed == 1) {                                        \
-      SetToOneMeanWeAlreadyCheckedThisGuy = 1;                                 \
-      UnityPrint("[[[[ Previous Test Should Have Ignored But Did Not ]]]]");   \
-      UNITY_OUTPUT_CHAR('\n');                                                 \
-    }
-
-int SetToOneToFailInTearDown;
-int SetToOneMeanWeAlreadyCheckedThisGuy;
-
-void setUp(void)
-{
-  SetToOneToFailInTearDown = 0;
-  SetToOneMeanWeAlreadyCheckedThisGuy = 0;
-}
-
-void tearDown(void)
-{
-  if (SetToOneToFailInTearDown == 1)
-    TEST_FAIL_MESSAGE("<= Failed in tearDown");
-  if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
-  {
-    UnityPrint("[[[[ Previous Test Should Have Passed But Did Not ]]]]");
-    UNITY_OUTPUT_CHAR('\n');
-  }
-}
-
-void testTrue(void)
-{
-    TEST_ASSERT(1);
-
-    TEST_ASSERT_TRUE(1);
-}
-
-void testFalse(void)
-{
-    TEST_ASSERT_FALSE(0);
-
-    TEST_ASSERT_UNLESS(0);
-}
-
-void testPreviousPass(void)
-{
-    TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures);
-}
-
-void testNotVanilla(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT(0);
-    VERIFY_FAILS_END
-}
-
-void testNotTrue(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_TRUE(0);
-    VERIFY_FAILS_END
-}
-
-void testNotFalse(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_FALSE(1);
-    VERIFY_FAILS_END
-}
-
-void testNotUnless(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_UNLESS(1);
-    VERIFY_FAILS_END
-}
-
-void testNotNotEqual(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_NOT_EQUAL(10, 10);
-    VERIFY_FAILS_END
-}
-
-void testFail(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_FAIL_MESSAGE("Expected for testing");
-    VERIFY_FAILS_END
-}
-
-void testIsNull(void)
-{
-    char* ptr1 = NULL;
-    char* ptr2 = "hello";
-    
-    TEST_ASSERT_NULL(ptr1);
-    TEST_ASSERT_NOT_NULL(ptr2);
-}
-
-void testIsNullShouldFailIfNot(void)
-{
-    char* ptr1 = "hello";
-    
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_NULL(ptr1);
-    VERIFY_FAILS_END
-}
-
-void testNotNullShouldFailIfNULL(void)
-{
-    char* ptr1 = NULL;
-    
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_NOT_NULL(ptr1);
-    VERIFY_FAILS_END
-}
-
-void testIgnore(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_IGNORE();
-    TEST_FAIL_MESSAGE("This should not be reached");
-    VERIFY_IGNORES_END
-}
-
-void testIgnoreMessage(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_IGNORE_MESSAGE("This is an expected TEST_IGNORE_MESSAGE string!");
-    TEST_FAIL_MESSAGE("This should not be reached");
-    VERIFY_IGNORES_END
-}
-
-void testNotEqualInts(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_INT(3982, 3983);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualInt8s(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_INT8(-127, -126);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualInt16s(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_INT16(-16383, -16382);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualInt32s(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_INT32(-2147483647, -2147483646);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualBits(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_BITS(0xFF00, 0x5555, 0x5A55);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualUInts(void)
-{
-    _UU16 v0, v1;
-    
-    v0 = 9000;
-    v1 = 9001;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_UINT(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualUInt8s(void)
-{
-    _UU8 v0, v1;
-    
-    v0 = 254;
-    v1 = 255;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_UINT8(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualUInt16s(void)
-{
-    _UU16 v0, v1;
-    
-    v0 = 65535;
-    v1 = 65534;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_UINT16(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualUInt32s(void)
-{
-    _UU32 v0, v1;
-    
-    v0 = 4294967295;
-    v1 = 4294967294;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_UINT32(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHex8s(void)
-{
-    _UU8 v0, v1;
-    
-    v0 = 0x23;
-    v1 = 0x22;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX8(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHex8sIfSigned(void)
-{
-    _US8 v0, v1;
-    
-    v0 = -2;
-    v1 = 2;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX8(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHex16s(void)
-{
-    _UU16 v0, v1;
-    
-    v0 = 0x1234;
-    v1 = 0x1235;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX16(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHex16sIfSigned(void)
-{
-    _US16 v0, v1;
-    
-    v0 = -1024;
-    v1 = -1028;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX16(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHex32s(void)
-{
-    _UU32 v0, v1;
-    
-    v0 = 900000;
-    v1 = 900001;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX32(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHex32sIfSigned(void)
-{
-    _US32 v0, v1;
-    
-    v0 = -900000;
-    v1 = 900001;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX32(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testEqualInts(void)
-{
-    int v0, v1;
-    int *p0, *p1;
-    
-    v0 = 19467;
-    v1 = 19467;
-    p0 = &v0;
-    p1 = &v1;
-
-    TEST_ASSERT_EQUAL_INT(1837, 1837);
-    TEST_ASSERT_EQUAL_INT(-27365, -27365);
-    TEST_ASSERT_EQUAL_INT(v0, v1);
-    TEST_ASSERT_EQUAL_INT(19467, v1);
-    TEST_ASSERT_EQUAL_INT(v0, 19467);
-    TEST_ASSERT_EQUAL_INT(*p0, v1);
-    TEST_ASSERT_EQUAL_INT(*p0, *p1);
-    TEST_ASSERT_EQUAL_INT(*p0, 19467);
-}
-
-void testEqualUints(void)
-{
-    unsigned int v0, v1;
-    unsigned int *p0, *p1;
-    
-    v0 = 19467;
-    v1 = 19467;
-    p0 = &v0;
-    p1 = &v1;
-
-    TEST_ASSERT_EQUAL_UINT(1837, 1837);
-    TEST_ASSERT_EQUAL_UINT(v0, v1);
-    TEST_ASSERT_EQUAL_UINT(19467, v1);
-    TEST_ASSERT_EQUAL_UINT(v0, 19467);
-    TEST_ASSERT_EQUAL_UINT(*p0, v1);
-    TEST_ASSERT_EQUAL_UINT(*p0, *p1);
-    TEST_ASSERT_EQUAL_UINT(*p0, 19467);
-    TEST_ASSERT_EQUAL_UINT(60872u, 60872u);
-}
-
-void testNotEqual(void)
-{
-    TEST_ASSERT_NOT_EQUAL(0, 1);
-    TEST_ASSERT_NOT_EQUAL(1, 0);
-    TEST_ASSERT_NOT_EQUAL(100, 101);
-    TEST_ASSERT_NOT_EQUAL(0, -1);
-    TEST_ASSERT_NOT_EQUAL(65535, -65535);
-    TEST_ASSERT_NOT_EQUAL(75, 900);
-    TEST_ASSERT_NOT_EQUAL(-100, -101);
-}
-
-void testEqualHex8s(void)
-{
-    _UU8 v0, v1;
-    _UU8 *p0, *p1;
-    
-    v0 = 0x22;
-    v1 = 0x22;
-    p0 = &v0;
-    p1 = &v1;
-
-    TEST_ASSERT_EQUAL_HEX8(0x22, 0x22);
-    TEST_ASSERT_EQUAL_HEX8(v0, v1);
-    TEST_ASSERT_EQUAL_HEX8(0x22, v1);
-    TEST_ASSERT_EQUAL_HEX8(v0, 0x22);
-    TEST_ASSERT_EQUAL_HEX8(*p0, v1);
-    TEST_ASSERT_EQUAL_HEX8(*p0, *p1);
-    TEST_ASSERT_EQUAL_HEX8(*p0, 0x22);
-}
-
-void testEqualHex8sNegatives(void)
-{
-    _UU8 v0, v1;
-    _UU8 *p0, *p1;
-    
-    v0 = 0xDD;
-    v1 = 0xDD;
-    p0 = &v0;
-    p1 = &v1;
-
-    TEST_ASSERT_EQUAL_HEX8(0xDD, 0xDD);
-    TEST_ASSERT_EQUAL_HEX8(v0, v1);
-    TEST_ASSERT_EQUAL_HEX8(0xDD, v1);
-    TEST_ASSERT_EQUAL_HEX8(v0, 0xDD);
-    TEST_ASSERT_EQUAL_HEX8(*p0, v1);
-    TEST_ASSERT_EQUAL_HEX8(*p0, *p1);
-    TEST_ASSERT_EQUAL_HEX8(*p0, 0xDD);
-}
-
-void testEqualHex16s(void)
-{
-    _UU16 v0, v1;
-    _UU16 *p0, *p1;
-    
-    v0 = 0x9876;
-    v1 = 0x9876;
-    p0 = &v0;
-    p1 = &v1;
-
-    TEST_ASSERT_EQUAL_HEX16(0x9876, 0x9876);
-    TEST_ASSERT_EQUAL_HEX16(v0, v1);
-    TEST_ASSERT_EQUAL_HEX16(0x9876, v1);
-    TEST_ASSERT_EQUAL_HEX16(v0, 0x9876);
-    TEST_ASSERT_EQUAL_HEX16(*p0, v1);
-    TEST_ASSERT_EQUAL_HEX16(*p0, *p1);
-    TEST_ASSERT_EQUAL_HEX16(*p0, 0x9876);
-}
-
-void testEqualHex32s(void)
-{
-    _UU32 v0, v1;
-    _UU32 *p0, *p1;
-    
-    v0 = 0x98765432ul;
-    v1 = 0x98765432ul;
-    p0 = &v0;
-    p1 = &v1;
-
-    TEST_ASSERT_EQUAL_HEX32(0x98765432ul, 0x98765432ul);
-    TEST_ASSERT_EQUAL_HEX32(v0, v1);
-    TEST_ASSERT_EQUAL_HEX32(0x98765432ul, v1);
-    TEST_ASSERT_EQUAL_HEX32(v0, 0x98765432ul);
-    TEST_ASSERT_EQUAL_HEX32(*p0, v1);
-    TEST_ASSERT_EQUAL_HEX32(*p0, *p1);
-    TEST_ASSERT_EQUAL_HEX32(*p0, 0x98765432ul);
-}
-
-void testEqualBits(void)
-{
-    _UU32 v0 = 0xFF55AA00;
-    _UU32 v1 = 0x55550000;
-
-    TEST_ASSERT_BITS(v1, v0, 0x55550000);
-    TEST_ASSERT_BITS(v1, v0, 0xFF55CC00);
-    TEST_ASSERT_BITS(0xFFFFFFFF, v0, 0xFF55AA00);
-    TEST_ASSERT_BITS(0xFFFFFFFF, v0, v0);
-    TEST_ASSERT_BITS(0xF0F0F0F0, v0, 0xFC5DAE0F);
-    TEST_ASSERT_BITS_HIGH(v1, v0);
-    TEST_ASSERT_BITS_LOW(0x000055FF, v0);
-    TEST_ASSERT_BIT_HIGH(30, v0);
-    TEST_ASSERT_BIT_LOW(5, v0);
-}
-
-void testEqualShorts(void)
-{
-    short v0, v1;
-    short *p0, *p1;
-    
-    v0 = 19467;
-    v1 = 19467;
-    p0 = &v0;
-    p1 = &v1;
-
-    TEST_ASSERT_EQUAL_INT(1837, 1837);
-    TEST_ASSERT_EQUAL_INT(-2987, -2987);
-    TEST_ASSERT_EQUAL_INT(v0, v1);
-    TEST_ASSERT_EQUAL_INT(19467, v1);
-    TEST_ASSERT_EQUAL_INT(v0, 19467);
-    TEST_ASSERT_EQUAL_INT(*p0, v1);
-    TEST_ASSERT_EQUAL_INT(*p0, *p1);
-    TEST_ASSERT_EQUAL_INT(*p0, 19467);
-}
-
-void testEqualUShorts(void)
-{
-    unsigned short v0, v1;
-    unsigned short *p0, *p1;
-    
-    v0 = 19467;
-    v1 = 19467;
-    p0 = &v0;
-    p1 = &v1;
-
-    TEST_ASSERT_EQUAL_UINT(1837, 1837);
-    TEST_ASSERT_EQUAL_UINT(2987, 2987);
-    TEST_ASSERT_EQUAL_UINT(v0, v1);
-    TEST_ASSERT_EQUAL_UINT(19467, v1);
-    TEST_ASSERT_EQUAL_UINT(v0, 19467);
-    TEST_ASSERT_EQUAL_UINT(*p0, v1);
-    TEST_ASSERT_EQUAL_UINT(*p0, *p1);
-    TEST_ASSERT_EQUAL_UINT(*p0, 19467);
-}
-
-void testEqualChars(void)
-{
-    signed char v0, v1;
-    signed char *p0, *p1;
-    
-    v0 = 109;
-    v1 = 109;
-    p0 = &v0;
-    p1 = &v1;
-
-    TEST_ASSERT_EQUAL_INT(42, 42);
-    TEST_ASSERT_EQUAL_INT(-116, -116);
-    TEST_ASSERT_EQUAL_INT(v0, v1);
-    TEST_ASSERT_EQUAL_INT(109, v1);
-    TEST_ASSERT_EQUAL_INT(v0, 109);
-    TEST_ASSERT_EQUAL_INT(*p0, v1);
-    TEST_ASSERT_EQUAL_INT(*p0, *p1);
-    TEST_ASSERT_EQUAL_INT(*p0, 109);
-}
-
-void testEqualUChars(void)
-{
-    unsigned char v0, v1;
-    unsigned char *p0, *p1;
-    
-    v0 = 251;
-    v1 = 251;
-    p0 = &v0;
-    p1 = &v1;
-
-    TEST_ASSERT_EQUAL_INT(42, 42);
-    TEST_ASSERT_EQUAL_INT(v0, v1);
-    TEST_ASSERT_EQUAL_INT(251, v1);
-    TEST_ASSERT_EQUAL_INT(v0, 251);
-    TEST_ASSERT_EQUAL_INT(*p0, v1);
-    TEST_ASSERT_EQUAL_INT(*p0, *p1);
-    TEST_ASSERT_EQUAL_INT(*p0, 251);
-}
-
-void testEqualPointers(void)
-{
-    int v0, v1;
-    int *p0, *p1, *p2;
-    
-    v0 = 19467;
-    v1 = 18271;
-    p0 = &v0;
-    p1 = &v1;
-    p2 = &v1;
-
-    TEST_ASSERT_EQUAL_PTR(p0, &v0);
-    TEST_ASSERT_EQUAL_PTR(&v1, p1);
-    TEST_ASSERT_EQUAL_PTR(p2, p1);
-    TEST_ASSERT_EQUAL_PTR(&v0, &v0);
-}
-
-void testNotEqualPointers(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_PTR(0x12345678, 0x12345677);
-    VERIFY_FAILS_END
-}
-
-void testIntsWithinDelta(void)
-{
-    TEST_ASSERT_INT_WITHIN(1, 5000, 5001);
-    TEST_ASSERT_INT_WITHIN(5, 5000, 4996);
-    TEST_ASSERT_INT_WITHIN(5, 5000, 5005);
-    TEST_ASSERT_INT_WITHIN(500, 50, -440);
-    
-    TEST_ASSERT_INT_WITHIN(2, -1, -1);
-    TEST_ASSERT_INT_WITHIN(5, 1, -1);
-    TEST_ASSERT_INT_WITHIN(5, -1, 1);
-}
-
-void testIntsNotWithinDelta(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_INT_WITHIN(5, 5000, 5006);
-    VERIFY_FAILS_END
-}
-
-void testUIntsWithinDelta(void)
-{
-    TEST_ASSERT_UINT_WITHIN(1, 5000, 5001);
-    TEST_ASSERT_UINT_WITHIN(5, 5000, 4996);
-    TEST_ASSERT_UINT_WITHIN(5, 5000, 5005);
-}
-
-void testUIntsNotWithinDelta(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_UINT_WITHIN(1, 2147483647u, 2147483649u);
-    VERIFY_FAILS_END
-}
-
-void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirst(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_UINT_WITHIN(5, 1, -1);
-    VERIFY_FAILS_END
-}
-
-void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirst(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_UINT_WITHIN(5, -1, 1);
-    VERIFY_FAILS_END
-}
-
-void testHEX32sWithinDelta(void)
-{
-    TEST_ASSERT_HEX32_WITHIN(1, 5000, 5001);
-    TEST_ASSERT_HEX32_WITHIN(5, 5000, 4996);
-    TEST_ASSERT_HEX32_WITHIN(5, 5000, 5005);
-}
-
-void testHEX32sNotWithinDelta(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_HEX32_WITHIN(1, 2147483647u, 2147483649u);
-    VERIFY_FAILS_END
-}
-
-void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_HEX32_WITHIN(5, 1, -1);
-    VERIFY_FAILS_END
-}
-
-void testHEX16sWithinDelta(void)
-{
-    TEST_ASSERT_HEX16_WITHIN(1, 5000, 5001);
-    TEST_ASSERT_HEX16_WITHIN(5, 5000, 4996);
-    TEST_ASSERT_HEX16_WITHIN(5, 5000, 5005);
-}
-
-void testHEX16sNotWithinDelta(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_HEX16_WITHIN(2, 65535, 0);
-    VERIFY_FAILS_END
-}
-
-void testHEX8sWithinDelta(void)
-{
-    TEST_ASSERT_HEX8_WITHIN(1, 254, 255);
-    TEST_ASSERT_HEX8_WITHIN(5, 251, 255);
-    TEST_ASSERT_HEX8_WITHIN(5, 1, 4);
-}
-
-void testHEX8sNotWithinDelta(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_HEX8_WITHIN(2, 255, 0);
-    VERIFY_FAILS_END
-}
-
-void testEqualStrings(void)
-{
-    const char *testString = "foo";
-
-    TEST_ASSERT_EQUAL_STRING(testString, testString);
-    TEST_ASSERT_EQUAL_STRING("foo", "foo");
-    TEST_ASSERT_EQUAL_STRING("foo", testString);
-    TEST_ASSERT_EQUAL_STRING(testString, "foo");
-    TEST_ASSERT_EQUAL_STRING("", "");
-}
-
-void testEqualStringsWithCarriageReturnsAndLineFeeds(void)
-{
-    const char *testString = "foo\r\nbar";
-
-    TEST_ASSERT_EQUAL_STRING(testString, testString);
-    TEST_ASSERT_EQUAL_STRING("foo\r\nbar", "foo\r\nbar");
-    TEST_ASSERT_EQUAL_STRING("foo\r\nbar", testString);
-    TEST_ASSERT_EQUAL_STRING(testString, "foo\r\nbar");
-    TEST_ASSERT_EQUAL_STRING("", "");
-}
-
-void testNotEqualString1(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("foo", "bar");
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString2(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("foo", "");
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString3(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("", "bar");
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString4(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("bar\r", "bar\n");
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString5(void)
-{
-    const char str1[] = { 0x41, 0x42, 0x03, 0x00 };
-    const char str2[] = { 0x41, 0x42, 0x04, 0x00 };
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING(str1, str2);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString_ExpectedStringIsNull(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING(NULL, "bar");
-    VERIFY_FAILS_END
-}
-
-void testNotEqualString_ActualStringIsNull(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING("foo", NULL);
-    VERIFY_FAILS_END
-}
-
-void testEqualStringArrays(void)
-{
-    const char *testStrings[] = { "foo", "boo", "woo", "moo" };
-    const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
-
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, expStrings, 3);
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 3);
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 2);
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 1);
-}
-
-void testNotEqualStringArray1(void)
-{
-    const char *testStrings[] = { "foo", "boo", "woo", "moo" };
-    const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringArray2(void)
-{
-    const char *testStrings[] = { "zoo", "boo", "woo", "moo" };
-    const char *expStrings[] = { "foo", "boo", "woo", "moo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringArray3(void)
-{
-    const char *testStrings[] = { "foo", "boo", "woo", NULL };
-    const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringArray4(void)
-{
-    const char *testStrings[] = { "foo", "boo", "woo", "moo" };
-    const char *expStrings[] = { "foo", NULL, "woo", "moo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringArray5(void)
-{
-    const char **testStrings = NULL;
-    const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualStringArray6(void)
-{
-    const char *testStrings[] = { "foo", "boo", "woo", "zoo" };
-    const char **expStrings = NULL;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-    VERIFY_FAILS_END
-}
-
-void testEqualStringArrayIfBothNulls(void)
-{
-    const char **testStrings = NULL;
-    const char **expStrings = NULL;
-
-    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
-}
-
-void testEqualMemory(void)
-{
-    const char *testString = "whatever";
-    
-    TEST_ASSERT_EQUAL_MEMORY(testString, testString, 8);
-    TEST_ASSERT_EQUAL_MEMORY("whatever", "whatever", 8);
-    TEST_ASSERT_EQUAL_MEMORY("whatever", testString, 8);
-    TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 8);
-    TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 2);
-    TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 1);
-}
-
-void testNotEqualMemory1(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_MEMORY("foo", "bar", 3);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualMemory2(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_MEMORY("fool", "food", 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualMemory3(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_MEMORY(NULL, "food", 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualMemory4(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_MEMORY("fool", NULL, 4);
-    VERIFY_FAILS_END
-}
-
-void testEqualIntArrays(void)
-{
-    int p0[] = {1, 8, 987, -2};
-    int p1[] = {1, 8, 987, -2};
-    int p2[] = {1, 8, 987, 2};
-    int p3[] = {1, 500, 600, 700};
-
-    TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 1);
-    TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 4);
-    TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
-    TEST_ASSERT_EQUAL_INT_ARRAY(p0, p2, 3);
-    TEST_ASSERT_EQUAL_INT_ARRAY(p0, p3, 1);
-}
-
-void testNotEqualIntArraysNullExpected(void)
-{
-    int* p0 = NULL;
-    int p1[] = {1, 8, 987, 2};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualIntArraysNullActual(void)
-{
-    int* p1 = NULL;
-    int p0[] = {1, 8, 987, 2};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualIntArrays1(void)
-{
-    int p0[] = {1, 8, 987, -2};
-    int p1[] = {1, 8, 987, 2};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualIntArrays2(void)
-{
-    int p0[] = {1, 8, 987, -2};
-    int p1[] = {2, 8, 987, -2};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualIntArrays3(void)
-{
-    int p0[] = {1, 8, 987, -2};
-    int p1[] = {1, 8, 986, -2};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testEqualInt8Arrays(void)
-{
-    _US8 p0[] = {1, 8, 117, -2};
-    _US8 p1[] = {1, 8, 117, -2};
-    _US8 p2[] = {1, 8, 117, 2};
-    _US8 p3[] = {1, 50, 60, 70};
-
-    TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 1);
-    TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 4);
-    TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4);
-    TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p2, 3);
-    TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p3, 1);
-}
-
-void testNotEqualInt8Arrays(void)
-{
-    _US8 p0[] = {1, 8, 127, -2};
-    _US8 p1[] = {1, 8, 127, 2};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testEqualUIntArrays(void)
-{
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {1, 8, 987, 65132u};
-    unsigned int p2[] = {1, 8, 987, 2};
-    unsigned int p3[] = {1, 500, 600, 700};
-
-    TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 1);
-    TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 4);
-    TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
-    TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p2, 3);
-    TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p3, 1);
-}
-
-void testNotEqualUIntArrays1(void)
-{
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {1, 8, 987, 65131u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualUIntArrays2(void)
-{
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {2, 8, 987, 65132u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualUIntArrays3(void)
-{
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {1, 8, 986, 65132u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testEqualInt16Arrays(void)
-{
-    _UU16 p0[] = {1, 8, 117, 3};
-    _UU16 p1[] = {1, 8, 117, 3};
-    _UU16 p2[] = {1, 8, 117, 2};
-    _UU16 p3[] = {1, 50, 60, 70};
-
-    TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 1);
-    TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 4);
-    TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4);
-    TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p2, 3);
-    TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p3, 1);
-}
-
-void testNotEqualInt16Arrays(void)
-{
-    _UU16 p0[] = {1, 8, 127, 3};
-    _UU16 p1[] = {1, 8, 127, 2};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testEqualUINT16Arrays(void)
-{
-    unsigned short p0[] = {1, 8, 987, 65132u};
-    unsigned short p1[] = {1, 8, 987, 65132u};
-    unsigned short p2[] = {1, 8, 987, 2};
-    unsigned short p3[] = {1, 500, 600, 700};
-
-    TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 1);
-    TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 4);
-    TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
-    TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p2, 3);
-    TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p3, 1);
-}
-
-void testNotEqualUINT16Arrays1(void)
-{
-    unsigned short p0[] = {1, 8, 987, 65132u};
-    unsigned short p1[] = {1, 8, 987, 65131u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualUINT16Arrays2(void)
-{
-    unsigned short p0[] = {1, 8, 987, 65132u};
-    unsigned short p1[] = {2, 8, 987, 65132u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualUINT16Arrays3(void)
-{
-    unsigned short p0[] = {1, 8, 987, 65132u};
-    unsigned short p1[] = {1, 8, 986, 65132u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testEqualHEXArrays(void)
-{
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {1, 8, 987, 65132u};
-    unsigned int p2[] = {1, 8, 987, 2};
-    unsigned int p3[] = {1, 500, 600, 700};
-
-    TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 1);
-    TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 4);
-    TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4);
-    TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3);
-    TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1);
-}
-
-void testNotEqualHEXArrays1(void)
-{
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {1, 8, 987, 65131u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHEXArrays2(void)
-{
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {2, 8, 987, 65132u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHEXArrays3(void)
-{
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {1, 8, 986, 65132u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testEqualHEX16Arrays(void)
-{
-    unsigned short p0[] = {1, 8, 987, 65132u};
-    unsigned short p1[] = {1, 8, 987, 65132u};
-    unsigned short p2[] = {1, 8, 987, 2};
-    unsigned short p3[] = {1, 500, 600, 700};
-
-    TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 1);
-    TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 4);
-    TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
-    TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p2, 3);
-    TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p3, 1);
-}
-
-void testNotEqualHEX16Arrays1(void)
-{
-    unsigned short p0[] = {1, 8, 987, 65132u};
-    unsigned short p1[] = {1, 8, 987, 65131u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHEX16Arrays2(void)
-{
-    unsigned short p0[] = {1, 8, 987, 65132u};
-    unsigned short p1[] = {2, 8, 987, 65132u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHEX16Arrays3(void)
-{
-    unsigned short p0[] = {1, 8, 987, 65132u};
-    unsigned short p1[] = {1, 8, 986, 65132u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testEqualHEX8Arrays(void)
-{
-    unsigned short p0[] = {1, 8, 254u, 123};
-    unsigned short p1[] = {1, 8, 254u, 123};
-    unsigned short p2[] = {1, 8, 254u, 2};
-    unsigned short p3[] = {1, 23, 25, 26};
-
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 1);
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 4);
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p2, 3);
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p3, 1);
-}
-
-void testNotEqualHEX8Arrays1(void)
-{
-    unsigned char p0[] = {1, 8, 254u, 253u};
-    unsigned char p1[] = {1, 8, 254u, 252u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHEX8Arrays2(void)
-{
-    unsigned char p0[] = {1, 8, 254u, 253u};
-    unsigned char p1[] = {2, 8, 254u, 253u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHEX8Arrays3(void)
-{
-    unsigned char p0[] = {1, 8, 254u, 253u};
-    unsigned char p1[] = {1, 8, 255u, 253u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testEqualMemoryArrays(void)
-{
-    int p0[] = {1, 8, 987, -2};
-    int p1[] = {1, 8, 987, -2};
-    int p2[] = {1, 8, 987, 2};
-    int p3[] = {1, 500, 600, 700};
-
-    TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, 4, 1);
-    TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, 4, 4);
-    TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
-    TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p2, 4, 3);
-    TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p3, 4, 1);
-}
-
-void testNotEqualMemoryArraysExpectedNull(void)
-{
-    int* p0 = NULL;
-    int p1[] = {1, 8, 987, 2};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualMemoryArraysActualNull(void)
-{
-    int p0[] = {1, 8, 987, -2};
-    int* p1 = NULL;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualMemoryArrays1(void)
-{
-    int p0[] = {1, 8, 987, -2};
-    int p1[] = {1, 8, 987, 2};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualMemoryArrays2(void)
-{
-    int p0[] = {1, 8, 987, -2};
-    int p1[] = {2, 8, 987, -2};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualMemoryArrays3(void)
-{
-    int p0[] = {1, 8, 987, -2};
-    int p1[] = {1, 8, 986, -2};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
-    VERIFY_FAILS_END
-}
-
-void testProtection(void)
-{
-    volatile int mask = 0;
-
-    if (TEST_PROTECT())
-    {
-        mask |= 1;
-        TEST_ABORT();
-    }
-    else
-    {
-        Unity.CurrentTestFailed = 0;
-        mask |= 2;
-    }
-
-    TEST_ASSERT_EQUAL(3, mask);
-}
-
-void testIgnoredAndThenFailInTearDown(void)
-{
-    SetToOneToFailInTearDown = 1;
-    TEST_IGNORE();
-}
-
-// ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES 64 BIT SUPPORT ==================
-#ifdef UNITY_SUPPORT_64
-
-void testEqualHex64s(void)
-{
-    _UU64 v0, v1;
-    _UU64 *p0, *p1;
-    
-    v0 = 0x9876543201234567;
-    v1 = 0x9876543201234567;
-    p0 = &v0;
-    p1 = &v1;
-
-    TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, 0x9876543201234567);
-    TEST_ASSERT_EQUAL_HEX64(v0, v1);
-    TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, v1);
-    TEST_ASSERT_EQUAL_HEX64(v0, 0x9876543201234567);
-    TEST_ASSERT_EQUAL_HEX64(*p0, v1);
-    TEST_ASSERT_EQUAL_HEX64(*p0, *p1);
-    TEST_ASSERT_EQUAL_HEX64(*p0, 0x9876543201234567);
-}
-
-void testNotEqualHex64s(void)
-{
-    _UU64 v0, v1;
-    
-    v0 = 9000000000;
-    v1 = 9100000000;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX64(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHex64sIfSigned(void)
-{
-    _US64 v0, v1;
-    
-    v0 = -9000000000;
-    v1 = 9000000000;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX64(v0, v1);
-    VERIFY_FAILS_END
-}
-
-void testHEX64sWithinDelta(void)
-{
-    TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
-    TEST_ASSERT_HEX64_WITHIN(5, 5000, 4996);
-    TEST_ASSERT_HEX64_WITHIN(5, 5000, 5005);
-}
-
-void testHEX64sNotWithinDelta(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
-    VERIFY_FAILS_END
-}
-
-void testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_HEX64_WITHIN(5, 1, -1);
-    VERIFY_FAILS_END
-}
-
-void testEqualHEX64Arrays(void)
-{
-    _UU64 p0[] = {1, 8, 987, 65132u};
-    _UU64 p1[] = {1, 8, 987, 65132u};
-    _UU64 p2[] = {1, 8, 987, 2};
-    _UU64 p3[] = {1, 500, 600, 700};
-
-    TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 1);
-    TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 4);
-    TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
-    TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p2, 3);
-    TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p3, 1);
-}
-
-void testNotEqualHEX64Arrays1(void)
-{
-    _UU64 p0[] = {1, 8, 987, 65132u};
-    _UU64 p1[] = {1, 8, 987, 65131u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualHEX64Arrays2(void)
-{
-    _UU64 p0[] = {1, 8, 987, 65132u};
-    _UU64 p1[] = {2, 8, 987, 65132u};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-#endif //64-bit SUPPORT
-
-// ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES FLOAT SUPPORT ==================
-#ifndef UNITY_EXCLUDE_FLOAT
-
-void testFloatsWithinDelta(void)
-{
-    TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f);
-    TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f);
-    TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f);
-    TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f);
-}
-
-void testFloatsNotWithinDelta(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f);
-    VERIFY_FAILS_END
-}
-
-void testFloatsEqual(void)
-{
-    TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f);
-    TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f);
-    TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f);
-    TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f);
-}
-
-void testFloatsNotEqual(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f);
-    VERIFY_FAILS_END
-}
-
-void testFloatsNotEqualNegative1(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f);
-    VERIFY_FAILS_END
-}
-
-void testFloatsNotEqualNegative2(void)
-{
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f);
-    VERIFY_FAILS_END
-}
-
-void testEqualFloatArrays(void)
-{
-    float p0[] = {1.0, -8.0,  25.4, -0.123};
-    float p1[] = {1.0, -8.0,  25.4, -0.123};
-    float p2[] = {1.0, -8.0,  25.4, -0.2};
-    float p3[] = {1.0, -23.0, 25.0, -0.26};
-
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 1);
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 4);
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p2, 3);
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p3, 1);
-}
-
-void testNotEqualFloatArraysExpectedNull(void)
-{
-    float* p0 = NULL;
-    float p1[] = {1.0, 8.0, 25.4, 0.252};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualFloatArraysActualNull(void)
-{
-    float p0[] = {1.0, 8.0, 25.4, 0.253};
-    float* p1 = NULL;
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualFloatArrays1(void)
-{
-    float p0[] = {1.0, 8.0, 25.4, 0.253};
-    float p1[] = {1.0, 8.0, 25.4, 0.252};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualFloatArrays2(void)
-{
-    float p0[] = {1.0, 8.0, 25.4, 0.253};
-    float p1[] = {2.0, 8.0, 25.4, 0.253};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualFloatArrays3(void)
-{
-    float p0[] = {1.0, 8.0, 25.4, 0.253};
-    float p1[] = {1.0, 8.0, 25.5, 0.253};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualFloatArraysNegative1(void)
-{
-    float p0[] = {-1.0, -8.0, -25.4, -0.253};
-    float p1[] = {-1.0, -8.0, -25.4, -0.252};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualFloatArraysNegative2(void)
-{
-    float p0[] = {-1.0, -8.0, -25.4, -0.253};
-    float p1[] = {-2.0, -8.0, -25.4, -0.253};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-void testNotEqualFloatArraysNegative3(void)
-{
-    float p0[] = {-1.0, -8.0, -25.4, -0.253};
-    float p1[] = {-1.0, -8.0, -25.5, -0.253};
-
-    EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
-    VERIFY_FAILS_END
-}
-
-#endif //FLOAT SUPPORT