ceedling 1.1.7 → 1.1.9

data/spec/units/generators/generator_partials_spec.rb

@@ -397,6 +397,56 @@ describe GeneratorPartials do
 
       expect( buf.string ).to_not include("#define FOO 1")
     end
+
+    # #1262: two consecutive typedefs (no macro carry-forward involved at
+    # all) had no byte-exact adjacency coverage -- only the macro-before-
+    # typedef pending_macros path did.
+    it "emits two consecutive typedefs each on their own line" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      typedef_a = CExtractorTypes::CStatement.new(text: "typedef uint8_t Byte;", line_num: 1)
+      typedef_b = CExtractorTypes::CStatement.new(text: "typedef uint16_t Word;", line_num: 2)
+
+      c_module = CExtractorTypes::CModule.new(
+        type_definitions: [typedef_a, typedef_b],
+        element_sequence: [typedef_a, typedef_b]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string ).to include( "typedef uint8_t Byte;\ntypedef uint16_t Word;\n" )
+    end
+
+    # #1262: same gap for two consecutive aggregate definitions.
+    it "emits two consecutive aggregate definitions each on their own line" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      aggregate_a = CExtractorTypes::CStatement.new(text: "struct Point { int x; int y; };", line_num: 1)
+      aggregate_b = CExtractorTypes::CStatement.new(text: "struct Color { int r; int g; int b; };", line_num: 2)
+
+      c_module = CExtractorTypes::CModule.new(
+        aggregate_definitions: [aggregate_a, aggregate_b],
+        element_sequence:      [aggregate_a, aggregate_b]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string ).to include( "struct Point { int x; int y; };\nstruct Color { int r; int g; int b; };\n" )
+    end
   end
 
   context "#generate_header (private method)" do
@@ -555,6 +605,54 @@ describe GeneratorPartials do
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
+    # #1262: a header with several single-line macros in a row and nothing
+    # type-defining after them (so generate_types never runs at all, per its
+    # own empty-module guard) is the ordinary, ungoverned case -- every macro
+    # here goes through this inline CStatement branch, not generate_types'
+    # own carry-forward logic, which already had its own adjacency coverage.
+    it "emits three consecutive macros each on their own line, with nothing following them" do
+      file_contents = <<~CONTENTS
+      #ifndef __CEEDLING_GENERATED_REGS_H__
+      #define __CEEDLING_GENERATED_REGS_H__
+
+      #define START_ADDRESS 0x00
+      #define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)
+      #define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)
+
+      #endif // __CEEDLING_GENERATED_REGS_H__
+
+      CONTENTS
+
+      c_module = make_module(
+        make_stmt(text: "#define START_ADDRESS 0x00", line_num: 1),
+        make_stmt(text: "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)", line_num: 2),
+        make_stmt(text: "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)", line_num: 3)
+      )
+
+      @generator.send(:generate_header, buf, 'regs', [], [], c_module, false)
+      expect( buf.string.strip() ).to eq file_contents.strip()
+    end
+
+    # #1262 regression: the actual reported shape -- one macro's trailing // comment
+    # includes an apostrophe. Extraction is what previously merged the macros (see
+    # c_extractor specs); this confirms generate_header still emits each item's text,
+    # comment included, on its own line once extraction is correct.
+    it "emits each macro on its own line even when one has a trailing comment with an apostrophe (GH #1262)" do
+      c_module = make_module(
+        make_stmt(text: "#define START_ADDRESS 0x00 // don't change this", line_num: 1),
+        make_stmt(text: "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)", line_num: 2),
+        make_stmt(text: "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)", line_num: 3)
+      )
+
+      @generator.send(:generate_header, buf, 'regs', [], [], c_module, false)
+
+      expect( buf.string ).to include(
+        "#define START_ADDRESS 0x00 // don't change this\n" +
+        "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)\n" +
+        "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)\n"
+      )
+    end
+
     it "should emit macro and variable statements inline while routing typedefs and aggregates to the shared types header" do
       # One item of each category that can appear in a generated Partial header:
       #   macro_definitions     → CStatement emitted as-is, inline

data/spec/units/generators/generator_test_results_backtrace_spec.rb

@@ -379,6 +379,32 @@ describe GeneratorTestResultsBacktrace do
       expect(crash_line).not_to include('failed to extract')
     end
 
+    # #1266 follow-on: the same unanchored-substring risk class as #1262/#1266, here in the
+    # "prefer whichever unresolved member's own symbol is named in the backtrace" search --
+    # no \b before the escaped symbol, so a shorter unresolved symbol that's a suffix of a
+    # longer one actually named in the crash frame can false-match and steal the attribution.
+    it 'attributes a crash to the member whose symbol actually appears in the backtrace, not a shorter symbol that is merely its suffix' do
+      test_cases_suffix = [
+        { test: 'test_x(1)', symbol: 'foo',    line_number: 10 },
+        { test: 'test_x(2)', symbol: 'my_foo', line_number: 20 }
+      ]
+      filename_suffix = 'test_module.c'
+
+      crash_output = <<~GDB
+        Program received signal SIGSEGV, Segmentation fault.
+        0x00005618066ea1fb in my_foo () at test/test_module.c:42
+        #0  0x00005618066ea1fb in my_foo () at test/test_module.c:42
+      GDB
+
+      allow(@tool_executor).to receive(:exec)
+        .and_return({ output: crash_output, time: 0.5, exit_code: 139, stderr: '', status: @ok_status })
+
+      expect(@file_wrapper).to receive(:write)
+        .with('/build/logs/test/test_module/test_x(2).gdb.log', /=== test_x\(2\) ===/, 'a')
+
+      @backtrace.do_gdb( filename_suffix, executable, shell_result, test_cases_suffix, context: :test )
+    end
+
     it 'handles a SIGABRT crash from assert() — shows assertion text, no source line' do
       test_cases_assert = [{ test: 'test_asserting', symbol: 'test_asserting', line_number: 8 }]
 

data/spec/units/generators/generator_test_runner_spec.rb

@@ -86,6 +86,29 @@ describe GeneratorTestRunner do
 
       expect( test_cases.first[:line_number] ).to eq( 5 )
     end
+
+    # #1266 follow-on: the same unanchored-substring risk class as #1262/#1266. A static
+    # helper function between two test cases whose name merely contains a later test's
+    # name as a substring (here "test_ab" inside "reset_test_ab_state") must not steal
+    # that test's line number, and an unescaped test name must not be treated as a regex.
+    it 'does not false-match a test name against an unrelated line that merely contains it as a substring' do
+      source = <<~SOURCE
+        void test_a(void) {}
+        void reset_test_ab_state(void) {}
+        void test_ab(void) {}
+      SOURCE
+
+      runner = build_runner( test_file_contents: source, preprocessed_file_contents: source )
+      test_cases = [
+        { test: 'test_a',  line_number: 0 },
+        { test: 'test_ab', line_number: 0 }
+      ]
+
+      runner.send( :remap_line_numbers!, test_cases, source )
+
+      expect( test_cases[0][:line_number] ).to eq( 1 )
+      expect( test_cases[1][:line_number] ).to eq( 3 )
+    end
   end
 
   describe '#initialize / #test_cases' 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/spec/units/preprocess/preprocessinator_line_marker_includes_extractor_spec.rb

@@ -0,0 +1,64 @@
+# =========================================================================
+#   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_helper'
+require 'ceedling/preprocess/preprocessinator_line_marker_includes_extractor'
+require 'ceedling/includes/includes'
+
+# Regression coverage for GH #1268 only -- this class otherwise has no unit spec on this
+# branch. Built on #extract_includes_from_string, a StringIO wrapper around the same
+# private #extract_includes every production call eventually reaches.
+describe PreprocessinatorLineMarkerIncludesExtractor do
+  before(:each) do
+    @include_factory = double('include_factory')
+
+    allow(@include_factory).to receive(:user_include_from_filepath) do |filepath|
+      UserInclude.new(filepath)
+    end
+    allow(@include_factory).to receive(:system_include_from_filepath) do |filepath|
+      SystemInclude.new(filepath)
+    end
+
+    @extractor = described_class.new(
+      :include_factory => @include_factory
+    )
+  end
+
+  def paths_of(includes)
+    includes.map(&:filepath)
+  end
+
+  describe '#extract_includes_from_string' do
+    # #1268: GCC's -fdirectives-only output preserves the ORIGINAL indentation of a
+    # top-level #include when it replaces that directive with a line marker entering
+    # the included file -- an indented `    #include "widget.h"` produces an indented
+    # `    # 1 "widget.h" 1`, not the flush-left marker every other marker GCC
+    # generates uses. LINE_MARKER_REGEX must recognize that marker too, or the include
+    # is silently missing from the extracted list entirely.
+    it 'recognizes a line marker that is itself indented (e.g. from an indented #include)' do
+      content = <<~OUTPUT
+        # 1 "test.c"
+            # 1 "widget.h" 1
+      OUTPUT
+
+      includes = @extractor.extract_includes_from_string( content, 'test.c', described_class::USER )
+
+      expect( paths_of(includes) ).to eq( ['widget.h'] )
+    end
+
+    it 'still recognizes an ordinary, flush-left line marker' do
+      content = <<~OUTPUT
+        # 1 "test.c"
+        # 1 "widget.h" 1
+      OUTPUT
+
+      includes = @extractor.extract_includes_from_string( content, 'test.c', described_class::USER )
+
+      expect( paths_of(includes) ).to eq( ['widget.h'] )
+    end
+  end
+end

data/spec/units/preprocess/preprocessinator_reconstructor_spec.rb

@@ -211,6 +211,41 @@ describe PreprocessinatorReconstructor do
       expect( @extractor.extract_file_as_array_from_expansion(input, filepath) ).to eq expected
     end
   
+    # #1268: GCC's -fdirectives-only output preserves the ORIGINAL indentation of a
+    # top-level #include when it replaces that directive with a line marker entering
+    # the included file -- e.g. a source line "    #include \"Module3.h\"" produces
+    # "    # 1 \"Module3.h\" 1", not the flush-left "# 1 ..." this method's marker
+    # regexes assumed every marker would be. An unrecognized entering-marker leaves
+    # `extract` stuck at whatever it already was instead of turning off, so the
+    # marker line itself (and everything up to the NEXT recognized marker, e.g. one
+    # from a nested system include triggered from inside the ignored file) leaks into
+    # the extracted output before the ping-pong finally self-corrects.
+    it "does not leak file content when the marker entering an included file is itself indented" do
+      filepath = "dir/our_file.c"
+
+      file_contents = [
+        '# 1 "dir/our_file.c"',
+        'void wanted_before(void);',
+        '    # 1 "dir/included.h" 1',        # indented entering-marker (leading whitespace from source)
+        'int leaked_from_included_h;',
+        '# 1 "/usr/include/nested.h" 1 3 4',  # a normal, flush-left marker from within included.h
+        'int also_should_not_leak;',
+        '# 2 "dir/included.h" 2',             # returning from nested.h back into included.h (still not our file)
+        'int still_should_not_leak;',
+        '# 3 "dir/our_file.c" 2',             # returning to our file
+        'void wanted_after(void);',
+      ]
+
+      expected = [
+        'void wanted_before(void);',
+        'void wanted_after(void);',
+      ]
+
+      input = StringIO.new( file_contents.join( "\n" ) )
+
+      expect( @extractor.extract_file_as_array_from_expansion( input, filepath ) ).to eq expected
+    end
+
     it "should extract text of original file from preprocessed expansion ignoring embedded expansions having similar names" do
       filepath = "dir1/dir2/our_file.c"
       
@@ -798,6 +833,45 @@ describe PreprocessinatorReconstructor do
       expect( @extractor.extract_macro_defs( file_text, '_INCLUDE_GUARD_' ) ).to eq expected
     end
 
+    # #1266: a plain substring test against the include guard rejected any macro whose
+    # name OR value merely contained the guard string, not only the guard macro itself.
+    # RTC_HOUR_SECONDS' own name contains the guard "RTC_H", and RTC_DAY_SECONDS'
+    # *value* references RTC_HOUR_SECONDS, so its captured text also contains "RTC_H" --
+    # both were silently dropped from the reconstructed header, breaking compilation.
+    it "does not reject an ordinary macro whose name or value merely contains the include guard as a substring (GH #1266)" do
+      file_text = <<~FILE_TEXT
+        #ifndef RTC_H
+        #define RTC_H
+
+        #define RTC_MINUTE_SECONDS 60u
+        #define RTC_HOUR_SECONDS (60u * RTC_MINUTE_SECONDS)
+        #define RTC_DAY_SECONDS (24u * RTC_HOUR_SECONDS)
+
+        #endif
+      FILE_TEXT
+
+      expected = [
+        "#define RTC_MINUTE_SECONDS 60u",
+        "#define RTC_HOUR_SECONDS (60u * RTC_MINUTE_SECONDS)",
+        "#define RTC_DAY_SECONDS (24u * RTC_HOUR_SECONDS)"
+      ]
+
+      expect( @extractor.extract_macro_defs( file_text, 'RTC_H' ) ).to eq expected
+    end
+
+    it "still rejects the include guard when it appears with trailing whitespace instead of a value" do
+      file_text = <<~FILE_TEXT
+        #ifndef RTC_H
+        #define RTC_H
+
+        #define RTC_MINUTE_SECONDS 60u
+      FILE_TEXT
+
+      expected = [ "#define RTC_MINUTE_SECONDS 60u" ]
+
+      expect( @extractor.extract_macro_defs( file_text, 'RTC_H' ) ).to eq expected
+    end
+
   end
 
   context "#compact_file_from_expansion" do

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]}"