ceedling 0.0.2 → 0.0.3

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

@@ -1,381 +0,0 @@
----
-:cmock:
-  :enforce_strict_ordering: 1
-  :plugins:
-  - :array
-  - :cexception
-  - :ignore
-  - :callback
-  :callback_after_arg_check: true
-  #:callback_include_count: false
-  :treat_externs: :include
-
-:systest:
-  :types: |
-    typedef struct _POINT_T {
-      int x;
-      int y;
-    } POINT_T;
-
-  :mockable: |
-    #include  "CException.h"
-    extern void foo(POINT_T* a);
-    POINT_T* bar(void);
-    void fooa(POINT_T a[]);
-    void foos(const char * a);
-    const char * bars(void);
-    void no_pointers(int a, char* b);
-    int mixed(int a, int* b, int c);
-
-  :source: 
-    :header: |   
-      #include "CException.h" 
-      void function_a(void);
-      void function_b(void);
-      void function_c(void);
-      int function_d(void);
-      void function_e(void);
-
-    :code: |
-      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'
-      :code: |
-        test()
-        {
-          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: |
-        test()
-        {
-          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: |
-        test()
-        {
-          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: |
-        test()
-        {
-          POINT_T pt = {1, 2};
-          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: |
-        test()
-        {
-          POINT_T pt = {1, 2};
-          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: |
-        test()
-        {
-          POINT_T pt = {1, 2};
-          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: |
-        test()
-        {
-          POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}};
-          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: |
-        test()
-        {
-          POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}};
-          POINT_T ex[] = {{1, 2}, {3, 4}, {5, 9}};
-          bar_ExpectAndReturn(pt);
-          foo_ExpectWithArray(ex, 3);
-          
-          function_a();
-        }
-
-    - :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: 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 creating array expects when we have mixed arguments for single object'
-      :code: |
-        test()
-        {
-          int expect_list[] = { 1, 9 };
-          no_pointers_Expect(1, "silly");
-          mixed_ExpectAndReturn(6, expect_list, 7, 13);
-          
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: FALSE
-      :should: 'handle creating array expects when we have mixed arguments and handle failures for single object'
-      :code: |
-        test()
-        {
-          int expect_list[] = { 9, 1 };
-          no_pointers_Expect(1, "silly");
-          mixed_ExpectAndReturn(6, expect_list, 7, 13);
-          
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: TRUE
-      :should: 'handle creating array expects when we have mixed arguments for multiple objects'
-      :code: |
-        test()
-        {
-          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());
-        }
-
-    - :pass: FALSE
-      :should: 'handle creating array expects when we have mixed arguments and handle failures for multiple objects'
-      :code: |
-        test()
-        {
-          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());
-        }
-
-    - :pass: TRUE
-      :should: 'handle an exception being caught'
-      :code: |
-        test()
-        {
-          bars_ExpectAndReturn("This is a\0 silly string");
-          foos_ExpectAndThrow("This is a\0 wacky string", 55);
-          foos_Expect("err");
-          
-          function_c();
-        }
-
-    - :pass: FALSE
-      :should: 'handle an exception being caught but still catch following errors'
-      :code: |
-        test()
-        {
-          bars_ExpectAndReturn("This is a\0 silly string");
-          foos_ExpectAndThrow("This is a\0 wacky string", 55);
-          foos_Expect("wrong error");
-          
-          function_c();
-        }
-
-    - :pass: FALSE
-      :should: 'fail strict ordering problems even though we would otherwise have passed'
-      :code: |
-        test()
-        {
-          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: 'that we can properly ignore last  function but the other will work properly'
-      :code: |
-        test()
-        {
-          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());
-        }
-
-    - :pass: TRUE
-      :should: 'that we can properly ignore first function but the other will work properly'
-      :code: |
-        test()
-        {
-          mixed_IgnoreAndReturn(13);
-          no_pointers_Expect(1, "silly");
-          
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: TRUE
-      :should: 'that we just have to ignore a call once because we are not counting calls'
-      :code: |
-        test()
-        {
-          foos_Ignore();
-          
-          function_e();
-        }
-
-    - :pass: TRUE
-      :should: 'that we can use a callback and an expect'
-      :code: |
-        test()
-        {
-          POINT_T pt1 = {2, 3};
-          POINT_T pt2 = {2, 3};
-          bar_ExpectAndReturn(&pt1);
-          foo_Expect(&pt2);
-          foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback);
-          
-          function_a();
-        }
-
-    - :pass: FALSE
-      :should: 'that we can fail even when using a callback if we want to expect call but did not and we are checking that'
-      :code: |
-        test()
-        {
-          POINT_T pt = {2, 3};
-          bar_ExpectAndReturn(&pt);
-          foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback);
-          
-          function_a();
-        }
-
-    - :pass: FALSE
-      :should: 'that we can fail even when using a callback if args are wrong and we are checking those'
-      :code: |
-        test()
-        {
-          POINT_T pt1 = {2, 3};
-          POINT_T pt2 = {1, 3};
-          bar_ExpectAndReturn(&pt1);
-          foo_Expect(&pt2);
-          foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback);
-          
-          function_a();
-        }
-
-    - :pass: FALSE
-      :should: 'that we can fail from the callback itself'
-      :code: |
-        test()
-        {
-          POINT_T pt = {3, 3};
-          bar_ExpectAndReturn(&pt);
-          foo_Expect(&pt);
-          foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback);
-          
-          function_a();
-        }
-
-...

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

@@ -1,382 +0,0 @@
----
-:cmock:
-  :when_ptr: :smart
-  :plugins:
-  - :array
-
-:systest:
-  :types: |
-    typedef struct _POINT_T {
-      int x;
-      int y;
-    } POINT_T;
-    #define ARRAY_A_SIZE  (5) 
-
-  :mockable: |
-    void foo(POINT_T* a);
-    POINT_T* bar(void);
-    void fooa(POINT_T a[ARRAY_A_SIZE+1-1]);
-    void foos(const char * a);
-    const char * bars(void);
-    void no_pointers(int a, char* b);
-    int mixed(int a, int* b, int c);
-    void potential_packing_problem(short *a);
-
-  :source: 
-    :header: |    
-      void function_a(void);
-      void function_b(void);
-      void function_c(void);
-      int  function_d(void);
-      void function_e(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 test_list[] = { 1, 2, 3, 4, 5 };
-        no_pointers(1, "silly");
-        return mixed(6, test_list, 7);
-      }
-      
-      void function_e(void) {
-        short test_list[] = {-1, -2, -3, -4};
-        potential_packing_problem(&test_list[1]);
-      }
-      
-  :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: FALSE
-      :should: 'handle the situation where we expected nulls to pointers but did not get that'
-      :code: |
-        test()
-        {
-          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: |
-        test()
-        {
-          POINT_T ex = {1, 2};
-          bar_ExpectAndReturn(NULL);
-          foo_Expect(&ex);
-          
-          function_a();
-        }
-        
-    - :pass: TRUE
-      :should: 'handle the situation where it falls back to pointers because you asked it to compare 0 elements'
-      :code: |
-        test()
-        {
-          POINT_T ex = {1, 2};
-          bar_ExpectAndReturn(&ex);
-          foo_ExpectWithArray(&ex, 0);
-          
-          function_a();
-        }
-        
-    - :pass: FALSE
-      :should: 'handle the situation where it fails because you asked it to compare zero elements and the pointers do not match'
-      :code: |
-        test()
-        {
-          POINT_T ex = {1, 2};
-          POINT_T pt = {1, 2};
-          bar_ExpectAndReturn(&pt);
-          foo_ExpectWithArray(&ex, 0);
-          
-          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: TRUE
-      :should: 'handle the situation where we pass single object with expect and use array handler'
-      :code: |
-        test()
-        {
-          POINT_T pt = {1, 2};
-          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: |
-        test()
-        {
-          POINT_T pt = {1, 2};
-          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: |
-        test()
-        {
-          POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}};
-          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 start'
-      :code: |
-        test()
-        {
-          POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}};
-          POINT_T ex[] = {{9, 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: |
-        test()
-        {
-          POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}};
-          POINT_T ex[] = {{1, 2}, {3, 4}, {5, 9}};
-          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 in middle'
-      :code: |
-        test()
-        {
-          POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}};
-          POINT_T ex[] = {{1, 2}, {3, 9}, {5, 6}};
-          bar_ExpectAndReturn(pt);
-          foo_ExpectWithArray(ex, 3);
-          
-          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 creating array expects when we have mixed arguments for single object'
-      :code: |
-        test()
-        {
-          int expect_list[] = { 1, 9 };
-          no_pointers_Expect(1, "silly");
-          mixed_ExpectAndReturn(6, expect_list, 7, 13);
-          
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: FALSE
-      :should: 'handle creating array expects when we have mixed arguments and handle failures for single object'
-      :code: |
-        test()
-        {
-          int expect_list[] = { 9, 1 };
-          no_pointers_Expect(1, "silly");
-          mixed_ExpectAndReturn(6, expect_list, 7, 13);
-          
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: TRUE
-      :should: 'handle creating array expects when we have mixed arguments for multiple objects'
-      :code: |
-        test()
-        {
-          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());
-        }
-
-    - :pass: FALSE
-      :should: 'handle creating array expects when we have mixed arguments and handle failures for multiple objects'
-      :code: |
-        test()
-        {
-          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());
-        }
-
-    - :pass: TRUE
-      :should: 'handle a passing version of a potential packing problem (particularly try with ARM simulators)'
-      :code: |
-        test()
-        {
-          short expect_list[] = { -2, -3, -4 };
-          potential_packing_problem_ExpectWithArray(expect_list, 3);
-          
-          function_e();
-        }
-
-    - :pass: FALSE
-      :should: 'handle a failing version of a potential packing problem (particularly try with ARM simulators)'
-      :code: |
-        test()
-        {
-          short expect_list[] = { -2, -3, 4 };
-          potential_packing_problem_ExpectWithArray(expect_list, 3);
-          
-          function_e();
-        }
-
-
-...