Documentation improvements

* Fixed a broken markdown bulleted list
* Replaced a missing document link (from the original source of this documentation) with a full sentence explaining the relation of `assert()` to static analysis.
* Typographic fixes
  * Replaced single and double straight quotes with smart quotes where appropriate
  * Replaced three periods with ellipses where appropriate

.editorconfig

@@ -0,0 +1,27 @@
+###############################################################################
+# Unity Project - A Test Framework for C
+# .editorconfig - F. Zahn 2019
+###############################################################################
+
+# This is the topmost .editorconfig file
+root = true
+
+# Settings that apply to all languages / files
+[*]
+charset = utf-8
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.txt]
+trim_trailing_whitespace = false
+
+[*.rb]
+indent_size = 2
+
+[*.yml]
+indent_size = 2

.gitattributes

@@ -16,6 +16,7 @@
 *.md        text
 makefile    text
 rakefile    text
+meson.build text
 
 
 #These files are binary and should not be normalized

.github/workflows/main.yml

@@ -0,0 +1,32 @@
+---
+# Continuous Integration Workflow: Test case suite run + validation build check
+name: CI
+
+# Controls when the action will run.
+# Triggers the workflow on push or pull request events but only for the master branch
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  # Job: Unit test suite
+  unit-tests:
+    name: "Unit Tests"
+    runs-on: ubuntu-latest
+    steps:
+      # Install Ruby Testing Tools
+      - name: Setup Ruby Testing Tools
+        run: |
+          sudo gem install rspec
+          sudo gem install rubocop -v 0.57.2
+
+      # Checks out repository under $GITHUB_WORKSPACE
+      - name: Checkout Latest Repo
+        uses: actions/checkout@v2
+
+      # Run Tests
+      - name: Run All Unit Tests
+        run: |
+          cd test && rake ci

.gitignore

@@ -1,9 +1,19 @@
 build/
+builddir/
 test/sandbox
 .DS_Store
+examples/example_1/subprojects/unity
 examples/example_1/test1.exe
 examples/example_1/test2.exe
 examples/example_2/all_tests.exe
 examples/example_1/test1.out
 examples/example_1/test2.out
 examples/example_2/all_tests.out
+examples/example_4/builddir
+*.sublime-project
+*.sublime-workspace
+*.cmake
+Makefile
+CMakeFiles
+CMakeCache.txt
+!unityConfig.cmake

.travis.yml

@@ -1,27 +0,0 @@
-language: c
-
-matrix:
- include:
-    - os: osx
-      compiler: clang
-      osx_image: xcode7.3
-    - os: linux
-      dist: trusty
-      compiler: gcc
-
-before_install:
-  - if [ "$TRAVIS_OS_NAME" == "osx" ]; then rvm install 2.1 && rvm use 2.1 && ruby -v; fi
-  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install --assume-yes --quiet gcc-multilib; fi
-install:
-  - gem install rspec
-  - gem install rubocop
-script:
-  - cd test && rake ci
-  - make -s
-  - make -s DEBUG=-m32
-  - cd ../extras/fixture/test && rake ci
-  - make -s default noStdlibMalloc
-  - make -s C89
-  - cd ../../../examples/example_1 && make -s ci
-  - cd ../example_2 && make -s ci
-  - cd ../example_3 && rake

CMakeLists.txt

@@ -0,0 +1,171 @@
+###################################################################################
+#                                                                                 #
+# NAME: CMakeLists.txt                                                            #
+#                                                                                 #
+# AUTHOR: Mike Karlesky, Mark VanderVoord, Greg Williams.                         #
+# WRITTEN BY: Michael Brockus.                                                    #
+#                                                                                 #
+# License: MIT                                                                    #
+#                                                                                 #
+###################################################################################
+
+cmake_minimum_required(VERSION 3.12)
+
+# Read src/unity.h file and get project version from it
+set(UNITY_HEADER "src/unity.h")
+
+file(STRINGS "${UNITY_HEADER}" UNITY_HEADER_CONTENT 
+    REGEX "^#define UNITY_VERSION_(MAJOR|MINOR|BUILD) +[0-9]+$"
+)
+
+set(UNITY_HEADER_VERSION_MAJOR 0)
+set(UNITY_HEADER_VERSION_MINOR 0)
+set(UNITY_HEADER_VERSION_BUILD 0)
+
+foreach(VERSION_LINE IN LISTS UNITY_HEADER_CONTENT)
+    foreach(VERSION_PART MAJOR MINOR BUILD)
+        string(CONCAT REGEX_STRING "#define UNITY_VERSION_" 
+                                   "${VERSION_PART}" 
+                                   " +([0-9]+)"
+        )
+
+        if(VERSION_LINE MATCHES "${REGEX_STRING}")
+            set(UNITY_HEADER_VERSION_${VERSION_PART} "${CMAKE_MATCH_1}")
+        endif()
+    endforeach()
+endforeach()
+
+project(unity
+    VERSION     ${UNITY_HEADER_VERSION_MAJOR}.${UNITY_HEADER_VERSION_MINOR}.${UNITY_HEADER_VERSION_BUILD}
+    LANGUAGES   C
+    DESCRIPTION "C Unit testing framework."
+)
+
+# Options to Build With Extras -------------------------------------------------
+option(UNITY_EXTENSION_FIXTURE "Compiles Unity with the \"fixture\" extension." OFF)
+option(UNITY_EXTENSION_MEMORY "Compiles Unity with the \"memory\" extension." OFF)
+
+set(UNITY_EXTENSION_FIXTURE_ENABLED $<BOOL:${UNITY_EXTENSION_FIXTURE}>)
+set(UNITY_EXTENSION_MEMORY_ENABLED $<OR:${UNITY_EXTENSION_FIXTURE_ENABLED},$<BOOL:${UNITY_EXTENSION_MEMORY}>>)
+
+if(${UNITY_EXTENSION_FIXTURE})
+    message(STATUS "Unity: Building with the fixture extension.")
+endif()
+
+if(${UNITY_EXTENSION_MEMORY})
+    message(STATUS "Unity: Building with the memory extension.")
+endif()
+
+# Main target ------------------------------------------------------------------
+add_library(${PROJECT_NAME} STATIC)
+add_library(${PROJECT_NAME}::framework ALIAS ${PROJECT_NAME})
+
+# Includes ---------------------------------------------------------------------
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
+target_sources(${PROJECT_NAME}
+    PRIVATE
+        src/unity.c
+        $<$<BOOL:${UNITY_EXTENSION_FIXTURE_ENABLED}>:extras/fixture/src/unity_fixture.c>
+        $<$<BOOL:${UNITY_EXTENSION_MEMORY_ENABLED}>:extras/memory/src/unity_memory.c>
+)
+
+target_include_directories(${PROJECT_NAME}
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}>
+        $<BUILD_INTERFACE:$<$<BOOL:${UNITY_EXTENSION_MEMORY_ENABLED}>:${CMAKE_CURRENT_SOURCE_DIR}/extras/memory/src>>
+        $<BUILD_INTERFACE:$<$<BOOL:${UNITY_EXTENSION_FIXTURE_ENABLED}>:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src>>
+)
+
+set(${PROJECT_NAME}_PUBLIC_HEADERS
+        src/unity.h
+        src/unity_internals.h
+        $<$<BOOL:${UNITY_EXTENSION_FIXTURE_ENABLED}>:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src/unity_fixture.h>
+        $<$<BOOL:${UNITY_EXTENSION_FIXTURE_ENABLED}>:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src/unity_fixture_internals.h>
+        $<$<BOOL:${UNITY_EXTENSION_MEMORY_ENABLED}>:${CMAKE_CURRENT_SOURCE_DIR}/extras/memory/src/unity_memory.h>
+)
+
+set_target_properties(${PROJECT_NAME}
+    PROPERTIES 
+        C_STANDARD          11
+        C_STANDARD_REQUIRED ON
+        C_EXTENSIONS        OFF
+        PUBLIC_HEADER       "${${PROJECT_NAME}_PUBLIC_HEADERS}"
+        EXPORT_NAME         framework
+)
+
+target_compile_options(${PROJECT_NAME}
+    PRIVATE
+        # Clang
+        $<$<C_COMPILER_ID:Clang>:
+            -Wcast-align
+            -Wcast-qual
+            -Wconversion
+            -Wexit-time-destructors                            
+            -Wglobal-constructors
+            -Wmissing-noreturn
+            -Wmissing-prototypes
+            -Wno-missing-braces
+            -Wold-style-cast
+            -Wshadow
+            -Wweak-vtables
+            -Werror
+            -Wall
+            $<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,8.0.0>:-Wextra-semi-stmt>
+        >
+        
+        # GCC
+        $<$<C_COMPILER_ID:GNU>:
+            -Waddress
+            -Waggregate-return
+            -Wformat-nonliteral
+            -Wformat-security
+            -Wformat
+            -Winit-self
+            -Wmissing-declarations
+            -Wmissing-include-dirs
+            -Wno-multichar
+            -Wno-parentheses
+            -Wno-type-limits
+            -Wno-unused-parameter
+            -Wunreachable-code
+            -Wwrite-strings
+            -Wpointer-arith
+            -Werror
+            -Wall
+        >
+
+        # MSVC
+        $<$<C_COMPILER_ID:MSVC>:
+            /Wall
+        >
+)
+
+write_basic_package_version_file(${PROJECT_NAME}ConfigVersion.cmake
+    VERSION       ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion 
+)
+
+## Target installation
+install(TARGETS   ${PROJECT_NAME}
+    EXPORT        ${PROJECT_NAME}Targets
+    ARCHIVE       DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY       DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}
+    COMPONENT     library
+)
+
+## Target's cmake files: targets export
+install(EXPORT  ${PROJECT_NAME}Targets
+    NAMESPACE   ${PROJECT_NAME}::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
+)
+
+## Target's cmake files: config and version config for find_package()
+install(FILES   ${PROJECT_NAME}Config.cmake
+                ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
+)

LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) <year> 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams
+Copyright (c) <year> 2007-21 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

README.md

@@ -1,60 +1,26 @@
-Unity Test API
+# Unity Test ![CI][]
-==============
 
-[![Unity Build Status](https://api.travis-ci.org/ThrowTheSwitch/Unity.png?branch=master)](https://travis-ci.org/ThrowTheSwitch/Unity)
+__Copyright (c) 2007 - 2021 Unity Project by Mike Karlesky, Mark VanderVoord, and Greg Williams__
-__Copyright (c) 2007 - 2017 Unity Project by Mike Karlesky, Mark VanderVoord, and Greg Williams__
 
-Running Tests
+Welcome to the Unity Test Project, one of the main projects of ThrowTheSwitch.org.
--------------
+Unity Test is a unit testing framework built for C, with a focus on working with embedded toolchains.
 
-    RUN_TEST(func, linenum)
+This project is made to test code targetting microcontrollers big and small.
+The core project is a single C file and a pair of headers, allowing it to be added to your existing build setup without too much headache.
+You may use any compiler you wish, and may use most existing build systems including Make, CMake, etc.
+If you'd like to leave the hard work to us, you might be interested in Ceedling, a build tool also by ThrowTheSwitch.org.
 
-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.
+If you're new to Unity, we encourage you to tour the [getting started guide][].
 
-Ignoring Tests
+## Getting Started
---------------
 
-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.
+The [docs][] folder contains a [getting started guide][] and much more tips about using Unity.
 
-    TEST_IGNORE()
+## Unity Assertion Summary
 
-Ignore this test and return immediately
+For the full list, see [UnityAssertionsReference.md][].
 
-    TEST_IGNORE_MESSAGE (message)
+### Basic Validity Tests
-
-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())
-        {
-            MyTest();
-        }
-    }
-
-If MyTest calls `TEST_ABORT`, program control will immediately return to `TEST_PROTECT` with a return value of zero.
-
-
-Unity Assertion Summary
-=======================
-
-Basic Validity Tests
---------------------
 
     TEST_ASSERT_TRUE(condition)
 
@@ -75,10 +41,10 @@ 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.
+This test is automatically marked as a failure.
+The message is output stating why.
 
-Numerical Assertions: Integers
+### Numerical Assertions: Integers
-------------------------------
 
     TEST_ASSERT_EQUAL_INT(expected, actual)
     TEST_ASSERT_EQUAL_INT8(expected, actual)
@@ -86,9 +52,9 @@ Numerical Assertions: Integers
     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
+Compare two integers for equality and display errors as signed integers.
-to your natural integer size so often this can just be used.  When you need to specify the exact size,
+A cast will be performed to your natural integer size so often this can just be used.
-like when comparing arrays, you can use a specific version:
+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)
@@ -96,8 +62,8 @@ like when comparing arrays, you can use a specific version:
     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
+Compare two integers for equality and display errors as unsigned integers.
-variants for different sizes also.
+Like INT, there are variants for different sizes also.
 
     TEST_ASSERT_EQUAL_HEX(expected, actual)
     TEST_ASSERT_EQUAL_HEX8(expected, actual)
@@ -105,9 +71,8 @@ variants for different sizes also.
     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,
+Compares two integers for equality and display errors as hexadecimal.
-you can specify the size... here the size will also effect how many nibbles are shown (for example, `HEX16`
+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).
-will show 4 nibbles).
 
     TEST_ASSERT_EQUAL(expected, actual)
 
@@ -115,96 +80,126 @@ 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
+Asserts that the actual value is within plus or minus delta of the expected value.
-size specific variants.
+This also comes in size specific variants.
-
 
     TEST_ASSERT_GREATER_THAN(threshold, actual)
 
-Asserts that the actual value is greater than the threshold. This also comes in size specific variants.
+Asserts that the actual value is greater than the threshold.
-
+This also comes in size specific variants.
 
     TEST_ASSERT_LESS_THAN(threshold, actual)
 
-Asserts that the actual value is less than the threshold. This also comes in size specific variants.
+Asserts that the actual value is less than the threshold.
+This also comes in size specific variants.
 
-
+### Arrays
-Arrays
-------
 
     _ARRAY
 
-You can append `_ARRAY` to any of these macros to make an array comparison of that type.  Here you will
+You can append `_ARRAY` to any of these macros to make an array comparison of that type.
-need to care a bit more about the actual size of the value being checked.  You will also specify an
+Here you will need to care a bit more about the actual size of the value being checked.
-additional argument which is the number of elements to compare.  For example:
+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)
 
     _EACH_EQUAL
 
-Another array comparison option is to check that EVERY element of an array is equal to a single expected
+Another array comparison option is to check that EVERY element of an array is equal to a single expected value.
-value. You do this by specifying the EACH_EQUAL macro. For example:
+You do this by specifying the EACH_EQUAL macro.
+For example:
 
     TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, elements)
 
-Numerical Assertions: Bitwise
+### 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.
+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.
+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.
+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 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.
+Test a single bit and verify that it is low.
+The bit is specified 0-31 for a 32-bit integer.
 
-Numerical Assertions: Floats
+### Numerical Assertions: Floats
-----------------------------
 
     TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual)
+    TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual)
 
 Asserts that the actual value is within plus or minus delta of the expected value.
 
+    TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual)
+    TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual)
+
+Asserts that the actual value is NOT 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_NOT_EQUAL_FLOAT(expected, actual)
------------------
+    TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual)
+
+Asserts that two floating point values are NOT "equal" within a small % delta of the expected value.
+
+    TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual)
+    TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual)
+    TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual)
+    TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual)
+
+Asserts that the actual value is less than or greater than the threshold.
+
+There are also `LESS_OR_EQUAL` and `GREATER_OR_EQUAL` variations.
+These obey the same rules for equality as do `TEST_ASSERT_EQUAL_FLOAT` and `TEST_ASSERT_EQUAL_DOUBLE`:
+If the two values are within a small % delta of the expected value, the assertion will pass.
+
+### 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.
+Compare two null-terminate strings.
+Fail if any character is different or if the lengths are different.
 
     TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len)
 
-Compare two strings.  Fail if any character is different, stop comparing after len characters.
+Compare two strings.
+Fail if any character is different, stop comparing after len characters.
 
     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.
+Compare two null-terminate strings.
+Fail if any character is different or if the lengths are different.
+Output a custom message on failure.
 
     TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message)
 
-Compare two strings.  Fail if any character is different, stop comparing after len characters. Output a custom message on failure.
+Compare two strings.
+Fail if any character is different, stop comparing after len characters.
+Output a custom message on failure.
 
-Pointer Assertions
+### 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.
+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)
 
@@ -214,18 +209,20 @@ Fails if the pointer is not equal to NULL
 
 Fails if the pointer is equal to NULL
 
-Memory Assertions
+### 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
+Compare two blocks of memory.
-standard types... but since it's a memory compare, you have to be careful that your data types are packed.
+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
+### \_MESSAGE
---------
 
-you can append _MESSAGE to any of the macros to make them take an additional argument.  This argument
+You can append `\_MESSAGE` to any of the macros to make them take an additional argument.
-is a string that will be printed at the end of the failure strings.  This is useful for specifying more
+This argument is a string that will be printed at the end of the failure strings.
-information about the problem.
+This is useful for specifying more information about the problem.
 
+[CI]: https://github.com/ThrowTheSwitch/Unity/workflows/CI/badge.svg
+[getting started guide]: docs/UnityGettingStartedGuide.md
+[docs]: docs/
+[UnityAssertionsReference.md]: docs/UnityAssertionsReference.md

auto/colour_prompt.rb

@@ -22,9 +22,10 @@ end
 class ColourCommandLine
   def initialize
     return unless RUBY_PLATFORM =~ /(win|w)32$/
+
     get_std_handle = Win32API.new('kernel32', 'GetStdHandle', ['L'], 'L')
     @set_console_txt_attrb =
-      Win32API.new('kernel32', 'SetConsoleTextAttribute', %w(L N), 'I')
+      Win32API.new('kernel32', 'SetConsoleTextAttribute', %w[L N], 'I')
     @hout = get_std_handle.call(-11)
   end
 
@@ -107,7 +108,7 @@ class ColourCommandLine
       $stdout.print("#{change_to(colour)}#{str}\033[0m") if mode == :print
     end
   end
-end # ColourCommandLine
+end
 
 def colour_puts(role, str)
   ColourCommandLine.new.out_c(:puts, role, str)

auto/colour_reporter.rb

@@ -4,7 +4,7 @@
 #   [Released under MIT License. Please refer to license.txt for details]
 # ==========================================
 
-require "#{File.expand_path(File.dirname(__FILE__))}/colour_prompt"
+require_relative 'colour_prompt'
 
 $colour_output = true
 

auto/extract_version.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+import re
+import sys
+
+ver_re = re.compile(r"^#define\s+UNITY_VERSION_(?:MAJOR|MINOR|BUILD)\s+(\d+)$")
+version = []
+
+with open(sys.argv[1], "r") as f:
+    for line in f:
+        m = ver_re.match(line)
+        if m:
+            version.append(m.group(1))
+
+print(".".join(version))
+

auto/generate_module.rb

@@ -13,7 +13,10 @@ require 'fileutils'
 require 'pathname'
 
 # TEMPLATE_TST
-TEMPLATE_TST ||= '#include "unity.h"
+TEMPLATE_TST ||= '#ifdef TEST
+
+#include "unity.h"
+
 %2$s#include "%1$s.h"
 
 void setUp(void)
@@ -24,10 +27,12 @@ void tearDown(void)
 {
 }
 
-void test_%1$s_NeedToImplement(void)
+void test_%4$s_NeedToImplement(void)
 {
     TEST_IGNORE_MESSAGE("Need to Implement %1$s");
 }
+
+#endif // TEST
 '.freeze
 
 # TEMPLATE_SRC
@@ -35,18 +40,16 @@ TEMPLATE_SRC ||= '%2$s#include "%1$s.h"
 '.freeze
 
 # TEMPLATE_INC
-TEMPLATE_INC ||= '#ifndef _%3$s_H
+TEMPLATE_INC ||= '#ifndef %3$s_H
-#define _%3$s_H
+#define %3$s_H
 %2$s
 
-#endif // _%3$s_H
+#endif // %3$s_H
 '.freeze
 
 class UnityModuleGenerator
   ############################
   def initialize(options = nil)
-    here = File.expand_path(File.dirname(__FILE__)) + '/'
-
     @options = UnityModuleGenerator.default_options
     case options
     when NilClass then @options
@@ -56,9 +59,9 @@ class UnityModuleGenerator
     end
 
     # Create default file paths if none were provided
-    @options[:path_src] = here + '../src/'    if @options[:path_src].nil?
+    @options[:path_src] = "#{__dir__}/../src/"   if @options[:path_src].nil?
-    @options[:path_inc] = @options[:path_src] if @options[:path_inc].nil?
+    @options[:path_inc] = @options[:path_src]    if @options[:path_inc].nil?
-    @options[:path_tst] = here + '../test/'   if @options[:path_tst].nil?
+    @options[:path_tst] = "#{__dir__}/../test/"  if @options[:path_tst].nil?
     @options[:path_src] += '/'                unless @options[:path_src][-1] == 47
     @options[:path_inc] += '/'                unless @options[:path_inc][-1] == 47
     @options[:path_tst] += '/'                unless @options[:path_tst][-1] == 47
@@ -113,8 +116,8 @@ class UnityModuleGenerator
   def self.grab_config(config_file)
     options = default_options
     unless config_file.nil? || config_file.empty?
-      require 'yaml'
+      require_relative 'yaml_helper'
-      yaml_guts = YAML.load_file(config_file)
+      yaml_guts = YamlHelper.load_file(config_file)
       options.merge!(yaml_guts[:unity] || yaml_guts[:cmock])
       raise "No :unity or :cmock section found in #{config_file}" unless options
     end
@@ -164,24 +167,23 @@ class UnityModuleGenerator
     files
   end
 
+  ############################
+  def neutralize_filename(name, start_cap = true)
+    return name if name.empty?
+    name = name.split(/(?:\s+|_|(?=[A-Z][a-z]))|(?<=[a-z])(?=[A-Z])/).map(&:capitalize).join('_')
+    name = name[0].downcase + name[1..-1] unless start_cap
+    name
+  end
+
   ############################
   def create_filename(part1, part2 = '')
-    if part2.empty?
+    name = part2.empty? ? part1 : part1 + '_' + part2
-      case (@options[:naming])
+    case (@options[:naming])
-      when 'bumpy' then part1
+    when 'bumpy' then neutralize_filename(name, false).delete('_')
-      when 'camel' then part1
+    when 'camel' then neutralize_filename(name).delete('_')
-      when 'snake' then part1.downcase
+    when 'snake' then neutralize_filename(name).downcase
-      when 'caps'  then part1.upcase
+    when 'caps'  then neutralize_filename(name).upcase
-      else              part1
+    else              name
-      end
-    else
-      case (@options[:naming])
-      when 'bumpy' then part1 + part2
-      when 'camel' then part1 + part2
-      when 'snake' then part1.downcase + '_' + part2.downcase
-      when 'caps'  then part1.upcase + '_' + part2.upcase
-      else              part1 + '_' + part2
-      end
     end
   end
 
@@ -209,7 +211,8 @@ class UnityModuleGenerator
         f.write("#{file[:boilerplate]}\n" % [file[:name]]) unless file[:boilerplate].nil?
         f.write(file[:template] % [file[:name],
                                    file[:includes].map { |ff| "#include \"#{ff}\"\n" }.join,
-                                   file[:name].upcase])
+                                   file[:name].upcase.tr('-', '_'),
+                                   file[:name].tr('-', '_')])
       end
       if @options[:update_svn]
         `svn add \"#{file[:path]}\"`
@@ -265,6 +268,7 @@ if $0 == __FILE__
     when /^-y\"?(.+)\"?/  then options = UnityModuleGenerator.grab_config(Regexp.last_match(1))
     when /^(\w+)/
       raise "ERROR: You can't have more than one Module name specified!" unless module_name.nil?
+
       module_name = arg
     when /^-(h|-help)/
       ARGV = [].freeze
@@ -299,6 +303,7 @@ if $0 == __FILE__
   end
 
   raise 'ERROR: You must have a Module name specified! (use option -h for help)' if module_name.nil?
+
   if destroy
     UnityModuleGenerator.new(options).destroy(module_name)
   else

auto/generate_test_runner.rb

@@ -1,21 +1,30 @@
+#!/usr/bin/ruby
+
 # ==========================================
 #   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]
 # ==========================================
 
-File.expand_path(File.join(File.dirname(__FILE__), 'colour_prompt'))
-
 class UnityTestRunnerGenerator
   def initialize(options = nil)
     @options = UnityTestRunnerGenerator.default_options
     case options
-    when NilClass then @options
+    when NilClass
-    when String   then @options.merge!(UnityTestRunnerGenerator.grab_config(options))
+      @options
-    when Hash     then @options.merge!(options)
+    when String
-    else raise 'If you specify arguments, it should be a filename or a hash of options'
+      @options.merge!(UnityTestRunnerGenerator.grab_config(options))
+    when Hash
+      # Check if some of these have been specified
+      @options[:has_setup] = !options[:setup_name].nil?
+      @options[:has_teardown] = !options[:teardown_name].nil?
+      @options[:has_suite_setup] = !options[:suite_setup].nil?
+      @options[:has_suite_teardown] = !options[:suite_teardown].nil?
+      @options.merge!(options)
+    else
+      raise 'If you specify arguments, it should be a filename or a hash of options'
     end
-    require "#{File.expand_path(File.dirname(__FILE__))}/type_sanitizer"
+    require_relative 'type_sanitizer'
   end
 
   def self.default_options
@@ -26,20 +35,26 @@ class UnityTestRunnerGenerator
       framework: :unity,
       test_prefix: 'test|spec|should',
       mock_prefix: 'Mock',
+      mock_suffix: '',
       setup_name: 'setUp',
       teardown_name: 'tearDown',
+      test_reset_name: 'resetTest',
+      test_verify_name: 'verifyTest',
       main_name: 'main', # set to :auto to automatically generate each time
       main_export_decl: '',
       cmdline_args: false,
-      use_param_tests: false
+      omit_begin_end: false,
+      use_param_tests: false,
+      include_extensions: '(?:hpp|hh|H|h)',
+      source_extensions: '(?:cpp|cc|ino|C|c)'
     }
   end
 
   def self.grab_config(config_file)
     options = default_options
     unless config_file.nil? || config_file.empty?
-      require 'yaml'
+      require_relative 'yaml_helper'
-      yaml_guts = YAML.load_file(config_file)
+      yaml_guts = YamlHelper.load_file(config_file)
       options.merge!(yaml_guts[:unity] || yaml_guts[:cmock])
       raise "No :unity or :cmock section found in #{config_file}" unless options
     end
@@ -52,12 +67,13 @@ class UnityTestRunnerGenerator
     # pull required data from source file
     source = File.read(input_file)
     source = source.force_encoding('ISO-8859-1').encode('utf-8', replace: nil)
-    tests               = find_tests(source)
+    tests = find_tests(source)
-    headers             = find_includes(source)
+    headers = find_includes(source)
-    testfile_includes   = (headers[:local] + headers[:system])
+    testfile_includes = (headers[:local] + headers[:system])
-    used_mocks          = find_mocks(testfile_includes)
+    used_mocks = find_mocks(testfile_includes)
-    testfile_includes   = (testfile_includes - used_mocks)
+    testfile_includes = (testfile_includes - used_mocks)
     testfile_includes.delete_if { |inc| inc =~ /(unity|cmock)/ }
+    find_setup_and_teardown(source)
 
     # build runner file
     generate(input_file, output_file, tests, used_mocks, testfile_includes)
@@ -75,9 +91,13 @@ class UnityTestRunnerGenerator
       create_header(output, used_mocks, testfile_includes)
       create_externs(output, tests, used_mocks)
       create_mock_management(output, used_mocks)
+      create_setup(output)
+      create_teardown(output)
       create_suite_setup(output)
       create_suite_teardown(output)
-      create_reset(output, used_mocks)
+      create_reset(output)
+      create_run_test(output) unless tests.empty?
+      create_args_wrappers(output, tests)
       create_main(output, input_file, tests, used_mocks)
     end
 
@@ -91,27 +111,64 @@ class UnityTestRunnerGenerator
   def find_tests(source)
     tests_and_line_numbers = []
 
+    # contains characters which will be substituted from within strings, doing
+    # this prevents these characters from interfering with scrubbers
+    # @ is not a valid C character, so there should be no clashes with files genuinely containing these markers
+    substring_subs = { '{' => '@co@', '}' => '@cc@', ';' => '@ss@', '/' => '@fs@' }
+    substring_re = Regexp.union(substring_subs.keys)
+    substring_unsubs = substring_subs.invert                   # the inverse map will be used to fix the strings afterwords
+    substring_unsubs['@quote@'] = '\\"'
+    substring_unsubs['@apos@'] = '\\\''
+    substring_unre = Regexp.union(substring_unsubs.keys)
     source_scrubbed = source.clone
-    source_scrubbed = source_scrubbed.gsub(/"[^"\n]*"/, '') # remove things in strings
+    source_scrubbed = source_scrubbed.gsub(/\\"/, '@quote@')   # hide escaped quotes to allow capture of the full string/char
-    source_scrubbed = source_scrubbed.gsub(/\/\/.*$/, '')      # remove line comments
+    source_scrubbed = source_scrubbed.gsub(/\\'/, '@apos@')    # hide escaped apostrophes to allow capture of the full string/char
-    source_scrubbed = source_scrubbed.gsub(/\/\*.*?\*\//m, '') # remove block comments
+    source_scrubbed = source_scrubbed.gsub(/("[^"\n]*")|('[^'\n]*')/) { |s| s.gsub(substring_re, substring_subs) } # temporarily hide problematic characters within strings
-    lines = source_scrubbed.split(/(^\s*\#.*$)                 # Treat preprocessor directives as a logical line
+    source_scrubbed = source_scrubbed.gsub(/\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '')  # remove line comments that comment out the start of blocks
-                              | (;|\{|\}) /x)                  # Match ;, {, and } as end of lines
+    source_scrubbed = source_scrubbed.gsub(/\/\*.*?\*\//m, '')                     # remove block comments
+    source_scrubbed = source_scrubbed.gsub(/\/\/.*$/, '')                          # remove line comments (all that remain)
+    lines = source_scrubbed.split(/(^\s*\#.*$) | (;|\{|\}) /x)                     # Treat preprocessor directives as a logical line. Match ;, {, and } as end of lines
+                           .map { |line| line.gsub(substring_unre, substring_unsubs) } # unhide the problematic characters previously removed
 
     lines.each_with_index do |line, _index|
       # find tests
-      next unless line =~ /^((?:\s*TEST_CASE\s*\(.*?\)\s*)*)\s*void\s+((?:#{@options[:test_prefix]}).*)\s*\(\s*(.*)\s*\)/
+      next unless line =~ /^((?:\s*(?:TEST_CASE|TEST_RANGE)\s*\(.*?\)\s*)*)\s*void\s+((?:#{@options[:test_prefix]}).*)\s*\(\s*(.*)\s*\)/m
+      next unless line =~ /^((?:\s*(?:TEST_CASE|TEST_RANGE)\s*\(.*?\)\s*)*)\s*void\s+((?:#{@options[:test_prefix]})\w*)\s*\(\s*(.*)\s*\)/m
+
       arguments = Regexp.last_match(1)
       name = Regexp.last_match(2)
       call = Regexp.last_match(3)
       params = Regexp.last_match(4)
       args = nil
+
       if @options[:use_param_tests] && !arguments.empty?
         args = []
-        arguments.scan(/\s*TEST_CASE\s*\((.*)\)\s*$/) { |a| args << a[0] }
+        type_and_args = arguments.split(/TEST_(CASE|RANGE)/)
+        for i in (1...type_and_args.length).step(2)
+          if type_and_args[i] == "CASE"
+            args << type_and_args[i + 1].sub(/^\s*\(\s*(.*?)\s*\)\s*$/m, '\1')
+            next
+          end
+
+          # RANGE
+          args += type_and_args[i + 1].scan(/(\[|<)\s*(-?\d+.?\d*)\s*,\s*(-?\d+.?\d*)\s*,\s*(-?\d+.?\d*)\s*(\]|>)/m).map do |arg_values_str|
+            exclude_end = arg_values_str[0] == '<' && arg_values_str[-1] == '>'
+            arg_values_str[1...-1].map do |arg_value_str|
+              arg_value_str.include?('.') ? arg_value_str.to_f : arg_value_str.to_i
+            end.push(exclude_end)
+          end.map do |arg_values|
+            Range.new(arg_values[0], arg_values[1], arg_values[3]).step(arg_values[2]).to_a
+          end.reduce(nil) do |result, arg_range_expanded|
+            result.nil? ? arg_range_expanded.map { |a| [a] } : result.product(arg_range_expanded)
+          end.map do |arg_combinations|
+            arg_combinations.flatten.join(', ')
+          end
+        end
       end
+
       tests_and_line_numbers << { test: name, args: args, call: call, params: params, line_number: 0 }
     end
+
     tests_and_line_numbers.uniq! { |v| v[:test] }
 
     # determine line numbers and create tests to run
@@ -120,6 +177,7 @@ class UnityTestRunnerGenerator
     tests_and_line_numbers.size.times do |i|
       source_lines[source_index..-1].each_with_index do |line, index|
         next unless line =~ /\s+#{tests_and_line_numbers[i][:test]}(?:\s|\()/
+
         source_index += index
         tests_and_line_numbers[i][:line_number] = source_index + 1
         break
@@ -137,9 +195,9 @@ class UnityTestRunnerGenerator
 
     # parse out includes
     includes = {
-      local: source.scan(/^\s*#include\s+\"\s*(.+)\.[hH]\s*\"/).flatten,
+      local: source.scan(/^\s*#include\s+\"\s*(.+\.#{@options[:include_extensions]})\s*\"/).flatten,
       system: source.scan(/^\s*#include\s+<\s*(.+)\s*>/).flatten.map { |inc| "<#{inc}>" },
-      linkonly: source.scan(/^TEST_FILE\(\s*\"\s*(.+)\.[cC]\w*\s*\"/).flatten
+      linkonly: source.scan(/^TEST_FILE\(\s*\"\s*(.+\.#{@options[:source_extensions]})\s*\"/).flatten
     }
     includes
   end
@@ -148,35 +206,43 @@ class UnityTestRunnerGenerator
     mock_headers = []
     includes.each do |include_path|
       include_file = File.basename(include_path)
-      mock_headers << include_path if include_file =~ /^#{@options[:mock_prefix]}/i
+      mock_headers << include_path if include_file =~ /^#{@options[:mock_prefix]}.*#{@options[:mock_suffix]}\.h$/i
     end
     mock_headers
   end
 
+  def find_setup_and_teardown(source)
+    @options[:has_setup] = source =~ /void\s+#{@options[:setup_name]}\s*\(/
+    @options[:has_teardown] = source =~ /void\s+#{@options[:teardown_name]}\s*\(/
+    @options[:has_suite_setup] ||= (source =~ /void\s+suiteSetUp\s*\(/)
+    @options[:has_suite_teardown] ||= (source =~ /int\s+suiteTearDown\s*\(int\s+([a-zA-Z0-9_])+\s*\)/)
+  end
+
   def create_header(output, mocks, testfile_includes = [])
     output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */')
-    create_runtest(output, mocks)
     output.puts("\n/*=======Automagically Detected Files To Include=====*/")
+    output.puts('extern "C" {') if @options[:externcincludes]
     output.puts("#include \"#{@options[:framework]}.h\"")
     output.puts('#include "cmock.h"') unless mocks.empty?
-    output.puts('#include <setjmp.h>')
+    output.puts('}') if @options[:externcincludes]
-    output.puts('#include <stdio.h>')
     if @options[:defines] && !@options[:defines].empty?
-      @options[:defines].each { |d| output.puts("#define #{d}") }
+      @options[:defines].each { |d| output.puts("#ifndef #{d}\n#define #{d}\n#endif /* #{d} */") }
     end
     if @options[:header_file] && !@options[:header_file].empty?
       output.puts("#include \"#{File.basename(@options[:header_file])}\"")
     else
       @options[:includes].flatten.uniq.compact.each do |inc|
-        output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}")
+        output.puts("#include #{inc.include?('<') ? inc : "\"#{inc}\""}")
       end
       testfile_includes.each do |inc|
-        output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}")
+        output.puts("#include #{inc.include?('<') ? inc : "\"#{inc}\""}")
       end
     end
+    output.puts('extern "C" {') if @options[:externcincludes]
     mocks.each do |mock|
-      output.puts("#include \"#{mock.gsub('.h', '')}.h\"")
+      output.puts("#include \"#{mock}\"")
     end
+    output.puts('}') if @options[:externcincludes]
     output.puts('#include "CException.h"') if @options[:plugins].include?(:cexception)
 
     return unless @options[:enforce_strict_ordering]
@@ -191,15 +257,15 @@ class UnityTestRunnerGenerator
     output.puts("\n/*=======External Functions This Runner Calls=====*/")
     output.puts("extern void #{@options[:setup_name]}(void);")
     output.puts("extern void #{@options[:teardown_name]}(void);")
+    output.puts("\n#ifdef __cplusplus\nextern \"C\"\n{\n#endif") if @options[:externc]
     tests.each do |test|
       output.puts("extern void #{test[:test]}(#{test[:call] || 'void'});")
     end
+    output.puts("#ifdef __cplusplus\n}\n#endif") if @options[:externc]
     output.puts('')
   end
 
   def create_mock_management(output, mock_headers)
-    return if mock_headers.empty?
-
     output.puts("\n/*=======Mock Management=====*/")
     output.puts('static void CMock_Init(void)')
     output.puts('{')
@@ -210,7 +276,7 @@ class UnityTestRunnerGenerator
       output.puts('  GlobalOrderError = NULL;')
     end
 
-    mocks = mock_headers.map { |mock| File.basename(mock) }
+    mocks = mock_headers.map { |mock| File.basename(mock, '.*') }
     mocks.each do |mock|
       mock_clean = TypeSanitizer.sanitize_c_identifier(mock)
       output.puts("  #{mock_clean}_Init();")
@@ -234,11 +300,25 @@ class UnityTestRunnerGenerator
     output.puts("}\n")
   end
 
+  def create_setup(output)
+    return if @options[:has_setup]
+
+    output.puts("\n/*=======Setup (stub)=====*/")
+    output.puts("void #{@options[:setup_name]}(void) {}")
+  end
+
+  def create_teardown(output)
+    return if @options[:has_teardown]
+
+    output.puts("\n/*=======Teardown (stub)=====*/")
+    output.puts("void #{@options[:teardown_name]}(void) {}")
+  end
+
   def create_suite_setup(output)
     return if @options[:suite_setup].nil?
 
     output.puts("\n/*=======Suite Setup=====*/")
-    output.puts('static void suite_setup(void)')
+    output.puts('void suiteSetUp(void)')
     output.puts('{')
     output.puts(@options[:suite_setup])
     output.puts('}')
@@ -248,60 +328,55 @@ class UnityTestRunnerGenerator
     return if @options[:suite_teardown].nil?
 
     output.puts("\n/*=======Suite Teardown=====*/")
-    output.puts('static int suite_teardown(int num_failures)')
+    output.puts('int suiteTearDown(int num_failures)')
     output.puts('{')
     output.puts(@options[:suite_teardown])
     output.puts('}')
   end
 
-  def create_runtest(output, used_mocks)
+  def create_reset(output)
-    cexception = @options[:plugins].include? :cexception
+    output.puts("\n/*=======Test Reset Options=====*/")
-    va_args1   = @options[:use_param_tests] ? ', ...' : ''
+    output.puts("void #{@options[:test_reset_name]}(void);")
-    va_args2   = @options[:use_param_tests] ? '__VA_ARGS__' : ''
+    output.puts("void #{@options[:test_reset_name]}(void)")
-    output.puts("\n/*=======Test Runner Used To Run Each Test Below=====*/")
-    output.puts('#define RUN_TEST_NO_ARGS') if @options[:use_param_tests]
-    output.puts("#define RUN_TEST(TestFunc, TestLineNum#{va_args1}) \\")
-    output.puts('{ \\')
-    output.puts("  Unity.CurrentTestName = #TestFunc#{va_args2.empty? ? '' : " \"(\" ##{va_args2} \")\""}; \\")
-    output.puts('  Unity.CurrentTestLineNumber = TestLineNum; \\')
-    output.puts('  if (UnityTestMatches()) { \\') if @options[:cmdline_args]
-    output.puts('  Unity.NumberOfTests++; \\')
-    output.puts('  CMock_Init(); \\') unless used_mocks.empty?
-    output.puts('  UNITY_CLR_DETAILS(); \\') unless used_mocks.empty?
-    output.puts('  if (TEST_PROTECT()) \\')
-    output.puts('  { \\')
-    output.puts('    CEXCEPTION_T e; \\') if cexception
-    output.puts('    Try { \\') if cexception
-    output.puts("      #{@options[:setup_name]}(); \\")
-    output.puts("      TestFunc(#{va_args2}); \\")
-    output.puts('    } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \\') if cexception
-    output.puts('  } \\')
-    output.puts('  if (TEST_PROTECT()) \\')
-    output.puts('  { \\')
-    output.puts("    #{@options[:teardown_name]}(); \\")
-    output.puts('    CMock_Verify(); \\') unless used_mocks.empty?
-    output.puts('  } \\')
-    output.puts('  CMock_Destroy(); \\') unless used_mocks.empty?
-    output.puts('  UnityConcludeTest(); \\')
-    output.puts('  } \\') if @options[:cmdline_args]
-    output.puts("}\n")
-  end
-
-  def create_reset(output, used_mocks)
-    output.puts("\n/*=======Test Reset Option=====*/")
-    output.puts('void resetTest(void);')
-    output.puts('void resetTest(void)')
     output.puts('{')
-    output.puts('  CMock_Verify();') unless used_mocks.empty?
-    output.puts('  CMock_Destroy();') unless used_mocks.empty?
     output.puts("  #{@options[:teardown_name]}();")
-    output.puts('  CMock_Init();') unless used_mocks.empty?
+    output.puts('  CMock_Verify();')
+    output.puts('  CMock_Destroy();')
+    output.puts('  CMock_Init();')
     output.puts("  #{@options[:setup_name]}();")
     output.puts('}')
+    output.puts("void #{@options[:test_verify_name]}(void);")
+    output.puts("void #{@options[:test_verify_name]}(void)")
+    output.puts('{')
+    output.puts('  CMock_Verify();')
+    output.puts('}')
+  end
+
+  def create_run_test(output)
+    require 'erb'
+    file = File.read(File.join(__dir__, 'run_test.erb'))
+    template = ERB.new(file, trim_mode: '<>')
+    output.puts("\n" + template.result(binding))
+  end
+
+  def create_args_wrappers(output, tests)
+    return unless @options[:use_param_tests]
+
+    output.puts("\n/*=======Parameterized Test Wrappers=====*/")
+    tests.each do |test|
+      next if test[:args].nil? || test[:args].empty?
+
+      test[:args].each.with_index(1) do |args, idx|
+        output.puts("static void runner_args#{idx}_#{test[:test]}(void)")
+        output.puts('{')
+        output.puts("    #{test[:test]}(#{args});")
+        output.puts("}\n")
+      end
+    end
   end
 
   def create_main(output, filename, tests, used_mocks)
-    output.puts("\n\n/*=======MAIN=====*/")
+    output.puts("\n/*=======MAIN=====*/")
     main_name = @options[:main_name].to_sym == :auto ? "main_#{filename.gsub('.c', '')}" : (@options[:main_name]).to_s
     if @options[:cmdline_args]
       if main_name != 'main'
@@ -314,50 +389,59 @@ class UnityTestRunnerGenerator
       output.puts('  {')
       output.puts('    if (parse_status < 0)')
       output.puts('    {')
-      output.puts("      UnityPrint(\"#{filename.gsub('.c', '')}.\");")
+      output.puts("      UnityPrint(\"#{filename.gsub('.c', '').gsub(/\\/, '\\\\\\')}.\");")
       output.puts('      UNITY_PRINT_EOL();')
-      if @options[:use_param_tests]
+      tests.each do |test|
-        tests.each do |test|
+        if (!@options[:use_param_tests]) || test[:args].nil? || test[:args].empty?
-          if test[:args].nil? || test[:args].empty?
+          output.puts("      UnityPrint(\"  #{test[:test]}\");")
-            output.puts("      UnityPrint(\"  #{test[:test]}(RUN_TEST_NO_ARGS)\");")
+          output.puts('      UNITY_PRINT_EOL();')
+        else
+          test[:args].each do |args|
+            output.puts("      UnityPrint(\"  #{test[:test]}(#{args})\");")
             output.puts('      UNITY_PRINT_EOL();')
-          else
-            test[:args].each do |args|
-              output.puts("      UnityPrint(\"  #{test[:test]}(#{args})\");")
-              output.puts('      UNITY_PRINT_EOL();')
-            end
           end
         end
-      else
-        tests.each { |test| output.puts("      UnityPrint(\"  #{test[:test]}\");\n    UNITY_PRINT_EOL();") }
       end
-      output.puts('    return 0;')
+      output.puts('      return 0;')
       output.puts('    }')
-      output.puts('  return parse_status;')
+      output.puts('    return parse_status;')
       output.puts('  }')
     else
+      main_return = @options[:omit_begin_end] ? 'void' : 'int'
       if main_name != 'main'
-        output.puts("#{@options[:main_export_decl]} int #{main_name}(void);")
+        output.puts("#{@options[:main_export_decl]} #{main_return} #{main_name}(void);")
       end
-      output.puts("int #{main_name}(void)")
+      output.puts("#{main_return} #{main_name}(void)")
       output.puts('{')
     end
-    output.puts('  suite_setup();') unless @options[:suite_setup].nil?
+    output.puts('  suiteSetUp();') if @options[:has_suite_setup]
-    output.puts("  UnityBegin(\"#{filename.gsub(/\\/, '\\\\\\')}\");")
+    if @options[:omit_begin_end]
-    if @options[:use_param_tests]
+      output.puts("  UnitySetTestFile(\"#{filename.gsub(/\\/, '\\\\\\')}\");")
-      tests.each do |test|
+    else
-        if test[:args].nil? || test[:args].empty?
+      output.puts("  UnityBegin(\"#{filename.gsub(/\\/, '\\\\\\')}\");")
-          output.puts("  RUN_TEST(#{test[:test]}, #{test[:line_number]}, RUN_TEST_NO_ARGS);")
+    end
-        else
+    tests.each do |test|
-          test[:args].each { |args| output.puts("  RUN_TEST(#{test[:test]}, #{test[:line_number]}, #{args});") }
+      if (!@options[:use_param_tests]) || test[:args].nil? || test[:args].empty?
+        output.puts("  run_test(#{test[:test]}, \"#{test[:test]}\", #{test[:line_number]});")
+      else
+        test[:args].each.with_index(1) do |args, idx|
+          wrapper = "runner_args#{idx}_#{test[:test]}"
+          testname = "#{test[:test]}(#{args})".dump
+          output.puts("  run_test(#{wrapper}, #{testname}, #{test[:line_number]});")
         end
       end
-    else
-      tests.each { |test| output.puts("  RUN_TEST(#{test[:test]}, #{test[:line_number]});") }
     end
     output.puts
     output.puts('  CMock_Guts_MemFreeFinal();') unless used_mocks.empty?
-    output.puts("  return #{@options[:suite_teardown].nil? ? '' : 'suite_teardown'}(UnityEnd());")
+    if @options[:has_suite_teardown]
+      if @options[:omit_begin_end]
+        output.puts('  (void) suite_teardown(0);')
+      else
+        output.puts('  return suiteTearDown(UnityEnd());')
+      end
+    else
+      output.puts('  return UnityEnd();') unless @options[:omit_begin_end]
+    end
     output.puts('}')
   end
 
@@ -369,10 +453,10 @@ class UnityTestRunnerGenerator
     output.puts("#include \"#{@options[:framework]}.h\"")
     output.puts('#include "cmock.h"') unless used_mocks.empty?
     @options[:includes].flatten.uniq.compact.each do |inc|
-      output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}")
+      output.puts("#include #{inc.include?('<') ? inc : "\"#{inc}\""}")
     end
     testfile_includes.each do |inc|
-      output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}")
+      output.puts("#include #{inc.include?('<') ? inc : "\"#{inc}\""}")
     end
     output.puts "\n"
     tests.each do |test|
@@ -395,13 +479,16 @@ if $0 == __FILE__
     when '-cexception'
       options[:plugins] = [:cexception]
       true
-    when /\.*\.ya?ml/
+    when '-externcincludes'
+      options[:externcincludes] = true
+      true
+    when /\.*\.ya?ml$/
       options = UnityTestRunnerGenerator.grab_config(arg)
       true
     when /--(\w+)=\"?(.*)\"?/
       options[Regexp.last_match(1).to_sym] = Regexp.last_match(2)
       true
-    when /\.*\.h/
+    when /\.*\.(?:hpp|hh|H|h)$/
       options[:includes] << arg
       true
     else false
@@ -419,13 +506,17 @@ if $0 == __FILE__
           '    *.h                   - header files are added as #includes in runner',
           '  options:',
           '    -cexception           - include cexception support',
+          '    -externc              - add extern "C" for cpp support',
           '    --setup_name=""       - redefine setUp func name to something else',
           '    --teardown_name=""    - redefine tearDown func name to something else',
           '    --main_name=""        - redefine main func name to something else',
           '    --test_prefix=""      - redefine test prefix from default test|spec|should',
+          '    --test_reset_name=""  - redefine resetTest func name to something else',
+          '    --test_verify_name="" - redefine verifyTest func name to something else',
           '    --suite_setup=""      - code to execute for setup of entire suite',
           '    --suite_teardown=""   - code to execute for teardown of entire suite',
           '    --use_param_tests=1   - enable parameterized tests (disabled by default)',
+          '    --omit_begin_end=1    - omit calls to UnityBegin and UnityEnd (disabled by default)',
           '    --header_file=""      - path/name of test header file to generate too'].join("\n")
     exit 1
   end

auto/parse_output.rb

@@ -1,206 +1,367 @@
 #============================================================
-#  Author:   John Theofanopoulos
+#  Author: John Theofanopoulos
-#  A simple parser.   Takes the output files generated during the build process and
+#  A simple parser. Takes the output files generated during the
-# extracts information relating to the tests.
+#  build process and extracts information relating to the tests.
 #
 #  Notes:
 #    To capture an output file under VS builds use the following:
-#      devenv [build instructions]  > Output.txt & type Output.txt
+#      devenv [build instructions] > Output.txt & type Output.txt
 #
-#    To capture an output file under GCC/Linux builds use the following:
+#    To capture an output file under Linux builds use the following:
 #      make | tee Output.txt
 #
+#    This script can handle the following output formats:
+#    - normal output (raw unity)
+#    - fixture output (unity_fixture.h/.c)
+#    - fixture output with verbose flag set ("-v")
+#    - time output flag set (UNITY_INCLUDE_EXEC_TIME define enabled with milliseconds output)
+#
 #    To use this parser use the following command
 #    ruby parseOutput.rb [options] [file]
-#        options:  -xml  : produce a JUnit compatible XML file
+#        options: -xml  : produce a JUnit compatible XML file
-#        file      :  file to scan for results
+#                 -suiteRequiredSuiteName
+#                       : replace default test suite name to
+#                           "RequiredSuiteName" (can be any name)
+#           file: file to scan for results
 #============================================================
 
+# Parser class for handling the input file
 class ParseOutput
   def initialize
-    @test_flag = false
+    # internal data
+    @class_name_idx = 0
+    @result_usual_idx = 3
+    @path_delim = nil
+
+    # xml output related
     @xml_out = false
     @array_list = false
-    @total_tests = false
+
-    @class_index = false
+    # current suite name and statistics
+    ## testsuite name
+    @real_test_suite_name = 'Unity'
+    ## classname for testcase
+    @test_suite = nil
+    @total_tests = 0
+    @test_passed = 0
+    @test_failed = 0
+    @test_ignored = 0
   end
 
-  #   Set the flag to indicate if there will be an XML output file or not
+  # Set the flag to indicate if there will be an XML output file or not
   def set_xml_output
     @xml_out = true
   end
 
-  #  if write our output to XML
+  # Set the flag to indicate if there will be an XML output file or not
+  def test_suite_name=(cli_arg)
+    @real_test_suite_name = cli_arg
+    puts 'Real test suite name will be \'' + @real_test_suite_name + '\''
+  end
+
+  def xml_encode_s(str)
+    str.encode(:xml => :attr)
+  end
+
+  # If write our output to XML
   def write_xml_output
     output = File.open('report.xml', 'w')
     output << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
     @array_list.each do |item|
       output << item << "\n"
     end
-    output << "</testsuite>\n"
   end
 
-  #  This function will try and determine when the suite is changed.   This is
+  # Pushes the suite info as xml to the array list, which will be written later
+  def push_xml_output_suite_info
+    # Insert opening tag at front
+    heading = '<testsuite name=' + xml_encode_s(@real_test_suite_name) + ' tests="' + @total_tests.to_s + '" failures="' + @test_failed.to_s + '"' + ' skips="' + @test_ignored.to_s + '">'
+    @array_list.insert(0, heading)
+    # Push back the closing tag
+    @array_list.push '</testsuite>'
+  end
+
+  # Pushes xml output data to the array list, which will be written later
+  def push_xml_output_passed(test_name, execution_time = 0)
+    @array_list.push '    <testcase classname=' + xml_encode_s(@test_suite) + ' name=' + xml_encode_s(test_name) + ' time=' + xml_encode_s((execution_time / 1000.0).to_s) + ' />'
+  end
+
+  # Pushes xml output data to the array list, which will be written later
+  def push_xml_output_failed(test_name, reason, execution_time = 0)
+    @array_list.push '    <testcase classname=' + xml_encode_s(@test_suite) + ' name=' + xml_encode_s(test_name) + ' time=' + xml_encode_s((execution_time / 1000.0).to_s) + '>'
+    @array_list.push '        <failure type="ASSERT FAILED">' + reason + '</failure>'
+    @array_list.push '    </testcase>'
+  end
+
+  # Pushes xml output data to the array list, which will be written later
+  def push_xml_output_ignored(test_name, reason, execution_time = 0)
+    @array_list.push '    <testcase classname=' + xml_encode_s(@test_suite) + ' name=' + xml_encode_s(test_name) + ' time=' + xml_encode_s((execution_time / 1000.0).to_s) + '>'
+    @array_list.push '        <skipped type="TEST IGNORED">' + reason + '</skipped>'
+    @array_list.push '    </testcase>'
+  end
+
+  # This function will try and determine when the suite is changed. This is
   # is the name that gets added to the classname parameter.
   def test_suite_verify(test_suite_name)
-    return if @test_flag
-
-    @test_flag = true
     # Split the path name
-    test_name = test_suite_name.split('/')
+    test_name = test_suite_name.split(@path_delim)
-    # Remove the extension
+
-    base_name = test_name[test_name.size - 1].split('.')
+    # Remove the extension and extract the base_name
-    @test_suite = 'test.' + base_name[0]
+    base_name = test_name[test_name.size - 1].split('.')[0]
+
+    # Return if the test suite hasn't changed
+    return unless base_name.to_s != @test_suite.to_s
+
+    @test_suite = base_name
     printf "New Test: %s\n", @test_suite
   end
 
-  # Test was flagged as having passed so format the output
+  # Prepares the line for verbose fixture output ("-v")
-  def test_passed(array)
+  def prepare_fixture_line(line)
-    last_item = array.length - 1
+    line = line.sub('IGNORE_TEST(', '')
-    test_name = array[last_item - 1]
+    line = line.sub('TEST(', '')
-    test_suite_verify(array[@class_name])
+    line = line.sub(')', ',')
-    printf "%-40s PASS\n", test_name
+    line = line.chomp
-
+    array = line.split(',')
-    return unless @xml_out
+    array.map { |x| x.to_s.lstrip.chomp }
-
-    @array_list.push '     <testcase classname="' + @test_suite + '" name="' + test_name + '"/>'
   end
 
   # Test was flagged as having passed so format the output.
   # This is using the Unity fixture output and not the original Unity output.
   def test_passed_unity_fixture(array)
-    test_suite = array[0].sub('TEST(', '')
+    class_name = array[0]
-    test_suite = test_suite.sub(',', '')
+    test_name  = array[1]
-    test_name = array[1].sub(')', '')
+    test_suite_verify(class_name)
+    printf "%-40s PASS\n", test_name
 
-    return unless @xml_out
+    push_xml_output_passed(test_name) if @xml_out
-
-    @array_list.push '     <testcase classname="' + test_suite + '" name="' + test_name + '"/>'
   end
 
-  # Test was flagged as being ingored so format the output
+  # Test was flagged as having failed so format the output.
-  def test_ignored(array)
+  # This is using the Unity fixture output and not the original Unity output.
-    last_item = array.length - 1
+  def test_failed_unity_fixture(array)
-    test_name = array[last_item - 2]
+    class_name = array[0]
-    reason = array[last_item].chomp
+    test_name  = array[1]
-    test_suite_verify(array[@class_name])
+    test_suite_verify(class_name)
-    printf "%-40s IGNORED\n", test_name
+    reason_array = array[2].split(':')
+    reason = reason_array[-1].lstrip.chomp + ' at line: ' + reason_array[-4]
 
-    if test_name.start_with? 'TEST('
-      array2 = test_name.split(' ')
-      @test_suite = array2[0].sub('TEST(', '')
-      @test_suite = @test_suite.sub(',', '')
-      test_name = array2[1].sub(')', '')
-    end
-
-    return unless @xml_out
-
-    @array_list.push '     <testcase classname="' + @test_suite + '" name="' + test_name + '">'
-    @array_list.push '            <skipped type="TEST IGNORED"> ' + reason + ' </skipped>'
-    @array_list.push '     </testcase>'
-  end
-
-  # Test was flagged as having failed  so format the line
-  def test_failed(array)
-    last_item = array.length - 1
-    test_name = array[last_item - 2]
-    reason = array[last_item].chomp + ' at line: ' + array[last_item - 3]
-    test_suite_verify(array[@class_name])
     printf "%-40s FAILED\n", test_name
 
-    if test_name.start_with? 'TEST('
+    push_xml_output_failed(test_name, reason) if @xml_out
-      array2 = test_name.split(' ')
+  end
-      @test_suite = array2[0].sub('TEST(', '')
+
-      @test_suite = @test_suite.sub(',', '')
+  # Test was flagged as being ignored so format the output.
-      test_name = array2[1].sub(')', '')
+  # This is using the Unity fixture output and not the original Unity output.
+  def test_ignored_unity_fixture(array)
+    class_name = array[0]
+    test_name  = array[1]
+    reason = 'No reason given'
+    if array.size > 2
+      reason_array = array[2].split(':')
+      tmp_reason = reason_array[-1].lstrip.chomp
+      reason = tmp_reason == 'IGNORE' ? 'No reason given' : tmp_reason
     end
+    test_suite_verify(class_name)
+    printf "%-40s IGNORED\n", test_name
+
+    push_xml_output_ignored(test_name, reason) if @xml_out
+  end
+
+  # Test was flagged as having passed so format the output
+  def test_passed(array)
+    # ':' symbol will be valid in function args now
+    real_method_name = array[@result_usual_idx - 1..-2].join(':')
+    array = array[0..@result_usual_idx - 2] + [real_method_name] + [array[-1]]
+
+    last_item = array.length - 1
+    test_time = get_test_time(array[last_item])
+    test_name = array[last_item - 1]
+    test_suite_verify(array[@class_name_idx])
+    printf "%-40s PASS %10d ms\n", test_name, test_time
 
     return unless @xml_out
 
-    @array_list.push '     <testcase classname="' + @test_suite + '" name="' + test_name + '">'
+    push_xml_output_passed(test_name, test_time) if @xml_out
-    @array_list.push '            <failure type="ASSERT FAILED"> ' + reason + ' </failure>'
-    @array_list.push '     </testcase>'
   end
 
-  # Figure out what OS we are running on.   For now we are assuming if it's not Windows it must
+  # Test was flagged as having failed so format the line
-  # be Unix based.
+  def test_failed(array)
-  def detect_os
+    # ':' symbol will be valid in function args now
-    os = RUBY_PLATFORM.split('-')
+    real_method_name = array[@result_usual_idx - 1..-3].join(':')
-    @class_name = if os.size == 2
+    array = array[0..@result_usual_idx - 3] + [real_method_name] + array[-2..-1]
-                    if os[1] == 'mingw32'
+
-                      1
+    last_item = array.length - 1
-                    else
+    test_time = get_test_time(array[last_item])
-                      0
+    test_name = array[last_item - 2]
-                    end
+    reason = array[last_item].chomp.lstrip + ' at line: ' + array[last_item - 3]
-                  else
+    class_name = array[@class_name_idx]
-                    0
+
-                  end
+    if test_name.start_with? 'TEST('
+      array2 = test_name.split(' ')
+
+      test_suite = array2[0].sub('TEST(', '')
+      test_suite = test_suite.sub(',', '')
+      class_name = test_suite
+
+      test_name = array2[1].sub(')', '')
+    end
+
+    test_suite_verify(class_name)
+    printf "%-40s FAILED %10d ms\n", test_name, test_time
+
+    push_xml_output_failed(test_name, reason, test_time) if @xml_out
+  end
+
+  # Test was flagged as being ignored so format the output
+  def test_ignored(array)
+    # ':' symbol will be valid in function args now
+    real_method_name = array[@result_usual_idx - 1..-3].join(':')
+    array = array[0..@result_usual_idx - 3] + [real_method_name] + array[-2..-1]
+
+    last_item = array.length - 1
+    test_time = get_test_time(array[last_item])
+    test_name = array[last_item - 2]
+    reason = array[last_item].chomp.lstrip
+    class_name = array[@class_name_idx]
+
+    if test_name.start_with? 'TEST('
+      array2 = test_name.split(' ')
+
+      test_suite = array2[0].sub('TEST(', '')
+      test_suite = test_suite.sub(',', '')
+      class_name = test_suite
+
+      test_name = array2[1].sub(')', '')
+    end
+
+    test_suite_verify(class_name)
+    printf "%-40s IGNORED %10d ms\n", test_name, test_time
+
+    push_xml_output_ignored(test_name, reason, test_time) if @xml_out
+  end
+
+  # Test time will be in ms
+  def get_test_time(value_with_time)
+    test_time_array = value_with_time.scan(/\((-?\d+.?\d*) ms\)\s*$/).flatten.map do |arg_value_str|
+      arg_value_str.include?('.') ? arg_value_str.to_f : arg_value_str.to_i
+    end
+
+    test_time_array.any? ? test_time_array[0] : 0
+  end
+
+  # Adjusts the os specific members according to the current path style
+  # (Windows or Unix based)
+  def detect_os_specifics(line)
+    if line.include? '\\'
+      # Windows X:\Y\Z
+      @class_name_idx = 1
+      @path_delim = '\\'
+    else
+      # Unix Based /X/Y/Z
+      @class_name_idx = 0
+      @path_delim = '/'
+    end
   end
 
   # Main function used to parse the file that was captured.
-  def process(name)
+  def process(file_name)
-    @test_flag = false
     @array_list = []
 
-    detect_os
+    puts 'Parsing file: ' + file_name
 
-    puts 'Parsing file: ' + name
+    @test_passed = 0
-
+    @test_failed = 0
-    test_pass = 0
+    @test_ignored = 0
-    test_fail = 0
-    test_ignore = 0
     puts ''
     puts '=================== RESULTS ====================='
     puts ''
-    File.open(name).each do |line|
+    # Apply binary encoding. Bad symbols will be unchanged
-      # Typical test lines look like this:
+    File.open(file_name, 'rb').each do |line|
+      # Typical test lines look like these:
+      # ----------------------------------------------------
+      # 1. normal output:
       # <path>/<test_file>.c:36:test_tc1000_opsys:FAIL: Expected 1 Was 0
       # <path>/<test_file>.c:112:test_tc5004_initCanChannel:IGNORE: Not Yet Implemented
       # <path>/<test_file>.c:115:test_tc5100_initCanVoidPtrs:PASS
       #
-      # where path is different on Unix vs Windows devices (Windows leads with a drive letter)
+      # 2. fixture output
+      # <path>/<test_file>.c:63:TEST(<test_group>, <test_function>):FAIL: Expected 0x00001234 Was 0x00005A5A
+      # <path>/<test_file>.c:36:TEST(<test_group>, <test_function>):IGNORE
+      # Note: "PASS" information won't be generated in this mode
+      #
+      # 3. fixture output with verbose information ("-v")
+      # TEST(<test_group, <test_file>)<path>/<test_file>:168::FAIL: Expected 0x8D Was 0x8C
+      # TEST(<test_group>, <test_file>)<path>/<test_file>:22::IGNORE: This Test Was Ignored On Purpose
+      # IGNORE_TEST(<test_group, <test_file>)
+      # TEST(<test_group, <test_file>) PASS
+      #
+      # Note: Where path is different on Unix vs Windows devices (Windows leads with a drive letter)!
+      detect_os_specifics(line)
       line_array = line.split(':')
 
       # If we were able to split the line then we can look to see if any of our target words
-      # were found.  Case is important.
+      # were found. Case is important.
-      if (line_array.size >= 4) || (line.start_with? 'TEST(')
+      next unless (line_array.size >= 4) || (line.start_with? 'TEST(') || (line.start_with? 'IGNORE_TEST(')
-        # Determine if this test passed
+
-        if line.include? ':PASS'
+      # check if the output is fixture output (with verbose flag "-v")
-          test_passed(line_array)
+      if (line.start_with? 'TEST(') || (line.start_with? 'IGNORE_TEST(')
-          test_pass += 1
+        line_array = prepare_fixture_line(line)
-        elsif line.include? ':FAIL:'
+        if line.include? ' PASS'
-          test_failed(line_array)
+          test_passed_unity_fixture(line_array)
-          test_fail += 1
+          @test_passed += 1
-        elsif line.include? ':IGNORE:'
+        elsif line.include? 'FAIL'
-          test_ignored(line_array)
+          test_failed_unity_fixture(line_array)
-          test_ignore += 1
+          @test_failed += 1
-        elsif line.start_with? 'TEST('
+        elsif line.include? 'IGNORE'
-          if line.include? ' PASS'
+          test_ignored_unity_fixture(line_array)
-            line_array = line.split(' ')
+          @test_ignored += 1
-            test_passed_unity_fixture(line_array)
+        end
-            test_pass += 1
+      # normal output / fixture output (without verbose "-v")
-          end
+      elsif line.include? ':PASS'
-        # If none of the keywords are found there are no more tests for this suite so clear
+        test_passed(line_array)
-        # the test flag
+        @test_passed += 1
-        else
+      elsif line.include? ':FAIL'
-          @test_flag = false
+        test_failed(line_array)
+        @test_failed += 1
+      elsif line.include? ':IGNORE:'
+        test_ignored(line_array)
+        @test_ignored += 1
+      elsif line.include? ':IGNORE'
+        line_array.push('No reason given')
+        test_ignored(line_array)
+        @test_ignored += 1
+      elsif line_array.size >= 4
+        # We will check output from color compilation
+        if line_array[@result_usual_idx..-1].any? { |l| l.include? 'PASS' }
+          test_passed(line_array)
+          @test_passed += 1
+        elsif line_array[@result_usual_idx..-1].any? { |l| l.include? 'FAIL' }
+          test_failed(line_array)
+          @test_failed += 1
+        elsif line_array[@result_usual_idx..-2].any? { |l| l.include? 'IGNORE' }
+          test_ignored(line_array)
+          @test_ignored += 1
+        elsif line_array[@result_usual_idx..-1].any? { |l| l.include? 'IGNORE' }
+          line_array.push('No reason given (' + get_test_time(line_array[@result_usual_idx..-1]).to_s + ' ms)')
+          test_ignored(line_array)
+          @test_ignored += 1
         end
-      else
-        @test_flag = false
       end
+      @total_tests = @test_passed + @test_failed + @test_ignored
     end
     puts ''
     puts '=================== SUMMARY ====================='
     puts ''
-    puts 'Tests Passed  : ' + test_pass.to_s
+    puts 'Tests Passed  : ' + @test_passed.to_s
-    puts 'Tests Failed  : ' + test_fail.to_s
+    puts 'Tests Failed  : ' + @test_failed.to_s
-    puts 'Tests Ignored : ' + test_ignore.to_s
+    puts 'Tests Ignored : ' + @test_ignored.to_s
-    @total_tests = test_pass + test_fail + test_ignore
 
     return unless @xml_out
 
-    heading = '<testsuite tests="' + @total_tests.to_s + '" failures="' + test_fail.to_s + '"' + ' skips="' + test_ignore.to_s + '">'
+    # push information about the suite
-    @array_list.insert(0, heading)
+    push_xml_output_suite_info
+    # write xml output file
     write_xml_output
   end
 end
@@ -209,11 +370,13 @@ end
 parse_my_file = ParseOutput.new
 
 if ARGV.size >= 1
-  ARGV.each do |a|
+  ARGV.each do |arg|
-    if a == '-xml'
+    if arg == '-xml'
       parse_my_file.set_xml_output
+    elsif arg.start_with?('-suite')
+      parse_my_file.test_suite_name = arg.delete_prefix('-suite')
     else
-      parse_my_file.process(a)
+      parse_my_file.process(arg)
       break
     end
   end

auto/run_test.erb

@@ -0,0 +1,37 @@
+/*=======Test Runner Used To Run Each Test=====*/
+static void run_test(UnityTestFunction func, const char* name, UNITY_LINE_TYPE line_num)
+{
+    Unity.CurrentTestName = name;
+    Unity.CurrentTestLineNumber = line_num;
+#ifdef UNITY_USE_COMMAND_LINE_ARGS
+    if (!UnityTestMatches())
+        return;
+#endif
+    Unity.NumberOfTests++;
+    UNITY_CLR_DETAILS();
+    UNITY_EXEC_TIME_START();
+    CMock_Init();
+    if (TEST_PROTECT())
+    {
+<% if @options[:plugins].include?(:cexception) %>
+        volatile CEXCEPTION_T e;
+        Try {
+            <%= @options[:setup_name] %>();
+            func();
+        } Catch(e) {
+            TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!");
+        }
+<% else %>
+        <%= @options[:setup_name] %>();
+        func();
+<% end %>
+    }
+    if (TEST_PROTECT())
+    {
+        <%= @options[:teardown_name] %>();
+        CMock_Verify();
+    }
+    CMock_Destroy();
+    UNITY_EXEC_TIME_STOP();
+    UnityConcludeTest();
+}

auto/stylize_as_junit.py

@@ -1,6 +1,15 @@
+#! python3
+# ==========================================
+#   Fork from Unity Project - A Test Framework for C
+#   Pull request on Gerrit in progress, the objective of this file is to be deleted when official Unity deliveries
+#   include that modification
+#   Copyright (c) 2015 Alexander Mueller / XelaRellum@web.de
+#   [Released under MIT License. Please refer to license.txt for details]
+# ==========================================
 import sys
 import os
 from glob import glob
+import argparse
 
 from pyparsing import *
 from junit_xml import TestSuite, TestCase
@@ -14,6 +23,7 @@ class UnityTestSummary:
         self.ignored = 0
         self.targets = 0
         self.root = None
+        self.output = None
         self.test_suites = dict()
 
     def run(self):
@@ -37,15 +47,18 @@ class UnityTestSummary:
             entry = entry_one | entry_two
 
             delimiter = Literal(':').suppress()
-            tc_result_line = Group(entry.setResultsName('tc_file_name') + delimiter + entry.setResultsName(
+            # Format of a result line is `[file_name]:line:test_name:RESULT[:msg]`
-                'tc_line_nr') + delimiter + entry.setResultsName('tc_name') + delimiter + entry.setResultsName(
+            tc_result_line = Group(ZeroOrMore(entry.setResultsName('tc_file_name'))
-                'tc_status') + Optional(
+                + delimiter + entry.setResultsName('tc_line_nr')
-                delimiter + entry.setResultsName('tc_msg'))).setResultsName("tc_line")
+                + 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
 
+            # Format of the summary line is `# Tests # Failures # Ignored`
             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")
@@ -67,7 +80,10 @@ class UnityTestSummary:
                     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]
+                    if 'tc_file_name' in tmp_tc_line:
+                        file_name = tmp_tc_line['tc_file_name'].split('\\').pop().split('/').pop().rsplit('.', 1)[0]
+                    else:
+                        file_name = result_file.strip("./")
                     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':
@@ -96,7 +112,7 @@ class UnityTestSummary:
         for suite_name in self.test_suites:
             ts.append(TestSuite(suite_name, self.test_suites[suite_name]))
 
-        with open('result.xml', 'w') as f:
+        with open(self.output, 'w') as f:
             TestSuite.to_file(f, ts, prettyprint='True', encoding='utf-8')
 
         return self.report
@@ -107,40 +123,39 @@ class UnityTestSummary:
     def set_root_path(self, path):
         self.root = path
 
-    @staticmethod
+    def set_output(self, output):
-    def usage(err_msg=None):
+        self.output = output
-        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:
+    parser = argparse.ArgumentParser(description=
-        # look in the specified or current directory for result files
+        """Takes as input the collection of *.testpass and *.testfail result
-        if len(sys.argv) > 1:
+        files, and converts them to a JUnit formatted XML.""")
-            targets_dir = sys.argv[1]
+    parser.add_argument('targets_dir', metavar='result_file_directory',
-        else:
+                        type=str, nargs='?', default='./',
-            targets_dir = './'
+                        help="""The location of your results files.
-        targets = list(map(lambda x: x.replace('\\', '/'), glob(targets_dir + '*.test*')))
+                        Defaults to current directory if not specified.""")
-        if len(targets) == 0:
+    parser.add_argument('root_path', nargs='?',
-            raise Exception("No *.testpass or *.testfail files found in '%s'" % targets_dir)
+                        default='os.path.split(__file__)[0]',
-        uts.set_targets(targets)
+                        help="""Helpful for producing more verbose output if
+                        using relative paths.""")
+    parser.add_argument('--output', '-o', type=str, default="result.xml",
+                        help="""The name of the JUnit-formatted file (XML).""")
+    args = parser.parse_args()
 
-        # set the root path
+    if args.targets_dir[-1] != '/':
-        if len(sys.argv) > 2:
+        args.targets_dir+='/'
-            root_path = sys.argv[2]
+    targets = list(map(lambda x: x.replace('\\', '/'), glob(args.targets_dir + '*.test*')))
-        else:
+    if len(targets) == 0:
-            root_path = os.path.split(__file__)[0]
+        raise Exception("No *.testpass or *.testfail files found in '%s'" % args.targets_dir)
-        uts.set_root_path(root_path)
+    uts.set_targets(targets)
 
-        # run the summarizer
+    # set the root path
-        print(uts.run())
+    uts.set_root_path(args.root_path)
-    except Exception as e:
+
-        UnityTestSummary.usage(e)
+    # set output
+    uts.set_output(args.output)
+
+    # run the summarizer
+    print(uts.run())

auto/stylize_as_junit.rb

@@ -61,8 +61,8 @@ class ArgvParser
 
     opts.parse!(args)
     options
-  end # parse()
+  end
-end # class OptparseExample
+end
 
 class UnityToJUnit
   include FileUtils::Verbose
@@ -152,11 +152,8 @@ class UnityToJUnit
 
   def parse_test_summary(summary)
     raise "Couldn't parse test results: #{summary}" unless summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ }
-    [Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i]
-  end
 
-  def here
+    [Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i]
-    File.expand_path(File.dirname(__FILE__))
   end
 
   private
@@ -221,9 +218,9 @@ class UnityToJUnit
   def write_suites_footer(stream)
     stream.puts '</testsuites>'
   end
-end # UnityToJUnit
+end
 
-if __FILE__ == $0
+if $0 == __FILE__
   # parse out the command options
   options = ArgvParser.parse(ARGV)
 
@@ -234,7 +231,9 @@ if __FILE__ == $0
     targets = "#{options.results_dir.tr('\\', '/')}**/*.test*"
 
     results = Dir[targets]
+
     raise "No *.testpass, *.testfail, or *.testresults files found in '#{targets}'" if results.empty?
+
     utj.targets = results
 
     # set the root path

auto/test_file_filter.rb

@@ -4,17 +4,18 @@
 #   [Released under MIT License. Please refer to license.txt for details]
 # ==========================================
 
-require'yaml'
+require_relative 'yaml_helper'
 
 module RakefileHelpers
   class TestFileFilter
     def initialize(all_files = false)
       @all_files = all_files
 
-      return false unless @all_files
+      return unless @all_files
-      return false unless File.exist?('test_file_filter.yml')
 
-      filters = YAML.load_file('test_file_filter.yml')
+      file = 'test_file_filter.yml'
+      return unless File.exist?(file)
+      filters = YamlHelper.load_file(file)
       @all_files = filters[:all_files]
       @only_files = filters[:only_files]
       @exclude_files = filters[:exclude_files]

auto/unity_test_summary.py

@@ -121,7 +121,7 @@ if __name__ == '__main__':
         targets_dir = sys.argv[1]
     else:
         targets_dir = './'
-    targets = list(map(lambda x: x.replace('\\', '/'), glob(targets_dir + '*.test*')))
+    targets = list(map(lambda x: x.replace('\\', '/'), glob(targets_dir + '**/*.test*', recursive=True)))
     if len(targets) == 0:
         raise Exception("No *.testpass or *.testfail files found in '%s'" % targets_dir)
     uts.set_targets(targets)

auto/unity_test_summary.rb

@@ -99,11 +99,8 @@ class UnityTestSummary
 
   def parse_test_summary(summary)
     raise "Couldn't parse test results: #{summary}" unless summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ }
-    [Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i]
-  end
 
-  def here
+    [Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i]
-    File.expand_path(File.dirname(__FILE__))
   end
 end
 
@@ -121,7 +118,9 @@ if $0 == __FILE__
     args[0] ||= './'
     targets = "#{ARGV[0].tr('\\', '/')}**/*.test*"
     results = Dir[targets]
+
     raise "No *.testpass, *.testfail, or *.testresults files found in '#{targets}'" if results.empty?
+
     uts.targets = results
 
     # set the root path

auto/yaml_helper.rb

@@ -0,0 +1,19 @@
+# ==========================================
+#   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]
+# ==========================================
+
+require 'yaml'
+
+module YamlHelper
+  def self.load(body)
+    YAML.respond_to?(:unsafe_load) ?
+      YAML.unsafe_load(body) : YAML.load(body)
+  end
+
+  def self.load_file(file)
+    body = File.read(file)
+    self.load(body)
+  end
+end

docs/MesonGeneratorRunner.md

@@ -0,0 +1,18 @@
+# Meson Generator - Test Runner
+
+One of the really nice things about using Unity with Ceedling is that Ceedling takes care of generating all of the test runners automatically. If you're not using Ceedling though, you'll need to do this yourself.
+
+The way this is done in Unity is via a Ruby script called `generate_test_runner.rb`. When given a test file such as `test_example.c`, the script will generate `test_example_Runner.c`, which provides the `main` method and some other useful plumbing.
+
+So that you don't have to run this by hand, a Meson generator is provided to generate the runner automatically for you. Generally with Meson, you would use Unity as a subproject and you'd want to access the generator from the parent.
+
+For example, to get the generator you can use:
+
+    unity_proj = subproject('unity')
+    runner_gen = unity_proj.get_variable('gen_test_runner')
+
+Once you have the generator you need to pass it the absolute path of your test file. This seems to be a bug in how the paths work with subprojects in Meson. You can get the full path with `meson.source_root()`, so you could do:
+
+    test_runner = meson.source_root() / 'test/test_example.c'
+
+You can then include `test_runner` as a normal dependency to your builds. Meson will create the test runner in a private directory for each build target. It's only meant to be used as part of the build, so if you need to refer to the runner after the build, you won't be able to use the generator.

docs/ThrowTheSwitchCodingStandard.md

@@ -1,137 +1,116 @@
-# ThrowTheSwitch.org Coding Standard
+# ThrowTheSwitch.org Coding Standard
 
-Hi. Welcome to the coding standard for ThrowTheSwitch.org. For the most part,
+Hi.
-we try to follow these standards to unify our contributors' code into a cohesive
+Welcome to the coding standard for ThrowTheSwitch.org.
-unit (puns intended). You might find places where these standards aren't
+For the most part, we try to follow these standards to unify our contributors' code into a cohesive unit (puns intended).
-followed. We're not perfect. Please be polite where you notice these discrepancies
+You might find places where these standards aren't followed.
-and we'll try to be polite when we notice yours.
+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
+Being consistent makes code easier to understand.
-our standard simple because we also believe that we can only expect someone to
+We've tried to keep our standard simple because we also believe that we can only expect someone to follow something that is understandable.
-follow something that is understandable. Please do your best.
+Please do your best.
-
 
 ## Our Philosophy
 
-Before we get into details on syntax, let's take a moment to talk about our
+Before we get into details on syntax, let's take a moment to talk about our vision for these tools.
-vision for these tools. We're C developers and embedded software developers.
+We're C developers and embedded software developers.
-These tools are great to test any C code, but catering to embedded software has
+These tools are great to test any C code, but catering to embedded software made us more tolerant of compiler quirks.
-made us more tolerant of compiler quirks. There are a LOT of quirky compilers
+There are a LOT of quirky compilers out there.
-out there. By quirky I mean "doesn't follow standards because they feel like
+By quirky I mean "doesn't follow standards because they feel like they have a license to do as they wish."
-they have a license to do as they wish."
 
-Our philosophy is "support every compiler we can". Most often, this means that
+Our philosophy is "support every compiler we can".
-we aim for writing C code that is standards compliant (often C89... that seems
+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).
-to be a sweet spot that is almost always compatible). But it also means these
+But it also means these tools are tolerant of things that aren't common.
-tools are tolerant of things that aren't common. Some that aren't even
+Some that aren't even compliant.
-compliant. There are configuration options to override the size of standard
+There are configuration options to override the size of standard types.
-types. There are configuration options to force Unity to not use certain
+There are configuration options to force Unity to not use certain standard library functions.
-standard library functions. A lot of Unity is configurable and we have worked
+A lot of Unity is configurable and we have worked hard to make it not TOO ugly in the process.
-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
+Similarly, our tools that parse C do their best.
-(yet) and, even if they were, they would still have to accept non-standard
+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.
-additions like gcc extensions or specifying `@0x1000` to force a variable to
+It's just what we do, because we like everything to Just Work™.
-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.
 
+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
+Let's talk about naming things.
-files, functions, variables, and so much more. While we're not always going to
+Programming is all about naming things.
-find the best name for something, we actually put quite a bit of effort into
+We name files, functions, variables, and so much more.
-finding *What Something WANTS to be Called*™.
+While we're not always going to find the best name for something, we actually put a bit of effort into finding *What Something WANTS to be Called*™.
+
+When naming things, we follow this hierarchy, the first being the most important to us (but we do all four when possible):
 
-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
 
-#### 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).
 
-We want to read our code. This means we like names and flow that are more
+### Descriptive
-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
+Finding the right name for something is an important endeavour.
-from poking around our code that this often results in names that are a little
+You might notice from poking around our code that this often results in names that are a little longer than the average.
-longer than the average. Guilty. We're okay with a tiny bit more typing if it
+Guilty.
-means our code is easier to understand.
+We're okay with a 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
+There are two exceptions to this rule that we also stick to as religiously as possible:
-possible:
 
-First, while we realize hungarian notation (and similar systems for encoding
+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 is to be avoided.
-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
+Second, loop counters and other local throw-away variables often have a purpose which is obvious.
-which is obvious. There's no need, therefore, to get carried away with complex
+There's no need, therefore, to get carried away with complex naming.
-naming. We find i, j, and k are better loop counters than loopCounterVar or
+We find i, j, and k are better loop counters than loopCounterVar or whatnot.
-whatnot. We only break this rule when we see that more description could improve
+We only break this rule when we see that more description could improve understanding of an algorithm.
-understanding of an algorithm.
 
+### Consistent
 
-#### 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.
 
-We like consistency, but we're not really obsessed with it. We try to name our
+### Memorable
-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.
 
+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 fulfil 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?
+We don't really want to add to the style battles out there.
-How many spaces? Where do the braces go? These are age-old questions that will
+Tabs or spaces?
-never be answered... or at least not answered in a way that will make everyone
+How many spaces?
-happy.
+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
+We've decided on our own style preferences.
-projects (and we hope that you do), then we ask if you do your best to follow
+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.
-the same. It will only hurt a little. We promise.
+It will only hurt a little. We promise.
 
+### Whitespace in C/C++
 
-#### 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.
-Our C-style is to use spaces and to use 4 of them per indent level. It's a nice
+We have no more reason than that.
-power-of-2 number that looks decent on a wide screen. We have no more reason
+We break that rule when we have lines that wrap (macros or function arguments or whatnot).
-than that. We break that rule when we have lines that wrap (macros or function
+When that happens, we like to indent further to line things up in nice tidy columns.
-arguments or whatnot). When that happens, we like to indent further to line
-things up in nice tidy columns.
 
 ```C
     if (stuff_happened)
@@ -140,8 +119,7 @@ things up in nice tidy columns.
     }
 ```
 
-
+### Case in C/C++
-#### Case
 
 - Files - all lower case with underscores.
 - Variables - all lower case with underscores
@@ -150,12 +128,12 @@ things up in nice tidy columns.
 - Functions - camel cased. Usually named ModuleName_FuncName
 - Constants and Globals - camel cased.
 
+### Braces in C/C++
 
-#### Braces
+The left brace is on the next line after the declaration.
-
+The right brace is directly below that.
-The left brace is on the next line after the declaration. The right brace is
+Everything in between in indented one level.
-directly below that. Everything in between in indented one level. If you're
+If you're catching an error and you have a one-line, go ahead and to it on the same line.
-catching an error and you have a one-line, go ahead and to it on the same line.
 
 ```C
     while (blah)
@@ -164,32 +142,32 @@ catching an error and you have a one-line, go ahead and to it on the same line.
     }
 ```
 
+### Comments in C/C++
 
-#### Comments
+Do you know what we hate?
-
+Old-school C block comments.
-Do you know what we hate? Old-school C block comments. BUT, we're using them
+BUT, we're using them anyway.
-anyway. As we mentioned, our goal is to support every compiler we can,
+As we mentioned, our goal is to support every compiler we can, especially embedded compilers.
-especially embedded compilers. There are STILL C compilers out there that only
+There are STILL C compilers out there that only support old-school block comments.
-support old-school block comments. So that is what we're using. We apologize. We
+So that is what we're using.
-think they are ugly too.
+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
+Is there really such thing as a Ruby coding standard?
-language, it seems almost sacrilegious to suggest that people should comply to
+Ruby is such a free form language, it seems almost sacrilegious to suggest that people should comply to one method!
-one method! We'll keep it really brief!
+We'll keep it really brief!
 
+### Whitespace in Ruby
 
-#### 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.
 
-Our Ruby style is to use spaces and to use 2 of them per indent level. It's a
+### Case in Ruby
-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
@@ -197,11 +175,13 @@ that happens, we like to indent further to line things up in nice tidy columns.
 - 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
+Egad.
-look nice while still being portable. Good enough?
+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][]*
 
-*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)*
+[ThrowTheSwitch.org]: https://throwtheswitch.org

docs/UnityConfigurationGuide.md

@@ -2,397 +2,550 @@
 
 ## C Standards, Compilers and Microcontrollers
 
-The embedded software world contains its challenges. Compilers support different
+The embedded software world contains its challenges.
-revisions of the C Standard. They ignore requirements in places, sometimes to
+Compilers support different revisions of the C Standard.
-make the language more usable in some special regard. Sometimes it's to simplify
+They ignore requirements in places, sometimes to make the language more usable in some special regard.
-their support. Sometimes it's due to specific quirks of the microcontroller they
+Sometimes it's to simplify their support.
-are targeting. Simulators add another dimension to this menagerie.
+Sometimes it's due to specific quirks of the microcontroller they are targeting.
+Simulators add another dimension to this menagerie.
 
-Unity is designed to run on almost anything that is targeted by a C compiler. It
+Unity is designed to run on almost anything that is targeted by a C compiler.
-would be awesome if this could be done with zero configuration. While there are
+It would be awesome if this could be done with zero configuration.
-some targets that come close to this dream, it is sadly not universal. It is
+While there are some targets that come close to this dream, it is sadly not universal.
-likely that you are going to need at least a couple of the configuration options
+It is likely that you are going to need at least a couple of the configuration options described in this document.
-described in this document.
-
-All of Unity's configuration options are `#defines`. Most of these are simple
-definitions. A couple are macros with arguments. They live inside the
-unity_internals.h header file. We don't necessarily recommend opening that file
-unless you really need to. That file is proof that a cross-platform library is
-challenging to build. From a more positive perspective, it is also proof that a
-great deal of complexity can be centralized primarily to one place in order to
-provide a more consistent and simple experience elsewhere.
 
+All of Unity's configuration options are `#defines`.
+Most of these are simple definitions.
+A couple are macros with arguments.
+They live inside the unity_internals.h header file.
+We don't necessarily recommend opening that file unless you really need to.
+That file is proof that a cross-platform library is challenging to build.
+From a more positive perspective, it is also proof that a great deal of complexity can be centralized primarily to one place to provide a more consistent and simple experience elsewhere.
 
 ### Using These Options
 
-It doesn't matter if you're using a target-specific compiler and a simulator or
+It doesn't matter if you're using a target-specific compiler and a simulator or a native compiler.
-a native compiler. In either case, you've got a couple choices for configuring
+In either case, you've got a couple choices for configuring these options:
-these options:
 
-1. Because these options are specified via C defines, you can pass most of these
+1. Because these options are specified via C defines, you can pass most of these options to your compiler through command line compiler flags. Even if you're using an embedded target that forces you to use their overbearing IDE for all configuration, there will be a place somewhere in your project to configure defines for your compiler.
-options to your compiler through command line compiler flags. Even if you're
+2. You can create a custom `unity_config.h` configuration file (present in your toolchain's search paths).
-using an embedded target that forces you to use their overbearing IDE for all
+  In this file, you will list definitions and macros specific to your target. All you must do is define `UNITY_INCLUDE_CONFIG_H` and Unity will rely on `unity_config.h` for any further definitions it may need.
-configuration, there will be a place somewhere in your project to configure
-defines for your compiler.
-2. You can create a custom `unity_config.h` configuration file (present in your
-toolchain's search paths). In this file, you will list definitions and macros
-specific to your target. All you must do is define `UNITY_INCLUDE_CONFIG_H` and
-Unity will rely on `unity_config.h` for any further definitions it may need.
 
+Unfortunately, it doesn't usually work well to just #define these things in the test itself.
+These defines need to take effect where ever unity.h is included.
+This would be test test, the test runner (if you're generating one), and from unity.c when it's compiled.
 
 ## The Options
 
 ### Integer Types
 
-If you've been a C developer for long, you probably already know that C's
+If you've been a C developer for long, you probably already know that C's concept of an integer varies from target to target.
-concept of an integer varies from target to target. The C Standard has rules
+The C Standard has rules about the `int` matching the register size of the target microprocessor.
-about the `int` matching the register size of the target microprocessor. It has
+It has rules about the `int` and how its size relates to other integer types.
-rules about the `int` and how its size relates to other integer types. An `int`
+An `int` on one target might be 16 bits while on another target it might be 64.
-on one target might be 16 bits while on another target it might be 64. There are
+There are more specific types in compilers compliant with C99 or later, but that's certainly not every compiler you are likely to encounter.
-more specific types in compilers compliant with C99 or later, but that's
+Therefore, Unity has a number of features for helping to adjust itself to match your required integer sizes.
-certainly not every compiler you are likely to encounter. Therefore, Unity has a
+It starts off by trying to do it automatically.
-number of features for helping to adjust itself to match your required integer
-sizes. It starts off by trying to do it automatically.
 
-
+#### `UNITY_EXCLUDE_STDINT_H`
-##### `UNITY_EXCLUDE_STDINT_H`
 
 The first thing that Unity does to guess your types is check `stdint.h`.
-This file includes defines like `UINT_MAX` that Unity can make use of to
+This file includes defines like `UINT_MAX` that Unity can use to learn a lot about your system.
-learn a lot about your system. It's possible you don't want it to do this
+It's possible you don't want it to do this (um. why not?) or (more likely) it's possible that your system doesn't support `stdint.h`.
-(um. why not?) or (more likely) it's possible that your system doesn't
+If that's the case, you're going to want to define this.
-support `stdint.h`. If that's the case, you're going to want to define this.
+That way, Unity will know to skip the inclusion of this file and you won't be left with a compiler error.
-That way, Unity will know to skip the inclusion of this file and you won't
-be left with a compiler error.
 
 _Example:_
-        #define UNITY_EXCLUDE_STDINT_H
 
+```C
+#define UNITY_EXCLUDE_STDINT_H
+```
 
-##### `UNITY_EXCLUDE_LIMITS_H`
+#### `UNITY_EXCLUDE_LIMITS_H`
 
-The second attempt to guess your types is to check `limits.h`. Some compilers
+The second attempt to guess your types is to check `limits.h`.
-that don't support `stdint.h` could include `limits.h` instead. If you don't
+Some compilers that don't support `stdint.h` could include `limits.h` instead.
-want Unity to check this file either, define this to make it skip the inclusion.
+If you don't want Unity to check this file either, define this to make it skip the inclusion.
 
 _Example:_
-        #define UNITY_EXCLUDE_LIMITS_H
 
+```C
+#define UNITY_EXCLUDE_LIMITS_H
+```
 
-##### `UNITY_EXCLUDE_SIZEOF`
+If you've disabled both of the automatic options above, you're going to have to do the configuration yourself.
+Don't worry.
+Even this isn't too bad... there are just a handful of defines that you are going to specify if you don't like the defaults.
 
-The third and final attempt to guess your types is to use the `sizeof()`
+#### `UNITY_INT_WIDTH`
-operator. Even if the first two options don't work, this one covers most cases.
+
-There _is_ a rare compiler or two out there that doesn't support sizeof() in the
+Define this to be the number of bits an `int` takes up on your system.
-preprocessing stage, though. For these, you have the ability to disable this
+The default, if not autodetected, is 32 bits.
-feature as well.
 
 _Example:_
-        #define UNITY_EXCLUDE_SIZEOF
 
-If you've disabled all of the automatic options above, you're going to have to
+```C
-do the configuration yourself. Don't worry. Even this isn't too bad... there are
+#define UNITY_INT_WIDTH 16
-just a handful of defines that you are going to specify if you don't like the
+```
-defaults.
 
+#### `UNITY_LONG_WIDTH`
 
-##### `UNITY_INT_WIDTH`
+Define this to be the number of bits a `long` takes up on your system.
-
+The default, if not autodetected, is 32 bits.
-Define this to be the number of bits an `int` takes up on your system. The
+This is used to figure out what kind of 64-bit support your system can handle.
-default, if not autodetected, is 32 bits.
+Does it need to specify a `long` or a `long long` to get a 64-bit value.
+On 16-bit systems, this option is going to be ignored.
 
 _Example:_
-        #define UNITY_INT_WIDTH 16
 
+```C
+#define UNITY_LONG_WIDTH 16
+```
 
-##### `UNITY_LONG_WIDTH`
+#### `UNITY_POINTER_WIDTH`
 
-Define this to be the number of bits a `long` takes up on your system. The
+Define this to be the number of bits a pointer takes up on your system.
-default, if not autodetected, is 32 bits. This is used to figure out what kind
+The default, if not autodetected, is 32-bits.
-of 64-bit support your system can handle. Does it need to specify a `long` or a
+If you're getting ugly compiler warnings about casting from pointers, this is the one to look at.
-`long long` to get a 64-bit value. On 16-bit systems, this option is going to be
+
-ignored.
+_Hint:_ In order to support exotic processors (for example TI C55x with a pointer width of 23-bit), choose the next power of two (in this case 32-bit).
+
+_Supported values:_ 16, 32 and 64
 
 _Example:_
-        #define UNITY_LONG_WIDTH 16
 
+```C
+// Choose on of these #defines to set your pointer width (if not autodetected)
+//#define UNITY_POINTER_WIDTH 16
+//#define UNITY_POINTER_WIDTH 32
+#define UNITY_POINTER_WIDTH 64 // Set UNITY_POINTER_WIDTH to 64-bit
+```
 
-##### `UNITY_POINTER_WIDTH`
+#### `UNITY_COMPARE_PTRS_ON_ZERO_ARRAY`
 
-Define this to be the number of bits a pointer takes up on your system. The
+Define this to make all array assertions compare pointers instead of contents when a length of zero is specified. When not enabled,
-default, if not autodetected, is 32-bits. If you're getting ugly compiler
+defining a length of zero will always result in a failure and a message warning the user that they have tried to compare empty
-warnings about casting from pointers, this is the one to look at.
+arrays.
+
+#### `UNITY_SUPPORT_64`
+
+Unity will automatically include 64-bit support if it auto-detects it, or if your `int`, `long`, or pointer widths are greater than 32-bits.
+Define this to enable 64-bit support if none of the other options already did it for you.
+There can be a significant size and speed impact to enabling 64-bit support on small targets, so don't define it if you don't need it.
 
 _Example:_
-        #define UNITY_POINTER_WIDTH 64
-
-
-##### `UNITY_INCLUDE_64`
-
-Unity will automatically include 64-bit support if it auto-detects it, or if
-your `int`, `long`, or pointer widths are greater than 32-bits. Define this to
-enable 64-bit support if none of the other options already did it for you. There
-can be a significant size and speed impact to enabling 64-bit support on small
-targets, so don't define it if you don't need it.
-
-_Example:_
-        #define UNITY_INCLUDE_64
 
+```C
+#define UNITY_SUPPORT_64
+```
 
 ### Floating Point Types
 
-In the embedded world, it's not uncommon for targets to have no support for
+In the embedded world, it's not uncommon for targets to have no support for floating point operations at all or to have support that is limited to only single precision.
-floating point operations at all or to have support that is limited to only
+We are able to guess integer sizes on the fly because integers are always available in at least one size.
-single precision. We are able to guess integer sizes on the fly because integers
+Floating point, on the other hand, is sometimes not available at all.
-are always available in at least one size. Floating point, on the other hand, is
+Trying to include `float.h` on these platforms would result in an error. This leaves manual configuration as the only option.
-sometimes not available at all. Trying to include `float.h` on these platforms
-would result in an error. This leaves manual configuration as the only option.
 
+#### `UNITY_INCLUDE_FLOAT`
 
-##### `UNITY_INCLUDE_FLOAT`
+#### `UNITY_EXCLUDE_FLOAT`
 
-##### `UNITY_EXCLUDE_FLOAT`
+#### `UNITY_INCLUDE_DOUBLE`
 
-##### `UNITY_INCLUDE_DOUBLE`
+#### `UNITY_EXCLUDE_DOUBLE`
 
-##### `UNITY_EXCLUDE_DOUBLE`
+By default, Unity guesses that you will want single precision floating point support, but not double precision.
-
+It's easy to change either of these using the include and exclude options here.
-By default, Unity guesses that you will want single precision floating point
+You may include neither, either, or both, as suits your needs.
-support, but not double precision. It's easy to change either of these using the
+For features that are enabled, the following floating point options also become available.
-include and exclude options here. You may include neither, either, or both, as
-suits your needs. For features that are enabled, the following floating point
-options also become available.
 
 _Example:_
 
-        //what manner of strange processor is this?
+```C
-        #define UNITY_EXCLUDE_FLOAT
+//what manner of strange processor is this?
-        #define UNITY_INCLUDE_DOUBLE
+#define UNITY_EXCLUDE_FLOAT
+#define UNITY_INCLUDE_DOUBLE
+```
 
+#### `UNITY_EXCLUDE_FLOAT_PRINT`
 
-##### `UNITY_FLOAT_VERBOSE`
+Unity aims for as small of a footprint as possible and avoids most standard library calls (some embedded platforms don’t have a standard library!).
-
+Because of this, its routines for printing integer values are minimalist and hand-coded.
-##### `UNITY_DOUBLE_VERBOSE`
+Therefore, the display of floating point values during a failure are optional.
-
+By default, Unity will print the actual results of floating point assertion failure (e.g. ”Expected 4.56 Was 4.68”).
-Unity aims for as small of a footprint as possible and avoids most standard
+To not include this extra support, you can use this define to instead respond to a failed assertion with a message like ”Values Not Within Delta”.
-library calls (some embedded platforms don't have a standard library!). Because
+If you would like verbose failure messages for floating point assertions, use these options to give more explicit failure messages.
-of this, its routines for printing integer values are minimalist and hand-coded.
-To keep Unity universal, though, we chose to _not_ develop our own floating
-point print routines. Instead, the display of floating point values during a
-failure are optional. By default, Unity will not print the actual results of
-floating point assertion failure. So a failed assertion will produce a message
-like `"Values Not Within Delta"`. If you would like verbose failure messages for
-floating point assertions, use these options to give more explicit failure
-messages (e.g. `"Expected 4.56 Was 4.68"`). Note that this feature requires the
-use of `sprintf` so might not be desirable in all cases.
 
 _Example:_
-        #define UNITY_DOUBLE_VERBOSE
 
+```C
+#define UNITY_EXCLUDE_FLOAT_PRINT
+```
 
-##### `UNITY_FLOAT_TYPE`
+#### `UNITY_FLOAT_TYPE`
 
-If enabled, Unity assumes you want your `FLOAT` asserts to compare standard C
+If enabled, Unity assumes you want your `FLOAT` asserts to compare standard C floats.
-floats. If your compiler supports a specialty floating point type, you can
+If your compiler supports a specialty floating point type, you can always override this behavior by using this definition.
-always override this behavior by using this definition.
 
 _Example:_
-        #define UNITY_FLOAT_TYPE float16_t
 
+```C
+#define UNITY_FLOAT_TYPE float16_t
+```
 
-##### `UNITY_DOUBLE_TYPE`
+#### `UNITY_DOUBLE_TYPE`
 
-If enabled, Unity assumes you want your `DOUBLE` asserts to compare standard C
+If enabled, Unity assumes you want your `DOUBLE` asserts to compare standard C doubles.
-doubles. If you would like to change this, you can specify something else by
+If you would like to change this, you can specify something else by using this option.
-using this option. For example, defining `UNITY_DOUBLE_TYPE` to `long double`
+For example, defining `UNITY_DOUBLE_TYPE` to `long double` could enable gargantuan floating point types on your 64-bit processor instead of the standard `double`.
-could enable gargantuan floating point types on your 64-bit processor instead of
-the standard `double`.
 
 _Example:_
-        #define UNITY_DOUBLE_TYPE long double
 
+```C
+#define UNITY_DOUBLE_TYPE long double
+```
 
-##### `UNITY_FLOAT_PRECISION`
+#### `UNITY_FLOAT_PRECISION`
 
-##### `UNITY_DOUBLE_PRECISION`
+#### `UNITY_DOUBLE_PRECISION`
 
-If you look up `UNITY_ASSERT_EQUAL_FLOAT` and `UNITY_ASSERT_EQUAL_DOUBLE` as
+If you look up `UNITY_ASSERT_EQUAL_FLOAT` and `UNITY_ASSERT_EQUAL_DOUBLE` as documented in the big daddy Unity Assertion Guide, you will learn that they are not really asserting that two values are equal but rather that two values are "close enough" to equal.
-documented in the big daddy Unity Assertion Guide, you will learn that they are
+"Close enough" is controlled by these precision configuration options.
-not really asserting that two values are equal but rather that two values are
+If you are working with 32-bit floats and/or 64-bit doubles (the normal on most processors), you should have no need to change these options.
-"close enough" to equal. "Close enough" is controlled by these precision
+They are both set to give you approximately 1 significant bit in either direction.
-configuration options. If you are working with 32-bit floats and/or 64-bit
+The float precision is 0.00001 while the double is 10-12.
-doubles (the normal on most processors), you should have no need to change these
+For further details on how this works, see the appendix of the Unity Assertion Guide.
-options. They are both set to give you approximately 1 significant bit in either
-direction. The float precision is 0.00001 while the double is 10-12.
-For further details on how this works, see the appendix of the Unity Assertion
-Guide.
 
 _Example:_
-        #define UNITY_FLOAT_PRECISION 0.001f
 
+```C
+#define UNITY_FLOAT_PRECISION 0.001f
+```
+
+### Miscellaneous
+
+#### `UNITY_EXCLUDE_STDDEF_H`
+
+Unity uses the `NULL` macro, which defines the value of a null pointer constant, defined in `stddef.h` by default.
+If you want to provide your own macro for this, you should exclude the `stddef.h` header file by adding this define to your configuration.
+
+_Example:_
+
+```C
+#define UNITY_EXCLUDE_STDDEF_H
+```
+
+#### `UNITY_INCLUDE_PRINT_FORMATTED`
+
+Unity provides a simple (and very basic) printf-like string output implementation, which is able to print a string modified by the following format string modifiers:
+
+- __%d__ - signed value (decimal)
+- __%i__ - same as __%d__
+- __%u__ - unsigned value (decimal)
+- __%f__ - float/Double (if float support is activated)
+- __%g__ - same as __%f__
+- __%b__ - binary prefixed with "0b"
+- __%x__ - hexadecimal (upper case) prefixed with "0x"
+- __%X__ - same as __%x__
+- __%p__ - pointer (same as __%x__ or __%X__)
+- __%c__ - a single character
+- __%s__ - a string (e.g. "string")
+- __%%__ - The "%" symbol (escaped)
+
+Length specifiers are also supported. If you are using long long types, make sure UNITY_SUPPORT_64 is true to ensure they are printed correctly.
+
+- __%ld__ - signed long value (decimal)
+- __%lld__ - signed long long value (decimal)
+- __%lu__ - unsigned long value (decimal)
+- __%llu__ - unsigned long long value (decimal)
+- __%lx__ - unsigned long value (hexadecimal)
+- __%llx__ - unsigned long long value (hexadecimal)
+
+_Example:_
+
+```C
+#define UNITY_INCLUDE_PRINT_FORMATTED
+
+int a = 0xfab1;
+TEST_PRINTF("Decimal   %d\n", -7);
+TEST_PRINTF("Unsigned  %u\n", 987);
+TEST_PRINTF("Float     %f\n", 3.1415926535897932384);
+TEST_PRINTF("Binary    %b\n", 0xA);
+TEST_PRINTF("Hex       %X\n", 0xFAB);
+TEST_PRINTF("Pointer   %p\n", &a);
+TEST_PRINTF("Character %c\n", 'F');
+TEST_PRINTF("String    %s\n", "My string");
+TEST_PRINTF("Percent   %%\n");
+TEST_PRINTF("Unsigned long long %llu\n", 922337203685477580);
+TEST_PRINTF("Color Red \033[41mFAIL\033[0m\n");
+TEST_PRINTF("\n");
+TEST_PRINTF("Multiple (%d) (%i) (%u) (%x)\n", -100, 0, 200, 0x12345);
+```
 
 ### Toolset Customization
 
-In addition to the options listed above, there are a number of other options
+In addition to the options listed above, there are a number of other options which will come in handy to customize Unity's behavior for your specific toolchain.
-which will come in handy to customize Unity's behavior for your specific
+It is possible that you may not need to touch any of these... but certain platforms, particularly those running in simulators, may need to jump through extra hoops to run properly.
-toolchain. It is possible that you may not need to touch any of these... but
+These macros will help in those situations.
-certain platforms, particularly those running in simulators, may need to jump
-through extra hoops to operate properly. These macros will help in those
-situations.
 
+#### `UNITY_OUTPUT_CHAR(a)`
 
-##### `UNITY_OUTPUT_CHAR(a)`
+#### `UNITY_OUTPUT_FLUSH()`
 
-##### `UNITY_OUTPUT_FLUSH()`
+#### `UNITY_OUTPUT_START()`
 
-##### `UNITY_OUTPUT_START()`
+#### `UNITY_OUTPUT_COMPLETE()`
 
-##### `UNITY_OUTPUT_COMPLETE()`
+By default, Unity prints its results to `stdout` as it runs.
-
+This works perfectly fine in most situations where you are using a native compiler for testing.
-By default, Unity prints its results to `stdout` as it runs. This works
+It works on some simulators as well so long as they have `stdout` routed back to the command line.
-perfectly fine in most situations where you are using a native compiler for
+There are times, however, where the simulator will lack support for dumping results or you will want to route results elsewhere for other reasons.
-testing. It works on some simulators as well so long as they have `stdout`
+In these cases, you should define the `UNITY_OUTPUT_CHAR` macro.
-routed back to the command line. There are times, however, where the simulator
+This macro accepts a single character at a time (as an `int`, since this is the parameter type of the standard C `putchar` function most commonly used).
-will lack support for dumping results or you will want to route results
+You may replace this with whatever function call you like.
-elsewhere for other reasons. In these cases, you should define the
-`UNITY_OUTPUT_CHAR` macro. This macro accepts a single character at a time (as
-an `int`, since this is the parameter type of the standard C `putchar` function
-most commonly used). You may replace this with whatever function call you like.
 
 _Example:_
-Say you are forced to run your test suite on an embedded processor with no
+Say you are forced to run your test suite on an embedded processor with no `stdout` option.
-`stdout` option. You decide to route your test result output to a custom serial
+You decide to route your test result output to a custom serial `RS232_putc()` function you wrote like thus:
-`RS232_putc()` function you wrote like thus:
 
-        #define UNITY_OUTPUT_CHAR(a) RS232_putc(a)
+```C
-        #define UNITY_OUTPUT_START() RS232_config(115200,1,8,0)
+#include "RS232_header.h"
-        #define UNITY_OUTPUT_FLUSH() RS232_flush()
+...
-        #define UNITY_OUTPUT_COMPLETE() RS232_close()
+#define UNITY_OUTPUT_CHAR(a)    RS232_putc(a)
+#define UNITY_OUTPUT_START()    RS232_config(115200,1,8,0)
+#define UNITY_OUTPUT_FLUSH()    RS232_flush()
+#define UNITY_OUTPUT_COMPLETE() RS232_close()
+```
 
 _Note:_
-`UNITY_OUTPUT_FLUSH()` can be set to the standard out flush function simply by
+`UNITY_OUTPUT_FLUSH()` can be set to the standard out flush function simply by specifying `UNITY_USE_FLUSH_STDOUT`.
-specifying `UNITY_USE_FLUSH_STDOUT`. No other defines are required. If you
+No other defines are required.
-specify a custom flush function instead with `UNITY_OUTPUT_FLUSH` directly, it
-will declare an instance of your function by default. If you want to disable
-this behavior, add `UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION`.
 
+#### `UNITY_OUTPUT_FOR_ECLIPSE`
 
-##### `UNITY_SUPPORT_WEAK`
+#### `UNITY_OUTPUT_FOR_IAR_WORKBENCH`
 
-For some targets, Unity can make the otherwise required `setUp()` and
+#### `UNITY_OUTPUT_FOR_QT_CREATOR`
-`tearDown()` functions optional. This is a nice convenience for test writers
+
-since `setUp` and `tearDown` don't often actually _do_ anything. If you're using
+When managing your own builds, it is often handy to have messages output in a format which is recognized by your IDE.
-gcc or clang, this option is automatically defined for you. Other compilers can
+These are some standard formats which can be supported.
-also support this behavior, if they support a C feature called weak functions. A
+If you're using Ceedling to manage your builds, it is better to stick with the standard format (leaving these all undefined) and allow Ceedling to use its own decorators.
-weak function is a function that is compiled into your executable _unless_ a
+
-non-weak version of the same function is defined elsewhere. If a non-weak
+#### `UNITY_PTR_ATTRIBUTE`
-version is found, the weak version is ignored as if it never existed. If your
+
-compiler supports this feature, you can let Unity know by defining
+Some compilers require a custom attribute to be assigned to pointers, like `near` or `far`.
-`UNITY_SUPPORT_WEAK` as the function attributes that would need to be applied to
+In these cases, you can give Unity a safe default for these by defining this option with the attribute you would like.
-identify a function as weak. If your compiler lacks support for weak functions,
-you will always need to define `setUp` and `tearDown` functions (though they can
-be and often will be just empty). The most common options for this feature are:
 
 _Example:_
-        #define UNITY_SUPPORT_WEAK weak
-        #define UNITY_SUPPORT_WEAK __attribute__((weak))
 
+```C
+#define UNITY_PTR_ATTRIBUTE __attribute__((far))
+#define UNITY_PTR_ATTRIBUTE near
+```
 
-##### `UNITY_PTR_ATTRIBUTE`
+#### `UNITY_PRINT_EOL`
 
-Some compilers require a custom attribute to be assigned to pointers, like
+By default, Unity outputs \n at the end of each line of output.
-`near` or `far`. In these cases, you can give Unity a safe default for these by
+This is easy to parse by the scripts, by Ceedling, etc, but it might not be ideal for YOUR system.
-defining this option with the attribute you would like.
+Feel free to override this and to make it whatever you wish.
 
 _Example:_
-        #define UNITY_PTR_ATTRIBUTE __attribute__((far))
-        #define UNITY_PTR_ATTRIBUTE near
 
+```C
+#define UNITY_PRINT_EOL { UNITY_OUTPUT_CHAR('\r'); UNITY_OUTPUT_CHAR('\n'); }
+```
+
+#### `UNITY_EXCLUDE_DETAILS`
+
+This is an option for if you absolutely must squeeze every byte of memory out of your system.
+Unity stores a set of internal scratchpads which are used to pass extra detail information around.
+It's used by systems like CMock in order to report which function or argument flagged an error.
+If you're not using CMock and you're not using these details for other things, then you can exclude them.
+
+_Example:_
+
+```C
+#define UNITY_EXCLUDE_DETAILS
+```
+
+#### `UNITY_PRINT_TEST_CONTEXT`
+
+This option allows you to specify your own function to print additional context as part of the error message when a test has failed.
+It can be useful if you want to output some specific information about the state of the test at the point of failure, and `UNITY_SET_DETAILS` isn't flexible enough for your needs.
+
+_Example:_
+
+```C
+#define UNITY_PRINT_TEST_CONTEXT PrintIterationCount
+
+extern int iteration_count;
+
+void PrintIterationCount(void)
+{
+  UnityPrintFormatted("At iteration #%d: ", iteration_count);
+}
+```
+
+#### `UNITY_EXCLUDE_SETJMP`
+
+If your embedded system doesn't support the standard library setjmp, you can exclude Unity's reliance on this by using this define.
+This dropped dependence comes at a price, though.
+You will be unable to use custom helper functions for your tests, and you will be unable to use tools like CMock.
+Very likely, if your compiler doesn't support setjmp, you wouldn't have had the memory space for those things anyway, though... so this option exists for those situations.
+
+_Example:_
+
+```C
+#define UNITY_EXCLUDE_SETJMP
+```
+
+#### `UNITY_OUTPUT_COLOR`
+
+If you want to add color using ANSI escape codes you can use this define.
+
+_Example:_
+
+```C
+#define UNITY_OUTPUT_COLOR
+```
+
+#### `UNITY_SHORTHAND_AS_INT`
+
+#### `UNITY_SHORTHAND_AS_MEM`
+
+#### `UNITY_SHORTHAND_AS_RAW`
+
+#### `UNITY_SHORTHAND_AS_NONE`
+
+These options give you control of the `TEST_ASSERT_EQUAL` and the `TEST_ASSERT_NOT_EQUAL` shorthand assertions.
+Historically, Unity treated the former as an alias for an integer comparison.
+It treated the latter as a direct comparison using `!=`.
+This asymmetry was confusing, but there was much disagreement as to how best to treat this pair of assertions.
+These four options will allow you to specify how Unity will treat these assertions.
+
+- AS INT - the values will be cast to integers and directly compared.
+  Arguments that don't cast easily to integers will cause compiler errors.
+- AS MEM - the address of both values will be taken and the entire object's memory footprint will be compared byte by byte.
+  Directly placing constant numbers like `456` as expected values will cause errors.
+- AS_RAW - Unity assumes that you can compare the two values using `==` and `!=` and will do so.
+  No details are given about mismatches, because it doesn't really know what type it's dealing with.
+- AS_NONE - Unity will disallow the use of these shorthand macros altogether, insisting that developers choose a more descriptive option.
+
+#### `UNITY_SUPPORT_VARIADIC_MACROS`
+
+This will force Unity to support variadic macros when using its own built-in RUN_TEST macro.
+This will rarely be necessary. Most often, Unity will automatically detect if the compiler supports variadic macros by checking to see if it's C99+ compatible.
+In the event that the compiler supports variadic macros, but is primarily C89 (ANSI), defining this option will allow you to use them.
+This option is also not necessary when using Ceedling or the test runner generator script.
+
+#### `UNITY_SUPPORT_TEST_CASES`
+
+Unity can automatically define all supported parameterized tests macros.
+That feature is disabled by default.
+To enable it, use the following example:
+
+```C
+#define UNITY_SUPPORT_TEST_CASES
+```
+
+You can manually provide required `TEST_CASE` or `TEST_RANGE` macro definitions
+before including `unity.h`, and they won't be redefined.
+If you provide one of the following macros, some of default definitions will not be
+defined:
+| User defines macro | Unity will _not_ define following macro |
+|---|---|
+| `UNITY_EXCLUDE_TEST_CASE` | `TEST_CASE` |
+| `UNITY_EXCLUDE_TEST_RANGE` | `TEST_RANGE` |
+| `TEST_CASE` | `TEST_CASE` |
+| `TEST_RANGE` | `TEST_RANGE` |
+
+`UNITY_EXCLUDE_TEST_*` defines is not processed by test runner generator script.
+If you exclude one of them from definition, you should provide your own definition
+for them or avoid using undefined `TEST_*` macro as a test generator.
+Otherwise, compiler cannot build source code file with provided call.
+
+_Note:_
+That feature requires variadic macro support by compiler. If required feature
+is not detected, it will not be enabled, even though preprocessor macro is defined.
 
 ## Getting Into The Guts
 
-There will be cases where the options above aren't quite going to get everything
+There will be cases where the options above aren't quite going to get everything perfect.
-perfect. They are likely sufficient for any situation where you are compiling
+They are likely sufficient for any situation where you are compiling and executing your tests with a native toolchain (e.g. clang on Mac).
-and executing your tests with a native toolchain (e.g. clang on Mac). These
+These options may even get you through the majority of cases encountered in working with a target simulator run from your local command line.
-options may even get you through the majority of cases encountered in working
+But especially if you must run your test suite on your target hardware, your Unity configuration will
-with a target simulator run from your local command line. But especially if you
+require special help.
-must run your test suite on your target hardware, your Unity configuration will
+This special help will usually reside in one of two places: the `main()` function or the `RUN_TEST` macro.
-require special help. This special help will usually reside in one of two
+Let's look at how these work.
-places: the `main()` function or the `RUN_TEST` macro. Let's look at how these
-work.
 
+### `main()`
 
-##### `main()`
+Each test module is compiled and run on its own, separate from the other test files in your project.
-
+Each test file, therefore, has a `main` function.
-Each test module is compiled and run on its own, separate from the other test
+This `main` function will need to contain whatever code is necessary to initialize your system to a workable state.
-files in your project. Each test file, therefore, has a `main` function. This
+This is particularly true for situations where you must set up a memory map or initialize a communication channel for the output of your test results.
-`main` function will need to contain whatever code is necessary to initialize
-your system to a workable state. This is particularly true for situations where
-you must set up a memory map or initialize a communication channel for the
-output of your test results.
 
 A simple main function looks something like this:
 
-        int main(void) {
+```C
-            UNITY_BEGIN();
+int main(void) {
-            RUN_TEST(test_TheFirst);
+    UNITY_BEGIN();
-            RUN_TEST(test_TheSecond);
+    RUN_TEST(test_TheFirst);
-            RUN_TEST(test_TheThird);
+    RUN_TEST(test_TheSecond);
-            return UNITY_END();
+    RUN_TEST(test_TheThird);
-        }
+    return UNITY_END();
+}
+```
 
-You can see that our main function doesn't bother taking any arguments. For our
+You can see that our main function doesn't bother taking any arguments.
-most barebones case, we'll never have arguments because we just run all the
+For our most barebones case, we'll never have arguments because we just run all the tests each time.
-tests each time. Instead, we start by calling `UNITY_BEGIN`. We run each test
+Instead, we start by calling `UNITY_BEGIN`.
-(in whatever order we wish). Finally, we call `UNITY_END`, returning its return
+We run each test (in whatever order we wish).
-value (which is the total number of failures).
+Finally, we call `UNITY_END`, returning its return value (which is the total number of failures).
 
-It should be easy to see that you can add code before any test cases are run or
+It should be easy to see that you can add code before any test cases are run or after all the test cases have completed.
-after all the test cases have completed. This allows you to do any needed
+This allows you to do any needed system-wide setup or teardown that might be required for your special circumstances.
-system-wide setup or teardown that might be required for your special
-circumstances.
 
+#### `RUN_TEST`
 
-##### `RUN_TEST`
+The `RUN_TEST` macro is called with each test case function.
+Its job is to perform whatever setup and teardown is necessary for executing a single test case function.
+This includes catching failures, calling the test module's `setUp()` and `tearDown()` functions, and calling `UnityConcludeTest()`.
+If using CMock or test coverage, there will be additional stubs in use here.
+A simple minimalist RUN_TEST macro looks something like this:
 
-The `RUN_TEST` macro is called with each test case function. Its job is to
+```C
-perform whatever setup and teardown is necessary for executing a single test
+#define RUN_TEST(testfunc) \
-case function. This includes catching failures, calling the test module's
+    UNITY_NEW_TEST(#testfunc) \
-`setUp()` and `tearDown()` functions, and calling `UnityConcludeTest()`. If
+    if (TEST_PROTECT()) { \
-using CMock or test coverage, there will be additional stubs in use here. A
+        setUp(); \
-simple minimalist RUN_TEST macro looks something like this:
+        testfunc(); \
+    } \
+    if (TEST_PROTECT() && (!TEST_IS_IGNORED)) \
+        tearDown(); \
+    UnityConcludeTest();
+```
 
-        #define RUN_TEST(testfunc) \
+So that's quite a macro, huh?
-            UNITY_NEW_TEST(#testfunc) \
+It gives you a glimpse of what kind of stuff Unity has to deal with for every single test case.
-            if (TEST_PROTECT()) { \
+For each test case, we declare that it is a new test.
-                setUp(); \
+Then we run `setUp` and our test function.
-                testfunc(); \
+These are run within a `TEST_PROTECT` block, the function of which is to handle failures that occur during the test.
-            } \
+Then, assuming our test is still running and hasn't been ignored, we run `tearDown`.
-            if (TEST_PROTECT() && (!TEST_IS_IGNORED)) \
+No matter what, our last step is to conclude this test before moving on to the next.
-                tearDown(); \
-            UnityConcludeTest();
-
-So that's quite a macro, huh? It gives you a glimpse of what kind of stuff Unity
-has to deal with for every single test case. For each test case, we declare that
-it is a new test. Then we run `setUp` and our test function. These are run
-within a `TEST_PROTECT` block, the function of which is to handle failures that
-occur during the test. Then, assuming our test is still running and hasn't been
-ignored, we run `tearDown`. No matter what, our last step is to conclude this
-test before moving on to the next.
-
-Let's say you need to add a call to `fsync` to force all of your output data to
-flush to a file after each test. You could easily insert this after your
-`UnityConcludeTest` call. Maybe you want to write an xml tag before and after
-each result set. Again, you could do this by adding lines to this macro. Updates
-to this macro are for the occasions when you need an action before or after
-every single test case throughout your entire suite of tests.
 
+Let's say you need to add a call to `fsync` to force all of your output data to flush to a file after each test.
+You could easily insert this after your `UnityConcludeTest` call.
+Maybe you want to write an xml tag before and after each result set.
+Again, you could do this by adding lines to this macro.
+Updates to this macro are for the occasions when you need an action before or after every single test case throughout your entire suite of tests.
 
 ## Happy Porting
 
-The defines and macros in this guide should help you port Unity to just about
+The defines and macros in this guide should help you port Unity to just about any C target we can imagine.
-any C target we can imagine. If you run into a snag or two, don't be afraid of
+If you run into a snag or two, don't be afraid of asking for help on the forums.
-asking for help on the forums. We love a good challenge!
+We love a good challenge!
 
+*Find The Latest of This And More at [ThrowTheSwitch.org][]*
 
-*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)*
+[ThrowTheSwitch.org]: https://throwtheswitch.org

docs/UnityGettingStartedGuide.md

@@ -2,121 +2,104 @@
 
 ## Welcome
 
-Congratulations. You're now the proud owner of your very own pile of bits! What
+Congratulations.
-are you going to do with all these ones and zeros? This document should be able
+You're now the proud owner of your very own pile of bits!
-to help you decide just that.
+What are you going to do with all these ones and zeros?
+This document should be able to help you decide just that.
 
-Unity is a unit test framework. The goal has been to keep it small and
+Unity is a unit test framework.
-functional. The core Unity test framework is three files: a single C file and a
+The goal has been to keep it small and functional.
-couple header files. These team up to provide functions and macros to make
+The core Unity test framework is three files: a single C file and a couple header files.
-testing easier.
+These team up to provide functions and macros to make testing easier.
-
-Unity was designed to be cross platform. It works hard to stick with C standards
-while still providing support for the many embedded C compilers that bend the
-rules. Unity has been used with many compilers, including GCC, IAR, Clang,
-Green Hills, Microchip, and MS Visual Studio. It's not much work to get it to
-work with a new target.
 
+Unity was designed to be cross-platform.
+It works hard to stick with C standards while still providing support for the many embedded C compilers that bend the rules.
+Unity has been used with many compilers, including GCC, IAR, Clang, Green Hills, Microchip, and MS Visual Studio.
+It's not much work to get it to work with a new target.
 
 ### Overview of the Documents
 
 #### Unity Assertions reference
 
-This document will guide you through all the assertion options provided by
+This document will guide you through all the assertion options provided by Unity.
-Unity. This is going to be your unit testing bread and butter. You'll spend more
+This is going to be your unit testing bread and butter.
-time with assertions than any other part of Unity.
+You'll spend more time with assertions than any other part of Unity.
-
 
 #### Unity Assertions Cheat Sheet
 
-This document contains an abridged summary of the assertions described in the
+This document contains an abridged summary of the assertions described in the previous document.
-previous document. It's perfect for printing and referencing while you
+It's perfect for printing and referencing while you familiarize yourself with Unity's options.
-familiarize yourself with Unity's options.
-
 
 #### Unity Configuration Guide
 
-This document is the one to reference when you are going to use Unity with a new
+This document is the one to reference when you are going to use Unity with a new target or compiler.
-target or compiler. It'll guide you through the configuration options and will
+It'll guide you through the configuration options and will help you customize your testing experience to meet your needs.
-help you customize your testing experience to meet your needs.
-
 
 #### Unity Helper Scripts
 
-This document describes the helper scripts that are available for simplifying
+This document describes the helper scripts that are available for simplifying your testing workflow.
-your testing workflow. It describes the collection of optional Ruby scripts
+It describes the collection of optional Ruby scripts included in the auto directory of your Unity installation.
-included in the auto directory of your Unity installation. Neither Ruby nor
+Neither Ruby nor these scripts are necessary for using Unity.
-these scripts are necessary for using Unity. They are provided as a convenience
+They are provided as a convenience for those who wish to use them.
-for those who wish to use them.
-
 
 #### Unity License
 
-What's an open source project without a license file? This brief document
+What's an open source project without a license file?
-describes the terms you're agreeing to when you use this software. Basically, we
+This brief document describes the terms you're agreeing to when you use this software.
-want it to be useful to you in whatever context you want to use it, but please
+Basically, we want it to be useful to you in whatever context you want to use it, but please don't blame us if you run into problems.
-don't blame us if you run into problems.
-
 
 ### Overview of the Folders
 
-If you have obtained Unity through Github or something similar, you might be
+If you have obtained Unity through Github or something similar, you might be surprised by just how much stuff you suddenly have staring you in the face.
-surprised by just how much stuff you suddenly have staring you in the face.
+Don't worry, Unity itself is very small.
-Don't worry, Unity itself is very small. The rest of it is just there to make
+The rest of it is just there to make your life easier.
-your life easier. You can ignore it or use it at your convenience. Here's an
+You can ignore it or use it at your convenience.
-overview of everything in the project.
+Here's an overview of everything in the project.
 
-- `src` - This is the code you care about! This folder contains a C file and two
+- `src` - This is the code you care about! This folder contains a C file and two header files.
-header files. These three files _are_ Unity.
+  These three files _are_ Unity.
-- `docs` - You're reading this document, so it's possible you have found your way
+- `docs` - You're reading this document, so it's possible you have found your way into this folder already.
-into this folder already. This is where all the handy documentation can be
+  This is where all the handy documentation can be found.
-found.
 - `examples` - This contains a few examples of using Unity.
-- `extras` - These are optional add ons to Unity that are not part of the core
+- `extras` - These are optional add ons to Unity that are not part of the core project.
-project. If you've reached us through James Grenning's book, you're going to
+  If you've reached us through James Grenning's book, you're going to want to look here.
-want to look here.
+- `test` - This is how Unity and its scripts are all tested.
-- `test` - This is how Unity and its scripts are all tested. If you're just using
+  If you're just using Unity, you'll likely never need to go in here.
-Unity, you'll likely never need to go in here. If you are the lucky team member
+  If you are the lucky team member who gets to port Unity to a new toolchain, this is a good place to verify everything is configured properly.
-who gets to port Unity to a new toolchain, this is a good place to verify
+- `auto` - Here you will find helpful Ruby scripts for simplifying your test workflow.
-everything is configured properly.
+  They are purely optional and are not required to make use of Unity.
-- `auto` - Here you will find helpful Ruby scripts for simplifying your test
-workflow. They are purely optional and are not required to make use of Unity.
-
 
 ## How to Create A Test File
 
-Test files are C files. Most often you will create a single test file for each C
+Test files are C files.
-module that you want to test. The test file should include unity.h and the
+Most often you will create a single test file for each C module that you want to test.
-header for your C module to be tested.
+The test file should include unity.h and the header for your C module to be tested.
 
-Next, a test file will include a `setUp()` and `tearDown()` function. The setUp
+Next, a test file will include a `setUp()` and `tearDown()` function.
-function can contain anything you would like to run before each test. The
+The setUp function can contain anything you would like to run before each test.
-tearDown function can contain anything you would like to run after each test.
+The tearDown function can contain anything you would like to run after each test.
-Both functions accept no arguments and return nothing. You may leave either or
+Both functions accept no arguments and return nothing.
-both of these blank if you have no need for them. If you're using a compiler
+You may leave either or both of these blank if you have no need for them.
-that is configured to make these functions optional, you may leave them off
-completely. Not sure? Give it a try. If you compiler complains that it can't
-find setUp or tearDown when it links, you'll know you need to at least include
-an empty function for these.
 
-The majority of the file will be a series of test functions. Test functions
+If you're using Ceedling or the test runner generator script, you may leave these off completely.
-follow the convention of starting with the word "test" or "spec". You don't HAVE
+Not sure?
-to name them this way, but it makes it clear what functions are tests for other
+Give it a try.
-developers.  Test functions take no arguments and return nothing. All test
+If your compiler complains that it can't find setUp or tearDown when it links, you'll know you need to at least include an empty function for these.
-accounting is handled internally in Unity.
+
+The majority of the file will be a series of test functions.
+Test functions follow the convention of starting with the word "test_" or "spec_".
+You don't HAVE to name them this way, but it makes it clear what functions are tests for other developers.
+Also, the automated scripts that come with Unity or Ceedling will default to looking for test functions to be prefixed this way.
+Test functions take no arguments and return nothing. All test accounting is handled internally in Unity.
 
 Finally, at the bottom of your test file, you will write a `main()` function.
-This function will call `UNITY_BEGIN()`, then `RUN_TEST` for each test, and
+This function will call `UNITY_BEGIN()`, then `RUN_TEST` for each test, and finally `UNITY_END()`.
-finally `UNITY_END()`.This is what will actually trigger each of those test
+This is what will actually trigger each of those test functions to run, so it is important that each function gets its own `RUN_TEST` call.
-functions to run, so it is important that each function gets its own `RUN_TEST`
-call.
 
-Remembering to add each test to the main function can get to be tedious. If you
+Remembering to add each test to the main function can get to be tedious.
-enjoy using helper scripts in your build process, you might consider making use
+If you enjoy using helper scripts in your build process, you might consider making use of our handy [generate_test_runner.rb][] script.
-of our handy generate_test_runner.rb script. This will create the main function
+This will create the main function and all the calls for you, assuming that you have followed the suggested naming conventions.
-and all the calls for you, assuming that you have followed the suggested naming
+In this case, there is no need for you to include the main function in your test file at all.
-conventions. In this case, there is no need for you to include the main function
-in your test file at all.
 
 When you're done, your test file will look something like this:
 
@@ -140,6 +123,7 @@ void test_function_should_doAlsoDoBlah(void) {
     //more test stuff
 }
 
+// not needed when using generate_test_runner.rb
 int main(void) {
     UNITY_BEGIN();
     RUN_TEST(test_function_should_doBlahAndBlah);
@@ -148,44 +132,111 @@ int main(void) {
 }
 ```
 
-It's possible that you will require more customization than this, eventually.
+It's possible that you will need more customization than this, eventually.
 For that sort of thing, you're going to want to look at the configuration guide.
 This should be enough to get you going, though.
 
+### Running Test Functions
+
+When writing your own `main()` functions, for a test-runner.
+There are two ways to execute the test.
+
+The classic variant
+
+``` c
+RUN_TEST(func, linenum)
+```
+
+Or its simpler replacement that starts at the beginning of the function.
+
+``` c
+RUN_TEST(func)
+```
+
+These macros perform the necessary setup before the test is called and handles clean-up and result tabulation afterwards.
+
+### Ignoring Test Functions
+
+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.
+This is useful when your test runners are automatically generated.
+
+``` c
+TEST_IGNORE()
+```
+
+Ignore this test and return immediately
+
+```c
+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.
+
+```c
+    TEST_PROTECT()
+```
+
+Setup and Catch macro
+
+```c
+    TEST_ABORT()
+```
+
+Abort Test macro
+
+Example:
+
+```c
+    main()
+    {
+        if (TEST_PROTECT())
+        {
+            MyTest();
+        }
+    }
+```
+
+If MyTest calls `TEST_ABORT`, program control will immediately return to `TEST_PROTECT` with a return value of zero.
 
 ## How to Build and Run A Test File
 
-This is the single biggest challenge to picking up a new unit testing framework,
+This is the single biggest challenge to picking up a new unit testing framework, at least in a language like C or C++.
-at least in a language like C or C++. These languages are REALLY good at getting
+These languages are REALLY good at getting you "close to the metal" (why is the phrase metal? Wouldn't it be more accurate to say "close to the silicon"?).
-you "close to the metal" (why is the phrase metal? Wouldn't it be more accurate
+While this feature is usually a good thing, it can make testing more challenging.
-to say "close to the silicon"?). While this feature is usually a good thing, it
-can make testing more challenging.
 
-You have two really good options for toolchains. Depending on where you're
+You have two really good options for toolchains.
-coming from, it might surprise you that neither of these options is running the
+Depending on where you're coming from, it might surprise you that neither of these options is running the unit tests on your hardware.
-unit tests on your hardware.
 There are many reasons for this, but here's a short version:
+
 - On hardware, you have too many constraints (processing power, memory, etc),
 - On hardware, you don't have complete control over all registers,
 - On hardware, unit testing is more challenging,
 - Unit testing isn't System testing. Keep them separate.
 
-Instead of running your tests on your actual hardware, most developers choose to
+Instead of running your tests on your actual hardware, most developers choose to develop them as native applications (using gcc or MSVC for example) or as applications running on a simulator.
-develop them as native applications (using gcc or MSVC for example) or as
+Either is a good option.
-applications running on a simulator. Either is a good option. Native apps have
+Native apps have the advantages of being faster and easier to set up.
-the advantages of being faster and easier to set up. Simulator apps have the
+Simulator apps have the advantage of working with the same compiler as your target application.
-advantage of working with the same compiler as your target application. The
+The options for configuring these are discussed in the configuration guide.
-options for configuring these are discussed in the configuration guide.
 
-To get either to work, you might need to make a few changes to the file
+To get either to work, you might need to make a few changes to the file containing your register set (discussed later).
-containing your register set (discussed later).
 
-In either case, a test is built by linking unity, the test file, and the C
+In either case, a test is built by linking unity, the test file, and the C file(s) being tested.
-file(s) being tested. These files create an executable which can be run as the
+These files create an executable which can be run as the test set for that module.
-test set for that module. Then, this process is repeated for the next test file.
+Then, this process is repeated for the next test file.
-This flexibility of separating tests into individual executables allows us to
+This flexibility of separating tests into individual executables allows us to much more thoroughly unit test our system and it keeps all the test code out of our final release!
-much more thoroughly unit test our system and it keeps all the test code out of
-our final release!
 
+*Find The Latest of This And More at [ThrowTheSwitch.org][]*
 
-*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)*
+[generate_test_runner.rb]: ../auto/generate_test_runner.rb
+[ThrowTheSwitch.org]: https://throwtheswitch.org

docs/UnityHelperScriptsGuide.md

@@ -3,30 +3,25 @@
 ## With a Little Help From Our Friends
 
 Sometimes what it takes to be a really efficient C programmer is a little non-C.
-The Unity project includes a couple Ruby scripts for making your life just a tad
+The Unity project includes a couple of Ruby scripts for making your life just a tad easier.
-easier. They are completely optional. If you choose to use them, you'll need a
+They are completely optional.
-copy of Ruby, of course. Just install whatever the latest version is, and it is
+If you choose to use them, you'll need a copy of Ruby, of course.
-likely to work. You can find Ruby at [ruby-lang.org](https://ruby-labg.org/).
+Just install whatever the latest version is, and it is likely to work. You can find Ruby at [ruby-lang.org][].
-
 
 ### `generate_test_runner.rb`
 
-Are you tired of creating your own `main` function in your test file? Do you
+Are you tired of creating your own `main` function in your test file?
-keep forgetting to add a `RUN_TEST` call when you add a new test case to your
+Do you keep forgetting to add a `RUN_TEST` call when you add a new test case to your suite?
-suite? Do you want to use CMock or other fancy add-ons but don't want to figure
+Do you want to use CMock or other fancy add-ons but don't want to figure out how to create your own `RUN_TEST` macro?
-out how to create your own `RUN_TEST` macro?
 
 Well then we have the perfect script for you!
 
-The `generate_test_runner` script processes a given test file and automatically
+The `generate_test_runner` script processes a given test file and automatically creates a separate test runner file that includes ?main?to execute the test cases within the scanned test file.
-creates a separate test runner file that includes ?main?to execute the test
+All you do then is add the generated runner to your list of files to be compiled and linked, and presto you're done!
-cases within the scanned test file. All you do then is add the generated runner
-to your list of files to be compiled and linked, and presto you're done!
 
-This script searches your test file for void function signatures having a
+This script searches your test file for void function signatures having a function name beginning with "test" or "spec".
-function name beginning with "test" or "spec". It treats each of these
+It treats each of these functions as a test case and builds up a test suite of them.
-functions as a test case and builds up a test suite of them. For example, the
+For example, the following includes three test cases:
-following includes three test cases:
 
 ```C
 void testVerifyThatUnityIsAwesomeAndWillMakeYourLifeEasier(void)
@@ -41,32 +36,30 @@ void spec_Function_should_DoWhatItIsSupposedToDo(void) {
 }
 ```
 
-You can run this script a couple of ways. The first is from the command line:
+You can run this script a couple of ways.
+The first is from the command line:
 
 ```Shell
 ruby generate_test_runner.rb TestFile.c NameOfRunner.c
 ```
 
-Alternatively, if you include only the test file parameter, the script will copy
+Alternatively, if you include only the test file parameter, the script will copy the name of the test file and automatically append `_Runner` to the name of the generated file.
-the name of the test file and automatically append "_Runner" to the name of the
+The example immediately below will create TestFile_Runner.c.
-generated file. The example immediately below will create TestFile_Runner.c.
 
 ```Shell
 ruby generate_test_runner.rb TestFile.c
 ```
 
-You can also add a [YAML](http://www.yaml.org/) file to configure extra options.
+You can also add a [YAML][] file to configure extra options.
-Conveniently, this YAML file is of the same format as that used by Unity and
+Conveniently, this YAML file is of the same format as that used by Unity and CMock.
-CMock. So if you are using YAML files already, you can simply pass the very same
+So if you are using YAML files already, you can simply pass the very same file into the generator script.
-file into the generator script.
 
 ```Shell
 ruby generate_test_runner.rb TestFile.c my_config.yml
 ```
 
-The contents of the YAML file `my_config.yml` could look something like the
+The contents of the YAML file `my_config.yml` could look something like the example below.
-example below. If you're wondering what some of these options do, you're going
+If you're wondering what some of these options do, you're going to love the next section of this document.
-to love the next section of this document.
 
 ```YAML
 :unity:
@@ -74,23 +67,20 @@ to love the next section of this document.
     - stdio.h
     - microdefs.h
   :cexception: 1
-  :suit_setup: "blah = malloc(1024);"
+  :suite_setup: "blah = malloc(1024);"
   :suite_teardown: "free(blah);"
 ```
 
-If you would like to force your generated test runner to include one or more
+If you would like to force your generated test runner to include one or more header files, you can just include those at the command line too.
-header files, you can just include those at the command line too. Just make sure
+Just make sure these are _after_ the YAML file, if you are using one:
-these are _after_ the YAML file, if you are using one:
 
 ```Shell
 ruby generate_test_runner.rb TestFile.c my_config.yml extras.h
 ```
 
-Another option, particularly if you are already using Ruby to orchestrate your
+Another option, particularly if you are already using Ruby to orchestrate your builds - or more likely the Ruby-based build tool Rake - is requiring this script directly.
-builds - or more likely the Ruby-based build tool Rake - is requiring this
+Anything that you would have specified in a YAML file can be passed to the script as part of a hash.
-script directly. Anything that you would have specified in a YAML file can be
+Let's push the exact same requirement set as we did above but this time through Ruby code directly:
-passed to the script as part of a hash. Let's push the exact same requirement
-set as we did above but this time through Ruby code directly:
 
 ```Ruby
 require "generate_test_runner.rb"
@@ -103,9 +93,8 @@ options = {
 UnityTestRunnerGenerator.new.run(testfile, runner_name, options)
 ```
 
-If you have multiple files to generate in a build script (such as a Rakefile),
+If you have multiple files to generate in a build script (such as a Rakefile), you might want to instantiate a generator object with your options and call it to generate each runner afterwards.
-you might want to instantiate a generator object with your options and call it
+Like thus:
-to generate each runner thereafter. Like thus:
 
 ```Ruby
 gen = UnityTestRunnerGenerator.new(options)
@@ -114,46 +103,54 @@ test_files.each do |f|
 end
 ```
 
-#### Options accepted by generate_test_runner.rb:
+#### Options accepted by generate_test_runner.rb
-
-The following options are available when executing `generate_test_runner`. You
-may pass these as a Ruby hash directly or specify them in a YAML file, both of
-which are described above. In the `examples` directory, Example 3's Rakefile
-demonstrates using a Ruby hash.
 
+The following options are available when executing `generate_test_runner`.
+You may pass these as a Ruby hash directly or specify them in a YAML file, both of which are described above.
+In the `examples` directory, Example 3's Rakefile demonstrates using a Ruby hash.
 
 ##### `:includes`
 
-This option specifies an array of file names to be ?#include?'d at the top of
+This option specifies an array of file names to be `#include`'d at the top of your runner C file.
-your runner C file. You might use it to reference custom types or anything else
+You might use it to reference custom types or anything else universally needed in your generated runners.
-universally needed in your generated runners.
-
 
 ##### `:suite_setup`
 
 Define this option with C code to be executed _before any_ test cases are run.
 
+Alternatively, if your C compiler supports weak symbols, you can leave this option unset and instead provide a `void suiteSetUp(void)` function in your test suite.
+The linker will look for this symbol and fall back to a Unity-provided stub if it is not found.
 
 ##### `:suite_teardown`
 
-Define this option with C code to be executed ?after all?test cases have
+Define this option with C code to be executed _after all_ test cases have finished.
-finished.
+An integer variable `num_failures` is available for diagnostics.
+The code should end with a `return` statement; the value returned will become the exit code of `main`.
+You can normally just return `num_failures`.
 
+Alternatively, if your C compiler supports weak symbols, you can leave this option unset and instead provide a `int suiteTearDown(int num_failures)` function in your test suite.
+The linker will look for this symbol and fall back to a Unity-provided stub if it is not found.
 
 ##### `:enforce_strict_ordering`
 
-This option should be defined if you have the strict order feature enabled in
+This option should be defined if you have the strict order feature enabled in CMock (see CMock documentation).
-CMock (see CMock documentation). This generates extra variables required for
+This generates extra variables required for everything to run smoothly.
-everything to run smoothly. If you provide the same YAML to the generator as
+If you provide the same YAML to the generator as used in CMock's configuration, you've already configured the generator properly.
-used in CMock's configuration, you've already configured the generator properly.
 
+##### `:externc`
+
+This option should be defined if you are mixing C and CPP and want your test runners to automatically include extern "C" support when they are generated.
+
+##### `:mock_prefix` and `:mock_suffix`
+
+Unity automatically generates calls to Init, Verify and Destroy for every file included in the main test file that starts with the given mock prefix and ends with the given mock suffix, file extension not included.
+By default, Unity assumes a `Mock` prefix and no suffix.
 
 ##### `:plugins`
 
-This option specifies an array of plugins to be used (of course, the array can
+This option specifies an array of plugins to be used (of course, the array can contain only a single plugin).
-contain only a single plugin). This is your opportunity to enable support for
+This is your opportunity to enable support for CException support, which will add a check for unhandled exceptions in each test, reporting a failure if one is detected.
-CException support, which will add a check for unhandled exceptions in each
+To enable this feature using Ruby:
-test, reporting a failure if one is detected. To enable this feature using Ruby:
 
 ```Ruby
 :plugins => [ :cexception ]
@@ -166,45 +163,164 @@ Or as a yaml file:
   -:cexception
 ```
 
-If you are using CMock, it is very likely that you are already passing an array
+If you are using CMock, it is very likely that you are already passing an array of plugins to CMock.
-of plugins to CMock. You can just use the same array here. This script will just
+You can just use the same array here.
-ignore the plugins that don't require additional support.
+This script will just ignore the plugins that don't require additional support.
 
+##### `:include_extensions`
+
+This option specifies the pattern for matching acceptable header file extensions.
+By default it will accept hpp, hh, H, and h files.
+If you need a different combination of files to search, update this from the default `'(?:hpp|hh|H|h)'`.
+
+##### `:source_extensions`
+
+This option specifies the pattern for matching acceptable source file extensions.
+By default it will accept cpp, cc, C, c, and ino files.
+If you need a different combination of files to search, update this from the default `'(?:cpp|cc|ino|C|c)'`.
+
+##### `:use_param_tests`
+
+This option enables parameterized test usage.
+That tests accepts arguments from `TEST_CASE` and `TEST_RANGE` macros,
+that are located above current test definition.
+By default, Unity assumes, that parameterized tests are disabled.
+
+Few usage examples can be found in `/test/tests/test_unity_parameterized.c` file.
+
+You should define `UNITY_SUPPORT_TEST_CASES` macro for tests success compiling,
+if you enable current option.
+
+You can see list of supported macros list in the next section.
+
+#### Parameterized tests provided macros
+
+Unity provides support for few param tests generators, that can be combined
+with each other. You must define test function as usual C function with usual
+C arguments, and test generator will pass what you tell as a list of arguments.
+
+Let's show how all of them works on the following test function definitions:
+
+```C
+/* Place your test generators here, usually one generator per one or few lines */
+void test_demoParamFunction(int a, int b, int c)
+{
+  TEST_ASSERT_GREATER_THAN_INT(a + b, c);
+}
+```
+
+##### `TEST_CASE`
+
+Test case is a basic generator, that can be used for param testing.
+One call of that macro will generate only one call for test function.
+It can be used with different args, such as numbers, enums, strings,
+global variables, another preprocessor defines.
+
+If we use replace comment before test function with the following code:
+
+```C
+TEST_CASE(1, 2, 5)
+TEST_CASE(3, 7, 20)
+```
+
+script will generate 2 test calls:
+
+```C
+test_demoParamFunction(1, 2, 5);
+test_demoParamFunction(10, 7, 20);
+```
+
+That calls will be wrapped with `setUp`, `tearDown` and other
+usual Unity calls, as for independent unit tests.
+The following output can be generated after test executable startup:
+
+```Log
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(1, 2, 5):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(10, 7, 20):PASS
+```
+
+##### `TEST_RANGE`
+
+Test range is an advanced generator. It single call can be converted to zero,
+one or few `TEST_CASE` equivalent commands.
+
+That generator can be used for creating numeric ranges in decimal representation
+only: integers & floating point numbers. It uses few formats for every parameter:
+
+1. `[start, stop, step]` is stop-inclusive format
+2. `<start, stop, step>` is stop-exclusive formats
+
+Format providers 1 and 2 accept only three arguments:
+
+* `start` is start number
+* `stop` is end number (can or cannot exists in result sequence for format 1,
+will be always skipped for format 2)
+* `step` is incrementing step: can be either positive or negative value.
+
+Let's use our `test_demoParamFunction` test for checking, what ranges
+will be generated for our single `TEST_RANGE` row:
+
+```C
+TEST_RANGE([3, 4, 1], [10, 5, -2], <30, 31, 1>)
+```
+
+Tests execution output will be similar to that text:
+
+```Log
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 10, 30):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 8, 30):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 6, 30):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 10, 30):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 8, 30):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 6, 30):PASS
+```
+
+As we can see:
+
+| Parameter | Format | Possible values | Total of values | Format number |
+|---|---|---|---|---|
+| `a` | `[3, 4, 1]` | `3`, `4` | 2 | Format 1 |
+| `b` | `[10, 5, -2]` | `10`, `8`, `6` | 3 | Format 1, negative step, end number is not included |
+| `c` | `<30, 31, 1>` | `30` | 1 | Format 2 |
+
+_Note_, that format 2 also supports negative step.
+
+We totally have 2 * 3 * 1 = 6 equal test cases, that can be written as following:
+
+```C
+TEST_CASE(3, 10, 30)
+TEST_CASE(3, 8, 30)
+TEST_CASE(3, 6, 30)
+TEST_CASE(4, 10, 30)
+TEST_CASE(4, 8, 30)
+TEST_CASE(4, 6, 30)
+```
 
 ### `unity_test_summary.rb`
 
-A Unity test file contains one or more test case functions. Each test case can
+A Unity test file contains one or more test case functions.
-pass, fail, or be ignored. Each test file is run individually producing results
+Each test case can pass, fail, or be ignored.
-for its collection of test cases. A given project will almost certainly be
+Each test file is run individually producing results for its collection of test cases.
-composed of multiple test files. Therefore, the suite of tests is comprised of
+A given project will almost certainly be composed of multiple test files.
-one or more test cases spread across one or more test files. This script
+Therefore, the suite of tests is comprised of one or more test cases spread across one or more test files.
-aggregates individual test file results to generate a summary of all executed
+This script aggregates individual test file results to generate a summary of all executed test cases.
-test cases. The output includes how many tests were run, how many were ignored,
+The output includes how many tests were run, how many were ignored, and how many failed. In addition, the output includes a listing of which specific tests were ignored and failed.
-and how many failed. In addition, the output includes a listing of which
+A good example of the breadth and details of these results can be found in the `examples` directory.
-specific tests were ignored and failed. A good example of the breadth and
+Intentionally ignored and failing tests in this project generate corresponding entries in the summary report.
-details of these results can be found in the `examples` directory. Intentionally
-ignored and failing tests in this project generate corresponding entries in the
-summary report.
 
-If you're interested in other (prettier?) output formats, check into the
+If you're interested in other (prettier?) output formats, check into the [Ceedling][] build tool project that works with Unity and CMock and supports xunit-style xml as well as other goodies.
-Ceedling build tool project (ceedling.sourceforge.net) that works with Unity and
-CMock and supports xunit-style xml as well as other goodies.
 
-This script assumes the existence of files ending with the extensions
+This script assumes the existence of files ending with the extensions `.testpass` and `.testfail`.
-`.testpass` and `.testfail`.The contents of these files includes the test
+The contents of these files includes the test results summary corresponding to each test file executed with the extension set according to the presence or absence of failures for that test file.
-results summary corresponding to each test file executed with the extension set
+The script searches a specified path for these files, opens each one it finds, parses the results, and aggregates and prints a summary.
-according to the presence or absence of failures for that test file. The script
+Calling it from the command line looks like this:
-searches a specified path for these files, opens each one it finds, parses the
-results, and aggregates and prints a summary. Calling it from the command line
-looks like this:
 
 ```Shell
 ruby unity_test_summary.rb build/test/
 ```
 
-You can optionally specify a root path as well. This is really helpful when you
+You can optionally specify a root path as well.
-are using relative paths in your tools' setup, but you want to pull the summary
+This is really helpful when you are using relative paths in your tools' setup, but you want to pull the summary into an IDE like Eclipse for clickable shortcuts.
-into an IDE like Eclipse for clickable shortcuts.
 
 ```Shell
 ruby unity_test_summary.rb build/test/ ~/projects/myproject/
@@ -238,5 +354,9 @@ OVERALL UNITY TEST SUMMARY
 
 How convenient is that?
 
+*Find The Latest of This And More at [ThrowTheSwitch.org][]*
 
-*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)*
+[ruby-lang.org]: https://ruby-lang.org/
+[YAML]: http://www.yaml.org/
+[Ceedling]: http://www.throwtheswitch.org/ceedling
+[ThrowTheSwitch.org]: https://throwtheswitch.org

examples/example_1/makefile

@@ -41,6 +41,7 @@ CFLAGS += -Wno-unknown-pragmas
 CFLAGS += -Wstrict-prototypes
 CFLAGS += -Wundef
 CFLAGS += -Wold-style-definition
+#CFLAGS += -Wno-misleading-indentation
 
 TARGET_BASE1=test1
 TARGET_BASE2=test2
@@ -57,7 +58,7 @@ default: $(SRC_FILES1) $(SRC_FILES2)
 	$(C_COMPILER) $(CFLAGS) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES1) -o $(TARGET1)
 	$(C_COMPILER) $(CFLAGS) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES2) -o $(TARGET2)
 	- ./$(TARGET1)
-	./$(TARGET2)
+	- ./$(TARGET2)
 
 test/test_runners/TestProductionCode_Runner.c: test/TestProductionCode.c
 	ruby $(UNITY_ROOT)/auto/generate_test_runner.rb test/TestProductionCode.c  test/test_runners/TestProductionCode_Runner.c

examples/example_1/meson.build

@@ -0,0 +1,48 @@
+project('Unity example', 'c',
+  license: 'MIT',
+  default_options: [
+    'c_std=c99',
+    'warning_level=3',
+  ],
+  meson_version: '>= 0.49.0'
+)
+
+unity_subproject = subproject('unity')
+unity_dependency = unity_subproject.get_variable('unity_dep')
+unity_gen_runner = unity_subproject.get_variable('gen_test_runner')
+
+src1 = files([
+  'src' / 'ProductionCode.c',
+  'test' / 'TestProductionCode.c',
+])
+
+src2 = files([
+  'src' / 'ProductionCode2.c',
+  'test' / 'TestProductionCode2.c',
+])
+
+inc = include_directories('src')
+
+test1 = executable('test1',
+  sources: [
+    src1,
+    unity_gen_runner.process('test' / 'TestProductionCode.c')
+  ],
+  include_directories: [ inc ],
+  dependencies: [ unity_dependency ],
+)
+
+test('test1', test1,
+  should_fail: true)
+
+test2 = executable('test2',
+  sources: [
+    src2,
+    unity_gen_runner.process('test' / 'TestProductionCode2.c')
+  ],
+  include_directories: [ inc ],
+  dependencies: [ unity_dependency ],
+)
+
+test('test2', test2)
+

examples/example_1/readme.txt

@@ -2,4 +2,11 @@ Example 1
 =========
 
 Close to the simplest possible example of Unity, using only basic features.
-Run make to build & run the example tests.
+
+Build and run with Make
+---
+Just run `make`.
+
+Build and run with Meson
+---
+Run `meson setup build` to create the build directory, and then `meson test -C build` to build and run the tests.

examples/example_1/src/ProductionCode.c

@@ -4,14 +4,14 @@
 int Counter = 0;
 int NumbersToFind[9] = { 0, 34, 55, 66, 32, 11, 1, 77, 888 }; /* some obnoxious array to search that is 1-based indexing instead of 0. */
 
-/* This function is supposed to search through NumbersToFind and find a particular number.  
+/* This function is supposed to search through NumbersToFind and find a particular number.
- * If it finds it, the index is returned.  Otherwise 0 is returned which sorta makes sense since 
+ * If it finds it, the index is returned.  Otherwise 0 is returned which sorta makes sense since
- * NumbersToFind is indexed from 1.  Unfortunately it's broken 
+ * NumbersToFind is indexed from 1.  Unfortunately it's broken
  * (and should therefore be caught by our tests) */
 int FindFunction_WhichIsBroken(int NumberToFind)
 {
     int i = 0;
-    while (i <= 8) /* Notice I should have been in braces */
+    while (i < 8) /* Notice I should have been in braces */
         i++;
         if (NumbersToFind[i] == NumberToFind) /* Yikes!  I'm getting run after the loop finishes instead of during it! */
             return i;

examples/example_1/subprojects/unity.wrap

@@ -0,0 +1,3 @@
+[wrap-git]
+url = https://github.com/ThrowTheSwitch/Unity.git
+revision = head

examples/example_1/test/TestProductionCode.c

@@ -5,7 +5,7 @@
 /* sometimes you may want to get at local data in a module.
  * for example: If you plan to pass by reference, this could be useful
  * however, it should often be avoided */
-extern int Counter; 
+extern int Counter;
 
 void setUp(void)
 {
@@ -21,7 +21,7 @@ void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWork
 {
   /* All of these should pass */
   TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78));
-  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(1));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(2));
   TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33));
   TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999));
   TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1));
@@ -31,9 +31,9 @@ void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWil
 {
   /* You should see this line fail in your test summary */
   TEST_ASSERT_EQUAL(1, FindFunction_WhichIsBroken(34));
-  
+
-  /* Notice the rest of these didn't get a chance to run because the line above failed.  
+  /* Notice the rest of these didn't get a chance to run because the line above failed.
-   * Unit tests abort each test function on the first sign of trouble. 
+   * Unit tests abort each test function on the first sign of trouble.
    * Then NEXT test function runs as normal. */
   TEST_ASSERT_EQUAL(8, FindFunction_WhichIsBroken(8888));
 }
@@ -42,7 +42,7 @@ void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(v
 {
     /* This should be true because setUp set this up for us before this test */
     TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable());
-    
+
     /* This should be true because we can still change our answer */
     Counter = 0x1234;
     TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable());

examples/example_2/makefile

@@ -41,6 +41,7 @@ CFLAGS += -Wno-unknown-pragmas
 CFLAGS += -Wstrict-prototypes
 CFLAGS += -Wundef
 CFLAGS += -Wold-style-definition
+#CFLAGS += -Wno-misleading-indentation
 
 TARGET_BASE1=all_tests
 TARGET1 = $(TARGET_BASE1)$(TARGET_EXTENSION)
@@ -55,7 +56,7 @@ SRC_FILES1=\
   test/test_runners/TestProductionCode2_Runner.c \
   test/test_runners/all_tests.c
 INC_DIRS=-Isrc -I$(UNITY_ROOT)/src -I$(UNITY_ROOT)/extras/fixture/src
-SYMBOLS=
+SYMBOLS=-DUNITY_FIXTURE_NO_EXTRAS
 
 all: clean default
 

examples/example_2/src/ProductionCode.c

@@ -11,7 +11,7 @@ int NumbersToFind[9] = { 0, 34, 55, 66, 32, 11, 1, 77, 888 }; //some obnoxious a
 int FindFunction_WhichIsBroken(int NumberToFind)
 {
     int i = 0;
-    while (i <= 8) //Notice I should have been in braces
+    while (i < 8) //Notice I should have been in braces
         i++;
         if (NumbersToFind[i] == NumberToFind) //Yikes!  I'm getting run after the loop finishes instead of during it!
             return i;

examples/example_2/test/TestProductionCode.c

@@ -23,7 +23,7 @@ TEST(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInLis
 {
   //All of these should pass
   TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78));
-  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(1));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(2));
   TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33));
   TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999));
   TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1));

examples/example_3/rakefile.rb

@@ -1,12 +1,9 @@
-HERE = File.expand_path(File.dirname(__FILE__)) + '/'
-UNITY_ROOT = File.expand_path(File.dirname(__FILE__)) + '/../..'
-
 require 'rake'
 require 'rake/clean'
-require HERE + 'rakefile_helper'
+require_relative 'rakefile_helper'
 
 TEMP_DIRS = [
-  File.join(HERE, 'build')
+  File.join(__dir__, 'build')
 ].freeze
 
 TEMP_DIRS.each do |dir|
@@ -16,8 +13,6 @@ end
 
 task prepare_for_tests: TEMP_DIRS
 
-include RakefileHelpers
-
 # Load default configuration, for now
 DEFAULT_CONFIG_FILE = 'target_gcc_32.yml'.freeze
 configure_toolchain(DEFAULT_CONFIG_FILE)
@@ -32,8 +27,8 @@ task :summary do
 end
 
 desc 'Build and test Unity'
-task all: %i(clean unit summary)
+task all: %i[clean unit summary]
-task default: %i(clobber all)
+task default: %i[clobber all]
 task ci: [:default]
 task cruise: [:default]
 

examples/example_3/rakefile_helper.rb

@@ -1,249 +1,255 @@
-require 'yaml'
+# ==========================================
+#   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]
+# ==========================================
+
 require 'fileutils'
-require UNITY_ROOT + '/auto/unity_test_summary'
+require_relative '../../auto/unity_test_summary'
-require UNITY_ROOT + '/auto/generate_test_runner'
+require_relative '../../auto/generate_test_runner'
-require UNITY_ROOT + '/auto/colour_reporter'
+require_relative '../../auto/colour_reporter'
+require_relative '../../auto/yaml_helper'
+C_EXTENSION = '.c'.freeze
 
-module RakefileHelpers
+def load_configuration(config_file)
-  C_EXTENSION = '.c'.freeze
+  $cfg_file = config_file
+  $cfg = YamlHelper.load_file($cfg_file)
+end
 
-  def load_configuration(config_file)
+def configure_clean
-    $cfg_file = config_file
+  CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil?
-    $cfg = YAML.load(File.read($cfg_file))
+end
+
+def configure_toolchain(config_file = DEFAULT_CONFIG_FILE)
+  config_file += '.yml' unless config_file =~ /\.yml$/
+  load_configuration(config_file)
+  configure_clean
+end
+
+def unit_test_files
+  path = $cfg['compiler']['unit_tests_path'] + 'Test*' + C_EXTENSION
+  path.tr!('\\', '/')
+  FileList.new(path)
+end
+
+def local_include_dirs
+  include_dirs = $cfg['compiler']['includes']['items'].dup
+  include_dirs.delete_if { |dir| dir.is_a?(Array) }
+  include_dirs
+end
+
+def extract_headers(filename)
+  includes = []
+  lines = File.readlines(filename)
+  lines.each do |line|
+    m = line.match(/^\s*#include\s+\"\s*(.+\.[hH])\s*\"/)
+    includes << m[1] unless m.nil?
   end
+  includes
+end
 
-  def configure_clean
+def find_source_file(header, paths)
-    CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil?
+  paths.each do |dir|
+    src_file = dir + header.ext(C_EXTENSION)
+    return src_file if File.exist?(src_file)
   end
+  nil
+end
 
-  def configure_toolchain(config_file = DEFAULT_CONFIG_FILE)
+def tackit(strings)
-    config_file += '.yml' unless config_file =~ /\.yml$/
+  result = if strings.is_a?(Array)
-    load_configuration(config_file)
+             "\"#{strings.join}\""
-    configure_clean
+           else
-  end
+             strings
+           end
+  result
+end
 
-  def unit_test_files
+def squash(prefix, items)
-    path = $cfg['compiler']['unit_tests_path'] + 'Test*' + C_EXTENSION
+  result = ''
-    path.tr!('\\', '/')
+  items.each { |item| result += " #{prefix}#{tackit(item)}" }
-    FileList.new(path)
+  result
-  end
+end
 
-  def local_include_dirs
+def build_compiler_fields
-    include_dirs = $cfg['compiler']['includes']['items'].dup
+  command = tackit($cfg['compiler']['path'])
-    include_dirs.delete_if { |dir| dir.is_a?(Array) }
+  defines = if $cfg['compiler']['defines']['items'].nil?
-    include_dirs
+              ''
-  end
+            else
+              squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'])
+            end
+  options = squash('', $cfg['compiler']['options'])
+  includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
+  includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
 
-  def extract_headers(filename)
+  { command: command, defines: defines, options: options, includes: includes }
-    includes = []
+end
-    lines = File.readlines(filename)
-    lines.each do |line|
-      m = line.match(/^\s*#include\s+\"\s*(.+\.[hH])\s*\"/)
-      includes << m[1] unless m.nil?
-    end
-    includes
-  end
 
-  def find_source_file(header, paths)
+def compile(file, _defines = [])
-    paths.each do |dir|
+  compiler = build_compiler_fields
-      src_file = dir + header.ext(C_EXTENSION)
+  cmd_str  = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{file} " \
-      return src_file if File.exist?(src_file)
+             "#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}"
-    end
+  obj_file = "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}"
-    nil
+  execute(cmd_str + obj_file)
-  end
+  obj_file
+end
 
-  def tackit(strings)
+def build_linker_fields
-    result = if strings.is_a?(Array)
+  command = tackit($cfg['linker']['path'])
-               "\"#{strings.join}\""
+  options = if $cfg['linker']['options'].nil?
+              ''
+            else
+              squash('', $cfg['linker']['options'])
+            end
+  includes = if $cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil?
+               ''
              else
-               strings
+               squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items'])
-             end
+             end.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
-    result
-  end
 
-  def squash(prefix, items)
+  { command: command, options: options, includes: includes }
-    result = ''
+end
-    items.each { |item| result += " #{prefix}#{tackit(item)}" }
-    result
-  end
 
-  def build_compiler_fields
+def link_it(exe_name, obj_list)
-    command = tackit($cfg['compiler']['path'])
+  linker = build_linker_fields
-    defines = if $cfg['compiler']['defines']['items'].nil?
+  cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " +
-                ''
+            (obj_list.map { |obj| "#{$cfg['linker']['object_files']['path']}#{obj} " }).join +
-              else
+            $cfg['linker']['bin_files']['prefix'] + ' ' +
-                squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'])
+            $cfg['linker']['bin_files']['destination'] +
-              end
+            exe_name + $cfg['linker']['bin_files']['extension']
-    options  = squash('', $cfg['compiler']['options'])
+  execute(cmd_str)
-    includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
+end
-    includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
 
-    { command: command, defines: defines, options: options, includes: includes }
+def build_simulator_fields
-  end
+  return nil if $cfg['simulator'].nil?
 
-  def compile(file, _defines = [])
+  command = if $cfg['simulator']['path'].nil?
-    compiler = build_compiler_fields
+              ''
-    cmd_str  = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{file} " \
+            else
-               "#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}"
+              (tackit($cfg['simulator']['path']) + ' ')
-    obj_file = "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}"
+            end
-    execute(cmd_str + obj_file)
+  pre_support = if $cfg['simulator']['pre_support'].nil?
-    obj_file
+                  ''
-  end
-
-  def build_linker_fields
-    command = tackit($cfg['linker']['path'])
-    options = if $cfg['linker']['options'].nil?
-                ''
-              else
-                squash('', $cfg['linker']['options'])
-              end
-    includes = if $cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil?
-                 ''
-               else
-                 squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items'])
-               end.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
-
-    { command: command, options: options, includes: includes }
-  end
-
-  def link_it(exe_name, obj_list)
-    linker = build_linker_fields
-    cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " +
-              (obj_list.map { |obj| "#{$cfg['linker']['object_files']['path']}#{obj} " }).join +
-              $cfg['linker']['bin_files']['prefix'] + ' ' +
-              $cfg['linker']['bin_files']['destination'] +
-              exe_name + $cfg['linker']['bin_files']['extension']
-    execute(cmd_str)
-  end
-
-  def build_simulator_fields
-    return nil if $cfg['simulator'].nil?
-    command = if $cfg['simulator']['path'].nil?
-                ''
-              else
-                (tackit($cfg['simulator']['path']) + ' ')
-              end
-    pre_support = if $cfg['simulator']['pre_support'].nil?
-                    ''
-                  else
-                    squash('', $cfg['simulator']['pre_support'])
-                  end
-    post_support = if $cfg['simulator']['post_support'].nil?
-                     ''
-                   else
-                     squash('', $cfg['simulator']['post_support'])
-                   end
-
-    { command: command, pre_support: pre_support, post_support: post_support }
-  end
-
-  def execute(command_string, verbose = true, raise_on_fail = true)
-    report command_string
-    output = `#{command_string}`.chomp
-    report(output) if verbose && !output.nil? && !output.empty?
-    if !$?.exitstatus.zero? && raise_on_fail
-      raise "Command failed. (Returned #{$?.exitstatus})"
-    end
-    output
-  end
-
-  def report_summary
-    summary = UnityTestSummary.new
-    summary.root = HERE
-    results_glob = "#{$cfg['compiler']['build_path']}*.test*"
-    results_glob.tr!('\\', '/')
-    results = Dir[results_glob]
-    summary.targets = results
-    summary.run
-    fail_out 'FAIL: There were failures' if summary.failures > 0
-  end
-
-  def run_tests(test_files)
-    report 'Running system tests...'
-
-    # Tack on TEST define for compiling unit tests
-    load_configuration($cfg_file)
-    test_defines = ['TEST']
-    $cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil?
-    $cfg['compiler']['defines']['items'] << 'TEST'
-
-    include_dirs = local_include_dirs
-
-    # Build and execute each unit test
-    test_files.each do |test|
-      obj_list = []
-
-      # Detect dependencies and build required required modules
-      extract_headers(test).each do |header|
-        # Compile corresponding source file if it exists
-        src_file = find_source_file(header, include_dirs)
-        obj_list << compile(src_file, test_defines) unless src_file.nil?
-      end
-
-      # Build the test runner (generate if configured to do so)
-      test_base = File.basename(test, C_EXTENSION)
-      runner_name = test_base + '_Runner.c'
-      if $cfg['compiler']['runner_path'].nil?
-        runner_path = $cfg['compiler']['build_path'] + runner_name
-        test_gen = UnityTestRunnerGenerator.new($cfg_file)
-        test_gen.run(test, runner_path)
-      else
-        runner_path = $cfg['compiler']['runner_path'] + runner_name
-      end
-
-      obj_list << compile(runner_path, test_defines)
-
-      # Build the test module
-      obj_list << compile(test, test_defines)
-
-      # Link the test executable
-      link_it(test_base, obj_list)
-
-      # Execute unit test and generate results file
-      simulator = build_simulator_fields
-      executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension']
-      cmd_str = if simulator.nil?
-                  executable
                 else
-                  "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}"
+                  squash('', $cfg['simulator']['pre_support'])
                 end
-      output = execute(cmd_str, true, false)
+  post_support = if $cfg['simulator']['post_support'].nil?
-      test_results = $cfg['compiler']['build_path'] + test_base
+                   ''
-      test_results += if output.match(/OK$/m).nil?
+                 else
-                        '.testfail'
+                   squash('', $cfg['simulator']['post_support'])
-                      else
+                 end
-                        '.testpass'
+
-                      end
+  { command: command, pre_support: pre_support, post_support: post_support }
-      File.open(test_results, 'w') { |f| f.print output }
+end
-    end
+
+def execute(command_string, verbose = true, raise_on_fail = true)
+  report command_string
+  output = `#{command_string}`.chomp
+  report(output) if verbose && !output.nil? && !output.empty?
+
+  if !$?.nil? && !$?.exitstatus.zero? && raise_on_fail
+    raise "Command failed. (Returned #{$?.exitstatus})"
   end
 
-  def build_application(main)
+  output
-    report 'Building application...'
+end
 
+def report_summary
+  summary = UnityTestSummary.new
+  summary.root = __dir__
+  results_glob = "#{$cfg['compiler']['build_path']}*.test*"
+  results_glob.tr!('\\', '/')
+  results = Dir[results_glob]
+  summary.targets = results
+  summary.run
+  fail_out 'FAIL: There were failures' if summary.failures > 0
+end
+
+def run_tests(test_files)
+  report 'Running system tests...'
+
+  # Tack on TEST define for compiling unit tests
+  load_configuration($cfg_file)
+  test_defines = ['TEST']
+  $cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil?
+  $cfg['compiler']['defines']['items'] << 'TEST'
+
+  include_dirs = local_include_dirs
+
+  # Build and execute each unit test
+  test_files.each do |test|
     obj_list = []
-    load_configuration($cfg_file)
-    main_path = $cfg['compiler']['source_path'] + main + C_EXTENSION
 
     # Detect dependencies and build required required modules
-    include_dirs = get_local_include_dirs
+    extract_headers(test).each do |header|
-    extract_headers(main_path).each do |header|
+      # Compile corresponding source file if it exists
       src_file = find_source_file(header, include_dirs)
-      obj_list << compile(src_file) unless src_file.nil?
+      obj_list << compile(src_file, test_defines) unless src_file.nil?
     end
 
-    # Build the main source file
+    # Build the test runner (generate if configured to do so)
-    main_base = File.basename(main_path, C_EXTENSION)
+    test_base = File.basename(test, C_EXTENSION)
-    obj_list << compile(main_path)
+    runner_name = test_base + '_Runner.c'
+    if $cfg['compiler']['runner_path'].nil?
+      runner_path = $cfg['compiler']['build_path'] + runner_name
+      test_gen = UnityTestRunnerGenerator.new($cfg_file)
+      test_gen.run(test, runner_path)
+    else
+      runner_path = $cfg['compiler']['runner_path'] + runner_name
+    end
 
-    # Create the executable
+    obj_list << compile(runner_path, test_defines)
-    link_it(main_base, obj_list)
-  end
 
-  def fail_out(msg)
+    # Build the test module
-    puts msg
+    obj_list << compile(test, test_defines)
-    puts 'Not returning exit code so continuous integration can pass'
+
-    #    exit(-1) # Only removed to pass example_3, which has failing tests on purpose.
+    # Link the test executable
-    #               Still fail if the build fails for any other reason.
+    link_it(test_base, obj_list)
+
+    # Execute unit test and generate results file
+    simulator = build_simulator_fields
+    executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension']
+    cmd_str = if simulator.nil?
+                executable
+              else
+                "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}"
+              end
+    output = execute(cmd_str, true, false)
+    test_results = $cfg['compiler']['build_path'] + test_base
+    test_results += if output.match(/OK$/m).nil?
+                      '.testfail'
+                    else
+                      '.testpass'
+                    end
+    File.open(test_results, 'w') { |f| f.print output }
   end
 end
+
+def build_application(main)
+  report 'Building application...'
+
+  obj_list = []
+  load_configuration($cfg_file)
+  main_path = $cfg['compiler']['source_path'] + main + C_EXTENSION
+
+  # Detect dependencies and build required required modules
+  include_dirs = get_local_include_dirs
+  extract_headers(main_path).each do |header|
+    src_file = find_source_file(header, include_dirs)
+    obj_list << compile(src_file) unless src_file.nil?
+  end
+
+  # Build the main source file
+  main_base = File.basename(main_path, C_EXTENSION)
+  obj_list << compile(main_path)
+
+  # Create the executable
+  link_it(main_base, obj_list)
+end
+
+def fail_out(msg)
+  puts msg
+  puts 'Not returning exit code so continuous integration can pass'
+  #    exit(-1) # Only removed to pass example_3, which has failing tests on purpose.
+  #               Still fail if the build fails for any other reason.
+end

examples/example_3/src/ProductionCode.c

@@ -11,7 +11,7 @@ int NumbersToFind[9] = { 0, 34, 55, 66, 32, 11, 1, 77, 888 }; //some obnoxious a
 int FindFunction_WhichIsBroken(int NumberToFind)
 {
     int i = 0;
-    while (i <= 8) //Notice I should have been in braces
+    while (i < 8) //Notice I should have been in braces
         i++;
         if (NumbersToFind[i] == NumberToFind) //Yikes!  I'm getting run after the loop finishes instead of during it!
             return i;

examples/example_3/target_gcc_32.yml

@@ -1,8 +1,9 @@
 # Copied from ~Unity/targets/gcc_32.yml
 unity_root:  &unity_root '../..'
+unity_source: &unity_source '../../src/'
 compiler:
   path: gcc
-  source_path:     'src/'
+  source_path:     &source_path 'src/'
   unit_tests_path: &unit_tests_path 'test/'
   build_path:      &build_path 'build/'
   options:
@@ -15,8 +16,8 @@ compiler:
   includes:
     prefix: '-I'
     items:
-      - 'src/'
+      - *source_path
-      - '../../src/'
+      - *unity_source
       - *unit_tests_path
   defines:
     prefix: '-D'

examples/example_4/meson.build

@@ -0,0 +1,12 @@
+#
+# build script written by : Michael Brockus.
+# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
+#
+# license: MIT
+#
+project('example-4', 'c', meson_version: '>= 0.55.0')
+
+unity_dep = dependency('unity')
+
+subdir('src')
+subdir('test')

examples/example_4/readme.txt

@@ -0,0 +1,15 @@
+Example 4
+=========
+
+Close to the simplest possible example of Unity, using only basic features.
+to build this example run "meson setup <build dir name>".
+
+Meson uses the Ninja build system to actually build the code. To start the 
+build, simply type the following command.  
+
+"ninja -C <build dir name>"
+
+Meson provides native support for running tests. The command to do that is simple.
+
+"meson test -C <build dir name>".
+ 

examples/example_4/src/ProductionCode.c

@@ -0,0 +1,24 @@
+
+#include "ProductionCode.h"
+
+int Counter = 0;
+int NumbersToFind[9] = { 0, 34, 55, 66, 32, 11, 1, 77, 888 }; /* some obnoxious array to search that is 1-based indexing instead of 0. */
+
+/* This function is supposed to search through NumbersToFind and find a particular number.
+ * If it finds it, the index is returned.  Otherwise 0 is returned which sorta makes sense since
+ * NumbersToFind is indexed from 1.  Unfortunately it's broken
+ * (and should therefore be caught by our tests) */
+int FindFunction_WhichIsBroken(int NumberToFind)
+{
+    int i = 0;
+    while (i < 8) /* Notice I should have been in braces */
+        i++;
+        if (NumbersToFind[i] == NumberToFind) /* Yikes!  I'm getting run after the loop finishes instead of during it! */
+            return i;
+    return 0;
+}
+
+int FunctionWhichReturnsLocalVariable(void)
+{
+    return Counter;
+}

examples/example_4/src/ProductionCode.h

@@ -0,0 +1,3 @@
+
+int FindFunction_WhichIsBroken(int NumberToFind);
+int FunctionWhichReturnsLocalVariable(void);

examples/example_4/src/ProductionCode2.c

@@ -0,0 +1,11 @@
+
+#include "ProductionCode2.h"
+
+char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction)
+{
+  (void)Poor;
+  (void)LittleFunction;
+  /* Since There Are No Tests Yet, This Function Could Be Empty For All We Know.
+   * Which isn't terribly useful... but at least we put in a TEST_IGNORE so we won't forget */
+  return (char*)0;
+}

examples/example_4/src/ProductionCode2.h

@@ -0,0 +1,2 @@
+
+char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction);

examples/example_4/src/meson.build

@@ -0,0 +1,16 @@
+#
+# build script written by : Michael Brockus.
+# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
+#
+# license: MIT
+#
+inc_dir = include_directories('.')
+lib_list = {'a': ['ProductionCode.c' ], 'b': ['ProductionCode2.c']}
+
+foreach lib, src : lib_list
+    set_variable(lib + '_lib', 
+        static_library(lib + '_lib', sources: src, include_directories: inc_dir))
+endforeach
+
+a_dep = declare_dependency(link_with: a_lib, include_directories: inc_dir)
+b_dep = declare_dependency(link_with: b_lib, include_directories: inc_dir)

examples/example_4/subprojects/unity.wrap

@@ -0,0 +1,6 @@
+[wrap-git]
+url = https://github.com/ThrowTheSwitch/Unity.git
+revision = head
+
+[provide]
+unity = unity_dep

examples/example_4/test/TestProductionCode.c

@@ -0,0 +1,63 @@
+
+#include "ProductionCode.h"
+#include "unity.h"
+
+/* sometimes you may want to get at local data in a module.
+ * for example: If you plan to pass by reference, this could be useful
+ * however, it should often be avoided */
+extern int Counter;
+
+void setUp(void)
+{
+  /* This is run before EACH TEST */
+  Counter = 0x5a5a;
+}
+
+void tearDown(void)
+{
+}
+
+
+void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void)
+{
+  /* All of these should pass */
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(2));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1));
+}
+
+void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void)
+{
+  /* You should see this line fail in your test summary */
+  TEST_ASSERT_EQUAL(1, FindFunction_WhichIsBroken(34));
+
+  /* Notice the rest of these didn't get a chance to run because the line above failed.
+   * Unit tests abort each test function on the first sign of trouble.
+   * Then NEXT test function runs as normal. */
+  TEST_ASSERT_EQUAL(8, FindFunction_WhichIsBroken(8888));
+}
+
+void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void)
+{
+    /* This should be true because setUp set this up for us before this test */
+    TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable());
+
+    /* This should be true because we can still change our answer */
+    Counter = 0x1234;
+    TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable());
+}
+
+void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void)
+{
+    /* This should be true again because setup was rerun before this test (and after we changed it to 0x1234) */
+    TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable());
+}
+
+void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void)
+{
+    /* Sometimes you get the test wrong.  When that happens, you get a failure too... and a quick look should tell
+     * you what actually happened...which in this case was a failure to setup the initial condition. */
+    TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable());
+}

examples/example_4/test/TestProductionCode2.c

@@ -0,0 +1,35 @@
+
+#include "ProductionCode2.h"
+#include "unity.h"
+
+/* These should be ignored because they are commented out in various ways:
+#include "whatever.h" 
+#include "somethingelse.h"
+*/
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void test_IgnoredTest(void);
+void test_AnotherIgnoredTest(void);
+void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void);
+
+void test_IgnoredTest(void)
+{
+    TEST_IGNORE_MESSAGE("This Test Was Ignored On Purpose");
+}
+
+void test_AnotherIgnoredTest(void)
+{
+    TEST_IGNORE_MESSAGE("These Can Be Useful For Leaving Yourself Notes On What You Need To Do Yet");
+}
+
+void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void)
+{
+    TEST_IGNORE(); /* Like This */
+}

examples/example_4/test/meson.build

@@ -0,0 +1,7 @@
+#
+# build script written by : Michael Brockus.
+# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
+#
+# license: MIT
+#
+subdir('test_runners')

examples/example_4/test/test_runners/TestProductionCode2_Runner.c

@@ -0,0 +1,53 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+
+/*=======Test Runner Used To Run Each Test Below=====*/
+#define RUN_TEST(TestFunc, TestLineNum) \
+{ \
+  Unity.CurrentTestName = #TestFunc; \
+  Unity.CurrentTestLineNumber = TestLineNum; \
+  Unity.NumberOfTests++; \
+  if (TEST_PROTECT()) \
+  { \
+      setUp(); \
+      TestFunc(); \
+  } \
+  if (TEST_PROTECT()) \
+  { \
+    tearDown(); \
+  } \
+  UnityConcludeTest(); \
+}
+
+/*=======Automagically Detected Files To Include=====*/
+#include "unity.h"
+#include <setjmp.h>
+#include <stdio.h>
+#include "ProductionCode2.h"
+
+/*=======External Functions This Runner Calls=====*/
+extern void setUp(void);
+extern void tearDown(void);
+extern void test_IgnoredTest(void);
+extern void test_AnotherIgnoredTest(void);
+extern void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void);
+
+
+/*=======Test Reset Option=====*/
+void resetTest(void);
+void resetTest(void)
+{
+  tearDown();
+  setUp();
+}
+
+
+/*=======MAIN=====*/
+int main(void)
+{
+  UnityBegin("test/TestProductionCode2.c");
+  RUN_TEST(test_IgnoredTest, 18);
+  RUN_TEST(test_AnotherIgnoredTest, 23);
+  RUN_TEST(test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented, 28);
+
+  return (UnityEnd());
+}

examples/example_4/test/test_runners/TestProductionCode_Runner.c

@@ -0,0 +1,57 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+
+/*=======Test Runner Used To Run Each Test Below=====*/
+#define RUN_TEST(TestFunc, TestLineNum) \
+{ \
+  Unity.CurrentTestName = #TestFunc; \
+  Unity.CurrentTestLineNumber = TestLineNum; \
+  Unity.NumberOfTests++; \
+  if (TEST_PROTECT()) \
+  { \
+      setUp(); \
+      TestFunc(); \
+  } \
+  if (TEST_PROTECT()) \
+  { \
+    tearDown(); \
+  } \
+  UnityConcludeTest(); \
+}
+
+/*=======Automagically Detected Files To Include=====*/
+#include "unity.h"
+#include <setjmp.h>
+#include <stdio.h>
+#include "ProductionCode.h"
+
+/*=======External Functions This Runner Calls=====*/
+extern void setUp(void);
+extern void tearDown(void);
+extern void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void);
+extern void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void);
+extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void);
+extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void);
+extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void);
+
+
+/*=======Test Reset Option=====*/
+void resetTest(void);
+void resetTest(void)
+{
+  tearDown();
+  setUp();
+}
+
+
+/*=======MAIN=====*/
+int main(void)
+{
+  UnityBegin("test/TestProductionCode.c");
+  RUN_TEST(test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode, 20);
+  RUN_TEST(test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken, 30);
+  RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue, 41);
+  RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain, 51);
+  RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed, 57);
+
+  return (UnityEnd());
+}

examples/example_4/test/test_runners/meson.build

@@ -0,0 +1,13 @@
+#
+# build script written by : Michael Brockus.
+# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
+#
+# license: MIT
+#
+cases = [
+          ['TestProductionCode_Runner.c',  join_paths('..' ,'TestProductionCode.c' )],
+          ['TestProductionCode2_Runner.c', join_paths('..' ,'TestProductionCode2.c')]
+        ]
+
+test('01-test-case', executable('01-test-case', cases[0], dependencies: [ a_dep, unity_dep ]))
+test('02-test-case', executable('02-test-case', cases[1], dependencies: [ b_dep, unity_dep ]))

examples/unity_config.h

@@ -176,6 +176,22 @@
 /* #define UNITY_DOUBLE_PRECISION 0.001f */
 
 
+/* *************************** MISCELLANEOUS ***********************************
+ * Miscellaneous configuration options for Unity
+ **************************************************************************** */
+
+/* Unity uses the stddef.h header included in the C standard library for the
+ * "NULL" macro. Define this in order to disable the include of stddef.h. If you
+ * do this, you have to make sure to provide your own "NULL" definition.
+ */
+/* #define UNITY_EXCLUDE_STDDEF_H */
+
+/* Define this to enable the unity formatted print macro:
+ * "TEST_PRINTF"
+ */
+/* #define UNITY_INCLUDE_PRINT_FORMATTED */
+
+
 /* *************************** TOOLSET CUSTOMIZATION ***************************
  * In addition to the options listed above, there are a number of other options
  * which will come in handy to customize Unity's behavior for your specific
@@ -208,25 +224,6 @@
 /* #define UNITY_OUTPUT_START()                    RS232_config(115200,1,8,0) */
 /* #define UNITY_OUTPUT_COMPLETE()                 RS232_close() */
 
-/* For some targets, Unity can make the otherwise required `setUp()` and
- * `tearDown()` functions optional. This is a nice convenience for test writers
- * since `setUp` and `tearDown` don't often actually _do_ anything. If you're
- * using gcc or clang, this option is automatically defined for you. Other
- * compilers can also support this behavior, if they support a C feature called
- * weak functions. A weak function is a function that is compiled into your
- * executable _unless_ a non-weak version of the same function is defined
- * elsewhere. If a non-weak version is found, the weak version is ignored as if
- * it never existed. If your compiler supports this feature, you can let Unity
- * know by defining `UNITY_SUPPORT_WEAK` as the function attributes that would
- * need to be applied to identify a function as weak. If your compiler lacks
- * support for weak functions, you will always need to define `setUp` and
- * `tearDown` functions (though they can be and often will be just empty). The
- * most common options for this feature are:
- */
-/* #define UNITY_SUPPORT_WEAK weak */
-/* #define UNITY_SUPPORT_WEAK __attribute__((weak)) */
-/* #define UNITY_NO_WEAK */
-
 /* Some compilers require a custom attribute to be assigned to pointers, like
  * `near` or `far`. In these cases, you can give Unity a safe default for these
  * by defining this option with the attribute you would like.
@@ -236,4 +233,12 @@
 /* #define UNITY_PTR_ATTRIBUTE __attribute__((far)) */
 /* #define UNITY_PTR_ATTRIBUTE near */
 
+/* Print execution time of each test when executed in verbose mode
+ *
+ * Example:
+ *
+ * TEST - PASS (10 ms)
+ */
+/* #define UNITY_INCLUDE_EXEC_TIME */
+
 #endif /* UNITY_CONFIG_H */

extras/fixture/rakefile.rb

@@ -1,48 +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]
-# ==========================================
-
-HERE = File.expand_path(File.dirname(__FILE__)) + '/'
-
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require HERE + 'rakefile_helper'
-
-TEMP_DIRS = [
-  File.join(HERE, 'build')
-].freeze
-
-TEMP_DIRS.each do |dir|
-  directory(dir)
-  CLOBBER.include(dir)
-end
-
-task prepare_for_tests: TEMP_DIRS
-
-include RakefileHelpers
-
-# Load default configuration, for now
-DEFAULT_CONFIG_FILE = 'gcc_auto_stdint.yml'.freeze
-configure_toolchain(DEFAULT_CONFIG_FILE)
-
-task unit: [:prepare_for_tests] do
-  run_tests
-end
-
-desc 'Build and test Unity Framework'
-task all: %i(clean unit)
-task default: %i(clobber all)
-task ci: %i(no_color default)
-task cruise: %i(no_color default)
-
-desc 'Load configuration'
-task :config, :config_file do |_t, args|
-  configure_toolchain(args[:config_file])
-end
-
-task :no_color do
-  $colour_output = false
-end

extras/fixture/rakefile_helper.rb

@@ -1,178 +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]
-# ==========================================
-
-require 'yaml'
-require 'fileutils'
-require HERE + '../../auto/unity_test_summary'
-require HERE + '../../auto/generate_test_runner'
-require HERE + '../../auto/colour_reporter'
-
-module RakefileHelpers
-  C_EXTENSION = '.c'.freeze
-
-  def load_configuration(config_file)
-    return if $configured
-
-    $cfg_file = HERE + "../../test/targets/#{config_file}" unless config_file =~ /[\\|\/]/
-    $cfg = YAML.load(File.read($cfg_file))
-    $colour_output = false unless $cfg['colour']
-    $configured = true if config_file != DEFAULT_CONFIG_FILE
-  end
-
-  def configure_clean
-    CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil?
-  end
-
-  def configure_toolchain(config_file = DEFAULT_CONFIG_FILE)
-    config_file += '.yml' unless config_file =~ /\.yml$/
-    config_file = config_file unless config_file =~ /[\\|\/]/
-    load_configuration(config_file)
-    configure_clean
-  end
-
-  def tackit(strings)
-    result = if strings.is_a?(Array)
-               "\"#{strings.join}\""
-             else
-               strings
-             end
-    result
-  end
-
-  def squash(prefix, items)
-    result = ''
-    items.each { |item| result += " #{prefix}#{tackit(item)}" }
-    result
-  end
-
-  def build_compiler_fields
-    command = tackit($cfg['compiler']['path'])
-    defines = if $cfg['compiler']['defines']['items'].nil?
-                ''
-              else
-                squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar'] + ['UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\)'])
-              end
-    options  = squash('', $cfg['compiler']['options'])
-    includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
-    includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
-
-    { command: command, defines: defines, options: options, includes: includes }
-  end
-
-  def compile(file, _defines = [])
-    compiler = build_compiler_fields
-    unity_include = $cfg['compiler']['includes']['prefix'] + '../../src'
-    cmd_str = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{unity_include} #{file} " \
-              "#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}" \
-              "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}"
-
-    execute(cmd_str)
-  end
-
-  def build_linker_fields
-    command = tackit($cfg['linker']['path'])
-    options = if $cfg['linker']['options'].nil?
-                ''
-              else
-                squash('', $cfg['linker']['options'])
-              end
-    includes = if $cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil?
-                 ''
-               else
-                 squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items'])
-               end.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
-
-    { command: command, options: options, includes: includes }
-  end
-
-  def link_it(exe_name, obj_list)
-    linker = build_linker_fields
-    cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " +
-              (obj_list.map { |obj| "#{$cfg['linker']['object_files']['path']}#{obj} " }).join +
-              $cfg['linker']['bin_files']['prefix'] + ' ' +
-              $cfg['linker']['bin_files']['destination'] +
-              exe_name + $cfg['linker']['bin_files']['extension']
-    execute(cmd_str)
-  end
-
-  def build_simulator_fields
-    return nil if $cfg['simulator'].nil?
-    command = if $cfg['simulator']['path'].nil?
-                ''
-              else
-                (tackit($cfg['simulator']['path']) + ' ')
-              end
-    pre_support = if $cfg['simulator']['pre_support'].nil?
-                    ''
-                  else
-                    squash('', $cfg['simulator']['pre_support'])
-                  end
-    post_support = if $cfg['simulator']['post_support'].nil?
-                     ''
-                   else
-                     squash('', $cfg['simulator']['post_support'])
-                   end
-    { command: command, pre_support: pre_support, post_support: post_support }
-  end
-
-  def execute(command_string, verbose = true)
-    report command_string
-    output = `#{command_string}`.chomp
-    report(output) if verbose && !output.nil? && !output.empty?
-    raise "Command failed. (Returned #{$?.exitstatus})" if $?.exitstatus != 0
-    output
-  end
-
-  def report_summary
-    summary = UnityTestSummary.new
-    summary.root = HERE
-    results_glob = "#{$cfg['compiler']['build_path']}*.test*"
-    results_glob.tr!('\\', '/')
-    results = Dir[results_glob]
-    summary.targets = results
-    summary.run
-  end
-
-  def run_tests
-    report 'Running Unity system tests...'
-
-    # Tack on TEST define for compiling unit tests
-    load_configuration($cfg_file)
-    test_defines = ['TEST']
-    $cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil?
-
-    # Get a list of all source files needed
-    src_files  = Dir[HERE + 'src/*.c']
-    src_files += Dir[HERE + 'test/*.c']
-    src_files += Dir[HERE + 'test/main/*.c']
-    src_files << '../../src/unity.c'
-
-    # Build object files
-    src_files.each { |f| compile(f, test_defines) }
-    obj_list = src_files.map { |f| File.basename(f.ext($cfg['compiler']['object_files']['extension'])) }
-
-    # Link the test executable
-    test_base = 'framework_test'
-    link_it(test_base, obj_list)
-
-    # Execute unit test and generate results file
-    simulator = build_simulator_fields
-    executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension']
-    cmd_str = if simulator.nil?
-                executable + ' -v -r'
-              else
-                "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}"
-              end
-    output = execute(cmd_str)
-    test_results = $cfg['compiler']['build_path'] + test_base
-    test_results += if output.match(/OK$/m).nil?
-                      '.testfail'
-                    else
-                      '.testpass'
-                    end
-    File.open(test_results, 'w') { |f| f.print output }
-  end
-end

extras/fixture/readme.md

@@ -0,0 +1,26 @@
+# Unity Fixtures
+
+This Framework is an optional add-on to Unity.
+By including unity_fixture.h in place of unity.h, you may now work with Unity in a manner similar to CppUTest.
+This framework adds the concepts of test groups and gives finer control of your tests over the command line.
+
+This framework is primarily supplied for those working through James Grenning's book on Embedded Test Driven Development, or those coming to Unity from CppUTest.
+We should note that using this framework glosses over some of the features of Unity, and makes it more difficult to integrate with other testing tools like Ceedling and CMock.
+
+## Dependency Notification
+
+Fixtures, by default, uses the Memory addon as well.
+This is to make it simple for those trying to follow along with James' book.
+Using them together is completely optional.
+You may choose to use Fixtures without Memory handling by defining `UNITY_FIXTURE_NO_EXTRAS`.
+It will then stop automatically pulling in extras and leave you to do it as desired.
+
+## Usage information
+
+By default the test executables produced by Unity Fixtures run all tests once, but the behavior can be configured with command-line flags.
+Run the test executable with the `--help` flag for more information.
+
+It's possible to add a custom line at the end of the help message, typically to point to project-specific or company-specific unit test documentation.
+Define `UNITY_CUSTOM_HELP_MSG` to provide a custom message, e.g.:
+
+    #define UNITY_CUSTOM_HELP_MSG "If any test fails see https://example.com/troubleshooting"

extras/fixture/readme.txt

@@ -1,9 +0,0 @@
-Copyright (c) 2010 James Grenning and Contributed to Unity Project
-
-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]
-
-This Framework is an optional add-on to Unity.  By including unity_framework.h in place of unity.h,
-you may now work with Unity in a manner similar to CppUTest.  This framework adds the concepts of 
-test groups and gives finer control of your tests over the command line.

extras/fixture/src/meson.build

@@ -0,0 +1,10 @@
+unity_inc += include_directories('.')
+unity_src += files('unity_fixture.c')
+
+if not meson.is_subproject()
+  install_headers(
+    'unity_fixture.h',
+    'unity_fixture_internals.h',
+    subdir: meson.project_name()
+  )
+endif

extras/fixture/src/unity_fixture.c

@@ -15,10 +15,8 @@ struct UNITY_FIXTURE_T UnityFixture;
  * Build with -D UNITY_OUTPUT_CHAR=outputChar and include <stdio.h>
  * int (*outputChar)(int) = putchar; */
 
-#if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA)
 void setUp(void)    { /*does nothing*/ }
 void tearDown(void) { /*does nothing*/ }
-#endif
 
 static void announceTestRun(unsigned int runNumber)
 {
@@ -79,20 +77,27 @@ void UnityTestRunner(unityfunction* setup,
         Unity.TestFile = file;
         Unity.CurrentTestName = printableName;
         Unity.CurrentTestLineNumber = line;
-        if (!UnityFixture.Verbose)
+        if (UnityFixture.Verbose)
-            UNITY_OUTPUT_CHAR('.');
-        else
         {
             UnityPrint(printableName);
         #ifndef UNITY_REPEAT_TEST_NAME
             Unity.CurrentTestName = NULL;
         #endif
         }
+        else if (UnityFixture.Silent)
+        {
+            /* Do Nothing */
+        }
+        else
+        {
+            UNITY_OUTPUT_CHAR('.');
+        }
 
         Unity.NumberOfTests++;
-        UnityMalloc_StartTest();
         UnityPointer_Init();
 
+        UNITY_EXEC_TIME_START();
+
         if (TEST_PROTECT())
         {
             setup();
@@ -105,8 +110,6 @@ void UnityTestRunner(unityfunction* setup,
         if (TEST_PROTECT())
         {
             UnityPointer_UndoAllSets();
-            if (!Unity.CurrentTestFailed)
-                UnityMalloc_EndTest();
         }
         UnityConcludeFixtureTest();
     }
@@ -118,191 +121,22 @@ void UnityIgnoreTest(const char* printableName, const char* group, const char* n
     {
         Unity.NumberOfTests++;
         Unity.TestIgnores++;
-        if (!UnityFixture.Verbose)
+        if (UnityFixture.Verbose)
-            UNITY_OUTPUT_CHAR('!');
-        else
         {
             UnityPrint(printableName);
             UNITY_PRINT_EOL();
         }
+        else if (UnityFixture.Silent)
+        {
+            /* Do Nothing */
+        }
+        else
+        {
+            UNITY_OUTPUT_CHAR('!');
+        }
     }
 }
 
-
-/*------------------------------------------------- */
-/* Malloc and free stuff */
-#define MALLOC_DONT_FAIL -1
-static int malloc_count;
-static int malloc_fail_countdown = MALLOC_DONT_FAIL;
-
-void UnityMalloc_StartTest(void)
-{
-    malloc_count = 0;
-    malloc_fail_countdown = MALLOC_DONT_FAIL;
-}
-
-void UnityMalloc_EndTest(void)
-{
-    malloc_fail_countdown = MALLOC_DONT_FAIL;
-    if (malloc_count != 0)
-    {
-        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "This test leaks!");
-    }
-}
-
-void UnityMalloc_MakeMallocFailAfterCount(int countdown)
-{
-    malloc_fail_countdown = countdown;
-}
-
-/* These definitions are always included from unity_fixture_malloc_overrides.h */
-/* We undef to use them or avoid conflict with <stdlib.h> per the C standard */
-#undef malloc
-#undef free
-#undef calloc
-#undef realloc
-
-#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
-static unsigned char unity_heap[UNITY_INTERNAL_HEAP_SIZE_BYTES];
-static size_t heap_index;
-#else
-#include <stdlib.h>
-#endif
-
-typedef struct GuardBytes
-{
-    size_t size;
-    size_t guard_space;
-} Guard;
-
-
-static const char end[] = "END";
-
-void* unity_malloc(size_t size)
-{
-    char* mem;
-    Guard* guard;
-    size_t total_size = size + sizeof(Guard) + sizeof(end);
-
-    if (malloc_fail_countdown != MALLOC_DONT_FAIL)
-    {
-        if (malloc_fail_countdown == 0)
-            return NULL;
-        malloc_fail_countdown--;
-    }
-
-    if (size == 0) return NULL;
-#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
-    if (heap_index + total_size > UNITY_INTERNAL_HEAP_SIZE_BYTES)
-    {
-        guard = NULL;
-    }
-    else
-    {
-        guard = (Guard*)&unity_heap[heap_index];
-        heap_index += total_size;
-    }
-#else
-    guard = (Guard*)UNITY_FIXTURE_MALLOC(total_size);
-#endif
-    if (guard == NULL) return NULL;
-    malloc_count++;
-    guard->size = size;
-    guard->guard_space = 0;
-    mem = (char*)&(guard[1]);
-    memcpy(&mem[size], end, sizeof(end));
-
-    return (void*)mem;
-}
-
-static int isOverrun(void* mem)
-{
-    Guard* guard = (Guard*)mem;
-    char* memAsChar = (char*)mem;
-    guard--;
-
-    return guard->guard_space != 0 || strcmp(&memAsChar[guard->size], end) != 0;
-}
-
-static void release_memory(void* mem)
-{
-    Guard* guard = (Guard*)mem;
-    guard--;
-
-    malloc_count--;
-#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
-    if (mem == unity_heap + heap_index - guard->size - sizeof(end))
-    {
-        heap_index -= (guard->size + sizeof(Guard) + sizeof(end));
-    }
-#else
-    UNITY_FIXTURE_FREE(guard);
-#endif
-}
-
-void unity_free(void* mem)
-{
-    int overrun;
-
-    if (mem == NULL)
-    {
-        return;
-    }
-
-    overrun = isOverrun(mem);
-    release_memory(mem);
-    if (overrun)
-    {
-        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during free()");
-    }
-}
-
-void* unity_calloc(size_t num, size_t size)
-{
-    void* mem = unity_malloc(num * size);
-    if (mem == NULL) return NULL;
-    memset(mem, 0, num * size);
-    return mem;
-}
-
-void* unity_realloc(void* oldMem, size_t size)
-{
-    Guard* guard = (Guard*)oldMem;
-    void* newMem;
-
-    if (oldMem == NULL) return unity_malloc(size);
-
-    guard--;
-    if (isOverrun(oldMem))
-    {
-        release_memory(oldMem);
-        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during realloc()");
-    }
-
-    if (size == 0)
-    {
-        release_memory(oldMem);
-        return NULL;
-    }
-
-    if (guard->size >= size) return oldMem;
-
-#ifdef UNITY_EXCLUDE_STDLIB_MALLOC /* Optimization if memory is expandable */
-    if (oldMem == unity_heap + heap_index - guard->size - sizeof(end) &&
-        heap_index + size - guard->size <= UNITY_INTERNAL_HEAP_SIZE_BYTES)
-    {
-        release_memory(oldMem);    /* Not thread-safe, like unity_heap generally */
-        return unity_malloc(size); /* No memcpy since data is in place */
-    }
-#endif
-    newMem = unity_malloc(size);
-    if (newMem == NULL) return NULL; /* Do not release old memory */
-    memcpy(newMem, oldMem, guard->size);
-    release_memory(oldMem);
-    return newMem;
-}
-
-
 /*-------------------------------------------------------- */
 /*Automatic pointer restoration functions */
 struct PointerPair
@@ -348,6 +182,7 @@ int UnityGetCommandLineOptions(int argc, const char* argv[])
 {
     int i;
     UnityFixture.Verbose = 0;
+    UnityFixture.Silent = 0;
     UnityFixture.GroupFilter = 0;
     UnityFixture.NameFilter = 0;
     UnityFixture.RepeatCount = 1;
@@ -357,11 +192,51 @@ int UnityGetCommandLineOptions(int argc, const char* argv[])
 
     for (i = 1; i < argc; )
     {
-        if (strcmp(argv[i], "-v") == 0)
+        if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0)
+        {
+            /* Usage */
+            UnityPrint("Runs a series of unit tests.");
+            UNITY_PRINT_EOL();
+            UNITY_PRINT_EOL();
+            UnityPrint("When no flag is specified, all tests are run.");
+            UNITY_PRINT_EOL();
+            UNITY_PRINT_EOL();
+            UnityPrint("Optional flags:");
+            UNITY_PRINT_EOL();
+            UnityPrint("  -v          Verbose output: show all tests executed even if they pass");
+            UNITY_PRINT_EOL();
+            UnityPrint("  -s          Silent mode: minimal output showing only test failures");
+            UNITY_PRINT_EOL();
+            UnityPrint("  -g NAME     Only run tests in groups that contain the string NAME");
+            UNITY_PRINT_EOL();
+            UnityPrint("  -n NAME     Only run tests whose name contains the string NAME");
+            UNITY_PRINT_EOL();
+            UnityPrint("  -r NUMBER   Repeatedly run all tests NUMBER times");
+            UNITY_PRINT_EOL();
+            UnityPrint("  -h, --help  Display this help message");
+            UNITY_PRINT_EOL();
+            UNITY_PRINT_EOL();
+#ifdef UNITY_CUSTOM_HELP_MSG
+            /* User-defined help message, e.g. to point to project-specific documentation */
+            UnityPrint(UNITY_CUSTOM_HELP_MSG);
+            UNITY_PRINT_EOL();
+#else
+            /* Default help suffix if a custom one is not defined */
+            UnityPrint("More information about Unity: https://www.throwtheswitch.org/unity");
+            UNITY_PRINT_EOL();
+#endif
+            return 1;  /* Exit without running the tests */
+        }
+        else if (strcmp(argv[i], "-v") == 0)
         {
             UnityFixture.Verbose = 1;
             i++;
         }
+        else if (strcmp(argv[i], "-s") == 0)
+        {
+            UnityFixture.Silent = 1;
+            i++;
+        }
         else if (strcmp(argv[i], "-g") == 0)
         {
             i++;
@@ -417,7 +292,10 @@ void UnityConcludeFixtureTest(void)
     {
         if (UnityFixture.Verbose)
         {
-            UnityPrint(" PASS");
+            UnityPrint(" ");
+            UnityPrint(UnityStrPass);
+            UNITY_EXEC_TIME_STOP();
+            UNITY_PRINT_EXEC_TIME();
             UNITY_PRINT_EOL();
         }
     }

extras/fixture/src/unity_fixture.h

@@ -9,10 +9,20 @@
 #define UNITY_FIXTURE_H_
 
 #include "unity.h"
-#include "unity_internals.h"
-#include "unity_fixture_malloc_overrides.h"
 #include "unity_fixture_internals.h"
 
+#ifndef UNITY_FIXTURE_NO_EXTRAS
+#include "unity_memory.h"
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "unity_internals.h"
+
+
 int UnityMain(int argc, const char* argv[], void (*runAllTests)(void));
 
 
@@ -77,7 +87,8 @@ int UnityMain(int argc, const char* argv[], void (*runAllTests)(void));
 #define DOUBLES_EQUAL(expected, actual, delta)         TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual))
 #endif
 
-/* You must compile with malloc replacement, as defined in unity_fixture_malloc_overrides.h */
+#ifdef __cplusplus
-void UnityMalloc_MakeMallocFailAfterCount(int count);
+}
+#endif
 
 #endif /* UNITY_FIXTURE_H_ */

extras/fixture/src/unity_fixture_internals.h

@@ -16,6 +16,7 @@ extern "C"
 struct UNITY_FIXTURE_T
 {
     int Verbose;
+    int Silent;
     unsigned int RepeatCount;
     const char* NameFilter;
     const char* GroupFilter;
@@ -24,7 +25,7 @@ extern struct UNITY_FIXTURE_T UnityFixture;
 
 typedef void unityfunction(void);
 void UnityTestRunner(unityfunction* setup,
-                     unityfunction* body,
+                     unityfunction* testBody,
                      unityfunction* teardown,
                      const char* printableName,
                      const char* group,
@@ -32,12 +33,10 @@ void UnityTestRunner(unityfunction* setup,
                      const char* file, unsigned int line);
 
 void UnityIgnoreTest(const char* printableName, const char* group, const char* name);
-void UnityMalloc_StartTest(void);
-void UnityMalloc_EndTest(void);
 int UnityGetCommandLineOptions(int argc, const char* argv[]);
 void UnityConcludeFixtureTest(void);
 
-void UnityPointer_Set(void** ptr, void* newValue, UNITY_LINE_TYPE line);
+void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line);
 void UnityPointer_UndoAllSets(void);
 void UnityPointer_Init(void);
 #ifndef UNITY_MAX_POINTERS

extras/fixture/test/Makefile

@@ -3,15 +3,12 @@ ifeq ($(shell uname -s), Darwin)
 CC = clang
 endif
 #DEBUG = -O0 -g
-CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror
+CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror -DUNITY_FIXTURE_NO_EXTRAS
 CFLAGS += $(DEBUG)
-DEFINES = -D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar
-DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\)
 SRC = ../src/unity_fixture.c \
       ../../../src/unity.c   \
       unity_fixture_Test.c   \
       unity_fixture_TestRunner.c \
-      unity_output_Spy.c     \
       main/AllTests.c
 
 INC_DIR = -I../src -I../../../src/

extras/fixture/test/main/AllTests.c

@@ -11,8 +11,6 @@ static void runAllTests(void)
 {
     RUN_TEST_GROUP(UnityFixture);
     RUN_TEST_GROUP(UnityCommandOptions);
-    RUN_TEST_GROUP(LeakDetection);
-    RUN_TEST_GROUP(InternalMalloc);
 }
 
 int main(int argc, const char* argv[])

extras/fixture/test/unity_fixture_Test.c

@@ -6,7 +6,6 @@
  * ========================================== */
 
 #include "unity_fixture.h"
-#include "unity_output_Spy.h"
 #include <stdlib.h>
 #include <string.h>
 
@@ -44,71 +43,6 @@ TEST(UnityFixture, PointerSetting)
     TEST_ASSERT_POINTERS_EQUAL(pointer3, (int*)3);
 }
 
-TEST(UnityFixture, ForceMallocFail)
-{
-    void* m;
-    void* mfails;
-    UnityMalloc_MakeMallocFailAfterCount(1);
-    m = malloc(10);
-    CHECK(m);
-    mfails = malloc(10);
-    TEST_ASSERT_POINTERS_EQUAL(0, mfails);
-    free(m);
-}
-
-TEST(UnityFixture, ReallocSmallerIsUnchanged)
-{
-    void* m1 = malloc(10);
-    void* m2 = realloc(m1, 5);
-    TEST_ASSERT_POINTERS_EQUAL(m1, m2);
-    free(m2);
-}
-
-TEST(UnityFixture, ReallocSameIsUnchanged)
-{
-    void* m1 = malloc(10);
-    void* m2 = realloc(m1, 10);
-    TEST_ASSERT_POINTERS_EQUAL(m1, m2);
-    free(m2);
-}
-
-TEST(UnityFixture, ReallocLargerNeeded)
-{
-    void* m1 = malloc(10);
-    void* m2;
-    CHECK(m1);
-    strcpy((char*)m1, "123456789");
-    m2 = realloc(m1, 15);
-    /* CHECK(m1 != m2); //Depends on implementation */
-    STRCMP_EQUAL("123456789", m2);
-    free(m2);
-}
-
-TEST(UnityFixture, ReallocNullPointerIsLikeMalloc)
-{
-    void* m = realloc(0, 15);
-    CHECK(m != 0);
-    free(m);
-}
-
-TEST(UnityFixture, ReallocSizeZeroFreesMemAndReturnsNullPointer)
-{
-    void* m1 = malloc(10);
-    void* m2 = realloc(m1, 0);
-    TEST_ASSERT_POINTERS_EQUAL(0, m2);
-}
-
-TEST(UnityFixture, CallocFillsWithZero)
-{
-    void* m = calloc(3, sizeof(char));
-    char* s = (char*)m;
-    CHECK(m);
-    TEST_ASSERT_BYTES_EQUAL(0, s[0]);
-    TEST_ASSERT_BYTES_EQUAL(0, s[1]);
-    TEST_ASSERT_BYTES_EQUAL(0, s[2]);
-    free(m);
-}
-
 static char *p1;
 static char *p2;
 
@@ -140,12 +74,10 @@ TEST(UnityFixture, ConcludeTestIncrementsFailCount)
 {
     UNITY_UINT savedFails = Unity.TestFailures;
     UNITY_UINT savedIgnores = Unity.TestIgnores;
-    UnityOutputCharSpy_Enable(1);
     Unity.CurrentTestFailed = 1;
     UnityConcludeFixtureTest(); /* Resets TestFailed for this test to pass */
     Unity.CurrentTestIgnored = 1;
     UnityConcludeFixtureTest(); /* Resets TestIgnored */
-    UnityOutputCharSpy_Enable(0);
     TEST_ASSERT_EQUAL(savedFails + 1, Unity.TestFailures);
     TEST_ASSERT_EQUAL(savedIgnores + 1, Unity.TestIgnores);
     Unity.TestFailures = savedFails;
@@ -311,233 +243,3 @@ IGNORE_TEST(UnityCommandOptions, TestShouldBeIgnored)
 {
     TEST_FAIL_MESSAGE("This test should not run!");
 }
-
-/*------------------------------------------------------------ */
-
-TEST_GROUP(LeakDetection);
-
-TEST_SETUP(LeakDetection)
-{
-#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
-    UnityOutputCharSpy_Create(200);
-#else
-    UnityOutputCharSpy_Create(1000);
-#endif
-}
-
-TEST_TEAR_DOWN(LeakDetection)
-{
-    UnityOutputCharSpy_Destroy();
-}
-
-#define EXPECT_ABORT_BEGIN \
-  { \
-    jmp_buf TestAbortFrame;   \
-    memcpy(TestAbortFrame, Unity.AbortFrame, sizeof(jmp_buf)); \
-    if (TEST_PROTECT()) \
-    {
-
-#define EXPECT_ABORT_END \
-    } \
-    memcpy(Unity.AbortFrame, TestAbortFrame, sizeof(jmp_buf)); \
-  }
-
-/* This tricky set of defines lets us see if we are using the Spy, returns 1 if true */
-#ifdef __STDC_VERSION__
-
-#if __STDC_VERSION__ >= 199901L
-#define USING_SPY_AS(a)                    EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0)
-#define ASSIGN_VALUE(a)                    VAL_##a
-#define VAL_UnityOutputCharSpy_OutputChar  0, 1
-#define EXPAND_AND_USE_2ND(a, b)           SECOND_PARAM(a, b, throwaway)
-#define SECOND_PARAM(a, b, ...)            b
-#if USING_SPY_AS(UNITY_OUTPUT_CHAR)
-  #define USING_OUTPUT_SPY /* UNITY_OUTPUT_CHAR = UnityOutputCharSpy_OutputChar */
-#endif
-#endif /* >= 199901 */
-
-#else  /* __STDC_VERSION__ else */
-#define UnityOutputCharSpy_OutputChar 42
-#if UNITY_OUTPUT_CHAR == UnityOutputCharSpy_OutputChar /* Works if no -Wundef -Werror */
-  #define USING_OUTPUT_SPY
-#endif
-#undef UnityOutputCharSpy_OutputChar
-#endif /* __STDC_VERSION__ */
-
-TEST(LeakDetection, DetectsLeak)
-{
-#ifndef USING_OUTPUT_SPY
-    TEST_IGNORE_MESSAGE("Build with '-D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar' to enable tests");
-#else
-    void* m = malloc(10);
-    TEST_ASSERT_NOT_NULL(m);
-    UnityOutputCharSpy_Enable(1);
-    EXPECT_ABORT_BEGIN
-    UnityMalloc_EndTest();
-    EXPECT_ABORT_END
-    UnityOutputCharSpy_Enable(0);
-    Unity.CurrentTestFailed = 0;
-    CHECK(strstr(UnityOutputCharSpy_Get(), "This test leaks!"));
-    free(m);
-#endif
-}
-
-TEST(LeakDetection, BufferOverrunFoundDuringFree)
-{
-#ifndef USING_OUTPUT_SPY
-    TEST_IGNORE();
-#else
-    void* m = malloc(10);
-    char* s = (char*)m;
-    TEST_ASSERT_NOT_NULL(m);
-    s[10] = (char)0xFF;
-    UnityOutputCharSpy_Enable(1);
-    EXPECT_ABORT_BEGIN
-    free(m);
-    EXPECT_ABORT_END
-    UnityOutputCharSpy_Enable(0);
-    Unity.CurrentTestFailed = 0;
-    CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()"));
-#endif
-}
-
-TEST(LeakDetection, BufferOverrunFoundDuringRealloc)
-{
-#ifndef USING_OUTPUT_SPY
-    TEST_IGNORE();
-#else
-    void* m = malloc(10);
-    char* s = (char*)m;
-    TEST_ASSERT_NOT_NULL(m);
-    s[10] = (char)0xFF;
-    UnityOutputCharSpy_Enable(1);
-    EXPECT_ABORT_BEGIN
-    m = realloc(m, 100);
-    EXPECT_ABORT_END
-    UnityOutputCharSpy_Enable(0);
-    Unity.CurrentTestFailed = 0;
-    CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()"));
-#endif
-}
-
-TEST(LeakDetection, BufferGuardWriteFoundDuringFree)
-{
-#ifndef USING_OUTPUT_SPY
-    TEST_IGNORE();
-#else
-    void* m = malloc(10);
-    char* s = (char*)m;
-    TEST_ASSERT_NOT_NULL(m);
-    s[-1] = (char)0x00; /* Will not detect 0 */
-    s[-2] = (char)0x01;
-    UnityOutputCharSpy_Enable(1);
-    EXPECT_ABORT_BEGIN
-    free(m);
-    EXPECT_ABORT_END
-    UnityOutputCharSpy_Enable(0);
-    Unity.CurrentTestFailed = 0;
-    CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()"));
-#endif
-}
-
-TEST(LeakDetection, BufferGuardWriteFoundDuringRealloc)
-{
-#ifndef USING_OUTPUT_SPY
-    TEST_IGNORE();
-#else
-    void* m = malloc(10);
-    char* s = (char*)m;
-    TEST_ASSERT_NOT_NULL(m);
-    s[-1] = (char)0x0A;
-    UnityOutputCharSpy_Enable(1);
-    EXPECT_ABORT_BEGIN
-    m = realloc(m, 100);
-    EXPECT_ABORT_END
-    UnityOutputCharSpy_Enable(0);
-    Unity.CurrentTestFailed = 0;
-    CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()"));
-#endif
-}
-
-TEST(LeakDetection, PointerSettingMax)
-{
-#ifndef USING_OUTPUT_SPY
-    TEST_IGNORE();
-#else
-    int i;
-    for (i = 0; i < UNITY_MAX_POINTERS; i++) UT_PTR_SET(pointer1, &int1);
-    UnityOutputCharSpy_Enable(1);
-    EXPECT_ABORT_BEGIN
-    UT_PTR_SET(pointer1, &int1);
-    EXPECT_ABORT_END
-    UnityOutputCharSpy_Enable(0);
-    Unity.CurrentTestFailed = 0;
-    CHECK(strstr(UnityOutputCharSpy_Get(), "Too many pointers set"));
-#endif
-}
-
-/*------------------------------------------------------------ */
-
-TEST_GROUP(InternalMalloc);
-#define TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(first_mem_ptr, ptr) \
-    ptr = malloc(10); free(ptr);                                   \
-    TEST_ASSERT_EQUAL_PTR_MESSAGE(first_mem_ptr, ptr, "Memory was stranded, free in LIFO order");
-
-
-TEST_SETUP(InternalMalloc) { }
-TEST_TEAR_DOWN(InternalMalloc) { }
-
-TEST(InternalMalloc, MallocPastBufferFails)
-{
-#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
-    void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
-    void* n = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
-    free(m);
-    TEST_ASSERT_NOT_NULL(m);
-    TEST_ASSERT_NULL(n);
-    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n);
-#endif
-}
-
-TEST(InternalMalloc, CallocPastBufferFails)
-{
-#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
-    void* m = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
-    void* n = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
-    free(m);
-    TEST_ASSERT_NOT_NULL(m);
-    TEST_ASSERT_NULL(n);
-    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n);
-#endif
-}
-
-TEST(InternalMalloc, MallocThenReallocGrowsMemoryInPlace)
-{
-#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
-    void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
-    void* n = realloc(m, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 9);
-    free(n);
-    TEST_ASSERT_NOT_NULL(m);
-    TEST_ASSERT_EQUAL(m, n);
-    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n);
-#endif
-}
-
-TEST(InternalMalloc, ReallocFailDoesNotFreeMem)
-{
-#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
-    void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
-    void* n1 = malloc(10);
-    void* out_of_mem = realloc(n1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
-    void* n2 = malloc(10);
-
-    free(n2);
-    if (out_of_mem == NULL) free(n1);
-    free(m);
-
-    TEST_ASSERT_NOT_NULL(m);       /* Got a real memory location */
-    TEST_ASSERT_NULL(out_of_mem);  /* The realloc should have failed */
-    TEST_ASSERT_NOT_EQUAL(n2, n1); /* If n1 != n2 then realloc did not free n1 */
-    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n2);
-#endif
-}

extras/fixture/test/unity_fixture_TestRunner.c

@@ -10,13 +10,6 @@
 TEST_GROUP_RUNNER(UnityFixture)
 {
     RUN_TEST_CASE(UnityFixture, PointerSetting);
-    RUN_TEST_CASE(UnityFixture, ForceMallocFail);
-    RUN_TEST_CASE(UnityFixture, ReallocSmallerIsUnchanged);
-    RUN_TEST_CASE(UnityFixture, ReallocSameIsUnchanged);
-    RUN_TEST_CASE(UnityFixture, ReallocLargerNeeded);
-    RUN_TEST_CASE(UnityFixture, ReallocNullPointerIsLikeMalloc);
-    RUN_TEST_CASE(UnityFixture, ReallocSizeZeroFreesMemAndReturnsNullPointer);
-    RUN_TEST_CASE(UnityFixture, CallocFillsWithZero);
     RUN_TEST_CASE(UnityFixture, PointerSet);
     RUN_TEST_CASE(UnityFixture, FreeNULLSafety);
     RUN_TEST_CASE(UnityFixture, ConcludeTestIncrementsFailCount);
@@ -37,21 +30,3 @@ TEST_GROUP_RUNNER(UnityCommandOptions)
     RUN_TEST_CASE(UnityCommandOptions, GroupFilterReallyFilters);
     RUN_TEST_CASE(UnityCommandOptions, TestShouldBeIgnored);
 }
-
-TEST_GROUP_RUNNER(LeakDetection)
-{
-    RUN_TEST_CASE(LeakDetection, DetectsLeak);
-    RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringFree);
-    RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringRealloc);
-    RUN_TEST_CASE(LeakDetection, BufferGuardWriteFoundDuringFree);
-    RUN_TEST_CASE(LeakDetection, BufferGuardWriteFoundDuringRealloc);
-    RUN_TEST_CASE(LeakDetection, PointerSettingMax);
-}
-
-TEST_GROUP_RUNNER(InternalMalloc)
-{
-    RUN_TEST_CASE(InternalMalloc, MallocPastBufferFails);
-    RUN_TEST_CASE(InternalMalloc, CallocPastBufferFails);
-    RUN_TEST_CASE(InternalMalloc, MallocThenReallocGrowsMemoryInPlace);
-    RUN_TEST_CASE(InternalMalloc, ReallocFailDoesNotFreeMem);
-}

extras/memory/readme.md

@@ -0,0 +1,42 @@
+# Unity Memory
+
+This Framework is an optional add-on to Unity.
+By including unity.h and then unity_memory.h, you have the added ability to track malloc and free calls.
+This addon requires that the stdlib functions be overridden by its own defines.
+These defines will still malloc / realloc / free etc, but will also track the calls in order to ensure that you don't have any memory leaks in your programs.
+
+Note that this is only useful in situations where a unit is in charge of both the allocation and deallocation of memory.
+When it is not symmetric, unit testing can report a number of false failures.
+A more advanced runtime tool is required to track complete system memory handling.
+
+## Module API
+
+### `UnityMalloc_StartTest` and `UnityMalloc_EndTest`
+
+These must be called at the beginning and end of each test.
+For simplicity, they can be added to `setUp` and `tearDown` in order to do their job.
+When using the test runner generator scripts, these will be automatically added to the runner whenever unity_memory.h is included.
+
+### `UnityMalloc_MakeMallocFailAfterCount`
+
+This can be called from the tests themselves.
+Passing this function a number will force the reference counter to start keeping track of malloc calls.
+During that test, if the number of malloc calls exceeds the number given, malloc will immediately start returning `NULL`.
+This allows you to test error conditions.
+Think of it as a simplified mock.
+
+## Configuration
+
+### `UNITY_MALLOC` and `UNITY_FREE`
+
+By default, this module tries to use the real stdlib `malloc` and `free` internally.
+If you would prefer it to use something else, like FreeRTOS's `pvPortMalloc` and `pvPortFree`, then you can use these defines to make it so.
+
+### `UNITY_EXCLUDE_STDLIB_MALLOC`
+
+If you would like this library to ignore stdlib or other heap engines completely, and manage the memory on its own, then define this. All memory will be handled internally (and at likely lower overhead).
+Note that this is not a very featureful memory manager, but is sufficient for most testing purposes.
+
+### `UNITY_INTERNAL_HEAP_SIZE_BYTES`
+
+When using the built-in memory manager (see `UNITY_EXCLUDE_STDLIB_MALLOC`) this define allows you to set the heap size this library will use to manage the memory.

extras/memory/src/meson.build

@@ -0,0 +1,9 @@
+unity_inc += include_directories('.')
+unity_src += files('unity_memory.c')
+
+if not meson.is_subproject()
+  install_headers(
+    'unity_memory.h',
+    subdir: meson.project_name()
+  )
+endif

extras/memory/src/unity_memory.c

@@ -0,0 +1,202 @@
+/* ==========================================
+ *  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 "unity_memory.h"
+#include <string.h>
+
+#define MALLOC_DONT_FAIL -1
+static int malloc_count;
+static int malloc_fail_countdown = MALLOC_DONT_FAIL;
+
+void UnityMalloc_StartTest(void)
+{
+    malloc_count = 0;
+    malloc_fail_countdown = MALLOC_DONT_FAIL;
+}
+
+void UnityMalloc_EndTest(void)
+{
+    malloc_fail_countdown = MALLOC_DONT_FAIL;
+    if (malloc_count != 0)
+    {
+        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "This test leaks!");
+    }
+}
+
+void UnityMalloc_MakeMallocFailAfterCount(int countdown)
+{
+    malloc_fail_countdown = countdown;
+}
+
+/* These definitions are always included from unity_fixture_malloc_overrides.h */
+/* We undef to use them or avoid conflict with <stdlib.h> per the C standard */
+#undef malloc
+#undef free
+#undef calloc
+#undef realloc
+
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+static unsigned char unity_heap[UNITY_INTERNAL_HEAP_SIZE_BYTES];
+static size_t heap_index;
+#else
+#include <stdlib.h>
+#endif
+
+typedef struct GuardBytes
+{
+    size_t size;
+    size_t guard_space;
+} Guard;
+
+#define UNITY_MALLOC_ALIGNMENT (UNITY_POINTER_WIDTH / 8)
+static const char end[] = "END";
+
+static size_t unity_size_round_up(size_t size)
+{
+    size_t rounded_size;
+
+    rounded_size = ((size + UNITY_MALLOC_ALIGNMENT - 1) / UNITY_MALLOC_ALIGNMENT) * UNITY_MALLOC_ALIGNMENT;
+
+    return rounded_size;
+}
+
+void* unity_malloc(size_t size)
+{
+    char* mem;
+    Guard* guard;
+    size_t total_size;
+
+    total_size = sizeof(Guard) + unity_size_round_up(size + sizeof(end));
+
+    if (malloc_fail_countdown != MALLOC_DONT_FAIL)
+    {
+        if (malloc_fail_countdown == 0)
+            return NULL;
+        malloc_fail_countdown--;
+    }
+
+    if (size == 0) return NULL;
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    if (heap_index + total_size > UNITY_INTERNAL_HEAP_SIZE_BYTES)
+    {
+        guard = NULL;
+    }
+    else
+    {
+        /* We know we can get away with this cast because we aligned memory already */
+        guard = (Guard*)(void*)(&unity_heap[heap_index]);
+        heap_index += total_size;
+    }
+#else
+    guard = (Guard*)UNITY_MALLOC(total_size);
+#endif
+    if (guard == NULL) return NULL;
+    malloc_count++;
+    guard->size = size;
+    guard->guard_space = 0;
+    mem = (char*)&(guard[1]);
+    memcpy(&mem[size], end, sizeof(end));
+
+    return (void*)mem;
+}
+
+static int isOverrun(void* mem)
+{
+    Guard* guard = (Guard*)mem;
+    char* memAsChar = (char*)mem;
+    guard--;
+
+    return guard->guard_space != 0 || strcmp(&memAsChar[guard->size], end) != 0;
+}
+
+static void release_memory(void* mem)
+{
+    Guard* guard = (Guard*)mem;
+    guard--;
+
+    malloc_count--;
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    {
+        size_t block_size;
+
+        block_size = unity_size_round_up(guard->size + sizeof(end));
+
+        if (mem == unity_heap + heap_index - block_size)
+        {
+            heap_index -= (sizeof(Guard) + block_size);
+        }
+    }
+#else
+    UNITY_FREE(guard);
+#endif
+}
+
+void unity_free(void* mem)
+{
+    int overrun;
+
+    if (mem == NULL)
+    {
+        return;
+    }
+
+    overrun = isOverrun(mem);
+    release_memory(mem);
+    if (overrun)
+    {
+        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during free()");
+    }
+}
+
+void* unity_calloc(size_t num, size_t size)
+{
+    void* mem = unity_malloc(num * size);
+    if (mem == NULL) return NULL;
+    memset(mem, 0, num * size);
+    return mem;
+}
+
+void* unity_realloc(void* oldMem, size_t size)
+{
+    Guard* guard = (Guard*)oldMem;
+    void* newMem;
+
+    if (oldMem == NULL) return unity_malloc(size);
+
+    guard--;
+    if (isOverrun(oldMem))
+    {
+        release_memory(oldMem);
+        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during realloc()");
+    }
+
+    if (size == 0)
+    {
+        release_memory(oldMem);
+        return NULL;
+    }
+
+    if (guard->size >= size) return oldMem;
+
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC /* Optimization if memory is expandable */
+    {
+        size_t old_total_size = unity_size_round_up(guard->size + sizeof(end));
+
+        if ((oldMem == unity_heap + heap_index - old_total_size) &&
+            ((heap_index - old_total_size + unity_size_round_up(size + sizeof(end))) <= UNITY_INTERNAL_HEAP_SIZE_BYTES))
+        {
+            release_memory(oldMem);    /* Not thread-safe, like unity_heap generally */
+            return unity_malloc(size); /* No memcpy since data is in place */
+        }
+    }
+#endif
+    newMem = unity_malloc(size);
+    if (newMem == NULL) return NULL; /* Do not release old memory */
+    memcpy(newMem, oldMem, guard->size);
+    release_memory(oldMem);
+    return newMem;
+}

extras/memory/src/unity_memory.h

@@ -1,12 +1,16 @@
-/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* ==========================================
- * ==========================================
  *  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]
  * ========================================== */
 
-#ifndef UNITY_FIXTURE_MALLOC_OVERRIDES_H_
+#ifndef UNITY_MEMORY_OVERRIDES_H_
-#define UNITY_FIXTURE_MALLOC_OVERRIDES_H_
+#define UNITY_MEMORY_OVERRIDES_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 #include <stddef.h>
 
@@ -21,17 +25,17 @@
     #endif
 #endif
 
-/* These functions are used by the Unity Fixture to allocate and release memory
+/* These functions are used by Unity to allocate and release memory
  * on the heap and can be overridden with platform-specific implementations.
- * For example, when using FreeRTOS UNITY_FIXTURE_MALLOC becomes pvPortMalloc()
+ * For example, when using FreeRTOS UNITY_MALLOC becomes pvPortMalloc()
- * and UNITY_FIXTURE_FREE becomes vPortFree(). */
+ * and UNITY_FREE becomes vPortFree(). */
-#if !defined(UNITY_FIXTURE_MALLOC) || !defined(UNITY_FIXTURE_FREE)
+#if !defined(UNITY_MALLOC) || !defined(UNITY_FREE)
     #include <stdlib.h>
-    #define UNITY_FIXTURE_MALLOC(size) malloc(size)
+    #define UNITY_MALLOC(size) malloc(size)
-    #define UNITY_FIXTURE_FREE(ptr)    free(ptr)
+    #define UNITY_FREE(ptr)    free(ptr)
 #else
-    extern void* UNITY_FIXTURE_MALLOC(size_t size);
+    extern void* UNITY_MALLOC(size_t size);
-    extern void UNITY_FIXTURE_FREE(void* ptr);
+    extern void UNITY_FREE(void* ptr);
 #endif
 
 #define malloc  unity_malloc
@@ -44,4 +48,13 @@ void* unity_calloc(size_t num, size_t size);
 void* unity_realloc(void * oldMem, size_t size);
 void unity_free(void * mem);
 
-#endif /* UNITY_FIXTURE_MALLOC_OVERRIDES_H_ */
+/* You must compile with malloc replacement, as defined in unity_fixture_malloc_overrides.h */
+void UnityMalloc_StartTest(void);
+void UnityMalloc_EndTest(void);
+void UnityMalloc_MakeMallocFailAfterCount(int countdown);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif 

extras/memory/test/Makefile

@@ -0,0 +1,78 @@
+CC = gcc
+ifeq ($(shell uname -s), Darwin)
+CC = clang
+endif
+#DEBUG = -O0 -g
+CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror
+CFLAGS += $(DEBUG)
+DEFINES = -D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar
+ifeq ($(OS),Windows_NT)
+  DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar(int)
+else
+  DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\)
+endif
+SRC = ../src/unity_memory.c \
+      ../../../src/unity.c   \
+      unity_memory_Test.c   \
+      unity_memory_TestRunner.c \
+      unity_output_Spy.c     \
+
+INC_DIR = -I../src -I../../../src/
+BUILD_DIR = ../build
+TARGET = ../build/memory_tests.exe
+
+all: default noStdlibMalloc 32bits
+
+default: $(BUILD_DIR)
+	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_SUPPORT_64
+	@ echo "default build"
+	./$(TARGET)
+
+32bits: $(BUILD_DIR)
+	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m32
+	@ echo "32bits build"
+	./$(TARGET)
+
+noStdlibMalloc: $(BUILD_DIR)
+	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC
+	@ echo "build with noStdlibMalloc"
+	./$(TARGET)
+
+C89: CFLAGS += -D UNITY_EXCLUDE_STDINT_H # C89 did not have type 'long long', <stdint.h>
+C89: $(BUILD_DIR)
+	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -std=c89 && ./$(TARGET)
+	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC -std=c89
+	./$(TARGET)
+
+$(BUILD_DIR):
+	mkdir -p $(BUILD_DIR)
+
+clean:
+	rm -f $(TARGET) $(BUILD_DIR)/*.gc*
+
+cov: $(BUILD_DIR)
+	cd $(BUILD_DIR) && \
+	$(CC) $(DEFINES) $(foreach i, $(SRC), ../test/$(i)) $(INC_DIR) -o $(TARGET) -fprofile-arcs -ftest-coverage
+	rm -f $(BUILD_DIR)/*.gcda
+	./$(TARGET) > /dev/null ; ./$(TARGET) -v > /dev/null
+	cd $(BUILD_DIR) && \
+	gcov unity_memory.c | head -3
+	grep '###' $(BUILD_DIR)/unity_memory.c.gcov -C2 || true # Show uncovered lines
+
+# These extended flags DO get included before any target build runs
+CFLAGS += -Wbad-function-cast
+CFLAGS += -Wcast-qual
+CFLAGS += -Wconversion
+CFLAGS += -Wformat=2
+CFLAGS += -Wmissing-prototypes
+CFLAGS += -Wold-style-definition
+CFLAGS += -Wpointer-arith
+CFLAGS += -Wshadow
+CFLAGS += -Wstrict-overflow=5
+CFLAGS += -Wstrict-prototypes
+CFLAGS += -Wswitch-default
+CFLAGS += -Wundef
+CFLAGS += -Wno-error=undef  # Warning only, this should not stop the build
+CFLAGS += -Wunreachable-code
+CFLAGS += -Wunused
+CFLAGS += -fstrict-aliasing

extras/memory/test/unity_memory_Test.c

@@ -0,0 +1,325 @@
+/* ==========================================
+ *  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 "unity_memory.h"
+#include "unity_output_Spy.h"
+#include <stdlib.h>
+#include <string.h>
+
+/* This test module includes the following tests: */
+
+void test_ForceMallocFail(void);
+void test_ReallocSmallerIsUnchanged(void);
+void test_ReallocSameIsUnchanged(void);
+void test_ReallocLargerNeeded(void);
+void test_ReallocNullPointerIsLikeMalloc(void);
+void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void);
+void test_CallocFillsWithZero(void);
+void test_FreeNULLSafety(void);
+void test_DetectsLeak(void);
+void test_BufferOverrunFoundDuringFree(void);
+void test_BufferOverrunFoundDuringRealloc(void);
+void test_BufferGuardWriteFoundDuringFree(void);
+void test_BufferGuardWriteFoundDuringRealloc(void);
+void test_MallocPastBufferFails(void);
+void test_CallocPastBufferFails(void);
+void test_MallocThenReallocGrowsMemoryInPlace(void);
+void test_ReallocFailDoesNotFreeMem(void);
+
+/* It makes use of the following features */
+void setUp(void);
+void tearDown(void);
+
+/* Let's Go! */
+void setUp(void) 
+{ 
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    UnityOutputCharSpy_Create(200);
+#else
+    UnityOutputCharSpy_Create(1000);
+#endif
+    UnityMalloc_StartTest();
+}
+
+void tearDown(void) 
+{ 
+    UnityMalloc_EndTest();
+    UnityOutputCharSpy_Destroy();
+}
+
+void test_ForceMallocFail(void)
+{
+    void* m;
+    void* mfails;
+    UnityMalloc_MakeMallocFailAfterCount(1);
+    m = malloc(10);
+    TEST_ASSERT_NOT_NULL(m);
+    mfails = malloc(10);
+    TEST_ASSERT_EQUAL_PTR(0, mfails);
+    free(m);
+}
+
+void test_ReallocSmallerIsUnchanged(void)
+{
+    void* m1 = malloc(10);
+    void* m2 = realloc(m1, 5);
+    TEST_ASSERT_NOT_NULL(m1);
+    TEST_ASSERT_EQUAL_PTR(m1, m2);
+    free(m2);
+}
+
+void test_ReallocSameIsUnchanged(void)
+{
+    void* m1 = malloc(10);
+    void* m2 = realloc(m1, 10);
+    TEST_ASSERT_NOT_NULL(m1);
+    TEST_ASSERT_EQUAL_PTR(m1, m2);
+    free(m2);
+}
+
+void test_ReallocLargerNeeded(void)
+{
+    void* m2;
+    void* m1 = malloc(10);
+    TEST_ASSERT_NOT_NULL(m1);
+    strcpy((char*)m1, "123456789");
+    m2 = realloc(m1, 15);
+    TEST_ASSERT_EQUAL_STRING("123456789", m2);
+    free(m2);
+}
+
+void test_ReallocNullPointerIsLikeMalloc(void)
+{
+    void* m = realloc(0, 15);
+    TEST_ASSERT_NOT_NULL(m);
+    free(m);
+}
+
+void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void)
+{
+    void* m1 = malloc(10);
+    void* m2 = realloc(m1, 0);
+    TEST_ASSERT_EQUAL_PTR(0, m2);
+}
+
+void test_CallocFillsWithZero(void)
+{
+    void* m = calloc(3, sizeof(char));
+    char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
+    TEST_ASSERT_EQUAL_HEX8(0, s[0]);
+    TEST_ASSERT_EQUAL_HEX8(0, s[1]);
+    TEST_ASSERT_EQUAL_HEX8(0, s[2]);
+    free(m);
+}
+
+void test_FreeNULLSafety(void)
+{
+    free(NULL);
+}
+
+/*------------------------------------------------------------ */
+
+#define EXPECT_ABORT_BEGIN \
+  { \
+    jmp_buf TestAbortFrame;   \
+    memcpy(TestAbortFrame, Unity.AbortFrame, sizeof(jmp_buf)); \
+    if (TEST_PROTECT()) \
+    {
+
+#define EXPECT_ABORT_END \
+    } \
+    memcpy(Unity.AbortFrame, TestAbortFrame, sizeof(jmp_buf)); \
+  }
+
+/* This tricky set of defines lets us see if we are using the Spy, returns 1 if true */
+#ifdef __STDC_VERSION__
+
+#ifdef UNITY_SUPPORT_VARIADIC_MACROS
+#define USING_SPY_AS(a)                    EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0)
+#define ASSIGN_VALUE(a)                    VAL_##a
+#define VAL_UnityOutputCharSpy_OutputChar  0, 1
+#define EXPAND_AND_USE_2ND(a, b)           SECOND_PARAM(a, b, throwaway)
+#define SECOND_PARAM(a, b, ...)            b
+#if USING_SPY_AS(UNITY_OUTPUT_CHAR)
+  #define USING_OUTPUT_SPY /* UNITY_OUTPUT_CHAR = UnityOutputCharSpy_OutputChar */
+#endif
+#endif /* UNITY_SUPPORT_VARIADIC_MACROS */
+
+#else  /* __STDC_VERSION__ else */
+
+#define UnityOutputCharSpy_OutputChar 42
+#if UNITY_OUTPUT_CHAR == UnityOutputCharSpy_OutputChar /* Works if no -Wundef -Werror */
+  #define USING_OUTPUT_SPY
+#endif
+#undef UnityOutputCharSpy_OutputChar
+  
+#endif /* __STDC_VERSION__ */
+
+void test_DetectsLeak(void)
+{
+#ifdef USING_OUTPUT_SPY
+    void* m = malloc(10);
+    TEST_ASSERT_NOT_NULL(m);
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    UnityMalloc_EndTest();
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    Unity.CurrentTestFailed = 0;
+    TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "This test leaks!"));
+    free(m);
+#else
+    TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test");
+#endif
+}
+
+void test_BufferOverrunFoundDuringFree(void)
+{
+#ifdef USING_OUTPUT_SPY
+    void* m = malloc(10);
+    char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
+    s[10] = (char)0xFF;
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    free(m);
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    Unity.CurrentTestFailed = 0;
+    TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()"));
+#else
+    TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test");
+#endif
+}
+
+void test_BufferOverrunFoundDuringRealloc(void)
+{
+#ifdef USING_OUTPUT_SPY
+    void* m = malloc(10);
+    char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
+    s[10] = (char)0xFF;
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    m = realloc(m, 100);
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    Unity.CurrentTestFailed = 0;
+    TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()"));
+#else
+    TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test");
+#endif
+}
+
+void test_BufferGuardWriteFoundDuringFree(void)
+{
+#ifdef USING_OUTPUT_SPY
+    void* m = malloc(10);
+    char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
+    s[-1] = (char)0x00; /* Will not detect 0 */
+    s[-2] = (char)0x01;
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    free(m);
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    Unity.CurrentTestFailed = 0;
+    TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()"));
+#else
+    TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test");
+#endif
+}
+
+void test_BufferGuardWriteFoundDuringRealloc(void)
+{
+#ifdef USING_OUTPUT_SPY
+    void* m = malloc(10);
+    char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
+    s[-1] = (char)0x0A;
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    m = realloc(m, 100);
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    Unity.CurrentTestFailed = 0;
+    TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()"));
+#else
+    TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test");
+#endif
+}
+
+/*------------------------------------------------------------ */
+
+#define TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(first_mem_ptr, ptr) \
+    ptr = malloc(10); free(ptr);                                   \
+    TEST_ASSERT_EQUAL_PTR_MESSAGE(first_mem_ptr, ptr, "Memory was stranded, free in LIFO order");
+
+void test_MallocPastBufferFails(void)
+{
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
+    void* n = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
+    free(m);
+    TEST_ASSERT_NOT_NULL(m);
+    TEST_ASSERT_NULL(n);
+    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n);
+#else
+    TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test");
+#endif
+}
+
+void test_CallocPastBufferFails(void)
+{
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    void* m = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
+    void* n = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
+    free(m);
+    TEST_ASSERT_NOT_NULL(m);
+    TEST_ASSERT_NULL(n);
+    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n);
+#else
+    TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test");
+#endif
+}
+
+void test_MallocThenReallocGrowsMemoryInPlace(void)
+{
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
+    void* n = realloc(m, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 9);
+    free(n);
+    TEST_ASSERT_NOT_NULL(m);
+    TEST_ASSERT_EQUAL(m, n);
+    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n);
+#else
+    TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test");
+#endif
+}
+
+void test_ReallocFailDoesNotFreeMem(void)
+{
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
+    void* n1 = malloc(10);
+    void* out_of_mem = realloc(n1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
+    void* n2 = malloc(10);
+
+    free(n2);
+    if (out_of_mem == NULL) free(n1);
+    free(m);
+
+    TEST_ASSERT_NOT_NULL(m);       /* Got a real memory location */
+    TEST_ASSERT_NULL(out_of_mem);  /* The realloc should have failed */
+    TEST_ASSERT_NOT_EQUAL(n2, n1); /* If n1 != n2 then realloc did not free n1 */
+    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n2);
+#else
+    TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test");
+#endif
+}

extras/memory/test/unity_memory_TestRunner.c

@@ -0,0 +1,49 @@
+/* ==========================================
+ *  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 "unity_memory.h"
+
+extern void test_ForceMallocFail(void);
+extern void test_ReallocSmallerIsUnchanged(void);
+extern void test_ReallocSameIsUnchanged(void);
+extern void test_ReallocLargerNeeded(void);
+extern void test_ReallocNullPointerIsLikeMalloc(void);
+extern void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void);
+extern void test_CallocFillsWithZero(void);
+extern void test_FreeNULLSafety(void);
+extern void test_DetectsLeak(void);
+extern void test_BufferOverrunFoundDuringFree(void);
+extern void test_BufferOverrunFoundDuringRealloc(void);
+extern void test_BufferGuardWriteFoundDuringFree(void);
+extern void test_BufferGuardWriteFoundDuringRealloc(void);
+extern void test_MallocPastBufferFails(void);
+extern void test_CallocPastBufferFails(void);
+extern void test_MallocThenReallocGrowsMemoryInPlace(void);
+extern void test_ReallocFailDoesNotFreeMem(void);
+
+int main(void)
+{
+    UnityBegin("unity_memory_Test.c");
+    RUN_TEST(test_ForceMallocFail);
+    RUN_TEST(test_ReallocSmallerIsUnchanged);
+    RUN_TEST(test_ReallocSameIsUnchanged);
+    RUN_TEST(test_ReallocLargerNeeded);
+    RUN_TEST(test_ReallocNullPointerIsLikeMalloc);
+    RUN_TEST(test_ReallocSizeZeroFreesMemAndReturnsNullPointer);
+    RUN_TEST(test_CallocFillsWithZero);
+    RUN_TEST(test_FreeNULLSafety);
+    RUN_TEST(test_DetectsLeak);
+    RUN_TEST(test_BufferOverrunFoundDuringFree);
+    RUN_TEST(test_BufferOverrunFoundDuringRealloc);
+    RUN_TEST(test_BufferGuardWriteFoundDuringFree);
+    RUN_TEST(test_BufferGuardWriteFoundDuringRealloc);
+    RUN_TEST(test_MallocPastBufferFails);
+    RUN_TEST(test_CallocPastBufferFails);
+    RUN_TEST(test_MallocThenReallocGrowsMemoryInPlace);
+    RUN_TEST(test_ReallocFailDoesNotFreeMem);
+    return UnityEnd();
+}

extras/memory/test/unity_output_Spy.c

@@ -1,16 +1,15 @@
-/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* ==========================================
- * ==========================================
  *  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 "unity_output_Spy.h"
-#include "unity_fixture.h"
 
 #include <stdio.h>
 #include <string.h>
+#include <stdlib.h>
 
 static int size;
 static int count;

extras/memory/test/unity_output_Spy.h

@@ -1,12 +1,11 @@
-/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* ==========================================
- * ==========================================
  *  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]
  * ========================================== */
 
-#ifndef D_unity_output_Spy_H
+#ifndef UNITY_OUTPUT_SPY_H
-#define D_unity_output_Spy_H
+#define UNITY_OUTPUT_SPY_H
 
 void UnityOutputCharSpy_Create(int s);
 void UnityOutputCharSpy_Destroy(void);

library.json

@@ -0,0 +1,18 @@
+{
+  "name": "Unity",
+  "version": "2.5.2",
+  "keywords": "unit-testing, testing, tdd, testing-framework",
+  "description": "Simple Unit Testing for C",
+  "homepage": "http://www.throwtheswitch.org/unity",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ThrowTheSwitch/Unity.git"
+  },
+  "frameworks": "*",
+  "platforms": "*",
+  "headers": "unity.h",
+  "build": {
+    "extraScript": "platformio-build.py"
+  }
+}

meson.build

@@ -0,0 +1,73 @@
+#
+# build script written by : Michael Gene Brockus.
+# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
+#
+# license: MIT
+#
+project('unity', 'c',
+  license: 'MIT',
+
+  # Set project version to value extracted from unity.h header
+  version: run_command(
+    [
+      'auto/extract_version.py',
+      'src/unity.h'
+    ],
+    check: true
+  ).stdout().strip(),
+
+  meson_version: '>=0.47.0',
+  default_options: [
+    'werror=true',
+    'c_std=c11'
+  ]
+)
+
+build_fixture = get_option('extension_fixture')
+build_memory = get_option('extension_memory')
+
+unity_src = []
+unity_inc = []
+
+subdir('src')
+
+if build_fixture
+  # Building the fixture extension implies building the memory
+  # extension.
+  build_memory = true
+  subdir('extras/fixture/src')
+endif
+
+if build_memory
+  subdir('extras/memory/src')
+endif
+
+unity_lib = static_library(meson.project_name(),
+  sources: unity_src,
+  include_directories: unity_inc,
+  install: not meson.is_subproject(),
+)
+
+unity_dep = declare_dependency(
+  link_with: unity_lib,
+  include_directories: unity_inc
+)
+
+# Generate pkg-config file.
+if not meson.is_subproject()
+  pkg = import('pkgconfig')
+  pkg.generate(
+    name: meson.project_name(),
+    version: meson.project_version(),
+    libraries: [ unity_lib ],
+    description: 'C Unit testing framework.'
+  )
+endif
+
+# Create a generator that can be used by consumers of our build system to generate
+# test runners.
+gen_test_runner = generator(
+  find_program('auto/generate_test_runner.rb'),
+  output: '@BASENAME@_Runner.c',
+  arguments: ['@INPUT@', '@OUTPUT@']
+)

meson_options.txt

@@ -0,0 +1,2 @@
+option('extension_fixture', type: 'boolean', value: 'false', description: 'Whether to enable the fixture extension.')
+option('extension_memory', type: 'boolean', value: 'false', description: 'Whether to enable the memory extension.')

platformio-build.py

@@ -0,0 +1,17 @@
+import os
+
+Import("env")
+
+env.Append(CPPDEFINES=["UNITY_INCLUDE_CONFIG_H"])
+
+# import "unity_config.h" folder to the library builder
+try:
+    Import("projenv")
+
+    projenv.Append(CPPDEFINES=["UNITY_INCLUDE_CONFIG_H"])
+    for p in projenv["CPPPATH"]:
+        p = projenv.subst(p)
+        if os.path.isfile(os.path.join(p, "unity_config.h")):
+            env.Prepend(CPPPATH=[p])
+except:
+    pass

release/build.info

@@ -1,2 +0,0 @@
-121
-

release/version.info

@@ -1,2 +0,0 @@
-2.4.2
-

src/meson.build

@@ -0,0 +1,17 @@
+#
+# build script written by : Michael Gene Brockus.
+# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
+#
+# license: MIT
+#
+
+unity_inc += include_directories('.')
+unity_src += files('unity.c')
+
+if not meson.is_subproject()
+  install_headers(
+    'unity.h',
+    'unity_internals.h',
+    subdir: meson.project_name()
+  )
+endif

src/unity.h

@@ -1,6 +1,6 @@
 /* ==========================================
     Unity Project - A Test Framework for C
-    Copyright (c) 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams
+    Copyright (c) 2007-21 Mike Karlesky, Mark VanderVoord, Greg Williams
     [Released under MIT License. Please refer to license.txt for details]
 ========================================== */
 
@@ -8,6 +8,11 @@
 #define UNITY_FRAMEWORK_H
 #define UNITY
 
+#define UNITY_VERSION_MAJOR    2
+#define UNITY_VERSION_MINOR    5
+#define UNITY_VERSION_BUILD    4
+#define UNITY_VERSION          ((UNITY_VERSION_MAJOR << 16) | (UNITY_VERSION_MINOR << 8) | UNITY_VERSION_BUILD)
+
 #ifdef __cplusplus
 extern "C"
 {
@@ -15,9 +20,38 @@ extern "C"
 
 #include "unity_internals.h"
 
+/*-------------------------------------------------------
+ * Test Setup / Teardown
+ *-------------------------------------------------------*/
+
+/* These functions are intended to be called before and after each test.
+ * If using unity directly, these will need to be provided for each test
+ * executable built. If you are using the test runner generator and/or
+ * Ceedling, these are optional. */
 void setUp(void);
 void tearDown(void);
 
+/* These functions are intended to be called at the beginning and end of an
+ * entire test suite.  suiteTearDown() is passed the number of tests that
+ * failed, and its return value becomes the exit code of main(). If using
+ * Unity directly, you're in charge of calling these if they are desired.
+ * If using Ceedling or the test runner generator, these will be called
+ * automatically if they exist. */
+void suiteSetUp(void);
+int suiteTearDown(int num_failures);
+
+/*-------------------------------------------------------
+ * Test Reset and Verify
+ *-------------------------------------------------------*/
+
+/* These functions are intended to be called before during tests in order
+ * to support complex test loops, etc. Both are NOT built into Unity. Instead
+ * the test runner generator will create them. resetTest will run teardown and
+ * setup again, verifying any end-of-test needs between. verifyTest will only
+ * run the verification. */
+void resetTest(void);
+void verifyTest(void);
+
 /*-------------------------------------------------------
  * Configuration Options
  *-------------------------------------------------------
@@ -55,7 +89,7 @@ void tearDown(void);
  *     - define UNITY_SUPPORT_TEST_CASES to include the TEST_CASE macro, though really it's mostly about the runner generator script
 
  * Parameterized Tests
- *     - you'll want to create a define of TEST_CASE(...) which basically evaluates to nothing
+ *     - you'll want to create a define of TEST_CASE(...) and/or TEST_RANGE(...) which basically evaluates to nothing
 
  * Tests with Arguments
  *     - you'll want to define UNITY_USE_COMMAND_LINE_ARGS if you have the test runner passing arguments to Unity
@@ -68,11 +102,16 @@ void tearDown(void);
 #define TEST_FAIL()                                                                                UNITY_TEST_FAIL(__LINE__, NULL)
 #define TEST_IGNORE_MESSAGE(message)                                                               UNITY_TEST_IGNORE(__LINE__, (message))
 #define TEST_IGNORE()                                                                              UNITY_TEST_IGNORE(__LINE__, NULL)
+#define TEST_MESSAGE(message)                                                                      UnityMessage((message), __LINE__)
 #define TEST_ONLY()
+#ifdef UNITY_INCLUDE_PRINT_FORMATTED
+#define TEST_PRINTF(message, ...)                                                                  UnityPrintF(__LINE__, (message), __VA_ARGS__)
+#endif
 
 /* It is not necessary for you to call PASS. A PASS condition is assumed if nothing fails.
  * This method allows you to abort a test immediately with a PASS state, ignoring the remainder of the test. */
 #define TEST_PASS()                                                                                TEST_ABORT()
+#define TEST_PASS_MESSAGE(message)                                                                 do { UnityMessage((message), __LINE__); TEST_ABORT(); } while (0)
 
 /* This macro does nothing, but it is useful for build tools (like Ceedling) to make use of this to figure out
  * which files should be linked to in order to perform a test. Use it like TEST_FILE("sandwiches.c") */
@@ -89,6 +128,8 @@ void tearDown(void);
 #define TEST_ASSERT_FALSE(condition)                                                               UNITY_TEST_ASSERT(      !(condition), __LINE__, " Expected FALSE Was TRUE")
 #define TEST_ASSERT_NULL(pointer)                                                                  UNITY_TEST_ASSERT_NULL(    (pointer), __LINE__, " Expected NULL")
 #define TEST_ASSERT_NOT_NULL(pointer)                                                              UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, " Expected Non-NULL")
+#define TEST_ASSERT_EMPTY(pointer)                                                                 UNITY_TEST_ASSERT_EMPTY(    (pointer), __LINE__, " Expected Empty")
+#define TEST_ASSERT_NOT_EMPTY(pointer)                                                             UNITY_TEST_ASSERT_NOT_EMPTY((pointer), __LINE__, " Expected Non-Empty")
 
 /* Integers (of all sizes) */
 #define TEST_ASSERT_EQUAL_INT(expected, actual)                                                    UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
@@ -96,23 +137,41 @@ void tearDown(void);
 #define TEST_ASSERT_EQUAL_INT16(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_INT32(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_INT64(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL(expected, actual)                                                        UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_NOT_EQUAL(expected, actual)                                                    UNITY_TEST_ASSERT(((expected) !=  (actual)), __LINE__, " Expected Not-Equal")
 #define TEST_ASSERT_EQUAL_UINT(expected, actual)                                                   UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_UINT8(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_UINT16(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_UINT32(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_UINT64(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_EQUAL_size_t(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_UINT((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_HEX(expected, actual)                                                    UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_HEX8(expected, actual)                                                   UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_HEX16(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_HEX32(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_HEX64(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_EQUAL_CHAR(expected, actual)                                                   UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_BITS(mask, expected, actual)                                                   UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BITS_HIGH(mask, actual)                                                        UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(-1), (actual), __LINE__, NULL)
+#define TEST_ASSERT_BITS_HIGH(mask, actual)                                                        UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT)(-1), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BITS_LOW(mask, actual)                                                         UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (actual), __LINE__, NULL)
+#define TEST_ASSERT_BITS_LOW(mask, actual)                                                         UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT)(0), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BIT_HIGH(bit, actual)                                                          UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, NULL)
+#define TEST_ASSERT_BIT_HIGH(bit, actual)                                                          UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(-1), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BIT_LOW(bit, actual)                                                           UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, NULL)
+#define TEST_ASSERT_BIT_LOW(bit, actual)                                                           UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(0), (actual), __LINE__, NULL)
+
+/* Integer Not Equal To (of all sizes) */
+#define TEST_ASSERT_NOT_EQUAL_INT(threshold, actual)                                               UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual)                                              UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual)                                             UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual)                                             UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual)                                             UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual)                                              UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual)                                             UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual)                                            UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual)                                            UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual)                                            UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_size_t(threshold, actual)                                            UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual)                                              UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual)                                             UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual)                                             UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual)                                             UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual)                                              UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (actual), __LINE__, NULL)
 
 /* Integer Greater Than/ Less Than (of all sizes) */
 #define TEST_ASSERT_GREATER_THAN(threshold, actual)                                                UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL)
@@ -120,28 +179,72 @@ void tearDown(void);
 #define TEST_ASSERT_GREATER_THAN_INT8(threshold, actual)                                           UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_GREATER_THAN_INT16(threshold, actual)                                          UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_GREATER_THAN_INT32(threshold, actual)                                          UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_THAN_INT64(threshold, actual)                                          UNITY_TEST_ASSERT_GREATER_THAN_INT64((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_GREATER_THAN_UINT(threshold, actual)                                           UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual)                                          UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual)                                         UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual)                                         UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual)                                         UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_THAN_size_t(threshold, actual)                                         UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual)                                           UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual)                                          UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual)                                          UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, NULL)
-
+#define TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual)                                          UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_THAN_CHAR(threshold, actual)                                           UNITY_TEST_ASSERT_GREATER_THAN_CHAR((threshold), (actual), __LINE__, NULL)
 
 #define TEST_ASSERT_LESS_THAN(threshold, actual)                                                   UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_LESS_THAN_INT(threshold, actual)                                               UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_LESS_THAN_INT8(threshold, actual)                                              UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_LESS_THAN_INT16(threshold, actual)                                             UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_LESS_THAN_INT32(threshold, actual)                                             UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_THAN_INT64(threshold, actual)                                             UNITY_TEST_ASSERT_SMALLER_THAN_INT64((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_LESS_THAN_UINT(threshold, actual)                                              UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_LESS_THAN_UINT8(threshold, actual)                                             UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_LESS_THAN_UINT16(threshold, actual)                                            UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_LESS_THAN_UINT32(threshold, actual)                                            UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_THAN_UINT64(threshold, actual)                                            UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_THAN_size_t(threshold, actual)                                            UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_LESS_THAN_HEX8(threshold, actual)                                              UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_LESS_THAN_HEX16(threshold, actual)                                             UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_LESS_THAN_HEX32(threshold, actual)                                             UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_THAN_HEX64(threshold, actual)                                             UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_THAN_CHAR(threshold, actual)                                              UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, NULL)
 
+#define TEST_ASSERT_GREATER_OR_EQUAL(threshold, actual)                                            UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual)                                        UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual)                                       UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual)                                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual)                                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual)                                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual)                                       UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual)                                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual)                                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual)                                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual)                                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_size_t(threshold, actual)                                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual)                                       UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual)                                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual)                                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual)                                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR(threshold, actual)                                       UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL)
+
+#define TEST_ASSERT_LESS_OR_EQUAL(threshold, actual)                                               UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_INT(threshold, actual)                                           UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_INT8(threshold, actual)                                          UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_INT16(threshold, actual)                                         UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_INT32(threshold, actual)                                         UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_INT64(threshold, actual)                                         UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_UINT(threshold, actual)                                          UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_UINT8(threshold, actual)                                         UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_UINT16(threshold, actual)                                        UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_UINT32(threshold, actual)                                        UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_UINT64(threshold, actual)                                        UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_size_t(threshold, actual)                                        UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_HEX8(threshold, actual)                                          UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_HEX16(threshold, actual)                                         UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_HEX32(threshold, actual)                                         UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_HEX64(threshold, actual)                                         UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_CHAR(threshold, actual)                                          UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL)
 
 /* Integer Ranges (of all sizes) */
 #define TEST_ASSERT_INT_WITHIN(delta, expected, actual)                                            UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
@@ -154,11 +257,33 @@ void tearDown(void);
 #define TEST_ASSERT_UINT16_WITHIN(delta, expected, actual)                                         UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_UINT32_WITHIN(delta, expected, actual)                                         UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_UINT64_WITHIN(delta, expected, actual)                                         UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_size_t_WITHIN(delta, expected, actual)                                         UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_HEX_WITHIN(delta, expected, actual)                                            UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_HEX8_WITHIN(delta, expected, actual)                                           UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_HEX16_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_HEX32_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_HEX64_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_CHAR_WITHIN(delta, expected, actual)                                           UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, NULL)
+
+/* Integer Array Ranges (of all sizes) */
+#define TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements)                        UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements)                       UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements)                      UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements)                      UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements)                      UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements)                       UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements)                      UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements)                     UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements)                     UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements)                     UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_size_t_ARRAY_WITHIN(delta, expected, actual, num_elements)                     UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_HEX_ARRAY_WITHIN(delta, expected, actual, num_elements)                        UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements)                       UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements)                      UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements)                      UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements)                      UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+#define TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements)                       UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL)
+
 
 /* Structs and Strings */
 #define TEST_ASSERT_EQUAL_PTR(expected, actual)                                                    UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, NULL)
@@ -177,6 +302,7 @@ void tearDown(void);
 #define TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
+#define TEST_ASSERT_EQUAL_size_t_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_HEX_ARRAY(expected, actual, num_elements)                                UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements)                               UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
@@ -185,8 +311,7 @@ void tearDown(void);
 #define TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements)                                UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements)                        UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, NULL)
-
+#define TEST_ASSERT_EQUAL_CHAR_ARRAY(expected, actual, num_elements)                               UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-
 
 /* Arrays Compared To Single Value */
 #define TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements)                                 UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, NULL)
@@ -199,6 +324,7 @@ void tearDown(void);
 #define TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, NULL)
+#define TEST_ASSERT_EACH_EQUAL_size_t(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EACH_EQUAL_HEX(expected, actual, num_elements)                                 UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements)                                UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements)                               UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, NULL)
@@ -207,12 +333,20 @@ void tearDown(void);
 #define TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements)                                 UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements)                         UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, NULL)
+#define TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements)                                UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, NULL)
 
 /* Floating Point (If Enabled) */
 #define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual)                                      UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_FLOAT(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual)                                              UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements)                      UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements)                               UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual)                                          UNITY_TEST_ASSERT_GREATER_THAN_FLOAT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual)                                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual)                                             UNITY_TEST_ASSERT_LESS_THAN_FLOAT((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual)                                         UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_FLOAT_IS_INF(actual)                                                           UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, NULL)
 #define TEST_ASSERT_FLOAT_IS_NEG_INF(actual)                                                       UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, NULL)
 #define TEST_ASSERT_FLOAT_IS_NAN(actual)                                                           UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, NULL)
@@ -224,9 +358,16 @@ void tearDown(void);
 
 /* Double (If Enabled) */
 #define TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual)                                         UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual)                                     UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_DOUBLE(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual)                                             UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements)                     UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
 #define TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual)                                         UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual)                                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual)                                            UNITY_TEST_ASSERT_LESS_THAN_DOUBLE((threshold), (actual), __LINE__, NULL)
+#define TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual)                                        UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, NULL)
 #define TEST_ASSERT_DOUBLE_IS_INF(actual)                                                          UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, NULL)
 #define TEST_ASSERT_DOUBLE_IS_NEG_INF(actual)                                                      UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, NULL)
 #define TEST_ASSERT_DOUBLE_IS_NAN(actual)                                                          UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, NULL)
@@ -236,6 +377,28 @@ void tearDown(void);
 #define TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual)                                                      UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, NULL)
 #define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual)                                              UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, NULL)
 
+/* Shorthand */
+#ifdef UNITY_SHORTHAND_AS_OLD
+#define TEST_ASSERT_EQUAL(expected, actual)                                                        UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL(expected, actual)                                                    UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal")
+#endif
+#ifdef UNITY_SHORTHAND_AS_INT
+#define TEST_ASSERT_EQUAL(expected, actual)                                                        UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL(expected, actual)                                                    UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
+#endif
+#ifdef UNITY_SHORTHAND_AS_MEM
+#define TEST_ASSERT_EQUAL(expected, actual)                                                        UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, NULL)
+#define TEST_ASSERT_NOT_EQUAL(expected, actual)                                                    UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
+#endif
+#ifdef UNITY_SHORTHAND_AS_RAW
+#define TEST_ASSERT_EQUAL(expected, actual)                                                        UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, " Expected Equal")
+#define TEST_ASSERT_NOT_EQUAL(expected, actual)                                                    UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal")
+#endif
+#ifdef UNITY_SHORTHAND_AS_NONE
+#define TEST_ASSERT_EQUAL(expected, actual)                                                        UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
+#define TEST_ASSERT_NOT_EQUAL(expected, actual)                                                    UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
+#endif
+
 /*-------------------------------------------------------
  * Test Asserts (with additional messages)
  *-------------------------------------------------------*/
@@ -247,6 +410,8 @@ void tearDown(void);
 #define TEST_ASSERT_FALSE_MESSAGE(condition, message)                                              UNITY_TEST_ASSERT(      !(condition), __LINE__, (message))
 #define TEST_ASSERT_NULL_MESSAGE(pointer, message)                                                 UNITY_TEST_ASSERT_NULL(    (pointer), __LINE__, (message))
 #define TEST_ASSERT_NOT_NULL_MESSAGE(pointer, message)                                             UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, (message))
+#define TEST_ASSERT_EMPTY_MESSAGE(pointer, message)                                                UNITY_TEST_ASSERT_EMPTY(    (pointer), __LINE__, (message))
+#define TEST_ASSERT_NOT_EMPTY_MESSAGE(pointer, message)                                            UNITY_TEST_ASSERT_NOT_EMPTY((pointer), __LINE__, (message))
 
 /* Integers (of all sizes) */
 #define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message))
@@ -254,13 +419,12 @@ void tearDown(void);
 #define TEST_ASSERT_EQUAL_INT16_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_INT32_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_INT64_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message)                                       UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT(((expected) !=  (actual)), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, message)                                  UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_UINT16_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_UINT32_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_UINT64_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, (message))
+#define TEST_ASSERT_EQUAL_size_t_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message)                                  UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, (message))
@@ -271,6 +435,26 @@ void tearDown(void);
 #define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message)                                        UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (actual), __LINE__, (message))
 #define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message)                                         UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, (message))
 #define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message)                                          UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, (message))
+#define TEST_ASSERT_EQUAL_CHAR_MESSAGE(expected, actual, message)                                  UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, (message))
+
+/* Integer Not Equal To (of all sizes) */
+#define TEST_ASSERT_NOT_EQUAL_INT_MESSAGE(threshold, actual, message)                              UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_INT8_MESSAGE(threshold, actual, message)                             UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_INT16_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_INT32_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_INT64_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_UINT_MESSAGE(threshold, actual, message)                             UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_UINT8_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_UINT16_MESSAGE(threshold, actual, message)                           UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_UINT32_MESSAGE(threshold, actual, message)                           UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_UINT64_MESSAGE(threshold, actual, message)                           UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_size_t_MESSAGE(threshold, actual, message)                           UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_HEX8_MESSAGE(threshold, actual, message)                             UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_HEX16_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_HEX32_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_HEX64_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_CHAR_MESSAGE(threshold, actual, message)                             UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (actual), __LINE__, (message))
+
 
 /* Integer Greater Than/ Less Than (of all sizes) */
 #define TEST_ASSERT_GREATER_THAN_MESSAGE(threshold, actual, message)                               UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message))
@@ -278,28 +462,72 @@ void tearDown(void);
 #define TEST_ASSERT_GREATER_THAN_INT8_MESSAGE(threshold, actual, message)                          UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_GREATER_THAN_INT16_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_GREATER_THAN_INT32_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_THAN_INT64_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_GREATER_THAN_INT64((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_GREATER_THAN_UINT_MESSAGE(threshold, actual, message)                          UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_GREATER_THAN_UINT8_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_GREATER_THAN_UINT16_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_GREATER_THAN_UINT32_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_THAN_UINT64_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_THAN_size_t_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_GREATER_THAN_HEX8_MESSAGE(threshold, actual, message)                          UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_GREATER_THAN_HEX16_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_GREATER_THAN_HEX32_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, (message))
-
+#define TEST_ASSERT_GREATER_THAN_HEX64_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_THAN_CHAR_MESSAGE(threshold, actual, message)                          UNITY_TEST_ASSERT_GREATER_THAN_CHAR((threshold), (actual), __LINE__, (message))
 
 #define TEST_ASSERT_LESS_THAN_MESSAGE(threshold, actual, message)                                  UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_LESS_THAN_INT_MESSAGE(threshold, actual, message)                              UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_LESS_THAN_INT8_MESSAGE(threshold, actual, message)                             UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_LESS_THAN_INT16_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_LESS_THAN_INT32_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_THAN_INT64_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_SMALLER_THAN_INT64((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_LESS_THAN_UINT_MESSAGE(threshold, actual, message)                             UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_LESS_THAN_UINT8_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_LESS_THAN_UINT16_MESSAGE(threshold, actual, message)                           UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_LESS_THAN_UINT32_MESSAGE(threshold, actual, message)                           UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_THAN_UINT64_MESSAGE(threshold, actual, message)                           UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_THAN_size_t_MESSAGE(threshold, actual, message)                           UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_LESS_THAN_HEX8_MESSAGE(threshold, actual, message)                             UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_LESS_THAN_HEX16_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_LESS_THAN_HEX32_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_THAN_HEX64_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_THAN_CHAR_MESSAGE(threshold, actual, message)                             UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, (message))
 
+#define TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(threshold, actual, message)                           UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_INT_MESSAGE(threshold, actual, message)                       UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_INT8_MESSAGE(threshold, actual, message)                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_INT16_MESSAGE(threshold, actual, message)                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_INT32_MESSAGE(threshold, actual, message)                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_INT64_MESSAGE(threshold, actual, message)                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_UINT_MESSAGE(threshold, actual, message)                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message)                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message)                    UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message)                    UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message)                    UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_size_t_MESSAGE(threshold, actual, message)                    UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message)                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message)                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message)                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message)                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message)                      UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message))
+
+#define TEST_ASSERT_LESS_OR_EQUAL_MESSAGE(threshold, actual, message)                              UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_INT_MESSAGE(threshold, actual, message)                          UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_INT8_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_INT16_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_INT32_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_INT64_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_UINT_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message)                       UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message)                       UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message)                       UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_size_t_MESSAGE(threshold, actual, message)                       UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message))
 
 /* Integer Ranges (of all sizes) */
 #define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message)                           UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, (message))
@@ -312,11 +540,33 @@ void tearDown(void);
 #define TEST_ASSERT_UINT16_WITHIN_MESSAGE(delta, expected, actual, message)                        UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_UINT32_WITHIN_MESSAGE(delta, expected, actual, message)                        UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_UINT64_WITHIN_MESSAGE(delta, expected, actual, message)                        UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, (message))
+#define TEST_ASSERT_size_t_WITHIN_MESSAGE(delta, expected, actual, message)                        UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_HEX_WITHIN_MESSAGE(delta, expected, actual, message)                           UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_HEX8_WITHIN_MESSAGE(delta, expected, actual, message)                          UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_HEX16_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_HEX32_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_HEX64_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, (message))
+#define TEST_ASSERT_CHAR_WITHIN_MESSAGE(delta, expected, actual, message)                          UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, (message))
+
+/* Integer Array Ranges (of all sizes) */
+#define TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)       UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)      UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)     UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_INT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)     UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)     UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)      UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)     UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)    UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_UINT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)    UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)    UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_size_t_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)    UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_HEX_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)       UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)      UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)     UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)     UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)     UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+#define TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)      UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message))
+
 
 /* Structs and Strings */
 #define TEST_ASSERT_EQUAL_PTR_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, (message))
@@ -335,6 +585,7 @@ void tearDown(void);
 #define TEST_ASSERT_EQUAL_UINT16_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_UINT64_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
+#define TEST_ASSERT_EQUAL_size_t_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_HEX_ARRAY_MESSAGE(expected, actual, num_elements, message)               UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(expected, actual, num_elements, message)              UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_HEX16_ARRAY_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
@@ -343,6 +594,7 @@ void tearDown(void);
 #define TEST_ASSERT_EQUAL_PTR_ARRAY_MESSAGE(expected, actual, num_elements, message)               UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_STRING_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message)       UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, (message))
+#define TEST_ASSERT_EQUAL_CHAR_ARRAY_MESSAGE(expected, actual, num_elements, message)              UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
 
 /* Arrays Compared To Single Value*/
 #define TEST_ASSERT_EACH_EQUAL_INT_MESSAGE(expected, actual, num_elements, message)                UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, (message))
@@ -355,7 +607,8 @@ void tearDown(void);
 #define TEST_ASSERT_EACH_EQUAL_UINT16_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EACH_EQUAL_UINT32_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EACH_EQUAL_UINT64_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EACH_EQUAL_HEX32_MESSAGE(expected, actual, num_elements, message)              UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message))
+#define TEST_ASSERT_EACH_EQUAL_size_t_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message))
+#define TEST_ASSERT_EACH_EQUAL_HEX_MESSAGE(expected, actual, num_elements, message)                UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EACH_EQUAL_HEX8_MESSAGE(expected, actual, num_elements, message)               UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EACH_EQUAL_HEX16_MESSAGE(expected, actual, num_elements, message)              UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EACH_EQUAL_HEX32_MESSAGE(expected, actual, num_elements, message)              UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message))
@@ -363,12 +616,19 @@ void tearDown(void);
 #define TEST_ASSERT_EACH_EQUAL_PTR_MESSAGE(expected, actual, num_elements, message)                UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EACH_EQUAL_STRING_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EACH_EQUAL_MEMORY_MESSAGE(expected, actual, len, num_elements, message)        UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, (message))
+#define TEST_ASSERT_EACH_EQUAL_CHAR_MESSAGE(expected, actual, num_elements, message)               UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, (message))
 
 /* Floating Point (If Enabled) */
 #define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_FLOAT_MESSAGE(expected, actual, message)                             UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT((expected), (actual), __LINE__, (message))
+#define TEST_ASSERT_FLOAT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)     UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EACH_EQUAL_FLOAT_MESSAGE(expected, actual, num_elements, message)              UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, (message))
+#define TEST_ASSERT_GREATER_THAN_FLOAT_MESSAGE(threshold, actual, message)                         UNITY_TEST_ASSERT_GREATER_THAN_FLOAT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_FLOAT_MESSAGE(threshold, actual, message)                     UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_THAN_FLOAT_MESSAGE(threshold, actual, message)                            UNITY_TEST_ASSERT_LESS_THAN_FLOAT((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_FLOAT_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_FLOAT_IS_INF_MESSAGE(actual, message)                                          UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, (message))
 #define TEST_ASSERT_FLOAT_IS_NEG_INF_MESSAGE(actual, message)                                      UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, (message))
 #define TEST_ASSERT_FLOAT_IS_NAN_MESSAGE(actual, message)                                          UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, (message))
@@ -381,8 +641,14 @@ void tearDown(void);
 /* Double (If Enabled) */
 #define TEST_ASSERT_DOUBLE_WITHIN_MESSAGE(delta, expected, actual, message)                        UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_DOUBLE_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_DOUBLE_MESSAGE(expected, actual, message)                            UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message))
+#define TEST_ASSERT_DOUBLE_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message)    UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EQUAL_DOUBLE_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
 #define TEST_ASSERT_EACH_EQUAL_DOUBLE_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, (message))
+#define TEST_ASSERT_GREATER_THAN_DOUBLE_MESSAGE(threshold, actual, message)                        UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE_MESSAGE(threshold, actual, message)                    UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_THAN_DOUBLE_MESSAGE(threshold, actual, message)                           UNITY_TEST_ASSERT_LESS_THAN_DOUBLE((threshold), (actual), __LINE__, (message))
+#define TEST_ASSERT_LESS_OR_EQUAL_DOUBLE_MESSAGE(threshold, actual, message)                       UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE((threshold), (actual), __LINE__, (message))
 #define TEST_ASSERT_DOUBLE_IS_INF_MESSAGE(actual, message)                                         UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, (message))
 #define TEST_ASSERT_DOUBLE_IS_NEG_INF_MESSAGE(actual, message)                                     UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, (message))
 #define TEST_ASSERT_DOUBLE_IS_NAN_MESSAGE(actual, message)                                         UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, (message))
@@ -392,6 +658,28 @@ void tearDown(void);
 #define TEST_ASSERT_DOUBLE_IS_NOT_NAN_MESSAGE(actual, message)                                     UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, (message))
 #define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE_MESSAGE(actual, message)                             UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, (message))
 
+/* Shorthand */
+#ifdef UNITY_SHORTHAND_AS_OLD
+#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message)                                       UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message))
+#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, (message))
+#endif
+#ifdef UNITY_SHORTHAND_AS_INT
+#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message)                                       UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, message)
+#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message)                                   UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
+#endif
+#ifdef  UNITY_SHORTHAND_AS_MEM
+#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message)                                       UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, message)
+#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message)                                   UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
+#endif
+#ifdef  UNITY_SHORTHAND_AS_RAW
+#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message)                                       UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, message)
+#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, message)
+#endif
+#ifdef UNITY_SHORTHAND_AS_NONE
+#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message)                                       UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
+#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message)                                   UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
+#endif
+
 /* end of UNITY_FRAMEWORK_H */
 #ifdef __cplusplus
 }

src/unity_internals.h

@@ -1,6 +1,6 @@
 /* ==========================================
     Unity Project - A Test Framework for C
-    Copyright (c) 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams
+    Copyright (c) 2007-21 Mike Karlesky, Mark VanderVoord, Greg Williams
     [Released under MIT License. Please refer to license.txt for details]
 ========================================== */
 
@@ -19,6 +19,14 @@
 #include <math.h>
 #endif
 
+#ifndef UNITY_EXCLUDE_STDDEF_H
+#include <stddef.h>
+#endif
+
+#ifdef UNITY_INCLUDE_PRINT_FORMATTED
+#include <stdarg.h>
+#endif
+
 /* Unity Attempts to Auto-Detect Integer Types
  * Attempt 1: UINT_MAX, ULONG_MAX in <limits.h>, or default to 32 bits
  * Attempt 2: UINTPTR_MAX in <stdint.h>, or default to same size as long
@@ -32,6 +40,46 @@
 #include <limits.h>
 #endif
 
+#if defined(__GNUC__) || defined(__clang__)
+  #define UNITY_FUNCTION_ATTR(a)    __attribute__((a))
+#else
+  #define UNITY_FUNCTION_ATTR(a)    /* ignore */
+#endif
+
+#ifndef UNITY_NORETURN
+  #if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+      #define UNITY_NORETURN [[ noreturn ]]
+    #endif
+  #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+    #if defined(_WIN32) && defined(_MSC_VER)
+      /* We are using MSVC compiler on Windows platform. */
+      /* Not all Windows SDKs supports <stdnoreturn.h>, but compiler can support C11: */
+      /* https://devblogs.microsoft.com/cppblog/c11-and-c17-standard-support-arriving-in-msvc/ */
+      /* Not sure, that Mingw compilers has Windows SDK headers at all. */
+      #include <sdkddkver.h>
+    #endif
+
+    /* Using Windows SDK predefined macro for detecting supported SDK with MSVC compiler. */
+    /* Mingw GCC should work without that fixes. */
+    /* Based on: */
+    /* https://docs.microsoft.com/en-us/cpp/porting/modifying-winver-and-win32-winnt?view=msvc-170 */
+    /* NTDDI_WIN10_FE is equal to Windows 10 SDK 2104 */
+    #if defined(_MSC_VER) && ((!defined(NTDDI_WIN10_FE)) || WDK_NTDDI_VERSION < NTDDI_WIN10_FE)
+      /* Based on tests and: */
+      /* https://docs.microsoft.com/en-us/cpp/c-language/noreturn?view=msvc-170 */
+      /* https://en.cppreference.com/w/c/language/_Noreturn */
+      #define UNITY_NORETURN _Noreturn
+    #else /* Using newer Windows SDK or not MSVC compiler */
+      #include <stdnoreturn.h>
+      #define UNITY_NORETURN noreturn
+    #endif
+  #endif
+#endif
+#ifndef UNITY_NORETURN
+  #define UNITY_NORETURN UNITY_FUNCTION_ATTR(__noreturn__)
+#endif
+
 /*-------------------------------------------------------
  * Guess Widths If Not Specified
  *-------------------------------------------------------*/
@@ -39,6 +87,8 @@
 /* Determine the size of an int, if not already specified.
  * We cannot use sizeof(int), because it is not yet defined
  * at this stage in the translation of the C program.
+ * Also sizeof(int) does return the size in addressable units on all platforms,
+ * which may not necessarily be the size in bytes.
  * Therefore, infer it from UINT_MAX if possible. */
 #ifndef UNITY_INT_WIDTH
   #ifdef UINT_MAX
@@ -110,19 +160,21 @@
  * 64-bit Support
  *-------------------------------------------------------*/
 
+/* Auto-detect 64 Bit Support */
 #ifndef UNITY_SUPPORT_64
   #if UNITY_LONG_WIDTH == 64 || UNITY_POINTER_WIDTH == 64
     #define UNITY_SUPPORT_64
   #endif
 #endif
 
+/* 64-Bit Support Dependent Configuration */
 #ifndef UNITY_SUPPORT_64
     /* No 64-bit Support */
     typedef UNITY_UINT32 UNITY_UINT;
-    typedef UNITY_INT32 UNITY_INT;
+    typedef UNITY_INT32  UNITY_INT;
+    #define UNITY_MAX_NIBBLES (8)  /* Maximum number of nibbles in a UNITY_(U)INT */
 #else
-
+  /* 64-bit Support */
-    /* 64-bit Support */
   #if (UNITY_LONG_WIDTH == 32)
     typedef unsigned long long UNITY_UINT64;
     typedef signed long long   UNITY_INT64;
@@ -133,8 +185,8 @@
     #error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported)
   #endif
     typedef UNITY_UINT64 UNITY_UINT;
-    typedef UNITY_INT64 UNITY_INT;
+    typedef UNITY_INT64  UNITY_INT;
-
+    #define UNITY_MAX_NIBBLES (16) /* Maximum number of nibbles in a UNITY_(U)INT */
 #endif
 
 /*-------------------------------------------------------
@@ -142,26 +194,28 @@
  *-------------------------------------------------------*/
 
 #if (UNITY_POINTER_WIDTH == 32)
-#define UNITY_PTR_TO_INT UNITY_INT32
+  #define UNITY_PTR_TO_INT UNITY_INT32
-#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32
+  #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32
 #elif (UNITY_POINTER_WIDTH == 64)
-#define UNITY_PTR_TO_INT UNITY_INT64
+  #define UNITY_PTR_TO_INT UNITY_INT64
-#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX64
+  #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX64
 #elif (UNITY_POINTER_WIDTH == 16)
-#define UNITY_PTR_TO_INT UNITY_INT16
+  #define UNITY_PTR_TO_INT UNITY_INT16
-#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX16
+  #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX16
 #else
-    #error Invalid UNITY_POINTER_WIDTH specified! (16, 32 or 64 are supported)
+  #error Invalid UNITY_POINTER_WIDTH specified! (16, 32 or 64 are supported)
 #endif
 
 #ifndef UNITY_PTR_ATTRIBUTE
-#define UNITY_PTR_ATTRIBUTE
+  #define UNITY_PTR_ATTRIBUTE
 #endif
 
 #ifndef UNITY_INTERNAL_PTR
-#define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const void*
+  #define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const void*
 #endif
 
+/* optionally define UNITY_COMPARE_PTRS_ON_ZERO_ARRAY */
+
 /*-------------------------------------------------------
  * Float Support
  *-------------------------------------------------------*/
@@ -241,40 +295,40 @@ typedef UNITY_FLOAT_TYPE UNITY_FLOAT;
  * Output Method: stdout (DEFAULT)
  *-------------------------------------------------------*/
 #ifndef UNITY_OUTPUT_CHAR
-/* Default to using putchar, which is defined in stdio.h */
+  /* Default to using putchar, which is defined in stdio.h */
-#include <stdio.h>
+  #include <stdio.h>
-#define UNITY_OUTPUT_CHAR(a) (void)putchar(a)
+  #define UNITY_OUTPUT_CHAR(a) (void)putchar(a)
 #else
   /* If defined as something else, make sure we declare it here so it's ready for use */
   #ifdef UNITY_OUTPUT_CHAR_HEADER_DECLARATION
-extern void UNITY_OUTPUT_CHAR_HEADER_DECLARATION;
+    extern void UNITY_OUTPUT_CHAR_HEADER_DECLARATION;
   #endif
 #endif
 
 #ifndef UNITY_OUTPUT_FLUSH
-#ifdef UNITY_USE_FLUSH_STDOUT
+  #ifdef UNITY_USE_FLUSH_STDOUT
-/* We want to use the stdout flush utility */
+    /* We want to use the stdout flush utility */
-#include <stdio.h>
+    #include <stdio.h>
-#define UNITY_OUTPUT_FLUSH() (void)fflush(stdout)
+    #define UNITY_OUTPUT_FLUSH()    (void)fflush(stdout)
+  #else
+    /* We've specified nothing, therefore flush should just be ignored */
+    #define UNITY_OUTPUT_FLUSH()    (void)0
+  #endif
 #else
-/* We've specified nothing, therefore flush should just be ignored */
+  /* If defined as something else, make sure we declare it here so it's ready for use */
-#define UNITY_OUTPUT_FLUSH()
+  #ifdef UNITY_OUTPUT_FLUSH_HEADER_DECLARATION
-#endif
+    extern void UNITY_OUTPUT_FLUSH_HEADER_DECLARATION;
-#else
+  #endif
-/* We've defined flush as something else, so make sure we declare it here so it's ready for use */
-#ifdef UNITY_OUTPUT_FLUSH_HEADER_DECLARATION
-extern void UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION;
-#endif
 #endif
 
 #ifndef UNITY_OUTPUT_FLUSH
 #define UNITY_FLUSH_CALL()
 #else
-#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH()
+#define UNITY_FLUSH_CALL()  UNITY_OUTPUT_FLUSH()
 #endif
 
 #ifndef UNITY_PRINT_EOL
-#define UNITY_PRINT_EOL()    UNITY_OUTPUT_CHAR('\n')
+#define UNITY_PRINT_EOL()   UNITY_OUTPUT_CHAR('\n')
 #endif
 
 #ifndef UNITY_OUTPUT_START
@@ -285,6 +339,69 @@ extern void UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION;
 #define UNITY_OUTPUT_COMPLETE()
 #endif
 
+#ifdef UNITY_INCLUDE_EXEC_TIME
+  #if !defined(UNITY_EXEC_TIME_START) && \
+      !defined(UNITY_EXEC_TIME_STOP) && \
+      !defined(UNITY_PRINT_EXEC_TIME) && \
+      !defined(UNITY_TIME_TYPE)
+      /* If none any of these macros are defined then try to provide a default implementation */
+
+    #if defined(UNITY_CLOCK_MS)
+      /* This is a simple way to get a default implementation on platforms that support getting a millisecond counter */
+      #define UNITY_TIME_TYPE UNITY_UINT
+      #define UNITY_EXEC_TIME_START() Unity.CurrentTestStartTime = UNITY_CLOCK_MS()
+      #define UNITY_EXEC_TIME_STOP() Unity.CurrentTestStopTime = UNITY_CLOCK_MS()
+      #define UNITY_PRINT_EXEC_TIME() { \
+        UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \
+        UnityPrint(" ("); \
+        UnityPrintNumberUnsigned(execTimeMs); \
+        UnityPrint(" ms)"); \
+        }
+    #elif defined(_WIN32)
+      #include <time.h>
+      #define UNITY_TIME_TYPE clock_t
+      #define UNITY_GET_TIME(t) t = (clock_t)((clock() * 1000) / CLOCKS_PER_SEC)
+      #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime)
+      #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime)
+      #define UNITY_PRINT_EXEC_TIME() { \
+        UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \
+        UnityPrint(" ("); \
+        UnityPrintNumberUnsigned(execTimeMs); \
+        UnityPrint(" ms)"); \
+        }
+    #elif defined(__unix__) || defined(__APPLE__)
+      #include <time.h>
+      #define UNITY_TIME_TYPE struct timespec
+      #define UNITY_GET_TIME(t) clock_gettime(CLOCK_MONOTONIC, &t)
+      #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime)
+      #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime)
+      #define UNITY_PRINT_EXEC_TIME() { \
+        UNITY_UINT execTimeMs = ((Unity.CurrentTestStopTime.tv_sec - Unity.CurrentTestStartTime.tv_sec) * 1000L); \
+        execTimeMs += ((Unity.CurrentTestStopTime.tv_nsec - Unity.CurrentTestStartTime.tv_nsec) / 1000000L); \
+        UnityPrint(" ("); \
+        UnityPrintNumberUnsigned(execTimeMs); \
+        UnityPrint(" ms)"); \
+        }
+    #endif
+  #endif
+#endif
+
+#ifndef UNITY_EXEC_TIME_START
+#define UNITY_EXEC_TIME_START() do { /* nothing*/ } while (0)
+#endif
+
+#ifndef UNITY_EXEC_TIME_STOP
+#define UNITY_EXEC_TIME_STOP()  do { /* nothing*/ } while (0)
+#endif
+
+#ifndef UNITY_TIME_TYPE
+#define UNITY_TIME_TYPE         UNITY_UINT
+#endif
+
+#ifndef UNITY_PRINT_EXEC_TIME
+#define UNITY_PRINT_EXEC_TIME() do { /* nothing*/ } while (0)
+#endif
+
 /*-------------------------------------------------------
  * Footprint
  *-------------------------------------------------------*/
@@ -297,23 +414,6 @@ extern void UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION;
 #define UNITY_COUNTER_TYPE UNITY_UINT
 #endif
 
-/*-------------------------------------------------------
- * Language Features Available
- *-------------------------------------------------------*/
-#if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA)
-#   ifdef __GNUC__ /* includes clang */
-#       if !(defined(__WIN32__) && defined(__clang__)) && !defined(__TMS470__)
-#           define UNITY_WEAK_ATTRIBUTE __attribute__((weak))
-#       endif
-#   endif
-#endif
-
-#ifdef UNITY_NO_WEAK
-#   undef UNITY_WEAK_ATTRIBUTE
-#   undef UNITY_WEAK_PRAGMA
-#endif
-
-
 /*-------------------------------------------------------
  * Internal Structs Needed
  *-------------------------------------------------------*/
@@ -323,10 +423,11 @@ typedef void (*UnityTestFunction)(void);
 #define UNITY_DISPLAY_RANGE_INT  (0x10)
 #define UNITY_DISPLAY_RANGE_UINT (0x20)
 #define UNITY_DISPLAY_RANGE_HEX  (0x40)
+#define UNITY_DISPLAY_RANGE_CHAR (0x80)
 
 typedef enum
 {
-UNITY_DISPLAY_STYLE_INT = sizeof(int)+ UNITY_DISPLAY_RANGE_INT,
+    UNITY_DISPLAY_STYLE_INT      = (UNITY_INT_WIDTH / 8) + UNITY_DISPLAY_RANGE_INT,
     UNITY_DISPLAY_STYLE_INT8     = 1 + UNITY_DISPLAY_RANGE_INT,
     UNITY_DISPLAY_STYLE_INT16    = 2 + UNITY_DISPLAY_RANGE_INT,
     UNITY_DISPLAY_STYLE_INT32    = 4 + UNITY_DISPLAY_RANGE_INT,
@@ -334,7 +435,7 @@ UNITY_DISPLAY_STYLE_INT = sizeof(int)+ UNITY_DISPLAY_RANGE_INT,
     UNITY_DISPLAY_STYLE_INT64    = 8 + UNITY_DISPLAY_RANGE_INT,
 #endif
 
-UNITY_DISPLAY_STYLE_UINT = sizeof(unsigned) + UNITY_DISPLAY_RANGE_UINT,
+    UNITY_DISPLAY_STYLE_UINT     = (UNITY_INT_WIDTH / 8) + UNITY_DISPLAY_RANGE_UINT,
     UNITY_DISPLAY_STYLE_UINT8    = 1 + UNITY_DISPLAY_RANGE_UINT,
     UNITY_DISPLAY_STYLE_UINT16   = 2 + UNITY_DISPLAY_RANGE_UINT,
     UNITY_DISPLAY_STYLE_UINT32   = 4 + UNITY_DISPLAY_RANGE_UINT,
@@ -349,9 +450,23 @@ UNITY_DISPLAY_STYLE_UINT = sizeof(unsigned) + UNITY_DISPLAY_RANGE_UINT,
     UNITY_DISPLAY_STYLE_HEX64    = 8 + UNITY_DISPLAY_RANGE_HEX,
 #endif
 
+    UNITY_DISPLAY_STYLE_CHAR     = 1 + UNITY_DISPLAY_RANGE_CHAR + UNITY_DISPLAY_RANGE_INT,
+
     UNITY_DISPLAY_STYLE_UNKNOWN
 } UNITY_DISPLAY_STYLE_T;
 
+typedef enum
+{
+    UNITY_WITHIN           = 0x0,
+    UNITY_EQUAL_TO         = 0x1,
+    UNITY_GREATER_THAN     = 0x2,
+    UNITY_GREATER_OR_EQUAL = 0x2 + UNITY_EQUAL_TO,
+    UNITY_SMALLER_THAN     = 0x4,
+    UNITY_SMALLER_OR_EQUAL = 0x4 + UNITY_EQUAL_TO,
+    UNITY_NOT_EQUAL        = 0x0,
+    UNITY_UNKNOWN
+} UNITY_COMPARISON_T;
+
 #ifndef UNITY_EXCLUDE_FLOAT
 typedef enum UNITY_FLOAT_TRAIT
 {
@@ -370,7 +485,8 @@ typedef enum UNITY_FLOAT_TRAIT
 typedef enum
 {
     UNITY_ARRAY_TO_VAL = 0,
-    UNITY_ARRAY_TO_ARRAY
+    UNITY_ARRAY_TO_ARRAY,
+    UNITY_ARRAY_UNKNOWN
 } UNITY_FLAGS_T;
 
 struct UNITY_STORAGE_T
@@ -387,6 +503,10 @@ struct UNITY_STORAGE_T
     UNITY_COUNTER_TYPE TestIgnores;
     UNITY_COUNTER_TYPE CurrentTestFailed;
     UNITY_COUNTER_TYPE CurrentTestIgnored;
+#ifdef UNITY_INCLUDE_EXEC_TIME
+    UNITY_TIME_TYPE CurrentTestStartTime;
+    UNITY_TIME_TYPE CurrentTestStopTime;
+#endif
 #ifndef UNITY_EXCLUDE_SETJMP_H
     jmp_buf AbortFrame;
 #endif
@@ -400,8 +520,14 @@ extern struct UNITY_STORAGE_T Unity;
 
 void UnityBegin(const char* filename);
 int  UnityEnd(void);
+void UnitySetTestFile(const char* filename);
 void UnityConcludeTest(void);
+
+#ifndef RUN_TEST
 void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum);
+#else
+#define UNITY_SKIP_DEFAULT_RUNNER
+#endif
 
 /*-------------------------------------------------------
  * Details Support
@@ -412,9 +538,9 @@ void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int
 #define UNITY_SET_DETAIL(d1)
 #define UNITY_SET_DETAILS(d1,d2)
 #else
-#define UNITY_CLR_DETAILS()      { Unity.CurrentDetail1 = 0;   Unity.CurrentDetail2 = 0;  }
+#define UNITY_CLR_DETAILS()         do { Unity.CurrentDetail1 = 0;     Unity.CurrentDetail2 = 0;    } while (0)
-#define UNITY_SET_DETAIL(d1)     { Unity.CurrentDetail1 = d1;  Unity.CurrentDetail2 = 0;  }
+#define UNITY_SET_DETAIL(d1)        do { Unity.CurrentDetail1 = (d1);  Unity.CurrentDetail2 = 0;    } while (0)
-#define UNITY_SET_DETAILS(d1,d2) { Unity.CurrentDetail1 = d1;  Unity.CurrentDetail2 = d2; }
+#define UNITY_SET_DETAILS(d1,d2)    do { Unity.CurrentDetail1 = (d1);  Unity.CurrentDetail2 = (d2); } while (0)
 
 #ifndef UNITY_DETAIL1_NAME
 #define UNITY_DETAIL1_NAME "Function"
@@ -425,17 +551,26 @@ void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int
 #endif
 #endif
 
+#ifdef UNITY_PRINT_TEST_CONTEXT
+void UNITY_PRINT_TEST_CONTEXT(void);
+#endif
+
 /*-------------------------------------------------------
  * Test Output
  *-------------------------------------------------------*/
 
 void UnityPrint(const char* string);
+
+#ifdef UNITY_INCLUDE_PRINT_FORMATTED
+void UnityPrintF(const UNITY_LINE_TYPE line, const char* format, ...);
+#endif
+
 void UnityPrintLen(const char* string, const UNITY_UINT32 length);
 void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number);
 void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style);
-void UnityPrintNumber(const UNITY_INT number);
+void UnityPrintNumber(const UNITY_INT number_to_print);
 void UnityPrintNumberUnsigned(const UNITY_UINT number);
-void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles);
+void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print);
 
 #ifndef UNITY_EXCLUDE_FLOAT_PRINT
 void UnityPrintFloat(const UNITY_DOUBLE input_number);
@@ -455,17 +590,12 @@ void UnityAssertEqualNumber(const UNITY_INT expected,
                             const UNITY_LINE_TYPE lineNumber,
                             const UNITY_DISPLAY_STYLE_T style);
 
-void UnityAssertGreaterNumber(const UNITY_INT threshold,
+void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold,
-                            const UNITY_INT actual,
+                                           const UNITY_INT actual,
-                            const char* msg,
+                                           const UNITY_COMPARISON_T compare,
-                            const UNITY_LINE_TYPE lineNumber,
+                                           const char *msg,
-                            const UNITY_DISPLAY_STYLE_T style);
+                                           const UNITY_LINE_TYPE lineNumber,
-
+                                           const UNITY_DISPLAY_STYLE_T style);
-void UnityAssertSmallerNumber(const UNITY_INT threshold,
-                            const UNITY_INT actual,
-                            const char* msg,
-                            const UNITY_LINE_TYPE lineNumber,
-                            const UNITY_DISPLAY_STYLE_T style);
 
 void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
                               UNITY_INTERNAL_PTR actual,
@@ -514,9 +644,24 @@ void UnityAssertNumbersWithin(const UNITY_UINT delta,
                               const UNITY_LINE_TYPE lineNumber,
                               const UNITY_DISPLAY_STYLE_T style);
 
-void UnityFail(const char* message, const UNITY_LINE_TYPE line);
+void UnityAssertNumbersArrayWithin(const UNITY_UINT delta,
+                                   UNITY_INTERNAL_PTR expected,
+                                   UNITY_INTERNAL_PTR actual,
+                                   const UNITY_UINT32 num_elements,
+                                   const char* msg,
+                                   const UNITY_LINE_TYPE lineNumber,
+                                   const UNITY_DISPLAY_STYLE_T style,
+                                   const UNITY_FLAGS_T flags);
 
+#ifndef UNITY_EXCLUDE_SETJMP_H
+UNITY_NORETURN void UnityFail(const char* message, const UNITY_LINE_TYPE line);
+UNITY_NORETURN void UnityIgnore(const char* message, const UNITY_LINE_TYPE line);
+#else
+void UnityFail(const char* message, const UNITY_LINE_TYPE line);
 void UnityIgnore(const char* message, const UNITY_LINE_TYPE line);
+#endif
+
+void UnityMessage(const char* message, const UNITY_LINE_TYPE line);
 
 #ifndef UNITY_EXCLUDE_FLOAT
 void UnityAssertFloatsWithin(const UNITY_FLOAT delta,
@@ -525,12 +670,25 @@ void UnityAssertFloatsWithin(const UNITY_FLOAT delta,
                              const char* msg,
                              const UNITY_LINE_TYPE lineNumber);
 
-void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected,
+void UnityAssertFloatsNotWithin(const UNITY_FLOAT delta,
-                                UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual,
+                                const UNITY_FLOAT expected,
-                                const UNITY_UINT32 num_elements,
+                                const UNITY_FLOAT actual,
                                 const char* msg,
-                                const UNITY_LINE_TYPE lineNumber,
+                                const UNITY_LINE_TYPE lineNumber);
-                                const UNITY_FLAGS_T flags);
+
+void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold,
+                                   const UNITY_FLOAT actual,
+                                   const UNITY_COMPARISON_T compare,
+                                   const char* msg,
+                                   const UNITY_LINE_TYPE linenumber);
+
+void UnityAssertWithinFloatArray(const UNITY_FLOAT delta,
+                                 UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected,
+                                 UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual,
+                                 const UNITY_UINT32 num_elements,
+                                 const char* msg,
+                                 const UNITY_LINE_TYPE lineNumber,
+                                 const UNITY_FLAGS_T flags);
 
 void UnityAssertFloatSpecial(const UNITY_FLOAT actual,
                              const char* msg,
@@ -545,12 +703,25 @@ void UnityAssertDoublesWithin(const UNITY_DOUBLE delta,
                               const char* msg,
                               const UNITY_LINE_TYPE lineNumber);
 
-void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected,
+void UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta,
-                                 UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual,
+                                 const UNITY_DOUBLE expected,
-                                 const UNITY_UINT32 num_elements,
+                                 const UNITY_DOUBLE actual,
                                  const char* msg,
-                                 const UNITY_LINE_TYPE lineNumber,
+                                 const UNITY_LINE_TYPE lineNumber);
-                                 const UNITY_FLAGS_T flags);
+
+void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold,
+                                    const UNITY_DOUBLE actual,
+                                    const UNITY_COMPARISON_T compare,
+                                    const char* msg,
+                                    const UNITY_LINE_TYPE linenumber);
+
+void UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta,
+                                  UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected,
+                                  UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual,
+                                  const UNITY_UINT32 num_elements,
+                                  const char* msg,
+                                  const UNITY_LINE_TYPE lineNumber,
+                                  const UNITY_FLAGS_T flags);
 
 void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual,
                               const char* msg,
@@ -574,9 +745,15 @@ UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num);
  * Error Strings We Might Need
  *-------------------------------------------------------*/
 
+extern const char UnityStrOk[];
+extern const char UnityStrPass[];
+extern const char UnityStrFail[];
+extern const char UnityStrIgnore[];
+
 extern const char UnityStrErrFloat[];
 extern const char UnityStrErrDouble[];
 extern const char UnityStrErr64[];
+extern const char UnityStrErrShorthand[];
 
 /*-------------------------------------------------------
  * Test Running Macros
@@ -590,17 +767,33 @@ extern const char UnityStrErr64[];
 #define TEST_ABORT() return
 #endif
 
+/* Automatically enable variadic macros support, if it not enabled before */
+#ifndef UNITY_SUPPORT_VARIADIC_MACROS
+  #ifdef __STDC_VERSION__
+    #if __STDC_VERSION__ >= 199901L
+      #define UNITY_SUPPORT_VARIADIC_MACROS
+    #endif
+  #endif
+#endif
+
 /* This tricky series of macros gives us an optional line argument to treat it as RUN_TEST(func, num=__LINE__) */
 #ifndef RUN_TEST
-#ifdef __STDC_VERSION__
+#ifdef UNITY_SUPPORT_VARIADIC_MACROS
-#if __STDC_VERSION__ >= 199901L
+#define RUN_TEST(...) RUN_TEST_AT_LINE(__VA_ARGS__, __LINE__, throwaway)
-#define RUN_TEST(...) UnityDefaultTestRun(RUN_TEST_FIRST(__VA_ARGS__), RUN_TEST_SECOND(__VA_ARGS__))
+#define RUN_TEST_AT_LINE(func, line, ...) UnityDefaultTestRun(func, #func, line)
-#define RUN_TEST_FIRST(...) RUN_TEST_FIRST_HELPER(__VA_ARGS__, throwaway)
-#define RUN_TEST_FIRST_HELPER(first, ...) (first), #first
-#define RUN_TEST_SECOND(...) RUN_TEST_SECOND_HELPER(__VA_ARGS__, __LINE__, throwaway)
-#define RUN_TEST_SECOND_HELPER(first, second, ...) (second)
 #endif
 #endif
+
+/* Enable default macros for masking param tests test cases */
+#ifdef UNITY_SUPPORT_TEST_CASES
+  #ifdef UNITY_SUPPORT_VARIADIC_MACROS
+    #if !defined(TEST_CASE) && !defined(UNITY_EXCLUDE_TEST_CASE)
+      #define TEST_CASE(...)
+    #endif
+    #if !defined(TEST_RANGE) && !defined(UNITY_EXCLUDE_TEST_RANGE)
+      #define TEST_RANGE(...)
+    #endif
+  #endif
 #endif
 
 /* If we can't do the tricky version, we'll just have to require them to always include the line number */
@@ -627,6 +820,16 @@ extern const char UnityStrErr64[];
 #define UNITY_END() UnityEnd()
 #endif
 
+#ifndef UNITY_SHORTHAND_AS_INT
+#ifndef UNITY_SHORTHAND_AS_MEM
+#ifndef UNITY_SHORTHAND_AS_NONE
+#ifndef UNITY_SHORTHAND_AS_RAW
+#define UNITY_SHORTHAND_AS_OLD
+#endif
+#endif
+#endif
+#endif
+
 /*-----------------------------------------------
  * Command Line Argument Support
  *-----------------------------------------------*/
@@ -647,9 +850,11 @@ int UnityTestMatches(void);
  * Test Asserts
  *-------------------------------------------------------*/
 
-#define UNITY_TEST_ASSERT(condition, line, message)                                              if (condition) {} else {UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), (message));}
+#define UNITY_TEST_ASSERT(condition, line, message)                                              do { if (condition) { /* nothing*/ } else { UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), (message)); } } while (0)
 #define UNITY_TEST_ASSERT_NULL(pointer, line, message)                                           UNITY_TEST_ASSERT(((pointer) == NULL),  (UNITY_LINE_TYPE)(line), (message))
 #define UNITY_TEST_ASSERT_NOT_NULL(pointer, line, message)                                       UNITY_TEST_ASSERT(((pointer) != NULL),  (UNITY_LINE_TYPE)(line), (message))
+#define UNITY_TEST_ASSERT_EMPTY(pointer, line, message)                                          UNITY_TEST_ASSERT(((pointer[0]) == 0),  (UNITY_LINE_TYPE)(line), (message))
+#define UNITY_TEST_ASSERT_NOT_EMPTY(pointer, line, message)                                      UNITY_TEST_ASSERT(((pointer[0]) != 0),  (UNITY_LINE_TYPE)(line), (message))
 
 #define UNITY_TEST_ASSERT_EQUAL_INT(expected, actual, line, message)                             UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
 #define UNITY_TEST_ASSERT_EQUAL_INT8(expected, actual, line, message)                            UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
@@ -662,47 +867,100 @@ int UnityTestMatches(void);
 #define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message)                            UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
 #define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message)                           UnityAssertEqualNumber((UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
 #define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message)                           UnityAssertEqualNumber((UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
+#define UNITY_TEST_ASSERT_EQUAL_CHAR(expected, actual, line, message)                            UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR)
 #define UNITY_TEST_ASSERT_BITS(mask, expected, actual, line, message)                            UnityAssertBits((UNITY_INT)(mask), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line))
 
+#define UNITY_TEST_ASSERT_NOT_EQUAL_INT(threshold, actual, line, message)                        UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold),               (UNITY_INT)(actual),               UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual, line, message)                       UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold),  (UNITY_INT)(UNITY_INT8 )(actual),  UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual, line, message)                      UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold),  (UNITY_INT)(UNITY_INT16)(actual),  UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual, line, message)                      UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold),  (UNITY_INT)(UNITY_INT32)(actual),  UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual, line, message)                       UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold),               (UNITY_INT)(actual),               UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual, line, message)                      UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual, line, message)                     UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual, line, message)                     UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual, line, message)                       UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual, line, message)                      UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual, line, message)                      UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual, line, message)                       UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold),  (UNITY_INT)(UNITY_INT8 )(actual),  UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR)
 
-#define UNITY_TEST_ASSERT_GREATER_THAN_INT(threshold, actual, line, message)               UnityAssertGreaterNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
+#define UNITY_TEST_ASSERT_GREATER_THAN_INT(threshold, actual, line, message)                     UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold),              (UNITY_INT)(actual),              UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_GREATER_THAN_INT8(threshold, actual, line, message)               UnityAssertGreaterNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
+#define UNITY_TEST_ASSERT_GREATER_THAN_INT8(threshold, actual, line, message)                    UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
-#define UNITY_TEST_ASSERT_GREATER_THAN_INT16(threshold, actual, line, message)               UnityAssertGreaterNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
+#define UNITY_TEST_ASSERT_GREATER_THAN_INT16(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
-#define UNITY_TEST_ASSERT_GREATER_THAN_INT32(threshold, actual, line, message)               UnityAssertGreaterNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
+#define UNITY_TEST_ASSERT_GREATER_THAN_INT32(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
-#define UNITY_TEST_ASSERT_GREATER_THAN_UINT(threshold, actual, line, message)               UnityAssertGreaterNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
+#define UNITY_TEST_ASSERT_GREATER_THAN_UINT(threshold, actual, line, message)                    UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold),              (UNITY_INT)(actual),              UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual, line, message)               UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
+#define UNITY_TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
-#define UNITY_TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual, line, message)               UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
+#define UNITY_TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual, line, message)                  UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
-#define UNITY_TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual, line, message)               UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
+#define UNITY_TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual, line, message)                  UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
-#define UNITY_TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual, line, message)               UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
+#define UNITY_TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual, line, message)                    UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
-#define UNITY_TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual, line, message)               UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
+#define UNITY_TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
-#define UNITY_TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual, line, message)               UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
+#define UNITY_TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
+#define UNITY_TEST_ASSERT_GREATER_THAN_CHAR(threshold, actual, line, message)                    UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR)
 
+#define UNITY_TEST_ASSERT_SMALLER_THAN_INT(threshold, actual, line, message)                     UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold),              (UNITY_INT)(actual),              UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_INT8(threshold, actual, line, message)                    UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_INT16(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_INT32(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT(threshold, actual, line, message)                    UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold),              (UNITY_INT)(actual),              UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT8(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT16(threshold, actual, line, message)                  UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT32(threshold, actual, line, message)                  UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX8(threshold, actual, line, message)                    UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX16(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX32(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_CHAR(threshold, actual, line, message)                    UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR)
 
-#define UNITY_TEST_ASSERT_SMALLER_THAN_INT(threshold, actual, line, message)               UnityAssertSmallerNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual, line, message)                 UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)              (threshold), (UNITY_INT)              (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_SMALLER_THAN_INT8(threshold, actual, line, message)               UnityAssertSmallerNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual, line, message)                UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 ) (threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
-#define UNITY_TEST_ASSERT_SMALLER_THAN_INT16(threshold, actual, line, message)               UnityAssertSmallerNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16) (threshold), (UNITY_INT)(UNITY_INT16) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
-#define UNITY_TEST_ASSERT_SMALLER_THAN_INT32(threshold, actual, line, message)               UnityAssertSmallerNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32) (threshold), (UNITY_INT)(UNITY_INT32) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
-#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT(threshold, actual, line, message)               UnityAssertSmallerNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual, line, message)                UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)              (threshold), (UNITY_INT)              (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT8(threshold, actual, line, message)               UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
-#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT16(threshold, actual, line, message)               UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual, line, message)              UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
-#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT32(threshold, actual, line, message)               UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual, line, message)              UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
-#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX8(threshold, actual, line, message)               UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual, line, message)                UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
-#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX16(threshold, actual, line, message)               UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
-#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX32(threshold, actual, line, message)               UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR(threshold, actual, line, message)                UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 ) (threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR)
 
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT(threshold, actual, line, message)                 UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)             (threshold),  (UNITY_INT)              (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8(threshold, actual, line, message)                UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold),  (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold),  (UNITY_INT)(UNITY_INT16) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold),  (UNITY_INT)(UNITY_INT32) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT(threshold, actual, line, message)                UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)             (threshold),  (UNITY_INT)              (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16(threshold, actual, line, message)              UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32(threshold, actual, line, message)              UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8(threshold, actual, line, message)                UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR(threshold, actual, line, message)                UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold),  (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR)
 
-
+#define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message)                     UnityAssertNumbersWithin(              (delta), (UNITY_INT)                          (expected), (UNITY_INT)                          (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message)                     UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
+#define UNITY_TEST_ASSERT_INT8_WITHIN(delta, expected, actual, line, message)                    UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_INT8 )             (expected), (UNITY_INT)(UNITY_INT8 )             (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
-#define UNITY_TEST_ASSERT_INT8_WITHIN(delta, expected, actual, line, message)                    UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
+#define UNITY_TEST_ASSERT_INT16_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_INT16)             (expected), (UNITY_INT)(UNITY_INT16)             (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
-#define UNITY_TEST_ASSERT_INT16_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
+#define UNITY_TEST_ASSERT_INT32_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_INT32)             (expected), (UNITY_INT)(UNITY_INT32)             (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
-#define UNITY_TEST_ASSERT_INT32_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
+#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message)                    UnityAssertNumbersWithin(              (delta), (UNITY_INT)                          (expected), (UNITY_INT)                          (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message)                    UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
 #define UNITY_TEST_ASSERT_UINT8_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
 #define UNITY_TEST_ASSERT_UINT16_WITHIN(delta, expected, actual, line, message)                  UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
 #define UNITY_TEST_ASSERT_UINT32_WITHIN(delta, expected, actual, line, message)                  UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
 #define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message)                    UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
 #define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
 #define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
+#define UNITY_TEST_ASSERT_CHAR_WITHIN(delta, expected, actual, line, message)                    UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_INT8 )             (expected), (UNITY_INT)(UNITY_INT8 )             (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR)
+
+#define UNITY_TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)     UnityAssertNumbersArrayWithin(              (delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)    UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)   UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)   UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)    UnityAssertNumbersArrayWithin(              (delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)   UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)  UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)  UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)    UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)   UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)   UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)    UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_ARRAY)
+
 
 #define UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, line, message)                             UnityAssertEqualNumber((UNITY_PTR_TO_INT)(expected), (UNITY_PTR_TO_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER)
 #define UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, line, message)                          UnityAssertEqualString((const char*)(expected), (const char*)(actual), (message), (UNITY_LINE_TYPE)(line))
@@ -723,21 +981,23 @@ int UnityTestMatches(void);
 #define UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements, line, message)         UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_ARRAY)
 #define UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, line, message)      UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY)
 #define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR,    UNITY_ARRAY_TO_ARRAY)
 
-#define UNITY_TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements, line, message)          UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)              expected, sizeof(int)),  (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT,     UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements, line, message)          UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)              (expected), (UNITY_INT_WIDTH / 8)),          (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT,     UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements, line, message)         UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8  )expected, 1),            (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8,    UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements, line, message)         UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8  )(expected), 1),                              (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8,    UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )expected, 2),            (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16,   UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2),                              (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16,   UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )expected, 4),            (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32,   UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4),                              (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32,   UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements, line, message)         UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)              expected, sizeof(unsigned int)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT,    UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements, line, message)         UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)              (expected), (UNITY_INT_WIDTH / 8)),          (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT,    UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT8 )expected, 1),            (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8,   UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT8 )(expected), 1),                              (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8,   UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT16)expected, 2),            (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16,  UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT16)(expected), 2),                              (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16,  UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT32)expected, 4),            (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32,  UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT32)(expected), 4),                              (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32,  UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements, line, message)         UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8  )expected, 1),            (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8,    UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements, line, message)         UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8  )(expected), 1),                              (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8,    UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )expected, 2),            (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16,   UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2),                              (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16,   UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )expected, 4),            (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32,   UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4),                              (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32,   UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements, line, message)          UnityAssertEqualIntArray(UnityNumToPtr((UNITY_PTR_TO_INT)       expected, sizeof(int*)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements, line, message)          UnityAssertEqualIntArray(UnityNumToPtr((UNITY_PTR_TO_INT)       (expected), (UNITY_POINTER_WIDTH / 8)),      (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_VAL)
 #define UNITY_TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements, line, message)       UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL)
 #define UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements, line, message)  UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements, line, message)         UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8  )(expected), 1),                              (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR,    UNITY_ARRAY_TO_VAL)
 
 #ifdef UNITY_SUPPORT_64
 #define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message)                           UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
@@ -746,12 +1006,30 @@ int UnityTestMatches(void);
 #define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64,  UNITY_ARRAY_TO_ARRAY)
 #define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message)      UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_ARRAY)
 #define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64,  UNITY_ARRAY_TO_ARRAY)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)expected, 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64,  UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64,  UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT64)expected, 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_VAL)
-#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)expected, 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64,  UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64,  UNITY_ARRAY_TO_VAL)
 #define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
 #define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message)                  UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
 #define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual, line, message)                      UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL,        (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual, line, message)                     UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL,        (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual, line, message)                      UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL,        (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
+#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN,     (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
+#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message)                  UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN,     (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
+#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN,     (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message)              UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN,     (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message)                  UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN,     (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message)                   UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN,     (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message)              UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message)               UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
+#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)   UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)  UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)   UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_ARRAY)
 #else
 #define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message)                           UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
 #define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message)                          UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
@@ -762,13 +1040,35 @@ int UnityTestMatches(void);
 #define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message)                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
 #define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message)                  UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
 #define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message)                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message)                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message)                  UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message)                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message)               UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message)              UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message)               UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message)                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message)                  UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message)                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message)               UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message)              UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message)               UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)  UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
+#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
 #endif
 
 #ifdef UNITY_EXCLUDE_FLOAT
 #define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message)                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
+#define UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual, line, message)               UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
 #define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message)                           UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual, line, message)                       UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
+#define UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)  UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
 #define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message)       UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
 #define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message)        UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
+#define UNITY_TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual, line, message)                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual, line, message)               UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
+#define UNITY_TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual, line, message)                      UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
+#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual, line, message)                  UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
 #define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message)                                    UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
 #define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message)                                UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
 #define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message)                                    UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
@@ -779,9 +1079,16 @@ int UnityTestMatches(void);
 #define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message)                        UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
 #else
 #define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message)                   UnityAssertFloatsWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line))
+#define UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual, line, message)               UnityAssertFloatsNotWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line))
 #define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message)                           UNITY_TEST_ASSERT_FLOAT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message))
-#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message)       UnityAssertEqualFloatArray((UNITY_FLOAT*)(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual, line, message)                       UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message))
-#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message)        UnityAssertEqualFloatArray(UnityFloatToPtr(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message)  UnityAssertWithinFloatArray((UNITY_FLOAT)(delta), (const UNITY_FLOAT*)(expected), (const UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message)       UnityAssertWithinFloatArray((UNITY_FLOAT)0, (const UNITY_FLOAT*)(expected), (const UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message)        UnityAssertWithinFloatArray((UNITY_FLOAT)0, UnityFloatToPtr(expected), (const UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual, line, message)                   UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line))
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual, line, message)               UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line))
+#define UNITY_TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual, line, message)                      UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line))
+#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_FLOAT(threshold, actual, line, message)                  UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line))
 #define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message)                                    UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF)
 #define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message)                                UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF)
 #define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message)                                    UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN)
@@ -794,9 +1101,16 @@ int UnityTestMatches(void);
 
 #ifdef UNITY_EXCLUDE_DOUBLE
 #define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message)                  UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
+#define UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual, line, message)              UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
 #define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message)                          UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual, line, message)                      UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
+#define UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
 #define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message)      UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
 #define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message)       UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
+#define UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual, line, message)                  UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual, line, message)              UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
+#define UNITY_TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual, line, message)                     UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
+#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual, line, message)                 UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
 #define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message)                                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
 #define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message)                               UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
 #define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message)                                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
@@ -806,10 +1120,17 @@ int UnityTestMatches(void);
 #define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message)                               UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
 #define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message)                       UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
 #else
-#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message)                  UnityAssertDoublesWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)line)
+#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message)                  UnityAssertDoublesWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line))
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message)                          UNITY_TEST_ASSERT_DOUBLE_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)expected, (UNITY_DOUBLE)actual, (UNITY_LINE_TYPE)(line), message)
+#define UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual, line, message)              UnityAssertDoublesNotWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line))
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message)      UnityAssertEqualDoubleArray((UNITY_DOUBLE*)(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message)                          UNITY_TEST_ASSERT_DOUBLE_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message))
-#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message)       UnityAssertEqualDoubleArray(UnityDoubleToPtr(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual, line, message)                      UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message))
+#define UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)(delta), (const UNITY_DOUBLE*)(expected), (const UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message)      UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, (const UNITY_DOUBLE*)(expected), (const UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY)
+#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message)       UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, UnityDoubleToPtr(expected), (const UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL)
+#define UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual, line, message)                  UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line))
+#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual, line, message)              UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line))
+#define UNITY_TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual, line, message)                     UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line))
+#define UNITY_TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(threshold, actual, line, message)                 UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line))
 #define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message)                                   UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF)
 #define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message)                               UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF)
 #define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message)                                   UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN)

test/.rubocop.yml

@@ -3,7 +3,7 @@
 #inherit_from: .rubocop_todo.yml
 
 AllCops:
-  TargetRubyVersion: 2.1
+  TargetRubyVersion: 2.3
 
 # These are areas where ThrowTheSwitch's coding style diverges from the Ruby standard
 Style/SpecialGlobalVars:
@@ -12,13 +12,31 @@ Style/FormatString:
   Enabled: false
 Style/GlobalVars:
   Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false
 Style/RegexpLiteral:
   AllowInnerSlashes: true
 Style/HashSyntax:
   EnforcedStyle: no_mixed_keys
+Style/NumericPredicate:
+  Enabled: false
+Style/MultilineBlockChain:
+  Enabled: false
+Style/Alias:
+  Enabled: false
+Style/EvalWithLocation:
+  Enabled: false
+Style/MixinUsage:
+  Enabled: false
+
+# These are also places we diverge... but we will likely comply down the road
+Style/IfUnlessModifier:
+  Enabled: false
+Style/FormatStringToken:
+  Enabled: false
 
 # This is disabled because it seems to get confused over nested hashes
-Style/AlignHash:
+Layout/AlignHash:
   Enabled: false
   EnforcedHashRocketStyle: table
   EnforcedColonStyle: table

test/Makefile

@@ -7,16 +7,29 @@ E = -Weverything
 CFLAGS += $E -Wno-unknown-warning-option -Wno-missing-prototypes
 CFLAGS += -Wno-unused-macros -Wno-padded -Wno-missing-noreturn
 endif
-CFLAGS += -std=c99 -pedantic -Wall -Wextra -Wconversion -Werror
+CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror
+#CFLAGS += -Wconversion #disabled because if falsely complains about the isinf and isnan macros
 CFLAGS += -Wno-switch-enum -Wno-double-promotion
+CFLAGS += -Wno-poison-system-directories
 CFLAGS += -Wbad-function-cast -Wcast-qual -Wold-style-definition -Wshadow -Wstrict-overflow \
           -Wstrict-prototypes -Wswitch-default -Wundef
 #DEBUG = -O0 -g
 CFLAGS += $(DEBUG)
+UNITY_SUPPORT_64 = -D UNITY_SUPPORT_64
+UNITY_INCLUDE_DOUBLE = -D UNITY_INCLUDE_DOUBLE
 DEFINES =  -D UNITY_OUTPUT_CHAR=putcharSpy
 DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=putcharSpy\(int\)
-DEFINES += -D UNITY_SUPPORT_64 -D UNITY_INCLUDE_DOUBLE
+DEFINES += -D UNITY_OUTPUT_FLUSH=flushSpy
-SRC = ../src/unity.c tests/testunity.c build/testunityRunner.c
+DEFINES += -D UNITY_OUTPUT_FLUSH_HEADER_DECLARATION=flushSpy\(void\)
+DEFINES += $(UNITY_SUPPORT_64) $(UNITY_INCLUDE_DOUBLE)
+SRC1 = ../src/unity.c tests/test_unity_arrays.c build/test_unity_arraysRunner.c
+SRC2 = ../src/unity.c tests/test_unity_core.c build/test_unity_coreRunner.c
+SRC3 = ../src/unity.c tests/test_unity_doubles.c build/test_unity_doublesRunner.c
+SRC4 = ../src/unity.c tests/test_unity_floats.c build/test_unity_floatsRunner.c
+SRC5 = ../src/unity.c tests/test_unity_integers.c build/test_unity_integersRunner.c
+SRC6 = ../src/unity.c tests/test_unity_integers_64.c build/test_unity_integers_64Runner.c
+SRC7 = ../src/unity.c tests/test_unity_memory.c build/test_unity_memoryRunner.c
+SRC8 = ../src/unity.c tests/test_unity_strings.c build/test_unity_stringsRunner.c
 INC_DIR = -I ../src
 COV_FLAGS = -fprofile-arcs -ftest-coverage -I ../../src
 BUILD_DIR = build
@@ -26,18 +39,80 @@ TARGET = build/testunity-cov.exe
 # For verbose output of all the tests, run 'make test'.
 default: coverage
 .PHONY: default coverage test clean
-coverage: DEFINES += -D UNITY_NO_WEAK
+coverage: $(SRC1) $(SRC2) $(SRC3) $(SRC4) $(SRC5) $(SRC6) $(SRC7) $(SRC8)
-coverage: $(BUILD_DIR)/testunityRunner.c
 	cd $(BUILD_DIR) && \
-	$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC), ../$i) $(COV_FLAGS) -o ../$(TARGET)
+	$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC1), ../$i) $(COV_FLAGS) -o ../$(TARGET)
+	rm -f $(BUILD_DIR)/*.gcda
+	./$(TARGET) | grep 'Tests\|]]]' -A1
+	cd $(BUILD_DIR) && \
+	gcov unity.c | head -3
+	grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true
+	cd $(BUILD_DIR) && \
+	$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC2), ../$i) $(COV_FLAGS) -o ../$(TARGET)
+	rm -f $(BUILD_DIR)/*.gcda
+	./$(TARGET) | grep 'Tests\|]]]' -A1
+	cd $(BUILD_DIR) && \
+	gcov unity.c | head -3
+	grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true
+	cd $(BUILD_DIR) && \
+	$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC3), ../$i) $(COV_FLAGS) -o ../$(TARGET)
+	rm -f $(BUILD_DIR)/*.gcda
+	./$(TARGET) | grep 'Tests\|]]]' -A1
+	cd $(BUILD_DIR) && \
+	gcov unity.c | head -3
+	grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true
+	cd $(BUILD_DIR) && \
+	$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC4), ../$i) $(COV_FLAGS) -o ../$(TARGET)
+	rm -f $(BUILD_DIR)/*.gcda
+	./$(TARGET) | grep 'Tests\|]]]' -A1
+	cd $(BUILD_DIR) && \
+	gcov unity.c | head -3
+	grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true
+	cd $(BUILD_DIR) && \
+	$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC5), ../$i) $(COV_FLAGS) -o ../$(TARGET)
+	rm -f $(BUILD_DIR)/*.gcda
+	./$(TARGET) | grep 'Tests\|]]]' -A1
+	cd $(BUILD_DIR) && \
+	gcov unity.c | head -3
+	grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true
+	cd $(BUILD_DIR) && \
+	$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC6), ../$i) $(COV_FLAGS) -o ../$(TARGET)
+	rm -f $(BUILD_DIR)/*.gcda
+	./$(TARGET) | grep 'Tests\|]]]' -A1
+	cd $(BUILD_DIR) && \
+	gcov unity.c | head -3
+	grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true
+	cd $(BUILD_DIR) && \
+	$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC7), ../$i) $(COV_FLAGS) -o ../$(TARGET)
+	rm -f $(BUILD_DIR)/*.gcda
+	./$(TARGET) | grep 'Tests\|]]]' -A1
+	cd $(BUILD_DIR) && \
+	gcov unity.c | head -3
+	grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true
+	cd $(BUILD_DIR) && \
+	$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC8), ../$i) $(COV_FLAGS) -o ../$(TARGET)
 	rm -f $(BUILD_DIR)/*.gcda
 	./$(TARGET) | grep 'Tests\|]]]' -A1
 	cd $(BUILD_DIR) && \
 	gcov unity.c | head -3
 	grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true
 
-test: $(BUILD_DIR)/testunityRunner.c
+test: $(SRC1) $(SRC2) $(SRC3) $(SRC4) $(SRC5) $(SRC6) $(SRC7) $(SRC8)
-	$(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC) -o $(TARGET)
+	$(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC1) -o $(TARGET)
+	./$(TARGET)
+	$(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC2) -o $(TARGET)
+	./$(TARGET)
+	$(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC3) -o $(TARGET)
+	./$(TARGET)
+	$(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC4) -o $(TARGET)
+	./$(TARGET)
+	$(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC5) -o $(TARGET)
+	./$(TARGET)
+	$(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC6) -o $(TARGET)
+	./$(TARGET)
+	$(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC7) -o $(TARGET)
+	./$(TARGET)
+	$(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC8) -o $(TARGET)
 	./$(TARGET)
 
 # Compile only, for testing that preprocessor detection works
@@ -46,8 +121,29 @@ intDetection:
 	$(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_STDINT_H
 	$(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_LIMITS_H
 
-$(BUILD_DIR)/testunityRunner.c: tests/testunity.c | $(BUILD_DIR)
+$(BUILD_DIR)/test_unity_arraysRunner.c: tests/test_unity_arrays.c | $(BUILD_DIR)
-	awk $(AWK_SCRIPT) tests/testunity.c > $@
+	awk $(AWK_SCRIPT) tests/test_unity_arrays.c > $@
+
+$(BUILD_DIR)/test_unity_coreRunner.c: tests/test_unity_core.c | $(BUILD_DIR)
+	awk $(AWK_SCRIPT) tests/test_unity_core.c > $@
+
+$(BUILD_DIR)/test_unity_doublesRunner.c: tests/test_unity_doubles.c | $(BUILD_DIR)
+	awk $(AWK_SCRIPT) tests/test_unity_doubles.c > $@
+
+$(BUILD_DIR)/test_unity_floatsRunner.c: tests/test_unity_floats.c | $(BUILD_DIR)
+	awk $(AWK_SCRIPT) tests/test_unity_floats.c > $@
+
+$(BUILD_DIR)/test_unity_integersRunner.c: tests/test_unity_integers.c | $(BUILD_DIR)
+	awk $(AWK_SCRIPT) tests/test_unity_integers.c > $@
+
+$(BUILD_DIR)/test_unity_integers_64Runner.c: tests/test_unity_integers_64.c | $(BUILD_DIR)
+	awk $(AWK_SCRIPT) tests/test_unity_integers_64.c > $@
+
+$(BUILD_DIR)/test_unity_memoryRunner.c: tests/test_unity_memory.c | $(BUILD_DIR)
+	awk $(AWK_SCRIPT) tests/test_unity_memory.c > $@
+
+$(BUILD_DIR)/test_unity_stringsRunner.c: tests/test_unity_strings.c | $(BUILD_DIR)
+	awk $(AWK_SCRIPT) tests/test_unity_strings.c > $@
 
 AWK_SCRIPT=\
   '/^void test/{ declarations[d++]=$$0; gsub(/\(?void\)? ?/,""); tests[t++]=$$0; line[u++]=NR } \
@@ -61,4 +157,4 @@ $(BUILD_DIR):
 	mkdir -p $(BUILD_DIR)
 
 clean:
-	rm -f $(TARGET) $(BUILD_DIR)/*.gc* $(BUILD_DIR)/testunityRunner.c
+	rm -f $(TARGET) $(BUILD_DIR)/*.gc* $(BUILD_DIR)/test_unity_*Runner.c

test/rakefile

@@ -4,17 +4,17 @@
 #   [Released under MIT License. Please refer to license.txt for details]
 # ==========================================
 
-UNITY_ROOT = File.expand_path(File.dirname(__FILE__)) + '/'
 $verbose = false
+$extra_paths = []
 
 require 'rake'
 require 'rake/clean'
-require UNITY_ROOT + 'rakefile_helper'
+require_relative 'rakefile_helper'
 require 'rspec/core/rake_task'
 
 TEMP_DIRS = [
-	File.join(UNITY_ROOT, 'build'),
+	File.join(__dir__, 'build'),
-	File.join(UNITY_ROOT, 'sandbox')
+	File.join(__dir__, 'sandbox')
 ]
 
 TEMP_DIRS.each do |dir|
@@ -30,33 +30,70 @@ include RakefileHelpers
 DEFAULT_CONFIG_FILE = 'gcc_auto_stdint.yml'
 configure_toolchain(DEFAULT_CONFIG_FILE)
 
-desc "Test unity with its own unit tests"
+############# ALL THE SELF-TESTS WE CAN PERFORM
-task :unit => [:prepare_for_tests] do
+namespace :test do
-  run_tests unit_test_files
+  desc "Build and test Unity"
-end
+  task :all => [:clean, :prepare_for_tests, 'test:scripts', 'test:unit', :style, 'test:fixture', 'test:memory', 'test:summary']
+  task :ci => [:clean, :prepare_for_tests, 'test:scripts', 'test:unit', :style, 'test:make', 'test:fixture', 'test:memory', 'test:summary']
 
-desc "Test unity's helper scripts"
+  desc "Test unity with its own unit tests"
-task :scripts => [:prepare_for_tests] do
+  task :unit => [:prepare_for_tests] do
-  Dir['tests/test_*.rb'].each do |scriptfile|
+    run_tests unit_test_files
-    require "./"+scriptfile
+  end
+
+  namespace :unit do
+    unit_test_files.each do |f|
+      desc "test this unit only"
+      task File.basename(f,'.c').sub('test_unity_','') => [:prepare_for_tests] do
+        run_tests [f]
+      end
+    end
+  end
+
+  desc "Test unity's helper scripts"
+  task :scripts => [:prepare_for_tests] do
+    Dir['tests/test_*.rb'].each do |scriptfile|
+      require "./"+scriptfile
+    end
+  end
+
+  desc "Test unity triggered from make"
+  task :make => [:prepare_for_tests] do
+    run_make_tests()
+  end
+
+  desc "Test unity fixture addon"
+  task :fixture => [:prepare_for_tests] do
+    test_fixtures()
+  end
+
+  desc "Test unity memory addon"
+  task :memory => [:prepare_for_tests] do
+    test_memory()
+  end
+
+  desc "Test unity examples"
+  task :examples => [:prepare_for_tests] do
+    execute("cd ../examples/example_1 && make -s ci", false)
+    execute("cd ../examples/example_2 && make -s ci", false)
+    execute("cd ../examples/example_3 && rake", false)
+  end
+
+  desc "Run all rspecs"
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.pattern = 'spec/**/*_spec.rb'
+  end
+
+  desc "Generate test summary"
+  task :summary do
+    report_summary
   end
 end
 
-desc "Run all rspecs"
+###################### Shorthand for many common tasks
-RSpec::Core::RakeTask.new(:spec) do |t|
+task :ci => ['test:ci']
-  t.pattern = 'spec/**/*_spec.rb'
+task :all => ['test:all']
-end
-
-desc "Generate test summary"
-task :summary do
-  report_summary
-end
-
-desc "Build and test Unity"
-task :all => [:clean, :prepare_for_tests, :scripts, :unit, :style, :summary]
 task :default => [:clobber, :all]
-task :ci => [:no_color, :default]
-task :cruise => [:no_color, :default]
 
 desc "Load configuration"
 task :config, :config_file do |t, args|
@@ -71,6 +108,7 @@ task :verbose do
   $verbose = true
 end
 
+################### CODING STYLE VALIDATION
 namespace :style do
   desc "Check style"
   task :check do
@@ -82,7 +120,7 @@ namespace :style do
   namespace :check do
     Dir['../**/*.rb'].each do |f|
       filename = File.basename(f, '.rb')
-      desc "Check Style of #{filename}"
+      #desc "Check Style of #{filename}"
       task filename.to_sym => ['style:clean'] do
         report execute("rubocop #{f} --color --config .rubocop.yml", true)
         report "Style Checked for #{f}"
@@ -98,7 +136,7 @@ namespace :style do
   namespace :c do
     Dir['../{src,extras/**}/*.{c,h}'].each do |f|
       filename = File.basename(f)[0..-3]
-      desc "Check Style of #{filename}"
+      #desc "Check Style of #{filename}"
       task filename.to_sym do
         run_astyle f
       end

test/rakefile_helper.rb

@@ -4,11 +4,11 @@
 #   [Released under MIT License. Please refer to license.txt for details]
 # ==========================================
 
-require 'yaml'
 require 'fileutils'
-require UNITY_ROOT + '../auto/unity_test_summary'
+require_relative '../auto/unity_test_summary'
-require UNITY_ROOT + '../auto/generate_test_runner'
+require_relative '../auto/generate_test_runner'
-require UNITY_ROOT + '../auto/colour_reporter'
+require_relative '../auto/colour_reporter'
+require_relative '../auto/yaml_helper'
 
 module RakefileHelpers
   C_EXTENSION = '.c'.freeze
@@ -16,13 +16,13 @@ module RakefileHelpers
     return if $configured
 
     $cfg_file = "targets/#{config_file}" unless config_file =~ /[\\|\/]/
-    $cfg = YAML.load(File.read($cfg_file))
+    $cfg = YamlHelper.load_file($cfg_file)
     $colour_output = false unless $cfg['colour']
     $configured = true if config_file != DEFAULT_CONFIG_FILE
   end
 
   def configure_clean
-    CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil?
+    CLEAN.include('build/*.*')
   end
 
   def configure_toolchain(config_file = DEFAULT_CONFIG_FILE)
@@ -33,13 +33,16 @@ module RakefileHelpers
   end
 
   def unit_test_files
-    path = $cfg['compiler']['unit_tests_path'] + 'test*' + C_EXTENSION
+    path = 'tests/test*' + C_EXTENSION
     path.tr!('\\', '/')
     FileList.new(path)
   end
 
   def local_include_dirs
-    include_dirs = $cfg['compiler']['includes']['items'].dup
+    include_dirs = $cfg[:paths][:includes] || []
+    include_dirs += $cfg[:paths][:source] || []
+    include_dirs += $cfg[:paths][:test] || []
+    include_dirs += $cfg[:paths][:support] || []
     include_dirs.delete_if { |dir| dir.is_a?(Array) }
     include_dirs
   end
@@ -86,75 +89,73 @@ module RakefileHelpers
     end
   end
 
-  def build_compiler_fields(inject_defines)
+  def build_command_string(hash, values, defines = nil)
-    command = tackit($cfg['compiler']['path'])
-    defines = if $cfg['compiler']['defines']['items'].nil?
-                ''
-              else
-                squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=putcharSpy'] + ['UNITY_OUTPUT_CHAR_HEADER_DECLARATION=putcharSpy\(int\)'] + inject_defines)
-              end
-    options = squash('', $cfg['compiler']['options'])
-    includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
-    includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
 
-    { :command => command, :defines => defines, :options => options, :includes => includes }
+    # Replace named and numbered slots
+    args = []
+    hash[:arguments].each do |arg|
+      if arg.include? '$'
+        if arg.include? ': COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE'
+          pattern = arg.gsub(': COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE','')
+          [ File.join('..','src') ].each do |f|
+            args << pattern.gsub(/\$/,f)
+          end
+
+        elsif arg.include? ': COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR'
+          pattern = arg.gsub(': COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR','')
+          [ $extra_paths, 'src', File.join('tests'), File.join('testdata'), $cfg[:paths][:support] ].flatten.uniq.compact.each do |f|
+            args << pattern.gsub(/\$/,f)
+          end
+
+        elsif arg.include? ': COLLECTION_DEFINES_TEST_AND_VENDOR'
+          pattern = arg.gsub(': COLLECTION_DEFINES_TEST_AND_VENDOR','')
+          [ $cfg[:defines][:test], defines ].flatten.uniq.compact.each do |f|
+            args << pattern.gsub(/\$/,f)
+          end
+
+        elsif arg =~ /\$\{(\d+)\}/
+          i = $1.to_i - 1
+          if (values[i].is_a?(Array))
+            values[i].each {|v| args << arg.gsub(/\$\{\d+\}/, v)}
+          else
+            args << arg.gsub(/\$\{(\d)+\}/, values[i] || '')
+          end
+
+        else
+          args << arg
+
+        end
+      else
+        args << arg
+      end
+    end
+
+    # Build Command
+    return tackit(hash[:executable]) + squash('', args)
   end
 
   def compile(file, defines = [])
-    compiler = build_compiler_fields(defines)
+    out_file = File.join('build', File.basename(file, C_EXTENSION)) + $cfg[:extension][:object]
-    cmd_str  = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{file} " \
+    cmd_str = build_command_string( $cfg[:tools][:test_compiler], [ file, out_file ], defines )
-               "#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}"
+    execute(cmd_str)
-    obj_file = "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}"
+    out_file
-    execute(cmd_str + obj_file)
-
-    obj_file
-  end
-
-  def build_linker_fields
-    command = tackit($cfg['linker']['path'])
-    options = if $cfg['linker']['options'].nil?
-                ''
-              else
-                squash('', $cfg['linker']['options'])
-              end
-    includes = if $cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil?
-                 ''
-               else
-                 squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items'])
-               end.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
-
-    { :command => command, :options => options, :includes => includes }
   end
 
   def link_it(exe_name, obj_list)
-    linker = build_linker_fields
+    exe_name = File.join('build', File.basename(exe_name))
-    cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " +
+    cmd_str = build_command_string( $cfg[:tools][:test_linker], [ obj_list, exe_name ] )
-              (obj_list.map { |obj| "#{$cfg['linker']['object_files']['path']}#{obj} " }).join +
-              $cfg['linker']['bin_files']['prefix'] + ' ' +
-              $cfg['linker']['bin_files']['destination'] +
-              exe_name + $cfg['linker']['bin_files']['extension']
     execute(cmd_str)
   end
 
-  def build_simulator_fields
+  def runtest(bin_name, ok_to_fail = false, extra_args = nil)
-    return nil if $cfg['simulator'].nil?
+    bin_name = File.join('build', File.basename(bin_name))
-    command = if $cfg['simulator']['path'].nil?
+    extra_args = extra_args.nil? ? "" : " " + extra_args
-                ''
+    if $cfg[:tools][:test_fixture]
-              else
+      cmd_str = build_command_string( $cfg[:tools][:test_fixture], [ bin_name, extra_args ] )
-                (tackit($cfg['simulator']['path']) + ' ')
+    else
-              end
+      cmd_str = bin_name + extra_args
-    pre_support = if $cfg['simulator']['pre_support'].nil?
+    end
-                    ''
+    execute(cmd_str, ok_to_fail)
-                  else
-                    squash('', $cfg['simulator']['pre_support'])
-                  end
-    post_support = if $cfg['simulator']['post_support'].nil?
-                     ''
-                   else
-                     squash('', $cfg['simulator']['post_support'])
-                   end
-
-    { :command => command, :pre_support => pre_support, :post_support => post_support }
   end
 
   def run_astyle(style_what)
@@ -172,42 +173,101 @@ module RakefileHelpers
   def execute(command_string, ok_to_fail = false)
     report command_string if $verbose
     output = `#{command_string}`.chomp
-    report(output) if $verbose && !output.nil? && !output.empty?
+    report(output) if ($verbose && !output.nil? && !output.empty?) || (!$?.nil? && !$?.exitstatus.zero? && !ok_to_fail)
-    raise "Command failed. (Returned #{$?.exitstatus})" if !$?.exitstatus.zero? && !ok_to_fail
+    raise "Command failed. (Returned #{$?.exitstatus})" if !$?.nil? && !$?.exitstatus.zero? && !ok_to_fail
     output
   end
 
   def report_summary
     summary = UnityTestSummary.new
-    summary.root = UNITY_ROOT
+    summary.root = __dir__
-    results_glob = "#{$cfg['compiler']['build_path']}*.test*"
+    results_glob = File.join('build','*.test*')
     results_glob.tr!('\\', '/')
     results = Dir[results_glob]
     summary.targets = results
     report summary.run
   end
 
-  def run_tests(test_files)
+  def save_test_results(test_base, output)
-    report 'Running Unity system tests...'
+    test_results = File.join('build',test_base)
+    if output.match(/OK$/m).nil?
+      test_results += '.testfail'
+    else
+      report output unless $verbose # Verbose already prints this line, as does a failure
+      test_results += '.testpass'
+    end
+    File.open(test_results, 'w') { |f| f.print output }
+  end
 
-    # Tack on TEST define for compiling unit tests
+  def test_fixtures()
-    load_configuration($cfg_file)
+    report "\nRunning Fixture Addon"
-    test_defines = ['TEST']
+
-    $cfg['compiler']['defines']['items'] ||= []
+    # Get a list of all source files needed
-    $cfg['compiler']['defines']['items'] << 'TEST'
+    src_files  = Dir[File.join('..','extras','fixture','src','*.c')]
+    src_files += Dir[File.join('..','extras','fixture','test','*.c')]
+    src_files += Dir[File.join('..','extras','fixture','test','main','*.c')]
+    src_files += Dir[File.join('..','extras','memory','src','*.c')]
+    src_files << File.join('..','src','unity.c')
+
+    # Build object files
+    $extra_paths = [File.join('..','extras','fixture','src'), File.join('..','extras','memory','src')]
+    obj_list = src_files.map { |f| compile(f, ['UNITY_SKIP_DEFAULT_RUNNER', 'UNITY_FIXTURE_NO_EXTRAS']) }
+
+    # Link the test executable
+    test_base = File.basename('framework_test', C_EXTENSION)
+    link_it(test_base, obj_list)
+
+    # Run and collect output
+    output = runtest(test_base + " -v -r")
+    save_test_results(test_base, output)
+  end
+
+  def test_memory()
+    { 'w_malloc' => [],
+      'wo_malloc' => ['UNITY_EXCLUDE_STDLIB_MALLOC']
+    }.each_pair do |name, defs|
+      report "\nRunning Memory Addon #{name}"
+
+      # Get a list of all source files needed
+      src_files  = Dir[File.join('..','extras','memory','src','*.c')]
+      src_files += Dir[File.join('..','extras','memory','test','*.c')]
+      src_files += Dir[File.join('..','extras','memory','test','main','*.c')]
+      src_files << File.join('..','src','unity.c')
+
+      # Build object files
+      $extra_paths = [File.join('..','extras','memory','src')]
+      obj_list = src_files.map { |f| compile(f, defs) }
+
+      # Link the test executable
+      test_base = File.basename("memory_test_#{name}", C_EXTENSION)
+      link_it(test_base, obj_list)
+
+      # Run and collect output
+      output = runtest(test_base)
+      save_test_results(test_base, output)
+    end
+  end
+
+  def run_tests(test_files)
+    report "\nRunning Unity system tests"
 
     include_dirs = local_include_dirs
 
     # Build and execute each unit test
     test_files.each do |test|
-      obj_list = []
 
-      unless $cfg['compiler']['aux_sources'].nil?
+      # Drop Out if we're skipping this type of test
-        $cfg['compiler']['aux_sources'].each do |aux|
+      if $cfg[:skip_tests]
-          obj_list << compile(aux, test_defines)
+        if $cfg[:skip_tests].include?(:parameterized) && test.match(/parameterized/)
+          report("Skipping Parameterized Tests for this Target:IGNORE")
+          next
         end
       end
 
+      report "\nRunning Tests in #{test}"
+      obj_list = []
+      test_defines = []
+
       # Detect dependencies and build required modules
       extract_headers(test).each do |header|
         # Compile corresponding source file if it exists
@@ -218,14 +278,8 @@ module RakefileHelpers
 
       # Build the test runner (generate if configured to do so)
       test_base = File.basename(test, C_EXTENSION)
-
       runner_name = test_base + '_Runner.c'
-
+      runner_path = File.join('build',runner_name)
-      runner_path = if $cfg['compiler']['runner_path'].nil?
-                      $cfg['compiler']['build_path'] + runner_name
-                    else
-                      $cfg['compiler']['runner_path'] + runner_name
-                    end
 
       options = $cfg[:unity]
       options[:use_param_tests] = test =~ /parameterized/ ? true : false
@@ -239,22 +293,23 @@ module RakefileHelpers
       link_it(test_base, obj_list)
 
       # Execute unit test and generate results file
-      simulator = build_simulator_fields
+      output = runtest(test_base)
-      executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension']
+      save_test_results(test_base, output)
-      cmd_str = if simulator.nil?
+    end
-                  executable
+  end
-                else
+
-                  "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}"
+  def run_make_tests()
-                end
+    [ "make -s",                               # test with all defaults
-      output = execute(cmd_str)
+      #"make -s DEBUG=-m32",                    # test 32-bit architecture with 64-bit support
-      test_results = $cfg['compiler']['build_path'] + test_base
+      #"make -s DEBUG=-m32 UNITY_SUPPORT_64=",  # test 32-bit build without 64-bit types
-      if output.match(/OK$/m).nil?
+      "make -s UNITY_INCLUDE_DOUBLE= ",        # test without double
-        test_results += '.testfail'
+      "cd #{File.join("..","extras","fixture",'test')} && make -s default noStdlibMalloc",
-      else
+      "cd #{File.join("..","extras","fixture",'test')} && make -s C89",
-        report output unless $verbose # Verbose already prints this line, as does a failure
+      "cd #{File.join("..","extras","memory",'test')} && make -s default noStdlibMalloc",
-        test_results += '.testpass'
+      "cd #{File.join("..","extras","memory",'test')} && make -s C89",
-      end
+    ].each do |cmd|
-      File.open(test_results, 'w') { |f| f.print output }
+      report "Testing '#{cmd}'"
+      execute(cmd, false)
     end
   end
 end

test/targets/ansi.yml

@@ -0,0 +1,44 @@
+---
+colour: true
+:unity:
+  :plugins: []
+:skip_tests:
+- :parameterized
+:tools:
+  :test_compiler:
+    :name: compiler
+    :executable: gcc
+    :arguments:
+    - "-c"
+    - "-m64"
+    - "-Wall"
+    - "-Wno-address"
+    - "-ansi"
+    - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE'
+    - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR'
+    - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR"
+    - "${1}"
+    - "-o ${2}"
+  :test_linker:
+    :name: linker
+    :executable: gcc
+    :arguments:
+    - "${1}"
+    - "-lm"
+    - "-m64"
+    - "-o ${2}"
+:extension:
+  :object: ".o"
+  :executable: ".exe"
+:paths:
+  :test:
+    - src/
+    - "../src/"
+    - testdata/
+    - tests/
+:defines:
+  :test:
+  - UNITY_INCLUDE_DOUBLE
+  - UNITY_SUPPORT_TEST_CASES
+  - UNITY_EXCLUDE_TESTING_NEW_COMMENTS
+  - UNITY_SUPPORT_64

test/targets/clang_file.yml

@@ -1,78 +1,72 @@
 ---
-compiler:
-  path: clang
-  source_path:     '../src/'
-  unit_tests_path: &unit_tests_path 'tests/'
-  build_path:      &build_path 'build/'
-  options:
-    - '-c'
-    - '-Wall'
-    - '-Wextra'
-    - '-Werror'
-    - '-Wcast-qual'
-    - '-Wconversion'
-    - '-Wdisabled-optimization'
-    - '-Wformat=2'
-    - '-Winit-self'
-    - '-Winline'
-    - '-Winvalid-pch'
-    - '-Wmissing-include-dirs'
-    - '-Wnonnull'
-    - '-Wpacked'
-    - '-Wpointer-arith'
-    - '-Wswitch-default'
-    - '-Wstrict-aliasing'
-    - '-Wstrict-overflow=5'
-    - '-Wuninitialized'
-    - '-Wunused'
-#   - '-Wunreachable-code'
-    - '-Wreturn-type'
-    - '-Wshadow'
-    - '-Wundef'
-    - '-Wwrite-strings'
-    - '-Wno-nested-externs'
-    - '-Wno-unused-parameter'
-    - '-Wno-variadic-macros'
-    - '-Wbad-function-cast'
-    - '-fms-extensions'
-    - '-fno-omit-frame-pointer'
-    - '-ffloat-store'
-    - '-fno-common'
-    - '-fstrict-aliasing'
-    - '-std=gnu99'
-    - '-pedantic'
-    - '-O0'
-  includes:
-    prefix: '-I'
-    items:
-      - 'src/'
-      - '../src/'
-      - 'testdata/'
-      - *unit_tests_path
-  defines:
-    prefix: '-D'
-    items:
-      - UNITY_INCLUDE_DOUBLE
-      - UNITY_SUPPORT_64
-      - UNITY_OUTPUT_RESULTS_FILE
-  object_files:
-    prefix: '-o'
-    extension: '.o'
-    destination: *build_path
-linker:
-  path: clang
-  options:
-    - -lm
-    - '-m64'
-  includes:
-    prefix: '-I'
-  object_files:
-    path: *build_path
-    extension: '.o'
-  bin_files:
-    prefix: '-o'
-    extension: '.exe'
-    destination: *build_path
 colour: true
 :unity:
   :plugins: []
+:tools:
+  :test_compiler:
+    :name: compiler
+    :executable: clang
+    :arguments:
+    - "-c"
+    - "-Wall"
+    - "-Wextra"
+    - "-Werror"
+    - "-Wcast-qual"
+    - "-Wconversion"
+    - "-Wdisabled-optimization"
+    - "-Wformat=2"
+    - "-Winit-self"
+    - "-Winline"
+    - "-Winvalid-pch"
+    - "-Wmissing-include-dirs"
+    - "-Wnonnull"
+    - "-Wpacked"
+    - "-Wpointer-arith"
+    - "-Wswitch-default"
+    - "-Wstrict-aliasing"
+    - "-Wstrict-overflow=5"
+    - "-Wuninitialized"
+    - "-Wunused"
+    - "-Wreturn-type"
+    - "-Wshadow"
+    - "-Wundef"
+    - "-Wwrite-strings"
+    - "-Wno-nested-externs"
+    - "-Wno-unused-parameter"
+    - "-Wno-variadic-macros"
+    - "-Wbad-function-cast"
+    - "-fms-extensions"
+    - "-fno-omit-frame-pointer"
+    - "-ffloat-store"
+    - "-fno-common"
+    - "-fstrict-aliasing"
+    - "-std=gnu99"
+    - "-pedantic"
+    - "-O0"
+    - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE'
+    - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR'
+    - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR"
+    - "${1}"
+    - "-o ${2}"
+  :test_linker:
+    :name: linker
+    :executable: clang
+    :arguments:
+    - "${1}"
+    - "-lm"
+    - "-m64"
+    - "-o ${2}"
+:extension:
+  :object: ".o"
+  :executable: ".exe"
+:paths:
+  :test:
+    - src/
+    - "../src/"
+    - testdata/
+    - tests/
+:defines:
+  :test:
+  - UNITY_INCLUDE_DOUBLE
+  - UNITY_SUPPORT_64
+  - UNITY_OUTPUT_RESULTS_FILE

test/targets/clang_strict.yml

@@ -1,78 +1,72 @@
 ---
-compiler:
-  path: clang
-  source_path:     '../src/'
-  unit_tests_path: &unit_tests_path 'tests/'
-  build_path:      &build_path 'build/'
-  options:
-    - '-c'
-    - '-Wall'
-    - '-Wextra'
-    - '-Werror'
-    - '-Wcast-qual'
-    - '-Wconversion'
-    - '-Wdisabled-optimization'
-    - '-Wformat=2'
-    - '-Winit-self'
-    - '-Winline'
-    - '-Winvalid-pch'
-    - '-Wmissing-include-dirs'
-    - '-Wnonnull'
-    - '-Wpacked'
-    - '-Wpointer-arith'
-    - '-Wswitch-default'
-    - '-Wstrict-aliasing'
-    - '-Wstrict-overflow=5'
-    - '-Wuninitialized'
-    - '-Wunused'
-#   - '-Wunreachable-code'
-    - '-Wreturn-type'
-    - '-Wshadow'
-    - '-Wundef'
-    - '-Wwrite-strings'
-    - '-Wno-nested-externs'
-    - '-Wno-unused-parameter'
-    - '-Wno-variadic-macros'
-    - '-Wbad-function-cast'
-    - '-fms-extensions'
-    - '-fno-omit-frame-pointer'
-    #- '-ffloat-store'
-    - '-fno-common'
-    - '-fstrict-aliasing'
-    - '-std=gnu99'
-    - '-pedantic'
-    - '-O0'
-  includes:
-    prefix: '-I'
-    items:
-      - 'src/'
-      - '../src/'
-      - 'testdata/'
-      - *unit_tests_path
-  defines:
-    prefix: '-D'
-    items:
-      - UNITY_INCLUDE_DOUBLE
-      - UNITY_SUPPORT_TEST_CASES
-      - UNITY_SUPPORT_64
-  object_files:
-    prefix: '-o'
-    extension: '.o'
-    destination: *build_path
-linker:
-  path: clang
-  options:
-    - -lm
-    - '-m64'
-  includes:
-    prefix: '-I'
-  object_files:
-    path: *build_path
-    extension: '.o'
-  bin_files:
-    prefix: '-o'
-    extension: '.exe'
-    destination: *build_path
 colour: true
 :unity:
   :plugins: []
+:tools:
+  :test_compiler:
+    :name: compiler
+    :executable: clang
+    :arguments:
+    - "-c"
+    - "-Wall"
+    - "-Wextra"
+    - "-Werror"
+    - "-Wcast-qual"
+    - "-Wconversion"
+    - "-Wdisabled-optimization"
+    - "-Wformat=2"
+    - "-Winit-self"
+    - "-Winline"
+    - "-Winvalid-pch"
+    - "-Wmissing-include-dirs"
+    - "-Wnonnull"
+    - "-Wpacked"
+    - "-Wpointer-arith"
+    - "-Wswitch-default"
+    - "-Wstrict-aliasing"
+    - "-Wstrict-overflow=5"
+    - "-Wuninitialized"
+    - "-Wunused"
+    - "-Wreturn-type"
+    - "-Wshadow"
+    - "-Wundef"
+    - "-Wwrite-strings"
+    - "-Wno-nested-externs"
+    - "-Wno-unused-parameter"
+    - "-Wno-variadic-macros"
+    - "-Wbad-function-cast"
+    - "-fms-extensions"
+    - "-fno-omit-frame-pointer"
+    - "-fno-common"
+    - "-fstrict-aliasing"
+    - "-std=gnu99"
+    - "-pedantic"
+    - "-O0"
+    - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE'
+    - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR'
+    - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR"
+    - "${1}"
+    - "-o ${2}"
+  :test_linker:
+    :name: linker
+    :executable: clang
+    :arguments:
+    - "${1}"
+    - "-lm"
+    - "-m64"
+    - "-o ${2}"
+:extension:
+  :object: ".o"
+  :executable: ".exe"
+:paths:
+  :test:
+    - src/
+    - "../src/"
+    - testdata/
+    - tests/
+:defines:
+  :test:
+  - UNITY_INCLUDE_DOUBLE
+  - UNITY_SUPPORT_TEST_CASES
+  - UNITY_SUPPORT_64
+  - UNITY_COMPARE_PTRS_ON_ZERO_ARRAY

test/targets/gcc_32.yml

@@ -1,49 +1,45 @@
-compiler:
+---
-  path: gcc
-  source_path:     '../src/'
-  unit_tests_path: &unit_tests_path 'tests/'
-  build_path:      &build_path 'build/'
-  options:
-    - '-c'
-    - '-m32'
-    - '-Wall'
-    - '-Wno-address'
-    - '-std=c99'
-    - '-pedantic'
-  includes:
-    prefix: '-I'
-    items:
-      - 'src/'
-      - '../src/'
-      - 'testdata/'
-      - *unit_tests_path
-  defines:
-    prefix: '-D'
-    items:
-      - UNITY_EXCLUDE_STDINT_H
-      - UNITY_EXCLUDE_LIMITS_H
-      - UNITY_INCLUDE_DOUBLE
-      - UNITY_SUPPORT_TEST_CASES
-      - UNITY_INT_WIDTH=32
-      - UNITY_LONG_WIDTH=32
-  object_files:
-    prefix: '-o'
-    extension: '.o'
-    destination: *build_path
-linker:
-  path: gcc
-  options:
-    - -lm
-    - '-m32'
-  includes:
-    prefix: '-I'
-  object_files:
-    path: *build_path
-    extension: '.o'
-  bin_files:
-    prefix: '-o'
-    extension: '.exe'
-    destination: *build_path
 colour: true
 :unity:
   :plugins: []
+:tools:
+  :test_compiler:
+    :name: compiler
+    :executable: gcc
+    :arguments:
+    - "-c"
+    - "-m32"
+    - "-Wall"
+    - "-Wno-address"
+    - "-std=c99"
+    - "-pedantic"
+    - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE'
+    - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR'
+    - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR"
+    - "${1}"
+    - "-o ${2}"
+  :test_linker:
+    :name: linker
+    :executable: gcc
+    :arguments:
+    - "${1}"
+    - "-lm"
+    - "-m32"
+    - "-o ${2}"
+:extension:
+  :object: ".o"
+  :executable: ".exe"
+:paths:
+  :test:
+    - src/
+    - "../src/"
+    - testdata/
+    - tests/
+:defines:
+  :test:
+  - UNITY_EXCLUDE_STDINT_H
+  - UNITY_EXCLUDE_LIMITS_H
+  - UNITY_INCLUDE_DOUBLE
+  - UNITY_SUPPORT_TEST_CASES
+  - UNITY_INT_WIDTH=32
+  - UNITY_LONG_WIDTH=32

test/targets/gcc_64.yml

@@ -1,50 +1,46 @@
-compiler:
+---
-  path: gcc
-  source_path:     '../src/'
-  unit_tests_path: &unit_tests_path 'tests/'
-  build_path:      &build_path 'build/'
-  options:
-    - '-c'
-    - '-m64'
-    - '-Wall'
-    - '-Wno-address'
-    - '-std=c99'
-    - '-pedantic'
-  includes:
-    prefix: '-I'
-    items:
-      - 'src/'
-      - '../src/'
-      - 'testdata/'
-      - *unit_tests_path
-  defines:
-    prefix: '-D'
-    items:
-      - UNITY_EXCLUDE_STDINT_H
-      - UNITY_EXCLUDE_LIMITS_H
-      - UNITY_INCLUDE_DOUBLE
-      - UNITY_SUPPORT_TEST_CASES
-      - UNITY_SUPPORT_64
-      - UNITY_INT_WIDTH=32
-      - UNITY_LONG_WIDTH=64
-  object_files:
-    prefix: '-o'
-    extension: '.o'
-    destination: *build_path
-linker:
-  path: gcc
-  options:
-    - -lm
-    - '-m64'
-  includes:
-    prefix: '-I'
-  object_files:
-    path: *build_path
-    extension: '.o'
-  bin_files:
-    prefix: '-o'
-    extension: '.exe'
-    destination: *build_path
 colour: true
 :unity:
   :plugins: []
+:tools:
+  :test_compiler:
+    :name: compiler
+    :executable: gcc
+    :arguments:
+    - "-c"
+    - "-m64"
+    - "-Wall"
+    - "-Wno-address"
+    - "-std=c99"
+    - "-pedantic"
+    - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE'
+    - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR'
+    - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR"
+    - "${1}"
+    - "-o ${2}"
+  :test_linker:
+    :name: linker
+    :executable: gcc
+    :arguments:
+    - "${1}"
+    - "-lm"
+    - "-m64"
+    - "-o ${2}"
+:extension:
+  :object: ".o"
+  :executable: ".exe"
+:paths:
+  :test:
+    - src/
+    - "../src/"
+    - testdata/
+    - tests/
+:defines:
+  :test:
+  - UNITY_EXCLUDE_STDINT_H
+  - UNITY_EXCLUDE_LIMITS_H
+  - UNITY_INCLUDE_DOUBLE
+  - UNITY_SUPPORT_TEST_CASES
+  - UNITY_SUPPORT_64
+  - UNITY_INT_WIDTH=32
+  - UNITY_LONG_WIDTH=64

test/targets/gcc_auto_limits.yml

@@ -1,47 +1,43 @@
-compiler:
+---
-  path: gcc
-  source_path:     '../src/'
-  unit_tests_path: &unit_tests_path 'tests/'
-  build_path:      &build_path 'build/'
-  options:
-    - '-c'
-    - '-m64'
-    - '-Wall'
-    - '-Wno-address'
-    - '-std=c99'
-    - '-pedantic'
-  includes:
-    prefix: '-I'
-    items:
-      - 'src/'
-      - '../src/'
-      - 'testdata/'
-      - *unit_tests_path
-  defines:
-    prefix: '-D'
-    items:
-      - UNITY_EXCLUDE_STDINT_H
-      - UNITY_INCLUDE_DOUBLE
-      - UNITY_SUPPORT_TEST_CASES
-      - UNITY_SUPPORT_64
-  object_files:
-    prefix: '-o'
-    extension: '.o'
-    destination: *build_path
-linker:
-  path: gcc
-  options:
-    - -lm
-    - '-m64'
-  includes:
-    prefix: '-I'
-  object_files:
-    path: *build_path
-    extension: '.o'
-  bin_files:
-    prefix: '-o'
-    extension: '.exe'
-    destination: *build_path
 colour: true
 :unity:
   :plugins: []
+:tools:
+  :test_compiler:
+    :name: compiler
+    :executable: gcc
+    :arguments:
+    - "-c"
+    - "-m64"
+    - "-Wall"
+    - "-Wno-address"
+    - "-std=c99"
+    - "-pedantic"
+    - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE'
+    - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR'
+    - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR"
+    - "${1}"
+    - "-o ${2}"
+  :test_linker:
+    :name: linker
+    :executable: gcc
+    :arguments:
+    - "${1}"
+    - "-lm"
+    - "-m64"
+    - "-o ${2}"
+:extension:
+  :object: ".o"
+  :executable: ".exe"
+:paths:
+  :test:
+    - src/
+    - "../src/"
+    - testdata/
+    - tests/
+:defines:
+  :test:
+  - UNITY_EXCLUDE_STDINT_H
+  - UNITY_INCLUDE_DOUBLE
+  - UNITY_SUPPORT_TEST_CASES
+  - UNITY_SUPPORT_64

test/targets/gcc_auto_stdint.yml

@@ -1,59 +1,55 @@
-compiler:
+---
-  path: gcc
-  source_path:     '../src/'
-  unit_tests_path: &unit_tests_path 'tests/'
-  build_path:      &build_path 'build/'
-  options:
-    - '-c'
-    - '-m64'
-    - '-Wall'
-    - '-Wno-address'
-    - '-std=c99'
-    - '-pedantic'
-    - '-Wextra'
-    - '-Werror'
-    - '-Wpointer-arith'
-    - '-Wcast-align'
-    - '-Wwrite-strings'
-    - '-Wswitch-default'
-    - '-Wunreachable-code'
-    - '-Winit-self'
-    - '-Wmissing-field-initializers'
-    - '-Wno-unknown-pragmas'
-    - '-Wstrict-prototypes'
-    - '-Wundef'
-    - '-Wold-style-definition'
-  includes:
-    prefix: '-I'
-    items:
-      - 'src/'
-      - '../src/'
-      - 'testdata/'
-      - *unit_tests_path
-  defines:
-    prefix: '-D'
-    items:
-      - UNITY_INCLUDE_DOUBLE
-      - UNITY_SUPPORT_TEST_CASES
-      - UNITY_SUPPORT_64
-  object_files:
-    prefix: '-o'
-    extension: '.o'
-    destination: *build_path
-linker:
-  path: gcc
-  options:
-    - -lm
-    - '-m64'
-  includes:
-    prefix: '-I'
-  object_files:
-    path: *build_path
-    extension: '.o'
-  bin_files:
-    prefix: '-o'
-    extension: '.exe'
-    destination: *build_path
 colour: true
 :unity:
   :plugins: []
+:tools:
+  :test_compiler:
+    :name: compiler
+    :executable: gcc
+    :arguments:
+    - "-c"
+    - "-m64"
+    - "-Wall"
+    - "-Wno-address"
+    - "-std=c99"
+    - "-pedantic"
+    - "-Wextra"
+    - "-Werror"
+    - "-Wpointer-arith"
+    - "-Wcast-align"
+    - "-Wwrite-strings"
+    - "-Wswitch-default"
+    - "-Wunreachable-code"
+    - "-Winit-self"
+    - "-Wmissing-field-initializers"
+    - "-Wno-unknown-pragmas"
+    - "-Wstrict-prototypes"
+    - "-Wundef"
+    - "-Wold-style-definition"
+    - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE'
+    - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR'
+    - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR"
+    - "${1}"
+    - "-o ${2}"
+  :test_linker:
+    :name: linker
+    :executable: gcc
+    :arguments:
+    - "${1}"
+    - "-lm"
+    - "-m64"
+    - "-o ${2}"
+:extension:
+  :object: ".o"
+  :executable: ".exe"
+:paths:
+  :test:
+    - src/
+    - "../src/"
+    - testdata/
+    - tests/
+:defines:
+  :test:
+  - UNITY_INCLUDE_DOUBLE
+  - UNITY_SUPPORT_TEST_CASES
+  - UNITY_SUPPORT_64

test/targets/gcc_manual_math.yml

@@ -1,47 +1,43 @@
-compiler:
+---
-  path: gcc
-  source_path:     '../src/'
-  unit_tests_path: &unit_tests_path 'tests/'
-  build_path:      &build_path 'build/'
-  options:
-    - '-c'
-    - '-m64'
-    - '-Wall'
-    - '-Wno-address'
-    - '-std=c99'
-    - '-pedantic'
-  includes:
-    prefix: '-I'
-    items:
-      - 'src/'
-      - '../src/'
-      - 'testdata/'
-      - *unit_tests_path
-  defines:
-    prefix: '-D'
-    items:
-      - UNITY_EXCLUDE_MATH_H
-      - UNITY_INCLUDE_DOUBLE
-      - UNITY_SUPPORT_TEST_CASES
-      - UNITY_SUPPORT_64
-  object_files:
-    prefix: '-o'
-    extension: '.o'
-    destination: *build_path
-linker:
-  path: gcc
-  options:
-    - -lm
-    - '-m64'
-  includes:
-    prefix: '-I'
-  object_files:
-    path: *build_path
-    extension: '.o'
-  bin_files:
-    prefix: '-o'
-    extension: '.exe'
-    destination: *build_path
 colour: true
 :unity:
   :plugins: []
+:tools:
+  :test_compiler:
+    :name: compiler
+    :executable: gcc
+    :arguments:
+    - "-c"
+    - "-m64"
+    - "-Wall"
+    - "-Wno-address"
+    - "-std=c99"
+    - "-pedantic"
+    - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE'
+    - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR'
+    - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR"
+    - "${1}"
+    - "-o ${2}"
+  :test_linker:
+    :name: linker
+    :executable: gcc
+    :arguments:
+    - "${1}"
+    - "-lm"
+    - "-m64"
+    - "-o ${2}"
+:extension:
+  :object: ".o"
+  :executable: ".exe"
+:paths:
+  :test:
+    - src/
+    - "../src/"
+    - testdata/
+    - tests/
+:defines:
+  :test:
+  - UNITY_EXCLUDE_MATH_H
+  - UNITY_INCLUDE_DOUBLE
+  - UNITY_SUPPORT_TEST_CASES
+  - UNITY_SUPPORT_64

test/targets/hitech_picc18.yml

@@ -1,101 +1,91 @@
-# rumor has it that this yaml file works for the standard edition of the
+---
-# hitech PICC18 compiler, but not the pro version.
-#
-compiler:
-  path: cd build && picc18
-  source_path: '..\src\'
-  unit_tests_path: &unit_tests_path 'tests\'
-  build_path: &build_path 'build\'
-  options:
-    - --chip=18F87J10
-    - --ide=hitide
-    - --q #quiet please
-    - --asmlist
-    - --codeoffset=0
-    - --emi=wordwrite # External memory interface protocol
-    - --warn=0 # allow all normal warning messages
-    - --errors=10 # Number of errors before aborting compile
-    - --char=unsigned
-    - -Bl # Large memory model
-    - -G # generate symbol file
-    - --cp=16 # 16-bit pointers
-    - --double=24
-    - -N255 # 255-char symbol names
-    - --opt=none # Do not use any compiler optimziations
-    - -c # compile only
-    - -M
-  includes:
-    prefix: '-I'
-    items:
-      - 'c:/Projects/NexGen/Prototypes/CMockTest/src/'
-      - 'c:/Projects/NexGen/Prototypes/CMockTest/mocks/'
-      - 'c:/CMock/src/'
-      - 'c:/CMock/examples/src/'
-      - 'c:/CMock/vendor/unity/src/'
-      - 'c:/CMock/vendor/unity/examples/helper/'
-      - *unit_tests_path
-  defines:
-    prefix: '-D'
-    items:
-      - UNITY_INT_WIDTH=16
-      - UNITY_POINTER_WIDTH=16
-      - CMOCK_MEM_STATIC
-      - CMOCK_MEM_SIZE=3000
-      - UNITY_SUPPORT_TEST_CASES
-      - _PICC18
-  object_files:
-    # prefix: '-O' # Hi-Tech doesn't want a prefix. They key off of filename .extensions, instead
-    extension: '.obj'
-    destination: *build_path
-
-linker:
-  path: cd build && picc18
-  options:
-    - --chip=18F87J10
-    - --ide=hitide
-    - --cp=24 # 24-bit pointers. Is this needed for linker??
-    - --double=24 # Is this needed for linker??
-    - -Lw # Scan the pic87*w.lib in the lib/ of the compiler installation directory
-    - --summary=mem,file # info listing
-    - --summary=+psect
-    - --summary=+hex
-    - --output=+intel
-    - --output=+mcof
-    - --runtime=+init # Directs startup code to copy idata, ibigdata and ifardata psects from ROM to RAM.
-    - --runtime=+clear # Directs startup code to clear bss, bigbss, rbss and farbss psects
-    - --runtime=+clib # link in the c-runtime
-    - --runtime=+keep # Keep the generated startup src after its obj is linked
-    - -G # Generate src-level symbol file
-    - -MIWasTheLastToBuild.map
-    - --warn=0 # allow all normal warning messages
-    - -Bl # Large memory model (probably not needed for linking)
-  includes:
-    prefix: '-I'
-    object_files:
-      path: *build_path
-      extension: '.obj'
-    bin_files:
-      prefix: '-O'
-      extension: '.hex'
-      destination: *build_path
-
-simulator:
-  path:
-  pre_support:
-    - 'java -client -jar ' # note space
-    - ['C:\Program Files\HI-TECH Software\HI-TIDE\3.15\lib\', 'simpic18.jar']
-    - 18F87J10
-  post_support:
-
 :cmock:
   :plugins: []
   :includes:
-    - Types.h
+  - Types.h
   :suite_teardown: |
     if (num_failures)
       _FAILED_TEST();
     else
       _PASSED_TESTS();
     return 0;
-
 colour: true
+:tools:
+  :test_compiler:
+    :name: compiler
+    :executable: cd build && picc18
+    :arguments:
+    - "--chip=18F87J10"
+    - "--ide=hitide"
+    - "--q"
+    - "--asmlist"
+    - "--codeoffset=0"
+    - "--emi=wordwrite"
+    - "--warn=0"
+    - "--errors=10"
+    - "--char=unsigned"
+    - "-Bl"
+    - "-G"
+    - "--cp=16"
+    - "--double=24"
+    - "-N255"
+    - "--opt=none"
+    - "-c"
+    - "-M"
+    - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE'
+    - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR'
+    - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR"
+    - "${1}"
+    - " ${2}"
+  :test_linker:
+    :name: linker
+    :executable: cd build && picc18
+    :arguments:
+    - "${1}"
+    - "--chip=18F87J10"
+    - "--ide=hitide"
+    - "--cp=24"
+    - "--double=24"
+    - "-Lw"
+    - "--summary=mem,file"
+    - "--summary=+psect"
+    - "--summary=+hex"
+    - "--output=+intel"
+    - "--output=+mcof"
+    - "--runtime=+init"
+    - "--runtime=+clear"
+    - "--runtime=+clib"
+    - "--runtime=+keep"
+    - "-G"
+    - "-MIWasTheLastToBuild.map"
+    - "--warn=0"
+    - "-Bl"
+    - "-O ${2}"
+  :test_fixture:
+    :name: simulator
+    :executable: 'java -client -jar '
+    :arguments:
+    - - C:\Program Files\HI-TECH Software\HI-TIDE\3.15\lib\
+      - simpic18.jar
+    - 18F87J10
+    - "${1}"
+:extension:
+  :object: ".obj"
+  :executable: ".hex"
+:paths:
+  :test:
+    - c:/Projects/NexGen/Prototypes/CMockTest/src/
+    - c:/Projects/NexGen/Prototypes/CMockTest/mocks/
+    - c:/CMock/src/
+    - c:/CMock/examples/src/
+    - c:/CMock/vendor/unity/src/
+    - c:/CMock/vendor/unity/examples/helper/
+    - tests\
+:defines:
+  :test:
+  - UNITY_INT_WIDTH=16
+  - UNITY_POINTER_WIDTH=16
+  - CMOCK_MEM_STATIC
+  - CMOCK_MEM_SIZE=3000
+  - UNITY_SUPPORT_TEST_CASES
+  - _PICC18