ceedling 1.1.5 → 1.1.6

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_test_runner_spec.rb

@@ -8,6 +8,7 @@
 require 'spec_helper'
 require 'ceedling/generators/generator_test_runner'
 require 'ceedling/parsing_parcels'
+require 'ceedling/includes/includes'
 
 describe GeneratorTestRunner do
   before(:each) do
@@ -141,4 +142,72 @@ describe GeneratorTestRunner do
       )
     end
   end
+
+  # ===========================================================================
+  describe '#generate' do
+  # ===========================================================================
+    # Regression coverage for https://github.com/ThrowTheSwitch/Ceedling/issues/1236:
+    # a system #include with a directory component (e.g. <sys/stat.h>) was rendered
+    # into the generated runner as a bare, unbracketed basename ("stat.h"), losing
+    # both the directory and the user/system distinction, breaking runner compilation.
+    #
+    # @unity_runner_generator is a real UnityTestRunnerGenerator, constructed directly
+    # inside #initialize rather than injected -- swapped out for a double here so these
+    # specs assert on exactly what GeneratorTestRunner itself hands off, independent of
+    # Unity's own generated file formatting.
+    def build_and_capture_includes(includes:, mocks: [])
+      runner = build_runner( test_file_contents: "void test_Thing(void) {}\n" )
+
+      captured = nil
+      fake_generator = double('unity_runner_generator')
+      allow(fake_generator).to receive(:generate) do |*args|
+        captured = args[4]
+      end
+      runner.instance_variable_set(:@unity_runner_generator, fake_generator)
+
+      runner.generate(
+        module_name: 'test_thing',
+        runner_filepath: '/build/test/runners/test_thing_runner.c',
+        mocks: mocks,
+        includes: includes
+      )
+
+      return captured
+    end
+
+    it 'renders a system include with a directory component in angle brackets, directory intact' do
+      captured = build_and_capture_includes( includes: [ SystemInclude.new('sys/stat.h') ] )
+
+      expect( captured ).to eq( ['<sys/stat.h>'] )
+    end
+
+    it 'prefers a reconciled system include\'s include_path over its resolved filepath' do
+      # Mirrors what Includes.reconcile actually produces: filepath is the real,
+      # resolved (possibly absolute) location; include_path is the original,
+      # as-written directive text that must be what's rendered.
+      reconciled = SystemInclude.new('/usr/include/sys/stat.h', include_path: 'sys/stat.h')
+
+      captured = build_and_capture_includes( includes: [ reconciled ] )
+
+      expect( captured ).to eq( ['<sys/stat.h>'] )
+    end
+
+    it 'renders a user include with a directory component down to its bare filename, unchanged from prior behavior' do
+      # Unlike a system header, a project's own directories are exposed to the
+      # compiler as a flat list of -I search paths -- rendering a user include's
+      # own directory component here breaks resolution rather than fixing anything,
+      # so this behavior is intentionally unchanged by the issue #1236 fix.
+      captured = build_and_capture_includes( includes: [ UserInclude.new('sub/header.h') ] )
+
+      expect( captured ).to eq( ['header.h'] )
+    end
+
+    it 'renders a mixed list of system and user includes each in their own correct form' do
+      captured = build_and_capture_includes(
+        includes: [ SystemInclude.new('sys/stat.h'), UserInclude.new('sub/header.h') ]
+      )
+
+      expect( captured ).to eq( ['<sys/stat.h>', 'header.h'] )
+    end
+  end
 end

data/spec/units/partials/partializer_spec.rb

@@ -871,6 +871,75 @@ describe Partializer do
       expect(result).not_to include(UserInclude.new('partial_module.h'))
     end
 
+    # Regression test for #1215: PUBLIC/PRIVATE were once the only mock modes that existed,
+    # so this method's own "does this module have a mock to redirect to" check only ever
+    # listed those two. DEDUCT (MOCK_PARTIAL_ALL_MODULE) was added later without updating
+    # this check, so a module mocked via MOCK_PARTIAL_ALL_MODULE -- e.g. a vendor header
+    # whose only mockable functions are static inline, which requires DEDUCT to select at
+    # all -- was silently never redirected to its mock interface header.
+    it "remaps mockable deduct (ALL_MODULE) partial to interface header" do
+      includes = [UserInclude.new('header1.h'), UserInclude.new('partial_module.h'), UserInclude.new('header2.h')]
+      partials = {
+        'partial_module' => make_partial_config(mocks_type: Partials::DEDUCT)
+      }
+      impl_filename = 'module_impl.h'
+      interface_filename = 'partial_module_interface.h'
+      impl_header = UserInclude.new(impl_filename)
+      interface_header = UserInclude.new(interface_filename)
+
+      allow(@file_path_utils).to receive(:form_partial_implementation_header_filename)
+        .with('module')
+        .and_return(impl_filename)
+
+      allow(@file_path_utils).to receive(:form_partial_interface_header_filename)
+        .with('partial_module')
+        .and_return(interface_filename)
+
+      result = @partializer.remap_implementation_source_includes(
+        name: 'module',
+        includes: includes,
+        partials: partials
+      )
+
+      expect(result).to include(impl_header)
+      expect(result).to include(interface_header)
+      expect(result).to include(UserInclude.new('header1.h'))
+      expect(result).to include(UserInclude.new('header2.h'))
+      expect(result).not_to include(UserInclude.new('partial_module.h'))
+    end
+
+    # Same regression as the DEDUCT case above, for ACCUMULATE (MOCK_PARTIAL_MODULE).
+    it "remaps mockable accumulate partial to interface header" do
+      includes = [UserInclude.new('header1.h'), UserInclude.new('partial_module.h'), UserInclude.new('header2.h')]
+      partials = {
+        'partial_module' => make_partial_config(mocks_type: Partials::ACCUMULATE)
+      }
+      impl_filename = 'module_impl.h'
+      interface_filename = 'partial_module_interface.h'
+      impl_header = UserInclude.new(impl_filename)
+      interface_header = UserInclude.new(interface_filename)
+
+      allow(@file_path_utils).to receive(:form_partial_implementation_header_filename)
+        .with('module')
+        .and_return(impl_filename)
+
+      allow(@file_path_utils).to receive(:form_partial_interface_header_filename)
+        .with('partial_module')
+        .and_return(interface_filename)
+
+      result = @partializer.remap_implementation_source_includes(
+        name: 'module',
+        includes: includes,
+        partials: partials
+      )
+
+      expect(result).to include(impl_header)
+      expect(result).to include(interface_header)
+      expect(result).to include(UserInclude.new('header1.h'))
+      expect(result).to include(UserInclude.new('header2.h'))
+      expect(result).not_to include(UserInclude.new('partial_module.h'))
+    end
+
     it "remaps multiple mockable partials to interface headers" do
       includes = [
         UserInclude.new('header1.h'),

data/spec/units/preprocess/preprocessinator_includes_handler_spec.rb

@@ -339,6 +339,67 @@ RSpec.describe PreprocessinatorIncludesHandler do
   end
 
 
+  # ===========================================================================
+  describe '#extract_bare_includes_from_text' do
+  # ===========================================================================
+
+    let(:filepath) { '/src/module.c' }
+
+    it 'extracts a simple user include' do
+      stub_file_open(filepath, "#include \"foo.h\"\n")
+      result = subject.extract_bare_includes_from_text(filepath: filepath)
+      expect(result.map(&:filename)).to include('foo.h')
+    end
+
+    it 'extracts a system include too, unlike extract_user_includes_from_text' do
+      stub_file_open(filepath, "#include <stdio.h>\n")
+      result = subject.extract_bare_includes_from_text(filepath: filepath)
+      expect(result.map(&:filename)).to include('stdio.h')
+    end
+
+    it 'returns plain Include objects, not UserInclude/SystemInclude' do
+      stub_file_open(filepath, "#include \"foo.h\"\n#include <stdio.h>\n")
+      result = subject.extract_bare_includes_from_text(filepath: filepath)
+      expect(result).to all( be_an_instance_of(Include) )
+    end
+
+    it 'ignores includes inside line comments' do
+      stub_file_open(filepath, "// #include \"commented_out.h\"\n")
+      result = subject.extract_bare_includes_from_text(filepath: filepath)
+      expect(result).to be_empty
+    end
+
+    it 'ignores includes inside block comments' do
+      content = "/* #include \"in_block.h\" */\n#include \"real.h\"\n"
+      stub_file_open(filepath, content)
+      result = subject.extract_bare_includes_from_text(filepath: filepath)
+      expect(result.map(&:filename)).to contain_exactly('real.h')
+    end
+
+    # The defining difference from extract_user_includes_from_text: no conditional
+    # tracking at all -- an #include inside an #ifdef for an undefined macro is
+    # still captured, since this method's whole purpose is to see past a guard
+    # whose condition can't be evaluated without opening another header (issue #1223).
+    it 'captures a conditionally-guarded include regardless of whether the guard could be evaluated true' do
+      content = <<~C
+        #ifdef UNDEFINED_MACRO
+        #include "conditional.h"
+        #endif
+      C
+      stub_file_open(filepath, content)
+      result = subject.extract_bare_includes_from_text(filepath: filepath)
+      expect(result.map(&:filename)).to include('conditional.h')
+    end
+
+    it 'removes a self-referential include matching the file being scanned' do
+      stub_file_open(filepath, "#include \"#{filepath}\"\n#include \"foo.h\"\n")
+      result = subject.extract_bare_includes_from_text(filepath: filepath)
+      expect(result.map(&:filename)).to contain_exactly('foo.h')
+    end
+
+  end
+
+
   # ===========================================================================
   describe '#extract_system_includes_from_text' do
   # ===========================================================================