ceedling 0.18.0 → 0.19.0

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

@@ -21,6 +21,7 @@
     void no_pointers(int a, const char* b);
     int mixed(int a, int* b, int c);
     void potential_packing_problem(short *a);
+    void voidpointerfunc(void* a);
 
   :source:
     :header: |
@@ -29,6 +30,7 @@
       void function_c(void);
       int  function_d(void);
       void function_e(void);
+      void function_f(void);
 
     :code: |
       void function_a(void)
@@ -55,6 +57,11 @@
         potential_packing_problem(&test_list[1]);
       }
 
+      void function_f(void) {
+        char arg[6] = "hello";
+        voidpointerfunc(arg);
+      }
+
   :tests:
     :common: |
       void setUp(void) {}
@@ -380,5 +387,60 @@
           function_e();
         }
 
+    - :pass: TRUE
+      :should: 'handle a void pointers as arguments and still be able to use the array plugin'
+      :code: |
+        test()
+        {
+          char expect_list[6] = "hello";
+          voidpointerfunc_ExpectWithArray(expect_list, 5);
+
+          function_f();
+        }
+
+    - :pass: TRUE
+      :should: 'handle a void pointers as arguments and still be able to use the array plugin (short)'
+      :code: |
+        test()
+        {
+          char expect_list[6] = "help!";
+          voidpointerfunc_ExpectWithArray(expect_list, 3);
+
+          function_f();
+        }
+
+    - :pass: FALSE
+      :should: 'handle a void pointers as arguments and still be able to use the array plugin (fail)'
+      :code: |
+        test()
+        {
+          char expect_list[6] = "help!";
+          voidpointerfunc_ExpectWithArray(expect_list, 4);
+
+          function_f();
+        }
+
+    - :pass: TRUE
+      :should: 'handle a void pointer with a standard expectation (pass)'
+      :code: |
+        test()
+        {
+          char expect_list[2] = "h";
+          voidpointerfunc_Expect(expect_list);
+
+          function_f();
+        }
+
+    - :pass: FALSE
+      :should: 'handle a void pointer with a standard expectation (fail)'
+      :code: |
+        test()
+        {
+          char expect_list[2] = "g";
+          voidpointerfunc_Expect(expect_list);
+
+          function_f();
+        }
+
 
 ...

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

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

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

@@ -8,7 +8,7 @@
 :systest:
   :types: |
     #define UINT32 unsigned int
-    
+
     typedef signed int custom_type;
 
   :mockable: |
@@ -17,7 +17,7 @@
     UINT32 bar(custom_type b);
     void baz(custom_type c);
 
-  :source: 
+  :source:
     :header: |
       #include "CException.h"
       UINT32 function_a(int a, int b);
@@ -26,13 +26,13 @@
       void function_d(void);
 
     :code: |
-      UINT32 function_a(int a, int b)    
+      UINT32 function_a(int a, int b)
       {
         return foo((custom_type)a) + bar((custom_type)b);
-      }    
+      }
 
-      void function_b(void) 
-      { 
+      void function_b(void)
+      {
         baz((custom_type)1);
         foo((custom_type)2);
         bar((custom_type)3);
@@ -42,7 +42,7 @@
         baz((custom_type)7);
       }
 
-      void function_c(void) 
+      void function_c(void)
       {
         foo((custom_type)1);
         foo((custom_type)2);
@@ -50,7 +50,7 @@
         bar((custom_type)4);
         foo((custom_type)5);
       }
-      
+
       void function_d(void)
       {
         CEXCEPTION_T e;
@@ -70,13 +70,13 @@
         }
         Catch(e) {}
       }
-      
+
   :tests:
     :common: |
       #include "CException.h"
       void setUp(void) {}
       void tearDown(void) {}
-      
+
     :units:
     - :pass: TRUE
       :should: 'successfully exercise two simple ExpectAndReturn mock calls'
@@ -87,20 +87,20 @@
           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'
+      :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 less times than expected'
+      :verify_error: 'Called less times than expected'
       :code: |
         test()
         {
@@ -112,7 +112,7 @@
 
     - :pass: FALSE
       :should: 'fail because bar and foo called in reverse order'
-      :verify_error: 'called earlier than expected'
+      :verify_error: 'Called earlier than expected'
       :code: |
         test()
         {
@@ -185,7 +185,7 @@
           bar_ExpectAndReturn((custom_type)6, 10);
           function_b();
         }
-        
+
     - :pass: TRUE
       :should: 'pass when using cexception, as long as the order is right'
       :code: |
@@ -207,7 +207,7 @@
           foo_ExpectAndReturn((custom_type)3, 10);
           function_d();
         }
-        
+
     - :pass: TRUE
       :should: 'successfully handle back to back ExpectAndReturn setup and mock calls'
       :code: |
@@ -216,30 +216,30 @@
           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'
+      :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));