ceedling 0.17.0 → 0.18.0

data/vendor/cmock/test/unit/cmock_plugin_manager_test.rb

@@ -2,27 +2,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]
-# ========================================== 
+# ==========================================
 
 require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
 require 'cmock_plugin_manager'
+require 'cmock_generator_plugin_expect'
+require 'cmock_generator_plugin_ignore'
+require 'cmock_generator_plugin_cexception'
+
+describe CMockPluginManager, "Verify CMockPluginManager Module" do
 
-class CMockPluginManagerTest < Test::Unit::TestCase
-  def setup
-    create_mocks :config, :utils, :pluginA, :pluginB
-    @config.stubs!(:respond_to?).returns(true)
-    @config.stubs!(:when_ptr).returns(:compare_data)
-    @config.stubs!(:enforce_strict_ordering).returns(false)
-    @config.stubs!(:ignore).returns(:args_and_calls)
+  before do
+    create_mocks :utils, :pluginA, :pluginB
+    @config = create_stub(
+      :respond_to => true,
+      :when_ptr => :compare_data,
+      :enforce_strict_ordering => false,
+      :ignore => :args_and_calls
+    )
+
+    #if (RUBY_VERSION.split('.')[0].to_i >= 2)
+    #  @config.define_singleton_method( :plugins ){ @plugins || [] }
+    #  @config.define_singleton_method( :plugins= ){ |val| @plugins = val }
+    #else
+      eval "class << @config\ndef plugins\n@plugins||[]\nend\ndef plugins=(val)\n@plugins=val\nend\nend\n"
+    #end
   end
 
-  def teardown
+  after do
   end
-  
-  should "return all plugins by default" do
-    @config.expect.plugins.returns(['cexception','ignore'])
-    @utils.expect.helpers.returns({})
-    
+
+  it "return all plugins by default" do
+    @config.plugins = ['cexception','ignore']
+    @utils.expect :helpers, {}
+
     @cmock_plugins = CMockPluginManager.new(@config, @utils)
 
     test_plugins = @cmock_plugins.plugins
@@ -36,13 +49,12 @@ class CMockPluginManagerTest < Test::Unit::TestCase
     assert_equal(true, contained[:ignore])
     assert_equal(true, contained[:cexception])
   end
-  
-  should "return restricted plugins based on config" do
-    @config.expect.plugins.returns([])
-    @utils.expect.helpers.returns({})
-    
+
+  it "return restricted plugins based on config" do
+    @utils.expect :helpers, {}
+
     @cmock_plugins = CMockPluginManager.new(@config, @utils)
-    
+
     test_plugins = @cmock_plugins.plugins
     contained = { :expect => false, :ignore => false, :cexception => false }
     test_plugins.each do |plugin|
@@ -54,30 +66,28 @@ class CMockPluginManagerTest < Test::Unit::TestCase
     assert_equal(false,contained[:ignore])
     assert_equal(false,contained[:cexception])
   end
-  
-  should "run a desired method over each plugin requested and return the results" do
-    @config.expect.plugins.returns([])
-    @utils.expect.helpers.returns({})
+
+  it "run a desired method over each plugin requested and return the results" do
+    @utils.expect :helpers, {}
     @cmock_plugins = CMockPluginManager.new(@config, @utils)
-    
+
+    @pluginA = create_stub(:test_method => ["This Is An Awesome Test-"])
+    @pluginB = create_stub(:test_method => ["And This is Part 2-","Of An Awesome Test"])
     @cmock_plugins.plugins = [@pluginA, @pluginB]
-    @pluginA.stubs!(:test_method).returns(["This Is An Awesome Test-"])
-    @pluginB.stubs!(:test_method).returns(["And This is Part 2-","Of An Awesome Test"])
-    
+
     expected = "This Is An Awesome Test-And This is Part 2-Of An Awesome Test"
     output   = @cmock_plugins.run(:test_method)
     assert_equal(expected, output)
   end
-  
-  should "run a desired method and arg list over each plugin requested and return the results" do
-    @config.expect.plugins.returns([])
-    @utils.expect.helpers.returns({})
+
+  it "run a desired method and arg list over each plugin requested and return the results" do
+    @utils.expect :helpers, {}
     @cmock_plugins = CMockPluginManager.new(@config, @utils)
-    
+
+    @pluginA = create_stub(:test_method => ["This Is An Awesome Test-"])
+    @pluginB = create_stub(:test_method => ["And This is Part 2-","Of An Awesome Test"])
     @cmock_plugins.plugins = [@pluginA, @pluginB]
-    @pluginA.stubs!(:test_method).returns(["This Is An Awesome Test-"])
-    @pluginB.stubs!(:test_method).returns(["And This is Part 2-","Of An Awesome Test"])
-    
+
     expected = "This Is An Awesome Test-And This is Part 2-Of An Awesome Test"
     output   = @cmock_plugins.run(:test_method, "chickenpotpie")
     assert_equal(expected, output)

data/vendor/cmock/test/unit/cmock_unityhelper_parser_test.rb

@@ -2,50 +2,50 @@
 #   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]
-# ========================================== 
+# ==========================================
 
 require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
 require 'cmock_unityhelper_parser'
 
-class CMockUnityHelperParserTest < Test::Unit::TestCase
+describe CMockUnityHelperParser, "Verify CMockUnityHelperParser Module" do
 
-  def setup
+  before do
     create_mocks :config
   end
 
-  def teardown
+  after do
   end
-    
-  should "ignore lines that are commented out" do
-    source = 
+
+  it "ignore lines that are commented out" do
+    source =
       " abcd;\n" +
       "// #define UNITY_TEST_ASSERT_EQUAL_CHICKENS(a,b,line,msg) {...};\n" +
       "or maybe // #define UNITY_TEST_ASSERT_EQUAL_CHICKENS(a,b,line,msg) {...};\n\n"
-    @config.expects.plugins.returns([]) #not :array
-    @config.expects.treat_as.returns({})
-    @config.expects.load_unity_helper.returns(source)
+    @config.expect :plugins, [] #not :array
+    @config.expect :treat_as, {}
+    @config.expect :load_unity_helper, source
     @parser = CMockUnityHelperParser.new(@config)
     expected = {}
-    
+
     assert_equal(expected, @parser.c_types)
   end
-  
-  should "ignore stuff in block comments" do
-    source = 
+
+  it "ignore stuff in block comments" do
+    source =
       " abcd; /*\n" +
       "#define UNITY_TEST_ASSERT_EQUAL_CHICKENS(a,b,line,msg) {...};\n" +
       "#define UNITY_TEST_ASSERT_EQUAL_CHICKENS(a,b,line,msg) {...};\n */\n"
-    @config.expects.plugins.returns([]) #not :array
-    @config.expects.treat_as.returns({})
-    @config.expect.load_unity_helper.returns(source)
+    @config.expect :plugins, [] #not :array
+    @config.expect :treat_as, {}
+    @config.expect :load_unity_helper, source
     @parser = CMockUnityHelperParser.new(@config)
     expected = {}
-    
+
     assert_equal(expected, @parser.c_types)
   end
-  
-  should "notice equal helpers in the proper form and ignore others" do
-    source = 
+
+  it "notice equal helpers in the proper form and ignore others" do
+    source =
       "abcd;\n" +
       "#define UNITY_TEST_ASSERT_EQUAL_TURKEYS_T(a,b,line,msg) {...};\n" +
       "abcd;\n" +
@@ -53,20 +53,20 @@ class CMockUnityHelperParserTest < Test::Unit::TestCase
       "#define UNITY_TEST_ASSERT_WRONG_NAME_EQUAL(a,b,c,d) {...};\n" +
       "#define UNITY_TEST_ASSERT_EQUAL_unsigned_funky_rabbits(a,b,c,d) {...};\n" +
       "abcd;\n"
-    @config.expects.plugins.returns([]) #not :array
-    @config.expects.treat_as.returns({})
-    @config.expect.load_unity_helper.returns(source)
+    @config.expect :plugins, [] #not :array
+    @config.expect :treat_as, {}
+    @config.expect :load_unity_helper, source
     @parser = CMockUnityHelperParser.new(@config)
     expected = {
       'TURKEYS_T' => "UNITY_TEST_ASSERT_EQUAL_TURKEYS_T",
       'unsigned_funky_rabbits' => "UNITY_TEST_ASSERT_EQUAL_unsigned_funky_rabbits"
     }
-    
+
     assert_equal(expected, @parser.c_types)
   end
 
-  should "notice equal helpers that contain arrays" do
-    source = 
+  it "notice equal helpers that contain arrays" do
+    source =
       "abcd;\n" +
       "#define UNITY_TEST_ASSERT_EQUAL_TURKEYS_ARRAY(a,b,c,d,e) {...};\n" +
       "abcd;\n" +
@@ -74,19 +74,19 @@ class CMockUnityHelperParserTest < Test::Unit::TestCase
       "#define UNITY_TEST_ASSERT_WRONG_NAME_EQUAL_ARRAY(a,b,c,d,e) {...};\n" +
       "#define UNITY_TEST_ASSERT_EQUAL_unsigned_funky_rabbits_ARRAY(a,b,c,d,e) {...};\n" +
       "abcd;\n"
-    @config.expects.plugins.returns([]) #not :array
-    @config.expects.treat_as.returns({})
-    @config.expect.load_unity_helper.returns(source)
+    @config.expect :plugins, [] #not :array
+    @config.expect :treat_as, {}
+    @config.expect :load_unity_helper, source
     @parser = CMockUnityHelperParser.new(@config)
     expected = {
       'TURKEYS*' => "UNITY_TEST_ASSERT_EQUAL_TURKEYS_ARRAY",
       'unsigned_funky_rabbits*' => "UNITY_TEST_ASSERT_EQUAL_unsigned_funky_rabbits_ARRAY"
     }
-    
+
     assert_equal(expected, @parser.c_types)
   end
 
-  should "pull in the standard set of helpers and add them to my list" do
+  it "pull in the standard set of helpers and add them to my list" do
     pairs = {
       "UINT"          => "HEX32",
       "unsigned long" => "HEX64",
@@ -97,15 +97,15 @@ class CMockUnityHelperParserTest < Test::Unit::TestCase
       "UINT*"         => "UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY",
       "unsigned_long*"=> "UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY",
     }
-    @config.expects.plugins.returns([]) #not :array
-    @config.expects.treat_as.returns(pairs)
-    @config.expect.load_unity_helper.returns(nil)
+    @config.expect :plugins, [] #not :array
+    @config.expect :treat_as, pairs
+    @config.expect :load_unity_helper, nil
     @parser = CMockUnityHelperParser.new(@config)
-    
+
     assert_equal(expected, @parser.c_types)
   end
-  
-  should "pull in the user specified set of helpers and add them to my list" do
+
+  it "pull in the user specified set of helpers and add them to my list" do
     pairs = {
       "char*"         => "STRING",
       "unsigned  int" => "HEX32",
@@ -116,18 +116,18 @@ class CMockUnityHelperParserTest < Test::Unit::TestCase
       "char**"        => "UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY",
       "unsigned_int*" => "UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY",
     }
-    @config.expects.plugins.returns([]) #not :array
-    @config.expects.treat_as.returns(pairs)
-    @config.expect.load_unity_helper.returns(nil)
+    @config.expect :plugins, [] #not :array
+    @config.expect :treat_as, pairs
+    @config.expect :load_unity_helper, nil
     @parser = CMockUnityHelperParser.new(@config)
-    
+
     assert_equal(expected, @parser.c_types)
   end
-  
-  should "be able to fetch helpers on my list" do
-    @config.expects.plugins.returns([]) #not :array
-    @config.expects.treat_as.returns({})
-    @config.expect.load_unity_helper.returns("")
+
+  it "be able to fetch helpers on my list" do
+    @config.expect :plugins, [] #not :array
+    @config.expect :treat_as, {}
+    @config.expect :load_unity_helper, ""
     @parser = CMockUnityHelperParser.new(@config)
     @parser.c_types = {
       'UINT8'     => "UNITY_TEST_ASSERT_EQUAL_UINT8",
@@ -135,89 +135,89 @@ class CMockUnityHelperParserTest < Test::Unit::TestCase
       'SPINACH'   => "UNITY_TEST_ASSERT_EQUAL_SPINACH",
       'LONG_LONG' => "UNITY_TEST_ASSERT_EQUAL_LONG_LONG"
     }
-  
+
     [["UINT8","UINT8"],
      ["UINT16*","UINT16_ARRAY"],
      ["const SPINACH","SPINACH"],
      ["LONG LONG","LONG_LONG"] ].each do |ctype, exptype|
-      assert_equal(["UNITY_TEST_ASSERT_EQUAL_#{exptype}",''], @parser.get_helper(ctype))  
+      assert_equal(["UNITY_TEST_ASSERT_EQUAL_#{exptype}",''], @parser.get_helper(ctype))
     end
   end
 
-  should "return memory comparison when asked to fetch helper of types not on my list" do
-    @config.expects.plugins.returns([]) #not :array
-    @config.expects.treat_as.returns({})
-    @config.expects.load_unity_helper.returns("")
+  it "return memory comparison when asked to fetch helper of types not on my list" do
+    @config.expect :plugins, [] #not :array
+    @config.expect :treat_as, {}
+    @config.expect :load_unity_helper, ""
     @parser = CMockUnityHelperParser.new(@config)
     @parser.c_types = {
       'UINT8'   => "UNITY_TEST_ASSERT_EQUAL_UINT8",
       'UINT16*' => "UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY",
       'SPINACH' => "UNITY_TEST_ASSERT_EQUAL_SPINACH",
     }
-  
+
     ["UINT32","SPINACH_T","SALAD","PINEAPPLE"].each do |ctype|
-      @config.expect.memcmp_if_unknown.returns(true)
-      assert_equal(["UNITY_TEST_ASSERT_EQUAL_MEMORY",'&'], @parser.get_helper(ctype))  
+      @config.expect :memcmp_if_unknown, true
+      assert_equal(["UNITY_TEST_ASSERT_EQUAL_MEMORY",'&'], @parser.get_helper(ctype))
     end
   end
 
-  should "return memory array comparison when asked to fetch helper of types not on my list" do
-    @config.expects.plugins.returns([:array])
-    @config.expects.treat_as.returns({})
-    @config.expects.load_unity_helper.returns("")
+  it "return memory array comparison when asked to fetch helper of types not on my list" do
+    @config.expect :plugins, [:array]
+    @config.expect :treat_as, {}
+    @config.expect :load_unity_helper, ""
     @parser = CMockUnityHelperParser.new(@config)
     @parser.c_types = {
       'UINT8'   => "UNITY_TEST_ASSERT_EQUAL_UINT8",
       'UINT16*' => "UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY",
       'SPINACH' => "UNITY_TEST_ASSERT_EQUAL_SPINACH",
     }
-  
+
     ["UINT32*","SPINACH_T*"].each do |ctype|
-      @config.expect.memcmp_if_unknown.returns(true)
-      assert_equal(["UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY",''], @parser.get_helper(ctype))  
+      @config.expect :memcmp_if_unknown, true
+      assert_equal(["UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY",''], @parser.get_helper(ctype))
     end
   end
-  
-  should "return the array handler if we cannot find the normal handler" do
-    @config.expects.plugins.returns([]) #not :array
-    @config.expects.treat_as.returns({})
-    @config.expect.load_unity_helper.returns("")
+
+  it "return the array handler if we cannot find the normal handler" do
+    @config.expect :plugins, [] #not :array
+    @config.expect :treat_as, {}
+    @config.expect :load_unity_helper, ""
     @parser = CMockUnityHelperParser.new(@config)
     @parser.c_types = {
       'UINT8'   => "UNITY_TEST_ASSERT_EQUAL_UINT8",
       'UINT16*' => "UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY",
       'SPINACH' => "UNITY_TEST_ASSERT_EQUAL_SPINACH",
     }
-  
-      assert_equal(["UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY",'&'], @parser.get_helper("UINT16"))  
+
+      assert_equal(["UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY",'&'], @parser.get_helper("UINT16"))
   end
-  
-  should "return the normal handler if we cannot find the array handler" do
-    @config.expects.plugins.returns([]) #not :array
-    @config.expects.treat_as.returns({})
-    @config.expect.load_unity_helper.returns("")
+
+  it "return the normal handler if we cannot find the array handler" do
+    @config.expect :plugins, [] #not :array
+    @config.expect :treat_as, {}
+    @config.expect :load_unity_helper, ""
     @parser = CMockUnityHelperParser.new(@config)
     @parser.c_types = {
       'UINT8'   => "UNITY_TEST_ASSERT_EQUAL_UINT8",
       'UINT16'  => "UNITY_TEST_ASSERT_EQUAL_UINT16",
       'SPINACH' => "UNITY_TEST_ASSERT_EQUAL_SPINACH",
     }
-  
-      assert_equal(["UNITY_TEST_ASSERT_EQUAL_UINT8",'*'], @parser.get_helper("UINT8*"))  
+
+      assert_equal(["UNITY_TEST_ASSERT_EQUAL_UINT8",'*'], @parser.get_helper("UINT8*"))
   end
-  
-  should "raise error when asked to fetch helper of type not on my list and not allowed to mem check" do
-    @config.expects.plugins.returns([]) #not :array
-    @config.expects.treat_as.returns({})
-    @config.expect.load_unity_helper.returns("")
-    @config.expect.memcmp_if_unknown.returns(false)
+
+  it "raise error when asked to fetch helper of type not on my list and not allowed to mem check" do
+    @config.expect :plugins, [] #not :array
+    @config.expect :treat_as, {}
+    @config.expect :load_unity_helper, ""
+    @config.expect :memcmp_if_unknown, false
     @parser = CMockUnityHelperParser.new(@config)
     @parser.c_types = {
       'UINT8'   => "UNITY_TEST_ASSERT_EQUAL_UINT8",
       'UINT32*' => "UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY",
       'SPINACH' => "UNITY_TEST_ASSERT_EQUAL_SPINACH",
     }
-  
-    assert_raise(RuntimeError) { @parser.get_helper("UINT16") }
+
+    assert_raises (RuntimeError) { @parser.get_helper("UINT16") }
   end
 end

data/vendor/unity/auto/generate_test_runner.rb

@@ -17,6 +17,7 @@ class UnityTestRunnerGenerator
       when Hash     then @options.merge!(options)
       else          raise "If you specify arguments, it should be a filename or a hash of options"
     end
+    require "#{File.expand_path(File.dirname(__FILE__))}/type_sanitizer"
   end
 
   def self.default_options
@@ -190,7 +191,7 @@ class UnityTestRunnerGenerator
         output.puts("  GlobalOrderError = NULL;")
       end
       mocks.each do |mock|
-        mock_clean = mock.gsub(/(?:-|\s+)/, "_")
+        mock_clean = TypeSanitizer.sanitize_c_identifier(mock)
         output.puts("  #{mock_clean}_Init();")
       end
       output.puts("}\n")
@@ -198,7 +199,7 @@ class UnityTestRunnerGenerator
       output.puts("static void CMock_Verify(void)")
       output.puts("{")
       mocks.each do |mock|
-        mock_clean = mock.gsub(/(?:-|\s+)/, "_")
+        mock_clean = TypeSanitizer.sanitize_c_identifier(mock)
         output.puts("  #{mock_clean}_Verify();")
       end
       output.puts("}\n")
@@ -206,7 +207,7 @@ class UnityTestRunnerGenerator
       output.puts("static void CMock_Destroy(void)")
       output.puts("{")
       mocks.each do |mock|
-        mock_clean = mock.gsub(/(?:-|\s+)/, "_")
+        mock_clean = TypeSanitizer.sanitize_c_identifier(mock)
         output.puts("  #{mock_clean}_Destroy();")
       end
       output.puts("}\n")