ceedling 1.1.1 → 1.1.3

data/lib/ceedling/generators/generator_test_results_backtrace.rb

@@ -13,7 +13,8 @@ class GeneratorTestResultsBacktrace
     @RESULTS_COLLECTOR = Struct.new( :passed, :failed, :ignored, :output, keyword_init:true )
   end
 
-  # Re-runs each test case under gdb to identify which ones crashed and why.
+  # Re-runs each test case (or, for a parameterized test, each group of parameterized
+  # cases -- see `group_test_cases`) under gdb to identify which one(s) crashed and why.
   # Writes the full gdb transcript to a per-test-case log file and assembles a
   # terse crash label (signal + description, optional source line in backticks)
   # for each failing test case. Returns a modified shell_result with regenerated output.
@@ -28,54 +29,83 @@ class GeneratorTestResultsBacktrace
 
     test_name = File.basename( filename, '.*' )
 
-    # Iterate on test cases
-    test_cases.each do |test_case|
-      # Per-test-case log file: <log_path>/<context>/<test_name>/<test_case>.gdb.log
-      log_path = @file_path_utils.form_test_gdb_log( test_name, context: context, name: test_case[:test] )
-      @file_wrapper.mkdir( File.dirname( log_path ) )
-
-      # Build the test fixture to run with our test case of interest
+    # Iterate on test cases, one sub-process run per group (see `group_test_cases`)
+    group_test_cases( test_cases ).each do |group|
+      # Build the test fixture to run with our test case (or parameterized group) of interest
       command = @tool_executor.build_command_line(
         @configurator.tools_test_backtrace_gdb, [],
         gdb_script_filepath,
         executable,
-        test_case[:test]
+        unity_filter_arg( group )
       )
       # Things are gonna go boom, so ignore booms to get output
       command[:options][:boom] = false
 
       crash_result = @tool_executor.exec( command )
 
-      # Sum execution time for each test case
+      # Sum execution time for each sub-process run
       # Note: Running tests separately increases total execution time
       shell_result[:time] += crash_result[:time].to_f()
 
-      test_output = ''
+      unresolved = []
 
-      # Process single test case stats
-      case crash_result[:output]
-      # Success test case
-      when /(^#{filename}.+:PASS\s*$)/
-        test_case_results[:passed]  += 1
-        test_output = $1 # Grab regex match
+      # Attribute each group member its own real result line, if Unity printed one
+      group.each do |test_case|
+        case crash_result[:output]
+        # Success test case
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:PASS\s*$)/
+          test_case_results[:passed]  += 1
+          test_case_results[:output] << $1
 
-      # Ignored test case
-      when /(^#{filename}.+:IGNORE\s*$)/
-        test_case_results[:ignored] += 1
-        test_output = $1 # Grab regex match
+        # Ignored test case
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:IGNORE\s*$)/
+          test_case_results[:ignored] += 1
+          test_case_results[:output] << $1
 
-      when /(^#{filename}.+:FAIL(:.+)?\s*$)/
-        test_case_results[:failed]  += 1
-        test_output = $1 # Grab regex match
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:FAIL(:.+)?\s*$)/
+          test_case_results[:failed]  += 1
+          test_case_results[:output] << $1
 
-      else # Crash failure case
-        test_case_results[:failed]  += 1
+        # No result line for this member -- either it crashed, or it never got to run
+        # because an earlier member in this same group crashed. Resolved below.
+        else
+          unresolved << test_case
+        end
+      end
 
-        # Append full gdb output for this test case to the log
-        @file_wrapper.write( log_path, "=== #{test_case[:test]} ===\n#{crash_result[:output]}\n", 'a' )
+      next if unresolved.empty?
 
-        # Collect file_name and line in which crash occurred
-        matched = crash_result[:output].match( /#{test_case[:test]}\s*\(\)\sat.+#{filename}:(\d+)\n/ )
+      # Prefer whichever unresolved member's own C symbol is actually named in the gdb
+      # backtrace (works regardless of position in the group); fall back to the first
+      # unresolved member if no member's symbol can be found in the transcript (e.g. a
+      # brief crash report with no frame information at all).
+      crashed_case = unresolved.find do |tc|
+        crash_result[:output].match?( /#{Regexp.escape(tc[:symbol])}\s*\(\)\sat/ )
+      end
+      crashed_case ||= unresolved.first
+
+      # Per-test-case log file: <log_path>/<context>/<test_name>/<test_case>.gdb.log
+      log_path = @file_path_utils.form_test_gdb_log( test_name, context: context, name: crashed_case[:test] )
+      @file_wrapper.mkdir( File.dirname( log_path ) )
+      @file_wrapper.write( log_path, "=== #{crashed_case[:test]} ===\n#{crash_result[:output]}\n", 'a' )
+
+      unresolved.each do |test_case|
+        test_case_results[:failed] += 1
+
+        if !test_case.equal?( crashed_case )
+          # An earlier case in this same parameterized group already crashed the
+          # process -- this member never got a chance to run.
+          test_case_results[:output] <<
+            "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: " \
+            "Test case not run -- an earlier case in this parameterized test group crashed"
+          next
+        end
+
+        # Collect file_name and line in which crash occurred.
+        # Match against the actual C symbol (`:symbol`), not the human-facing test name
+        # (`:test`): a parameterized test case crashes inside a generated wrapper function
+        # (`runner_args<N>_<test>`), not a function literally named `<test>(<args>)`.
+        matched = crash_result[:output].match( /#{Regexp.escape(test_case[:symbol])}\s*\(\)\sat.+#{filename}:(\d+)\n/ )
 
         # If we found an error report line containing `test_case() at filename.c:###` in `gdb` output
         if matched
@@ -86,7 +116,7 @@ class GeneratorTestResultsBacktrace
           signal_label = format_signal_label( crash_result[:output] )
 
           # Extract the offending source line (nil for assertion crashes or when unavailable)
-          source_line = extract_source_line( crash_result[:output], test_case[:test], filename )
+          source_line = extract_source_line( crash_result[:output], test_case[:symbol], filename )
 
           # Unity's test executable output is line oriented.
           # Multi-line output is not possible (it looks like random `printf()` statements to the results parser).
@@ -94,7 +124,7 @@ class GeneratorTestResultsBacktrace
           crash_detail = source_line ? "#{NEWLINE_TOKEN}`#{source_line}`" : ''
 
           # Log path appears on its own encoded line so the results parser treats it separately
-          test_output =
+          test_case_results[:output] <<
             "#{filename}:#{line_number}:#{test_case[:test]}:FAIL: Test case crashed" \
             " >> #{signal_label}" \
             "#{crash_detail}" \
@@ -106,20 +136,18 @@ class GeneratorTestResultsBacktrace
           label = format_signal_label( crash_result[:output] )
 
           if !label.empty?
-            test_output =
+            test_case_results[:output] <<
               "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: Test case crashed" \
               " >> #{label}" \
               "#{NEWLINE_TOKEN}(#{log_path})"
           else
-            test_output =
+            test_case_results[:output] <<
               "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: " \
               "Test case crashed (failed to extract `gdb` report)" \
               "#{NEWLINE_TOKEN}(#{log_path})"
           end
         end
       end
-
-      test_case_results[:output] << test_output
     end
 
     # Reset shell result exit code and output
@@ -135,7 +163,8 @@ class GeneratorTestResultsBacktrace
     return shell_result
   end
 
-  # Re-runs each test case individually to determine which ones crashed.
+  # Re-runs each test case (or, for a parameterized test, each group of parameterized
+  # cases -- see `group_test_cases`) individually to determine which one(s) crashed.
   # For crash cases, captures any extra output from the test binary (e.g.
   # assertion messages on stderr) and includes it in the failure report.
   # Returns a modified shell_result with regenerated output.
@@ -146,50 +175,61 @@ class GeneratorTestResultsBacktrace
     # Reset time
     shell_result[:time] = 0
 
-    # Iterate on test cases
-    test_cases.each do |test_case|
-      # Build the test fixture to run with our test case of interest
+    # Iterate on test cases, one sub-process run per group (see `group_test_cases`)
+    group_test_cases( test_cases ).each do |group|
+      # Build the test fixture to run with our test case (or parameterized group) of interest
       command = @tool_executor.build_command_line(
         @configurator.tools_test_fixture_simple_backtrace, [],
         executable,
-        test_case[:test]
+        unity_filter_arg( group )
       )
       # Things are gonna go boom, so ignore booms to get output
       command[:options][:boom] = false
 
       crash_result = @tool_executor.exec( command )
 
-      # Sum execution time for each test case
+      # Sum execution time for each sub-process run
       # Note: Running tests separately increases total execution time
       shell_result[:time] += crash_result[:time].to_f()
 
-      # Process single test case stats
-      case crash_result[:output]
-      # Success test case
-      when /(^#{filename}.+:PASS\s*$)/
-        test_case_results[:passed]  += 1
-        test_output = $1 # Grab regex match
-
-      # Ignored test case
-      when /(^#{filename}.+:IGNORE\s*$)/
-        test_case_results[:ignored] += 1
-        test_output = $1 # Grab regex match
-
-      when /(^#{filename}.+:FAIL(:.+)?\s*$)/
-        test_case_results[:failed]  += 1
-        test_output = $1 # Grab regex match
-
-      else # Crash failure case
-        test_case_results[:failed]  += 1
-
-        # Collect any non-result, non-blank lines (e.g. assertion messages on stderr)
-        extra = extract_simple_crash_output( crash_result[:output], filename )
-        test_output = "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: Test case crashed"
-        test_output += " >> #{extra.join(NEWLINE_TOKEN)}" unless extra.empty?
-      end
+      crashed = false # Has the actual crash in this group already been attributed?
+
+      # Attribute each group member its own real result line, if Unity printed one
+      group.each do |test_case|
+        case crash_result[:output]
+        # Success test case
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:PASS\s*$)/
+          test_case_results[:passed]  += 1
+          test_case_results[:output] << $1
 
-      # Collect up real and stand-in test results output
-      test_case_results[:output] << test_output
+        # Ignored test case
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:IGNORE\s*$)/
+          test_case_results[:ignored] += 1
+          test_case_results[:output] << $1
+
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:FAIL(:.+)?\s*$)/
+          test_case_results[:failed]  += 1
+          test_case_results[:output] << $1
+
+        # No result line for this member -- either it crashed, or it never got to run
+        # because an earlier member in this same group crashed.
+        else
+          test_case_results[:failed] += 1
+
+          if crashed
+            test_case_results[:output] <<
+              "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: " \
+              "Test case not run -- an earlier case in this parameterized test group crashed"
+          else
+            crashed = true
+            # Collect any non-result, non-blank lines (e.g. assertion messages on stderr)
+            extra = extract_simple_crash_output( crash_result[:output], filename )
+            test_output = "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: Test case crashed"
+            test_output += " >> #{extra.join(NEWLINE_TOKEN)}" unless extra.empty?
+            test_case_results[:output] << test_output
+          end
+        end
+      end
     end
 
     # Reset shell result exit code and output
@@ -208,6 +248,34 @@ class GeneratorTestResultsBacktrace
   ### Private ###
   private
 
+  # Groups test cases so each parameterized test's cases are isolated together as one
+  # sub-process run instead of one run per case. Unity's `-n`/`-f` command-line filter
+  # parser treats a comma as a separator between multiple OR'd filter clauses, so an
+  # exact filter can never match a parameterized case's runtime name once it has more
+  # than one argument (e.g. `name(5, 3, 2)`). Grouping by base name and matching each
+  # member's own result line out of the group's single shared sub-run output sidesteps
+  # that limitation entirely. Non-parameterized test cases are unaffected: each forms
+  # its own single-member group, isolated exactly as before.
+  def group_test_cases(test_cases)
+    test_cases.group_by { |test_case| test_case[:test].sub(/\(.*\)\z/, '') }.values
+  end
+
+  # Builds the Unity command-line filter argument for isolating one group (see
+  # `group_test_cases`). A non-parameterized (single-member, no-args) group is isolated
+  # with an exact-match filter as before. A parameterized group is isolated with a
+  # non-strict prefix filter on its shared base name -- the only reliable way to select
+  # such a group, since its members' runtime names contain commas.
+  def unity_filter_arg(group)
+    test_name = group.first[:test]
+
+    if test_name.include?('(')
+      base_name = test_name.sub(/\(.*\)\z/, '')
+      %(-f "#{base_name}")
+    else
+      %(-n "#{test_name}")
+    end
+  end
+
   # Builds a terse crash label from gdb output.
   # Rules:
   #   - Named signal explicitly in output → "[SIGNAL] Description"

data/lib/ceedling/generators/generator_test_runner.rb

@@ -62,8 +62,26 @@ class GeneratorTestRunner
     # Unity's runner generator `find_tests()` produces an array of hashes with the following keys...
     # { test:, args:, call:, params:, line_number: }
 
-    # For external use of test case names and line numbers, keep only those pieces of info
-    @test_cases = @test_cases_internal.map {|hash| hash.slice( :test, :line_number )}
+    # For external use, reduce down to test name, runtime C symbol, and line number.
+    # A parameterized test (`:args` populated) is expanded into one entry per TEST_CASE /
+    # TEST_RANGE / TEST_MATRIX row, since Unity's generated runner registers each invocation
+    # under its own name (matching `generate_test_runner.rb`'s `"#{test}(#{args})"` naming) and
+    # runs it through its own wrapper function (`runner_args<N>_<test>`). Collapsing these to a
+    # single bare-name entry breaks exact-match test case isolation (crash handling) for
+    # parameterized tests.
+    @test_cases = @test_cases_internal.flat_map do |hash|
+      if hash[:args].nil? || hash[:args].empty?
+        [ { test: hash[:test], symbol: hash[:test], line_number: hash[:line_number] } ]
+      else
+        hash[:args].each_with_index.map do |args, idx|
+          {
+            test:        "#{hash[:test]}(#{args})",
+            symbol:      "runner_args#{idx + 1}_#{hash[:test]}",
+            line_number: hash[:line_number]
+          }
+        end
+      end
+    end
   end
 
   def extract_test_cases(source_contents)

data/lib/ceedling/objects.yml

@@ -288,6 +288,7 @@ preprocessinator_comment_stripper:
 preprocessinator_reconstructor:
   compose:
     - parsing_parcels
+    - file_wrapper
 
 preprocessinator:
   compose:

data/lib/ceedling/preprocess/preprocessinator_file_assembler.rb

@@ -217,7 +217,11 @@ class PreprocessinatorFileAssembler
 
     # Write contents of final preprocessed file a line at a time
     # ----------------------------------------------------------
-    @file_wrapper.open( preprocessed_filepath, 'w' ) do |file|
+    # Binary mode: `contents` lines below come from an upstream preprocessed
+    # file and may already carry their own line endings. Windows text mode
+    # rewrites "\n" on write, which would alter a line ending already present
+    # in that content instead of passing it through unchanged.
+    @file_wrapper.open( preprocessed_filepath, 'wb' ) do |file|
       # Add include guards and extra blank lines to beginning of file contents
       file << "#ifndef #{guardname}\n"
       file << "#define #{guardname}\n\n"
@@ -361,7 +365,11 @@ class PreprocessinatorFileAssembler
   def assemble_preprocessed_code_file(filename:, preprocessed_filepath:, contents:, extras:, includes:)
     # Write contents of final preprocessed file a line at a time
     # ----------------------------------------------------------
-    @file_wrapper.open( preprocessed_filepath, 'w' ) do |file|
+    # Binary mode: `contents` lines below come from an upstream preprocessed
+    # file and may already carry their own line endings. Windows text mode
+    # rewrites "\n" on write, which would alter a line ending already present
+    # in that content instead of passing it through unchanged.
+    @file_wrapper.open( preprocessed_filepath, 'wb' ) do |file|
       # Reinsert #include statements into stripped down file
       # Rely on Include object stringification for formatting of incudes
       includes.each { |include| file << "#{include}\n" }

data/lib/ceedling/preprocess/preprocessinator_reconstructor.rb

@@ -9,9 +9,9 @@ require 'ceedling/constants'
 require 'ceedling/encodinator'
 require 'ceedling/parsing_parcels'
 
-class PreprocessinatorReconstructor 
- 
-  constructor :parsing_parcels
+class PreprocessinatorReconstructor
+
+  constructor :parsing_parcels, :file_wrapper
 
   ##
   ## Preprocessor Expansion Output Handling
@@ -104,10 +104,13 @@ class PreprocessinatorReconstructor
   # Opens `input_filepath` for reading and `output_filepath` for writing,
   # then delegates to `compact_from_expansion` with the resulting IO objects.
   def compact_file_from_expansion(input_filepath:, source_filepath:, output_filepath:)
-    # Open input in binary mode: GCC output under non-C locale contains non-ASCII bytes
-    # (localized markers). Per-line clean_encoding in _scan_expansion_for_file handles content.
-    File.open( input_filepath, 'rb' ) do |input|
-      File.open( output_filepath, 'w' ) do |output|
+    # Binary mode on both ends: GCC output under non-C locale contains non-ASCII
+    # bytes (localized markers; per-line clean_encoding in _scan_expansion_for_file
+    # handles content), and the compacted output is read again downstream by code
+    # that depends on its line count being exact. Windows text mode would rewrite
+    # "\n" to "\r\n" on write, which this content must not be subject to.
+    @file_wrapper.open( input_filepath, 'rb' ) do |input|
+      @file_wrapper.open( output_filepath, 'wb' ) do |output|
         compact_from_expansion( input: input, filepath: source_filepath, output: output )
       end
     end
@@ -280,16 +283,21 @@ class PreprocessinatorReconstructor
 
     # Buffer for the last logical line (may still receive aggregated content)
     pending_line  = nil
-    # Whether a blank line should follow pending_line when flushed
-    pending_blank = false
-
-    # Yields pending_line (and optional trailing blank) then clears the buffer
+    # Count of blank lines to emit after pending_line when flushed. Tracked as
+    # an exact count, not just "was there a blank" -- callers that depend on
+    # this method for line-for-line fidelity with the original source (so
+    # that unrelated line-number math downstream stays correct) need every
+    # blank line preserved, including runs that used to be a multi-line
+    # comment before an earlier pass turned it into equivalent blank lines.
+    pending_blank_count = 0
+
+    # Yields pending_line (and any pending blank lines) then clears the buffer
     flush = lambda do
       unless pending_line.nil?
         block.call( pending_line )
-        block.call( '' ) if pending_blank
+        pending_blank_count.times { block.call( '' ) }
         pending_line  = nil
-        pending_blank = false
+        pending_blank_count = 0
       end
     end
 
@@ -308,9 +316,9 @@ class PreprocessinatorReconstructor
         # Strip a line so we can omit useless blank lines
         _line = line.strip()
 
-        # Skip processing blank lines, but mark a pending blank unless we already have one
+        # Skip processing blank lines, but track an exact count of them so runs of blanks survive intact
         if _line.empty?
-          pending_blank = true if !pending_line.nil? && !pending_line.empty?
+          pending_blank_count += 1 if !pending_line.nil? && !pending_line.empty?
           next
         end
 

data/lib/version.rb

@@ -15,7 +15,7 @@
 module Ceedling
   module Version
     # Convenience constants for gem building, etc.
-    GEM = '1.1.1'
+    GEM = '1.1.3'
     TAG = GEM
 
     # If run as a script print Ceedling's version to $stdout

data/plugins/gcov/lib/gcov.rb

@@ -354,8 +354,8 @@ class Gcov < Plugin
 
     shell_result = @tool_executor.exec( command )
 
-    # First line of gcc --version: "gcc (...platform info...) major.minor.patch"
-    version_match = shell_result[:output].match(/^gcc\s+.*\s+(\d+)\.(\d+)\.\d+/)
+    # First line of gcc --version: "gcc[.exe] (...platform info...) major.minor.patch"
+    version_match = shell_result[:output].match(/^gcc(?:#{Regexp.escape(EXTENSION_WIN_EXE)})?\s+.*\s+(\d+)\.(\d+)\.\d+/)
 
     if version_match.nil? || version_match[1].nil? || version_match[2].nil?
       raise CeedlingException.new("Could not collect `gcc` version from its command line")

data/spec/support/system/system_context.rb

@@ -279,6 +279,21 @@ class SystemContext
       sections << stderr.strip
     end
 
+    # Loginator routes `Verbosity::DEBUG` messages (including the backtrace
+    # `log_debug_backtrace` emits for a caught exception) to stdout rather than
+    # stderr, and this method's stdout scan above only pulls lines containing
+    # the literal substrings 'ERROR'/'EXCEPTION' -- a bare backtrace line
+    # (file:line:in `method') contains neither, so without surfacing it here
+    # explicitly, the one piece of stdout most useful for diagnosing *why* a
+    # command failed would otherwise only ever reach the full raw-output log
+    # file, not this console-visible summary (what CI output actually shows).
+    label = 'Debug Backtrace ==>'
+    backtrace_block = extract_section(stdout, label)
+    unless backtrace_block.empty?
+      sections << ">> DEBUG BACKTRACE"
+      sections.concat(backtrace_block)
+    end
+
     label = 'FAILED TEST SUMMARY'
     failed_block = extract_section(stdout, label)
     unless failed_block.empty?

data/spec/system/deployment_as_gem_spec.rb

@@ -91,6 +91,7 @@ ceedling_system_tests do
       test_case :crash_none_writes_fail_results_file
       test_case :crash_simple_sigsegv_all_test_cases
       test_case :crash_simple_sigabrt_assert_failure
+      test_case :crash_simple_sigsegv_with_parameterized_test
     end
 
     describe "Backtrace with GDB" do
@@ -100,6 +101,7 @@ ceedling_system_tests do
       test_case :crash_gdb_sigsegv_targets_test_case_filter
       test_case :crash_gdb_sigsegv_excludes_test_case_filter
       test_case :crash_gdb_sigabrt_assert_failure
+      test_case :crash_gdb_sigsegv_with_parameterized_test
     end
 
     describe "Test filtering" do

data/spec/system/deployment_as_vendor_spec.rb

@@ -94,6 +94,7 @@ ceedling_system_tests do
       test_case :crash_none_writes_fail_results_file
       test_case :crash_simple_sigsegv_all_test_cases
       test_case :crash_simple_sigabrt_assert_failure
+      test_case :crash_simple_sigsegv_with_parameterized_test
     end
 
     describe "Backtrace with GDB" do
@@ -103,6 +104,7 @@ ceedling_system_tests do
       test_case :crash_gdb_sigsegv_targets_test_case_filter
       test_case :crash_gdb_sigsegv_excludes_test_case_filter
       test_case :crash_gdb_sigabrt_assert_failure
+      test_case :crash_gdb_sigsegv_with_parameterized_test
     end
 
     describe "Test filtering" do

data/spec/system/gcov_deployment_spec.rb

@@ -7,11 +7,13 @@
 
 require 'spec_system_helper'
 require_relative 'support/gcov_common_test_cases'
+require_relative 'support/gcov_partials_test_cases'
 
 ceedling_system_tests do
   describe "Gcov" do
     include CommonSystemTestCases
     include GcovCommonTestCases
+    include GcovPartialsTestCases
     before :all do
       determine_reports_to_test
       @c = SystemContext.new
@@ -50,6 +52,18 @@ ceedling_system_tests do
       test_case :create_html_report_100_coverage_excluding_crashing_test_case
     end
 
+    describe "Coverage reporting with Partials" do
+      before do
+        @c.with_context do
+          @c.ceedling_appcmd_exec("new --local #{@proj_name}")
+        end
+      end
+
+      test_case :gcov_partials_coverage_blank_lines_in_function_body
+      test_case :gcov_partials_coverage_decorators_on_own_lines
+      test_case :gcov_partials_coverage_function_scope_static_promotion
+    end
+
     describe "Backtrace with GDB" do
       include_context "requires gdb"
 
@@ -78,7 +92,7 @@ ceedling_system_tests do
             # than resetting, crashing the test executable before Unity can print
             # its statistics line.
             FileUtils.rm_rf('temp_sensor')
-            output = `bundle exec ruby -S ceedling example temp_sensor 2>&1`
+            output = @c.ceedling_appcmd_exec("example temp_sensor")
             expect(output).to match(/created/)
           end
         end
@@ -86,7 +100,7 @@ ceedling_system_tests do
         it "should be testable" do
           @c.with_context do
             Dir.chdir "temp_sensor" do
-              @output = `bundle exec ruby -S ceedling --mixin=add_gcov gcov:all 2>&1`
+              @output = @c.ceedling_build_exec("gcov:all --mixin=add_gcov")
               # Validate full test suite results
               expect(@output).to match(/TESTED:\s+86/)
               expect(@output).to match(/PASSED:\s+86/)
@@ -107,7 +121,7 @@ ceedling_system_tests do
         it "should be able to test a single module (it should INHERIT file-specific flags)" do
           @c.with_context do
             Dir.chdir "temp_sensor" do
-              @output = `bundle exec ruby -S ceedling --mixin=add_gcov gcov:TemperatureCalculator 2>&1`
+              @output = @c.ceedling_build_exec("gcov:TemperatureCalculator --mixin=add_gcov")
               expect(@output).to match(/TESTED:\s+2/)
               expect(@output).to match(/PASSED:\s+2/)
 
@@ -119,7 +133,7 @@ ceedling_system_tests do
         it "should be able to test multiple files matching a pattern" do
           @c.with_context do
             Dir.chdir "temp_sensor" do
-              @output = `bundle exec ruby -S ceedling --mixin=add_gcov gcov:pattern[Temp] 2>&1`
+              @output = @c.ceedling_build_exec("gcov:pattern[Temp] --mixin=add_gcov")
               expect(@output).to match(/TESTED:\s+6/)
               expect(@output).to match(/PASSED:\s+6/)
 
@@ -132,7 +146,7 @@ ceedling_system_tests do
         it "should be able to test all files matching in a path" do
           @c.with_context do
             Dir.chdir "temp_sensor" do
-              @output = `bundle exec ruby -S ceedling --mixin=add_gcov gcov:path[adc] 2>&1`
+              @output = @c.ceedling_build_exec("gcov:path[adc] --mixin=add_gcov")
               expect(@output).to match(/TESTED:\s+24/)
               expect(@output).to match(/PASSED:\s+24/)
 
@@ -147,7 +161,7 @@ ceedling_system_tests do
         it "should be able to test specific test cases in a file" do
           @c.with_context do
             Dir.chdir "temp_sensor" do
-              @output = `bundle exec ruby -S ceedling --mixin=add_gcov gcov:path[adc] --test-case="RunShouldNot" 2>&1`
+              @output = @c.ceedling_build_exec('gcov:path[adc] --mixin=add_gcov --test-case="RunShouldNot"')
               expect(@output).to match(/TESTED:\s+2/)
               expect(@output).to match(/PASSED:\s+2/)