ceedling 1.1.9 → 1.1.10

data/spec/units/generators/generator_partials_spec.rb

@@ -61,6 +61,21 @@ describe GeneratorPartials do
     CExtractorTypes::CModule.new()
   end
 
+  # A StringIO standing in for the generated types header, with the filename lookup stubbed.
+  # Several examples differ only in what they hand generate_types, not in this plumbing.
+  def types_buffer(name, 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(File.join('/path/to/output', header_filename), 'wb')
+      .and_yield(buf)
+
+    buf
+  end
+
   context "#generate_implementation" do
     it "should call generate_header() and generate_source() with correct parameters" do
       # Setup
@@ -131,7 +146,7 @@ describe GeneratorPartials do
         header_includes,
         defns,
         c_module,
-        true
+        include_variables: true, include_guard: nil
       )
 
       # Verify generate_source was called with correct parameters
@@ -208,7 +223,7 @@ describe GeneratorPartials do
         includes,
         decls,
         c_module,
-        false
+        include_variables: false, include_guard: nil
       )
 
       # Verify file path utilities were called
@@ -447,6 +462,104 @@ describe GeneratorPartials do
 
       expect( buf.string ).to include( "struct Point { int x; int y; };\nstruct Color { int r; int g; int b; };\n" )
     end
+    # The spoof and the carried includes are what make this header compile wherever it lands.
+    # Order between them is load-bearing: a carried header can transitively reach the real
+    # module header, so the guard has to be satisfied before any include is processed.
+    it "states the module's own guard before the includes it carries, then the types" do
+      file_contents = <<~CONTENTS
+      #ifndef __CEEDLING_GENERATED_MY_MODULE_TYPES_H__
+      #define __CEEDLING_GENERATED_MY_MODULE_TYPES_H__
+
+      #define MY_MODULE_H
+
+      #include "foundation.h"
+      #include <stdint.h>
+
+      typedef uint8_t Byte;
+
+      #endif // __CEEDLING_GENERATED_MY_MODULE_TYPES_H__
+
+      CONTENTS
+
+      buf = types_buffer( 'my_module', 'my_module_types.h' )
+      typedef_stmt = CExtractorTypes::CStatement.new(text: "typedef uint8_t Byte;", line_num: 1)
+
+      @generator.generate_types(
+        name: 'my_module',
+        c_module: CExtractorTypes::CModule.new(
+          type_definitions: [typedef_stmt],
+          element_sequence: [typedef_stmt]
+        ),
+        output_path: '/path/to/output',
+        includes: [UserInclude.new('foundation.h'), SystemInclude.new('stdint.h')],
+        include_guard: 'MY_MODULE_H'
+      )
+
+      expect( buf.string.strip() ).to eq file_contents.strip()
+    end
+
+    it "states no guard when the module's header has none to spoof" do
+      buf = types_buffer( 'my_module', 'my_module_types.h' )
+      typedef_stmt = CExtractorTypes::CStatement.new(text: "typedef uint8_t Byte;", line_num: 1)
+
+      @generator.generate_types(
+        name: 'my_module',
+        c_module: CExtractorTypes::CModule.new(
+          type_definitions: [typedef_stmt],
+          element_sequence: [typedef_stmt]
+        ),
+        output_path: '/path/to/output',
+        includes: [UserInclude.new('foundation.h')],
+        include_guard: nil
+      )
+
+      expect( buf.string ).to include('#include "foundation.h"')
+      expect( buf.string.scan(/^#define /).length ).to eq(1) # the generated guard alone
+    end
+
+    # The real header's guard also arrives among the extracted macros, since it survives
+    # preprocessing. Stating it deliberately and carrying it too would duplicate it.
+    it "drops the carried copy of the guard it states itself" do
+      buf = types_buffer( 'my_module', 'my_module_types.h' )
+      guard_macro  = CExtractorTypes::CStatement.new(text: "#define MY_MODULE_H", line_num: 1)
+      typedef_stmt = CExtractorTypes::CStatement.new(text: "typedef uint8_t Byte;", line_num: 2)
+
+      @generator.generate_types(
+        name: 'my_module',
+        c_module: CExtractorTypes::CModule.new(
+          type_definitions:  [typedef_stmt],
+          macro_definitions: [guard_macro],
+          element_sequence:  [guard_macro, typedef_stmt]
+        ),
+        output_path: '/path/to/output',
+        include_guard: 'MY_MODULE_H'
+      )
+
+      expect( buf.string.scan(/^#define MY_MODULE_H$/).length ).to eq(1)
+    end
+
+    # A macro whose name merely begins with the guard's, and a guard-named macro that actually
+    # carries a value. Neither is the guard statement.
+    it "keeps a macro whose name only resembles the guard" do
+      buf = types_buffer( 'my_module', 'my_module_types.h' )
+      near_macro   = CExtractorTypes::CStatement.new(text: "#define MY_MODULE_H_LIMIT 8", line_num: 1)
+      valued_macro = CExtractorTypes::CStatement.new(text: "#define MY_MODULE_H 2", line_num: 2)
+      typedef_stmt = CExtractorTypes::CStatement.new(text: "typedef uint8_t Byte;", line_num: 3)
+
+      @generator.generate_types(
+        name: 'my_module',
+        c_module: CExtractorTypes::CModule.new(
+          type_definitions:  [typedef_stmt],
+          macro_definitions: [near_macro, valued_macro],
+          element_sequence:  [near_macro, valued_macro, typedef_stmt]
+        ),
+        output_path: '/path/to/output',
+        include_guard: 'MY_MODULE_H'
+      )
+
+      expect( buf.string ).to include('#define MY_MODULE_H_LIMIT 8')
+      expect( buf.string ).to include('#define MY_MODULE_H 2')
+    end
   end
 
   context "#generate_header (private method)" do
@@ -462,7 +575,7 @@ describe GeneratorPartials do
 
       CONTENTS
 
-      @generator.send(:generate_header, buf, 'foo_bar', [], [], empty_module, false)
+      @generator.send(:generate_header, buf, 'foo_bar', [], [], empty_module, include_variables: false)
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
@@ -483,7 +596,7 @@ describe GeneratorPartials do
         buf,
         'Apples-and-Bananas',
         [UserInclude.new('foo.h'), UserInclude.new('bar.h')],
-        [], empty_module, false
+        [], empty_module, include_variables: false
       )
 
       expect( buf.string.strip() ).to eq file_contents.strip()
@@ -505,7 +618,7 @@ describe GeneratorPartials do
         make_var(name: 'slices_of_bread', type: 'unsigned int', text: 'unsigned int slices_of_bread = 10;'),
         make_var(name: 'crumbs', type: 'char', text: 'char crumbs[10];')
       )
-      @generator.send(:generate_header, buf, 'pb-and-j', [], [], c_module, true)
+      @generator.send(:generate_header, buf, 'pb-and-j', [], [], c_module, include_variables: true)
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
@@ -513,7 +626,7 @@ describe GeneratorPartials 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)
+      @generator.send(:generate_header, buf, 'mymod', [], [], c_module, include_variables: true)
 
       expect(buf.string).to include('extern volatile cmd_t cmd;')
     end
@@ -522,7 +635,7 @@ describe GeneratorPartials 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)
+      @generator.send(:generate_header, buf, 'mymod', [], [], c_module, include_variables: true)
 
       expect(buf.string).to include('extern const uint8_t* const lookup_table;')
     end
@@ -576,7 +689,7 @@ describe GeneratorPartials do
         [UserInclude.new('Eeny.h'), UserInclude.new('Meeny.h')],
         decls,
         c_module,
-        true
+        include_variables: true
       )
 
       expect( buf.string.strip() ).to eq file_contents.strip()
@@ -601,7 +714,7 @@ describe GeneratorPartials do
         make_stmt(text: "struct Point { int x; int y; };")
       )
 
-      @generator.send(:generate_header, buf, 'defs', [], [], c_module, false)
+      @generator.send(:generate_header, buf, 'defs', [], [], c_module, include_variables: false)
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
@@ -629,7 +742,7 @@ describe GeneratorPartials do
         make_stmt(text: "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)", line_num: 3)
       )
 
-      @generator.send(:generate_header, buf, 'regs', [], [], c_module, false)
+      @generator.send(:generate_header, buf, 'regs', [], [], c_module, include_variables: false)
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
@@ -644,7 +757,7 @@ describe GeneratorPartials do
         make_stmt(text: "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)", line_num: 3)
       )
 
-      @generator.send(:generate_header, buf, 'regs', [], [], c_module, false)
+      @generator.send(:generate_header, buf, 'regs', [], [], c_module, include_variables: false)
 
       expect( buf.string ).to include(
         "#define START_ADDRESS 0x00 // don't change this\n" +
@@ -694,7 +807,7 @@ describe GeneratorPartials do
         element_sequence:      [macro_stmt, typedef_stmt, var_decl, aggregate_stmt]
       )
 
-      @generator.send(:generate_header, buf, 'all_statements', [], [], c_module, true)
+      @generator.send(:generate_header, buf, 'all_statements', [], [], c_module, include_variables: true)
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
@@ -718,7 +831,7 @@ describe GeneratorPartials do
         make_stmt(text: "typedef uint8_t Byte;", line_num: 3)
       )
 
-      @generator.send(:generate_header, buf, 'mixed', [], [], c_module, true)
+      @generator.send(:generate_header, buf, 'mixed', [], [], c_module, include_variables: true)
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
@@ -738,7 +851,7 @@ describe GeneratorPartials do
         make_var( name: 'counter', type: 'int', text: 'int counter;', line_num: 2)
       )
 
-      @generator.send(:generate_header, buf, 'interface', [], [], c_module, false)
+      @generator.send(:generate_header, buf, 'interface', [], [], c_module, include_variables: false)
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
@@ -780,7 +893,7 @@ describe GeneratorPartials do
         element_sequence:      [typedef_stmt, foo_raw, var_decl, bar_raw]
       )
 
-      @generator.send(:generate_header, buf, 'interleaved', [], [foo_decl, bar_decl], c_module, true)
+      @generator.send(:generate_header, buf, 'interleaved', [], [foo_decl, bar_decl], c_module, include_variables: true)
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
@@ -792,7 +905,7 @@ describe GeneratorPartials do
       raw = CExtractorTypes::CFunctionDeclaration.new(name: 'exported_func')
       c_module = make_module(raw)
 
-      @generator.send(:generate_header, buf, 'mymod', [], [decl], c_module, false)
+      @generator.send(:generate_header, buf, 'mymod', [], [decl], c_module, include_variables: false)
 
       expect(buf.string).to include('__declspec(dllexport) void exported_func(void);')
     end
@@ -802,7 +915,7 @@ describe GeneratorPartials do
         make_var(name: 'counter', type: 'int', text: 'int counter __attribute__((aligned(16)));')
       )
 
-      @generator.send(:generate_header, buf, 'mymod', [], [], c_module, true)
+      @generator.send(:generate_header, buf, 'mymod', [], [], c_module, include_variables: true)
 
       expect(buf.string).to include('extern int counter;')
       expect(buf.string).not_to include('__attribute__')

data/spec/units/partials/partializer_spec.rb

@@ -23,12 +23,18 @@ describe Partializer do
     @reportinator       = Reportinator.new
     @loginator          = double("Loginator").as_null_object
 
+    # Guard extraction reads the module's own header text through these two.
+    @preprocessinator_reconstructor = double("PreprocessinatorReconstructor")
+    @file_wrapper                   = double("FileWrapper")
+
     @partializer = described_class.new(
       {
         :partializer_helper => @partializer_helper,
         :file_finder        => @file_finder,
         :c_extractor        => @c_extractor,
         :file_path_utils    => @file_path_utils,
+        :preprocessinator_reconstructor => @preprocessinator_reconstructor,
+        :file_wrapper       => @file_wrapper,
         :reportinator       => @reportinator,
         :loginator          => @loginator
       }
@@ -809,6 +815,40 @@ describe Partializer do
   end
 
   context "#remap_implementation_source_includes" do
+    # A module tested and mocked in one test file splits its own content across two generated
+    # headers: the implementation carries the public bodies and the interface declares the
+    # private functions those bodies call. The generated source needs both, so this module's own
+    # interface header belongs in its own include list.
+    it "carries this module's own interface header when it is also mocked" do
+      allow(@file_path_utils).to receive(:form_partial_implementation_header_filename)
+        .with('module').and_return('ceedling_partial_module_impl.h')
+      allow(@file_path_utils).to receive(:form_partial_interface_header_filename)
+        .with('module').and_return('ceedling_partial_module_interface.h')
+
+      result = @partializer.remap_implementation_source_includes(
+        name: 'module',
+        includes: [UserInclude.new('module.h')],
+        partials: { 'module' => make_partial_config(tests_type: :public, mocks_type: :private) }
+      )
+
+      expect( result.map( &:filename ) ).to eq(
+        ['ceedling_partial_module_impl.h', 'ceedling_partial_module_interface.h']
+      )
+    end
+
+    it "carries no interface header for a module that is tested but not mocked" do
+      allow(@file_path_utils).to receive(:form_partial_implementation_header_filename)
+        .with('module').and_return('ceedling_partial_module_impl.h')
+
+      result = @partializer.remap_implementation_source_includes(
+        name: 'module',
+        includes: [UserInclude.new('module.h')],
+        partials: { 'module' => make_partial_config(tests_type: :public) }
+      )
+
+      expect( result.map( &:filename ) ).to eq(['ceedling_partial_module_impl.h'])
+    end
+
     it "returns implementation header when input is empty and no partials" do
       includes = []
       partials = {}
@@ -1214,6 +1254,129 @@ describe Partializer do
   ### extract_module_contents()
   ###
 
+  context "#extract_module_include_guard" do
+    # Read from the original header, not the reconstituted copy: that copy carries a synthetic
+    # guard which #sanitize then strips, so it is not a dependable source for the name to spoof.
+    it "reads a bounded prefix of the module's own header and returns the guard found" do
+      expect(@file_wrapper).to receive(:read)
+        .with('src/Foo.h', Partializer::GUARD_SCAN_BYTES)
+        .and_return("#ifndef FOO_H\n#define FOO_H\n")
+      allow(@preprocessinator_reconstructor).to receive(:extract_include_guard)
+        .with("#ifndef FOO_H\n#define FOO_H\n")
+        .and_return('FOO_H')
+
+      expect( @partializer.extract_module_include_guard('src/Foo.h') ).to eq('FOO_H')
+    end
+
+    # A `#pragma once` header offers no macro any generated file could define, which is what a
+    # nil return means to every caller.
+    it "returns nil when the header carries no guard macro" do
+      allow(@file_wrapper).to receive(:read).and_return("#pragma once\n")
+      allow(@preprocessinator_reconstructor).to receive(:extract_include_guard).and_return(nil)
+
+      expect( @partializer.extract_module_include_guard('src/Foo.h') ).to be_nil
+    end
+
+    it "returns nil for an absent filepath without reading anything" do
+      expect(@file_wrapper).not_to receive(:read)
+
+      expect( @partializer.extract_module_include_guard(nil) ).to be_nil
+    end
+  end
+
+  context "#remap_types_header_includes" do
+    # Nothing replaces this module's own header here. The types header cannot include itself, so
+    # its own entry is simply dropped.
+    it "drops the module's own header without substituting anything" do
+      result = @partializer.remap_types_header_includes(
+        name: 'module',
+        includes: [UserInclude.new('module.h'), UserInclude.new('foundation.h')],
+        partials: {}
+      )
+
+      expect( result ).to eq([UserInclude.new('foundation.h')])
+    end
+
+    it "keeps every other include in its original relative order" do
+      result = @partializer.remap_types_header_includes(
+        name: 'module',
+        includes: [UserInclude.new('first.h'), UserInclude.new('module.h'), UserInclude.new('last.h')],
+        partials: {}
+      )
+
+      expect( result.map( &:filename ) ).to eq(['first.h', 'last.h'])
+    end
+
+    # Another partialized module's real header would reintroduce exactly the content that
+    # module's own Partial replaced, so a mocked one is redirected to its generated interface
+    # header and an unmocked one is dropped.
+    it "redirects a mocked partialized dependency to its interface header" do
+      allow(@file_path_utils).to receive(:form_partial_interface_header_filename)
+        .with('other')
+        .and_return('ceedling_partial_other_interface.h')
+
+      result = @partializer.remap_types_header_includes(
+        name: 'module',
+        includes: [UserInclude.new('module.h'), UserInclude.new('other.h')],
+        partials: { 'other' => make_partial_config(mocks_type: :public) }
+      )
+
+      expect( result.map( &:filename ) ).to eq(['ceedling_partial_other_interface.h'])
+    end
+
+    it "drops a partialized dependency that is not mocked" do
+      result = @partializer.remap_types_header_includes(
+        name: 'module',
+        includes: [UserInclude.new('module.h'), UserInclude.new('other.h')],
+        partials: { 'other' => make_partial_config(tests_type: :public) }
+      )
+
+      expect( result ).to be_empty
+    end
+
+    # Comparing a module name to an include means comparing names. A header whose basename
+    # merely extends the module's is a different file.
+    it "leaves a header whose name only extends a partialized module's name" do
+      result = @partializer.remap_types_header_includes(
+        name: 'module',
+        includes: [UserInclude.new('module.h'), UserInclude.new('other_extra.h'), UserInclude.new('other.h')],
+        partials: { 'other' => make_partial_config(tests_type: :public) }
+      )
+
+      expect( result.map( &:filename ) ).to eq(['other_extra.h'])
+    end
+
+    # The interface header includes the types header, so carrying it back into the types header
+    # would fold that file's function declarations into this one.
+    it "never carries this module's own interface header, even when it is also mocked" do
+      allow(@file_path_utils).to receive(:form_partial_interface_header_filename)
+        .and_return('ceedling_partial_module_interface.h')
+
+      result = @partializer.remap_types_header_includes(
+        name: 'module',
+        includes: [UserInclude.new('module.h'), UserInclude.new('foundation.h')],
+        partials: { 'module' => make_partial_config(tests_type: :public, mocks_type: :private) }
+      )
+
+      expect( result.map( &:filename ) ).to eq(['foundation.h'])
+    end
+
+    it "logs the carried list under its own noun when a test is named" do
+      expect(@loginator).to receive(:log_list).with(
+        anything,
+        'Dependency includes to carry into the shared types header for Partial a_test::module:',
+        Verbosity::OBNOXIOUS
+      )
+
+      @partializer.remap_types_header_includes(
+        name: 'module',
+        includes: [UserInclude.new('foundation.h')],
+        partials: {},
+        test: 'a_test'
+      )
+    end
+  end
+
   context "#extract_module_contents" do
     before(:each) do
       @name = 'TestModule'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ceedling
 version: !ruby/object:Gem::Version
-  version: 1.1.9
+  version: 1.1.10
 platform: ruby
 authors:
 - Mark VanderVoord
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-20 00:00:00.000000000 Z
+date: 2026-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -945,6 +945,7 @@ files:
 - spec/system/example_wondrous_forest_spec.rb
 - spec/system/gcov_deployment_spec.rb
 - spec/system/mixin_ordering_spec.rb
+- spec/system/partials_types_header_spec.rb
 - spec/system/preprocessing_encoding_spec.rb
 - spec/system/preprocessing_fallback_conditionals_spec.rb
 - spec/system/preprocessing_locale_spec.rb
@@ -1799,6 +1800,7 @@ test_files:
 - spec/system/example_wondrous_forest_spec.rb
 - spec/system/gcov_deployment_spec.rb
 - spec/system/mixin_ordering_spec.rb
+- spec/system/partials_types_header_spec.rb
 - spec/system/preprocessing_encoding_spec.rb
 - spec/system/preprocessing_fallback_conditionals_spec.rb
 - spec/system/preprocessing_locale_spec.rb