ceedling 0.15.1 → 0.15.2

data/vendor/unity/{rakefile.rb → Rakefile}

@@ -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]
-# ========================================== 
+# ==========================================
 
 UNITY_ROOT = File.expand_path(File.dirname(__FILE__)) + '/'
 
@@ -24,8 +24,13 @@ task :prepare_for_tests => TEMP_DIRS
 
 include RakefileHelpers
 
-# Load default configuration, for now
-DEFAULT_CONFIG_FILE = 'gcc_32.yml'
+# Load proper GCC as defult configuration
+if 1.size == 8 # 8 bytes => 64-bits
+  DEFAULT_CONFIG_FILE = 'gcc_64.yml'
+else # Assume 32-bit otherwise
+  DEFAULT_CONFIG_FILE = 'gcc_32.yml'
+end
+
 configure_toolchain(DEFAULT_CONFIG_FILE)
 
 desc "Test unity with its own unit tests"
@@ -33,9 +38,11 @@ task :unit => [:prepare_for_tests] do
   run_tests get_unit_test_files
 end
 
-Rake::TestTask.new(:scripts) do |t|
-  t.pattern = 'test/test_*.rb'
-  t.verbose = true
+desc "Test unity's helper scripts"
+task :scripts => [:prepare_for_tests] do
+  Dir['test/test_*.rb'].each do |scriptfile|
+    require "./"+scriptfile
+  end
 end
 
 desc "Generate test summary"

data/vendor/unity/auto/colour_prompt.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]
-# ========================================== 
+# ==========================================
 
 if RUBY_PLATFORM =~/(win|w)32$/
 	begin
@@ -21,14 +21,14 @@ end
 
 class ColourCommandLine
   def initialize
-    if RUBY_PLATFORM =~/(win|w)32$/  
+    if RUBY_PLATFORM =~/(win|w)32$/
       get_std_handle = Win32API.new("kernel32", "GetStdHandle", ['L'], 'L')
       @set_console_txt_attrb =
-      Win32API.new("kernel32","SetConsoleTextAttribute",['L','N'], 'I')
+        Win32API.new("kernel32","SetConsoleTextAttribute",['L','N'], 'I')
       @hout = get_std_handle.call(-11)
     end
   end
-  
+
   def change_to(new_colour)
     if RUBY_PLATFORM =~/(win|w)32$/
       @set_console_txt_attrb.call(@hout,self.win32_colour(new_colour))
@@ -36,10 +36,10 @@ class ColourCommandLine
 	  	"\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_green then 2
       when :dark_cyan then 3
@@ -59,22 +59,43 @@ class ColourCommandLine
         0
     end
   end
-	
+
 	def posix_colour(colour)
+    # ANSI Escape Codes - Foreground colors
+    # | Code | Color                     |
+    # | 39   | Default foreground color  |
+    # | 30   | Black                     |
+    # | 31   | Red                       |
+    # | 32   | Green                     |
+    # | 33   | Yellow                    |
+    # | 34   | Blue                      |
+    # | 35   | Magenta                   |
+    # | 36   | Cyan                      |
+    # | 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 :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, :default then 37
+      when :white, :default_white then 37
+      when :default then 39
       else
-        30
+        39
     end
   end
-	
+
   def out_c(mode, colour, str)
     case RUBY_PLATFORM
 			when /(win|w)32$/
@@ -85,7 +106,7 @@ class ColourCommandLine
 			else
 				$stdout.puts("#{change_to(colour)}#{str}\033[0m") if mode == :puts
 				$stdout.print("#{change_to(colour)}#{str}\033[0m") if mode == :print
-		end			
+		end
   end
 end # ColourCommandLine
 

data/vendor/unity/auto/generate_test_runner.rb

@@ -2,8 +2,9 @@
 #   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]
-# ========================================== 
+# ==========================================
 
+$QUICK_RUBY_VERSION = RUBY_VERSION.split('.').inject(0){|vv,v| vv * 100 + v.to_i }
 File.expand_path(File.join(File.dirname(__FILE__),'colour_prompt'))
 
 class UnityTestRunnerGenerator
@@ -17,7 +18,7 @@ class UnityTestRunnerGenerator
       else          raise "If you specify arguments, it should be a filename or a hash of options"
     end
   end
-  
+
   def self.grab_config(config_file)
     options = { :includes => [], :plugins => [], :framework => :unity }
     unless (config_file.nil? or config_file.empty?)
@@ -33,46 +34,44 @@ class UnityTestRunnerGenerator
     tests = []
     testfile_includes = []
     used_mocks = []
-    
+
     @options.merge!(options) unless options.nil?
     module_name = File.basename(input_file)
-    
+
     #pull required data from source file
-    File.open(input_file, 'r') do |input|
-      tests               = find_tests(input)
-      testfile_includes   = find_includes(input)
-      used_mocks          = find_mocks(testfile_includes)
-    end
+    source = File.read(input_file)
+    source = source.force_encoding("ISO-8859-1").encode("utf-8", :replace => nil) if ($QUICK_RUBY_VERSION > 10900)
+    tests               = find_tests(source)
+    testfile_includes   = find_includes(source)
+    used_mocks          = find_mocks(testfile_includes)
 
     #build runner file
-    generate(input_file, output_file, tests, used_mocks)
-    
+    generate(input_file, output_file, tests, used_mocks, testfile_includes)
+
     #determine which files were used to return them
     all_files_used = [input_file, output_file]
     all_files_used += testfile_includes.map {|filename| filename + '.c'} unless testfile_includes.empty?
     all_files_used += @options[:includes] unless @options[:includes].empty?
     return all_files_used.uniq
   end
-  
-  def generate(input_file, output_file, tests, used_mocks)
+
+  def generate(input_file, output_file, tests, used_mocks, testfile_includes)
     File.open(output_file, 'w') do |output|
-      create_header(output, used_mocks)
+      create_header(output, used_mocks, testfile_includes)
       create_externs(output, tests, used_mocks)
       create_mock_management(output, used_mocks)
       create_suite_setup_and_teardown(output)
       create_reset(output, used_mocks)
-      create_main(output, input_file, tests)
+      create_main(output, input_file, tests, used_mocks)
     end
   end
-  
-  def find_tests(input_file)
+
+  def find_tests(source)
     tests_raw = []
     tests_args = []
     tests_and_line_numbers = []
-    
-    input_file.rewind
-    source_raw = input_file.read
-    source_scrubbed = source_raw.gsub(/\/\/.*$/, '')           # remove line comments
+
+    source_scrubbed = source.gsub(/\/\/.*$/, '')               # remove line comments
     source_scrubbed = source_scrubbed.gsub(/\/\*.*?\*\//m, '') # remove block comments
     lines = source_scrubbed.split(/(^\s*\#.*$)                 # Treat preprocessor directives as a logical line
                               | (;|\{|\}) /x)                  # Match ;, {, and } as end of lines
@@ -94,7 +93,7 @@ class UnityTestRunnerGenerator
     end
 
     #determine line numbers and create tests to run
-    source_lines = source_raw.split("\n")
+    source_lines = source.split("\n")
     source_index = 0;
     tests_and_line_numbers.size.times do |i|
       source_lines[source_index..-1].each_with_index do |line, index|
@@ -105,34 +104,33 @@ class UnityTestRunnerGenerator
         end
       end
     end
-    
+
     return tests_and_line_numbers
   end
 
-  def find_includes(input_file)
-    input_file.rewind
-    
-    #read in file
-    source = input_file.read
-    
+  def find_includes(source)
+
     #remove comments (block and line, in three steps to ensure correct precedence)
     source.gsub!(/\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '')  # remove line comments that comment out the start of blocks
-    source.gsub!(/\/\*.*?\*\//m, '')                     # remove block comments 
+    source.gsub!(/\/\*.*?\*\//m, '')                     # remove block comments
     source.gsub!(/\/\/.*$/, '')                          # remove line comments (all that remain)
-    
+
     #parse out includes
-    return source.scan(/^\s*#include\s+\"\s*(.+)\.[hH]\s*\"/).flatten
+    includes = source.scan(/^\s*#include\s+\"\s*(.+)\.[hH]\s*\"/).flatten
+    brackets_includes = source.scan(/^\s*#include\s+<\s*(.+)\s*>/).flatten
+    brackets_includes.each { |inc| includes << '<' + inc +'>' }
+    return includes
   end
-  
+
   def find_mocks(includes)
     mock_headers = []
     includes.each do |include_file|
       mock_headers << File.basename(include_file) if (include_file =~ /^mock/i)
     end
-    return mock_headers  
+    return mock_headers
   end
-  
-  def create_header(output, mocks)
+
+  def create_header(output, mocks, testfile_includes)
     output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */')
     create_runtest(output, mocks)
     output.puts("\n//=======Automagically Detected Files To Include=====")
@@ -144,17 +142,22 @@ class UnityTestRunnerGenerator
     output.puts('#include <setjmp.h>')
     output.puts('#include <stdio.h>')
     output.puts('#include "CException.h"') if @options[:plugins].include?(:cexception)
+  testfile_includes.delete("unity").delete("cmock")
+  testrunner_includes = testfile_includes - mocks
+  testrunner_includes.each do |inc|
+    output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h','')}.h\""}")
+  end
     mocks.each do |mock|
       output.puts("#include \"#{mock.gsub('.h','')}.h\"")
     end
     if @options[:enforce_strict_ordering]
-      output.puts('')    
-      output.puts('int GlobalExpectCount;') 
-      output.puts('int GlobalVerifyOrder;') 
-      output.puts('char* GlobalOrderError;') 
+      output.puts('')
+      output.puts('int GlobalExpectCount;')
+      output.puts('int GlobalVerifyOrder;')
+      output.puts('char* GlobalOrderError;')
     end
   end
-  
+
   def create_externs(output, tests, mocks)
     output.puts("\n//=======External Functions This Runner Calls=====")
     output.puts("extern void setUp(void);")
@@ -164,7 +167,7 @@ class UnityTestRunnerGenerator
     end
     output.puts('')
   end
-  
+
   def create_mock_management(output, mocks)
     unless (mocks.empty?)
       output.puts("\n//=======Mock Management=====")
@@ -172,8 +175,8 @@ class UnityTestRunnerGenerator
       output.puts("{")
       if @options[:enforce_strict_ordering]
         output.puts("  GlobalExpectCount = 0;")
-        output.puts("  GlobalVerifyOrder = 0;") 
-        output.puts("  GlobalOrderError = NULL;") 
+        output.puts("  GlobalVerifyOrder = 0;")
+        output.puts("  GlobalOrderError = NULL;")
       end
       mocks.each do |mock|
         mock_clean = mock.gsub(/(?:-|\s+)/, "_")
@@ -198,7 +201,7 @@ class UnityTestRunnerGenerator
       output.puts("}\n")
     end
   end
-  
+
   def create_suite_setup_and_teardown(output)
     unless (@options[:suite_setup].nil?)
       output.puts("\n//=======Suite Setup=====")
@@ -215,37 +218,37 @@ class UnityTestRunnerGenerator
       output.puts("}")
     end
   end
-  
+
   def create_runtest(output, used_mocks)
     cexception = @options[:plugins].include? :cexception
     va_args1   = @options[:use_param_tests] ? ', ...' : ''
     va_args2   = @options[:use_param_tests] ? '__VA_ARGS__' : ''
     output.puts("\n//=======Test Runner Used To Run Each Test Below=====")
-    output.puts("#define RUN_TEST_NO_ARGS") if @options[:use_param_tests] 
+    output.puts("#define RUN_TEST_NO_ARGS") if @options[:use_param_tests]
     output.puts("#define RUN_TEST(TestFunc, TestLineNum#{va_args1}) \\")
     output.puts("{ \\")
     output.puts("  Unity.CurrentTestName = #TestFunc#{va_args2.empty? ? '' : " \"(\" ##{va_args2} \")\""}; \\")
     output.puts("  Unity.CurrentTestLineNumber = TestLineNum; \\")
     output.puts("  Unity.NumberOfTests++; \\")
+    output.puts("  CMock_Init(); \\") unless (used_mocks.empty?)
     output.puts("  if (TEST_PROTECT()) \\")
     output.puts("  { \\")
     output.puts("    CEXCEPTION_T e; \\") if cexception
     output.puts("    Try { \\") if cexception
-    output.puts("      CMock_Init(); \\") unless (used_mocks.empty?) 
     output.puts("      setUp(); \\")
     output.puts("      TestFunc(#{va_args2}); \\")
-    output.puts("      CMock_Verify(); \\") unless (used_mocks.empty?)
     output.puts("    } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, \"Unhandled Exception!\"); } \\") if cexception
     output.puts("  } \\")
-    output.puts("  CMock_Destroy(); \\") unless (used_mocks.empty?)
     output.puts("  if (TEST_PROTECT() && !TEST_IS_IGNORED) \\")
     output.puts("  { \\")
     output.puts("    tearDown(); \\")
+    output.puts("    CMock_Verify(); \\") unless (used_mocks.empty?)
     output.puts("  } \\")
+    output.puts("  CMock_Destroy(); \\") unless (used_mocks.empty?)
     output.puts("  UnityConcludeTest(); \\")
     output.puts("}\n")
   end
-  
+
   def create_reset(output, used_mocks)
     output.puts("\n//=======Test Reset Option=====")
     output.puts("void resetTest()")
@@ -253,18 +256,18 @@ class UnityTestRunnerGenerator
     output.puts("  CMock_Verify();") unless (used_mocks.empty?)
     output.puts("  CMock_Destroy();") unless (used_mocks.empty?)
     output.puts("  tearDown();")
-    output.puts("  CMock_Init();") unless (used_mocks.empty?) 
+    output.puts("  CMock_Init();") unless (used_mocks.empty?)
     output.puts("  setUp();")
     output.puts("}")
   end
-  
-  def create_main(output, filename, tests)
+
+  def create_main(output, filename, tests, used_mocks)
     output.puts("\n\n//=======MAIN=====")
     output.puts("int main(void)")
     output.puts("{")
     output.puts("  suite_setup();") unless @options[:suite_setup].nil?
-    output.puts("  Unity.TestFile = \"#{filename}\";")
     output.puts("  UnityBegin();")
+    output.puts("  Unity.TestFile = \"#{filename}\";")
     if (@options[:use_param_tests])
       tests.each do |test|
         if ((test[:args].nil?) or (test[:args].empty?))
@@ -277,6 +280,7 @@ class UnityTestRunnerGenerator
         tests.each { |test| output.puts("  RUN_TEST(#{test[:test]}, #{test[:line_number]});") }
     end
     output.puts()
+    output.puts("  CMock_Guts_MemFreeFinal();") unless used_mocks.empty?
     output.puts("  return #{@options[:suite_teardown].nil? ? "" : "suite_teardown"}(UnityEnd());")
     output.puts("}")
   end
@@ -286,18 +290,18 @@ end
 if ($0 == __FILE__)
   options = { :includes => [] }
   yaml_file = nil
-  
+
   #parse out all the options first
-  ARGV.reject! do |arg| 
+  ARGV.reject! do |arg|
     case(arg)
-      when '-cexception' 
+      when '-cexception'
         options[:plugins] = [:cexception]; true
       when /\.*\.yml/
         options = UnityTestRunnerGenerator.grab_config(arg); true
       else false
     end
-  end     
-           
+  end
+
   #make sure there is at least one parameter left (the input file)
   if !ARGV[0]
     puts ["usage: ruby #{__FILE__} (yaml) (options) input_test_file output_test_runner (includes)",
@@ -305,12 +309,12 @@ if ($0 == __FILE__)
            "  -cexception - include cexception support"].join("\n")
     exit 1
   end
-  
+
   #create the default test runner name if not specified
   ARGV[1] = ARGV[0].gsub(".c","_Runner.c") if (!ARGV[1])
-  
+
   #everything else is an include file
   options[:includes] ||= (ARGV.slice(2..-1).flatten.compact) if (ARGV.size > 2)
-  
+
   UnityTestRunnerGenerator.new(options).run(ARGV[0], ARGV[1])
 end

data/vendor/unity/auto/parseOutput.rb

@@ -0,0 +1,189 @@
+#============================================================
+#  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 GCC/Linux builds use the following:
+#      make | tee Output.txt
+#
+#    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
+#============================================================
+
+
+class ParseOutput
+# The following flag is set to true when a test is found or false otherwise.
+    @testFlag
+    @xmlOut
+    @arrayList
+    @totalTests
+    @classIndex
+
+#   Set the flag to indicate if there will be an XML output file or not  
+    def setXmlOutput()
+        @xmlOut = true
+    end
+    
+#  if write our output to XML
+    def writeXmlOuput()
+            output = File.open("report.xml", "w")
+            output << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+            @arrayList.each do |item|
+                output << item << "\n"
+            end
+            output << "</testsuite>\n"
+    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  testSuiteVerify(testSuiteName)
+        if @testFlag == false
+            @testFlag = true;
+            # Split the path name 
+            testName = testSuiteName.split("/")
+            # Remove the extension
+            baseName = testName[testName.size - 1].split(".")
+            @testSuite = "test." + baseName[0]
+            printf "New Test: %s\n", @testSuite
+        end
+    end
+    
+
+# Test was flagged as having passed so format the output
+    def testPassed(array)
+        lastItem = array.length - 1
+        testName = array[lastItem - 1]
+        testSuiteVerify(array[@className])
+        printf "%-40s PASS\n", testName
+        if @xmlOut == true
+            @arrayList.push "     <testcase classname=\"" + @testSuite + "\" name=\"" + testName + "\"/>"
+        end          
+    end
+
+# Test was flagged as being ingored so format the output
+    def testIgnored(array)
+        lastItem = array.length - 1
+        testName = array[lastItem - 2]
+        reason = array[lastItem].chomp
+        testSuiteVerify(array[@className])
+        printf "%-40s IGNORED\n", testName
+        if @xmlOut == true
+            @arrayList.push "     <testcase classname=\"" + @testSuite + "\" name=\"" + testName + "\">"
+            @arrayList.push "            <skipped type=\"TEST IGNORED\"> " + reason + " </skipped>"
+            @arrayList.push "     </testcase>"
+        end          
+    end
+
+# Test was flagged as having failed  so format the line
+    def testFailed(array)
+        lastItem = array.length - 1
+        testName = array[lastItem - 2]
+        reason = array[lastItem].chomp + " at line: " + array[lastItem - 3]
+        testSuiteVerify(array[@className])
+        printf "%-40s FAILED\n", testName
+        if @xmlOut == true
+            @arrayList.push "     <testcase classname=\"" + @testSuite + "\" name=\"" + testName + "\">"
+            @arrayList.push "            <failure type=\"ASSERT FAILED\"> " + reason + " </failure>"
+            @arrayList.push "     </testcase>"
+        end          
+    end
+
+    
+# Figure out what OS we are running on.   For now we are assuming if it's not Windows it must
+# be Unix based.  
+    def detectOS()
+        myOS = RUBY_PLATFORM.split("-")
+        if myOS.size == 2
+            if myOS[1] == "mingw32"
+                @className = 1
+            else
+                @className = 0
+            end
+        end
+        
+    end
+
+# Main function used to parse the file that was captured.
+    def process(name)
+        @testFlag = false
+        @arrayList = Array.new
+
+        detectOS()
+
+        puts "Parsing file: " + name
+    
+      
+        testPass = 0
+        testFail = 0
+        testIgnore = 0
+        puts ""
+        puts "=================== RESULTS ====================="
+        puts ""
+        File.open(name).each do |line|
+        # Typical test lines look like this:
+        # <path>/<test_file>.c:36:test_tc1000_opsys:FAIL: Expected 1 Was 0
+        # <path>/<test_file>.c:112:test_tc5004_initCanChannel:IGNORE: Not Yet Implemented
+        # <path>/<test_file>.c:115:test_tc5100_initCanVoidPtrs:PASS
+        #
+        # where path is different on Unix vs Windows devices (Windows leads with a drive letter)
+            lineArray = line.split(":")
+            lineSize = lineArray.size
+            # 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.
+            if lineSize >= 4
+                # Determine if this test passed
+                if  line.include? ":PASS"
+                    testPassed(lineArray)
+                    testPass += 1
+                elsif line.include? ":FAIL:"
+                    testFailed(lineArray)
+                    testFail += 1
+                elsif line.include? ":IGNORE:"
+                    testIgnored(lineArray)
+                    testIgnore += 1
+                # If none of the keywords are found there are no more tests for this suite so clear
+                # the test flag
+                else
+                    @testFlag = false
+                end
+            else
+                @testFlag = false
+                end
+            end
+        puts ""
+        puts "=================== SUMMARY ====================="
+        puts ""
+        puts "Tests Passed  : " + testPass.to_s
+        puts "Tests Failed  : " + testFail.to_s
+        puts "Tests Ignored : " + testIgnore.to_s
+        @totalTests = testPass + testFail + testIgnore
+        if @xmlOut == true
+            heading = "<testsuite tests=\"" +  @totalTests.to_s  + "\" failures=\"" + testFail.to_s + "\""  + " skips=\"" +  testIgnore.to_s + "\">" 
+            @arrayList.insert(0, heading) 
+            writeXmlOuput()
+        end
+
+    #  return result
+    end
+
+ end
+
+# If the command line has no values in, used a default value of Output.txt
+parseMyFile = ParseOutput.new
+
+if ARGV.size >= 1 
+    ARGV.each do |a|
+        if a == "-xml"
+            parseMyFile.setXmlOutput();
+        else
+            parseMyFile.process(a)
+            break
+        end
+    end
+end