ceedling 0.0.2 → 0.0.3

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

@@ -1,91 +0,0 @@
----
-#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/new_project_template/vendor/ceedling/vendor/cmock/test/system/test_interactions/nonstandard_parsed_stuff_2.yml

@@ -1,59 +0,0 @@
----
-#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/new_project_template/vendor/ceedling/vendor/cmock/test/system/test_interactions/parsing_challenges.yml

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

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

@@ -1,277 +0,0 @@
----
-:cmock:
-  :plugins:
-  - # none
-
-:systest:
-  :types: |
-    struct THING { int a; int b; };
-
-    union STARS_AND_STRIPES { int a; char b; };
-    
-    enum HOKEY_POKEY { IN, OUT, SHAKE_IT_ALL_ABOUT };
-
-  :mockable: |
-    void foo_struct(struct THING*, struct THING);
-    struct THING foobar_struct(void);
-
-    void foo_union(union STARS_AND_STRIPES*, union STARS_AND_STRIPES);
-    union STARS_AND_STRIPES foobar_union(void);
-
-    void foo_enum(enum HOKEY_POKEY a, enum HOKEY_POKEY * b);
-    enum HOKEY_POKEY foobar_enum(void);
-
-  :source: 
-    :header: |    
-      void exercise_struct(struct THING* a, struct THING b);
-      struct THING return_struct(void);
-
-      void exercise_union(union STARS_AND_STRIPES* a, union STARS_AND_STRIPES b);
-      union STARS_AND_STRIPES return_union(void);
-
-      void exercise_enum(enum HOKEY_POKEY a, enum HOKEY_POKEY * b);
-      enum HOKEY_POKEY return_enum(void);
-
-    :code: |
-      void exercise_struct(struct THING* a, struct THING b)
-      {
-        foo_struct(a, b);
-      }
-      
-      struct THING return_struct(void)
-      {
-        return foobar_struct();
-      }
-    
-      void exercise_union(union STARS_AND_STRIPES* a, union STARS_AND_STRIPES b)
-      {
-        foo_union(a, b);
-      }
-      
-      union STARS_AND_STRIPES return_union(void)
-      {
-        return foobar_union();
-      }
-
-      void exercise_enum(enum HOKEY_POKEY a, enum HOKEY_POKEY * b)
-      {
-        foo_enum(a, b);
-      }
-
-      enum HOKEY_POKEY return_enum(void)
-      {
-        return foobar_enum();
-      }
-
-
-  :tests:
-    :common: |
-      struct THING struct1;
-      struct THING struct2;
-      struct THING struct3;
-      struct THING struct4;
-      struct THING struct5;
-      struct THING struct6;
-    
-      union STARS_AND_STRIPES union1;
-      union STARS_AND_STRIPES union2;
-      union STARS_AND_STRIPES union3;
-      union STARS_AND_STRIPES union4;
-      union STARS_AND_STRIPES union5;
-      union STARS_AND_STRIPES union6;
-      
-      enum HOKEY_POKEY enum1;
-      enum HOKEY_POKEY enum2;
-
-      void setUp(void)
-      {
-        struct1.a = 1;
-        struct1.b = 2;
-        
-        struct2.a = 3;
-        struct2.b = 4;
-
-        struct3.a = 5;
-        struct3.b = 6;
-
-        struct4.a = 7;
-        struct4.b = 8;
-        
-        struct5.a = 9;
-        struct5.b = 10;
-
-        struct6.a = 9;
-        struct6.b = 10;
-
-        union1.a = 1;
-        union2.a = 2;
-        union3.a = 3;
-        union4.a = 4;
-        union5.a = 5;
-        union6.a = 5;
-        
-        enum1 = OUT;
-        enum2 = IN;
-      }
-      
-      void tearDown(void) {}
-            
-    :units:
-    - :pass: TRUE
-      :should: 'successfully compare structs'
-      :code: |
-        test()
-        {
-          foo_struct_Expect(&struct1, struct2);
-          exercise_struct(&struct1, struct2);
-        }
-
-    - :pass: FALSE
-      :should: 'blow up on bad struct pointer comparison'
-      :code: |
-        test()
-        {
-          foo_struct_Expect(&struct1, struct2);
-          exercise_struct(&struct3, struct2);
-        }
-
-    - :pass: FALSE
-      :should: 'blow up on bad structure comparison'
-      :code: |
-        test()
-        {
-          foo_struct_Expect(&struct1, struct2);
-          exercise_struct(&struct1, struct4);
-        }
-
-    - :pass: TRUE
-      :should: 'compare returned structs as equal'
-      :code: |
-        test()
-        {
-          foobar_struct_ExpectAndReturn(struct5);
-          TEST_ASSERT_EQUAL_THING(struct6, return_struct());
-        }
-
-    - :pass: FALSE
-      :should: 'compare returned structs as unequal'
-      :code: |
-        test()
-        {
-          foobar_struct_ExpectAndReturn(struct4);
-          TEST_ASSERT_EQUAL_THING(struct5, return_struct());
-        }
-
-    - :pass: TRUE
-      :should: 'successfully compare unions'
-      :code: |
-        test()
-        {
-          foo_union_Expect(&union1, union2);
-          exercise_union(&union1, union2);
-        }
-
-    - :pass: FALSE
-      :should: 'blow up on bad union pointer comparison'
-      :code: |
-        test()
-        {
-          foo_union_Expect(&union1, union2);
-          exercise_union(&union3, union2);
-        }
-
-    - :pass: FALSE
-      :should: 'blow up on bad union comparison'
-      :code: |
-        test()
-        {
-          foo_union_Expect(&union1, union2);
-          exercise_union(&union1, union4);
-        }
-
-    - :pass: TRUE
-      :should: 'compare returned unions as equal'
-      :code: |
-        test()
-        {
-          foobar_union_ExpectAndReturn(union5);
-          TEST_ASSERT_EQUAL_STARS_AND_STRIPES(union6, return_union());
-        }
-
-    - :pass: FALSE
-      :should: 'compare returned unions as unequal'
-      :code: |
-        test()
-        {
-          foobar_union_ExpectAndReturn(union4);
-          TEST_ASSERT_EQUAL_STARS_AND_STRIPES(union5, return_union());
-        }
-
-    - :pass: TRUE
-      :should: 'successfully pass enum values'
-      :code: |
-        test()
-        {
-          foo_enum_Expect(OUT, &enum1);
-          exercise_enum(OUT, &enum1);
-        }
-
-    - :pass: FALSE
-      :should: 'blow up on bad enum pointer comparison'
-      :code: |
-        test()
-        {
-          foo_enum_Expect(IN, &enum1);
-          exercise_enum(IN, &enum2);
-        }
-
-    - :pass: FALSE
-      :should: 'blow up on bad enum comparison'
-      :code: |
-        test()
-        {
-          foo_enum_Expect(IN, &enum1);
-          exercise_enum(SHAKE_IT_ALL_ABOUT, &enum1);
-        }
-
-    - :pass: TRUE
-      :should: 'compare returned enums as equal'
-      :code: |
-        test()
-        {
-          foobar_enum_ExpectAndReturn(OUT);
-          TEST_ASSERT_EQUAL(OUT, return_enum());
-        }
-
-    - :pass: FALSE
-      :should: 'compare returned unions as unequal'
-      :code: |
-        test()
-        {
-          foobar_enum_ExpectAndReturn(OUT);
-          TEST_ASSERT_EQUAL(IN, return_enum());
-        }
-
-
-  :unity_helper:
-    :header: |
-      void AssertEqualTHINGStruct(struct THING expected, struct THING actual);
-      void AssertEqualSTARS_AND_STRIPESUnion(union STARS_AND_STRIPES expected, union STARS_AND_STRIPES actual);
-
-      #define TEST_ASSERT_EQUAL_THING(expected, actual) {AssertEqualTHINGStruct(expected, actual);}
-      #define TEST_ASSERT_EQUAL_STARS_AND_STRIPES(expected, actual) {AssertEqualSTARS_AND_STRIPESUnion(expected, actual);}
-
-    :code: |
-      void AssertEqualTHINGStruct(struct THING expected, struct THING actual)
-      {
-        TEST_ASSERT_EQUAL_INT_MESSAGE(expected.a, actual.a, "actual struct member \"a\" does not equal expected");
-        TEST_ASSERT_EQUAL_INT_MESSAGE(expected.b, actual.b, "actual struct member \"b\" does not equal expected");
-      }
-
-      void AssertEqualSTARS_AND_STRIPESUnion(union STARS_AND_STRIPES expected, union STARS_AND_STRIPES actual)
-      {
-        TEST_ASSERT_EQUAL_INT_MESSAGE(expected.a, actual.a, "actual union member \"a\" does not equal expected");
-        TEST_ASSERT_EQUAL_MESSAGE(expected.b, actual.b, "actual union member \"b\" does not equal expected");
-      }
-  
-...