ceedling 1.1.9 → 1.2.0

data/spec/system/parent_directory_reference_spec.rb

@@ -0,0 +1,114 @@
+# =========================================================================
+#   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'
+
+##
+## Parent Directory (..) References
+## =================================
+##
+## Both #include directives and TEST_SOURCE_FILE() are resolved against a test
+## file's own directory, exactly as a real compiler resolves a directory-relative
+## quoted #include -- a query naming ".." to reach a sibling directory must
+## resolve the same way a real filesystem path would, under every preprocessing
+## mode a project can select.
+##
+## Test assets: assets/fixtures/parent_directory_references/
+##   - common/helper.h, common/helper.c: declares/defines helper_value() returning 111
+##   - unit/test_dotdot_include.c: #include "../common/helper.h", asserts 111
+##   - alpha/extra.c: extra_value() returning 222, no corresponding header
+##   - unit/test_dotdot_source.c: TEST_SOURCE_FILE("../alpha/extra.c"), asserts 222
+##
+
+ceedling_system_tests do
+  include_context "a fresh ceedling gem project", "dotdot"
+
+  describe "Deployed as a gem" do
+    def copy_dotdot_include_assets
+      in_project do
+        copy_fixture("parent_directory_references/common/helper.h", 'test/common')
+        copy_fixture("parent_directory_references/common/helper.c", 'test/common')
+        copy_fixture("parent_directory_references/unit/test_dotdot_include.c", 'test/unit')
+      end
+    end
+
+    def copy_dotdot_source_assets
+      in_project do
+        copy_fixture("parent_directory_references/alpha/extra.c", 'test/alpha')
+        copy_fixture("parent_directory_references/unit/test_dotdot_source.c", 'test/unit')
+      end
+    end
+
+    # =========================================================================
+    describe "A test file that #includes a header in a sibling directory via .." do
+    # =========================================================================
+
+      before { copy_dotdot_include_assets }
+
+      it "compiles, links, and passes with preprocessing disabled -- the bare-scan fallback path" do
+        in_project do
+          settings = { :project => { :use_test_preprocessor => :none } }
+          @c.merge_project_yml_for_test(settings)
+
+          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/)
+        end
+      end
+
+      it "compiles, links, and passes with full test preprocessing enabled -- the GCC directives-only path" do
+        in_project do
+          settings = { :project => { :use_test_preprocessor => :all } }
+          @c.merge_project_yml_for_test(settings)
+
+          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/)
+        end
+      end
+
+    end
+
+    # =========================================================================
+    describe "A test file with a TEST_SOURCE_FILE() entry naming a sibling directory via .." do
+    # =========================================================================
+
+      before { copy_dotdot_source_assets }
+
+      it "compiles, links, and passes, resolving the directive against the test file's own directory" do
+        in_project 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/)
+        end
+      end
+
+    end
+
+    # =========================================================================
+    describe "A `ceedling test:` task name containing .." do
+    # =========================================================================
+
+      before { copy_dotdot_include_assets }
+
+      it "fails clearly, naming .. as unsupported rather than a generic file-not-found" do
+        in_project do
+          output = @c.ceedling_build_exec("test:../unit/test_dotdot_include")
+          expect(@c.last_exit_status).to_not eq(0)
+          expect(output).to match(/\.\./)
+          expect(output).to match(/context/i)
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/system/partials_module_disambiguation_spec.rb

@@ -0,0 +1,143 @@
+# =========================================================================
+#   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'
+
+##
+## End-to-end builds for selecting a Partial module when more than one module
+## shares its basename.
+##
+## The project shape is issue #1311's own: one include root, headers namespaced
+## below it, and a source tree mirroring that namespace. Both config modules define
+## a private `adjust` with different arithmetic, so a Partial built from the wrong
+## module still compiles and links. A wrong resolution surfaces as a wrong value,
+## which is the silent failure the issue warns about.
+##
+## Assets: assets/fixtures/same_named_modules/
+##
+
+ceedling_system_tests do
+  include_context "a fresh ceedling gem project", "partial_disambig"
+
+  describe "Deployed as a gem" do
+
+    # One module staged, so its bare name is unambiguous project-wide. This is the
+    # baseline the ambiguous cases are read against.
+    context "with only one of the two same-named modules present" do
+      before do
+        copy_same_named_partial_modules('uart')
+        in_project do
+          copy_fixture("same_named_modules/test/test_uart_config_bare.c", 'test')
+        end
+      end
+
+      it "builds a Partial from a bare module name and reaches that module's own functions" do
+        in_project do
+          output = @c.ceedling_build_exec("test:all")
+
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to match(/TESTED:\s+2/)
+          expect(output).to match(/PASSED:\s+2/)
+          expect(output).to match(/FAILED:\s+0/)
+        end
+      end
+    end
+
+    # Issue #1311's own shape: one test file Partializing two modules that share a
+    # basename, each named by its own directory.
+    context "with both same-named modules Partialized in one test" do
+      before do
+        copy_same_named_partial_modules('uart', 'spi')
+        in_project do
+          copy_fixture("same_named_modules/test/test_both_configs.c", 'test')
+        end
+      end
+
+      it "builds a Partial per module and reaches each module's own functions" do
+        in_project do
+          output = @c.ceedling_build_exec("test:all")
+
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to match(/TESTED:\s+2/)
+          expect(output).to match(/PASSED:\s+2/)
+          expect(output).to match(/FAILED:\s+0/)
+        end
+      end
+
+      # Fallback preprocessing synthesizes each generated Partial's #include from the
+      # module name rather than resolving the real file, so the include carries its
+      # module's directory without sitting under any build root. That directory still
+      # names the module, and dropping it leaves two same-named modules indistinguishable
+      # even though the test named both by directory.
+      it "builds a Partial per module under fallback preprocessing" do
+        in_project 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+2/)
+          expect(output).to match(/PASSED:\s+2/)
+          expect(output).to match(/FAILED:\s+0/)
+        end
+      end
+
+      # The two Partials are distinct files only because each sits in the subdirectory
+      # mirroring its own module. Sharing one directory would mean sharing one filename.
+      it "generates each Partial into its own mirrored subdirectory" do
+        in_project do
+          @c.ceedling_build_exec("test:all")
+
+          partials = Dir.glob('build/test/partials/**/ceedling_partial_config_impl.c')
+
+          expect(partials.length).to eq(2)
+          expect(partials.any? { |path| path.include?('drivers/uart') }).to be true
+          expect(partials.any? { |path| path.include?('drivers/spi') }).to be true
+        end
+      end
+    end
+
+    # Mocking is the other half of the same feature. Two same-named modules each mocked as
+    # a Partial must each get their own mock, which only happens if the two are held apart
+    # by the directory that distinguishes them.
+    context "with both same-named modules mocked as Partials in one test" do
+      before do
+        copy_same_named_partial_modules('uart', 'spi')
+        in_project do
+          copy_fixture("same_named_modules/test/test_both_configs_mocked.c", 'test')
+        end
+      end
+
+      # Both mocks share a filename, so only the directory each #include names tells them
+      # apart. CMock and the runner fold that directory into each mock's guard and
+      # lifecycle function names.
+      it "generates a mock per module and keeps their expectations separate" do
+        in_project 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/)
+        end
+      end
+
+      it "generates each mock into its own mirrored subdirectory" do
+        in_project do
+          @c.ceedling_build_exec("test:all")
+
+          mocks = Dir.glob('build/test/mocks/**/mock_ceedling_partial_config_interface.c')
+
+          expect(mocks.length).to eq(2)
+          expect(mocks.any? { |path| path.include?('drivers/uart') }).to be true
+          expect(mocks.any? { |path| path.include?('drivers/spi') }).to be true
+        end
+      end
+    end
+
+  end
+end

data/spec/system/pinned_thread_count_spec.rb

@@ -0,0 +1,102 @@
+# =========================================================================
+#   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'
+
+# Every other system test either leaves :compile_threads/:test_threads at
+# their default of 1 (fully serial, no real thread pool spun up at all) or
+# relies on :auto (a worker count derived from the host machine's own CPU
+# count, different on every runner). Neither setup ever deterministically
+# exercises Batchinator's real multi-thread path -- a genuine concurrency
+# bug (e.g. a caller forgetting to synchronize shared state under
+# state.lock) could regress without any existing system test ever seeing
+# more than one worker thread active, or seeing a worker count that varies
+# machine to machine.
+#
+# This test pins both thread counts to a small, fixed value greater than
+# one so real parallel compilation and real parallel test execution both
+# happen on every run, everywhere, and asserts on correctness of the
+# result (right pass/fail counts, right modules run) -- not just "the
+# build didn't crash." wondrous_forest is reused as the multi-file fixture
+# since its correct, fully-passing counts are already an established
+# baseline elsewhere (see example_wondrous_forest_spec.rb).
+ceedling_system_tests do
+  before :all do
+    @c = SystemContext.new
+    @c.deploy_gem
+  end
+
+  after :all do
+    @c.done!
+  end
+
+  describe "Parallel work with a small, fixed thread count (wondrous_forest)" do
+    before do
+      @c.with_context do
+        output = @c.ceedling_appcmd_exec("example wondrous_forest")
+        expect(output).to match(/created/)
+
+        Dir.chdir "wondrous_forest" do
+          @c.ceedling_build_exec("clobber")
+        end
+      end
+    end
+
+    it "builds and runs every test correctly with :compile_threads and :test_threads both pinned to 2" do
+      @c.with_context do
+        Dir.chdir "wondrous_forest" do
+          @c.merge_project_yml_for_test({
+            :project => { :compile_threads => 2, :test_threads => 2 }
+          })
+
+          output = @c.ceedling_build_exec("test:all")
+
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to match(/TESTED:\s+71/)
+          expect(output).to match(/PASSED:\s+71/)
+          expect(output).to match(/FAILED:\s+0/)
+        end
+      end
+    end
+
+    it "builds and runs every test correctly with asymmetric small :compile_threads and :test_threads values" do
+      @c.with_context do
+        Dir.chdir "wondrous_forest" do
+          @c.merge_project_yml_for_test({
+            :project => { :compile_threads => 3, :test_threads => 2 }
+          })
+
+          output = @c.ceedling_build_exec("test:all")
+
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to match(/TESTED:\s+71/)
+          expect(output).to match(/PASSED:\s+71/)
+          expect(output).to match(/FAILED:\s+0/)
+        end
+      end
+    end
+
+    it "attributes results to the correct module when testing a pattern subset under pinned threads" do
+      @c.with_context do
+        Dir.chdir "wondrous_forest" do
+          @c.merge_project_yml_for_test({
+            :project => { :compile_threads => 2, :test_threads => 2 }
+          })
+
+          output = @c.ceedling_build_exec("test:pattern[Sensor]")
+
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to match(/PASSED/)
+          expect(output).to match(/FAILED:\s+0/)
+          expect(output).to match(/TemperatureSensor\.out/i)
+          expect(output).to match(/HumiditySensor\.out/i)
+          expect(output).to match(/LightSensor\.out/i)
+        end
+      end
+    end
+  end
+end

data/spec/system/plugin_delta_builds_spec.rb

@@ -0,0 +1,179 @@
+# =========================================================================
+#   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'
+require_relative 'support/gcov_helpers'
+require_relative 'support/valgrind_helpers'
+
+# Gcov/Valgrind/Bullseye all run their own build through the exact same core test
+# pipeline as ordinary `test:` builds, tagged with their own `context:` symbol --
+# see spec/system/delta_builds_spec.rb for the equivalent ordinary-:test coverage
+# this file extends to those plugin contexts specifically. Two gaps closed here:
+#
+# 1. Each pipeline context now gets its own isolated dependency cache file, so a
+#    `test:all` run's own pruning flush no longer evicts a plugin context's cache.
+# 2. A plugin's own swapped-in tool (Gcov's instrumented compiler, Valgrind's
+#    executable wrapper) is resolved before dependency-tracker meta is captured,
+#    so editing that plugin's own tool config actually invalidates its own cache.
+ceedling_system_tests do
+  include GcovHelpers
+
+  before :all do
+    determine_reports_to_test
+    @c = SystemContext.new
+    @c.deploy_gem
+  end
+
+  after :all do
+    @c.done!
+  end
+
+  before { @proj_name = unique_proj_name("plugin_delta") }
+
+  # Every example here builds in a plugin context -- gcov below, valgrind
+  # further down -- which is exactly where the :test flags fallback described
+  # in the shared context would land sanitizer flags unasked.
+  include_context "cannot be sanitized"
+
+  def deploy_gcov_project!
+    @c.ceedling_appcmd_exec("new --local #{@proj_name}")
+
+    Dir.chdir @proj_name do
+      prep_project_yml_for_coverage
+      FileUtils.cp test_asset_path("example_file.h"), 'src/'
+      FileUtils.cp test_asset_path("example_file.c"), 'src/'
+      FileUtils.cp test_asset_path("test_example_file_success.c"), 'test/'
+    end
+  end
+
+  describe "Gcov context: cache isolation and tool-change staleness" do
+    before do
+      @c.with_context { deploy_gcov_project! }
+    end
+
+    it "does not evict the gcov context's cache when an ordinary test:all run happens in between" do
+      @c.with_context do
+        Dir.chdir @proj_name do
+          baseline = @c.ceedling_build_exec("gcov:all")
+          expect(baseline).to_not match(/EXCEPTION/)
+
+          # An ordinary test:all run, sharing nothing on purpose with the gcov
+          # context's own build tree -- before Gap 1, its refresh_dependencies
+          # prune silently evicted gcov's cache entries anyway, since they lived
+          # in the same shared cache file.
+          @c.ceedling_build_exec("test:all")
+
+          rebuild = @c.ceedling_build_exec("gcov:all")
+          expect(rebuild).to_not match(/EXCEPTION/)
+          expect(rebuild).to_not match(/^Compiling /)
+          expect(rebuild).to_not match(/^Linking /)
+        end
+      end
+    end
+
+    it "recompiles and relinks the gcov context when :tools ↳ :gcov_compiler changes, with no source edits" do
+      @c.with_context do
+        Dir.chdir @proj_name do
+          @c.ceedling_build_exec("gcov:all")
+
+          # An inert key Ceedling itself never reads -- isolates the assertion to
+          # the dependency tracker's own meta-hash comparison, not any real
+          # behavior change a different flag or executable might otherwise cause.
+          @c.merge_project_yml_for_test({ :tools => { :gcov_compiler => { :ceedling_delta_probe => true } } })
+
+          rebuild = @c.ceedling_build_exec("gcov:all")
+          expect(rebuild).to_not match(/EXCEPTION/)
+          expect(rebuild).to match(/^Compiling /)
+        end
+      end
+    end
+
+    it "prints the coverage summary on a fully-cached gcov:all re-run" do
+      @c.with_context do
+        Dir.chdir @proj_name do
+          @c.ceedling_build_exec("gcov:all")
+
+          rebuild = @c.ceedling_build_exec("gcov:all")
+          expect(rebuild).to_not match(/^Compiling /)
+          expect(rebuild).to_not match(/^Linking /)
+          expect(rebuild).to match(/GCOV: CODE COVERAGE SUMMARY/i).or match(/Coverage Summary/i)
+        end
+      end
+    end
+
+    it "skips recompiling an untested source left unchanged, but recompiles it once its content changes" do
+      @c.with_context do
+        Dir.chdir @proj_name do
+          add_gcov_option("untested_sources", ":compile")
+          # Untested — no test references this source file.
+          FileUtils.cp test_asset_path("uncovered_example_file.c"), 'src/'
+
+          @c.ceedling_build_exec("gcov:all")
+
+          rebuild = @c.ceedling_build_exec("gcov:all")
+          expect(rebuild).to_not match(/EXCEPTION/)
+          expect(rebuild).to_not match(/Compiling.*uncovered_example_file/)
+
+          probe = read_spec_file('src/uncovered_example_file.c')
+          File.write('src/uncovered_example_file.c', "#{probe}\n// probe\n")
+
+          recompile = @c.ceedling_build_exec("gcov:all")
+          expect(recompile).to match(/Compiling.*uncovered_example_file/)
+        end
+      end
+    end
+  end
+
+  describe "Valgrind context: cache isolation and tool-change staleness" do
+    include_context "requires valgrind"
+
+    before do
+      @c.with_context do
+        @c.ceedling_appcmd_exec("new --local #{@proj_name}")
+
+        Dir.chdir @proj_name do
+          FileUtils.cp feature_asset_path("project.yml"), "project.yml"
+          @c.uncomment_project_yml_option_for_test("- valgrind")
+          FileUtils.cp test_asset_path("example_file.h"), 'src/'
+          FileUtils.cp test_asset_path("example_file.c"), 'src/'
+          FileUtils.cp test_asset_path("test_example_file_success.c"), 'test/'
+        end
+      end
+    end
+
+    it "does not evict the valgrind context's cache when an ordinary test:all run happens in between" do
+      @c.with_context do
+        Dir.chdir @proj_name do
+          @c.ceedling_build_exec("valgrind:all")
+          @c.ceedling_build_exec("test:all")
+
+          rebuild = @c.ceedling_build_exec("valgrind:all")
+          expect(rebuild).to_not match(/EXCEPTION/)
+          expect(rebuild).to_not match(/^Compiling /)
+          expect(rebuild).to_not match(/^Linking /)
+          expect(rebuild).to_not match(/^Running /)
+        end
+      end
+    end
+
+    it "reruns the valgrind context's fixture when :valgrind ↳ :arguments changes, with nothing else changed" do
+      @c.with_context do
+        Dir.chdir @proj_name do
+          @c.ceedling_build_exec("valgrind:all")
+
+          @c.merge_project_yml_for_test({ :valgrind => { :arguments => ["--leak-check=full", "--show-leak-kinds=all", "--track-origins=yes", "--errors-for-leak-kinds=all", "--num-callers=40"] } })
+
+          rebuild = @c.ceedling_build_exec("valgrind:all")
+          expect(rebuild).to_not match(/EXCEPTION/)
+          expect(rebuild).to_not match(/^Compiling /)
+          expect(rebuild).to_not match(/^Linking /)
+          expect(rebuild).to match(/^Running /)
+        end
+      end
+    end
+  end
+end

data/spec/system/preprocessing_encoding_spec.rb

@@ -44,8 +44,8 @@ ceedling_system_tests do
             output = @c.ceedling_build_exec("test:unicoder")
             expect(@c.last_exit_status).to eq(0)
             # Only assert non-fallback when the platform actually supports -fdirectives-only.
-            # Apple clang (macOS) silently ignores the flag and ceedling falls back automatically.
-            expect(output).not_to match(/using fallback method/i) unless output.match(/lacks -fdirectives-only support/i)
+            # Older Apple Clang releases ignore the flag, and Ceedling falls back automatically.
+            expect(output).not_to match(/using fallback method/i) unless /lacks -fdirectives-only support/i.match?(output)
             expect(output).to match(/TESTED:\s+1/)
             expect(output).to match(/PASSED:\s+1/)
             expect(output).to match(/FAILED:\s+0/)
@@ -82,8 +82,8 @@ ceedling_system_tests do
             output = @c.ceedling_build_exec("test:unicoder_partial")
             expect(@c.last_exit_status).to eq(0)
             # Only assert non-fallback when the platform actually supports -fdirectives-only.
-            # Apple clang (macOS) silently ignores the flag and ceedling falls back automatically.
-            expect(output).not_to match(/using fallback method/i) unless output.match(/lacks -fdirectives-only support/i)
+            # Older Apple Clang releases ignore the flag, and Ceedling falls back automatically.
+            expect(output).not_to match(/using fallback method/i) unless /lacks -fdirectives-only support/i.match?(output)
             expect(output).to match(/TESTED:\s+1/)
             expect(output).to match(/PASSED:\s+1/)
             expect(output).to match(/FAILED:\s+0/)
@@ -110,5 +110,88 @@ ceedling_system_tests do
         end
       end
     end
+
+    # Distinct from the multibyte-UTF-8 cases above: those plant *valid*
+    # multi-byte characters (whole, well-formed sequences). This plants an
+    # *incomplete* one -- a lead byte with missing or insufficient
+    # continuation bytes, as if a multi-byte character had been clipped by a
+    # chunk boundary or a truncated copy/paste. Written directly with
+    # File.binwrite (not a checked-in fixture asset) so the malformed bytes
+    # never have to round-trip through a text editor or git's own line-ending
+    # handling -- only ever exist on disk for the life of this test.
+    describe "Test builds with an incomplete (truncated) multi-byte UTF-8 sequence in C source file comments" do
+      before do
+        @c.with_context do
+          Dir.chdir @proj_name do
+            # \xE4\xBD is the first two of three bytes of U+4F60 (你), missing
+            # its final continuation byte. \xE4 alone is a lead byte with no
+            # continuation bytes at all. Both are invalid UTF-8 on their own.
+            File.binwrite('src/truncated_encoding.h', (+<<~HEADER).force_encoding('BINARY'))
+              /* Truncated multi-byte sequence: \xE4\xBD -- missing its final continuation byte */
+              #ifndef TRUNCATED_ENCODING_H
+              #define TRUNCATED_ENCODING_H
+
+              /* Lone lead byte, no continuation at all: \xE4 */
+              int truncated_encoding_greet(void);
+
+              #endif /* TRUNCATED_ENCODING_H */
+            HEADER
+
+            File.binwrite('src/truncated_encoding.c', (+<<~SOURCE).force_encoding('BINARY'))
+              /* Truncated multi-byte sequence in implementation: \xE4\xBD */
+              #include "truncated_encoding.h"
+
+              int truncated_encoding_greet(void)
+              {
+                  return 5; /* \xE4 lone lead byte in a trailing comment */
+              }
+            SOURCE
+
+            File.write('test/test_truncated_encoding.c', <<~TEST)
+              #include "unity.h"
+              #include "mock_truncated_encoding.h"
+
+              void test_truncated_encoding_greet_returns_expected_length(void)
+              {
+                  truncated_encoding_greet_ExpectAndReturn(5);
+                  TEST_ASSERT_EQUAL(5, truncated_encoding_greet());
+              }
+            TEST
+          end
+        end
+      end
+
+      it "tests standard preprocessing with a truncated multi-byte sequence in comments" do
+        @c.with_context do
+          Dir.chdir @proj_name do
+            @c.merge_project_yml_for_test({ :project => { :use_test_preprocessor => :mocks } })
+            output = @c.ceedling_build_exec("test:truncated_encoding")
+            expect(@c.last_exit_status).to eq(0)
+            expect(output).not_to match(/using fallback method/i) unless /lacks -fdirectives-only support/i.match?(output)
+            expect(output).to match(/TESTED:\s+1/)
+            expect(output).to match(/PASSED:\s+1/)
+            expect(output).to match(/FAILED:\s+0/)
+          end
+        end
+      end
+
+      it "tests fallback preprocessing with a truncated multi-byte sequence in comments" do
+        @c.with_context do
+          Dir.chdir @proj_name do
+            settings = {
+              :project    => { :use_test_preprocessor => :mocks },
+              :test_build => { :preprocess_force_fallback => true }
+            }
+            @c.merge_project_yml_for_test(settings)
+            output = @c.ceedling_build_exec("test:truncated_encoding")
+            expect(@c.last_exit_status).to eq(0)
+            expect(output).to match(/using fallback method/i)
+            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