ceedling 0.29.1 → 0.30.0

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

@@ -1,124 +1,124 @@
----
-:cmock:
-  :plugins:
-  - # none
-
-:systest:
-  :types: |
-    #define UINT32 unsigned int
-
-    typedef signed int custom_type;
-
-  :mockable: |
-    UINT32 foo(custom_type a);
-    UINT32 bar(custom_type b);
-    UINT32 foo_varargs(custom_type a, ...);
-    const char* foo_char_strings(const char a[], const char* b);
-
-  :source:
-    :header: |
-      UINT32 function_a(int a, int b);
-      void function_b(void);
-      UINT32 function_c(int a);
-      const char* function_d(const char a[], const char* b);
-
-    :code: |
-      UINT32 function_a(int a, int b)
-      {
-        return foo((custom_type)a) + bar((custom_type)b);
-      }
-
-      void function_b(void) { }
-
-      UINT32 function_c(int a)
-      {
-        return foo_varargs((custom_type)a, "ignored", 5);
-      }
-
-      const char* function_d(const char a[], const char* b)
-      {
-        return foo_char_strings(a, b);
-      }
-
-  :tests:
-    :common: |
-      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 not called but is 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 but is not expected'
-      :code: |
-        test()
-        {
-          bar_ExpectAndReturn((custom_type)1, 10);
-          function_b();
-        }
-
-    - :pass: TRUE
-      :should: 'consume var args passed to mocked function'
-      :code: |
-        test()
-        {
-          foo_varargs_ExpectAndReturn((custom_type)3, 10);
-          TEST_ASSERT_EQUAL(10, function_c(3));
-        }
-
-    - :pass: TRUE
-      :should: 'handle char strings'
-      :code: |
-        test()
-        {
-          const char* retval = "moe";
-          foo_char_strings_ExpectAndReturn("larry", "curly", (char*)retval);
-          TEST_ASSERT_EQUAL_STRING("moe", function_d("larry", "curly"));
-        }
-
-    - :pass: TRUE
-      :should: 'successfully exercise multiple cycles of expecting and mocking and pass'
-      :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));
-        }
-
-    - :pass: FALSE
-      :should: 'successfully exercise multiple cycles of expecting and mocking and fail'
-      :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, 5));
-        }
-
-...
+---
+:cmock:
+  :plugins:
+  - # none
+
+:systest:
+  :types: |
+    #define UINT32 unsigned int
+
+    typedef signed int custom_type;
+
+  :mockable: |
+    UINT32 foo(custom_type a);
+    UINT32 bar(custom_type b);
+    UINT32 foo_varargs(custom_type a, ...);
+    const char* foo_char_strings(const char a[], const char* b);
+
+  :source:
+    :header: |
+      UINT32 function_a(int a, int b);
+      void function_b(void);
+      UINT32 function_c(int a);
+      const char* function_d(const char a[], const char* b);
+
+    :code: |
+      UINT32 function_a(int a, int b)
+      {
+        return foo((custom_type)a) + bar((custom_type)b);
+      }
+
+      void function_b(void) { }
+
+      UINT32 function_c(int a)
+      {
+        return foo_varargs((custom_type)a, "ignored", 5);
+      }
+
+      const char* function_d(const char a[], const char* b)
+      {
+        return foo_char_strings(a, b);
+      }
+
+  :tests:
+    :common: |
+      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 not called but is 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 but is not expected'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn((custom_type)1, 10);
+          function_b();
+        }
+
+    - :pass: TRUE
+      :should: 'consume var args passed to mocked function'
+      :code: |
+        test()
+        {
+          foo_varargs_ExpectAndReturn((custom_type)3, 10);
+          TEST_ASSERT_EQUAL(10, function_c(3));
+        }
+
+    - :pass: TRUE
+      :should: 'handle char strings'
+      :code: |
+        test()
+        {
+          const char* retval = "moe";
+          foo_char_strings_ExpectAndReturn("larry", "curly", (char*)retval);
+          TEST_ASSERT_EQUAL_STRING("moe", function_d("larry", "curly"));
+        }
+
+    - :pass: TRUE
+      :should: 'successfully exercise multiple cycles of expecting and mocking and pass'
+      :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));
+        }
+
+    - :pass: FALSE
+      :should: 'successfully exercise multiple cycles of expecting and mocking and fail'
+      :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, 5));
+        }
+
+...

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

@@ -1,87 +1,87 @@
----
-:cmock:
-  :plugins:
-  - # none
-
-:systest:
-  :types: |
-
-  :mockable: |
-    // no argument names
-    void foo(char const*, char* const, const char*);
-    
-    // argument names
-    void bar(char const* param1, char* const param2, const char* param3);
-
-  :source: 
-    :header: |
-      void exercise_const1(char const* param1, char* const param2, const char* param3);
-      void exercise_const2(char const* param1, char* const param2, const char* param3);
-
-    :code: |
-      char value1 = '1';
-      char value2 = '2';
-    
-      const char* A = &value1;
-      char* const B = &value2;
-      const char* C = "C";
-      const char* D = "D";
-    
-      void exercise_const1(char const* param1, char* const param2, const char* param3)
-      {
-        foo(param1, param2, param3);
-      }
-
-      void exercise_const2(char const* param1, char* const param2, const char* param3)
-      {
-        bar(param1, param2, param3);
-      }
-      
-  :tests:
-    :common: |
-      extern const char* A;
-      extern char* const B;
-      extern const char* C;
-      extern const char* D;
-      
-      void setUp(void) {}
-      void tearDown(void) {}
-    :units:
-    - :pass: TRUE
-      :should: 'successfully pass several const parameters'
-      :code: |
-        test()
-        {
-          foo_Expect( A, B, C );
-          exercise_const1( A, B, C );
-        }
-      
-    - :pass: FALSE
-      :should: 'should fail upon wrong const arguments passed'
-      :code: |
-        test()
-        {
-          foo_Expect( A, B, C );
-          exercise_const1( (const char*)B, (char * const)A, C );
-        }
-
-    - :pass: FALSE
-      :should: 'should fail upon wrong const arguments passed'
-      :code: |
-        test()
-        {
-          foo_Expect( A, B, C );
-          exercise_const1( A, B, D );
-        }
-
-    - :pass: FALSE
-      :should: 'should fail upon wrong const arguments passed'
-      :code: |
-        test()
-        {
-          bar_Expect( A, B, C );
-          exercise_const2( A, (char * const)C, (const char *)B );
-        }
-
-
-...
+---
+:cmock:
+  :plugins:
+  - # none
+
+:systest:
+  :types: |
+
+  :mockable: |
+    // no argument names
+    void foo(char const*, char* const, const char*);
+    
+    // argument names
+    void bar(char const* param1, char* const param2, const char* param3);
+
+  :source: 
+    :header: |
+      void exercise_const1(char const* param1, char* const param2, const char* param3);
+      void exercise_const2(char const* param1, char* const param2, const char* param3);
+
+    :code: |
+      char value1 = '1';
+      char value2 = '2';
+    
+      const char* A = &value1;
+      char* const B = &value2;
+      const char* C = "C";
+      const char* D = "D";
+    
+      void exercise_const1(char const* param1, char* const param2, const char* param3)
+      {
+        foo(param1, param2, param3);
+      }
+
+      void exercise_const2(char const* param1, char* const param2, const char* param3)
+      {
+        bar(param1, param2, param3);
+      }
+      
+  :tests:
+    :common: |
+      extern const char* A;
+      extern char* const B;
+      extern const char* C;
+      extern const char* D;
+      
+      void setUp(void) {}
+      void tearDown(void) {}
+    :units:
+    - :pass: TRUE
+      :should: 'successfully pass several const parameters'
+      :code: |
+        test()
+        {
+          foo_Expect( A, B, C );
+          exercise_const1( A, B, C );
+        }
+      
+    - :pass: FALSE
+      :should: 'should fail upon wrong const arguments passed'
+      :code: |
+        test()
+        {
+          foo_Expect( A, B, C );
+          exercise_const1( (const char*)B, (char * const)A, C );
+        }
+
+    - :pass: FALSE
+      :should: 'should fail upon wrong const arguments passed'
+      :code: |
+        test()
+        {
+          foo_Expect( A, B, C );
+          exercise_const1( A, B, D );
+        }
+
+    - :pass: FALSE
+      :should: 'should fail upon wrong const arguments passed'
+      :code: |
+        test()
+        {
+          bar_Expect( A, B, C );
+          exercise_const2( A, (char * const)C, (const char *)B );
+        }
+
+
+...

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

@@ -1,308 +1,308 @@
----
-: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");
-        }
-
-...
+---
+: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");
+        }
+
+...