ceedling 0.29.1 → 0.30.0

data/vendor/cmock/test/system/test_compilation/parsing.h

@@ -1,89 +1,89 @@
-/* ==========================================
-    CMock Project - Automatic Mock Generation for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
-typedef unsigned short U16;
-typedef signed int int32_t;
-
-/* CMock should handle UTF-8 characters in comments. The world is an awesomely diverse place! */
-/* my µC Rocks! Open Source, not ©! My language has no Ümlauts! ǺƜǝƧǾɱɛ! */ /**! Illegal: åäö */
-
-typedef struct _POINT_T
-{
-  int x;
-  int y;
-} POINT_T;
-
-// typedef edge case;
-// not ANSI C but it has been done and will break cmock if not handled
-typedef void VOID_TYPE_CRAZINESS;
-
-/* fun parsing & mock generation cases */
-
-void var_args1(int a, ...);
-void var_args2(int a, int b, ...);
-
-VOID_TYPE_CRAZINESS void_type_craziness1(int, float, double, char, short, long, long int, long long, void*);
-int void_type_craziness2( VOID_TYPE_CRAZINESS );
-
-   void  crazy_whitespace  (   int    lint, double shot  ,  short  stack )  ;
-
-char
- crazy_multiline
-(
-  int a,
-  unsigned int b);
-
-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);
-
-extern unsigned long int incredible_descriptors(register const unsigned short a);
-
-int32_t example_c99_type(int32_t param1);
-
-void I2CIntRegister(uint32_t ui32Base, void (*pfnHandler)(void));
-
-/* these are function pointers, not function declarations USING a function pointer, and so should NOT get mocked */
-int (* func_pointer)(void);
-extern int (*another_func_pointer)(unsigned int argument);
-struct struct_to_be_ignored {
-  union {
-    int i32;
-    void *p;
-  } variant;
-  void (*a_function_pointer_in_a_struct)(void *);
-};
-
-typedef struct
-{
-  uint32_t a;
-  struct
-  {
-    uint32_t bb;
-    float bc;
-    float bd;
-  } b;
-  int (*another_function_pointer_in_a_struct) (void);
-} another_thing_that_should_get_ignored;
-
-inline int stuff(int num)
-{
-    int reg = 0x12;
-    if (num > 0)
-    {
-      reg |= (0x0Eu);
-    }
-    else
-    {
-      reg |= (0x07u);
-    }
-    return reg;
-}
+/* ==========================================
+    CMock Project - Automatic Mock Generation for C
+    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+    [Released under MIT License. Please refer to license.txt for details]
+========================================== */
+
+typedef unsigned short U16;
+typedef signed int int32_t;
+
+/* CMock should handle UTF-8 characters in comments. The world is an awesomely diverse place! */
+/* my µC Rocks! Open Source, not ©! My language has no Ümlauts! ǺƜǝƧǾɱɛ! */ /**! Illegal: åäö */
+
+typedef struct _POINT_T
+{
+  int x;
+  int y;
+} POINT_T;
+
+// typedef edge case;
+// not ANSI C but it has been done and will break cmock if not handled
+typedef void VOID_TYPE_CRAZINESS;
+
+/* fun parsing & mock generation cases */
+
+void var_args1(int a, ...);
+void var_args2(int a, int b, ...);
+
+VOID_TYPE_CRAZINESS void_type_craziness1(int, float, double, char, short, long, long int, long long, void*);
+int void_type_craziness2( VOID_TYPE_CRAZINESS );
+
+   void  crazy_whitespace  (   int    lint, double shot  ,  short  stack )  ;
+
+char
+ crazy_multiline
+(
+  int a,
+  unsigned int b);
+
+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);
+
+extern unsigned long int incredible_descriptors(register const unsigned short a);
+
+int32_t example_c99_type(int32_t param1);
+
+void I2CIntRegister(uint32_t ui32Base, void (*pfnHandler)(void));
+
+/* these are function pointers, not function declarations USING a function pointer, and so should NOT get mocked */
+int (* func_pointer)(void);
+extern int (*another_func_pointer)(unsigned int argument);
+struct struct_to_be_ignored {
+  union {
+    int i32;
+    void *p;
+  } variant;
+  void (*a_function_pointer_in_a_struct)(void *);
+};
+
+typedef struct
+{
+  uint32_t a;
+  struct
+  {
+    uint32_t bb;
+    float bc;
+    float bd;
+  } b;
+  int (*another_function_pointer_in_a_struct) (void);
+} another_thing_that_should_get_ignored;
+
+inline int stuff(int num)
+{
+    int reg = 0x12;
+    if (num > 0)
+    {
+      reg |= (0x0Eu);
+    }
+    else
+    {
+      reg |= (0x07u);
+    }
+    return reg;
+}

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

@@ -1,375 +1,375 @@
----
-#this test is different than all_plugins_coexist primarily because of these options
-:cmock:
-  :enforce_strict_ordering: 1
-  :treat_externs: :include
-  :plugins:
-  - :array
-  - :cexception
-  - :ignore
-  - :callback
-  - :return_thru_ptr
-  - :ignore_arg
-  - :expect_any_args
-
-:systest:
-  :types: |
-    typedef struct _POINT_T {
-      int x;
-      int y;
-    } POINT_T;
-
-  :mockable: |
-    #include  "CException.h"
-    void foo(POINT_T* a);
-    POINT_T* bar(void);
-    void fooa(POINT_T a[]);
-    void foos(const char * a);
-    extern const char* bars(void);
-    void no_pointers(int a, const char* b);
-    int mixed(int a, int* b, int c);
-    void no_args(void);
-
-  :source:
-    :header: |
-      #include "CException.h"
-      void function_a(void);
-      void function_b(void);
-      void function_c(void);
-      int function_d(void);
-      void function_e(void);
-
-    :code: |
-      void function_a(void)
-      {
-        foo(bar());
-      }
-
-      void function_b(void) {
-        fooa(bar());
-      }
-
-      void function_c(void) {
-        CEXCEPTION_T e;
-        Try {
-          foos(bars());
-        } Catch(e) { foos("err"); }
-      }
-
-      int function_d(void) {
-        int test_list[] = { 1, 2, 3, 4, 5 };
-        no_pointers(1, "silly");
-        return mixed(6, test_list, 7);
-      }
-
-      void function_e(void) {
-        foos("Hello");
-        foos("Tuna");
-        foos("Oranges");
-      }
-
-  :tests:
-    :common: |
-      #include "CException.h"
-      void setUp(void) {}
-      void tearDown(void) {}
-
-    :units:
-    - :pass: TRUE
-      :should: 'handle the situation where we pass nulls to pointers'
-      :code: |
-        test()
-        {
-          bar_ExpectAndReturn(NULL);
-          foo_Expect(NULL);
-
-          function_a();
-        }
-
-    - :pass: FALSE
-      :should: 'handle the situation where we expected nulls to pointers but did not get that'
-      :code: |
-        test()
-        {
-          POINT_T pt = {1, 2};
-          bar_ExpectAndReturn(&pt);
-          foo_Expect(NULL);
-
-          function_a();
-        }
-
-    - :pass: FALSE
-      :should: 'handle the situation where we did not expect nulls to pointers but got null'
-      :code: |
-        test()
-        {
-          POINT_T ex = {1, 2};
-          bar_ExpectAndReturn(NULL);
-          foo_Expect(&ex);
-
-          function_a();
-        }
-
-    - :pass: FALSE
-      :should: 'handle the situation where we pass single object with expect and it is wrong'
-      :code: |
-        test()
-        {
-          POINT_T pt = {1, 2};
-          POINT_T ex = {1, 3};
-          bar_ExpectAndReturn(&pt);
-          foo_Expect(&ex);
-
-          function_a();
-        }
-
-    - :pass: TRUE
-      :should: 'handle the situation where we pass single object with expect and use array handler'
-      :code: |
-        test()
-        {
-          POINT_T pt = {1, 2};
-          POINT_T ex = {1, 2};
-          bar_ExpectAndReturn(&pt);
-          foo_ExpectWithArray(&ex, 1);
-
-          function_a();
-        }
-
-    - :pass: FALSE
-      :should: 'handle the situation where we pass single object with expect and use array handler and it is wrong'
-      :code: |
-        test()
-        {
-          POINT_T pt = {1, 2};
-          POINT_T ex = {1, 3};
-          bar_ExpectAndReturn(&pt);
-          foo_ExpectWithArray(&ex, 1);
-
-          function_a();
-        }
-
-    - :pass: TRUE
-      :should: 'handle the situation where we pass multiple objects with expect and use array handler'
-      :code: |
-        test()
-        {
-          POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}};
-          POINT_T ex[] = {{1, 2}, {3, 4}, {5, 6}};
-          bar_ExpectAndReturn(pt);
-          foo_ExpectWithArray(ex, 3);
-
-          function_a();
-        }
-
-    - :pass: FALSE
-      :should: 'handle the situation where we pass multiple objects with expect and use array handler and it is wrong at end'
-      :code: |
-        test()
-        {
-          POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}};
-          POINT_T ex[] = {{1, 2}, {3, 4}, {5, 9}};
-          bar_ExpectAndReturn(pt);
-          foo_ExpectWithArray(ex, 3);
-
-          function_a();
-        }
-
-    - :pass: TRUE
-      :should: 'handle the situation where we pass single array element with expect'
-      :code: |
-        test()
-        {
-          POINT_T pt = {1, 2};
-          POINT_T ex = {1, 2};
-          bar_ExpectAndReturn(&pt);
-          fooa_Expect(&ex);
-
-          function_b();
-        }
-
-    - :pass: TRUE
-      :should: 'handle standard c string as null terminated and not do crappy memory compares of a byte, passing'
-      :code: |
-        test()
-        {
-          const char* constretval = "This is a\0 silly string";
-          char* retval = (char*)constretval;
-          bars_ExpectAndReturn(retval);
-          foos_Expect("This is a\0 wacky string");
-
-          function_c();
-        }
-
-    - :pass: FALSE
-      :should: 'handle standard c string as null terminated and not do crappy memory compares of a byte, finding failures'
-      :code: |
-        test()
-        {
-          const char* constretval = "This is a silly string";
-          char* retval = (char*)constretval;
-          bars_ExpectAndReturn(retval);
-          foos_Expect("This is a wacky string");
-
-          function_c();
-        }
-
-    - :pass: TRUE
-      :should: 'handle creating array expects when we have mixed arguments for single object'
-      :code: |
-        test()
-        {
-          int expect_list[] = { 1, 9 };
-          no_pointers_Expect(1, "silly");
-          mixed_ExpectAndReturn(6, expect_list, 7, 13);
-
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: FALSE
-      :should: 'handle creating array expects when we have mixed arguments and handle failures for single object'
-      :code: |
-        test()
-        {
-          int expect_list[] = { 9, 1 };
-          no_pointers_Expect(1, "silly");
-          mixed_ExpectAndReturn(6, expect_list, 7, 13);
-
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: TRUE
-      :should: 'handle creating array expects when we have mixed arguments for multiple objects'
-      :code: |
-        test()
-        {
-          int expect_list[] = { 1, 2, 3, 4, 6 };
-          no_pointers_Expect(1, "silly");
-          mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
-
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: FALSE
-      :should: 'handle creating array expects when we have mixed arguments and handle failures for multiple objects'
-      :code: |
-        test()
-        {
-          int expect_list[] = { 1, 2, 3, 4, 6 };
-          no_pointers_Expect(1, "silly");
-          mixed_ExpectWithArrayAndReturn(6, expect_list, 5, 7, 13);
-
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: TRUE
-      :should: 'handle an exception being caught'
-      :code: |
-        test()
-        {
-          const char* constretval = "This is a\0 silly string";
-          char* retval = (char*)constretval;
-          bars_ExpectAndReturn(retval);
-          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()
-        {
-          const char* constretval = "This is a\0 silly string";
-          char* retval = (char*)constretval;
-          bars_ExpectAndReturn(retval);
-          foos_ExpectAndThrow("This is a\0 wacky string", 55);
-          foos_Expect("wrong error");
-
-          function_c();
-        }
-
-    - :pass: FALSE
-      :should: 'fail strict ordering problems even though we would otherwise have passed'
-      :code: |
-        test()
-        {
-          int expect_list[] = { 1, 2, 3, 4, 6 };
-          mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
-          no_pointers_Expect(1, "silly");
-
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: TRUE
-      :should: 'properly ExpectAnyArgs first function but the other will work properly'
-      :code: |
-        test()
-        {
-          int expect_list[] = { 1, 2, 3, 4, 6 };
-          no_pointers_ExpectAnyArgs();
-          mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
-
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: TRUE
-      :should: 'properly ExpectAnyArgs last function but the other will work properly'
-      :code: |
-        test()
-        {
-          no_pointers_Expect(1, "silly");
-          mixed_ExpectAnyArgsAndReturn(13);
-
-          TEST_ASSERT_EQUAL(13, function_d());
-        }
-
-    - :pass: TRUE
-      :should: 'be ok if we ExpectAnyArgs a call each because we are counting calls'
-      :code: |
-        test()
-        {
-          foos_ExpectAnyArgs();
-          foos_ExpectAnyArgs();
-          foos_ExpectAnyArgs();
-
-          function_e();
-        }
-
-    - :pass: TRUE
-      :should: 'be ok if we ExpectAnyArgs and Expect intermixed because we are counting calls'
-      :code: |
-        test()
-        {
-          foos_Expect("Hello");
-          foos_ExpectAnyArgs();
-          foos_ExpectAnyArgs();
-
-          function_e();
-        }
-
-    - :pass: FALSE
-      :should: 'be able to detect Expect problem if we ExpectAnyArgs and Expect intermixed'
-      :code: |
-        test()
-        {
-          foos_Expect("Hello");
-          foos_ExpectAnyArgs();
-          foos_Expect("Wrong");
-
-          function_e();
-        }
-
-    - :pass: FALSE
-      :should: 'fail if we do not ExpectAnyArgs a call once because we are counting calls'
-      :code: |
-        test()
-        {
-          foos_ExpectAnyArgs();
-          foos_ExpectAnyArgs();
-
-          function_e();
-        }
-
-...
+---
+#this test is different than all_plugins_coexist primarily because of these options
+:cmock:
+  :enforce_strict_ordering: 1
+  :treat_externs: :include
+  :plugins:
+  - :array
+  - :cexception
+  - :ignore
+  - :callback
+  - :return_thru_ptr
+  - :ignore_arg
+  - :expect_any_args
+
+:systest:
+  :types: |
+    typedef struct _POINT_T {
+      int x;
+      int y;
+    } POINT_T;
+
+  :mockable: |
+    #include  "CException.h"
+    void foo(POINT_T* a);
+    POINT_T* bar(void);
+    void fooa(POINT_T a[]);
+    void foos(const char * a);
+    extern const char* bars(void);
+    void no_pointers(int a, const char* b);
+    int mixed(int a, int* b, int c);
+    void no_args(void);
+
+  :source:
+    :header: |
+      #include "CException.h"
+      void function_a(void);
+      void function_b(void);
+      void function_c(void);
+      int function_d(void);
+      void function_e(void);
+
+    :code: |
+      void function_a(void)
+      {
+        foo(bar());
+      }
+
+      void function_b(void) {
+        fooa(bar());
+      }
+
+      void function_c(void) {
+        CEXCEPTION_T e;
+        Try {
+          foos(bars());
+        } Catch(e) { foos("err"); }
+      }
+
+      int function_d(void) {
+        int test_list[] = { 1, 2, 3, 4, 5 };
+        no_pointers(1, "silly");
+        return mixed(6, test_list, 7);
+      }
+
+      void function_e(void) {
+        foos("Hello");
+        foos("Tuna");
+        foos("Oranges");
+      }
+
+  :tests:
+    :common: |
+      #include "CException.h"
+      void setUp(void) {}
+      void tearDown(void) {}
+
+    :units:
+    - :pass: TRUE
+      :should: 'handle the situation where we pass nulls to pointers'
+      :code: |
+        test()
+        {
+          bar_ExpectAndReturn(NULL);
+          foo_Expect(NULL);
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'handle the situation where we expected nulls to pointers but did not get that'
+      :code: |
+        test()
+        {
+          POINT_T pt = {1, 2};
+          bar_ExpectAndReturn(&pt);
+          foo_Expect(NULL);
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'handle the situation where we did not expect nulls to pointers but got null'
+      :code: |
+        test()
+        {
+          POINT_T ex = {1, 2};
+          bar_ExpectAndReturn(NULL);
+          foo_Expect(&ex);
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'handle the situation where we pass single object with expect and it is wrong'
+      :code: |
+        test()
+        {
+          POINT_T pt = {1, 2};
+          POINT_T ex = {1, 3};
+          bar_ExpectAndReturn(&pt);
+          foo_Expect(&ex);
+
+          function_a();
+        }
+
+    - :pass: TRUE
+      :should: 'handle the situation where we pass single object with expect and use array handler'
+      :code: |
+        test()
+        {
+          POINT_T pt = {1, 2};
+          POINT_T ex = {1, 2};
+          bar_ExpectAndReturn(&pt);
+          foo_ExpectWithArray(&ex, 1);
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'handle the situation where we pass single object with expect and use array handler and it is wrong'
+      :code: |
+        test()
+        {
+          POINT_T pt = {1, 2};
+          POINT_T ex = {1, 3};
+          bar_ExpectAndReturn(&pt);
+          foo_ExpectWithArray(&ex, 1);
+
+          function_a();
+        }
+
+    - :pass: TRUE
+      :should: 'handle the situation where we pass multiple objects with expect and use array handler'
+      :code: |
+        test()
+        {
+          POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}};
+          POINT_T ex[] = {{1, 2}, {3, 4}, {5, 6}};
+          bar_ExpectAndReturn(pt);
+          foo_ExpectWithArray(ex, 3);
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'handle the situation where we pass multiple objects with expect and use array handler and it is wrong at end'
+      :code: |
+        test()
+        {
+          POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}};
+          POINT_T ex[] = {{1, 2}, {3, 4}, {5, 9}};
+          bar_ExpectAndReturn(pt);
+          foo_ExpectWithArray(ex, 3);
+
+          function_a();
+        }
+
+    - :pass: TRUE
+      :should: 'handle the situation where we pass single array element with expect'
+      :code: |
+        test()
+        {
+          POINT_T pt = {1, 2};
+          POINT_T ex = {1, 2};
+          bar_ExpectAndReturn(&pt);
+          fooa_Expect(&ex);
+
+          function_b();
+        }
+
+    - :pass: TRUE
+      :should: 'handle standard c string as null terminated and not do crappy memory compares of a byte, passing'
+      :code: |
+        test()
+        {
+          const char* constretval = "This is a\0 silly string";
+          char* retval = (char*)constretval;
+          bars_ExpectAndReturn(retval);
+          foos_Expect("This is a\0 wacky string");
+
+          function_c();
+        }
+
+    - :pass: FALSE
+      :should: 'handle standard c string as null terminated and not do crappy memory compares of a byte, finding failures'
+      :code: |
+        test()
+        {
+          const char* constretval = "This is a silly string";
+          char* retval = (char*)constretval;
+          bars_ExpectAndReturn(retval);
+          foos_Expect("This is a wacky string");
+
+          function_c();
+        }
+
+    - :pass: TRUE
+      :should: 'handle creating array expects when we have mixed arguments for single object'
+      :code: |
+        test()
+        {
+          int expect_list[] = { 1, 9 };
+          no_pointers_Expect(1, "silly");
+          mixed_ExpectAndReturn(6, expect_list, 7, 13);
+
+          TEST_ASSERT_EQUAL(13, function_d());
+        }
+
+    - :pass: FALSE
+      :should: 'handle creating array expects when we have mixed arguments and handle failures for single object'
+      :code: |
+        test()
+        {
+          int expect_list[] = { 9, 1 };
+          no_pointers_Expect(1, "silly");
+          mixed_ExpectAndReturn(6, expect_list, 7, 13);
+
+          TEST_ASSERT_EQUAL(13, function_d());
+        }
+
+    - :pass: TRUE
+      :should: 'handle creating array expects when we have mixed arguments for multiple objects'
+      :code: |
+        test()
+        {
+          int expect_list[] = { 1, 2, 3, 4, 6 };
+          no_pointers_Expect(1, "silly");
+          mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
+
+          TEST_ASSERT_EQUAL(13, function_d());
+        }
+
+    - :pass: FALSE
+      :should: 'handle creating array expects when we have mixed arguments and handle failures for multiple objects'
+      :code: |
+        test()
+        {
+          int expect_list[] = { 1, 2, 3, 4, 6 };
+          no_pointers_Expect(1, "silly");
+          mixed_ExpectWithArrayAndReturn(6, expect_list, 5, 7, 13);
+
+          TEST_ASSERT_EQUAL(13, function_d());
+        }
+
+    - :pass: TRUE
+      :should: 'handle an exception being caught'
+      :code: |
+        test()
+        {
+          const char* constretval = "This is a\0 silly string";
+          char* retval = (char*)constretval;
+          bars_ExpectAndReturn(retval);
+          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()
+        {
+          const char* constretval = "This is a\0 silly string";
+          char* retval = (char*)constretval;
+          bars_ExpectAndReturn(retval);
+          foos_ExpectAndThrow("This is a\0 wacky string", 55);
+          foos_Expect("wrong error");
+
+          function_c();
+        }
+
+    - :pass: FALSE
+      :should: 'fail strict ordering problems even though we would otherwise have passed'
+      :code: |
+        test()
+        {
+          int expect_list[] = { 1, 2, 3, 4, 6 };
+          mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
+          no_pointers_Expect(1, "silly");
+
+          TEST_ASSERT_EQUAL(13, function_d());
+        }
+
+    - :pass: TRUE
+      :should: 'properly ExpectAnyArgs first function but the other will work properly'
+      :code: |
+        test()
+        {
+          int expect_list[] = { 1, 2, 3, 4, 6 };
+          no_pointers_ExpectAnyArgs();
+          mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13);
+
+          TEST_ASSERT_EQUAL(13, function_d());
+        }
+
+    - :pass: TRUE
+      :should: 'properly ExpectAnyArgs last function but the other will work properly'
+      :code: |
+        test()
+        {
+          no_pointers_Expect(1, "silly");
+          mixed_ExpectAnyArgsAndReturn(13);
+
+          TEST_ASSERT_EQUAL(13, function_d());
+        }
+
+    - :pass: TRUE
+      :should: 'be ok if we ExpectAnyArgs a call each because we are counting calls'
+      :code: |
+        test()
+        {
+          foos_ExpectAnyArgs();
+          foos_ExpectAnyArgs();
+          foos_ExpectAnyArgs();
+
+          function_e();
+        }
+
+    - :pass: TRUE
+      :should: 'be ok if we ExpectAnyArgs and Expect intermixed because we are counting calls'
+      :code: |
+        test()
+        {
+          foos_Expect("Hello");
+          foos_ExpectAnyArgs();
+          foos_ExpectAnyArgs();
+
+          function_e();
+        }
+
+    - :pass: FALSE
+      :should: 'be able to detect Expect problem if we ExpectAnyArgs and Expect intermixed'
+      :code: |
+        test()
+        {
+          foos_Expect("Hello");
+          foos_ExpectAnyArgs();
+          foos_Expect("Wrong");
+
+          function_e();
+        }
+
+    - :pass: FALSE
+      :should: 'fail if we do not ExpectAnyArgs a call once because we are counting calls'
+      :code: |
+        test()
+        {
+          foos_ExpectAnyArgs();
+          foos_ExpectAnyArgs();
+
+          function_e();
+        }
+
+...