ceedling 0.0.2 → 0.0.3

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

@@ -1,208 +0,0 @@
----
-: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/new_project_template/vendor/ceedling/vendor/cmock/test/system/test_interactions/function_pointer_handling.yml

@@ -1,82 +0,0 @@
----
-: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'));
-        }
-
-
-...

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

@@ -1,153 +0,0 @@
----
-:cmock:
-  :plugins:
-  - 'ignore'
-
-:systest:
-  :types: |
-
-  :mockable: |
-    int foo(int a);
-    void bar(int b);
-
-  :source: 
-    :header: |
-      int function(int a, int b, int c);
-    :code: |
-      int function(int a, int b, int c)
-      {
-        bar(b);
-        return foo(a) + foo(b) + foo(c);
-      }    
-
-  :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() calls'
-      :code: |
-        test()
-        {
-          bar_Expect(4);
-          foo_IgnoreAndReturn(10);
-          foo_IgnoreAndReturn(40);
-          foo_IgnoreAndReturn(80);
-          TEST_ASSERT_EQUAL(130, function(3, 4, 3));
-        }
-      
-    - :pass: TRUE
-      :should: 'ignore foo() calls and always return last item if we run out'
-      :code: |
-        test()
-        {
-          bar_Expect(4);
-          foo_IgnoreAndReturn(20);
-          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: |
-        test()
-        {
-          bar_Expect(4);
-          foo_IgnoreAndReturn(20);
-          TEST_ASSERT_EQUAL(60, function(3, 4, 9));
-        }
-      
-    - :pass: TRUE
-      :should: 'ignore bar() and foo() calls'
-      :code: |
-        test()
-        {
-          bar_Ignore();
-          foo_IgnoreAndReturn(50);
-          TEST_ASSERT_EQUAL(150, function(0, 0, 0));
-        }
-      
-    - :pass: TRUE
-      :should: 'ignore foo() calls over multiple mock calls'
-      :code: |
-        test()
-        {
-          bar_Ignore();
-          foo_IgnoreAndReturn(50);
-          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: |
-        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: 'multiple cycles of expects still fail when ignores 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/new_project_template/vendor/ceedling/vendor/cmock/test/system/test_interactions/newer_standards_stuff1.yml

@@ -1,52 +0,0 @@
----
-#The purpose of this test is to pull in some standard library stuff from C99
-:cmock:
-  :includes:
-    - "<stdint.h>"
-    - "<limits.h>"
-
-:systest:
-  :types: |
-    #include <stdint.h>
-    #include <limits.h>
-  
-  
-  :mockable: |
-    int32_t foo(int32_t a);
-
-  :source: 
-    :header: |    
-      int8_t function_a(void);
-
-    :code: |
-      int8_t function_a(void) {
-        return (int8_t)(INT_MIN == foo(INT_MAX));
-      }
-      
-  :tests:
-    :common: |
-      void setUp(void) {}
-      void tearDown(void) {}
-      
-    :units:
-    - :pass: TRUE
-      :should: 'handle handle a simple comparison of C99 types which pass'
-      :code: |
-        test()
-        {
-          foo_ExpectAndReturn(INT_MAX, INT_MIN);
-          
-          TEST_ASSERT_TRUE(function_a());
-        }
-
-    - :pass: FALSE
-      :should: 'handle handle a simple comparison of C99 types which fail'
-      :code: |
-        test()
-        {
-          foo_ExpectAndReturn(INT_MIN, INT_MIN);
-          
-          TEST_ASSERT_TRUE(function_a());
-        }
-        
-...