ceedling 0.13.0.rc1 → 0.13.0

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

@@ -0,0 +1,85 @@
+# ==========================================
+#   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'
+
+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)
+  end
+
+  def teardown
+  end
+  
+  should "return all plugins by default" do
+    @config.expect.plugins.returns(['cexception','ignore'])
+    @utils.expect.helpers.returns({})
+    
+    @cmock_plugins = CMockPluginManager.new(@config, @utils)
+
+    test_plugins = @cmock_plugins.plugins
+    contained = { :expect => false, :ignore => false, :cexception => false }
+    test_plugins.each do |plugin|
+      contained[:expect]     = true   if plugin.instance_of?(CMockGeneratorPluginExpect)
+      contained[:ignore]     = true   if plugin.instance_of?(CMockGeneratorPluginIgnore)
+      contained[:cexception] = true   if plugin.instance_of?(CMockGeneratorPluginCexception)
+    end
+    assert_equal(true, contained[:expect])
+    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({})
+    
+    @cmock_plugins = CMockPluginManager.new(@config, @utils)
+    
+    test_plugins = @cmock_plugins.plugins
+    contained = { :expect => false, :ignore => false, :cexception => false }
+    test_plugins.each do |plugin|
+      contained[:expect]     = true   if plugin.instance_of?(CMockGeneratorPluginExpect)
+      contained[:ignore]     = true   if plugin.instance_of?(CMockGeneratorPluginIgnore)
+      contained[:cexception] = true   if plugin.instance_of?(CMockGeneratorPluginCexception)
+    end
+    assert_equal(true, contained[:expect])
+    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({})
+    @cmock_plugins = CMockPluginManager.new(@config, @utils)
+    
+    @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({})
+    @cmock_plugins = CMockPluginManager.new(@config, @utils)
+    
+    @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)
+  end
+end

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

@@ -0,0 +1,223 @@
+# ==========================================
+#   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
+
+  def setup
+    create_mocks :config
+  end
+
+  def teardown
+  end
+    
+  should "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)
+    @parser = CMockUnityHelperParser.new(@config)
+    expected = {}
+    
+    assert_equal(expected, @parser.c_types)
+  end
+  
+  should "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)
+    @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 = 
+      "abcd;\n" +
+      "#define UNITY_TEST_ASSERT_EQUAL_TURKEYS_T(a,b,line,msg) {...};\n" +
+      "abcd;\n" +
+      "#define UNITY_TEST_ASSERT_EQUAL_WRONG_NUM_ARGS(a,b,c,d,e) {...};\n" +
+      "#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)
+    @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 = 
+      "abcd;\n" +
+      "#define UNITY_TEST_ASSERT_EQUAL_TURKEYS_ARRAY(a,b,c,d,e) {...};\n" +
+      "abcd;\n" +
+      "#define UNITY_TEST_ASSERT_EQUAL_WRONG_NUM_ARGS_ARRAY(a,b,c,d,e,f) {...};\n" +
+      "#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)
+    @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
+    pairs = {
+      "UINT"          => "HEX32",
+      "unsigned long" => "HEX64",
+    }
+    expected = {
+      "UINT"          => "UNITY_TEST_ASSERT_EQUAL_HEX32",
+      "unsigned_long" => "UNITY_TEST_ASSERT_EQUAL_HEX64",
+      "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)
+    @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
+    pairs = {
+      "char*"         => "STRING",
+      "unsigned  int" => "HEX32",
+    }
+    expected = {
+      "char*"         => "UNITY_TEST_ASSERT_EQUAL_STRING",
+      "unsigned_int"  => "UNITY_TEST_ASSERT_EQUAL_HEX32",
+      "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)
+    @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("")
+    @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",
+      '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))  
+    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("")
+    @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))  
+    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("")
+    @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))  
+    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("")
+    @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"))  
+  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("")
+    @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*"))  
+  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)
+    @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") }
+  end
+end

data/vendor/cmock/vendor/behaviors/Manifest.txt

@@ -0,0 +1,9 @@
+Manifest.txt
+Rakefile
+lib/behaviors.rb
+lib/behaviors/reporttask.rb
+test/behaviors_tasks_test.rb
+test/behaviors_test.rb
+test/tasks_test/lib/user.rb
+test/tasks_test/Rakefile
+test/tasks_test/test/user_test.rb

data/vendor/cmock/vendor/behaviors/Rakefile

@@ -0,0 +1,19 @@
+require 'rake'
+require 'rubygems'
+require 'hoe'
+
+Hoe.new('behaviors','1.0.3') do |p|
+  p.author = "Atomic Object LLC" 
+  p.email = "dev@atomicobject.com" 
+  p.url = "http://behaviors.rubyforge.org" 
+  p.summary = "behavior-driven unit test helper" 
+  p.description = <<-EOS
+Behaviors allows for Test::Unit test case methods to be defined as 
+human-readable descriptions of program behavior. It also provides 
+Rake tasks to list the behaviors of your project.
+  EOS
+  p.test_globs = ['test/*_test.rb']
+
+  p.changes = <<-EOS
+  EOS
+end

data/vendor/cmock/vendor/behaviors/lib/behaviors.rb

@@ -0,0 +1,76 @@
+=begin rdoc
+= Usage
+Behaviors provides a single method: should.
+  
+Instead of naming test methods like:
+
+ def test_something
+ end
+
+You declare test methods like:
+
+ should "perform action" do
+ end
+
+You may omit the body of a <tt>should</tt> method to describe unimplemented behavior.
+
+ should "perform other action"
+
+When you run your unit tests, empty <tt>should</tt> methods will appear as an 'UNIMPLEMENTED CASE' along with the described behavior.
+This is useful for sketching out planned behavior quickly.
+
+Simply <tt>extend Behaviors</tt> in your <tt>TestCase</tt> to start using behaviors. 
+
+  require 'test/unit'
+  require 'behaviors'
+  require 'user'
+
+  class UserTest < Test::Unit::TestCase
+    extend Behaviors
+    ...
+  end
+
+= Motivation
+Test methods typically focus on the name of the method under test instead of its behavior.
+Creating test methods with <tt>should</tt> statements focuses on the behavior of an object.
+This helps you to think about the role of the object under test.
+
+Using a behavior-driven approach prevents the danger in assuming a one-to-one mapping of method names to 
+test method names.
+As always, you get the most value by writing the tests first.
+
+For a more complete BDD framework, try RSpec http://rspec.rubyforge.org/
+  
+= Rake tasks
+
+You can define a <tt>Behaviors::ReportTask</tt> in your <tt>Rakefile</tt> to generate rake tasks that
+summarize the behavior of your project.
+
+These tasks are named <tt>behaviors</tt> and <tt>behaviors_html</tt>. They will output to the
+console or an html file in the <tt>doc</tt> directory with a list all of your <tt>should</tt> tests.
+  Behaviors::ReportTask.new do |t|
+    t.pattern = 'test/**/*_test.rb'
+  end
+
+You may also initialize the <tt>ReportTask</tt> with a custom name to associate with a particular suite of tests.
+  Behaviors::ReportTask.new(:widget_subsystem) do |t|
+    t.pattern = 'test/widgets/*_test.rb'
+  end
+
+The html report will be placed in the <tt>doc</tt> directory by default.
+You can override this default by setting the <tt>html_dir</tt> in the <tt>ReportTask</tt>.
+  Behaviors::ReportTask.new do |t|
+    t.pattern = 'test/**/*_test.rb'
+    t.html_dir = 'behaviors_html_reports'
+  end
+=end
+module Behaviors
+  def should(behave,&block)
+    mname = "test_should_#{behave}"
+    if block
+      define_method mname, &block
+    else
+      puts ">>> UNIMPLEMENTED CASE: #{name.sub(/Test$/,'')} should #{behave}"
+    end
+  end
+end

data/vendor/cmock/vendor/behaviors/lib/behaviors/reporttask.rb

@@ -0,0 +1,158 @@
+require 'rake'
+require 'rake/tasklib'
+
+module Behaviors
+include Rake
+
+  class ReportTask < TaskLib
+    attr_accessor :pattern
+    attr_accessor :html_dir
+
+    def initialize(name=:behaviors)
+      @name = name
+      @html_dir = 'doc'
+      yield self if block_given?
+      define
+    end
+
+    def define
+      desc "List behavioral definitions for the classes specified (use for=<regexp> to further limit files included in report)"
+      task @name do
+        specifications.each do |spec|
+          puts "#{spec.name} should:\n"
+          spec.requirements.each do |req|
+            puts " - #{req}"
+          end
+        end
+      end
+
+      desc "Generate html report of behavioral definitions for the classes specified (use for=<regexp> to further limit files included in report)"
+      task "#{@name}_html" do
+        require 'erb'
+        txt =<<-EOS 
+<html>
+<head>
+<style>
+
+div.title
+{
+  width: 600px;
+  font: bold 14pt trebuchet ms;
+}
+
+div.specification 
+{
+  font: bold 12pt trebuchet ms;
+  border: solid 1px black;
+  width: 600px;
+  padding: 5px;
+  margin: 5px;
+}
+
+ul.requirements
+{
+  font: normal 11pt verdana;
+  padding-left: 0;
+  margin-left: 0;
+  border-bottom: 1px solid gray;
+  width: 600px;
+}
+
+ul.requirements li
+{
+  list-style: none;
+  margin: 0;
+  padding: 0.25em;
+  border-top: 1px solid gray;
+}
+</style>
+</head>
+<body>
+<div class="title">Specifications</div>
+<% specifications.each do |spec| %>
+<div class="specification">
+<%= spec.name %> should: 
+<ul class="requirements">
+<% spec.requirements.each do |req| %>
+<li><%= req %></li>
+<% end %>
+</ul>
+</div>
+<% end %>
+</body>
+</html>
+        EOS
+        output_dir = File.expand_path(@html_dir)
+        mkdir_p output_dir
+        output_filename = output_dir + "/behaviors.html"
+        File.open(output_filename,"w") do |f|
+          f.write ERB.new(txt).result(binding)
+        end
+        puts "(Wrote #{output_filename})"
+      end
+    end
+
+    private
+    def test_files
+      test_list = FileList[@pattern]
+      if ENV['for'] 
+        test_list = test_list.grep(/#{ENV['for']}/i)
+      end
+      test_list
+    end  
+
+    def specifications
+      test_files.map do |file|
+        spec = OpenStruct.new
+        m = %r".*/([^/].*)_test.rb".match(file)
+        class_name = titleize(m[1]) if m[1]
+        spec.name = class_name
+        spec.requirements = []
+        File::readlines(file).each do |line| 
+          if line =~ /^\s*should\s+\(?\s*["'](.*)["']/
+            spec.requirements << $1
+          end
+        end
+        spec
+      end
+    end
+
+    ############################################################
+    # STOLEN FROM inflector.rb
+    ############################################################
+    #--
+    # Copyright (c) 2005 David Heinemeier Hansson
+    #
+    # Permission is hereby granted, free of charge, to any person obtaining
+    # a copy of this software and associated documentation files (the
+    # "Software"), to deal in the Software without restriction, including
+    # without limitation the rights to use, copy, modify, merge, publish,
+    # distribute, sublicense, and/or sell copies of the Software, and to
+    # permit persons to whom the Software is furnished to do so, subject to
+    # the following conditions:
+    #
+    # The above copyright notice and this permission notice shall be
+    # included in all copies or substantial portions of the Software.
+    #
+    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+    #++
+    def titleize(word)
+      humanize(underscore(word)).gsub(/\b([a-z])/) { $1.capitalize }
+    end    
+
+    def underscore(camel_cased_word)    camel_cased_word.to_s.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+    end
+
+    def humanize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+    end
+
+  end
+end