ceedling 1.1.2 → 1.1.4

data/spec/units/c_extractor/c_extractor_integration_spec.rb

@@ -34,7 +34,11 @@ describe CExtractor do
         c_extractor_functions:     functions,
         c_extractor_declarations:  declarations,
         c_extractor_preprocessing: preprocessing,
-        c_extractor_definitions:   definitions
+        c_extractor_definitions:   definitions,
+        # Bare double (no :partials_max_extraction_length stub) so #respond_to? is
+        # false and CExtractor falls back to its own built-in default buffer length.
+        configurator:              double('Configurator'),
+        loginator:                 double('Loginator').as_null_object
       }
     )
     extractor.setup()
@@ -602,18 +606,21 @@ describe CExtractor do
       CONTENTS
 
       # TODO: Test for function name extraction after implementing generic handling of feature summaries
-      expect { extractor.from_string(content: file_contents, chunk_size: 10, max_buffer_length: 20) }.to raise_error(CeedlingException, /Feature extraction exceeded maximum length/)
+      expect { extractor.from_string(content: file_contents, chunk_size: 10, max_buffer_length: 20) }.to raise_error(CeedlingException, /Extraction exceeded maximum length/)
     end
 
-    it "should fail to extract a signature longer than max length" do
-      file_contents = <<~CONTENTS
-      void a_function(void) {
-        int a = 1 + 1;
-      }
-      CONTENTS
-
-      contents = extractor.from_string(content: file_contents, chunk_size: 10, max_line_length: 10)
-      expect(contents.function_definitions.length ).to eq 0
+    it "should extract a variable declaration longer than 1000 characters" do
+      # A single limit governs every feature type (see extract_next_feature); this confirms a
+      # declaration comfortably longer than the old, now-removed 1000-character inner limit is
+      # captured rather than silently dropped, as long as it's within the (much larger) buffer
+      # ceiling -- the default here, since none is passed explicitly.
+      values = (1..400).map { |n| n.to_s }.join(', ')
+      file_contents = "static const int a_table[] = { #{values} };\n"
+      expect(file_contents.length).to be > 1000
+
+      contents = extractor.from_string(content: file_contents)
+      expect(contents.variable_declarations.length).to eq 1
+      expect(contents.variable_declarations[0].name).to eq 'a_table'
     end
 
     it "should extract typedef definitions and no other features from a typedefs-only input" do

data/spec/units/c_extractor/c_extractor_spec.rb

@@ -21,6 +21,58 @@ require 'stringio'
 ##
 describe CExtractor do
 
+  ###
+  ### setup() / default_max_buffer_length() -- :partials -> :max_extraction_length wiring
+  ###
+  describe "#setup (private method testing)" do
+    # Helper to build a CExtractor with a given configurator double, without wiring the
+    # other collaborators -- default_max_buffer_length only reads @configurator
+    let(:build_extractor) do
+      ->(configurator) do
+        extractor = CExtractor.new(
+          {
+            c_extractor_code_text:     CExtractorCodeText.new,
+            c_extractor_functions:     CExtractorFunctions.new({ c_extractor_code_text: CExtractorCodeText.new }),
+            c_extractor_declarations:  CExtractorDeclarations.new({ c_extractor_code_text: CExtractorCodeText.new }),
+            c_extractor_preprocessing: CExtractorPreprocessing.new({ c_extractor_code_text: CExtractorCodeText.new }),
+            c_extractor_definitions:   CExtractorDefinitions.new({ c_extractor_code_text: CExtractorCodeText.new }),
+            configurator:              configurator,
+            loginator:                 double('Loginator').as_null_object
+          }
+        )
+        extractor.setup()
+        extractor
+      end
+    end
+
+    it "scales :partials_max_extraction_length by 1000 when the configurator provides it" do
+      configurator = double('Configurator', partials_max_extraction_length: 7)
+      extractor = build_extractor.call(configurator)
+
+      expect(extractor.send(:default_max_buffer_length)).to eq(7000)
+    end
+
+    it "falls back to the built-in default when the configurator doesn't provide it" do
+      # A bare double with no stub -- #respond_to? is false, exactly like direct/test
+      # construction of this class where no real project configuration is available.
+      configurator = double('Configurator')
+      extractor = build_extractor.call(configurator)
+
+      expect(extractor.send(:default_max_buffer_length)).to eq(CExtractorConstants::DEFAULT_MAX_FUNCTION_LENGTH)
+    end
+
+    it "setup() itself assigns @max_buffer_length from default_max_buffer_length" do
+      configurator = double('Configurator', partials_max_extraction_length: 3)
+      extractor = build_extractor.call(configurator)
+
+      # @max_buffer_length has no reader; drive behavior through from_string, which raises
+      # once the buffer set up by setup() is exceeded.
+      expect {
+        extractor.from_string(content: ('x' * 3001), chunk_size: 500)
+      }.to raise_error(CeedlingException, /exceeded maximum length of 3000 characters/)
+    end
+  end
+
   ###
   ### extract_next_feature()
   ###
@@ -55,7 +107,11 @@ describe CExtractor do
             c_extractor_functions:    functions,
             c_extractor_declarations: declarations,
             c_extractor_preprocessing: preprocessing,
-            c_extractor_definitions:  definitions
+            c_extractor_definitions:  definitions,
+            # Bare double (no :partials_max_extraction_length stub) so #respond_to? is
+            # false and CExtractor falls back to its own built-in default buffer length.
+            configurator:             double('Configurator'),
+            loginator:                double('Loginator').as_null_object
           }
         )
         extractor.setup()

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/configurator_spec.rb

@@ -9,6 +9,7 @@ require 'spec_helper'
 require 'ceedling/config/configurator'
 require 'ceedling/ruby_expandinator'
 require 'ceedling/exceptions'
+require 'ceedling/constants'
 
 describe Configurator do
 
@@ -184,4 +185,48 @@ describe Configurator do
 
   end
 
+  describe "#set_partials_derived_config" do
+
+    def partials_config
+      { project: { use_partials: true }, defines: { test: ['TEST'] }, cmock: {} }
+    end
+
+    it "does nothing when :use_partials is disabled" do
+      config = partials_config
+      config[:project][:use_partials] = false
+
+      @configurator.set_partials_derived_config( config )
+
+      expect( config[:defines][:test] ).to eq( ['TEST'] )
+      expect( config[:defines] ).to_not have_key( :preprocess )
+    end
+
+    it "appends the partials prefix symbol to a simple :test: defines list" do
+      config = partials_config
+
+      @configurator.set_partials_derived_config( config )
+
+      expect( config[:defines][:test] ).to include( "CEEDLING_PARTIALS_PREFIX=#{PARTIAL_FILENAME_PREFIX}" )
+    end
+
+    it "leaves :preprocess: defines untouched when the project does not define that section" do
+      config = partials_config
+
+      @configurator.set_partials_derived_config( config )
+
+      expect( config[:defines] ).to_not have_key( :preprocess )
+    end
+
+    it "appends the partials prefix symbol under the :* matcher when the project defines its own :preprocess: matcher hash" do
+      config = partials_config
+      config[:defines][:preprocess] = { 'TestSoilMoisture.c' => ['CEEDLING_DELTA_PROBE'] }
+
+      @configurator.set_partials_derived_config( config )
+
+      expect( config[:defines][:preprocess][:*] ).to include( "CEEDLING_PARTIALS_PREFIX=#{PARTIAL_FILENAME_PREFIX}" )
+      expect( config[:defines][:preprocess]['TestSoilMoisture.c'] ).to eq( ['CEEDLING_DELTA_PROBE'] )
+    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,80 @@ 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 only the typedefs and aggregate definitions, guarded and in element_sequence order, 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;
+      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 macro and a variable sit between the two type-defining statements in
+      # element_sequence; only the typedef and the aggregate belong in the shared
+      # types header, in their original relative order, and neither the macro nor
+      # the variable (which stay behind for generate_header) appear here at all.
+      typedef_stmt   = CExtractorTypes::CStatement.new(text: "typedef uint8_t Byte;", line_num: 1)
+      macro_stmt     = CExtractorTypes::CStatement.new(text: "#define FOO 1", line_num: 2)
+      var_decl       = make_var(name: 'counter', type: 'int', text: 'int counter;', 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, macro_stmt, var_decl, 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
+  end
+
   context "#generate_header (private method)" do
     # Define common StringIO buffer
     let(:buf) { StringIO.new() }
@@ -282,6 +356,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 +452,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 +541,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 +556,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 +666,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