ceedling 1.1.0 → 1.1.2

data/spec/units/preprocess/preprocessinator_file_assembler_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe PreprocessinatorFileAssembler do
   # Use real ParsingParcels for _filter_conditionals and collect_file_contents_fallback tests
   let(:real_parsing_parcels) { ParsingParcels.new }
   let(:real_reconstructor) do
-    PreprocessinatorReconstructor.new({ parsing_parcels: real_parsing_parcels })
+    PreprocessinatorReconstructor.new({ parsing_parcels: real_parsing_parcels, file_wrapper: @file_wrapper })
   end
 
   before :each do
@@ -260,4 +260,253 @@ RSpec.describe PreprocessinatorFileAssembler do
 
   end
 
+
+  # ===========================================================================
+  describe '#collect_mockable_header_file_contents' do
+  # ===========================================================================
+
+    let(:test) { 'test_module' }
+    let(:filepath) { '/src/module.h' }
+    let(:directives_only_filepath) { '/build/directives/module.h' }
+    let(:preprocessed_filepath) { '/build/full_expansion/module.h' }
+    let(:flags) { [] }
+    let(:defines) { [] }
+    let(:include_paths) { [] }
+
+    before :each do
+      allow(@file_path_utils).to receive(:form_preprocessed_file_full_expansion_filepath)
+        .with(filepath, test).and_return(preprocessed_filepath)
+      allow(@configurator).to receive(:tools_test_file_full_preprocessor).and_return(:full_preprocessor)
+      allow(@tool_executor).to receive(:build_command_line).and_return('gcc -E ...')
+      allow(@tool_executor).to receive(:exec)
+      stub_file_open(preprocessed_filepath, "# 1 \"#{filepath}\"\nint x;\n", 'r')
+    end
+
+    def call_collect_mockable(fallback:, extras:)
+      subject.collect_mockable_header_file_contents(
+        test: test,
+        filepath: filepath,
+        directives_only_filepath: directives_only_filepath,
+        fallback: fallback,
+        flags: flags,
+        defines: defines,
+        include_paths: include_paths,
+        extras: extras
+      )
+    end
+
+    context 'when extras are not requested' do
+
+      it 'returns an empty extras list and a nil include guard' do
+        _contents, extras, include_guard = call_collect_mockable(fallback: true, extras: false)
+        expect(extras).to eq([])
+        expect(include_guard).to be_nil
+      end
+
+      it 'does not read the original file to look for an include guard' do
+        expect(@file_wrapper).not_to receive(:read)
+        call_collect_mockable(fallback: true, extras: false)
+      end
+
+    end
+
+    context 'when extras are requested' do
+
+      let(:header_with_guard) do
+        <<~C
+          #ifndef FOO_H
+          #define FOO_H
+
+          void foo(void);
+
+          #endif
+        C
+      end
+
+      it 'extracts the include guard from the original file in fallback mode' do
+        allow(@file_wrapper).to receive(:read).with(filepath, 2048).and_return(header_with_guard)
+        stub_file_open(filepath, header_with_guard, 'rb')
+
+        _contents, _extras, include_guard = call_collect_mockable(fallback: true, extras: true)
+        expect(include_guard).to eq('FOO_H')
+      end
+
+      it 'extracts the include guard from the original file in directives-only mode' do
+        allow(@file_wrapper).to receive(:read).with(filepath, 2048).and_return(header_with_guard)
+        stub_file_open(directives_only_filepath, header_with_guard, 'r')
+
+        _contents, _extras, include_guard = call_collect_mockable(fallback: false, extras: true)
+        expect(include_guard).to eq('FOO_H')
+      end
+
+      it 'returns a nil include guard when the original file has no #ifndef/#define guard pair' do
+        header_without_guard = "#pragma once\n\nvoid foo(void);\n"
+        allow(@file_wrapper).to receive(:read).with(filepath, 2048).and_return(header_without_guard)
+        stub_file_open(filepath, header_without_guard, 'rb')
+
+        _contents, _extras, include_guard = call_collect_mockable(fallback: true, extras: true)
+        expect(include_guard).to be_nil
+      end
+
+    end
+
+  end
+
+
+  # ===========================================================================
+  describe '#assemble_preprocessed_header_file' do
+  # ===========================================================================
+
+    let(:preprocessed_filepath) { '/build/mocks/test_module/module.h' }
+
+    # Binary mode ('wb'): `contents` lines assembled into this file come from
+    # an upstream preprocessed file and must reach disk with their line
+    # endings unaltered, which text mode would not guarantee.
+    def stub_file_write(filepath)
+      output = StringIO.new
+      allow(@file_wrapper).to receive(:open).with(filepath, 'wb').and_yield(output)
+      output
+    end
+
+    it 'writes the given include guard name as the #ifndef/#define/#endif guard' do
+      output = stub_file_write(preprocessed_filepath)
+
+      subject.assemble_preprocessed_header_file(
+        filename:              'module.h',
+        preprocessed_filepath: preprocessed_filepath,
+        contents:              ['void foo(void);'],
+        extras:                [],
+        includes:              [],
+        include_guard:         'FOO_H'
+      )
+
+      expect(output.string).to include("#ifndef FOO_H\n")
+      expect(output.string).to include("#define FOO_H\n")
+      expect(output.string).to include('#endif // FOO_H')
+    end
+
+    it 'derives a synthetic include guard from the filename when none is given' do
+      output = stub_file_write(preprocessed_filepath)
+
+      subject.assemble_preprocessed_header_file(
+        filename:              'module.h',
+        preprocessed_filepath: preprocessed_filepath,
+        contents:              ['void foo(void);'],
+        extras:                [],
+        includes:              []
+      )
+
+      expect(output.string).to include("#ifndef __CEEDLING_GENERATED_MODULE_H__\n")
+      expect(output.string).to include("#define __CEEDLING_GENERATED_MODULE_H__\n")
+    end
+
+    it 'writes provided includes and contents between the guard lines' do
+      output = stub_file_write(preprocessed_filepath)
+
+      subject.assemble_preprocessed_header_file(
+        filename:              'module.h',
+        preprocessed_filepath: preprocessed_filepath,
+        contents:              ['void foo(void);'],
+        extras:                [],
+        includes:              ['#include "bar.h"'],
+        include_guard:         'FOO_H'
+      )
+
+      expect(output.string).to include('#include "bar.h"')
+      expect(output.string).to include('void foo(void);')
+    end
+
+    it 'opens its output file in binary mode' do
+      stub_file_write(preprocessed_filepath)
+
+      subject.assemble_preprocessed_header_file(
+        filename:              'module.h',
+        preprocessed_filepath: preprocessed_filepath,
+        contents:              [],
+        extras:                [],
+        includes:              []
+      )
+
+      expect(@file_wrapper).to have_received(:open).with(preprocessed_filepath, 'wb')
+    end
+
+    it "passes content lines through to the output file unchanged, including embedded CRLF" do
+      output = stub_file_write(preprocessed_filepath)
+      content_line_with_crlf = "void foo(void) {\r\n  return;\r\n}"
+
+      subject.assemble_preprocessed_header_file(
+        filename:              'module.h',
+        preprocessed_filepath: preprocessed_filepath,
+        contents:              [content_line_with_crlf],
+        extras:                [],
+        includes:              []
+      )
+
+      expect(output.string).to include(content_line_with_crlf)
+    end
+
+  end
+
+
+  # ===========================================================================
+  describe '#assemble_preprocessed_code_file' do
+  # ===========================================================================
+
+    let(:preprocessed_filepath) { '/build/test/preprocess/module.c' }
+
+    # Binary mode ('wb'): `contents` lines assembled into this file come from
+    # an upstream preprocessed file and must reach disk with their line
+    # endings unaltered, which text mode would not guarantee.
+    def stub_file_write(filepath)
+      output = StringIO.new
+      allow(@file_wrapper).to receive(:open).with(filepath, 'wb').and_yield(output)
+      output
+    end
+
+    it 'writes provided includes and contents to the output file' do
+      output = stub_file_write(preprocessed_filepath)
+
+      subject.assemble_preprocessed_code_file(
+        filename:              'module.c',
+        preprocessed_filepath: preprocessed_filepath,
+        contents:              ['void foo(void) {}'],
+        extras:                [],
+        includes:              ['#include "bar.h"']
+      )
+
+      expect(output.string).to include('#include "bar.h"')
+      expect(output.string).to include('void foo(void) {}')
+    end
+
+    it 'opens its output file in binary mode' do
+      stub_file_write(preprocessed_filepath)
+
+      subject.assemble_preprocessed_code_file(
+        filename:              'module.c',
+        preprocessed_filepath: preprocessed_filepath,
+        contents:              [],
+        extras:                [],
+        includes:              []
+      )
+
+      expect(@file_wrapper).to have_received(:open).with(preprocessed_filepath, 'wb')
+    end
+
+    it "passes content lines through to the output file unchanged, including embedded CRLF" do
+      output = stub_file_write(preprocessed_filepath)
+      content_line_with_crlf = "void foo(void) {\r\n  return;\r\n}"
+
+      subject.assemble_preprocessed_code_file(
+        filename:              'module.c',
+        preprocessed_filepath: preprocessed_filepath,
+        contents:              [content_line_with_crlf],
+        extras:                [],
+        includes:              []
+      )
+
+      expect(output.string).to include(content_line_with_crlf)
+    end
+
+  end
+
 end

data/spec/units/preprocess/preprocessinator_reconstructor_spec.rb

@@ -12,9 +12,11 @@ require 'ceedling/parsing_parcels'
 describe PreprocessinatorReconstructor do
   before(:each) do
     @parsing_parcels = ParsingParcels.new()
+    @file_wrapper    = double( "FileWrapper" )
     @extractor = described_class.new(
       {
-        :parsing_parcels => @parsing_parcels
+        :parsing_parcels => @parsing_parcels,
+        :file_wrapper    => @file_wrapper,
       }
     )
   end
@@ -75,6 +77,105 @@ describe PreprocessinatorReconstructor do
       expect( @extractor.extract_file_as_array_from_expansion( input, filepath ) ).to eq expected
     end
 
+    it "should preserve a run of multiple consecutive blank lines rather than collapsing to one" do
+      filepath = "this/path/MY_FILE.C"
+
+      file_contents = [
+        '# 1 "./this/path/MY_FILE.C" 99999',
+        'void some_function(void) {',
+        '',
+        '',
+        '',
+        '  return 0;',
+        '}'
+      ]
+
+      # All three blank lines must survive -- e.g. a stripped multi-line comment
+      # or literal blank lines in the source, either way nothing gets dropped.
+      expected = [
+        'void some_function(void) {',
+        '',
+        '',
+        '',
+        '  return 0;',
+        '}'
+      ]
+
+      input = StringIO.new( file_contents.join( "\n" ) )
+
+      expect( @extractor.extract_file_as_array_from_expansion( input, filepath ) ).to eq expected
+    end
+
+    it "should preserve independent runs of differing blank-line counts between separate code lines" do
+      filepath = "path/multi.c"
+
+      file_contents = [
+        '# 1 "path/multi.c" 1',
+        'int a;',
+        '',
+        '',
+        'int b;',
+        '',
+        'int c;',
+        '',
+        '',
+        '',
+        'int d;'
+      ]
+
+      # Each run's count must stay attached to its own gap -- not merged with a
+      # neighboring run, not truncated to a shared count.
+      expected = [
+        'int a;',
+        '',
+        '',
+        'int b;',
+        '',
+        'int c;',
+        '',
+        '',
+        '',
+        'int d;'
+      ]
+
+      input = StringIO.new( file_contents.join( "\n" ) )
+
+      expect( @extractor.extract_file_as_array_from_expansion( input, filepath ) ).to eq expected
+    end
+
+    it "should preserve a following blank-line run after a marker-continuation (dangling semicolon) fragment" do
+      filepath = "sys/types_wrapper.c"
+
+      file_contents = [
+        '# 1 "sys/types_wrapper.c" 1',
+        'typedef unsigned long uint32_t',    # System typedef expansion, unterminated
+        '# 1 "sys/types_wrapper.c" 2',       # GCC re-marks the SAME source line...
+        ';',                                  # ...to attach a dangling ';' as a continuation, not a new line
+        '',
+        '',
+        'void some_function(void) {',
+        '  return;',
+        '}',
+        '# 1 "some/useless/file.c"'
+      ]
+
+      # The typedef and its dangling ';' must aggregate onto a single output
+      # line (existing behavior), and the two blank lines that follow -- e.g.
+      # from a stripped comment after the typedef -- must both still survive.
+      expected = [
+        'typedef unsigned long uint32_t;',
+        '',
+        '',
+        'void some_function(void) {',
+        '  return;',
+        '}'
+      ]
+
+      input = StringIO.new( file_contents.join( "\n" ) )
+
+      expect( @extractor.extract_file_as_array_from_expansion( input, filepath ) ).to eq expected
+    end
+
     it "should extract text of original file from preprocessed expansion with complex preprocessor line marker sequence" do
       filepath = "dir/our_file.c"
       
@@ -207,6 +308,8 @@ describe PreprocessinatorReconstructor do
         '',
         'static _Bool ecs_foo__init_structure(void);',
         '',
+        '',
+        '',
         'void ecs_foo_init(void) {',
         '    var1 = ecs_foo__init_structure();',
         '}',
@@ -697,4 +800,51 @@ describe PreprocessinatorReconstructor do
 
   end
 
+  context "#compact_file_from_expansion" do
+    it "should open its input in binary mode and its output in binary mode" do
+      # Binary mode on both ends: this content is read again downstream by code
+      # that depends on its line count being exact, so nothing here should be
+      # subject to platform-specific line ending translation.
+      input_handle  = StringIO.new( '# 1 "WANT.c" 5' + "\n" + 'text_we_want();' + "\n" )
+      output_handle = StringIO.new
+
+      expect(@file_wrapper).to receive(:open).with( 'input.c', 'rb' ).and_yield( input_handle )
+      expect(@file_wrapper).to receive(:open).with( 'output.c', 'wb' ).and_yield( output_handle )
+
+      @extractor.compact_file_from_expansion(
+        input_filepath:  'input.c',
+        source_filepath: 'WANT.c',
+        output_filepath: 'output.c'
+      )
+    end
+
+    it "should extract the same content from CRLF-terminated input as from LF-terminated input" do
+      # GCC's preprocessor output on Windows is CRLF-terminated. Extraction must
+      # produce identical results regardless of the input's line endings, since
+      # the exact line count of what's extracted matters to code downstream.
+      lf_input = StringIO.new(
+        '# 1 "WANT.c" 5' + "\n" + "line_one();\n" + "\n" + "line_two();\n"
+      )
+      crlf_input = StringIO.new(
+        '# 1 "WANT.c" 5' + "\r\n" + "line_one();\r\n" + "\r\n" + "line_two();\r\n"
+      )
+      lf_output   = StringIO.new
+      crlf_output = StringIO.new
+
+      allow(@file_wrapper).to receive(:open).with( 'lf.c', 'rb' ).and_yield( lf_input )
+      allow(@file_wrapper).to receive(:open).with( 'lf_out.c', 'wb' ).and_yield( lf_output )
+      allow(@file_wrapper).to receive(:open).with( 'crlf.c', 'rb' ).and_yield( crlf_input )
+      allow(@file_wrapper).to receive(:open).with( 'crlf_out.c', 'wb' ).and_yield( crlf_output )
+
+      @extractor.compact_file_from_expansion(
+        input_filepath: 'lf.c', source_filepath: 'WANT.c', output_filepath: 'lf_out.c'
+      )
+      @extractor.compact_file_from_expansion(
+        input_filepath: 'crlf.c', source_filepath: 'WANT.c', output_filepath: 'crlf_out.c'
+      )
+
+      expect( crlf_output.string ).to eq( lf_output.string )
+    end
+  end
+
 end

data/spec/units/test_build_executor_spec.rb

@@ -0,0 +1,114 @@
+# =========================================================================
+#   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/test_invoker/test_build_executor'
+require 'ceedling/test_invoker/test_invoker_types'
+
+PROJECT_BUILD_VENDOR_UNITY_PATH = 'build/vendor/unity' unless defined?(PROJECT_BUILD_VENDOR_UNITY_PATH)
+UNITY_C_FILE = 'unity.c' unless defined?(UNITY_C_FILE)
+
+describe TestBuildExecutor do
+  before(:each) do
+    @configurator            = double( "Configurator" )
+    @loginator                = double( "Loginator" )
+    @reportinator               = double( "Reportinator" )
+    @batchinator                  = double( "Batchinator" )
+    @preprocessinator                = double( "Preprocessinator" )
+    @partializer                       = double( "Partializer" )
+    @generator                           = double( "Generator" )
+    @test_context_extractor                 = double( "TestContextExtractor" )
+    @plugin_manager                            = double( "PluginManager" )
+    @file_path_utils                              = double( "FilePathUtils" )
+    @file_finder                                     = double( "FileFinder" )
+    @file_wrapper                                       = double( "FileWrapper" )
+
+    @tools_test_compiler  = { name: 'fake compiler' }
+    @tools_test_assembler = { name: 'fake assembler' }
+
+    allow(@configurator).to receive(:extension_assembly).and_return( '.asm' )
+    allow(@configurator).to receive(:tools_test_compiler).and_return( @tools_test_compiler )
+    allow(@configurator).to receive(:tools_test_assembler).and_return( @tools_test_assembler )
+    allow(@configurator).to receive(:project_use_mocks).and_return( false )
+    allow(@configurator).to receive(:project_use_exceptions).and_return( false )
+    allow(@configurator).to receive(:collection_all_support).and_return( [] )
+
+    allow(@file_path_utils).to receive(:form_test_build_list_filepath).and_return( 'build/list' )
+    allow(@file_path_utils).to receive(:form_test_dependencies_filepath).and_return( 'build/deps' )
+
+    @executor = described_class.new(
+      {
+        :configurator            => @configurator,
+        :loginator               => @loginator,
+        :reportinator            => @reportinator,
+        :batchinator             => @batchinator,
+        :preprocessinator        => @preprocessinator,
+        :partializer             => @partializer,
+        :generator               => @generator,
+        :test_context_extractor  => @test_context_extractor,
+        :plugin_manager          => @plugin_manager,
+        :file_path_utils         => @file_path_utils,
+        :file_finder             => @file_finder,
+        :file_wrapper            => @file_wrapper
+      }
+    )
+
+    testable = TestInvokerTypes::Testable.new(
+      :compile_defines  => [],
+      :search_paths     => [],
+      :compile_flags    => [],
+      :assembler_flags  => []
+    )
+
+    @state = TestInvokerTypes::PipelineState.new( :testables => { :a_test => testable } )
+  end
+
+  context "#compile_test_component" do
+    it "compiles a C source file with the configured test compiler tool" do
+      allow(@file_wrapper).to receive(:extname).with( 'src/foo.c' ).and_return( '.c' )
+      allow(@configurator).to receive(:test_build_use_assembly).and_return( false )
+
+      expect(@generator).to receive(:generate_object_file_c) do |**args|
+        expect( args[:tool] ).to eq( @tools_test_compiler )
+      end
+      expect(@generator).to_not receive(:generate_object_file_asm)
+
+      @executor.send(
+        :compile_test_component,
+        :context => :test, :test => :a_test, :source => 'src/foo.c', :object => 'build/foo.o', :state => @state
+      )
+    end
+
+    it "assembles an assembly source file with the configured test assembler tool when assembly support is enabled" do
+      allow(@file_wrapper).to receive(:extname).with( 'src/foo.asm' ).and_return( '.asm' )
+      allow(@configurator).to receive(:test_build_use_assembly).and_return( true )
+
+      expect(@generator).to receive(:generate_object_file_asm) do |**args|
+        expect( args[:tool] ).to eq( @tools_test_assembler )
+      end
+      expect(@generator).to_not receive(:generate_object_file_c)
+
+      @executor.send(
+        :compile_test_component,
+        :context => :test, :test => :a_test, :source => 'src/foo.asm', :object => 'build/foo.o', :state => @state
+      )
+    end
+
+    it "does not compile an assembly source file when assembly support is disabled" do
+      allow(@file_wrapper).to receive(:extname).with( 'src/foo.asm' ).and_return( '.asm' )
+      allow(@configurator).to receive(:test_build_use_assembly).and_return( false )
+
+      expect(@generator).to_not receive(:generate_object_file_c)
+      expect(@generator).to_not receive(:generate_object_file_asm)
+
+      @executor.send(
+        :compile_test_component,
+        :context => :test, :test => :a_test, :source => 'src/foo.asm', :object => 'build/foo.o', :state => @state
+      )
+    end
+  end
+end

data/vendor/unity/auto/generate_test_runner.rb

@@ -100,9 +100,10 @@ class UnityTestRunnerGenerator
       create_suite_setup(output)
       create_suite_teardown(output)
       create_reset(output)
-      create_run_test(output) unless tests.empty?
+      create_run_test(output)
       create_args_wrappers(output, tests)
       create_shuffle_tests(output) if @options[:shuffle_tests]
+      tests = create_warning_test(output, input_file, tests)
       create_main(output, input_file, tests, used_mocks)
     end
 
@@ -406,10 +407,43 @@ class UnityTestRunnerGenerator
   end
 
   def create_run_test(output)
-    require 'erb'
-    file = File.read(File.join(__dir__, 'run_test.erb'))
-    template = ERB.new(file, trim_mode: '<>')
-    output.puts("\n#{template.result(binding)}")
+    output.puts("/*=======Test Runner Used To Run Each Test=====*/")
+    output.puts("static void run_test(UnityTestFunction func, const char* name, UNITY_LINE_TYPE line_num)")
+    output.puts("{")
+    output.puts("    Unity.CurrentTestName = name;")
+    output.puts("    Unity.CurrentTestLineNumber = (UNITY_UINT) line_num;")
+    output.puts("#ifdef UNITY_USE_COMMAND_LINE_ARGS")
+    output.puts("    if (!UnityTestMatches())")
+    output.puts("        return;")
+    output.puts("#endif")
+    output.puts("    Unity.NumberOfTests++;")
+    output.puts("    UNITY_CLR_DETAILS();")
+    output.puts("    UNITY_EXEC_TIME_START();")
+    output.puts("    CMock_Init();")
+    output.puts("    if (TEST_PROTECT())")
+    output.puts("    {")
+    if @options[:plugins].include?(:cexception)
+      output.puts("        volatile CEXCEPTION_T e;")
+      output.puts("        Try {")
+      output.puts("            #{@options[:setup_name]}();")
+      output.puts("            func();")
+      output.puts("        } Catch(e) {")
+      output.puts("            TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, \"Unhandled Exception!\");")
+      output.puts("        }")
+    else
+      output.puts("        #{@options[:setup_name]}();")
+      output.puts("        func();")
+    end
+    output.puts("    }")
+    output.puts("    if (TEST_PROTECT())")
+    output.puts("    {")
+    output.puts("        #{@options[:teardown_name]}();")
+    output.puts("        CMock_Verify();")
+    output.puts("    }")
+    output.puts("    CMock_Destroy();")
+    output.puts("    UNITY_EXEC_TIME_STOP();")
+    output.puts("    UnityConcludeTest();")
+    output.puts("}")
   end
 
   def create_args_wrappers(output, tests)
@@ -428,6 +462,22 @@ class UnityTestRunnerGenerator
     end
   end
 
+  def create_warning_test(output, filename, tests)
+    if count_tests(tests) == 0
+      warning_test = {
+        :test => "test_empty_warning",
+        :line_number => 0
+      }
+      output.puts("\n/*=======Warning Test=====*/")
+      output.puts("static void #{warning_test[:test]}(void)")
+      output.puts('{')
+      output.puts("    TEST_IGNORE_MESSAGE(\"Test file '#{filename.gsub(/\\/, '\\\\\\')}' contains no tests.\");")
+      output.puts("}\n")
+      tests = [warning_test]
+    end
+    return tests
+  end
+
   def create_shuffle_tests(output)
     output.puts("\n/*=======Shuffle Test Order=====*/")
     output.puts('static void shuffleTests(struct UnityRunTestParameters run_test_params_arr[], int num_of_tests)')

data/vendor/unity/src/unity.h

@@ -11,7 +11,7 @@
 
 #define UNITY_VERSION_MAJOR    2
 #define UNITY_VERSION_MINOR    7
-#define UNITY_VERSION_BUILD    0
+#define UNITY_VERSION_BUILD    1
 #define UNITY_VERSION          ((UNITY_VERSION_MAJOR << 16) | (UNITY_VERSION_MINOR << 8) | UNITY_VERSION_BUILD)
 
 #ifdef __cplusplus

data/vendor/unity/test/testdata/testRunnerGeneratorEmpty.c

@@ -0,0 +1,13 @@
+/* =========================================================================
+    Unity - A Test Framework for C
+    ThrowTheSwitch.org
+    Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
+/* This Test File Is Used To Verify The Warning When No Tests Are Found */
+
+#include "unity.h"
+
+void setUp(void) {}
+void tearDown(void) {}

data/vendor/unity/test/tests/test_generate_test_runner.rb

@@ -336,6 +336,17 @@ RUNNER_TESTS = [
   },
 
 
+  { :name => 'EmptyFileWarning',
+    :testfile => 'testdata/testRunnerGeneratorEmpty.c',
+    :testdefines => ['TEST'],
+    :options => nil, #defaults
+    :expected => {
+      :to_pass => [ ],
+      :to_fail => [ ],
+      :to_ignore => [ 'test_empty_warning' ],
+    }
+  },
+
   #### WITH MOCKS ##########################################
 
   { :name => 'DefaultsThroughOptions',