ceedling 1.1.10 → 1.2.0

data/spec/units/plugins/module_generator_options_spec.rb

@@ -0,0 +1,185 @@
+# =========================================================================
+#   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'
+
+$LOAD_PATH.unshift( File.expand_path( '../../../plugins/module_generator/lib', __dir__ ) )
+
+require 'module_generator_request'
+require 'module_generator_options'
+
+describe ModuleGeneratorOptions do
+
+  let(:config) do
+    {
+      collection_paths_source:  ['src', 'src/lab'],
+      collection_paths_include: ['inc', 'inc/lab'],
+      collection_paths_test:    ['test', 'test/lab'],
+      project_test_file_prefix: 'test_',
+      cmock_mock_prefix:        'mock_',
+      module_generator_boilerplates: { src: '/* src */', inc: '', tst: '' }
+    }
+  end
+
+  let(:cmock_config) { { mock_prefix: 'mock_', treat_as: { 'BYTE' => 'HEX8' }, includes: ['extra.h'] } }
+
+  # Matches a hint to the path whose last segment it names, the way the real matcher
+  # ranks an exact trailing match first
+  let(:path_finder) { ->( hint, paths ) { paths.find { |path| path.end_with?( "/#{hint}" ) } } }
+
+  let(:files) { {} }
+
+  def options(**overrides)
+    return described_class.new(
+      config:             config.merge( overrides ),
+      cmock_config:       cmock_config,
+      path_finder:        path_finder,
+      boilerplate_reader: ->( path ) { files[path] }
+    )
+  end
+
+  def request(name, path_hint: nil, pattern: nil)
+    return ModuleGeneratorRequest.new( name: name, path_hint: path_hint, pattern: pattern )
+  end
+
+  describe '#unity' do
+    it 'carries the project prefixes, the pattern, and the module generator defaults' do
+      expect(options.unity( request( 'Lair', pattern: 'mch' ) )).to include(
+        pattern: 'mch', test_prefix: 'test_', mock_prefix: 'mock_', test_define: 'TEST', update_svn: false, naming: nil,
+        includes: { src: [], inc: [], tst: [] }
+      )
+    end
+
+    it 'guards tests with #ifdef unless :test_guard asks for #if' do
+      expect(options.unity( request( 'x' ) )[:test_guard]).to eq( 'ifdef' )
+      expect(options( module_generator_test_guard: :if ).unity( request( 'x' ) )[:test_guard]).to eq( 'if' )
+    end
+
+    it 'refuses an unknown :test_guard' do
+      expect { options( module_generator_test_guard: :ifndef ) }.to raise_error( CeedlingException, /:test_guard.*ifndef/ )
+    end
+
+    it 'never asks Unity to run Subversion, even when :update_svn is configured' do
+      expect(options( module_generator_update_svn: true ).unity( request( 'x' ) )[:update_svn]).to be( false )
+    end
+
+    it 'uses the first path of each list without a hint' do
+      expect(options.unity( request( 'Lair' ) )).to include( path_src: 'src', path_inc: 'inc', path_tst: 'test' )
+    end
+
+    it 'uses configured paths without a hint' do
+      unity = options( module_generator_path_src: 'source/', module_generator_path_tst: 'tests/' ).unity( request( 'Lair' ) )
+
+      expect(unity).to include( path_src: 'source/', path_inc: 'inc', path_tst: 'tests/' )
+    end
+
+    it 'uses the paths a hint matches' do
+      expect(options.unity( request( 'Lair', path_hint: 'lab' ) )).to include( path_src: 'src/lab', path_inc: 'inc/lab', path_tst: 'test/lab' )
+    end
+
+    it 'falls back to the first path of a list the hint matches nothing in' do
+      unity = options( collection_paths_test: ['test'] ).unity( request( 'Lair', path_hint: 'lab' ) )
+
+      expect(unity).to include( path_src: 'src/lab', path_tst: 'test' )
+    end
+
+    it 'refuses a hint that matches nothing in any list' do
+      expect { options.unity( request( 'Lair', path_hint: 'bad' ) ) }.to raise_error( CeedlingException, /`bad`/ )
+    end
+
+    it 'places headers with the source when no include paths are listed' do
+      unity = options( collection_paths_include: [] ).unity( request( 'Lair', path_hint: 'lab' ) )
+
+      expect(unity).to include( path_src: 'src/lab', path_inc: 'src/lab' )
+    end
+
+    it 'passes :naming through to Unity unchanged' do
+      expect(options( module_generator_naming: :bumpy ).unity( request( 'x' ) )[:naming]).to eq( 'bumpy' )
+      expect(options( module_generator_naming: :camel ).unity( request( 'x' ) )[:naming]).to eq( 'camel' )
+      expect(options( module_generator_naming: :snake ).unity( request( 'x' ) )[:naming]).to eq( 'snake' )
+      expect(options( module_generator_naming: 'caps' ).unity( request( 'x' ) )[:naming]).to eq( 'caps' )
+    end
+
+    it 'refuses an unknown :naming' do
+      expect { options( module_generator_naming: :kebab ) }.to raise_error( CeedlingException, /:naming.*kebab/ )
+    end
+
+    it 'fills in includes for each kind of file' do
+      unity = options( module_generator_includes: { tst: ['defs.h'] } ).unity( request( 'x' ) )
+
+      expect(unity[:includes]).to eq( src: [], inc: [], tst: ['defs.h'] )
+    end
+
+    it 'reads boilerplate files over configured boilerplates without changing the configuration' do
+      files['bp/src.txt'] = '/* from a file */'
+      unity = options( module_generator_boilerplate_files: { src: 'bp/src.txt' } ).unity( request( 'x' ) )
+
+      expect(unity[:boilerplates]).to eq( src: '/* from a file */', inc: '', tst: '' )
+      expect(config[:module_generator_boilerplates][:src]).to eq( '/* src */' )
+    end
+
+    it 'refuses a boilerplate file that does not exist' do
+      expect { options( module_generator_boilerplate_files: { tst: 'missing.txt' } ) }
+        .to raise_error( CeedlingException, /missing\.txt/ )
+    end
+  end
+
+  it 'reports its test define' do
+    expect(options( module_generator_test_define: 'UNIT_TEST' ).test_define).to eq( 'UNIT_TEST' )
+    expect(options.test_define).to eq( 'TEST' )
+  end
+
+  describe '#test' do
+    it 'reads the header from the include path and writes the test to the test path' do
+      test = options.test( request( 'widget', path_hint: 'lab' ) )
+
+      expect(test).to include( header: 'inc/lab/widget.h', path: 'test/lab/test_widget.c' )
+    end
+
+    it 'keeps a subdirectory a slash names for both the header and the test' do
+      test = options.test( request( 'rev/widget' ) )
+
+      expect(test).to include( header: 'inc/rev/widget.h', path: 'test/rev/test_widget.c' )
+      expect(test[:file]).to include( module_name: 'widget', header: 'widget.h' )
+    end
+
+    it 'describes the test file with the configured includes, boilerplate, and guard' do
+      test = options(
+        module_generator_includes: { tst: ['defs.h'] }, module_generator_boilerplates: { tst: '/* t */' },
+        module_generator_test_define: 'UNIT_TEST', module_generator_test_guard: :if
+      ).test( request( 'widget' ) )
+
+      expect(test[:file]).to include( includes: ['defs.h'], boilerplate: '/* t */', test_define: 'UNIT_TEST', test_guard: 'if' )
+    end
+
+    it 'parses the header with the project CMock configuration' do
+      expect(options.test( request( 'widget' ) )[:cmock]).to include( treat_as: { 'BYTE' => 'HEX8' } )
+    end
+  end
+
+  describe '#stub' do
+    it 'reads the header from the include path and writes the skeleton to the source path' do
+      stub = options.stub( request( 'stubby', path_hint: 'lab' ) )
+
+      expect(stub[:header]).to eq( 'inc/lab/stubby.h' )
+      expect(stub[:cmock]).to include( skeleton_path: 'src/lab', subdir: nil )
+    end
+
+    it 'keeps a subdirectory a slash names for both the header and the skeleton' do
+      stub = options.stub( request( 'rev/stubby' ) )
+
+      expect(stub[:header]).to eq( 'inc/rev/stubby.h' )
+      expect(stub[:cmock]).to include( skeleton_path: 'src', subdir: 'rev' )
+    end
+
+    it 'builds on the project CMock configuration' do
+      expect(options.stub( request( 'stubby' ) )[:cmock]).to include( treat_as: { 'BYTE' => 'HEX8' }, mock_prefix: 'mock_' )
+    end
+  end
+
+end

data/spec/units/plugins/module_generator_project_spec.rb

@@ -0,0 +1,55 @@
+# =========================================================================
+#   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'
+
+$LOAD_PATH.unshift( File.expand_path( '../../../plugins/module_generator/lib', __dir__ ) )
+
+require 'module_generator_project'
+
+describe ModuleGeneratorProject do
+
+  describe '#test_defined?' do
+    # Test defines as a build resolves them for each test file
+    let(:resolved) { { 'test/test_widget.c' => ['UNIT_TEST=1', 'OTHER'], 'test/test_gadget.c' => ['OTHER'] } }
+    let(:project)  { described_class.new( {}, test_defines: ->( path ) { resolved.fetch( path, [] ) } ) }
+
+    it 'finds a symbol among the defines resolved for that test file, with or without a value' do
+      expect(project.test_defined?( 'UNIT_TEST', 'test/test_widget.c' )).to be true
+      expect(project.test_defined?( 'OTHER', 'test/test_gadget.c' )).to be true
+    end
+
+    it 'reports a symbol the defines resolved for that test file lack' do
+      expect(project.test_defined?( 'UNIT_TEST', 'test/test_gadget.c' )).to be false
+      expect(project.test_defined?( 'UNIT_TEST', 'test/test_other.c' )).to be false
+    end
+  end
+
+  describe '#same_named' do
+    let(:project) do
+      described_class.new(
+        { collection_all_source:  ['src/Widget.c', 'lib/net/Socket.c'],
+        collection_all_headers: ['inc/net/Widget.h'],
+        collection_all_tests:   ['test/test_Socket.c'] },
+        test_defines: ->( _path ) { [] }
+      )
+    end
+
+    it 'lists existing project files elsewhere that share a planned file name' do
+      planned = ['src/lab/Widget.c', 'inc/lab/Widget.h', 'test/lab/test_Widget.c']
+
+      expect(project.same_named( planned )).to eq(
+        'src/lab/Widget.c' => ['src/Widget.c'], 'inc/lab/Widget.h' => ['inc/net/Widget.h']
+      )
+    end
+
+    it 'ignores the planned file itself' do
+      expect(project.same_named( ['./src/Widget.c'] )).to eq( {} )
+    end
+  end
+
+end

data/spec/units/plugins/module_generator_request_spec.rb

@@ -0,0 +1,107 @@
+# =========================================================================
+#   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'
+
+$LOAD_PATH.unshift( File.expand_path( '../../../plugins/module_generator/lib', __dir__ ) )
+
+require 'module_generator_request'
+
+describe ModuleGeneratorRequest do
+
+  def parse(*args, patterns: true)
+    return described_class.parse( args, test_prefix: 'test_', patterns: patterns )
+  end
+
+  def request(name, path_hint: nil, pattern: nil)
+    return described_class.new( name: name, path_hint: path_hint, pattern: pattern )
+  end
+
+  it 'reads a bare module name' do
+    expect(parse( 'MadScience' )).to eq( [request( 'MadScience' )] )
+  end
+
+  it 'reads a path hint before a colon' do
+    expect(parse( 'lab:SecretLair' )).to eq( [request( 'SecretLair', path_hint: 'lab' )] )
+  end
+
+  it 'joins several ordered hints into one path' do
+    expect(parse( 'lab:secret:lair' )).to eq( [request( 'lair', path_hint: 'lab/secret' )] )
+  end
+
+  it 'keeps a Windows drive letter in a hint' do
+    expect(parse( 'C:/proj/lab:Foo' )).to eq( [request( 'Foo', path_hint: 'C:/proj/lab' )] )
+    expect(parse( 'C:\\proj:Foo' )).to eq( [request( 'Foo', path_hint: 'C:\\proj' )] )
+  end
+
+  it 'reads an absolute Windows path without a hint as the name' do
+    expect(parse( 'C:/proj/Foo' )).to eq( [request( 'C:/proj/Foo' )] )
+  end
+
+  it 'keeps a slash-separated subdirectory in the name' do
+    expect(parse( 'lab:newlab/SecretLair' )).to eq( [request( 'newlab/SecretLair', path_hint: 'lab' )] )
+  end
+
+  it 'applies a pattern to every module in the call' do
+    expect(parse( 'Lair', 'mch', 'Lab' )).to eq( [request( 'Lair', pattern: 'mch' ), request( 'Lab', pattern: 'mch' )] )
+  end
+
+  it 'reads a pattern in any letter case' do
+    expect(parse( 'Lair', 'MCH' )).to eq( [request( 'Lair', pattern: 'mch' )] )
+  end
+
+  it 'reads the first argument as a module even when it spells a pattern' do
+    expect(parse( 'src' )).to eq( [request( 'src' )] )
+  end
+
+  it 'applies each hint only to its own module' do
+    expect(parse( 'lab:first', 'second' )).to eq( [request( 'first', path_hint: 'lab' ), request( 'second' )] )
+  end
+
+  it 'reads a name carrying the test prefix as a test-only module' do
+    expect(parse( 'lab:test_widget' )).to eq( [request( 'widget', path_hint: 'lab', pattern: 'test' )] )
+  end
+
+  it 'reads a name that only begins with the letters of the test prefix as a module' do
+    expect(parse( 'testimony' )).to eq( [request( 'testimony' )] )
+  end
+
+  it 'requires a word boundary after a test prefix that has no separator of its own' do
+    requests = described_class.parse( ['TestWidget', 'Testimony'], test_prefix: 'Test' )
+
+    expect(requests).to eq( [request( 'Widget', pattern: 'test' ), request( 'Testimony' )] )
+  end
+
+  it 'reads patterns and the test prefix as module names when patterns are off' do
+    expect(parse( 'test_widget', 'mch', patterns: false )).to eq( [request( 'test_widget' ), request( 'mch' )] )
+  end
+
+  it 'returns frozen requests' do
+    expect(parse( 'MadScience' ).first).to be_frozen
+  end
+
+  describe 'refusals' do
+    it 'refuses a call naming no module' do
+      expect { parse( nil ) }.to raise_error( CeedlingException, /names no module/ )
+      expect { parse( '' ) }.to raise_error( CeedlingException, /names no module/ )
+    end
+
+    it 'refuses a hint with no module name after it' do
+      expect { parse( 'lab:' ) }.to raise_error( CeedlingException, /`lab:` names no module/ )
+    end
+
+    it 'refuses a second pattern' do
+      expect { parse( 'Lair', 'mch', 'mvp' ) }.to raise_error( CeedlingException, /one pattern/ )
+    end
+
+    it 'refuses a name made only of the test prefix' do
+      expect { parse( 'test_' ) }.to raise_error( CeedlingException, /`test_` names no module/ )
+    end
+  end
+
+end

data/spec/units/plugins/module_generator_spec.rb

@@ -0,0 +1,214 @@
+# =========================================================================
+#   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'
+require 'ceedling/constants'
+require 'ceedling/plugins/plugin'
+require 'pathname'
+
+[File.expand_path( '../../../plugins/module_generator/lib', __dir__ ),
+ File.expand_path( '../../../vendor/unity/auto', __dir__ ),
+ File.expand_path( '../../../vendor/cmock/lib', __dir__ )].each { |path| $LOAD_PATH.unshift( path ) unless $LOAD_PATH.include?( path ) }
+
+require 'module_generator'
+require 'generate_module'
+require 'cmock'
+require 'module_generator_unity'
+
+# The plugin hands each request to Unity's module generator or CMock's skeleton
+# generator. Both are doubled here, so nothing touches the filesystem.
+describe ModuleGenerator do
+
+  let(:config) do
+    { collection_paths_source: ['src', 'src/lab'], collection_paths_include: ['inc'], collection_paths_test: ['test'],
+      project_test_file_prefix: 'test_', cmock_mock_prefix: 'mock_' }
+  end
+
+  let(:configurator)       { double( 'configurator', project_config_hash: config, get_cmock_config: { mock_prefix: 'mock_' } ) }
+  let(:file_finder_helper) { double( 'file_finder_helper' ) }
+  let(:file_wrapper)       { double( 'file_wrapper' ) }
+  let(:loginator)          { double( 'loginator', log: nil ) }
+  let(:defineinator)       { double( 'defineinator' ) }
+
+  # Test defines as a build resolves them for each test file, TEST unless a spec says otherwise
+  let(:resolved_defines)   { Hash.new( ['TEST'] ) }
+  let(:unity)              { double( 'unity_module_generator', files_to_operate_on: [] ) }
+  let(:cmock)              { double( 'cmock' ) }
+
+  let(:plugin) do
+    described_class.new(
+      { configurator: configurator, file_finder_helper: file_finder_helper, file_wrapper: file_wrapper, loginator: loginator, defineinator: defineinator },
+      'module_generator', '/plugins/module_generator'
+    )
+  end
+
+  # A real generator reaching the disk is a broken stub, so it fails loudly instead
+  before(:each) do
+    allow(defineinator).to receive(:defines) { |subkey:, filepath:| subkey == :test ? resolved_defines[filepath] : [] }
+    %i[generate destroy].each do |method|
+      allow_any_instance_of( UnityModuleGenerator ).to receive( method ).and_raise( 'Unit specs must not write module files' )
+    end
+  end
+
+  def request(name, path_hint: nil, pattern: nil)
+    return ModuleGeneratorRequest.new( name: name, path_hint: path_hint, pattern: pattern )
+  end
+
+  it 'reports the configured test file prefix' do
+    expect(plugin.test_prefix).to eq( 'test_' )
+  end
+
+  it 'creates a module with the options built for its request' do
+    expect(ModuleGeneratorUnity).to receive(:new).with( hash_including( pattern: 'mch', path_src: 'src' ) ).and_return( unity )
+    expect(unity).to receive(:generate).with( 'Lair' )
+
+    plugin.create( request( 'Lair', pattern: 'mch' ) )
+  end
+
+  it 'destroys a module with the options built for its request' do
+    expect(ModuleGeneratorUnity).to receive(:new).with( hash_including( path_src: 'src' ) ).and_return( unity )
+    expect(unity).to receive(:destroy).with( 'Lair' )
+
+    plugin.destroy( request( 'Lair' ) )
+  end
+
+  it 'matches a hint through the path finder' do
+    allow(file_finder_helper).to receive(:find_best_path_in_collection) { |_hint, paths| paths.last }
+    expect(ModuleGeneratorUnity).to receive(:new).with( hash_including( path_src: 'src/lab' ) ).and_return( unity )
+    allow(unity).to receive(:generate)
+
+    plugin.create( request( 'Lair', path_hint: 'lab' ) )
+  end
+
+  it 'reads a list the path finder finds no match in as unmatched' do
+    allow(file_finder_helper).to receive(:find_best_path_in_collection).and_raise( CeedlingException.new( 'Found no path' ) )
+
+    expect { plugin.create( request( 'Lair', path_hint: 'bad' ) ) }.to raise_error( CeedlingException, /`bad` matches no/ )
+  end
+
+  it 'reads boilerplate files through the file wrapper' do
+    config[:module_generator_boilerplate_files] = { src: 'bp.txt' }
+    allow(file_wrapper).to receive(:exist?).with( 'bp.txt' ).and_return( true )
+    allow(file_wrapper).to receive(:read).with( 'bp.txt' ).and_return( '/* bp */' )
+    expect(ModuleGeneratorUnity).to receive(:new).with( hash_including( boilerplates: hash_including( src: '/* bp */' ) ) ).and_return( unity )
+    allow(unity).to receive(:generate)
+
+    plugin.create( request( 'Lair' ) )
+  end
+
+  it 'warns that :update_svn is deprecated when it is configured' do
+    config[:module_generator_update_svn] = true
+    allow(ModuleGeneratorUnity).to receive(:new).and_return( unity )
+    allow(unity).to receive(:generate)
+    expect(loginator).to receive(:log).with( /:update_svn.*deprecated/, Verbosity::COMPLAIN, LogLabels::WARNING )
+
+    plugin.create( request( 'Lair' ) )
+  end
+
+  it 'says nothing about :update_svn when it is not configured' do
+    allow(ModuleGeneratorUnity).to receive(:new).and_return( unity )
+    allow(unity).to receive(:generate)
+    expect(loginator).not_to receive(:log)
+
+    plugin.create( request( 'Lair' ) )
+  end
+
+  def planned_test(path)
+    return { path: Pathname.new( path ), test_define: 'TEST' }
+  end
+
+  it 'warns about each generated test file its test define does not reach' do
+    resolved_defines['test/test_Lair.c'] = ['OTHER']
+    allow(ModuleGeneratorUnity).to receive(:new).and_return( unity )
+    allow(unity).to receive(:files_to_operate_on).with( 'Lair' ).and_return( [{ path: Pathname.new( 'src/Lair.c' ) }, planned_test( 'test/test_Lair.c' )] )
+    allow(unity).to receive(:generate)
+    expect(loginator).to receive(:log).with( /`test\/test_Lair.c`.*`#ifdef TEST`.*:defines/m, Verbosity::COMPLAIN, LogLabels::WARNING ).once
+
+    plugin.create( request( 'Lair' ) )
+  end
+
+  it 'names the #if guard in the warning when :test_guard is #if' do
+    config[:module_generator_test_guard] = :if
+    resolved_defines['test/test_Lair.c'] = []
+    allow(ModuleGeneratorUnity).to receive(:new).and_return( unity )
+    allow(unity).to receive(:files_to_operate_on).and_return( [planned_test( 'test/test_Lair.c' )] )
+    allow(unity).to receive(:generate)
+    expect(loginator).to receive(:log).with( /`#if TEST`/, Verbosity::COMPLAIN, LogLabels::WARNING )
+
+    plugin.create( request( 'Lair' ) )
+  end
+
+  it 'says nothing about the test define when it reaches the generated test file' do
+    allow(ModuleGeneratorUnity).to receive(:new).and_return( unity )
+    allow(unity).to receive(:files_to_operate_on).and_return( [planned_test( 'test/test_Lair.c' )] )
+    allow(unity).to receive(:generate)
+    expect(loginator).not_to receive(:log)
+
+    plugin.create( request( 'Lair' ) )
+  end
+
+  it 'warns about each existing file that shares a name with a file it creates, then creates them' do
+    config.merge!( collection_all_source: ['lib/Lair.c'], collection_all_headers: [], collection_all_tests: [] )
+    allow(ModuleGeneratorUnity).to receive(:new).and_return( unity )
+    allow(unity).to receive(:files_to_operate_on).with( 'Lair' ).and_return( [{ path: Pathname.new( 'src/Lair.c' ) }] )
+    expect(loginator).to receive(:log).with( /`src\/Lair.c`.*`lib\/Lair.c`/, Verbosity::COMPLAIN, LogLabels::WARNING )
+    expect(unity).to receive(:generate).with( 'Lair' )
+
+    plugin.create( request( 'Lair' ) )
+  end
+
+  describe '#test' do
+    let(:parser) { double( 'cmock_header_parser' ) }
+
+    before(:each) do
+        allow(CMockConfig).to receive(:new).and_return( double( 'cmock_config' ) )
+      allow(CMockHeaderParser).to receive(:new).and_return( parser )
+      allow(file_wrapper).to receive(:read).with( 'inc/widget.h' ).and_return( 'void shorty(void);' )
+      allow(parser).to receive(:parse).with( 'widget', 'void shorty(void);' ).and_return( functions: [{ name: 'shorty' }] )
+      allow(file_wrapper).to receive(:mkdir)
+    end
+
+    it 'writes a test file with a test for each function the header declares' do
+      allow(file_wrapper).to receive(:exist?).with( 'test/test_widget.c' ).and_return( false )
+      expect(file_wrapper).to receive(:write).with( 'test/test_widget.c', /void test_shorty_NeedToImplement/ )
+
+      plugin.test( request( 'widget' ) )
+    end
+
+    it 'adds tests to an existing test file only for untested functions' do
+      allow(file_wrapper).to receive(:exist?).with( 'test/test_widget.c' ).and_return( true )
+      allow(file_wrapper).to receive(:read).with( 'test/test_widget.c' ).and_return( "void test_shorty(void) {}\n" )
+      expect(file_wrapper).not_to receive(:write)
+
+      plugin.test( request( 'widget' ) )
+    end
+
+    it 'warns when its test define does not reach the test file it writes' do
+      resolved_defines['test/test_widget.c'] = []
+      allow(file_wrapper).to receive(:exist?).with( 'test/test_widget.c' ).and_return( false )
+      allow(file_wrapper).to receive(:write)
+      expect(loginator).to receive(:log).with( /`test\/test_widget.c`.*`#ifdef TEST`/m, Verbosity::COMPLAIN, LogLabels::WARNING )
+
+      plugin.test( request( 'widget' ) )
+    end
+
+    it 'refuses a header that does not exist' do
+      allow(file_wrapper).to receive(:read).with( 'inc/widget.h' ).and_raise( Errno::ENOENT )
+
+      expect { plugin.test( request( 'widget' ) ) }.to raise_error( CeedlingException, %r{`inc/widget.h`} )
+    end
+  end
+
+  it 'stubs a header through CMock with the skeleton beside the source' do
+    expect(CMock).to receive(:new).with( hash_including( mock_prefix: 'mock_', skeleton_path: 'src' ) ).and_return( cmock )
+    expect(cmock).to receive(:setup_skeletons).with( 'inc/stubby.h' )
+
+    plugin.stub( request( 'stubby' ) )
+  end
+
+end

data/spec/units/plugins/module_generator_test_file_spec.rb

@@ -0,0 +1,102 @@
+# =========================================================================
+#   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'
+
+$LOAD_PATH.unshift( File.expand_path( '../../../plugins/module_generator/lib', __dir__ ) )
+
+require 'module_generator_test_file'
+
+describe ModuleGeneratorTestFile do
+
+  def test_file(**overrides)
+    return described_class.new(
+      **{ module_name: 'widget', header: 'widget.h', includes: [], boilerplate: nil, test_define: 'TEST', test_guard: 'ifdef' }.merge( overrides )
+    )
+  end
+
+  let(:new_file) do
+    <<~C
+      #ifdef TEST
+
+      #include "unity.h"
+
+      #include "widget.h"
+
+      void setUp(void)
+      {
+      }
+
+      void tearDown(void)
+      {
+      }
+
+      void test_shorty_NeedToImplement(void)
+      {
+          TEST_IGNORE_MESSAGE("Need to Implement shorty");
+      }
+
+      void test_tiny_NeedToImplement(void)
+      {
+          TEST_IGNORE_MESSAGE("Need to Implement tiny");
+      }
+
+      #endif // TEST
+    C
+  end
+
+  it 'writes a new test file with an ignored test for each function' do
+    result = test_file.render( %w[shorty tiny] )
+
+    expect(result.content).to eq( new_file )
+    expect(result.added).to eq( %w[shorty tiny] )
+  end
+
+  it 'starts with the boilerplate, naming the module, and includes configured headers first' do
+    content = test_file( boilerplate: '/* Tests for %1$s */', includes: ['defs.h'] ).render( %w[shorty] ).content
+
+    expect(content).to start_with( "/* Tests for widget */\n#ifdef TEST\n" )
+    expect(content).to include( "#include \"unity.h\"\n\n#include \"defs.h\"\n#include \"widget.h\"\n" )
+  end
+
+  it 'guards with #if and a configured test define' do
+    content = test_file( test_define: 'UNIT_TEST', test_guard: 'if' ).render( %w[shorty] ).content
+
+    expect(content).to start_with( "#if UNIT_TEST\n" )
+    expect(content).to end_with( "#endif // UNIT_TEST\n" )
+  end
+
+  it 'adds tests only for functions an existing file does not test, ahead of its closing guard' do
+    existing = new_file.sub( /\nvoid test_tiny.*?\}\n/m, '' )
+    result   = test_file.render( %w[shorty tiny], existing: existing )
+
+    expect(result.added).to eq( %w[tiny] )
+    expect(result.content).to eq( new_file )
+  end
+
+  it 'counts a test the user named for a function as testing it' do
+    existing = "void test_shorty_returns_zero(void)\n{\n}\n"
+    result   = test_file.render( %w[shorty tiny], existing: existing )
+
+    expect(result.added).to eq( %w[tiny] )
+    expect(result.content).to start_with( existing )
+  end
+
+  it 'appends new tests to an existing file with no closing guard' do
+    result = test_file.render( %w[tiny], existing: "/* mine */\n" )
+
+    expect(result.content).to eq( "/* mine */\n\nvoid test_tiny_NeedToImplement(void)\n{\n    TEST_IGNORE_MESSAGE(\"Need to Implement tiny\");\n}\n" )
+  end
+
+  it 'leaves an existing file unchanged when every function is tested' do
+    result = test_file.render( %w[shorty tiny], existing: new_file )
+
+    expect(result.added).to be_empty
+    expect(result.content).to eq( new_file )
+  end
+
+end