ceedling 0.9.0 → 1.0.1

data/vendor/cmock/test/system/test_interactions/doesnt_leave_details_behind.yml

@@ -0,0 +1,315 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+---
+:cmock:
+  :enforce_strict_ordering: 1
+  :plugins:
+  - :array
+  - :cexception
+  - :ignore
+  - :callback
+  - :return_thru_ptr
+  - :ignore_arg
+  - :expect_any_args
+  :callback_after_arg_check: false
+  :callback_include_count: false
+  :treat_externs: :include
+
+:systest:
+  :types: |
+    typedef struct _POINT_T {
+      int x;
+      int y;
+    } POINT_T;
+
+  :mockable: |
+    #include  "CException.h"
+    extern void foo(POINT_T* a);
+    POINT_T* bar(void);
+    void no_args(void);
+
+  :source:
+    :header: |
+      #include "CException.h"
+      void function_a(void);
+      int function_b(void);
+
+    :code: |
+      void function_a(void)
+      {
+        foo(bar());
+        no_args();
+      }
+
+      int function_b(void)
+      {
+        POINT_T pt = { 1, 2 };
+        foo(&pt);
+        return (pt.x + pt.y);
+      }
+
+  :tests:
+    :common: |
+      #include "CException.h"
+      void setUp(void) {}
+      void tearDown(void) {}
+      void my_foo_callback(POINT_T* a) { TEST_ASSERT_EQUAL_INT(2, a->x); }
+
+    :units:
+    - :pass: TRUE
+      :should: 'just pass if we do not insert anything ugly into it'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn(NULL);
+          foo_Expect(NULL);
+          no_args_Expect();
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after an expect and return'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn(NULL);
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+          foo_Expect(NULL);
+          no_args_Expect();
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after an expect'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn(NULL);
+          foo_Expect(NULL);
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+          no_args_Expect();
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after throw expectation'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          CEXCEPTION_T e;
+
+          bar_ExpectAndReturn(NULL);
+          foo_Expect(NULL);
+          no_args_ExpectAndThrow(5);
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+
+          Try { function_a(); } Catch(e) {}
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after a mock call'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn(NULL);
+          foo_Expect(NULL);
+          no_args_Expect();
+
+          function_a();
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after throw'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          CEXCEPTION_T e;
+
+          bar_ExpectAndReturn(NULL);
+          foo_Expect(NULL);
+          no_args_ExpectAndThrow(5);
+
+          Try { function_a(); } Catch(e) {}
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after ignore'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn(NULL);
+          foo_Expect(NULL);
+          no_args_Ignore();
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after ignored mock'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn(NULL);
+          foo_Expect(NULL);
+          no_args_Ignore();
+
+          function_a();
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after callback setup'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          POINT_T pt = { 2, 2 };
+          bar_ExpectAndReturn(&pt);
+          foo_StubWithCallback(my_foo_callback);
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+
+          no_args_Expect();
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after mock with callback'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          POINT_T pt = { 2, 2 };
+          bar_ExpectAndReturn(&pt);
+          foo_StubWithCallback(my_foo_callback);
+          no_args_Expect();
+
+          function_a();
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after expect any args'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          POINT_T pt = { 2, 2 };
+          bar_ExpectAndReturn(&pt);
+          foo_ExpectAnyArgs();
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+
+          no_args_Expect();
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after mock which expected any args'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          POINT_T pt = { 2, 2 };
+          bar_ExpectAndReturn(&pt);
+          foo_ExpectAnyArgs();
+          no_args_Expect();
+
+          function_a();
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after ignored arg'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          POINT_T pt = { 2, 2 };
+          bar_ExpectAndReturn(&pt);
+          foo_Expect(NULL);
+          foo_IgnoreArg_a();
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+
+          no_args_Expect();
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after mock which ignored an arg'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          POINT_T pt = { 2, 2 };
+          bar_ExpectAndReturn(&pt);
+          foo_Expect(NULL);
+          foo_IgnoreArg_a();
+          no_args_Expect();
+
+          function_a();
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after mock which threw a CException'
+      :verify_error: 'FAIL: Expected 1 Was 2. CustomFail'
+      :code: |
+        test()
+        {
+          CEXCEPTION_T e;
+          bar_ExpectAndThrow(0x12);
+
+          Try {
+            function_a();
+          }
+          Catch(e) {}
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(1,2,"CustomFail");
+        }
+
+    - :pass: FALSE
+      :should: 'not contain mock details in failed assertion after mock which used a return thru ptr'
+      :verify_error: 'FAIL: Expected 3 Was 7. CustomFail'
+      :code: |
+        test()
+        {
+          POINT_T pt1 = { 1, 2 };
+          POINT_T pt2 = { 3, 4 };
+
+          foo_Expect(&pt1);
+          foo_ReturnThruPtr_a(&pt2);
+
+          TEST_ASSERT_EQUAL_INT_MESSAGE(3, function_b(), "CustomFail");
+        }
+
+...

data/vendor/cmock/test/system/test_interactions/enforce_strict_ordering.yml

@@ -0,0 +1,254 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+---
+:cmock:
+  :enforce_strict_ordering: 1
+  :plugins:
+  - :ignore
+  - :cexception
+
+:systest:
+  :types: |
+    #define UINT32 unsigned int
+
+    typedef signed int custom_type;
+
+  :mockable: |
+    #include  "CException.h"
+    UINT32 foo(custom_type a);
+    UINT32 bar(custom_type b);
+    void baz(custom_type c);
+
+  :source:
+    :header: |
+      #include "CException.h"
+      UINT32 function_a(int a, int b);
+      void function_b(void);
+      void function_c(void);
+      void function_d(void);
+
+    :code: |
+      UINT32 function_a(int a, int b)
+      {
+        return foo((custom_type)a) + bar((custom_type)b);
+      }
+
+      void function_b(void)
+      {
+        baz((custom_type)1);
+        foo((custom_type)2);
+        bar((custom_type)3);
+        baz((custom_type)4);
+        foo((custom_type)5);
+        bar((custom_type)6);
+        baz((custom_type)7);
+      }
+
+      void function_c(void)
+      {
+        foo((custom_type)1);
+        foo((custom_type)2);
+        bar((custom_type)3);
+        bar((custom_type)4);
+        foo((custom_type)5);
+      }
+
+      void function_d(void)
+      {
+        CEXCEPTION_T e;
+        Try
+        {
+          foo((custom_type)1);
+        }
+        Catch(e) {}
+        Try
+        {
+          bar((custom_type)2);
+        }
+        Catch(e) {}
+        Try
+        {
+          foo((custom_type)3);
+        }
+        Catch(e) {}
+      }
+
+  :tests:
+    :common: |
+      #include "CException.h"
+      void setUp(void) {}
+      void tearDown(void) {}
+
+    :units:
+    - :pass: TRUE
+      :should: 'successfully exercise two simple ExpectAndReturn mock calls'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)2, 20);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+        }
+
+    - :pass: FALSE
+      :should: 'fail because bar() is called but is not expected'
+      :verify_error: 'Called more times than expected'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+        }
+
+    - :pass: FALSE
+      :should: 'fail because bar() is called twice but is expected once'
+      :verify_error: 'Called fewer times than expected'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)2, 20);
+          bar_ExpectAndReturn((custom_type)3, 30);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+        }
+
+    - :pass: FALSE
+      :should: 'fail because bar and foo called in reverse order'
+      :verify_error: 'Called earlier than expected'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn((custom_type)2, 20);
+          foo_ExpectAndReturn((custom_type)1, 10);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+        }
+
+    - :pass: TRUE
+      :should: 'pass because bar and foo called in order with multiple params'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          foo_ExpectAndReturn((custom_type)2, 10);
+          bar_ExpectAndReturn((custom_type)3, 20);
+          bar_ExpectAndReturn((custom_type)4, 10);
+          foo_ExpectAndReturn((custom_type)5, 10);
+          function_c();
+        }
+
+    - :pass: FALSE
+      :should: 'fail because bar and foo called out of order at end'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          foo_ExpectAndReturn((custom_type)2, 10);
+          bar_ExpectAndReturn((custom_type)3, 20);
+          foo_ExpectAndReturn((custom_type)5, 10);
+          bar_ExpectAndReturn((custom_type)4, 10);
+          function_c();
+        }
+
+    - :pass: FALSE
+      :should: 'fail because bar and foo called out of order at start'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)2, 10);
+          foo_ExpectAndReturn((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)3, 20);
+          bar_ExpectAndReturn((custom_type)4, 10);
+          foo_ExpectAndReturn((custom_type)5, 10);
+          function_c();
+        }
+
+    - :pass: TRUE
+      :should: 'pass because we are properly ignoring baz'
+      :code: |
+        test()
+        {
+          baz_Ignore();
+          foo_ExpectAndReturn((custom_type)2, 10);
+          bar_ExpectAndReturn((custom_type)3, 20);
+          foo_ExpectAndReturn((custom_type)5, 10);
+          bar_ExpectAndReturn((custom_type)6, 10);
+          function_b();
+        }
+
+    - :pass: FALSE
+      :should: 'fail because bar and foo out of order, even though baz is ignored'
+      :code: |
+        test()
+        {
+          baz_Ignore();
+          foo_ExpectAndReturn((custom_type)2, 10);
+          foo_ExpectAndReturn((custom_type)5, 10);
+          bar_ExpectAndReturn((custom_type)3, 20);
+          bar_ExpectAndReturn((custom_type)6, 10);
+          function_b();
+        }
+
+    - :pass: TRUE
+      :should: 'pass when using cexception, as long as the order is right'
+      :code: |
+        test()
+        {
+          foo_ExpectAndThrow((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)2, 20);
+          foo_ExpectAndReturn((custom_type)3, 10);
+          function_d();
+        }
+
+    - :pass: FALSE
+      :should: 'fail when an throw call is made out of order'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn((custom_type)2, 20);
+          foo_ExpectAndThrow((custom_type)1, 10);
+          foo_ExpectAndReturn((custom_type)3, 10);
+          function_d();
+        }
+
+    - :pass: TRUE
+      :should: 'successfully handle back to back ExpectAndReturn setup and mock calls'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)2, 20);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+
+          foo_ExpectAndReturn((custom_type)3, 30);
+          bar_ExpectAndReturn((custom_type)4, 40);
+          TEST_ASSERT_EQUAL(70, function_a(3, 4));
+
+          foo_ExpectAndReturn((custom_type)1, 50);
+          bar_ExpectAndReturn((custom_type)9, 60);
+          TEST_ASSERT_EQUAL(110, function_a(1, 9));
+        }
+
+    - :pass: FALSE
+      :should: 'successfully catch errors during back to back ExpectAndReturn setup and mock calls'
+      :verify_error: 'Called earlier than expected'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)2, 20);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+
+          foo_ExpectAndReturn((custom_type)3, 30);
+          bar_ExpectAndReturn((custom_type)4, 40);
+          TEST_ASSERT_EQUAL(70, function_a(3, 4));
+
+          bar_ExpectAndReturn((custom_type)9, 60);
+          foo_ExpectAndReturn((custom_type)1, 50);
+          TEST_ASSERT_EQUAL(110, function_a(1, 9));
+        }
+...

data/vendor/cmock/test/system/test_interactions/expect_and_return_custom_types.yml

@@ -0,0 +1,115 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+---
+:cmock:
+  :plugins:
+  - # none
+  :memcmp_if_unknown: false
+  :unity_helper_path: expect_and_return_custom_types_unity_helper.h
+
+:systest:
+  :types: |
+    typedef struct _EXAMPLE_STRUCT_T { int x; int y; } EXAMPLE_STRUCT_T;
+
+  :mockable: |
+    EXAMPLE_STRUCT_T foo(EXAMPLE_STRUCT_T a);
+
+  :source:
+    :header: |
+      EXAMPLE_STRUCT_T function_a(EXAMPLE_STRUCT_T a, EXAMPLE_STRUCT_T b);
+      EXAMPLE_STRUCT_T function_b(EXAMPLE_STRUCT_T a, EXAMPLE_STRUCT_T b);
+
+    :code: |
+      EXAMPLE_STRUCT_T function_a(EXAMPLE_STRUCT_T a, EXAMPLE_STRUCT_T b)
+      {
+        EXAMPLE_STRUCT_T retval = foo(a);
+        retval.x += b.x;
+        retval.y += b.y;
+        return retval;
+      }
+
+      EXAMPLE_STRUCT_T function_b(EXAMPLE_STRUCT_T a, EXAMPLE_STRUCT_T b)
+      {
+        EXAMPLE_STRUCT_T retval = foo(b);
+        retval.x *= a.x;
+        retval.y *= a.y;
+        return retval;
+      }
+
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+
+    :units:
+    - :pass: TRUE
+      :should: 'successfully exercise simple ExpectAndReturn mock calls'
+      :code: |
+        test()
+        {
+          EXAMPLE_STRUCT_T c = {1,2};
+          EXAMPLE_STRUCT_T d = {3,4};
+          EXAMPLE_STRUCT_T e = {2,4};
+          EXAMPLE_STRUCT_T f = {5,8};
+          foo_ExpectAndReturn(c, e);
+          TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(f, function_a(c,d));
+        }
+
+    - :pass: FALSE
+      :should: 'fail because it is expecting to call foo with c not d'
+      :code: |
+        test()
+        {
+          EXAMPLE_STRUCT_T c = {1,2};
+          EXAMPLE_STRUCT_T d = {3,4};
+          EXAMPLE_STRUCT_T e = {2,4};
+          EXAMPLE_STRUCT_T f = {5,8};
+          foo_ExpectAndReturn(d, e);
+          TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(f, function_a(c,d));
+        }
+
+    - :pass: TRUE
+      :should: 'successfully exercise simple ExpectAndReturn mock calls on other function'
+      :code: |
+        test()
+        {
+          EXAMPLE_STRUCT_T c = {1,2};
+          EXAMPLE_STRUCT_T d = {3,4};
+          EXAMPLE_STRUCT_T e = {2,4};
+          EXAMPLE_STRUCT_T f = {2,8};
+          foo_ExpectAndReturn(d, e);
+          TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(f, function_b(c,d));
+        }
+
+    - :pass: FALSE
+      :should: 'fail because it is expecting to call foo with d not c'
+      :code: |
+        test()
+        {
+          EXAMPLE_STRUCT_T c = {1,2};
+          EXAMPLE_STRUCT_T d = {3,4};
+          EXAMPLE_STRUCT_T e = {2,4};
+          EXAMPLE_STRUCT_T f = {2,8};
+          foo_ExpectAndReturn(c, e);
+          TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(f, function_b(c,d));
+        }
+
+  :unity_helper:
+    :header: |
+      void AssertEqualExampleStruct(EXAMPLE_STRUCT_T expected, EXAMPLE_STRUCT_T actual, unsigned short line);
+      #define UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, line, message) {AssertEqualExampleStruct(expected, actual, (unsigned short)line);}
+      #define TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual) UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, __LINE__, NULL);
+
+    :code: |
+      void AssertEqualExampleStruct(EXAMPLE_STRUCT_T expected, EXAMPLE_STRUCT_T actual, unsigned short line)
+      {
+        UNITY_TEST_ASSERT_EQUAL_INT(expected.x, actual.x, line, "Example Struct Failed For Field x");
+        UNITY_TEST_ASSERT_EQUAL_INT(expected.y, actual.y, line, "Example Struct Failed For Field y");
+      }
+
+...