ceedling 1.1.4 → 1.1.6

data/lib/ceedling/preprocess/preprocessinator_includes_handler.rb

@@ -115,6 +115,39 @@ class PreprocessinatorIncludesHandler
     return includes
   end
 
+  # Scan the original file's own text for every #include line, unconditionally --
+  # no #if/#ifdef tracking at all, just literal presence. Supplements the gcc-based
+  # bare pass (`extract_bare_includes`), which runs against an isolated, sibling-free
+  # copy of the file and so can never open another header to resolve a conditional
+  # that depends on a macro that header defines (e.g. `#if SOME_MACRO_FROM_ANOTHER_HEADER`)
+  # -- GCC treats the macro as undefined there and silently drops the #include line
+  # from that pass's output even though it's a perfectly ordinary, real, top-level
+  # #include once actually evaluated with the real file in place. This method's result
+  # is meant to be unioned with the gcc-based bare pass's own result (see
+  # Preprocessinator#preprocess_file_includes_common), not used on its own -- an
+  # `Includes.reconcile` call downstream still only keeps an entry here if the
+  # accurate directives-only pass also reports it, so unconditionally capturing every
+  # literal #include line (regardless of whether its own guard is really true) is
+  # safe: it can only ever let back in an entry the accurate pass already confirmed,
+  # never introduce a spurious one on its own. A supplement, not a replacement --
+  # the gcc pass can still do something this literal scan structurally can't: resolve
+  # an #include whose own target is a macro rather than a literal filename.
+  def extract_bare_includes_from_text(filepath:)
+    includes = []
+
+    # Open in binary mode: code_lines applies clean_encoding per-line, but each_line
+    # itself can raise on invalid byte sequences before clean_encoding is reached.
+    @file_wrapper.open(filepath, 'rb') do |input|
+      @parsing_parcels.code_lines( input ) do |line|
+        _include = @include_factory.user_include_from_directive( line ) ||
+                   @include_factory.system_include_from_directive( line )
+        includes << Include.new( _include.filepath ) if !_include.nil?
+      end
+    end
+
+    return clean_self_reference( filepath, includes )
+  end
+
   def extract_user_includes_preprocess(name:, filepath:, preprocessed_filepath:)
     includes = []
 

data/lib/ceedling/test_invoker/test_build_executor.rb

@@ -187,7 +187,9 @@ class TestBuildExecutor
       # their own includes lists), so a module tested and mocked in the same test file gets
       # exactly one C definition of each of its typedefs and aggregate types.
       types_header = @generator.generate_partial_types(
-        name:        name,
+        name:        config.module, # Module name, not test name -- two modules Partialed
+                                     # in the same test file must not collide on one
+                                     # shared types header filename
         c_module:    module_contents,
         output_path: testable.paths[:partials]
       )

data/lib/version.rb

@@ -15,7 +15,7 @@
 module Ceedling
   module Version
     # Convenience constants for gem building, etc.
-    GEM = '1.1.4'
+    GEM = '1.1.6'
     TAG = GEM
 
     # If run as a script print Ceedling's version to $stdout

data/site-local/configuration/reference/partials.html

@@ -4162,22 +4162,23 @@
 <a id="__codelineno-0-4" name="__codelineno-0-4" href="#__codelineno-0-4"></a><span class="w">  </span><span class="nt">:max_extraction_length</span><span class="p">:</span><span class="w"> </span><span class="l l-Scalar l-Scalar-Plain">8000</span>
 </code></pre></div>
 <h2 id="max_extraction_length"><code>:max_extraction_length</code></h2>
-<p>Notes:
-- The default should be sufficient for nearly all test builds. Modification should only be necessary on error.
-- This configuration option is only available in Ceedling 1.1.4+.</p>
+<p>Notes:</p>
+<ul>
+<li>The default should be sufficient for nearly all test builds. Modification should only be necessary on error.</li>
+<li>This configuration option is only available in Ceedling 1.1.4+.</li>
+</ul>
 <p>Building a Partial requires Ceedling to extract each C construct — a
 variable declaration, a function, a macro, and so on — from your source
 files one at a time. Extraction reads a construct into a growing buffer
-until it finds that construct's natural end (a terminating <code>;</code>, a closing
+until it finds that construct’s natural end (a terminating <code>;</code>, a closing
 <code>}</code>, etc.). This setting bounds how large that buffer may grow before
-extraction fails outright, rather than continuing to search indefinitely
-into whatever else follows in the file.</p>
-<p>The value is a multiplier of 1000 characters, not a raw character count —
-<code>8000</code> means 8,000,000 characters. It must be a whole number no smaller
+extraction fails outright.</p>
+<p>The value is a multiplier of 1000 characters, not a raw character count. For example,
+<code>8000</code> means 8,000,000 characters (approx. 7.6MB). It must be a whole number no smaller
 than <code>10</code> (10,000 characters).</p>
 <p>Raise this value if Ceedling reports an extraction failure for a
-legitimately large single construct in your codebase — a sizable generated
-lookup table, for instance. There's ordinarily no reason to lower it.</p>
+legitimately large single construct in your codebase (e.g. a sizable
+lookup table). Ordinarily, there’s no reason to lower it.</p>
 <p><strong>Default</strong>: 5000 (5,000,000 characters)</p>
 <p><br/><br/></p>
 

data/spec/support/system/spec_system_helper.rb

@@ -150,6 +150,17 @@ def test_asset_path(asset_file_name)
   File.join(File.dirname(__FILE__), '..', '..', '..', 'assets', asset_file_name)
 end
 
+# `ceedling new`/`upgrade` only populates a project's docs/ceedling/ by copying this
+# repo's own site-local/ -- the local mkdocs HTML bundle, built only by `rake
+# docs:build:local` (see bin/cli_helper.rb's own identical check). That's a step CI
+# runs in a dedicated job before the test suite, but a plain local `bundle install &&
+# rspec` never runs at all, so docs/ceedling/ is legitimately absent there. Tests
+# asserting a deployed project's doc contents check this first rather than hardcoding
+# an assumption that only ever holds in CI's own environment (issue #1216).
+def html_docs_bundle_available?
+  Dir.exist?(File.join(File.dirname(__FILE__), '..', '..', '..', 'site-local'))
+end
+
 def unique_proj_name(prefix)
   safe = RSpec.current_example.description
     .downcase

data/spec/support/system/system_context.rb

@@ -6,6 +6,7 @@
 # =========================================================================
 
 require 'fileutils'
+require 'bundler'
 require 'ceedling/encodinator'
 require_relative 'gem_dir_layout'
 
@@ -44,16 +45,26 @@ class SystemContext
     )
 
     Dir.chdir(shared_dir) do
-      saved = ENV.to_hash
       begin
-        %w{BUNDLE_GEMFILE BUNDLE_BIN_PATH RUBYOPT}.each { |k| ENV.delete(k) }
-        deploy_output  = `bundle config set --local path '#{shared_gem.install_dir}' 2>&1`
-        # --prefer-local: Without it, Bundler resolves gems (e.g. `erb`) fresh from
-        # rubygems repository even when Ruby's default-gem copy satisfies the Gemfile constraint.
-        deploy_output += `bundle install --prefer-local 2>&1`
+        # Bundler.with_unbundled_env restores the pre-`bundle exec` environment for this
+        # block -- clearing not just BUNDLE_GEMFILE/BUNDLE_BIN_PATH/RUBYOPT (the previous,
+        # incomplete hand-rolled list here) but also GEM_HOME/GEM_PATH/RUBYLIB/PATH and every
+        # other var Bundler sets when this spec suite itself runs under `bundle exec` against
+        # a non-default GEM_HOME (e.g. `bundle install --path vendor/bundle`). Any one of
+        # those left in place is enough on its own for the `bundle exec ruby -S ceedling
+        # version` verification below to load the *outer* project's bundler/gems instead of
+        # this shared gem's own `--local path` install, and fail to find this Gemfile's exact
+        # pinned versions there.
+        deploy_output = Bundler.with_unbundled_env do
+          output  = `bundle config set --local path '#{shared_gem.install_dir}' 2>&1`
+          # --prefer-local: Without it, Bundler resolves gems (e.g. `erb`) fresh from
+          # rubygems repository even when Ruby's default-gem copy satisfies the Gemfile constraint.
+          output += `bundle install --prefer-local 2>&1`
+          output
+        end
         raise VerificationFailed, "bundle install failed:\n#{deploy_output}" unless $?.success?
 
-        verify = `bundle exec ruby -S ceedling version 2>&1`
+        verify = Bundler.with_unbundled_env { `bundle exec ruby -S ceedling version 2>&1` }
         unless $?.success?
           raise VerificationFailed,
             "Ceedling does not appear to be installed or ready for use.\n" \
@@ -62,8 +73,6 @@ class SystemContext
       rescue
         FileUtils.rm_rf(shared_dir)
         raise
-      ensure
-        ENV.replace(saved)
       end
     end
 

data/spec/system/conditional_include_macro_visibility_spec.rb

@@ -0,0 +1,152 @@
+# =========================================================================
+#   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_system_helper'
+
+##
+## Conditional-#include Macro-Visibility Tests (directives-only preprocessing)
+## =============================================================================
+##
+## Ceedling discovers a file's #includes via two preprocessor passes reconciled
+## into one list: a "bare" pass and an accurate pass (gcc -E -fdirectives-only
+## against the real file with real search paths -- genuinely opens every
+## header). Reconciliation keeps an accurate-pass entry only if bare also found
+## it, to filter out headers reached only via a deeper, nested path.
+##
+## "Bare" is itself two things unioned together: a gcc -M -MG -MP pass against
+## an isolated, sibling-free copy of the file (so it never actually opens any
+## header the file #includes, but can still resolve an #include whose own
+## target is a macro, since command-line -D defines are visible even in
+## isolation), and a plain literal text scan of the file's own #include lines
+## (no conditional evaluation at all, so it sees past a guard the isolated gcc
+## pass can't evaluate -- but also can't resolve a macro-computed #include
+## target, since there's no literal filename in the source text to find).
+## Neither replaces the other; each catches what the other structurally can't.
+##
+## These tests characterize that reconciliation's behavior for #include
+## directives guarded by an #if/#ifdef, across the different places the
+## guarding macro can come from -- some already handled correctly, one
+## (issue #1223) fixed by adding the text-scan half of "bare" above.
+##
+## Test assets: assets/tests_with_conditional_includes/
+##   - widget.c/.h: three scenarios that already work correctly:
+##     (a) conditional include gated on a project :defines macro
+##     (b) conditional include gated on a same-file #define
+##     (c) a header reached only transitively (nested_wrapper.h's own
+##         #include, never itself directly #include'd by widget.c) --
+##         must not appear duplicated in as a false top-level entry
+##   - widget_feature.c/.h + feature_config.h + feature_extra.h: issue #1223
+##     itself -- a conditional include gated on a macro defined by an
+##     *earlier #include in the same file* (feature_config.h's FEATURE_LEVEL),
+##     which the isolated bare pass can never see, silently dropping
+##     feature_extra.h and leaving FEATURE_EXTRA_MACRO undeclared.
+##
+
+ceedling_system_tests do
+
+  before :all do
+    @c = SystemContext.new
+    @c.deploy_gem
+  end
+
+  after :all do
+    @c.done!
+  end
+
+  before { @proj_name = unique_proj_name("cond_inc") }
+
+  describe "Deployed as a gem" do
+    before do
+      @c.with_context do
+        @c.ceedling_appcmd_exec("new #{@proj_name}")
+      end
+    end
+
+    # =========================================================================
+    describe "Conditional includes that already resolve correctly today" do
+    # =========================================================================
+
+      before do
+        @c.with_context do
+          Dir.chdir @proj_name do
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/src/widget.h"), 'src/'
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/src/widget.c"), 'src/'
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/src/project_flag_extra.h"), 'src/'
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/src/local_flag_extra.h"), 'src/'
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/src/nested_wrapper.h"), 'src/'
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/src/nested_extra.h"), 'src/'
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/test/test_widget.c"), 'test/'
+
+            settings = {
+              :project => { :use_partials => true },
+              :defines => { :test => ['PROJECT_FLAG'] }
+            }
+            @c.merge_project_yml_for_test(settings)
+          end
+        end
+      end
+
+      it "resolves a project-:defines-gated include, a same-file-#define-gated include, and correctly excludes a transitively-nested header from duplication" do
+        @c.with_context do
+          Dir.chdir @proj_name do
+            output = @c.ceedling_build_exec("test:widget")
+            expect(@c.last_exit_status).to eq(0)
+            expect(output).to match(/TESTED:\s+3/)
+            expect(output).to match(/PASSED:\s+3/)
+            expect(output).to match(/FAILED:\s+0/)
+
+            # (c) nested_extra.h is reached only transitively, through
+            # nested_wrapper.h's own #include -- confirm it is not promoted
+            # into a spurious, duplicated top-level #include in the generated
+            # Partial implementation (the exact filtering property the #1223
+            # fix must not break).
+            generated = Dir.glob('build/test/partials/**/*_impl.c').first
+            expect(generated).not_to be_nil
+            contents = File.read(generated)
+            expect(contents.scan(/#include\s+"nested_extra\.h"/).length).to eq(0)
+          end
+        end
+      end
+
+    end
+
+    # =========================================================================
+    describe "Conditional include gated on a macro from an earlier #include in the same file (issue #1223)" do
+    # =========================================================================
+
+      before do
+        @c.with_context do
+          Dir.chdir @proj_name do
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/src/widget_feature.h"), 'src/'
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/src/widget_feature.c"), 'src/'
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/src/feature_config.h"), 'src/'
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/src/feature_extra.h"), 'src/'
+            FileUtils.cp test_asset_path("tests_with_conditional_includes/test/test_widget_feature.c"), 'test/'
+
+            settings = { :project => { :use_partials => true } }
+            @c.merge_project_yml_for_test(settings)
+          end
+        end
+      end
+
+      it "keeps FEATURE_EXTRA_MACRO visible in the generated Partial so the build compiles" do
+        @c.with_context do
+          Dir.chdir @proj_name do
+            output = @c.ceedling_build_exec("test:widget_feature")
+            expect(@c.last_exit_status).to eq(0)
+            expect(output).to match(/TESTED:\s+1/)
+            expect(output).to match(/PASSED:\s+1/)
+            expect(output).to match(/FAILED:\s+0/)
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/system/encoding_stress_spec.rb

@@ -131,8 +131,8 @@ ceedling_system_tests do
           @c.merge_project_yml_for_test({ :test_build => { :preprocess_force_fallback => false } })
           output = @c.ceedling_build_exec("test:all")
           expect(@c.last_exit_status).to eq(0)
-          expect(output).to match(/TESTED:\s+67/)
-          expect(output).to match(/PASSED:\s+67/)
+          expect(output).to match(/TESTED:\s+68/)
+          expect(output).to match(/PASSED:\s+68/)
         end
       end
     end
@@ -144,8 +144,8 @@ ceedling_system_tests do
           @c.merge_project_yml_for_test({ :test_build => { :preprocess_force_fallback => true } })
           output = @c.ceedling_build_exec("test:all")
           expect(@c.last_exit_status).to eq(0)
-          expect(output).to match(/TESTED:\s+67/)
-          expect(output).to match(/PASSED:\s+67/)
+          expect(output).to match(/TESTED:\s+68/)
+          expect(output).to match(/PASSED:\s+68/)
         end
       end
     end

data/spec/system/example_wondrous_forest_spec.rb

@@ -46,8 +46,8 @@ ceedling_system_tests do
         @c.with_context do
           Dir.chdir "wondrous_forest" do
             @output = @c.ceedling_build_exec("test:all")
-            expect(@output).to match(/TESTED:\s+67/)
-            expect(@output).to match(/PASSED:\s+67/)
+            expect(@output).to match(/TESTED:\s+68/)
+            expect(@output).to match(/PASSED:\s+68/)
             expect(@output).to match(/FAILED:\s+0/)
           end
         end

data/spec/system/support/common_test_cases.rb

@@ -114,7 +114,11 @@ module CommonSystemTestCases
     @c.with_context do
       Dir.chdir @proj_name do
         all_docs = Dir["docs/*"]
-        expect(all_docs).to contain_exactly('docs/ceedling', 'docs/unity', 'docs/cmock', 'docs/c_exception', 'docs/license.txt')
+        # docs/ceedling only exists when this repo's own local HTML docs bundle
+        # (site-local/) was available to copy in -- see html_docs_bundle_available?.
+        expected = ['docs/unity', 'docs/cmock', 'docs/c_exception', 'docs/license.txt']
+        expected << 'docs/ceedling' if html_docs_bundle_available?
+        expect(all_docs).to contain_exactly(*expected)
       end
     end
   end

data/spec/system/test_runner_system_include_spec.rb

@@ -0,0 +1,90 @@
+# =========================================================================
+#   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_system_helper'
+
+##
+## Generated Runner Preserves System #include Directory/Brackets (issue #1236)
+## =============================================================================
+##
+## A test file directly #include-ing a system header with a directory component
+## (e.g. `#include <sys/stat.h>`) previously produced a generated runner containing
+## `#include "stat.h"` -- the directory component and the system-include `<>`
+## delimiters were both lost, since GeneratorTestRunner#generate rendered every
+## include (mocks aside) down to its bare basename with no `<>` for system headers.
+## The test file itself compiled fine; only the separately generated runner file
+## failed, with a "No such file or directory" error on the mangled include.
+##
+
+TEST_RUNNER_SYSTEM_INCLUDE_C = <<~C
+  #include <sys/stat.h>
+
+  #include "unity.h"
+
+  void setUp(void) {}
+  void tearDown(void) {}
+
+  void test_runner_preserves_system_include_path(void)
+  {
+    struct stat value;
+    TEST_ASSERT_EQUAL_UINT(sizeof(value), sizeof(struct stat));
+  }
+C
+
+ceedling_system_tests do
+
+  before :all do
+    @c = SystemContext.new
+    @c.deploy_gem
+  end
+
+  after :all do
+    @c.done!
+  end
+
+  before { @proj_name = unique_proj_name("runner_sys_inc") }
+
+  describe "Deployed as a gem" do
+    before do
+      @c.with_context do
+        @c.ceedling_appcmd_exec("new #{@proj_name}")
+      end
+    end
+
+    before do
+      @c.with_context do
+        Dir.chdir @proj_name do
+          File.write('test/test_runner_system_include.c', TEST_RUNNER_SYSTEM_INCLUDE_C)
+        end
+      end
+    end
+
+    it "preserves a system include's directory component and angle brackets in the generated runner" do
+      @c.with_context do
+        Dir.chdir @proj_name do
+          output = @c.ceedling_build_exec("test:all")
+
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to match(/TESTED:\s+1/)
+          expect(output).to match(/PASSED:\s+1/)
+          expect(output).to match(/FAILED:\s+0/)
+
+          # The generated runner is what actually failed to compile in the reported
+          # issue -- assert on its content directly rather than just overall build
+          # success, since only the runner (not the test file itself) was affected.
+          runner_path = Dir.glob('build/test/runners/*_runner.c').first
+          expect(runner_path).not_to be_nil
+
+          runner_contents = File.read(runner_path)
+          expect(runner_contents).to include('#include <sys/stat.h>')
+          expect(runner_contents).not_to include('#include "stat.h"')
+        end
+      end
+    end
+  end
+
+end

data/spec/units/generators/generator_partials_spec.rb

@@ -241,12 +241,13 @@ describe GeneratorPartials do
       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
+    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__
@@ -267,13 +268,15 @@ describe GeneratorPartials do
         .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.
+      # 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)
-      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)
+      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(
@@ -281,7 +284,7 @@ describe GeneratorPartials do
         macro_definitions:     [macro_stmt],
         variable_declarations: [var_decl],
         aggregate_definitions: [aggregate_stmt],
-        element_sequence:      [typedef_stmt, macro_stmt, var_decl, aggregate_stmt]
+        element_sequence:      [typedef_stmt, var_decl, macro_stmt, aggregate_stmt]
       )
 
       result = @generator.generate_types(
@@ -294,6 +297,106 @@ describe GeneratorPartials do
       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