ceedling 1.1.10 → 1.2.0

data/spec/system/bracket_path_handling_spec.rb

@@ -0,0 +1,175 @@
+# =========================================================================
+#   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'
+
+##
+## A Source Path Segment Containing Literal [] Brackets Is Not Dropped (issue #104)
+## ==================================================================================
+##
+## `[`/`]` are legal filename characters (Windows especially -- the original report's
+## own scenario) but Ruby's Dir.glob treats an unescaped `[...]` as character-class
+## glob syntax, so a literal bracket in a real directory name silently failed to match
+## its own glob pattern. This broke not just plugin :load_paths: detection (the
+## original 2016 report) but the whole :paths: family: a source subdirectory named
+## e.g. `[legacy]` was silently dropped from the build entirely -- Dir.glob('src/**')
+## simply never matched it, no error, the file just never got compiled.
+##
+
+EXAMPLE_HEADER_BRACKET_PATH = <<~C
+  #ifndef EXAMPLE_FILE_BRACKET_H
+  #define EXAMPLE_FILE_BRACKET_H
+
+  int example_file_bracket_add(int a, int b);
+
+  #endif
+C
+
+EXAMPLE_SOURCE_BRACKET_PATH = <<~C
+  #include "example_file_bracket.h"
+
+  int example_file_bracket_add(int a, int b)
+  {
+    return a + b;
+  }
+C
+
+TEST_BRACKET_PATH_C = <<~C
+  #include "unity.h"
+  #include "example_file_bracket.h"
+
+  void setUp(void) {}
+  void tearDown(void) {}
+
+  void test_source_under_a_bracket_named_directory_is_compiled(void)
+  {
+    TEST_ASSERT_EQUAL_INT(3, example_file_bracket_add(1, 2));
+  }
+C
+
+# A trivial, dependency-free test -- these two additional scenarios exercise
+# collection/lookup paths (test-file collection, vendor framework collection, test
+# runner lookup) unrelated to source/header collection, so they don't need the
+# example_file_bracket fixtures above.
+TRIVIAL_TEST_C = <<~C
+  #include "unity.h"
+
+  void setUp(void) {}
+  void tearDown(void) {}
+
+  void test_trivial_truth(void)
+  {
+    TEST_ASSERT_EQUAL_INT(1, 1);
+  }
+C
+
+ceedling_system_tests do
+  include_context "a fresh ceedling gem project", "bracket_path"
+
+  describe "Deployed as a gem" do
+    before do
+      in_project do
+        # The default :paths ↳ :source is the recursive `src/**`, so a bracket-named
+        # subdirectory needs no extra configuration. Dir.glob reads '[legacy]' as a
+        # character class, never as a literal directory name.
+        FileUtils.mkdir_p('src/[legacy]')
+        File.write('src/[legacy]/example_file_bracket.h', EXAMPLE_HEADER_BRACKET_PATH)
+        File.write('src/[legacy]/example_file_bracket.c', EXAMPLE_SOURCE_BRACKET_PATH)
+        File.write('test/test_bracket_path.c', TEST_BRACKET_PATH_C)
+      end
+    end
+
+    it "compiles and tests a source file living under a bracket-named directory" do
+      in_project do
+        output = @c.ceedling_build_exec("test:all")
+
+        expect(@c.last_exit_status).to eq(0)
+        expect(output).to_not match(/yielded no directories/)
+        expect(output).to match(/TESTED:\s+1/)
+        expect(output).to match(/PASSED:\s+1/)
+        expect(output).to match(/FAILED:\s+0/)
+      end
+    end
+  end
+
+  ##
+  ## A Test File Itself Living Under a Bracket-Named Directory Is Not Dropped
+  ## ==========================================================================
+  ##
+  ## The default :paths: ↳ :test convention (`+:test/**`) is just as recursive as
+  ## :source/:include, and test-file collection (ConfiguratorBuilder#collect_tests)
+  ## builds its own glob pattern independently of source/header collection -- a
+  ## separate call site that needed its own fix. This also exercises test runner
+  ## lookup (FileFinder#runner_scope_dir), since the runner generated for a test
+  ## under a bracket-named directory is itself mirrored into a bracket-named
+  ## subdirectory of the runners output path and must be found again there.
+  ##
+
+  describe "Deployed as a gem, test file under a bracket-named directory" do
+    before do
+      in_project do
+        FileUtils.mkdir_p('test/[legacy]')
+        File.write('test/[legacy]/test_trivial.c', TRIVIAL_TEST_C)
+      end
+    end
+
+    it "compiles and tests a test file living under a bracket-named directory" do
+      in_project do
+        output = @c.ceedling_build_exec("test:all")
+
+        expect(@c.last_exit_status).to eq(0)
+        expect(output).to_not match(/yielded no directories/)
+        expect(output).to match(/TESTED:\s+1/)
+        expect(output).to match(/PASSED:\s+1/)
+        expect(output).to match(/FAILED:\s+0/)
+      end
+    end
+  end
+
+  ##
+  ## A Project Whose (Absolute) Build Root Falls Under a Bracket-Named Directory
+  ## Is Not Dropped
+  ## ==========================================================================
+  ##
+  ## The original 2016 report's own scenario (a bracket-containing staging/temp
+  ## directory, common on Windows). Every vendor framework path (Unity, and
+  ## CException/CMock when enabled) is rooted at :project ↳ :build_root -- `build`
+  ## by default, which is *relative* and so never embeds the project's own
+  ## directory ancestry in a glob pattern at all (Dir.glob resolves a relative
+  ## pattern against the process's cwd without re-parsing the cwd itself as glob
+  ## syntax). Only an *absolute* :build_root: -- a legitimate, supported setting --
+  ## actually embeds a bracket-containing ancestor into the glob pattern text these
+  ## vendor-collection call sites build, so that's what this scenario configures.
+  ##
+
+  describe "Deployed as a gem, absolute build root under a bracket-named directory" do
+    before do
+      in_project do
+        File.write('test/test_trivial.c', TRIVIAL_TEST_C)
+
+        # Absolute :build_root: under a bracket-named directory -- forces every
+        # vendor framework path (derived from :build_root:) to carry the bracket
+        # literally in the glob pattern text, unlike the default relative 'build'.
+        bracket_build_root = File.expand_path( File.join('[build-staging]', 'build') )
+        @c.merge_project_yml_for_test({ :project => { :build_root => bracket_build_root } })
+      end
+    end
+
+    it "compiles and tests a project whose absolute build root falls under a bracket-named directory" do
+      in_project do
+        output = @c.ceedling_build_exec("test:all")
+
+        expect(@c.last_exit_status).to eq(0)
+        expect(output).to_not match(/yielded no directories/)
+        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

data/spec/system/build_output_mirroring_spec.rb

@@ -0,0 +1,89 @@
+# =========================================================================
+#   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'
+
+##
+## Build Output Mirroring
+## =======================
+##
+## A project may have two source files with the same basename in different
+## configured source directories (e.g. src/foo/bar.c and src/baz/bar.c). Ceedling
+## mirrors each into its own object path rather than flattening both into one
+## shared path keyed only by basename -- collapsing them would leave the reverse
+## object-to-source lookup that drives an actual compile with no path information
+## left to tell them apart, an ambiguity Ceedling hard-errors on rather than
+## silently guessing wrong.
+##
+## These tests confirm both same-named sources compile to distinct, correctly
+## mirrored object paths and link into working binaries: a release build linking
+## both into one executable, and two separate single-module tests each exercising
+## one of the two same-named sources.
+##
+## Test assets: assets/fixtures/sources_with_duplicate_basenames/
+##   - foo/bar.c, foo/bar.h: defines foo_bar_value() returning 111
+##   - baz/bar.c, baz/bar.h: defines baz_bar_value() returning 222
+##   - main.c: release entry point calling both and printing their results
+##   - test_foo_bar.c: #includes "foo/bar.h", asserts foo_bar_value() == 111
+##   - test_baz_bar.c: #includes "baz/bar.h", asserts baz_bar_value() == 222
+##
+
+ceedling_system_tests do
+
+  describe "Deployed as a gem" do
+    include_context "a fresh ceedling gem project", "dup_source_name"
+
+    before do
+      in_project do
+        @c.merge_project_yml_for_test({ :project => { :release_build => true } })
+
+        copy_fixture("sources_with_duplicate_basenames/foo/bar.c", 'src/foo')
+        copy_fixture("sources_with_duplicate_basenames/foo/bar.h", 'src/foo')
+        copy_fixture("sources_with_duplicate_basenames/baz/bar.c", 'src/baz')
+        copy_fixture("sources_with_duplicate_basenames/baz/bar.h", 'src/baz')
+        copy_fixture("sources_with_duplicate_basenames/main.c", 'src')
+        copy_fixture("sources_with_duplicate_basenames/test_foo_bar.c", 'test')
+        copy_fixture("sources_with_duplicate_basenames/test_baz_bar.c", 'test')
+      end
+    end
+
+    # =========================================================================
+    describe "A project with two same-named source files in different source directories" do
+    # =========================================================================
+
+      it "compiles and links both same-named sources into one release binary" do
+        in_project do
+          output = @c.ceedling_build_exec("release")
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to_not match(/Ambiguous/)
+          expect(output).to match(/^Linking /)
+
+          expect(File.exist?('build/release/out/foo/bar.o')).to be true
+          expect(File.exist?('build/release/out/baz/bar.o')).to be true
+
+          binary = Dir.glob('build/artifacts/release/*.out').first
+          run_output = `#{binary}`
+          expect(run_output).to match(/foo_bar_value=111/)
+          expect(run_output).to match(/baz_bar_value=222/)
+        end
+      end
+
+      it "compiles, links, and passes two separate tests each exercising one of the same-named sources" do
+        in_project do
+          output = @c.ceedling_build_exec("test:all")
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to_not match(/Ambiguous/)
+          expect(output).to match(/TESTED:\s+2/)
+          expect(output).to match(/PASSED:\s+2/)
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/system/build_recovery_spec.rb

@@ -0,0 +1,382 @@
+# =========================================================================
+#   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'
+
+##
+## Recovery from a bad build
+## =========================
+##
+## A build can go wrong three ways that Ceedling must recover from on its own: an
+## artifact damaged between runs, a project broken and then repaired, and a build
+## interrupted in flight. In every case the builds that follow must converge on what a
+## clean build produces, and stay there, without a clobber.
+##
+## The cases come from fault-injection stress testing. Each damaged-artifact case left
+## every later build failing before Ceedling learned to track the artifact:
+##
+##   - a cached test result that is truncated or emptied
+##   - a dependency file that names a directory, as a truncated one can
+##   - a test's cached build directives, deleted or emptied
+##   - a generated mock header that is truncated
+##
+## The broken-project and interrupted-build cases never failed, and guard that they stay
+## that way. A broken build must fail the same way every time, never alternating, and
+## the repaired build must match a clean one.
+##
+## The project mocks a header and pulls a source in through TEST_SOURCE_FILE(), so a
+## build directive dropped from a damaged cache shows up as a link failure. The mocked
+## header carries a real inline and sits beside the source including it, under
+## :treat_inlines :include. That source therefore compiles from an isolated copy, so
+## every case also exercises that compile path, and the real inline crashes the test if
+## it is ever reached instead of the mock.
+##
+
+RECOVERY_ADDER_H = <<~C
+  #ifndef ADDER_H
+  #define ADDER_H
+
+  int adder_add(int a, int b);
+
+  #endif // ADDER_H
+C
+
+RECOVERY_ADDER_C = <<~C
+  #include "adder.h"
+  #include "sensor.h"
+
+  // Defined in helper_impl.c, which only TEST_SOURCE_FILE() brings into the test build
+  int helper_offset(void);
+
+  int adder_add(int a, int b)
+  {
+      // Separate statements fix the call order that strict mock ordering checks
+      int bias = sensor_bias();
+      int raw  = sensor_raw();
+      return a + b + bias + raw + helper_offset();
+  }
+C
+
+RECOVERY_SENSOR_H = <<~C
+  #ifndef SENSOR_H
+  #define SENSOR_H
+
+  // Crashes if the real inline ever runs in place of the mock
+  static inline int sensor_raw(void)
+  {
+      volatile int *reg = 0;
+      return *reg;
+  }
+
+  int sensor_bias(void);
+
+  #endif // SENSOR_H
+C
+
+RECOVERY_HELPER_IMPL_C = <<~C
+  int helper_offset(void)
+  {
+      return 0;
+  }
+C
+
+RECOVERY_TEST_ADDER_C = <<~C
+  #include "unity.h"
+  #include "adder.h"
+  #include "mock_sensor.h"
+
+  TEST_SOURCE_FILE("helper_impl.c")
+
+  void setUp(void) {}
+  void tearDown(void) {}
+
+  void test_adds_with_bias(void)
+  {
+      sensor_bias_ExpectAndReturn(1);
+      sensor_raw_ExpectAndReturn(0);
+      TEST_ASSERT_EQUAL_INT(6, adder_add(2, 3));
+  }
+
+  void test_adds_without_bias(void)
+  {
+      sensor_bias_ExpectAndReturn(0);
+      sensor_raw_ExpectAndReturn(0);
+      TEST_ASSERT_EQUAL_INT(5, adder_add(2, 3));
+  }
+C
+
+# Stands in for gcc. On the compile numbered in stall/at it marks the build as in flight
+# and stalls, so a spec can interrupt the build at a known point. Otherwise it is gcc.
+RECOVERY_STALLING_COMPILER_SH = <<~SH
+  #!/bin/sh
+  if [ -f stall/at ]; then
+    count=$(( $(cat stall/count 2>/dev/null || echo 0) + 1 ))
+    echo "$count" > stall/count
+    if [ "$count" -eq "$(cat stall/at)" ]; then
+      touch stall/stalled
+      sleep 300
+    fi
+  fi
+  exec gcc "$@"
+SH
+
+ceedling_system_tests do
+  include_context "a fresh ceedling gem project", "build_recovery"
+
+  describe "Deployed as a gem" do
+
+    before do
+      in_project do
+        File.write('src/adder.h', RECOVERY_ADDER_H)
+        File.write('src/adder.c', RECOVERY_ADDER_C)
+        File.write('src/sensor.h', RECOVERY_SENSOR_H)
+        File.write('src/helper_impl.c', RECOVERY_HELPER_IMPL_C)
+        File.write('test/test_adder.c', RECOVERY_TEST_ADDER_C)
+
+        # Issue #1240's own configuration: everything preprocessed, crashes backtraced,
+        # inline functions mocked
+        @c.merge_project_yml_for_test({
+          :project => { :use_mocks => true, :use_test_preprocessor => :all, :use_backtrace => :simple },
+          :cmock   => { :treat_inlines => :include }
+        })
+      end
+    end
+
+    def expect_green_build
+      output = @c.ceedling_build_exec("test:all")
+
+      expect(@c.last_exit_status).to eq(0), output.to_s
+      expect(output).to match(/TESTED:\s+2/)
+      expect(output).to match(/PASSED:\s+2/)
+    end
+
+    # The one artifact matching `pattern`, so a damage step never silently hits nothing
+    def only_file(pattern)
+      matches = Dir.glob(pattern)
+      expect(matches.length).to eq(1), "expected one match for #{pattern}, found #{matches}"
+      matches.first
+    end
+
+    # Every case below relies on this project taking the isolated-copy compile path
+    it "compiles the source beside its inline-mocked header from an isolated copy" do
+      in_project do
+        output = @c.ceedling_build_exec("test:all")
+
+        expect(@c.last_exit_status).to eq(0), output.to_s
+        expect(output).to match(/Compiling an isolated copy of '.*adder\.c'/)
+      end
+    end
+
+    # =========================================================================
+    describe "a damaged build artifact" do
+    # =========================================================================
+
+      def damage_then_rebuild
+        in_project do
+          expect_green_build
+          yield
+          expect_green_build
+        end
+      end
+
+      it "reruns a test whose cached result was truncated" do
+        damage_then_rebuild do
+          result = only_file('build/test/results/**/test_adder.pass')
+          File.truncate(result, File.size(result) / 2)
+        end
+      end
+
+      it "reruns a test whose cached result was emptied" do
+        damage_then_rebuild do
+          File.truncate(only_file('build/test/results/**/test_adder.pass'), 0)
+        end
+      end
+
+      it "recompiles an object whose dependency file names a directory" do
+        damage_then_rebuild do
+          deps   = only_file('build/test/dependencies/**/adder.d')
+          target = File.read(deps)[/\A(.*?):(?=\s)/, 1]
+          File.write(deps, "#{target}: build/vendor/unity/src/\n")
+        end
+      end
+
+      it "rebuilds a test's build directives when their cache directory was deleted" do
+        damage_then_rebuild do
+          FileUtils.rm_rf(Dir.glob('build/test/preprocess/build_directives/*/'))
+        end
+      end
+
+      # An emptied cache loads as no directives at all, silently dropping helper_impl.c from
+      # the object list. Nothing shows until a code change forces a relink, so this changes
+      # adder.c's code too. Treating the cache as damaged rebuilds the directives instead.
+      it "rebuilds a test's build directives when their cache was emptied" do
+        damage_then_rebuild do
+          File.truncate(only_file('build/test/preprocess/build_directives/**/*_source_files.yml'), 0)
+          File.write('src/adder.c', RECOVERY_ADDER_C.sub('return a + b', "int sum = a + b;\n    return sum"))
+        end
+      end
+
+      it "regenerates a mock whose generated header was truncated" do
+        damage_then_rebuild do
+          header = only_file('build/test/mocks/**/mock_sensor.h')
+          File.truncate(header, File.size(header) / 2)
+        end
+      end
+    end
+
+    # =========================================================================
+    describe "a broken project, then repaired" do
+    # =========================================================================
+
+      # Exit status plus test counts, the outcome a build is judged by
+      def outcome(output)
+        counts = %w[TESTED PASSED FAILED].map { |label| output.to_s[/^#{label}:\s+(\d+)/, 1] }
+        [@c.last_exit_status] + counts
+      end
+
+      # Builds a passing project, breaks it, then builds twice more expecting the same
+      # failing outcome both times. A failure that alternates between runs is its own bug.
+      # `never` names output neither failing build may contain. Restoring the originals
+      # must then build green twice over.
+      def break_then_repair(failure:, never: nil)
+        in_project do
+          expect_green_build
+          originals = Dir.glob('{src,test}/*').select { |path| File.file?(path) }.to_h { |path| [path, File.read(path)] }
+
+          yield
+
+          first  = @c.ceedling_build_exec("test:all")
+          second = @c.ceedling_build_exec("test:all")
+
+          expect(outcome(first).first).to_not eq(0), first.to_s
+          expect(outcome(second)).to eq(outcome(first))
+          expect(second).to match(failure)
+          [first, second].each { |output| expect(output).to_not match(never) } if never
+
+          originals.each { |path, content| File.write(path, content) }
+
+          expect_green_build
+          expect_green_build
+        end
+      end
+
+      it "fails the same way on each build of a source compile error, and recovers once fixed" do
+        break_then_repair(failure: /Test Compiler/) do
+          File.write('src/adder.c', RECOVERY_ADDER_C + "\nthis is not C;\n")
+        end
+      end
+
+      # The include resolves nowhere, which once sent preprocessing on to read output that
+      # was never written (issue #1240). It must fail by naming the header instead.
+      it "fails by naming a missing header on each build, and recovers once fixed" do
+        break_then_repair(failure: /no_such_header\.h/, never: /comment stripping/) do
+          File.write('test/test_adder.c', %(#include "no_such_header.h"\n) + RECOVERY_TEST_ADDER_C)
+        end
+      end
+
+      it "fails the same way on each build of a link error, and recovers once fixed" do
+        break_then_repair(failure: /Test Linker/) do
+          File.write('test/test_adder.c', RECOVERY_TEST_ADDER_C + <<~C)
+
+            int undefined_function(void);
+            void test_links(void) { TEST_ASSERT_EQUAL_INT(0, undefined_function()); }
+          C
+        end
+      end
+
+      # Issue #1240's report: a crashing test, backtraced, alternated between results on
+      # successive builds. Every build must report the same crash.
+      it "reports a crashing test identically on each build, and recovers once fixed" do
+        break_then_repair(failure: /crashed/i) do
+          File.write('test/test_adder.c', RECOVERY_TEST_ADDER_C + <<~C)
+
+            void test_crashes(void) { volatile int *p = 0; *p = 1; }
+          C
+        end
+      end
+    end
+
+    # =========================================================================
+    describe "an interrupted build" do
+    # =========================================================================
+
+      # Signals reach the build through its process group, and the stand-in compiler is a
+      # shell script, so these cases need a POSIX host
+      before do
+        skip "Interrupting a build in flight is only exercised on POSIX hosts" if /mingw|win32/.match?(RUBY_PLATFORM.downcase)
+
+        in_project do
+          File.write('stall_cc.sh', RECOVERY_STALLING_COMPILER_SH)
+          FileUtils.chmod(0755, 'stall_cc.sh')
+          FileUtils.mkdir_p('stall')
+
+          # One compile at a time, so "the Nth compile" names the same object every run
+          @c.merge_project_yml_for_test({
+            :project             => { :compile_threads => 1, :test_threads => 1 },
+            :tools_test_compiler => { :executable => File.expand_path('stall_cc.sh') }
+          })
+        end
+      end
+
+      # Starts a build that stalls inside its Nth compile, signals the whole build while it
+      # is stalled there, and expects the interrupted build to report failure
+      def interrupt_build_at(compile:, signal:)
+        File.write('stall/at', compile.to_s)
+        FileUtils.rm_f(['stall/count', 'stall/stalled'])
+
+        pid = Process.spawn('bundle exec ruby -S ceedling build test:all', pgroup: true, out: File::NULL, err: File::NULL)
+
+        deadline = Time.now + 120
+        until File.exist?('stall/stalled')
+          raise "build finished before reaching compile #{compile}" if Process.waitpid(pid, Process::WNOHANG)
+          raise "build never reached compile #{compile}" if Time.now > deadline
+          sleep 0.1
+        end
+
+        Process.kill(signal, -pid)
+        Process.wait(pid)
+
+        # A signal-killed process reports neither success nor failure, only not success
+        expect($?.success?).to be_falsey
+      ensure
+        FileUtils.rm_f('stall/at')
+      end
+
+      it "recovers from SIGKILL during the first compile of a clean build" do
+        in_project do
+          interrupt_build_at(compile: 1, signal: 'KILL')
+
+          expect_green_build
+          expect_green_build
+        end
+      end
+
+      it "recovers from SIGINT partway through a clean build" do
+        in_project do
+          interrupt_build_at(compile: 3, signal: 'INT')
+
+          expect_green_build
+          expect_green_build
+        end
+      end
+
+      # The rebuild compiles only the changed source, so its first compile is that source
+      it "recovers from SIGKILL while recompiling a changed source" do
+        in_project do
+          expect_green_build
+          File.write('src/adder.c', RECOVERY_ADDER_C.sub('return a + b', "int sum = a + b;\n    return sum"))
+
+          interrupt_build_at(compile: 1, signal: 'KILL')
+
+          expect_green_build
+          expect_green_build
+        end
+      end
+    end
+
+  end
+end