ceedling 0.15.1 → 0.15.2

data/vendor/cmock/test/system/test_compilation/const.h

@@ -4,12 +4,17 @@
     [Released under MIT License. Please refer to license.txt for details]
 ========================================== */
 
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)
+#pragma GCC diagnostic ignored "-Wpragmas"
+#endif
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#pragma GCC diagnostic ignored "-Wduplicate-decl-specifier"
+
 struct _DUMMY_T { unsigned int a; float b; };
 
 void const_variants1( const char* a, int const, unsigned short const * c );
 
-void const_variants2( 
+void const_variants2(
 	struct _DUMMY_T const * const param1,
 	const unsigned long int const * const param2,
-	const struct _DUMMY_T const * param3 ); 
-
+	const struct _DUMMY_T const * param3 );

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

@@ -3,12 +3,14 @@
 :cmock:
   :enforce_strict_ordering: 1
   :treat_externs: :include
-  :ignore: :args_only
   :plugins:
   - :array
   - :cexception
   - :ignore
   - :callback
+  - :return_thru_ptr
+  - :ignore_arg
+  - :expect_any_args
 
 :systest:
   :types: |
@@ -23,14 +25,14 @@
     POINT_T* bar(void);
     void fooa(POINT_T a[]);
     void foos(const char * a);
-    extern const char * bars(void);
-    void no_pointers(int a, char* b);
+    extern const char* bars(void);
+    void no_pointers(int a, const char* b);
     int mixed(int a, int* b, int c);
     void no_args(void);
 
-  :source: 
-    :header: |   
-      #include "CException.h" 
+  :source:
+    :header: |
+      #include "CException.h"
       void function_a(void);
       void function_b(void);
       void function_c(void);
@@ -38,40 +40,40 @@
       void function_e(void);
 
     :code: |
-      void function_a(void)    
+      void function_a(void)
       {
         foo(bar());
-      }    
+      }
 
       void function_b(void) {
         fooa(bar());
       }
-      
+
       void function_c(void) {
         CEXCEPTION_T e;
         Try {
           foos(bars());
         } Catch(e) { foos("err"); }
       }
-      
+
       int function_d(void) {
         int test_list[] = { 1, 2, 3, 4, 5 };
         no_pointers(1, "silly");
         return mixed(6, test_list, 7);
       }
-      
+
       void function_e(void) {
         foos("Hello");
         foos("Tuna");
         foos("Oranges");
       }
-      
+
   :tests:
     :common: |
       #include "CException.h"
       void setUp(void) {}
       void tearDown(void) {}
-      
+
     :units:
     - :pass: TRUE
       :should: 'handle the situation where we pass nulls to pointers'
@@ -80,10 +82,10 @@
         {
           bar_ExpectAndReturn(NULL);
           foo_Expect(NULL);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we expected nulls to pointers but did not get that'
       :code: |
@@ -92,10 +94,10 @@
           POINT_T pt = {1, 2};
           bar_ExpectAndReturn(&pt);
           foo_Expect(NULL);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we did not expect nulls to pointers but got null'
       :code: |
@@ -104,10 +106,10 @@
           POINT_T ex = {1, 2};
           bar_ExpectAndReturn(NULL);
           foo_Expect(&ex);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we pass single object with expect and it is wrong'
       :code: |
@@ -117,10 +119,10 @@
           POINT_T ex = {1, 3};
           bar_ExpectAndReturn(&pt);
           foo_Expect(&ex);
-          
+
           function_a();
         }
-        
+
     - :pass: TRUE
       :should: 'handle the situation where we pass single object with expect and use array handler'
       :code: |
@@ -130,10 +132,10 @@
           POINT_T ex = {1, 2};
           bar_ExpectAndReturn(&pt);
           foo_ExpectWithArray(&ex, 1);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we pass single object with expect and use array handler and it is wrong'
       :code: |
@@ -143,10 +145,10 @@
           POINT_T ex = {1, 3};
           bar_ExpectAndReturn(&pt);
           foo_ExpectWithArray(&ex, 1);
-          
+
           function_a();
         }
-        
+
     - :pass: TRUE
       :should: 'handle the situation where we pass multiple objects with expect and use array handler'
       :code: |
@@ -156,10 +158,10 @@
           POINT_T ex[] = {{1, 2}, {3, 4}, {5, 6}};
           bar_ExpectAndReturn(pt);
           foo_ExpectWithArray(ex, 3);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we pass multiple objects with expect and use array handler and it is wrong at end'
       :code: |
@@ -169,7 +171,7 @@
           POINT_T ex[] = {{1, 2}, {3, 4}, {5, 9}};
           bar_ExpectAndReturn(pt);
           foo_ExpectWithArray(ex, 3);
-          
+
           function_a();
         }
 
@@ -182,7 +184,7 @@
           POINT_T ex = {1, 2};
           bar_ExpectAndReturn(&pt);
           fooa_Expect(&ex);
-          
+
           function_b();
         }
 
@@ -191,20 +193,24 @@
       :code: |
         test()
         {
-          bars_ExpectAndReturn("This is a\0 silly string");
+          const char* constretval = "This is a\0 silly string";
+          char* retval = (char*)constretval;
+          bars_ExpectAndReturn(retval);
           foos_Expect("This is a\0 wacky string");
-          
+
           function_c();
         }
-        
+
     - :pass: FALSE
       :should: 'handle standard c string as null terminated and not do crappy memory compares of a byte, finding failures'
       :code: |
         test()
         {
-          bars_ExpectAndReturn("This is a silly string");
+          const char* constretval = "This is a silly string";
+          char* retval = (char*)constretval;
+          bars_ExpectAndReturn(retval);
           foos_Expect("This is a wacky string");
-          
+
           function_c();
         }
 
@@ -216,7 +222,7 @@
           int expect_list[] = { 1, 9 };
           no_pointers_Expect(1, "silly");
           mixed_ExpectAndReturn(6, expect_list, 7, 13);
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
@@ -228,7 +234,7 @@
           int expect_list[] = { 9, 1 };
           no_pointers_Expect(1, "silly");
           mixed_ExpectAndReturn(6, expect_list, 7, 13);
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
@@ -240,7 +246,7 @@
           int expect_list[] = { 1, 2, 3, 4, 6 };
           no_pointers_Expect(1, "silly");
           mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
@@ -252,7 +258,7 @@
           int expect_list[] = { 1, 2, 3, 4, 6 };
           no_pointers_Expect(1, "silly");
           mixed_ExpectWithArrayAndReturn(6, expect_list, 5, 7, 13);
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
@@ -261,10 +267,12 @@
       :code: |
         test()
         {
-          bars_ExpectAndReturn("This is a\0 silly string");
+          const char* constretval = "This is a\0 silly string";
+          char* retval = (char*)constretval;
+          bars_ExpectAndReturn(retval);
           foos_ExpectAndThrow("This is a\0 wacky string", 55);
           foos_Expect("err");
-          
+
           function_c();
         }
 
@@ -273,10 +281,12 @@
       :code: |
         test()
         {
-          bars_ExpectAndReturn("This is a\0 silly string");
+          const char* constretval = "This is a\0 silly string";
+          char* retval = (char*)constretval;
+          bars_ExpectAndReturn(retval);
           foos_ExpectAndThrow("This is a\0 wacky string", 55);
           foos_Expect("wrong error");
-          
+
           function_c();
         }
 
@@ -288,53 +298,77 @@
           int expect_list[] = { 1, 2, 3, 4, 6 };
           mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
           no_pointers_Expect(1, "silly");
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
     - :pass: TRUE
-      :should: 'properly ignore first function but the other will work properly'
+      :should: 'properly ExpectAnyArgs first function but the other will work properly'
       :code: |
         test()
         {
           int expect_list[] = { 1, 2, 3, 4, 6 };
-          no_pointers_Ignore();
+          no_pointers_ExpectAnyArgs();
           mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
     - :pass: TRUE
-      :should: 'properly ignore last function but the other will work properly'
+      :should: 'properly ExpectAnyArgs last function but the other will work properly'
       :code: |
         test()
         {
           no_pointers_Expect(1, "silly");
-          mixed_IgnoreAndReturn(13);
-          
+          mixed_ExpectAnyArgsAndReturn(13);
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
     - :pass: TRUE
-      :should: 'be ok if we ignore a call each because we are counting calls'
+      :should: 'be ok if we ExpectAnyArgs a call each because we are counting calls'
+      :code: |
+        test()
+        {
+          foos_ExpectAnyArgs();
+          foos_ExpectAnyArgs();
+          foos_ExpectAnyArgs();
+
+          function_e();
+        }
+
+    - :pass: TRUE
+      :should: 'be ok if we ExpectAnyArgs and Expect intermixed because we are counting calls'
       :code: |
         test()
         {
-          foos_Ignore();
-          foos_Ignore();
-          foos_Ignore();
-          
+          foos_Expect("Hello");
+          foos_ExpectAnyArgs();
+          foos_ExpectAnyArgs();
+
           function_e();
         }
 
     - :pass: FALSE
-      :should: 'fail if we do not ignore a call once because we are counting calls'
+      :should: 'be able to detect Expect problem if we ExpectAnyArgs and Expect intermixed'
       :code: |
         test()
         {
-          foos_Ignore();
-          foos_Ignore();
-          
+          foos_Expect("Hello");
+          foos_ExpectAnyArgs();
+          foos_Expect("Wrong");
+
+          function_e();
+        }
+
+    - :pass: FALSE
+      :should: 'fail if we do not ExpectAnyArgs a call once because we are counting calls'
+      :code: |
+        test()
+        {
+          foos_ExpectAnyArgs();
+          foos_ExpectAnyArgs();
+
           function_e();
         }
 

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

@@ -8,6 +8,7 @@
   - :callback
   - :return_thru_ptr
   - :ignore_arg
+  - :expect_any_args
   :callback_after_arg_check: true
   :callback_include_count: false
   :treat_externs: :include
@@ -26,13 +27,13 @@
     void fooa(POINT_T a[]);
     void foos(const char * a);
     const char * bars(void);
-    void no_pointers(int a, char* b);
+    void no_pointers(int a, const char* b);
     int mixed(int a, int* b, int c);
     void no_args(void);
 
-  :source: 
-    :header: |   
-      #include "CException.h" 
+  :source:
+    :header: |
+      #include "CException.h"
       void function_a(void);
       void function_b(void);
       void function_c(void);
@@ -40,41 +41,41 @@
       void function_e(void);
 
     :code: |
-      void function_a(void)    
+      void function_a(void)
       {
         foo(bar());
-      }    
+      }
 
       void function_b(void) {
         fooa(bar());
       }
-      
+
       void function_c(void) {
         CEXCEPTION_T e;
         Try {
           foos(bars());
         } Catch(e) { foos("err"); }
       }
-      
+
       int function_d(void) {
         int test_list[] = { 1, 2, 3, 4, 5 };
         no_pointers(1, "silly");
         return mixed(6, test_list, 7);
       }
-      
+
       void function_e(void) {
         foos("Hello");
         foos("Tuna");
         foos("Oranges");
       }
-      
+
   :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: 'handle the situation where we pass nulls to pointers'
@@ -83,10 +84,10 @@
         {
           bar_ExpectAndReturn(NULL);
           foo_Expect(NULL);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we expected nulls to pointers but did not get that'
       :code: |
@@ -95,10 +96,10 @@
           POINT_T pt = {1, 2};
           bar_ExpectAndReturn(&pt);
           foo_Expect(NULL);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we did not expect nulls to pointers but got null'
       :code: |
@@ -107,10 +108,10 @@
           POINT_T ex = {1, 2};
           bar_ExpectAndReturn(NULL);
           foo_Expect(&ex);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we pass single object with expect and it is wrong'
       :code: |
@@ -120,10 +121,10 @@
           POINT_T ex = {1, 3};
           bar_ExpectAndReturn(&pt);
           foo_Expect(&ex);
-          
+
           function_a();
         }
-        
+
     - :pass: TRUE
       :should: 'handle the situation where we pass single object with expect and use array handler'
       :code: |
@@ -133,10 +134,10 @@
           POINT_T ex = {1, 2};
           bar_ExpectAndReturn(&pt);
           foo_ExpectWithArray(&ex, 1);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we pass single object with expect and use array handler and it is wrong'
       :code: |
@@ -146,10 +147,10 @@
           POINT_T ex = {1, 3};
           bar_ExpectAndReturn(&pt);
           foo_ExpectWithArray(&ex, 1);
-          
+
           function_a();
         }
-        
+
     - :pass: TRUE
       :should: 'handle the situation where we pass multiple objects with expect and use array handler'
       :code: |
@@ -159,10 +160,10 @@
           POINT_T ex[] = {{1, 2}, {3, 4}, {5, 6}};
           bar_ExpectAndReturn(pt);
           foo_ExpectWithArray(ex, 3);
-          
+
           function_a();
         }
-        
+
     - :pass: FALSE
       :should: 'handle the situation where we pass multiple objects with expect and use array handler and it is wrong at end'
       :code: |
@@ -172,7 +173,7 @@
           POINT_T ex[] = {{1, 2}, {3, 4}, {5, 9}};
           bar_ExpectAndReturn(pt);
           foo_ExpectWithArray(ex, 3);
-          
+
           function_a();
         }
 
@@ -185,7 +186,7 @@
           POINT_T ex = {1, 2};
           bar_ExpectAndReturn(&pt);
           fooa_Expect(&ex);
-          
+
           function_b();
         }
 
@@ -194,20 +195,22 @@
       :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 and 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();
         }
 
@@ -219,7 +222,7 @@
           int expect_list[] = { 1, 9 };
           no_pointers_Expect(1, "silly");
           mixed_ExpectAndReturn(6, expect_list, 7, 13);
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
@@ -231,7 +234,7 @@
           int expect_list[] = { 9, 1 };
           no_pointers_Expect(1, "silly");
           mixed_ExpectAndReturn(6, expect_list, 7, 13);
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
@@ -243,7 +246,7 @@
           int expect_list[] = { 1, 2, 3, 4, 6 };
           no_pointers_Expect(1, "silly");
           mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
@@ -255,7 +258,7 @@
           int expect_list[] = { 1, 2, 3, 4, 6 };
           no_pointers_Expect(1, "silly");
           mixed_ExpectWithArrayAndReturn(6, expect_list, 5, 7, 13);
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
@@ -264,10 +267,11 @@
       :code: |
         test()
         {
-          bars_ExpectAndReturn("This is a\0 silly string");
+          const char* retval = "This is a\0 silly string";
+          bars_ExpectAndReturn((char*)retval);
           foos_ExpectAndThrow("This is a\0 wacky string", 55);
           foos_Expect("err");
-          
+
           function_c();
         }
 
@@ -276,10 +280,11 @@
       :code: |
         test()
         {
-          bars_ExpectAndReturn("This is a\0 silly string");
+          const char* retval = "This is a\0 silly string";
+          bars_ExpectAndReturn((char*)retval);
           foos_ExpectAndThrow("This is a\0 wacky string", 55);
           foos_Expect("wrong error");
-          
+
           function_c();
         }
 
@@ -291,7 +296,7 @@
           int expect_list[] = { 1, 2, 3, 4, 6 };
           mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
           no_pointers_Expect(1, "silly");
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
@@ -303,7 +308,7 @@
           int expect_list[] = { 1, 2, 3, 4, 6 };
           mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
           no_pointers_Ignore();
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
@@ -314,7 +319,7 @@
         {
           mixed_IgnoreAndReturn(13);
           no_pointers_Expect(1, "silly");
-          
+
           TEST_ASSERT_EQUAL(13, function_d());
         }
 
@@ -324,7 +329,7 @@
         test()
         {
           foos_Ignore();
-          
+
           function_e();
         }
 
@@ -338,7 +343,7 @@
           bar_ExpectAndReturn(&pt1);
           foo_Expect(&pt2);
           foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback);
-          
+
           function_a();
         }
 
@@ -350,7 +355,7 @@
           POINT_T pt = {2, 3};
           bar_ExpectAndReturn(&pt);
           foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback);
-          
+
           function_a();
         }
 
@@ -364,7 +369,7 @@
           bar_ExpectAndReturn(&pt1);
           foo_Expect(&pt2);
           foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback);
-          
+
           function_a();
         }
 
@@ -377,7 +382,7 @@
           bar_ExpectAndReturn(&pt);
           foo_Expect(&pt);
           foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback);
-          
+
           function_a();
         }