ceedling 0.25.0 → 0.27.0

data/vendor/cmock/vendor/unity/auto/parse_output.rb

@@ -0,0 +1,220 @@
+#============================================================
+#  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
+  def initialize
+    @test_flag = false
+    @xml_out = false
+    @array_list = false
+    @total_tests = false
+    @class_index = false
+  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
+    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 test_suite_verify(test_suite_name)
+    return if @test_flag
+
+    @test_flag = true
+    # Split the path name
+    test_name = test_suite_name.split('/')
+    # Remove the extension
+    base_name = test_name[test_name.size - 1].split('.')
+    @test_suite = 'test.' + base_name[0]
+    printf "New Test: %s\n", @test_suite
+  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])
+    printf "%-40s PASS\n", test_name
+
+    return unless @xml_out
+
+    @array_list.push '     <testcase classname="' + @test_suite + '" name="' + test_name + '"/>'
+  end
+
+  # Test was flagged as having passed so format the output.
+  # This is using the Unity fixture output and not the original Unity output.
+  def test_passed_unity_fixture(array)
+    test_suite = array[0].sub('TEST(', '')
+    test_suite = test_suite.sub(',', '')
+    test_name = array[1].sub(')', '')
+
+    return unless @xml_out
+
+    @array_list.push '     <testcase classname="' + test_suite + '" name="' + test_name + '"/>'
+  end
+
+  # Test was flagged as being ingored so format the output
+  def test_ignored(array)
+    last_item = array.length - 1
+    test_name = array[last_item - 2]
+    reason = array[last_item].chomp
+    test_suite_verify(array[@class_name])
+    printf "%-40s IGNORED\n", test_name
+
+    if test_name.start_with? 'TEST('
+      array2 = test_name.split(' ')
+      @test_suite = array2[0].sub('TEST(', '')
+      @test_suite = @test_suite.sub(',', '')
+      test_name = array2[1].sub(')', '')
+    end
+
+    return unless @xml_out
+
+    @array_list.push '     <testcase classname="' + @test_suite + '" name="' + test_name + '">'
+    @array_list.push '            <skipped type="TEST IGNORED"> ' + reason + ' </skipped>'
+    @array_list.push '     </testcase>'
+  end
+
+  # Test was flagged as having failed  so format the line
+  def test_failed(array)
+    last_item = array.length - 1
+    test_name = array[last_item - 2]
+    reason = array[last_item].chomp + ' at line: ' + array[last_item - 3]
+    test_suite_verify(array[@class_name])
+    printf "%-40s FAILED\n", test_name
+
+    if test_name.start_with? 'TEST('
+      array2 = test_name.split(' ')
+      @test_suite = array2[0].sub('TEST(', '')
+      @test_suite = @test_suite.sub(',', '')
+      test_name = array2[1].sub(')', '')
+    end
+
+    return unless @xml_out
+
+    @array_list.push '     <testcase classname="' + @test_suite + '" name="' + test_name + '">'
+    @array_list.push '            <failure type="ASSERT FAILED"> ' + reason + ' </failure>'
+    @array_list.push '     </testcase>'
+  end
+
+  # Figure out what OS we are running on.   For now we are assuming if it's not Windows it must
+  # be Unix based.
+  def detect_os
+    os = RUBY_PLATFORM.split('-')
+    @class_name = if os.size == 2
+                    if os[1] == 'mingw32'
+                      1
+                    else
+                      0
+                    end
+                  else
+                    0
+                  end
+  end
+
+  # Main function used to parse the file that was captured.
+  def process(name)
+    @test_flag = false
+    @array_list = []
+
+    detect_os
+
+    puts 'Parsing file: ' + name
+
+    test_pass = 0
+    test_fail = 0
+    test_ignore = 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)
+      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.
+      if (line_array.size >= 4) || (line.start_with? 'TEST(')
+        # Determine if this test passed
+        if line.include? ':PASS'
+          test_passed(line_array)
+          test_pass += 1
+        elsif line.include? ':FAIL:'
+          test_failed(line_array)
+          test_fail += 1
+        elsif line.include? ':IGNORE:'
+          test_ignored(line_array)
+          test_ignore += 1
+        elsif line.start_with? 'TEST('
+          if line.include? ' PASS'
+            line_array = line.split(' ')
+            test_passed_unity_fixture(line_array)
+            test_pass += 1
+          end
+        # If none of the keywords are found there are no more tests for this suite so clear
+        # the test flag
+        else
+          @test_flag = false
+        end
+      else
+        @test_flag = false
+      end
+    end
+    puts ''
+    puts '=================== SUMMARY ====================='
+    puts ''
+    puts 'Tests Passed  : ' + test_pass.to_s
+    puts 'Tests Failed  : ' + test_fail.to_s
+    puts 'Tests Ignored : ' + test_ignore.to_s
+    @total_tests = test_pass + test_fail + test_ignore
+
+    return unless @xml_out
+
+    heading = '<testsuite tests="' + @total_tests.to_s + '" failures="' + test_fail.to_s + '"' + ' skips="' + test_ignore.to_s + '">'
+    @array_list.insert(0, heading)
+    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 |a|
+    if a == '-xml'
+      parse_my_file.set_xml_output
+    else
+      parse_my_file.process(a)
+      break
+    end
+  end
+end

data/vendor/cmock/vendor/unity/auto/stylize_as_junit.rb

@@ -12,7 +12,6 @@ require 'pp'
 VERSION = 1.0
 
 class ArgvParser
-
   #
   # Return a structure describing the options.
   #
@@ -20,41 +19,41 @@ class ArgvParser
     # 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"
+    options.results_dir = '.'
+    options.root_path = '.'
+    options.out_file = 'results.xml'
 
-    opts = OptionParser.new do |opts|
-      opts.banner = "Usage: unity_to_junit.rb [options]"
+    opts = OptionParser.new do |o|
+      o.banner = 'Usage: unity_to_junit.rb [options]'
 
-      opts.separator ""
-      opts.separator "Specific options:"
+      o.separator ''
+      o.separator 'Specific options:'
 
-      opts.on("-r", "--results <dir>", "Look for Unity Results files here.") do |results|
-        #puts "results #{results}"
+      o.on('-r', '--results <dir>', 'Look for Unity Results files here.') do |results|
+        # puts "results #{results}"
         options.results_dir = results
       end
 
-      opts.on("-p", "--root_path <path>", "Prepend this path to files in results.") do |root_path|
+      o.on('-p', '--root_path <path>', 'Prepend this path to files in results.') do |root_path|
         options.root_path = root_path
       end
 
-      opts.on("-o", "--output <filename>", "XML file to generate.") do |out_file|
-        #puts "out_file: #{out_file}"
+      o.on('-o', '--output <filename>', 'XML file to generate.') do |out_file|
+        # puts "out_file: #{out_file}"
         options.out_file = out_file
       end
 
-      opts.separator ""
-      opts.separator "Common options:"
+      o.separator ''
+      o.separator 'Common options:'
 
       # No argument, shows at tail.  This will print an options summary.
-      opts.on_tail("-h", "--help", "Show this message") do
-        puts opts
+      o.on_tail('-h', '--help', 'Show this message') do
+        puts o
         exit
       end
 
       # Another typical switch to print the version.
-      opts.on_tail("--version", "Show version") do
+      o.on_tail('--version', 'Show version') do
         puts "unity_to_junit.rb version #{VERSION}"
         exit
       end
@@ -62,13 +61,13 @@ class ArgvParser
 
     opts.parse!(args)
     options
-  end  # parse()
-
-end  # class OptparseExample
+  end # parse()
+end # class OptparseExample
 
 class UnityToJUnit
   include FileUtils::Verbose
   attr_reader :report, :total_tests, :failures, :ignored
+  attr_writer :targets, :root, :out_file
 
   def initialize
     @report = ''
@@ -77,125 +76,115 @@ class UnityToJUnit
 
   def run
     # Clean up result file names
-    results = @targets.map {|target| target.gsub(/\\/,"/")}
-    #puts "Output File: #{@out_file}"
-    f = File.new(@out_file, "w")
+    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 )
+    write_suites_header(f)
     results.each do |result_file|
-      lines = File.readlines(result_file).map { |line| line.chomp }
-      if lines.length == 0
-        raise "Empty test result file: #{result_file}"
-      else
-        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])
-      end
-      #use line[0] from the test output to get the test_file path and name
-      test_file_str = lines[0].gsub("\\","/")
-      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
+      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, ".*")
+      @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 )
+      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 )
+    write_suites_footer(f)
     f.close
   end
 
-  def set_targets(target_array)
-    @targets = target_array
-  end
-
-  def set_root_path(path)
-    @root = path
-  end
-  def set_out_file(filename)
-    @out_file = filename
-  end
-  def usage(err_msg=nil)
+  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"
+    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 = get_results_structure
+
+  def get_details(_result_file, lines)
+    results = results_structure
     lines.each do |line|
-      line = line.gsub("\\","/")
-      src_file,src_line,test_name,status,msg = line.split(/:/)
-      line_out = ((@root and (@root != 0)) ? "#{@root}#{line}" : line ).gsub(/\//, "\\")
-      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}
+      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
-    return results
+    results
   end
 
   def parse_test_summary(summary)
-    if summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ }
-      [$1.to_i,$2.to_i,$3.to_i]
-    else
-      raise "Couldn't parse test results: #{summary}"
-    end
+    raise "Couldn't parse test results: #{summary}" unless summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ }
+    [Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i]
+  end
+
+  def here
+    File.expand_path(File.dirname(__FILE__))
   end
-  def here; File.expand_path(File.dirname(__FILE__)); end
 
   private
 
-  def get_results_structure
-    return {
-      :source    => {:path => '', :file => ''},
-      :successes => [],
-      :failures  => [],
-      :ignores   => [],
-      :counts    => {:total => 0, :passed => 0, :failed => 0, :ignored  => 0},
-      :stdout    => [],
+  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 )
+  def write_xml_header(stream)
     stream.puts "<?xml version='1.0' encoding='utf-8' ?>"
   end
 
-  def write_suites_header( stream )
-    stream.puts "<testsuites>"
+  def write_suites_header(stream)
+    stream.puts '<testsuites>'
   end
 
-  def write_suite_header( counts, stream )
+  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 )
+  def write_failures(results, stream)
     result = results[:failures]
     result.each do |item|
       filename = File.join(results[:source][:path], File.basename(results[:source][:file], '.*'))
@@ -206,15 +195,14 @@ class UnityToJUnit
     end
   end
 
-  def write_tests( results, stream )
+  def write_tests(results, stream)
     result = results[:successes]
     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\" />"
     end
   end
 
-  def write_ignored( results, stream )
+  def write_ignored(results, stream)
     result = results[:ignores]
     result.each do |item|
       filename = File.join(results[:source][:path], File.basename(results[:source][:file], '.*'))
@@ -226,39 +214,39 @@ class UnityToJUnit
     end
   end
 
-  def write_suite_footer( stream )
+  def write_suite_footer(stream)
     stream.puts "\t</testsuite>"
   end
 
-  def write_suites_footer( stream )
-    stream.puts "</testsuites>"
+  def write_suites_footer(stream)
+    stream.puts '</testsuites>'
   end
-end #UnityToJUnit
+end # UnityToJUnit
 
 if __FILE__ == $0
-  #parse out the command options
+  # parse out the command options
   options = ArgvParser.parse(ARGV)
 
-  #create an instance to work with
+  # create an instance to work with
   utj = UnityToJUnit.new
   begin
-    #look in the specified or current directory for result files
-    targets = "#{options.results_dir.gsub(/\\/, '/')}**/*.test*"
+    # 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.set_targets(results)
+    utj.targets = results
 
-    #set the root path
-    utj.set_root_path(options.root_path)
+    # set the root path
+    utj.root = options.root_path
 
-    #set the output XML file name
-    #puts "Output File from options: #{options.out_file}"
-    utj.set_out_file(options.out_file)
+    # set the output XML file name
+    # puts "Output File from options: #{options.out_file}"
+    utj.out_file = options.out_file
 
-    #run the summarizer
+    # run the summarizer
     puts utj.run
-  rescue Exception => e
+  rescue StandardError => e
     utj.usage e.message
   end
 end