ceedling 0.18.0 → 0.19.0

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

@@ -0,0 +1,65 @@
+---
+:cmock:
+  :plugins: []
+  :treat_as:
+    custom_type: INT
+
+:systest:
+  :types: |
+    typedef struct _BIG_FAT_STRUCT_T
+    {
+      char bytes[512];
+    } BIG_FAT_STRUCT_T;
+
+  :mockable: |
+    void foo(BIG_FAT_STRUCT_T a);
+
+  :source:
+    :header: |
+      void   function_a(void);
+      void   function_b(void);
+
+    :code: |
+      void function_a(void)
+      {
+        BIG_FAT_STRUCT_T stuff = { { 8, 0 } };
+        foo(stuff);
+      }
+
+      void function_b(void)
+      {
+        BIG_FAT_STRUCT_T stuff1 = { { 9, 1, 0 } };
+        BIG_FAT_STRUCT_T stuff2 = { { 9, 2, 0 } };
+        foo(stuff1);
+        foo(stuff2);
+      }
+
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+
+    :units:
+    - :pass: TRUE
+      :should: 'successfully should be able to run function a because it only takes half the memory'
+      :code: |
+        test()
+        {
+          BIG_FAT_STRUCT_T expected = { { 8, 0 } };
+          foo_Expect(expected);
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'should error out because we do not have eough memory to handle two of these structures'
+      :code: |
+        test()
+        {
+          BIG_FAT_STRUCT_T expected1 = { { 9, 1, 0 } };
+          BIG_FAT_STRUCT_T expected2 = { { 9, 2, 0 } };
+          foo_Expect(expected1);
+          foo_Expect(expected2);
+          function_b();
+        }
+
+...

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

@@ -2,11 +2,12 @@
 :cmock:
   :plugins:
   - # no plugins
-  :treat_as_void: 
+  :treat_as_void:
   - VOID_TYPE_CRAZINESS_CFG
   :treat_as:
     TypeDefInt: HEX8
-  
+    VOID_TYPE_CRAZINESS_CFG*: PTR
+
 :systest:
   :types: |
     typedef unsigned short U16;
@@ -28,13 +29,14 @@
     #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);
+    void void_type_craziness3(VOID_TYPE_CRAZINESS_CFG* a);
 
     // pointer parsing exercise
     U16  *ptr_return1(int a);
@@ -49,50 +51,51 @@
     // 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: 
+
+  :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); 
+      int  exercise_many_descriptors(int a);
+      void exercise_type_craziness3(VOID_TYPE_CRAZINESS_CFG* 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);
@@ -111,22 +114,27 @@
         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);
       }
-      
+
+      void exercise_type_craziness3(VOID_TYPE_CRAZINESS_CFG* a)
+      {
+        void_type_craziness3(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;
@@ -149,7 +157,7 @@
           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: |
@@ -159,7 +167,7 @@
           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: |
@@ -218,5 +226,15 @@
           TEST_ASSERT_EQUAL(53, exercise_typedef_like_names((TypeDefInt)54));
         }
 
+    - :pass: TRUE
+      :should: 'handle typedef of void used as a void pointer'
+      :code: |
+        test()
+        {
+          char blah[5] = "blah";
+          void_type_craziness3_Expect(blah);
+          exercise_type_craziness3(blah);
+        }
+
 
 ...

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

@@ -0,0 +1,280 @@
+---
+:cmock:
+  :plugins:
+  - :array
+  - :ignore
+  - :callback
+  - :return_thru_ptr
+
+: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");
+      }
+
+...