ceedling 0.15.1 → 0.15.2

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

@@ -3,7 +3,7 @@
   :plugins:
   - # none
   :memcmp_if_unknown: false
-  
+
 :systest:
   :types: |
     typedef struct _EXAMPLE_STRUCT_T { int x; int y; } EXAMPLE_STRUCT_T;
@@ -11,34 +11,34 @@
   :mockable: |
     EXAMPLE_STRUCT_T foo(EXAMPLE_STRUCT_T a);
 
-  :source: 
-    :header: |    
+  :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 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 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: |
       #include "expect_and_return_custom_types_unity_helper.h"
       void setUp(void) {}
       void tearDown(void) {}
-      
+
     :units:
     - :pass: TRUE
       :should: 'successfully exercise simple ExpectAndReturn mock calls'
@@ -52,7 +52,7 @@
           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: |
@@ -65,7 +65,7 @@
           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: |
@@ -78,7 +78,7 @@
           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: |
@@ -95,7 +95,7 @@
   :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, 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: |

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

@@ -10,7 +10,7 @@
 
 :systest:
   :types: |
-    typedef char* MY_STRING;
+    typedef const char* MY_STRING;
     typedef int MY_INT;
     typedef unsigned int MY_HEX;
     typedef int* PTR_INT;
@@ -23,8 +23,8 @@
     MY_INT* pointer_foo(MY_HEX* a);
     void pointer_bar(PTR_INT a);
 
-  :source: 
-    :header: |    
+  :source:
+    :header: |
       MY_INT function_a(MY_INT a, MY_INT b);
       MY_STRING function_b(MY_STRING a, MY_STRING b);
       float function_c(float a, float b);
@@ -32,38 +32,38 @@
       void function_e(PTR_INT a);
 
     :code: |
-      MY_INT function_a(MY_INT a, MY_INT b)    
+      MY_INT function_a(MY_INT a, MY_INT b)
       {
         return foo((MY_HEX)a) + bar((MY_HEX)b);
-      }    
-      
+      }
+
       MY_STRING function_b(MY_STRING a, MY_STRING b)
       {
         return foo_char_strings(a, b);
       }
-      
+
       float function_c(float a, float b)
       {
         return float_adder(b, a);
       }
-      
+
       MY_INT function_d(MY_HEX a)
       {
         MY_HEX b = a;
         MY_INT* c = pointer_foo(&b);
         return *c;
       }
-      
+
       void function_e(PTR_INT a)
       {
         pointer_bar(a);
       }
-      
+
   :tests:
     :common: |
       void setUp(void) {}
       void tearDown(void) {}
-      
+
     :units:
     - :pass: TRUE
       :should: 'successfully exercise two simple ExpectAndReturn mock calls'
@@ -74,7 +74,7 @@
           bar_ExpectAndReturn((MY_HEX)2, 20);
           TEST_ASSERT_EQUAL(30, function_a(1, 2));
         }
-      
+
     - :pass: FALSE
       :should: 'fail because bar() is expected but not called'
       :code: |
@@ -107,8 +107,8 @@
       :code: |
         test()
         {
-          float_adder_ExpectAndReturn(1.2345, 6.7890, 8.0235);
-          TEST_ASSERT_EQUAL_FLOAT(8.0235, function_c(6.7890, 1.2345));
+          float_adder_ExpectAndReturn(1.2345f, 6.7890f, 8.0235f);
+          TEST_ASSERT_EQUAL_FLOAT(8.0235f, function_c(6.7890f, 1.2345f));
         }
 
     - :pass: FALSE
@@ -116,10 +116,10 @@
       :code: |
         test()
         {
-          float_adder_ExpectAndReturn(1.2345, 6.7892, 8.0235);
-          TEST_ASSERT_EQUAL_FLOAT(8.0235, function_c(6.7890, 1.2345));
+          float_adder_ExpectAndReturn(1.2345f, 6.7892f, 8.0235f);
+          TEST_ASSERT_EQUAL_FLOAT(8.0235f, function_c(6.7890f, 1.2345f));
         }
-        
+
     - :pass: TRUE
       :should: 'handle pointers to treat_as values just as cleanly as the treat_as itself for passes'
       :code: |
@@ -130,7 +130,7 @@
           pointer_foo_ExpectAndReturn(&TestHex, &TestInt);
           TEST_ASSERT_EQUAL_INT(33, function_d(45));
         }
-        
+
     - :pass: FALSE
       :should: 'handle pointers to treat_as values just as cleanly as the treat_as itself for failures'
       :verify_error: 'Element 0 Expected 0x0000002D Was 0x0000002B'
@@ -142,7 +142,7 @@
           pointer_foo_ExpectAndReturn(&TestHex, &TestInt);
           TEST_ASSERT_EQUAL_INT(33, function_d(43));
         }
-        
+
     - :pass: TRUE
       :should: 'handle treat_as values containing pointers for passes'
       :code: |
@@ -155,7 +155,7 @@
           pointer_bar_Expect(ExpPtr);
           function_e(ActPtr);
         }
-        
+
     - :pass: FALSE
       :should: 'handle treat_as values containing pointers for failures'
       :verify_error: 'Element 0 Expected 33 Was 45'

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

@@ -0,0 +1,238 @@
+---
+:cmock:
+  :plugins:
+  - 'expect_any_args'
+
+:systest:
+  :types: |
+
+  :mockable: |
+    int foo(int a);
+    void bar(int b);
+
+  :source:
+    :header: |
+      int function(int a, int b, int c);
+      void func_b(int a);
+    :code: |
+      int function(int a, int b, int c)
+      {
+        bar(b);
+        return foo(a) + foo(b) + foo(c);
+      }
+      void func_b(int a)
+      {
+        bar(a);
+      }
+
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+    :units:
+    - :pass: TRUE
+      :should: 'successfully exercise simple ExpectAndReturn mock calls'
+      :code: |
+        test()
+        {
+          bar_Expect(2);
+          foo_ExpectAndReturn(1, 10);
+          foo_ExpectAndReturn(2, 20);
+          foo_ExpectAndReturn(3, 30);
+          TEST_ASSERT_EQUAL(60, function(1, 2, 3));
+        }
+
+    - :pass: TRUE
+      :should: 'ignore foo() call details'
+      :code: |
+        test()
+        {
+          bar_Expect(4);
+          foo_ExpectAnyArgsAndReturn(10);
+          foo_ExpectAnyArgsAndReturn(40);
+          foo_ExpectAnyArgsAndReturn(80);
+          TEST_ASSERT_EQUAL(130, function(3, 4, 3));
+        }
+
+    - :pass: FALSE
+      :should: 'ignore foo() call details and notice if we called foo() more times than expected'
+      :code: |
+        test()
+        {
+          bar_Expect(4);
+          foo_ExpectAnyArgsAndReturn(20);
+          foo_ExpectAnyArgsAndReturn(30);
+          TEST_ASSERT_EQUAL(50, function(3, 4, 9));
+        }
+
+    - :pass: FALSE
+      :should: 'ignore foo() call details and notice if we called foo() less times than expected'
+      :code: |
+        test()
+        {
+          bar_Expect(4);
+          foo_ExpectAnyArgsAndReturn(20);
+          foo_ExpectAnyArgsAndReturn(10);
+          foo_ExpectAnyArgsAndReturn(50);
+          foo_ExpectAnyArgsAndReturn(60);
+          TEST_ASSERT_EQUAL(70, function(3, 4, 9));
+        }
+
+    - :pass: TRUE
+      :should: 'ignore bar() and foo() call details'
+      :code: |
+        test()
+        {
+          bar_ExpectAnyArgs();
+          foo_ExpectAnyArgsAndReturn(50);
+          foo_ExpectAnyArgsAndReturn(50);
+          foo_ExpectAnyArgsAndReturn(50);
+          TEST_ASSERT_EQUAL(150, function(0, 0, 0));
+        }
+
+    - :pass: TRUE
+      :should: 'be able to handle an expect after ignore calls since we are ignoring args only'
+      :code: |
+        test()
+        {
+          bar_ExpectAnyArgs();
+          foo_ExpectAnyArgsAndReturn(50);
+          foo_ExpectAnyArgsAndReturn(50);
+          foo_ExpectAndReturn(3, 50);
+          TEST_ASSERT_EQUAL(150, function(1, 2, 3));
+        }
+
+    - :pass: TRUE
+      :should: 'be able to handle an ignore after an expect call since we are ignoring args only'
+      :code: |
+        test()
+        {
+          bar_ExpectAnyArgs();
+          foo_ExpectAndReturn(1, 50);
+          foo_ExpectAnyArgsAndReturn(50);
+          foo_ExpectAnyArgsAndReturn(50);
+          TEST_ASSERT_EQUAL(150, function(1, 2, 3));
+        }
+
+    - :pass: TRUE
+      :should: 'be able to handle an ignore within expect calls since we are ignoring args only'
+      :code: |
+        test()
+        {
+          bar_ExpectAnyArgs();
+          foo_ExpectAndReturn(1, 50);
+          foo_ExpectAnyArgsAndReturn(50);
+          foo_ExpectAndReturn(3, 50);
+          TEST_ASSERT_EQUAL(150, function(1, 2, 3));
+        }
+
+    - :pass: FALSE
+      :should: 'be able to detect problems with an expect even when using ignores'
+      :code: |
+        test()
+        {
+          bar_ExpectAnyArgs();
+          foo_ExpectAndReturn(1, 50);
+          foo_ExpectAnyArgsAndReturn(50);
+          foo_ExpectAndReturn(4, 50);
+          TEST_ASSERT_EQUAL(150, function(1, 2, 3));
+        }
+
+    - :pass: TRUE
+      :should: 'be able to handle a lone ExpectAnyArg call'
+      :code: |
+        test()
+        {
+          bar_ExpectAnyArgs();
+          func_b(1);
+        }
+
+    - :pass: FALSE
+      :should: 'be able to handle a lone ExpectAnyArg call that does not get called'
+      :code: |
+        test()
+        {
+          bar_ExpectAnyArgs();
+        }
+
+    - :pass: FALSE
+      :should: 'be able to handle a missing ExpectAnyArg call'
+      :code: |
+        test()
+        {
+          func_b(1);
+        }
+
+    - :pass: TRUE
+      :should: 'ignore foo() calls over multiple mock calls'
+      :code: |
+        test()
+        {
+          bar_ExpectAnyArgs();
+          foo_ExpectAnyArgsAndReturn(50);
+          foo_ExpectAnyArgsAndReturn(60);
+          foo_ExpectAnyArgsAndReturn(70);
+          TEST_ASSERT_EQUAL(180, function(0, 0, 0));
+
+          bar_ExpectAnyArgs();
+          foo_ExpectAnyArgsAndReturn(30);
+          foo_ExpectAnyArgsAndReturn(80);
+          foo_ExpectAnyArgsAndReturn(10);
+          TEST_ASSERT_EQUAL(120, function(0, 0, 0));
+
+          bar_ExpectAnyArgs();
+          foo_ExpectAnyArgsAndReturn(70);
+          foo_ExpectAnyArgsAndReturn(20);
+          foo_ExpectAnyArgsAndReturn(20);
+          TEST_ASSERT_EQUAL(110, function(0, 0, 0));
+        }
+
+    - :pass: TRUE
+      :should: 'have multiple cycles of expects still pass when this plugin enabled'
+      :code: |
+        test()
+        {
+          bar_Expect(2);
+          foo_ExpectAndReturn(1, 50);
+          foo_ExpectAndReturn(2, 60);
+          foo_ExpectAndReturn(3, 70);
+          TEST_ASSERT_EQUAL(180, function(1, 2, 3));
+
+          bar_Expect(5);
+          foo_ExpectAndReturn(4, 30);
+          foo_ExpectAndReturn(5, 80);
+          foo_ExpectAndReturn(6, 10);
+          TEST_ASSERT_EQUAL(120, function(4, 5, 6));
+
+          bar_Expect(8);
+          foo_ExpectAndReturn(7, 70);
+          foo_ExpectAndReturn(8, 20);
+          foo_ExpectAndReturn(9, 20);
+          TEST_ASSERT_EQUAL(110, function(7, 8, 9));
+        }
+
+    - :pass: FALSE
+      :should: 'have multiple cycles of expects still fail when this plugin enabled'
+      :code: |
+        test()
+        {
+          bar_Expect(2);
+          foo_ExpectAndReturn(1, 50);
+          foo_ExpectAndReturn(2, 60);
+          foo_ExpectAndReturn(3, 70);
+          TEST_ASSERT_EQUAL(180, function(1, 2, 3));
+
+          bar_Expect(5);
+          foo_ExpectAndReturn(4, 30);
+          foo_ExpectAndReturn(5, 80);
+          foo_ExpectAndReturn(6, 10);
+          TEST_ASSERT_EQUAL(120, function(4, 5, 6));
+
+          bar_Expect(8);
+          foo_ExpectAndReturn(7, 70);
+          foo_ExpectAndReturn(8, 20);
+          foo_ExpectAndReturn(9, 20);
+          TEST_ASSERT_EQUAL(110, function(0, 8, 9));
+        }
+
+...

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

@@ -3,7 +3,7 @@
   :plugins:
   - # none
   :treat_as:
-    INT_PTR: INT* 
+    INT_PTR: INT*
 
 :systest:
   :types: |
@@ -21,38 +21,38 @@
     const char* bars(void);
     INT_PTR zoink(INT_PTR a);
 
-  :source: 
-    :header: |    
+  :source:
+    :header: |
       void function_a(void);
       void function_b(void);
       void function_c(void);
       int  function_d(void);
 
     :code: |
-      void function_a(void)    
+      void function_a(void)
       {
         foo(bar());
-      }    
+      }
 
       void function_b(void) {
         fooa(bar());
       }
-      
+
       void function_c(void) {
         foos(bars());
       }
-      
+
       int function_d(void) {
         int i = 456;
         INT_PTR ptr = (INT_PTR)(&i);
         return (int)(*(zoink(ptr)));
       }
-      
+
   :tests:
     :common: |
       void setUp(void) {}
       void tearDown(void) {}
-      
+
     :units:
     - :pass: TRUE
       :should: 'handle the situation where we pass nulls to pointers'
@@ -61,10 +61,10 @@
         {
           bar_ExpectAndReturn(NULL);
           foo_Expect(NULL);
-          
+
           function_a();
         }
-        
+
     - :pass: TRUE
       :should: 'handle the situation where we pass single object with expect'
       :code: |
@@ -74,10 +74,10 @@
           POINT_T ex = {1, 2};
           bar_ExpectAndReturn(&pt);
           foo_Expect(&ex);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we pass single object with expect and it is wrong'
       :code: |
@@ -87,10 +87,10 @@
           POINT_T ex = {1, 3};
           bar_ExpectAndReturn(&pt);
           foo_Expect(&ex);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we pass nulls to pointers and fail'
       :code: |
@@ -99,10 +99,10 @@
           POINT_T pt = {1, 2};
           bar_ExpectAndReturn(&pt);
           foo_Expect(NULL);
-          
+
           function_a();
         }
-      
+
     - :pass: TRUE
       :should: 'handle the situation where we pass nulls to arrays'
       :code: |
@@ -110,7 +110,7 @@
         {
           bar_ExpectAndReturn(NULL);
           fooa_Expect(NULL);
-          
+
           function_b();
         }
 
@@ -123,10 +123,10 @@
           POINT_T ex = {1, 2};
           bar_ExpectAndReturn(&pt);
           fooa_Expect(&ex);
-          
+
           function_b();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we pass single array element with expect and it is wrong'
       :code: |
@@ -136,10 +136,10 @@
           POINT_T ex = {1, 3};
           bar_ExpectAndReturn(&pt);
           fooa_Expect(&ex);
-          
+
           function_b();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we pass nulls to arrays and fail'
       :code: |
@@ -148,7 +148,7 @@
           POINT_T pt = {1, 2};
           bar_ExpectAndReturn(&pt);
           fooa_Expect(NULL);
-          
+
           function_b();
         }
 
@@ -157,23 +157,25 @@
       :code: |
         test()
         {
-          bars_ExpectAndReturn("This is a\0 silly string");
+          const char* retval = "This is a\0 silly string";
+          bars_ExpectAndReturn((char*)retval);
           foos_Expect("This is a\0 wacky string");
-          
+
           function_c();
         }
-        
+
     - :pass: FALSE
       :should: 'handle standard c string as null terminated on not do crappy memory compares of a byte, finding failures'
       :code: |
         test()
         {
-          bars_ExpectAndReturn("This is a silly string");
+          const char* retval = "This is a silly string";
+          bars_ExpectAndReturn((char*)retval);
           foos_Expect("This is a wacky string");
-          
+
           function_c();
         }
-        
+
     - :pass: TRUE
       :should: 'handle handle typedefs that ARE pointers by using treat_as'
       :code: |
@@ -183,12 +185,12 @@
           int r = 789;
           INT_PTR ptr_e = (INT_PTR)(&e);
           INT_PTR ptr_r = (INT_PTR)(&r);
-          
+
           zoink_ExpectAndReturn(ptr_e, ptr_r);
-          
+
           TEST_ASSERT_EQUAL(r, function_d());
         }
-        
+
     - :pass: FALSE
       :should: 'handle handle typedefs that ARE pointers by using treat_as and catch failures'
       :code: |
@@ -198,9 +200,9 @@
           int r = 789;
           INT_PTR ptr_e = (INT_PTR)(&e);
           INT_PTR ptr_r = (INT_PTR)(&r);
-          
+
           zoink_ExpectAndReturn(ptr_e, ptr_r);
-          
+
           TEST_ASSERT_EQUAL(r, function_d());
         }