ceedling 0.13.0.rc1 → 0.13.0

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

@@ -0,0 +1,153 @@
+---
+:cmock:
+  :plugins:
+  - 'ignore'
+
+:systest:
+  :types: |
+
+  :mockable: |
+    int foo(int a);
+    void bar(int b);
+
+  :source: 
+    :header: |
+      int function(int a, int b, int c);
+    :code: |
+      int function(int a, int b, int c)
+      {
+        bar(b);
+        return foo(a) + foo(b) + foo(c);
+      }    
+
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+    :units:
+    - :pass: TRUE
+      :should: 'successfully exercise simple ExpectAndReturn mock calls'
+      :code: |
+        test()
+        {
+          bar_Expect(2);
+          foo_ExpectAndReturn(1, 10);
+          foo_ExpectAndReturn(2, 20);
+          foo_ExpectAndReturn(3, 30);
+          TEST_ASSERT_EQUAL(60, function(1, 2, 3));
+        }
+      
+    - :pass: TRUE
+      :should: 'ignore foo() calls'
+      :code: |
+        test()
+        {
+          bar_Expect(4);
+          foo_IgnoreAndReturn(10);
+          foo_IgnoreAndReturn(40);
+          foo_IgnoreAndReturn(80);
+          TEST_ASSERT_EQUAL(130, function(3, 4, 3));
+        }
+      
+    - :pass: TRUE
+      :should: 'ignore foo() calls and always return last item if we run out'
+      :code: |
+        test()
+        {
+          bar_Expect(4);
+          foo_IgnoreAndReturn(20);
+          foo_IgnoreAndReturn(30);
+          TEST_ASSERT_EQUAL(80, function(3, 4, 9));
+        }
+      
+    - :pass: TRUE
+      :should: 'ignore foo() calls and always return only item if only one specified'
+      :code: |
+        test()
+        {
+          bar_Expect(4);
+          foo_IgnoreAndReturn(20);
+          TEST_ASSERT_EQUAL(60, function(3, 4, 9));
+        }
+      
+    - :pass: TRUE
+      :should: 'ignore bar() and foo() calls'
+      :code: |
+        test()
+        {
+          bar_Ignore();
+          foo_IgnoreAndReturn(50);
+          TEST_ASSERT_EQUAL(150, function(0, 0, 0));
+        }
+      
+    - :pass: TRUE
+      :should: 'ignore foo() calls over multiple mock calls'
+      :code: |
+        test()
+        {
+          bar_Ignore();
+          foo_IgnoreAndReturn(50);
+          foo_IgnoreAndReturn(60);
+          foo_IgnoreAndReturn(70);
+          TEST_ASSERT_EQUAL(180, function(0, 0, 0));
+          
+          bar_Ignore();
+          foo_IgnoreAndReturn(30);
+          foo_IgnoreAndReturn(80);
+          foo_IgnoreAndReturn(10);
+          TEST_ASSERT_EQUAL(120, function(0, 0, 0));
+          
+          foo_IgnoreAndReturn(70);
+          foo_IgnoreAndReturn(20);
+          TEST_ASSERT_EQUAL(110, function(0, 0, 0));
+        }
+      
+    - :pass: TRUE
+      :should: 'multiple cycles of expects still pass when ignores enabled'
+      :code: |
+        test()
+        {
+          bar_Expect(2);
+          foo_ExpectAndReturn(1, 50);
+          foo_ExpectAndReturn(2, 60);
+          foo_ExpectAndReturn(3, 70);
+          TEST_ASSERT_EQUAL(180, function(1, 2, 3));
+          
+          bar_Expect(5);
+          foo_ExpectAndReturn(4, 30);
+          foo_ExpectAndReturn(5, 80);
+          foo_ExpectAndReturn(6, 10);
+          TEST_ASSERT_EQUAL(120, function(4, 5, 6));
+          
+          bar_Expect(8);
+          foo_ExpectAndReturn(7, 70);
+          foo_ExpectAndReturn(8, 20);
+          foo_ExpectAndReturn(9, 20);
+          TEST_ASSERT_EQUAL(110, function(7, 8, 9));
+        }
+      
+    - :pass: FALSE
+      :should: 'multiple cycles of expects still fail when ignores enabled'
+      :code: |
+        test()
+        {
+          bar_Expect(2);
+          foo_ExpectAndReturn(1, 50);
+          foo_ExpectAndReturn(2, 60);
+          foo_ExpectAndReturn(3, 70);
+          TEST_ASSERT_EQUAL(180, function(1, 2, 3));
+          
+          bar_Expect(5);
+          foo_ExpectAndReturn(4, 30);
+          foo_ExpectAndReturn(5, 80);
+          foo_ExpectAndReturn(6, 10);
+          TEST_ASSERT_EQUAL(120, function(4, 5, 6));
+          
+          bar_Expect(8);
+          foo_ExpectAndReturn(7, 70);
+          foo_ExpectAndReturn(8, 20);
+          foo_ExpectAndReturn(9, 20);
+          TEST_ASSERT_EQUAL(110, function(0, 8, 9));
+        }
+
+...

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

@@ -0,0 +1,52 @@
+---
+#The purpose of this test is to pull in some standard library stuff from C99
+:cmock:
+  :includes:
+    - "<stdint.h>"
+    - "<limits.h>"
+
+:systest:
+  :types: |
+    #include <stdint.h>
+    #include <limits.h>
+  
+  
+  :mockable: |
+    int32_t foo(int32_t a);
+
+  :source: 
+    :header: |    
+      int8_t function_a(void);
+
+    :code: |
+      int8_t function_a(void) {
+        return (int8_t)(INT_MIN == foo(INT_MAX));
+      }
+      
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+      
+    :units:
+    - :pass: TRUE
+      :should: 'handle handle a simple comparison of C99 types which pass'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn(INT_MAX, INT_MIN);
+          
+          TEST_ASSERT_TRUE(function_a());
+        }
+
+    - :pass: FALSE
+      :should: 'handle handle a simple comparison of C99 types which fail'
+      :code: |
+        test()
+        {
+          foo_ExpectAndReturn(INT_MIN, INT_MIN);
+          
+          TEST_ASSERT_TRUE(function_a());
+        }
+        
+...

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

@@ -0,0 +1,91 @@
+---
+#The purpose of this test is to play with things like "const char const *" which isn't supported by some compilers
+:cmock:
+  :enforce_strict_ordering: 1
+  :plugins:
+  - :array
+  - :cexception
+  - :ignore
+
+:systest:
+  :types: |
+    typedef struct _POINT_T {
+      int x;
+      int y;
+    } POINT_T;
+
+  :mockable: |
+    #include  "CException.h"
+    void foos(const char const * a);
+    const char const * bars(void);
+
+  :source: 
+    :header: |   
+      #include "CException.h" 
+      void function_a(void);
+      void function_b(void);
+      void function_c(void);
+      int function_d(void);
+
+    :code: |
+      void function_c(void) {
+        CEXCEPTION_T e;
+        Try {
+          foos(bars());
+        } Catch(e) { foos("err"); }
+      }
+      
+  :tests:
+    :common: |
+      #include "CException.h"
+      void setUp(void) {}
+      void tearDown(void) {}
+      
+    :units:
+    - :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 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();
+        }
+
+...

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

@@ -0,0 +1,59 @@
+---
+#The purpose of this test is to play with our really rough multidimensional array support, which involves an implicit cast not supported everywhere
+:cmock:
+  :plugins:
+  - :array
+
+:systest:
+  :types: |
+  
+  
+  :mockable: |
+    void foo(unsigned char** a);
+    unsigned char** bar(void);
+
+  :source: 
+    :header: |    
+      void function_a(void);
+
+    :code: |
+      void function_a(void) {
+        foo(bar());
+      }
+      
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+      
+    :units:
+    - :pass: TRUE
+      :should: 'handle two dimensional array of unsigned characters just like we would handle a single dimensional array in expect (where we really only care about first element)'
+      :code: |
+        test()
+        {
+          unsigned char a[] = { 1, 2, 3, 4, 5, 6 };
+          unsigned char** pa = (unsigned char**)(&a);
+          
+          bar_ExpectAndReturn(pa);
+          foo_Expect(pa);
+          
+          function_a();
+        }
+        
+    - :pass: FALSE
+      :should: 'handle two dimensional array of unsigned characters just like we would handle a single dimensional array in expect as failures (where we really only care about first element)'
+      :code: |
+        test()
+        {
+          unsigned char a[] = { 1, 2, 3, 4, 5, 6 };
+          unsigned char b[] = { 5, 6, 7, 8, 9, 0 };
+          unsigned char** pa = (unsigned char**)(&a);
+          unsigned char** pb = (unsigned char**)(&b);
+          
+          bar_ExpectAndReturn(pa);
+          foo_Expect(pb);
+          
+          function_a();
+        }
+...

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

@@ -0,0 +1,222 @@
+---
+:cmock:
+  :plugins:
+  - # no plugins
+  :treat_as_void: 
+  - VOID_TYPE_CRAZINESS_CFG
+  :treat_as:
+    TypeDefInt: HEX8
+  
+:systest:
+  :types: |
+    typedef unsigned short U16;
+    typedef struct _POINT_T
+    {
+      int x;
+      int y;
+    } POINT_T;
+    typedef void VOID_TYPE_CRAZINESS_CFG;
+    typedef int TypeDefInt;
+
+  :mockable: |
+    /* Make sure we ignore the following
+    #include "NonExistantFile.h
+    */
+    //#include "AndIgnoreThisToo.h"
+    #ifdef __cplusplus
+    extern "C" {
+    #endif
+    #define SHOULD_IGNORE_NEXT_FUNC_DEF_AS_PART_OF_MACRO   \
+            void IgnoredFunction(NotAValidType ToMakeItFailIfWeActuallyMockedThis);
+    
+    // typedef edge case; must be in mockable.h for test to compile
+    // not ANSI C but it has been done and will break cmock if not handled
+    typedef void VOID_TYPE_CRAZINESS_LCL;
+    
+    VOID_TYPE_CRAZINESS_LCL void_type_craziness1(int * a, int *b, int* c);
+    void void_type_craziness2(VOID_TYPE_CRAZINESS_CFG);
+
+    // pointer parsing exercise
+    U16  *ptr_return1(int a);
+    U16*  ptr_return2(int a);
+    U16 * ptr_return3(int a);
+
+    unsigned int** ptr_ptr_return1(unsigned int** a);
+    unsigned int* *ptr_ptr_return2(unsigned int* *a);
+    unsigned int **ptr_ptr_return3(unsigned int **a);
+    unsigned int ** ptr_ptr_return4(unsigned int ** a);
+
+    // variable argument lists
+    void var_args1(int a, ...);
+    void var_args2(int a, int b, ...);
+    
+    // parsing "stress tests"
+    char
+    crazy_multiline(
+      int a,
+      unsigned int b);
+    
+    unsigned long int incredible_descriptors(register const unsigned short a);
+    
+    TypeDefInt uses_typedef_like_names(TypeDefInt typedefvar);
+    
+    void oh_brackets1(int fudge[5]);
+    void oh_brackets2(int caramel[]);
+    #ifdef __cplusplus
+    }
+    #endif
+    
+  :source: 
+    :header: |
+      U16* exercise_return_pointers(int a);
+      void exercise_var_args(int a, int b);
+      void exercise_arglist_pointers(void);
+      char exercise_multiline_declarations(int a, unsigned int b);
+      void exercise_double_pointers(unsigned int** a);
+      int  exercise_many_descriptors(int a); 
+      TypeDefInt exercise_typedef_like_names(TypeDefInt a);
+
+    :code: |
+      int A, B, C;
+      unsigned int *pA, *pB, *pC;
+      
+      U16* exercise_return_pointers(int a)
+      {
+        ptr_return1(a);
+        ptr_return2(a);
+        return ptr_return3(a);
+      }    
+
+      void exercise_var_args(int a, int b)
+      {
+        var_args1(a, 3);
+        var_args2(a, b, 'c');
+      }
+      
+      void exercise_arglist_pointers(void)
+      {
+        void_type_craziness1(&A, &B, &C);
+        void_type_craziness2();
+      }
+
+      char exercise_multiline_declarations(int a, unsigned int b)
+      {
+        return crazy_multiline(a, b);
+      }
+
+      void exercise_double_pointers(unsigned int** a)
+      {
+        ptr_ptr_return1((unsigned int**)a);
+        ptr_ptr_return2((unsigned int**)a);
+        ptr_ptr_return3((unsigned int**)a);
+        ptr_ptr_return4((unsigned int**)a);
+      }
+      
+      int exercise_many_descriptors(int a)
+      {
+        return (int)incredible_descriptors((unsigned short)a);
+      }
+      
+      TypeDefInt exercise_typedef_like_names(TypeDefInt a)
+      {
+        return uses_typedef_like_names(a);
+      }
+      
+  :tests:
+    :common: |
+      extern int A, B, C;
+      extern unsigned int *pA, *pB, *pC;
+      
+      void setUp(void)
+      {
+        A = 100;
+        B = 200;
+        C = 300;
+        pA = (unsigned int*)(&A);
+        pB = (unsigned int*)(&B);
+        pC = (unsigned int*)(&C);
+      }
+      void tearDown(void) {}
+    :units:
+    - :pass: TRUE
+      :should: 'execute simple pointer return value check'
+      :code: |
+        test()
+        {
+          U16 retval;
+          ptr_return1_ExpectAndReturn(2, NULL);
+          ptr_return2_ExpectAndReturn(2, NULL);
+          ptr_return3_ExpectAndReturn(2, &retval);
+          TEST_ASSERT_EQUAL_PTR(&retval, exercise_return_pointers(2));
+        }
+        
+    - :pass: TRUE
+      :should: 'ignore var args in expect prototype generation'
+      :code: |
+        test()
+        {
+          var_args1_Expect(2);
+          var_args2_Expect(2, 3);
+          exercise_var_args(2, 3);
+        }
+        
+    - :pass: TRUE
+      :should: "not process a typedef'd void as anything other than void"
+      :code: |
+        test()
+        {
+          void_type_craziness1_Expect(&A, &B, &C);
+          void_type_craziness2_Expect();
+          exercise_arglist_pointers();
+        }
+
+    - :pass: TRUE
+      :should: 'successfully mock crazy multline function prototypes'
+      :code: |
+        test()
+        {
+          crazy_multiline_ExpectAndReturn(-10, 11, 'z');
+          TEST_ASSERT_EQUAL('z', exercise_multiline_declarations(-10, 11));
+        }
+
+    - :pass: TRUE
+      :should: 'mock double pointers just fine'
+      :code: |
+        test()
+        {
+          ptr_ptr_return1_ExpectAndReturn(&pA, &pB);
+          ptr_ptr_return2_ExpectAndReturn(&pA, &pB);
+          ptr_ptr_return3_ExpectAndReturn(&pA, &pB);
+          ptr_ptr_return4_ExpectAndReturn(&pA, &pB);
+          exercise_double_pointers((unsigned int**)(&pA));
+        }
+
+    - :pass: TRUE
+      :should: 'mock prototypes with long lists of return and parameter type descriptors'
+      :code: |
+        test()
+        {
+          incredible_descriptors_ExpectAndReturn(888, 777);
+          TEST_ASSERT_EQUAL(777, exercise_many_descriptors(888));
+        }
+
+    - :pass: TRUE
+      :should: 'handle words like typdef as PART of a variable or type'
+      :code: |
+        test()
+        {
+          uses_typedef_like_names_ExpectAndReturn((TypeDefInt)54, (TypeDefInt)53);
+          TEST_ASSERT_EQUAL(53, exercise_typedef_like_names((TypeDefInt)54));
+        }
+
+    - :pass: FALSE
+      :should: 'handle words like typdef as PART of a variable or type during failing tests'
+      :code: |
+        test()
+        {
+          uses_typedef_like_names_ExpectAndReturn((TypeDefInt)52, (TypeDefInt)53);
+          TEST_ASSERT_EQUAL(53, exercise_typedef_like_names((TypeDefInt)54));
+        }
+
+
+...