ceedling 1.0.1 → 1.1.0

data/spec/units/tool_validator_spec.rb

@@ -0,0 +1,60 @@
+# =========================================================================
+#   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/constants'
+require 'ceedling/tool_validator'
+require 'ceedling/ruby_expandinator'
+require 'ceedling/exceptions'
+
+# Scoped narrowly to the inline Ruby string expansion (--ruby-replacement) fail-fast
+# gating behavior introduced by RubyExpandinator. Broader ToolValidator coverage is a
+# pre-existing gap outside this feature's scope.
+describe ToolValidator do
+  before(:each) do
+    @file_wrapper = double('file_wrapper').as_null_object
+    @loginator = double('loginator').as_null_object
+    @system_wrapper = double('system_wrapper').as_null_object
+    @reportinator = double('reportinator').as_null_object
+    @ruby_expandinator = RubyExpandinator.new
+
+    @tool_validator = described_class.new(
+      {
+        :file_wrapper => @file_wrapper,
+        :loginator => @loginator,
+        :system_wrapper => @system_wrapper,
+        :reportinator => @reportinator,
+        :ruby_expandinator => @ruby_expandinator
+      }
+    )
+  end
+
+  describe '#validate — Ruby replacement pattern in :executable' do
+    let(:tool) { { :name => 'my_tool', :executable => '#{1+1}' } }
+
+    it 'raises CeedlingException (fail-fast, not deferred) when the feature is disabled and boom is true' do
+      expect {
+        @tool_validator.validate( tool: tool, extension: '.exe', boom: true )
+      }.to raise_error(CeedlingException, /my_tool/)
+    end
+
+    it 'logs and returns false when the feature is disabled and boom is false' do
+      expect(@loginator).to receive(:log).with(/my_tool/, anything)
+
+      expect(@tool_validator.validate( tool: tool, extension: '.exe', boom: false )).to eq(false)
+    end
+
+    it 'passes validation (deferring to shell at run time) when the feature is enabled' do
+      @ruby_expandinator.enable!
+
+      # Assert no exception (the fail-fast gate this spec targets doesn't trigger) --
+      # not asserting the aggregate `valid` boolean, since validate() also folds in
+      # validate_stderr_redirect()'s result, which is outside this spec's scope.
+      expect { @tool_validator.validate( tool: tool, extension: '.exe', boom: true ) }.not_to raise_error
+    end
+  end
+end

data/spec/units/yaml_wrapper_spec.rb

@@ -0,0 +1,108 @@
+# =========================================================================
+#   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/yaml_wrapper'
+
+describe YamlWrapper do
+  before(:each) do
+    @yaml_wrapper = described_class.new
+  end
+
+  describe '#load_string' do
+    it 'deserializes colon-prefixed keys as symbols and other keys as strings' do
+      yaml = <<~YAML
+        :foo: 1
+        bar: 2
+      YAML
+
+      expect(@yaml_wrapper.load_string(yaml)).to eq({ foo: 1, "bar" => 2 })
+    end
+
+    it 'resolves YAML aliases' do
+      yaml = <<~YAML
+        defaults: &defaults
+          :timeout: 30
+        production:
+          <<: *defaults
+          :timeout: 60
+      YAML
+
+      result = @yaml_wrapper.load_string(yaml)
+
+      expect(result["production"][:timeout]).to eq(60)
+      expect(result["defaults"][:timeout]).to eq(30)
+    end
+
+    it 'round-trips a nested Hash with symbol keys, mirroring test-result usage' do
+      structure = { source: { file: 'foo.c', dirname: '.', basename: 'foo.c' }, time: 0.006512 }
+      dumped = YAML.dump(structure)
+
+      expect(@yaml_wrapper.load_string(dumped)).to eq(structure)
+    end
+
+    # Test for protection against security vulnerabilities in YAML deserialization.
+    it 'refuses to instantiate arbitrary Ruby objects and reports it as :unsafe' do
+      yaml = "--- !ruby/object:OpenStruct {}\n"
+
+      expect { @yaml_wrapper.load_string(yaml) }.to raise_error(YamlLoadException) do |e|
+        expect(e.reason).to eq(:unsafe)
+        expect(e.message).to match(/not permitted by safe YAML loading/i)
+      end
+    end
+
+    it 'reports malformed YAML content as :syntax' do
+      yaml = "a: [1, 2\n" # unterminated flow sequence
+
+      expect { @yaml_wrapper.load_string(yaml) }.to raise_error(YamlLoadException) do |e|
+        expect(e.reason).to eq(:syntax)
+        expect(e.message).to match(/malformed yaml content/i)
+      end
+    end
+
+    it 'embeds the source_label in the underlying Psych message' do
+      yaml = "a: [1, 2\n"
+
+      expect { @yaml_wrapper.load_string(yaml, source_label: 'my_project.yml') }.to raise_error(YamlLoadException) do |e|
+        expect(e.message).to include('my_project.yml')
+      end
+    end
+  end
+
+  describe '#load' do
+    it 'reports a missing file as :not_found' do
+      expect { @yaml_wrapper.load('/no/such/file.yml') }.to raise_error(YamlLoadException) do |e|
+        expect(e.reason).to eq(:not_found)
+        expect(e.message).to match(/could not find yaml file/i)
+      end
+    end
+  end
+
+  # Test cacheing of Psych version probe that determines calling interface for safe_load.
+  describe '.psych_safe_load_uses_keywords?' do
+    def reset_memoized_psych_check
+      if described_class.instance_variable_defined?(:@psych_safe_load_uses_keywords)
+        described_class.send(:remove_instance_variable, :@psych_safe_load_uses_keywords)
+      end
+    end
+
+    before(:each) { reset_memoized_psych_check }
+    after(:each)  { reset_memoized_psych_check }
+
+    it 'selects the keyword calling convention for Psych >= 4.0' do
+      stub_const('Psych::VERSION', '4.0.0')
+
+      expect(described_class.psych_safe_load_uses_keywords?).to eq(true)
+    end
+
+    it 'selects the positional calling convention for Psych < 4.0' do
+      stub_const('Psych::VERSION', '3.3.2')
+
+      expect(described_class.psych_safe_load_uses_keywords?).to eq(false)
+    end
+  end
+end

data/vendor/cmock/Gemfile

@@ -1 +1,4 @@
-source "http://rubygems.org/"
+source "https://rubygems.org/"
+
+gem 'rspec'
+gem 'rubocop', '1.57.2'

data/vendor/cmock/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/vendor/cmock/config/production_environment.rb

@@ -1,7 +1,7 @@
 # =========================================================================
 #   CMock - Automatic Mock Generation for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 

data/vendor/cmock/config/test_environment.rb

@@ -1,7 +1,7 @@
 # =========================================================================
 #   CMock - Automatic Mock Generation for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 

data/vendor/cmock/docs/CMockChangeLog.md

@@ -13,6 +13,53 @@ Prior to 2008, the project was an internal project and not released to the publi
 
 ## Log
 
+### CMock 2.7.0 (July 2026)
+
+New Features:
+
+  - Significant improvements to array and pointer handling:
+    - Arrays are now passed as arrays. Yes, even multidimensional ones. (Fixes #69, #119, #213, #422)
+    - Array plugin now supports comparing `char*` (string) arguments as byte arrays via `_ExpectWithArray`, while still treating them as strings via `_Expect` (Fixes #262 and #177)
+    - Improved automatic detection of pointer/length argument pairs (Fixes #520)
+    - When a pointer is auto-paired with a size argument, `_ExpectWithArrayExtended` is also generated as a fallback to allow explicit depth override (Fixes #476)
+    - `void*` arguments now default to pointer comparison without the array plugin, and to byte-by-byte comparison when the array plugin is active (Fixes #400)
+    - Handles *simple* preprocessor features like #if 1 and #if 0 (Fixes #163)
+    - Ignores static assertions of various types (Fixes #128)
+    - Added option to trace all mock setup and mocked calls (Implements #403)
+  - Significant improvements to header parsing speed
+
+Significant Bugfixes:
+
+  - Fixed matching of pointer/len argument pairs in reverse order (Fixes #479)
+  - Fixed handling of array of pointers or a pointer to an array (Fixes #450)
+  - Fixed const and pointer order handling issues (Fixes #484 and #485)
+  - Fixed handling of skeleton paths (Fixes #488)
+  - Fixed handling of memory alignment issues (Fixes #178)
+  - Fixed handling of failures in teardown (#67)
+  - Improved handling of function-looking structs (Fixes #513 and #334)
+  - Improved handling of function-looking macros (Fixes #502)
+  - Improved handling of volatiles (Fixes #110 and #135)
+  - Improved handling of stub and callback counters (Fixes #132)
+  - Improved handling and testing of Windows (Fixes #435)
+
+Other:
+
+  - Added verification that memory errors are reported and stop tests (Verifies #463)
+  - Added verification that CMock features pass Valgrind (Verifies #506)
+  - Documented custom type support (#124)
+
+#### Major Code/Doc Contributors
+
+These individuals contributed significant features, bugfixes, and improvements.
+
+  - Mark VanderVoord
+  - Roland Stahn
+  - bal-stan
+
+#### Also, thanks for your contributions!
+
+Matt Sullivan, Peter Backeman, ml-physec
+
 ### CMock 2.6.0 (January 2025)
 
 New Features:

data/vendor/cmock/docs/CMockKnownIssues.md

@@ -9,5 +9,4 @@ be found on our Github repository.
 ## Issues
 
   - Able to parse most C header files without preprocessor needs, but when handling headers with significant preprocessor usage (#ifdefs, etc), it can get confused
-  - Multi-dimensional arrays currently simplified to single dimensional arrays of the full size
   - Incomplete support for VarArgs

data/vendor/cmock/docs/CMock_ArgumentValidation.md

@@ -1,16 +1,32 @@
 CMock: Argument Validation
 ==========================
 
-Much of the power of CMock comes from its ability to automatically 
-validate that the arguments passed to mocked functions are the 
+Much of the power of CMock comes from its ability to automatically
+validate that the arguments passed to mocked functions are the
 values that were expected to be passed. CMock puts a lot of effort
-into guessing how the user would most like to see those values 
+into guessing how the user would most like to see those values
 compared, and then represented when failures are encountered.
 
 Like Unity, CMock follows a philosophy of making its best guesses,
-and then allowing the user to explicity specify any features that 
+and then allowing the user to explicitly specify any features that
 they would like to change or customize.
 
+Quick Reference: Which Option Should I Use?
+-------------------------------------------
+
+| Situation | Recommended Option |
+|-----------|-------------------|
+| Built-in C types (`int`, `uint8_t`, `float`, …) | Nothing — Option 1 handles these automatically |
+| Simple typedef or `#define` alias of a known type | Option 2: add a `:treat_as` entry |
+| Small `enum` type | Option 2: map to `INT8`, `INT16`, or `INT` |
+| Opaque handle / function pointer where only identity matters | Option 2: map to `PTR` |
+| `typedef`'d fixed-size array | Option 2: `:treat_as_array` |
+| Legacy `typedef void MY_VOID` | Option 2: `:treat_as_void` |
+| `struct` or `union` needing field-level comparison | Option 3: custom assertion + `:unity_helper_path` |
+| Pointer to a `struct` with a custom assertion | Option 2 + 3: custom assertion, then `:treat_as` the pointer |
+| Type that changes meaning per test, or one-off complex logic | Option 4: Callback |
+| Last resort — type is unknown and rough equality is enough | Option 1b: memcmp fallback (automatic) |
+
 Option 1: Common Types
 ----------------------
 
@@ -72,22 +88,129 @@ a custom type?
 Option 2: Treat-As
 ------------------
 
-CMock maintains a list of non-standard types which are basically 
-aliases of standard types. For example, a common shorthand for 
-a single-byte unsigned integer might be `u8` or `U8` or `UNIT8`.
-Any of these can simply be mapped to the standard 
+CMock maintains a list of non-standard types which are basically
+aliases of standard types. For example, a common shorthand for
+a single-byte unsigned integer might be `u8` or `U8` or `UINT8`.
+Any of these can simply be mapped to the standard
 `TEST_ASSERT_EQUAL_HEX8`.
 
-While CMock has its own list of `:treat_as` mappings, you can 
+### Default Handlers
+
+CMock ships with a built-in `:treat_as` list that already covers the
+most common type aliases found in embedded C codebases. You get all
+of these for free without any configuration:
+
+| C Type              | Unity Assertion Used      |
+|---------------------|---------------------------|
+| `int`               | `INT`                     |
+| `char`              | `INT8`                    |
+| `short`             | `INT16`                   |
+| `long`              | `INT`                     |
+| `unsigned int`      | `HEX32`                   |
+| `unsigned long`     | `HEX32`                   |
+| `unsigned short`    | `HEX16`                   |
+| `unsigned char`     | `HEX8`                    |
+| `int8_t` / `INT8_T` / `int8` | `INT8`         |
+| `int16_t` / `INT16_T` / `int16` | `INT16`     |
+| `int32_t` / `INT32_T` / `int32` | `INT`       |
+| `uint8_t` / `UINT8_T` / `uint8` / `UINT8` | `HEX8` |
+| `uint16_t` / `UINT16_T` / `uint16` / `UINT16` | `HEX16` |
+| `uint32_t` / `UINT32_T` / `uint32` / `UINT32` | `HEX32` |
+| `bool` / `bool_t` / `BOOL` / `BOOL_T` | `INT`  |
+| `char*`             | `STRING`                  |
+| `pCHAR` / `cstring` / `CSTRING` | `STRING`   |
+| `void*`             | `HEX8_ARRAY`              |
+| `float` / `double`  | `FLOAT`                   |
+
+The right-hand side of each mapping is the suffix of the Unity assertion
+that will be used. `HEX8` means CMock will call `TEST_ASSERT_EQUAL_HEX8`,
+for instance. Pointer variants (ending in `*`) map to the corresponding
+array assertion (e.g. `HEX8*` → `TEST_ASSERT_EQUAL_HEX8_ARRAY`).
+
+### Adding Your Own Mappings
+
+While CMock has its own list of `:treat_as` mappings, you can
 add your own pairings to this list. This works especially well for
 the following types:
 
   - aliases of standard types using `#define` or `typedef`
   - `enum` types (works well as `INT8` or whatever size your enums are)
   - function pointers often work well as `PTR` comparisons
-  - `union` types sometimes make sense to treat as the largest type... 
+  - `union` types sometimes make sense to treat as the largest type...
     but this is a judgement call
 
+Your entries **merge** with the defaults — you are only adding or
+overriding specific types, not replacing the entire list. To remove
+a default mapping, set its value to `nil`.
+
+Here is a YAML configuration example:
+
+```yaml
+:cmock:
+  :treat_as:
+    MY_BOOL:    INT           # typedef bool MY_BOOL → compare as int
+    MY_U8:      HEX8          # typedef uint8_t MY_U8 → compare as hex byte
+    MY_U16:     HEX16
+    MY_U32:     HEX32
+    STATUS_T:   INT8          # small enum → compare as signed byte
+    HANDLE_T:   PTR           # opaque pointer → compare pointer addresses
+    float:      nil           # remove the default float mapping (unusual)
+```
+
+Or from Ruby:
+
+```ruby
+CMock.new(
+  treat_as: {
+    'MY_BOOL'  => 'INT',
+    'STATUS_T' => 'INT8',
+    'HANDLE_T' => 'PTR',
+  }
+).setup_mocks('my_module.h')
+```
+
+### Pointer Types in :treat_as
+
+You can map pointer-to-custom-type the same way. Use a `*` suffix on
+the right-hand side to indicate the comparison should use the array
+variant of the assertion:
+
+```yaml
+:treat_as:
+  MY_DATA_PTR: HEX8*    # compares the bytes pointed to, not the address
+```
+
+### Related Options: :treat_as_array and :treat_as_void
+
+Two narrower variants of `:treat_as` handle specific edge cases:
+
+**`:treat_as_array`** — for types that are themselves `typedef`'d arrays,
+such as `typedef int TenIntegers[10];`. This is a hash of typedef name
+to element type:
+
+```yaml
+:cmock:
+  :treat_as_array:
+    TenIntegers: int
+    MyBuffer:    uint8_t
+```
+
+This lets CMock treat parameters of these types the same way it would
+treat a pointer-plus-count, enabling features like `ExpectWithArray`
+and `ReturnArrayThruPtr`.
+
+**`:treat_as_void`** — for legacy codebases that typedef `void` to a
+custom name (e.g. `typedef void MY_VOID;`). Add such names here so
+CMock knows functions returning or accepting that type are effectively
+`void`:
+
+```yaml
+:cmock:
+  :treat_as_void:
+    - MY_VOID
+    - NORETURN_T
+```
+
 Option 3: Custom Assertions for Custom Types
 --------------------------------------------
 
@@ -206,31 +329,63 @@ void AssertEqualMyType(const MyType expected, const MyType actual, UNITY_LINE_TY
 
 ### Wrapping our Assertion in Macros
 
-Once you have a function which does the main work, we *need* to create
-one macro, and there are a number of other macros which are useful to
-create, in order to treat our assertion just like any other Unity 
-assertion.
+Once you have a function which does the main work, we need to create
+macros around it so that the assertion can be used conveniently both
+by CMock and directly in test code.
 
-`#define UNITY_TEST_ASSERT_EQUAL_MyType(e,a,l,m) AssertEqualMyType(e,a,l,m)`
+The macro that CMock **requires** is the `UNITY_TEST_ASSERT_EQUAL_` form.
+It starts with exactly that prefix, followed by the type name exactly as
+declared, and takes four arguments:
 
-The macro above is the one that CMock is looking for. Notice that it 
-starts with `UNITY_TEST_ASSERT_EQUAL_` followed by the name of our type, 
-*exactly* the way our type is named. The arguments are, in order:
+```c
+#define UNITY_TEST_ASSERT_EQUAL_MyType(e,a,l,m)  AssertEqualMyType(e,a,l,m)
+```
 
   - `e` - expected value
   - `a` - actual value
-  - `l` - line number to report
+  - `l` - line number to report (filled in automatically by CMock)
   - `m` - message to append at the end
 
-If CMock finds a macro that matches this argument list and naming convention,
-then it can automatically use this assertion where needed... all we need to
-do now is tell CMock where to find our custom assertion.
+CMock scans the helper header for macros matching this pattern and
+automatically uses them when it encounters the corresponding type.
+
+It is also useful (though optional) to add the simpler `TEST_ASSERT_EQUAL_`
+form so the assertion is easy to call directly inside your own test
+functions:
+
+```c
+#define TEST_ASSERT_EQUAL_MyType(e,a) \
+    UNITY_TEST_ASSERT_EQUAL_MyType(e,a,__LINE__,NULL)
+
+#define TEST_ASSERT_EQUAL_MyType_MESSAGE(e,a,m) \
+    UNITY_TEST_ASSERT_EQUAL_MyType(e,a,__LINE__,m)
+```
+
+With these in place, you can write `TEST_ASSERT_EQUAL_MyType(expected, actual)`
+in your tests just like any built-in Unity assertion.
 
 ### Informing CMock about our Assertion
 
-In the CMock configuration file, in the `:cmock` or `:unity` sections, 
-there can be an option for `unity_helper_path`. Add the location of your
-new Unity helper file (file with this assertion) to this list.
+CMock needs to know which header file(s) contain your custom assertions.
+Set the `:unity_helper_path` option in your CMock configuration to point
+at the helper header:
+
+```yaml
+:cmock:
+  :unity_helper_path:
+    - test/support/my_types_helper.h
+```
+
+Or from Ruby:
+
+```ruby
+CMock.new(unity_helper_path: ['test/support/my_types_helper.h'])
+      .setup_mocks('my_module.h')
+```
+
+CMock parses each listed file, finds every `UNITY_TEST_ASSERT_EQUAL_*`
+macro definition, and uses those macros automatically when it generates
+mocks for parameters or return values of the matching types.
 
 Done!