ceedling 0.0.1

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

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

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

@@ -0,0 +1,123 @@
+---
+:cmock:
+  :plugins:
+  - # none
+
+:systest:
+  :types: |
+    #define UINT32 unsigned int
+    
+    typedef signed int custom_type;
+
+  :mockable: |
+    UINT32 foo(custom_type a);
+    UINT32 bar(custom_type b);
+    UINT32 foo_varargs(custom_type a, ...);
+    char* foo_char_strings(char a[], char* b);
+
+  :source: 
+    :header: |    
+      UINT32 function_a(int a, int b);
+      void function_b(void);
+      UINT32 function_c(int a);
+      char* function_d(char a[], char* b);
+
+    :code: |
+      UINT32 function_a(int a, int b)    
+      {
+        return foo((custom_type)a) + bar((custom_type)b);
+      }    
+
+      void function_b(void) { }
+
+      UINT32 function_c(int a)    
+      {
+        return foo_varargs((custom_type)a, "ignored", 5);
+      }
+      
+      char* function_d(char a[], char* b)
+      {
+        return foo_char_strings(a, b);
+      }
+      
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+      
+    :units:
+    - :pass: TRUE
+      :should: 'successfully exercise two simple ExpectAndReturn mock calls'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)2, 20);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+        }
+      
+    - :pass: FALSE
+      :should: 'fail because bar() is not called but is expected'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+        }
+
+    - :pass: FALSE
+      :should: 'fail because bar() is called but is not expected'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn((custom_type)1, 10);
+          function_b();
+        }
+
+    - :pass: TRUE
+      :should: 'consume var args passed to mocked function'
+      :code: |
+        test()
+        {
+          foo_varargs_ExpectAndReturn((custom_type)3, 10);
+          TEST_ASSERT_EQUAL(10, function_c(3));
+        }
+
+    - :pass: TRUE
+      :should: 'handle char strings'
+      :code: |
+        test()
+        {
+          foo_char_strings_ExpectAndReturn("larry", "curly", "moe");
+          TEST_ASSERT_EQUAL_STRING("moe", function_d("larry", "curly"));
+        }
+        
+    - :pass: TRUE
+      :should: 'successfully exercise multiple cycles of expecting and mocking and pass'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)2, 20);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+          
+          foo_ExpectAndReturn((custom_type)3, 30);
+          bar_ExpectAndReturn((custom_type)4, 40);
+          TEST_ASSERT_EQUAL(70, function_a(3, 4));
+        }
+        
+    - :pass: FALSE
+      :should: 'successfully exercise multiple cycles of expecting and mocking and fail'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)2, 20);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+          
+          foo_ExpectAndReturn((custom_type)3, 30);
+          bar_ExpectAndReturn((custom_type)4, 40);
+          TEST_ASSERT_EQUAL(70, function_a(3, 5));
+        }
+
+...

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

@@ -0,0 +1,87 @@
+---
+:cmock:
+  :plugins:
+  - # none
+
+:systest:
+  :types: |
+
+  :mockable: |
+    // no argument names
+    void foo(char const*, char* const, const char*);
+    
+    // argument names
+    void bar(char const* param1, char* const param2, const char* param3);
+
+  :source: 
+    :header: |
+      void exercise_const1(char const* param1, char* const param2, const char* param3);
+      void exercise_const2(char const* param1, char* const param2, const char* param3);
+
+    :code: |
+      char value1 = '1';
+      char value2 = '2';
+    
+      const char* A = &value1;
+      char* const B = &value2;
+      const char* C = "C";
+      const char* D = "D";
+    
+      void exercise_const1(char const* param1, char* const param2, const char* param3)
+      {
+        foo(param1, param2, param3);
+      }
+
+      void exercise_const2(char const* param1, char* const param2, const char* param3)
+      {
+        bar(param1, param2, param3);
+      }
+      
+  :tests:
+    :common: |
+      extern const char* A;
+      extern char* const B;
+      extern const char* C;
+      extern const char* D;
+      
+      void setUp(void) {}
+      void tearDown(void) {}
+    :units:
+    - :pass: TRUE
+      :should: 'successfully pass several const parameters'
+      :code: |
+        test()
+        {
+          foo_Expect( A, B, C );
+          exercise_const1( A, B, C );
+        }
+      
+    - :pass: FALSE
+      :should: 'should fail upon wrong const arguments passed'
+      :code: |
+        test()
+        {
+          foo_Expect( A, B, C );
+          exercise_const1( (const char*)B, (char * const)A, C );
+        }
+
+    - :pass: FALSE
+      :should: 'should fail upon wrong const arguments passed'
+      :code: |
+        test()
+        {
+          foo_Expect( A, B, C );
+          exercise_const1( A, B, D );
+        }
+
+    - :pass: FALSE
+      :should: 'should fail upon wrong const arguments passed'
+      :code: |
+        test()
+        {
+          bar_Expect( A, B, C );
+          exercise_const2( A, (char * const)C, (const char *)B );
+        }
+
+
+...