ceedling 0.12.2 → 0.13.0.rc1

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+require 'require_all'
+require 'constructor'
+
+RSpec.configure do |configuration|
+  configuration.mock_with :rr
+end
+
+here = File.dirname(__FILE__)
+
+$: << File.join(here, '../lib')
+$: << File.join(here, '../vendor/deep_merge/lib')
+$: << File.join(here, '../vendor/cmock/lib')
+
+support_files = File.join(File.dirname(__FILE__), "support/**/*.rb")
+require_all Dir.glob(support_files)
+support_dir = File.join(File.dirname(__FILE__), 'support')
+
+# Eventually, we should use this.
+#
+# # ceedling_files = File.join(File.dirname(__FILE__), '../lib/**/*.rb')
+# # require_all Dir.glob(ceedling_files)
+
+require 'preprocessinator_extractor'
+require 'configurator_builder'
+require 'configurator'
+
+class String
+  def left_margin(indentation_level = 0)
+    indent = " " * indentation_level
+
+    data_start_at_col = self.lines.map do |l|
+      white_space = l.match(/(^\s*)\S/)
+
+      if white_space
+        white_space[1].length
+      end
+    end.compact.min
+
+    self.lines.map do |l|
+      rel = l[data_start_at_col..-1]
+      if rel
+        indent + rel
+      end
+    end.compact.join
+  end
+end

data/spec/uncatagorized_specs_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe "uncategorized" do
+  describe "set_verbosity" do
+    # drived from test_graveyard/unit/busted/configurator_test.rb:21
+    xit "needs to be defined"
+  end
+end

data/test_graveyard/integration/paths.yml

@@ -0,0 +1,17 @@
+---
+:project:
+  :build_root: test/integration/paths/build
+
+:paths:
+  :test: []
+  :source: []
+  :include: []
+    
+:tools:
+  :test_compiler:
+    :executable: ''
+  :test_linker:
+    :executable: ''
+  :test_fixture:
+    :executable: ''
+...

data/test_graveyard/integration/paths_test.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../integration_test_helper'
+require 'rubygems'
+require 'rake' # for FileList
+require 'constructor'
+require 'file_system_utils'
+require 'file_wrapper'
+
+
+PATHS_ROOT = INTEGRATION_TEST_ROOT + '/paths'
+
+class PathsTest < Test::Unit::TestCase
+
+  def setup
+    ENV['CEEDLING_MAIN_PROJECT_FILE'] = File.join(INTEGRATION_TEST_ROOT, 'paths.yml')
+    
+    @file_system_utils = FileSystemUtils.new({:file_wrapper => FileWrapper.new})
+  end
+
+  def teardown
+  end
+
+
+  should "collect paths from file system and exercise globs and our special glob handling" do
+    # pass in two strings to find all test(s) dirs in main/ and modules/
+    expected = [
+      "#{PATHS_ROOT}/main/test",
+      "#{PATHS_ROOT}/modules/comm/ethernet/test",
+      "#{PATHS_ROOT}/modules/comm/serial/test",
+      "#{PATHS_ROOT}/modules/eeprom/test",
+      "#{PATHS_ROOT}/modules/display/tests",
+      "#{PATHS_ROOT}/modules/power/tests"]
+    list = @file_system_utils.collect_paths("#{PATHS_ROOT}/main/test", "#{PATHS_ROOT}/modules/**/tes{t,ts}")
+    assert_equal(expected.sort, list.to_a.sort)
+    
+    # pass in a FileList to find all src/ dirs in all of PATHS_ROOT space
+    expected = [
+      "#{PATHS_ROOT}/main/src",
+      "#{PATHS_ROOT}/modules/comm/ethernet/src",
+      "#{PATHS_ROOT}/modules/comm/serial/src",
+      "#{PATHS_ROOT}/modules/display/src",
+      "#{PATHS_ROOT}/modules/eeprom/src",
+      "#{PATHS_ROOT}/modules/power/src"]   
+    list = @file_system_utils.collect_paths(FileList.new("#{PATHS_ROOT}/**/sr?"))
+    assert_equal(expected.sort, list.to_a.sort)
+
+    # pass in a string to recursively find all subdirectories below source/
+    expected = [
+      "#{PATHS_ROOT}/source/comm",
+      "#{PATHS_ROOT}/source/comm/ethernet",
+      "#{PATHS_ROOT}/source/comm/serial",
+      "#{PATHS_ROOT}/source/display",
+      "#{PATHS_ROOT}/source/eeprom",
+      "#{PATHS_ROOT}/source/power"]
+    list = @file_system_utils.collect_paths("#{PATHS_ROOT}/source/**")
+    assert_equal(expected.sort, list.to_a.sort)
+
+    # pass in a string to find all subdirectories one level below source/
+    expected = [
+      "#{PATHS_ROOT}/source/comm",
+      "#{PATHS_ROOT}/source/display",
+      "#{PATHS_ROOT}/source/eeprom",
+      "#{PATHS_ROOT}/source/power"]
+    list = @file_system_utils.collect_paths("#{PATHS_ROOT}/source/*")
+    assert_equal(expected.sort, list.to_a.sort)
+
+
+    # pass in an array of strings to collect tests/ and all subdirectories below tests/
+    expected = [
+      "#{PATHS_ROOT}/tests",
+      "#{PATHS_ROOT}/tests/comm",
+      "#{PATHS_ROOT}/tests/comm/ethernet",
+      "#{PATHS_ROOT}/tests/comm/serial",
+      "#{PATHS_ROOT}/tests/display",
+      "#{PATHS_ROOT}/tests/eeprom",
+      "#{PATHS_ROOT}/tests/power"]
+    list = @file_system_utils.collect_paths(["#{PATHS_ROOT}/tests", "#{PATHS_ROOT}/tests/**"])
+    assert_equal(expected.sort, list.to_a.sort)
+  end
+
+end

data/test_graveyard/integration/rake_rules_aux_dependencies_test.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../integration_test_helper'
+require 'rubygems'
+require 'rake'
+
+
+class RakeRulesAuxDependenciesTest < Test::Unit::TestCase
+
+  def setup
+    rake_setup('rakefile_rules_deep_dependencies.rb', :file_finder, :generator)
+  end
+
+  def teardown
+    Rake.application = nil
+  end
+  
+  
+  should "recognize missing dependencies files, find their source, and execute rake tasks from the rule for dependency file generation" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_DEPENDENCIES_PATH', 'project/build/dependencies')
+    redefine_global_constant('EXTENSION_DEPENDENCIES', '.d')
+
+    # reload rakefile with new global constants
+    setup()
+
+    dependencies_src1 = 'files/source/thing.c'
+    dependencies_src2 = 'tests/test_thing.c'
+    dependencies_src3 = 'lib/stuff.c'
+    dependencies1     = 'project/build/dependencies/thing.d'
+    dependencies2     = 'project/build/dependencies/test_thing.d'
+    dependencies3     = 'project/build/dependencies/stuff.d'
+
+    # fake out rake so it won't look for the header files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, dependencies_src1)
+    @rake.define_task(Rake::FileTask, dependencies_src2)
+    @rake.define_task(Rake::FileTask, dependencies_src3)
+
+    # set up expectations
+    @file_finder.expects.find_compilation_input_file(dependencies1).returns(dependencies_src1)
+    @generator.expects.generate_dependencies_file(dependencies_src1, dependencies1)
+    @file_finder.expects.find_compilation_input_file(dependencies2).returns(dependencies_src2)
+    @generator.expects.generate_dependencies_file(dependencies_src2, dependencies2)
+    @file_finder.expects.find_compilation_input_file(dependencies3).returns(dependencies_src3)
+    @generator.expects.generate_dependencies_file(dependencies_src3, dependencies3)
+
+    # invoke the dependencies creation rule under test
+    @rake[dependencies1].invoke
+    @rake[dependencies2].invoke
+    @rake[dependencies3].invoke
+  end
+
+  should "handle alternate build file paths and file extensions for dependency file generation rule" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_DEPENDENCIES_PATH', 'dependencies/dump')
+    redefine_global_constant('EXTENSION_DEPENDENCIES', '.i')
+
+    # reload rakefile with new global constants
+    setup()
+
+    dependencies_src1 = 'files/source/thing.c'
+    dependencies1     = 'dependencies/dump/thing.i'
+
+    # fake out rake so it won't look for the header files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, dependencies_src1)
+
+    # set up expectations
+    @file_finder.expects.find_compilation_input_file(dependencies1).returns(dependencies_src1)
+    @generator.expects.generate_dependencies_file(dependencies_src1, dependencies1)
+
+    # invoke the dependencies creation rule under test
+    @rake[dependencies1].invoke
+  end
+
+end

data/test_graveyard/integration/rake_rules_cmock_test.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'rubygems'
+require 'rake'
+
+
+class RakeRulesCmockTest < Test::Unit::TestCase
+
+  def setup
+    rake_setup('rakefile_rules_cmock.rb', :file_finder, :generator)
+  end
+
+  def teardown
+    Rake.application = nil
+  end
+  
+  
+  should "recognize missing mock files, find their source, and execute rake tasks from the rule for mock generation" do
+    # default values as set in test_helper
+    redefine_global_constant('CMOCK_MOCK_PREFIX', 'mock_')
+    redefine_global_constant('EXTENSION_SOURCE', '.c')
+
+    # reload rakefile with new global constants
+    setup()
+
+    mock_src1 = 'files/source/thing.h'
+    mock_src2 = 'stuff.h'
+    mock_src3 = 'files/source/WooDoggie.h'
+    mock1     = 'files/mocks/mock_thing.c'
+    mock2     = 'mock_stuff.c'
+    mock3     = 'files/mocks/mock_WooDoggie.c'
+
+    # fake out rake so it won't look for the header files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, mock_src1)
+    @rake.define_task(Rake::FileTask, mock_src2)
+    @rake.define_task(Rake::FileTask, mock_src3)
+
+    # set up expectations
+    @file_finder.expects.find_mockable_header(mock1).returns(mock_src1)
+    @generator.expects.generate_mock(mock_src1)
+    @file_finder.expects.find_mockable_header(mock2).returns(mock_src2)
+    @generator.expects.generate_mock(mock_src2)
+    @file_finder.expects.find_mockable_header(mock3).returns(mock_src3)
+    @generator.expects.generate_mock(mock_src3)
+
+    # invoke the mock creation rule under test
+    @rake[mock1].invoke
+    @rake[mock2].invoke
+    @rake[mock3].invoke
+  end
+
+  should "handle alternate mock prefixes and source extensions for mock generation rule" do
+    redefine_global_constant('CMOCK_MOCK_PREFIX', 'Mock')
+    redefine_global_constant('EXTENSION_SOURCE', '.x')
+
+    # reload rakefile with new global constants
+    setup()
+
+    mock_src1 = 'files/source/IngBird.h'
+    mock1     = 'files/mocks/MockIngBird.x'
+
+    # fake out rake so it won't look for the header files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, mock_src1)
+
+    # set up expectations
+    @file_finder.expects.find_mockable_header(mock1).returns(mock_src1)
+    @generator.expects.generate_mock(mock_src1)
+
+    # invoke the mock creation rule under test
+    @rake[mock1].invoke
+  end
+
+end

data/test_graveyard/integration/rake_rules_preprocess_test.rb

@@ -0,0 +1,178 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'rubygems'
+require 'rake'
+
+
+class RakeRulesPreprocessTest < Test::Unit::TestCase
+
+  def setup    
+    rake_setup('rakefile_rules_preprocess.rb', :file_finder, :generator, :configurator)
+  end
+
+  def teardown
+    Rake.application = nil
+  end
+  
+  
+  ################################
+  ####### Preprocess Files #######
+  ################################
+
+  should "recognize missing preprocessed files, find their source, and execute rake tasks from the rule for generating preprocessed file output" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_FILES_PATH', 'project/build/preprocess/files')
+    # because rule matches on any file, gotta set this path here to help rake distinguish rules when file is tested
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_INCLUDES_PATH', 'project/build/preprocess/includes')
+
+    # reload rakefile with new global constants
+    setup()
+
+    # try all different paths and file extensions; we should be able to preprocess any kind of source file
+    preprocess_src1 = 'tests/a/test_thing.c'
+    preprocess_src2 = 'source/a_file.h'
+    preprocess_src3 = 'source/lib/include/API.H'
+    preprocess1     = 'project/build/preprocess/files/test_thing.c'
+    preprocess2     = 'project/build/preprocess/files/a_file.h'
+    preprocess3     = 'project/build/preprocess/files/API.H'
+  
+    # fake out rake so it won't look for the test files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, preprocess_src1)
+    @rake.define_task(Rake::FileTask, preprocess_src2)
+    @rake.define_task(Rake::FileTask, preprocess_src3)
+  
+    # set up expectations
+    @file_finder.expects.find_test_or_source_or_header_file(preprocess1).returns(preprocess_src1)
+    @configurator.expects.project_use_deep_dependencies.returns(true)
+    @generator.expects.generate_preprocessed_file(preprocess_src1)
+
+    @file_finder.expects.find_test_or_source_or_header_file(preprocess2).returns(preprocess_src2)
+    @configurator.expects.project_use_deep_dependencies.returns(true)
+    @generator.expects.generate_preprocessed_file(preprocess_src2)
+
+    @file_finder.expects.find_test_or_source_or_header_file(preprocess3).returns(preprocess_src3)
+    @configurator.expects.project_use_deep_dependencies.returns(true)
+    @generator.expects.generate_preprocessed_file(preprocess_src3)
+    
+    # invoke the test preprocess creation rule under test
+    @rake[preprocess1].invoke
+    @rake[preprocess2].invoke
+    @rake[preprocess3].invoke
+  end
+
+  should "complain if file preprocessing rule is executed but auxiliary dependencies are not enabled" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_FILES_PATH', 'project/build/preprocess/files')
+    # because rule matches on any file, gotta set this path here to help rake distinguish rules when file is tested
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_INCLUDES_PATH', 'project/build/preprocess/includes')
+
+    # reload rakefile with new global constants
+    setup()
+
+    # try all different paths and file extensions; we should be able to preprocess any kind of source file
+    preprocess_src1 = 'tests/a/test_thing.c'
+    preprocess1     = 'project/build/preprocess/files/test_thing.c'
+  
+    # fake out rake so it won't look for the test files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, preprocess_src1)
+  
+    # set up expectations
+    @file_finder.expects.find_test_or_source_or_header_file(preprocess1).returns(preprocess_src1)
+    @configurator.expects.project_use_deep_dependencies.returns(false)
+    
+    # invoke the test preprocess creation rule under test
+    assert_raise(RuntimeError){ @rake[preprocess1].invoke }
+  end
+
+  should "handle alternate output file paths for preprocessed file output rule" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_FILES_PATH', 'demacroified/files')
+    # because rule matches on any file, gotta set this path here to help rake distinguish rules when file is tested
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_INCLUDES_PATH', 'includes')
+
+    # reload rakefile with new global constants
+    setup()
+
+    preprocess_src1 = 'tests/a/test_thing.C'
+    preprocess1     = 'demacroified/files/test_thing.C'
+  
+    # fake out rake so it won't look for the test files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, preprocess_src1)
+  
+    # set up expectations
+    @file_finder.expects.find_test_or_source_or_header_file(preprocess1).returns(preprocess_src1)
+    @configurator.expects.project_use_deep_dependencies.returns(true)
+    @generator.expects.generate_preprocessed_file(preprocess_src1)
+
+    # invoke the test preprocess creation rule under test
+    @rake[preprocess1].invoke
+  end
+
+  ########################################
+  ####### Extract Shallow Includes #######
+  ########################################
+
+  should "recognize missing extracted includes files, find their source, and execute rake tasks from the rule for extracting file includes output" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_INCLUDES_PATH', 'project/build/preprocess/includes')
+    # because rule matches on any file, gotta set this path here to help rake distinguish rules when file is tested
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_FILES_PATH', 'project/build/preprocess/files')
+
+    # reload rakefile with new global constants
+    setup()
+
+    # try all different paths and file extensions; we should be able to preprocess any kind of source file
+    includes_src1 = 'tests/a/test_thing.c'
+    includes_src2 = 'source/a_file.h'
+    includes_src3 = 'source/lib/include/API.H'
+    includes1     = 'project/build/preprocess/includes/test_thing.c'
+    includes2     = 'project/build/preprocess/includes/a_file.h'
+    includes3     = 'project/build/preprocess/includes/API.H'
+  
+    # fake out rake so it won't look for the test files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, includes_src1)
+    @rake.define_task(Rake::FileTask, includes_src2)
+    @rake.define_task(Rake::FileTask, includes_src3)
+  
+    # set up expectations
+    @file_finder.expects.find_test_or_source_or_header_file(includes1).returns(includes_src1)
+    @generator.expects.generate_shallow_includes_list(includes_src1)
+    @file_finder.expects.find_test_or_source_or_header_file(includes2).returns(includes_src2)
+    @generator.expects.generate_shallow_includes_list(includes_src2)
+    @file_finder.expects.find_test_or_source_or_header_file(includes3).returns(includes_src3)
+    @generator.expects.generate_shallow_includes_list(includes_src3)
+    
+    # invoke the test includes creation rule under test
+    @rake[includes1].invoke
+    @rake[includes2].invoke
+    @rake[includes3].invoke
+  end
+
+  should "handle alternate output file paths for preprocessor incluedes file output rule" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_INCLUDES_PATH', 'include_stuff')
+    # because rule matches on any file, gotta set this path here to help rake distinguish rules when file is tested
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_FILES_PATH', 'project/build/preprocess/files')
+
+    # reload rakefile with new global constants
+    setup()
+
+    includes_src1 = 'tests/a/test_thing.C'
+    includes1     = 'include_stuff/test_thing.C'
+  
+    # fake out rake so it won't look for the test files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, includes_src1)
+  
+    # set up expectations
+    @file_finder.expects.find_test_or_source_or_header_file(includes1).returns(includes_src1)
+    @generator.expects.generate_shallow_includes_list(includes_src1)
+    
+    # invoke the test includes creation rule under test
+    @rake[includes1].invoke
+  end
+
+end