Initial project population

git-svn-id: http://unity.svn.sourceforge.net/svnroot/unity/trunk@1 e7d17a6e-8845-0410-bbbc-c8efb4fdad7e

auto/unity_test_summary.rb

+#!/usr/bin/ruby
+#
+# unity_test_summary.rb
+#
+require 'fileutils'
+require 'set'
+
+class UnityTestSummary
+
+  include FileUtils::Verbose
+
+  def run
+
+    $stderr.flush
+    $stdout.flush
+
+    # Clean up result file names
+    results = @targets.map {|target| target.gsub(/\\/,'/')}
+
+    # Dig through each result file, looking for details on pass/fail:
+    total_tests = 0
+    total_failures = 0
+    total_ignored = 0
+    
+    failure_output = ""
+    ignore_output = ""
+    
+    results.each do |result_file|
+      lines = File.readlines(result_file).map { |line| line.chomp }
+      if lines.length == 0
+        puts "Empty test result file: #{result_file}"
+      else
+        summary_line = -2
+        output = get_details(result_file, lines)
+        failure_output += output[:failures] if !output[:failures].empty?
+        ignore_output += output[:ignores] if !output[:ignores].empty?
+        tests,failures,ignored = parse_test_summary(lines[summary_line])
+        total_tests += tests
+        total_failures += failures
+        total_ignored += ignored
+      end
+    end
+    
+    if total_ignored > 0
+      puts "\n"
+      puts "--------------------------\n"
+      puts "UNITY IGNORED TEST SUMMARY\n"
+      puts "--------------------------\n"
+      puts ignore_output
+    end
+    
+    if total_failures > 0
+      puts "\n"
+      puts "--------------------------\n"
+      puts "UNITY FAILED TEST SUMMARY\n"
+      puts "--------------------------\n"
+      puts failure_output
+    end
+  
+    puts "\n"
+    puts "--------------------------\n"
+    puts "OVERALL UNITY TEST SUMMARY\n"
+    puts "--------------------------\n"
+    puts "TOTAL TESTS: #{total_tests} TOTAL FAILURES: #{total_failures} IGNORED: #{total_ignored}\n"
+    puts "\n"
+    
+    return total_failures
+  end
+
+  def usage(err_msg=nil)
+    puts err_msg if err_msg
+    puts "Usage: unity_test_summary.rb"
+    exit 1
+  end
+   
+  def set_targets(target_array)
+    @targets = target_array
+  end
+  
+  def set_root_path(path)
+    @root = path
+    puts "root_path = " + @root
+  end
+
+  protected
+  
+  @@targets=nil
+  @@path=nil
+  @@root=nil
+
+  def get_details(result_file, lines)
+    fail_lines = [] # indices of lines with failures
+    ignore_lines = [] # indices of lines with ignores
+    lines.each_with_index do |line,i|
+      if (i < (lines.length - 2) && !(line =~ /PASS$/))
+        if line =~ /(^.*\.c):(\d+)/
+          if line =~ /IGNORED$/
+            ignore_lines << i
+          else
+            fail_lines << i
+          end
+        elsif line =~ /IGNORED$/
+          ignore_lines << i        
+        end
+      end
+    end
+    
+    failures = []
+    fail_lines.each do |fail_line|
+      if lines[fail_line] =~ /\w:/
+        src_file,src_line,test_name,msg = lines[fail_line].split(/:/)
+        src_file = "#{@root}#{src_file}" unless @root == nil || @root.length == 0
+        detail = "#{src_file}:#{src_line}:#{test_name}:: #{msg}"
+        failures << detail.gsub(/\//, "\\")
+      end
+    end
+    if failures.length == 0
+      failure_results = ""
+    else
+      failure_results = failures.join("\n") + "\n"
+    end
+    
+    ignores = []
+    ignore_lines.each do |ignore_line|
+      if lines[ignore_line] =~ /\w:/
+        src_file,src_line,test_name,msg = lines[ignore_line].split(/:/)
+        src_file = "#{@root}#{src_file}" unless @root == nil || @root.length == 0
+        detail = "#{src_file}:#{src_line}:#{test_name}:: #{msg}"
+        ignores << detail.gsub(/\//, "\\")
+      end
+    end
+    if ignores.length == 0
+      ignore_results = ""
+    else
+      ignore_results = ignores.join("\n") + "\n"
+    end
+    
+    results = {:failures => failure_results, :ignores => ignore_results}
+  end
+  
+  def parse_test_summary(summary)
+    if summary =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/
+      [$1.to_i,$2.to_i,$3.to_i]
+    else
+      raise "Couldn't parse test results: #{summary}"
+    end
+  end
+
+  def here; File.expand_path(File.dirname(__FILE__)); end
+
+  def valid_file(fname)
+    raise "Can't find file #{fname}" unless File.exists?(fname)
+    fname
+  end
+
+  def valid_dir(dirname)
+    raise "Can't find dir #{dirname}" unless File.exists?(dirname)
+    dirname
+  end
+  
+  def search_file_and_replace(file_name, pattern, replacement)
+    text = File.read(valid_file(file_name))
+    text.gsub!(pattern, replacement)
+    File.open(file_name, "w") do |f| f.write text end
+  end
+
+  def create_file_from_template(dest_file, template_file)
+    raise "#{dest_file} already exists; remove it first" if File.exists?(dest_file)
+
+    template_file = valid_file("#{here}/rscript_template.rb")
+    template = ERB.new(File.read(template_file))
+
+    File.open(dest_file,"w") do |f|
+      f.write template.result(binding)
+    end
+  end
+
+  def humanize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+  end
+
+  def camelize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+
+  def titleize(word)
+    humanize(underscore(word)).gsub(/\b([a-z])/) { $1.capitalize }
+  end
+  
+  def underscore(camel_cased_word)
+    camel_cased_word.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+  end
+  
+end
+
+if $0 == __FILE__
+  script = UnityTestSummary.new
+  begin
+    script.run
+  rescue Exception => e
+    script.usage e.message
+  end
+end

docs/Unity Summary.txt

+Unity Test API
+==============
+
+-------------
+Running Tests 
+------------- 
+
+RUN_TEST(func)
+
+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.
+
+TEST_WRAP(function) 
+
+If the test functions call helper functions and those helper functions have the ability to make assertions, calls to those helpers should be wrapped in a TEST_WRAP macro.  This macro aborts the test if the helper triggered a failure.
+
+--------------
+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_THROW 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_THROW (message)
+
+Abort Test macro
+
+Example:
+
+main()
+{
+    if (TEST_PROTECT() == 0)
+    {
+        MyTest();
+    }
+}
+
+If MyTest calls TEST_THROW, a failure with the message provided will be inserted, and 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(message)
+
+This test is automatically marked as a failure.  The message is output stating why.
+
+------------------------------
+Numerical Assertions: Integers
+------------------------------
+
+TEST_ASSERT_EQUAL(expected, actual)
+
+Another way of calling TEST_ASSERT_EQUAL_INT
+
+TEST_ASSERT_EQUAL_INT(expected, actual)
+
+Compare two integers for equality and display errors as signed integers.
+
+TEST_ASSERT_EQUAL_UINT(expected, actual)	
+
+Compare two integers for equality and display errors as unsigned integers.
+
+TEST_ASSERT_EQUAL_HEX8(expected, actual)	
+
+Compare two integers for equality and display errors as an 8-bit hex value
+
+TEST_ASSERT_EQUAL_HEX16(expected, actual)	
+
+Compare two integers for equality and display errors as an 16-bit hex value
+
+TEST_ASSERT_EQUAL_HEX32(expected, actual)	
+
+Compare two integers for equality and display errors as an 32-bit hex value
+
+TEST_ASSERT_EQUAL_HEX(expected, actual)	
+
+Another way of calling TEST_ASSERT_EQUAL_HEX32
+
+TEST_ASSERT_INT_WITHIN(delta, expected, actual)
+
+Asserts that the actual value is within plus or minus delta of the expected value.
+
+TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message)
+
+Another way of calling TEST_ASSERT_EQUAL_INT_MESSAGE
+
+TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message)
+
+Compare two integers for equality and display errors as signed integers.  Outputs a custom message on failure.
+
+TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, message)	
+
+Compare two integers for equality and display errors as unsigned integers. Outputs a custom message on failure.
+
+TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message)
+	
+Compare two integers for equality and display errors as an 8-bit hex value. Outputs a custom message on failure.
+
+TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message)
+	
+Compare two integers for equality and display errors as an 16-bit hex value. Outputs a custom message on failure.
+
+TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message)	
+
+Compare two integers for equality and display errors as an 32-bit hex value. Outputs a custom message on failure.
+
+TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message)
+	
+Another way of calling TEST_ASSERT_EQUAL_HEX32_MESSAGE
+
+-----------------------------
+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.
+
+-----------------
+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
+

makefile

+C_COMPILER=gcc
+OUT_FILE=-o testunity
+ifeq ($(OS),Windows_NT)
+OUT_EXTENSION=.exe
+else
+OUT_EXTENSION=.out
+endif
+SRC_FILES=src/unity.c test/testunity.c test/testunity_Runner.c
+INC_DIRS=-Isrc
+SYMBOLS=-DTEST
+
+default:
+	$(C_COMPILER) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES) $(OUT_FILE)$(OUT_EXTENSION)

rakefile

+$here = File.expand_path( File.dirname( __FILE__ ) )
+
+require 'rake/clean'
+require 'rake/loaders/makefile'
+require 'fileutils'
+require 'set'
+require 'auto/unity_test_summary'
+require 'rakefile_helper'
+
+include RakefileHelpers
+
+CLEAN.include('bin/*')
+
+desc "Build Unity and run tests."
+task :default => [:clobber, :all]
+
+desc "Build Unity object file."
+task :build_unity => [:clobber, UNITY_OBJ]
+
+task :run_test => [TEST_RESULTS, :summary].flatten
+
+task :all => [UNITY_TEST_EXEC, :run_test]
+
+task :summary do
+  flush_output
+  summary = UnityTestSummary.new
+  summary.set_root_path($here)
+  summary.set_targets(Dir["bin/*.test*"])
+  summary.run
+end
+
+file UNITY_OBJ => [UNITY_SRC, UNITY_HDR] do |obj|
+  compile UNITY_SRC, obj.name
+end
+
+file UNITY_TEST_OBJ => [UNITY_TEST_SRC, UNITY_SRC, UNITY_HDR] do |obj|
+  compile UNITY_TEST_SRC, obj.name
+end
+
+file UNITY_TEST_RUNNER_OBJ => [UNITY_TEST_RUNNER_SRC, UNITY_TEST_SRC, UNITY_SRC, UNITY_HDR] do |obj|
+  compile UNITY_TEST_RUNNER_SRC, obj.name
+end
+
+file UNITY_TEST_EXEC => [UNITY_OBJ, UNITY_TEST_OBJ, UNITY_TEST_RUNNER_OBJ] do |bin|
+  link bin.prerequisites, bin.name
+end
+
+rule /.*\.test/ => [BIN_EXTENSION] do |file|
+  bin = file.name.ext BIN_EXTENSION
+  test_results = 'bin\sim.txt'
+  fail_file = file.name.ext 'testfail'
+  if File.exist?(fail_file)
+    rm_f fail_file
+  end
+  rm_f test_results
+  rm_f file.name
+  output = run_test bin
+  if !File.file?(test_results)
+    File.open(test_results, 'w') do |f|
+      f.print output
+    end
+  end
+  open test_results, 'r' do |f| 
+    testoutput = f.read
+    if testoutput.index 'OK'
+      cp test_results, file.name
+    else
+      cp test_results, fail_file
+    end
+  end
+end
+

rakefile_helper.rb

+HERE = File.expand_path( File.dirname( __FILE__ ) ).gsub(/\//, '\\')
+
+module RakefileConstants
+
+  PROGRAM_FILES_PATH = ENV['ProgramFiles']
+  begin
+    Dir.new PROGRAM_FILES_PATH + '\IAR Systems\Embedded Workbench 4.0\arm'
+    IAR_ROOT = PROGRAM_FILES_PATH + '\IAR Systems\Embedded Workbench 4.0'
+  rescue
+    Dir.new PROGRAM_FILES_PATH + '\IAR Systems\Embedded Workbench 4.0 Kickstart\arm'
+    IAR_ROOT = PROGRAM_FILES_PATH + '\IAR Systems\Embedded Workbench 4.0 Kickstart'
+  end
+  
+  C_EXTENSION = '.c'
+  OBJ_EXTENSION = '.r79'
+  BIN_EXTENSION = '.d79'
+  
+  UNIT_TEST_PATH = 'test'
+  SOURCE_PATH = 'src'
+  BIN_PATH = 'bin'
+  IAR_PATH = IAR_ROOT + '\common'
+  IAR_BIN = IAR_PATH + '\bin'
+  IAR_INCLUDE = IAR_PATH + '\inc'
+  IAR_CORE_PATH = IAR_ROOT + '\arm'
+  IAR_CORE_BIN = IAR_CORE_PATH + '\bin'
+  IAR_CORE_CONFIG = IAR_CORE_PATH + '\config'
+  IAR_CORE_INCLUDE = IAR_CORE_PATH + '\inc'
+  IAR_CORE_INCLUDE_DLIB = IAR_CORE_INCLUDE + '\lib'
+  IAR_CORE_LIB = IAR_CORE_PATH + '\lib'
+  IAR_CORE_DLIB = IAR_CORE_LIB + '\dl5tpannl8n.r79'
+  IAR_CORE_DLIB_CONFIG = IAR_CORE_LIB + '\dl5tpannl8n.h'
+  IAR_PROCESSOR_SPECIFIC_PATH = HERE + '\proc'
+  SIMULATOR_PROCESSOR = IAR_CORE_BIN + '\armproc.dll'
+  SIMULATOR_DRIVER = IAR_CORE_BIN + '\armsim.dll'
+  SIMULATOR_PLUGIN = IAR_CORE_BIN + '\armbat.dll'
+  SIMULATOR_BACKEND_DDF = IAR_CORE_CONFIG + '\ioat91sam9261.ddf'
+  PROCESSOR_TYPE = "ARM926EJ-S"
+  LINKER_CONFIG = IAR_CORE_CONFIG + '\lnkarm.xcl'
+  
+  UNITY_SRC = SOURCE_PATH + '\unity.c'
+  UNITY_HDR = SOURCE_PATH + '\unity.h'
+  UNITY_TEST_SRC = UNIT_TEST_PATH + '\testunity.c'
+  UNITY_TEST_RUNNER_SRC = UNIT_TEST_PATH + '\testunity_Runner.c'
+  UNITY_OBJ = BIN_PATH + '\unity' + OBJ_EXTENSION
+  UNITY_TEST_OBJ = BIN_PATH + '\testunity' + OBJ_EXTENSION
+  UNITY_TEST_RUNNER_OBJ = BIN_PATH + '\testunity_Runner' + OBJ_EXTENSION
+  UNITY_TEST_EXEC = UNITY_TEST_OBJ.ext BIN_EXTENSION
+  TEST_RESULTS = UNITY_TEST_OBJ.ext '.testpass'
+  
+  COMPILER = IAR_CORE_BIN + '\iccarm.exe'
+  LINKER = IAR_BIN + '\xlink.exe'
+  SIMULATOR = IAR_BIN + '\CSpyBat.exe'
+  
+end
+
+module RakefileHelpers
+  include RakefileConstants
+
+  def flush_output
+    $stderr.flush
+    $stdout.flush
+  end
+  
+  def report message
+    puts message
+    flush_output
+  end
+
+  def compile src, obj
+    execute "#{COMPILER} --dlib_config \"#{IAR_CORE_DLIB_CONFIG}\" -z3 --no_cse --no_unroll --no_inline --no_code_motion --no_tbaa --no_clustering --no_scheduling --debug --cpu_mode arm --endian little --cpu #{PROCESSOR_TYPE} --stack_align 4 -e --fpu None --diag_suppress Pa050 --diag_suppress Pe111 -I\"#{IAR_CORE_INCLUDE}\" -Isrc -Itest #{src} -o#{obj}"
+  end
+
+  def link prerequisites, executable
+    execute "\"#{LINKER}\" -rt \"#{IAR_CORE_DLIB}\" -B -s __program_start -I\"#{IAR_CORE_CONFIG}\" -I\"#{IAR_CORE_LIB}\" -f \"#{LINKER_CONFIG}\" #{prerequisites.join(' ')} -o #{executable}"
+  end
+
+  def run_test executable      
+    execute "\"#{SIMULATOR}\" --silent \"#{SIMULATOR_PROCESSOR}\" \"#{SIMULATOR_DRIVER}\" #{executable} --plugin \"#{SIMULATOR_PLUGIN}\" --backend -B --cpu #{PROCESSOR_TYPE} -p \"#{SIMULATOR_BACKEND_DDF}\" -d sim"
+  end
+  
+private
+
+  def execute command_string
+    report command_string
+    output = `#{command_string}`
+    report output
+    if $?.exitstatus != 0
+      raise "Command failed. (Returned #{$?.exitstatus})"
+    end
+    output
+  end
+
+end

src/unity.c

+#include "unity.h"
+#include <stdio.h>
+
+
+struct _Unity  Unity =
+{
+    NULL,
+    0,
+    0,
+    0,
+    0,
+    0,
+    NULL,
+    1e-4f,
+};
+
+void UnityPrintChar(char ch)
+{
+    putchar(ch);
+}
+
+void UnityPrint(const char *string)
+{
+    unsigned char * pch = (unsigned char *)string;
+
+    if (pch != NULL)
+    {
+        while (*pch)
+        {
+            UnityPrintChar(*pch);
+            pch++;
+        }
+    }
+}
+
+void UnityPrintNumberByStyle(long number, UNITY_DISPLAY_STYLE_T style)
+{
+    switch (style)
+    {
+    case UNITY_DISPLAY_STYLE_HEX8:    UnityPrintNumberHex(number,2);            break;
+    case UNITY_DISPLAY_STYLE_HEX16:   UnityPrintNumberHex(number,4);            break;
+    case UNITY_DISPLAY_STYLE_HEX32:   UnityPrintNumberHex(number,8);            break;
+    case UNITY_DISPLAY_STYLE_UINT:    UnityPrintNumberUnsigned(number);         break;
+    default:                          UnityPrintNumber(number);                 break;
+    }
+}
+
+/// basically do an itoa using as little ram as possible
+void UnityPrintNumber(long number)
+{
+    unsigned long divisor = 10;
+
+    if (number < 0)
+    {
+        UnityPrintChar('-');
+        number = -number;
+    }
+
+    // figure out initial divisor
+    while (number / divisor)
+    {
+        divisor *= 10;
+    }
+
+    // now divide number by divisor, mod and print, then divide divisor
+    do
+    {
+        divisor /= 10;
+        UnityPrintChar((char)('0' + (number / divisor % 10)));
+    }
+    while (divisor > 1U);
+}
+
+/// basically do an itoa using as little ram as possible
+void UnityPrintNumberUnsigned(unsigned long number)
+{
+    unsigned long divisor = 10;
+
+    // figure out initial divisor
+    while (number / divisor)
+    {
+        divisor *= 10;
+    }
+
+    // now divide number by divisor, mod and print, then divide divisor
+    do
+    {
+        divisor /= 10;
+        UnityPrintChar((char)('0' + (number / divisor % 10)));
+    }
+    while (divisor > 1U);
+}
+
+void UnityPrintNumberHex(unsigned long number, char nibbles)
+{
+    unsigned long nibble;
+    UnityPrint("0x");
+
+    while (nibbles > 0)
+    {
+        nibble = (number >> (--nibbles << 2)) & 0x0000000F;
+        if (nibble <= 9)
+        {
+            UnityPrintChar((char)('0' + nibble));
+        }
+        else
+        {
+            UnityPrintChar((char)('A' - 10 + nibble));
+        }
+    }
+}
+
+void UnityPrintMask(unsigned long mask, unsigned long number)
+{
+    unsigned long bit = 0x00000001;
+    int i;
+
+    for (i = 0; i < 32; i++)
+    {
+        if (bit & mask)
+        {
+            if (bit & number)
+            {
+                UnityPrintChar('1');
+            }
+            else
+            {
+                UnityPrintChar('0');
+            }
+        }
+        else
+        {
+            UnityPrintChar('X');
+        }
+        bit = bit << 1;
+    }
+}
+
+void UnityTestResultsBegin(int line)
+{
+    UnityPrint(Unity.TestFile);
+    UnityPrintChar(':');
+    UnityPrintNumber(line);
+    UnityPrintChar(':');
+    UnityPrint(Unity.CurrentTestName);
+    UnityPrintChar(':');
+}
+
+void UnityConcludeTest()
+{
+    if (Unity.CurrentTestIgnored)
+    {
+        Unity.TestIgnores++;
+    }
+    else if (!Unity.CurrentTestFailed)
+    {
+        UnityPrint(Unity.CurrentTestName);
+        UnityPrint("::: PASS\n");
+    }
+    else
+    {
+        Unity.TestFailures++;
+    }
+
+    Unity.CurrentTestFailed = 0;
+    Unity.CurrentTestIgnored = 0;
+}
+
+void UnityAssertBits(int mask, int expected, int actual, const char *msg, unsigned short lineNumber)
+{
+    if ((mask & expected) != (mask & actual))
+    {
+        Unity.CurrentTestFailed = 1;
+
+        UnityTestResultsBegin(lineNumber);
+        UnityPrint("Expected ");
+        UnityPrintMask(mask, expected);
+        UnityPrint(" was ");
+        UnityPrintMask(mask, actual);
+        UnityPrintChar('.');
+        if (msg)
+        {
+            UnityPrintChar(' ');
+            UnityPrint(msg);
+        }
+        UnityPrintChar('\n');
+    }
+}
+
+void UnityAssertEqualInt(int expected, int actual, const char *msg, unsigned short lineNumber, UNITY_DISPLAY_STYLE_T style)
+{
+    if (expected != actual)
+    {
+        Unity.CurrentTestFailed = 1;
+
+        UnityTestResultsBegin(lineNumber);
+        UnityPrint("Expected ");
+        UnityPrintNumberByStyle(expected, style);
+        UnityPrint(" was ");
+        UnityPrintNumberByStyle(actual, style);
+        UnityPrintChar('.');
+        if (msg)
+        {
+            UnityPrintChar(' ');
+            UnityPrint(msg);
+        }
+        UnityPrintChar('\n');
+    }
+}
+
+void UnityAssertFloatsWithin(float delta, float expected, float actual, const char *msg, unsigned short lineNumber)
+{
+    float diff = actual - expected;
+
+    if (diff < 0)
+    {
+        diff = -diff;
+    }
+
+    if (delta < diff)
+    {
+        Unity.CurrentTestFailed = 1;
+        UnityTestResultsBegin(lineNumber);
+        UnityPrint("Floats not within delta.");
+        if (msg)
+        {
+            UnityPrintChar(' ');
+            UnityPrint(msg);
+        }
+        UnityPrintChar('\n');
+    }
+}
+
+void UnityAssertIntsWithin(int delta, int expected, int actual, const char *msg, unsigned short lineNumber)
+{
+    int diff = actual - expected;
+
+    if (diff < 0)
+    {
+        diff = -diff;
+    }
+
+    if (delta < diff)
+    {
+        Unity.CurrentTestFailed = 1;
+        UnityTestResultsBegin(lineNumber);
+        UnityPrint("Ints not within delta.");
+        if (msg)
+        {
+            UnityPrintChar(' ');
+            UnityPrint(msg);
+        }
+        UnityPrintChar('\n');
+    }
+}
+
+void UnityAssertEqualString(const char *expected, const char *actual, const char *msg, unsigned short lineNumber)
+{
+    unsigned int i;
+
+    // if both pointers not null compare the strings
+    if (expected && actual)
+    {
+        for (i = 0; expected[i] || actual[i]; i++)
+        {
+            if (expected[i] != actual[i])
+            {
+                Unity.CurrentTestFailed = 1;
+            }
+        }
+    }
+    else
+    { // handle case of one pointers being null (if both null, test should pass)
+        if (expected != actual)
+        {
+            Unity.CurrentTestFailed = 1;
+        }
+    }
+
+    if (Unity.CurrentTestFailed)
+    {
+        UnityTestResultsBegin(lineNumber);
+        UnityPrint("Expected '");
+        UnityPrint(expected);
+        UnityPrint("' was '");
+        UnityPrint(actual);
+        UnityPrintChar('\'');
+        UnityPrintChar('.');
+        if (msg)
+        {
+            UnityPrintChar(' ');
+            UnityPrint(msg);
+        }
+        UnityPrintChar('\n');
+    }
+}
+
+void UnityFail(const char *message, int line)
+{
+    Unity.CurrentTestFailed = 1;
+    UnityTestResultsBegin(line);
+    UnityPrint(message);
+    UnityPrintChar('\n');
+}
+
+void UnityIgnore(const char *message, int line)
+{
+    Unity.CurrentTestIgnored = 1;
+    UnityTestResultsBegin(line);
+    UnityPrint(message);
+    UnityPrint(" IGNORED\n");
+}
+
+void UnityBegin()
+{
+    Unity.NumberOfTests = 0;
+}
+
+void UnityEnd(void)
+{
+    UnityPrintNumber(Unity.NumberOfTests);
+    UnityPrint(" Tests ");
+    UnityPrintNumber(Unity.TestFailures);
+    UnityPrint(" Failures ");
+    UnityPrintNumber(Unity.TestIgnores);
+    UnityPrint(" Ignored\n");
+    if (Unity.TestFailures == 0U)
+    {
+        UnityPrint("OK\n");
+    }
+    else
+    {
+        UnityPrint("FAIL\n");
+    }
+}
+

src/unity.h

+#ifndef UNITY_FRAMEWORK_H
+#define UNITY_FRAMEWORK_H
+
+#define UNITY
+
+#include <stdio.h>
+
+typedef void (*UnityTestFunction)(void);
+
+typedef enum 
+{
+    UNITY_DISPLAY_STYLE_INT,
+    UNITY_DISPLAY_STYLE_UINT,
+    UNITY_DISPLAY_STYLE_HEX8,
+    UNITY_DISPLAY_STYLE_HEX16,
+    UNITY_DISPLAY_STYLE_HEX32
+} UNITY_DISPLAY_STYLE_T;
+
+struct _Unity
+{
+    char* CurrentTestName;
+    unsigned char NumberOfTests;
+    unsigned char TestFailures;
+    unsigned char TestIgnores;
+    unsigned char CurrentTestFailed;
+    unsigned char CurrentTestIgnored;
+    const char *TestFile;
+    float DefaultDelta;
+};
+
+extern struct _Unity Unity;
+
+void CreateResults();
+
+void UnityBegin();
+void UnityEnd(void);
+
+void UnityPrintChar(char ch);
+void UnityPrint(const char *string);
+void UnityPrintMask(unsigned long mask, unsigned long number);
+void UnityPrintNumberByStyle(long number, UNITY_DISPLAY_STYLE_T style);
+void UnityPrintNumber(long number);
+void UnityPrintNumberUnsigned(unsigned long number);
+void UnityPrintNumberHex(unsigned long number, char nibbles);
+void UnityConcludeTest();
+
+void UnityAssertEqualInt(int expected, int actual,
+const char *msg, unsigned short lineNumber, UNITY_DISPLAY_STYLE_T style);
+
+void UnityAssertBits(int mask, int expected, int actual,
+const char *msg, unsigned short lineNumber);
+
+void UnityAssertEqualString(const char *expected, const char *actual,
+const char *msg, unsigned short lineNumber );
+
+void UnityAssertFloatsWithin(float delta, float expected, float actual,
+const char *msg, unsigned short lineNumber);
+
+void UnityAssertIntsWithin(int delta, int expected, int actual,
+const char *msg, unsigned short lineNumber);
+
+void UnityFail(const char *message, int line);
+
+void UnityIgnore(const char *message, int line);
+
+#define EXIT_WRAPPED_TEST(exprString) \
+if( Unity.CurrentTestFailed ) {\
+    UnityPrint(__FILE__); \
+    UnityPrint(":"); \
+    UnityPrintNumber(__LINE__); \
+    UnityPrint(":REDIRECTED:"); \
+    UnityPrint(exprString); \
+    UnityPrintChar('\n'); \
+}
+
+#define RETURN_IF_NECESSARY() \
+    if( Unity.CurrentTestFailed || Unity.CurrentTestIgnored ) {return;}
+
+#define TEST_WRAP_NO_RETURN(function) \
+{\
+    function; \
+    EXIT_WRAPPED_TEST(#function); \
+}
+
+#define RUN_TEST(func) \
+    Unity.CurrentTestName = #func; \
+    Unity.NumberOfTests ++; \
+    runTest(func); \
+    UnityConcludeTest();
+
+#define TEST_WRAP(function) \
+{\
+    TEST_WRAP_NO_RETURN(function); \
+    Unity.TestFile=__FILE__; \
+    RETURN_IF_NECESSARY(); \
+}
+
+#define TEST_ASSERT_MESSAGE(condition, message) if (condition) {} else {TEST_FAIL(message);}
+#define TEST_ASSERT(condition) TEST_ASSERT_MESSAGE(condition, NULL)
+
+#define TEST_ASSERT_TRUE_MESSAGE(condition) TEST_ASSERT_MESSAGE(condition, message)
+#define TEST_ASSERT_TRUE(condition) TEST_ASSERT(condition)
+
+#define TEST_ASSERT_UNLESS_MESSAGE(condition) TEST_ASSERT_MESSAGE(!(condition), message)
+#define TEST_ASSERT_UNLESS(condition) TEST_ASSERT(!(condition))
+
+#define TEST_ASSERT_FALSE_MESSAGE(condition) TEST_ASSERT_MESSAGE(!(condition), message)
+#define TEST_ASSERT_FALSE(condition) TEST_ASSERT(!(condition))
+
+#define TEST_ASSERT_NULL(pointer) TEST_ASSERT_MESSAGE(pointer == NULL, #pointer " was not null.")
+
+#define TEST_ASSERT_NOT_NULL(pointer) TEST_ASSERT_MESSAGE(pointer != NULL, #pointer " was null.")
+
+#define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertEqualInt((int)(expected), (int)(actual), (message), (unsigned short)__LINE__, UNITY_DISPLAY_STYLE_INT); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_EQUAL_INT(expected, actual)	TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, NULL)
+
+#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) TEST_ASSERT_EQUAL_INT_MESSAGE((expected), (actual), (message))
+#define TEST_ASSERT_EQUAL(expected, actual) TEST_ASSERT_EQUAL_INT(expected, actual)
+
+#define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertIntsWithin((delta), (expected), (actual), NULL, (unsigned short)__LINE__); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_INT_WITHIN(delta, expected, actual) TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, NULL)
+
+#define TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertEqualInt((int)(expected), (int)(actual), (message), (unsigned short)__LINE__, UNITY_DISPLAY_STYLE_UINT); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_EQUAL_UINT(expected, actual) TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, NULL)
+
+#define TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertEqualInt((int)(expected), (int)(actual), (message), (unsigned short)__LINE__, UNITY_DISPLAY_STYLE_HEX8); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_EQUAL_HEX8(expected, actual) TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, NULL)
+
+#define TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertEqualInt((int)(expected), (int)(actual), (message), (unsigned short)__LINE__, UNITY_DISPLAY_STYLE_HEX16); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_EQUAL_HEX16(expected, actual)	TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, NULL)
+
+#define TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertEqualInt((int)(expected), (int)(actual), (message), (unsigned short)__LINE__, UNITY_DISPLAY_STYLE_HEX32); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_EQUAL_HEX32(expected, actual)	TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, NULL)
+
+#define TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message) TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message)
+#define TEST_ASSERT_EQUAL_HEX(expected, actual) TEST_ASSERT_EQUAL_HEX32(expected, message)
+
+#define TEST_ASSERT_BITS_MESSAGE(mask, expected, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertBits((mask), (expected), (actual), (message), (unsigned short)__LINE__); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_BITS(mask, expected, actual) TEST_ASSERT_BITS_MESSAGE(mask, expected, actual, NULL)
+
+#define TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertBits((mask), (-1), (actual), (message), (unsigned short)__LINE__); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_BITS_HIGH(mask, actual) TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, NULL)
+
+#define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertBits((mask), (0), (actual), (message), (unsigned short)__LINE__); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_BITS_LOW(mask, actual) TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, NULL)
+
+#define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertBits((1 << bit), (-1), (actual), (message), (unsigned short)__LINE__); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_BIT_HIGH(bit, actual) TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, NULL)
+
+#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertBits((1 << bit), (0), (actual), (message), (unsigned short)__LINE__); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_BIT_LOW(bit, actual) TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, NULL)
+
+#define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertFloatsWithin((delta), (expected), (actual), (message), (unsigned short)__LINE__); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, NULL)
+
+#define TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) \
+    Unity.TestFile=__FILE__; \
+    UnityAssertEqualString((expected), (actual), (message), (unsigned short)__LINE__); \
+    RETURN_IF_NECESSARY();
+#define TEST_ASSERT_EQUAL_STRING(expected, actual) TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, NULL)
+
+#define TEST_FAIL(message) { Unity.TestFile=__FILE__; UnityFail((message), (unsigned short)__LINE__); return; }
+#define TEST_IGNORE_MESSAGE(message) { Unity.TestFile=__FILE__; UnityIgnore((message), (unsigned short)__LINE__); return; }
+#define TEST_IGNORE() TEST_IGNORE_MESSAGE("")
+
+#define TEST_PROTECT() (setjmp(AbortFrame) == 0)
+#define TEST_THROW(message) { Unity.TestFile=__FILE__; UnityFail((message), (unsigned short)__LINE__); longjmp(AbortFrame, 1); }
+
+#endif
+

test/testunity.c

+#define UNITY_ENABLE_EXTERNAL_ASSERTIONS
+
+#include <setjmp.h>
+#include "unity.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testTrue(void)
+{
+    TEST_ASSERT(1);
+    
+    TEST_ASSERT_TRUE(1);
+}
+
+void testFalse(void)
+{
+    TEST_ASSERT_FALSE(0);
+    
+    TEST_ASSERT_UNLESS(0);
+}
+
+void testPreviousPass(void)
+{
+    TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures);
+}
+
+void vanilla_asserter(int val)
+{
+    TEST_ASSERT(val);
+}
+
+void testNotVanilla(void)
+{
+    int failed;
+    vanilla_asserter(0);
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_EQUAL_INT(1U, failed);
+    TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures);
+}
+
+void true_asserter(int val)
+{
+    TEST_ASSERT_TRUE(val);
+}
+
+void testNotTrue(void)
+{
+    int failed;
+    true_asserter(0);
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_EQUAL_INT(1U, failed);
+    TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures);
+}
+
+void false_asserter(int val)
+{
+    TEST_ASSERT_FALSE(val);
+}
+
+void testNotFalse(void)
+{
+    int failed;
+    false_asserter(1);
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_EQUAL_INT(1U, failed);
+    TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures);
+}
+
+void unless_asserter(int val)
+{
+    TEST_ASSERT_UNLESS(val);
+}
+
+void testNotUnless(void)
+{
+    int failed;
+    unless_asserter(1);
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_EQUAL_INT(1U, failed);
+    TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures);
+}
+
+void failer(void)
+{
+    TEST_FAIL("Expected for testing");
+}
+
+void testFail(void)
+{
+    int failed;
+    failer();
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_EQUAL_INT(1U, failed);
+    TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures);
+}
+
+void ignorer(void)
+{
+    TEST_IGNORE();
+    TEST_FAIL("This should not be reached");
+}
+
+void assertIgnoreInWrapper(void)
+{
+    TEST_WRAP(ignorer());
+    TEST_FAIL("This should not be reached");
+}
+
+void testIgnoreInWrapper(void)
+{
+    unsigned char ignored;
+    assertIgnoreInWrapper();
+    ignored = Unity.CurrentTestIgnored;
+    Unity.CurrentTestIgnored = 0;
+    TEST_ASSERT_EQUAL_INT(1, ignored);
+}
+
+void testIgnore(void)
+{
+    int ignored;
+    ignorer();
+
+    ignored = Unity.CurrentTestIgnored;
+    Unity.CurrentTestIgnored = 0;
+
+    TEST_ASSERT(ignored);
+}
+
+void ignorerWithMessage(void)
+{
+    TEST_IGNORE_MESSAGE("This is an expected TEST_IGNORE_MESSAGE string!");
+    TEST_FAIL("This should not be reached");
+}
+
+void testIgnoreMessage(void)
+{
+    int ignored;
+    ignorerWithMessage();
+
+    ignored = Unity.CurrentTestIgnored;
+    Unity.CurrentTestIgnored = 0;
+
+    TEST_ASSERT(ignored);
+}
+
+void assertIgnoreWithMessageInWrapper(void)
+{
+    TEST_WRAP(ignorerWithMessage());
+    TEST_FAIL("This should not be reached");
+}
+
+void testIgnoreMessageInWrapper(void)
+{
+    unsigned char ignored;
+    assertIgnoreWithMessageInWrapper();
+    ignored = Unity.CurrentTestIgnored;
+    Unity.CurrentTestIgnored = 0;
+    TEST_ASSERT_EQUAL_INT(1, ignored);
+}
+
+void wrapper(void)
+{
+    TEST_WRAP(failer()); // if this doesn't force a return, then the failures will be incorrectly reset
+    Unity.CurrentTestFailed = 0;
+}
+
+void testWrap(void)
+{
+    int failed;
+    wrapper();
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0U;
+
+    TEST_ASSERT_EQUAL_INT(1U, failed);
+}
+
+void intFailer(void)
+{
+    TEST_ASSERT_EQUAL_INT(3982, 3983);
+}
+
+void testNotEqualInts(void)
+{
+    int failed;
+    intFailer();
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is expected");
+}
+
+void bitFailer(void)
+{
+    TEST_ASSERT_BITS(0xFF00, 0x5555, 0x5A55);
+}
+
+void testNotEqualBits(void)
+{
+    int failed;
+    bitFailer();
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is expected");
+}
+
+void uintFailer(void)
+{
+    TEST_ASSERT_EQUAL_UINT(900000, 900001);
+}
+
+void testNotEqualUInts(void)
+{
+    int failed;
+    uintFailer();
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is expected");
+}
+
+void hex8Failer(void)
+{
+    TEST_ASSERT_EQUAL_HEX8(0x23,0x22);
+}
+
+void testNotEqualHex8s(void)
+{
+    int failed;
+    hex8Failer();
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is expected");
+}
+
+void hex16Failer(void)
+{
+    TEST_ASSERT_EQUAL_HEX16(0x1234, 0x1235);
+}
+
+void testNotEqualHex16s(void)
+{
+    int failed;
+    hex16Failer();
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is expected");
+}
+
+void hex32Failer(void)
+{
+    TEST_ASSERT_EQUAL_HEX32(900000, 900001);
+}
+
+void testNotEqualHex32s(void)
+{
+    int failed;
+    hex32Failer();
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is expected");
+}
+
+void UnwrappedAssertion(int expected, int actual)
+{
+    TEST_ASSERT_EQUAL(expected,actual);
+}
+
+void testMultipleUnwrappedAssertionsHandledAppropriately(void)
+{
+    int failed;
+
+    UnwrappedAssertion(4,5);
+    UnwrappedAssertion(6,6);
+    UnwrappedAssertion(19,19);
+    
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is expected");
+}
+
+void testEqualInts(void)
+{
+    int v0, v1;
+    int *p0, *p1;
+    v0 = 19467;
+    v1 = 19467;
+    p0 = &v0;
+    p1 = &v1;
+
+    TEST_ASSERT_EQUAL_INT(1837, 1837);
+    TEST_ASSERT_EQUAL_INT(-27365, -27365);
+    TEST_ASSERT_EQUAL_INT(v0, v1);
+    TEST_ASSERT_EQUAL_INT(19467, v1);
+    TEST_ASSERT_EQUAL_INT(v0, 19467);
+    TEST_ASSERT_EQUAL_INT(*p0, v1);
+    TEST_ASSERT_EQUAL_INT(*p0, *p1);
+    TEST_ASSERT_EQUAL_INT(*p0, 19467);
+}
+
+void testEqualUints(void)
+{
+    unsigned int v0, v1;
+    unsigned int *p0, *p1;
+    v0 = 19467;
+    v1 = 19467;
+    p0 = &v0;
+    p1 = &v1;
+
+    TEST_ASSERT_EQUAL_UINT(1837, 1837);
+    TEST_ASSERT_EQUAL_UINT(v0, v1);
+    TEST_ASSERT_EQUAL_UINT(19467, v1);
+    TEST_ASSERT_EQUAL_UINT(v0, 19467);
+    TEST_ASSERT_EQUAL_UINT(*p0, v1);
+    TEST_ASSERT_EQUAL_UINT(*p0, *p1);
+    TEST_ASSERT_EQUAL_UINT(*p0, 19467);
+}
+
+void testEqualHex8s(void)
+{
+    unsigned int v0, v1;
+    unsigned int *p0, *p1;
+    v0 = 0x22;
+    v1 = 0x22;
+    p0 = &v0;
+    p1 = &v1;
+
+    TEST_ASSERT_EQUAL_HEX8(0x22, 0x22);
+    TEST_ASSERT_EQUAL_HEX8(v0, v1);
+    TEST_ASSERT_EQUAL_HEX8(0x22, v1);
+    TEST_ASSERT_EQUAL_HEX8(v0, 0x22);
+    TEST_ASSERT_EQUAL_HEX8(*p0, v1);
+    TEST_ASSERT_EQUAL_HEX8(*p0, *p1);
+    TEST_ASSERT_EQUAL_HEX8(*p0, 0x22);
+}
+
+void testEqualHex16s(void)
+{
+    unsigned int v0, v1;
+    unsigned int *p0, *p1;
+    v0 = 0x9876;
+    v1 = 0x9876;
+    p0 = &v0;
+    p1 = &v1;
+
+    TEST_ASSERT_EQUAL_HEX16(0x9876, 0x9876);
+    TEST_ASSERT_EQUAL_HEX16(v0, v1);
+    TEST_ASSERT_EQUAL_HEX16(0x9876, v1);
+    TEST_ASSERT_EQUAL_HEX16(v0, 0x9876);
+    TEST_ASSERT_EQUAL_HEX16(*p0, v1);
+    TEST_ASSERT_EQUAL_HEX16(*p0, *p1);
+    TEST_ASSERT_EQUAL_HEX16(*p0, 0x9876);
+}
+
+void testEqualHex32s(void)
+{
+    unsigned int v0, v1;
+    unsigned int *p0, *p1;
+    v0 = 0x98765432;
+    v1 = 0x98765432;
+    p0 = &v0;
+    p1 = &v1;
+
+    TEST_ASSERT_EQUAL_HEX32(0x98765432, 0x98765432);
+    TEST_ASSERT_EQUAL_HEX32(v0, v1);
+    TEST_ASSERT_EQUAL_HEX32(0x98765432, v1);
+    TEST_ASSERT_EQUAL_HEX32(v0, 0x98765432);
+    TEST_ASSERT_EQUAL_HEX32(*p0, v1);
+    TEST_ASSERT_EQUAL_HEX32(*p0, *p1);
+    TEST_ASSERT_EQUAL_HEX32(*p0, 0x98765432);
+}
+
+void testEqualBits(void)
+{
+    unsigned int v0 = 0xFF55AA00;
+    unsigned int v1 = 0x55550000;
+
+    TEST_ASSERT_BITS(v1, v0, 0x55550000);
+    TEST_ASSERT_BITS(v1, v0, 0xFF55CC00);
+    TEST_ASSERT_BITS(0xFFFFFFFF, v0, 0xFF55AA00);
+    TEST_ASSERT_BITS(0xFFFFFFFF, v0, v0);
+    TEST_ASSERT_BITS(0xF0F0F0F0, v0, 0xFC5DAE0F);
+    TEST_ASSERT_BITS_HIGH(v1, v0);
+    TEST_ASSERT_BITS_LOW(0x000055FF, v0);
+    TEST_ASSERT_BIT_HIGH(30, v0);
+    TEST_ASSERT_BIT_LOW(5, v0);
+}
+
+void testEqualShorts(void)
+{
+    short v0, v1;
+    short *p0, *p1;
+    v0 = 19467;
+    v1 = 19467;
+    p0 = &v0;
+    p1 = &v1;
+
+    TEST_ASSERT_EQUAL_INT(1837, 1837);
+    TEST_ASSERT_EQUAL_INT(-2987, -2987);
+    TEST_ASSERT_EQUAL_INT(v0, v1);
+    TEST_ASSERT_EQUAL_INT(19467, v1);
+    TEST_ASSERT_EQUAL_INT(v0, 19467);
+    TEST_ASSERT_EQUAL_INT(*p0, v1);
+    TEST_ASSERT_EQUAL_INT(*p0, *p1);
+    TEST_ASSERT_EQUAL_INT(*p0, 19467);
+}
+
+void testEqualUShorts(void)
+{
+    unsigned short v0, v1;
+    unsigned short *p0, *p1;
+    v0 = 19467;
+    v1 = 19467;
+    p0 = &v0;
+    p1 = &v1;
+
+    TEST_ASSERT_EQUAL_INT(1837, 1837);
+    TEST_ASSERT_EQUAL_INT(-2987, -2987);
+    TEST_ASSERT_EQUAL_INT(v0, v1);
+    TEST_ASSERT_EQUAL_INT(19467, v1);
+    TEST_ASSERT_EQUAL_INT(v0, 19467);
+    TEST_ASSERT_EQUAL_INT(*p0, v1);
+    TEST_ASSERT_EQUAL_INT(*p0, *p1);
+    TEST_ASSERT_EQUAL_INT(*p0, 19467);
+}
+
+void testEqualChars(void)
+{
+    signed char v0, v1;
+    signed char *p0, *p1;
+    v0 = 109;
+    v1 = 109;
+    p0 = &v0;
+    p1 = &v1;
+
+    TEST_ASSERT_EQUAL_INT(42, 42);
+    TEST_ASSERT_EQUAL_INT(-116, -116);
+    TEST_ASSERT_EQUAL_INT(v0, v1);
+    TEST_ASSERT_EQUAL_INT(109, v1);
+    TEST_ASSERT_EQUAL_INT(v0, 109);
+    TEST_ASSERT_EQUAL_INT(*p0, v1);
+    TEST_ASSERT_EQUAL_INT(*p0, *p1);
+    TEST_ASSERT_EQUAL_INT(*p0, 109);
+}
+
+void testEqualUChars(void)
+{
+    unsigned char v0, v1;
+    unsigned char *p0, *p1;
+    v0 = 251;
+    v1 = 251;
+    p0 = &v0;
+    p1 = &v1;
+
+    TEST_ASSERT_EQUAL_INT(42, 42);
+    TEST_ASSERT_EQUAL_INT(v0, v1);
+    TEST_ASSERT_EQUAL_INT(251, v1);
+    TEST_ASSERT_EQUAL_INT(v0, 251);
+    TEST_ASSERT_EQUAL_INT(*p0, v1);
+    TEST_ASSERT_EQUAL_INT(*p0, *p1);
+    TEST_ASSERT_EQUAL_INT(*p0, 251);
+}
+
+void testEqualPointers(void)
+{
+    int v0, v1;
+    int *p0, *p1, *p2;
+    v0 = 19467;
+    v1 = 80080;
+    p0 = &v0;
+    p1 = &v1;
+    p2 = &v1;
+
+    TEST_ASSERT_EQUAL_INT(p0, &v0);
+    TEST_ASSERT_EQUAL_INT(&v1, p1);
+    TEST_ASSERT_EQUAL_INT(p2, p1);
+    TEST_ASSERT_EQUAL_INT(&v0, &v0);
+}
+
+void testFloatsWithinDelta(void)
+{
+    TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f);
+    TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f);
+    TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f);
+    TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f);
+}
+
+void floatWithinFailer(void)
+{
+    TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f);
+}
+
+void testFloatsNotWithinDelta(void)
+{
+    int failed;
+    floatWithinFailer();
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is also expected");
+}
+
+void testIntsWithinDelta(void)
+{
+    TEST_ASSERT_INT_WITHIN(1, 5000, 5001);
+    TEST_ASSERT_INT_WITHIN(5, 5000, 4996);
+    TEST_ASSERT_INT_WITHIN(5, 5000, 5005);
+    TEST_ASSERT_INT_WITHIN(500, 50, -440);
+}
+
+void intWithinFailer(void)
+{
+    TEST_ASSERT_INT_WITHIN(5, 5000, 5006);
+}
+
+void testIntsNotWithinDelta(void)
+{
+    int failed;
+    intWithinFailer();
+
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is also expected");
+}
+
+void testEqualStrings(void)
+{
+    const char *testString = "foo";
+
+    TEST_ASSERT_EQUAL_STRING(testString, testString);
+    TEST_ASSERT_EQUAL_STRING("foo", "foo");
+    TEST_ASSERT_EQUAL_STRING("foo", testString);
+    TEST_ASSERT_EQUAL_STRING(testString, "foo");
+    TEST_ASSERT_EQUAL_STRING("", "");
+    TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures);
+}
+
+void stringFailer1(void)
+{
+    TEST_ASSERT_EQUAL_STRING("foo", "bar");
+}
+
+void stringFailer2(void)
+{
+    TEST_ASSERT_EQUAL_STRING("foo", "");
+}
+
+void stringFailer3(void)
+{
+    TEST_ASSERT_EQUAL_STRING("", "bar");
+}
+
+void testNotEqualString1(void)
+{
+    int failed;
+    stringFailer1();
+    
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is also expected");
+}
+
+void testNotEqualString2(void)
+{
+    int failed;
+    stringFailer2();
+    
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is also expected");
+}
+
+void testNotEqualString3(void)
+{
+    int failed;
+    stringFailer3();
+    
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is also expected");
+}
+
+void stringFailer_ExpectedStringIsNull(void)
+{
+    TEST_ASSERT_EQUAL_STRING(NULL, "bar");
+}
+
+void testNotEqualString_ExpectedStringIsNull(void)
+{
+    int failed;
+    stringFailer_ExpectedStringIsNull();
+    
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is also expected");
+}
+
+void stringFailer_ActualStringIsNull(void)
+{
+    TEST_ASSERT_EQUAL_STRING("foo", NULL);
+}
+
+void testNotEqualString_ActualStringIsNull(void)
+{
+    int failed;
+    stringFailer_ActualStringIsNull();
+    
+    failed = Unity.CurrentTestFailed;
+    Unity.CurrentTestFailed = 0;
+
+    TEST_ASSERT_MESSAGE(1U == failed, "This is also expected");
+}
+
+void testProtection(void)
+{
+    volatile int mask = 0;
+    jmp_buf AbortFrame;
+    
+    if (TEST_PROTECT())
+    {
+        mask |= 1;
+        TEST_THROW("This throw was expected");
+    }
+    else
+    {
+        Unity.CurrentTestFailed = 0;
+        mask |= 2;
+    }
+    
+    TEST_ASSERT_EQUAL(3, mask);
+}
+

test/testunity_Runner.c

+#define UNITY_ENABLE_EXTERNAL_ASSERTIONS
+
+#include <setjmp.h>
+#include "unity.h"
+
+void setUp(void);
+void tearDown(void);
+
+void testTrue(void);
+void testFalse(void);
+void testPreviousPass(void);
+void testNotVanilla(void);
+void testNotTrue(void);
+void testNotFalse(void);
+void testNotUnless(void);
+void testFail(void);
+void testIgnoreInWrapper(void);
+void testIgnore(void);
+void testIgnoreMessage(void);
+void testIgnoreMessageInWrapper(void);
+void testWrap(void);
+void testNotEqualInts(void);
+void testNotEqualBits(void);
+void testNotEqualUInts(void);
+void testNotEqualHex8s(void);
+void testNotEqualHex16s(void);
+void testNotEqualHex32s(void);
+void testMultipleUnwrappedAssertionsHandledAppropriately(void);
+void testEqualInts(void);
+void testEqualUints(void);
+void testEqualHex8s(void);
+void testEqualHex16s(void);
+void testEqualHex32s(void);
+void testEqualBits(void);
+void testEqualShorts(void);
+void testEqualUShorts(void);
+void testEqualChars(void);
+void testEqualUChars(void);
+void testEqualPointers(void);
+void testFloatsWithinDelta(void);
+void testFloatsNotWithinDelta(void);
+void testIntsWithinDelta(void);
+void testIntsNotWithinDelta(void);
+void testEqualStrings(void);
+void testNotEqualString1(void);
+void testNotEqualString2(void);
+void testNotEqualString3(void);
+void testNotEqualString_ExpectedStringIsNull(void);
+void testNotEqualString_ActualStringIsNull(void);
+void testProtection(void);
+
+
+static void runTest(UnityTestFunction test)
+{
+    setUp();
+    test();
+    tearDown();
+}
+
+int main(void)
+{
+    Unity.TestFile = __FILE__;
+    UnityBegin();
+
+    // RUN_TEST calls runTest
+    RUN_TEST(testTrue);
+    RUN_TEST(testFalse);
+    RUN_TEST(testNotVanilla);
+    RUN_TEST(testNotTrue);
+    RUN_TEST(testNotFalse);
+    RUN_TEST(testNotUnless);
+    RUN_TEST(testPreviousPass);
+    RUN_TEST(testFail);
+    RUN_TEST(testWrap);
+    RUN_TEST(testIgnoreInWrapper);
+    RUN_TEST(testIgnore);
+    RUN_TEST(testIgnoreMessage);
+    RUN_TEST(testIgnoreMessageInWrapper);
+    RUN_TEST(testNotEqualBits);
+    RUN_TEST(testNotEqualInts);
+    RUN_TEST(testNotEqualUInts);
+    RUN_TEST(testNotEqualHex8s);
+    RUN_TEST(testNotEqualHex16s);
+    RUN_TEST(testNotEqualHex32s);
+    RUN_TEST(testMultipleUnwrappedAssertionsHandledAppropriately);
+    RUN_TEST(testEqualBits);
+    RUN_TEST(testEqualInts);
+    RUN_TEST(testEqualUints);
+    RUN_TEST(testEqualHex8s);
+    RUN_TEST(testEqualHex16s);
+    RUN_TEST(testEqualHex32s);
+    RUN_TEST(testEqualShorts);
+    RUN_TEST(testEqualUShorts);
+    RUN_TEST(testEqualChars);
+    RUN_TEST(testEqualUChars);
+    RUN_TEST(testEqualPointers);
+    RUN_TEST(testEqualStrings);
+    RUN_TEST(testIntsWithinDelta);
+    RUN_TEST(testIntsNotWithinDelta);
+    RUN_TEST(testFloatsWithinDelta);
+    RUN_TEST(testFloatsNotWithinDelta);
+    RUN_TEST(testNotEqualString1);
+    RUN_TEST(testNotEqualString2);
+    RUN_TEST(testNotEqualString3);
+    RUN_TEST(testNotEqualString_ExpectedStringIsNull);
+    RUN_TEST(testNotEqualString_ActualStringIsNull);
+    RUN_TEST(testProtection);
+
+    UnityEnd();
+    return 0;
+}