celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From abroekh...@apache.org
Subject svn commit: r1528380 [1/5] - in /incubator/celix/trunk: ./ cmake/ cmake/cmock/ cmake/cmock/config/ cmake/cmock/lib/ cmake/cmock/src/ cmake/cpputest/ cmake/cpputest/include/ cmake/cpputest/include/CppUTest/ cmake/cpputest/include/CppUTestExt/ cmake/cppu...
Date Wed, 02 Oct 2013 09:01:23 GMT
Author: abroekhuis
Date: Wed Oct  2 09:01:20 2013
New Revision: 1528380

URL: http://svn.apache.org/r1528380
Log:
CELIX-55: Test Support

Added test support for Unity/CMock and CPPUTest

Added:
    incubator/celix/trunk/cmake/cmock/
    incubator/celix/trunk/cmake/cmock/config/
    incubator/celix/trunk/cmake/cmock/config/production_environment.rb
    incubator/celix/trunk/cmake/cmock/config/test_environment.rb
    incubator/celix/trunk/cmake/cmock/lib/
    incubator/celix/trunk/cmake/cmock/lib/cmock.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_config.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_file_writer.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_generator.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_array.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_callback.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_cexception.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_expect.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_ignore.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_generator_utils.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_header_parser.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_plugin_manager.rb
    incubator/celix/trunk/cmake/cmock/lib/cmock_unityhelper_parser.rb
    incubator/celix/trunk/cmake/cmock/lib/test.h
    incubator/celix/trunk/cmake/cmock/src/
    incubator/celix/trunk/cmake/cmock/src/cmock.c
    incubator/celix/trunk/cmake/cmock/src/cmock.h
    incubator/celix/trunk/cmake/cmock/test.yml
    incubator/celix/trunk/cmake/cpputest/
    incubator/celix/trunk/cmake/cpputest/include/
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/CommandLineArguments.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/CommandLineTestRunner.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/JUnitTestOutput.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/MemoryLeakAllocator.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/MemoryLeakDetector.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/MemoryLeakDetectorMallocMacros.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/MemoryLeakDetectorNewMacros.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/MemoryLeakWarningPlugin.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/PlatformSpecificFunctions.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/SimpleString.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/TestFailure.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/TestHarness.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/TestHarness_c.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/TestOutput.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/TestPlugin.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/TestRegistry.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/TestResult.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/TestTestingFixture.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/Utest.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/UtestMacros.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTest/VirtualCall.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/CodeMemoryReportFormatter.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReportAllocator.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReportFormatter.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MemoryReporterPlugin.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockActualFunctionCall.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockExpectedFunctionCall.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockExpectedFunctionsList.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockFailure.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockFunctionCall.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockNamedValue.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupport.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupportPlugin.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/MockSupport_c.h
    incubator/celix/trunk/cmake/cpputest/include/CppUTestExt/OrderedTest.h
    incubator/celix/trunk/cmake/cpputest/include/Platforms/
    incubator/celix/trunk/cmake/cpputest/include/Platforms/Gcc/
    incubator/celix/trunk/cmake/cpputest/include/Platforms/Gcc/Platform.h
    incubator/celix/trunk/cmake/cpputest/include/Platforms/StarterKit/
    incubator/celix/trunk/cmake/cpputest/include/Platforms/StarterKit/Platform.h
    incubator/celix/trunk/cmake/cpputest/include/Platforms/Symbian/
    incubator/celix/trunk/cmake/cpputest/include/Platforms/Symbian/Platform.h
    incubator/celix/trunk/cmake/cpputest/include/Platforms/VisualCpp/
    incubator/celix/trunk/cmake/cpputest/include/Platforms/VisualCpp/Platform.h
    incubator/celix/trunk/cmake/cpputest/include/Platforms/VisualCpp/stdint.h
    incubator/celix/trunk/cmake/cpputest/lib/
    incubator/celix/trunk/cmake/cpputest/lib/libCppUTest.a
    incubator/celix/trunk/cmake/cpputest/lib/libCppUTestExt.a
    incubator/celix/trunk/cmake/unity/
    incubator/celix/trunk/cmake/unity/colour_prompt.rb
    incubator/celix/trunk/cmake/unity/colour_reporter.rb
    incubator/celix/trunk/cmake/unity/generate_config.yml
    incubator/celix/trunk/cmake/unity/generate_module.rb
    incubator/celix/trunk/cmake/unity/generate_test_runner.rb
    incubator/celix/trunk/cmake/unity/src/
    incubator/celix/trunk/cmake/unity/src/unity.c
    incubator/celix/trunk/cmake/unity/src/unity.h
    incubator/celix/trunk/cmake/unity/src/unity_internals.h
    incubator/celix/trunk/cmake/unity/test_file_filter.rb
    incubator/celix/trunk/cmake/unity/unity_test_summary.rb
    incubator/celix/trunk/examples/component_testing/
    incubator/celix/trunk/examples/component_testing/CMakeLists.txt
    incubator/celix/trunk/examples/component_testing/client/
    incubator/celix/trunk/examples/component_testing/client/CMakeLists.txt
    incubator/celix/trunk/examples/component_testing/client/META-INF/
    incubator/celix/trunk/examples/component_testing/client/META-INF/MANIFEST.MF
    incubator/celix/trunk/examples/component_testing/client/private/
    incubator/celix/trunk/examples/component_testing/client/private/include/
    incubator/celix/trunk/examples/component_testing/client/private/include/client_impl.h
    incubator/celix/trunk/examples/component_testing/client/private/src/
    incubator/celix/trunk/examples/component_testing/client/private/src/client_activator.c
    incubator/celix/trunk/examples/component_testing/client/private/src/client_impl.c
    incubator/celix/trunk/examples/component_testing/client/private/test/
    incubator/celix/trunk/examples/component_testing/client/private/test/client_test.cpp
    incubator/celix/trunk/examples/component_testing/server/
    incubator/celix/trunk/examples/component_testing/server/CMakeLists.txt
    incubator/celix/trunk/examples/component_testing/server/META-INF/
    incubator/celix/trunk/examples/component_testing/server/META-INF/MANIFEST.MF
    incubator/celix/trunk/examples/component_testing/server/private/
    incubator/celix/trunk/examples/component_testing/server/private/include/
    incubator/celix/trunk/examples/component_testing/server/private/include/server_impl.h
    incubator/celix/trunk/examples/component_testing/server/private/src/
    incubator/celix/trunk/examples/component_testing/server/private/src/server_activator.c
    incubator/celix/trunk/examples/component_testing/server/private/src/server_impl.c
    incubator/celix/trunk/examples/component_testing/server/public/
    incubator/celix/trunk/examples/component_testing/server/public/include/
    incubator/celix/trunk/examples/component_testing/server/public/include/server.h
    incubator/celix/trunk/utils/private/test/testUnity.c
    incubator/celix/trunk/utils/private/test/testcpputest.cpp
    incubator/celix/trunk/utils/public/include/tomock.h
Modified:
    incubator/celix/trunk/CMakeLists.txt
    incubator/celix/trunk/cmake/Test.cmake
    incubator/celix/trunk/framework/private/test/framework_test.c
    incubator/celix/trunk/framework/public/include/service_event.h
    incubator/celix/trunk/utils/CMakeLists.txt
    incubator/celix/trunk/utils/public/include/exports.h

Modified: incubator/celix/trunk/CMakeLists.txt
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/CMakeLists.txt?rev=1528380&r1=1528379&r2=1528380&view=diff
==============================================================================
--- incubator/celix/trunk/CMakeLists.txt (original)
+++ incubator/celix/trunk/CMakeLists.txt Wed Oct  2 09:01:20 2013
@@ -16,7 +16,7 @@
 # under the License.
 
 cmake_minimum_required (VERSION 2.6)
-project (Celix C)
+project (Celix C CXX)
 
 cmake_policy(SET CMP0012 NEW)
 

Modified: incubator/celix/trunk/cmake/Test.cmake
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/Test.cmake?rev=1528380&r1=1528379&r2=1528380&view=diff
==============================================================================
--- incubator/celix/trunk/cmake/Test.cmake (original)
+++ incubator/celix/trunk/cmake/Test.cmake Wed Oct  2 09:01:20 2013
@@ -17,7 +17,7 @@
 
 include(FindCUnit)
 
-ADD_CUSTOM_TARGET(test)
+ADD_CUSTOM_TARGET(test_cunit)
 MACRO(run_test)
     PARSE_ARGUMENTS(TEST "" "" ${ARGN})
     LIST(GET TEST_DEFAULT_ARGS 0 EXEC)
@@ -32,5 +32,83 @@ MACRO(run_test)
 		COMMAND if [ -e ${PROJECT_BINARY_DIR}/test_results/${EXEC}-Listing.xml ]\; then xsltproc --path ${CUNIT_SHARE_DIR} ${CUNIT_SHARE_DIR}/CUnit-List.xsl ${PROJECT_BINARY_DIR}/test_results/${EXEC}-Listing.xml > ${EXEC}-Listing.html \; fi
 		WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/test_results
 	)
-	ADD_DEPENDENCIES(test ${__testTarget})
-ENDMACRO(run_test)
\ No newline at end of file
+	ADD_DEPENDENCIES(test_cunit ${__testTarget})
+ENDMACRO(run_test)
+
+ADD_CUSTOM_TARGET(test_cppu)
+MACRO(run_cppu_test)
+    PARSE_ARGUMENTS(TEST "" "" ${ARGN})
+    LIST(GET TEST_DEFAULT_ARGS 0 EXEC)
+	
+	SET(__testTarget test_${EXEC})
+	
+	make_directory(${PROJECT_BINARY_DIR}/test_results)
+		
+	add_custom_target(${__testTarget}
+		${EXEC} "-ojunit" 
+		WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/test_results
+	)
+	ADD_DEPENDENCIES(test_cppu ${__testTarget})
+ENDMACRO(run_cppu_test)
+
+Include(FindRuby)
+ADD_CUSTOM_TARGET(testUnity)
+MACRO(run_unity_test)
+	PARSE_ARGUMENTS(TEST "SOURCE;MOCKS" "" ${ARGN})
+	LIST(GET TEST_DEFAULT_ARGS 0 EXEC)
+	
+	SET(__testTarget test_${EXEC})
+	SET(MOCKS "")
+	FOREACH(MOCK ${TEST_MOCKS})
+		get_filename_component(mockName ${MOCK} NAME_WE)
+		add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Mock${mockName}.c ${CMAKE_CURRENT_BINARY_DIR}/Mock${mockName}.h
+      		COMMAND ${RUBY_EXECUTABLE} ${PROJECT_SOURCE_DIR}/cmake/cmock/lib/cmock.rb -o${PROJECT_SOURCE_DIR}/cmake/cmock/test.yml ${CMAKE_CURRENT_SOURCE_DIR}/${MOCK}
+  			DEPENDS ${MOCK}
+  			COMMENT "Generating mock for ${MOCK}"
+      	)
+      	SET(MOCKS "${MOCKS}${CMAKE_CURRENT_BINARY_DIR}/Mock${mockName}.c")
+	ENDFOREACH(MOCK)
+
+	add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${EXEC}_runner.c
+		COMMAND ${RUBY_EXECUTABLE} ${PROJECT_SOURCE_DIR}/cmake/unity/generate_test_runner.rb 
+				${CMAKE_CURRENT_SOURCE_DIR}/${TEST_SOURCE} ${CMAKE_CURRENT_BINARY_DIR}/${EXEC}_runner.c
+		DEPENDS ${TEST_SOURCE}
+		COMMENT "Generating runner: ${CMAKE_CURRENT_BINARY_DIR}/${EXEC}_runner.c"
+	)
+	include_directories(${PROJECT_SOURCE_DIR}/cmake/cmock/src)
+	include_directories(${PROJECT_SOURCE_DIR}/cmake/unity/src)
+	include_directories(${CMAKE_CURRENT_BINARY_DIR})
+	add_executable(${EXEC} ${TEST_SOURCE} ${CMAKE_CURRENT_BINARY_DIR}/${EXEC}_runner.c 
+	    ${PROJECT_SOURCE_DIR}/cmake/unity/src/unity.c
+	    ${PROJECT_SOURCE_DIR}/cmake/cmock/src/cmock.c 
+		${MOCKS})
+	
+	message(${CMAKE_CURRENT_BINARY_DIR}/${EXEC})
+	#add_test(${EXEC} ${CMAKE_CURRENT_BINARY_DIR}/${EXEC})
+	add_custom_command(OUTPUT ${PROJECT_BINARY_DIR}/test_results/${EXEC}
+		COMMAND ${EXEC}
+		COMMAND touch ${PROJECT_BINARY_DIR}/test_results/${EXEC}
+		WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/test_results
+		COMMENT "Run tests"
+	)
+	
+	ADD_CUSTOM_TARGET(${__testTarget}
+    	DEPENDS ${PROJECT_BINARY_DIR}/test_results/${EXEC}
+    	COMMENT "Some comment")
+	ADD_DEPENDENCIES(testUnity ${__testTarget})
+ENDMACRO(run_unity_test)
+
+MACRO(gm)
+	PARSE_ARGUMENTS(MOCK "" "" ${ARGN})
+	LIST(GET MOCK_DEFAULT_ARGS 0 MOCKS)
+	
+	FOREACH(MOCK ${MOCKS})
+		get_filename_component(mockName ${MOCK} NAME_WE)
+		add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Mock${mockName}.c ${CMAKE_CURRENT_BINARY_DIR}/Mock${mockName}.h
+      		#COMMAND ${RUBY_EXECUTABLE} ${PROJECT_SOURCE_DIR}/cmake/cmock/lib/cmock.rb -o${PROJECT_SOURCE_DIR}/cmake/cmock/test.yml ${CMAKE_CURRENT_SOURCE_DIR}/${MOCK}
+  			#DEPENDS ${MOCK}
+  			COMMENT "Generating mock for ${MOCK}"
+      	)
+	ENDFOREACH(MOCK)
+	
+ENDMACRO(gm)
\ No newline at end of file

Added: incubator/celix/trunk/cmake/cmock/config/production_environment.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/config/production_environment.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/config/production_environment.rb (added)
+++ incubator/celix/trunk/cmake/cmock/config/production_environment.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,14 @@
+# ==========================================
+#   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]
+# ========================================== 
+ 
+# Setup our load path:
+[ 
+ 'lib',
+].each do |dir|
+  $LOAD_PATH.unshift( File.join( File.expand_path(File.dirname(__FILE__)) + '/../', dir) )
+end
+
+

Added: incubator/celix/trunk/cmake/cmock/config/test_environment.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/config/test_environment.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/config/test_environment.rb (added)
+++ incubator/celix/trunk/cmake/cmock/config/test_environment.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,16 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+# Setup our load path:
+[ 
+  'lib',
+  'vendor/behaviors/lib',
+  'vendor/hardmock/lib',
+  'vendor/unity/auto/',
+  'test/system/'
+].each do |dir|
+  $LOAD_PATH.unshift( File.join( File.expand_path(File.dirname(__FILE__) + "/../"), dir) )
+end

Added: incubator/celix/trunk/cmake/cmock/lib/cmock.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,65 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+[ "../config/production_environment",
+  "cmock_header_parser",
+  "cmock_generator",
+  "cmock_file_writer",
+  "cmock_config",
+  "cmock_plugin_manager",
+  "cmock_generator_utils",
+  "cmock_unityhelper_parser"].each {|req| require "#{File.expand_path(File.dirname(__FILE__))}/#{req}"}
+
+class CMock
+  
+  def initialize(options=nil)
+    cm_config      = CMockConfig.new(options)    
+    cm_unityhelper = CMockUnityHelperParser.new(cm_config)
+    cm_writer      = CMockFileWriter.new(cm_config)
+    cm_gen_utils   = CMockGeneratorUtils.new(cm_config, {:unity_helper => cm_unityhelper})
+    cm_gen_plugins = CMockPluginManager.new(cm_config, cm_gen_utils)
+    @cm_parser     = CMockHeaderParser.new(cm_config)
+    @cm_generator  = CMockGenerator.new(cm_config, cm_writer, cm_gen_utils, cm_gen_plugins)
+    @silent        = (cm_config.verbosity < 2)
+  end
+  
+  def setup_mocks(files)
+    [files].flatten.each do |src|
+      generate_mock src
+    end
+  end
+
+  private ###############################
+
+  def generate_mock(src)
+    name = File.basename(src, '.h')
+    puts "Creating mock for #{name}..." unless @silent
+    @cm_generator.create_mock(name, @cm_parser.parse(name, File.read(src)))
+  end
+end
+
+  # Command Line Support ###############################
+  
+if ($0 == __FILE__)
+  usage = "usage: ruby #{__FILE__} (-oOptionsFile) File(s)ToMock"
+  
+  if (!ARGV[0])
+    puts usage
+    exit 1
+  end
+  
+  options = nil
+  filelist = []
+  ARGV.each do |arg|
+    if (arg =~ /^-o(\w*)/)
+      options = arg.gsub(/^-o/,'')
+    else
+      filelist << arg
+    end
+  end
+  
+  CMock.new(options).setup_mocks(filelist)
+end
\ No newline at end of file

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_config.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_config.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_config.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_config.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,123 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+class CMockConfig
+  
+  CMockDefaultOptions = 
+  {
+    :framework                => :unity,
+    :mock_path                => 'mocks',
+    :mock_prefix              => 'Mock',
+    :plugins                  => [],
+    :strippables              => ['(?:__attribute__\s*\(+.*?\)+)'],
+    :attributes               => ['__ramfunc', '__irq', '__fiq', 'register', 'extern'],
+    :enforce_strict_ordering  => false,
+    :unity_helper             => false,
+    :treat_as                 => {},
+    :treat_as_void            => [],
+    :memcmp_if_unknown        => true,
+    :when_no_prototypes       => :warn,           #the options being :ignore, :warn, or :error
+    :when_ptr                 => :compare_data,   #the options being :compare_ptr, :compare_data, or :smart
+    :verbosity                => 2,               #the options being 0 errors only, 1 warnings and errors, 2 normal info, 3 verbose
+    :treat_externs            => :exclude,        #the options being :include or :exclude
+    :ignore                   => :args_and_calls, #the options being :args_and_calls or :args_only
+    :callback_include_count   => true,
+    :callback_after_arg_check => false,
+    :includes                    => nil, 
+    :includes_h_pre_orig_header  => nil, 
+    :includes_h_post_orig_header => nil, 
+    :includes_c_pre_header       => nil, 
+    :includes_c_post_header      => nil, 
+  }
+  
+  def initialize(options=nil)
+    case(options)
+      when NilClass then options = CMockDefaultOptions.clone 
+      when String   then options = CMockDefaultOptions.clone.merge(load_config_file_from_yaml(options))
+      when Hash     then options = CMockDefaultOptions.clone.merge(options)
+      else          raise "If you specify arguments, it should be a filename or a hash of options"
+    end
+    
+    #do some quick type verification
+    [:plugins, :attributes, :treat_as_void].each do |opt|
+      unless (options[opt].class == Array)
+        options[opt] = []
+        puts "WARNING: :#{opt.to_s} should be an array." unless (options[:verbosity] < 1)
+      end
+    end
+    [:includes, :includes_h_pre_orig_header, :includes_h_post_orig_header, :includes_c_pre_header, :includes_c_post_header].each do |opt|
+      unless (options[opt].nil? or (options[opt].class == Array))
+        options[opt] = []
+        puts "WARNING: :#{opt.to_s} should be an array." unless (options[:verbosity] < 1)
+      end
+    end
+    options[:plugins].compact!
+    options[:plugins].map! {|p| p.to_sym}
+    @options = options
+    @options[:treat_as].merge!(standard_treat_as_map)
+    @options.each_key { |key| eval("def #{key.to_s}() return @options[:#{key.to_s}] end") }
+  end
+  
+  def load_config_file_from_yaml yaml_filename
+    require 'yaml'
+    require 'fileutils'
+    YAML.load_file(yaml_filename)[:cmock]
+  end
+  
+  def set_path(path)
+    @src_path = path
+  end
+  
+  def load_unity_helper
+    return File.new(@options[:unity_helper]).read if (@options[:unity_helper])
+    return nil
+  end
+
+  def standard_treat_as_map 
+    {
+      'int'             => 'INT',
+      'char'            => 'INT8',
+      'short'           => 'INT16',
+      'long'            => 'INT',
+      'int8'            => 'INT8',
+      'int16'           => 'INT16',
+      'int32'           => 'INT',
+      'int8_t'          => 'INT8',
+      'int16_t'         => 'INT16',
+      'int32_t'         => 'INT',
+      'INT8_T'          => 'INT8',
+      'INT16_T'         => 'INT16',
+      'INT32_T'         => 'INT',
+      'bool'            => 'INT',
+      'bool_t'          => 'INT',
+      'BOOL'            => 'INT',
+      'BOOL_T'          => 'INT',
+      'unsigned int'    => 'HEX32',
+      'unsigned long'   => 'HEX32',
+      'uint32'          => 'HEX32',
+      'uint32_t'        => 'HEX32',
+      'UINT32'          => 'HEX32',
+      'UINT32_T'        => 'HEX32',
+      'void*'           => 'PTR',
+      'unsigned short'  => 'HEX16',
+      'uint16'          => 'HEX16',
+      'uint16_t'        => 'HEX16',
+      'UINT16'          => 'HEX16',
+      'UINT16_T'        => 'HEX16',
+      'unsigned char'   => 'HEX8',
+      'uint8'           => 'HEX8',
+      'uint8_t'         => 'HEX8',
+      'UINT8'           => 'HEX8',
+      'UINT8_T'         => 'HEX8',
+      'char*'           => 'STRING',
+      'pCHAR'           => 'STRING',
+      'cstring'         => 'STRING',
+      'CSTRING'         => 'STRING',
+      'float'           => 'FLOAT',
+      'double'          => 'FLOAT',
+    }
+  end
+end

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_file_writer.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_file_writer.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_file_writer.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_file_writer.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,33 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+class CMockFileWriter
+
+  attr_reader :config
+
+  def initialize(config)
+    @config = config
+  end
+
+  def create_file(filename)
+    raise "Where's the block of data to create?" unless block_given?
+    full_file_name_temp = "#{@config.mock_path}/#{filename}.new"
+    full_file_name_done = "#{@config.mock_path}/#{filename}"
+    File.open(full_file_name_temp, 'w') do |file|
+      yield(file, filename)
+    end
+    update_file(full_file_name_done, full_file_name_temp)
+  end
+  
+  private ###################################
+  
+  def update_file(dest, src)
+    require 'fileutils'
+    FileUtils.rm(dest) if (File.exist?(dest))
+    FileUtils.cp(src, dest)
+    FileUtils.rm(src)
+  end
+end

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_generator.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_generator.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_generator.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_generator.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,203 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+$here = File.dirname __FILE__
+
+class CMockGenerator
+
+  attr_accessor :config, :file_writer, :module_name, :mock_name, :utils, :plugins, :ordered
+  
+  def initialize(config, file_writer, utils, plugins)
+    @file_writer = file_writer
+    @utils       = utils
+    @plugins     = plugins
+    @config      = config
+    @prefix      = @config.mock_prefix
+    @ordered     = @config.enforce_strict_ordering
+    @framework   = @config.framework.to_s
+    
+    @includes_h_pre_orig_header  = @config.includes || @config.includes_h_pre_orig_header || []
+    @includes_h_post_orig_header = @config.includes_h_post_orig_header || []
+    @includes_c_pre_header       = @config.includes_c_pre_header || []
+    @includes_c_post_header      = @config.includes_c_post_header || []
+  end
+
+  def create_mock(module_name, parsed_stuff)
+    @module_name = module_name
+    @mock_name   = @prefix + @module_name
+    create_mock_header_file(parsed_stuff)
+    create_mock_source_file(parsed_stuff)
+  end
+  
+  private if $ThisIsOnlyATest.nil? ##############################
+  
+  def create_mock_header_file(parsed_stuff)
+    @file_writer.create_file(@mock_name + ".h") do |file, filename|
+      create_mock_header_header(file, filename)
+      create_mock_header_service_call_declarations(file)
+      create_typedefs(file, parsed_stuff[:typedefs])
+      parsed_stuff[:functions].each do |function|
+        file << @plugins.run(:mock_function_declarations, function)
+      end
+      create_mock_header_footer(file)
+    end
+  end
+
+  def create_mock_source_file(parsed_stuff)
+    @file_writer.create_file(@mock_name + ".c") do |file, filename|
+      create_source_header_section(file, filename)
+      create_instance_structure(file, parsed_stuff[:functions])
+      create_extern_declarations(file)
+      create_mock_verify_function(file, parsed_stuff[:functions])
+      create_mock_init_function(file)
+      create_mock_destroy_function(file, parsed_stuff[:functions])
+      parsed_stuff[:functions].each do |function|
+        create_mock_implementation(file, function)
+        create_mock_interfaces(file, function)
+      end
+    end
+  end
+  
+  def create_mock_header_header(file, filename) 
+    define_name   = filename.gsub(/\.h/, "_h").upcase
+    orig_filename = filename.gsub(@config.mock_prefix, "")   
+    file << "/* AUTOGENERATED FILE. DO NOT EDIT. */\n"
+    file << "#ifndef _#{define_name}\n"
+    file << "#define _#{define_name}\n\n"
+    @includes_h_pre_orig_header.each {|inc| file << "#include \"#{inc}\"\n"} 
+    file << "#include \"#{orig_filename}\"\n"
+    @includes_h_post_orig_header.each {|inc| file << "#include \"#{inc}\"\n"}
+    plugin_includes = @plugins.run(:include_files)
+    file << plugin_includes if (!plugin_includes.empty?)
+    file << "\n"
+  end
+  
+  def create_typedefs(file, typedefs)
+    file << "\n"
+    typedefs.each {|typedef| file << "#{typedef}\n" }
+    file << "\n\n"
+  end
+
+  def create_mock_header_service_call_declarations(file) 
+    file << "void #{@mock_name}_Init(void);\n"
+    file << "void #{@mock_name}_Destroy(void);\n"
+    file << "void #{@mock_name}_Verify(void);\n\n"
+  end
+
+  def create_mock_header_footer(header)
+    header << "\n#endif\n"
+  end
+  
+  def create_source_header_section(file, filename)
+    header_file = filename.gsub(".c",".h")
+    file << "/* AUTOGENERATED FILE. DO NOT EDIT. */\n"
+    file << "#include <string.h>\n"
+    file << "#include <stdlib.h>\n"
+    file << "#include <setjmp.h>\n"
+    file << "#include \"#{@framework}.h\"\n"
+    file << "#include \"cmock.h\"\n"
+    @includes_c_pre_header.each {|inc| file << "#include \"#{inc}\"\n"}
+    file << "#include \"#{header_file}\"\n"
+    @includes_c_post_header.each {|inc| file << "#include \"#{inc}\"\n"}
+    file << "\n"
+  end
+  
+  def create_instance_structure(file, functions)
+    functions.each do |function| 
+      file << "typedef struct _CMOCK_#{function[:name]}_CALL_INSTANCE\n{\n"
+      file << "  UNITY_LINE_TYPE LineNumber;\n"
+      file << @plugins.run(:instance_typedefs, function)
+      file << "\n} CMOCK_#{function[:name]}_CALL_INSTANCE;\n\n"
+    end
+    file << "static struct #{@mock_name}Instance\n{\n"
+    if (functions.size == 0)
+      file << "  unsigned char placeHolder;\n"
+    end
+    functions.each do |function|
+      file << @plugins.run(:instance_structure, function)
+      file << "  CMOCK_MEM_INDEX_TYPE #{function[:name]}_CallInstance;\n"
+    end
+    file << "} Mock;\n\n"
+  end
+  
+  def create_extern_declarations(file)
+    file << "extern jmp_buf AbortFrame;\n"
+    if (@ordered)
+      file << "extern int GlobalExpectCount;\n"
+      file << "extern int GlobalVerifyOrder;\n"
+      file << "extern char* GlobalOrderError;\n"
+    end
+    file << "\n"
+  end
+  
+  def create_mock_verify_function(file, functions)
+    file << "void #{@mock_name}_Verify(void)\n{\n"
+    verifications = functions.collect {|function| @plugins.run(:mock_verify, function)}.join
+    verifications += "  UNITY_TEST_ASSERT_NULL(GlobalOrderError, cmock_line, \"Internal CMock error.\");\n" if (@ordered)
+    file << "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n" unless verifications.empty?
+    file << verifications
+    file << "}\n\n"
+  end
+  
+  def create_mock_init_function(file)
+    file << "void #{@mock_name}_Init(void)\n{\n"
+    file << "  #{@mock_name}_Destroy();\n"
+    file << "}\n\n"
+  end
+  
+  def create_mock_destroy_function(file, functions)
+    file << "void #{@mock_name}_Destroy(void)\n{\n"
+    file << "  CMock_Guts_MemFreeAll();\n"
+    file << "  memset(&Mock, 0, sizeof(Mock));\n"
+    file << functions.collect {|function| @plugins.run(:mock_destroy, function)}.join
+    if (@ordered)
+      file << "  GlobalExpectCount = 0;\n"
+      file << "  GlobalVerifyOrder = 0;\n"
+      file << "  if (GlobalOrderError)\n"
+      file << "  {\n"
+      file << "    free(GlobalOrderError);\n"
+      file << "    GlobalOrderError = NULL;\n"
+      file << "  }\n"
+    end
+    file << "}\n\n"
+  end
+  
+  def create_mock_implementation(file, function)        
+    # prepare return value and arguments       
+    if (function[:modifier].empty?)
+      function_mod_and_rettype = function[:return][:type] 
+    else
+      function_mod_and_rettype = function[:modifier] + ' ' + function[:return][:type] 
+    end
+    args_string = function[:args_string]
+    args_string += (", " + function[:var_arg]) unless (function[:var_arg].nil?)
+    
+    # Create mock function
+    file << "#{function_mod_and_rettype} #{function[:name]}(#{args_string})\n"
+    file << "{\n"
+    file << "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n"
+    file << "  CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance = (CMOCK_#{function[:name]}_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.#{function[:name]}_CallInstance);\n"
+    file << "  Mock.#{function[:name]}_CallInstance = CMock_Guts_MemNext(Mock.#{function[:name]}_CallInstance);\n"
+    file << @plugins.run(:mock_implementation_precheck, function)
+    file << "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"Function '#{function[:name]}' called more times than expected.\");\n"
+    file << "  cmock_line = cmock_call_instance->LineNumber;\n"
+    if (@ordered)
+      file << "  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)\n"
+      file << "    UNITY_TEST_FAIL(cmock_line, \"Function '#{function[:name]}' called earlier than expected.\");"
+      file << "  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)\n"
+      file << "    UNITY_TEST_FAIL(cmock_line, \"Function '#{function[:name]}' called later than expected.\");"
+      # file << "  UNITY_TEST_ASSERT((cmock_call_instance->CallOrder == ++GlobalVerifyOrder), cmock_line, \"Out of order function calls. Function '#{function[:name]}'\");\n"
+    end
+    file << @plugins.run(:mock_implementation, function)
+    file << "  return cmock_call_instance->ReturnVal;\n" unless (function[:return][:void?]) 
+    file << "}\n\n"
+  end
+  
+  def create_mock_interfaces(file, function)
+    file << @utils.code_add_argument_loader(function)
+    file << @plugins.run(:mock_interfaces, function)
+  end
+end

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_array.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_array.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_array.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_array.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,57 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+class CMockGeneratorPluginArray
+
+  attr_reader :priority
+  attr_accessor :config, :utils, :unity_helper, :ordered
+  def initialize(config, utils)
+    @config       = config
+    @ptr_handling = @config.when_ptr
+    @ordered      = @config.enforce_strict_ordering
+    @utils        = utils
+    @unity_helper = @utils.helpers[:unity_helper]
+    @priority     = 8
+  end
+
+  def instance_typedefs(function)
+    function[:args].inject("") do |all, arg|
+      (arg[:ptr?]) ? all + "  int Expected_#{arg[:name]}_Depth;\n" : all
+    end
+  end
+
+  def mock_function_declarations(function)
+    return nil unless function[:contains_ptr?]
+    args_call   = function[:args].map{|m| m[:ptr?] ? "#{m[:name]}, #{m[:name]}_Depth" : "#{m[:name]}"}.join(', ')
+    args_string = function[:args].map{|m| m[:ptr?] ? "#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{m[:type]} #{m[:name]}"}.join(', ')
+    if (function[:return][:void?])
+      return "#define #{function[:name]}_ExpectWithArray(#{args_call}) #{function[:name]}_CMockExpectWithArray(__LINE__, #{args_call})\n" +
+             "void #{function[:name]}_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, #{args_string});\n"
+    else
+      return "#define #{function[:name]}_ExpectWithArrayAndReturn(#{args_call}, cmock_retval) #{function[:name]}_CMockExpectWithArrayAndReturn(__LINE__, #{args_call}, cmock_retval)\n" +
+             "void #{function[:name]}_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, #{args_string}, #{function[:return][:str]});\n"
+    end
+  end
+
+  def mock_interfaces(function)
+    return nil unless function[:contains_ptr?]
+    lines = []
+    func_name = function[:name]
+    args_string = function[:args].map{|m| m[:ptr?] ? "#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{m[:type]} #{m[:name]}"}.join(', ')
+    call_string = function[:args].map{|m| m[:ptr?] ? "#{m[:name]}, #{m[:name]}_Depth" : m[:name]}.join(', ')
+    if (function[:return][:void?])
+      lines << "void #{func_name}_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, #{args_string})\n"
+    else
+      lines << "void #{func_name}_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, #{args_string}, #{function[:return][:str]})\n"
+    end
+    lines << "{\n"
+    lines << @utils.code_add_base_expectation(func_name)
+    lines << "  CMockExpectParameters_#{func_name}(cmock_call_instance, #{call_string});\n"
+    lines << "  cmock_call_instance->ReturnVal = cmock_to_return;\n" unless (function[:return][:void?])
+    lines << "}\n\n"
+  end
+
+end

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_callback.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_callback.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_callback.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_callback.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,78 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+class CMockGeneratorPluginCallback
+
+  attr_accessor :include_count
+  attr_reader :priority
+  attr_reader :config, :utils
+  
+  def initialize(config, utils)
+    @config = config
+    @utils = utils
+    @priority = 6
+    
+    @include_count = @config.callback_include_count
+    if (@config.callback_after_arg_check)
+      alias :mock_implementation          :mock_implementation_for_callbacks
+      alias :mock_implementation_precheck :nothing
+    else
+      alias :mock_implementation_precheck :mock_implementation_for_callbacks
+      alias :mock_implementation          :nothing
+    end
+  end
+
+  def instance_structure(function)
+    func_name = function[:name]
+    "  CMOCK_#{func_name}_CALLBACK #{func_name}_CallbackFunctionPointer;\n" +
+    "  int #{func_name}_CallbackCalls;\n"
+  end
+
+  def mock_function_declarations(function)
+    func_name = function[:name]
+    return_type = function[:return][:const?] ? "const #{function[:return][:type]}" : function[:return][:type]
+    style  = (@include_count ? 1 : 0) | (function[:args].empty? ? 0 : 2)
+    styles = [ "void", "int cmock_num_calls", function[:args_string], "#{function[:args_string]}, int cmock_num_calls" ]
+    "typedef #{return_type} (* CMOCK_#{func_name}_CALLBACK)(#{styles[style]});\nvoid #{func_name}_StubWithCallback(CMOCK_#{func_name}_CALLBACK Callback);\n"
+  end
+
+  def mock_implementation_for_callbacks(function)
+    func_name   = function[:name]
+    style  = (@include_count ? 1 : 0) | (function[:args].empty? ? 0 : 2) | (function[:return][:void?] ? 0 : 4)
+    "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n  {\n" +
+    case(style)
+      when 0 then "    Mock.#{func_name}_CallbackFunctionPointer();\n    return;\n  }\n"
+      when 1 then "    Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n    return;\n  }\n"
+      when 2 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n    return;\n  }\n"
+      when 3 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n    return;\n  }\n"
+      when 4 then "    return Mock.#{func_name}_CallbackFunctionPointer(void);\n  }\n"
+      when 5 then "    return Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n  }\n"
+      when 6 then "    return Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n  }\n"
+      when 7 then "    return Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n  }\n"
+    end
+  end
+  
+  def nothing(function)
+    return ""
+  end
+
+  def mock_interfaces(function)
+    func_name = function[:name]
+    "void #{func_name}_StubWithCallback(CMOCK_#{func_name}_CALLBACK Callback)\n{\n" + 
+    "  Mock.#{func_name}_CallbackFunctionPointer = Callback;\n}\n\n"
+  end
+
+  def mock_destroy(function)
+    "  Mock.#{function[:name]}_CallbackFunctionPointer = NULL;\n" +
+    "  Mock.#{function[:name]}_CallbackCalls = 0;\n"
+  end
+  
+  def mock_verify(function)
+    func_name = function[:name]
+    "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n    Mock.#{func_name}_CallInstance = CMOCK_GUTS_NONE;\n"
+  end
+
+end

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_cexception.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_cexception.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_cexception.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_cexception.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,51 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+class CMockGeneratorPluginCexception
+
+  attr_reader :priority
+  attr_reader :config, :utils
+  
+  def initialize(config, utils)
+    @config = config
+    @utils = utils
+    @priority = 7
+  end
+
+  def include_files
+    return "#include \"CException.h\"\n"
+  end
+
+  def instance_typedefs(function)
+    "  CEXCEPTION_T ExceptionToThrow;\n"
+  end
+  
+  def mock_function_declarations(function)
+    if (function[:args_string] == "void")
+      return "#define #{function[:name]}_ExpectAndThrow(cmock_to_throw) #{function[:name]}_CMockExpectAndThrow(__LINE__, cmock_to_throw)\n" +
+             "void #{function[:name]}_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, CEXCEPTION_T cmock_to_throw);\n"
+    else
+      return "#define #{function[:name]}_ExpectAndThrow(#{function[:args_call]}, cmock_to_throw) #{function[:name]}_CMockExpectAndThrow(__LINE__, #{function[:args_call]}, cmock_to_throw)\n" +
+             "void #{function[:name]}_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, #{function[:args_string]}, CEXCEPTION_T cmock_to_throw);\n"
+    end
+  end
+
+  def mock_implementation(function)
+    "  if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE)\n  {\n" + 
+    "    Throw(cmock_call_instance->ExceptionToThrow);\n  }\n"
+  end
+
+  def mock_interfaces(function)
+    arg_insert = (function[:args_string] == "void") ? "" : "#{function[:args_string]}, "
+    call_string = function[:args].map{|m| m[:name]}.join(', ')
+    [ "void #{function[:name]}_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, #{arg_insert}CEXCEPTION_T cmock_to_throw)\n{\n",
+      @utils.code_add_base_expectation(function[:name]),
+      @utils.code_call_argument_loader(function),
+      "  cmock_call_instance->ExceptionToThrow = cmock_to_throw;\n",
+      "}\n\n" ].join
+  end
+
+end

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_expect.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_expect.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_expect.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_expect.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,86 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+class CMockGeneratorPluginExpect
+
+  attr_reader :priority
+  attr_accessor :config, :utils, :unity_helper, :ordered
+
+  def initialize(config, utils)
+    @config       = config
+    @ptr_handling = @config.when_ptr
+    @ordered      = @config.enforce_strict_ordering
+    @utils        = utils
+    @unity_helper = @utils.helpers[:unity_helper]
+    @priority     = 5
+  end
+  
+  def instance_typedefs(function)
+    lines = ""
+    lines << "  #{function[:return][:type]} ReturnVal;\n"  unless (function[:return][:void?])
+    lines << "  int CallOrder;\n"                          if (@ordered)
+    function[:args].each do |arg|
+      lines << "  #{arg[:type]} Expected_#{arg[:name]};\n"
+    end
+    lines
+  end
+  
+  def mock_function_declarations(function)
+    if (function[:args].empty?)
+      if (function[:return][:void?])
+        return "#define #{function[:name]}_Expect() #{function[:name]}_CMockExpect(__LINE__)\n" +
+               "void #{function[:name]}_CMockExpect(UNITY_LINE_TYPE cmock_line);\n"
+      else
+        return "#define #{function[:name]}_ExpectAndReturn(cmock_retval) #{function[:name]}_CMockExpectAndReturn(__LINE__, cmock_retval)\n" +
+               "void #{function[:name]}_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]});\n"
+      end
+    else        
+      if (function[:return][:void?])
+        return "#define #{function[:name]}_Expect(#{function[:args_call]}) #{function[:name]}_CMockExpect(__LINE__, #{function[:args_call]})\n" +
+               "void #{function[:name]}_CMockExpect(UNITY_LINE_TYPE cmock_line, #{function[:args_string]});\n"
+      else
+        return "#define #{function[:name]}_ExpectAndReturn(#{function[:args_call]}, cmock_retval) #{function[:name]}_CMockExpectAndReturn(__LINE__, #{function[:args_call]}, cmock_retval)\n" +
+               "void #{function[:name]}_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:args_string]}, #{function[:return][:str]});\n"
+      end
+    end
+  end
+  
+  def mock_implementation(function)
+    lines = ""
+    function[:args].each do |arg|
+      lines << @utils.code_verify_an_arg_expectation(function, arg)
+    end
+    lines
+  end
+  
+  def mock_interfaces(function)
+    lines = ""
+    func_name = function[:name]
+    if (function[:return][:void?])
+      if (function[:args_string] == "void")
+        lines << "void #{func_name}_CMockExpect(UNITY_LINE_TYPE cmock_line)\n{\n"
+      else
+        lines << "void #{func_name}_CMockExpect(UNITY_LINE_TYPE cmock_line, #{function[:args_string]})\n{\n"
+      end
+    else
+      if (function[:args_string] == "void")
+        lines << "void #{func_name}_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]})\n{\n"
+      else
+        lines << "void #{func_name}_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:args_string]}, #{function[:return][:str]})\n{\n"
+      end
+    end
+    lines << @utils.code_add_base_expectation(func_name)
+    lines << @utils.code_call_argument_loader(function)
+    lines << @utils.code_assign_argument_quickly("cmock_call_instance->ReturnVal", function[:return]) unless (function[:return][:void?])
+    lines << "}\n\n"
+  end
+  
+  def mock_verify(function)
+    func_name = function[:name]
+    "  UNITY_TEST_ASSERT(CMOCK_GUTS_NONE == Mock.#{func_name}_CallInstance, cmock_line, \"Function '#{func_name}' called less times than expected.\");\n"
+  end
+
+end

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_ignore.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_ignore.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_ignore.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_generator_plugin_ignore.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,83 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+class CMockGeneratorPluginIgnore
+
+  attr_reader :priority
+  attr_reader :config, :utils
+  
+  def initialize(config, utils)
+    @config = config
+    if (@config.ignore == :args_and_calls)
+      alias :mock_implementation_precheck :mock_implementation_for_ignores
+      alias :mock_implementation          :nothing
+    else
+      alias :mock_implementation          :mock_implementation_for_ignores
+      alias :mock_implementation_precheck :nothing
+    end
+    @utils = utils
+    @priority = 2
+  end
+  
+  def instance_structure(function)
+    if (function[:return][:void?])
+      "  int #{function[:name]}_IgnoreBool;\n"
+    else
+      "  int #{function[:name]}_IgnoreBool;\n  #{function[:return][:type]} #{function[:name]}_FinalReturn;\n"
+    end
+  end
+  
+  def mock_function_declarations(function)
+    if (function[:return][:void?])
+      return "#define #{function[:name]}_Ignore() #{function[:name]}_CMockIgnore(__LINE__)\n" +
+             "void #{function[:name]}_CMockIgnore(UNITY_LINE_TYPE cmock_line);\n"
+    else        
+      return "#define #{function[:name]}_IgnoreAndReturn(cmock_retval) #{function[:name]}_CMockIgnoreAndReturn(__LINE__, cmock_retval)\n" +
+             "void #{function[:name]}_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]});\n"
+    end 
+  end
+  
+  def mock_implementation_for_ignores(function)
+    lines = "  if (Mock.#{function[:name]}_IgnoreBool)\n  {\n" 
+    if (function[:return][:void?])
+      lines << "    return;\n  }\n"
+    else
+      retval = function[:return].merge( { :name => "cmock_call_instance->ReturnVal"} )
+      lines << "    if (cmock_call_instance == NULL)\n      return Mock.#{function[:name]}_FinalReturn;\n"
+      lines << "  " + @utils.code_assign_argument_quickly("Mock.#{function[:name]}_FinalReturn", retval) unless (retval[:void?])
+      lines << "    return cmock_call_instance->ReturnVal;\n  }\n"
+    end
+    lines
+  end
+  
+  def mock_interfaces(function)
+    lines = ""
+    if (function[:return][:void?])
+      lines << "void #{function[:name]}_CMockIgnore(UNITY_LINE_TYPE cmock_line)\n{\n"
+    else
+      lines << "void #{function[:name]}_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]})\n{\n"
+    end
+    if (@config.ignore == :args_only)
+      lines << @utils.code_add_base_expectation(function[:name], true)
+    elsif (!function[:return][:void?]) 
+      lines << @utils.code_add_base_expectation(function[:name], false)
+    end
+    unless (function[:return][:void?])
+      lines << "  cmock_call_instance->ReturnVal = cmock_to_return;\n"
+    end
+    lines << "  Mock.#{function[:name]}_IgnoreBool = (int)1;\n"
+    lines << "}\n\n"
+  end
+
+  def mock_verify(function)
+    func_name = function[:name]
+    "  if (Mock.#{func_name}_IgnoreBool)\n    Mock.#{func_name}_CallInstance = CMOCK_GUTS_NONE;\n"
+  end
+  
+  def nothing(function)
+    return ""
+  end
+end

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_generator_utils.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_generator_utils.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_generator_utils.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_generator_utils.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,177 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+class CMockGeneratorUtils
+
+  attr_accessor :config, :helpers, :ordered, :ptr_handling, :arrays, :cexception
+
+  def initialize(config, helpers={})
+    @config = config
+    @ptr_handling = @config.when_ptr
+    @ordered      = @config.enforce_strict_ordering
+    @arrays       = @config.plugins.include? :array
+    @cexception   = @config.plugins.include? :cexception
+    @treat_as     = @config.treat_as
+	  @helpers = helpers
+    
+    if (@arrays)
+      case(@ptr_handling)
+        when :smart        then alias :code_verify_an_arg_expectation :code_verify_an_arg_expectation_with_smart_arrays 
+        when :compare_data then alias :code_verify_an_arg_expectation :code_verify_an_arg_expectation_with_normal_arrays 
+        when :compare_ptr  then raise "ERROR: the array plugin doesn't enjoy working with :compare_ptr only.  Disable one option."
+      end
+    else
+      alias :code_verify_an_arg_expectation :code_verify_an_arg_expectation_with_no_arrays
+    end
+  end
+  
+  def code_add_base_expectation(func_name, global_ordering_supported=true)
+    lines =  "  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_#{func_name}_CALL_INSTANCE));\n"
+    lines << "  CMOCK_#{func_name}_CALL_INSTANCE* cmock_call_instance = (CMOCK_#{func_name}_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);\n"
+    lines << "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"CMock has run out of memory. Please allocate more.\");\n"
+    lines << "  Mock.#{func_name}_CallInstance = CMock_Guts_MemChain(Mock.#{func_name}_CallInstance, cmock_guts_index);\n"
+    lines << "  cmock_call_instance->LineNumber = cmock_line;\n"
+    lines << "  cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" if (@ordered and global_ordering_supported)
+    lines << "  cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n" if (@cexception)
+    lines
+  end
+  
+  def code_add_an_arg_expectation(arg, depth=1) 
+    lines =  code_assign_argument_quickly("cmock_call_instance->Expected_#{arg[:name]}", arg)
+    lines << "  cmock_call_instance->Expected_#{arg[:name]}_Depth = #{arg[:name]}_Depth;\n" if (@arrays and (depth.class == String))
+    lines
+  end
+  
+  def code_assign_argument_quickly(dest, arg) 
+    if (arg[:ptr?] or @treat_as.include?(arg[:type]))
+      "  #{dest} = #{arg[:const?] ? "(#{arg[:type]})" : ''}#{arg[:name]};\n"
+    else
+      "  memcpy(&#{dest}, &#{arg[:name]}, sizeof(#{arg[:type]}));\n"
+    end
+  end
+  
+  def code_add_argument_loader(function)
+    if (function[:args_string] != "void")
+      if (@arrays)
+        args_string = function[:args].map do |m| 
+          const_str = m[ :const? ] ? 'const ' : ''
+          m[:ptr?] ? "#{const_str}#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{const_str}#{m[:type]} #{m[:name]}"
+        end.join(', ')
+        "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{args_string})\n{\n" + 
+        function[:args].inject("") { |all, arg| all + code_add_an_arg_expectation(arg, (arg[:ptr?] ? "#{arg[:name]}_Depth" : 1) ) } +
+        "}\n\n"
+      else
+        "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{function[:args_string]})\n{\n" + 
+        function[:args].inject("") { |all, arg| all + code_add_an_arg_expectation(arg) } +
+        "}\n\n"
+      end
+    else
+      ""
+    end
+  end
+  
+  def code_call_argument_loader(function)
+    if (function[:args_string] != "void")
+      args = function[:args].map do |m|
+        (@arrays and m[:ptr?]) ? "#{m[:name]}, 1" : m[:name]
+      end
+      "  CMockExpectParameters_#{function[:name]}(cmock_call_instance, #{args.join(', ')});\n" 
+    else
+      ""
+    end
+  end
+  
+  #private ######################
+  
+  def lookup_expect_type(function, arg)
+    c_type     = arg[:type]
+    arg_name   = arg[:name]
+    expected   = "cmock_call_instance->Expected_#{arg_name}" 
+    unity_func = if ((arg[:ptr?]) and ((c_type =~ /\*\*/) or (@ptr_handling == :compare_ptr)))
+                   ['UNITY_TEST_ASSERT_EQUAL_PTR', '']
+                 else
+                   (@helpers.nil? or @helpers[:unity_helper].nil?) ? ["UNITY_TEST_ASSERT_EQUAL",''] : @helpers[:unity_helper].get_helper(c_type)
+                 end
+    unity_msg  = "Function '#{function[:name]}' called with unexpected value for argument '#{arg_name}'."
+    return c_type, arg_name, expected, unity_func[0], unity_func[1], unity_msg
+  end
+  
+  def code_verify_an_arg_expectation_with_no_arrays(function, arg)
+    c_type, arg_name, expected, unity_func, pre, unity_msg = lookup_expect_type(function, arg)
+    case(unity_func)
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY"
+        c_type_local = c_type.gsub(/\*$/,'')
+        return "  UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, \"#{unity_msg}\");\n"
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY"
+        [ "  if (#{pre}#{expected} == NULL)",
+          "    { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+          "  else",
+          "    { UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), cmock_line, \"#{unity_msg}\"); }\n"].join("\n")
+      when /_ARRAY/
+        [ "  if (#{pre}#{expected} == NULL)",
+          "    { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+          "  else",
+          "    { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, 1, cmock_line, \"#{unity_msg}\"); }\n"].join("\n")
+      else
+        return "  #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n" 
+    end  
+  end
+  
+  def code_verify_an_arg_expectation_with_normal_arrays(function, arg)
+    c_type, arg_name, expected, unity_func, pre, unity_msg = lookup_expect_type(function, arg)
+    depth_name = (arg[:ptr?]) ? "cmock_call_instance->Expected_#{arg_name}_Depth" : 1
+    case(unity_func)
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY"
+        c_type_local = c_type.gsub(/\*$/,'')
+        return "  UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, \"#{unity_msg}\");\n"
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY"
+        [ "  if (#{pre}#{expected} == NULL)",
+          "    { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+          "  else",
+          "    { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), #{depth_name}, cmock_line, \"#{unity_msg}\"); }\n"].compact.join("\n")
+      when /_ARRAY/
+        if (pre == '&')
+          "  #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, \"#{unity_msg}\");\n"
+        else
+          [ "  if (#{pre}#{expected} == NULL)",
+            "    { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+            "  else",
+            "    { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, \"#{unity_msg}\"); }\n"].compact.join("\n")
+        end
+      else
+        return "  #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n" 
+    end
+  end
+  
+  def code_verify_an_arg_expectation_with_smart_arrays(function, arg)
+    c_type, arg_name, expected, unity_func, pre, unity_msg = lookup_expect_type(function, arg)
+    depth_name = (arg[:ptr?]) ? "cmock_call_instance->Expected_#{arg_name}_Depth" : 1
+    case(unity_func)
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY"
+        c_type_local = c_type.gsub(/\*$/,'')
+        return "  UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, \"#{unity_msg}\");\n"
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY"
+        [ "  if (#{pre}#{expected} == NULL)",
+          "    { UNITY_TEST_ASSERT_NULL(#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+          ((depth_name != 1) ? "  else if (#{depth_name} == 0)\n    { UNITY_TEST_ASSERT_EQUAL_PTR(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\"); }" : nil),
+          "  else",
+          "    { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), #{depth_name}, cmock_line, \"#{unity_msg}\"); }\n"].compact.join("\n")
+      when /_ARRAY/
+        if (pre == '&')
+          "  #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, \"#{unity_msg}\");\n"
+        else
+          [ "  if (#{pre}#{expected} == NULL)",
+            "    { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+            ((depth_name != 1) ? "  else if (#{depth_name} == 0)\n    { UNITY_TEST_ASSERT_EQUAL_PTR(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\"); }" : nil),
+            "  else",
+            "    { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, \"#{unity_msg}\"); }\n"].compact.join("\n")
+        end
+      else
+        return "  #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n" 
+    end
+  end
+  
+end
\ No newline at end of file

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_header_parser.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_header_parser.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_header_parser.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_header_parser.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,269 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+class CMockHeaderParser
+
+  attr_accessor :funcs, :c_attributes, :treat_as_void, :treat_externs
+  
+  def initialize(cfg)
+    @funcs = []
+    @c_strippables = cfg.strippables
+    @c_attributes = (['const'] + cfg.attributes).uniq
+    @treat_as_void = (['void'] + cfg.treat_as_void).uniq
+    @declaration_parse_matcher = /([\d\w\s\*\(\),\[\]]+??)\(([\d\w\s\*\(\),\.\[\]+-]*)\)$/m
+    @standards = (['int','short','char','long','unsigned','signed'] + cfg.treat_as.keys).uniq
+    @when_no_prototypes = cfg.when_no_prototypes
+    @local_as_void = @treat_as_void
+    @verbosity = cfg.verbosity
+    @treat_externs = cfg.treat_externs
+  end
+  
+  def parse(name, source)
+    @module_name = name
+    @typedefs = []
+    @funcs = []
+    function_names = []
+    
+    parse_functions( import_source(source) ).map do |decl| 
+      func = parse_declaration(decl)
+      unless (function_names.include? func[:name])
+        @funcs << func
+        function_names << func[:name]
+      end
+    end
+    
+    { :includes  => nil,
+      :functions => @funcs,
+      :typedefs  => @typedefs
+    }
+  end
+  
+  private if $ThisIsOnlyATest.nil? ################
+  
+  def import_source(source)
+
+    # void must be void for cmock _ExpectAndReturn calls to process properly, not some weird typedef which equates to void
+    # to a certain extent, this action assumes we're chewing on pre-processed header files, otherwise we'll most likely just get stuff from @treat_as_void
+    @local_as_void = @treat_as_void
+    void_types = source.scan(/typedef\s+(?:\(\s*)?void(?:\s*\))?\s+([\w\d]+)\s*;/)
+    if void_types
+      @local_as_void += void_types.flatten.uniq.compact
+    end
+  
+    # smush multiline macros into single line (checking for continuation character at end of line '\')
+    source.gsub!(/\s*\\\s*/m, ' ')
+   
+    #remove comments (block and line, in three steps to ensure correct precedence)
+    source.gsub!(/\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '')  # remove line comments that comment out the start of blocks
+    source.gsub!(/\/\*.*?\*\//m, '')                     # remove block comments 
+    source.gsub!(/\/\/.*$/, '')                          # remove line comments (all that remain)
+
+    # remove assembler pragma sections
+    source.gsub!(/^\s*#\s*pragma\s+asm\s+.*?#\s*pragma\s+endasm/m, '')
+    
+    # remove preprocessor statements and extern "C" 
+    source.gsub!(/^\s*#.*/, '')
+    source.gsub!(/extern\s+\"C\"\s+\{/, '')
+    
+    # enums, unions, structs, and typedefs can all contain things (e.g. function pointers) that parse like function prototypes, so yank them
+    # forward declared structs are removed before struct definitions so they don't mess up real thing later. we leave structs keywords in function prototypes
+    source.gsub!(/^[\w\s]*struct[^;\{\}\(\)]+;/m, '')                                      # remove forward declared structs
+    source.gsub!(/^[\w\s]*(enum|union|struct|typepdef)[\w\s]*\{[^\}]+\}[\w\s\*\,]*;/m, '') # remove struct, union, and enum definitions and typedefs with braces
+    source.gsub!(/(\W)(?:register|auto|static|restrict)(\W)/, '\1\2')                      # remove problem keywords
+    source.gsub!(/\s*=\s*['"a-zA-Z0-9_\.]+\s*/, '')                                        # remove default value statements from argument lists
+    source.gsub!(/^(?:[\w\s]*\W)?typedef\W.*/, '')                                         # remove typedef statements
+    source.gsub!(/(^|\W+)(?:#{@c_strippables.join('|')})(?=$|\W+)/,'\1') unless @c_strippables.empty? # remove known attributes slated to be stripped
+    
+    #scan for functions which return function pointers, because they are a pain
+    source.gsub!(/([\w\s\*]+)\(*\(\s*\*([\w\s\*]+)\s*\(([\w\s\*,]*)\)\)\s*\(([\w\s\*,]*)\)\)*/) do |m|
+      functype = "cmock_#{@module_name}_func_ptr#{@typedefs.size + 1}"
+      @typedefs << "typedef #{$1.strip}(*#{functype})(#{$4});"
+      "#{functype} #{$2.strip}(#{$3});"
+    end
+    
+    #drop extra white space to make the rest go faster
+    source.gsub!(/^\s+/, '')          # remove extra white space from beginning of line
+    source.gsub!(/\s+$/, '')          # remove extra white space from end of line
+    source.gsub!(/\s*\(\s*/, '(')     # remove extra white space from before left parens
+    source.gsub!(/\s*\)\s*/, ')')     # remove extra white space from before right parens
+    source.gsub!(/\s+/, ' ')          # remove remaining extra white space
+    
+    #split lines on semicolons and remove things that are obviously not what we are looking for
+    src_lines = source.split(/\s*;\s*/)
+    src_lines.delete_if {|line| line.strip.length == 0}                            # remove blank lines
+    src_lines.delete_if {|line| !(line =~ /\(\s*\*(?:.*\[\d*\])??\s*\)/).nil?}     #remove function pointer arrays
+    if (@treat_externs == :include)
+      src_lines.delete_if {|line| !(line =~ /(?:^|\s+)(?:inline)\s+/).nil?}        #remove inline functions
+    else
+      src_lines.delete_if {|line| !(line =~ /(?:^|\s+)(?:extern|inline)\s+/).nil?} #remove inline and extern functions
+    end
+  end
+
+  def parse_functions(source)
+    funcs = []
+    source.each {|line| funcs << line.strip.gsub(/\s+/, ' ') if (line =~ @declaration_parse_matcher)}
+    if funcs.empty?
+      case @when_no_prototypes
+        when :error
+          raise "ERROR: No function prototypes found!" 
+        when :warn
+          puts "WARNING: No function prototypes found!" unless (@verbosity < 1)
+      end
+    end
+    return funcs
+  end
+  
+  def parse_args(arg_list)
+    args = []
+    arg_list.split(',').each do |arg|
+      arg.strip! 
+      return args if (arg =~ /^\s*((\.\.\.)|(void))\s*$/)   # we're done if we reach void by itself or ...
+      arg_array = arg.split
+      arg_elements = arg_array - @c_attributes              # split up words and remove known attributes
+      args << { :type   => (arg_type =arg_elements[0..-2].join(' ')), 
+                :name   => arg_elements[-1], 
+                :ptr?   => divine_ptr(arg_type),
+                :const? => arg_array.include?('const')
+              }
+    end
+    return args
+  end
+
+  def divine_ptr(arg_type)
+    return false unless arg_type.include? '*'
+    return false if arg_type.gsub(/(const|char|\*|\s)+/,'').empty?
+    return true
+  end
+
+  def clean_args(arg_list)
+    if ((@local_as_void.include?(arg_list.strip)) or (arg_list.empty?))
+      return 'void'
+    else
+      c=0
+      arg_list.gsub!(/(\w+)(?:\s*\[[\s\d\w+-]*\])+/,'*\1')  # magically turn brackets into asterisks
+      arg_list.gsub!(/\s+\*/,'*')                           # remove space to place asterisks with type (where they belong)
+      arg_list.gsub!(/\*(\w)/,'* \1')                       # pull asterisks away from arg to place asterisks with type (where they belong)
+      
+      #scan argument list for function pointers and replace them with custom types
+      arg_list.gsub!(/([\w\s]+)\(*\(\s*\*([\w\s\*]+)\)\s*\(([\w\s\*,]*)\)\)*/) do |m|
+        functype = "cmock_#{@module_name}_func_ptr#{@typedefs.size + 1}"
+        funcret  = $1.strip
+        funcname = $2.strip
+        funcargs = $3.strip
+        funconst = ''
+        if (funcname.include? 'const')
+          funcname.gsub!('const','').strip!
+          funconst = 'const '
+        end
+        @typedefs << "typedef #{funcret}(*#{functype})(#{funcargs});"
+        funcname = "cmock_arg#{c+=1}" if (funcname.empty?)
+        "#{functype} #{funconst}#{funcname}"
+      end
+      
+      #automatically name unnamed arguments (those that only had a type)
+      arg_list.split(/\s*,\s*/).map { |arg| 
+        parts = (arg.split - ['struct', 'union', 'enum', 'const', 'const*'])
+        if ((parts.size < 2) or (parts[-1][-1].chr == '*') or (@standards.include?(parts[-1])))
+          "#{arg} cmock_arg#{c+=1}" 
+        else
+          arg
+        end
+      }.join(', ')
+    end
+  end
+  
+  def parse_declaration(declaration)
+    decl = {}
+    
+    regex_match = @declaration_parse_matcher.match(declaration)
+    raise "Failed parsing function declaration: '#{declaration}'" if regex_match.nil? 
+    
+    #grab argument list
+    args = regex_match[2].strip
+
+    #process function attributes, return type, and name
+    descriptors = regex_match[1]
+    descriptors.gsub!(/\s+\*/,'*')     #remove space to place asterisks with return type (where they belong)
+    descriptors.gsub!(/\*(\w)/,'* \1') #pull asterisks away from function name to place asterisks with return type (where they belong)
+    descriptors = descriptors.split    #array of all descriptor strings
+
+    #grab name
+    decl[:name] = descriptors[-1]      #snag name as last array item
+
+    #build attribute and return type strings
+    decl[:modifier] = []
+    rettype = []
+    descriptors[0..-2].each do |word|
+      if @c_attributes.include?(word)
+        decl[:modifier] << word
+      else
+        rettype << word
+      end
+    end
+    decl[:modifier] = decl[:modifier].join(' ')
+    rettype = rettype.join(' ')
+    rettype = 'void' if (@local_as_void.include?(rettype.strip))
+    decl[:return] = { :type   => rettype, 
+                      :name   => 'cmock_to_return', 
+                      :ptr?   => divine_ptr(rettype),
+                      :const? => rettype.split(/\s/).include?('const'),
+                      :str    => "#{rettype} cmock_to_return",
+                      :void?  => (rettype == 'void')
+                    }
+        
+    #remove default argument statements from mock definitions
+    args.gsub!(/=\s*[a-zA-Z0-9_\.]+\s*/, ' ')
+    
+    #check for var args
+    if (args =~ /\.\.\./)
+      decl[:var_arg] = args.match( /[\w\s]*\.\.\./ ).to_s.strip
+      if (args =~ /\,[\w\s]*\.\.\./)
+        args = args.gsub!(/\,[\w\s]*\.\.\./,'')
+      else
+        args = 'void'
+      end
+    else
+      decl[:var_arg] = nil
+    end
+    args = clean_args(args)
+    decl[:args_string] = args
+    decl[:args] = parse_args(args)
+    decl[:args_call] = decl[:args].map{|a| a[:name]}.join(', ')
+    decl[:contains_ptr?] = decl[:args].inject(false) {|ptr, arg| arg[:ptr?] ? true : ptr }
+      
+    if (decl[:return][:type].nil?   or decl[:name].nil?   or decl[:args].nil? or
+        decl[:return][:type].empty? or decl[:name].empty?)
+      raise "Failed Parsing Declaration Prototype!\n" +
+        "  declaration: '#{declaration}'\n" +
+        "  modifier: '#{decl[:modifier]}'\n" +
+        "  return: #{prototype_inspect_hash(decl[:return])}\n" +
+        "  function: '#{decl[:name]}'\n" +
+        "  args: #{prototype_inspect_array_of_hashes(decl[:args])}\n"
+    end
+
+    return decl
+  end
+
+  def prototype_inspect_hash(hash)
+    pairs = []
+    hash.each_pair { |name, value| pairs << ":#{name} => #{"'" if (value.class == String)}#{value}#{"'" if (value.class == String)}" }
+    return "{#{pairs.join(', ')}}"
+  end
+
+  def prototype_inspect_array_of_hashes(array)
+    hashes = []
+    array.each { |hash| hashes << prototype_inspect_hash(hash) }
+    case (array.size)
+    when 0
+      return "[]"
+    when 1
+      return "[#{hashes[0]}]"
+    else
+      return "[\n    #{hashes.join("\n    ")}\n  ]\n"
+    end
+  end
+
+end

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_plugin_manager.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_plugin_manager.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_plugin_manager.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_plugin_manager.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,40 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+class CMockPluginManager
+
+  attr_accessor :plugins
+  
+  def initialize(config, utils)
+    @plugins = []
+    plugins_to_load = ["expect", config.plugins].flatten.uniq.compact
+    plugins_to_load.each do |plugin|
+      plugin_name = plugin.to_s
+      object_name = "CMockGeneratorPlugin" + camelize(plugin_name)
+      begin
+        unless (Object.const_defined? object_name)
+          require "#{File.expand_path(File.dirname(__FILE__))}/cmock_generator_plugin_#{plugin_name.downcase}.rb"
+        end
+        @plugins << eval("#{object_name}.new(config, utils)")
+      rescue
+        raise "ERROR: CMock unable to load plugin '#{plugin_name}'"
+      end
+    end
+    @plugins.sort! {|a,b| a.priority <=> b.priority }
+  end
+  
+  def run(method, args=nil)
+    if args.nil?
+      return @plugins.collect{ |plugin| plugin.send(method) if plugin.respond_to?(method) }.flatten.join
+    else
+      return @plugins.collect{ |plugin| plugin.send(method, args) if plugin.respond_to?(method) }.flatten.join
+    end
+  end
+  
+  def camelize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+end

Added: incubator/celix/trunk/cmake/cmock/lib/cmock_unityhelper_parser.rb
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/cmock_unityhelper_parser.rb?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/lib/cmock_unityhelper_parser.rb (added)
+++ incubator/celix/trunk/cmake/cmock/lib/cmock_unityhelper_parser.rb Wed Oct  2 09:01:20 2013
@@ -0,0 +1,74 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+class CMockUnityHelperParser
+  
+  attr_accessor :c_types
+  
+  def initialize(config)
+    @config = config
+    @fallback = @config.plugins.include?(:array) ? 'UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY' : 'UNITY_TEST_ASSERT_EQUAL_MEMORY'
+    @c_types = map_C_types.merge(import_source)
+  end
+
+  def get_helper(ctype)
+    lookup = ctype.gsub(/(?:^|(\S?)(\s*)|(\W))const(?:$|(\s*)(\S)|(\W))/,'\1\3\5\6').strip.gsub(/\s+/,'_')
+    return [@c_types[lookup], ''] if (@c_types[lookup])
+    if (lookup =~ /\*$/)
+      lookup = lookup.gsub(/\*$/,'')
+      return [@c_types[lookup], '*'] if (@c_types[lookup])
+    else
+      lookup = lookup + '*'
+      return [@c_types[lookup], '&'] if (@c_types[lookup])
+    end
+    return ['UNITY_TEST_ASSERT_EQUAL_PTR', ''] if (ctype =~ /cmock_\w+_ptr\d+/)
+    raise("Don't know how to test #{ctype} and memory tests are disabled!") unless @config.memcmp_if_unknown
+    return (lookup =~ /\*$/) ? [@fallback, '&'] : [@fallback, '']
+  end
+  
+  private ###########################
+  
+  def map_C_types
+    c_types = {}
+    @config.treat_as.each_pair do |ctype, expecttype|
+      if (expecttype =~ /\*/)
+        c_types[ctype.gsub(/\s+/,'_')] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype.gsub(/\*/,'')}_ARRAY"
+      else
+        c_types[ctype.gsub(/\s+/,'_')] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype}"
+        c_types[ctype.gsub(/\s+/,'_')+'*'] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype}_ARRAY"
+      end
+    end
+    c_types
+  end
+  
+  def import_source
+    source = @config.load_unity_helper
+    return {} if source.nil?
+    c_types = {}
+    source = source.gsub(/\/\/.*$/, '') #remove line comments
+    source = source.gsub(/\/\*.*?\*\//m, '') #remove block comments
+     
+    #scan for comparison helpers
+    match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+))\s*\(' + Array.new(4,'\s*\w+\s*').join(',') + '\)')
+    pairs = source.scan(match_regex).flatten.compact
+    (pairs.size/2).times do |i|
+      expect = pairs[i*2]
+      ctype = pairs[(i*2)+1]
+      c_types[ctype] = expect unless expect.include?("_ARRAY")
+    end
+      
+    #scan for array variants of those helpers
+    match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+_ARRAY))\s*\(' + Array.new(5,'\s*\w+\s*').join(',') + '\)')
+    pairs = source.scan(match_regex).flatten.compact
+    (pairs.size/2).times do |i|
+      expect = pairs[i*2]
+      ctype = pairs[(i*2)+1]
+      c_types[ctype.gsub('_ARRAY','*')] = expect
+    end
+    
+    c_types
+  end
+end

Added: incubator/celix/trunk/cmake/cmock/lib/test.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/lib/test.h?rev=1528380&view=auto
==============================================================================
    (empty)

Added: incubator/celix/trunk/cmake/cmock/src/cmock.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/src/cmock.c?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/src/cmock.c (added)
+++ incubator/celix/trunk/cmake/cmock/src/cmock.c Wed Oct  2 09:01:20 2013
@@ -0,0 +1,186 @@
+/* ==========================================
+    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]
+========================================== */
+
+#include "unity.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  ((sizeof(CMOCK_MEM_INDEX_TYPE) > CMOCK_MEM_ALIGN_SIZE) ? sizeof(CMOCK_MEM_INDEX_TYPE) : CMOCK_MEM_ALIGN_SIZE)
+
+//private variables
+#ifdef CMOCK_MEM_DYNAMIC
+static unsigned char*         CMock_Guts_Buffer = NULL;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_ALIGN_SIZE;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr;
+#else
+static unsigned char          CMock_Guts_Buffer[CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE];
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr;
+#endif
+//-------------------------------------------------------
+// CMock_Guts_MemNew
+//-------------------------------------------------------
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size)
+{
+  CMOCK_MEM_INDEX_TYPE index;
+
+  //verify arguments valid (we must be allocating space for at least 1 byte, and the existing chain must be in memory somewhere)
+  if (size < 1)
+    return CMOCK_GUTS_NONE;
+
+  //verify we have enough room
+  size = size + CMOCK_MEM_INDEX_SIZE;
+  if (size & CMOCK_MEM_ALIGN_MASK)
+    size = (size + CMOCK_MEM_ALIGN_MASK) & ~CMOCK_MEM_ALIGN_MASK;
+  if ((CMock_Guts_BufferSize - CMock_Guts_FreePtr) < size)
+  {
+#ifdef CMOCK_MEM_DYNAMIC
+    CMock_Guts_BufferSize += CMOCK_MEM_SIZE + size;
+    CMock_Guts_Buffer = realloc(CMock_Guts_Buffer, CMock_Guts_BufferSize);
+    if (CMock_Guts_Buffer == NULL)
+#endif //yes that if will continue to the return below if TRUE
+      return CMOCK_GUTS_NONE;
+  }
+
+  //determine where we're putting this new block, and init its pointer to be the end of the line
+  index = CMock_Guts_FreePtr + CMOCK_MEM_INDEX_SIZE;
+  *(CMOCK_MEM_INDEX_TYPE*)(&CMock_Guts_Buffer[CMock_Guts_FreePtr]) = CMOCK_GUTS_NONE;
+  CMock_Guts_FreePtr += size;
+
+  return index;
+}
+
+//-------------------------------------------------------
+// CMock_Guts_MemChain
+//-------------------------------------------------------
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemChain(CMOCK_MEM_INDEX_TYPE root_index, CMOCK_MEM_INDEX_TYPE obj_index)
+{
+  CMOCK_MEM_INDEX_TYPE index;
+  void* root;
+  void* obj;
+  void* next;
+
+  if (root_index == CMOCK_GUTS_NONE)
+  {
+    //if there is no root currently, we return this object as the root of the chain
+    return obj_index;
+  }
+  else
+  {
+    //reject illegal nodes
+    if ((root_index < CMOCK_MEM_ALIGN_SIZE) || (root_index >= CMock_Guts_FreePtr))
+    {
+      return CMOCK_GUTS_NONE;
+    }
+    if ((obj_index < CMOCK_MEM_ALIGN_SIZE) || (obj_index >= CMock_Guts_FreePtr))
+    {
+      return CMOCK_GUTS_NONE;
+    }
+    
+    root = (void*)(&CMock_Guts_Buffer[root_index]);
+    obj  = (void*)(&CMock_Guts_Buffer[obj_index]);
+
+    //find the end of the existing chain and add us
+    next = root;
+    do {
+      index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE);
+      if (index >= CMock_Guts_FreePtr)
+        return CMOCK_GUTS_NONE;
+      if (index > 0)
+        next = (void*)(&CMock_Guts_Buffer[index]);
+    } while (index > 0);
+    *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE) = ((CMOCK_MEM_PTR_AS_INT)obj - (CMOCK_MEM_PTR_AS_INT)CMock_Guts_Buffer);
+    return root_index;
+  }
+}
+
+//-------------------------------------------------------
+// CMock_Guts_MemNext
+//-------------------------------------------------------
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNext(CMOCK_MEM_INDEX_TYPE previous_item_index)
+{
+  CMOCK_MEM_INDEX_TYPE index;
+  void* previous_item;
+
+  //There is nothing "next" if the pointer isn't from our buffer
+  if ((previous_item_index < CMOCK_MEM_ALIGN_SIZE) || (previous_item_index  >= CMock_Guts_FreePtr))
+    return CMOCK_GUTS_NONE;
+  previous_item = (void*)(&CMock_Guts_Buffer[previous_item_index]);
+
+  //if the pointer is good, then use it to look up the next index
+  //(we know the first element always goes in zero, so NEXT must always be > 1)
+  index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)previous_item - CMOCK_MEM_INDEX_SIZE);
+  if ((index > 1) && (index < CMock_Guts_FreePtr))
+    return index;
+  else
+    return CMOCK_GUTS_NONE;
+}
+
+//-------------------------------------------------------
+// CMock_GetAddressFor
+//-------------------------------------------------------
+void* CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index)
+{
+  if ((index >= CMOCK_MEM_ALIGN_SIZE) && (index < CMock_Guts_FreePtr))
+  {
+    return (void*)(&CMock_Guts_Buffer[index]);
+  }
+  else
+  {
+    return NULL;
+  }
+}
+
+//-------------------------------------------------------
+// CMock_Guts_MemBytesFree
+//-------------------------------------------------------
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesFree(void)
+{
+  return CMock_Guts_BufferSize - CMock_Guts_FreePtr;
+}
+
+//-------------------------------------------------------
+// CMock_Guts_MemBytesUsed
+//-------------------------------------------------------
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesUsed(void)
+{
+  return CMock_Guts_FreePtr - CMOCK_MEM_ALIGN_SIZE;
+}
+
+//-------------------------------------------------------
+// CMock_Guts_MemFreeAll
+//-------------------------------------------------------
+void CMock_Guts_MemFreeAll(void)
+{
+  CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE; //skip the very beginning
+}

Added: incubator/celix/trunk/cmake/cmock/src/cmock.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/src/cmock.h?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/src/cmock.h (added)
+++ incubator/celix/trunk/cmake/cmock/src/cmock.h Wed Oct  2 09:01:20 2013
@@ -0,0 +1,30 @@
+/* ==========================================
+    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_H
+#define CMOCK_FRAMEWORK_H
+
+//should be big enough to index full range of CMOCK_MEM_MAX
+#ifndef CMOCK_MEM_INDEX_TYPE
+#define CMOCK_MEM_INDEX_TYPE  unsigned int
+#endif
+
+#define CMOCK_GUTS_NONE (0)
+
+//-------------------------------------------------------
+// Memory API
+//-------------------------------------------------------
+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);
+
+void*                 CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index);
+
+CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemBytesFree(void);
+CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemBytesUsed(void);
+void                  CMock_Guts_MemFreeAll(void);
+
+#endif //CMOCK_FRAMEWORK

Added: incubator/celix/trunk/cmake/cmock/test.yml
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/cmake/cmock/test.yml?rev=1528380&view=auto
==============================================================================
--- incubator/celix/trunk/cmake/cmock/test.yml (added)
+++ incubator/celix/trunk/cmake/cmock/test.yml Wed Oct  2 09:01:20 2013
@@ -0,0 +1,4 @@
+:cmock: 
+    :attributes: 
+    - UTILS_EXPORT
+    :mock_path: .
\ No newline at end of file



Mime
View raw message