ceedling 1.1.8 → 1.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c1edc565bc9fcb24accc9fd0d5001076fe86564cb0acd02c7d1fc092476c2c1
-  data.tar.gz: 0c5ec0119bc3249824177c6094afd3e3ef9ee7da698b92fed894924d45d83625
+  metadata.gz: 28f18f89f99b7e81f68293c994fa85ff25532ca62bd250c2d1c7e351ec3ec7a0
+  data.tar.gz: 1252cbea2a5752315c65826f8068313450cf08d0ea63259e1e8a5d422588140c
 SHA512:
-  metadata.gz: 6efc0307567637d4019978131f45758d694b97ea93a4a7ada5ff6be8c682d70eff9d8d453de4882cc46344bb1b0aa098dbf7982582a7d7a168818caba2bd7e51
-  data.tar.gz: 6366fddeaff5572f317efffb161ff64378cae4e6b2dea30aa11f3baf4aac1777611331483d071a080cb9a01aa1e4087409d5314559881ae0a12ce753a1f86311
+  metadata.gz: 7aeb58a943b8df79fa31e12694a16019fba66cf798cc899eccb4d1e7b64d0b5fe09e5965f376791381cbc8c0e47a65c0563dbc5a00e1523714e813b8491a9896
+  data.tar.gz: e6cf0643c68cd8fa2c96b99de3e2e95ca276b27bf5ecb5cfa41ae9f1371ed55f3675ec5491d585b989629f2f89b0f16fc65f0586daa6ade065fbe903d9208087

data/GIT_COMMIT_SHA

@@ -1 +1 @@
-885dc91
+2209dc2

data/README.md

@@ -1,7 +1,7 @@
 Ceedling ![CI](https://github.com/ThrowTheSwitch/Ceedling/workflows/CI/badge.svg)
 ========
 
-**Ceedling 1.1.8** is the latest and greatest.
+**Ceedling 1.1.9** is the latest and greatest.
 
 See [_Release Notes_][release-notes], [_Changelog_](docs/Changelog.md), 
 [_Breaking Changes_][breaking-changes], and [_Known Issues_][known-issues].

data/docs/Changelog.md

@@ -10,6 +10,24 @@ This changelog is complemented by three other documents:
 
 ---
 
+# [1.1.9] — 2026-09-20
+
+## 💪 Fixed
+
+### Partials
+
+- [#1293](https://github.com/ThrowTheSwitch/Ceedling/issues/1293) Fixed a Partials-generated header occasionally redefining a type already declared by the real header it replaces, causing a `typedef redefinition with different types` compilation error. The triggering condition involved a source file whose real header was reachable both directly and through a macro-included intermediate file allowed by incomplete Partials include directive ordering.
+
+### Preprocessing
+
+- Fixed whitespace occasionally inserted by the underlying compiler's preprocessor around a `#` or `##` operator (e.g. `x ##y` becoming `x ## y`) being carried through verbatim into Partials-generated and reconstructed macro definitions. Extracted macro text is now normalized so preprocessing stringize and token-paste operators always sit directly against their operands, regardless of what a given toolchain's preprocessor happens to emit.
+
+## ⚠️ Changed
+
+- Updated Unity to latest version.
+
+---
+
 # [1.1.8] — 2026-09-10
 
 ## 💪 Fixed

data/docs/KnownIssues.md

@@ -22,6 +22,7 @@ Known issues are complemented by three other documents:
 1. Any path for a C file specified with `TEST_SOURCE_FILE(...)` is in relation to **_project root_** — that is, from where you execute `ceedling` at the command line. If you move source files or change your directory structure, many of your `TEST_SOURCE_FILE(...)` calls may need to be updated. A more flexible and dynamic approach to path handling will come in a future update.
 1. In certain combinations of conditional preprocessing blocks with dependent symbols defined in another file, Ceedling can silently fail to extract computed includes (e.g. `#include SOME_MACRO()`).
 1. User includes (`#include "path/user.h"`) from source C files lose their relative path when Partial and mock header files are generated from source. Compilation failures can result from certain uncommon cases involving headers of the same names in different directories and a source file including both such headers.
+1. The automatic vendor copying of Unity, CMock, and CException into a project's build directory can intermittently fail with a file/directory type error, most often under antivirus/EDR file locking, cloud-sync filter drivers, or two concurrent Ceedling invocations racing the same destination. Deleting `build/` (or reinstalling the gem) and rebuilding works around it.
 1. The Bullseye code coverage plugin has been temporarily disabled as of 1.0.0. The makers of Bullseye have generously provided a license for development, and the plugin will be available in the next minor release.
 
 ---

data/lib/ceedling/c_extractor/c_extractor_preprocessing.rb

@@ -246,7 +246,10 @@ class CExtractorPreprocessing
       # literal run -- it has to be seen and dispatched on its own below, before
       # any '"' or "'" inside the comment's own text gets mistaken for the start
       # of a string/char literal (see the // and /* branches for why that matters).
-      text << (scanner.scan(/[^"'\\\n\/]*/) || '')
+      # '#' is excluded the same way, so a #/## operator is seen and dispatched on
+      # its own below rather than absorbed into this run along with whatever
+      # whitespace happens to surround it (see the ## and # branches for why).
+      text << (scanner.scan(/[^"'\\\n\/#]*/) || '')
 
       if scanner.scan(%r{//})
         # A trailing line comment (e.g. "// don't change this") can contain an
@@ -280,6 +283,31 @@ class CExtractorPreprocessing
       elsif scanner.scan(%r{/})
         text << '/'
 
+      elsif scanner.scan(/##/)
+        # The C standard specifies ##'s token-paste semantics but not the exact
+        # whitespace a preprocessor emits when reconstructing macro text -- real
+        # toolchains can and do disagree here, and Ceedling regenerates this text
+        # into partials rather than promising byte-for-byte reproduction of that
+        # spacing. Discard whatever immediately follows the operator in the source,
+        # so its right-hand operand always glues on directly. The left side only
+        # trims when a word character (the operand actually being pasted) is
+        # immediately adjacent -- a lookbehind, not a blind rstrip -- so unrelated
+        # punctuation spacing that happens to precede the operator (e.g. the space
+        # after a macro argument's comma, or after the parameter list's closing
+        # paren when the replacement list itself starts with the operator) is left
+        # alone; that space was never the preprocessor-reconstruction artifact this
+        # is defending against. ## checked before bare '#' below so a real paste
+        # operator is never split into two stringize matches.
+        text.sub!(/(?<=\w)[ \t]+\z/, '')
+        scanner.scan(/[ \t]*/)
+        text << '##'
+
+      elsif scanner.scan(/#/)
+        # Same rationale as ## above, for the stringize operator.
+        text.sub!(/(?<=\w)[ \t]+\z/, '')
+        scanner.scan(/[ \t]*/)
+        text << '#'
+
       elsif (ch = scanner.peek(1)) == '"' || ch == "'"
         before = scanner.pos
         @c_extractor_code_text.skip_c_string(scanner, ch)

data/lib/ceedling/file_path_utils.rb

@@ -124,6 +124,10 @@ class FilePathUtils
     pairs = paths.map { |p| [p, p.gsub('\\', '/').chomp('/')] }
 
     # Sort shallowest-first so ancestors are always encountered before their descendants.
+    # No tiebreaker for same-depth entries needed: Ruby's sort_by doesn't guarantee a
+    # stable order among ties, but two same-depth paths can never be each other's
+    # ancestor, so the ancestor-exclusion check below is correct regardless of which
+    # order same-depth ties come out in.
     pairs.sort_by! { |_, normalized| normalized.count('/') }
 
     kept = []

data/lib/ceedling/includes/includes.rb

@@ -254,8 +254,15 @@ class Includes
     return _includes
   end
 
+  # Ruby's sort/sort_by family does not guarantee a stable sort -- the relative order
+  # of elements a comparator treats as equal (every UserInclude here, all mapping to
+  # the same "1") is free to come out differently across Ruby versions and platforms.
+  # partition sidesteps the question entirely: it's a simple filter, not a comparator
+  # sort, so each group's own original relative order is preserved by definition, on
+  # every Ruby version and platform, with nothing to be unstable about.
   def self.sort!(includes)
-    includes.sort_by! { |include| include.is_a?(SystemInclude) ? 0 : 1 }
+    system, other = includes.partition { |include| include.is_a?(SystemInclude) }
+    includes.replace(system + other)
     return includes
   end
 end

data/lib/ceedling/partials/partializer.rb

@@ -86,20 +86,17 @@ class Partializer
   def remap_implementation_header_includes(name:, includes:, partials:, types_header: nil, test: nil)
     _includes = includes.clone()
 
-    # Get list of all partialized module names
-    partialized_modules = partials.keys
+    # This module's own header include is spliced out in favor of the shared types
+    # header at its exact original list position -- see #splice_in_replacement.
+    _includes = splice_in_replacement(includes: _includes, name: name, replacement: types_header)
 
-    # Remove includes for all partialized modules
-    # Remove our own orginal name as well
+    # Remove includes for every other partialized module (this module's own name was
+    # already handled above)
     _includes = remove_matching_includes(
       includes: _includes,
-      modules: ([name] + partialized_modules)
+      modules: (partials.keys - [name])
     )
 
-    # When this module has any typedefs or aggregate definitions, they live in a shared
-    # header generated once and included here rather than duplicated inline.
-    _includes << UserInclude.new(types_header) if types_header
-
     # Remove any duplicates
     Includes.sanitize!(_includes)
 
@@ -116,9 +113,19 @@ class Partializer
   def remap_implementation_source_includes(name:, includes:, partials:, test: nil)
     _includes = includes.clone()
 
-    # Add implementation header
-    _includes << UserInclude.new(
-      @file_path_utils.form_partial_implementation_header_filename(name)
+    # Splice the implementation header in at this module's own header's original list
+    # position, same rationale as #splice_in_replacement -- the generated
+    # implementation header carries the shared types header in correctly-ordered
+    # position internally, but that alone doesn't help if THIS file's own separate
+    # include list still reaches an unrelated header that transitively re-includes the
+    # real module header before the implementation header (and everything it carries)
+    # is ever reached. Appending it at the very end (after this file's own copy of every
+    # other real include) would put it after exactly that kind of transitive
+    # re-inclusion instead of before it.
+    _includes = splice_in_replacement(
+      includes: _includes,
+      name: name,
+      replacement: @file_path_utils.form_partial_implementation_header_filename(name)
     )
 
     mockable_modules = []
@@ -144,11 +151,12 @@ class Partializer
       end
     end
 
-    # Remove the original module header now that it's remapped to mockable interface
-    # Remove our own orginal name as well
+    # Remove the original headers of any OTHER modules now remapped to mockable
+    # interfaces above -- this module's own original header was already handled by
+    # the splice above.
     _includes = remove_matching_includes(
       includes: _includes,
-      modules: ([name] + mockable_modules)
+      modules: mockable_modules
     )
 
     # Remove any duplicates
@@ -167,20 +175,17 @@ class Partializer
   def remap_interface_header_includes(name:, includes:, partials:, types_header: nil, test: nil)
     _includes = includes.clone()
 
-    # Get list of all partialized module names
-    partialized_modules = partials.keys
+    # This module's own header include is spliced out in favor of the shared types
+    # header at its exact original list position -- see #splice_in_replacement.
+    _includes = splice_in_replacement(includes: _includes, name: name, replacement: types_header)
 
-    # Remove includes for all partialized modules
-    # Remove our own orginal name as well
+    # Remove includes for every other partialized module (this module's own name was
+    # already handled above)
     _includes = remove_matching_includes(
       includes: _includes,
-      modules: ([name] + partialized_modules)
+      modules: (partials.keys - [name])
     )
 
-    # When this module has any typedefs or aggregate definitions, they live in a shared
-    # header generated once and included here rather than duplicated inline.
-    _includes << UserInclude.new(types_header) if types_header
-
     # Remove any duplicates
     Includes.sanitize!(_includes)
 
@@ -452,6 +457,46 @@ class Partializer
     )
   end
 
+  # Swaps `name`'s own header include for `replacement` at that same list position,
+  # instead of stripping it out and appending the replacement at the very end.
+  #
+  # Both call sites' generated replacements (the shared types header; the generated
+  # implementation header, which itself carries the types header) spoof the real
+  # header's own include guard (a top-of-file `#define <ORIGINAL_GUARD>`) so that if the
+  # real header is *also* reached a second way -- e.g. a transitively-included,
+  # differently-named header that itself does a genuine `#include` of this module's
+  # real header -- the real header's guard is already
+  # tripped and its content (a second, conflicting copy of the same typedefs/structs)
+  # never gets processed. That only works if the spoofing macro is defined *before*
+  # such a transitive re-inclusion is reached, not after. Appending at the very end put
+  # it after any such re-inclusion instead of before it. Keeping the replacement at the
+  # original header's own list position preserves everything the generated content
+  # depends on that came before it in the source's own working include order (e.g. a
+  # shared Types.h), while still landing ahead of anything transitively re-reaching the
+  # real header afterward.
+  def splice_in_replacement(includes:, name:, replacement:)
+    return remove_matching_includes(includes: includes, modules: [name]) unless replacement
+
+    replaced = false
+    spliced = includes.map do |include|
+      if !replaced && include.filename.ext().downcase() == name.downcase()
+        replaced = true
+        UserInclude.new(replacement)
+      else
+        include
+      end
+    end
+    # This module's own header wasn't in the includes list at all -- no original
+    # position to preserve, so fall back to appending.
+    spliced << UserInclude.new(replacement) unless replaced
+
+    # A duplicate/case-variant entry beyond the first match (e.g. both 'module.h' and
+    # 'MODULE.H' present) has no meaningful position of its own to preserve -- drop it
+    # like remove_matching_includes always has.
+    spliced = remove_matching_includes(includes: spliced, modules: [name])
+    spliced
+  end
+
   # Remove includes that match the given module names (case-insensitive)
   # Returns a new array with matching includes removed
   def remove_matching_includes(includes:, modules:)

data/lib/version.rb

@@ -15,7 +15,7 @@
 module Ceedling
   module Version
     # Convenience constants for gem building, etc.
-    GEM = '1.1.8'
+    GEM = '1.1.9'
     TAG = GEM
 
     # If run as a script print Ceedling's version to $stdout

data/spec/units/c_extractor/c_extractor_integration_spec.rb

@@ -1007,6 +1007,24 @@ describe CExtractor do
       expect(plain.decorators).to eq([])
     end
 
+    it "normalizes a preprocessor-inserted space before ## in a backslash-continued macro definition" do
+      file_contents = <<~CONTENTS
+      #define MODULE_DEV_TYPE_CB(dev_type)      \\
+          void MODULE_TrigCbDev ##dev_type(void) \\
+          {                                     \\
+              MODULE_CommonTrigCb();            \\
+          }
+
+      static AlertEntry_t s_alert_table[ALERT_MANAGER_MAX_ALERTS];
+      CONTENTS
+
+      contents = extract_from.call(file_contents)
+
+      expect(contents.macro_definitions.length).to eq 1
+      expect(contents.macro_definitions[0].text).to include('MODULE_TrigCbDev##dev_type')
+      expect(contents.macro_definitions[0].text).not_to include('MODULE_TrigCbDev ##dev_type')
+    end
+
   end
 
 end

data/spec/units/c_extractor/c_extractor_preprocessing_spec.rb

@@ -388,6 +388,83 @@ describe CExtractorPreprocessing do
       expect(scanner.pos).to eq 0
     end
 
+    context "whitespace around # and ## operators" do
+      it "trims a space before ##" do
+        result, _pos = try_directive("#define M(x) void f ##x(void) { g(); }\n")
+        expect(result).to eq [true, "#define M(x) void f##x(void) { g(); }"]
+      end
+
+      it "trims a space after ##" do
+        result, _pos = try_directive("#define M(x) void f## x(void) { g(); }\n")
+        expect(result).to eq [true, "#define M(x) void f##x(void) { g(); }"]
+      end
+
+      it "trims space on both sides of ##" do
+        result, _pos = try_directive("#define M(x) void f ## x(void) { g(); }\n")
+        expect(result).to eq [true, "#define M(x) void f##x(void) { g(); }"]
+      end
+
+      it "trims a space after the stringize operator #" do
+        result, _pos = try_directive("#define S(x) # x\n")
+        expect(result).to eq [true, "#define S(x) #x"]
+      end
+
+      it "trims a space before a stringize operator directly gluing onto a preceding identifier" do
+        result, _pos = try_directive("#define M(a, b) a #b\n")
+        expect(result).to eq [true, "#define M(a, b) a#b"]
+      end
+
+      it "does not touch whitespace before # or ## when preceded by punctuation, not an identifier being pasted" do
+        # The space here separates the macro's own parameter list from a
+        # replacement list that happens to start with the operator -- that's
+        # ordinary formatting, not preprocessor-reconstruction spacing around an
+        # operand being pasted, so it's out of this fix's scope.
+        result, _pos = try_directive("#define S(x)  #x\n")
+        expect(result).to eq [true, "#define S(x)  #x"]
+      end
+
+      it "normalizes the GNU comma-deletion ,##__VA_ARGS__ form" do
+        result, _pos = try_directive("#define LOG(fmt, ...) printf(fmt, ## __VA_ARGS__)\n")
+        expect(result).to eq [true, "#define LOG(fmt, ...) printf(fmt, ##__VA_ARGS__)"]
+      end
+
+      it "is idempotent for already-canonical ## spacing" do
+        input = "#define M(x) void f##x(void) { g(); }\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+
+      it "is idempotent for already-canonical # spacing" do
+        input = "#define S(x) #x\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+
+      it "does not touch ## inside a string literal" do
+        input = %q{#define M(x) "a ## b"} + "\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+
+      it "does not touch ## inside a // comment" do
+        input = "#define M(x) x // a ## b\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+
+      it "does not touch ## inside a /* */ comment" do
+        input = "#define M(x) x /* a ## b */\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+
+      it "leaves ordinary whitespace unrelated to # or ## untouched" do
+        input = "#define M(x) void  f  (  )  ;\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+    end
+
   end
 
   context "#filter_directive" do

data/spec/units/includes/includes_spec.rb

@@ -412,18 +412,36 @@ describe "Includes sorting" do
         MockInclude.new("mock_module.h"),
         UserInclude.new("config.h")
       ]
-      
+
       Includes.sort!(includes)
-      
+
       expect(includes.length).to eq(3)
       expect(includes[0]).to be_a(UserInclude)
       expect(includes[1]).to be_a(UserInclude)
       expect(includes[2]).to be_a(UserInclude)
     end
 
+    # Ruby's sort/sort_by family does not guarantee a stable sort -- every UserInclude
+    # here ties on the same comparator value, so a comparator-sort-based implementation
+    # is free to reorder them unpredictably across Ruby versions/platforms even with no
+    # actual duplicates present. This is the shape that exposed that gap in practice.
+    it "preserves each group's own original relative order exactly, not just which group it ends up in" do
+      header1 = UserInclude.new("header1.h")
+      header2 = UserInclude.new("header2.h")
+      header3 = UserInclude.new("header3.h")
+      stdio   = SystemInclude.new("stdio.h")
+      stdlib  = SystemInclude.new("stdlib.h")
+
+      includes = [header1, stdio, header2, stdlib, header3]
+
+      result = Includes.sort!(includes)
+
+      expect(result).to eq([stdio, stdlib, header1, header2, header3])
+    end
+
     it "handles empty array" do
       includes = []
-      
+
       result = Includes.sort!(includes)
       
       expect(result).to eq([])

data/spec/units/partials/partializer_spec.rb

@@ -547,6 +547,46 @@ describe Partializer do
 
       expect(result).to match_array([UserInclude.new('header1.h')])
     end
+
+    # The shared types header's own top-of-file guard-spoofing macro must
+    # be defined before anything later in the list gets a chance to transitively
+    # re-include this module's real header a second, unguarded way -- splicing the
+    # types header in at the module's own original position (rather than appending it
+    # after everything else) is what guarantees that ordering.
+    it "splices the shared types header in at the module's own original list position, not at the end" do
+      includes = [
+        UserInclude.new('header1.h'),
+        UserInclude.new('module.h'),
+        UserInclude.new('header2.h')
+      ]
+      result = @partializer.remap_implementation_header_includes(
+        name: 'module',
+        includes: includes,
+        partials: {},
+        types_header: 'ceedling_partial_module_types.h'
+      )
+
+      expect(result).to eq([
+        UserInclude.new('header1.h'),
+        UserInclude.new('ceedling_partial_module_types.h'),
+        UserInclude.new('header2.h')
+      ])
+    end
+
+    it "appends the shared types header when the module's own header wasn't in the includes list to begin with" do
+      includes = [UserInclude.new('header1.h')]
+      result = @partializer.remap_implementation_header_includes(
+        name: 'module',
+        includes: includes,
+        partials: {},
+        types_header: 'ceedling_partial_module_types.h'
+      )
+
+      expect(result).to eq([
+        UserInclude.new('header1.h'),
+        UserInclude.new('ceedling_partial_module_types.h')
+      ])
+    end
   end
 
   ###
@@ -733,6 +773,28 @@ describe Partializer do
 
       expect(result).to match_array([UserInclude.new('header1.h')])
     end
+
+    # See the matching example in #remap_implementation_header_includes for the full
+    # rationale; the mockable interface header needs the identical ordering guarantee.
+    it "splices the shared types header in at the module's own original list position, not at the end" do
+      includes = [
+        UserInclude.new('header1.h'),
+        UserInclude.new('module.h'),
+        UserInclude.new('header2.h')
+      ]
+      result = @partializer.remap_interface_header_includes(
+        name: 'module',
+        includes: includes,
+        partials: {},
+        types_header: 'ceedling_partial_module_types.h'
+      )
+
+      expect(result).to eq([
+        UserInclude.new('header1.h'),
+        UserInclude.new('ceedling_partial_module_types.h'),
+        UserInclude.new('header2.h')
+      ])
+    end
   end
 
   ###

data/vendor/unity/auto/generate_test_runner.rb

@@ -200,8 +200,10 @@ class UnityTestRunnerGenerator
     source_lines = source.split("\n")
     source_index = 0
     tests_and_line_numbers.size.times do |i|
+      # Compile once per test
+      name_regex = /(?:^|\s)#{tests_and_line_numbers[i][:test]}(?:\s|\()/
       source_lines[source_index..].each_with_index do |line, index|
-        next unless line =~ /\s+#{tests_and_line_numbers[i][:test]}(?:\s|\()/
+        next unless line =~ name_regex
 
         source_index += index
         tests_and_line_numbers[i][:line_number] = source_index + 1

data/vendor/unity/auto/unity_test_summary.rb

@@ -124,7 +124,7 @@ if $0 == __FILE__
   begin
     # look in the specified or current directory for result files
     args[0] ||= './'
-    targets = "#{ARGV[0].tr('\\', '/')}**/*.test*"
+    targets = "#{args[0].tr('\\', '/')}**/*.test*"
     results = Dir[targets]
 
     raise "No *.testpass, *.testfail, or *.testresults files found in '#{targets}'" if results.empty?
@@ -133,7 +133,7 @@ if $0 == __FILE__
 
     # set the root path
     args[1] ||= "#{Dir.pwd}/"
-    uts.root = ARGV[1]
+    uts.root = args[1]
 
     # run the summarizer
     puts uts.run

data/vendor/unity/docs/UnityChangeLog.md

@@ -13,6 +13,13 @@ Prior to 2008, the project was an internal project and not released to the publi
 
 ## Log
 
+### Unity 2.7.2
+
+Significant Bugfixes:
+
+  - Default `UNITY_INCLUDE_EXEC_TIME` macros compile as ISO C99, are statement-safe, and accept `-Wsign-conversion` (#838)
+  - `unity_test_summary.rb` honors its own default result directory and root path again. @youdie006
+
 ### Unity 2.7.0 (July 2026)
 
 New Features:

data/vendor/unity/docs/UnityConfigurationGuide.md

@@ -488,6 +488,10 @@ Define this to measure and report execution time for each test in the suite. Whe
 it's best to automatically find a way to determine the time in milliseconds. On most Windows, macos, or 
 Linux environments, this is automatic. If not, you can give Unity more information.
 
+On Unix and macOS, the default uses POSIX `clock_gettime(CLOCK_MONOTONIC)` when that clock is available.
+If it is not (strict ISO C with no POSIX clocks in `<time.h>`), it falls back to the standard `clock()` function,
+which is also the Windows default.
+
 #### `UNITY_CLOCK_MS`
 
 If you're working on a system (embedded or otherwise) which has an accessible millisecond timer. You can

data/vendor/unity/src/unity_internals.h

@@ -395,33 +395,34 @@ typedef UNITY_FLOAT_TYPE UNITY_FLOAT;
       !defined(UNITY_EXEC_TIME_STOP) && \
       !defined(UNITY_PRINT_EXEC_TIME) && \
       !defined(UNITY_TIME_TYPE)
-      /* If none any of these macros are defined then try to provide a default implementation */
+      /* If none of these macros are defined then try to provide a default implementation */
 
     #if defined(UNITY_CLOCK_MS)
       /* This is a simple way to get a default implementation on platforms that support getting a millisecond counter */
       #define UNITY_TIME_TYPE UNITY_UINT
       #define UNITY_EXEC_TIME_START() Unity.CurrentTestStartTime = UNITY_CLOCK_MS()
       #define UNITY_EXEC_TIME_STOP() Unity.CurrentTestStopTime = UNITY_CLOCK_MS()
-      #define UNITY_PRINT_EXEC_TIME() { \
+      #define UNITY_PRINT_EXEC_TIME() do { \
         UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \
         UnityPrint(" ("); \
         UnityPrintNumberUnsigned(execTimeMs); \
         UnityPrint(" ms)"); \
-        }
+        } while (0)
     #elif defined(_WIN32)
       #include <time.h>
       #define UNITY_TIME_TYPE clock_t
       #define UNITY_GET_TIME(t) t = (clock_t)((clock() * 1000) / CLOCKS_PER_SEC)
       #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime)
       #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime)
-      #define UNITY_PRINT_EXEC_TIME() { \
-        UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \
+      #define UNITY_PRINT_EXEC_TIME() do { \
+        UNITY_UINT execTimeMs = (UNITY_UINT)(Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \
         UnityPrint(" ("); \
         UnityPrintNumberUnsigned(execTimeMs); \
         UnityPrint(" ms)"); \
-        }
+        } while (0)
     #elif defined(__unix__) || defined(__APPLE__)
       #include <time.h>
+      #if defined(CLOCK_MONOTONIC)
       #define UNITY_TIME_TYPE struct timespec
       #define UNITY_GET_TIME(t) clock_gettime(CLOCK_MONOTONIC, &t)
       #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime)
@@ -432,7 +433,20 @@ typedef UNITY_FLOAT_TYPE UNITY_FLOAT;
         UnityPrint(" ("); \
         UnityPrintNumberUnsigned(execTimeMs); \
         UnityPrint(" ms)"); \
-        } while(0)
+        } while (0)
+      #else
+      /* CLOCK_MONOTONIC is POSIX, not ISO C. Fall back so -std=c99 still compiles. */
+      #define UNITY_TIME_TYPE clock_t
+      #define UNITY_GET_TIME(t) t = (clock_t)((clock() * 1000) / CLOCKS_PER_SEC)
+      #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime)
+      #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime)
+      #define UNITY_PRINT_EXEC_TIME() do { \
+        UNITY_UINT execTimeMs = (UNITY_UINT)(Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \
+        UnityPrint(" ("); \
+        UnityPrintNumberUnsigned(execTimeMs); \
+        UnityPrint(" ms)"); \
+        } while (0)
+      #endif
     #endif
   #endif
 #endif

data/vendor/unity/test/Makefile

@@ -43,7 +43,7 @@ TARGET = build/testunity-cov.exe
 # To generate coverage, call 'make -s', the default target runs.
 # For verbose output of all the tests, run 'make test'.
 default: test
-.PHONY: default coverage test clean
+.PHONY: default coverage test clean intDetection execTimeDetection
 coverage: $(SRC1) $(SRC2) $(SRC3) $(SRC4) $(SRC5) $(SRC6) $(SRC7) $(SRC8)
 	cd $(BUILD_DIR) && \
 	$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC1), ../$i) $(COV_FLAGS) -o ../$(TARGET)
@@ -122,10 +122,17 @@ test: $(SRC1) $(SRC2) $(SRC3) $(SRC4) $(SRC5) $(SRC6) $(SRC7) $(SRC8)
 
 # Compile only, for testing that preprocessor detection works
 UNITY_C_ONLY =-c ../src/unity.c -o $(BUILD_DIR)/unity.o
-intDetection:
+intDetection: | $(BUILD_DIR)
 	$(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_STDINT_H
 	$(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_LIMITS_H
 
+# UNITY_INCLUDE_EXEC_TIME is optional and was historically untested, so the
+# default timer macros could rot. Compile them with Unity's own warning flags
+# and with -Wsign-conversion (the failure reported in #838).
+execTimeDetection: | $(BUILD_DIR)
+	$(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_INCLUDE_EXEC_TIME
+	$(CC) $(CFLAGS) -Wsign-conversion $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_INCLUDE_EXEC_TIME
+
 $(BUILD_DIR)/test_unity_arraysRunner.c: tests/test_unity_arrays.c | $(BUILD_DIR)
 	awk $(AWK_SCRIPT) tests/test_unity_arrays.c > $@
 

data/vendor/unity/test/rakefile_helper.rb

@@ -407,6 +407,7 @@ module RakefileHelpers
     combined_output = ''
     [ "make -s",                 # test with all defaults
       "make -s coverage",        # test with coverage
+      "make -s execTimeDetection", # compile default UNITY_INCLUDE_EXEC_TIME macros
       "cd #{File.join("..","extras","fixture",'test')} && make -s default noStdlibMalloc",
       "cd #{File.join("..","extras","fixture",'test')} && make -s C89",
       "cd #{File.join("..","extras","memory",'test')} && make -s default noStdlibMalloc",

data/vendor/unity/test/tests/test_generate_test_runner.rb

@@ -1334,6 +1334,55 @@ should 'GenerateSuiteTeardownWhenBeginAndEndAreOmitted' do
   $generate_test_runner_tests += 1
 end
 
+should 'FindTestsLineNumbersWhenNameStartsTheLine' do
+  # The return type may sit on its own line, leaving the test name at column 0.
+  # The line search must still find the definition (and must not scan to the end
+  # of the file for every test, which is what made large files slow).
+  source = "#include \"unity.h\"\n" \
+           "\n" \
+           "void\n" \
+           "test_FirstAtColumnZero(void)\n" \
+           "{\n" \
+           "}\n" \
+           "\n" \
+           "void\n" \
+           "test_SecondAtColumnZero(void)\n" \
+           "{\n" \
+           "}\n"
+  found = UnityTestRunnerGenerator.new({}).find_tests(source).map { |t| [t[:test], t[:line_number]] }
+  expected = [['test_FirstAtColumnZero', 4], ['test_SecondAtColumnZero', 9]]
+  if found == expected
+    report 'Runner_FindTestsLineNumbersWhenNameStartsTheLine:PASS'
+  else
+    report "  FAIL: expected #{expected.inspect}, got #{found.inspect}"
+    report 'Runner_FindTestsLineNumbersWhenNameStartsTheLine:FAIL'
+    $generate_test_runner_failures += 1
+  end
+  $generate_test_runner_tests += 1
+end
+
+should 'FindTestsLineNumbersWhenOneNameIsAPrefixOfAnother' do
+  # Issue #288: test_my_function must not be located inside
+  # test_my_function_invalid_behavior, which is defined first.
+  source = "void test_my_function_invalid_behavior(void)\n" \
+           "{\n" \
+           "}\n" \
+           "\n" \
+           "void test_my_function(void)\n" \
+           "{\n" \
+           "}\n"
+  found = UnityTestRunnerGenerator.new({}).find_tests(source).map { |t| [t[:test], t[:line_number]] }
+  expected = [['test_my_function_invalid_behavior', 1], ['test_my_function', 5]]
+  if found == expected
+    report 'Runner_FindTestsLineNumbersWhenOneNameIsAPrefixOfAnother:PASS'
+  else
+    report "  FAIL: expected #{expected.inspect}, got #{found.inspect}"
+    report 'Runner_FindTestsLineNumbersWhenOneNameIsAPrefixOfAnother:FAIL'
+    $generate_test_runner_failures += 1
+  end
+  $generate_test_runner_tests += 1
+end
+
 RUNNER_TESTS.each do |testset|
   basename = File.basename(testset[:testfile], C_EXTENSION)
   testset_name = "Runner_#{basename}_#{testset[:name]}"

data/vendor/unity/test/tests/test_unity_test_summary.rb

@@ -0,0 +1,58 @@
+# =========================================================================
+#   Unity - A Test Framework for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'fileutils'
+require_relative '../../auto/colour_reporter'
+
+# the 'test:scripts' rake task tallies these, so only initialize them if we are loaded first
+$generate_test_runner_tests ||= 0
+$generate_test_runner_failures ||= 0
+$unity_test_summary_failures = 0
+
+SUMMARY_SCRIPT  = File.expand_path('../../auto/unity_test_summary.rb', __dir__)
+SUMMARY_SANDBOX = File.expand_path('../sandbox/test_summary', __dir__)
+SUMMARY_RESULTS = <<~RESULTS
+  test/test_a.c:12:test_thing:PASS
+  test/test_b.c:34:test_broken:FAIL: Expected 1 Was 2
+  test/test_c.c:56:test_skipped:IGNORE: not ready
+
+  -----------------------
+  3 Tests 1 Failures 1 Ignored
+RESULTS
+
+def summary_test(name, passed)
+  if passed
+    report "#{name}:PASS"
+  else
+    report "#{name}:FAIL"
+    $generate_test_runner_failures += 1
+    $unity_test_summary_failures += 1
+  end
+  $generate_test_runner_tests += 1
+end
+
+FileUtils.rm_rf(SUMMARY_SANDBOX)
+FileUtils.mkdir_p(SUMMARY_SANDBOX)
+File.write(File.join(SUMMARY_SANDBOX, 'test_sample.testfail'), SUMMARY_RESULTS)
+
+begin
+  Dir.chdir(SUMMARY_SANDBOX) do
+    # with no arguments at all, the result files are looked for in the current directory
+    output = `ruby "#{SUMMARY_SCRIPT}" 2>&1`
+    summary_test('UnityTestSummary_DefaultsResultDirectoryToCurrentDirectory',
+                 $?.success? && output.include?('3 TOTAL TESTS 1 TOTAL FAILURES 1 IGNORED'))
+
+    # with only a result directory given, the root path defaults to the current directory
+    expected = "#{Dir.pwd}/test/test_b.c:34".tr('/', '\\')
+    output = `ruby "#{SUMMARY_SCRIPT}" ./ 2>&1`
+    summary_test('UnityTestSummary_DefaultsRootPathToCurrentDirectory', output.include?(expected))
+  end
+ensure
+  FileUtils.rm_rf(SUMMARY_SANDBOX)
+end
+
+raise "There were #{$unity_test_summary_failures} failures while testing unity_test_summary.rb" if $unity_test_summary_failures > 0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ceedling
 version: !ruby/object:Gem::Version
-  version: 1.1.8
+  version: 1.1.9
 platform: ruby
 authors:
 - Mark VanderVoord
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-10 00:00:00.000000000 Z
+date: 2026-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -1739,6 +1739,7 @@ files:
 - vendor/unity/test/tests/test_unity_parameterized.c
 - vendor/unity/test/tests/test_unity_parameterizedDemo.c
 - vendor/unity/test/tests/test_unity_strings.c
+- vendor/unity/test/tests/test_unity_test_summary.rb
 - vendor/unity/test/tests/types_for_test.h
 - vendor/unity/unityConfig.cmake
 homepage: https://throwtheswitch.org/ceedling