ceedling 0.15.1 → 0.15.2

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

@@ -10,7 +10,7 @@
     int foo(int a);
     void bar(int b);
 
-  :source: 
+  :source:
     :header: |
       int function(int a, int b, int c);
     :code: |
@@ -18,7 +18,7 @@
       {
         bar(b);
         return foo(a) + foo(b) + foo(c);
-      }    
+      }
 
   :tests:
     :common: |
@@ -36,7 +36,7 @@
           foo_ExpectAndReturn(3, 30);
           TEST_ASSERT_EQUAL(60, function(1, 2, 3));
         }
-      
+
     - :pass: TRUE
       :should: 'ignore foo() calls'
       :code: |
@@ -48,7 +48,16 @@
           foo_IgnoreAndReturn(80);
           TEST_ASSERT_EQUAL(130, function(3, 4, 3));
         }
-      
+
+    - :pass: TRUE
+      :should: 'ignore the situation where foo() is not called even though we explicitly ignored it'
+      :code: |
+        test()
+        {
+          foo_IgnoreAndReturn(20);
+          //notice we do not call foo
+        }
+
     - :pass: TRUE
       :should: 'ignore foo() calls and always return last item if we run out'
       :code: |
@@ -59,7 +68,7 @@
           foo_IgnoreAndReturn(30);
           TEST_ASSERT_EQUAL(80, function(3, 4, 9));
         }
-      
+
     - :pass: TRUE
       :should: 'ignore foo() calls and always return only item if only one specified'
       :code: |
@@ -69,7 +78,7 @@
           foo_IgnoreAndReturn(20);
           TEST_ASSERT_EQUAL(60, function(3, 4, 9));
         }
-      
+
     - :pass: TRUE
       :should: 'ignore bar() and foo() calls'
       :code: |
@@ -79,7 +88,7 @@
           foo_IgnoreAndReturn(50);
           TEST_ASSERT_EQUAL(150, function(0, 0, 0));
         }
-      
+
     - :pass: TRUE
       :should: 'ignore foo() calls over multiple mock calls'
       :code: |
@@ -90,18 +99,18 @@
           foo_IgnoreAndReturn(60);
           foo_IgnoreAndReturn(70);
           TEST_ASSERT_EQUAL(180, function(0, 0, 0));
-          
+
           bar_Ignore();
           foo_IgnoreAndReturn(30);
           foo_IgnoreAndReturn(80);
           foo_IgnoreAndReturn(10);
           TEST_ASSERT_EQUAL(120, function(0, 0, 0));
-          
+
           foo_IgnoreAndReturn(70);
           foo_IgnoreAndReturn(20);
           TEST_ASSERT_EQUAL(110, function(0, 0, 0));
         }
-      
+
     - :pass: TRUE
       :should: 'multiple cycles of expects still pass when ignores enabled'
       :code: |
@@ -112,20 +121,20 @@
           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: 'multiple cycles of expects still fail when ignores enabled'
       :code: |
@@ -136,13 +145,13 @@
           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);

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

@@ -6,26 +6,26 @@
 
 :systest:
   :types: |
-  
-  
+
+
   :mockable: |
     void foo(unsigned char** a);
     unsigned char** bar(void);
 
-  :source: 
-    :header: |    
+  :source:
+    :header: |
       void function_a(void);
 
     :code: |
       void function_a(void) {
         foo(bar());
       }
-      
+
   :tests:
     :common: |
       void setUp(void) {}
       void tearDown(void) {}
-      
+
     :units:
     - :pass: TRUE
       :should: 'handle two dimensional array of unsigned characters just like we would handle a single dimensional array in expect (where we really only care about first element)'
@@ -34,13 +34,13 @@
         {
           unsigned char a[] = { 1, 2, 3, 4, 5, 6 };
           unsigned char** pa = (unsigned char**)(&a);
-          
+
           bar_ExpectAndReturn(pa);
           foo_Expect(pa);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle two dimensional array of unsigned characters just like we would handle a single dimensional array in expect as failures (where we really only care about first element)'
       :code: |
@@ -50,10 +50,10 @@
           unsigned char b[] = { 5, 6, 7, 8, 9, 0 };
           unsigned char** pa = (unsigned char**)(&a);
           unsigned char** pb = (unsigned char**)(&b);
-          
+
           bar_ExpectAndReturn(pa);
           foo_Expect(pb);
-          
+
           function_a();
         }
 ...

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

@@ -0,0 +1,235 @@
+---
+:cmock:
+    :mock_path: test/mocks
+    :mock_prefix: mock_
+    :treat_as:
+        abs_struct: PTR
+        intptr: INT*
+    :when_ptr: :smart
+    :plugins:
+        - :array
+        - :ignore_arg
+        - :return_thru_ptr
+
+:systest:
+  :types: |
+    typedef int *intptr;
+
+    struct a_struct
+    {
+        int i1;
+        int i2;
+        int i3;
+    };
+
+    struct _abs_struct
+    {
+        int abs_i1;
+        int abs_i2;
+    };
+
+    typedef struct _abs_struct abs_struct;
+
+  :mockable: |
+      void ptr_ret_int(int *r);
+      void ptr_ret_ints(int *r, int *s);
+      void ptr_ret_array(char r[], int len);
+      void ptr_ret_typedef(intptr r);
+      void ptr_ret_struct(struct a_struct *r);
+      void ptr_ret_abstract(abs_struct *r);
+      void ptr_ret_abstract_array(abs_struct *r, int len);
+      void ptr_ret_const_int(int *r, const int *s);
+      void ptr_ret_string(char *s);
+
+  :source:
+    :header: |
+      #include <string.h>
+      #define lengthof(x) (sizeof(x)/sizeof((x)[0]))
+
+    :code: |
+
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+
+    :units:
+    - :pass: TRUE
+      :should: "handle a single int* argument"
+      :code: |
+        test()
+        {
+          int r = 1;
+          int res = 4;
+
+          ptr_ret_int_Expect(&r);
+          ptr_ret_int_ReturnThruPtr_r(&res);
+          ptr_ret_int(&r);
+          TEST_ASSERT_EQUAL(4, r);
+        }
+
+    - :pass: TRUE
+      :should: "handle multiple calls"
+      :code: |
+        test()
+        {
+          int r = 1;
+          int res1 = 4;
+          int res2 = 8;
+          int res3 = 16;
+
+          ptr_ret_int_Expect(&r);
+          ptr_ret_int_ReturnThruPtr_r(&res1);
+          ptr_ret_int_Expect(&r);
+          ptr_ret_int_ReturnThruPtr_r(&res2);
+          ptr_ret_int_Expect(&r);
+          ptr_ret_int_ReturnThruPtr_r(&res3);
+
+          ptr_ret_int(&r);
+          TEST_ASSERT_EQUAL(4, r);
+          ptr_ret_int(&r);
+          TEST_ASSERT_EQUAL(8, r);
+          ptr_ret_int(&r);
+          TEST_ASSERT_EQUAL(16, r);
+
+        }
+
+    - :pass: TRUE
+      :should: "ignore an argument"
+      :code: |
+        test()
+        {
+          int r = 1, s = 2;
+          int res = 4;
+
+          ptr_ret_int_Expect(&r);
+          ptr_ret_int_IgnoreArg_r();
+          ptr_ret_int_ReturnThruPtr_r(&res);
+          ptr_ret_int(&s);
+          TEST_ASSERT_EQUAL(4, s);
+        }
+
+    - :pass: TRUE
+      :should: "ignore a null pointer argument"
+      :code: |
+        test()
+        {
+          int r = 1;
+          int res = 4;
+
+          ptr_ret_int_Expect(NULL);
+          ptr_ret_int_IgnoreArg_r();
+          ptr_ret_int_ReturnThruPtr_r(&res);
+          ptr_ret_int(&r);
+          TEST_ASSERT_EQUAL(4, r);
+        }
+
+    - :pass: TRUE
+      :should: "handle multiple int* arguments"
+      :code: |
+        test()
+        {
+          int r, s = 0x0880AA55;
+          int r_res = 4;
+          int s_res = 6;
+
+          ptr_ret_ints_Expect(&r, &s);
+          ptr_ret_ints_ReturnThruPtr_r(&r_res);
+          ptr_ret_ints_ReturnThruPtr_s(&s_res);
+          ptr_ret_ints(&r, &s);
+          TEST_ASSERT_EQUAL(4, r);
+          TEST_ASSERT_EQUAL(6, s);
+        }
+
+    - :pass: TRUE
+      :should: "only return through pointer when asked to"
+      :code: |
+        test()
+        {
+          int r = 0x0880AA55;
+          int s = 0xAA55;
+          int r_res = 4;
+
+          ptr_ret_ints_Expect(&r, &s);
+          ptr_ret_ints_ReturnThruPtr_r(&r_res);
+          ptr_ret_ints(&r, &s);
+          TEST_ASSERT_EQUAL(4, r);
+          TEST_ASSERT_EQUAL(0xAA55, s);
+        }
+
+    - :pass: TRUE
+      :should: "return an array through a pointer correctly"
+      :code: |
+        test()
+        {
+          char r_a[] = "booboorooboo";
+          char r_a_ret[] = "FEEFI";
+
+          ptr_ret_array_Expect(r_a, lengthof(r_a));
+          ptr_ret_array_ReturnArrayThruPtr_r(r_a_ret, (int)strlen(r_a_ret));
+          ptr_ret_array(r_a, lengthof(r_a));
+          TEST_ASSERT_EQUAL_STRING("FEEFIorooboo", r_a);
+        }
+
+    - :pass: TRUE
+      :should: "handle structs"
+      :code: |
+        test()
+        {
+          struct a_struct r_s = { .i1 = 2, .i2 = 3, .i3 = 4, };
+          struct a_struct r_s_ret = { .i1 = 8, .i2 = 16, .i3 = 32, };
+
+          ptr_ret_struct_Expect(&r_s);
+          ptr_ret_struct_ReturnThruPtr_r(&r_s_ret);
+          ptr_ret_struct(&r_s);
+          TEST_ASSERT_EQUAL_MEMORY(&r_s_ret, &r_s, sizeof(struct a_struct));
+        }
+
+    - :pass: TRUE
+      :should: "handle typedefs"
+      :code: |
+        test()
+        {
+          abs_struct r_as = {.abs_i1 = 0x1234, .abs_i2 = 0x4567};
+          abs_struct r_as_ret = {.abs_i1 = 0xFFAA55, .abs_i2 = 0xAAFFAA};
+          ptr_ret_abstract_Expect(&r_as);
+          ptr_ret_abstract_ReturnMemThruPtr_r(&r_as_ret, sizeof(abs_struct));
+          ptr_ret_abstract(&r_as);
+          TEST_ASSERT_EQUAL_MEMORY(&r_as_ret, &r_as, sizeof(abs_struct));
+        }
+
+    - :pass: TRUE
+      :should: "only generate ReturnThruPtr definitions for non-const arguments"
+      :code: |
+        test()
+        {
+        #if !defined(ptr_ret_const_int_ReturnThruPtr_r)
+            TEST_FAIL_MESSAGE("ReturnThruPtr not defined for a pointer argument.");
+        #endif
+
+        #if defined(ptr_ret_const_int_ReturnThruPtr_s)
+            TEST_FAIL_MESSAGE("ReturnThruPtr defined for a const pointer argument.");
+        #endif
+        }
+
+    - :pass: TRUE
+      :should: "generate ReturnThruPtr definitions for string arguments"
+      :code: |
+        test()
+        {
+        #if !defined(ptr_ret_string_ReturnThruPtr_s)
+            TEST_FAIL_MESSAGE("ReturnThruPtr not defined for a string argument.");
+        #endif
+        }
+
+    - :pass: TRUE
+      :should: "generate IgnoreArg definitions"
+      :code: |
+        test()
+        {
+        #if !defined(ptr_ret_array_IgnoreArg_r)         \
+            || !defined(ptr_ret_array_IgnoreArg_len)    \
+            || !defined(ptr_ret_const_int_IgnoreArg_s)
+            TEST_FAIL_MESSAGE("IgnoreArg not defined for an argument.");
+        #endif
+        }

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

@@ -8,7 +8,7 @@
     :when_ptr: :smart
     :plugins:
         - :array
-        - :ignore_arg
+        - :expect_any_args
         - :return_thru_ptr
 
 :systest:
@@ -21,13 +21,13 @@
         int i2;
         int i3;
     };
-    
-    struct _abs_struct 
+
+    struct _abs_struct
     {
         int abs_i1;
         int abs_i2;
     };
-    
+
     typedef struct _abs_struct abs_struct;
 
   :mockable: |
@@ -61,7 +61,7 @@
         {
           int r = 1;
           int res = 4;
-          
+
           ptr_ret_int_Expect(&r);
           ptr_ret_int_ReturnThruPtr_r(&res);
           ptr_ret_int(&r);
@@ -77,21 +77,21 @@
           int res1 = 4;
           int res2 = 8;
           int res3 = 16;
-          
+
           ptr_ret_int_Expect(&r);
           ptr_ret_int_ReturnThruPtr_r(&res1);
           ptr_ret_int_Expect(&r);
           ptr_ret_int_ReturnThruPtr_r(&res2);
           ptr_ret_int_Expect(&r);
           ptr_ret_int_ReturnThruPtr_r(&res3);
-      
+
           ptr_ret_int(&r);
           TEST_ASSERT_EQUAL(4, r);
           ptr_ret_int(&r);
           TEST_ASSERT_EQUAL(8, r);
           ptr_ret_int(&r);
           TEST_ASSERT_EQUAL(16, r);
-      
+
         }
 
     - :pass: TRUE
@@ -99,11 +99,10 @@
       :code: |
         test()
         {
-          int r = 1, s = 2;
+          int s = 2;
           int res = 4;
-          
-          ptr_ret_int_Expect(&r);
-          ptr_ret_int_IgnoreArg_r();
+
+          ptr_ret_int_ExpectAnyArgs();
           ptr_ret_int_ReturnThruPtr_r(&res);
           ptr_ret_int(&s);
           TEST_ASSERT_EQUAL(4, s);
@@ -116,9 +115,8 @@
         {
           int r = 1;
           int res = 4;
-          
-          ptr_ret_int_Expect(NULL);
-          ptr_ret_int_IgnoreArg_r();
+
+          ptr_ret_int_ExpectAnyArgs();
           ptr_ret_int_ReturnThruPtr_r(&res);
           ptr_ret_int(&r);
           TEST_ASSERT_EQUAL(4, r);
@@ -132,7 +130,7 @@
           int r, s = 0x0880AA55;
           int r_res = 4;
           int s_res = 6;
-      
+
           ptr_ret_ints_Expect(&r, &s);
           ptr_ret_ints_ReturnThruPtr_r(&r_res);
           ptr_ret_ints_ReturnThruPtr_s(&s_res);
@@ -149,7 +147,7 @@
           int r = 0x0880AA55;
           int s = 0xAA55;
           int r_res = 4;
-      
+
           ptr_ret_ints_Expect(&r, &s);
           ptr_ret_ints_ReturnThruPtr_r(&r_res);
           ptr_ret_ints(&r, &s);
@@ -164,9 +162,9 @@
         {
           char r_a[] = "booboorooboo";
           char r_a_ret[] = "FEEFI";
-      
+
           ptr_ret_array_Expect(r_a, lengthof(r_a));
-          ptr_ret_array_ReturnArrayThruPtr_r(r_a_ret, strlen(r_a_ret));
+          ptr_ret_array_ReturnArrayThruPtr_r(r_a_ret, (int)strlen(r_a_ret));
           ptr_ret_array(r_a, lengthof(r_a));
           TEST_ASSERT_EQUAL_STRING("FEEFIorooboo", r_a);
         }
@@ -178,7 +176,7 @@
         {
           struct a_struct r_s = { .i1 = 2, .i2 = 3, .i3 = 4, };
           struct a_struct r_s_ret = { .i1 = 8, .i2 = 16, .i3 = 32, };
-      
+
           ptr_ret_struct_Expect(&r_s);
           ptr_ret_struct_ReturnThruPtr_r(&r_s_ret);
           ptr_ret_struct(&r_s);
@@ -206,7 +204,7 @@
         #if !defined(ptr_ret_const_int_ReturnThruPtr_r)
             TEST_FAIL_MESSAGE("ReturnThruPtr not defined for a pointer argument.");
         #endif
-        
+
         #if defined(ptr_ret_const_int_ReturnThruPtr_s)
             TEST_FAIL_MESSAGE("ReturnThruPtr defined for a const pointer argument.");
         #endif
@@ -223,13 +221,11 @@
         }
 
     - :pass: TRUE
-      :should: "generate IgnoreArg definitions"
+      :should: "generate ExpectAnyArgs definitions"
       :code: |
         test()
         {
-        #if !defined(ptr_ret_array_IgnoreArg_r)         \
-            || !defined(ptr_ret_array_IgnoreArg_len)    \
-            || !defined(ptr_ret_const_int_IgnoreArg_s)
-            TEST_FAIL_MESSAGE("IgnoreArg not defined for an argument.");
+        #if !defined(ptr_ret_array_ExpectAnyArgs)
+            TEST_FAIL_MESSAGE("ExpectAnyArgs not defined for an argument.");
         #endif
         }