ceedling 1.1.3 → 1.1.5

data/spec/units/config/configurator_setup_spec.rb

@@ -0,0 +1,61 @@
+# =========================================================================
+#   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/config/configurator_setup'
+require 'ceedling/reportinator'
+
+# Only #validate_partials is covered here. The rest of ConfiguratorSetup has no unit spec
+# at all today (its closest sibling, #validate_threads, is untested too) -- this file scopes
+# itself to the new method rather than backfilling that existing gap.
+describe ConfiguratorSetup do
+  before(:each) do
+    @configurator_builder   = double('ConfiguratorBuilder')
+    @configurator_validator = double('ConfiguratorValidator')
+    @configurator_plugins   = double('ConfiguratorPlugins')
+    @loginator              = double('Loginator')
+    @reportinator           = Reportinator.new
+    @file_wrapper           = double('FileWrapper')
+
+    @setup = described_class.new(
+      {
+        configurator_builder:   @configurator_builder,
+        configurator_validator: @configurator_validator,
+        configurator_plugins:   @configurator_plugins,
+        loginator:              @loginator,
+        reportinator:           @reportinator,
+        file_wrapper:           @file_wrapper
+      }
+    )
+  end
+
+  context "#validate_partials" do
+    it "accepts an integer at the minimum" do
+      config = { partials: { max_extraction_length: 10 } }
+      expect(@setup.validate_partials(config)).to be true
+    end
+
+    it "accepts an integer above the minimum" do
+      config = { partials: { max_extraction_length: 5000 } }
+      expect(@setup.validate_partials(config)).to be true
+    end
+
+    it "rejects a non-integer value" do
+      config = { partials: { max_extraction_length: '5000' } }
+      expect(@loginator).to receive(:log)
+        .with(/:partials ↳ :max_extraction_length is not an integer/, Verbosity::ERRORS)
+      expect(@setup.validate_partials(config)).to be false
+    end
+
+    it "rejects an integer below the minimum" do
+      config = { partials: { max_extraction_length: 9 } }
+      expect(@loginator).to receive(:log)
+        .with(/:partials ↳ :max_extraction_length must be at least 10/, Verbosity::ERRORS)
+      expect(@setup.validate_partials(config)).to be false
+    end
+  end
+end

data/spec/units/file_path_utils_spec.rb

@@ -271,4 +271,21 @@ describe FilePathUtils do
     end
   end
 
+  describe '#form_partial_types_header_filename' do
+    before(:each) do
+      @fpu = described_class.new({
+        :configurator => double('configurator'),
+        :file_wrapper => double('file_wrapper')
+      })
+    end
+
+    it 'forms a filename from the module name, the partial prefix, and a _types suffix' do
+      # Mirrors the sibling _interface/_impl header filename conventions -- a shared
+      # location for a module's typedefs and aggregate definitions needs a name
+      # distinct from those two generated headers so all three can coexist.
+      expect( @fpu.form_partial_types_header_filename('LightSensor') )
+        .to eq('ceedling_partial_LightSensor_types.h')
+    end
+  end
+
 end

data/spec/units/generators/generator_helper_spec.rb

@@ -21,30 +21,57 @@ describe GeneratorHelper do
     @helper = described_class.new({ :loginator => @loginator })
 
     # A minimal status double for shell_result[:status].
-    @ok_status = double('status', termsig: nil)
+    @ok_status = double('status', termsig: nil, signaled?: false, exitstatus: 0, success?: true)
   end
 
 
   # ---------------------------------------------------------------------------
   # Helper: build a shell_result hash
   # ---------------------------------------------------------------------------
-  def shell_result(output: VALID_STATS_OUTPUT, stderr: '', termsig: nil)
-    status = double('status', termsig: termsig)
+  # `success` left unspecified derives from `termsig`/`exitstatus` the way a real
+  # Process::Status would -- signaled or nonzero-exit is never success. Callers that
+  # need an inconsistent combination (a status that looks successful despite a nonzero
+  # exit, exercised nowhere here) can still pass `success:` explicitly.
+  def shell_result(output: VALID_STATS_OUTPUT, stderr: '', termsig: nil, exitstatus: 0, success: nil)
+    success = (termsig.nil? && exitstatus == 0) if success.nil?
+    status = double(
+      'status', termsig: termsig, signaled?: !termsig.nil?, exitstatus: exitstatus, success?: success
+    )
     { :output => output, :stderr => stderr, :status => status }
   end
 
 
   describe '#test_crash?' do
 
-    context 'SIGSEGV detection (termsig == 11)' do
-      it 'returns true when the process was terminated by signal 11' do
+    context 'signal death (any signal, not just SIGSEGV)' do
+      it 'returns true when the process was terminated by signal 11 (SIGSEGV)' do
         result = shell_result(termsig: 11)
         expect( @helper.test_crash?('test_foo.c', 'test_foo.out', result) ).to be true
       end
 
-      it 'does not flag SIGSEGV for other signal numbers' do
-        result = shell_result(termsig: 6)   # SIGABRT
+      it 'returns true when the process was terminated by signal 6 (SIGABRT) -- e.g. UBSan/ASan halt_on_error' do
+        result = shell_result(termsig: 6)
         # output still has stats, stderr is empty → only the signal check matters here
+        expect( @helper.test_crash?('test_foo.c', 'test_foo.out', result) ).to be true
+      end
+    end
+
+    context 'a clean summary contradicted by the real exit status' do
+      it 'returns true when 0 failures are reported but the real process exited nonzero and unsignaled' do
+        # e.g. LeakSanitizer detecting a leak during teardown, after every test case
+        # already printed and Unity's own summary already looked clean.
+        result = shell_result(output: VALID_STATS_OUTPUT, exitstatus: 1, success: false)
+        expect( @helper.test_crash?('test_foo.c', 'test_foo.out', result) ).to be true
+      end
+
+      it 'returns false when a nonzero real exit is consistent with Unity reporting real failures' do
+        failing_output = "\n---------\n2 Tests 1 Failures 0 Ignored\nFAIL\n"
+        result = shell_result(output: failing_output, exitstatus: 1, success: false)
+        expect( @helper.test_crash?('test_foo.c', 'test_foo.out', result) ).to be false
+      end
+
+      it 'returns false when 0 failures are reported and the real process exited successfully' do
+        result = shell_result(output: VALID_STATS_OUTPUT, exitstatus: 0, success: true)
         expect( @helper.test_crash?('test_foo.c', 'test_foo.out', result) ).to be false
       end
     end

data/spec/units/generators/generator_partials_spec.rb

@@ -222,6 +222,183 @@ describe GeneratorPartials do
     end
   end
 
+  context "#generate_types" do
+    it "writes nothing and returns nil when the module has no typedefs or aggregate definitions" do
+      allow(@file_wrapper).to receive(:open)
+
+      c_module = make_module(
+        make_stmt(text: "#define FOO 1", line_num: 1),
+        make_var(name: 'counter', type: 'int', text: 'int counter;', line_num: 2)
+      )
+
+      result = @generator.generate_types(
+        name: 'my_module',
+        c_module: c_module,
+        output_path: '/path/to/output'
+      )
+
+      expect(@file_wrapper).not_to have_received(:open)
+      expect(result).to be_nil
+    end
+
+    it "writes the typedefs and aggregate definitions, guarded and in element_sequence order, carrying forward a macro that precedes one of them, and returns the bare filename" do
+      file_contents = <<~CONTENTS
+      #ifndef __CEEDLING_GENERATED_MY_MODULE_TYPES_H__
+      #define __CEEDLING_GENERATED_MY_MODULE_TYPES_H__
+
+      typedef uint8_t Byte;
+      #define FOO 1
+      struct Config { int id; };
+
+      #endif // __CEEDLING_GENERATED_MY_MODULE_TYPES_H__
+
+      CONTENTS
+
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+      expected_filepath = File.join(output_path, header_filename)
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename)
+        .with(name)
+        .and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open)
+        .with(expected_filepath, 'wb')
+        .and_yield(buf)
+
+      # A variable and a macro sit between the two type-defining statements in
+      # element_sequence. The variable (which stays behind for generate_header) is
+      # entirely absent here, but the macro precedes the aggregate and is carried
+      # forward immediately before it -- the aggregate's definition may depend on it
+      # (e.g. an array-size constant), and this header is #included before
+      # generate_header's own later, inline copy of that same macro would exist.
+      typedef_stmt   = CExtractorTypes::CStatement.new(text: "typedef uint8_t Byte;", line_num: 1)
+      var_decl       = make_var(name: 'counter', type: 'int', text: 'int counter;', line_num: 2)
+      macro_stmt     = CExtractorTypes::CStatement.new(text: "#define FOO 1", line_num: 3)
+      aggregate_stmt = CExtractorTypes::CStatement.new(text: "struct Config { int id; };", line_num: 4)
+
+      c_module = CExtractorTypes::CModule.new(
+        type_definitions:      [typedef_stmt],
+        macro_definitions:     [macro_stmt],
+        variable_declarations: [var_decl],
+        aggregate_definitions: [aggregate_stmt],
+        element_sequence:      [typedef_stmt, var_decl, macro_stmt, aggregate_stmt]
+      )
+
+      result = @generator.generate_types(
+        name: name,
+        c_module: c_module,
+        output_path: output_path
+      )
+
+      expect( buf.string.strip() ).to eq file_contents.strip()
+      expect(@file_wrapper).to have_received(:open).with(expected_filepath, 'wb')
+      expect(result).to eq(header_filename)
+    end
+
+    it "carries a macro forward directly before the single typedef it immediately precedes" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+      expected_filepath = File.join(output_path, header_filename)
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      macro_stmt   = CExtractorTypes::CStatement.new(text: "#define LOCAL_CAPACITY 4", line_num: 1)
+      typedef_stmt = CExtractorTypes::CStatement.new(text: "typedef struct { int values[LOCAL_CAPACITY]; } Context;", line_num: 3)
+
+      c_module = CExtractorTypes::CModule.new(
+        type_definitions:  [typedef_stmt],
+        macro_definitions: [macro_stmt],
+        element_sequence:  [macro_stmt, typedef_stmt]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string ).to include( "#define LOCAL_CAPACITY 4\ntypedef struct { int values[LOCAL_CAPACITY]; } Context;\n" )
+    end
+
+    it "carries forward multiple macros preceding one type-defining item, in their own original relative order" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      macro_a      = CExtractorTypes::CStatement.new(text: "#define WIDTH 4", line_num: 1)
+      macro_b      = CExtractorTypes::CStatement.new(text: "#define HEIGHT 8", line_num: 2)
+      typedef_stmt = CExtractorTypes::CStatement.new(text: "typedef int Grid[WIDTH][HEIGHT];", line_num: 3)
+
+      c_module = CExtractorTypes::CModule.new(
+        type_definitions:  [typedef_stmt],
+        macro_definitions: [macro_a, macro_b],
+        element_sequence:  [macro_a, macro_b, typedef_stmt]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string ).to include( "#define WIDTH 4\n#define HEIGHT 8\ntypedef int Grid[WIDTH][HEIGHT];\n" )
+    end
+
+    it "carries a macro forward only once, before the first type-defining item it precedes, not before a later one too" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      macro_stmt     = CExtractorTypes::CStatement.new(text: "#define FOO 1", line_num: 1)
+      typedef_stmt   = CExtractorTypes::CStatement.new(text: "typedef int Foo;", line_num: 2)
+      aggregate_stmt = CExtractorTypes::CStatement.new(text: "struct Bar { int x; };", line_num: 3)
+
+      c_module = CExtractorTypes::CModule.new(
+        type_definitions:      [typedef_stmt],
+        macro_definitions:     [macro_stmt],
+        aggregate_definitions: [aggregate_stmt],
+        element_sequence:      [macro_stmt, typedef_stmt, aggregate_stmt]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string.scan("#define FOO 1").length ).to eq(1)
+    end
+
+    it "does not carry a macro into the shared header when it appears only after every type-defining item" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      typedef_stmt = CExtractorTypes::CStatement.new(text: "typedef int Foo;", line_num: 1)
+      macro_stmt   = CExtractorTypes::CStatement.new(text: "#define FOO 1", line_num: 2)
+
+      c_module = CExtractorTypes::CModule.new(
+        type_definitions:  [typedef_stmt],
+        macro_definitions: [macro_stmt],
+        element_sequence:  [typedef_stmt, macro_stmt]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string ).to_not include("#define FOO 1")
+    end
+  end
+
   context "#generate_header (private method)" do
     # Define common StringIO buffer
     let(:buf) { StringIO.new() }
@@ -282,6 +459,24 @@ describe GeneratorPartials do
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
+    it "should reapply a leading qualifier decorator to an extern declaration" do
+      c_module = make_module(
+        make_var(name: 'cmd', type: 'cmd_t', text: 'cmd_t cmd = { 0 };', decorators: ['static', 'volatile'])
+      )
+      @generator.send(:generate_header, buf, 'mymod', [], [], c_module, true)
+
+      expect(buf.string).to include('extern volatile cmd_t cmd;')
+    end
+
+    it "should not reapply a qualifier already embedded in a pointer-level declarator" do
+      c_module = make_module(
+        make_var(name: 'lookup_table', type: 'uint8_t* const', text: 'uint8_t* const lookup_table;', decorators: ['static', 'const'])
+      )
+      @generator.send(:generate_header, buf, 'mymod', [], [], c_module, true)
+
+      expect(buf.string).to include('extern const uint8_t* const lookup_table;')
+    end
+
     it "should generate a header file with #include statements, variable declarations, and function signatures" do
       file_contents = <<~CONTENTS
       #ifndef __CEEDLING_GENERATED_APPLES_AND_BANANAS_H__
@@ -360,23 +555,29 @@ describe GeneratorPartials do
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
-    it "should emit all four injectable statement categories correctly in element_sequence order" do
-      # One item of each category that can be injected into a generated Partial header:
-      #   macro_definitions    → CStatement emitted as-is
-      #   type_definitions     → CStatement emitted as-is
-      #   aggregate_definitions → CStatement emitted as-is
-      #   variable_declarations → CVariableDeclaration emitted as extern declaration
+    it "should emit macro and variable statements inline while routing typedefs and aggregates to the shared types header" do
+      # One item of each category that can appear in a generated Partial header:
+      #   macro_definitions     → CStatement emitted as-is, inline
+      #   type_definitions      → CStatement skipped here; belongs to generate_types instead
+      #   aggregate_definitions → CStatement skipped here; belongs to generate_types instead
+      #   variable_declarations → CVariableDeclaration emitted as extern declaration, inline
+      #
+      # A typedef or aggregate defines a type, and C rejects a second definition of the same
+      # type in one translation unit even when it's textually identical -- unlike a macro,
+      # which may legally repeat. Since a module's implementation and interface headers can
+      # both be included in the same test file, generate_header always defers type-defining
+      # content to the one shared types header generate_types produces, rather than risking
+      # two independent copies landing in the same translation unit.
       #
       # Ordering is intentionally interleaved (not grouped by category) to confirm that
-      # element_sequence — not typed-array membership — governs emit order.
+      # element_sequence — not typed-array membership — governs emit order for the items
+      # that do remain inline.
       file_contents = <<~CONTENTS
       #ifndef __CEEDLING_GENERATED_ALL_STATEMENTS_H__
       #define __CEEDLING_GENERATED_ALL_STATEMENTS_H__
 
       #define MAX_ITEMS 16
-      typedef uint8_t Byte;
       extern int item_count;
-      struct Config { int id; int flags; };
 
       #endif // __CEEDLING_GENERATED_ALL_STATEMENTS_H__
 
@@ -443,13 +644,11 @@ describe GeneratorPartials do
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
-    it "should interleave functions with other elements in element_sequence order" do
+    it "should interleave functions with other elements in element_sequence order, skipping a leading typedef routed to the shared types header" do
       file_contents = <<~CONTENTS
       #ifndef __CEEDLING_GENERATED_INTERLEAVED_H__
       #define __CEEDLING_GENERATED_INTERLEAVED_H__
 
-      typedef uint8_t Byte;
-
       void foo(void);
 
       extern int counter;
@@ -460,6 +659,8 @@ describe GeneratorPartials do
 
       CONTENTS
 
+      # typedef_stmt is a member of type_definitions, so generate_header leaves it out here;
+      # it's the sole responsibility of generate_types (see the "shared types header" tests)
       typedef_stmt = make_stmt(text: "typedef uint8_t Byte;", line_num: 1)
       var_decl     = make_var( name: 'counter', type: 'int', text: 'int counter;', line_num: 5)
 
@@ -568,6 +769,16 @@ describe GeneratorPartials do
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
+    it "should reapply a leading qualifier decorator to a variable definition" do
+      c_module = make_module(
+        make_var(name: 'cmd', type: 'cmd_t', text: 'cmd_t cmd = { 0 };', decorators: ['static', 'volatile'])
+      )
+
+      @generator.send(:generate_source, buf, [], [], c_module)
+
+      expect(buf.string).to include('volatile cmd_t cmd = { 0 };')
+    end
+
     it "should generate a source file with include directives, variable declarations, and functions" do
       file_contents = <<~CONTENTS
       // Ceeding generated file