ceedling 0.13.0 → 0.15.0

data/vendor/cmock/src/cmock.h

@@ -20,6 +20,7 @@
 CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size);
 CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemChain(CMOCK_MEM_INDEX_TYPE root_index, CMOCK_MEM_INDEX_TYPE obj_index);
 CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemNext(CMOCK_MEM_INDEX_TYPE previous_item_index);
+CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemEndOfChain(CMOCK_MEM_INDEX_TYPE root_index);
 
 void*                 CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index);
 

data/vendor/cmock/src/cmock_internals.h

@@ -0,0 +1,43 @@
+/* ==========================================
+    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]
+========================================== */
+
+#ifndef CMOCK_FRAMEWORK_INTERNALS_H
+#define CMOCK_FRAMEWORK_INTERNALS_H
+
+#include "cmock.h"
+
+//define CMOCK_MEM_DYNAMIC to grab memory as needed with malloc
+//when you do that, CMOCK_MEM_SIZE is used for incremental size instead of total
+#ifdef CMOCK_MEM_STATIC
+#undef CMOCK_MEM_DYNAMIC
+#endif
+
+#ifdef CMOCK_MEM_DYNAMIC
+#include <stdlib.h>
+#endif
+
+//this is used internally during pointer arithmetic. make sure this type is the same size as the target's pointer type
+#ifndef CMOCK_MEM_PTR_AS_INT
+#define CMOCK_MEM_PTR_AS_INT unsigned long
+#endif
+
+//0 for no alignment, 1 for 16-bit, 2 for 32-bit, 3 for 64-bit
+#ifndef CMOCK_MEM_ALIGN
+#define CMOCK_MEM_ALIGN (2)
+#endif
+
+//amount of memory to allow cmock to use in its internal heap
+#ifndef CMOCK_MEM_SIZE
+#define CMOCK_MEM_SIZE (32768)
+#endif
+
+//automatically calculated defs for easier reading
+#define CMOCK_MEM_ALIGN_SIZE  (1u << CMOCK_MEM_ALIGN)
+#define CMOCK_MEM_ALIGN_MASK  (CMOCK_MEM_ALIGN_SIZE - 1)
+#define CMOCK_MEM_INDEX_SIZE  (CMOCK_MEM_PTR_AS_INT)((sizeof(CMOCK_MEM_INDEX_TYPE) > CMOCK_MEM_ALIGN_SIZE) ? sizeof(CMOCK_MEM_INDEX_TYPE) : CMOCK_MEM_ALIGN_SIZE)
+
+
+#endif //CMOCK_FRAMEWORK_INTERNALS

data/vendor/cmock/test/c/TestCMockC.c

@@ -5,7 +5,7 @@
 ========================================== */
 
 #include "unity.h"
-#include "cmock.h"
+#include "cmock_internals.h"
 
 #define TEST_MEM_INDEX_SIZE  (sizeof(CMOCK_MEM_INDEX_TYPE))
 
@@ -21,7 +21,7 @@ void tearDown(void)
 void test_MemNewWillReturnNullIfGivenIllegalSizes(void)
 {
   TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNew(0) );
-  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNew(CMOCK_MEM_SIZE - TEST_MEM_INDEX_SIZE + 1) );
+  TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, CMock_Guts_MemNew(CMOCK_MEM_SIZE - TEST_MEM_INDEX_SIZE + 1) );
   TEST_ASSERT_NULL( CMock_Guts_GetAddressFor(CMOCK_GUTS_NONE) );
 
   //verify we're cleared still
@@ -30,7 +30,7 @@ void test_MemNewWillReturnNullIfGivenIllegalSizes(void)
 }
 
 void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void)
-{
+{
   CMOCK_MEM_INDEX_TYPE next = CMock_Guts_MemNew(4);
   TEST_ASSERT_EQUAL(4 + TEST_MEM_INDEX_SIZE, CMock_Guts_MemBytesUsed());
   TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 4 - TEST_MEM_INDEX_SIZE, CMock_Guts_MemBytesFree());
@@ -57,7 +57,7 @@ void test_MemNextWillReturnNullIfGivenABadRoot(void)
 void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 {
   unsigned int  i;
-  CMOCK_MEM_INDEX_TYPE next;
+  CMOCK_MEM_INDEX_TYPE next;
   CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
   CMOCK_MEM_INDEX_TYPE element[4];
 
@@ -73,8 +73,8 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
   *((unsigned int*)CMock_Guts_GetAddressFor(element[0])) = 0;
 
   //verify we're using the right amount of memory
-  TEST_ASSERT_EQUAL(1 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed());
-  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 1 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesFree());
+  TEST_ASSERT_EQUAL(1 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 1 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesFree());
 
   //second element
   element[1] = CMock_Guts_MemNew(sizeof(unsigned int));
@@ -84,8 +84,8 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
   *((unsigned int*)CMock_Guts_GetAddressFor(element[1])) = 1;
 
   //verify we're using the right amount of memory
-  TEST_ASSERT_EQUAL(2 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed());
-  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 2 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesFree());
+  TEST_ASSERT_EQUAL(2 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 2 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesFree());
 
   //third element
   element[2] = CMock_Guts_MemNew(sizeof(unsigned int));
@@ -96,8 +96,8 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
   *((unsigned int*)CMock_Guts_GetAddressFor(element[2])) = 2;
 
   //verify we're using the right amount of memory
-  TEST_ASSERT_EQUAL(3 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed());
-  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 3 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesFree());
+  TEST_ASSERT_EQUAL(3 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 3 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesFree());
 
   //fourth element
   element[3] = CMock_Guts_MemNew(sizeof(unsigned int));
@@ -109,8 +109,8 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
   *((unsigned int*)CMock_Guts_GetAddressFor(element[3])) = 3;
 
   //verify we're using the right amount of memory
-  TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed());
-  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 4 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesFree());
+  TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 4 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesFree());
 
   //traverse list
   next = first;
@@ -125,8 +125,8 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
   TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
 
   //verify we're using the right amount of memory
-  TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesUsed());
-  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 4 * (TEST_MEM_INDEX_SIZE + 4), CMock_Guts_MemBytesFree());
+  TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 4 * (TEST_MEM_INDEX_SIZE + sizeof(unsigned int)), CMock_Guts_MemBytesFree());
 
   //Free it all
   CMock_Guts_MemFreeAll();
@@ -138,17 +138,17 @@ void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
 
 void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void)
 {
-  unsigned int  i;
+  unsigned int  i;
   CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
   CMOCK_MEM_INDEX_TYPE next;
 
-  //even though we are asking for one byte, we've told it to align to closest 4 bytes, therefore it will waste a byte each time
-  //so each call will use 8 bytes (4 for the index, 1 for the data, and 3 wasted).
-  //therefore we can safely allocated total/8 times.
-  for (i = 0; i < (CMOCK_MEM_SIZE / 8); i++)
+  //even though we are asking for one byte, we've told it to align to closest CMOCK_MEM_ALIGN_SIZE bytes, therefore it will waste a byte each time
+  //so each call will use (CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE) bytes (CMOCK_MEM_INDEX_SIZE for the index, 1 for the data, and (CMOCK_MEM_ALIGN_SIZE - 1) wasted).
+  //therefore we can safely allocated total/(CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE) times.
+  for (i = 0; i < (CMOCK_MEM_SIZE / (CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE)); i++)
   {
-    TEST_ASSERT_EQUAL(i*8, CMock_Guts_MemBytesUsed());
-    TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*8, CMock_Guts_MemBytesFree());
+    TEST_ASSERT_EQUAL(i*(CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE), CMock_Guts_MemBytesUsed());
+    TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*(CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE), CMock_Guts_MemBytesFree());
 
     next = CMock_Guts_MemNew(1);
     TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
@@ -172,28 +172,29 @@ void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void)
 
   //verify we can still walk through the elements allocated
   next = first;
-  for (i = 0; i < (CMOCK_MEM_SIZE / 8); i++)
+  for (i = 0; i < (CMOCK_MEM_SIZE / (CMOCK_MEM_INDEX_SIZE + CMOCK_MEM_ALIGN_SIZE)); i++)
   {
     TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
     next = CMock_Guts_MemNext(next);
   }
 
   //there aren't any after that
-  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, (_UU32)next);
 }
 
 void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd(void)
 {
-  unsigned int  i;
+  unsigned int  i;
   CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
   CMOCK_MEM_INDEX_TYPE next;
 
-  //we're asking for 12 bytes each time now (4 for index, 8 for data).
-  //10 requests will give us 120 bytes used, which isn't enough for another 12 bytes if total memory is 128
-  for (i = 0; i < 10; i++)
+  //we're asking for (CMOCK_MEM_INDEX_SIZE + 8) bytes each time now (CMOCK_MEM_INDEX_SIZE for index, 8 for data).
+  //CMOCK_MEM_SIZE/(CMOCK_MEM_INDEX_SIZE + 8) requests will request as much data as possible, while ensuring that there isn't enough
+  //memory for the next request
+  for (i = 0; i < CMOCK_MEM_SIZE/(CMOCK_MEM_INDEX_SIZE + 8); i++)
   {
-    TEST_ASSERT_EQUAL(i*12, CMock_Guts_MemBytesUsed());
-    TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*12, CMock_Guts_MemBytesFree());
+    TEST_ASSERT_EQUAL(i*(CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesUsed());
+    TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - i*(CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesFree());
 
     next = CMock_Guts_MemNew(8);
     TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
@@ -206,22 +207,22 @@ void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtE
   }
 
   //verify we're at top of memory
-  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 8, CMock_Guts_MemBytesUsed());
-  TEST_ASSERT_EQUAL(8, CMock_Guts_MemBytesFree());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - CMOCK_MEM_SIZE % (CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE % (CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesFree());
 
   //The very next call will return a NONE, and any after that
   TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(8));
   TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(5));
 
   //verify nothing has changed
-  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - 8, CMock_Guts_MemBytesUsed());
-  TEST_ASSERT_EQUAL(8, CMock_Guts_MemBytesFree());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE - CMOCK_MEM_SIZE % (CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE % (CMOCK_MEM_INDEX_SIZE + 8), CMock_Guts_MemBytesFree());
 
   //verify we can still walk through the elements allocated
   next = first;
-  for (i = 0; i < 10; i++)
+  for (i = 0; i < CMOCK_MEM_SIZE/(CMOCK_MEM_INDEX_SIZE + 8); i++)
   {
-    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
+    TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
     TEST_ASSERT_EQUAL(i, *((unsigned int*)CMock_Guts_GetAddressFor(next)));
     next = CMock_Guts_MemNext(next);
   }
@@ -232,7 +233,11 @@ void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtE
 
 void test_ThatWeCanAskForAllSortsOfSizes(void)
 {
-  unsigned int  i;
+#if CMOCK_MEM_ALIGN != 2
+  TEST_IGNORE_MESSAGE("Test relies on a particular environmental setup, which is not present");
+#else
+
+  unsigned int  i;
   CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
   CMOCK_MEM_INDEX_TYPE next;
   unsigned int  sizes[5] = {3, 1, 80, 5, 4};
@@ -277,4 +282,42 @@ void test_ThatWeCanAskForAllSortsOfSizes(void)
 
   //there aren't any after that
   TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, next);
+#endif
+}
+
+void test_MemEndOfChain(void)
+{
+  CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
+  CMOCK_MEM_INDEX_TYPE element[4];
+
+  //verify we're cleared first
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
+
+  //first element
+  element[0] = CMock_Guts_MemNew(sizeof(unsigned int));
+  first = CMock_Guts_MemChain(first, element[0]);
+  TEST_ASSERT_MESSAGE(element[0] == CMock_Guts_MemEndOfChain(first), "Should have returned element[0]");
+
+  //second element
+  element[1] = CMock_Guts_MemNew(sizeof(unsigned int));
+  CMock_Guts_MemChain(first, element[1]);
+  TEST_ASSERT_MESSAGE(element[1] == CMock_Guts_MemEndOfChain(first), "Should have returned element[1]");
+
+  //third element
+  element[2] = CMock_Guts_MemNew(sizeof(unsigned int));
+  CMock_Guts_MemChain(first, element[2]);
+  TEST_ASSERT_MESSAGE(element[2] == CMock_Guts_MemEndOfChain(first), "Should have returned element[2]");
+
+  //fourth element
+  element[3] = CMock_Guts_MemNew(sizeof(unsigned int));
+  CMock_Guts_MemChain(first, element[3]);
+  TEST_ASSERT_MESSAGE(element[3] == CMock_Guts_MemEndOfChain(first), "Should have returned element[3]");
+
+  //Free it all
+  CMock_Guts_MemFreeAll();
+
+  //verify we're cleared
+  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
 }

data/vendor/cmock/test/c/TestCMockC_Runner.c

@@ -15,6 +15,7 @@ extern void test_MemNewWillReturnNullIfGivenIllegalSizes(void);
 extern void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void);
 extern void test_MemNextWillReturnNullIfGivenABadRoot(void);
 extern void test_ThatWeCanClaimAndChainAFewElementsTogether(void);
+extern void test_MemEndOfChain(void);
 extern void test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory(void);
 extern void test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd(void);
 extern void test_ThatWeCanAskForAllSortsOfSizes(void);
@@ -28,6 +29,7 @@ int main(void)
   RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 32);
   RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 46);
   RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 57);
+  RUN_TEST(test_MemEndOfChain, 282);
   RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory, 139);
   RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd, 185);
   RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 233);

data/vendor/cmock/test/spec/cmock_file_writer_spec.rb

@@ -5,6 +5,7 @@ require 'cmock_file_writer'
 describe CMockFileWriter do 
 	before do
 		@cmConfig = Object.new
+
 		#create instance of class under test
 		@subject = CMockFileWriter.new(@cmConfig)
 	end
@@ -17,9 +18,28 @@ describe CMockFileWriter do
 	end
 
 	describe 'create_file' do
-		it "complain if a block was not specified when calling create" do 
+
+		it "should complain if a block was not specified when calling create" do 
 			expect {@subject.create_file("text.txt")}.should raise_error
 			# should.be_false
 		end
+
+		it "should perform block on new file" do
+					# mock(@cmConfig).enforce_strict_ordering {false}
+			mock(@cmConfig).mock_path {"testPath"}
+			mock(@cmConfig).mock_path {"testPath"}
+
+			FakeFile = Object.new
+			mock(File).open("testPath/test.txt.new", "w").yields(FakeFile, "test.txt")
+			mock(FakeFile).write("hello world"){nil}
+
+			mock(File).exist?("testPath/test.txt") {true}
+			mock(FileUtils).rm("testPath/test.txt")
+			mock(FileUtils).cp("testPath/test.txt.new", "testPath/test.txt")
+			mock(FileUtils).rm("testPath/test.txt.new")
+			# Call function under test
+			@subject.create_file("test.txt") {|f| f.write("hello world")}
+		end
+
 	end
 end

data/vendor/cmock/test/spec/cmock_generator_plugin_array_spec.rb

@@ -0,0 +1,52 @@
+here = File.expand_path(File.dirname(__FILE__))
+require "#{here}/spec_helper" #add this to execute tests from the spec directory
+require 'cmock_generator_plugin_array'
+
+describe :CMockGeneratorPluginArray do 
+	before do
+		@cmConfig = Object.new
+		@cmUtils = Object.new
+		mock(@cmConfig).when_ptr {:compare_data}
+		mock(@cmConfig).enforce_strict_ordering {false}
+		mock(@cmUtils).helpers { {} }
+		#create instance of class under test
+		@subject = CMockGeneratorPluginArray.new(@cmConfig, @cmUtils)
+	end
+
+	it "should not respond to include_files" do
+			# @subject.should_not respond_to(:include_files)
+  end
+ 
+ # 	it "should not add to typedef structure for functions of " + 
+ # 	   "style 'int* func(void)'" do
+ #    	function = {:name => "Oak", :args => [], :return => :int_ptr}
+ #    	returned = @subject.instance_typedefs(function)
+ #    	returned.should == ""
+ #  	end
+  
+	# it "should add to typedef structure mock needs of functions of style "+
+	# 	 "'void func(int chicken, int* pork)'" do 
+	#     arg1 = { :name => "chicken", :type => "int", :ptr? => false}
+	# 	arg2 = { :name => "pork", :type => "int*", :ptr? => true}
+	#     function = {:name => "Cedar",
+	# 	  	  :args => [arg1, arg2],
+	# 		    :return => :void}
+	#     expected = "  int Expected_pork_Depth;\n"
+	#     returned = @subject.instance_typedefs(function)
+	#     returned.should == expected
+ # 	end
+
+ # 	it "should not add an additional mock interface for functions not containing pointers" do
+	#     function = {:name => "Maple", :args_string => "int blah", :return  => :string,
+	#     	:contains_ptr? => false}
+ #    	returned = @subject.mock_function_declarations(function)
+ #    	returned.should_be nil
+ # 	end
+	
+	# describe 'create_file' do
+	# 	it "complain if a block was not specified when calling create" do 
+	# 		expect {@subject.create_file("text.txt")}.should raise_error
+	# 		# should.be_false
+	# 	end
+	# end
+end

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

@@ -6,6 +6,8 @@
   - :cexception
   - :ignore
   - :callback
+  - :return_thru_ptr
+  - :ignore_arg
   :callback_after_arg_check: true
   :callback_include_count: false
   :treat_externs: :include

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

@@ -0,0 +1,235 @@
+---
+:cmock:
+    :mock_path: test/mocks
+    :mock_prefix: mock_
+    :treat_as:
+        abs_struct: PTR
+        intptr: INT*
+    :when_ptr: :smart
+    :plugins:
+        - :array
+        - :ignore_arg
+        - :return_thru_ptr
+
+:systest:
+  :types: |
+    typedef int *intptr;
+
+    struct a_struct
+    {
+        int i1;
+        int i2;
+        int i3;
+    };
+    
+    struct _abs_struct 
+    {
+        int abs_i1;
+        int abs_i2;
+    };
+    
+    typedef struct _abs_struct abs_struct;
+
+  :mockable: |
+      void ptr_ret_int(int *r);
+      void ptr_ret_ints(int *r, int *s);
+      void ptr_ret_array(char r[], int len);
+      void ptr_ret_typedef(intptr r);
+      void ptr_ret_struct(struct a_struct *r);
+      void ptr_ret_abstract(abs_struct *r);
+      void ptr_ret_abstract_array(abs_struct *r, int len);
+      void ptr_ret_const_int(int *r, const int *s);
+      void ptr_ret_string(char *s);
+
+  :source:
+    :header: |
+      #include <string.h>
+      #define lengthof(x) (sizeof(x)/sizeof((x)[0]))
+
+    :code: |
+
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+
+    :units:
+    - :pass: TRUE
+      :should: "handle a single int* argument"
+      :code: |
+        test()
+        {
+          int r = 1;
+          int res = 4;
+          
+          ptr_ret_int_Expect(&r);
+          ptr_ret_int_ReturnThruPtr_r(&res);
+          ptr_ret_int(&r);
+          TEST_ASSERT_EQUAL(4, r);
+        }
+
+    - :pass: TRUE
+      :should: "handle multiple calls"
+      :code: |
+        test()
+        {
+          int r = 1;
+          int res1 = 4;
+          int res2 = 8;
+          int res3 = 16;
+          
+          ptr_ret_int_Expect(&r);
+          ptr_ret_int_ReturnThruPtr_r(&res1);
+          ptr_ret_int_Expect(&r);
+          ptr_ret_int_ReturnThruPtr_r(&res2);
+          ptr_ret_int_Expect(&r);
+          ptr_ret_int_ReturnThruPtr_r(&res3);
+      
+          ptr_ret_int(&r);
+          TEST_ASSERT_EQUAL(4, r);
+          ptr_ret_int(&r);
+          TEST_ASSERT_EQUAL(8, r);
+          ptr_ret_int(&r);
+          TEST_ASSERT_EQUAL(16, r);
+      
+        }
+
+    - :pass: TRUE
+      :should: "ignore an argument"
+      :code: |
+        test()
+        {
+          int r = 1, s = 2;
+          int res = 4;
+          
+          ptr_ret_int_Expect(&r);
+          ptr_ret_int_IgnoreArg_r();
+          ptr_ret_int_ReturnThruPtr_r(&res);
+          ptr_ret_int(&s);
+          TEST_ASSERT_EQUAL(4, s);
+        }
+
+    - :pass: TRUE
+      :should: "ignore a null pointer argument"
+      :code: |
+        test()
+        {
+          int r = 1;
+          int res = 4;
+          
+          ptr_ret_int_Expect(NULL);
+          ptr_ret_int_IgnoreArg_r();
+          ptr_ret_int_ReturnThruPtr_r(&res);
+          ptr_ret_int(&r);
+          TEST_ASSERT_EQUAL(4, r);
+        }
+
+    - :pass: TRUE
+      :should: "handle multiple int* arguments"
+      :code: |
+        test()
+        {
+          int r, s = 0x0880AA55;
+          int r_res = 4;
+          int s_res = 6;
+      
+          ptr_ret_ints_Expect(&r, &s);
+          ptr_ret_ints_ReturnThruPtr_r(&r_res);
+          ptr_ret_ints_ReturnThruPtr_s(&s_res);
+          ptr_ret_ints(&r, &s);
+          TEST_ASSERT_EQUAL(4, r);
+          TEST_ASSERT_EQUAL(6, s);
+        }
+
+    - :pass: TRUE
+      :should: "only return through pointer when asked to"
+      :code: |
+        test()
+        {
+          int r = 0x0880AA55;
+          int s = 0xAA55;
+          int r_res = 4;
+      
+          ptr_ret_ints_Expect(&r, &s);
+          ptr_ret_ints_ReturnThruPtr_r(&r_res);
+          ptr_ret_ints(&r, &s);
+          TEST_ASSERT_EQUAL(4, r);
+          TEST_ASSERT_EQUAL(0xAA55, s);
+        }
+
+    - :pass: TRUE
+      :should: "return an array through a pointer correctly"
+      :code: |
+        test()
+        {
+          char r_a[] = "booboorooboo";
+          char r_a_ret[] = "FEEFI";
+      
+          ptr_ret_array_Expect(r_a, lengthof(r_a));
+          ptr_ret_array_ReturnArrayThruPtr_r(r_a_ret, strlen(r_a_ret));
+          ptr_ret_array(r_a, lengthof(r_a));
+          TEST_ASSERT_EQUAL_STRING("FEEFIorooboo", r_a);
+        }
+
+    - :pass: TRUE
+      :should: "handle structs"
+      :code: |
+        test()
+        {
+          struct a_struct r_s = { .i1 = 2, .i2 = 3, .i3 = 4, };
+          struct a_struct r_s_ret = { .i1 = 8, .i2 = 16, .i3 = 32, };
+      
+          ptr_ret_struct_Expect(&r_s);
+          ptr_ret_struct_ReturnThruPtr_r(&r_s_ret);
+          ptr_ret_struct(&r_s);
+          TEST_ASSERT_EQUAL_MEMORY(&r_s_ret, &r_s, sizeof(struct a_struct));
+        }
+
+    - :pass: TRUE
+      :should: "handle typedefs"
+      :code: |
+        test()
+        {
+          abs_struct r_as = {.abs_i1 = 0x1234, .abs_i2 = 0x4567};
+          abs_struct r_as_ret = {.abs_i1 = 0xFFAA55, .abs_i2 = 0xAAFFAA};
+          ptr_ret_abstract_Expect(&r_as);
+          ptr_ret_abstract_ReturnMemThruPtr_r(&r_as_ret, sizeof(abs_struct));
+          ptr_ret_abstract(&r_as);
+          TEST_ASSERT_EQUAL_MEMORY(&r_as_ret, &r_as, sizeof(abs_struct));
+        }
+
+    - :pass: TRUE
+      :should: "only generate ReturnThruPtr definitions for non-const arguments"
+      :code: |
+        test()
+        {
+        #if !defined(ptr_ret_const_int_ReturnThruPtr_r)
+            TEST_FAIL_MESSAGE("ReturnThruPtr not defined for a pointer argument.");
+        #endif
+        
+        #if defined(ptr_ret_const_int_ReturnThruPtr_s)
+            TEST_FAIL_MESSAGE("ReturnThruPtr defined for a const pointer argument.");
+        #endif
+        }
+
+    - :pass: TRUE
+      :should: "generate ReturnThruPtr definitions for string arguments"
+      :code: |
+        test()
+        {
+        #if !defined(ptr_ret_string_ReturnThruPtr_s)
+            TEST_FAIL_MESSAGE("ReturnThruPtr not defined for a string argument.");
+        #endif
+        }
+
+    - :pass: TRUE
+      :should: "generate IgnoreArg definitions"
+      :code: |
+        test()
+        {
+        #if !defined(ptr_ret_array_IgnoreArg_r)         \
+            || !defined(ptr_ret_array_IgnoreArg_len)    \
+            || !defined(ptr_ret_const_int_IgnoreArg_s)
+            TEST_FAIL_MESSAGE("IgnoreArg not defined for an argument.");
+        #endif
+        }