ceedling 0.0.2 → 0.0.3

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

@@ -1,108 +0,0 @@
----
-:cmock:
-  :plugins:
-  - # none
-  :memcmp_if_unknown: false
-  
-:systest:
-  :types: |
-    typedef struct _EXAMPLE_STRUCT_T { int x; int y; } EXAMPLE_STRUCT_T;
-
-  :mockable: |
-    EXAMPLE_STRUCT_T foo(EXAMPLE_STRUCT_T a);
-
-  :source: 
-    :header: |    
-      EXAMPLE_STRUCT_T function_a(EXAMPLE_STRUCT_T a, EXAMPLE_STRUCT_T b);
-      EXAMPLE_STRUCT_T function_b(EXAMPLE_STRUCT_T a, EXAMPLE_STRUCT_T b);
-
-    :code: |
-      EXAMPLE_STRUCT_T function_a(EXAMPLE_STRUCT_T a, EXAMPLE_STRUCT_T b)    
-      {
-        EXAMPLE_STRUCT_T retval = foo(a);
-        retval.x += b.x;
-        retval.y += b.y;
-        return retval;
-      }    
-      
-      EXAMPLE_STRUCT_T function_b(EXAMPLE_STRUCT_T a, EXAMPLE_STRUCT_T b)    
-      {
-        EXAMPLE_STRUCT_T retval = foo(b);
-        retval.x *= a.x;
-        retval.y *= a.y;
-        return retval;
-      }    
-
-  :tests:
-    :common: |
-      #include "expect_and_return_custom_types_unity_helper.h"
-      void setUp(void) {}
-      void tearDown(void) {}
-      
-    :units:
-    - :pass: TRUE
-      :should: 'successfully exercise simple ExpectAndReturn mock calls'
-      :code: |
-        test()
-        {
-          EXAMPLE_STRUCT_T c = {1,2};
-          EXAMPLE_STRUCT_T d = {3,4};
-          EXAMPLE_STRUCT_T e = {2,4};
-          EXAMPLE_STRUCT_T f = {5,8};
-          foo_ExpectAndReturn(c, e);
-          TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(f, function_a(c,d));
-        }
-      
-    - :pass: FALSE
-      :should: 'fail because it is expecting to call foo with c not d'
-      :code: |
-        test()
-        {
-          EXAMPLE_STRUCT_T c = {1,2};
-          EXAMPLE_STRUCT_T d = {3,4};
-          EXAMPLE_STRUCT_T e = {2,4};
-          EXAMPLE_STRUCT_T f = {5,8};
-          foo_ExpectAndReturn(d, e);
-          TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(f, function_a(c,d));
-        }
-        
-    - :pass: TRUE
-      :should: 'successfully exercise simple ExpectAndReturn mock calls on other function'
-      :code: |
-        test()
-        {
-          EXAMPLE_STRUCT_T c = {1,2};
-          EXAMPLE_STRUCT_T d = {3,4};
-          EXAMPLE_STRUCT_T e = {2,4};
-          EXAMPLE_STRUCT_T f = {2,8};
-          foo_ExpectAndReturn(d, e);
-          TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(f, function_b(c,d));
-        }
-      
-    - :pass: FALSE
-      :should: 'fail because it is expecting to call foo with d not c'
-      :code: |
-        test()
-        {
-          EXAMPLE_STRUCT_T c = {1,2};
-          EXAMPLE_STRUCT_T d = {3,4};
-          EXAMPLE_STRUCT_T e = {2,4};
-          EXAMPLE_STRUCT_T f = {2,8};
-          foo_ExpectAndReturn(c, e);
-          TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(f, function_b(c,d));
-        }
-
-  :unity_helper:
-    :header: |
-      void AssertEqualExampleStruct(EXAMPLE_STRUCT_T expected, EXAMPLE_STRUCT_T actual, unsigned short line);
-      #define UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, line, message) {AssertEqualExampleStruct(expected, actual, line);}
-      #define TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual) UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, __LINE__, NULL);
-
-    :code: |
-      void AssertEqualExampleStruct(EXAMPLE_STRUCT_T expected, EXAMPLE_STRUCT_T actual, unsigned short line)
-      {
-        UNITY_TEST_ASSERT_EQUAL_INT(expected.x, actual.x, line, "Example Struct Failed For Field x");
-        UNITY_TEST_ASSERT_EQUAL_INT(expected.y, actual.y, line, "Example Struct Failed For Field y");
-      }
-
-...

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

@@ -1,173 +0,0 @@
----
-:cmock:
-  :plugins:
-  - # none
-  :treat_as:
-    MY_STRING: STRING
-    MY_INT: INT
-    PTR_INT: INT*
-    MY_HEX: HEX32
-
-:systest:
-  :types: |
-    typedef char* MY_STRING;
-    typedef int MY_INT;
-    typedef unsigned int MY_HEX;
-    typedef int* PTR_INT;
-
-  :mockable: |
-    MY_INT foo(MY_HEX a);
-    MY_INT bar(MY_HEX b);
-    MY_STRING foo_char_strings(MY_STRING a, MY_STRING b);
-    float float_adder(float a, float b);
-    MY_INT* pointer_foo(MY_HEX* a);
-    void pointer_bar(PTR_INT a);
-
-  :source: 
-    :header: |    
-      MY_INT function_a(MY_INT a, MY_INT b);
-      MY_STRING function_b(MY_STRING a, MY_STRING b);
-      float function_c(float a, float b);
-      MY_INT function_d(MY_HEX a);
-      void function_e(PTR_INT a);
-
-    :code: |
-      MY_INT function_a(MY_INT a, MY_INT b)    
-      {
-        return foo((MY_HEX)a) + bar((MY_HEX)b);
-      }    
-      
-      MY_STRING function_b(MY_STRING a, MY_STRING b)
-      {
-        return foo_char_strings(a, b);
-      }
-      
-      float function_c(float a, float b)
-      {
-        return float_adder(b, a);
-      }
-      
-      MY_INT function_d(MY_HEX a)
-      {
-        MY_HEX b = a;
-        MY_INT* c = pointer_foo(&b);
-        return *c;
-      }
-      
-      void function_e(PTR_INT a)
-      {
-        pointer_bar(a);
-      }
-      
-  :tests:
-    :common: |
-      void setUp(void) {}
-      void tearDown(void) {}
-      
-    :units:
-    - :pass: TRUE
-      :should: 'successfully exercise two simple ExpectAndReturn mock calls'
-      :code: |
-        test()
-        {
-          foo_ExpectAndReturn((MY_HEX)1, 10);
-          bar_ExpectAndReturn((MY_HEX)2, 20);
-          TEST_ASSERT_EQUAL(30, function_a(1, 2));
-        }
-      
-    - :pass: FALSE
-      :should: 'fail because bar() is expected but not called'
-      :code: |
-        test()
-        {
-          foo_ExpectAndReturn((MY_HEX)1, 10);
-          TEST_ASSERT_EQUAL(30, function_a(1, 2));
-        }
-
-    - :pass: FALSE
-      :should: 'fail because foo_char_strings() is called but is not expected'
-      :code: |
-        test()
-        {
-          foo_char_strings_ExpectAndReturn((MY_STRING)"jello", (MY_STRING)"jiggle", (MY_STRING)"boing!");
-          function_a(1,2);
-        }
-
-    - :pass: TRUE
-      :should: 'handle char strings'
-      :code: |
-        test()
-        {
-          foo_char_strings_ExpectAndReturn((MY_STRING)"jello", (MY_STRING)"jiggle", (MY_STRING)"boing!");
-          TEST_ASSERT_EQUAL_STRING("boing!", function_b((MY_STRING)"jello", (MY_STRING)"jiggle"));
-        }
-
-    - :pass: TRUE
-      :should: 'handle floating point numbers with Unity support: pass'
-      :code: |
-        test()
-        {
-          float_adder_ExpectAndReturn(1.2345, 6.7890, 8.0235);
-          TEST_ASSERT_EQUAL_FLOAT(8.0235, function_c(6.7890, 1.2345));
-        }
-
-    - :pass: FALSE
-      :should: 'handle floating point numbers with Unity support: fail'
-      :code: |
-        test()
-        {
-          float_adder_ExpectAndReturn(1.2345, 6.7892, 8.0235);
-          TEST_ASSERT_EQUAL_FLOAT(8.0235, function_c(6.7890, 1.2345));
-        }
-        
-    - :pass: TRUE
-      :should: 'handle pointers to treat_as values just as cleanly as the treat_as itself for passes'
-      :code: |
-        test()
-        {
-          MY_HEX TestHex = (MY_HEX)45;
-          MY_INT TestInt = (MY_INT)33;
-          pointer_foo_ExpectAndReturn(&TestHex, &TestInt);
-          TEST_ASSERT_EQUAL_INT(33, function_d(45));
-        }
-        
-    - :pass: FALSE
-      :should: 'handle pointers to treat_as values just as cleanly as the treat_as itself for failures'
-      :verify_error: 'Element 0 Expected 0x0000002D Was 0x0000002B'
-      :code: |
-        test()
-        {
-          MY_HEX TestHex = (MY_HEX)45;
-          MY_INT TestInt = (MY_INT)33;
-          pointer_foo_ExpectAndReturn(&TestHex, &TestInt);
-          TEST_ASSERT_EQUAL_INT(33, function_d(43));
-        }
-        
-    - :pass: TRUE
-      :should: 'handle treat_as values containing pointers for passes'
-      :code: |
-        test()
-        {
-          MY_INT ExpInt = (MY_INT)33;
-          PTR_INT ExpPtr = (PTR_INT)(&ExpInt);
-          MY_INT ActInt = (MY_INT)33;
-          PTR_INT ActPtr = (PTR_INT)(&ActInt);
-          pointer_bar_Expect(ExpPtr);
-          function_e(ActPtr);
-        }
-        
-    - :pass: FALSE
-      :should: 'handle treat_as values containing pointers for failures'
-      :verify_error: 'Element 0 Expected 33 Was 45'
-      :code: |
-        test()
-        {
-          MY_INT ExpInt = (MY_INT)33;
-          PTR_INT ExpPtr = (PTR_INT)(&ExpInt);
-          MY_INT ActInt = (MY_INT)45;
-          PTR_INT ActPtr = (PTR_INT)(&ActInt);
-          pointer_bar_Expect(ExpPtr);
-          function_e(ActPtr);
-        }
-
-...

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

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