ceedling 0.0.1

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

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