ceedling 1.2.1 → 1.2.2

data/spec/system/header_include_path_validation_spec.rb

@@ -86,8 +86,8 @@ ceedling_system_tests do
           # A mock's location mirrors its real header's resolved path, not whatever path its
           # own #include happened to write, so both tests' mocks land at the identical
           # location -- each #include names the same real header, drivers/foo.h.
-          expect(File.exist?('build/test/mocks/test_bare_mock/drivers/mock_foo.h')).to be true
-          expect(File.exist?('build/test/mocks/test_pathed_mock/drivers/mock_foo.h')).to be true
+          expect(File.exist?('build/test/mocks/test/test_bare_mock/drivers/mock_foo.h')).to be true
+          expect(File.exist?('build/test/mocks/test/test_pathed_mock/drivers/mock_foo.h')).to be true
         end
       end
 
@@ -159,7 +159,7 @@ ceedling_system_tests do
 
           # alt_drivers sorts ahead of drivers within :include's single src/** glob,
           # so the generated mock mirrors alt_drivers/foo.h's own location.
-          expect(File.exist?('build/test/mocks/test_ambiguous_mock/alt_drivers/mock_foo.h')).to be true
+          expect(File.exist?('build/test/mocks/test/test_ambiguous_mock/alt_drivers/mock_foo.h')).to be true
         end
       end
 
@@ -172,7 +172,7 @@ ceedling_system_tests do
           expect(output).to match(/TESTED:\s+1/)
           expect(output).to match(/PASSED:\s+1/)
 
-          expect(File.exist?('build/test/mocks/test_pathed_mock_ambiguous/drivers/mock_foo.h')).to be true
+          expect(File.exist?('build/test/mocks/test/test_pathed_mock_ambiguous/drivers/mock_foo.h')).to be true
         end
       end
 

data/spec/system/launcher_handoff_spec.rb

@@ -0,0 +1,82 @@
+# =========================================================================
+#   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'
+
+##
+## Launcher Hand-off
+## =================
+##
+## GH #1365: a launcher selecting another installation ran that installation's
+## application inside its own process. The gem's launcher now hands a `--local`
+## project's build to the vendored copy's own launcher, in its own process.
+##
+## spec/integration/launcher_handoff_spec.rb covers every command short of a build.
+## These run a real build through a hand-off, on every platform, where Windows
+## emulates the process replacement and must still carry the build's exit status.
+##
+
+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("handoff") }
+
+  # A vendored copy reporting its own version, a test file with one failing test, and
+  # the Windows executable extension the build expects
+  def prepare_vendored_project
+    version_rb = File.join( 'vendor', 'ceedling', 'lib', 'version.rb' )
+    File.write( version_rb, File.read( version_rb ).sub( /BASE = '[^']+'/, "BASE = '9.9.9'" ) )
+
+    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.c"), 'test/'
+
+    @c.remove_project_yml_option_for_test( :extension, :executable ) if /mingw|win32/.match?( RUBY_PLATFORM.downcase )
+  end
+
+  def expect_build_in_vendored_copy(output)
+    expect(@c.last_exit_status).to eq(1), output
+    expect(output).to match(/is handing off to Ceedling 9\.9\.9\S* at /)
+    expect(output).to match(/Ceedling 9\.9\.9\S* at .+ is now running, launched from Ceedling /)
+    expect(output).to match(/TESTED:\s+2/)
+    expect(output).to match(/PASSED:\s+1/)
+    expect(output).to match(/FAILED:\s+1/)
+  end
+
+  describe "A `--local` project run by the gem" do
+    before { @c.with_context { @c.ceedling_appcmd_exec("new --local #{@proj_name}") } }
+
+    it "builds in the vendored copy its :which_ceedling selects and exits with the build's status" do
+      @c.with_context do
+        Dir.chdir @proj_name do
+          prepare_vendored_project()
+
+          expect_build_in_vendored_copy( @c.ceedling_build_exec("test:all") )
+        end
+      end
+    end
+
+    it "builds in the vendored copy WHICH_CEEDLING selects over the project's own setting" do
+      @c.with_context do
+        Dir.chdir @proj_name do
+          prepare_vendored_project()
+          @c.merge_project_yml_for_test( {:project => {:which_ceedling => 'gem'}} )
+          ENV['WHICH_CEEDLING'] = 'vendor/ceedling'
+
+          expect_build_in_vendored_copy( @c.ceedling_build_exec("test:all") )
+        end
+      end
+    end
+  end
+end

data/spec/system/mock_include_folders_spec.rb

@@ -0,0 +1,91 @@
+# =========================================================================
+#   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'
+
+##
+## Mocks Named by the Folders Their #includes Spell
+## ================================================
+##
+## CMock names a mock by the folder its #include names, and the compiler reaches the mock
+## through that #include as written. Mock generation, stand-ins, compiled sources and search
+## paths must all agree on where each mock lives (the path handling audit around GH #1370).
+##
+
+MOCK_FOLDER_PREAMBLE = "#include \"unity.h\"\nvoid setUp(void) {}\nvoid tearDown(void) {}\n"
+
+ceedling_system_tests do
+  include_context "a fresh ceedling gem project", "mock_folders"
+
+  def write(path, content)
+    FileUtils.mkdir_p( File.dirname( path ) )
+    File.write( path, content )
+  end
+
+  def build(include_paths, preprocessor: :none)
+    @c.merge_project_yml_for_test( { :project => { :use_test_preprocessor => preprocessor }, :paths => { :include => include_paths } } )
+    output = @c.ceedling_build_exec( "test:all" )
+
+    expect(@c.last_exit_status).to eq(0), output
+    expect(output).to match(/PASSED:\s+1/)
+  end
+
+  it "builds two same-named mocks whose #include folders alone tell them apart" do
+    in_project do
+      write( 'inc/a/foo.h', "int a_read(void);\n" )
+      write( 'inc/b/foo.h', "int b_read(void);\n" )
+      write( 'test/test_c.c', MOCK_FOLDER_PREAMBLE + "#include \"a/mock_foo.h\"\n#include \"b/mock_foo.h\"\n" \
+                              "void test_reads(void) { a_read_ExpectAndReturn(5); b_read_ExpectAndReturn(6); TEST_ASSERT_EQUAL_INT(11, a_read() + b_read()); }\n" )
+
+      build( ['inc', 'inc/a', 'inc/b'] )
+    end
+  end
+
+  # The mocks root carries the test's name, which the #include's folder happens to share
+  it "builds a mock whose #include folder shares the test's own name" do
+    in_project do
+      write( 'inc/test_c/foo.h', "int foo_read(void);\n" )
+      write( 'test/test_c.c', MOCK_FOLDER_PREAMBLE + "#include \"test_c/mock_foo.h\"\nvoid test_reads(void) { foo_read_ExpectAndReturn(5); TEST_ASSERT_EQUAL_INT(5, foo_read()); }\n" )
+
+      build( ['inc', 'inc/test_c'] )
+    end
+  end
+
+  it "builds a mock whose #include spells more path than its header's mirror without naming it by folder" do
+    in_project do
+      @c.merge_project_yml_for_test( { :cmock => { :mock_name_include_folder => false } } )
+      write( 'inc/a/foo.h', "int foo_read(void);\n" )
+      write( 'test/test_c.c', MOCK_FOLDER_PREAMBLE + "#include \"inc/a/mock_foo.h\"\nvoid test_reads(void) { foo_read_ExpectAndReturn(5); TEST_ASSERT_EQUAL_INT(5, foo_read()); }\n" )
+
+      build( ['inc/**'] )
+    end
+  end
+
+  # Each stand-in opens as its real mock will, through its own folder, so a macro one header
+  # defines selects a mock only where that header is the one included
+  it "reconciles #includes through the header each same-named mock's folder names" do
+    in_project do
+      write( 'inc/a/foo.h', "int a_read(void);\n" )
+      write( 'inc/b/foo.h', "#define USE_B_EXTRA 1\nint b_read(void);\n" )
+      write( 'inc/extra.h', "int extra(void);\n" )
+      write( 'test/test_c.c', MOCK_FOLDER_PREAMBLE + "#include \"a/mock_foo.h\"\n#include \"b/mock_foo.h\"\n#if USE_B_EXTRA\n#include \"mock_extra.h\"\n#endif\n" \
+                              "void test_reads(void) { a_read_ExpectAndReturn(5); b_read_ExpectAndReturn(6); extra_ExpectAndReturn(1); TEST_ASSERT_EQUAL_INT(12, a_read() + b_read() + extra()); }\n" )
+
+      build( ['inc/**'], preprocessor: :all )
+    end
+  end
+
+  it "leaves a mock #include in a branch that is off out of a preprocessed build" do
+    in_project do
+      write( 'inc/x/foo.h', "int foo_read(void);\n" )
+      write( 'test/test_c.c', MOCK_FOLDER_PREAMBLE + "#include \"x/mock_foo.h\"\n#if 0\n#include \"../legacy/mock_old.h\"\n#endif\n" \
+                              "void test_reads(void) { foo_read_ExpectAndReturn(5); TEST_ASSERT_EQUAL_INT(5, foo_read()); }\n" )
+
+      build( ['inc/**'], preprocessor: :all )
+    end
+  end
+end

data/spec/system/parent_directory_reference_spec.rb

@@ -98,12 +98,14 @@ ceedling_system_tests do
 
       before { copy_dotdot_include_assets }
 
-      it "fails clearly, naming .. as unsupported rather than a generic file-not-found" do
+      # GH #1370 audit (G9): a task name is relative to the working directory, as every
+      # collected path is, so `..` names a place outside the project, where no test exists here
+      it "looks for the test outside the project, and names it when none is there" 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)
+          expect(output).to include("../unit/test_dotdot_include")
+          expect(output).to_not match(/no file context/i)
         end
       end
 

data/spec/system/path_handling_probes_spec.rb

@@ -0,0 +1,192 @@
+# =========================================================================
+#   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 'tmpdir'
+
+##
+## Path Handling Through Real Builds (GH #1370 and the audit around it)
+## ======================================================================
+##
+## Each example builds a project whose configuration names paths in a way the path
+## handling audit found unsafe, and names the gap it probes. The project sits at `app/`
+## within its own directory, so a `..` root reaches only that directory, never a
+## neighboring project.
+##
+
+PROBE_TEST_PREAMBLE = "#include \"unity.h\"\nvoid setUp(void) {}\nvoid tearDown(void) {}\n"
+
+ceedling_system_tests do
+  include_context "a fresh ceedling gem project", "path_probe"
+
+  # Moves the fresh project into `app/` and runs the block from there
+  def in_app
+    in_project do
+      FileUtils.mkdir_p( 'app' )
+      FileUtils.mv( Dir.children( '.' ) - ['app'], 'app' )
+      Dir.chdir( 'app' ) { yield File.expand_path( '..' ) }
+    end
+  end
+
+  def write(path, content)
+    FileUtils.mkdir_p( File.dirname( path ) )
+    File.write( path, content )
+  end
+
+  # The report's setup: a vendor SDK far above the project, beside a `..` root
+  it "G1 (#1370): mocks a header far outside the project beside a `..` root" do
+    Dir.mktmpdir do |far|
+      sdk = File.join( File.realpath( far ), 'deep', 'sdk', 'inc' )
+      write( File.join( sdk, 'sdk.h' ), "int sdk_read(void);\n" )
+
+      in_app do |parent|
+        write( 'test/test_m.c', PROBE_TEST_PREAMBLE + "#include \"mock_sdk.h\"\nvoid test_reads(void) { sdk_read_ExpectAndReturn(3); TEST_ASSERT_EQUAL_INT(3, sdk_read()); }\n" )
+        @c.merge_project_yml_for_test( { :paths => { :include => ['../**', sdk] } } )
+
+        output = @c.ceedling_build_exec( "test:all" )
+
+        expect(@c.last_exit_status).to eq(0), output
+        expect(output).to match(/PASSED:\s+1/)
+        expect(Dir.children( parent ) - ['app']).to be_empty
+      end
+    end
+  end
+
+  it "G4: links the source beside a header below a `./` include root" do
+    in_app do
+      write( 'include/drv/x.h', "int x_value(void);\n" )
+      write( 'src/drv/x.c', "#include \"x.h\"\nint x_value(void) { return 7; }\n" )
+      write( 'test/test_x.c', PROBE_TEST_PREAMBLE + "#include \"x.h\"\nvoid test_value(void) { TEST_ASSERT_EQUAL_INT(7, x_value()); }\n" )
+      @c.merge_project_yml_for_test( { :project => { :use_test_preprocessor => :all }, :paths => { :include => ['./include/**'] } } )
+
+      output = @c.ceedling_build_exec( "test:all" )
+
+      expect(@c.last_exit_status).to eq(0), output
+      expect(output).to match(/PASSED:\s+1/)
+    end
+  end
+
+  it "G5: compiles both of two same-named sources below two roots into a release" do
+    in_app do
+      write( 'src/foo.c', "int foo_a(void) { return 1; }\n" )
+      write( 'lib/foo.c', "int foo_b(void) { return 2; }\n" )
+      write( 'src/main.c', "int foo_a(void);\nint foo_b(void);\nint main(void) { return foo_a() + foo_b() - 3; }\n" )
+      @c.merge_project_yml_for_test( { :project => { :release_build => true }, :paths => { :source => ['src/**', 'lib/**'] } } )
+
+      output = @c.ceedling_build_exec( "release" )
+
+      expect(@c.last_exit_status).to eq(0), output
+    end
+  end
+
+  # The mock search path for the header's mirrored directory reaches the #include as written
+  it "G14: builds a mock #include that climbs with `..`, keeping the mock below its test's mocks directory" do
+    in_app do
+      write( 'inc/x/foo.h', "int foo_read(void);\n" )
+      write( 'test/test_c.c', PROBE_TEST_PREAMBLE + "#include \"../x/mock_foo.h\"\nvoid test_reads(void) { foo_read_ExpectAndReturn(5); TEST_ASSERT_EQUAL_INT(5, foo_read()); }\n" )
+      @c.merge_project_yml_for_test( { :paths => { :include => ['inc/**'] } } )
+
+      output = @c.ceedling_build_exec( "test:all" )
+
+      expect(@c.last_exit_status).to eq(0), output
+      expect(output).to match(/PASSED:\s+1/)
+      expect(Dir.glob( 'build/test/mocks/test/test_c/**/mock_foo.h' )).to_not be_empty
+      expect(Dir.children( 'build/test/mocks' )).to eq( ['test'] )
+      expect(Dir.children( 'build/test/mocks/test' )).to eq( ['test_c'] )
+    end
+  end
+
+  # A test reaches a module's static functions by #including its source, which must not be
+  # linked a second time from its own object
+  it "links a test that #includes both a module's header and its source" do
+    in_app do
+      write( 'src/foo.h', "int foo(void);\n" )
+      write( 'src/foo.c', "#include \"foo.h\"\nstatic int helper(void) { return 2; }\nint foo(void) { return helper() + 1; }\n" )
+      write( 'test/test_foo.c', PROBE_TEST_PREAMBLE + "#include \"foo.h\"\n#include \"foo.c\"\nvoid test_helper(void) { TEST_ASSERT_EQUAL_INT(2, helper()); TEST_ASSERT_EQUAL_INT(3, foo()); }\n" )
+
+      output = @c.ceedling_build_exec( "test:all" )
+
+      expect(@c.last_exit_status).to eq(0), output
+      expect(output).to match(/PASSED:\s+1/)
+    end
+  end
+
+  # One file collected by one spelling and configured by another is one source
+  it "builds with a `./` build root and Unity helper, which name files the collections spell otherwise" do
+    in_app do
+      write( 'src/calc.h', "int calc(int a);\n" )
+      write( 'src/calc.c', "#include \"calc.h\"\n#include \"CException.h\"\nint calc(int a) { if (a < 0) { Throw(1); } return a + 1; }\n" )
+      write( 'test/support/unity_helper.h', "#define UNITY_HELPER_VALUE 1\n" )
+      write( 'test/support/unity_helper.c', "int unity_helper_value(void) { return 1; }\n" )
+      write( 'test/test_calc.c', PROBE_TEST_PREAMBLE + "#include \"CException.h\"\n#include \"calc.h\"\nvoid test_calc(void) { TEST_ASSERT_EQUAL_INT(2, calc(1)); }\n" )
+      @c.merge_project_yml_for_test( {
+        :project => { :build_root => './build', :use_exceptions => true },
+        :paths   => { :support => ['test/support'] },
+        :cmock   => { :unity_helper_path => ['./test/support/unity_helper.h'] }
+      } )
+
+      output = @c.ceedling_build_exec( "test:all" )
+
+      expect(@c.last_exit_status).to eq(0), output
+      expect(output).to match(/PASSED:\s+1/)
+    end
+  end
+
+  # A project file's relative paths resolve against the working directory, not the project
+  # file's own directory
+  it "G22: builds a project named by --project from another directory, with paths relative to that directory" do
+    in_app do |parent|
+      write( 'src/calc.c', "#include \"calc.h\"\nint calc(int a) { return a + 1; }\n" )
+      write( 'src/calc.h', "int calc(int a);\n" )
+      write( 'test/test_calc.c', PROBE_TEST_PREAMBLE + "#include \"calc.h\"\nvoid test_calc(void) { TEST_ASSERT_EQUAL_INT(2, calc(1)); }\n" )
+
+      project = YAML.load_file( 'project.yml' )
+      project[:project][:build_root] = 'app/build'
+      project[:paths] = { :test => ['app/test/**'], :source => ['app/src/**'], :include => ['app/src/**'], :support => [] }
+      File.write( 'project.yml', project.to_yaml )
+
+      Dir.chdir( parent ) do
+        output = @c.ceedling_build_exec( "--project app/project.yml test:all" )
+
+        expect(@c.last_exit_status).to eq(0), output
+        expect(output).to match(/PASSED:\s+1/)
+        expect(Dir.exist?( 'app/build/test' )).to be true
+      end
+    end
+  end
+
+  # Ceedling refuses a build root holding the project's own directories
+  it "G16: never lets clobber empty the project's own test directory" do
+    in_app do
+      write( 'test/test_keep.c', PROBE_TEST_PREAMBLE + "void test_it(void) {}\n" )
+      @c.merge_project_yml_for_test( { :project => { :build_root => '.' } } )
+
+      output = @c.ceedling_build_exec( "clobber" )
+
+      expect(@c.last_exit_status).to_not eq(0)
+      expect(output).to match( /:build_root => '\.' is the project directory or holds it/ )
+      expect(File.exist?( 'test/test_keep.c' )).to be( true )
+    end
+  end
+
+  it "reports coverage of a source in a sibling directory outside the project" do
+    in_app do |parent|
+      write( File.join( parent, 'shared', 'src', 'calc.c' ), "#include \"calc.h\"\nint calc(int a) { return a + 1; }\n" )
+      write( File.join( parent, 'shared', 'src', 'calc.h' ), "int calc(int a);\n" )
+      write( 'test/test_calc.c', PROBE_TEST_PREAMBLE + "#include \"calc.h\"\nvoid test_calc(void) { TEST_ASSERT_EQUAL_INT(2, calc(1)); }\n" )
+      @c.merge_project_yml_for_test( {
+        :plugins => { :enabled => ['gcov'] },
+        :paths   => { :source => ['../shared/src/**'], :include => ['../shared/src/**'] }
+      } )
+
+      output = @c.ceedling_build_exec( "gcov:all" )
+
+      expect(@c.last_exit_status).to eq(0), output
+      expect(output).to match(/calc\.c/)
+    end
+  end
+end

data/spec/system/preprocessing_parameterized_tests_spec.rb

@@ -164,7 +164,7 @@ ceedling_system_tests do
             @c.ceedling_build_exec
             expect(@c.last_exit_status).to eq(0)
 
-            runner_path = 'build/test/runners/test_ptc_runner.c'
+            runner_path = 'build/test/runners/test/test_ptc_runner.c'
             expect(File.exist?(runner_path)).to eq(true)
             runner_contents = read_spec_file(runner_path)
 

data/spec/system/rake_release_task_path_disambiguation_spec.rb

@@ -61,8 +61,8 @@ ceedling_system_tests do
           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
+          expect(File.exist?('build/release/out/src/baz/bar.o')).to be true
+          expect(File.exist?('build/release/out/src/foo/bar.o')).to be false
         end
       end
 
@@ -73,8 +73,8 @@ ceedling_system_tests do
           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
+          expect(File.exist?('build/release/out/src/foo/bar.o')).to be true
+          expect(File.exist?('build/release/out/src/baz/bar.o')).to be false
         end
       end
 
@@ -85,8 +85,8 @@ ceedling_system_tests do
           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
+          expect(File.exist?('build/release/out/src/baz/bar.o')).to be true
+          expect(File.exist?('build/release/out/src/foo/bar.o')).to be false
         end
       end
 

data/spec/system/rake_test_task_path_disambiguation_spec.rb

@@ -113,6 +113,91 @@ ceedling_system_tests do
 
     end
 
+    # =========================================================================
+    describe "A test at its root beside same-named tests below it" do
+    # =========================================================================
+
+      # GH #1364: a test at its root builds beside same-named tests below it
+      before do
+        in_project do
+          copy_fixture("tests_with_duplicate_test_names/test_foo.c", 'test')
+          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 "runs all three under test:all, and summarizes all three" 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+3/)
+          expect(output).to match(/PASSED:\s+3/)
+          expect(output).to match(/test_this_is_the_root_directory_test_foo/)
+
+          summary = @c.ceedling_build_exec("summary")
+          expect(summary).to match(/TESTED:\s+3/)
+        end
+      end
+
+      it "runs exactly the test at the root when named by its full path" do
+        in_project do
+          output = @c.ceedling_build_exec("test:test/test_foo.c")
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to match(/TESTED:\s+1/)
+          expect(output).to match(/test_this_is_the_root_directory_test_foo/)
+        end
+      end
+
+      it "runs all three under gcov:all" do
+        in_project do
+          @c.merge_project_yml_for_test({ :plugins => { :enabled => ['gcov'] } })
+
+          output = @c.ceedling_build_exec("gcov:all")
+          expect(@c.last_exit_status).to eq(0)
+          expect(output).to_not match(/Ambiguous/)
+          expect(output).to match(/TESTED:\s+3/)
+          expect(output).to match(/PASSED:\s+3/)
+        end
+      end
+
+    end
+
+    # =========================================================================
+    describe "Same-named tests under more than one test root" do
+    # =========================================================================
+
+      # GH #1364: tests with one path below different roots keep apart
+      it "runs both tests when one root lies inside the other" do
+        in_project do
+          copy_fixture("tests_with_duplicate_test_names/unit/test_foo.c", 'test')
+          copy_fixture("tests_with_duplicate_test_names/integration/test_foo.c", 'test/unit')
+          @c.merge_project_yml_for_test({ :paths => { :test => ['+:test/unit/**'] } })
+
+          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(/test_this_is_the_unit_directory_test_foo/)
+          expect(output).to match(/test_this_is_the_integration_directory_test_foo/)
+        end
+      end
+
+      it "runs both tests when two roots hold the same layout" do
+        in_project do
+          copy_fixture("tests_with_duplicate_test_names/unit/test_foo.c", 'test/foo')
+          copy_fixture("tests_with_duplicate_test_names/integration/test_foo.c", 'extra/foo')
+          @c.merge_project_yml_for_test({ :paths => { :test => ['+:extra/**'] } })
+
+          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(/test_this_is_the_unit_directory_test_foo/)
+          expect(output).to match(/test_this_is_the_integration_directory_test_foo/)
+        end
+      end
+
+    end
+
   end
 
 end

data/spec/system/special_path_characters_spec.rb

@@ -0,0 +1,86 @@
+# =========================================================================
+#   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'
+
+##
+## Tests Under Paths Holding Shell Characters Run (issue #1373)
+## ==============================================================
+##
+## A test's executable sits beneath its path from the project root, and tools run through
+## the system shell. The default tools that run a test executable named it unquoted, so a
+## test under `test/o'neil/` reported every case as a crash, and one under `test/my dir/`
+## stopped the build. Each runs here, with a pass, a failure, and a crash that the simple
+## backtrace reruns pin to its own case.
+##
+
+SPECIAL_PATH_TEST_C = <<~C
+  #include "unity.h"
+
+  void setUp(void) {}
+  void tearDown(void) {}
+
+  void test_passes(void) { TEST_ASSERT_TRUE(1); }
+  void test_fails(void)  { TEST_ASSERT_EQUAL_INT(1, 2); }
+C
+
+SPECIAL_PATH_CRASH_C = <<~C
+
+  void test_crashes(void) { volatile int *p = 0; *p = 1; }
+C
+
+ceedling_system_tests do
+  include_context "a fresh ceedling gem project", "special_path"
+
+  ["o'neil", "my dir"].each do |directory|
+    describe "A test under `test/#{directory}/`" do
+      before do
+        in_project do
+          FileUtils.mkdir_p( "test/#{directory}" )
+          File.write( "test/#{directory}/test_special.c", SPECIAL_PATH_TEST_C )
+        end
+      end
+
+      it "runs a test under `test/#{directory}/`, reporting each case's own result" do
+        in_project do
+          output = @c.ceedling_build_exec( "test:all" )
+
+          expect(@c.last_exit_status).to eq(1), output
+          expect(output).to_not match(/crashed/i)
+          expect(output).to match(/TESTED:\s+2/)
+          expect(output).to match(/PASSED:\s+1/)
+          expect(output).to match(/FAILED:\s+1/)
+        end
+      end
+
+      it "pins a crash under `test/#{directory}/` to its own case through simple backtrace reruns" do
+        in_project do
+          File.write( "test/#{directory}/test_special.c", SPECIAL_PATH_TEST_C + SPECIAL_PATH_CRASH_C )
+
+          output = @c.ceedling_build_exec( "test:all" )
+
+          expect(output).to match(/Test: test_crashes/)
+          expect(output).to match(/TESTED:\s+3/)
+          expect(output).to match(/PASSED:\s+1/)
+          expect(output).to match(/FAILED:\s+2/)
+        end
+      end
+
+      it "runs a test under `test/#{directory}/` with gcov" do
+        in_project do
+          @c.merge_project_yml_for_test( {:plugins => {:enabled => ['gcov']}} )
+
+          output = @c.ceedling_build_exec( "gcov:all" )
+
+          expect(output).to_not match(/crashed/i)
+          expect(output).to match(/PASSED:\s+1/)
+          expect(output).to match(/FAILED:\s+1/)
+        end
+      end
+    end
+  end
+end