ceedling 1.0.0 → 1.0.1

data/plugins/fake_function_framework/examples/fff_example/test/test_foo.c

@@ -1,47 +0,0 @@
-#include "unity.h"
-#include "foo.h"
-#include "mock_bar.h"
-#include "mock_zzz.h"
-
-void setUp(void)
-{
-}
-
-void tearDown(void)
-{
-}
-
-void test_foo(void)
-{
-	//When
-	foo_turn_on();
-
-	//Then
-	TEST_ASSERT_EQUAL(1, bar_turn_on_fake.call_count);
-	TEST_ASSERT_EQUAL(1, zzz_sleep_fake.call_count);
-	TEST_ASSERT_EQUAL_STRING("sleepy", zzz_sleep_fake.arg1_val);
-}
-
-void test_foo_again(void)
-{
-	//When
-	foo_turn_on();
-
-	//Then
-	TEST_ASSERT_EQUAL(1, bar_turn_on_fake.call_count);
-}
-
-void test_foo_mock_with_const(void)
-{
-	foo_print_message("123");
-
-	TEST_ASSERT_EQUAL(1, bar_print_message_fake.call_count);
-	TEST_ASSERT_EQUAL_STRING("123", bar_print_message_fake.arg0_val);
-}
-
-void test_foo_mock_with_variable_args(void)
-{
-	foo_print_special_message();
-	TEST_ASSERT_EQUAL(1, bar_print_message_formatted_fake.call_count);
-	TEST_ASSERT_EQUAL_STRING("The numbers are %d, %d and %d", bar_print_message_formatted_fake.arg0_val);
-}

data/plugins/fake_function_framework/lib/fake_function_framework.rb

@@ -1,87 +0,0 @@
-require 'ceedling/plugin'
-require 'fff_mock_generator'
-
-class FakeFunctionFramework < Plugin
-
-  # Set up Ceedling to use this plugin.
-  def setup
-    # Get the location of this plugin.
-    @plugin_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-    puts "Using fake function framework (fff)..."
-
-    # Switch out the cmock_builder with our own.
-    @ceedling[:cmock_builder].cmock = FffMockGeneratorForCMock.new(@ceedling[:setupinator].config_hash[:cmock])
-
-    # Add the path to fff.h to the include paths.
-    COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR << "#{@plugin_root}/vendor/fff"
-    COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR << "#{@plugin_root}/src"
-  end
-
-  def post_runner_generate(arg_hash)
-    # After the test runner file has been created, append the FFF globals
-    # definition to the end of the test runner. These globals will be shared by
-    # all mocks linked into the test.
-    File.open(arg_hash[:runner_file], 'a') do |f|
-      f.puts
-      f.puts "//=======Defintions of FFF variables====="
-      f.puts %{#include "fff.h"}
-      f.puts "DEFINE_FFF_GLOBALS;"
-    end
-  end
-
-end # class FakeFunctionFramework
-
-class FffMockGeneratorForCMock
-
-    def initialize(options=nil)
-    @cm_config      = CMockConfig.new(options)
-    @cm_parser      = CMockHeaderParser.new(@cm_config)
-    @silent        = (@cm_config.verbosity < 2)
-
-    # These are the additional files to include in the mock files.
-    @includes_h_pre_orig_header  = (@cm_config.includes || @cm_config.includes_h_pre_orig_header || []).map{|h| h =~ /</ ? h : "\"#{h}\""}
-    @includes_h_post_orig_header = (@cm_config.includes_h_post_orig_header || []).map{|h| h =~ /</ ? h : "\"#{h}\""}
-    @includes_c_pre_header       = (@cm_config.includes_c_pre_header || []).map{|h| h =~ /</ ? h : "\"#{h}\""}
-    @includes_c_post_header      = (@cm_config.includes_c_post_header || []).map{|h| h =~ /</ ? h : "\"#{h}\""}
-  end
-
-  def setup_mocks(files)
-    [files].flatten.each do |src|
-      generate_mock (src)
-    end
-  end
-
-  def generate_mock (header_file_to_mock)
-      module_name = File.basename(header_file_to_mock, '.h')
-      puts "Creating mock for #{module_name}..." unless @silent
-      mock_name = @cm_config.mock_prefix + module_name + @cm_config.mock_suffix
-      mock_path = @cm_config.mock_path
-      if @cm_config.subdir
-          # If a subdirectory has been configured, append it to the mock path.
-          mock_path = "#{mock_path}/#{@cm_config.subdir}"
-      end
-      full_path_for_mock = "#{mock_path}/#{mock_name}"
-
-      # Parse the header file so we know what to mock.
-      parsed_header = @cm_parser.parse(module_name, File.read(header_file_to_mock))
-
-      # Create the directory if it doesn't exist.
-      mkdir_p full_path_for_mock.pathmap("%d")
-
-      # Generate the mock header file.
-      puts "Creating mock: #{full_path_for_mock}.h"
-
-      # Create the mock header.
-      File.open("#{full_path_for_mock}.h", 'w') do |f|
-        f.write(FffMockGenerator.create_mock_header(module_name, mock_name, parsed_header,
-          @includes_h_pre_orig_header, @includes_h_post_orig_header))
-      end
-
-      # Create the mock source file.
-      File.open("#{full_path_for_mock}.c", 'w') do |f|
-        f.write(FffMockGenerator.create_mock_source(mock_name, parsed_header,
-          @includes_c_pre_orig_header, @includes_c_post_orig_header))
-      end
-  end
-
-end

data/plugins/fake_function_framework/lib/fff_mock_generator.rb

@@ -1,163 +0,0 @@
-# Creates mock files from parsed header files that can be linked into applications.
-# The mocks created are compatible with CMock for use with Ceedling.
-
-class FffMockGenerator
-
-  def self.create_mock_header(module_name, mock_name, parsed_header, pre_includes=nil,
-    post_includes=nil)
-    output = StringIO.new
-    write_opening_include_guard(mock_name, output)
-    output.puts
-    write_extra_includes(pre_includes, output)
-    write_header_includes(module_name, output)
-    write_extra_includes(post_includes, output)
-    output.puts
-    write_typedefs(parsed_header, output)
-    output.puts
-    write_function_declarations(parsed_header, output)
-    output.puts
-    write_control_function_prototypes(mock_name, output)
-    output.puts
-    write_closing_include_guard(mock_name, output)
-    output.string
-  end
-
-  def self.create_mock_source (mock_name, parsed_header, pre_includes=nil,
-    post_includes=nil)
-    output = StringIO.new
-    write_extra_includes(pre_includes, output)
-    write_source_includes(mock_name, output)
-    write_extra_includes(post_includes, output)
-    output.puts
-    write_function_definitions(parsed_header, output)
-    output.puts
-    write_control_function_definitions(mock_name, parsed_header, output)
-    output.string
-  end
-
-  private
-
-# Header file generation functions.
-
-  def self.write_opening_include_guard(mock_name, output)
-    output.puts "#ifndef #{mock_name}_H"
-    output.puts "#define #{mock_name}_H"
-  end
-
-  def self.write_header_includes(module_name, output)
-    output.puts %{#include "fff.h"}
-    output.puts %{#include "fff_unity_helper.h"}
-    output.puts %{#include "#{module_name}.h"}
-  end
-
-  def self.write_typedefs(parsed_header, output)
-    return unless parsed_header.key?(:typedefs)
-    parsed_header[:typedefs].each do |typedef|
-      output.puts typedef
-    end
-  end
-
-  def self.write_function_declarations(parsed_header, output)
-    write_function_macros("DECLARE", parsed_header, output)
-  end
-
-
-  def self.write_control_function_prototypes(mock_name, output)
-    output.puts "void #{mock_name}_Init(void);"
-    output.puts "void #{mock_name}_Verify(void);"
-    output.puts "void #{mock_name}_Destroy(void);"
-  end
-
-  def self.write_closing_include_guard(mock_name, output)
-    output.puts "#endif // #{mock_name}_H"
-  end
-
-# Source file generation functions.
-
-  def self.write_source_includes (mock_name, output)
-    output.puts "#include <string.h>"
-    output.puts %{#include "fff.h"}
-    output.puts %{#include "#{mock_name}.h"}
-  end
-
-  def self.write_function_definitions(parsed_header, output)
-    write_function_macros("DEFINE", parsed_header, output)
-  end
-
-  def self.write_control_function_definitions(mock_name, parsed_header, output)
-    output.puts "void #{mock_name}_Init(void)"
-    output.puts "{"
-    # In the init function, reset the FFF globals. These are used for things
-    # like the call history.
-    output.puts "    FFF_RESET_HISTORY();"
-    
-    # Also, reset all of the fakes.
-    if parsed_header[:functions]
-      parsed_header[:functions].each do |function|
-        output.puts "    RESET_FAKE(#{function[:name]})"
-      end
-    end
-    output.puts "}"
-    output.puts "void #{mock_name}_Verify(void)"
-    output.puts "{"
-    output.puts "}"
-    output.puts "void #{mock_name}_Destroy(void)"
-    output.puts "{"
-    output.puts "}"
-  end
-
-# Shared functions.
-
-  def self.write_extra_includes(includes, output)
-    if includes
-      includes.each {|inc| output.puts "#include #{inc}\n"}
-    end
-  end
-
-  def self.write_function_macros(macro_type, parsed_header, output)
-    return unless parsed_header.key?(:functions)
-    parsed_header[:functions].each do |function|
-      name = function[:name]
-      return_type = function[:return][:type]
-      if function.has_key? :modifier
-          # Prepend any modifier. If there isn't one, trim any leading whitespace.
-          return_type = "#{function[:modifier]} #{return_type}".lstrip
-      end
-      arg_count = function[:args].size
-
-      # Check for variable arguments.
-      var_arg_suffix = ""
-      if function[:var_arg]
-        # If there are are variable arguments, then we need to add this argument
-        # to the count, update the suffix that will get added to the macro.
-        arg_count += 1
-        var_arg_suffix = "_VARARG"
-      end
-
-      # Generate the correct macro.
-      if return_type == 'void'
-        output.print "#{macro_type}_FAKE_VOID_FUNC#{arg_count}#{var_arg_suffix}(#{name}"
-      else
-        output.print "#{macro_type}_FAKE_VALUE_FUNC#{arg_count}#{var_arg_suffix}(#{return_type}, #{name}"
-      end
-
-      # Append each argument type.
-      function[:args].each do |arg|
-        output.print ", "
-        if arg[:const?]
-          output.print "const "
-        end
-        output.print "#{arg[:type]}"
-      end
-
-      # If this argument list ends with a variable argument, add it here at the end.
-      if function[:var_arg]
-        output.print ", ..."
-      end
-
-      # Close the declaration.
-      output.puts ");"
-    end
-  end
-
-end

data/plugins/fake_function_framework/spec/fff_mock_header_generator_spec.rb

@@ -1,304 +0,0 @@
-require 'stringio'
-require 'fff_mock_generator.rb'
-require 'header_generator.rb'
-
-# Test the contents of the .h file created for the mock.
-describe "FffMockGenerator.create_mock_header" do
-
-  context "when there is nothing to mock," do
-    let(:mock_header) {
-      parsed_header = {}
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated header file starts with an opening include guard" do
-      expect(mock_header).to start_with(
-          "#ifndef mock_display_H\n" +
-          "#define mock_display_H")
-    end
-    it "then the generated file ends with a closing include guard" do
-      expect(mock_header).to end_with(
-          "#endif // mock_display_H\n")
-    end
-    it "then the generated file includes the fff header" do
-      expect(mock_header).to include(
-          %{#include "fff.h"\n})
-    end
-    it "then the generated file has a prototype for the init function" do
-      expect(mock_header).to include(
-          "void mock_display_Init(void);")
-    end
-    it "then the generated file has a prototype for the verify function" do
-      expect(mock_header).to include(
-          "void mock_display_Verify(void);")
-    end
-    it "then the generated file has a prototype for the destroy function" do
-      expect(mock_header).to include(
-          "void mock_display_Destroy(void);")
-    end
-  end
-
-  context "when there is a function with no args and a void return," do
-      let(:mock_header) {
-        parsed_header = create_cmock_style_parsed_header(
-          [{:name => 'display_turnOffStatusLed', :return_type => 'void'}])
-        FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-      }
-      it "then the generated header file starts with an opening include guard" do
-        expect(mock_header).to start_with(
-          "#ifndef mock_display_H\n" +
-          "#define mock_display_H")
-      end
-      it "then the generated header file contains a fake function declaration" do
-        expect(mock_header).to include(
-          "DECLARE_FAKE_VOID_FUNC0(display_turnOffStatusLed);"
-        )
-      end
-      it "then the generated file ends with a closing include guard" do
-          expect(mock_header).to end_with(
-              "#endif // mock_display_H\n")
-      end
-  end
-
-  context "when there is a function with no args and a bool return," do
-    let(:mock_header) {
-      parsed_header = create_cmock_style_parsed_header(
-        [{:name => 'display_isError', :return_type => 'bool'}])
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the fake function declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VALUE_FUNC0(bool, display_isError);"
-      )
-    end
-  end
-
-  context "when there is a function with no args and an int return," do
-    let(:mock_header) {
-      parsed_header = create_cmock_style_parsed_header(
-        [{:name => 'display_isError', :return_type => 'int'}])
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the fake function declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VALUE_FUNC0(int, display_isError);"
-      )
-    end
-  end
-
-  context "when there is a function with args and a void return," do
-    let(:mock_header) {
-      parsed_header = create_cmock_style_parsed_header(
-        [{:name => 'display_setVolume', :return_type => 'void', :args => ['int']}])
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the fake function declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VOID_FUNC1(display_setVolume, int);"
-      )
-    end
-  end
-
-  context "when there is a function with args and a value return," do
-    let(:mock_header) {
-      parsed_header = create_cmock_style_parsed_header(
-        [{:name => 'a_function', :return_type => 'int', :args => ['char *']}])
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the fake function declaration" do
-      expect(mock_header).to include(
-        "FAKE_VALUE_FUNC1(int, a_function, char *);"
-      )
-    end
-  end
-
-  context "when there is a function with many args and a void return," do
-    let(:mock_header) {
-      parsed_header = create_cmock_style_parsed_header(
-        [{:name => 'a_function', :return_type => 'void',
-          :args => ['int', 'char *', 'int', 'int', 'bool', 'applesauce']}])
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the fake function declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VOID_FUNC6(a_function, int, char *, int, int, bool, applesauce);"
-      )
-    end
-  end
-
-  context "when there are multiple functions," do
-    let(:mock_header) {
-      parsed_header = create_cmock_style_parsed_header(
-        [ {:name => 'a_function', :return_type => 'int', :args => ['char *']},
-          {:name => 'another_function', :return_type => 'void'},
-          {:name => 'three', :return_type => 'bool', :args => ['float', 'int']}
-        ])
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the first fake function declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VALUE_FUNC1(int, a_function, char *);"
-      )
-    end
-    it "then the generated file contains the second fake function declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VOID_FUNC0(another_function);"
-      )
-    end
-    it "then the generated file contains the third fake function declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VALUE_FUNC2(bool, three, float, int);"
-      )
-    end
-  end
-
-  context "when there is a typedef," do
-    let(:mock_header) {
-      parsed_header = create_cmock_style_parsed_header(
-        nil, ["typedef void (*displayCompleteCallback) (void);"])
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the typedef" do
-      expect(mock_header).to include(
-        "typedef void (*displayCompleteCallback) (void);"
-      )
-    end
-  end
-
-  context "when there is a void function with variable arguments" do
-    let(:mock_header){
-      parsed_header = {}
-      parsed_header[:functions] = [{
-        :name => "function_with_var_args",
-        :return => {:type => "void"},
-        :var_arg => "...",
-        :args => [{:type => 'char *'}]
-      }]
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the vararg declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VOID_FUNC2_VARARG(function_with_var_args, char *, ...)"
-      )
-    end
-  end
-
-  context "when there is a function with a return value and variable arguments" do
-    let(:mock_header){
-      parsed_header = {}
-      parsed_header[:functions] = [{
-        :name => "function_with_var_args",
-        :return => {:type => "int"},
-        :var_arg => "...",
-        :args => [{:type => 'char *'}]
-      }]
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the vararg declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VALUE_FUNC2_VARARG(int, function_with_var_args, char *, ...)"
-      )
-    end
-  end
-
-  context "when there is a void function with variable arguments and " +
-          "additional arguments" do
-    let(:mock_header){
-      parsed_header = {}
-      parsed_header[:functions] = [{
-        :name => "function_with_var_args",
-        :return => {:type => "void"},
-        :var_arg => "...",
-        :args => [{:type => 'char *'}, {:type => 'int'}]
-      }]
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the vararg declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VOID_FUNC3_VARARG(function_with_var_args, char *, int, ...)"
-      )
-    end
-  end
-
-  context "when there is a function with a pointer to a const value" do
-    let(:mock_header){
-      parsed_header = {}
-      parsed_header[:functions] = [{
-        :name => "const_test_function",
-        :return => {:type => "void"},
-        :args => [{:type => "char *", :name => "a", :ptr? => false, :const? => true},
-                  {:type => "char *", :name => "b", :ptr? => false, :const? => false}]
-      }]
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the correct const argument in the declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VOID_FUNC2(const_test_function, const char *, char *)"
-      )
-    end
-  end
-
-  context "when there is a function that returns a const pointer" do
-    let(:mock_header){
-      parsed_header = {}
-      parsed_header[:functions] = [{
-        :name => "return_const_pointer_test_function",
-        :modifier => "const",
-        :return => {:type => "char *" },
-        :args => [{:type => "int", :name => "a"}]
-      }]
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the correct const return value in the declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VALUE_FUNC1(const char *, return_const_pointer_test_function, int)"
-      )
-    end
-  end
-  
-  context "when there is a function that returns a const int" do
-    let(:mock_header){
-      parsed_header = {}
-      parsed_header[:functions] = [{
-        :name => "return_const_int_test_function",
-        :modifier => "const",
-        :return => {:type => "int" },
-        :args => []
-      }]
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
-    }
-    it "then the generated file contains the correct const return value in the declaration" do
-      expect(mock_header).to include(
-        "DECLARE_FAKE_VALUE_FUNC0(const int, return_const_int_test_function)"
-      )
-    end
-  end
-
-  context "when there are pre-includes" do
-    let(:mock_header) {
-      parsed_header = {}
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header,
-        [%{"another_header.h"}])
-    }
-    it "then they are included before the other files" do
-      expect(mock_header).to include(
-        %{#include "another_header.h"\n} +
-        %{#include "fff.h"}
-      )
-    end
-  end
-
-  context "when there are post-includes" do
-    let(:mock_header) {
-      parsed_header = {}
-      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header,
-        nil, [%{"another_header.h"}])
-    }
-    it "then they are included after the other files" do
-      expect(mock_header).to include(
-        %{#include "display.h"\n} +
-        %{#include "another_header.h"\n}
-      )
-    end
-  end
-
-end