ceedling 0.31.1 → 1.0.0

data/vendor/cmock/vendor/unity/docs/UnityConfigurationGuide.md

@@ -121,6 +121,12 @@ _Example:_
 #define UNITY_POINTER_WIDTH 64 // Set UNITY_POINTER_WIDTH to 64-bit
 ```
 
+#### `UNITY_COMPARE_PTRS_ON_ZERO_ARRAY`
+
+Define this to make all array assertions compare pointers instead of contents when a length of zero is specified. When not enabled,
+defining a length of zero will always result in a failure and a message warning the user that they have tried to compare empty
+arrays.
+
 #### `UNITY_SUPPORT_64`
 
 Unity will automatically include 64-bit support if it auto-detects it, or if your `int`, `long`, or pointer widths are greater than 32-bits.
@@ -216,6 +222,17 @@ _Example:_
 #define UNITY_FLOAT_PRECISION 0.001f
 ```
 
+#### `UNITY_IS_NAN` and `UNITY_IS_INF`
+
+If your toolchain defines `isnan` and `isinf` in `math.h` as macros, nothing needs to be done. If your toolchain doesn't define these, Unity
+will create these macros itself. You may override either or both of these defines to specify how you want to evaluate if a number is NaN or Infinity.
+
+_Example:_
+
+```C
+#define UNITY_IS_NAN(n) ((n != n) ? 1 : 0)
+```
+
 ### Miscellaneous
 
 #### `UNITY_EXCLUDE_STDDEF_H`
@@ -234,7 +251,7 @@ _Example:_
 Unity provides a simple (and very basic) printf-like string output implementation, which is able to print a string modified by the following format string modifiers:
 
 - __%d__ - signed value (decimal)
-- __%i__ - same as __%i__
+- __%i__ - same as __%d__
 - __%u__ - unsigned value (decimal)
 - __%f__ - float/Double (if float support is activated)
 - __%g__ - same as __%f__
@@ -246,6 +263,15 @@ Unity provides a simple (and very basic) printf-like string output implementatio
 - __%s__ - a string (e.g. "string")
 - __%%__ - The "%" symbol (escaped)
 
+Length specifiers are also supported. If you are using long long types, make sure UNITY_SUPPORT_64 is true to ensure they are printed correctly.
+
+- __%ld__ - signed long value (decimal)
+- __%lld__ - signed long long value (decimal)
+- __%lu__ - unsigned long value (decimal)
+- __%llu__ - unsigned long long value (decimal)
+- __%lx__ - unsigned long value (hexadecimal)
+- __%llx__ - unsigned long long value (hexadecimal)
+
 _Example:_
 
 ```C
@@ -261,7 +287,8 @@ TEST_PRINTF("Pointer   %p\n", &a);
 TEST_PRINTF("Character %c\n", 'F');
 TEST_PRINTF("String    %s\n", "My string");
 TEST_PRINTF("Percent   %%\n");
-TEST_PRINTF("Color Red \033[41mFAIL\033[00m\n");
+TEST_PRINTF("Unsigned long long %llu\n", 922337203685477580);
+TEST_PRINTF("Color Red \033[41mFAIL\033[0m\n");
 TEST_PRINTF("\n");
 TEST_PRINTF("Multiple (%d) (%i) (%u) (%x)\n", -100, 0, 200, 0x12345);
 ```
@@ -383,6 +410,68 @@ _Example:_
 #define UNITY_EXCLUDE_SETJMP
 ```
 
+#### `UNITY_TEST_PROTECT`
+
+#### `UNITY_TEST_ABORT`
+
+Unity handles test failures via `setjmp`/`longjmp` pair by default. As mentioned above, you can disable this with `UNITY_EXCLUDE_SETJMP`. You can also customise what happens on every `TEST_PROTECT` and `TEST_ABORT` call. This can be accomplished by providing user-defined `UNITY_TEST_PROTECT` and `UNITY_TEST_ABORT` macros (and these may be defined independently).
+
+`UNITY_TEST_PROTECT` is used as an `if` statement expression, and has to evaluate to `true` on the first call (when saving stack environment with `setjmp`), and to `false` when it returns as a result of a `TEST_ABORT` (when restoring the stack environment with `longjmp`).
+
+Whenever an assert macro fails, `TEST_ABORT` is used to restore the stack environment previously set by `TEST_PROTECT`. This part may be overriden with `UNITY_TEST_ABORT`, e.g. if custom failure handling is needed.
+
+_Example 1:_
+
+Calling `longjmp` on your target is possible, but has a platform-specific (or implementation-specific) set of prerequisites, e.g. privileged access level. You can extend the default behaviour of `TEST_PROTECT` and `TEST_ABORT` as:
+
+`unity_config.h`:
+
+```C
+#include "my_custom_test_handlers.h"
+
+#define UNITY_TEST_PROTECT() custom_test_protect()
+#define UNITY_TEST_ABORT()   custom_test_abort()
+```
+
+`my_custom_test_handlers.c`:
+
+```C
+int custom_test_protect(void) {
+  platform_specific_code();
+  return setjmp(Unity.AbortFrame) == 0;
+}
+
+UNITY_NORETURN void custom_test_abort(void) {
+  more_platform_specific_code();
+  longjmp(Unity.AbortFrame, 1);
+}
+```
+
+_Example 2:_
+
+Unity is used to provide the assertion macros only, and an external test harness/runner is used for test orchestration/reporting. In this case you can easily plug your code by overriding `TEST_ABORT` as:
+
+`unity_config.h`:
+
+```C
+#include "my_custom_test_handlers.h"
+
+#define UNITY_TEST_PROTECT() 1
+#define UNITY_TEST_ABORT()   custom_test_abort()
+```
+
+`my_custom_test_handlers.c`:
+
+```C
+void custom_test_abort(void) {
+  if (Unity.CurrentTestFailed == 1) {
+    custom_failed_test_handler();
+  } else if (Unity.CurrentTestIgnored == 1) {
+    custom_ignored_test_handler();
+  }
+}
+```
+
 #### `UNITY_OUTPUT_COLOR`
 
 If you want to add color using ANSI escape codes you can use this define.
@@ -393,6 +482,34 @@ _Example:_
 #define UNITY_OUTPUT_COLOR
 ```
 
+#### `UNITY_INCLUDE_EXEC_TIME`
+
+Define this to measure and report execution time for each test in the suite. When enabled, Unity will do
+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.
+
+#### `UNITY_CLOCK_MS`
+
+If you're working on a system (embedded or otherwise) which has an accessible millisecond timer. You can
+define `UNITY_CLOCK_MS` to be the name of the function which returns the millisecond timer. It will then
+attempt to use that function for timing purposes.
+
+#### `UNITY_EXEC_TIME_START`
+
+Define this hook to start a millisecond timer if necessary.
+
+#### `UNITY_EXEC_TIME_STOP`
+
+Define this hook to stop a millisecond timer if necessary.
+
+#### `UNITY_PRINT_EXEC_TIME`
+
+Define this hook to print the current execution time. Used to report the milliseconds elapsed.
+
+#### `UNITY_TIME_TYPE`
+
+Finally, this can be set to the type which holds the millisecond timer.
+
 #### `UNITY_SHORTHAND_AS_INT`
 
 #### `UNITY_SHORTHAND_AS_MEM`
@@ -422,6 +539,38 @@ This will rarely be necessary. Most often, Unity will automatically detect if th
 In the event that the compiler supports variadic macros, but is primarily C89 (ANSI), defining this option will allow you to use them.
 This option is also not necessary when using Ceedling or the test runner generator script.
 
+#### `UNITY_SUPPORT_TEST_CASES`
+
+Unity can automatically define all supported parameterized tests macros.
+That feature is disabled by default.
+To enable it, use the following example:
+
+```C
+#define UNITY_SUPPORT_TEST_CASES
+```
+
+You can manually provide required `TEST_CASE`, `TEST_RANGE` or `TEST_MATRIX` macro definitions
+before including `unity.h`, and they won't be redefined.
+If you provide one of the following macros, some of default definitions will not be
+defined:
+| User defines macro | Unity will _not_ define following macro |
+|---|---|
+| `UNITY_EXCLUDE_TEST_CASE` | `TEST_CASE` |
+| `UNITY_EXCLUDE_TEST_RANGE` | `TEST_RANGE` |
+| `UNITY_EXCLUDE_TEST_MATRIX` | `TEST_MATRIX` |
+| `TEST_CASE` | `TEST_CASE` |
+| `TEST_RANGE` | `TEST_RANGE` |
+| `TEST_MATRIX` | `TEST_MATRIX` |
+
+`UNITY_EXCLUDE_TEST_*` defines is not processed by test runner generator script.
+If you exclude one of them from definition, you should provide your own definition
+for them or avoid using undefined `TEST_*` macro as a test generator.
+Otherwise, compiler cannot build source code file with provided call.
+
+_Note:_
+That feature requires variadic macro support by compiler. If required feature
+is not detected, it will not be enabled, even though preprocessor macro is defined.
+
 ## Getting Into The Guts
 
 There will be cases where the options above aren't quite going to get everything perfect.

data/vendor/cmock/vendor/unity/docs/UnityHelperScriptsGuide.md

@@ -114,6 +114,11 @@ In the `examples` directory, Example 3's Rakefile demonstrates using a Ruby hash
 This option specifies an array of file names to be `#include`'d at the top of your runner C file.
 You might use it to reference custom types or anything else universally needed in your generated runners.
 
+##### `:defines`
+
+This option specifies an array of definitions to be `#define`'d at the top of your runner C file.
+Each definition will be wrapped in an `#ifndef`.
+
 ##### `:suite_setup`
 
 Define this option with C code to be executed _before any_ test cases are run.
@@ -121,6 +126,8 @@ Define this option with C code to be executed _before any_ test cases are run.
 Alternatively, if your C compiler supports weak symbols, you can leave this option unset and instead provide a `void suiteSetUp(void)` function in your test suite.
 The linker will look for this symbol and fall back to a Unity-provided stub if it is not found.
 
+This option can also be specified at the command prompt as `--suite_setup=""`
+
 ##### `:suite_teardown`
 
 Define this option with C code to be executed _after all_ test cases have finished.
@@ -131,6 +138,8 @@ You can normally just return `num_failures`.
 Alternatively, if your C compiler supports weak symbols, you can leave this option unset and instead provide a `int suiteTearDown(int num_failures)` function in your test suite.
 The linker will look for this symbol and fall back to a Unity-provided stub if it is not found.
 
+This option can also be specified at the command prompt as `--suite_teardown=""`
+
 ##### `:enforce_strict_ordering`
 
 This option should be defined if you have the strict order feature enabled in CMock (see CMock documentation).
@@ -141,6 +150,8 @@ If you provide the same YAML to the generator as used in CMock's configuration,
 
 This option should be defined if you are mixing C and CPP and want your test runners to automatically include extern "C" support when they are generated.
 
+This option can also be specified at the command prompt as `--externc`
+
 ##### `:mock_prefix` and `:mock_suffix`
 
 Unity automatically generates calls to Init, Verify and Destroy for every file included in the main test file that starts with the given mock prefix and ends with the given mock suffix, file extension not included.
@@ -165,8 +176,11 @@ Or as a yaml file:
 
 If you are using CMock, it is very likely that you are already passing an array of plugins to CMock.
 You can just use the same array here.
+
 This script will just ignore the plugins that don't require additional support.
 
+This option can also be specified at the command prompt as `--cexception`
+
 ##### `:include_extensions`
 
 This option specifies the pattern for matching acceptable header file extensions.
@@ -179,6 +193,280 @@ This option specifies the pattern for matching acceptable source file extensions
 By default it will accept cpp, cc, C, c, and ino files.
 If you need a different combination of files to search, update this from the default `'(?:cpp|cc|ino|C|c)'`.
 
+##### `:use_param_tests`
+
+This option enables parameterized test usage.
+That tests accepts arguments from `TEST_CASE` and `TEST_RANGE` macros,
+that are located above current test definition.
+By default, Unity assumes, that parameterized tests are disabled.
+
+Few usage examples can be found in `/test/tests/test_unity_parameterized.c` file.
+
+You should define `UNITY_SUPPORT_TEST_CASES` macro for tests success compiling,
+if you enable current option.
+
+You can see list of supported macros list in the
+[Parameterized tests provided macros](#parameterized-tests-provided-macros)
+section that follows.
+
+This option can also be specified at the command prompt as `--use_param_tests=1`
+
+##### `:cmdline_args`
+
+When set to `true`, the generated test runner can accept a number of
+options to modify how the test(s) are run.
+
+Ensure Unity is compiled with `UNITY_USE_COMMAND_LINE_ARGS` defined or else
+the required functions will not exist.
+
+These are the available options:
+
+| Option    | Description                                       |
+| --------- | ------------------------------------------------- |
+| `-l`      | List all tests and exit                           |
+| `-f NAME` | Filter to run only tests whose name includes NAME |
+| `-n NAME` | Run only the test named NAME                      |
+| `-h`      | show the Help menu that lists these options       |
+| `-q`      | Quiet/decrease verbosity                          |
+| `-v`      | increase Verbosity                                |
+| `-x NAME` | eXclude tests whose name includes NAME            |
+
+##### `:setup_name`
+
+Override the default test `setUp` function name.
+
+This option can also be specified at the command prompt as `--setup_name=""`
+
+##### `:teardown_name`
+
+Override the default test `tearDown` function name.
+
+This option can also be specified at the command prompt as `--teardown_name=""`
+
+##### `:test_reset_name`
+
+Override the default test `resetTest` function name.
+
+This option can also be specified at the command prompt as `--test_reset_name=""`
+
+##### `:test_verify_name`
+
+Override the default test `verifyTest` function name.
+
+This option can also be specified at the command prompt as `--test_verify_name=""`
+
+##### `:main_name`
+
+Override the test's `main()` function name (from `main` to whatever is specified).
+The sentinel value `:auto` will use the test's filename with the `.c` extension removed prefixed
+with `main_` as the "main" function.
+
+To clarify, if `:main_name == :auto` and the test filename is "test_my_project.c", then the
+generated function name will be `main_test_my_project(int argc, char** argv)`.
+
+This option can also be specified at the command prompt as `--main_name=""`
+
+##### `main_export_decl`
+
+Provide any `cdecl` for the `main()` test function. Is empty by default.
+
+##### `:omit_begin_end`
+
+If `true`, the `UnityBegin` and `UnityEnd` function will not be called for
+Unity test state setup and cleanup.
+
+This option can also be specified at the command prompt as `--omit_begin_end`
+
+#### Parameterized tests provided macros
+
+Unity provides support for few param tests generators, that can be combined
+with each other. You must define test function as usual C function with usual
+C arguments, and test generator will pass what you tell as a list of arguments.
+
+Let's show how all of them works on the following test function definitions:
+
+```C
+/* Place your test generators here, usually one generator per one or few lines */
+void test_demoParamFunction(int a, int b, int c)
+{
+  TEST_ASSERT_GREATER_THAN_INT(a + b, c);
+}
+```
+
+##### `TEST_CASE`
+
+Test case is a basic generator, that can be used for param testing.
+One call of that macro will generate only one call for test function.
+It can be used with different args, such as numbers, enums, strings,
+global variables, another preprocessor defines.
+
+If we use replace comment before test function with the following code:
+
+```C
+TEST_CASE(1, 2, 5)
+TEST_CASE(10, 7, 20)
+```
+
+script will generate 2 test calls:
+
+```C
+test_demoParamFunction(1, 2, 5);
+test_demoParamFunction(10, 7, 20);
+```
+
+That calls will be wrapped with `setUp`, `tearDown` and other
+usual Unity calls, as for independent unit tests.
+The following output can be generated after test executable startup:
+
+```Log
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(1, 2, 5):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(10, 7, 20):PASS
+```
+
+##### `TEST_RANGE`
+
+Test range is an advanced generator. It single call can be converted to zero,
+one or few `TEST_CASE` equivalent commands.
+
+That generator can be used for creating numeric ranges in decimal representation
+only: integers & floating point numbers. It uses few formats for every parameter:
+
+1. `[start, stop, step]` is stop-inclusive format
+2. `<start, stop, step>` is stop-exclusive formats
+
+Format providers 1 and 2 accept only three arguments:
+
+* `start` is start number
+* `stop` is end number (can or cannot exists in result sequence for format 1,
+will be always skipped for format 2)
+* `step` is incrementing step: can be either positive or negative value.
+
+Let's use our `test_demoParamFunction` test for checking, what ranges
+will be generated for our single `TEST_RANGE` row:
+
+```C
+TEST_RANGE([3, 4, 1], [10, 5, -2], <30, 31, 1>)
+```
+
+Tests execution output will be similar to that text:
+
+```Log
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 10, 30):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 8, 30):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(3, 6, 30):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 10, 30):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 8, 30):PASS
+tests/test_unity_parameterizedDemo.c:14:test_demoParamFunction(4, 6, 30):PASS
+```
+
+As we can see:
+
+| Parameter | Format | Possible values | Total of values | Format number |
+|---|---|---|---|---|
+| `a` | `[3, 4, 1]` | `3`, `4` | 2 | Format 1 |
+| `b` | `[10, 5, -2]` | `10`, `8`, `6` | 3 | Format 1, negative step, end number is not included |
+| `c` | `<30, 31, 1>` | `30` | 1 | Format 2 |
+
+_Note_, that format 2 also supports negative step.
+
+We totally have 2 * 3 * 1 = 6 equal test cases, that can be written as following:
+
+```C
+TEST_CASE(3, 10, 30)
+TEST_CASE(3, 8, 30)
+TEST_CASE(3, 6, 30)
+TEST_CASE(4, 10, 30)
+TEST_CASE(4, 8, 30)
+TEST_CASE(4, 6, 30)
+```
+
+##### `TEST_MATRIX`
+
+Test matix is an advanced generator. It single call can be converted to zero,
+one or few `TEST_CASE` equivalent commands.
+
+That generator will create tests for all cobinations of the provided list. Each argument has to be given as a list of one or more elements in the format `[<parm1>, <param2>, ..., <paramN-1>, <paramN>]`.
+
+All parameters supported by the `TEST_CASE` is supported as arguments:
+- Numbers incl type specifiers e.g. `<1>`, `<1u>`, `<1l>`, `<2.3>`, or `<2.3f>`
+- Strings incl string concatianion e.g. `<"string">`, or `<"partial" "string">`
+- Chars e.g. `<'c'>`
+- Enums e.g. `<ENUM_NAME>`
+- Elements of arrays e.g. `<data[0]>`
+
+Let's use our `test_demoParamFunction` test for checking, what ranges
+will be generated for our single `TEST_RANGE` row:
+
+```C
+TEST_MATRIX([3, 4, 7], [10, 8, 2, 1],[30u, 20.0f])
+```
+
+Tests execution output will be similar to that text:
+
+```Log
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 10, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 10, 20.0f):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 8, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 8, 20.0f):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 2, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 2, 20.0f):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 1, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(3, 1, 20.0f):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 10, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 10, 20.0f):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 8, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 8, 20.0f):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 2, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 2, 20.0f):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 1, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(4, 1, 20.0f):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 10, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 10, 20.0f):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 8, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 8, 20.0f):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 2, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 2, 20.0f):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 1, 30u):PASS
+tests/test_unity_parameterizedDemo.c:18:test_demoParamFunction(7, 1, 20.0f):PASS
+```
+
+As we can see:
+
+| Parameter | Format | Count of values |
+|---|---|---|
+| `a` | `[3, 4, 7]` | 2 |
+| `b` | `[10, 8, 2, 1]` | 4 |
+| `c` | `[30u, 20.0f]` | 2 |
+
+We totally have 2 * 4 * 2 = 16 equal test cases, that can be written as following:
+
+```C
+TEST_CASE(3, 10, 30u)
+TEST_CASE(3, 10, 20.0f)
+TEST_CASE(3, 8, 30u)
+TEST_CASE(3, 8, 20.0f)
+TEST_CASE(3, 2, 30u)
+TEST_CASE(3, 2, 20.0f)
+TEST_CASE(3, 1, 30u)
+TEST_CASE(3, 1, 20.0f)
+TEST_CASE(4, 10, 30u)
+TEST_CASE(4, 10, 20.0f)
+TEST_CASE(4, 8, 30u)
+TEST_CASE(4, 8, 20.0f)
+TEST_CASE(4, 2, 30u)
+TEST_CASE(4, 2, 20.0f)
+TEST_CASE(4, 1, 30u)
+TEST_CASE(4, 1, 20.0f)
+TEST_CASE(7, 10, 30u)
+TEST_CASE(7, 10, 20.0f)
+TEST_CASE(7, 8, 30u)
+TEST_CASE(7, 8, 20.0f)
+TEST_CASE(7, 2, 30u)
+TEST_CASE(7, 2, 20.0f)
+TEST_CASE(7, 1, 30u)
+TEST_CASE(7, 1, 20.0f)
+```
+
 ### `unity_test_summary.rb`
 
 A Unity test file contains one or more test case functions.
@@ -239,7 +527,7 @@ How convenient is that?
 
 *Find The Latest of This And More at [ThrowTheSwitch.org][]*
 
-[ruby-lang.org]: https://ruby-labg.org/
+[ruby-lang.org]: https://ruby-lang.org/
 [YAML]: http://www.yaml.org/
 [Ceedling]: http://www.throwtheswitch.org/ceedling
 [ThrowTheSwitch.org]: https://throwtheswitch.org

data/vendor/cmock/vendor/unity/docs/UnityKnownIssues.md

@@ -0,0 +1,13 @@
+# Unity Test - Known Issues
+
+## A Note
+
+This project will do its best to keep track of significant bugs that might effect your usage of this
+project and its supporting scripts. A more detailed and up-to-date list for cutting edge Unity can
+be found on our Github repository.
+
+## Issues
+
+  - No built-in validation of no-return functions
+  - Incomplete support for Printf-style formatting
+  - Incomplete support for VarArgs

data/vendor/cmock/vendor/unity/examples/example_1/makefile

@@ -1,8 +1,9 @@
-# ==========================================
-#   Unity Project - A Test Framework for C
-#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-#   [Released under MIT License. Please refer to license.txt for details]
-# ==========================================
+# =========================================================================
+#   Unity - A Test Framework for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 #We try to detect the OS we are running on, and adjust commands as needed
 ifeq ($(OS),Windows_NT)

data/vendor/cmock/vendor/unity/examples/example_1/meson.build

@@ -0,0 +1,48 @@
+project('Unity example', 'c',
+  license: 'MIT',
+  default_options: [
+    'c_std=c99',
+    'warning_level=3',
+  ],
+  meson_version: '>= 0.49.0'
+)
+
+unity_subproject = subproject('unity')
+unity_dependency = unity_subproject.get_variable('unity_dep')
+unity_gen_runner = unity_subproject.get_variable('gen_test_runner')
+
+src1 = files([
+  'src' / 'ProductionCode.c',
+  'test' / 'TestProductionCode.c',
+])
+
+src2 = files([
+  'src' / 'ProductionCode2.c',
+  'test' / 'TestProductionCode2.c',
+])
+
+inc = include_directories('src')
+
+test1 = executable('test1',
+  sources: [
+    src1,
+    unity_gen_runner.process('test' / 'TestProductionCode.c')
+  ],
+  include_directories: [ inc ],
+  dependencies: [ unity_dependency ],
+)
+
+test('test1', test1,
+  should_fail: true)
+
+test2 = executable('test2',
+  sources: [
+    src2,
+    unity_gen_runner.process('test' / 'TestProductionCode2.c')
+  ],
+  include_directories: [ inc ],
+  dependencies: [ unity_dependency ],
+)
+
+test('test2', test2)
+

data/vendor/cmock/vendor/unity/examples/example_1/readme.txt

@@ -2,4 +2,11 @@ Example 1
 =========
 
 Close to the simplest possible example of Unity, using only basic features.
-Run make to build & run the example tests.
+
+Build and run with Make
+---
+Just run `make`.
+
+Build and run with Meson
+---
+Run `meson setup build` to create the build directory, and then `meson test -C build` to build and run the tests.

data/vendor/cmock/vendor/unity/examples/example_1/src/ProductionCode.c

@@ -1,3 +1,9 @@
+/* =========================================================================
+    Unity - A Test Framework for C
+    ThrowTheSwitch.org
+    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
 
 #include "ProductionCode.h"
 

data/vendor/cmock/vendor/unity/examples/example_1/src/ProductionCode.h

@@ -1,3 +1,9 @@
+/* =========================================================================
+    Unity - A Test Framework for C
+    ThrowTheSwitch.org
+    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
 
 int FindFunction_WhichIsBroken(int NumberToFind);
 int FunctionWhichReturnsLocalVariable(void);

data/vendor/cmock/vendor/unity/examples/example_1/src/ProductionCode2.c

@@ -1,3 +1,9 @@
+/* =========================================================================
+    Unity - A Test Framework for C
+    ThrowTheSwitch.org
+    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
 
 #include "ProductionCode2.h"
 

data/vendor/cmock/vendor/unity/examples/example_1/src/ProductionCode2.h

@@ -1,2 +1,8 @@
+/* =========================================================================
+    Unity - A Test Framework for C
+    ThrowTheSwitch.org
+    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
 
 char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction);

data/vendor/cmock/vendor/unity/examples/example_1/subprojects/unity.wrap

@@ -0,0 +1,3 @@
+[wrap-git]
+url = https://github.com/ThrowTheSwitch/Unity.git
+revision = head