ceedling 0.13.0.rc1 → 0.13.0

data/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 );
+        }
+
+
+...

data/vendor/cmock/test/system/test_interactions/enforce_strict_ordering.yml

@@ -0,0 +1,247 @@
+---
+:cmock:
+  :enforce_strict_ordering: 1
+  :plugins:
+  - :ignore
+  - :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);
+    void baz(custom_type c);
+
+  :source: 
+    :header: |
+      #include "CException.h"
+      UINT32 function_a(int a, int b);
+      void function_b(void);
+      void function_c(void);
+      void function_d(void);
+
+    :code: |
+      UINT32 function_a(int a, int b)    
+      {
+        return foo((custom_type)a) + bar((custom_type)b);
+      }    
+
+      void function_b(void) 
+      { 
+        baz((custom_type)1);
+        foo((custom_type)2);
+        bar((custom_type)3);
+        baz((custom_type)4);
+        foo((custom_type)5);
+        bar((custom_type)6);
+        baz((custom_type)7);
+      }
+
+      void function_c(void) 
+      {
+        foo((custom_type)1);
+        foo((custom_type)2);
+        bar((custom_type)3);
+        bar((custom_type)4);
+        foo((custom_type)5);
+      }
+      
+      void function_d(void)
+      {
+        CEXCEPTION_T e;
+        Try
+        {
+          foo((custom_type)1);
+        }
+        Catch(e) {}
+        Try
+        {
+          bar((custom_type)2);
+        }
+        Catch(e) {}
+        Try
+        {
+          foo((custom_type)3);
+        }
+        Catch(e) {}
+      }
+      
+  :tests:
+    :common: |
+      #include "CException.h"
+      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 called but is not expected'
+      :verify_error: 'called more times than 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 twice but is expected once'
+      :verify_error: 'called less times than expected'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)2, 20);
+          bar_ExpectAndReturn((custom_type)3, 30);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+        }
+
+    - :pass: FALSE
+      :should: 'fail because bar and foo called in reverse order'
+      :verify_error: 'called earlier than expected'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn((custom_type)2, 20);
+          foo_ExpectAndReturn((custom_type)1, 10);
+          TEST_ASSERT_EQUAL(30, function_a(1, 2));
+        }
+
+    - :pass: TRUE
+      :should: 'pass because bar and foo called in order with multiple params'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          foo_ExpectAndReturn((custom_type)2, 10);
+          bar_ExpectAndReturn((custom_type)3, 20);
+          bar_ExpectAndReturn((custom_type)4, 10);
+          foo_ExpectAndReturn((custom_type)5, 10);
+          function_c();
+        }
+
+    - :pass: FALSE
+      :should: 'fail because bar and foo called out of order at end'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)1, 10);
+          foo_ExpectAndReturn((custom_type)2, 10);
+          bar_ExpectAndReturn((custom_type)3, 20);
+          foo_ExpectAndReturn((custom_type)5, 10);
+          bar_ExpectAndReturn((custom_type)4, 10);
+          function_c();
+        }
+
+    - :pass: FALSE
+      :should: 'fail because bar and foo called out of order at start'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn((custom_type)2, 10);
+          foo_ExpectAndReturn((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)3, 20);
+          bar_ExpectAndReturn((custom_type)4, 10);
+          foo_ExpectAndReturn((custom_type)5, 10);
+          function_c();
+        }
+
+    - :pass: TRUE
+      :should: 'pass because we are properly ignoring baz'
+      :code: |
+        test()
+        {
+          baz_Ignore();
+          foo_ExpectAndReturn((custom_type)2, 10);
+          bar_ExpectAndReturn((custom_type)3, 20);
+          foo_ExpectAndReturn((custom_type)5, 10);
+          bar_ExpectAndReturn((custom_type)6, 10);
+          function_b();
+        }
+
+    - :pass: FALSE
+      :should: 'fail because bar and foo out of order, even though baz is ignored'
+      :code: |
+        test()
+        {
+          baz_Ignore();
+          foo_ExpectAndReturn((custom_type)2, 10);
+          foo_ExpectAndReturn((custom_type)5, 10);
+          bar_ExpectAndReturn((custom_type)3, 20);
+          bar_ExpectAndReturn((custom_type)6, 10);
+          function_b();
+        }
+        
+    - :pass: TRUE
+      :should: 'pass when using cexception, as long as the order is right'
+      :code: |
+        test()
+        {
+          foo_ExpectAndThrow((custom_type)1, 10);
+          bar_ExpectAndReturn((custom_type)2, 20);
+          foo_ExpectAndReturn((custom_type)3, 10);
+          function_d();
+        }
+
+    - :pass: FALSE
+      :should: 'fail when an throw call is made out of order'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn((custom_type)2, 20);
+          foo_ExpectAndThrow((custom_type)1, 10);
+          foo_ExpectAndReturn((custom_type)3, 10);
+          function_d();
+        }
+        
+    - :pass: TRUE
+      :should: 'successfully handle back to back ExpectAndReturn setup and mock calls'
+      :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));
+          
+          foo_ExpectAndReturn((custom_type)1, 50);
+          bar_ExpectAndReturn((custom_type)9, 60);
+          TEST_ASSERT_EQUAL(110, function_a(1, 9));
+        }
+      
+    - :pass: FALSE
+      :should: 'successfully catch errors during back to back ExpectAndReturn setup and mock calls'
+      :verify_error: 'called earlier than expected'
+      :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));
+          
+          bar_ExpectAndReturn((custom_type)9, 60);
+          foo_ExpectAndReturn((custom_type)1, 50);
+          TEST_ASSERT_EQUAL(110, function_a(1, 9));
+        }
+...

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

@@ -0,0 +1,108 @@
+---
+: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/vendor/cmock/test/system/test_interactions/expect_and_return_treat_as.yml

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