ceedling 0.0.2 → 0.0.3

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

@@ -1,85 +0,0 @@
-# ==========================================
-#   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/new_project_template/vendor/ceedling/vendor/cmock/test/unit/cmock_unityhelper_parser_test.rb

@@ -1,223 +0,0 @@
-# ==========================================
-#   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/new_project_template/vendor/ceedling/vendor/cmock/vendor/behaviors/Manifest.txt

@@ -1,9 +0,0 @@
-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/new_project_template/vendor/ceedling/vendor/cmock/vendor/behaviors/Rakefile

@@ -1,19 +0,0 @@
-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/new_project_template/vendor/ceedling/vendor/cmock/vendor/behaviors/lib/behaviors.rb

@@ -1,76 +0,0 @@
-=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/new_project_template/vendor/ceedling/vendor/cmock/vendor/behaviors/lib/behaviors/reporttask.rb

@@ -1,158 +0,0 @@
-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