ceedling 1.1.9 → 1.2.0

data/spec/units/tool_validator_spec.rb

@@ -9,52 +9,331 @@ require 'spec_helper'
 require 'ceedling/constants'
 require 'ceedling/tool_validator'
 require 'ceedling/ruby_expandinator'
+require 'ceedling/filename_extension'
 require 'ceedling/exceptions'
 
-# Scoped narrowly to the inline Ruby string expansion (--ruby-replacement) fail-fast
-# gating behavior introduced by RubyExpandinator. Broader ToolValidator coverage is a
-# pre-existing gap outside this feature's scope.
+# Unit coverage for ToolValidator through doubled file and system layers.
+#
+# Nothing here touches the filesystem or the environment. Whether a candidate path exists
+# and which search paths and platform apply are stubbed per example. What a real
+# filesystem and PATH make of the same rules is proven in
+# spec/integration/tool_validator_spec.rb.
 describe ToolValidator do
   before(:each) do
-    @file_wrapper = double('file_wrapper').as_null_object
-    @loginator = double('loginator').as_null_object
-    @system_wrapper = double('system_wrapper').as_null_object
-    @reportinator = double('reportinator').as_null_object
+    @file_wrapper   = double('file_wrapper')
+    @loginator      = double('loginator')
+    @system_wrapper = double('system_wrapper')
     @ruby_expandinator = RubyExpandinator.new
 
+    allow(@file_wrapper).to receive(:exist?).and_return(false)
+    allow(@loginator).to receive(:log)
+    allow(@system_wrapper).to receive(:search_paths).and_return(['/usr/bin'])
+    allow(@system_wrapper).to receive(:windows?).and_return(false)
+
     @tool_validator = described_class.new(
       {
-        :file_wrapper => @file_wrapper,
-        :loginator => @loginator,
-        :system_wrapper => @system_wrapper,
-        :reportinator => @reportinator,
+        :file_wrapper      => @file_wrapper,
+        :loginator         => @loginator,
+        :system_wrapper    => @system_wrapper,
         :ruby_expandinator => @ruby_expandinator
       }
     )
   end
 
-  describe '#validate — Ruby replacement pattern in :executable' do
-    let(:tool) { { :name => 'my_tool', :executable => '#{1+1}' } }
+  let(:no_extension) { FilenameExtension.new('') }
+
+  # A tool with a valid redirect, so an example isolates the executable check
+  def tool(executable, **extras)
+    { :name => 'my_tool', :executable => executable, :stderr_redirect => :none }.merge(extras)
+  end
+
+  def validate(tool, extension: no_extension, **options)
+    @tool_validator.validate( tool: tool, extension: extension, **options )
+  end
+
+  def exists(*paths)
+    paths.each { |path| allow(@file_wrapper).to receive(:exist?).with(path).and_return(true) }
+  end
+
+  describe 'naming in messages' do
+    it 'names the tool by the given name' do
+      expect(@loginator).to receive(:log).with(/tools ↳ my_tool/, Verbosity::ERRORS)
+      validate( tool('gcc'), name: 'tools ↳ my_tool' )
+    end
+
+    it "falls back to the tool's own name when none is given" do
+      expect(@loginator).to receive(:log).with(/my_tool ↳ :executable/, Verbosity::ERRORS)
+      validate( tool('gcc'), name: nil )
+    end
+
+    it "falls back to the tool's own name when the given name is empty" do
+      expect(@loginator).to receive(:log).with(/my_tool ↳ :executable/, Verbosity::ERRORS)
+      validate( tool('gcc'), name: '' )
+    end
+  end
+
+  describe 'a missing :executable' do
+    it 'logs the omission and returns false' do
+      expect(@loginator).to receive(:log).with(/my_tool is missing :executable/, Verbosity::ERRORS)
+      expect( validate( tool(nil) ) ).to be(false)
+    end
+
+    it 'raises under boom' do
+      expect { validate( tool(nil), boom: true ) }.to raise_error(CeedlingException, /missing :executable/)
+    end
+  end
 
-    it 'raises CeedlingException (fail-fast, not deferred) when the feature is disabled and boom is true' do
-      expect {
-        @tool_validator.validate( tool: tool, extension: '.exe', boom: true )
-      }.to raise_error(CeedlingException, /my_tool/)
+  describe 'an optional tool' do
+    it 'is accepted without any lookup when optional is respected' do
+      expect(@file_wrapper).to_not receive(:exist?)
+      expect( validate( tool('gcc', :optional => true), respect_optional: true ) ).to be(true)
+    end
+
+    it 'is looked up when optional is not respected' do
+      expect( validate( tool('gcc', :optional => true) ) ).to be(false)
+    end
+  end
+
+  # The shell resolves an executable built from an argument at run time
+  it 'accepts an argument replacement pattern without any lookup' do
+    expect(@file_wrapper).to_not receive(:exist?)
+    expect( validate( tool('${1}') ) ).to be(true)
+  end
+
+  describe 'a Ruby replacement pattern in :executable' do
+    let(:ruby_tool) { tool('#{1+1}') }
+
+    it 'raises (fail-fast, not deferred) when the feature is disabled and boom is true' do
+      expect { validate( ruby_tool, boom: true ) }.to raise_error(CeedlingException, /my_tool/)
     end
 
     it 'logs and returns false when the feature is disabled and boom is false' do
       expect(@loginator).to receive(:log).with(/my_tool/, anything)
-
-      expect(@tool_validator.validate( tool: tool, extension: '.exe', boom: false )).to eq(false)
+      expect( validate( ruby_tool ) ).to be(false)
     end
 
-    it 'passes validation (deferring to shell at run time) when the feature is enabled' do
+    it 'passes validation, deferring to the shell at run time, when the feature is enabled' do
       @ruby_expandinator.enable!
+      expect( validate( ruby_tool, boom: true ) ).to be(true)
+    end
+  end
+
+  describe 'parsing the executable from its command' do
+    it 'checks an unquoted executable by its first token' do
+      exists( '/usr/bin/gcc' )
+      expect( validate( tool('gcc -Wall -c') ) ).to be(true)
+    end
+
+    it 'checks a quoted executable by its quoted text' do
+      exists( '/opt/code cruncher/cc' )
+      expect( validate( tool('"/opt/code cruncher/cc" --fast') ) ).to be(true)
+    end
+  end
+
+  describe 'a bare executable name' do
+    before(:each) { allow(@system_wrapper).to receive(:search_paths).and_return(['/first', '/second']) }
+
+    it 'is found as named in any search path' do
+      exists( '/second/gcc' )
+      expect( validate( tool('gcc') ) ).to be(true)
+    end
+
+    it 'is found under any configured extension' do
+      exists( '/first/tool.sh' )
+      expect( validate( tool('tool'), extension: FilenameExtension.new(['.bat', '.sh']) ) ).to be(true)
+    end
+
+    it 'is found as .exe on Windows' do
+      allow(@system_wrapper).to receive(:windows?).and_return(true)
+      exists( '/first/gcc.exe' )
+      expect( validate( tool('gcc') ) ).to be(true)
+    end
+
+    it 'is not found as .exe elsewhere' do
+      exists( '/first/gcc.exe' )
+      expect( validate( tool('gcc') ) ).to be(false)
+    end
+
+    # A drive-relative name carries no separator, so it is searched for like any bare name
+    it 'treats a drive-relative name as bare' do
+      exists( '/first/C:gcc.exe' )
+      expect( validate( tool('C:gcc.exe') ) ).to be(true)
+    end
+
+    it 'logs that it does not exist in the search paths and returns false' do
+      expect(@loginator).to receive(:log).with(/`gcc` does not exist in system search paths/, Verbosity::ERRORS)
+      expect( validate( tool('gcc') ) ).to be(false)
+    end
+
+    it 'raises under boom when not found' do
+      expect { validate( tool('gcc'), boom: true ) }.to raise_error(CeedlingException, /does not exist in system search paths/)
+    end
+  end
+
+  describe 'an explicit executable path' do
+    it 'passes when the file exists' do
+      exists( 'tools/bin/gcc' )
+      expect( validate( tool('tools/bin/gcc') ) ).to be(true)
+    end
+
+    it 'is never searched for in the search paths' do
+      expect(@system_wrapper).to_not receive(:search_paths)
+      validate( tool('tools/bin/gcc') )
+    end
+
+    it 'logs that it does not exist on disk and returns false' do
+      expect(@loginator).to receive(:log).with(/`tools\/bin\/gcc` does not exist on disk/, Verbosity::ERRORS)
+      expect( validate( tool('tools/bin/gcc') ) ).to be(false)
+    end
+
+    it 'raises under boom when missing' do
+      expect { validate( tool('tools/bin/gcc'), boom: true ) }.to raise_error(CeedlingException, /does not exist on disk/)
+    end
+  end
+
+  describe ':stderr_redirect' do
+    before(:each) { exists( '/usr/bin/gcc' ) }
+
+    StdErrRedirect.constants.each do |constant|
+      it "accepts :#{constant.to_s.downcase}" do
+        expect( validate( tool('gcc', :stderr_redirect => constant.to_s.downcase.to_sym) ) ).to be(true)
+      end
+    end
+
+    it 'matches a recognized option regardless of case' do
+      expect( validate( tool('gcc', :stderr_redirect => :AUTO) ) ).to be(true)
+    end
+
+    it 'accepts a custom redirect string' do
+      expect( validate( tool('gcc', :stderr_redirect => '2>error.log') ) ).to be(true)
+    end
+
+    it 'logs the recognized options for an unrecognized one and returns false' do
+      expect(@loginator).to receive(:log).with(/:bogus is not a recognized option \{.*:auto.*\}/, Verbosity::ERRORS)
+      expect( validate( tool('gcc', :stderr_redirect => :bogus) ) ).to be(false)
+    end
+
+    it 'raises for an unrecognized option under boom' do
+      expect { validate( tool('gcc', :stderr_redirect => :bogus), boom: true ) }.to raise_error(CeedlingException, /:bogus/)
+    end
+
+    # A value of the wrong type is a malformed configuration rather than a bad choice
+    # among options, so it stops the build either way
+    it 'raises for a value that is neither a Symbol nor a String, even without boom' do
+      expect { validate( tool('gcc', :stderr_redirect => 2) ) }.to raise_error(CeedlingException, /neither a recognized value/)
+    end
+  end
+
+  # Ceedling's own tools always get a redirect filled in, but a direct caller's may not
+  it 'accepts a tool with no :stderr_redirect set' do
+    exists( '/usr/bin/gcc' )
+    expect( validate( { :name => 'my_tool', :executable => 'gcc' } ) ).to be(true)
+  end
+
+  describe 'a blank :executable' do
+    it 'is reported as missing and returns false' do
+      expect(@loginator).to receive(:log).with(/my_tool is missing :executable/, Verbosity::ERRORS)
+      expect( validate( tool('') ) ).to be(false)
+    end
+
+    it 'is reported as missing under boom when only whitespace' do
+      expect { validate( tool('   '), boom: true ) }.to raise_error(CeedlingException, /missing :executable/)
+    end
+  end
+
+  describe 'a Windows-style explicit path' do
+    # Command Hooks entries reach the validator without the backslash cleanup project
+    # tools get at load time
+    it 'is checked on disk when written with backslashes' do
+      expect(@system_wrapper).to_not receive(:search_paths)
+      exists( 'C:\\tools\\gcc.exe' )
+      expect( validate( tool('C:\\tools\\gcc.exe') ) ).to be(true)
+    end
+
+    it 'is found as .exe on Windows when written without its extension' do
+      allow(@system_wrapper).to receive(:windows?).and_return(true)
+      exists( 'C:/tools/gcc.exe' )
+      expect( validate( tool('C:/tools/gcc') ) ).to be(true)
+    end
+  end
+
+  it 'finds an explicit path under a configured extension' do
+    exists( 'tools/tool.sh' )
+    expect( validate( tool('tools/tool'), extension: FilenameExtension.new(['.sh']) ) ).to be(true)
+  end
+
+  # EXTENSION_EXECUTABLE exists only once a project configuration is loaded
+  it "uses the platform's executable extension when none is given and none is configured" do
+    skip 'EXTENSION_EXECUTABLE is already defined in this process' if defined?(EXTENSION_EXECUTABLE)
+    exists( '/usr/bin/gcc' )
+    expect( @tool_validator.validate( tool: tool('gcc') ) ).to be(true)
+  end
+
+  describe '.executable_from' do
+    it 'is nil for a missing, empty, or whitespace-only command' do
+      expect( ToolValidator.executable_from( nil ) ).to be_nil
+      expect( ToolValidator.executable_from( '' ) ).to be_nil
+      expect( ToolValidator.executable_from( "  \t" ) ).to be_nil
+    end
+
+    it 'is the first token of an unquoted command' do
+      expect( ToolValidator.executable_from( '  gcc -Wall -c ' ) ).to eq('gcc')
+    end
+
+    it 'is the quoted text of a quoted command' do
+      expect( ToolValidator.executable_from( '"/opt/code cruncher/cc" --fast' ) ).to eq('/opt/code cruncher/cc')
+    end
+
+    it 'is the first token when a quote is never closed' do
+      expect( ToolValidator.executable_from( '"/opt/cc --fast' ) ).to eq('"/opt/cc')
+    end
+  end
+
+  describe '.candidates' do
+    def candidates(executable, extension: FilenameExtension.new(['.sh']), windows: false, search_paths: ['/a', '/b'])
+      ToolValidator.candidates( executable, extension: extension, windows: windows, search_paths: search_paths )
+    end
+
+    it 'joins a bare name with each search path, each followed by its extension variants' do
+      expect( candidates('gcc') ).to eq(['/a/gcc', '/a/gcc.sh', '/b/gcc', '/b/gcc.sh'])
+    end
+
+    it 'yields only an explicit path and its variants' do
+      expect( candidates('tools/gcc') ).to eq(['tools/gcc', 'tools/gcc.sh'])
+    end
+
+    it 'treats a backslash as marking an explicit path' do
+      expect( candidates('C:\\tools\\gcc', extension: FilenameExtension.new('')) ).to eq(['C:\\tools\\gcc'])
+    end
+
+    it 'adds .exe variants only on Windows' do
+      expect( candidates('gcc', extension: FilenameExtension.new(''), windows: true, search_paths: ['/a']) ).to eq(['/a/gcc', '/a/gcc.exe'])
+      expect( candidates('gcc', extension: FilenameExtension.new(''), windows: false, search_paths: ['/a']) ).to eq(['/a/gcc'])
+    end
+
+    # How an extension variant treats the drive colon is platform-specific, so only the
+    # joining is asserted
+    it 'treats a drive-relative name as bare' do
+      result = candidates('C:gcc.exe', extension: FilenameExtension.new(''), search_paths: ['/a'])
+
+      expect( result.first ).to eq('/a/C:gcc.exe')
+      expect( result ).to all( start_with('/a/') )
+    end
+  end
+
+  describe 'combining both checks' do
+    it 'returns false when only the executable check fails' do
+      expect( validate( tool('missing') ) ).to be(false)
+    end
+
+    it 'returns false when only the redirect check fails' do
+      exists( '/usr/bin/gcc' )
+      expect( validate( tool('gcc', :stderr_redirect => :bogus) ) ).to be(false)
+    end
 
-      # Assert no exception (the fail-fast gate this spec targets doesn't trigger) --
-      # not asserting the aggregate `valid` boolean, since validate() also folds in
-      # validate_stderr_redirect()'s result, which is outside this spec's scope.
-      expect { @tool_validator.validate( tool: tool, extension: '.exe', boom: true ) }.not_to raise_error
+    it 'returns true when both pass' do
+      exists( '/usr/bin/gcc' )
+      expect( validate( tool('gcc') ) ).to be(true)
     end
   end
 end

data/spec/units/version_spec.rb

@@ -0,0 +1,74 @@
+# =========================================================================
+#   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 'version'
+
+# version.rb composes the reported version from a hand-maintained BASE and a DEV
+# marker that the release pipeline empties. These examples pin the composition
+# rules rather than any particular version number, so they hold both in a
+# development checkout and during a release build.
+describe Ceedling::Version do
+
+  describe 'composition' do
+    it 'builds the reported version from BASE' do
+      expect(described_class::GEM).to start_with( described_class::BASE )
+    end
+
+    it 'ends with the development marker' do
+      expect(described_class::GEM).to end_with( described_class::DEV )
+    end
+
+    it 'reports the same value as a tag and as a gem version' do
+      expect(described_class::TAG).to eq( described_class::GEM )
+    end
+  end
+
+  # The marker is appended conditionally, so the one thing worth guarding is that
+  # the condition cannot fire twice and produce `1.2.0.dev.dev`.
+  describe 'the development marker' do
+    it 'appears exactly once, however BASE is written' do
+      skip 'release build -- marker deliberately cleared' if described_class::DEV.empty?
+
+      expect(described_class::GEM.scan( described_class::DEV ).length).to eq(1)
+    end
+
+    it 'is not appended twice when BASE already carries it' do
+      base = "9.9.9#{described_class::DEV}"
+
+      composed = base.end_with?( described_class::DEV ) ? base : "#{base}#{described_class::DEV}"
+
+      expect(composed).to eq( base )
+    end
+
+    it 'composes to a bare version once cleared, as a release build leaves it' do
+      base = '9.9.9'
+      dev  = ''
+
+      composed = base.end_with?( dev ) ? base : "#{base}#{dev}"
+
+      expect(composed).to eq( '9.9.9' )
+    end
+  end
+
+  # A `.dev` version is a RubyGems prerelease. That is what keeps a locally built
+  # gem from ever satisfying a plain `gem install ceedling`.
+  describe 'RubyGems interpretation' do
+    it 'marks a development build as a prerelease' do
+      skip 'release build -- marker deliberately cleared' if described_class::DEV.empty?
+
+      expect(Gem::Version.new( described_class::GEM )).to be_prerelease
+    end
+
+    it 'sorts a development build below the release it precedes' do
+      skip 'release build -- marker deliberately cleared' if described_class::DEV.empty?
+
+      expect(Gem::Version.new( described_class::GEM )).to be < Gem::Version.new( described_class::BASE )
+    end
+  end
+
+end

data/spec/units/yaml_wrapper_spec.rb

@@ -10,7 +10,8 @@ require 'ceedling/yaml_wrapper'
 
 describe YamlWrapper do
   before(:each) do
-    @yaml_wrapper = described_class.new
+    @file_wrapper = double('file_wrapper').as_null_object
+    @yaml_wrapper = described_class.new({ file_wrapper: @file_wrapper })
   end
 
   describe '#load_string' do
@@ -75,6 +76,8 @@ describe YamlWrapper do
 
   describe '#load' do
     it 'reports a missing file as :not_found' do
+      allow(@file_wrapper).to receive(:read).with('/no/such/file.yml').and_raise(Errno::ENOENT)
+
       expect { @yaml_wrapper.load('/no/such/file.yml') }.to raise_error(YamlLoadException) do |e|
         expect(e.reason).to eq(:not_found)
         expect(e.message).to match(/could not find yaml file/i)

data/vendor/cmock/docs/CMock_Summary.md

@@ -547,6 +547,17 @@ from the defaults. We've tried to specify what the defaults are below.
 
   * default: true
 
+* `:mock_name_include_folder`:
+  Name a mock by the folder it is generated into as well as its filename. The
+  folder is the path below `:mock_path`, built from `:subdir` and any folder
+  given to `setup_mocks`. A mock of "config.h" generated into `uart/` gets an
+  include guard and Init, Verify and Destroy functions named `uart_Mockconfig`
+  rather than `Mockconfig`. This lets two mocks of the same filename coexist in
+  one test. A test should include such a mock by that same folder, and Unity's
+  test runner generator needs its option of the same name enabled to match.
+
+  * default: false
+
 * `:mock_path`:
   The directory where you would like the mock files generated to be
   placed.

data/vendor/cmock/lib/cmock_config.rb

@@ -15,6 +15,7 @@ class CMockConfig
       :skeleton_path               => '',
       :weak                        => '',
       :subdir                      => nil,
+      :mock_name_include_folder    => false,
       :plugins                     => [],
       :strippables                 => ['(?:__attribute__\s*\([ (]*.*?[ )]*\)+)'],
       :attributes                  => %w[__ramfunc __irq __fiq register extern],

data/vendor/cmock/lib/cmock_generator.rb

@@ -22,6 +22,7 @@ class CMockGenerator
     @fail_on_unexpected_calls = @config.fail_on_unexpected_calls
     @exclude_setjmp_h = @config.exclude_setjmp_h
     @subdir = @config.subdir
+    @name_include_folder = @config.mock_name_include_folder
     @debug_output = @config.debug_output
 
     @includes_h_pre_orig_header  = ((@config.includes || []) + (@config.includes_h_pre_orig_header || [])).uniq.map { |h| h =~ /</ ? h : "\"#{h}\"" }
@@ -62,12 +63,15 @@ class CMockGenerator
     # adds a trailing slash to the folder output
     mock_folder = File.join(mock_folder, '') if mock_folder
 
+    # optionally fold the folder into the mock name to keep same-named headers distinct
+    identity = @name_include_folder && mock_folder ? mock_folder.sub(/\A(?:\.[\/\\])+/, '') + mock_name : mock_name
+
     # create out mock project from incoming data
     mock_project = {
       :module_name  => module_name,
       :module_ext   => (module_ext || '.h'),
       :mock_name    => mock_name,
-      :clean_name   => TypeSanitizer.sanitize_c_identifier(mock_name),
+      :clean_name   => TypeSanitizer.sanitize_c_identifier(identity),
       :folder       => mock_folder,
       :parsed_stuff => parsed_stuff,
       :skeleton     => false

data/vendor/cmock/test/unit/cmock_generator_main_test.rb

@@ -47,6 +47,7 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
     @config.expect :includes_c_pre_header, nil
     @config.expect :includes_c_post_header, nil
     @config.expect :subdir, nil
+    @config.expect :mock_name_include_folder, false
     @config.expect :fail_on_unexpected_calls, true
     @config.expect :treat_inlines, :exclude
     @config.expect :exclude_setjmp_h, false
@@ -69,6 +70,7 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
     @config.expect :includes_c_pre_header, nil
     @config.expect :includes_c_post_header, nil
     @config.expect :subdir, nil
+    @config.expect :mock_name_include_folder, false
     @config.expect :fail_on_unexpected_calls, true
     @config.expect :treat_inlines, :exclude
     @config.expect :exclude_setjmp_h, false
@@ -426,6 +428,35 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
     assert_equal(expected, output.flatten)
   end
 
+  def capture_mock_project(generator, folder)
+    captured = nil
+    generator.define_singleton_method(:create_mock_subdir) { |project| captured = project }
+    generator.define_singleton_method(:create_mock_header_file) { |_project| }
+    generator.define_singleton_method(:create_mock_source_file) { |_project| }
+    generator.create_mock("config", {}, ".h", folder)
+    captured
+  end
+
+  it "name a mock by its filename alone by default" do
+    project = capture_mock_project(@cmock_generator, "drivers/uart")
+
+    assert_equal("Mockconfig", project[:clean_name])
+    assert_equal("drivers/uart/", project[:folder])
+  end
+
+  it "name a mock by its folder when configured to" do
+    @cmock_generator.instance_variable_set(:@name_include_folder, true)
+
+    assert_equal("drivers_uart_Mockconfig", capture_mock_project(@cmock_generator, "drivers/uart")[:clean_name])
+    assert_equal("drivers_uart_Mockconfig", capture_mock_project(@cmock_generator, "./drivers/uart")[:clean_name])
+  end
+
+  it "name a mock by its filename when configured to use a folder but given none" do
+    @cmock_generator.instance_variable_set(:@name_include_folder, true)
+
+    assert_equal("Mockconfig", capture_mock_project(@cmock_generator, nil)[:clean_name])
+  end
+
   it "create mock verify functions in source file when no functions specified" do
     functions = []
     output = []

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

@@ -182,9 +182,9 @@ class UnityModuleGenerator
   ############################
   def create_filename(part1, part2 = '')
     name = part2.empty? ? part1 : "#{part1}_#{part2}"
-    case @options[:naming]
-    when 'bumpy' then neutralize_filename(name, start_cap: false).delete('_')
-    when 'camel' then neutralize_filename(name).delete('_')
+    case @options[:naming]&.to_s
+    when 'bumpy' then neutralize_filename(name).delete('_')
+    when 'camel' then neutralize_filename(name, start_cap: false).delete('_')
     when 'snake' then neutralize_filename(name).downcase
     when 'caps'  then neutralize_filename(name).upcase
     else              name
@@ -221,7 +221,7 @@ class UnityModuleGenerator
       end
       if @options[:update_svn]
         `svn add \"#{file[:path]}\"`
-        if $!.exitstatus.zero?
+        if $?.exitstatus.zero?
           puts "File #{file[:path]} created and added to source control"
         else
           puts "File #{file[:path]} created but FAILED adding to source control!"

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

@@ -36,6 +36,7 @@ class UnityTestRunnerGenerator
       test_prefix: 'test|spec|should',
       mock_prefix: 'Mock',
       mock_suffix: '',
+      mock_name_include_folder: false,
       setup_name: 'setUp',
       teardown_name: 'tearDown',
       test_reset_name: 'resetTest',
@@ -200,8 +201,10 @@ class UnityTestRunnerGenerator
     source_lines = source.split("\n")
     source_index = 0
     tests_and_line_numbers.size.times do |i|
+      # Compile once per test
+      name_regex = /(?:^|\s)#{tests_and_line_numbers[i][:test]}(?:\s|\()/
       source_lines[source_index..].each_with_index do |line, index|
-        next unless line =~ /\s+#{tests_and_line_numbers[i][:test]}(?:\s|\()/
+        next unless line =~ name_regex
 
         source_index += index
         tests_and_line_numbers[i][:line_number] = source_index + 1
@@ -337,7 +340,10 @@ class UnityTestRunnerGenerator
       output.puts('  GlobalOrderError = NULL;')
     end
 
-    mocks = mock_headers.map { |mock| File.basename(mock, '.*') }
+    # optionally keep the folder a mock is included from to match cmock's naming
+    mocks = mock_headers.map do |mock|
+      @options[:mock_name_include_folder] ? mock.sub(/\A(?:\.[\/\\])+/, '').sub(/\.[^.\/\\]*\z/, '') : File.basename(mock, '.*')
+    end
     mocks.each do |mock|
       mock_clean = TypeSanitizer.sanitize_c_identifier(mock)
       output.puts("  #{mock_clean}_Init();")

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

@@ -124,7 +124,7 @@ if $0 == __FILE__
   begin
     # look in the specified or current directory for result files
     args[0] ||= './'
-    targets = "#{ARGV[0].tr('\\', '/')}**/*.test*"
+    targets = "#{args[0].tr('\\', '/')}**/*.test*"
     results = Dir[targets]
 
     raise "No *.testpass, *.testfail, or *.testresults files found in '#{targets}'" if results.empty?
@@ -133,7 +133,7 @@ if $0 == __FILE__
 
     # set the root path
     args[1] ||= "#{Dir.pwd}/"
-    uts.root = ARGV[1]
+    uts.root = args[1]
 
     # run the summarizer
     puts uts.run

data/vendor/cmock/vendor/unity/docs/UnityChangeLog.md

@@ -13,6 +13,13 @@ Prior to 2008, the project was an internal project and not released to the publi
 
 ## Log
 
+### Unity 2.7.2
+
+Significant Bugfixes:
+
+  - Default `UNITY_INCLUDE_EXEC_TIME` macros compile as ISO C99, are statement-safe, and accept `-Wsign-conversion` (#838)
+  - `unity_test_summary.rb` honors its own default result directory and root path again. @youdie006
+
 ### Unity 2.7.0 (July 2026)
 
 New Features:

data/vendor/cmock/vendor/unity/docs/UnityConfigurationGuide.md

@@ -488,6 +488,10 @@ Define this to measure and report execution time for each test in the suite. Whe
 it's best to automatically find a way to determine the time in milliseconds. On most Windows, macos, or 
 Linux environments, this is automatic. If not, you can give Unity more information.
 
+On Unix and macOS, the default uses POSIX `clock_gettime(CLOCK_MONOTONIC)` when that clock is available.
+If it is not (strict ISO C with no POSIX clocks in `<time.h>`), it falls back to the standard `clock()` function,
+which is also the Windows default.
+
 #### `UNITY_CLOCK_MS`
 
 If you're working on a system (embedded or otherwise) which has an accessible millisecond timer. You can