ceedling 0.25.0 → 0.27.0

data/lib/ceedling/rules_tests.rake

@@ -25,12 +25,17 @@ end
 
 
 rule(/#{PROJECT_TEST_BUILD_OUTPUT_PATH}\/#{'.+\\'+EXTENSION_EXECUTABLE}$/) do |bin_file|
+
+  lib_args = ((defined? LIBRARIES_SYSTEM) ? LIBRARIES_SYSTEM : [])
+  lib_args.map! {|v| LIBRARIES_FLAG.gsub(/\$\{1\}/, v) } if (defined? LIBRARIES_FLAG)
+
   @ceedling[:generator].generate_executable_file(
     TOOLS_TEST_LINKER,
     TEST_SYM,
     bin_file.prerequisites,
     bin_file.name,
-    @ceedling[:file_path_utils].form_test_build_map_filepath( bin_file.name ) )
+    @ceedling[:file_path_utils].form_test_build_map_filepath( bin_file.name ),
+    lib_args )
 end
 
 

data/lib/ceedling/setupinator.rb

@@ -24,6 +24,7 @@ class Setupinator
     @ceedling[:configurator].populate_unity_defaults( config_hash )
     @ceedling[:configurator].populate_cmock_defaults( config_hash )
     @ceedling[:configurator].find_and_merge_plugins( config_hash )
+    @ceedling[:configurator].merge_imports( config_hash )
     @ceedling[:configurator].tools_setup( config_hash )
     @ceedling[:configurator].eval_environment_variables( config_hash )
     @ceedling[:configurator].eval_paths( config_hash )

data/lib/ceedling/tasks_base.rake

@@ -92,6 +92,9 @@ namespace :options do
       # @ceedling[:setupinator].reset_defaults( @ceedling[:setupinator].config_hash )
       hash = @ceedling[:project_config_manager].merge_options( @ceedling[:setupinator].config_hash, option_path )
       @ceedling[:setupinator].do_setup( hash )
+      if @ceedling[:configurator].project_release_build
+        load(File.join(CEEDLING_LIB, 'ceedling', 'rules_release.rake'))
+      end
     end
   end
 

data/lib/ceedling/tasks_filesystem.rake

@@ -18,6 +18,9 @@ CLOBBER.include(File.join(PROJECT_BUILD_RELEASE_ROOT, '**/*'))
 CLOBBER.include(File.join(PROJECT_LOG_PATH, '**/*'))
 CLOBBER.include(File.join(PROJECT_TEMP_PATH, '**/*'))
 
+# just in case they're using git, let's make sure we allow them to preserved the build directory if desired.
+CLOBBER.exclude(File.join(TESTS_BASE_PATH), '**/.gitkeep')
+
 # because of cmock config, mock path can optionally exist apart from standard test build paths
 CLOBBER.include(File.join(CMOCK_MOCK_PATH, '*'))
 
@@ -49,35 +52,35 @@ task(:directories => PROJECT_BUILD_PATHS) { @ceedling[:dependinator].touch_force
 
 # list paths discovered at load time
 namespace :paths do
-  
+
   paths = @ceedling[:setupinator].config_hash[:paths]
   paths.each_key do |section|
     name = section.to_s.downcase
     path_list = Object.const_get("COLLECTION_PATHS_#{name.upcase}")
-    
+
     if (path_list.size != 0)
       desc "List all collected #{name} paths."
       task(name.to_sym) { puts "#{name} paths:"; path_list.sort.each {|path| puts " - #{path}" } }
     end
   end
-  
+
 end
 
 
 # list files & file counts discovered at load time
 namespace :files do
-  
+
   categories = [
     ['test',   COLLECTION_ALL_TESTS],
     ['source', COLLECTION_ALL_SOURCE],
     ['header', COLLECTION_ALL_HEADERS]
     ]
   categories << ['assembly', COLLECTION_ALL_ASSEMBLY] if (RELEASE_BUILD_USE_ASSEMBLY)
-  
+
   categories.each do |category|
     name       = category[0]
     collection = category[1]
-    
+
     desc "List all collected #{name} files."
     task(name.to_sym) do
       puts "#{name} files:"
@@ -85,7 +88,7 @@ namespace :files do
       puts "file count: #{collection.size}"
     end
   end
-  
+
 end
 
 

data/lib/ceedling/tasks_release.rake

@@ -19,7 +19,9 @@ task RELEASE_SYM => [:directories] do
     # if assembler use isn't enabled, COLLECTION_ALL_ASSEMBLY is empty array & nothing happens
     core_objects.concat( @ceedling[:release_invoker].setup_and_invoke_asm_objects( COLLECTION_ALL_ASSEMBLY ) )
   
-    file( PROJECT_RELEASE_BUILD_TARGET => (core_objects + extra_objects) )
+    # if we're using libraries, we need to add those to our collection as well
+    library_objects = (defined? LIBRARIES_RELEASE && !LIBRARIES_RELEASE.empty?) ? LIBRARIES_RELEASE.flatten.compact : []
+    file( PROJECT_RELEASE_BUILD_TARGET => (core_objects + extra_objects + library_objects) )
     Rake::Task[PROJECT_RELEASE_BUILD_TARGET].invoke
   ensure
     @ceedling[:plugin_manager].post_release  

data/lib/ceedling/test_includes_extractor.rb

@@ -3,7 +3,6 @@ class TestIncludesExtractor
 
   constructor :configurator, :yaml_wrapper, :file_wrapper
 
-
   def setup
     @includes  = {}
     @mocks     = {}
@@ -26,16 +25,16 @@ class TestIncludesExtractor
     return [] if @mocks[file_key].nil?
     return @mocks[file_key]
   end
-  
+
   # includes with file extension
   def lookup_includes_list(file)
     file_key = form_file_key(file)
     return [] if (@includes[file_key]).nil?
     return @includes[file_key]
   end
-  
+
   private #################################
-  
+
   def form_file_key(filepath)
     return File.basename(filepath).to_sym
   end
@@ -43,21 +42,26 @@ class TestIncludesExtractor
   def extract_from_file(file)
     includes = []
     header_extension = @configurator.extension_header
-    
+
     contents = @file_wrapper.read(file)
 
     # remove line comments
     contents = contents.gsub(/\/\/.*$/, '')
     # remove block comments
     contents = contents.gsub(/\/\*.*?\*\//m, '')
-    
+
     contents.split("\n").each do |line|
       # look for include statement
       scan_results = line.scan(/#include\s+\"\s*(.+#{'\\'+header_extension})\s*\"/)
-      
+
+      includes << scan_results[0][0] if (scan_results.size > 0)
+
+      # look for TEST_FILE statement
+      scan_results = line.scan(/TEST_FILE\(\s*\"\s*(.+\.\w+)\s*\"\s*\)/)
+
       includes << scan_results[0][0] if (scan_results.size > 0)
     end
-    
+
     return includes.uniq
   end
 
@@ -66,16 +70,16 @@ class TestIncludesExtractor
     header_extension = @configurator.extension_header
     file_key         = form_file_key(file)
     @mocks[file_key] = []
-      
+
     # add includes to lookup hash
     @includes[file_key] = includes
-      
-    includes.each do |include_file|          
+
+    includes.each do |include_file|
       # check if include is a mock
       scan_results = include_file.scan(/(#{mock_prefix}.+)#{'\\'+header_extension}/)
       # add mock to lookup hash
       @mocks[file_key] << scan_results[0][0] if (scan_results.size > 0)
     end
   end
-  
+
 end

data/lib/ceedling/test_invoker.rb

@@ -23,6 +23,37 @@ class TestInvoker
     @mocks   = []
   end
   
+  def get_test_definition_str(test)
+    return "-D" + File.basename(test, File.extname(test)).upcase.sub(/@.*$/, "")
+  end
+
+  def get_tools_compilers
+    tools_compilers = Hash.new
+    tools_compilers["for unit test"] = TOOLS_TEST_COMPILER if defined? TOOLS_TEST_COMPILER
+    tools_compilers["for gcov"]      = TOOLS_GCOV_COMPILER if defined? TOOLS_GCOV_COMPILER
+    return tools_compilers
+  end
+
+  def add_test_definition(test)
+    test_definition_str = get_test_definition_str(test)
+    get_tools_compilers.each do |tools_compiler_key, tools_compiler_value|
+      tools_compiler_value[:arguments].push("-D#{File.basename(test, ".*").strip.upcase.sub(/@.*$/, "")}")
+      @streaminator.stdout_puts("Add the definition value in the build option #{tools_compiler_value[:arguments][-1]} #{tools_compiler_key}", Verbosity::OBNOXIOUS)
+    end
+  end
+
+  def delete_test_definition(test)
+    test_definition_str = get_test_definition_str(test)
+    get_tools_compilers.each do |tools_compiler_key, tools_compiler_value|
+      num_options = tools_compiler_value[:arguments].size
+      @streaminator.stdout_puts("Delete the definition value in the build option #{tools_compiler_value[:arguments][-1]} #{tools_compiler_key}", Verbosity::OBNOXIOUS)
+      tools_compiler_value[:arguments].delete_if{|i| i == test_definition_str}
+      if num_options > tools_compiler_value[:arguments].size + 1
+        @streaminator.stderr_puts("WARNING: duplicated test definition.")
+      end
+    end
+  end
+
   def setup_and_invoke(tests, context=TEST_SYM, options={:force_run => true})
   
     @tests = tests
@@ -47,6 +78,11 @@ class TestInvoker
         results_pass = @file_path_utils.form_pass_results_filepath( test )
         results_fail = @file_path_utils.form_fail_results_filepath( test )
         
+        # add the definition value in the build option for the unit test
+        if @configurator.defines_use_test_definition
+          add_test_definition(test)
+        end
+
         # clean results files so we have a missing file with which to kick off rake's dependency rules
         @test_invoker_helper.clean_results( {:pass => results_pass, :fail => results_fail}, options )
 
@@ -69,6 +105,10 @@ class TestInvoker
       rescue => e
         @build_invoker_utils.process_exception( e, context )
       ensure
+        # delete the definition value in the build option for the unit test
+        if @configurator.defines_use_test_definition
+          delete_test_definition(test)
+        end
         @plugin_manager.post_test( test )
       end
       

data/lib/ceedling/version.rb

@@ -2,14 +2,14 @@
 module Ceedling
   module Version
     # @private
-    GEM = "0.25.0"
+    GEM = "0.27.0"
     # @private
     CEEDLING = GEM
     # @private
     CEXCEPTION = "1.3.1"
     # @private
-    CMOCK = "2.4.3"
+    CMOCK = "2.4.4"
     # @private
-    UNITY = "2.4.0"
+    UNITY = "2.4.1"
   end
 end

data/lib/ceedling/version.rb.erb

@@ -2,7 +2,7 @@
 module Ceedling
   module Version
     # @private
-    GEM = "0.24.0"
+    GEM = "0.27.0"
     # @private
     CEEDLING = "<%= versions["CEEDLING"] %>"
     # @private

data/plugins/command_hooks/lib/command_hooks.rb

@@ -46,7 +46,7 @@ class CommandHooks < Plugin
 
   private
 
-  def run_hook_step(hook, name)
+  def run_hook_step(hook, name="")
     if (hook[:executable])
       cmd = @ceedling[:tool_executor].build_command_line( hook, [], name )
       shell_result = @ceedling[:tool_executor].exec( cmd[:line], cmd[:options] )

data/plugins/fake_function_framework/examples/fff_example/src/bar.h

@@ -9,5 +9,6 @@ void bar_print_message_formatted(const char * format, ...);
 void bar_numbers(int one, int two, char three);
 void bar_const_test(const char * a, char * const b, const int c);
 custom_t bar_needs_custom_type(void);
+const char * bar_return_const_ptr(int one);
 
 #endif // bar_H

data/plugins/fake_function_framework/examples/fff_example/src/event_processor.c

@@ -5,6 +5,7 @@
 */
 
 #include <stdio.h>
+#include <string.h>
 #include "event_processor.h"
 #include "display.h"
 

data/plugins/fake_function_framework/lib/fff_mock_generator.rb

@@ -119,6 +119,10 @@ class FffMockGenerator
     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.

data/plugins/fake_function_framework/spec/{fff_mock_generator_spec.rb → fff_mock_header_generator_spec.rb}

@@ -1,6 +1,8 @@
 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
@@ -235,230 +237,68 @@ describe "FffMockGenerator.create_mock_header" do
     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
-
-describe "FffMockGenerator.create_mock_source" do
-
-  context "when there is nothing to mock," do
-    let(:mock_source) {
-      parsed_header = {}
-      FffMockGenerator.create_mock_source("mock_my_module", parsed_header)
-    }
-    it "then the generated file includes the fff header" do
-      expect(mock_source).to include(
-        # fff.h also requires including string.h
-        %{#include <string.h>\n} +
-        %{#include "fff.h"}
-      )
-    end
-    it "then the generated file includes the mock header" do
-      expect(mock_source).to include(
-        %{#include "mock_my_module.h"\n}
-      )
-    end
-    it "then the generated file defines the init function" do
-      expect(mock_source).to include(
-        "void mock_my_module_Init(void)\n" +
-        "{\n" +
-        "    FFF_RESET_HISTORY();\n" +
-        "}"
-      )
-    end
-    it "then the generated file defines the verify function" do
-      expect(mock_source).to include(
-        "void mock_my_module_Verify(void)\n" +
-        "{\n" +
-        "}"
-      )
-    end
-    it "then the generated file defines the destroy function" do
-      expect(mock_source).to include(
-        "void mock_my_module_Destroy(void)\n" +
-        "{\n" +
-        "}"
-      )
-    end
-  end
-
-  context "when there are multiple functions," do
-    let(:mock_source) {
-      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_source("mock_display", parsed_header)
-    }
-    it "then the generated file contains the first fake function definition" do
-      expect(mock_source).to include(
-        "DEFINE_FAKE_VALUE_FUNC1(int, a_function, char *);"
-      )
-    end
-    it "then the generated file contains the second fake function definition" do
-      expect(mock_source).to include(
-        "DEFINE_FAKE_VOID_FUNC0(another_function);"
-      )
-    end
-    it "then the generated file contains the third fake function definition" do
-      expect(mock_source).to include(
-        "DEFINE_FAKE_VALUE_FUNC2(bool, three, float, int);"
-      )
-    end
-    it "then the init function resets all of the fakes" do
-      expect(mock_source).to include(
-        "void mock_display_Init(void)\n" +
-        "{\n" +
-        "    FFF_RESET_HISTORY();\n" +
-        "    RESET_FAKE(a_function)\n" +
-        "    RESET_FAKE(another_function)\n" +
-        "    RESET_FAKE(three)\n" +
-        "}"
-      )
-    end
-  end
-
-  context "when there is a void function with variable arguments and " +
-          "additional arguments" do
-    let(:mock_source){
+  context "when there is a function that returns a const pointer" do
+    let(:mock_header){
       parsed_header = {}
       parsed_header[:functions] = [{
-        :name => "function_with_var_args",
-        :return => {:type => "void"},
-        :var_arg => "...",
-        :args => [{:type => 'char *'}, {:type => 'int'}]
+        :name => "return_const_pointer_test_function",
+        :modifier => "const",
+        :return => {:type => "char *" },
+        :args => [{:type => "int", :name => "a"}]
       }]
-      FffMockGenerator.create_mock_source("mock_display", parsed_header)
+      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header)
     }
-    it "then the generated file contains the vararg definition" do
-      expect(mock_source).to include(
-        "DEFINE_FAKE_VOID_FUNC3_VARARG(function_with_var_args, char *, int, ...)"
+    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 with a pointer to a const value" do
-    let(:mock_source){
+  
+  context "when there is a function that returns a const int" 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}]
+        :name => "return_const_int_test_function",
+        :modifier => "const",
+        :return => {:type => "int" },
+        :args => []
       }]
-      FffMockGenerator.create_mock_source("mock_display", parsed_header)
+      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_source).to include(
-        "DEFINE_FAKE_VOID_FUNC2(const_test_function, const char *, char *)"
+    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_source) {
-      parsed_source = {}
-      FffMockGenerator.create_mock_source("mock_display", parsed_source,
+    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_source).to include(
+      expect(mock_header).to include(
         %{#include "another_header.h"\n} +
-        %{#include <string.h>}
+        %{#include "fff.h"}
       )
     end
   end
 
   context "when there are post-includes" do
-    let(:mock_source) {
-      parsed_source = {}
-      FffMockGenerator.create_mock_source("mock_display", parsed_source,
+    let(:mock_header) {
+      parsed_header = {}
+      FffMockGenerator.create_mock_header("display", "mock_display", parsed_header,
         nil, [%{"another_header.h"}])
     }
-    it "then they are included before the other files" do
-      expect(mock_source).to include(
-        %{#include "mock_display.h"\n} +
+    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
-
-# Create a CMock-style parsed header hash. This the type of hash created by
-# CMock when parsing header files for automock generation. It contains all of
-# includes, typedefs and functions (with return types and arguments) parsed from
-# the header file.
-def create_cmock_style_parsed_header(functions, typedefs = nil)
-  parsed_header = {
-      :includes => nil,
-      :functions => [],
-      :typedefs => []
-  }
 
-  # Add the typedefs.
-  if typedefs
-      typedefs.each do |typedef|
-          parsed_header[:typedefs] << typedef
-      end
-  end
-
-  # Add the functions.
-  if functions
-    functions.each do |function|
-      # Build the array of arguments.
-      args = []
-      if function.key?(:args)
-        function[:args].each do |arg|
-          args << {
-            :type => arg
-          }
-        end
-      end
-      parsed_header[:functions] << {
-        :name => function[:name],
-        :modifier => "",
-        :return => {
-          :type => function[:return_type],
-          :name => "cmock_to_return",
-          :ptr? => false,
-          :const? => false,
-          :str => "void cmock_to_return",
-          :void? => true
-        },
-        :var_arg => nil,
-        :args_string => "void",
-        :args => args,
-        :args_call => "",
-        :contains_ptr? => false
-      }
-    end
-  end
-  parsed_header
 end