ceedling 0.13.0.rc1 → 0.13.0

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

@@ -0,0 +1,170 @@
+---
+:cmock:
+  :plugins:
+  - :cexception
+
+:systest:
+  :types: |
+    #define UINT32 unsigned int
+    typedef signed int custom_type;
+
+  :mockable: |
+    #include "CException.h"
+    UINT32 foo(custom_type a);
+    UINT32 bar(custom_type b);
+    UINT32 foo_varargs(custom_type a, ...);
+
+  :source: 
+    :header: |
+      #include "CException.h"
+      UINT32 function_a(int a);
+      void function_b(char a);
+
+    :code: |
+      UINT32 function_a(int a)    
+      {
+        UINT32 r = 0;
+        CEXCEPTION_T e;
+        
+        Try
+        {
+          r = (UINT32)foo((custom_type)a);
+        }
+        Catch(e)
+        {
+          r = (UINT32)e*2;
+        }
+        return r;
+      }
+      
+      void function_b(char a)
+      {
+        if (a)
+        {
+          Throw((CEXCEPTION_T)a);
+        }
+      }
+      
+  :tests:
+    :common: |
+      #include "CException.h"
+      void setUp(void) {}
+      void tearDown(void) {}
+      
+    :units:
+    - :pass: TRUE
+      :should: 'successfully exercise a simple ExpectAndReturn mock calls'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          TEST_ASSERT_EQUAL(10, function_a(1));
+        }
+      
+    - :pass: TRUE
+      :should: 'successfully throw an error on first call'
+      :code: |
+        test()
+        {
+          foo_ExpectAndThrow((custom_type)1, 55);
+          TEST_ASSERT_EQUAL(110, function_a(1));
+        }
+      
+    - :pass: TRUE
+      :should: 'successfully throw an error on later calls'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          foo_ExpectAndReturn((custom_type)2, 20);
+          foo_ExpectAndThrow((custom_type)3, 15);
+          foo_ExpectAndReturn((custom_type)4, 40);
+          TEST_ASSERT_EQUAL(10, function_a(1));
+          TEST_ASSERT_EQUAL(20, function_a(2));
+          TEST_ASSERT_EQUAL(30, function_a(3));
+          TEST_ASSERT_EQUAL(40, function_a(4));
+        }
+      
+    - :pass: TRUE
+      :should: 'pass because we nothing happens'
+      :code: |
+        test()
+        {
+          function_b(0);
+        }
+      
+    - :pass: FALSE
+      :should: 'fail because we did not expect function B to throw'
+      :code: |
+        test()
+        {
+          function_b(1);
+        }
+      
+    - :pass: TRUE
+      :should: 'fail because we expect function B to throw'
+      :code: |
+        test()
+        {
+          CEXCEPTION_T e;
+          Try
+          {
+            function_b(3);
+            TEST_FAIL_MESSAGE("Should Have Thrown");
+          }
+          Catch(e)
+          {
+            TEST_ASSERT_EQUAL(3, e);
+          }
+        }
+      
+    - :pass: TRUE
+      :should: 'successfully throw an error on consecutive calls'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          foo_ExpectAndReturn((custom_type)1, 20);
+          foo_ExpectAndThrow((custom_type)1, 15);
+          foo_ExpectAndThrow((custom_type)3, 40);
+          TEST_ASSERT_EQUAL(10, function_a(1));
+          TEST_ASSERT_EQUAL(20, function_a(1));
+          TEST_ASSERT_EQUAL(30, function_a(1));
+          TEST_ASSERT_EQUAL(80, function_a(3));
+        }
+      
+    - :pass: TRUE
+      :should: 'successfully throw an error on later calls and after a previous mock call'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          foo_ExpectAndReturn((custom_type)1, 20);
+          foo_ExpectAndThrow((custom_type)1, 15);
+          TEST_ASSERT_EQUAL(10, function_a(1));
+          TEST_ASSERT_EQUAL(20, function_a(1));
+          TEST_ASSERT_EQUAL(30, function_a(1));
+          
+          foo_ExpectAndReturn((custom_type)2, 20);
+          foo_ExpectAndThrow((custom_type)3, 40);
+          TEST_ASSERT_EQUAL(20, function_a(2));
+          TEST_ASSERT_EQUAL(80, function_a(3));
+        }
+      
+    - :pass: TRUE
+      :should: 'successfully throw an error if expects and mocks called before it'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          foo_ExpectAndReturn((custom_type)1, 20);
+          TEST_ASSERT_EQUAL(10, function_a(1));
+          TEST_ASSERT_EQUAL(20, function_a(1));
+          
+          foo_ExpectAndReturn((custom_type)2, 20);
+          foo_ExpectAndThrow((custom_type)3, 40);
+          TEST_ASSERT_EQUAL(20, function_a(2));
+          TEST_ASSERT_EQUAL(80, function_a(3));
+        }
+        
+...

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

@@ -0,0 +1,208 @@
+---
+:cmock:
+  :plugins:
+  - # none
+  :treat_as:
+    INT_PTR: INT* 
+
+:systest:
+  :types: |
+    typedef struct _POINT_T {
+      int x;
+      int y;
+    } POINT_T;
+    typedef int* INT_PTR;
+
+  :mockable: |
+    void foo(POINT_T* a);
+    POINT_T* bar(void);
+    void fooa(POINT_T a[]);
+    void foos(const char *a);
+    const char* bars(void);
+    INT_PTR zoink(INT_PTR a);
+
+  :source: 
+    :header: |    
+      void function_a(void);
+      void function_b(void);
+      void function_c(void);
+      int  function_d(void);
+
+    :code: |
+      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'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn(NULL);
+          foo_Expect(NULL);
+          
+          function_a();
+        }
+        
+    - :pass: TRUE
+      :should: 'handle the situation where we pass single object with expect'
+      :code: |
+        test()
+        {
+          POINT_T pt = {1, 2};
+          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: |
+        test()
+        {
+          POINT_T pt = {1, 2};
+          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: |
+        test()
+        {
+          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: |
+        test()
+        {
+          bar_ExpectAndReturn(NULL);
+          fooa_Expect(NULL);
+          
+          function_b();
+        }
+
+    - :pass: TRUE
+      :should: 'handle the situation where we pass single array element with expect'
+      :code: |
+        test()
+        {
+          POINT_T pt = {1, 2};
+          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: |
+        test()
+        {
+          POINT_T pt = {1, 2};
+          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: |
+        test()
+        {
+          POINT_T pt = {1, 2};
+          bar_ExpectAndReturn(&pt);
+          fooa_Expect(NULL);
+          
+          function_b();
+        }
+
+    - :pass: TRUE
+      :should: 'handle standard c string as null terminated on not do crappy memory compares of a byte, passing'
+      :code: |
+        test()
+        {
+          bars_ExpectAndReturn("This is a\0 silly string");
+          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");
+          foos_Expect("This is a wacky string");
+          
+          function_c();
+        }
+        
+    - :pass: TRUE
+      :should: 'handle handle typedefs that ARE pointers by using treat_as'
+      :code: |
+        test()
+        {
+          int e = 456;
+          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: |
+        test()
+        {
+          int e = 457;
+          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());
+        }
+
+
+...

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

@@ -0,0 +1,82 @@
+---
+:cmock:
+  :plugins:
+  - # none
+  :treat_as:
+    FUNCTION_T: PTR
+
+:systest:
+  :types: |
+    typedef void (*FUNCTION_T)(void);
+
+  :mockable: |
+    void takes_function_type( FUNCTION_T myfunc );
+    void takes_function_ptr( unsigned int (*func_ptr)(int, char) );
+    void takes_const_function_ptr( unsigned int (* const)(int, char) );
+    unsigned short (*returns_function_ptr( const char op_code ))( int, long int );
+
+  :source: 
+    :header: |
+      void exercise_function_pointer_param(void);
+      unsigned short (*exercise_function_pointer_return( const char op_code ))( int, long int );
+      
+      // functions for function pointer tests
+      unsigned int dummy_function1(int a, char b);
+      unsigned short dummy_function2(int a, long int b);
+
+    :code: |
+      /*
+       * functions used in tests
+       */
+       
+      unsigned int dummy_function1(int a, char b)
+      {
+        // prevent compiler warnings by using everything
+        return (unsigned int)a + (unsigned int)b;
+      }
+
+      unsigned short dummy_function2(int a, long int b)
+      {
+        // prevent compiler warnings by using everything
+        return (unsigned short)a + (unsigned short)b;
+      }
+
+      /*
+       * functions executed by tests
+       */
+
+      void exercise_function_pointer_param(void)
+      {
+        takes_function_ptr(dummy_function1);
+      }
+
+      unsigned short (*exercise_function_pointer_return( const char op_code ))( int, long int )
+      {
+        return returns_function_ptr(op_code);
+      }
+
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+    :units:
+    - :pass: TRUE
+      :should: 'expect a function pointer param'
+      :code: |
+        test()
+        {
+          takes_function_ptr_Expect(dummy_function1);
+          exercise_function_pointer_param();
+        }
+
+    - :pass: TRUE
+      :should: 'return a function pointer'
+      :code: |
+        test()
+        {
+          returns_function_ptr_ExpectAndReturn('z', dummy_function2);
+          TEST_ASSERT_EQUAL_PTR(dummy_function2, exercise_function_pointer_return('z'));
+        }
+
+
+...