Bump Version

This reverts commit cdfb7e092c.

.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

@@ -0,0 +1,31 @@
+*           text=auto
+
+# These files are text and should be normalized (convert crlf to lf)
+*.rb        text
+*.test      text
+*.c         text
+*.cpp       text
+*.h         text
+*.txt       text
+*.yml       text
+*.s79       text
+*.bat       text
+*.xcl       text
+*.inc       text
+*.info      text
+*.md        text
+makefile    text
+rakefile    text
+meson.build text
+
+
+#These files are binary and should not be normalized
+*.doc       binary
+*.odt       binary
+*.pdf       binary
+*.ewd       binary
+*.eww       binary
+*.dni       binary
+*.wsdt      binary
+*.dbgdt     binary
+*.mac       binary

.gitignore

@@ -1 +1,11 @@
-build/
+build/
+builddir/
+test/sandbox
+.DS_Store
+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

.travis.yml

@@ -0,0 +1,26 @@
+sudo: required
+language: ruby c
+
+matrix:
+ include:
+    #- os: osx
+    #  compiler: clang
+    #  osx_image: xcode7.3
+    - os: linux
+      dist: trusty
+      rvm: "2.4"
+      compiler: gcc
+    - os: linux
+      dist: xenial
+      rvm: "2.7"
+      compiler: clang
+
+before_install:
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install --assume-yes --quiet gcc-multilib; fi
+
+install:
+  - gem install rspec
+  - gem install rubocop -v 0.57.2
+
+script:
+  - cd test && rake ci

CMakeLists.txt

@@ -0,0 +1,133 @@
+###################################################################################
+#                                                                                 #
+# 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."
+)
+
+# 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
+)
+
+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}>
+)
+
+set(${PROJECT_NAME}_PUBLIC_HEADERS src/unity.h
+                                   src/unity_internals.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
+        $<$<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>
+        $<$<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>
+        -Wall
+        -Werror
+)
+
+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

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <year> 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,191 @@
+Unity Test API
+==============
+
+[![Unity Build Status](https://api.travis-ci.org/ThrowTheSwitch/Unity.png?branch=master)](https://travis-ci.org/ThrowTheSwitch/Unity)
+__Copyright (c) 2007 - 2020 Unity Project by Mike Karlesky, Mark VanderVoord, and Greg Williams__
+
+Getting Started
+===============
+The [docs](docs/) folder contains a [getting started guide](docs/UnityGettingStartedGuide.md)
+and much more tips about using Unity. 
+
+Unity Assertion Summary
+=======================
+For the full list, see [UnityAssertionsReference.md](docs/UnityAssertionsReference.md).
+
+Basic Validity Tests
+--------------------
+
+    TEST_ASSERT_TRUE(condition)
+
+Evaluates whatever code is in condition and fails if it evaluates to false
+
+    TEST_ASSERT_FALSE(condition)
+
+Evaluates whatever code is in condition and fails if it evaluates to true
+
+    TEST_ASSERT(condition)
+
+Another way of calling `TEST_ASSERT_TRUE`
+
+    TEST_ASSERT_UNLESS(condition)
+
+Another way of calling `TEST_ASSERT_FALSE`
+
+    TEST_FAIL()
+    TEST_FAIL_MESSAGE(message)
+
+This test is automatically marked as a failure. The message is output stating why.
+
+Numerical Assertions: Integers
+------------------------------
+
+    TEST_ASSERT_EQUAL_INT(expected, actual)
+    TEST_ASSERT_EQUAL_INT8(expected, actual)
+    TEST_ASSERT_EQUAL_INT16(expected, actual)
+    TEST_ASSERT_EQUAL_INT32(expected, actual)
+    TEST_ASSERT_EQUAL_INT64(expected, actual)
+
+Compare two integers for equality and display errors as signed integers. A cast will be performed
+to your natural integer size so often this can just be used. When you need to specify the exact size,
+like when comparing arrays, you can use a specific version:
+
+    TEST_ASSERT_EQUAL_UINT(expected, actual)
+    TEST_ASSERT_EQUAL_UINT8(expected, actual)
+    TEST_ASSERT_EQUAL_UINT16(expected, actual)
+    TEST_ASSERT_EQUAL_UINT32(expected, actual)
+    TEST_ASSERT_EQUAL_UINT64(expected, actual)
+
+Compare two integers for equality and display errors as unsigned integers. Like INT, there are
+variants for different sizes also.
+
+    TEST_ASSERT_EQUAL_HEX(expected, actual)
+    TEST_ASSERT_EQUAL_HEX8(expected, actual)
+    TEST_ASSERT_EQUAL_HEX16(expected, actual)
+    TEST_ASSERT_EQUAL_HEX32(expected, actual)
+    TEST_ASSERT_EQUAL_HEX64(expected, actual)
+
+Compares two integers for equality and display errors as hexadecimal. Like the other integer comparisons,
+you can specify the size... here the size will also effect how many nibbles are shown (for example, `HEX16`
+will show 4 nibbles).
+
+    TEST_ASSERT_EQUAL(expected, actual)
+
+Another way of calling TEST_ASSERT_EQUAL_INT
+
+    TEST_ASSERT_INT_WITHIN(delta, expected, actual)
+
+Asserts that the actual value is within plus or minus delta of the expected value. This also comes in
+size specific variants.
+
+
+    TEST_ASSERT_GREATER_THAN(threshold, actual)
+
+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.
+
+
+Arrays
+------
+
+    _ARRAY
+
+You can append `_ARRAY` to any of these macros to make an array comparison of that type.  Here you will
+need to care a bit more about the actual size of the value being checked.  You will also specify an
+additional argument which is the number of elements to compare.  For example:
+
+    TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, elements)
+
+    _EACH_EQUAL
+
+Another array comparison option is to check that EVERY element of an array is equal to a single expected
+value. You do this by specifying the EACH_EQUAL macro. For example:
+
+    TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, elements)
+
+Numerical Assertions: Bitwise
+-----------------------------
+
+    TEST_ASSERT_BITS(mask, expected, actual)
+
+Use an integer mask to specify which bits should be compared between two other integers.  High bits in the mask are compared, low bits ignored.
+
+    TEST_ASSERT_BITS_HIGH(mask, actual)
+
+Use an integer mask to specify which bits should be inspected to determine if they are all set high.  High bits in the mask are compared, low bits ignored.
+
+    TEST_ASSERT_BITS_LOW(mask, actual)
+
+Use an integer mask to specify which bits should be inspected to determine if they are all set low.  High bits in the mask are compared, low bits ignored.
+
+    TEST_ASSERT_BIT_HIGH(bit, actual)
+
+Test a single bit and verify that it is high.  The bit is specified 0-31 for a 32-bit integer.
+
+    TEST_ASSERT_BIT_LOW(bit, actual)
+
+Test a single bit and verify that it is low.  The bit is specified 0-31 for a 32-bit integer.
+
+Numerical Assertions: Floats
+----------------------------
+
+    TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual)
+
+Asserts that the actual value is within plus or minus delta of the expected value.
+
+    TEST_ASSERT_EQUAL_FLOAT(expected, actual)
+    TEST_ASSERT_EQUAL_DOUBLE(expected, actual)
+
+Asserts that two floating point values are "equal" within a small % delta of the expected value.
+
+String Assertions
+-----------------
+
+    TEST_ASSERT_EQUAL_STRING(expected, actual)
+
+Compare two null-terminate strings.  Fail if any character is different or if the lengths are different.
+
+    TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len)
+
+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.
+
+    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.
+
+Pointer Assertions
+------------------
+
+Most pointer operations can be performed by simply using the integer comparisons above. However, a couple of special cases are added for clarity.
+
+    TEST_ASSERT_NULL(pointer)
+
+Fails if the pointer is not equal to NULL
+
+    TEST_ASSERT_NOT_NULL(pointer)
+
+Fails if the pointer is equal to NULL
+
+Memory Assertions
+-----------------
+
+    TEST_ASSERT_EQUAL_MEMORY(expected, actual, len)
+
+Compare two blocks of memory.  This is a good generic assertion for types that can't be coerced into acting like
+standard types... but since it's a memory compare, you have to be careful that your data types are packed.
+
+\_MESSAGE
+---------
+
+you can append \_MESSAGE to any of the macros to make them take an additional argument.  This argument
+is a string that will be printed at the end of the failure strings.  This is useful for specifying more
+information about the problem.
+

auto/colour_prompt.rb

@@ -2,93 +2,118 @@
 #   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]
-# ========================================== 
+# ==========================================
 
-if RUBY_PLATFORM =~/(win|w)32$/
+if RUBY_PLATFORM =~ /(win|w)32$/
-	begin
+  begin
-		require 'Win32API'
+    require 'Win32API'
-	rescue LoadError
+  rescue LoadError
-		puts "ERROR! \"Win32API\" library not found"
+    puts 'ERROR! "Win32API" library not found'
-		puts "\"Win32API\" is required for colour on a windows machine"
+    puts '"Win32API" is required for colour on a windows machine'
-		puts "  try => \"gem install Win32API\" on the command line"
+    puts '  try => "gem install Win32API" on the command line'
-		puts
+    puts
-	end
+  end
-	# puts
+  # puts
   # puts 'Windows Environment Detected...'
-	# puts 'Win32API Library Found.'
+  # puts 'Win32API Library Found.'
-	# puts
+  # puts
 end
 
 class ColourCommandLine
   def initialize
-    if RUBY_PLATFORM =~/(win|w)32$/  
+    return unless RUBY_PLATFORM =~ /(win|w)32$/
-      get_std_handle = Win32API.new("kernel32", "GetStdHandle", ['L'], 'L')
+
-      @set_console_txt_attrb =
+    get_std_handle = Win32API.new('kernel32', 'GetStdHandle', ['L'], 'L')
-      Win32API.new("kernel32","SetConsoleTextAttribute",['L','N'], 'I')
+    @set_console_txt_attrb =
-      @hout = get_std_handle.call(-11)
+      Win32API.new('kernel32', 'SetConsoleTextAttribute', %w[L N], 'I')
+    @hout = get_std_handle.call(-11)
+  end
+
+  def change_to(new_colour)
+    if RUBY_PLATFORM =~ /(win|w)32$/
+      @set_console_txt_attrb.call(@hout, win32_colour(new_colour))
+    else
+      "\033[30;#{posix_colour(new_colour)};22m"
     end
   end
-  
+
-  def change_to(new_colour)
-    if RUBY_PLATFORM =~/(win|w)32$/
-      @set_console_txt_attrb.call(@hout,self.win32_colour(new_colour))
-    else
-	  	"\033[30;#{posix_colour(new_colour)};22m"
-	 	end
-  end
-  
   def win32_colour(colour)
     case colour
-      when :black then 0  
+    when :black then 0
-      when :dark_blue then 1
+    when :dark_blue then 1
-      when :dark_green then 2
+    when :dark_green then 2
-      when :dark_cyan then 3
+    when :dark_cyan then 3
-      when :dark_red then 4
+    when :dark_red then 4
-      when :dark_purple then 5
+    when :dark_purple then 5
-      when :dark_yellow, :narrative then 6
+    when :dark_yellow, :narrative then 6
-      when :default_white, :default, :dark_white then 7
+    when :default_white, :default, :dark_white then 7
-      when :silver then 8
+    when :silver then 8
-      when :blue then 9
+    when :blue then 9
-      when :green, :success then 10
+    when :green, :success then 10
-      when :cyan, :output then 11
+    when :cyan, :output then 11
-      when :red, :failure then 12
+    when :red, :failure then 12
-      when :purple then 13
+    when :purple then 13
-      when :yellow then 14
+    when :yellow then 14
-      when :white then 15
+    when :white then 15
-      else
+    else
-        0
+      0
     end
   end
-	
+
-	def posix_colour(colour)
+  def posix_colour(colour)
-	  case colour
+    # ANSI Escape Codes - Foreground colors
-      when :black then 30  
+    # | Code | Color                     |
-      when :red, :failure then 31
+    # | 39   | Default foreground color  |
-      when :green, :success then 32
+    # | 30   | Black                     |
-			when :yellow then 33
+    # | 31   | Red                       |
-      when :blue, :narrative then 34
+    # | 32   | Green                     |
-      when :purple, :magenta then 35
+    # | 33   | Yellow                    |
-      when :cyan, :output then 36
+    # | 34   | Blue                      |
-      when :white, :default_white, :default then 37
+    # | 35   | Magenta                   |
-      else
+    # | 36   | Cyan                      |
-        30
+    # | 37   | Light gray                |
+    # | 90   | Dark gray                 |
+    # | 91   | Light red                 |
+    # | 92   | Light green               |
+    # | 93   | Light yellow              |
+    # | 94   | Light blue                |
+    # | 95   | Light magenta             |
+    # | 96   | Light cyan                |
+    # | 97   | White                     |
+
+    case colour
+    when :black then 30
+    when :red, :failure then 31
+    when :green, :success then 32
+    when :yellow then 33
+    when :blue, :narrative then 34
+    when :purple, :magenta then 35
+    when :cyan, :output then 36
+    when :white, :default_white then 37
+    when :default then 39
+    else
+      39
     end
   end
-	
+
   def out_c(mode, colour, str)
     case RUBY_PLATFORM
-			when /(win|w)32$/
+    when /(win|w)32$/
-			  change_to(colour)
+      change_to(colour)
-				 $stdout.puts str if mode == :puts
+      $stdout.puts str if mode == :puts
-				 $stdout.print str if mode == :print
+      $stdout.print str if mode == :print
-			  change_to(:default_white)
+      change_to(:default_white)
-			else
+    else
-				$stdout.puts("#{change_to(colour)}#{str}\033[0m") if mode == :puts
+      $stdout.puts("#{change_to(colour)}#{str}\033[0m") if mode == :puts
-				$stdout.print("#{change_to(colour)}#{str}\033[0m") if mode == :print
+      $stdout.print("#{change_to(colour)}#{str}\033[0m") if mode == :print
-		end			
+    end
   end
-end # ColourCommandLine
+end
 
-def colour_puts(role,str)  ColourCommandLine.new.out_c(:puts, role, str)  end
+def colour_puts(role, str)
-def colour_print(role,str) ColourCommandLine.new.out_c(:print, role, str) end
+  ColourCommandLine.new.out_c(:puts, role, str)
+end
 
+def colour_print(role, str)
+  ColourCommandLine.new.out_c(:print, role, str)
+end

auto/colour_reporter.rb

@@ -1,39 +1,39 @@
-# ==========================================
+# ==========================================
-#   Unity Project - A Test Framework for C
+#   Unity Project - A Test Framework for C
-#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-#   [Released under MIT License. Please refer to license.txt for details]
+#   [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
+$colour_output = true
-
+
-def report(message)
+def report(message)
-  if not $colour_output
+  if !$colour_output
-    $stdout.puts(message)
+    $stdout.puts(message)
-  else
+  else
-    message = message.join('\n') if (message.class == Array)
+    message = message.join('\n') if message.class == Array
-    message.each_line do |line|
+    message.each_line do |line|
-      line.chomp!
+      line.chomp!
-      colour = case(line)
+      colour = case line
-        when /(?:total\s+)?tests:?\s+(\d+)\s+(?:total\s+)?failures:?\s+\d+\s+Ignored:?/i
+               when /(?:total\s+)?tests:?\s+(\d+)\s+(?:total\s+)?failures:?\s+\d+\s+Ignored:?/i
-          ($1.to_i == 0) ? :green : :red
+                 Regexp.last_match(1).to_i.zero? ? :green : :red
-        when /PASS/
+               when /PASS/
-          :green
+                 :green
-        when /^OK$/
+               when /^OK$/
-          :green
+                 :green
-        when /(?:FAIL|ERROR)/
+               when /(?:FAIL|ERROR)/
-          :red
+                 :red
-        when /IGNORE/
+               when /IGNORE/
-          :yellow
+                 :yellow
-        when /^(?:Creating|Compiling|Linking)/
+               when /^(?:Creating|Compiling|Linking)/
-          :white
+                 :white
-        else
+               else
-          :silver
+                 :silver
-      end
+               end
-      colour_puts(colour, line)
+      colour_puts(colour, line)
-    end
+    end
-  end
+  end
-  $stdout.flush
+  $stdout.flush
-  $stderr.flush
+  $stderr.flush
-end
+end

auto/generate_config.yml

@@ -1,36 +1,36 @@
-#this is a sample configuration file for generate_module
+#this is a sample configuration file for generate_module
-#you would use it by calling generate_module with the -ygenerate_config.yml option
+#you would use it by calling generate_module with the -ygenerate_config.yml option
-#files like this are useful for customizing generate_module to your environment
+#files like this are useful for customizing generate_module to your environment
-:generate_module:
+:generate_module:
-  :defaults:
+  :defaults:
-    #these defaults are used in place of any missing options at the command line
+    #these defaults are used in place of any missing options at the command line
-    :path_src: ../src/
+    :path_src: ../src/
-    :path_inc: ../src/
+    :path_inc: ../src/
-    :path_tst: ../test/
+    :path_tst: ../test/
-    :update_svn: true
+    :update_svn: true
-  :includes:
+  :includes:
-    #use [] for no additional includes, otherwise list the includes on separate lines
+    #use [] for no additional includes, otherwise list the includes on separate lines
-    :src:
+    :src:
-      - Defs.h
+      - Defs.h
-      - Board.h
+      - Board.h
-    :inc: []
+    :inc: []
-    :tst:
+    :tst:
-      - Defs.h
+      - Defs.h
-      - Board.h
+      - Board.h
-      - Exception.h
+      - Exception.h
-  :boilerplates: 
+  :boilerplates: 
-    #these are inserted at the top of generated files.
+    #these are inserted at the top of generated files.
-    #just comment out or remove if not desired.
+    #just comment out or remove if not desired.
-    #use %1$s where you would like the file name to appear (path/extension not included)
+    #use %1$s where you would like the file name to appear (path/extension not included)
-    :src: |
+    :src: |
-      //-------------------------------------------
+      //-------------------------------------------
-      // %1$s.c
+      // %1$s.c
-      //-------------------------------------------
+      //-------------------------------------------
-    :inc: |
+    :inc: |
-      //-------------------------------------------
+      //-------------------------------------------
-      // %1$s.h
+      // %1$s.h
-      //-------------------------------------------
+      //-------------------------------------------
-    :tst: |
+    :tst: |
-      //-------------------------------------------
+      //-------------------------------------------
-      // Test%1$s.c : Units tests for %1$s.c
+      // Test%1$s.c : Units tests for %1$s.c
-      //-------------------------------------------
+      //-------------------------------------------

auto/generate_module.rb

@@ -1,202 +1,312 @@
-# ==========================================
+# ==========================================
-#   Unity Project - A Test Framework for C
+#   Unity Project - A Test Framework for C
-#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-#   [Released under MIT License. Please refer to license.txt for details]
+#   [Released under MIT License. Please refer to license.txt for details]
-# ========================================== 
+# ==========================================
-
+
-# This script creates all the files with start code necessary for a new module.
+# This script creates all the files with start code necessary for a new module.
-# A simple module only requires a source file, header file, and test file.
+# A simple module only requires a source file, header file, and test file.
-# Triad modules require a source, header, and test file for each triad type (like model, conductor, and hardware).
+# Triad modules require a source, header, and test file for each triad type (like model, conductor, and hardware).
-
+
-require 'rubygems'
+require 'rubygems'
-require 'fileutils'
+require 'fileutils'
-
+require 'pathname'
-HERE = File.expand_path(File.dirname(__FILE__)) + '/'
+
-
+# TEMPLATE_TST
-#help text when requested
+TEMPLATE_TST ||= '#include "unity.h"
-HELP_TEXT = [ "\nGENERATE MODULE\n-------- ------",
+
-              "\nUsage: ruby generate_module [options] module_name",
+%2$s#include "%1$s.h"
-              "  -i\"include\" sets the path to output headers to 'include' (DEFAULT ../src)",
+
-              "  -s\"../src\"  sets the path to output source to '../src'   (DEFAULT ../src)",
+void setUp(void)
-              "  -t\"C:/test\" sets the path to output source to 'C:/test'  (DEFAULT ../test)",
+{
-              "  -p\"MCH\"     sets the output pattern to MCH.",
+}
-              "              dh  - driver hardware.",
+
-              "              dih - driver interrupt hardware.",
+void tearDown(void)
-              "              mch - model conductor hardware.",
+{
-              "              mvp - model view presenter.",
+}
-              "              src - just a single source module. (DEFAULT)",
+
-              "  -d          destroy module instead of creating it.",
+void test_%4$s_NeedToImplement(void)
-              "  -u          update subversion too (requires subversion command line)",
+{
-              "  -y\"my.yml\"  selects a different yaml config file for module generation",
+    TEST_IGNORE_MESSAGE("Need to Implement %1$s");
-              "" ].join("\n")
+}
-
+'.freeze
-#Built in patterns
+
-PATTERNS = { 'src' => {''         => { :inc => [] } },
+# TEMPLATE_SRC
-             'dh'  => {'Driver'   => { :inc => ['%1$sHardware.h'] }, 
+TEMPLATE_SRC ||= '%2$s#include "%1$s.h"
-                       'Hardware' => { :inc => [] } 
+'.freeze
-                      },
+
-             'dih' => {'Driver'   => { :inc => ['%1$sHardware.h', '%1$sInterrupt.h'] }, 
+# TEMPLATE_INC
-                       'Interrupt'=> { :inc => ['%1$sHardware.h'] },
+TEMPLATE_INC ||= '#ifndef %3$s_H
-                       'Hardware' => { :inc => [] } 
+#define %3$s_H
-                      },
+%2$s
-             'mch' => {'Model'    => { :inc => [] }, 
+
-                       'Conductor'=> { :inc => ['%1$sModel.h', '%1$sHardware.h'] },
+#endif // %3$s_H
-                       'Hardware' => { :inc => [] } 
+'.freeze
-                      },
+
-             'mvp' => {'Model'    => { :inc => [] }, 
+class UnityModuleGenerator
-                       'Presenter'=> { :inc => ['%1$sModel.h', '%1$sView.h'] },
+  ############################
-                       'View'     => { :inc => [] } 
+  def initialize(options = nil)
-                      }
+    @options = UnityModuleGenerator.default_options
-           }
+    case options
-
+    when NilClass then @options
-#TEMPLATE_TST
+    when String   then @options.merge!(UnityModuleGenerator.grab_config(options))
-TEMPLATE_TST = %q[#include "unity.h"
+    when Hash     then @options.merge!(options)
-%2$s#include "%1$s.h"
+    else raise 'If you specify arguments, it should be a filename or a hash of options'
-
+    end
-void setUp(void)
+
-{
+    # Create default file paths if none were provided
-}
+    @options[:path_src] = "#{__dir__}/../src/"   if @options[:path_src].nil?
-
+    @options[:path_inc] = @options[:path_src]    if @options[:path_inc].nil?
-void tearDown(void)
+    @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
-void test_%1$s_NeedToImplement(void)
+
-{
+    # Built in patterns
-    TEST_IGNORE();
+    @patterns = {
-}
+      'src'  =>  {
-]
+        '' =>  { inc: [] }
-
+      },
-#TEMPLATE_SRC
+      'test' =>  {
-TEMPLATE_SRC = %q[%2$s#include "%1$s.h"
+        '' =>  { inc: [] }
-]
+      },
-
+      'dh'   =>  {
-#TEMPLATE_INC
+        'Driver'    =>  { inc: [create_filename('%1$s', 'Hardware.h')] },
-TEMPLATE_INC = %q[#ifndef _%3$s_H
+        'Hardware'  =>  { inc: [] }
-#define _%3$s_H%2$s
+      },
-
+      'dih'  =>  {
-#endif // _%3$s_H
+        'Driver'    =>  { inc: [create_filename('%1$s', 'Hardware.h'), create_filename('%1$s', 'Interrupt.h')] },
-]
+        'Interrupt' =>  { inc: [create_filename('%1$s', 'Hardware.h')] },
-
+        'Hardware'  =>  { inc: [] }
-# Parse the command line parameters.
+      },
-ARGV.each do |arg|
+      'mch'  =>  {
-  case(arg)
+        'Model'     =>  { inc: [] },
-    when /^-d/      then @destroy = true
+        'Conductor' =>  { inc: [create_filename('%1$s', 'Model.h'), create_filename('%1$s', 'Hardware.h')] },
-    when /^-u/      then @update_svn = true
+        'Hardware'  =>  { inc: [] }
-    when /^-p(\w+)/ then @pattern = $1
+      },
-    when /^-s(.+)/  then @path_src = $1
+      'mvp'  =>  {
-    when /^-i(.+)/  then @path_inc = $1
+        'Model'     =>  { inc: [] },
-    when /^-t(.+)/  then @path_tst = $1
+        'Presenter' =>  { inc: [create_filename('%1$s', 'Model.h'), create_filename('%1$s', 'View.h')] },
-    when /^-y(.+)/  then @yaml_config = $1
+        'View'      =>  { inc: [] }
-    when /^(\w+)/
+      }
-      raise "ERROR: You can't have more than one Module name specified!" unless @module_name.nil?
+    }
-      @module_name = arg
+  end
-    when /^-(h|-help)/ 
+
-      puts HELP_TEXT
+  ############################
-      exit
+  def self.default_options
-    else
+    {
-      raise "ERROR: Unknown option specified '#{arg}'"
+      pattern: 'src',
-  end
+      includes: {
-end
+        src: [],
-raise "ERROR: You must have a Module name specified! (use option -h for help)" if @module_name.nil?
+        inc: [],
-
+        tst: []
-#load yaml file if one was requested
+      },
-if @yaml_config
+      update_svn: false,
-  require 'yaml'
+      boilerplates: {},
-  cfg = YAML.load_file(HERE + @yaml_config)[:generate_module]
+      test_prefix: 'Test',
-  @path_src     = cfg[:defaults][:path_src]   if @path_src.nil?
+      mock_prefix: 'Mock'
-  @path_inc     = cfg[:defaults][:path_inc]   if @path_inc.nil?
+    }
-  @path_tst     = cfg[:defaults][:path_tst]   if @path_tst.nil?
+  end
-  @update_svn   = cfg[:defaults][:update_svn] if @update_svn.nil?
+
-  @extra_inc    = cfg[:includes]
+  ############################
-  @boilerplates = cfg[:boilerplates]
+  def self.grab_config(config_file)
-else
+    options = default_options
-  @boilerplates = {}
+    unless config_file.nil? || config_file.empty?
-end
+      require 'yaml'
-
+      yaml_guts = YAML.load_file(config_file)
-# Create default file paths if none were provided
+      options.merge!(yaml_guts[:unity] || yaml_guts[:cmock])
-@path_src = HERE + "../src/"  if @path_src.nil?
+      raise "No :unity or :cmock section found in #{config_file}" unless options
-@path_inc = @path_src         if @path_inc.nil?
+    end
-@path_tst = HERE + "../test/" if @path_tst.nil?
+    options
-@path_src += '/'              unless (@path_src[-1] == 47)
+  end
-@path_inc += '/'              unless (@path_inc[-1] == 47)
+
-@path_tst += '/'              unless (@path_tst[-1] == 47)
+  ############################
-@pattern  = 'src'             if @pattern.nil?
+  def files_to_operate_on(module_name, pattern = nil)
-@includes = { :src => [], :inc => [], :tst => [] }
+    # strip any leading path information from the module name and save for later
-@includes.merge!(@extra_inc) unless @extra_inc.nil?
+    subfolder = File.dirname(module_name)
-
+    module_name = File.basename(module_name)
-#create triad definition
+
-TRIAD = [ { :ext => '.c', :path => @path_src,        :template => TEMPLATE_SRC, :inc => :src, :boilerplate => @boilerplates[:src] }, 
+    # create triad definition
-          { :ext => '.h', :path => @path_inc,        :template => TEMPLATE_INC, :inc => :inc, :boilerplate => @boilerplates[:inc] },
+    prefix = @options[:test_prefix] || 'Test'
-          { :ext => '.c', :path => @path_tst+'Test', :template => TEMPLATE_TST, :inc => :tst, :boilerplate => @boilerplates[:tst] },
+    triad = [{ ext: '.c', path: @options[:path_src], prefix: '', template: TEMPLATE_SRC, inc: :src, boilerplate: @options[:boilerplates][:src] },
-        ]
+             { ext: '.h', path: @options[:path_inc], prefix: '',     template: TEMPLATE_INC, inc: :inc, boilerplate: @options[:boilerplates][:inc] },
-
+             { ext: '.c', path: @options[:path_tst], prefix: prefix, template: TEMPLATE_TST, inc: :tst, boilerplate: @options[:boilerplates][:tst] }]
-#prepare the pattern for use
+
-@patterns = PATTERNS[@pattern.downcase]
+    # prepare the pattern for use
-raise "ERROR: The design pattern specified isn't one that I recognize!" if @patterns.nil?
+    pattern = (pattern || @options[:pattern] || 'src').downcase
-
+    patterns = @patterns[pattern]
-# Assemble the path/names of the files we need to work with.
+    raise "ERROR: The design pattern '#{pattern}' specified isn't one that I recognize!" if patterns.nil?
-files = []
+
-TRIAD.each do |triad|
+    # single file patterns (currently just 'test') can reject the other parts of the triad
-  @patterns.each_pair do |pattern_file, pattern_traits|
+    triad.select! { |v| v[:inc] == :tst } if pattern == 'test'
-    files << {
+
-      :path => "#{triad[:path]}#{@module_name}#{pattern_file}#{triad[:ext]}",
+    # Assemble the path/names of the files we need to work with.
-      :name => "#{@module_name}#{pattern_file}",
+    files = []
-      :template => triad[:template],
+    triad.each do |cfg|
-      :boilerplate => triad[:boilerplate],
+      patterns.each_pair do |pattern_file, pattern_traits|
-      :includes => case(triad[:inc])
+        submodule_name = create_filename(module_name, pattern_file)
-                     when :src then @includes[:src] | pattern_traits[:inc].map{|f| f % [@module_name]}
+        filename = cfg[:prefix] + submodule_name + cfg[:ext]
-                     when :inc then @includes[:inc]
+        files << {
-                     when :tst then @includes[:tst] | pattern_traits[:inc].map{|f| "Mock#{f}"% [@module_name]}
+          path: (Pathname.new("#{cfg[:path]}#{subfolder}") + filename).cleanpath,
-                   end
+          name: submodule_name,
-    }
+          template: cfg[:template],
-  end
+          boilerplate: cfg[:boilerplate],
-end
+          includes: case (cfg[:inc])
-
+                    when :src then (@options[:includes][:src] || []) | (pattern_traits[:inc].map { |f| format(f, module_name) })
-# destroy files if that was what was requested
+                    when :inc then (@options[:includes][:inc] || [])
-if @destroy
+                    when :tst then (@options[:includes][:tst] || []) | (pattern_traits[:inc].map { |f| format("#{@options[:mock_prefix]}#{f}", module_name) })
-  files.each do |filespec|
+                    end
-    file = filespec[:path]
+        }
-    if File.exist?(file)
+      end
-      if @update_svn
+    end
-        `svn delete \"#{file}\" --force` 
+
-        puts "File #{file} deleted and removed from source control"
+    files
-      else
+  end
-        FileUtils.remove(file)
+
-        puts "File #{file} deleted"
+  ############################
-      end
+  def neutralize_filename(name, start_cap=true)
-    else
+    return name if name.empty?
-      puts "File #{file} does not exist so cannot be removed."
+    name = name.split(/(?:\s+|_|(?=[A-Z][a-z]))|(?<=[a-z])(?=[A-Z])/).map{|v|v.capitalize}.join('_')
-    end
+    if start_cap
-  end
+      return name
-  puts "Destroy Complete"
+    else
-  exit
+      return name[0].downcase + name[1..-1]
-end
+    end
-
+  end
-#Abort if any module already exists
+
-files.each do |file|
+  ############################
-  raise "ERROR: File #{file[:name]} already exists. Exiting." if File.exist?(file[:path])
+  def create_filename(part1, part2 = '')
-end
+    name = part2.empty? ? part1 : part1 + '_' + part2
-
+    case (@options[:naming])
-# Create Source Modules
+    when 'bumpy' then neutralize_filename(name,false).gsub('_','')
-files.each_with_index do |file, i|
+    when 'camel' then neutralize_filename(name).gsub('_','')
-  File.open(file[:path], 'w') do |f|
+    when 'snake' then neutralize_filename(name).downcase
-    f.write(file[:boilerplate] % [file[:name]]) unless file[:boilerplate].nil?
+    when 'caps'  then neutralize_filename(name).upcase
-    f.write(file[:template] % [ file[:name], 
+    else              name
-                                file[:includes].map{|f| "#include \"#{f}\"\n"}.join, 
+    end
-                                file[:name].upcase ]
+  end
-           )
+
-  end
+  ############################
-  if (@update_svn)
+  def generate(module_name, pattern = nil)
-    `svn add \"#{file[:path]}\"` 
+    files = files_to_operate_on(module_name, pattern)
-    if $?.exitstatus == 0
+
-      puts "File #{file[:path]} created and added to source control"
+    # Abort if all of the module files already exist
-    else
+    all_files_exist = true
-      puts "File #{file[:path]} created but FAILED adding to source control!"
+    files.each do |file|
-    end
+      all_files_exist = false unless File.exist?(file[:path])
-  else
+    end
-    puts "File #{file[:path]} created"
+    raise "ERROR: File #{files[0][:name]} already exists. Exiting." if all_files_exist
-  end
+
-end
+    # Create Source Modules
-
+    files.each_with_index do |file, _i|
-puts 'Generate Complete'
+      # If this file already exists, don't overwrite it.
+      if File.exist?(file[:path])
+        puts "File #{file[:path]} already exists!"
+        next
+      end
+      # Create the path first if necessary.
+      FileUtils.mkdir_p(File.dirname(file[:path]), verbose: false)
+      File.open(file[:path], 'w') do |f|
+        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.gsub(/-/, '_'),
+                                   file[:name].gsub(/-/, '_')])
+      end
+      if @options[:update_svn]
+        `svn add \"#{file[:path]}\"`
+        if $!.exitstatus.zero?
+          puts "File #{file[:path]} created and added to source control"
+        else
+          puts "File #{file[:path]} created but FAILED adding to source control!"
+        end
+      else
+        puts "File #{file[:path]} created"
+      end
+    end
+    puts 'Generate Complete'
+  end
+
+  ############################
+  def destroy(module_name, pattern = nil)
+    files_to_operate_on(module_name, pattern).each do |filespec|
+      file = filespec[:path]
+      if File.exist?(file)
+        if @options[:update_svn]
+          `svn delete \"#{file}\" --force`
+          puts "File #{file} deleted and removed from source control"
+        else
+          FileUtils.remove(file)
+          puts "File #{file} deleted"
+        end
+      else
+        puts "File #{file} does not exist so cannot be removed."
+      end
+    end
+    puts 'Destroy Complete'
+  end
+end
+
+############################
+# Handle As Command Line If Called That Way
+if $0 == __FILE__
+  destroy = false
+  options = {}
+  module_name = nil
+
+  # Parse the command line parameters.
+  ARGV.each do |arg|
+    case arg
+    when /^-d/            then destroy = true
+    when /^-u/            then options[:update_svn] = true
+    when /^-p\"?(\w+)\"?/ then options[:pattern] = Regexp.last_match(1)
+    when /^-s\"?(.+)\"?/  then options[:path_src] = Regexp.last_match(1)
+    when /^-i\"?(.+)\"?/  then options[:path_inc] = Regexp.last_match(1)
+    when /^-t\"?(.+)\"?/  then options[:path_tst] = Regexp.last_match(1)
+    when /^-n\"?(.+)\"?/  then options[:naming] = Regexp.last_match(1)
+    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
+    else
+      raise "ERROR: Unknown option specified '#{arg}'"
+    end
+  end
+
+  unless ARGV[0]
+    puts ["\nGENERATE MODULE\n-------- ------",
+          "\nUsage: ruby generate_module [options] module_name",
+          "  -i\"include\" sets the path to output headers to 'include' (DEFAULT ../src)",
+          "  -s\"../src\"  sets the path to output source to '../src'   (DEFAULT ../src)",
+          "  -t\"C:/test\" sets the path to output source to 'C:/test'  (DEFAULT ../test)",
+          '  -p"MCH"     sets the output pattern to MCH.',
+          '              dh   - driver hardware.',
+          '              dih  - driver interrupt hardware.',
+          '              mch  - model conductor hardware.',
+          '              mvp  - model view presenter.',
+          '              src  - just a source module, header and test. (DEFAULT)',
+          '              test - just a test file.',
+          '  -d          destroy module instead of creating it.',
+          '  -n"camel"   sets the file naming convention.',
+          '              bumpy - BumpyCaseFilenames.',
+          '              camel - camelCaseFilenames.',
+          '              snake - snake_case_filenames.',
+          '              caps  - CAPS_CASE_FILENAMES.',
+          '  -u          update subversion too (requires subversion command line)',
+          '  -y"my.yml"  selects a different yaml config file for module generation',
+          ''].join("\n")
+    exit
+  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
+    UnityModuleGenerator.new(options).generate(module_name)
+  end
+
+end

auto/generate_test_runner.rb

@@ -1,313 +1,511 @@
-# ==========================================
+# ==========================================
-#   Unity Project - A Test Framework for C
+#   Unity Project - A Test Framework for C
-#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-#   [Released under MIT License. Please refer to license.txt for details]
+#   [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)
-class UnityTestRunnerGenerator
+    @options = UnityTestRunnerGenerator.default_options
-
+    case options
-  def initialize(options = nil)
+    when NilClass
-    @options = { :includes => [], :plugins => [], :framework => :unity }
+      @options
-    case(options)
+    when String
-      when NilClass then @options
+      @options.merge!(UnityTestRunnerGenerator.grab_config(options))
-      when String   then @options.merge!(UnityTestRunnerGenerator.grab_config(options))
+    when Hash
-      when Hash     then @options.merge!(options)
+      # Check if some of these have been specified
-      else          raise "If you specify arguments, it should be a filename or a hash of options"
+      @options[:has_setup] = !options[:setup_name].nil?
-    end
+      @options[:has_teardown] = !options[:teardown_name].nil?
-  end
+      @options[:has_suite_setup] = !options[:suite_setup].nil?
-  
+      @options[:has_suite_teardown] = !options[:suite_teardown].nil?
-  def self.grab_config(config_file)
+      @options.merge!(options)
-    options = { :includes => [], :plugins => [], :framework => :unity }
+    else
-    unless (config_file.nil? or config_file.empty?)
+      raise 'If you specify arguments, it should be a filename or a hash of options'
-      require 'yaml'
+    end
-      yaml_guts = YAML.load_file(config_file)
+    require_relative 'type_sanitizer'
-      options.merge!(yaml_guts[:unity] ? yaml_guts[:unity] : yaml_guts[:cmock])
+  end
-      raise "No :unity or :cmock section found in #{config_file}" unless options
+
-    end
+  def self.default_options
-    return(options)
+    {
-  end
+      includes: [],
-
+      defines: [],
-  def run(input_file, output_file, options=nil)
+      plugins: [],
-    tests = []
+      framework: :unity,
-    testfile_includes = []
+      test_prefix: 'test|spec|should',
-    used_mocks = []
+      mock_prefix: 'Mock',
-    
+      mock_suffix: '',
-    @options.merge!(options) unless options.nil?
+      setup_name: 'setUp',
-    module_name = File.basename(input_file)
+      teardown_name: 'tearDown',
-    
+      test_reset_name: 'resetTest',
-    #pull required data from source file
+      test_verify_name: 'verifyTest',
-    File.open(input_file, 'r') do |input|
+      main_name: 'main', # set to :auto to automatically generate each time
-      tests               = find_tests(input)
+      main_export_decl: '',
-      testfile_includes   = find_includes(input)
+      cmdline_args: false,
-      used_mocks          = find_mocks(testfile_includes)
+      omit_begin_end: false,
-    end
+      use_param_tests: false,
-
+      include_extensions: '(?:hpp|hh|H|h)',
-    #build runner file
+      source_extensions: '(?:cpp|cc|ino|C|c)'
-    generate(input_file, output_file, tests, used_mocks)
+    }
-    
+  end
-    #determine which files were used to return them
+
-    all_files_used = [input_file, output_file]
+  def self.grab_config(config_file)
-    all_files_used += testfile_includes.map {|filename| filename + '.c'} unless testfile_includes.empty?
+    options = default_options
-    all_files_used += @options[:includes] unless @options[:includes].empty?
+    unless config_file.nil? || config_file.empty?
-    return all_files_used.uniq
+      require 'yaml'
-  end
+      yaml_guts = YAML.load_file(config_file)
-  
+      options.merge!(yaml_guts[:unity] || yaml_guts[:cmock])
-  def generate(input_file, output_file, tests, used_mocks)
+      raise "No :unity or :cmock section found in #{config_file}" unless options
-    File.open(output_file, 'w') do |output|
+    end
-      create_header(output, used_mocks)
+    options
-      create_externs(output, tests, used_mocks)
+  end
-      create_mock_management(output, used_mocks)
+
-      create_suite_setup_and_teardown(output)
+  def run(input_file, output_file, options = nil)
-      create_reset(output, used_mocks)
+    @options.merge!(options) unless options.nil?
-      create_main(output, input_file, tests)
+
-    end
+    # pull required data from source file
-  end
+    source = File.read(input_file)
-  
+    source = source.force_encoding('ISO-8859-1').encode('utf-8', replace: nil)
-  def find_tests(input_file)
+    tests = find_tests(source)
-    tests_raw = []
+    headers = find_includes(source)
-    tests_args = []
+    testfile_includes = (headers[:local] + headers[:system])
-    tests_and_line_numbers = []
+    used_mocks = find_mocks(testfile_includes)
-    
+    testfile_includes = (testfile_includes - used_mocks)
-    input_file.rewind
+    testfile_includes.delete_if { |inc| inc =~ /(unity|cmock)/ }
-    source_raw = input_file.read
+    find_setup_and_teardown(source)
-    source_scrubbed = source_raw.gsub(/\/\/.*$/, '')           # remove line comments
+
-    source_scrubbed = source_scrubbed.gsub(/\/\*.*?\*\//m, '') # remove block comments
+    # build runner file
-    lines = source_scrubbed.split(/(^\s*\#.*$)                 # Treat preprocessor directives as a logical line
+    generate(input_file, output_file, tests, used_mocks, testfile_includes)
-                              | (;|\{|\}) /x)                  # Match ;, {, and } as end of lines
+
-
+    # determine which files were used to return them
-    lines.each_with_index do |line, index|
+    all_files_used = [input_file, output_file]
-      #find tests
+    all_files_used += testfile_includes.map { |filename| filename + '.c' } unless testfile_includes.empty?
-      if line =~ /^((?:\s*TEST_CASE\s*\(.*?\)\s*)*)\s*void\s+(test.*?)\s*\(\s*(.*)\s*\)/
+    all_files_used += @options[:includes] unless @options[:includes].empty?
-        arguments = $1
+    all_files_used += headers[:linkonly] unless headers[:linkonly].empty?
-        name = $2
+    all_files_used.uniq
-        call = $3
+  end
-        args = nil
+
-        if (@options[:use_param_tests] and !arguments.empty?)
+  def generate(input_file, output_file, tests, used_mocks, testfile_includes)
-          args = []
+    File.open(output_file, 'w') do |output|
-          arguments.scan(/\s*TEST_CASE\s*\((.*)\)\s*$/) {|a| args << a[0]}
+      create_header(output, used_mocks, testfile_includes)
-        end
+      create_externs(output, tests, used_mocks)
-        tests_and_line_numbers << { :test => name, :args => args, :call => call, :line_number => 0 }
+      create_mock_management(output, used_mocks)
-        tests_args = []
+      create_setup(output)
-      end
+      create_teardown(output)
-    end
+      create_suite_setup(output)
-
+      create_suite_teardown(output)
-    #determine line numbers and create tests to run
+      create_reset(output)
-    source_lines = source_raw.split("\n")
+      create_run_test(output) unless tests.empty?
-    source_index = 0;
+      create_args_wrappers(output, tests)
-    tests_and_line_numbers.size.times do |i|
+      create_main(output, input_file, tests, used_mocks)
-      source_lines[source_index..-1].each_with_index do |line, index|
+    end
-        if (line =~ /#{tests_and_line_numbers[i][:test]}/)
+
-          source_index += index
+    return unless @options[:header_file] && !@options[:header_file].empty?
-          tests_and_line_numbers[i][:line_number] = source_index + 1
+
-          break
+    File.open(@options[:header_file], 'w') do |output|
-        end
+      create_h_file(output, @options[:header_file], tests, testfile_includes, used_mocks)
-      end
+    end
-    end
+  end
-    
+
-    return tests_and_line_numbers
+  def find_tests(source)
-  end
+    tests_and_line_numbers = []
-
+
-  def find_includes(input_file)
+    # contains characters which will be substituted from within strings, doing
-    input_file.rewind
+    # 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
-    #read in file
+    substring_subs = { '{' => '@co@', '}' => '@cc@', ';' => '@ss@', '/' => '@fs@' }
-    source = input_file.read
+    substring_re = Regexp.union(substring_subs.keys)
-    
+    substring_unsubs = substring_subs.invert                   # the inverse map will be used to fix the strings afterwords
-    #remove comments (block and line, in three steps to ensure correct precedence)
+    substring_unsubs['@quote@'] = '\\"'
-    source.gsub!(/\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '')  # remove line comments that comment out the start of blocks
+    substring_unsubs['@apos@'] = '\\\''
-    source.gsub!(/\/\*.*?\*\//m, '')                     # remove block comments 
+    substring_unre = Regexp.union(substring_unsubs.keys)
-    source.gsub!(/\/\/.*$/, '')                          # remove line comments (all that remain)
+    source_scrubbed = source.clone
-    
+    source_scrubbed = source_scrubbed.gsub(/\\"/, '@quote@')   # hide escaped quotes to allow capture of the full string/char
-    #parse out includes
+    source_scrubbed = source_scrubbed.gsub(/\\'/, '@apos@')    # hide escaped apostrophes to allow capture of the full string/char
-    return source.scan(/^\s*#include\s+\"\s*(.+)\.[hH]\s*\"/).flatten
+    source_scrubbed = source_scrubbed.gsub(/("[^"\n]*")|('[^'\n]*')/) { |s| s.gsub(substring_re, substring_subs) } # temporarily hide problematic characters within strings
-  end
+    source_scrubbed = source_scrubbed.gsub(/\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '')  # remove line comments that comment out the start of blocks
-  
+    source_scrubbed = source_scrubbed.gsub(/\/\*.*?\*\//m, '')                     # remove block comments
-  def find_mocks(includes)
+    source_scrubbed = source_scrubbed.gsub(/\/\/.*$/, '')                          # remove line comments (all that remain)
-    mock_headers = []
+    lines = source_scrubbed.split(/(^\s*\#.*$) | (;|\{|\}) /x)                     # Treat preprocessor directives as a logical line. Match ;, {, and } as end of lines
-    includes.each do |include_file|
+                           .map { |line| line.gsub(substring_unre, substring_unsubs) } # unhide the problematic characters previously removed
-      mock_headers << File.basename(include_file) if (include_file =~ /^mock/i)
+
-    end
+    lines.each_with_index do |line, _index|
-    return mock_headers  
+      # find tests
-  end
+      next unless line =~ /^((?:\s*(?:TEST_CASE|TEST_RANGE)\s*\(.*?\)\s*)*)\s*void\s+((?:#{@options[:test_prefix]}).*)\s*\(\s*(.*)\s*\)/m
-  
+
-  def create_header(output, mocks)
+      arguments = Regexp.last_match(1)
-    output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */')
+      name = Regexp.last_match(2)
-    create_runtest(output, mocks)
+      call = Regexp.last_match(3)
-    output.puts("\n//=======Automagically Detected Files To Include=====")
+      params = Regexp.last_match(4)
-    output.puts("#include \"#{@options[:framework].to_s}.h\"")
+      args = nil
-    output.puts('#include "cmock.h"') unless (mocks.empty?)
+
-    @options[:includes].flatten.uniq.compact.each do |inc|
+      if @options[:use_param_tests] && !arguments.empty?
-      output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h','')}.h\""}")
+        args = []
-    end
+        arguments.scan(/\s*TEST_CASE\s*\((.*)\)\s*$/) { |a| args << a[0] }
-    output.puts('#include <setjmp.h>')
+
-    output.puts('#include <stdio.h>')
+        arguments.scan(/\s*TEST_RANGE\s*\((.*)\)\s*$/).flatten.each do |range_str|
-    output.puts('#include "CException.h"') if @options[:plugins].include?(:cexception)
+          args += range_str.scan(/\[(-?\d+.?\d*), *(-?\d+.?\d*), *(-?\d+.?\d*)\]/).map do |arg_values_str|
-    mocks.each do |mock|
+            arg_values_str.map do |arg_value_str|
-      output.puts("#include \"#{mock.gsub('.h','')}.h\"")
+              arg_value_str.include?('.') ? arg_value_str.to_f : arg_value_str.to_i
-    end
+            end
-    if @options[:enforce_strict_ordering]
+          end.map do |arg_values|
-      output.puts('')    
+            (arg_values[0]..arg_values[1]).step(arg_values[2]).to_a
-      output.puts('int GlobalExpectCount;') 
+          end.reduce do |result, arg_range_expanded|
-      output.puts('int GlobalVerifyOrder;') 
+            result.product(arg_range_expanded)
-      output.puts('char* GlobalOrderError;') 
+          end.map do |arg_combinations|
-    end
+            arg_combinations.flatten.join(', ')
-  end
+          end
-  
+        end
-  def create_externs(output, tests, mocks)
+      end
-    output.puts("\n//=======External Functions This Runner Calls=====")
+
-    output.puts("extern void setUp(void);")
+      tests_and_line_numbers << { test: name, args: args, call: call, params: params, line_number: 0 }
-    output.puts("extern void tearDown(void);")
+    end
-    tests.each do |test|
+
-      output.puts("extern void #{test[:test]}(#{test[:call] || 'void'});")
+    tests_and_line_numbers.uniq! { |v| v[:test] }
-    end
+
-    output.puts('')
+    # determine line numbers and create tests to run
-  end
+    source_lines = source.split("\n")
-  
+    source_index = 0
-  def create_mock_management(output, mocks)
+    tests_and_line_numbers.size.times do |i|
-    unless (mocks.empty?)
+      source_lines[source_index..-1].each_with_index do |line, index|
-      output.puts("\n//=======Mock Management=====")
+        next unless line =~ /\s+#{tests_and_line_numbers[i][:test]}(?:\s|\()/
-      output.puts("static void CMock_Init(void)")
+
-      output.puts("{")
+        source_index += index
-      if @options[:enforce_strict_ordering]
+        tests_and_line_numbers[i][:line_number] = source_index + 1
-        output.puts("  GlobalExpectCount = 0;")
+        break
-        output.puts("  GlobalVerifyOrder = 0;") 
+      end
-        output.puts("  GlobalOrderError = NULL;") 
+    end
-      end
+
-      mocks.each do |mock|
+    tests_and_line_numbers
-        output.puts("  #{mock}_Init();")
+  end
-      end
+
-      output.puts("}\n")
+  def find_includes(source)
-
+    # remove comments (block and line, in three steps to ensure correct precedence)
-      output.puts("static void CMock_Verify(void)")
+    source.gsub!(/\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '')  # remove line comments that comment out the start of blocks
-      output.puts("{")
+    source.gsub!(/\/\*.*?\*\//m, '')                     # remove block comments
-      mocks.each do |mock|
+    source.gsub!(/\/\/.*$/, '')                          # remove line comments (all that remain)
-        output.puts("  #{mock}_Verify();")
+
-      end
+    # parse out includes
-      output.puts("}\n")
+    includes = {
-
+      local: source.scan(/^\s*#include\s+\"\s*(.+\.#{@options[:include_extensions]})\s*\"/).flatten,
-      output.puts("static void CMock_Destroy(void)")
+      system: source.scan(/^\s*#include\s+<\s*(.+)\s*>/).flatten.map { |inc| "<#{inc}>" },
-      output.puts("{")
+      linkonly: source.scan(/^TEST_FILE\(\s*\"\s*(.+\.#{@options[:source_extensions]})\s*\"/).flatten
-      mocks.each do |mock|
+    }
-        output.puts("  #{mock}_Destroy();")
+    includes
-      end
+  end
-      output.puts("}\n")
+
-    end
+  def find_mocks(includes)
-  end
+    mock_headers = []
-  
+    includes.each do |include_path|
-  def create_suite_setup_and_teardown(output)
+      include_file = File.basename(include_path)
-    unless (@options[:suite_setup].nil?)
+      mock_headers << include_path if include_file =~ /^#{@options[:mock_prefix]}.*#{@options[:mock_suffix]}$/i
-      output.puts("\n//=======Suite Setup=====")
+    end
-      output.puts("static int suite_setup(void)")
+    mock_headers
-      output.puts("{")
+  end
-      output.puts(@options[:suite_setup])
+
-      output.puts("}")
+  def find_setup_and_teardown(source)
-    end
+    @options[:has_setup] = source =~ /void\s+#{@options[:setup_name]}\s*\(/
-    unless (@options[:suite_teardown].nil?)
+    @options[:has_teardown] = source =~ /void\s+#{@options[:teardown_name]}\s*\(/
-      output.puts("\n//=======Suite Teardown=====")
+    @options[:has_suite_setup] ||= (source =~ /void\s+suiteSetUp\s*\(/)
-      output.puts("static int suite_teardown(int num_failures)")
+    @options[:has_suite_teardown] ||= (source =~ /void\s+suiteTearDown\s*\(/)
-      output.puts("{")
+  end
-      output.puts(@options[:suite_teardown])
+
-      output.puts("}")
+  def create_header(output, mocks, testfile_includes = [])
-    end
+    output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */')
-  end
+    output.puts("\n/*=======Automagically Detected Files To Include=====*/")
-  
+    output.puts("#include \"#{@options[:framework]}.h\"")
-  def create_runtest(output, used_mocks)
+    output.puts('#include "cmock.h"') unless mocks.empty?
-    cexception = @options[:plugins].include? :cexception
+    if @options[:defines] && !@options[:defines].empty?
-    va_args1   = @options[:use_param_tests] ? ', ...' : ''
+      @options[:defines].each { |d| output.puts("#ifndef #{d}\n#define #{d}\n#endif /* #{d} */") }
-    va_args2   = @options[:use_param_tests] ? '__VA_ARGS__' : ''
+    end
-    output.puts("\n//=======Test Runner Used To Run Each Test Below=====")
+    if @options[:header_file] && !@options[:header_file].empty?
-    output.puts("#define RUN_TEST_NO_ARGS") if @options[:use_param_tests] 
+      output.puts("#include \"#{File.basename(@options[:header_file])}\"")
-    output.puts("#define RUN_TEST(TestFunc, TestLineNum#{va_args1}) \\")
+    else
-    output.puts("{ \\")
+      @options[:includes].flatten.uniq.compact.each do |inc|
-    output.puts("  Unity.CurrentTestName = #TestFunc#{va_args2.empty? ? '' : " \"(\" ##{va_args2} \")\""}; \\")
+        output.puts("#include #{inc.include?('<') ? inc : "\"#{inc}\""}")
-    output.puts("  Unity.CurrentTestLineNumber = TestLineNum; \\")
+      end
-    output.puts("  Unity.NumberOfTests++; \\")
+      testfile_includes.each do |inc|
-    output.puts("  if (TEST_PROTECT()) \\")
+        output.puts("#include #{inc.include?('<') ? inc : "\"#{inc}\""}")
-    output.puts("  { \\")
+      end
-    output.puts("    CEXCEPTION_T e; \\") if cexception
+    end
-    output.puts("    Try { \\") if cexception
+    mocks.each do |mock|
-    output.puts("      CMock_Init(); \\") unless (used_mocks.empty?) 
+      output.puts("#include \"#{mock}\"")
-    output.puts("      setUp(); \\")
+    end
-    output.puts("      TestFunc(#{va_args2}); \\")
+    output.puts('#include "CException.h"') if @options[:plugins].include?(:cexception)
-    output.puts("      CMock_Verify(); \\") unless (used_mocks.empty?)
+
-    output.puts("    } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, \"Unhandled Exception!\"); } \\") if cexception
+    return unless @options[:enforce_strict_ordering]
-    output.puts("  } \\")
+
-    output.puts("  CMock_Destroy(); \\") unless (used_mocks.empty?)
+    output.puts('')
-    output.puts("  if (TEST_PROTECT() && !TEST_IS_IGNORED) \\")
+    output.puts('int GlobalExpectCount;')
-    output.puts("  { \\")
+    output.puts('int GlobalVerifyOrder;')
-    output.puts("    tearDown(); \\")
+    output.puts('char* GlobalOrderError;')
-    output.puts("  } \\")
+  end
-    output.puts("  UnityConcludeTest(); \\")
+
-    output.puts("}\n")
+  def create_externs(output, tests, _mocks)
-  end
+    output.puts("\n/*=======External Functions This Runner Calls=====*/")
-  
+    output.puts("extern void #{@options[:setup_name]}(void);")
-  def create_reset(output, used_mocks)
+    output.puts("extern void #{@options[:teardown_name]}(void);")
-    output.puts("\n//=======Test Reset Option=====")
+    output.puts("\n#ifdef __cplusplus\nextern \"C\"\n{\n#endif") if @options[:externc]
-    output.puts("void resetTest()")
+    tests.each do |test|
-    output.puts("{")
+      output.puts("extern void #{test[:test]}(#{test[:call] || 'void'});")
-    output.puts("  CMock_Verify();") unless (used_mocks.empty?)
+    end
-    output.puts("  CMock_Destroy();") unless (used_mocks.empty?)
+    output.puts("#ifdef __cplusplus\n}\n#endif") if @options[:externc]
-    output.puts("  tearDown();")
+    output.puts('')
-    output.puts("  CMock_Init();") unless (used_mocks.empty?) 
+  end
-    output.puts("  setUp();")
+
-    output.puts("}")
+  def create_mock_management(output, mock_headers)
-  end
+    output.puts("\n/*=======Mock Management=====*/")
-  
+    output.puts('static void CMock_Init(void)')
-  def create_main(output, filename, tests)
+    output.puts('{')
-    output.puts("\n\n//=======MAIN=====")
+
-    output.puts("int main(void)")
+    if @options[:enforce_strict_ordering]
-    output.puts("{")
+      output.puts('  GlobalExpectCount = 0;')
-    output.puts("  suite_setup();") unless @options[:suite_setup].nil?
+      output.puts('  GlobalVerifyOrder = 0;')
-    output.puts("  Unity.TestFile = \"#{filename}\";")
+      output.puts('  GlobalOrderError = NULL;')
-    output.puts("  UnityBegin();")
+    end
-    if (@options[:use_param_tests])
+
-      tests.each do |test|
+    mocks = mock_headers.map { |mock| File.basename(mock, '.*') }
-        if ((test[:args].nil?) or (test[:args].empty?))
+    mocks.each do |mock|
-          output.puts("  RUN_TEST(#{test[:test]}, #{test[:line_number]}, RUN_TEST_NO_ARGS);")
+      mock_clean = TypeSanitizer.sanitize_c_identifier(mock)
-        else
+      output.puts("  #{mock_clean}_Init();")
-          test[:args].each {|args| output.puts("  RUN_TEST(#{test[:test]}, #{test[:line_number]}, #{args});")}
+    end
-        end
+    output.puts("}\n")
-      end
+
-    else
+    output.puts('static void CMock_Verify(void)')
-        tests.each { |test| output.puts("  RUN_TEST(#{test[:test]}, #{test[:line_number]});") }
+    output.puts('{')
-    end
+    mocks.each do |mock|
-    output.puts()
+      mock_clean = TypeSanitizer.sanitize_c_identifier(mock)
-    output.puts("  return #{@options[:suite_teardown].nil? ? "" : "suite_teardown"}(UnityEnd());")
+      output.puts("  #{mock_clean}_Verify();")
-    output.puts("}")
+    end
-  end
+    output.puts("}\n")
-end
+
-
+    output.puts('static void CMock_Destroy(void)')
-
+    output.puts('{')
-if ($0 == __FILE__)
+    mocks.each do |mock|
-  options = { :includes => [] }
+      mock_clean = TypeSanitizer.sanitize_c_identifier(mock)
-  yaml_file = nil
+      output.puts("  #{mock_clean}_Destroy();")
-  
+    end
-  #parse out all the options first
+    output.puts("}\n")
-  ARGV.reject! do |arg| 
+  end
-    case(arg)
+
-      when '-cexception' 
+  def create_setup(output)
-        options[:plugins] = [:cexception]; true
+    return if @options[:has_setup]
-      when /\.*\.yml/
+
-        options = UnityTestRunnerGenerator.grab_config(arg); true
+    output.puts("\n/*=======Setup (stub)=====*/")
-      else false
+    output.puts("void #{@options[:setup_name]}(void) {}")
-    end
+  end
-  end     
+
-           
+  def create_teardown(output)
-  #make sure there is at least one parameter left (the input file)
+    return if @options[:has_teardown]
-  if !ARGV[0]
+
-    puts ["usage: ruby #{__FILE__} (yaml) (options) input_test_file output_test_runner (includes)",
+    output.puts("\n/*=======Teardown (stub)=====*/")
-           "  blah.yml    - will use config options in the yml file (see docs)",
+    output.puts("void #{@options[:teardown_name]}(void) {}")
-           "  -cexception - include cexception support"].join("\n")
+  end
-    exit 1
+
-  end
+  def create_suite_setup(output)
-  
+    return if @options[:suite_setup].nil?
-  #create the default test runner name if not specified
+
-  ARGV[1] = ARGV[0].gsub(".c","_Runner.c") if (!ARGV[1])
+    output.puts("\n/*=======Suite Setup=====*/")
-  
+    output.puts('void suiteSetUp(void)')
-  #everything else is an include file
+    output.puts('{')
-  options[:includes] ||= (ARGV.slice(2..-1).flatten.compact) if (ARGV.size > 2)
+    output.puts(@options[:suite_setup])
-  
+    output.puts('}')
-  UnityTestRunnerGenerator.new(options).run(ARGV[0], ARGV[1])
+  end
-end
+
+  def create_suite_teardown(output)
+    return if @options[:suite_teardown].nil?
+
+    output.puts("\n/*=======Suite Teardown=====*/")
+    output.puts('int suiteTearDown(int num_failures)')
+    output.puts('{')
+    output.puts(@options[:suite_teardown])
+    output.puts('}')
+  end
+
+  def create_reset(output)
+    output.puts("\n/*=======Test Reset Options=====*/")
+    output.puts("void #{@options[:test_reset_name]}(void);")
+    output.puts("void #{@options[:test_reset_name]}(void)")
+    output.puts('{')
+    output.puts("  #{@options[:teardown_name]}();")
+    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'
+    template = ERB.new(File.read(File.join(__dir__, 'run_test.erb')), nil, '<>')
+    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/*=======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'
+        output.puts("#{@options[:main_export_decl]} int #{main_name}(int argc, char** argv);")
+      end
+      output.puts("#{@options[:main_export_decl]} int #{main_name}(int argc, char** argv)")
+      output.puts('{')
+      output.puts('  int parse_status = UnityParseOptions(argc, argv);')
+      output.puts('  if (parse_status != 0)')
+      output.puts('  {')
+      output.puts('    if (parse_status < 0)')
+      output.puts('    {')
+      output.puts("      UnityPrint(\"#{filename.gsub('.c', '')}.\");")
+      output.puts('      UNITY_PRINT_EOL();')
+      tests.each do |test|
+        if (!@options[:use_param_tests]) || test[:args].nil? || test[:args].empty?
+          output.puts("      UnityPrint(\"  #{test[:test]}\");")
+          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
+      output.puts('      return 0;')
+      output.puts('    }')
+      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]} #{main_return} #{main_name}(void);")
+      end
+      output.puts("#{main_return} #{main_name}(void)")
+      output.puts('{')
+    end
+    output.puts('  suiteSetUp();') if @options[:has_suite_setup]
+    if @options[:omit_begin_end]
+      output.puts("  UnitySetTestFile(\"#{filename.gsub(/\\/, '\\\\\\')}\");")
+    else
+      output.puts("  UnityBegin(\"#{filename.gsub(/\\/, '\\\\\\')}\");")
+    end
+    tests.each do |test|
+      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
+    end
+    output.puts
+    output.puts('  CMock_Guts_MemFreeFinal();') unless used_mocks.empty?
+    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
+
+  def create_h_file(output, filename, tests, testfile_includes, used_mocks)
+    filename = File.basename(filename).gsub(/[-\/\\\.\,\s]/, '_').upcase
+    output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */')
+    output.puts("#ifndef _#{filename}")
+    output.puts("#define _#{filename}\n\n")
+    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}\""}")
+    end
+    testfile_includes.each do |inc|
+      output.puts("#include #{inc.include?('<') ? inc : "\"#{inc}\""}")
+    end
+    output.puts "\n"
+    tests.each do |test|
+      if test[:params].nil? || test[:params].empty?
+        output.puts("void #{test[:test]}(void);")
+      else
+        output.puts("void #{test[:test]}(#{test[:params]});")
+      end
+    end
+    output.puts("#endif\n\n")
+  end
+end
+
+if $0 == __FILE__
+  options = { includes: [] }
+
+  # parse out all the options first (these will all be removed as we go)
+  ARGV.reject! do |arg|
+    case arg
+    when '-cexception'
+      options[:plugins] = [:cexception]
+      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 /\.*\.(?:hpp|hh|H|h)$/
+      options[:includes] << arg
+      true
+    else false
+    end
+  end
+
+  # make sure there is at least one parameter left (the input file)
+  unless ARGV[0]
+    puts ["\nusage: ruby #{__FILE__} (files) (options) input_test_file (output)",
+          "\n  input_test_file         - this is the C file you want to create a runner for",
+          '  output                  - this is the name of the runner file to generate',
+          '                            defaults to (input_test_file)_Runner',
+          '  files:',
+          '    *.yml / *.yaml        - loads configuration from here in :unity or :cmock',
+          '    *.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
+
+  # create the default test runner name if not specified
+  ARGV[1] = ARGV[0].gsub('.c', '_Runner.c') unless ARGV[1]
+
+  UnityTestRunnerGenerator.new(options).run(ARGV[0], ARGV[1])
+end

auto/parse_output.rb

@@ -0,0 +1,322 @@
+#============================================================
+#  Author: John Theofanopoulos
+#  A simple parser. Takes the output files generated during the
+#  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
+#
+#    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")
+#
+#    To use this parser use the following command
+#    ruby parseOutput.rb [options] [file]
+#        options: -xml  : produce a JUnit compatible XML file
+#           file: file to scan for results
+#============================================================
+
+# Parser class for handling the input file
+class ParseOutput
+  def initialize
+    # internal data
+    @class_name_idx = 0
+    @path_delim = nil
+
+    # xml output related
+    @xml_out = false
+    @array_list = false
+
+    # current suite name and statistics
+    @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
+  def set_xml_output
+    @xml_out = true
+  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
+  end
+
+  # 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="Unity" 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)
+    @array_list.push '    <testcase classname="' + @test_suite + '" name="' + test_name + '"/>'
+  end
+
+  # Pushes xml output data to the array list, which will be written later
+  def push_xml_output_failed(test_name, reason)
+    @array_list.push '    <testcase classname="' + @test_suite + '" name="' + test_name + '">'
+    @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)
+    @array_list.push '    <testcase classname="' + @test_suite + '" name="' + test_name + '">'
+    @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)
+    # Split the path name
+    test_name = test_suite_name.split(@path_delim)
+
+    # Remove the extension and extract the base_name
+    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
+
+  # Prepares the line for verbose fixture output ("-v")
+  def prepare_fixture_line(line)
+    line = line.sub('IGNORE_TEST(', '')
+    line = line.sub('TEST(', '')
+    line = line.sub(')', ',')
+    line = line.chomp
+    array = line.split(',')
+    array.map { |x| x.to_s.lstrip.chomp }
+  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)
+    class_name = array[0]
+    test_name  = array[1]
+    test_suite_verify(class_name)
+    printf "%-40s PASS\n", test_name
+
+    push_xml_output_passed(test_name) if @xml_out
+  end
+
+  # Test was flagged as having failed so format the output.
+  # This is using the Unity fixture output and not the original Unity output.
+  def test_failed_unity_fixture(array)
+    class_name = array[0]
+    test_name  = array[1]
+    test_suite_verify(class_name)
+    reason_array = array[2].split(':')
+    reason = reason_array[-1].lstrip.chomp + ' at line: ' + reason_array[-4]
+
+    printf "%-40s FAILED\n", test_name
+
+    push_xml_output_failed(test_name, reason) if @xml_out
+  end
+
+  # Test was flagged as being ignored so format the output.
+  # 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)
+    last_item = array.length - 1
+    test_name = array[last_item - 1]
+    test_suite_verify(array[@class_name_idx])
+    printf "%-40s PASS\n", test_name
+
+    return unless @xml_out
+
+    push_xml_output_passed(test_name) if @xml_out
+  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.lstrip + ' at line: ' + array[last_item - 3]
+    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 FAILED\n", test_name
+
+    push_xml_output_failed(test_name, reason) if @xml_out
+  end
+
+  # Test was flagged as being ignored so format the output
+  def test_ignored(array)
+    last_item = array.length - 1
+    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\n", test_name
+
+    push_xml_output_ignored(test_name, reason) if @xml_out
+  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(file_name)
+    @array_list = []
+
+    puts 'Parsing file: ' + file_name
+
+    @test_passed = 0
+    @test_failed = 0
+    @test_ignored = 0
+    puts ''
+    puts '=================== RESULTS ====================='
+    puts ''
+    File.open(file_name).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
+      #
+      # 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.
+      next unless (line_array.size >= 4) || (line.start_with? 'TEST(') || (line.start_with? 'IGNORE_TEST(')
+
+      # check if the output is fixture output (with verbose flag "-v")
+      if (line.start_with? 'TEST(') || (line.start_with? 'IGNORE_TEST(')
+        line_array = prepare_fixture_line(line)
+        if line.include? ' PASS'
+          test_passed_unity_fixture(line_array)
+          @test_passed += 1
+        elsif line.include? 'FAIL'
+          test_failed_unity_fixture(line_array)
+          @test_failed += 1
+        elsif line.include? 'IGNORE'
+          test_ignored_unity_fixture(line_array)
+          @test_ignored += 1
+        end
+      # normal output / fixture output (without verbose "-v")
+      elsif line.include? ':PASS'
+        test_passed(line_array)
+        @test_passed += 1
+      elsif line.include? ':FAIL'
+        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
+      end
+      @total_tests = @test_passed + @test_failed + @test_ignored
+    end
+    puts ''
+    puts '=================== SUMMARY ====================='
+    puts ''
+    puts 'Tests Passed  : ' + @test_passed.to_s
+    puts 'Tests Failed  : ' + @test_failed.to_s
+    puts 'Tests Ignored : ' + @test_ignored.to_s
+
+    return unless @xml_out
+
+    # push information about the suite
+    push_xml_output_suite_info
+    # write xml output file
+    write_xml_output
+  end
+end
+
+# If the command line has no values in, used a default value of Output.txt
+parse_my_file = ParseOutput.new
+
+if ARGV.size >= 1
+  ARGV.each do |arg|
+    if arg == '-xml'
+      parse_my_file.set_xml_output
+    else
+      parse_my_file.process(arg)
+      break
+    end
+  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, int 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) %>
+        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.rb

@@ -0,0 +1,251 @@
+#!/usr/bin/ruby
+#
+# unity_to_junit.rb
+#
+require 'fileutils'
+require 'optparse'
+require 'ostruct'
+require 'set'
+
+require 'pp'
+
+VERSION = 1.0
+
+class ArgvParser
+  #
+  # Return a structure describing the options.
+  #
+  def self.parse(args)
+    # The options specified on the command line will be collected in *options*.
+    # We set default values here.
+    options = OpenStruct.new
+    options.results_dir = '.'
+    options.root_path = '.'
+    options.out_file = 'results.xml'
+
+    opts = OptionParser.new do |o|
+      o.banner = 'Usage: unity_to_junit.rb [options]'
+
+      o.separator ''
+      o.separator 'Specific options:'
+
+      o.on('-r', '--results <dir>', 'Look for Unity Results files here.') do |results|
+        # puts "results #{results}"
+        options.results_dir = results
+      end
+
+      o.on('-p', '--root_path <path>', 'Prepend this path to files in results.') do |root_path|
+        options.root_path = root_path
+      end
+
+      o.on('-o', '--output <filename>', 'XML file to generate.') do |out_file|
+        # puts "out_file: #{out_file}"
+        options.out_file = out_file
+      end
+
+      o.separator ''
+      o.separator 'Common options:'
+
+      # No argument, shows at tail.  This will print an options summary.
+      o.on_tail('-h', '--help', 'Show this message') do
+        puts o
+        exit
+      end
+
+      # Another typical switch to print the version.
+      o.on_tail('--version', 'Show version') do
+        puts "unity_to_junit.rb version #{VERSION}"
+        exit
+      end
+    end
+
+    opts.parse!(args)
+    options
+  end
+end
+
+class UnityToJUnit
+  include FileUtils::Verbose
+  attr_reader :report, :total_tests, :failures, :ignored
+  attr_writer :targets, :root, :out_file
+
+  def initialize
+    @report = ''
+    @unit_name = ''
+  end
+
+  def run
+    # Clean up result file names
+    results = @targets.map { |target| target.tr('\\', '/') }
+    # puts "Output File: #{@out_file}"
+    f = File.new(@out_file, 'w')
+    write_xml_header(f)
+    write_suites_header(f)
+    results.each do |result_file|
+      lines = File.readlines(result_file).map(&:chomp)
+
+      raise "Empty test result file: #{result_file}" if lines.empty?
+
+      result_output = get_details(result_file, lines)
+      tests, failures, ignored = parse_test_summary(lines)
+      result_output[:counts][:total] = tests
+      result_output[:counts][:failed] = failures
+      result_output[:counts][:ignored] = ignored
+      result_output[:counts][:passed] = (result_output[:counts][:total] - result_output[:counts][:failed] - result_output[:counts][:ignored])
+
+      # use line[0] from the test output to get the test_file path and name
+      test_file_str = lines[0].tr('\\', '/')
+      test_file_str = test_file_str.split(':')
+      test_file = if test_file_str.length < 2
+                    result_file
+                  else
+                    test_file_str[0] + ':' + test_file_str[1]
+                  end
+      result_output[:source][:path] = File.dirname(test_file)
+      result_output[:source][:file] = File.basename(test_file)
+
+      # save result_output
+      @unit_name = File.basename(test_file, '.*')
+
+      write_suite_header(result_output[:counts], f)
+      write_failures(result_output, f)
+      write_tests(result_output, f)
+      write_ignored(result_output, f)
+      write_suite_footer(f)
+    end
+    write_suites_footer(f)
+    f.close
+  end
+
+  def usage(err_msg = nil)
+    puts "\nERROR: "
+    puts err_msg if err_msg
+    puts 'Usage: unity_to_junit.rb [options]'
+    puts ''
+    puts 'Specific options:'
+    puts '    -r, --results <dir>              Look for Unity Results files here.'
+    puts '    -p, --root_path <path>           Prepend this path to files in results.'
+    puts '    -o, --output <filename>          XML file to generate.'
+    puts ''
+    puts 'Common options:'
+    puts '    -h, --help                       Show this message'
+    puts '        --version                    Show version'
+
+    exit 1
+  end
+
+  protected
+
+  def get_details(_result_file, lines)
+    results = results_structure
+    lines.each do |line|
+      line = line.tr('\\', '/')
+      _src_file, src_line, test_name, status, msg = line.split(/:/)
+      case status
+      when 'IGNORE' then results[:ignores] << { test: test_name, line: src_line, message: msg }
+      when 'FAIL'   then results[:failures] << { test: test_name, line: src_line, message: msg }
+      when 'PASS'   then results[:successes] << { test: test_name, line: src_line, message: msg }
+      end
+    end
+    results
+  end
+
+  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
+
+  private
+
+  def results_structure
+    {
+      source: { path: '', file: '' },
+      successes: [],
+      failures: [],
+      ignores: [],
+      counts: { total: 0, passed: 0, failed: 0, ignored: 0 },
+      stdout: []
+    }
+  end
+
+  def write_xml_header(stream)
+    stream.puts "<?xml version='1.0' encoding='utf-8' ?>"
+  end
+
+  def write_suites_header(stream)
+    stream.puts '<testsuites>'
+  end
+
+  def write_suite_header(counts, stream)
+    stream.puts "\t<testsuite errors=\"0\" skipped=\"#{counts[:ignored]}\" failures=\"#{counts[:failed]}\" tests=\"#{counts[:total]}\" name=\"unity\">"
+  end
+
+  def write_failures(results, stream)
+    result = results[:failures]
+    result.each do |item|
+      filename = File.join(results[:source][:path], File.basename(results[:source][:file], '.*'))
+      stream.puts "\t\t<testcase classname=\"#{@unit_name}\" name=\"#{item[:test]}\" time=\"0\">"
+      stream.puts "\t\t\t<failure message=\"#{item[:message]}\" type=\"Assertion\"/>"
+      stream.puts "\t\t\t<system-err>&#xD;[File] #{filename}&#xD;[Line] #{item[:line]}&#xD;</system-err>"
+      stream.puts "\t\t</testcase>"
+    end
+  end
+
+  def write_tests(results, stream)
+    result = results[:successes]
+    result.each do |item|
+      stream.puts "\t\t<testcase classname=\"#{@unit_name}\" name=\"#{item[:test]}\" time=\"0\" />"
+    end
+  end
+
+  def write_ignored(results, stream)
+    result = results[:ignores]
+    result.each do |item|
+      filename = File.join(results[:source][:path], File.basename(results[:source][:file], '.*'))
+      puts "Writing ignored tests for test harness: #{filename}"
+      stream.puts "\t\t<testcase classname=\"#{@unit_name}\" name=\"#{item[:test]}\" time=\"0\">"
+      stream.puts "\t\t\t<skipped message=\"#{item[:message]}\" type=\"Assertion\"/>"
+      stream.puts "\t\t\t<system-err>&#xD;[File] #{filename}&#xD;[Line] #{item[:line]}&#xD;</system-err>"
+      stream.puts "\t\t</testcase>"
+    end
+  end
+
+  def write_suite_footer(stream)
+    stream.puts "\t</testsuite>"
+  end
+
+  def write_suites_footer(stream)
+    stream.puts '</testsuites>'
+  end
+end
+
+if $0 == __FILE__
+  # parse out the command options
+  options = ArgvParser.parse(ARGV)
+
+  # create an instance to work with
+  utj = UnityToJUnit.new
+  begin
+    # look in the specified or current directory for result files
+    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
+    utj.root = options.root_path
+
+    # set the output XML file name
+    # puts "Output File from options: #{options.out_file}"
+    utj.out_file = options.out_file
+
+    # run the summarizer
+    puts utj.run
+  rescue StandardError => e
+    utj.usage e.message
+  end
+end

auto/test_file_filter.rb

@@ -2,7 +2,7 @@
 #   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'
 
@@ -10,14 +10,16 @@ module RakefileHelpers
   class TestFileFilter
     def initialize(all_files = false)
       @all_files = all_files
-      if not @all_files == true
+
-        if File.exist?('test_file_filter.yml')
+      return unless @all_files
-          filters = YAML.load_file( 'test_file_filter.yml' )
+      return unless File.exist?('test_file_filter.yml')
-          @all_files, @only_files, @exclude_files = 
+
-            filters[:all_files], filters[:only_files], filters[:exclude_files] 
+      filters = YAML.load_file('test_file_filter.yml')
-        end
+      @all_files = filters[:all_files]
-      end
+      @only_files = filters[:only_files]
-    end		
+      @exclude_files = filters[:exclude_files]
+    end
+
     attr_accessor :all_files, :only_files, :exclude_files
   end
 end

auto/type_sanitizer.rb

@@ -0,0 +1,6 @@
+module TypeSanitizer
+  def self.sanitize_c_identifier(unsanitized)
+    # convert filename to valid C identifier by replacing invalid chars with '_'
+    unsanitized.gsub(/[-\/\\\.\,\s]/, '_')
+  end
+end

auto/unity_test_summary.py

@@ -0,0 +1,139 @@
+#! python3
+# ==========================================
+#   Unity Project - A Test Framework for C
+#   Copyright (c) 2015 Alexander Mueller / XelaRellum@web.de
+#   [Released under MIT License. Please refer to license.txt for details]
+#   Based on the ruby script by  Mike Karlesky, Mark VanderVoord, Greg Williams
+# ==========================================
+import sys
+import os
+import re
+from glob import glob
+
+class UnityTestSummary:
+    def __init__(self):
+        self.report = ''
+        self.total_tests = 0
+        self.failures = 0
+        self.ignored = 0
+
+    def run(self):
+        # Clean up result file names
+        results = []
+        for target in self.targets:
+            results.append(target.replace('\\', '/'))
+
+        # Dig through each result file, looking for details on pass/fail:
+        failure_output = []
+        ignore_output = []
+
+        for result_file in results:
+            lines = list(map(lambda line: line.rstrip(), open(result_file, "r").read().split('\n')))
+            if len(lines) == 0:
+                raise Exception("Empty test result file: %s" % result_file)
+
+            details = self.get_details(result_file, lines)
+            failures = details['failures']
+            ignores = details['ignores']
+            if len(failures) > 0: failure_output.append('\n'.join(failures))
+            if len(ignores) > 0: ignore_output.append('n'.join(ignores))
+            tests,failures,ignored = self.parse_test_summary('\n'.join(lines))
+            self.total_tests += tests
+            self.failures += failures
+            self.ignored += ignored
+
+        if self.ignored > 0:
+            self.report += "\n"
+            self.report += "--------------------------\n"
+            self.report += "UNITY IGNORED TEST SUMMARY\n"
+            self.report += "--------------------------\n"
+            self.report += "\n".join(ignore_output)
+
+        if self.failures > 0:
+            self.report += "\n"
+            self.report += "--------------------------\n"
+            self.report += "UNITY FAILED TEST SUMMARY\n"
+            self.report += "--------------------------\n"
+            self.report += '\n'.join(failure_output)
+
+        self.report += "\n"
+        self.report += "--------------------------\n"
+        self.report += "OVERALL UNITY TEST SUMMARY\n"
+        self.report += "--------------------------\n"
+        self.report += "{total_tests} TOTAL TESTS {failures} TOTAL FAILURES {ignored} IGNORED\n".format(total_tests = self.total_tests, failures=self.failures, ignored=self.ignored)
+        self.report += "\n"
+
+        return self.report
+
+    def set_targets(self, target_array):
+            self.targets = target_array
+
+    def set_root_path(self, path):
+        self.root = path
+
+    def usage(self, err_msg=None):
+        print("\nERROR: ")
+        if err_msg:
+            print(err_msg)
+        print("\nUsage: unity_test_summary.py result_file_directory/ root_path/")
+        print("     result_file_directory - The location of your results files.")
+        print("                             Defaults to current directory if not specified.")
+        print("                             Should end in / if specified.")
+        print("     root_path - Helpful for producing more verbose output if using relative paths.")
+        sys.exit(1)
+
+    def get_details(self, result_file, lines):
+        results = { 'failures': [], 'ignores': [], 'successes': [] }
+        for line in lines:
+            parts = line.split(':')
+            if len(parts) == 5:
+                src_file,src_line,test_name,status,msg = parts
+            elif len(parts) == 4:
+                src_file,src_line,test_name,status = parts
+                msg = ''
+            else:
+                continue
+            if len(self.root) > 0:
+                line_out = "%s%s" % (self.root, line)
+            else:
+                line_out = line
+            if status == 'IGNORE':
+                results['ignores'].append(line_out)
+            elif status == 'FAIL':
+                results['failures'].append(line_out)
+            elif status == 'PASS':
+                results['successes'].append(line_out)
+        return results
+
+    def parse_test_summary(self, summary):
+        m = re.search(r"([0-9]+) Tests ([0-9]+) Failures ([0-9]+) Ignored", summary)
+        if not m:
+            raise Exception("Couldn't parse test results: %s" % summary)
+
+        return int(m.group(1)), int(m.group(2)), int(m.group(3))
+
+
+if __name__ == '__main__':
+  uts = UnityTestSummary()
+  try:
+    #look in the specified or current directory for result files
+    if len(sys.argv) > 1:
+        targets_dir = sys.argv[1]
+    else:
+        targets_dir = './'
+    targets = list(map(lambda x: x.replace('\\', '/'), glob(targets_dir + '**/*.test*', recursive=True)))
+    if len(targets) == 0:
+        raise Exception("No *.testpass or *.testfail files found in '%s'" % targets_dir)
+    uts.set_targets(targets)
+
+    #set the root path
+    if len(sys.argv) > 2:
+        root_path = sys.argv[2]
+    else:
+        root_path = os.path.split(__file__)[0]
+    uts.set_root_path(root_path)
+
+    #run the summarizer
+    print(uts.run())
+  except Exception as e:
+    uts.usage(e)

auto/unity_test_summary.rb

@@ -1,139 +1,135 @@
-# ==========================================
+# ==========================================
-#   Unity Project - A Test Framework for C
+#   Unity Project - A Test Framework for C
-#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-#   [Released under MIT License. Please refer to license.txt for details]
+#   [Released under MIT License. Please refer to license.txt for details]
-# ========================================== 
+# ==========================================
-
+
-#!/usr/bin/ruby
+# !/usr/bin/ruby
-#
+#
-# unity_test_summary.rb
+# unity_test_summary.rb
-#
+#
-require 'fileutils'
+require 'fileutils'
-require 'set'
+require 'set'
-
+
-class UnityTestSummary
+class UnityTestSummary
-  include FileUtils::Verbose
+  include FileUtils::Verbose
-
+
-  attr_reader :report, :total_tests, :failures, :ignored
+  attr_reader :report, :total_tests, :failures, :ignored
-  
+  attr_writer :targets, :root
-  def initialize
+
-    @report = ''
+  def initialize(_opts = {})
-    @total_tests = 0
+    @report = ''
-    @failures = 0
+    @total_tests = 0
-    @ignored = 0
+    @failures = 0
-  end
+    @ignored = 0
-  
+  end
-  def run
+
-    # Clean up result file names
+  def run
-    results = @targets.map {|target| target.gsub(/\\/,'/')}
+    # Clean up result file names
-    
+    results = @targets.map { |target| target.tr('\\', '/') }
-    # Dig through each result file, looking for details on pass/fail:   
+
-    failure_output = []
+    # Dig through each result file, looking for details on pass/fail:
-    ignore_output = []
+    failure_output = []
-    
+    ignore_output = []
-    results.each do |result_file|
+
-      lines = File.readlines(result_file).map { |line| line.chomp }
+    results.each do |result_file|
-      if lines.length == 0
+      lines = File.readlines(result_file).map(&:chomp)
-        raise "Empty test result file: #{result_file}"
+
-      else
+      raise "Empty test result file: #{result_file}" if lines.empty?
-        output = get_details(result_file, lines)
+
-        failure_output << output[:failures] unless output[:failures].empty?
+      output = get_details(result_file, lines)
-        ignore_output  << output[:ignores]  unless output[:ignores].empty?
+      failure_output << output[:failures] unless output[:failures].empty?
-        tests,failures,ignored = parse_test_summary(lines)
+      ignore_output  << output[:ignores]  unless output[:ignores].empty?
-        @total_tests += tests
+      tests, failures, ignored = parse_test_summary(lines)
-        @failures += failures
+      @total_tests += tests
-        @ignored += ignored
+      @failures += failures
-      end
+      @ignored += ignored
-    end
+    end
-    
+
-    if @ignored > 0
+    if @ignored > 0
-      @report += "\n"
+      @report += "\n"
-      @report += "--------------------------\n"
+      @report += "--------------------------\n"
-      @report += "UNITY IGNORED TEST SUMMARY\n"
+      @report += "UNITY IGNORED TEST SUMMARY\n"
-      @report += "--------------------------\n"
+      @report += "--------------------------\n"
-      @report += ignore_output.flatten.join("\n")
+      @report += ignore_output.flatten.join("\n")
-    end
+    end
-    
+
-    if @failures > 0
+    if @failures > 0
-      @report += "\n"
+      @report += "\n"
-      @report += "--------------------------\n"
+      @report += "--------------------------\n"
-      @report += "UNITY FAILED TEST SUMMARY\n"
+      @report += "UNITY FAILED TEST SUMMARY\n"
-      @report += "--------------------------\n"
+      @report += "--------------------------\n"
-      @report += failure_output.flatten.join("\n")
+      @report += failure_output.flatten.join("\n")
-    end
+    end
-  
+
-    @report += "\n"
+    @report += "\n"
-    @report += "--------------------------\n"
+    @report += "--------------------------\n"
-    @report += "OVERALL UNITY TEST SUMMARY\n"
+    @report += "OVERALL UNITY TEST SUMMARY\n"
-    @report += "--------------------------\n"
+    @report += "--------------------------\n"
-    @report += "#{@total_tests} TOTAL TESTS #{@failures} TOTAL FAILURES #{@ignored} IGNORED\n"
+    @report += "#{@total_tests} TOTAL TESTS #{@failures} TOTAL FAILURES #{@ignored} IGNORED\n"
-    @report += "\n"
+    @report += "\n"
-  end
+  end
-  
+
-  def set_targets(target_array)
+  def usage(err_msg = nil)
-    @targets = target_array
+    puts "\nERROR: "
-  end
+    puts err_msg if err_msg
-  
+    puts "\nUsage: unity_test_summary.rb result_file_directory/ root_path/"
-  def set_root_path(path)
+    puts '     result_file_directory - The location of your results files.'
-    @root = path
+    puts '                             Defaults to current directory if not specified.'
-  end
+    puts '                             Should end in / if specified.'
-
+    puts '     root_path - Helpful for producing more verbose output if using relative paths.'
-  def usage(err_msg=nil)
+    exit 1
-    puts "\nERROR: "
+  end
-    puts err_msg if err_msg
+
-    puts "\nUsage: unity_test_summary.rb result_file_directory/ root_path/"
+  protected
-    puts "     result_file_directory - The location of your results files."
+
-    puts "                             Defaults to current directory if not specified."
+  def get_details(_result_file, lines)
-    puts "                             Should end in / if specified."
+    results = { failures: [], ignores: [], successes: [] }
-    puts "     root_path - Helpful for producing more verbose output if using relative paths."
+    lines.each do |line|
-    exit 1
+      _src_file, _src_line, _test_name, status, _msg = line.split(/:/)
-  end
+      line_out = (@root && (@root != 0) ? "#{@root}#{line}" : line).gsub(/\//, '\\')
-  
+      case status
-  protected
+      when 'IGNORE' then results[:ignores]   << line_out
-
+      when 'FAIL'   then results[:failures]  << line_out
-  def get_details(result_file, lines)
+      when 'PASS'   then results[:successes] << line_out
-    results = { :failures => [], :ignores => [], :successes => [] }
+      end
-    lines.each do |line|
+    end
-      src_file,src_line,test_name,status,msg = line.split(/:/)
+    results
-      line_out = ((@root and (@root != 0)) ? "#{@root}#{line}" : line ).gsub(/\//, "\\")
+  end
-      case(status)
+
-        when 'IGNORE' then results[:ignores]   << line_out
+  def parse_test_summary(summary)
-        when 'FAIL'   then results[:failures]  << line_out
+    raise "Couldn't parse test results: #{summary}" unless summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ }
-        when 'PASS'   then results[:successes] << line_out
+
-      end
+    [Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i]
-    end
+  end
-    return results
+end
-  end
+
-  
+if $0 == __FILE__
-  def parse_test_summary(summary)
+
-    if summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ }
+  # parse out the command options
-      [$1.to_i,$2.to_i,$3.to_i]
+  opts, args = ARGV.partition { |v| v =~ /^--\w+/ }
-    else
+  opts.map! { |v| v[2..-1].to_sym }
-      raise "Couldn't parse test results: #{summary}"
+
-    end
+  # create an instance to work with
-  end
+  uts = UnityTestSummary.new(opts)
-
+
-  def here; File.expand_path(File.dirname(__FILE__)); end
+  begin
-  
+    # look in the specified or current directory for result files
-end
+    args[0] ||= './'
-
+    targets = "#{ARGV[0].tr('\\', '/')}**/*.test*"
-if $0 == __FILE__
+    results = Dir[targets]
-  uts = UnityTestSummary.new
+
-  begin
+    raise "No *.testpass, *.testfail, or *.testresults files found in '#{targets}'" if results.empty?
-    #look in the specified or current directory for result files
+
-    ARGV[0] ||= './'
+    uts.targets = results
-    targets = "#{ARGV[0].gsub(/\\/, '/')}*.test*"
+
-    results = Dir[targets]
+    # set the root path
-    raise "No *.testpass or *.testfail files found in '#{targets}'" if results.empty?
+    args[1] ||= Dir.pwd + '/'
-    uts.set_targets(results)
+    uts.root = ARGV[1]
-    
+
-    #set the root path
+    # run the summarizer
-    ARGV[1] ||= File.expand_path(File.dirname(__FILE__)) + '/'
+    puts uts.run
-    uts.set_root_path(ARGV[1])
+  rescue StandardError => e
-    
+    uts.usage e.message
-    #run the summarizer
+  end
-    puts uts.run
+end
-  rescue Exception => e
-    uts.usage e.message
-  end
-end

auto/unity_to_junit.py

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

docs/ThrowTheSwitchCodingStandard.md

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

docs/Unity Summary.txt

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

docs/UnityAssertionsReference.md

@@ -0,0 +1,831 @@
+# Unity Assertions Reference
+
+## Background and Overview
+
+### Super Condensed Version
+
+- An assertion establishes truth (i.e. boolean True) for a single condition.
+Upon boolean False, an assertion stops execution and reports the failure.
+- Unity is mainly a rich collection of assertions and the support to gather up
+and easily execute those assertions.
+- The structure of Unity allows you to easily separate test assertions from
+source code in, well, test code.
+- Unity's assertions:
+- Come in many, many flavors to handle different C types and assertion cases.
+- Use context to provide detailed and helpful failure messages.
+- Document types, expected values, and basic behavior in your source code for
+free.
+
+
+### Unity Is Several Things But Mainly It's Assertions
+
+One way to think of Unity is simply as a rich collection of assertions you can
+use to establish whether your source code behaves the way you think it does.
+Unity provides a framework to easily organize and execute those assertions in
+test code separate from your source code.
+
+
+### What's an Assertion?
+
+At their core, assertions are an establishment of truth - boolean truth. Was this
+thing equal to that thing? Does that code doohickey have such-and-such property
+or not? You get the idea. Assertions are executable code (to appreciate the big
+picture on this read up on the difference between
+[link:Dynamic Verification and Static Analysis]). A failing assertion stops
+execution and reports an error through some appropriate I/O channel (e.g.
+stdout, GUI, file, blinky light).
+
+Fundamentally, for dynamic verification all you need is a single assertion
+mechanism. In fact, that's what the [assert() macro in C's standard library](http://en.wikipedia.org/en/wiki/Assert.h)
+is for. So why not just use it? Well, we can do far better in the reporting
+department. C's `assert()` is pretty dumb as-is and is particularly poor for
+handling common data types like arrays, structs, etc. And, without some other
+support, it's far too tempting to litter source code with C's `assert()`'s. It's
+generally much cleaner, manageable, and more useful to separate test and source
+code in the way Unity facilitates.
+
+
+### Unity's Assertions: Helpful Messages _and_ Free Source Code Documentation
+
+Asserting a simple truth condition is valuable, but using the context of the
+assertion is even more valuable. For instance, if you know you're comparing bit
+flags and not just integers, then why not use that context to give explicit,
+readable, bit-level feedback when an assertion fails?
+
+That's what Unity's collection of assertions do - capture context to give you
+helpful, meaningful assertion failure messages. In fact, the assertions
+themselves also serve as executable documentation about types and values in your
+source code. So long as your tests remain current with your source and all those
+tests pass, you have a detailed, up-to-date view of the intent and mechanisms in
+your source code. And due to a wondrous mystery, well-tested code usually tends
+to be well designed code.
+
+
+## Assertion Conventions and Configurations
+
+### Naming and Parameter Conventions
+
+The convention of assertion parameters generally follows this order:
+
+```
+TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} )
+```
+
+The very simplest assertion possible uses only a single `actual` parameter (e.g.
+a simple null check).
+
+ - `Actual` is the value being tested and unlike the other parameters in an
+    assertion construction is the only parameter present in all assertion variants.
+ - `Modifiers` are masks, ranges, bit flag specifiers, floating point deltas.
+ - `Expected` is your expected value (duh) to compare to an `actual` value; it's
+    marked as an optional parameter because some assertions only need a single
+    `actual` parameter (e.g. null check).
+ - `Size/count` refers to string lengths, number of array elements, etc.
+
+Many of Unity's assertions are clear duplications in that the same data type
+is handled by several assertions. The differences among these are in how failure
+messages are presented. For instance, a `_HEX` variant of an assertion prints
+the expected and actual values of that assertion formatted as hexadecimal.
+
+
+#### TEST_ASSERT_X_MESSAGE Variants
+
+_All_ assertions are complemented with a variant that includes a simple string
+message as a final parameter. The string you specify is appended to an assertion
+failure message in Unity output.
+
+For brevity, the assertion variants with a message parameter are not listed
+below. Just tack on `_MESSAGE` as the final component to any assertion name in
+the reference list below and add a string as the final parameter.
+
+_Example:_
+
+```
+TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} )
+```
+
+becomes messageified like thus...
+
+```
+TEST_ASSERT_X_MESSAGE( {modifiers}, {expected}, actual, {size/count}, message )
+```
+
+Notes:
+- The `_MESSAGE` variants intentionally do not support `printf` style formatting
+  since many embedded projects don't support or avoid `printf` for various reasons.
+  It is possible to use `sprintf` before the assertion to assemble a complex fail
+  message, if necessary.
+- If you want to output a counter value within an assertion fail message (e.g. from
+  a loop) , building up an array of results and then using one of the `_ARRAY`
+  assertions (see below) might be a handy alternative to `sprintf`.
+
+
+#### TEST_ASSERT_X_ARRAY Variants
+
+Unity provides a collection of assertions for arrays containing a variety of
+types. These are documented in the Array section below. These are almost on par
+with the `_MESSAGE`variants of Unity's Asserts in that for pretty much any Unity
+type assertion you can tack on `_ARRAY` and run assertions on an entire block of
+memory.
+
+```
+    TEST_ASSERT_EQUAL_TYPEX_ARRAY( expected, actual, {size/count} )
+```
+
+ - `Expected` is an array itself.
+ - `Size/count` is one or two parameters necessary to establish the number of array
+    elements and perhaps the length of elements within the array.
+
+Notes:
+
+ - The `_MESSAGE` variant convention still applies here to array assertions. The
+   `_MESSAGE` variants of the `_ARRAY` assertions have names ending with
+   `_ARRAY_MESSAGE`.
+ - Assertions for handling arrays of floating point values are grouped with float
+   and double assertions (see immediately following section).
+
+
+### TEST_ASSERT_EACH_EQUAL_X Variants
+
+Unity provides a collection of assertions for arrays containing a variety of
+types which can be compared to a single value as well. These are documented in
+the Each Equal section below. these are almost on par with the `_MESSAGE`
+variants of Unity's Asserts in that for pretty much any Unity type assertion you
+can inject `_EACH_EQUAL` and run assertions on an entire block of memory.
+
+```
+TEST_ASSERT_EACH_EQUAL_TYPEX( expected, actual, {size/count} )
+```
+
+ - `Expected` is a single value to compare to.
+ - `Actual` is an array where each element will be compared to the expected value.
+ - `Size/count` is one of two parameters necessary to establish the number of array
+    elements and perhaps the length of elements within the array.
+
+Notes:
+
+ - The `_MESSAGE` variant convention still applies here to Each Equal assertions.
+ - Assertions for handling Each Equal of floating point values are grouped with
+   float and double assertions (see immediately following section).
+
+
+### Configuration
+
+#### Floating Point Support Is Optional
+
+Support for floating point types is configurable. That is, by defining the
+appropriate preprocessor symbols, floats and doubles can be individually enabled
+or disabled in Unity code. This is useful for embedded targets with no floating
+point math support (i.e. Unity compiles free of errors for fixed point only
+platforms). See Unity documentation for specifics.
+
+
+#### Maximum Data Type Width Is Configurable
+
+Not all targets support 64 bit wide types or even 32 bit wide types. Define the
+appropriate preprocessor symbols and Unity will omit all operations from
+compilation that exceed the maximum width of your target. See Unity
+documentation for specifics.
+
+
+## The Assertions in All Their Blessed Glory
+
+### Basic Fail, Pass and Ignore
+
+##### `TEST_FAIL()`
+
+##### `TEST_FAIL_MESSAGE("message")`
+
+This fella is most often used in special conditions where your test code is
+performing logic beyond a simple assertion. That is, in practice, `TEST_FAIL()`
+will always be found inside a conditional code block.
+
+_Examples:_
+
+- Executing a state machine multiple times that increments a counter your test
+code then verifies as a final step.
+- Triggering an exception and verifying it (as in Try / Catch / Throw - see the
+[CException](https://github.com/ThrowTheSwitch/CException) project).
+
+##### `TEST_PASS()`
+
+##### `TEST_PASS_MESSAGE("message")`
+
+This will abort the remainder of the test, but count the test as a pass. Under
+normal circumstances, it is not necessary to include this macro in your tests...
+a lack of failure will automatically be counted as a `PASS`. It is occasionally
+useful for tests with `#ifdef`s and such.
+
+##### `TEST_IGNORE()`
+
+##### `TEST_IGNORE_MESSAGE("message")`
+
+Marks a test case (i.e. function meant to contain test assertions) as ignored.
+Usually this is employed as a breadcrumb to come back and implement a test case.
+An ignored test case has effects if other assertions are in the enclosing test
+case (see Unity documentation for more).
+
+##### `TEST_MESSAGE(message)`
+
+This can be useful for outputting `INFO` messages into the Unity output stream
+without actually ending the test. Like pass and fail messages, it will be output
+with the filename and line number.
+
+### Boolean
+
+##### `TEST_ASSERT (condition)`
+
+##### `TEST_ASSERT_TRUE (condition)`
+
+##### `TEST_ASSERT_FALSE (condition)`
+
+##### `TEST_ASSERT_UNLESS (condition)`
+
+A simple wording variation on `TEST_ASSERT_FALSE`.The semantics of
+`TEST_ASSERT_UNLESS` aid readability in certain test constructions or
+conditional statements.
+
+##### `TEST_ASSERT_NULL (pointer)`
+
+##### `TEST_ASSERT_NOT_NULL (pointer)`
+
+Verify if a pointer is or is not NULL.
+
+##### `TEST_ASSERT_EMPTY (pointer)`
+
+##### `TEST_ASSERT_NOT_EMPTY (pointer)`
+
+Verify if the first element dereferenced from a pointer is or is not zero. This
+is particularly useful for checking for empty (or non-empty) null-terminated
+C strings, but can be just as easily used for other null-terminated arrays.
+
+### Signed and Unsigned Integers (of all sizes)
+
+Large integer sizes can be disabled for build targets that do not support them.
+For example, if your target only supports up to 16 bit types, by defining the
+appropriate symbols Unity can be configured to omit 32 and 64 bit operations
+that would break compilation (see Unity documentation for more). Refer to
+Advanced Asserting later in this document for advice on dealing with other word
+sizes.
+
+##### `TEST_ASSERT_EQUAL_INT (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_INT8 (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_INT16 (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_INT32 (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_INT64 (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_UINT (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_UINT8 (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_UINT16 (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_UINT32 (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_UINT64 (expected, actual)`
+
+
+### Unsigned Integers (of all sizes) in Hexadecimal
+
+All `_HEX` assertions are identical in function to unsigned integer assertions
+but produce failure messages with the `expected` and `actual` values formatted
+in hexadecimal. Unity output is big endian.
+
+##### `TEST_ASSERT_EQUAL_HEX (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_HEX8 (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_HEX16 (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_HEX32 (expected, actual)`
+
+##### `TEST_ASSERT_EQUAL_HEX64 (expected, actual)`
+
+
+### Characters
+
+While you can use the 8-bit integer assertions to compare `char`, another option is
+to use this specialized assertion which will show printable characters as printables,
+otherwise showing the HEX escape code for the characters.
+
+##### `TEST_ASSERT_EQUAL_CHAR (expected, actual)`
+
+
+### Masked and Bit-level Assertions
+
+Masked and bit-level assertions produce output formatted in hexadecimal. Unity
+output is big endian.
+
+
+##### `TEST_ASSERT_BITS (mask, expected, actual)`
+
+Only compares the masked (i.e. high) bits of `expected` and `actual` parameters.
+
+
+##### `TEST_ASSERT_BITS_HIGH (mask, actual)`
+
+Asserts the masked bits of the `actual` parameter are high.
+
+
+##### `TEST_ASSERT_BITS_LOW (mask, actual)`
+
+Asserts the masked bits of the `actual` parameter are low.
+
+
+##### `TEST_ASSERT_BIT_HIGH (bit, actual)`
+
+Asserts the specified bit of the `actual` parameter is high.
+
+
+##### `TEST_ASSERT_BIT_LOW (bit, actual)`
+
+Asserts the specified bit of the `actual` parameter is low.
+
+### Integer Less Than / Greater Than
+
+These assertions verify that the `actual` parameter is less than or greater
+than `threshold` (exclusive). For example, if the threshold value is 0 for the
+greater than assertion will fail if it is 0 or less. There are assertions for
+all the various sizes of ints, as for the equality assertions. Some examples:
+
+##### `TEST_ASSERT_GREATER_THAN_INT8 (threshold, actual)`
+
+##### `TEST_ASSERT_GREATER_OR_EQUAL_INT16 (threshold, actual)`
+
+##### `TEST_ASSERT_LESS_THAN_INT32 (threshold, actual)`
+
+##### `TEST_ASSERT_LESS_OR_EQUAL_UINT (threshold, actual)`
+
+##### `TEST_ASSERT_NOT_EQUAL_UINT8 (threshold, actual)`
+
+
+### Integer Ranges (of all sizes)
+
+These assertions verify that the `expected` parameter is within +/- `delta`
+(inclusive) of the `actual` parameter. For example, if the expected value is 10
+and the delta is 3 then the assertion will fail for any value outside the range
+of 7 - 13.
+
+##### `TEST_ASSERT_INT_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_INT8_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_INT16_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_INT32_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_INT64_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_UINT_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_UINT8_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_UINT16_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_UINT32_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_UINT64_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_HEX_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_HEX8_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_HEX16_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_HEX32_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_HEX64_WITHIN (delta, expected, actual)`
+
+##### `TEST_ASSERT_CHAR_WITHIN (delta, expected, actual)`
+
+### Structs and Strings
+
+##### `TEST_ASSERT_EQUAL_PTR (expected, actual)`
+
+Asserts that the pointers point to the same memory location.
+
+
+##### `TEST_ASSERT_EQUAL_STRING (expected, actual)`
+
+Asserts that the null terminated (`'\0'`)strings are identical. If strings are
+of different lengths or any portion of the strings before their terminators
+differ, the assertion fails. Two NULL strings (i.e. zero length) are considered
+equivalent.
+
+
+##### `TEST_ASSERT_EQUAL_MEMORY (expected, actual, len)`
+
+Asserts that the contents of the memory specified by the `expected` and `actual`
+pointers is identical. The size of the memory blocks in bytes is specified by
+the `len` parameter.
+
+
+### Arrays
+
+`expected` and `actual` parameters are both arrays. `num_elements` specifies the
+number of elements in the arrays to compare.
+
+`_HEX` assertions produce failure messages with expected and actual array
+contents formatted in hexadecimal.
+
+For array of strings comparison behavior, see comments for
+`TEST_ASSERT_EQUAL_STRING` in the preceding section.
+
+Assertions fail upon the first element in the compared arrays found not to
+match. Failure messages specify the array index of the failed comparison.
+
+##### `TEST_ASSERT_EQUAL_INT_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_INT8_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_INT16_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_INT32_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_INT64_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_UINT_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_UINT8_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_UINT16_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_UINT32_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_UINT64_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_HEX_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_HEX8_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_HEX16_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_HEX32_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_HEX64_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_CHAR_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_PTR_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_STRING_ARRAY (expected, actual, num_elements)`
+
+##### `TEST_ASSERT_EQUAL_MEMORY_ARRAY (expected, actual, len, num_elements)`
+
+`len` is the memory in bytes to be compared at each array element.
+
+### Integer Array Ranges (of all sizes)
+
+These assertions verify that the `expected` array parameter is within +/- `delta`
+(inclusive) of the `actual` array parameter. For example, if the expected value is
+\[10, 12\] and the delta is 3 then the assertion will fail for any value
+outside the range of \[7 - 13, 9 - 15\].
+
+##### `TEST_ASSERT_INT_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_INT8_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_INT16_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_INT32_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_INT64_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_UINT_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_UINT8_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_UINT16_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_UINT32_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_UINT64_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_HEX_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_HEX8_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_HEX16_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_HEX32_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_HEX64_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+##### `TEST_ASSERT_CHAR_ARRAY_WITHIN (delta, expected, actual, num_elements)`
+
+### Each Equal (Arrays to Single Value)
+
+`expected` are single values and `actual` are arrays. `num_elements` specifies
+the number of elements in the arrays to compare.
+
+`_HEX` assertions produce failure messages with expected and actual array
+contents formatted in hexadecimal.
+
+Assertions fail upon the first element in the compared arrays found not to
+match. Failure messages specify the array index of the failed comparison.
+
+#### `TEST_ASSERT_EACH_EQUAL_INT (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_INT8 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_INT16 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_INT32 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_INT64 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_UINT (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_UINT8 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_UINT16 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_UINT32 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_UINT64 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_HEX (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_HEX8 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_HEX16 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_HEX32 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_HEX64 (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_CHAR (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_PTR (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_STRING (expected, actual, num_elements)`
+
+#### `TEST_ASSERT_EACH_EQUAL_MEMORY (expected, actual, len, num_elements)`
+
+`len` is the memory in bytes to be compared at each array element.
+
+
+### Floating Point (If enabled)
+
+##### `TEST_ASSERT_FLOAT_WITHIN (delta, expected, actual)`
+
+Asserts that the `actual` value is within +/- `delta` of the `expected` value.
+The nature of floating point representation is such that exact evaluations of
+equality are not guaranteed.
+
+
+##### `TEST_ASSERT_EQUAL_FLOAT (expected, actual)`
+
+Asserts that the ?actual?value is "close enough to be considered equal" to the
+`expected` value. If you are curious about the details, refer to the Advanced
+Asserting section for more details on this. Omitting a user-specified delta in a
+floating point assertion is both a shorthand convenience and a requirement of
+code generation conventions for CMock.
+
+
+##### `TEST_ASSERT_EQUAL_FLOAT_ARRAY (expected, actual, num_elements)`
+
+See Array assertion section for details. Note that individual array element
+float comparisons are executed using T?EST_ASSERT_EQUAL_FLOAT?.That is, user
+specified delta comparison values requires a custom-implemented floating point
+array assertion.
+
+
+##### `TEST_ASSERT_FLOAT_IS_INF (actual)`
+
+Asserts that `actual` parameter is equivalent to positive infinity floating
+point representation.
+
+
+##### `TEST_ASSERT_FLOAT_IS_NEG_INF (actual)`
+
+Asserts that `actual` parameter is equivalent to negative infinity floating
+point representation.
+
+
+##### `TEST_ASSERT_FLOAT_IS_NAN (actual)`
+
+Asserts that `actual` parameter is a Not A Number floating point representation.
+
+
+##### `TEST_ASSERT_FLOAT_IS_DETERMINATE (actual)`
+
+Asserts that ?actual?parameter is a floating point representation usable for
+mathematical operations. That is, the `actual` parameter is neither positive
+infinity nor negative infinity nor Not A Number floating point representations.
+
+
+##### `TEST_ASSERT_FLOAT_IS_NOT_INF (actual)`
+
+Asserts that `actual` parameter is a value other than positive infinity floating
+point representation.
+
+
+##### `TEST_ASSERT_FLOAT_IS_NOT_NEG_INF (actual)`
+
+Asserts that `actual` parameter is a value other than negative infinity floating
+point representation.
+
+
+##### `TEST_ASSERT_FLOAT_IS_NOT_NAN (actual)`
+
+Asserts that `actual` parameter is a value other than Not A Number floating
+point representation.
+
+
+##### `TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE (actual)`
+
+Asserts that `actual` parameter is not usable for mathematical operations. That
+is, the `actual` parameter is either positive infinity or negative infinity or
+Not A Number floating point representations.
+
+
+### Double (If enabled)
+
+##### `TEST_ASSERT_DOUBLE_WITHIN (delta, expected, actual)`
+
+Asserts that the `actual` value is within +/- `delta` of the `expected` value.
+The nature of floating point representation is such that exact evaluations of
+equality are not guaranteed.
+
+
+##### `TEST_ASSERT_EQUAL_DOUBLE (expected, actual)`
+
+Asserts that the `actual` value is "close enough to be considered equal" to the
+`expected` value. If you are curious about the details, refer to the Advanced
+Asserting section for more details. Omitting a user-specified delta in a
+floating point assertion is both a shorthand convenience and a requirement of
+code generation conventions for CMock.
+
+
+##### `TEST_ASSERT_EQUAL_DOUBLE_ARRAY (expected, actual, num_elements)`
+
+See Array assertion section for details. Note that individual array element
+double comparisons are executed using `TEST_ASSERT_EQUAL_DOUBLE`.That is, user
+specified delta comparison values requires a custom implemented double array
+assertion.
+
+
+##### `TEST_ASSERT_DOUBLE_IS_INF (actual)`
+
+Asserts that `actual` parameter is equivalent to positive infinity floating
+point representation.
+
+
+##### `TEST_ASSERT_DOUBLE_IS_NEG_INF (actual)`
+
+Asserts that `actual` parameter is equivalent to negative infinity floating point
+representation.
+
+
+##### `TEST_ASSERT_DOUBLE_IS_NAN (actual)`
+
+Asserts that `actual` parameter is a Not A Number floating point representation.
+
+
+##### `TEST_ASSERT_DOUBLE_IS_DETERMINATE (actual)`
+
+Asserts that `actual` parameter is a floating point representation usable for
+mathematical operations. That is, the ?actual?parameter is neither positive
+infinity nor negative infinity nor Not A Number floating point representations.
+
+
+##### `TEST_ASSERT_DOUBLE_IS_NOT_INF (actual)`
+
+Asserts that `actual` parameter is a value other than positive infinity floating
+point representation.
+
+
+##### `TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF (actual)`
+
+Asserts that `actual` parameter is a value other than negative infinity floating
+point representation.
+
+
+##### `TEST_ASSERT_DOUBLE_IS_NOT_NAN (actual)`
+
+Asserts that `actual` parameter is a value other than Not A Number floating
+point representation.
+
+
+##### `TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE (actual)`
+
+Asserts that `actual` parameter is not usable for mathematical operations. That
+is, the `actual` parameter is either positive infinity or negative infinity or
+Not A Number floating point representations.
+
+
+## Advanced Asserting: Details On Tricky Assertions
+
+This section helps you understand how to deal with some of the trickier
+assertion situations you may run into. It will give you a glimpse into some of
+the under-the-hood details of Unity's assertion mechanisms. If you're one of
+those people who likes to know what is going on in the background, read on. If
+not, feel free to ignore the rest of this document until you need it.
+
+
+### How do the EQUAL assertions work for FLOAT and DOUBLE?
+
+As you may know, directly checking for equality between a pair of floats or a
+pair of doubles is sloppy at best and an outright no-no at worst. Floating point
+values can often be represented in multiple ways, particularly after a series of
+operations on a value. Initializing a variable to the value of 2.0 is likely to
+result in a floating point representation of 2 x 20,but a series of
+mathematical operations might result in a representation of 8 x 2-2
+that also evaluates to a value of 2. At some point repeated operations cause
+equality checks to fail.
+
+So Unity doesn't do direct floating point comparisons for equality. Instead, it
+checks if two floating point values are "really close." If you leave Unity
+running with defaults, "really close" means "within a significant bit or two."
+Under the hood, `TEST_ASSERT_EQUAL_FLOAT` is really `TEST_ASSERT_FLOAT_WITHIN`
+with the `delta` parameter calculated on the fly. For single precision, delta is
+the expected value multiplied by 0.00001, producing a very small proportional
+range around the expected value.
+
+If you are expecting a value of 20,000.0 the delta is calculated to be 0.2. So
+any value between 19,999.8 and 20,000.2 will satisfy the equality check. This
+works out to be roughly a single bit of range for a single-precision number, and
+that's just about as tight a tolerance as you can reasonably get from a floating
+point value.
+
+So what happens when it's zero? Zero - even more than other floating point
+values - can be represented many different ways. It doesn't matter if you have
+0 x 20 or 0 x 263.It's still zero, right? Luckily, if you
+subtract these values from each other, they will always produce a difference of
+zero, which will still fall between 0 plus or minus a delta of 0. So it still
+works!
+
+Double precision floating point numbers use a much smaller multiplier, again
+approximating a single bit of error.
+
+If you don't like these ranges and you want to make your floating point equality
+assertions less strict, you can change these multipliers to whatever you like by
+defining UNITY_FLOAT_PRECISION and UNITY_DOUBLE_PRECISION. See Unity
+documentation for more.
+
+
+### How do we deal with targets with non-standard int sizes?
+
+It's "fun" that C is a standard where something as fundamental as an integer
+varies by target. According to the C standard, an `int` is to be the target's
+natural register size, and it should be at least 16-bits and a multiple of a
+byte. It also guarantees an order of sizes:
+
+```C
+char <= short <= int <= long <= long long
+```
+
+Most often, `int` is 32-bits. In many cases in the embedded world, `int` is
+16-bits. There are rare microcontrollers out there that have 24-bit integers,
+and this remains perfectly standard C.
+
+To make things even more interesting, there are compilers and targets out there
+that have a hard choice to make. What if their natural register size is 10-bits
+or 12-bits? Clearly they can't fulfill _both_ the requirement to be at least
+16-bits AND the requirement to match the natural register size. In these
+situations, they often choose the natural register size, leaving us with
+something like this:
+
+```C
+char (8 bit) <= short (12 bit) <= int (12 bit) <= long (16 bit)
+```
+
+Um... yikes. It's obviously breaking a rule or two... but they had to break SOME
+rules, so they made a choice.
+
+When the C99 standard rolled around, it introduced alternate standard-size types.
+It also introduced macros for pulling in MIN/MAX values for your integer types.
+It's glorious! Unfortunately, many embedded compilers can't be relied upon to
+use the C99 types (Sometimes because they have weird register sizes as described
+above. Sometimes because they don't feel like it?).
+
+A goal of Unity from the beginning was to support every combination of
+microcontroller or microprocessor and C compiler. Over time, we've gotten really
+close to this. There are a few tricks that you should be aware of, though, if
+you're going to do this effectively on some of these more idiosyncratic targets.
+
+First, when setting up Unity for a new target, you're going to want to pay
+special attention to the macros for automatically detecting types
+(where available) or manually configuring them yourself. You can get information
+on both of these in Unity's documentation.
+
+What about the times where you suddenly need to deal with something odd, like a
+24-bit `int`? The simplest solution is to use the next size up. If you have a
+24-bit `int`, configure Unity to use 32-bit integers. If you have a 12-bit
+`int`, configure Unity to use 16 bits. There are two ways this is going to
+affect you:
+
+1. When Unity displays errors for you, it's going to pad the upper unused bits
+with zeros.
+2. You're going to have to be careful of assertions that perform signed
+operations, particularly `TEST_ASSERT_INT_WITHIN`.Such assertions might wrap
+your `int` in the wrong place, and you could experience false failures. You can
+always back down to a simple `TEST_ASSERT` and do the operations yourself.
+
+
+*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)*

docs/UnityConfigurationGuide.md

@@ -0,0 +1,563 @@
+# Unity Configuration Guide
+
+## C Standards, Compilers and Microcontrollers
+
+The embedded software world contains its challenges. Compilers support different
+revisions of the C Standard. They ignore requirements in places, sometimes to
+make the language more usable in some special regard. Sometimes it's to simplify
+their support. 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
+would be awesome if this could be done with zero configuration. While there are
+some targets that come close to this dream, it is sadly not universal. It is
+likely that you are going to need at least a couple of the configuration options
+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 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
+a native compiler. In either case, you've got a couple choices for configuring
+these options:
+
+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.
+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
+concept of an integer varies from target to target. The C Standard has rules
+about the `int` matching the register size of the target microprocessor. It has
+rules about the `int` and how its size relates to other integer types. An `int`
+on one target might be 16 bits while on another target it might be 64. There are
+more specific types in compilers compliant with C99 or later, but that's
+certainly not every compiler you are likely to encounter. Therefore, Unity has a
+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`
+
+The first thing that Unity does to guess your types is check `stdint.h`.
+This file includes defines like `UINT_MAX` that Unity can use to
+learn a lot about your system. 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`. 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.
+
+_Example:_
+```C
+#define UNITY_EXCLUDE_STDINT_H
+```
+
+
+##### `UNITY_EXCLUDE_LIMITS_H`
+
+The second attempt to guess your types is to check `limits.h`. Some compilers
+that don't support `stdint.h` could include `limits.h` instead. If you don't
+want Unity to check this file either, define this to make it skip the inclusion.
+
+_Example:_
+```C
+#define UNITY_EXCLUDE_LIMITS_H
+```
+
+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.
+
+
+##### `UNITY_INT_WIDTH`
+
+Define this to be the number of bits an `int` takes up on your system. The
+default, if not autodetected, is 32 bits.
+
+_Example:_
+```C
+#define UNITY_INT_WIDTH 16
+```
+
+
+##### `UNITY_LONG_WIDTH`
+
+Define this to be the number of bits a `long` takes up on your system. The
+default, if not autodetected, is 32 bits. This is used to figure out what kind
+of 64-bit support your system can handle. 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:_
+```C
+#define UNITY_LONG_WIDTH 16
+```
+
+
+##### `UNITY_POINTER_WIDTH`
+
+Define this to be the number of bits a pointer takes up on your system. The
+default, if not autodetected, is 32-bits. If you're getting ugly compiler
+warnings about casting from pointers, this is the one to look at.
+
+_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:_
+```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_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:_
+```C
+#define UNITY_SUPPORT_64
+```
+
+
+### Floating Point Types
+
+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. We are able to guess integer sizes on the fly because integers
+are always available in at least one size. Floating point, on the other hand, is
+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_EXCLUDE_FLOAT`
+
+##### `UNITY_INCLUDE_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. 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:_
+```C
+//what manner of strange processor is this?
+#define UNITY_EXCLUDE_FLOAT
+#define UNITY_INCLUDE_DOUBLE
+```
+
+
+##### `UNITY_EXCLUDE_FLOAT_PRINT`
+
+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.
+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”). 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”. If you would like verbose failure messages for floating
+point assertions, use these options to give more explicit failure messages.
+
+_Example:_
+```C
+#define UNITY_EXCLUDE_FLOAT_PRINT
+```
+
+
+##### `UNITY_FLOAT_TYPE`
+
+If enabled, Unity assumes you want your `FLOAT` asserts to compare standard C
+floats. If your compiler supports a specialty floating point type, you can
+always override this behavior by using this definition.
+
+_Example:_
+```C
+#define UNITY_FLOAT_TYPE float16_t
+```
+
+
+##### `UNITY_DOUBLE_TYPE`
+
+If enabled, Unity assumes you want your `DOUBLE` asserts to compare standard C
+doubles. If you would like to change this, you can specify something else by
+using this option. 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`.
+
+_Example:_
+```C
+#define UNITY_DOUBLE_TYPE long double
+```
+
+
+##### `UNITY_FLOAT_PRECISION`
+
+##### `UNITY_DOUBLE_PRECISION`
+
+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. "Close enough" is controlled by these precision
+configuration options. 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. 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:_
+```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 __%i__
+- __%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)
+
+_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("Color Red \033[41mFAIL\033[00m\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
+which will come in handy to customize Unity's behavior for your specific
+toolchain. 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. These macros will help in those
+situations.
+
+
+##### `UNITY_OUTPUT_CHAR(a)`
+
+##### `UNITY_OUTPUT_FLUSH()`
+
+##### `UNITY_OUTPUT_START()`
+
+##### `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. It works on some simulators as well so long as they have `stdout`
+routed back to the command line. There are times, however, where the simulator
+will lack support for dumping results or you will want to route results
+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
+`stdout` option. You decide to route your test result output to a custom serial
+`RS232_putc()` function you wrote like thus:
+```C
+#include "RS232_header.h"
+...
+#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
+specifying `UNITY_USE_FLUSH_STDOUT`. No other defines are required.
+
+
+##### `UNITY_OUTPUT_FOR_ECLIPSE`
+
+##### `UNITY_OUTPUT_FOR_IAR_WORKBENCH`
+
+##### `UNITY_OUTPUT_FOR_QT_CREATOR`
+
+When managing your own builds, it is often handy to have messages output in a format which is
+recognized by your IDE. These are some standard formats which can be supported. 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.
+
+
+##### `UNITY_PTR_ATTRIBUTE`
+
+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.
+
+_Example:_
+```C
+#define UNITY_PTR_ATTRIBUTE __attribute__((far))
+#define UNITY_PTR_ATTRIBUTE near
+```
+
+##### `UNITY_PRINT_EOL`
+
+By default, Unity outputs \n at the end of each line of output. This is easy
+to parse by the scripts, by Ceedling, etc, but it might not be ideal for YOUR
+system. Feel free to override this and to make it whatever you wish.
+
+_Example:_
+```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 assymetry 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.
+
+## Getting Into The Guts
+
+There will be cases where the options above aren't quite going to get everything
+perfect. They are likely sufficient for any situation where you are compiling
+and executing your tests with a native toolchain (e.g. clang on Mac). These
+options may even get you through the majority of cases encountered in working
+with a target simulator run from your local command line. But especially if you
+must run your test suite on your target hardware, your Unity configuration will
+require special help. This special help will usually reside in one of two
+places: the `main()` function or the `RUN_TEST` macro. Let's look at how these
+work.
+
+
+##### `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. This
+`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:
+
+```C
+int main(void) {
+    UNITY_BEGIN();
+    RUN_TEST(test_TheFirst);
+    RUN_TEST(test_TheSecond);
+    RUN_TEST(test_TheThird);
+    return UNITY_END();
+}
+```
+
+You can see that our main function doesn't bother taking any arguments. For our
+most barebones case, we'll never have arguments because we just run all the
+tests each time. Instead, we start by calling `UNITY_BEGIN`. We run each test
+(in whatever order we wish). 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
+after all the test cases have completed. This allows you to do any needed
+system-wide setup or teardown that might be required for your special
+circumstances.
+
+
+##### `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:
+
+```C
+#define RUN_TEST(testfunc) \
+    UNITY_NEW_TEST(#testfunc) \
+    if (TEST_PROTECT()) { \
+        setUp(); \
+        testfunc(); \
+    } \
+    if (TEST_PROTECT() && (!TEST_IS_IGNORED)) \
+        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.
+
+
+## Happy Porting
+
+The defines and macros in this guide should help you port Unity to just about
+any C target we can imagine. If you run into a snag or two, don't be afraid of
+asking for help on the forums. We love a good challenge!
+
+
+*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)*

docs/UnityGettingStartedGuide.md

@@ -0,0 +1,251 @@
+# Unity - Getting Started
+
+## Welcome
+
+Congratulations. You're now the proud owner of your very own pile of bits! 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
+functional. The core Unity test framework is three files: a single C file and a
+couple header files. 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.
+
+
+### Overview of the Documents
+
+#### Unity Assertions reference
+
+This document will guide you through all the assertion options provided by
+Unity. This is going to be your unit testing bread and butter. 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
+previous document. It's perfect for printing and referencing while you
+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
+target or compiler. It'll guide you through the configuration options and will
+help you customize your testing experience to meet your needs.
+
+
+#### Unity Helper Scripts
+
+This document describes the helper scripts that are available for simplifying
+your testing workflow. It describes the collection of optional Ruby scripts
+included in the auto directory of your Unity installation. Neither Ruby nor
+these scripts are necessary for using Unity. They are provided as a convenience
+for those who wish to use them.
+
+
+#### Unity License
+
+What's an open source project without a license file? This brief document
+describes the terms you're agreeing to when you use this software. 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.
+
+
+### Overview of the Folders
+
+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.
+Don't worry, Unity itself is very small. The rest of it is just there to make
+your life easier. You can ignore it or use it at your convenience. 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
+header files. These three files _are_ Unity.
+- `docs` - You're reading this document, so it's possible you have found your way
+into this folder already. This is where all the handy documentation can be
+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
+project. If you've reached us through James Grenning's book, you're going to
+want to look here.
+- `test` - This is how Unity and its scripts are all tested. If you're just using
+Unity, you'll likely never need to go in here. 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.
+- `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
+module that you want to test. 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
+function can contain anything you would like to run before 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 of these blank if you have no need for them.
+
+If you're using Ceedling or the test runner generator script, you may leave these 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
+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
+finally `UNITY_END()`.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.
+
+Remembering to add each test to the main function can get to be tedious. If you
+enjoy using helper scripts in your build process, you might consider making use
+of our handy [generate_test_runner.rb](../auto/generate_test_runner.rb) script.
+This will create the main function and all the calls for you, assuming that you
+have followed the suggested naming 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:
+
+```C
+#include "unity.h"
+#include "file_to_test.h"
+
+void setUp(void) {
+    // set stuff up here
+}
+
+void tearDown(void) {
+    // clean stuff up here
+}
+
+void test_function_should_doBlahAndBlah(void) {
+    //test stuff
+}
+
+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);
+    RUN_TEST(test_function_should_doAlsoDoBlah);
+    return UNITY_END();
+}
+```
+
+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 cleanup 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.
+
+    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.
+
+
+
+## How to Build and Run A Test File
+
+This is the single biggest challenge to picking up a new unit testing framework,
+at least in a language like C or C++. 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"?). 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
+coming from, it might surprise you that neither of these options is running the
+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
+develop them as native applications (using gcc or MSVC for example) or as
+applications running on a simulator. Either is a good option. Native apps have
+the advantages of being faster and easier to set up. Simulator apps have the
+advantage of working with the same compiler as your target application. The
+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
+containing your register set (discussed later).
+
+In either case, a test is built by linking unity, the test file, and the C
+file(s) being tested. These files create an executable which can be run as the
+test set for that module. Then, this process is repeated for the next test file.
+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!
+
+
+*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)*

docs/UnityHelperScriptsGuide.md

@@ -0,0 +1,278 @@
+# Unity Helper Scripts
+
+## 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 of Ruby scripts for making your life just a tad
+easier. They are completely optional. If you choose to use them, you'll need a
+copy of Ruby, of course. Just install whatever the latest version is, and it is
+likely to work. You can find Ruby at [ruby-lang.org](https://ruby-labg.org/).
+
+
+### `generate_test_runner.rb`
+
+Are you tired of creating your own `main` function in your test file? Do you
+keep forgetting to add a `RUN_TEST` call when you add a new test case to your
+suite? 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?
+
+Well then we have the perfect script for you!
+
+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. 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
+function name beginning with "test" or "spec". It treats each of these
+functions as a test case and builds up a test suite of them. For example, the
+following includes three test cases:
+
+```C
+void testVerifyThatUnityIsAwesomeAndWillMakeYourLifeEasier(void)
+{
+  ASSERT_TRUE(1);
+}
+void test_FunctionName_should_WorkProperlyAndReturn8(void) {
+  ASSERT_EQUAL_INT(8, FunctionName());
+}
+void spec_Function_should_DoWhatItIsSupposedToDo(void) {
+  ASSERT_NOT_NULL(Function(5));
+}
+```
+
+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
+the name of the test file and automatically append `_Runner` to the name of the
+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.
+Conveniently, this YAML file is of the same format as that used by Unity and
+CMock. So if you are using YAML files already, you can simply pass the very same
+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
+example below. If you're wondering what some of these options do, you're going
+to love the next section of this document.
+
+```YAML
+:unity:
+  :includes:
+    - stdio.h
+    - microdefs.h
+  :cexception: 1
+  :suit_setup: "blah = malloc(1024);"
+  :suite_teardown: "free(blah);"
+```
+
+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. Just make sure
+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
+builds - or more likely the Ruby-based build tool Rake - is requiring this
+script directly. Anything that you would have specified in a YAML file can be
+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"
+options = {
+  :includes => ["stdio.h", "microdefs.h"],
+  :cexception => 1,
+  :suite_setup => "blah = malloc(1024);",
+  :suite_teardown => "free(blah);"
+}
+UnityTestRunnerGenerator.new.run(testfile, runner_name, options)
+```
+
+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. Like thus:
+
+```Ruby
+gen = UnityTestRunnerGenerator.new(options)
+test_files.each do |f|
+  gen.run(f, File.basename(f,'.c')+"Runner.c"
+end
+```
+
+#### 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.
+
+
+##### `:includes`
+
+This option specifies an array of file names to be `#include`'d at the top of
+your runner C file. You might use it to reference custom types or anything else
+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
+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
+CMock (see CMock documentation). This generates extra variables required for
+everything to run smoothly. If you provide the same YAML to the generator as
+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
+contain only a single plugin). 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. To enable this feature using Ruby:
+
+```Ruby
+:plugins => [ :cexception ]
+```
+
+Or as a yaml file:
+
+```YAML
+:plugins:
+  -:cexception
+```
+
+If you are using CMock, it is very likely that you are already passing an array
+of plugins to CMock. You can just use the same array here. 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)'`.
+
+
+### `unity_test_summary.rb`
+
+A Unity test file contains one or more test case functions. Each test case can
+pass, fail, or be ignored. Each test file is run individually producing results
+for its collection of test cases. A given project will almost certainly be
+composed of multiple test files. Therefore, the suite of tests is comprised of
+one or more test cases spread across one or more test files. This script
+aggregates individual test file results to generate a summary of all executed
+test cases. 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. A good example of the breadth and
+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
+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
+`.testpass` and `.testfail`.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. The script
+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
+are using relative paths in your tools' setup, but you want to pull the summary
+into an IDE like Eclipse for clickable shortcuts.
+
+```Shell
+ruby unity_test_summary.rb build/test/ ~/projects/myproject/
+```
+
+Or, if you're more of a Windows sort of person:
+
+```Shell
+ruby unity_test_summary.rb build\teat\ C:\projects\myproject\
+```
+
+When configured correctly, you'll see a final summary, like so:
+
+```Shell
+--------------------------
+UNITY IGNORED TEST SUMMARY
+--------------------------
+blah.c:22:test_sandwiches_should_HaveBreadOnTwoSides:IGNORE
+
+-------------------------
+UNITY FAILED TEST SUMMARY
+-------------------------
+blah.c:87:test_sandwiches_should_HaveCondiments:FAIL:Expected 1 was 0
+meh.c:38:test_soda_should_BeCalledPop:FAIL:Expected "pop" was "coke"
+
+--------------------------
+OVERALL UNITY TEST SUMMARY
+--------------------------
+45 TOTAL TESTS 2 TOTAL FAILURES 1 IGNORED
+```
+
+How convenient is that?
+
+
+*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)*

docs/license.txt

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

examples/example_1/makefile

@@ -0,0 +1,72 @@
+# ==========================================
+#   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]
+# ==========================================
+
+#We try to detect the OS we are running on, and adjust commands as needed
+ifeq ($(OS),Windows_NT)
+  ifeq ($(shell uname -s),) # not in a bash-like shell
+	CLEANUP = del /F /Q
+	MKDIR = mkdir
+  else # in a bash-like shell, like msys
+	CLEANUP = rm -f
+	MKDIR = mkdir -p
+  endif
+	TARGET_EXTENSION=.exe
+else
+	CLEANUP = rm -f
+	MKDIR = mkdir -p
+	TARGET_EXTENSION=.out
+endif
+
+C_COMPILER=gcc
+ifeq ($(shell uname -s), Darwin)
+C_COMPILER=clang
+endif
+
+UNITY_ROOT=../..
+
+CFLAGS=-std=c89
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -Wpointer-arith
+CFLAGS += -Wcast-align
+CFLAGS += -Wwrite-strings
+CFLAGS += -Wswitch-default
+CFLAGS += -Wunreachable-code
+CFLAGS += -Winit-self
+CFLAGS += -Wmissing-field-initializers
+CFLAGS += -Wno-unknown-pragmas
+CFLAGS += -Wstrict-prototypes
+CFLAGS += -Wundef
+CFLAGS += -Wold-style-definition
+#CFLAGS += -Wno-misleading-indentation
+
+TARGET_BASE1=test1
+TARGET_BASE2=test2
+TARGET1 = $(TARGET_BASE1)$(TARGET_EXTENSION)
+TARGET2 = $(TARGET_BASE2)$(TARGET_EXTENSION)
+SRC_FILES1=$(UNITY_ROOT)/src/unity.c src/ProductionCode.c  test/TestProductionCode.c  test/test_runners/TestProductionCode_Runner.c
+SRC_FILES2=$(UNITY_ROOT)/src/unity.c src/ProductionCode2.c test/TestProductionCode2.c test/test_runners/TestProductionCode2_Runner.c
+INC_DIRS=-Isrc -I$(UNITY_ROOT)/src
+SYMBOLS=
+
+all: clean default
+
+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)
+
+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
+test/test_runners/TestProductionCode2_Runner.c: test/TestProductionCode2.c
+	ruby $(UNITY_ROOT)/auto/generate_test_runner.rb test/TestProductionCode2.c test/test_runners/TestProductionCode2_Runner.c
+
+clean:
+	$(CLEANUP) $(TARGET1) $(TARGET2)
+
+ci: CFLAGS += -Werror
+ci: default

examples/example_1/readme.txt

@@ -0,0 +1,5 @@
+Example 1
+=========
+
+Close to the simplest possible example of Unity, using only basic features.
+Run make to build & run the example tests.

examples/example_1/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_1/src/ProductionCode.h

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

examples/example_1/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_1/src/ProductionCode2.h

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

examples/example_1/test/TestProductionCode.c

@@ -0,0 +1,62 @@
+
+#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_1/test/TestProductionCode2.c

@@ -0,0 +1,31 @@
+
+#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)
+{
+    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_1/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_1/test/test_runners/TestProductionCode_Runner.c

@@ -1,50 +1,57 @@
-/* AUTOGENERATED FILE. DO NOT EDIT. */
+/* AUTOGENERATED FILE. DO NOT EDIT. */
-#include "unity.h"
+
-#include <setjmp.h>
+/*=======Test Runner Used To Run Each Test Below=====*/
-#include <stdio.h>
+#define RUN_TEST(TestFunc, TestLineNum) \
-
+{ \
-char MessageBuffer[50];
+  Unity.CurrentTestName = #TestFunc; \
-
+  Unity.CurrentTestLineNumber = TestLineNum; \
-extern void setUp(void);
+  Unity.NumberOfTests++; \
-extern void tearDown(void);
+  if (TEST_PROTECT()) \
-
+  { \
-extern void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void);
+      setUp(); \
-extern void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void);
+      TestFunc(); \
-extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void);
+  } \
-extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void);
+  if (TEST_PROTECT()) \
-extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void);
+  { \
-
+    tearDown(); \
-static void runTest(UnityTestFunction test)
+  } \
-{
+  UnityConcludeTest(); \
-  if (TEST_PROTECT())
+}
-  {
+
-      setUp();
+/*=======Automagically Detected Files To Include=====*/
-      test();
+#include "unity.h"
-  }
+#include <setjmp.h>
-  if (TEST_PROTECT() && !TEST_IS_IGNORED)
+#include <stdio.h>
-  {
+#include "ProductionCode.h"
-    tearDown();
+
-  }
+/*=======External Functions This Runner Calls=====*/
-}
+extern void setUp(void);
-void resetTest()
+extern void tearDown(void);
-{
+extern void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void);
-  tearDown();
+extern void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void);
-  setUp();
+extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void);
-}
+extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void);
-
+extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void);
-
+
-int main(void)
+
-{
+/*=======Test Reset Option=====*/
-  Unity.TestFile = "test/TestProductionCode.c";
+void resetTest(void);
-  UnityBegin();
+void resetTest(void)
-
+{
-  // RUN_TEST calls runTest
+  tearDown();
-  RUN_TEST(test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode, 20);
+  setUp();
-  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);
+/*=======MAIN=====*/
-
+int main(void)
-  UnityEnd();
+{
-  return 0;
+  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_2/makefile

@@ -0,0 +1,71 @@
+# ==========================================
+#   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]
+# ==========================================
+
+#We try to detect the OS we are running on, and adjust commands as needed
+ifeq ($(OS),Windows_NT)
+  ifeq ($(shell uname -s),) # not in a bash-like shell
+	CLEANUP = del /F /Q
+	MKDIR = mkdir
+  else # in a bash-like shell, like msys
+	CLEANUP = rm -f
+	MKDIR = mkdir -p
+  endif
+	TARGET_EXTENSION=.exe
+else
+	CLEANUP = rm -f
+	MKDIR = mkdir -p
+	TARGET_EXTENSION=.out
+endif
+
+C_COMPILER=gcc
+ifeq ($(shell uname -s), Darwin)
+C_COMPILER=clang
+endif
+
+UNITY_ROOT=../..
+
+CFLAGS=-std=c99
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -Wpointer-arith
+CFLAGS += -Wcast-align
+CFLAGS += -Wwrite-strings
+CFLAGS += -Wswitch-default
+CFLAGS += -Wunreachable-code
+CFLAGS += -Winit-self
+CFLAGS += -Wmissing-field-initializers
+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)
+SRC_FILES1=\
+  $(UNITY_ROOT)/src/unity.c \
+  $(UNITY_ROOT)/extras/fixture/src/unity_fixture.c \
+  src/ProductionCode.c \
+  src/ProductionCode2.c \
+  test/TestProductionCode.c \
+  test/TestProductionCode2.c \
+  test/test_runners/TestProductionCode_Runner.c \
+  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=-DUNITY_FIXTURE_NO_EXTRAS
+
+all: clean default
+
+default:
+	$(C_COMPILER) $(CFLAGS) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES1) -o $(TARGET1)
+	- ./$(TARGET1) -v
+
+clean:
+	$(CLEANUP) $(TARGET1)
+
+ci: CFLAGS += -Werror
+ci: default

examples/example_2/readme.txt

@@ -0,0 +1,5 @@
+Example 2
+=========
+
+Same as the first example, but now using Unity's test fixture to group tests
+together. Using the test fixture also makes writing test runners much easier.

examples/example_2/src/ProductionCode.c

@@ -1,24 +1,24 @@
-
+
-#include "ProductionCode.h"
+#include "ProductionCode.h"
-
+
-int Counter = 0;
+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.
+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)
+// (and should therefore be caught by our tests)
-int FindFunction_WhichIsBroken(int NumberToFind)
+int FindFunction_WhichIsBroken(int NumberToFind)
-{
+{
-    int i = 0;
+    int i = 0;
-    while (i <= 8) //Notice I should have been in braces
+    while (i < 8) //Notice I should have been in braces
-        i++;
+        i++;
-        if (NumbersToFind[i] == NumberToFind) //Yikes!  I'm getting run after the loop finishes instead of during it!
+        if (NumbersToFind[i] == NumberToFind) //Yikes!  I'm getting run after the loop finishes instead of during it!
-            return i;
+            return i;
-    return 0;
+    return 0;
-}
+}
-
+
-int FunctionWhichReturnsLocalVariable(void)
+int FunctionWhichReturnsLocalVariable(void)
-{
+{
-    return Counter;
+    return Counter;
-}
+}

examples/example_2/src/ProductionCode.h

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

examples/example_2/src/ProductionCode2.c

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

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

examples/example_2/test/TestProductionCode.c

@@ -0,0 +1,64 @@
+#include "ProductionCode.h"
+#include "unity.h"
+#include "unity_fixture.h"
+
+TEST_GROUP(ProductionCode);
+
+//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;
+
+TEST_SETUP(ProductionCode)
+{
+  //This is run before EACH TEST
+  Counter = 0x5a5a;
+}
+
+TEST_TEAR_DOWN(ProductionCode)
+{
+}
+
+TEST(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode)
+{
+  //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));
+}
+
+TEST(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken)
+{
+  // 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));
+}
+
+TEST(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue)
+{
+    //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());
+}
+
+TEST(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain)
+{
+    //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());
+}
+
+TEST(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed)
+{
+    //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_2/test/TestProductionCode2.c

@@ -0,0 +1,33 @@
+#include "ProductionCode2.h"
+#include "unity.h"
+#include "unity_fixture.h"
+
+TEST_GROUP(ProductionCode2);
+
+/* These should be ignored because they are commented out in various ways:
+#include "whatever.h"
+*/
+//#include "somethingelse.h"
+
+TEST_SETUP(ProductionCode2)
+{
+}
+
+TEST_TEAR_DOWN(ProductionCode2)
+{
+}
+
+TEST(ProductionCode2, IgnoredTest)
+{
+    TEST_IGNORE_MESSAGE("This Test Was Ignored On Purpose");
+}
+
+TEST(ProductionCode2, AnotherIgnoredTest)
+{
+    TEST_IGNORE_MESSAGE("These Can Be Useful For Leaving Yourself Notes On What You Need To Do Yet");
+}
+
+TEST(ProductionCode2, ThisFunctionHasNotBeenTested_NeedsToBeImplemented)
+{
+    TEST_IGNORE(); //Like This
+}

examples/example_2/test/test_runners/TestProductionCode2_Runner.c

@@ -0,0 +1,9 @@
+#include "unity.h"
+#include "unity_fixture.h"
+
+TEST_GROUP_RUNNER(ProductionCode2)
+{
+  RUN_TEST_CASE(ProductionCode2, IgnoredTest);
+  RUN_TEST_CASE(ProductionCode2, AnotherIgnoredTest);
+  RUN_TEST_CASE(ProductionCode2, ThisFunctionHasNotBeenTested_NeedsToBeImplemented);
+}

examples/example_2/test/test_runners/TestProductionCode_Runner.c

@@ -0,0 +1,11 @@
+#include "unity.h"
+#include "unity_fixture.h"
+
+TEST_GROUP_RUNNER(ProductionCode)
+{
+  RUN_TEST_CASE(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode);
+  RUN_TEST_CASE(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken);
+  RUN_TEST_CASE(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue);
+  RUN_TEST_CASE(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain);
+  RUN_TEST_CASE(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed);
+}

examples/example_2/test/test_runners/all_tests.c

@@ -0,0 +1,12 @@
+#include "unity_fixture.h"
+
+static void RunAllTests(void)
+{
+  RUN_TEST_GROUP(ProductionCode);
+  RUN_TEST_GROUP(ProductionCode2);
+}
+
+int main(int argc, const char * argv[])
+{
+  return UnityMain(argc, argv, RunAllTests);
+}

examples/example_3/helper/UnityHelper.c

@@ -1,10 +1,10 @@
-#include "unity.h"
+#include "unity.h"
-#include "UnityHelper.h"
+#include "UnityHelper.h"
-#include <stdio.h>
+#include <stdio.h>
-#include <string.h>
+#include <string.h>
-
+
-void AssertEqualExampleStruct(const EXAMPLE_STRUCT_T expected, const EXAMPLE_STRUCT_T actual, const unsigned short line)
+void AssertEqualExampleStruct(const EXAMPLE_STRUCT_T expected, const EXAMPLE_STRUCT_T actual, const unsigned short line)
-{
+{
-    UNITY_TEST_ASSERT_EQUAL_INT(expected.x, actual.x, line, "Example Struct Failed For Field x");
+    UNITY_TEST_ASSERT_EQUAL_INT(expected.x, actual.x, line, "Example Struct Failed For Field x");
-    UNITY_TEST_ASSERT_EQUAL_INT(expected.y, actual.y, line, "Example Struct Failed For Field y");
+    UNITY_TEST_ASSERT_EQUAL_INT(expected.y, actual.y, line, "Example Struct Failed For Field y");
-}
+}

examples/example_3/helper/UnityHelper.h

@@ -1,12 +1,12 @@
-#ifndef _TESTHELPER_H
+#ifndef _TESTHELPER_H
-#define _TESTHELPER_H
+#define _TESTHELPER_H
-
+
-#include "Types.h"
+#include "Types.h"
-
+
-void AssertEqualExampleStruct(const EXAMPLE_STRUCT_T expected, const EXAMPLE_STRUCT_T actual, const unsigned short line);
+void AssertEqualExampleStruct(const EXAMPLE_STRUCT_T expected, const EXAMPLE_STRUCT_T actual, const unsigned short line);
-
+
-#define UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, line, message) AssertEqualExampleStruct(expected, actual, line);
+#define UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, line, message) AssertEqualExampleStruct(expected, actual, line);
-
+
-#define TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual) UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, __LINE__, NULL);
+#define TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual) UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, __LINE__, NULL);
-
+
-#endif // _TESTHELPER_H
+#endif // _TESTHELPER_H

examples/example_3/rakefile.rb

@@ -0,0 +1,38 @@
+require 'rake'
+require 'rake/clean'
+require_relative 'rakefile_helper'
+
+TEMP_DIRS = [
+  File.join(__dir__, 'build')
+].freeze
+
+TEMP_DIRS.each do |dir|
+  directory(dir)
+  CLOBBER.include(dir)
+end
+
+task prepare_for_tests: TEMP_DIRS
+
+# Load default configuration, for now
+DEFAULT_CONFIG_FILE = 'target_gcc_32.yml'.freeze
+configure_toolchain(DEFAULT_CONFIG_FILE)
+
+task unit: [:prepare_for_tests] do
+  run_tests unit_test_files
+end
+
+desc 'Generate test summary'
+task :summary do
+  report_summary
+end
+
+desc 'Build and test Unity'
+task all: %i[clean unit summary]
+task default: %i[clobber all]
+task ci: [:default]
+task cruise: [:default]
+
+desc 'Load configuration'
+task :config, :config_file do |_t, args|
+  configure_toolchain(args[:config_file])
+end

examples/example_3/rakefile_helper.rb

@@ -0,0 +1,250 @@
+require 'yaml'
+require 'fileutils'
+require_relative '../../auto/unity_test_summary'
+require_relative '../../auto/generate_test_runner'
+require_relative '../../auto/colour_reporter'
+
+C_EXTENSION = '.c'.freeze
+
+def load_configuration(config_file)
+  $cfg_file = config_file
+  $cfg = YAML.load(File.read($cfg_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$/
+  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 find_source_file(header, paths)
+  paths.each do |dir|
+    src_file = dir + header.ext(C_EXTENSION)
+    return src_file if File.exist?(src_file)
+  end
+  nil
+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'])
+            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
+  cmd_str  = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{file} " \
+             "#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}"
+  obj_file = "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}"
+  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
+  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 !$?.nil? && !$?.exitstatus.zero? && raise_on_fail
+    raise "Command failed. (Returned #{$?.exitstatus})"
+  end
+
+  output
+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 = []
+
+    # 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]}"
+              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/readme.txt

@@ -0,0 +1,13 @@
+Example 3
+=========
+
+This example project gives an example of some passing, ignored, and failing tests.
+It's simple and meant for you to look over and get an idea for what all of this stuff does.
+
+You can build and test using rake. The rake version will let you test with gcc or a couple
+versions of IAR.  You can tweak the yaml files to get those versions running.
+
+Ruby is required if you're using the rake version (obviously).  This version shows off most of
+Unity's advanced features (automatically creating test runners, fancy summaries, etc.)
+Without ruby, you have to maintain your own test runners.  Do that for a while and you'll learn
+why you really want to start using the Ruby tools.

examples/example_3/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_3/src/ProductionCode.h

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

examples/example_3/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_3/src/ProductionCode2.h

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

examples/example_3/target_gcc_32.yml

@@ -1,44 +1,47 @@
-compiler:
+# Copied from ~Unity/targets/gcc_32.yml
-  path: gcc
+unity_root:  &unity_root '../..'
-  source_path:     'src/'
+unity_source: &unity_source '../../src/'
-  unit_tests_path: &unit_tests_path 'test/'
+compiler:
-  build_path:      &build_path 'build/'
+  path: gcc
-  options:
+  source_path:     &source_path 'src/'
-    - '-c'
+  unit_tests_path: &unit_tests_path 'test/'
-    - '-m32'
+  build_path:      &build_path 'build/'
-    - '-Wall'
+  options:
-    - '-Wno-address'
+    - '-c'
-    - '-std=c99'
+    - '-m32'
-    - '-pedantic'
+    - '-Wall'
-  includes:
+    - '-Wno-address'
-    prefix: '-I'
+    - '-std=c99'
-    items:
+    - '-pedantic'
-      - 'src/'
+  includes:
-      - '../src/'
+    prefix: '-I'
-      - *unit_tests_path
+    items:
-  defines:
+      - *source_path
-    prefix: '-D'
+      - *unity_source
-    items:
+      - *unit_tests_path
-      - UNITY_INCLUDE_DOUBLE
+  defines:
-      - UNITY_SUPPORT_TEST_CASES
+    prefix: '-D'
-  object_files:
+    items:
-    prefix: '-o'
+      - UNITY_INCLUDE_DOUBLE
-    extension: '.o'
+      - UNITY_SUPPORT_TEST_CASES
-    destination: *build_path
+  object_files:
-linker:
+    prefix: '-o'
-  path: gcc
+    extension: '.o'
-  options:
+    destination: *build_path
-    - -lm
+linker:
-    - '-m32'
+  path: gcc
-  includes:
+  options:
-    prefix: '-I'
+    - -lm
-  object_files:
+    - '-m32'
-    path: *build_path
+  includes:
-    extension: '.o'
+    prefix: '-I'
-  bin_files:
+  object_files:
-    prefix: '-o'
+    path: *build_path
-    extension: '.exe'
+    extension: '.o'
-    destination: *build_path
+  bin_files:
-colour: true
+    prefix: '-o'
-:unity:
+    extension: '.exe'
-  :plugins: []
+    destination: *build_path
+colour: true
+:unity:
+  :plugins: []

examples/example_3/test/TestProductionCode.c

@@ -1,62 +1,62 @@
-
+
-#include "ProductionCode.h"
+#include "ProductionCode.h"
-#include "unity.h"
+#include "unity.h"
-
+
-//sometimes you may want to get at local data in a module.
+//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
+//for example: If you plan to pass by reference, this could be useful
-//however, it should often be avoided
+//however, it should often be avoided
-extern int Counter; 
+extern int Counter; 
-
+
-void setUp(void)
+void setUp(void)
-{
+{
-  //This is run before EACH TEST
+  //This is run before EACH TEST
-  Counter = 0x5a5a;
+  Counter = 0x5a5a;
-}
+}
-
+
-void tearDown(void)
+void tearDown(void)
-{
+{
-}
+}
-
+
-void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void)
+void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void)
-{
+{
-  //All of these should pass
+  //All of these should pass
-  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78));
-  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(1));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(1));
-  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33));
-  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999));
-  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1));
-}
+}
-
+
-void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void)
+void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void)
-{
+{
-  // You should see this line fail in your test summary
+  // You should see this line fail in your test summary
-  TEST_ASSERT_EQUAL(1, FindFunction_WhichIsBroken(34));
+  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.
+  // Then NEXT test function runs as normal.
-  TEST_ASSERT_EQUAL(8, FindFunction_WhichIsBroken(8888));
+  TEST_ASSERT_EQUAL(8, FindFunction_WhichIsBroken(8888));
-}
+}
-
+
-void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void)
+void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void)
-{
+{
-    //This should be true because setUp set this up for us before this test
+    //This should be true because setUp set this up for us before this test
-    TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable());
+    TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable());
-    
+    
-    //This should be true because we can still change our answer
+    //This should be true because we can still change our answer
-    Counter = 0x1234;
+    Counter = 0x1234;
-    TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable());
+    TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable());
-}
+}
-
+
-void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void)
+void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void)
-{
+{
-    //This should be true again because setup was rerun before this test (and after we changed it to 0x1234)
+    //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());
+    TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable());
-}
+}
-
+
-void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void)
+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
+    //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.
+    // you what actually happened...which in this case was a failure to setup the initial condition.
-    TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable());
+    TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable());
-}
+}

examples/example_3/test/TestProductionCode2.c

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

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')
+
+unity_dep = dependency('unity', fallback : ['unity', 'unity_dep'])
+
+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,4 @@
+[wrap-git]
+directory = unity
+url = https://github.com/ThrowTheSwitch/Unity.git
+revision = head

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('Running: 01-test-case', executable('01-test-case', cases[0], dependencies: [ a_dep, unity_dep ]))
+test('Running: 02-test-case', executable('02-test-case', cases[1], dependencies: [ b_dep, unity_dep ]))

examples/makefile

@@ -1,40 +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]
-# ========================================== 
-
-C_COMPILER=gcc
-TARGET_BASE1=test1
-TARGET_BASE2=test2
-ifeq ($(OS),Windows_NT)
-	TARGET_EXTENSION=.exe
-else
-	TARGET_EXTENSION=.out
-endif
-TARGET1 = $(TARGET_BASE1)$(TARGET_EXTENSION)
-TARGET2 = $(TARGET_BASE2)$(TARGET_EXTENSION)
-SRC_FILES1=../src/unity.c src/ProductionCode.c  test/TestProductionCode.c  test/no_ruby/TestProductionCode_Runner.c
-SRC_FILES2=../src/unity.c src/ProductionCode2.c test/TestProductionCode2.c test/no_ruby/TestProductionCode2_Runner.c
-INC_DIRS=-Isrc -I../src
-SYMBOLS=-DTEST
-
-ifeq ($(OS),Windows_NT)
-	CLEANUP = del /F /Q build\* && del /F /Q $(TARGET1) && del /F /Q $(TARGET2)
-else
-	CLEANUP = rm -f build/*.o ; rm -f $(TARGET1) ; rm -f $(TARGET2)
-endif
-
-all: clean default
-
-default:
-#	ruby auto/generate_test_runner.rb test/TestProductionCode.c  test/no_ruby/TestProductionCode_Runner.c
-#	ruby auto/generate_test_runner.rb test/TestProductionCode2.c test/no_ruby/TestProductionCode2_Runner.c
-	$(C_COMPILER) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES1) -o $(TARGET1)
-	$(C_COMPILER) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES2) -o $(TARGET2)
-	$(TARGET1)
-	$(TARGET2)
-
-clean:
-	$(CLEANUP)
-	

examples/rakefile.rb

@@ -1,32 +0,0 @@
-HERE = File.expand_path(File.dirname(__FILE__)) + '/'
-
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require HERE+'rakefile_helper'
-
-include RakefileHelpers
-
-# Load default configuration, for now
-DEFAULT_CONFIG_FILE = 'gcc.yml'
-configure_toolchain(DEFAULT_CONFIG_FILE)
-
-task :unit do
-  run_tests get_unit_test_files
-end
-
-desc "Generate test summary"
-task :summary do
-  report_summary
-end
-
-desc "Build and test Unity"
-task :all => [:clean, :unit, :summary]
-task :default => [:clobber, :all]
-task :ci => [:default]
-task :cruise => [:default]
-
-desc "Load configuration"
-task :config, :config_file do |t, args|
-  configure_toolchain(args[:config_file])
-end

examples/rakefile_helper.rb

@@ -1,256 +0,0 @@
-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'
-  
-  def load_configuration(config_file)
-    $cfg_file = "../targets/#{config_file}"
-    $cfg = YAML.load(File.read($cfg_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$/
-    load_configuration('../targets/'+config_file)
-    configure_clean
-  end
-  
-  def get_unit_test_files
-    path = $cfg['compiler']['unit_tests_path'] + 'Test*' + C_EXTENSION
-    path.gsub!(/\\/, '/')
-    FileList.new(path)
-  end
-  
-  def get_local_include_dirs
-    include_dirs = $cfg['compiler']['includes']['items'].dup
-    include_dirs.delete_if {|dir| dir.is_a?(Array)}
-    return 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*\"/)
-      if not m.nil?
-        includes << m[1]
-      end
-    end
-    return includes
-  end
-
-  def find_source_file(header, paths)
-    paths.each do |dir|
-      src_file = dir + header.ext(C_EXTENSION)
-      if (File.exists?(src_file))
-        return src_file
-      end
-    end
-    return nil
-  end
-  
-  def tackit(strings)
-    if strings.is_a?(Array)
-      result = "\"#{strings.join}\""
-    else
-      result = strings
-    end
-    return result
-  end
-  
-  def squash(prefix, items)
-    result = ''
-    items.each { |item| result += " #{prefix}#{tackit(item)}" }
-    return result
-  end
-
-  def build_compiler_fields
-    command  = tackit($cfg['compiler']['path'])
-    if $cfg['compiler']['defines']['items'].nil?
-      defines  = ''
-    else
-      defines  = 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)
-    return {:command => command, :defines => defines, :options => options, :includes => includes}
-  end
-
-  def compile(file, defines=[])
-    compiler = build_compiler_fields
-    cmd_str  = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{file} " +
-               "#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}"
-    obj_file = "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}"
-    execute(cmd_str + obj_file)
-    return obj_file
-  end
-  
-  def build_linker_fields
-    command  = tackit($cfg['linker']['path'])
-    if $cfg['linker']['options'].nil?
-      options  = ''
-    else
-      options  = squash('', $cfg['linker']['options'])
-    end
-    if ($cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil?)
-      includes = ''
-    else
-      includes = squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items'])
-    end
-    includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
-    return {: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?
-    if $cfg['simulator']['path'].nil?
-      command = ''
-    else
-      command = (tackit($cfg['simulator']['path']) + ' ')
-    end
-    if $cfg['simulator']['pre_support'].nil?
-      pre_support = ''
-    else
-      pre_support = squash('', $cfg['simulator']['pre_support'])
-    end
-    if $cfg['simulator']['post_support'].nil?
-      post_support = ''
-    else
-      post_support = squash('', $cfg['simulator']['post_support'])
-    end
-    return {: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.length > 0))
-    if (($?.exitstatus != 0) and (raise_on_fail))
-      raise "Command failed. (Returned #{$?.exitstatus})"
-    end
-    return output
-  end
-  
-  def report_summary
-    summary = UnityTestSummary.new
-    summary.set_root_path(HERE)
-    results_glob = "#{$cfg['compiler']['build_path']}*.test*"
-    results_glob.gsub!(/\\/, '/')
-    results = Dir[results_glob]
-    summary.set_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 = get_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)
-        if !src_file.nil?
-          obj_list << compile(src_file, test_defines)
-        end
-      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']
-      if simulator.nil?
-        cmd_str = executable
-      else
-        cmd_str = "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}"
-      end
-      output = execute(cmd_str, true, false)
-      test_results = $cfg['compiler']['build_path'] + test_base
-      if output.match(/OK$/m).nil?
-        test_results += '.testfail'
-      else
-        test_results += '.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)
-      if !src_file.nil?
-        obj_list << compile(src_file)
-      end
-    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
-    exit(-1)
-  end
-end

examples/readme.txt

@@ -1,18 +0,0 @@
-Example Project
-
-This example project gives an example of some passing, ignored, and failing tests.
-It's simple and meant for you to look over and get an idea for what all of this stuff does.
-
-You can build and test using the makefile if you have gcc installed (you may need to tweak
-the locations of some tools in the makefile).  Otherwise, the rake version will let you
-test with gcc or a couple versions of IAR.  You can tweak the yaml files to get those versions
-running.
-
-Ruby is required if you're using the rake version (obviously).  This version shows off most of
-Unity's advanced features (automatically creating test runners, fancy summaries, etc.)  
-
-The makefile version doesn't require anything outside of your normal build tools, but won't do the
-extras for you.  So that you can test right away, we've written the test runners for you and 
-put them in the test\no_ruby subdirectory.  If you make changes to the tests or source, you might
-need to update these (like when you add or remove tests).  Do that for a while and you'll learn
-why you really want to start using the Ruby tools.

examples/test/no_ruby/TestProductionCode2_Runner.c

@@ -1,46 +0,0 @@
-/* AUTOGENERATED FILE. DO NOT EDIT. */
-#include "unity.h"
-#include <setjmp.h>
-#include <stdio.h>
-
-char MessageBuffer[50];
-
-extern void setUp(void);
-extern void tearDown(void);
-
-extern void test_IgnoredTest(void);
-extern void test_AnotherIgnoredTest(void);
-extern void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void);
-
-static void runTest(UnityTestFunction test)
-{
-  if (TEST_PROTECT())
-  {
-      setUp();
-      test();
-  }
-  if (TEST_PROTECT() && !TEST_IS_IGNORED)
-  {
-    tearDown();
-  }
-}
-void resetTest()
-{
-  tearDown();
-  setUp();
-}
-
-
-int main(void)
-{
-  Unity.TestFile = "test/TestProductionCode2.c";
-  UnityBegin();
-
-  // RUN_TEST calls runTest
-  RUN_TEST(test_IgnoredTest, 13);
-  RUN_TEST(test_AnotherIgnoredTest, 18);
-  RUN_TEST(test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented, 23);
-
-  UnityEnd();
-  return 0;
-}

examples/unity_config.h

@@ -0,0 +1,244 @@
+/* Unity Configuration
+ * As of May 11th, 2016 at ThrowTheSwitch/Unity commit 837c529
+ * Update: December 29th, 2016
+ * See Also: Unity/docs/UnityConfigurationGuide.pdf
+ *
+ * Unity is designed to run on almost anything that is targeted by a C compiler.
+ * It would be awesome if this could be done with zero configuration. While
+ * there are some targets that come close to this dream, it is sadly not
+ * universal. It is likely that you are going to need at least a couple of the
+ * configuration options 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.
+ *
+ * Using These Options
+ * It doesn't matter if you're using a target-specific compiler and a simulator
+ * or a native compiler. In either case, you've got a couple choices for
+ * configuring these options:
+ *
+ *  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.
+ *  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.
+ */
+
+#ifndef UNITY_CONFIG_H
+#define UNITY_CONFIG_H
+
+/* ************************* AUTOMATIC INTEGER TYPES ***************************
+ * C's concept of an integer varies from target to target. The C Standard has
+ * rules about the `int` matching the register size of the target
+ * microprocessor. It has rules about the `int` and how its size relates to
+ * other integer types. An `int` on one target might be 16 bits while on another
+ * target it might be 64. There are more specific types in compilers compliant
+ * with C99 or later, but that's certainly not every compiler you are likely to
+ * encounter. Therefore, Unity has a number of features for helping to adjust
+ * itself to match your required integer sizes. It starts off by trying to do it
+ * automatically.
+ **************************************************************************** */
+
+/* The first attempt to guess your types is to check `limits.h`. Some compilers
+ * that don't support `stdint.h` could include `limits.h`. If you don't
+ * want Unity to check this file, define this to make it skip the inclusion.
+ * Unity looks at UINT_MAX & ULONG_MAX, which were available since C89.
+ */
+/* #define UNITY_EXCLUDE_LIMITS_H */
+
+/* The second thing that Unity does to guess your types is check `stdint.h`.
+ * This file defines `UINTPTR_MAX`, since C99, that Unity can make use of to
+ * learn about your system. It's possible you don't want it to do this or it's
+ * possible that your system doesn't 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.
+ */
+/* #define UNITY_EXCLUDE_STDINT_H */
+
+/* ********************** MANUAL INTEGER TYPE DEFINITION ***********************
+ * If you've disabled all of the automatic options above, you're going to have
+ * to do the configuration yourself. There are just a handful of defines that
+ * you are going to specify if you don't like the defaults.
+ **************************************************************************** */
+
+ /* Define this to be the number of bits an `int` takes up on your system. The
+ * default, if not auto-detected, is 32 bits.
+ *
+ * Example:
+ */
+/* #define UNITY_INT_WIDTH 16 */
+
+/* Define this to be the number of bits a `long` takes up on your system. The
+ * default, if not autodetected, is 32 bits. This is used to figure out what
+ * kind of 64-bit support your system can handle.  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_LONG_WIDTH 16 */
+
+/* Define this to be the number of bits a pointer takes up on your system. The
+ * default, if not autodetected, is 32-bits. If you're getting ugly compiler
+ * warnings about casting from pointers, this is the one to look at.
+ *
+ * Example:
+ */
+/* #define UNITY_POINTER_WIDTH 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.
+ */
+/* #define UNITY_INCLUDE_64 */
+
+
+/* *************************** FLOATING POINT TYPES ****************************
+ * 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. We are able to guess integer sizes on the fly because
+ * integers are always available in at least one size. Floating point, on the
+ * other hand, is 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.
+ **************************************************************************** */
+
+ /* 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. You may include neither, just float,
+  * or both, as suits your needs.
+  */
+/* #define UNITY_EXCLUDE_FLOAT  */
+/* #define UNITY_INCLUDE_DOUBLE */
+/* #define UNITY_EXCLUDE_DOUBLE */
+
+/* For features that are enabled, the following floating point options also
+ * become available.
+ */
+
+/* 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. To keep Unity universal, though, we eventually chose to develop
+ * our own floating point print routines. Still, the display of floating point
+ * values during a failure are optional. By default, Unity will print the
+ * actual results of floating point assertion failures. So a failed assertion
+ * will produce a message like "Expected 4.0 Was 4.25". If you would like less
+ * verbose failure messages for floating point assertions, use this option to
+ * give a failure message `"Values Not Within Delta"` and trim the binary size.
+ */
+/* #define UNITY_EXCLUDE_FLOAT_PRINT */
+
+/* If enabled, Unity assumes you want your `FLOAT` asserts to compare standard C
+ * floats. If your compiler supports a specialty floating point type, you can
+ * always override this behavior by using this definition.
+ *
+ * Example:
+ */
+/* #define UNITY_FLOAT_TYPE float16_t */
+
+/* If enabled, Unity assumes you want your `DOUBLE` asserts to compare standard
+ * C doubles. If you would like to change this, you can specify something else
+ * by using this option. 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`.
+ *
+ * Example:
+ */
+/* #define UNITY_DOUBLE_TYPE long double */
+
+/* If you look up `UNITY_ASSERT_EQUAL_FLOAT` and `UNITY_ASSERT_EQUAL_DOUBLE` as
+ * documented in the 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. "Close enough" is controlled by these precision
+ * configuration options. 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. 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  */
+/* #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
+ * toolchain. 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 operate properly. These macros will help in those
+ * situations.
+ **************************************************************************** */
+
+/* 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. It works on some simulators as well so long as they have `stdout`
+ * routed back to the command line. There are times, however, where the
+ * simulator will lack support for dumping results or you will want to route
+ * results 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
+ * `stdout` option. You decide to route your test result output to a custom
+ * serial `RS232_putc()` function you wrote like thus:
+ */
+/* #define UNITY_OUTPUT_CHAR(a)                    RS232_putc(a) */
+/* #define UNITY_OUTPUT_CHAR_HEADER_DECLARATION    RS232_putc(int) */
+/* #define UNITY_OUTPUT_FLUSH()                    RS232_flush() */
+/* #define UNITY_OUTPUT_FLUSH_HEADER_DECLARATION   RS232_flush(void) */
+/* #define UNITY_OUTPUT_START()                    RS232_config(115200,1,8,0) */
+/* #define UNITY_OUTPUT_COMPLETE()                 RS232_close() */
+
+/* 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.
+ *
+ * Example:
+ */
+/* #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/eclipse/error_parsers.txt

@@ -0,0 +1,26 @@
+Eclipse error parsers
+=====================
+
+These are a godsend for extracting  & quickly navigating to
+warnings & error messages from console output. Unforunately
+I don't know how to write an Eclipse plugin so you'll have
+to add them manually.
+
+To add a console parser to Eclipse, go to Window --> Preferences
+--> C/C++ --> Build --> Settings. Click on the 'Error Parsers'
+tab and then click the 'Add...' button. See the table below for
+the parser fields to add.
+
+Eclipse will only parse the console output during a build, so
+running your unit tests must be part of your build process.
+Either add this to your make/rakefile, or add it as a post-
+build step in your Eclipse project settings.
+
+
+Unity unit test error parsers
+-----------------------------
+Severity    Pattern                                 File    Line    Description
+-------------------------------------------------------------------------------
+Error       (\.+)(.*?):(\d+):(.*?):FAIL: (.*)       $2      $3      $5
+Warning     (\.+)(.*?):(\d+):(.*?):IGNORE: (.*)     $2      $3      $5
+Warning     (\.+)(.*?):(\d+):(.*?):IGNORE\s*$       $2      $3      Ignored test

extras/fixture/build/MakefileWorker.mk

@@ -1,331 +0,0 @@
-#---------
-#
-# MakefileWorker.mk
-#
-# Include this helper file in your makefile
-# It makes
-#    A static library holding the application objs
-#    A test executable
-#
-# See this example for parameter settings 
-#    examples/Makefile
-#
-#----------
-# Inputs - these variables describe what to build
-#
-#   INCLUDE_DIRS - Directories used to search for include files.
-#                   This generates a -I for each directory
-#	SRC_DIRS - Directories containing source file to built into the library
-#   SRC_FILES - Specific source files to build into library. Helpful when not all code 
-#				in a directory can be built for test (hopefully a temporary situation)
-#	TEST_SRC_DIRS - Directories containing unit test code build into the unit test runner
-#				These do not go in a library. They are explicitly included in the test runner
-#	MOCKS_SRC_DIRS - Directories containing mock source files to build into the test runner
-#				These do not go in a library. They are explicitly included in the test runner
-#----------
-# You can adjust these variables to influence how to build the test target
-# and where to put and name outputs
-# See below to determine defaults
-#   COMPONENT_NAME - the name of the thing being built
-#   UNITY_HOME - where Unity home dir found
-#   UNITY_BUILD_HOME - place for scripts
-#   UNITY_OBJS_DIR - a directory where o and d files go
-#   UNITY_LIB_DIR - a directory where libs go
-#   UNITY_ENABLE_DEBUG - build for debug
-#   UNITY_USE_MEM_LEAK_DETECTION - Links with overridden new and delete
-#   UNITY_USE_STD_CPP_LIB - Set to N to keep the standard C++ library out
-#		of the test harness
-#   UNITY_USE_GCOV - Turn on coverage analysis
-#		Clean then build with this flag set to Y, then 'make gcov'
-#	UNITY_TEST_RUNNER_FLAGS
-#		None by default
-#   UNITY_MAPFILE - generate a map file
-#   UNITY_WARNINGFLAGS - overly picky by default
-#	OTHER_MAKEFILE_TO_INCLUDE - a hook to use this makefile to make 
-#		other targets. Like CSlim, which is part of fitnesse
-#----------
-#
-#  Other flags users can initialize to sneak in their settings
-#	UNITY_CFLAGS - C complier
-#	UNITY_LDFLAGS - Linker flags
-#----------
-
-
-ifndef COMPONENT_NAME
-    COMPONENT_NAME = name_this_in_the_makefile
-endif
-
-# Debug on by default
-ifndef UNITY_ENABLE_DEBUG
-	UNITY_ENABLE_DEBUG = Y
-endif
-
-# new and delete for memory leak detection on by default
-ifndef UNITY_USE_MEM_LEAK_DETECTION
-	UNITY_USE_MEM_LEAK_DETECTION = Y
-endif
-
-# Use gcov, off by default
-ifndef UNITY_USE_GCOV
-	UNITY_USE_GCOV = N
-endif
-
-# Default warnings
-ifndef UNITY_WARNINGFLAGS
-	UNITY_WARNINGFLAGS = -Wall -Werror -Wshadow -Wswitch-default 
-endif
-
-# Default dir for temporary files (d, o)
-ifndef UNITY_OBJS_DIR
-    UNITY_OBJS_DIR = objs
-endif
-
-# Default dir for the outout library
-ifndef UNITY_LIB_DIR
-    UNITY_LIB_DIR = lib
-endif
-
-# No map by default
-ifndef UNITY_MAP_FILE
-	UNITY_MAP_FILE = N
-endif
-
-#Not verbose by deafult
-ifdef VERBOSE
-	UNITY_TEST_RUNNER_FLAGS += -v
-endif
-
-ifdef GROUP
-	UNITY_TEST_RUNNER_FLAGS += -g $(GROUP)
-endif
-
-ifdef NAME
-	UNITY_TEST_RUNNER_FLAGS += -n $(NAME)
-endif
-
-ifdef REPEAT
-	UNITY_TEST_RUNNER_FLAGS += -r $(REPEAT)
-endif
-
-
-# --------------------------------------
-# derived flags in the following area
-# --------------------------------------
-ifeq ($(UNITY_USE_MEM_LEAK_DETECTION), N)
-	UNITY_CFLAGS += -DUNITY_MEM_LEAK_DETECTION_DISABLED
-else
-	UNITY_MEMLEAK_DETECTOR_MALLOC_MACRO_FILE = -include $(UNITY_HOME)/extras/fixture/src/unity_fixture_malloc_overrides.h
-endif
-
-ifeq ($(UNITY_ENABLE_DEBUG), Y)
-	UNITY_CFLAGS += -g
-endif
-
-ifeq ($(UNITY_USE_GCOV), Y)
-	UNITY_CFLAGS += -fprofile-arcs -ftest-coverage
-endif
-
-UNITY_CFLAGS += $(UNITY_MEMLEAK_DETECTOR_MALLOC_MACRO_FILE)
-
-TARGET_MAP = $(COMPONENT_NAME).map.txt
-ifeq ($(UNITY_MAP_FILE), Y)
-	UNITY_LDFLAGS += -Wl,-map,$(TARGET_MAP)
-endif
-
-LD_LIBRARIES += -lgcov
-
-TARGET_LIB = \
-    $(UNITY_LIB_DIR)/lib$(COMPONENT_NAME).a
-    
-TEST_TARGET = \
-    $(COMPONENT_NAME)_tests
-
-#Helper Functions
-get_src_from_dir  = $(wildcard $1/*.cpp) $(wildcard $1/*.c)
-get_dirs_from_dirspec  = $(wildcard $1)
-get_src_from_dir_list = $(foreach dir, $1, $(call get_src_from_dir,$(dir)))
-__src_to = $(subst .c,$1, $(subst .cpp,$1,$2))
-src_to = $(addprefix $(UNITY_OBJS_DIR)/,$(call __src_to,$1,$2))
-src_to_o = $(call src_to,.o,$1)
-src_to_d = $(call src_to,.d,$1)
-src_to_gcda = $(call src_to,.gcda,$1)
-src_to_gcno = $(call src_to,.gcno,$1)
-make_dotdot_a_subdir = $(subst ..,_dot_dot, $1)
-time = $(shell date +%s)
-delta_t = $(eval minus, $1, $2)
-debug_print_list = $(foreach word,$1,echo "  $(word)";) echo;
-
-#Derived
-STUFF_TO_CLEAN += $(TEST_TARGET) $(TEST_TARGET).exe $(TARGET_LIB) $(TARGET_MAP)
-
-SRC += $(call get_src_from_dir_list, $(SRC_DIRS)) $(SRC_FILES)			        
-OBJ = $(call src_to_o,$(SRC))
-OBJ2 = $(call make_dotdot_a_subdir. $(OBJ))
-
-STUFF_TO_CLEAN += $(OBJ)
-
-TEST_SRC = $(call get_src_from_dir_list, $(TEST_SRC_DIRS))
-TEST_OBJS = $(call src_to_o,$(TEST_SRC))
-STUFF_TO_CLEAN += $(TEST_OBJS)
-
-
-MOCKS_SRC = $(call get_src_from_dir_list, $(MOCKS_SRC_DIRS))
-MOCKS_OBJS = $(call src_to_o,$(MOCKS_SRC))
-STUFF_TO_CLEAN += $(MOCKS_OBJS)
-
-ALL_SRC = $(SRC) $(TEST_SRC) $(MOCKS_SRC)
-
-#Test coverage with gcov
-GCOV_OUTPUT = gcov_output.txt
-GCOV_REPORT = gcov_report.txt
-GCOV_ERROR = gcov_error.txt
-GCOV_GCDA_FILES = $(call src_to_gcda, $(ALL_SRC))
-GCOV_GCNO_FILES = $(call src_to_gcno, $(ALL_SRC))
-TEST_OUTPUT = $(TEST_TARGET).txt
-STUFF_TO_CLEAN += \
-	$(GCOV_OUTPUT)\
-	$(GCOV_REPORT)\
-	$(GCOV_REPORT).html\
-	$(GCOV_ERROR)\
-	$(GCOV_GCDA_FILES)\
-	$(GCOV_GCNO_FILES)\
-	$(TEST_OUTPUT)
-
-
-#The gcda files for gcov need to be deleted before each run
-#To avoid annoying messages.
-GCOV_CLEAN = $(SILENCE)rm -f $(GCOV_GCDA_FILES) $(GCOV_OUTPUT) $(GCOV_REPORT) $(GCOV_ERROR)
-RUN_TEST_TARGET = $(SILENCE)  $(GCOV_CLEAN) ; echo "Running $(TEST_TARGET)"; ./$(TEST_TARGET) $(UNITY_TEST_RUNNER_FLAGS)
-
-INCLUDES_DIRS_EXPANDED = $(call get_dirs_from_dirspec, $(INCLUDE_DIRS))
-INCLUDES += $(foreach dir, $(INCLUDES_DIRS_EXPANDED), -I$(dir))
-MOCK_DIRS_EXPANDED = $(call get_dirs_from_dirspec, $(MOCKS_SRC_DIRS))
-INCLUDES += $(foreach dir, $(MOCK_DIRS_EXPANDED), -I$(dir))
-
-
-DEP_FILES = $(call src_to_d, $(ALL_SRC))
-STUFF_TO_CLEAN += $(DEP_FILES) $(PRODUCTION_CODE_START) $(PRODUCTION_CODE_END)
-STUFF_TO_CLEAN += $(STDLIB_CODE_START) $(MAP_FILE) cpputest_*.xml junit_run_output
-
-# We'll use the UNITY_CFLAGS etc so that you can override AND add to the CppUTest flags
-CFLAGS = $(UNITY_CFLAGS) $(UNITY_ADDITIONAL_CFLAGS) $(INCLUDES) $(UNITY_WARNINGFLAGS)
-LDFLAGS = $(UNITY_LDFLAGS) $(UNITY_ADDITIONAL_LDFLAGS)
-
-# Targets
-
-.PHONY: all
-all: start $(TEST_TARGET)  
-	$(RUN_TEST_TARGET)	
-
-.PHONY: start
-start: $(TEST_TARGET) 
-	$(SILENCE)START_TIME=$(call time)
-
-.PHONY: all_no_tests
-all_no_tests: $(TEST_TARGET)
-
-.PHONY: flags
-flags: 
-	@echo
-	@echo "Compile C source with CFLAGS:"
-	@$(call debug_print_list,$(CFLAGS))
-	@echo "Link with LDFLAGS:"
-	@$(call debug_print_list,$(LDFLAGS))
-	@echo "Link with LD_LIBRARIES:"
-	@$(call debug_print_list,$(LD_LIBRARIES))
-	@echo "Create libraries with ARFLAGS:"
-	@$(call debug_print_list,$(ARFLAGS))
-	@echo "OBJ files:"
-	@$(call debug_print_list,$(OBJ2))
-	
-	
-$(TEST_TARGET): $(TEST_OBJS) $(MOCKS_OBJS)  $(PRODUCTION_CODE_START) $(TARGET_LIB) $(USER_LIBS) $(PRODUCTION_CODE_END) $(STDLIB_CODE_START) 
-	$(SILENCE)echo Linking $@
-	$(SILENCE)$(LINK.o) -o $@ $^ $(LD_LIBRARIES)
-
-$(TARGET_LIB): $(OBJ)
-	$(SILENCE)echo Building archive $@
-	$(SILENCE)mkdir -p lib
-	$(SILENCE)$(AR) $(ARFLAGS) $@ $^
-	$(SILENCE)ranlib $@
-
-test: $(TEST_TARGET)
-	$(RUN_TEST_TARGET) | tee $(TEST_OUTPUT)
-	
-vtest: $(TEST_TARGET)
-	$(RUN_TEST_TARGET) -v  | tee $(TEST_OUTPUT)
-
-$(UNITY_OBJS_DIR)/%.o: %.cpp
-	@echo compiling $(notdir $<)
-	$(SILENCE)mkdir -p $(dir $@)
-	$(SILENCE)$(COMPILE.cpp) -MMD -MP $(OUTPUT_OPTION) $<
-
-$(UNITY_OBJS_DIR)/%.o: %.c
-	@echo compiling $(notdir $<)
-	$(SILENCE)mkdir -p $(dir $@)
-	$(SILENCE)$(COMPILE.c) -MMD -MP  $(OUTPUT_OPTION) $<
-
-ifneq "$(MAKECMDGOALS)" "clean"
--include $(DEP_FILES)
-endif
-
-.PHONY: clean
-clean:
-	$(SILENCE)echo Making clean
-	$(SILENCE)$(RM) $(STUFF_TO_CLEAN)
-	$(SILENCE)rm -rf gcov $(UNITY_OBJS_DIR)
-	$(SILENCE)find . -name "*.gcno" | xargs rm -f
-	$(SILENCE)find . -name "*.gcda" | xargs rm -f
-	
-#realclean gets rid of all gcov, o and d files in the directory tree
-#not just the ones made by this makefile
-.PHONY: realclean
-realclean: clean
-	$(SILENCE)rm -rf gcov
-	$(SILENCE)find . -name "*.gdcno" | xargs rm -f
-	$(SILENCE)find . -name "*.[do]" | xargs rm -f	
-
-gcov: test
-	$(SILENCE)for d in $(SRC_DIRS) ; do \
-		gcov --object-directory $(UNITY_OBJS_DIR)/$$d $$d/*.c $$d/*.cpp >> $(GCOV_OUTPUT) 2>>$(GCOV_ERROR) ; \
-	done
-	$(SILENCE)for f in $(SRC_FILES) ; do \
-		gcov --object-directory $(UNITY_OBJS_DIR)/$$f $$f >> $(GCOV_OUTPUT) 2>>$(GCOV_ERROR) ; \
-	done
-	$(UNITY_BUILD_HOME)/filterGcov.sh $(GCOV_OUTPUT) $(GCOV_ERROR) $(GCOV_REPORT) $(TEST_OUTPUT)
-	$(SILENCE)cat $(GCOV_REPORT)
-	$(SILENCE)mkdir -p gcov
-	$(SILENCE)mv *.gcov gcov
-	$(SILENCE)mv gcov_* gcov
-	$(SILENCE)echo "See gcov directory for details"
- 
-debug:
-	@echo
-	@echo "Target Source files:"
-	@$(call debug_print_list,$(SRC))
-	@echo "Target Object files:"
-	@$(call debug_print_list,$(OBJ))
-	@echo "Test Source files:"
-	@$(call debug_print_list,$(TEST_SRC))
-	@echo "Test Object files:"
-	@$(call debug_print_list,$(TEST_OBJS))
-	@echo "Mock Source files:"
-	@$(call debug_print_list,$(MOCKS_SRC))
-	@echo "Mock Object files:"
-	@$(call debug_print_list,$(MOCKS_OBJS))
-	@echo "All Input Dependency files:"
-	@$(call debug_print_list,$(DEP_FILES))
-	@echo Stuff to clean:
-	@$(call debug_print_list,$(STUFF_TO_CLEAN))
-	@echo Includes:
-	@$(call debug_print_list,$(INCLUDES))
-
-ifneq "$(OTHER_MAKEFILE_TO_INCLUDE)" ""
--include $(OTHER_MAKEFILE_TO_INCLUDE)
-endif
-
-	
-	
-st,$(TEST_SRC))
-	@echo "Test Object files:"
-	@$(call debug_print

extras/fixture/build/filterGcov.sh

@@ -1,61 +0,0 @@
-#!/bin/bash
-INPUT_FILE=$1
-TEMP_FILE1=${INPUT_FILE}1.tmp
-TEMP_FILE2=${INPUT_FILE}2.tmp
-TEMP_FILE3=${INPUT_FILE}3.tmp
-ERROR_FILE=$2
-OUTPUT_FILE=$3
-HTML_OUTPUT_FILE=$3.html
-TEST_RESULTS=$4
-
-flattenGcovOutput() {
-while read line1
-do
-  read line2
-  echo $line2 " " $line1 
-  read junk
-  read junk
-done < ${INPUT_FILE}
-}
-
-getRidOfCruft() {
-sed '-e s/^Lines.*://g' \
-    '-e s/^[0-9]\./  &/g' \
-    '-e s/^[0-9][0-9]\./ &/g' \
-    '-e s/of.*File/ /g' \
-    "-e s/'//g" \
-    '-e s/^.*\/usr\/.*$//g' \
-    '-e s/^.*\.$//g' 
-}
-
-getFileNameRootFromErrorFile() {
-sed '-e s/gc..:cannot open .* file//g' ${ERROR_FILE}
-}
-
-writeEachNoTestCoverageFile() {
-while read line
-do
-  echo "  0.00%  " ${line}
-done 
-}
-
-createHtmlOutput() {
-    echo "<table border="2" cellspacing="5" cellpadding="5">"
-    echo "<tr><th>Coverage</th><th>File</th></tr>"
-    sed "-e s/.*%   /<tr><td>&<\/td><td>/" \
-        "-e s/[a-zA-Z0-9_]*\.[ch][a-z]*/<a href='file:\.\/&.gcov'>&<\/a><\/td><\/tr>/" 
-    echo "</table>"
-    sed "-e s/.*/&<br>/g" < ${TEST_RESULTS}
-}
-
-
-flattenGcovOutput | getRidOfCruft  > ${TEMP_FILE1}
-getFileNameRootFromErrorFile | writeEachNoTestCoverageFile > ${TEMP_FILE2}
-cat ${TEMP_FILE1}  ${TEMP_FILE2} | sort | uniq > ${OUTPUT_FILE}
-createHtmlOutput < ${OUTPUT_FILE} > ${HTML_OUTPUT_FILE}
-rm -f ${TEMP_FILE1} ${TEMP_FILE2} 
-erage</th><th>File</th></tr>"
-    sed "-e s/.*%   /<tr><td>&<\/td><td>/" \
-        "-e s/[a-zA-Z0-9_]*\.[ch][a-z]*/<a href='file:\.\/&.gcov'>&<\/a><\/td><\/tr>/" 
-    echo "</table>"
-    sed "-e s/.*/&<br>/g" < ${TEST_RESULTS

extras/fixture/rakefile.rb

@@ -1,37 +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'
-
-include RakefileHelpers
-
-# Load default configuration, for now
-DEFAULT_CONFIG_FILE = 'gcc.yml'
-configure_toolchain(DEFAULT_CONFIG_FILE)
-
-task :unit do
-  run_tests
-end
-
-desc "Build and test Unity Framework"
-task :all => [:clean, :unit]
-task :default => [:clobber, :all]
-task :ci => [:no_color, :default]
-task :cruise => [: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'
-  
-  def load_configuration(config_file)
-    unless ($configured)
-      $cfg_file = HERE+"../../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
-  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)
-    if strings.is_a?(Array)
-      result = "\"#{strings.join}\""
-    else
-      result = strings
-    end
-    return result
-  end
-  
-  def squash(prefix, items)
-    result = ''
-    items.each { |item| result += " #{prefix}#{tackit(item)}" }
-    return result
-  end
-
-  def build_compiler_fields
-    command  = tackit($cfg['compiler']['path'])
-    if $cfg['compiler']['defines']['items'].nil?
-      defines  = ''
-    else
-      defines  = squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar'])
-    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)
-    return {: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'])
-    if $cfg['linker']['options'].nil?
-      options  = ''
-    else
-      options  = squash('', $cfg['linker']['options'])
-    end
-    if ($cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil?)
-      includes = ''
-    else
-      includes = squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items'])
-    end
-    includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
-    return {:command => command, :options => options, :includes => includes}
-  end
-  
-  def link(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?
-    if $cfg['simulator']['path'].nil?
-      command = ''
-    else
-      command = (tackit($cfg['simulator']['path']) + ' ')
-    end
-    if $cfg['simulator']['pre_support'].nil?
-      pre_support = ''
-    else
-      pre_support = squash('', $cfg['simulator']['pre_support'])
-    end
-    if $cfg['simulator']['post_support'].nil?
-      post_support = ''
-    else
-      post_support = squash('', $cfg['simulator']['post_support'])
-    end
-    return {: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.length > 0))
-    if ($?.exitstatus != 0)
-      raise "Command failed. (Returned #{$?.exitstatus})"
-    end
-    return output
-  end
-  
-  def report_summary
-    summary = UnityTestSummary.new
-    summary.set_root_path(HERE)
-    results_glob = "#{$cfg['compiler']['build_path']}*.test*"
-    results_glob.gsub!(/\\/, '/')
-    results = Dir[results_glob]
-    summary.set_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 << '../../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(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']
-    if simulator.nil?
-      cmd_str = executable + " -v -r"
-    else
-      cmd_str = "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}"
-    end
-    output = execute(cmd_str)
-    test_results = $cfg['compiler']['build_path'] + test_base
-    if output.match(/OK$/m).nil?
-      test_results += '.testfail'
-    else
-      test_results += '.testpass'
-    end
-    File.open(test_results, 'w') { |f| f.print output }
-  end
-end

extras/fixture/readme.md

@@ -0,0 +1,29 @@
+# Unity Fixtures
+
+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.
+
+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/unity_fixture.c

@@ -1,34 +1,33 @@
-//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
-/* ==========================================
+ * ==========================================
-    Unity Project - A Test Framework for C
+ *  Unity Project - A Test Framework for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+ *  Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
+ *  [Released under MIT License. Please refer to license.txt for details]
-========================================== */
+ * ========================================== */
 
 #include "unity_fixture.h"
 #include "unity_internals.h"
 #include <string.h>
 
-UNITY_FIXTURE_T UnityFixture;
+struct UNITY_FIXTURE_T UnityFixture;
 
-//If you decide to use the function pointer approach.
+/* If you decide to use the function pointer approach.
-int (*outputChar)(int) = putchar;
+ * Build with -D UNITY_OUTPUT_CHAR=outputChar and include <stdio.h>
-
+ * int (*outputChar)(int) = putchar; */
-int verbose = 0;
 
 void setUp(void)    { /*does nothing*/ }
 void tearDown(void) { /*does nothing*/ }
 
-void announceTestRun(unsigned int runNumber)
+static void announceTestRun(unsigned int runNumber)
 {
     UnityPrint("Unity test run ");
-    UnityPrintNumber(runNumber+1);
+    UnityPrintNumberUnsigned(runNumber+1);
     UnityPrint(" of ");
-    UnityPrintNumber(UnityFixture.RepeatCount);
+    UnityPrintNumberUnsigned(UnityFixture.RepeatCount);
-    UNITY_OUTPUT_CHAR('\n');
+    UNITY_PRINT_EOL();
 }
 
-int UnityMain(int argc, char* argv[], void (*runAllTests)())
+int UnityMain(int argc, const char* argv[], void (*runAllTests)(void))
 {
     int result = UnityGetCommandLineOptions(argc, argv);
     unsigned int r;
@@ -37,17 +36,17 @@ int UnityMain(int argc, char* argv[], void (*runAllTests)())
 
     for (r = 0; r < UnityFixture.RepeatCount; r++)
     {
+        UnityBegin(argv[0]);
         announceTestRun(r);
-        UnityBegin();
         runAllTests();
-        UNITY_OUTPUT_CHAR('\n');
+        if (!UnityFixture.Verbose) UNITY_PRINT_EOL();
         UnityEnd();
     }
 
-    return UnityFailureCount();
+    return (int)Unity.TestFailures;
 }
 
-static int selected(const char * filter, const char * name)
+static int selected(const char* filter, const char* name)
 {
     if (filter == 0)
         return 1;
@@ -64,35 +63,41 @@ static int groupSelected(const char* group)
     return selected(UnityFixture.GroupFilter, group);
 }
 
-static void runTestCase()
-{
-
-}
-
 void UnityTestRunner(unityfunction* setup,
-        unityfunction* testBody,
+                     unityfunction* testBody,
-        unityfunction* teardown,
+                     unityfunction* teardown,
-        const char * printableName,
+                     const char* printableName,
-        const char * group,
+                     const char* group,
-        const char * name,
+                     const char* name,
-        const char * file, int line)
+                     const char* file,
+                     unsigned int line)
 {
     if (testSelected(name) && groupSelected(group))
     {
-        Unity.CurrentTestFailed = 0;
         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();
 
-        runTestCase();
+        UNITY_EXEC_TIME_START();
+
         if (TEST_PROTECT())
         {
             setup();
@@ -105,210 +110,79 @@ void UnityTestRunner(unityfunction* setup,
         if (TEST_PROTECT())
         {
             UnityPointer_UndoAllSets();
-            if (!Unity.CurrentTestFailed)
+        }
-                UnityMalloc_EndTest();
+        UnityConcludeFixtureTest();
-            UnityConcludeFixtureTest();
+    }
+}
+
+void UnityIgnoreTest(const char* printableName, const char* group, const char* name)
+{
+    if (testSelected(name) && groupSelected(group))
+    {
+        Unity.NumberOfTests++;
+        Unity.TestIgnores++;
+        if (UnityFixture.Verbose)
+        {
+            UnityPrint(printableName);
+            UNITY_PRINT_EOL();
+        }
+        else if (UnityFixture.Silent)
+        {
+            /* Do Nothing */
         }
         else
         {
-            //aborting - jwg - di i need these for the other TEST_PROTECTS?
+            UNITY_OUTPUT_CHAR('!');
         }
     }
 }
 
-void UnityIgnoreTest()
+/*-------------------------------------------------------- */
+/*Automatic pointer restoration functions */
+struct PointerPair
 {
-    Unity.NumberOfTests++;
+    void** pointer;
-    Unity.CurrentTestIgnored = 1;
+    void* old_value;
-    UNITY_OUTPUT_CHAR('!');
+};
-}
 
-
+static struct PointerPair pointer_store[UNITY_MAX_POINTERS];
-//-------------------------------------------------
-//Malloc and free stuff
-//
-#define MALLOC_DONT_FAIL -1
-static int malloc_count;
-static int malloc_fail_countdown = MALLOC_DONT_FAIL;
-
-void UnityMalloc_StartTest()
-{
-    malloc_count = 0;
-    malloc_fail_countdown = MALLOC_DONT_FAIL;
-}
-
-void UnityMalloc_EndTest()
-{
-    malloc_fail_countdown = MALLOC_DONT_FAIL;
-    if (malloc_count != 0)
-    {
-        TEST_FAIL_MESSAGE("This test leaks!");
-    }
-}
-
-void UnityMalloc_MakeMallocFailAfterCount(int countdown)
-{
-    malloc_fail_countdown = countdown;
-}
-
-#ifdef malloc
-#undef malloc
-#endif
-
-#ifdef free
-#undef free
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-
-typedef struct GuardBytes
-{
-    int size;
-    char guard[sizeof(int)];
-} Guard;
-
-
-static const char * end = "END";
-
-void * unity_malloc(size_t size)
-{
-    char* mem;
-    Guard* guard;
-
-    if (malloc_fail_countdown != MALLOC_DONT_FAIL)
-    {
-        if (malloc_fail_countdown == 0)
-            return 0;
-        malloc_fail_countdown--;
-    }
-
-    malloc_count++;
-
-    guard = (Guard*)malloc(size + sizeof(Guard) + 4);
-    guard->size = size;
-    mem = (char*)&(guard[1]);
-    memcpy(&mem[size], end, strlen(end) + 1);
-
-    return (void*)mem;
-}
-
-static int isOverrun(void * mem)
-{
-    Guard* guard = (Guard*)mem;
-    char* memAsChar = (char*)mem;
-    guard--;
-
-    return strcmp(&memAsChar[guard->size], end) != 0;
-}
-
-static void release_memory(void * mem)
-{
-    Guard* guard = (Guard*)mem;
-    guard--;
-
-    malloc_count--;
-    free(guard);
-}
-
-void unity_free(void * mem)
-{
-    int overrun = isOverrun(mem);//strcmp(&memAsChar[guard->size], end) != 0;
-    release_memory(mem);
-    if (overrun)
-    {
-        TEST_FAIL_MESSAGE("Buffer overrun detected during free()");
-    }
-}
-
-void* unity_calloc(size_t num, size_t size)
-{
-    void* mem = unity_malloc(num * size);
-    memset(mem, 0, num*size);
-    return mem;
-}
-
-void* unity_realloc(void * oldMem, size_t size)
-{
-    Guard* guard = (Guard*)oldMem;
-//    char* memAsChar = (char*)oldMem;
-    void* newMem;
-
-    if (oldMem == 0)
-        return unity_malloc(size);
-
-    guard--;
-    if (isOverrun(oldMem))
-    {
-        release_memory(oldMem);
-        TEST_FAIL_MESSAGE("Buffer overrun detected during realloc()");
-    }
-
-    if (size == 0)
-    {
-        release_memory(oldMem);
-        return 0;
-    }
-
-    if (guard->size >= size)
-        return oldMem;
-
-    newMem = unity_malloc(size);
-    memcpy(newMem, oldMem, size);
-    unity_free(oldMem);
-    return newMem;
-}
-
-
-//--------------------------------------------------------
-//Automatic pointer restoration functions
-typedef struct _PointerPair
-{
-    struct _PointerPair * next;
-    void ** pointer;
-    void * old_value;
-} PointerPair;
-
-enum {MAX_POINTERS=50};
-static PointerPair pointer_store[MAX_POINTERS];
 static int pointer_index = 0;
 
-void UnityPointer_Init()
+void UnityPointer_Init(void)
 {
     pointer_index = 0;
 }
 
-void UnityPointer_Set(void ** pointer, void * newValue)
+void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line)
 {
-    if (pointer_index >= MAX_POINTERS)
+    if (pointer_index >= UNITY_MAX_POINTERS)
-        TEST_FAIL_MESSAGE("Too many pointers set");
+    {
-
+        UNITY_TEST_FAIL(line, "Too many pointers set");
-    pointer_store[pointer_index].pointer = pointer;
+    }
-    pointer_store[pointer_index].old_value = *pointer;
+    else
-    *pointer = newValue;
+    {
-    pointer_index++;
+        pointer_store[pointer_index].pointer = pointer;
+        pointer_store[pointer_index].old_value = *pointer;
+        *pointer = newValue;
+        pointer_index++;
+    }
 }
 
-void UnityPointer_UndoAllSets()
+void UnityPointer_UndoAllSets(void)
 {
     while (pointer_index > 0)
     {
         pointer_index--;
         *(pointer_store[pointer_index].pointer) =
-        pointer_store[pointer_index].old_value;
+            pointer_store[pointer_index].old_value;
-
     }
 }
 
-int UnityFailureCount()
+int UnityGetCommandLineOptions(int argc, const char* argv[])
-{
-    return Unity.TestFailures;
-}
-
-int UnityGetCommandLineOptions(int argc, char* argv[])
 {
     int i;
     UnityFixture.Verbose = 0;
+    UnityFixture.Silent = 0;
     UnityFixture.GroupFilter = 0;
     UnityFixture.NameFilter = 0;
     UnityFixture.RepeatCount = 1;
@@ -318,11 +192,51 @@ int UnityGetCommandLineOptions(int argc, 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++;
@@ -347,35 +261,50 @@ int UnityGetCommandLineOptions(int argc, char* argv[])
             {
                 if (*(argv[i]) >= '0' && *(argv[i]) <= '9')
                 {
-                    UnityFixture.RepeatCount = atoi(argv[i]);
+                    unsigned int digit = 0;
+                    UnityFixture.RepeatCount = 0;
+                    while (argv[i][digit] >= '0' && argv[i][digit] <= '9')
+                    {
+                        UnityFixture.RepeatCount *= 10;
+                        UnityFixture.RepeatCount += (unsigned int)argv[i][digit++] - '0';
+                    }
                     i++;
                 }
             }
         }
+        else
+        {
+            /* ignore unknown parameter */
+            i++;
+        }
     }
     return 0;
 }
 
-void UnityConcludeFixtureTest()
+void UnityConcludeFixtureTest(void)
 {
     if (Unity.CurrentTestIgnored)
     {
         Unity.TestIgnores++;
+        UNITY_PRINT_EOL();
     }
     else if (!Unity.CurrentTestFailed)
     {
         if (UnityFixture.Verbose)
         {
-            UnityPrint(" PASS");
+            UnityPrint(" ");
-            UNITY_OUTPUT_CHAR('\n');
+            UnityPrint(UnityStrPass);
+            UNITY_EXEC_TIME_STOP();
+            UNITY_PRINT_EXEC_TIME();
+            UNITY_PRINT_EOL();
         }
     }
-    else if (Unity.CurrentTestFailed)
+    else /* Unity.CurrentTestFailed */
     {
         Unity.TestFailures++;
+        UNITY_PRINT_EOL();
     }
 
     Unity.CurrentTestFailed = 0;
     Unity.CurrentTestIgnored = 0;
 }
-

extras/fixture/src/unity_fixture.h

@@ -1,81 +1,83 @@
-//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
-/* ==========================================
+ * ==========================================
-    Unity Project - A Test Framework for C
+ *  Unity Project - A Test Framework for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+ *  Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
+ *  [Released under MIT License. Please refer to license.txt for details]
-========================================== */
+ * ========================================== */
 
 #ifndef UNITY_FIXTURE_H_
 #define UNITY_FIXTURE_H_
 
 #include "unity.h"
 #include "unity_internals.h"
-#include "unity_fixture_malloc_overrides.h"
 #include "unity_fixture_internals.h"
 
-int UnityMain(int argc, char* argv[], void (*runAllTests)());
+#ifndef UNITY_FIXTURE_NO_EXTRAS
+#include "unity_memory.h"
+#endif
+
+int UnityMain(int argc, const char* argv[], void (*runAllTests)(void));
 
 
 #define TEST_GROUP(group)\
-    int TEST_GROUP_##group = 0
+    static const char* TEST_GROUP_##group = #group
 
-#define TEST_SETUP(group) void TEST_##group##_SETUP()
+#define TEST_SETUP(group) void TEST_##group##_SETUP(void);\
+    void TEST_##group##_SETUP(void)
 
-#define TEST_TEAR_DOWN(group) void TEST_##group##_TEAR_DOWN()
+#define TEST_TEAR_DOWN(group) void TEST_##group##_TEAR_DOWN(void);\
+    void TEST_##group##_TEAR_DOWN(void)
 
 
 #define TEST(group, name) \
-    void TEST_##group##_##name##_();\
+    void TEST_##group##_##name##_(void);\
-    void TEST_##group##_##name##_run()\
+    void TEST_##group##_##name##_run(void);\
+    void TEST_##group##_##name##_run(void)\
     {\
         UnityTestRunner(TEST_##group##_SETUP,\
-             TEST_##group##_##name##_,\
+            TEST_##group##_##name##_,\
             TEST_##group##_TEAR_DOWN,\
             "TEST(" #group ", " #name ")",\
-            #group, #name,\
+            TEST_GROUP_##group, #name,\
             __FILE__, __LINE__);\
     }\
-    void  TEST_##group##_##name##_()
+    void  TEST_##group##_##name##_(void)
 
 #define IGNORE_TEST(group, name) \
-    void TEST_##group##_##name##_();\
+    void TEST_##group##_##name##_(void);\
-    void TEST_##group##_##name##_run()\
+    void TEST_##group##_##name##_run(void);\
+    void TEST_##group##_##name##_run(void)\
     {\
-        UnityIgnoreTest();\
+        UnityIgnoreTest("IGNORE_TEST(" #group ", " #name ")", TEST_GROUP_##group, #name);\
     }\
-    void  TEST_##group##_##name##_()
+    void TEST_##group##_##name##_(void)
-
-#define DECLARE_TEST_CASE(group, name) \
-    void TEST_##group##_##name##_run()
 
+/* Call this for each test, insider the group runner */
 #define RUN_TEST_CASE(group, name) \
-        DECLARE_TEST_CASE(group, name);\
+    { void TEST_##group##_##name##_run(void);\
-    TEST_##group##_##name##_run();
+      TEST_##group##_##name##_run(); }
 
-//This goes at the bottom of each test file or in a separate c file
+/* This goes at the bottom of each test file or in a separate c file */
 #define TEST_GROUP_RUNNER(group)\
-    void TEST_##group##_GROUP_RUNNER_runAll();\
+    void TEST_##group##_GROUP_RUNNER(void);\
-    void TEST_##group##_GROUP_RUNNER()\
+    void TEST_##group##_GROUP_RUNNER(void)
-    {\
-        TEST_##group##_GROUP_RUNNER_runAll();\
-    }\
-    void TEST_##group##_GROUP_RUNNER_runAll()
 
-//Call this from main
+/* Call this from main */
 #define RUN_TEST_GROUP(group)\
-    void TEST_##group##_GROUP_RUNNER();\
+    { void TEST_##group##_GROUP_RUNNER(void);\
-    TEST_##group##_GROUP_RUNNER();
+      TEST_##group##_GROUP_RUNNER(); }
 
-//CppUTest Compatibility Macros
+/* CppUTest Compatibility Macros */
-#define UT_PTR_SET(ptr, newPointerValue)               UnityPointer_Set((void**)&ptr, (void*)newPointerValue)
+#ifndef UNITY_EXCLUDE_CPPUTEST_ASSERTS
-#define TEST_ASSERT_POINTERS_EQUAL(expected, actual)   TEST_ASSERT_EQUAL_PTR(expected, actual)
+/* Sets a pointer and automatically restores it to its old value after teardown */
+#define UT_PTR_SET(ptr, newPointerValue)               UnityPointer_Set((void**)&(ptr), (void*)(newPointerValue), __LINE__)
+#define TEST_ASSERT_POINTERS_EQUAL(expected, actual)   TEST_ASSERT_EQUAL_PTR((expected), (actual))
 #define TEST_ASSERT_BYTES_EQUAL(expected, actual)      TEST_ASSERT_EQUAL_HEX8(0xff & (expected), 0xff & (actual))
-#define FAIL(message)                                  TEST_FAIL((message))
+#define FAIL(message)                                  TEST_FAIL_MESSAGE((message))
 #define CHECK(condition)                               TEST_ASSERT_TRUE((condition))
 #define LONGS_EQUAL(expected, actual)                  TEST_ASSERT_EQUAL_INT((expected), (actual))
 #define STRCMP_EQUAL(expected, actual)                 TEST_ASSERT_EQUAL_STRING((expected), (actual))
-#define DOUBLES_EQUAL(expected, actual, delta)         TEST_ASSERT_FLOAT_WITHIN(((expected), (actual), (delta))
+#define DOUBLES_EQUAL(expected, actual, delta)         TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual))
-
+#endif
-void UnityMalloc_MakeMallocFailAfterCount(int count);
 
 #endif /* UNITY_FIXTURE_H_ */

extras/fixture/src/unity_fixture_internals.h

@@ -1,44 +1,50 @@
-//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
-/* ==========================================
+ * ==========================================
-    Unity Project - A Test Framework for C
+ *  Unity Project - A Test Framework for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+ *  Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
+ *  [Released under MIT License. Please refer to license.txt for details]
-========================================== */
+ * ========================================== */
 
 #ifndef UNITY_FIXTURE_INTERNALS_H_
 #define UNITY_FIXTURE_INTERNALS_H_
 
-typedef struct _UNITY_FIXTURE_T
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct UNITY_FIXTURE_T
 {
     int Verbose;
+    int Silent;
     unsigned int RepeatCount;
     const char* NameFilter;
     const char* GroupFilter;
-} UNITY_FIXTURE_T;
+};
+extern struct UNITY_FIXTURE_T UnityFixture;
 
-typedef void unityfunction();
+typedef void unityfunction(void);
-void UnityTestRunner(unityfunction * setup,
+void UnityTestRunner(unityfunction* setup,
-        unityfunction * body,
+                     unityfunction* testBody,
-        unityfunction * teardown,
+                     unityfunction* teardown,
-        const char * printableName,
+                     const char* printableName,
-        const char * group,
+                     const char* group,
-        const char * name,
+                     const char* name,
-        const char * file, int line);
+                     const char* file, unsigned int line);
 
-void UnityIgnoreTest();
+void UnityIgnoreTest(const char* printableName, const char* group, const char* name);
-void UnityMalloc_StartTest();
+int UnityGetCommandLineOptions(int argc, const char* argv[]);
-void UnityMalloc_EndTest();
+void UnityConcludeFixtureTest(void);
-int UnityFailureCount();
-int UnityGetCommandLineOptions(int argc, char* argv[]);
-void UnityConcludeFixtureTest();
 
-void UnityPointer_Set(void ** ptr, void * newValue);
+void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line);
-void UnityPointer_UndoAllSets();
+void UnityPointer_UndoAllSets(void);
-void UnityPointer_Init();
+void UnityPointer_Init(void);
+#ifndef UNITY_MAX_POINTERS
+#define UNITY_MAX_POINTERS 5
+#endif
 
-void UnityAssertEqualPointer(const void * expected,
+#ifdef __cplusplus
-                            const void * actual,
+}
-                            const char* msg,
+#endif
-                            const UNITY_LINE_TYPE lineNumber);
 
 #endif /* UNITY_FIXTURE_INTERNALS_H_ */

extras/fixture/src/unity_fixture_malloc_overrides.h

@@ -1,16 +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]
-========================================== */
-
-#ifndef UNITY_FIXTURE_MALLOC_OVERRIDES_H_
-#define UNITY_FIXTURE_MALLOC_OVERRIDES_H_
-
-#define malloc  unity_malloc
-#define calloc  unity_calloc
-#define realloc unity_realloc
-#define free    unity_free
-
-#endif /* UNITY_FIXTURE_MALLOC_OVERRIDES_H_ */

extras/fixture/test/Makefile

@@ -0,0 +1,72 @@
+CC = gcc
+ifeq ($(shell uname -s), Darwin)
+CC = clang
+endif
+#DEBUG = -O0 -g
+CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror -DUNITY_FIXTURE_NO_EXTRAS
+CFLAGS += $(DEBUG)
+SRC = ../src/unity_fixture.c \
+      ../../../src/unity.c   \
+      unity_fixture_Test.c   \
+      unity_fixture_TestRunner.c \
+      main/AllTests.c
+
+INC_DIR = -I../src -I../../../src/
+BUILD_DIR = ../build
+TARGET = ../build/fixture_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_fixture.c | head -3
+	grep '###' $(BUILD_DIR)/unity_fixture.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/fixture/test/main/AllTests.c

@@ -1,20 +1,19 @@
-//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
-/* ==========================================
+ * ==========================================
-    Unity Project - A Test Framework for C
+ *  Unity Project - A Test Framework for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+ *  Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
+ *  [Released under MIT License. Please refer to license.txt for details]
-========================================== */
+ * ========================================== */
 
 #include "unity_fixture.h"
 
-static void runAllTests()
+static void runAllTests(void)
 {
     RUN_TEST_GROUP(UnityFixture);
     RUN_TEST_GROUP(UnityCommandOptions);
-    RUN_TEST_GROUP(LeakDetection)
 }
 
-int main(int argc, char* argv[])
+int main(int argc, const char* argv[])
 {
     return UnityMain(argc, argv, runAllTests);
 }

extras/fixture/test/template_fixture_tests.c

@@ -1,9 +1,9 @@
-//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
-/* ==========================================
+ * ==========================================
-    Unity Project - A Test Framework for C
+ *  Unity Project - A Test Framework for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+ *  Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
+ *  [Released under MIT License. Please refer to license.txt for details]
-========================================== */
+ * ========================================== */
 
 #include "unity_fixture.h"
 

extras/fixture/test/unity_fixture_Test.c

@@ -1,17 +1,14 @@
-//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
-/* ==========================================
+ * ==========================================
-    Unity Project - A Test Framework for C
+ *  Unity Project - A Test Framework for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+ *  Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
+ *  [Released under MIT License. Please refer to license.txt for details]
-========================================== */
+ * ========================================== */
 
 #include "unity_fixture.h"
-#include "unity_output_Spy.h"
 #include <stdlib.h>
 #include <string.h>
 
-extern UNITY_FIXTURE_T UnityFixture;
-
 TEST_GROUP(UnityFixture);
 
 TEST_SETUP(UnityFixture)
@@ -22,14 +19,13 @@ TEST_TEAR_DOWN(UnityFixture)
 {
 }
 
-int my_int;
+static int* pointer1 = 0;
-int* pointer1 = 0;
+static int* pointer2 = (int*)2;
-int* pointer2 = (int*)2;
+static int* pointer3 = (int*)3;
-int* pointer3 = (int*)3;
+static int int1;
-int int1;
+static int int2;
-int int2;
+static int int3;
-int int3;
+static int int4;
-int int4;
 
 TEST(UnityFixture, PointerSetting)
 {
@@ -47,68 +43,8 @@ TEST(UnityFixture, PointerSetting)
     TEST_ASSERT_POINTERS_EQUAL(pointer3, (int*)3);
 }
 
-TEST(UnityFixture, ForceMallocFail)
+static char *p1;
-{
+static char *p2;
-    UnityMalloc_MakeMallocFailAfterCount(1);
-    void* m = malloc(10);
-    CHECK(m);
-    void* 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);
-    strcpy((char*)m1, "123456789");
-    void* m2 = realloc(m1, 15);
-    CHECK(m1 != m2);
-    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;
-    TEST_ASSERT_BYTES_EQUAL(0, s[0]);
-    TEST_ASSERT_BYTES_EQUAL(0, s[1]);
-    TEST_ASSERT_BYTES_EQUAL(0, s[2]);
-    free(m);
-}
-
-char *p1;
-char *p2;
 
 TEST(UnityFixture, PointerSet)
 {
@@ -119,7 +55,7 @@ TEST(UnityFixture, PointerSet)
     p1 = &c1;
     p2 = &c2;
 
-    UnityPointer_Init(10);
+    UnityPointer_Init();
     UT_PTR_SET(p1, &newC1);
     UT_PTR_SET(p2, &newC2);
     TEST_ASSERT_POINTERS_EQUAL(&newC1, p1);
@@ -129,14 +65,33 @@ TEST(UnityFixture, PointerSet)
     TEST_ASSERT_POINTERS_EQUAL(&c2, p2);
 }
 
-//------------------------------------------------------------
+TEST(UnityFixture, FreeNULLSafety)
+{
+    free(NULL);
+}
+
+TEST(UnityFixture, ConcludeTestIncrementsFailCount)
+{
+    UNITY_UINT savedFails = Unity.TestFailures;
+    UNITY_UINT savedIgnores = Unity.TestIgnores;
+    Unity.CurrentTestFailed = 1;
+    UnityConcludeFixtureTest(); /* Resets TestFailed for this test to pass */
+    Unity.CurrentTestIgnored = 1;
+    UnityConcludeFixtureTest(); /* Resets TestIgnored */
+    TEST_ASSERT_EQUAL(savedFails + 1, Unity.TestFailures);
+    TEST_ASSERT_EQUAL(savedIgnores + 1, Unity.TestIgnores);
+    Unity.TestFailures = savedFails;
+    Unity.TestIgnores = savedIgnores;
+}
+
+/*------------------------------------------------------------ */
 
 TEST_GROUP(UnityCommandOptions);
 
-int savedVerbose;
+static int savedVerbose;
-int savedRepeat;
+static unsigned int savedRepeat;
-const char* savedName;
+static const char* savedName;
-const char* savedGroup;
+static const char* savedGroup;
 
 TEST_SETUP(UnityCommandOptions)
 {
@@ -155,7 +110,7 @@ TEST_TEAR_DOWN(UnityCommandOptions)
 }
 
 
-static char* noOptions[] = {
+static const char* noOptions[] = {
         "testrunner.exe"
 };
 
@@ -168,7 +123,7 @@ TEST(UnityCommandOptions, DefaultOptions)
     TEST_ASSERT_EQUAL(1, UnityFixture.RepeatCount);
 }
 
-static char* verbose[] = {
+static const char* verbose[] = {
         "testrunner.exe",
         "-v"
 };
@@ -179,7 +134,7 @@ TEST(UnityCommandOptions, OptionVerbose)
     TEST_ASSERT_EQUAL(1, UnityFixture.Verbose);
 }
 
-static char* group[] = {
+static const char* group[] = {
         "testrunner.exe",
         "-g", "groupname"
 };
@@ -190,7 +145,7 @@ TEST(UnityCommandOptions, OptionSelectTestByGroup)
     STRCMP_EQUAL("groupname", UnityFixture.GroupFilter);
 }
 
-static char* name[] = {
+static const char* name[] = {
         "testrunner.exe",
         "-n", "testname"
 };
@@ -201,7 +156,7 @@ TEST(UnityCommandOptions, OptionSelectTestByName)
     STRCMP_EQUAL("testname", UnityFixture.NameFilter);
 }
 
-static char* repeat[] = {
+static const char* repeat[] = {
         "testrunner.exe",
         "-r", "99"
 };
@@ -218,7 +173,7 @@ TEST(UnityCommandOptions, OptionSelectRepeatTestsSpecificCount)
     TEST_ASSERT_EQUAL(99, UnityFixture.RepeatCount);
 }
 
-static char* multiple[] = {
+static const char* multiple[] = {
         "testrunner.exe",
         "-v",
         "-g", "groupname",
@@ -235,7 +190,7 @@ TEST(UnityCommandOptions, MultipleOptions)
     TEST_ASSERT_EQUAL(98, UnityFixture.RepeatCount);
 }
 
-static char* dashRNotLast[] = {
+static const char* dashRNotLast[] = {
         "testrunner.exe",
         "-v",
         "-g", "gggg",
@@ -252,70 +207,39 @@ TEST(UnityCommandOptions, MultipleOptionsDashRNotLastAndNoValueSpecified)
     TEST_ASSERT_EQUAL(2, UnityFixture.RepeatCount);
 }
 
-
+static const char* unknownCommand[] = {
-//------------------------------------------------------------
+        "testrunner.exe",
-
+        "-v",
-TEST_GROUP(LeakDetection);
+        "-g", "groupname",
-
+        "-n", "testname",
-TEST_SETUP(LeakDetection)
+        "-r", "98",
+        "-z"
+};
+TEST(UnityCommandOptions, UnknownCommandIsIgnored)
 {
-    UnityOutputCharSpy_Create(1000);
+    TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(9, unknownCommand));
+    TEST_ASSERT_EQUAL(1, UnityFixture.Verbose);
+    STRCMP_EQUAL("groupname", UnityFixture.GroupFilter);
+    STRCMP_EQUAL("testname", UnityFixture.NameFilter);
+    TEST_ASSERT_EQUAL(98, UnityFixture.RepeatCount);
 }
 
-TEST_TEAR_DOWN(LeakDetection)
+TEST(UnityCommandOptions, GroupOrNameFilterWithoutStringFails)
 {
-    UnityOutputCharSpy_Destroy();
+    TEST_ASSERT_EQUAL(1, UnityGetCommandLineOptions(3, unknownCommand));
+    TEST_ASSERT_EQUAL(1, UnityGetCommandLineOptions(5, unknownCommand));
+    TEST_ASSERT_EQUAL(1, UnityMain(3, unknownCommand, NULL));
 }
 
-#define EXPECT_ABORT_BEGIN \
+TEST(UnityCommandOptions, GroupFilterReallyFilters)
-  { \
-    jmp_buf TestAbortFrame;   \
-    memcpy(TestAbortFrame, Unity.AbortFrame, sizeof(jmp_buf)); \
-    if (TEST_PROTECT()) \
-    {
-
-#define EXPECT_ABORT_END \
-    } \
-    memcpy(Unity.AbortFrame, TestAbortFrame, sizeof(jmp_buf)); \
-  }
-
-TEST(LeakDetection, DetectsLeak)
 {
-    void* m = malloc(10);
+    UNITY_UINT saved = Unity.NumberOfTests;
-    UnityOutputCharSpy_Enable(1);
+    TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(4, unknownCommand));
-    EXPECT_ABORT_BEGIN
+    UnityIgnoreTest(NULL, "non-matching", NULL);
-    UnityMalloc_EndTest();
+    TEST_ASSERT_EQUAL(saved, Unity.NumberOfTests);
-    EXPECT_ABORT_END
-    UnityOutputCharSpy_Enable(0);
-    CHECK(strstr(UnityOutputCharSpy_Get(), "This test leaks!"));
-    free(m);
-    Unity.CurrentTestFailed = 0;
 }
 
-TEST(LeakDetection, BufferOverrunFoundDuringFree)
+IGNORE_TEST(UnityCommandOptions, TestShouldBeIgnored)
 {
-    void* m = malloc(10);
+    TEST_FAIL_MESSAGE("This test should not run!");
-    char* s = (char*)m;
-    s[10] = (char)0xFF;
-    UnityOutputCharSpy_Enable(1);
-    EXPECT_ABORT_BEGIN
-    free(m);
-    EXPECT_ABORT_END
-    UnityOutputCharSpy_Enable(0);
-    CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()"));
-    Unity.CurrentTestFailed = 0;
-}
-
-TEST(LeakDetection, BufferOverrunFoundDuringRealloc)
-{
-    void* m = malloc(10);
-    char* s = (char*)m;
-    s[10] = (char)0xFF;
-    UnityOutputCharSpy_Enable(1);
-    EXPECT_ABORT_BEGIN
-    m = realloc(m, 100);
-    EXPECT_ABORT_END
-    UnityOutputCharSpy_Enable(0);
-    CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()"));
-    Unity.CurrentTestFailed = 0;
 }

extras/fixture/test/unity_fixture_TestRunner.c

@@ -1,23 +1,18 @@
-//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
-/* ==========================================
+ * ==========================================
-    Unity Project - A Test Framework for C
+ *  Unity Project - A Test Framework for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+ *  Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
+ *  [Released under MIT License. Please refer to license.txt for details]
-========================================== */
+ * ========================================== */
 
 #include "unity_fixture.h"
 
 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);
 }
 
 TEST_GROUP_RUNNER(UnityCommandOptions)
@@ -30,11 +25,8 @@ TEST_GROUP_RUNNER(UnityCommandOptions)
     RUN_TEST_CASE(UnityCommandOptions, OptionSelectRepeatTestsSpecificCount);
     RUN_TEST_CASE(UnityCommandOptions, MultipleOptions);
     RUN_TEST_CASE(UnityCommandOptions, MultipleOptionsDashRNotLastAndNoValueSpecified);
-}
+    RUN_TEST_CASE(UnityCommandOptions, UnknownCommandIsIgnored);
-
+    RUN_TEST_CASE(UnityCommandOptions, GroupOrNameFilterWithoutStringFails);
-TEST_GROUP_RUNNER(LeakDetection)
+    RUN_TEST_CASE(UnityCommandOptions, GroupFilterReallyFilters);
-{
+    RUN_TEST_CASE(UnityCommandOptions, TestShouldBeIgnored);
-    RUN_TEST_CASE(LeakDetection, DetectsLeak);
-    RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringFree);
-    RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringRealloc);
 }

extras/fixture/test/unity_output_Spy.c

@@ -1,56 +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]
-========================================== */
-
-
-#include "unity_output_Spy.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-static int size;
-static int count;
-static char* buffer;
-static int spy_enable;
-
-void UnityOutputCharSpy_Create(int s)
-{
-    size = s;
-    count = 0;
-    spy_enable = 0;
-    buffer = malloc(size);
-    memset(buffer, 0, size);
-}
-
-void UnityOutputCharSpy_Destroy()
-{
-    size = 0;
-    free(buffer);
-}
-
-int UnityOutputCharSpy_OutputChar(int c)
-{
-    if (spy_enable)
-    {
-        if (count < (size-1))
-            buffer[count++] = c;
-    }
-    else
-    {
-        putchar(c);
-    }
-    return c;
-}
-
-const char * UnityOutputCharSpy_Get()
-{
-    return buffer;
-}
-
-void UnityOutputCharSpy_Enable(int enable)
-{
-    spy_enable = enable;
-}