ceedling 0.0.1

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

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

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

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

@@ -0,0 +1,221 @@
+---
+:cmock:
+  :plugins:
+  - :callback
+  :treat_as:
+    custom_type: INT
+
+:systest:
+  :types: |
+    #define UINT32 unsigned int
+    
+    typedef signed int custom_type;
+
+  :mockable: |
+    UINT32 foo(custom_type* a);
+    UINT32 bar(custom_type* b);
+    int    baz(void);
+    void   fuz(int* args, int num);
+
+  :source: 
+    :header: |    
+      void   function_a(int a, int b);
+      UINT32 function_b(void);
+      int    function_c(void);
+
+    :code: |
+      void function_a(int a, int b)    
+      {
+        int args[6] = {0, 1, 2, 3, 5, 5};
+        args[0] = a;
+        fuz(args, b);
+      }    
+      
+      UINT32 function_b(void) 
+      {
+        UINT32 sum = 0;
+        custom_type a = 0;
+        custom_type b = 0;
+        sum = foo(&a) + bar(&b);
+        return sum + a + b;
+      }
+      
+      int function_c(void)    
+      {
+        return (baz() + baz() + baz());
+      }
+      
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+      
+      UINT32 FooAndBarHelper(custom_type* data, int num)
+      {
+          num++;
+          *data = (custom_type)(num * 2);
+          return (*data * 2);
+      }
+      
+      int BazCallbackPointless(int num)
+      {
+          return num;
+      }
+      
+      int BazCallbackComplainsIfCalledMoreThanTwice(int num)
+      {
+          TEST_ASSERT_MESSAGE(num < 2, "Do Not Call Baz More Than Twice");
+          return num;
+      }
+      
+      void FuzVerifier(int* args, int num_args, int num_calls)
+      {
+          int i;
+          TEST_ASSERT_MESSAGE(num_args < 5, "No More Than 5 Args Allowed");
+          for (i = 0; i < num_args; i++)
+          {
+              TEST_ASSERT_EQUAL(num_calls + i, args[i]);
+          }   
+      }
+      
+    :units:
+    - :pass: TRUE
+      :should: 'successfully exercise two simple ExpectAndReturn mock calls the normal way'
+      :code: |
+        test()
+        {
+          custom_type exp = 0;
+          foo_ExpectAndReturn(&exp, 10);
+          bar_ExpectAndReturn(&exp, 20);
+          TEST_ASSERT_EQUAL(30, function_b());
+        }
+        
+    - :pass: FALSE
+      :should: 'successfully exercise two simple ExpectAndReturn mock calls and catch failure the normal way'
+      :code: |
+        test()
+        {
+          custom_type exp = 1;
+          foo_ExpectAndReturn(&exp, 10);
+          bar_ExpectAndReturn(&exp, 20);
+          TEST_ASSERT_EQUAL(30, function_b());
+        }
+      
+    - :pass: TRUE
+      :should: 'successfully exercise using some basic callbacks'
+      :code: |
+        test()
+        {
+          foo_StubWithCallback((CMOCK_foo_CALLBACK)FooAndBarHelper);
+          bar_StubWithCallback((CMOCK_bar_CALLBACK)FooAndBarHelper);
+          TEST_ASSERT_EQUAL(12, function_b());
+        }
+      
+    - :pass: TRUE
+      :should: 'successfully exercise using some basic callbacks even if there were expects'
+      :code: |
+        test()
+        {
+          custom_type exp = 500;
+          foo_ExpectAndReturn(&exp, 10);
+          foo_StubWithCallback((CMOCK_foo_CALLBACK)FooAndBarHelper);
+          bar_StubWithCallback((CMOCK_bar_CALLBACK)FooAndBarHelper);
+          TEST_ASSERT_EQUAL(12, function_b());
+        }
+
+    - :pass: FALSE
+      :should: 'successfully exercise using some basic callbacks and notice failures'
+      :code: |
+        test()
+        {
+          foo_StubWithCallback((CMOCK_foo_CALLBACK)FooAndBarHelper);
+          bar_StubWithCallback((CMOCK_bar_CALLBACK)FooAndBarHelper);
+          TEST_ASSERT_EQUAL(10, function_b());
+        }
+      
+    - :pass: TRUE
+      :should: 'successfully exercise a callback with no arguments'
+      :code: |
+        test()
+        {
+          baz_StubWithCallback((CMOCK_baz_CALLBACK)BazCallbackPointless);
+          TEST_ASSERT_EQUAL(3, function_c());
+        }
+
+    - :pass: FALSE
+      :should: 'successfully throw a failure from within a callback function'
+      :code: |
+        test()
+        {
+          baz_StubWithCallback((CMOCK_baz_CALLBACK)BazCallbackComplainsIfCalledMoreThanTwice);
+          function_c();
+        }
+      
+    - :pass: TRUE
+      :should: 'be usable for things like dynamically sized memory checking for passing conditions'
+      :code: |
+        test()
+        {
+          fuz_StubWithCallback((CMOCK_fuz_CALLBACK)FuzVerifier);
+          function_a(0, 4);
+        }
+      
+    - :pass: FALSE
+      :should: 'be usable for things like dynamically sized memory checking for failing conditions'
+      :code: |
+        test()
+        {
+          fuz_StubWithCallback((CMOCK_fuz_CALLBACK)FuzVerifier);
+          function_a(0, 5);
+        }
+      
+    - :pass: FALSE
+      :should: 'be usable for things like dynamically sized memory checking for failing conditions 2'
+      :code: |
+        test()
+        {
+          fuz_StubWithCallback((CMOCK_fuz_CALLBACK)FuzVerifier);
+          function_a(1, 4);
+        }
+      
+    - :pass: TRUE
+      :should: 'run them interlaced'
+      :code: |
+        test()
+        {
+          custom_type exp = 0;
+          foo_ExpectAndReturn(&exp, 10);
+          foo_ExpectAndReturn(&exp, 15);
+          bar_ExpectAndReturn(&exp, 20);
+          bar_ExpectAndReturn(&exp, 40);
+          fuz_StubWithCallback((CMOCK_fuz_CALLBACK)FuzVerifier);
+          baz_StubWithCallback((CMOCK_baz_CALLBACK)BazCallbackPointless);
+          
+          TEST_ASSERT_EQUAL(30, function_b());
+          TEST_ASSERT_EQUAL(55, function_b());
+          function_a(0, 4);
+          TEST_ASSERT_EQUAL(3, function_c());
+        }
+      
+    - :pass: TRUE
+      :should: 'run them back to back'
+      :code: |
+        test()
+        {
+          custom_type exp = 0;
+          foo_ExpectAndReturn(&exp, 10);
+          bar_ExpectAndReturn(&exp, 20);
+          TEST_ASSERT_EQUAL(30, function_b());
+          
+          foo_ExpectAndReturn(&exp, 15);
+          bar_ExpectAndReturn(&exp, 40);
+          TEST_ASSERT_EQUAL(55, function_b());
+          
+          fuz_StubWithCallback((CMOCK_fuz_CALLBACK)FuzVerifier);
+          function_a(0, 4);
+          
+          baz_StubWithCallback((CMOCK_baz_CALLBACK)BazCallbackPointless);
+          TEST_ASSERT_EQUAL(3, function_c());
+        }
+
+...