ceedling 1.1.9 → 1.2.0

data/spec/units/plugins/ide_report_lines_spec.rb

@@ -0,0 +1,229 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/exceptions'
+
+$: << File.expand_path('../../../../plugins/report_tests_ide_stdout/lib', __FILE__)
+require 'ide_report_lines'
+
+# The patterns IDEs match build output against, as each publishes them
+module IdeParsers
+  # Eclipse CDT's GCC error parser, in its evaluation order. Each line goes to the first
+  # pattern matching the whole line.
+  CDT_PATTERNS = {
+    ReportedOnlyOnce:             [ :ignore,  /(.*?):(\d+):(\d+:)? .*\(Each undeclared identifier is reported only once.*/ ],
+    ForEachFunctionItAppearsIn:   [ :ignore,  /(.*?):(\d+):(\d+:)? .*for each function it appears in.\).*/ ],
+    ReportedOnlyOncePerInputFile: [ :ignore,  /(.*?):(\d+):(\d+:)? .*this will be reported only once per input file.*/ ],
+    ErrorUndeclared:              [ :error,   /(.*?):(\d+):(\d+:)? [Ee]rror: ([`'"](.*)['"] undeclared .*)/ ],
+    ErrorConflictingTypesFor:     [ :error,   /(.*?):(\d+):(\d+:)? [Ee]rror: (conflicting types for .*[`'"](.*)['"].*)/ ],
+    ParseErrorBefore:             [ :error,   /(.*?):(\d+):(\d+:)? (parse error before.*[`'"](.*)['"].*)/ ],
+    DefinedButNotUsed:            [ :warning, /(.*?):(\d+):(\d+:)? [Ww]arning: ([`'"](.*)['"] defined but not used.*)/ ],
+    WarningConflictingTypesFor:   [ :warning, /(.*?):(\d+):(\d+:)? [Ww]arning: (conflicting types for .*[`'"](.*)['"].*)/ ],
+    WarningDangerousFunction:     [ :warning, /(.*?):(\d+):(\d+:)? ([Ww]arning:)?\s*(the use of [`'"](.*)['"] is dangerous, better use [`'"](.*)['"].*)/ ],
+    InstantiatedFromHere:         [ :info,    /(.*?):(\d+):(\d+:)?\s*(.*((instantiated)|(required)) from .*)/ ],
+    SkippingInstantiationContexts: [ :info,   /(.*?):(\d+):(\d+:)?\s*(\[\s*skipping \d+ instantiation context.*)/ ],
+    InConstexprExpansion:         [ :info,    /(.*?):(\d+):(\d+:)?\s*(in 'constexpr' expansion of.*)/ ],
+    GenericError:                 [ :error,   /(.*?):(\d+):(\d+:)?\s*(([Ee]rror)|(ERROR)): (.*)/ ],
+    InvocationError:              [ :error,   /(.*?): (([Ee]rror)|(ERROR)): (.*)/ ],
+    GenericWarning:               [ :warning, /(.*?):(\d+):(\d+:)?\s*(([Ww]arning)|(WARNING)): (.*)/ ],
+    GenericInfo:                  [ :info,    /(.*?):(\d+):(\d+:)?\s*(([Nn]ote)|(NOTE)|([Ii]nfo)|(INFO)|(remark)): (.*)/ ],
+    OtherError:                   [ :error,   /(.*?):(\d+):(\d+:)? (.*)/ ]
+  }.freeze
+
+  # Java's matches() takes the whole line
+  def self.cdt(line)
+    CDT_PATTERNS.each do |name, (severity, pattern)|
+      match = /\A(?:#{pattern})\z/.match( line )
+      return { name: name, severity: severity, file: match[1], line: match[2] } if match
+    end
+    return nil
+  end
+
+  # The $gcc problem matcher from VS Code's C/C++ extension
+  VSCODE_GCC = /^(.*?):(\d+):(\d*):?\s+(?:fatal\s+)?(warning|error):\s+(.*)$/
+
+  # The Ceedling for VS Code extension's gcc preset, in its order
+  CEEDLING_EXTENSION_GCC = {
+    warning: /^(.*):(\d+):(\d+):\s+warning:\s+(.*)$/,
+    error:   /^(.*):(\d+):(\d+):\s+error:\s+(.*)$/,
+    other:   /^(.*):(\d+):(?:\([^)]*\):)?\s+(?!(warning:|error:|note:))(.*)$/
+  }.freeze
+
+  # CLion's output filter $FILE_PATH$:$LINE$:$COLUMN$.*, where a file path must be absolute
+  CLION_FILTER = %r{\A((?:[A-Za-z]:)?[/\\][^:]*):(\d+):(\d+).*\z}
+end
+
+describe IdeReportLines do
+  def lines(config, outcome: :failed, file: 'test/TestFoo.c', message: "Expected 1 Was 2")
+    return described_class.load( config ).lines( file, { test: 'test_c', line: 30, message: message }, outcome )
+  end
+
+  describe 'gcc lines' do
+    let(:gcc) { { format: :gcc } }
+
+    it 'locates a failure as an error, column 1, naming the test before its message' do
+      expect(lines( gcc )).to eq( "test/TestFoo.c:30:1: error: test_c: Expected 1 Was 2\n" )
+    end
+
+    it 'locates an ignored test as a warning' do
+      expect(lines( gcc, outcome: :ignored, message: 'not ready' )).to eq( "test/TestFoo.c:30:1: warning: test_c: not ready\n" )
+    end
+
+    it 'names only the test when there is no message' do
+      expect(lines( gcc, message: '' )).to eq( "test/TestFoo.c:30:1: error: test_c\n" )
+    end
+
+    # One problem per test in an IDE, with the whole message still in the console
+    it 'indents the continuation lines of a multi-line message' do
+      expect(lines( gcc, message: "Expected 1\nWas 2\n" )).to eq( "test/TestFoo.c:30:1: error: test_c: Expected 1\n    Was 2\n" )
+    end
+
+    it 'expands the path against the working directory when paths are absolute' do
+      expect(lines( gcc.merge( absolute_paths: true ) )).to eq( "#{File.expand_path( 'test/TestFoo.c' )}:30:1: error: test_c: Expected 1 Was 2\n" )
+    end
+  end
+
+  describe 'legacy lines' do
+    let(:legacy) { { format: :legacy } }
+
+    it 'repeats the file, line, and test before every line of a quoted message' do
+      expect(lines( legacy, message: "Expected 1\nWas 2" )).to eq( %(test/TestFoo.c:30:test_c: "Expected 1\ntest/TestFoo.c:30:test_c: Was 2"\n) )
+    end
+
+    it 'names only the test when there is no message' do
+      expect(lines( legacy, message: '' )).to eq( "test/TestFoo.c:30:test_c\n" )
+    end
+
+    it 'expands the path when paths are absolute' do
+      expect(lines( legacy.merge( absolute_paths: true ) )).to start_with( "#{File.expand_path( 'test/TestFoo.c' )}:30:test_c: " )
+    end
+  end
+
+  describe 'configuration' do
+    let(:relative) { "test/TestFoo.c:30:1: error: test_c: Expected 1 Was 2\n" }
+    let(:absolute) { "#{File.expand_path( 'test/TestFoo.c' )}:30:1: error: test_c: Expected 1 Was 2\n" }
+
+    # Each named IDE is a gcc configuration with the path form that IDE reads
+    it 'expands :vscode and :eclipse to gcc lines with relative paths' do
+      expect(lines( { format: :vscode } )).to eq( relative )
+      expect(lines( { format: :eclipse } )).to eq( relative )
+    end
+
+    it 'expands :clion to gcc lines with absolute paths' do
+      expect(lines( { format: :clion } )).to eq( absolute )
+    end
+
+    it 'lets :absolute_paths override a named IDE that reads either path form' do
+      expect(lines( { format: :eclipse, absolute_paths: true } )).to eq( absolute )
+      expect(lines( { format: :clion, absolute_paths: true } )).to eq( absolute )
+      expect(lines( { format: :vscode, absolute_paths: true } )).to eq( absolute )
+    end
+
+    # CLion's output filters find only absolute paths
+    it 'rejects relative paths for :clion' do
+      expect { lines( { format: :clion, absolute_paths: false } ) }.to raise_error(
+        CeedlingException, /:report_tests_ide_stdout ↳ :absolute_paths cannot be FALSE with :format :clion/
+      )
+    end
+
+    it 'reads a format as a symbol or string in any letter case' do
+      expect(lines( { format: 'GCC' } )).to eq( relative )
+      expect(lines( { format: :CLion } )).to eq( absolute )
+    end
+
+    it 'rejects an unknown format, listing the choices' do
+      expect { lines( { format: 'msvc' } ) }.to raise_error(
+        CeedlingException, /:report_tests_ide_stdout ↳ :format `msvc` is not a format. Choose from :gcc, :legacy, :vscode, :eclipse, :clion./
+      )
+    end
+
+    it 'rejects a format that is not a symbol or string' do
+      expect { lines( { format: nil } ) }.to raise_error( CeedlingException, /:report_tests_ide_stdout ↳ :format/ )
+    end
+
+    # A quoted 'true' would otherwise read as a setting it is not
+    it 'rejects an :absolute_paths that is not a boolean' do
+      expect { lines( { format: :gcc, absolute_paths: 'true' } ) }.to raise_error(
+        CeedlingException, /:report_tests_ide_stdout ↳ :absolute_paths must be TRUE or FALSE/
+      )
+    end
+  end
+
+  # Every generated line is one problem, located at the test. A continuation line holds
+  # message text, which a parser reads as a problem only if that text looks like one.
+  describe 'IDE parsers' do
+    def extension(line)
+      IdeParsers::CEEDLING_EXTENSION_GCC.each do |severity, pattern|
+        match = pattern.match( line )
+        return { severity: severity, file: match[1], line: match[2], message: match[4] } if match
+      end
+      return nil
+    end
+
+    # A sanitizer's stack frame names a file and line too
+    let(:message) { "Expected 1 Was 2\n#0 0x4011 in main test/TestFoo.c:12:5" }
+
+    def problem(outcome, config = { format: :gcc }, file: 'test/TestFoo.c')
+      return lines( config, outcome: outcome, file: file, message: message ).lines( chomp: true )
+    end
+
+    it "gives Eclipse CDT a failure as a GenericError and an ignored test as a GenericWarning" do
+      expect(IdeParsers.cdt( problem( :failed ).first )).to eq( name: :GenericError, severity: :error, file: 'test/TestFoo.c', line: '30' )
+      expect(IdeParsers.cdt( problem( :ignored ).first )).to eq( name: :GenericWarning, severity: :warning, file: 'test/TestFoo.c', line: '30' )
+    end
+
+    it "gives VS Code's $gcc matcher the file, line, severity, and message" do
+      match = IdeParsers::VSCODE_GCC.match( problem( :failed ).first )
+
+      expect(match.captures).to eq( [ 'test/TestFoo.c', '30', '1', 'error', 'test_c: Expected 1 Was 2' ] )
+      expect(IdeParsers::VSCODE_GCC.match( problem( :ignored ).first )[4]).to eq( 'warning' )
+    end
+
+    it "gives the Ceedling for VS Code extension's gcc preset an error and a warning" do
+      expect(extension( problem( :failed ).first )).to eq( severity: :error, file: 'test/TestFoo.c', line: '30', message: 'test_c: Expected 1 Was 2' )
+      expect(extension( problem( :ignored ).first )[:severity]).to eq( :warning )
+    end
+
+    it "gives CLion's output filter the absolute path, line, and column for :clion" do
+      match = IdeParsers::CLION_FILTER.match( problem( :failed, { format: :clion } ).first )
+
+      expect(match.captures).to eq( [ File.expand_path( 'test/TestFoo.c' ), '30', '1' ] )
+    end
+
+    # The reason :clion needs absolute paths
+    it "gives CLion's output filter nothing to find in a relative path" do
+      expect(IdeParsers::CLION_FILTER.match( problem( :failed ).first )).to be_nil
+    end
+
+    it 'leaves continuation lines to no parser' do
+      continuation = problem( :failed ).last
+
+      expect(continuation).to eq( '    #0 0x4011 in main test/TestFoo.c:12:5' )
+      expect(IdeParsers.cdt( continuation )).to be_nil
+      expect(IdeParsers::VSCODE_GCC.match( continuation )).to be_nil
+      expect(extension( continuation )).to be_nil
+    end
+
+    it 'keeps a Windows drive letter, or a space, in the path each parser reads' do
+      [ 'C:/Project Files/test/TestFoo.c', 'test dir/TestFoo.c' ].each do |file|
+        line = problem( :failed, file: file ).first
+
+        expect(IdeParsers.cdt( line )[:file]).to eq( file )
+        expect(IdeParsers::VSCODE_GCC.match( line )[1]).to eq( file )
+        expect(extension( line )[:file]).to eq( file )
+      end
+
+      expect(IdeParsers::CLION_FILTER.match( problem( :failed, file: 'C:/Project Files/test/TestFoo.c' ).first )[1]).to eq( 'C:/Project Files/test/TestFoo.c' )
+    end
+
+    # The legacy line is no problem to CDT, which only a space after the line number changes
+    it 'gives Eclipse CDT nothing to find in a legacy line' do
+      expect(IdeParsers.cdt( problem( :failed, { format: :legacy } ).first )).to be_nil
+    end
+  end
+end

data/spec/units/plugins/json_tests_reporter_spec.rb

@@ -0,0 +1,87 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'json'
+require 'stringio'
+
+$: << File.expand_path('../../../../plugins/report_tests_log_factory/lib', __FILE__)
+require 'json_tests_reporter'
+
+describe JsonTestsReporter do
+  let(:reporter) { described_class.new(handle: :json) }
+
+  # A realistic 2-pass/1-fail/1-ignore result set, shaped exactly like
+  # PluginReportinatorHelper#process_results actually aggregates it --
+  # nontrivial to construct correctly, valuable to pin end-to-end.
+  let(:results) do
+    {
+      successes: [ { source: { file: 'test/TestFoo.c' },
+                     collection: [ { test: 'test_a', line: 10 }, { test: 'test_b', line: 20 } ] } ],
+      failures:  [ { source: { file: 'test/TestFoo.c' },
+                     collection: [ { test: 'test_c', line: 30, message: 'Expected 1 Was 2' } ] } ],
+      ignores:   [ { source: { file: 'test/TestFoo.c' },
+                     collection: [ { test: 'test_d', line: 40 } ] } ],
+      counts: { total: 4, passed: 2, failed: 1, ignored: 1, stdout: 0 }
+    }
+  end
+
+  describe '#body' do
+    it 'produces the documented JSON shape for a mixed pass/fail/ignore result set' do
+      stream = StringIO.new
+      reporter.body(stream: stream, name: 'Ceedling Test Suite', results: results, duration_s: 1.5)
+
+      parsed = JSON.parse(stream.string)
+
+      expect(parsed).to eq({
+        'Name'          => 'Ceedling Test Suite',
+        'BuildDuration' => 1.5,
+        'FailedTests'   => [ { 'file' => 'test/TestFoo.c', 'test' => 'test_c', 'line' => 30, 'message' => 'Expected 1 Was 2' } ],
+        'PassedTests'   => [ { 'file' => 'test/TestFoo.c', 'test' => 'test_a' }, { 'file' => 'test/TestFoo.c', 'test' => 'test_b' } ],
+        'IgnoredTests'  => [ { 'file' => 'test/TestFoo.c', 'test' => 'test_d' } ],
+        'Summary'       => { 'total_tests' => 4, 'passed' => 2, 'ignored' => 1, 'failures' => 1 }
+      })
+    end
+
+    it 'reports counts[:passed] as given rather than deriving it from :total' do
+      inconsistent_results = results.dup
+      # :total is deliberately stale/wrong; :passed is the real, correct aggregate.
+      inconsistent_results[:counts] = { total: 999, passed: 2, failed: 1, ignored: 1, stdout: 0 }
+
+      stream = StringIO.new
+      reporter.body(stream: stream, name: 'x', results: inconsistent_results, duration_s: nil)
+
+      expect(JSON.parse(stream.string)['Summary']['passed']).to eq(2)
+    end
+
+    it 'reports a null build duration when none is known' do
+      stream = StringIO.new
+      reporter.body(stream: stream, name: 'x', results: results, duration_s: nil)
+
+      expect(JSON.parse(stream.string)['BuildDuration']).to be_nil
+    end
+
+    it 'lists a failure reported twice only once' do
+      failure = { test: 'test_c', line: 30, message: 'Expected 1 Was 2' }
+      results[:failures] = [ { source: { file: 'test/TestFoo.c' }, collection: [failure, failure.dup] } ]
+      stream = StringIO.new
+      reporter.body(stream: stream, name: 'x', results: results, duration_s: nil)
+
+      expect(JSON.parse(stream.string)['FailedTests'].length).to eq(1)
+    end
+
+    it 'carries a report name and messages containing JSON metacharacters intact' do
+      results[:failures] = [ { source: { file: 'test/T"x".c' }, collection: [ { test: 't', line: 1, message: "a\"b\\c\n" } ] } ]
+      stream = StringIO.new
+      reporter.body(stream: stream, name: 'Q-36 "Modulator"', results: results, duration_s: nil)
+
+      parsed = JSON.parse(stream.string)
+      expect(parsed['Name']).to eq('Q-36 "Modulator"')
+      expect(parsed['FailedTests'].first['message']).to eq("a\"b\\c\n")
+    end
+  end
+end

data/spec/units/plugins/junit_tests_reporter_spec.rb

@@ -0,0 +1,237 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'stringio'
+require 'rexml/document'
+require 'ceedling/config/config_walkinator'
+
+$: << File.expand_path('../../../../plugins/report_tests_log_factory/lib', __FILE__)
+require 'junit_tests_reporter'
+
+describe JunitTestsReporter do
+  let(:reporter) { described_class.new(handle: :junit) }
+
+  let(:results) do
+    {
+      times: { 'test/TestFoo.c' => 0.5 },
+      successes: [ { source: { file: 'test/TestFoo.c' },
+                     collection: [ { test: 'test_a', unity_test_time: 0 } ] } ],
+      failures:  [ { source: { file: 'test/TestFoo.c' },
+                     collection: [ { test: 'test_b', unity_test_time: 0, message: 'Expected 1 Was 2' } ] } ],
+      ignores:   [ { source: { file: 'test/TestFoo.c' },
+                     collection: [ { test: 'test_c', unity_test_time: 0 } ] } ],
+      stdout: [],
+      counts: { total: 3, passed: 1, failed: 1, ignored: 1 },
+      total_time: 0.5
+    }
+  end
+
+  # reorganize_results groups by test file into one <testsuite> -- real,
+  # nontrivial structural logic worth pinning as a whole via a full
+  # header+body+footer render, parsed back through REXML rather than
+  # asserted against literal text (so incidental whitespace/attribute-order
+  # differences don't make this brittle).
+  describe 'full render' do
+    it 'produces one testsuite per test file with a testcase per result, tagging failure/skipped correctly' do
+      stream = StringIO.new
+      reporter.header(stream: stream, name: 'Ceedling Test Suite', results: results, duration_s: nil)
+      reporter.body(stream: stream, name: 'Ceedling Test Suite', results: results, duration_s: nil)
+      reporter.footer(stream: stream, name: 'Ceedling Test Suite', results: results, duration_s: nil)
+
+      doc = REXML::Document.new(stream.string)
+      root = doc.root
+
+      expect(root.name).to eq('testsuites')
+      expect(root.attributes['tests']).to eq('3')
+      expect(root.attributes['failures']).to eq('1')
+
+      suite = root.elements['testsuite']
+      expect(suite.attributes['name']).to eq('test/TestFoo')
+      expect(suite.attributes['tests']).to eq('3')
+      expect(suite.attributes['failures']).to eq('1')
+      expect(suite.attributes['skipped']).to eq('1')
+
+      testcases = suite.get_elements('testcase')
+      expect(testcases.map { |tc| tc.attributes['name'] }).to contain_exactly('test_a', 'test_b', 'test_c')
+
+      failing = testcases.find { |tc| tc.attributes['name'] == 'test_b' }
+      expect(failing.elements['failure'].attributes['message']).to eq('Expected 1 Was 2')
+
+      ignored = testcases.find { |tc| tc.attributes['name'] == 'test_c' }
+      expect(ignored.elements['skipped']).not_to be_nil
+    end
+  end
+
+  def render(results, name: 'Ceedling Test Suite')
+    stream = StringIO.new
+    reporter.header(stream: stream, name: name, results: results, duration_s: nil)
+    reporter.body(stream: stream, name: name, results: results, duration_s: nil)
+    reporter.footer(stream: stream, name: name, results: results, duration_s: nil)
+    stream.string
+  end
+
+  describe 'suite details' do
+    it "takes a suite's time from its test file's execution time" do
+      suite = REXML::Document.new(render(results)).root.elements['testsuite']
+      expect(suite.attributes['time']).to eq('0.500')
+    end
+
+    it 'writes an empty failure element for a failure with no message' do
+      results[:failures].first[:collection].first[:message] = ''
+      failure = REXML::Document.new(render(results)).root.elements['testsuite/testcase/failure']
+      expect(failure.attributes['message']).to be_nil
+    end
+
+    it "gathers a test file's output, escaped, into its suite's system-out" do
+      results[:stdout] = [ { source: { file: 'test/TestFoo.c' }, collection: ['printed <one>', 'two'] } ]
+      out = REXML::Document.new(render(results)).root.elements['testsuite/system-out']
+      expect(out.text.split("\n").map(&:strip).reject(&:empty?)).to eq(['printed <one>', 'two'])
+    end
+  end
+
+  describe 'escaping' do
+    it 'produces well-formed, parseable XML when a failure message contains XML metacharacters' do
+      escaping_results = results.dup
+      escaping_results[:failures] = [ { source: { file: 'test/TestFoo.c' },
+        collection: [ { test: 'test_b', unity_test_time: 0, message: 'Expected "<a>" Was <b> & more' } ] } ]
+      escaping_results[:successes] = []
+      escaping_results[:ignores] = []
+
+      stream = StringIO.new
+      reporter.header(stream: stream, name: 'x', results: escaping_results, duration_s: nil)
+      reporter.body(stream: stream, name: 'x', results: escaping_results, duration_s: nil)
+      reporter.footer(stream: stream, name: 'x', results: escaping_results, duration_s: nil)
+
+      doc = REXML::Document.new(stream.string) # raises REXML::ParseException on malformed XML
+      message = doc.root.elements['testsuite/testcase/failure'].attributes['message']
+      expect(message).to eq('Expected "<a>" Was <b> & more')
+    end
+  end
+
+  # The same results structure goes to every configured reporter in turn
+  describe 'non-mutation' do
+    it 'does not mutate the original test-name string other reporters would also read' do
+      mutation_results = results.dup
+      test_item = { test: 'test&name', unity_test_time: 0 }
+      mutation_results[:successes] = [ { source: { file: 'test/TestFoo.c' }, collection: [ test_item ] } ]
+      mutation_results[:failures] = []
+      mutation_results[:ignores] = []
+
+      stream = StringIO.new
+      reporter.body(stream: stream, name: 'x', results: mutation_results, duration_s: nil)
+
+      expect(test_item[:test]).to eq('test&name')
+    end
+
+    it 'leaves nil and empty entries in a shared collection in place' do
+      collection = [ { test: 'test_a', unity_test_time: 0 }, nil, {} ]
+      results[:successes] = [ { source: { file: 'test/TestFoo.c' }, collection: collection } ]
+
+      render(results)
+
+      expect(collection.length).to eq(3)
+    end
+  end
+
+  it 'escapes the report name and a test file path in suite names' do
+    results[:successes] = [ { source: { file: 'test/T&"x".c' }, collection: [ { test: 'test_a', unity_test_time: 0 } ] } ]
+    results[:failures]  = []
+    results[:ignores]   = []
+    results[:times]     = { 'test/T&"x".c' => 0.5 }
+
+    root = REXML::Document.new(render(results, name: 'Q-36 & <Modulator>')).root
+
+    expect(root.attributes['name']).to eq('Q-36 & <Modulator>')
+    expect(root.elements['testsuite'].attributes['name']).to eq('test/T&"x"')
+  end
+
+  # A test carries the line Unity reported for it, when its results name one. These
+  # results give the passing test none, which covers a test without a line.
+  describe 'test locations' do
+    before(:each) do
+      results[:failures].first[:collection].first[:line] = 12
+      results[:ignores].first[:collection].first[:line]  = 20
+    end
+
+    def testcase(name, reports = results)
+      REXML::Document.new(render(reports)).root.get_elements('testsuite/testcase').find { |tc| tc.attributes['name'] == name }
+    end
+
+    # The path keeps two same-named test files in different folders, and their
+    # same-named test cases, distinct on CI dashboards
+    it "names each testcase's class for its suite, path kept, and its file" do
+      %w[test_a test_b test_c].each do |name|
+        expect(testcase(name).attributes['classname']).to eq('test/TestFoo')
+        expect(testcase(name).attributes['file']).to eq('test/TestFoo.c')
+      end
+    end
+
+    it "gives a failure its line and starts its message with the file and line" do
+      failing = testcase('test_b')
+
+      expect(failing.attributes['line']).to eq('12')
+      expect(failing.elements['failure'].attributes['message']).to eq('test/TestFoo.c:12: Expected 1 Was 2')
+    end
+
+    it 'gives an ignored test its line' do
+      expect(testcase('test_c').attributes['line']).to eq('20')
+    end
+
+    it 'gives a test without a line no line attribute' do
+      expect(testcase('test_a').attributes['line']).to be_nil
+    end
+
+    it 'leaves a failure without a line as it is' do
+      results[:failures].first[:collection].first.delete(:line)
+      failing = testcase('test_b')
+
+      expect(failing.attributes['line']).to be_nil
+      expect(failing.elements['failure'].attributes['message']).to eq('Expected 1 Was 2')
+    end
+
+    it 'escapes the file and class names' do
+      results[:successes] = [ { source: { file: 'test/T&"x".c' }, collection: [ { test: 'test_a', unity_test_time: 0 } ] } ]
+      results[:times]['test/T&"x".c'] = 0.5
+
+      expect(testcase('test_a').attributes['file']).to eq('test/T&"x".c')
+      expect(testcase('test_a').attributes['classname']).to eq('test/T&"x"')
+    end
+  end
+
+  # Some tools read a file attribute of the form path#line as a link to the line
+  describe ':file_line_anchor' do
+    before(:each) do
+      results[:failures].first[:collection].first[:line] = 12
+      results[:ignores].first[:collection].first[:line]  = 20
+    end
+
+    def configured(config)
+      reporter.config            = config
+      reporter.config_walkinator = ConfigWalkinator.new
+      reporter.setup
+      return reporter
+    end
+
+    def files
+      REXML::Document.new(render(results)).root.get_elements('testsuite/testcase').to_h { |tc| [tc.attributes['name'], tc.attributes['file']] }
+    end
+
+    it 'leaves the file plain by default' do
+      configured( nil )
+
+      expect(files).to eq( 'test_a' => 'test/TestFoo.c', 'test_b' => 'test/TestFoo.c', 'test_c' => 'test/TestFoo.c' )
+    end
+
+    # The passing test here has no line, so it keeps the plain path
+    it 'anchors the file at the line of each test that has one' do
+      configured( { file_line_anchor: true } )
+
+      expect(files).to eq( 'test_a' => 'test/TestFoo.c', 'test_b' => 'test/TestFoo.c#12', 'test_c' => 'test/TestFoo.c#20' )
+    end
+  end
+end