ceedling 1.1.10 → 1.2.1

data/spec/system/preprocessing_fallback_conditionals_spec.rb

@@ -31,7 +31,7 @@ require 'spec_system_helper'
 ##   :project    => { :use_partials => true }   — triggers source/header partial preprocessing
 ##   :test_build => { :preprocess_force_fallback => true }  — forces text-only fallback
 ##
-## Test assets: assets/tests_with_fallback_conditionals/
+## Test assets: assets/fixtures/tests_with_fallback_conditionals/
 ##   - conditional_module.h: declares ConditionalModule_Init()
 ##   - conditional_module.c: conditionally includes optional_dep.h and
 ##     calls OptionalDep_DoWork() when CONDITIONAL_FEATURE is defined
@@ -39,6 +39,15 @@ require 'spec_system_helper'
 ##   - test_conditionals.c: uses TEST_PARTIAL_ALL_MODULE to pull in the
 ##     partial; conditionally includes mock_optional_dep.h and selects
 ##     test cases based on CONDITIONAL_FEATURE
+##   - conditional_module.c's ConditionalModule_Init() also has a second,
+##     compound-guarded `#if defined(NEVER_DEFINED_FEATURE) && defined(CONDITIONAL_FEATURE)`
+##     call to OptionalDep_DoWork() nested inside the plain `#ifdef
+##     CONDITIONAL_FEATURE` block -- regression coverage for a misparse that
+##     evaluated only the first macro name (always false here, since
+##     NEVER_DEFINED_FEATURE is never defined by any test config) instead of
+##     conservatively treating the whole compound expression as active. The
+##     "with CONDITIONAL_FEATURE" scenario below expects two calls for this
+##     reason, not one.
 ##   - Files contain UTF-8 multi-byte characters in comments to exercise
 ##     encoding safety of the conditional-tracking path
 ##
@@ -113,7 +122,11 @@ ceedling_system_tests do
       # so OptionalDep_DoWork() is included in the partial. The test file's
       # corresponding #ifdef generates the mock. The #ifdef test case runs and
       # passes (ConditionalModule_Init() calls OptionalDep_DoWork() in the
-      # partial; the mock satisfies the expectation).
+      # partial; the mock satisfies the expectation). Two calls, not one: the
+      # nested compound-guarded call must also be conservatively included (see
+      # header comment above) -- a misparse of that compound condition would
+      # leave only one real call, one short of the two expectations, failing
+      # the test via an unmet CMock expectation rather than a raw crash.
       # -----------------------------------------------------------------------
       it "should include active #ifdef block and run #ifdef test case" do
         @c.with_context do
@@ -135,29 +148,10 @@ ceedling_system_tests do
         end
       end
 
-
-      # -----------------------------------------------------------------------
-      # Encoding safety: UTF-8 multi-byte characters in comments near #ifdef
-      # directives in source/header files must not cause encoding errors when
-      # the fallback partial preprocessor processes them.
-      # (The test assets already contain non-ASCII UTF-8 in comments.)
-      # -----------------------------------------------------------------------
-      it "should not raise errors for UTF-8 in comments near #ifdef" do
-        @c.with_context do
-          Dir.chdir @proj_name do
-            settings = {
-              :project    => { :use_partials => true },
-              :test_build => { :preprocess_force_fallback => true }
-            }
-            @c.merge_project_yml_for_test(settings)
-
-            output = @c.ceedling_build_exec("test:conditionals")
-            expect(@c.last_exit_status).to eq(0)
-            expect(output).to match(/using fallback method/i)
-            expect(output).to match(/PASSED:\s+1/)
-          end
-        end
-      end
+      # (The dedicated no-CONDITIONAL_FEATURE + UTF-8-in-comments example was folded
+      # away: the assets already carry non-ASCII UTF-8, so the two examples above
+      # exercise the encoding-safety path already, and preprocessing_encoding_spec
+      # plus the unit encoding tests cover it directly.)
 
     end
 

data/spec/system/preprocessing_parameterized_tests_spec.rb

@@ -161,12 +161,12 @@ ceedling_system_tests do
                        }
             @c.merge_project_yml_for_test(settings)
 
-            output = @c.ceedling_build_exec
+            @c.ceedling_build_exec
             expect(@c.last_exit_status).to eq(0)
 
             runner_path = 'build/test/runners/test_ptc_runner.c'
             expect(File.exist?(runner_path)).to eq(true)
-            runner_contents = File.read(runner_path)
+            runner_contents = read_spec_file(runner_path)
 
             test_name = 'test_should_handle_divisible_by_5_for_parameterized_test_case'
             [25, 125, 5].each do |value|

data/spec/system/rake_release_task_path_disambiguation_spec.rb

@@ -0,0 +1,97 @@
+# =========================================================================
+#   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'
+
+##
+## Rake Release Task Path Disambiguation
+## =======================================
+##
+## The ad hoc `release:compile:<file>` task (lib/ceedling/rakefiles/release/rules_release.rake) hands
+## its file argument straight to FileFinder without ever reducing it to a bare
+## basename first, so it inherits path disambiguation for free from the same
+## PathMatcher every other lookup in the project uses -- no rule-specific handling
+## of its own was needed. These tests confirm that inheritance actually holds: a
+## project with two same-named release sources in different source directories
+## (e.g. src/foo/bar.c and src/baz/bar.c), `release:compile:bar.c` invoked by bare
+## basename resolves to the first candidate by :paths search-path order (src/baz/bar.c,
+## since "baz" sorts ahead of "foo" within :source's single src/** glob), logging an
+## ℹ️ NOTICE naming src/foo/bar.c as passed over, while `release:compile:foo/bar.c` or
+## `release:compile:baz/bar.c` (enough trailing path to identify one of them) compiles
+## exactly that one source to its own correctly mirrored object, logging nothing.
+##
+## `release:assemble:<file>` resolves through the identical FileFinder/PathMatcher
+## path (find_assembly_file rather than find_source_file), so it is not separately
+## exercised here.
+##
+## 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
+##
+
+ceedling_system_tests do
+  include_context "a fresh ceedling gem project", "dup_release_source_name"
+
+  describe "Deployed as a gem" do
+    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')
+      end
+    end
+
+    # =========================================================================
+    describe "A project with two same-named release sources in different source directories" do
+    # =========================================================================
+
+      it "resolves to the first candidate by search-path order when release:compile: is invoked by bare basename, logging a NOTICE naming the other" do
+        in_project do
+          output = @c.ceedling_build_exec("release:compile:bar.c")
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to match(/Multiple files matched/)
+          expect(output).to match(/foo[\/\\]bar\.c/)
+          expect(output).to match(/baz[\/\\]bar\.c/)
+          expect(output).to match(/^Compiling bar\.c/)
+
+          expect(File.exist?('build/release/out/baz/bar.o')).to be true
+          expect(File.exist?('build/release/out/foo/bar.o')).to be false
+        end
+      end
+
+      it "compiles exactly the foo module when disambiguated by path" do
+        in_project do
+          output = @c.ceedling_build_exec("release:compile:foo/bar.c")
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to match(/^Compiling bar\.c/)
+          expect(output).to_not 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 false
+        end
+      end
+
+      it "compiles exactly the baz module when disambiguated by path" do
+        in_project do
+          output = @c.ceedling_build_exec("release:compile:baz/bar.c")
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to match(/^Compiling bar\.c/)
+          expect(output).to_not match(/^Linking /)
+
+          expect(File.exist?('build/release/out/baz/bar.o')).to be true
+          expect(File.exist?('build/release/out/foo/bar.o')).to be false
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/system/rake_test_task_path_disambiguation_spec.rb

@@ -0,0 +1,118 @@
+# =========================================================================
+#   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'
+
+##
+## Rake Test Task Path Disambiguation
+## ===================================
+##
+## A project may have two test files with the same basename in different test
+## directories (e.g. test/unit/test_foo.c and test/integration/test_foo.c). These
+## tests confirm that invoking `test:test_foo.c` (bare name) is a hard error naming
+## both candidates, while invoking `test:unit/test_foo.c` or `test:integration/test_foo.c`
+## (enough trailing path to identify one of them) runs exactly that one test. The same
+## disambiguating path also combines with Ceedling's longstanding convention of invoking
+## a test by its module name alone, no test file prefix required (`test:unit/foo.c`
+## resolving the same as `test:unit/test_foo.c`).
+##
+## Test assets: assets/fixtures/tests_with_duplicate_test_names/
+##   - unit/test_foo.c: one passing test case
+##   - integration/test_foo.c: a different passing test case, same filename
+##
+## A separate test below runs both same-named tests together via test:all, confirming
+## their build-output directories (runners, objects, results) are each mirrored beneath
+## the test's own identity rather than colliding on one flat, basename-keyed path.
+##
+
+ceedling_system_tests do
+  include_context "a fresh ceedling gem project", "dup_test_name"
+
+  describe "Deployed as a gem" do
+
+    # =========================================================================
+    describe "A project with two same-named test files in different directories" do
+    # =========================================================================
+
+      before do
+        in_project do
+          copy_fixture("tests_with_duplicate_test_names/unit/test_foo.c", 'test/unit')
+          copy_fixture("tests_with_duplicate_test_names/integration/test_foo.c", 'test/integration')
+        end
+      end
+
+      it "hard-errors naming both candidates when invoked by bare basename" do
+        in_project do
+          output = @c.ceedling_build_exec("test:test_foo.c")
+          expect(@c.last_exit_status).not_to eq(0)
+          expect(output).to match(/Ambiguous/)
+          expect(output).to match(/unit[\/\\]test_foo\.c/)
+          expect(output).to match(/integration[\/\\]test_foo\.c/)
+        end
+      end
+
+      it "runs exactly the unit test when disambiguated by path" do
+        in_project do
+          output = @c.ceedling_build_exec("test:unit/test_foo.c")
+          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(/test_this_is_the_unit_directory_test_foo/)
+        end
+      end
+
+      it "runs exactly the integration test when disambiguated by path" do
+        in_project do
+          output = @c.ceedling_build_exec("test:integration/test_foo.c")
+          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(/test_this_is_the_integration_directory_test_foo/)
+        end
+      end
+
+      it "runs exactly the unit test when disambiguated by path and invoked by bare module name (no test file prefix)" do
+        in_project do
+          output = @c.ceedling_build_exec("test:unit/foo.c")
+          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(/test_this_is_the_unit_directory_test_foo/)
+        end
+      end
+
+      it "runs exactly the integration test when disambiguated by path and invoked by bare module name (no test file prefix)" do
+        in_project do
+          output = @c.ceedling_build_exec("test:integration/foo.c")
+          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(/test_this_is_the_integration_directory_test_foo/)
+        end
+      end
+
+      it "runs both same-named tests together under test:all, each with its own correctly mirrored build output" 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/)
+          expect(output).to match(/test_this_is_the_unit_directory_test_foo/)
+          expect(output).to match(/test_this_is_the_integration_directory_test_foo/)
+
+          summary = @c.ceedling_build_exec("summary")
+          expect(summary).to match(/TESTED:\s+2/)
+          expect(summary).to match(/PASSED:\s+2/)
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/system/report_and_tooling_plugins_spec.rb

@@ -0,0 +1,327 @@
+# =========================================================================
+#   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 'json'
+require 'rexml/document'
+
+##
+## Reporting and Tooling Plugins in a Real Build
+## =============================================
+##
+## The log factory, the IDE and GTest-like console reports, and the JSON compilation
+## database each run against a real project here. Their unit and integration specs prove
+## what each one makes of its inputs. This spec proves Ceedling hands them those inputs
+## from an actual build, and that what they leave behind is usable.
+##
+## One test file holds a passing, a failing, and an ignored test, so every outcome
+## reaches every report.
+##
+
+ADDER_HEADER_C = <<~C
+  #ifndef ADDER_H
+  #define ADDER_H
+
+  int adder_add(int a, int b);
+
+  #endif // ADDER_H
+C
+
+ADDER_SOURCE_C = <<~C
+  #include "adder.h"
+
+  int adder_add(int a, int b)
+  {
+      return a + b;
+  }
+C
+
+TEST_ADDER_C = <<~C
+  #ifdef TEST
+
+  #include "unity.h"
+  #include "adder.h"
+
+  void setUp(void) {}
+  void tearDown(void) {}
+
+  void test_adder_adds(void)
+  {
+      TEST_ASSERT_EQUAL_INT(5, adder_add(2, 3));
+  }
+
+  void test_adder_fails(void)
+  {
+      TEST_ASSERT_EQUAL_INT(5, adder_add(2, 2));
+  }
+
+  void test_adder_waits(void)
+  {
+      TEST_IGNORE();
+  }
+
+  #endif // TEST
+C
+
+# A test file whose every test is ignored, one with a message and one without
+TEST_ADDER_PENDING_C = <<~C
+  #ifdef TEST
+
+  #include "unity.h"
+  #include "adder.h"
+
+  void setUp(void) {}
+  void tearDown(void) {}
+
+  void test_adder_carries(void)
+  {
+      TEST_IGNORE_MESSAGE("Waiting on a carry flag");
+  }
+
+  void test_adder_overflows(void)
+  {
+      TEST_IGNORE();
+  }
+
+  #endif // TEST
+C
+
+# An inline function makes a header mockable only through a shadow header, which is
+# what sends a source beside it to an isolated copy
+GPIO_HEADER_C = <<~C
+  #ifndef GPIO_H
+  #define GPIO_H
+
+  static inline int gpio_read(int pin) { return pin; }
+
+  #endif // GPIO_H
+C
+
+TOOLING_PLUGINS_READER_HEADER_C = <<~C
+  #ifndef READER_H
+  #define READER_H
+
+  int reader_read(int pin);
+
+  #endif // READER_H
+C
+
+READER_SOURCE_C = <<~C
+  #include "reader.h"
+  #include "gpio.h"
+
+  int reader_read(int pin)
+  {
+      return gpio_read(pin);
+  }
+C
+
+TEST_READER_C = <<~C
+  #ifdef TEST
+
+  #include "unity.h"
+  #include "reader.h"
+  #include "mock_gpio.h"
+
+  void setUp(void) {}
+  void tearDown(void) {}
+
+  void test_reader_reads_through_the_mock(void)
+  {
+      gpio_read_ExpectAndReturn(4, 1);
+      TEST_ASSERT_EQUAL_INT(1, reader_read(4));
+  }
+
+  #endif // TEST
+C
+
+ceedling_system_tests do
+  include_context "a fresh ceedling gem project", "report_plugins"
+
+  describe "Deployed as a gem" do
+
+    before do
+      in_project do
+        File.write('src/adder.h', ADDER_HEADER_C)
+        File.write('src/adder.c', ADDER_SOURCE_C)
+        File.write('test/test_adder.c', TEST_ADDER_C)
+      end
+    end
+
+    # =========================================================================
+    describe "the test suite report log factory" do
+    # =========================================================================
+
+      # The project template already configures all four reports
+      before { in_project { @c.uncomment_project_yml_option_for_test('- report_tests_log_factory') } }
+
+      let(:reports) do
+        %w[tests_report.json junit_tests_report.xml cppunit_tests_report.xml tests_report.html].map do |name|
+          File.join('build', 'artifacts', 'test', name)
+        end
+      end
+
+      it "writes every configured report, each one well formed" do
+        in_project do
+          @c.ceedling_build_exec("test:all")
+
+          json, junit, cppunit, html = reports.map { |report| File.read( report ) }
+
+          expect(JSON.parse( json )['Summary']).to include('total_tests' => 3, 'passed' => 1, 'failures' => 1, 'ignored' => 1)
+          expect(REXML::Document.new( junit ).root.attributes['tests']).to eq('3')
+          expect(REXML::Document.new( cppunit ).root.elements['Statistics/Tests'].text).to eq('3')
+          expect(html).to include('test_adder_fails')
+        end
+      end
+
+      # The summary task builds no tests. It reports from the results the build left.
+      it "writes the reports again from an earlier build's results on `ceedling summary`" do
+        in_project do
+          @c.ceedling_build_exec("test:all")
+          FileUtils.rm_rf( File.join('build', 'artifacts', 'test') )
+
+          @c.ceedling_build_exec("summary")
+
+          expect(reports.select { |report| File.exist?( report ) }).to eq(reports)
+          expect(REXML::Document.new( File.read( reports[1] ) ).root.attributes['tests']).to eq('3')
+        end
+      end
+    end
+
+    # =========================================================================
+    describe "the IDE console report" do
+    # =========================================================================
+
+      before do
+        in_project do
+          @c.comment_project_yml_option_for_test('- report_tests_pretty_stdout')
+          @c.uncomment_project_yml_option_for_test('- report_tests_ide_stdout')
+        end
+      end
+
+      it "lists a failure as an error and an ignored test as a warning, located as GCC locates them" do
+        in_project do
+          output = @c.ceedling_build_exec("test:all")
+
+          expect(output).to match(%r{^test/test_adder\.c:\d+:1: error: test_adder_fails: Expected 5 Was 4$})
+          expect(output).to match(%r{^test/test_adder\.c:\d+:1: warning: test_adder_waits})
+          expect(output).to match(/TESTED:\s+3/)
+        end
+      end
+
+      it "lists a failure as filepath, line, test name, and message in the legacy format" do
+        in_project do
+          @c.merge_project_yml_for_test( :report_tests_ide_stdout => { :format => :legacy } )
+          output = @c.ceedling_build_exec("test:all")
+
+          expect(output).to match(%r{test/test_adder\.c:\d+:test_adder_fails: "Expected 5 Was 4"})
+          expect(output).to match(/TESTED:\s+3/)
+        end
+      end
+    end
+
+    # =========================================================================
+    describe "the GTest-like console report" do
+    # =========================================================================
+
+      before do
+        in_project do
+          @c.comment_project_yml_option_for_test('- report_tests_pretty_stdout')
+          @c.uncomment_project_yml_option_for_test('- report_tests_gtestlike_stdout')
+        end
+      end
+
+      # A Unity ignore reports as a GTest skipped test by default, counted in the run
+      it "frames the run with GTest's header and footer counts, the ignored test skipped" do
+        in_project do
+          output = @c.ceedling_build_exec("test:all")
+
+          expect(output).to include('[==========] Running 3 tests from 1 test suite.')
+          expect(output).to include('[       OK ] test/test_adder.c.test_adder_adds')
+          expect(output).to match(/^test\/test_adder\.c\(\d+\): Skipped$/)
+          expect(output).to include('[  SKIPPED ] test/test_adder.c.test_adder_waits (0 ms)')
+          expect(output).to include("[  PASSED  ] 1 test.\n[  SKIPPED ] 1 test, listed below:\n")
+          expect(output).to include('[  FAILED  ] 1 test, listed below:')
+        end
+      end
+
+      it "gives a test file of only ignored tests its own suite" do
+        in_project do
+          File.write('test/test_adder_pending.c', TEST_ADDER_PENDING_C)
+
+          output = @c.ceedling_build_exec("test:all")
+
+          expect(output).to include('[==========] Running 5 tests from 2 test suites.')
+          expect(output).to include('[----------] 2 tests from test/test_adder_pending.c')
+          expect(output).to match(/^Waiting on a carry flag$/)
+          expect(output).to include('[  SKIPPED ] 3 tests, listed below:')
+        end
+      end
+
+      # The opt-out leaves ignored tests out of the report and its counts
+      it "leaves ignored tests out when configured to" do
+        in_project do
+          @c.merge_project_yml_for_test( :report_tests_gtestlike_stdout => { :ignored_as_skipped => false } )
+
+          output = @c.ceedling_build_exec("test:all")
+
+          expect(output).to include('[==========] Running 2 tests from 1 test suite.')
+          expect(output).not_to include('[ RUN      ] test/test_adder.c.test_adder_waits')
+          expect(output).not_to include('[  SKIPPED ]')
+          expect(output).to include('[  PASSED  ] 1 test.')
+        end
+      end
+    end
+
+    # =========================================================================
+    describe "the JSON compilation database" do
+    # =========================================================================
+
+      let(:database_path) { File.join('build', 'artifacts', 'compile_commands.json') }
+
+      before { in_project { @c.uncomment_project_yml_option_for_test('- compile_commands_json_db') } }
+
+      it "lists each compiled source once, across repeated builds" do
+        in_project do
+          @c.ceedling_build_exec("test:all")
+          FileUtils.touch('src/adder.c')
+          @c.ceedling_build_exec("test:all")
+
+          files = JSON.parse( File.read( database_path ) ).map { |entry| entry['file'] }
+
+          expect(files).to include('src/adder.c', 'test/test_adder.c')
+          expect(files).to eq(files.uniq)
+        end
+      end
+
+      # The compiler ran on a temporary copy, which is gone once the build ends
+      it "names the original source in the command for a source compiled from an isolated copy" do
+        in_project do
+          File.write('src/gpio.h', GPIO_HEADER_C)
+          File.write('src/reader.h', TOOLING_PLUGINS_READER_HEADER_C)
+          File.write('src/reader.c', READER_SOURCE_C)
+          File.write('test/test_reader.c', TEST_READER_C)
+          @c.merge_project_yml_for_test(
+            :project => { :use_mocks => true },
+            :paths   => { :include => ['src/**'] },
+            :cmock   => { :treat_inlines => :include }
+          )
+
+          output = @c.ceedling_build_exec("test:test_reader")
+          expect(output).to match(/Compiling an isolated copy of '.*reader\.c'/)
+
+          entry = JSON.parse( File.read( database_path ) ).find { |compile| compile['file'] == 'src/reader.c' }
+
+          expect(entry['command']).to include('src/reader.c')
+          expect(entry['command'].scan( %r{[\w./\\-]*reader\.c\b} )).to all( eq('src/reader.c') )
+        end
+      end
+    end
+
+  end
+
+end

data/spec/system/ruby_replacement_spec.rb

@@ -85,7 +85,7 @@ ceedling_system_tests do
 
           dump_file = 'dump_defines_enabled.yml'
           @c.ceedling_appcmd_exec("dumpconfig #{dump_file} defines --ruby-replacement")
-          @dump_text = File.exist?(dump_file) ? File.read(dump_file) : ''
+          @dump_text = File.exist?(dump_file) ? read_spec_file(dump_file) : ''
         end
       end
       expect(@c.last_exit_status).to eq(0)