ceedling 0.31.1 → 1.0.1

data/plugins/subprojects/subprojects.rake

@@ -1,78 +0,0 @@
-
-
-SUBPROJECTS_PATHS.each do |subproj|
-
-  subproj_source     = subproj[:source]
-  subproj_include    = subproj[:include]
-  subproj_name       = subproj[:name]
-  subproj_build_root = subproj[:build_root]
-  subproj_build_out  = "#{subproj[:build_root]}/out"
-  subproj_build_c    = "#{subproj[:build_root]}/out/c"
-  subproj_build_asm  = "#{subproj[:build_root]}/out/asm"
-  subproj_directories = [ subproj_build_root, subproj_build_out, subproj_build_c, subproj_build_asm ]
-
-  subproj_directories.each do |subdir|
-    directory(subdir)
-  end
-
-  CLEAN.include(File.join(subproj_build_root, '*'))
-  CLEAN.include(File.join(subproj_build_out, '*'))
-
-  CLOBBER.include(File.join(subproj_build_root, '**/*'))
-
-  # Add a rule for building the actual static library from our object files
-  rule(/#{subproj_build_root}#{'.+\\'+EXTENSION_SUBPROJECTS}$/ => [
-      proc do |task_name|
-        @ceedling[SUBPROJECTS_SYM].list_all_object_files_for_subproject(task_name)
-      end
-    ]) do |bin_file|
-    @ceedling[:generator].generate_executable_file(
-      TOOLS_SUBPROJECTS_LINKER,
-      SUBPROJECTS_SYM,
-      bin_file.prerequisites,
-      bin_file.name,
-      @ceedling[:file_path_utils].form_test_build_map_filepath(bin_file.name))
-  end
-
-  # Add a rule for building object files from assembly files to link into a library
-  if (RELEASE_BUILD_USE_ASSEMBLY)
-    rule(/#{subproj_build_asm}#{'.+\\'+EXTENSION_OBJECT}$/ => [
-        proc do |task_name|
-          @ceedling[SUBPROJECTS_SYM].find_library_assembly_file_for_object(task_name)
-        end
-      ]) do |object|
-      @ceedling[SUBPROJECTS_SYM].replace_constant(:COLLECTION_PATHS_SUBPROJECTS, @ceedling[SUBPROJECTS_SYM].find_my_paths(object.source, :asm))
-      @ceedling[SUBPROJECTS_SYM].replace_constant(:COLLECTION_DEFINES_SUBPROJECTS, @ceedling[SUBPROJECTS_SYM].find_my_defines(object.source, :asm))
-      @ceedling[:generator].generate_object_file(
-        TOOLS_SUBPROJECTS_ASSEMBLER,
-        OPERATION_ASSEMBLE_SYM,
-        SUBPROJECTS_SYM,
-        object.source,
-        object.name )
-    end
-  end
-
-  # Add a rule for building object files from C files to link into a library
-  rule(/#{subproj_build_c}#{'.+\\'+EXTENSION_OBJECT}$/ => [
-      proc do |task_name|
-        @ceedling[SUBPROJECTS_SYM].find_library_source_file_for_object(task_name)
-      end
-    ]) do |object|
-    @ceedling[SUBPROJECTS_SYM].replace_constant(:COLLECTION_PATHS_SUBPROJECTS, @ceedling[SUBPROJECTS_SYM].find_my_paths(object.source, :c))
-    @ceedling[SUBPROJECTS_SYM].replace_constant(:COLLECTION_DEFINES_SUBPROJECTS, @ceedling[SUBPROJECTS_SYM].find_my_defines(object.source, :c))
-    @ceedling[:generator].generate_object_file(
-      TOOLS_SUBPROJECTS_COMPILER,
-      OPERATION_COMPILE_SYM,
-      SUBPROJECTS_SYM,
-      object.source,
-      object.name,
-      @ceedling[:file_path_utils].form_release_build_c_list_filepath( object.name ) )
-  end
-
-  # Add the subdirectories involved to our list of those that should be autogenerated
-  task :directories => subproj_directories.clone
-
-  # Finally, add the static library to our RELEASE build dependency list
-  task RELEASE_SYM => ["#{subproj_build_root}/#{subproj_name}#{EXTENSION_SUBPROJECTS}"] 
-end
-

data/plugins/teamcity_tests_report/README.md

@@ -1,18 +0,0 @@
-ceedling-teamcity-tests-report
-==============================
-
-## Overview
-
-The teamcity_tests_report replaces the normal ceedling "pretty" output with 
-a version that has results tagged to be consumed with the teamcity CI server.
-
-## Setup
-
-Enable the plugin in your project.yml by adding `teamcity_tests_report`
-to the list of enabled plugins.
-
-``` YAML
-:plugins:
-  :enabled:
-    - teamcity_tests_report
-```

data/plugins/teamcity_tests_report/config/teamcity_tests_report.yml

@@ -1,4 +0,0 @@
----
-:plugins:
-  # tell Ceedling we got results display taken care of
-  :display_raw_test_results: FALSE

data/plugins/teamcity_tests_report/lib/teamcity_tests_report.rb

@@ -1,57 +0,0 @@
-require 'ceedling/plugin'
-require 'ceedling/defaults'
-
-class TeamcityTestsReport < Plugin
-
-  def setup
-    @suite_started = nil
-    @output_enabled = !defined?(TEAMCITY_BUILD) || TEAMCITY_BUILD
-  end
-
-  def escape(string)
-    string.gsub(/['|\[\]]/, '|\0').gsub('\r', '|r').gsub('\n', '|n')
-  end
-
-  def pre_test(test)
-    teamcity_message "testSuiteStarted name='#{File.basename(test, '.c')}'"
-    @suite_started = Time.now
-  end
-
-  def post_test(test)
-    teamcity_message "testSuiteFinished name='#{File.basename(test, '.c')}'"
-  end
-
-  def post_test_fixture_execute(arg_hash)
-    duration = (Time.now - @suite_started) * 1000
-    results = @ceedling[:plugin_reportinator].assemble_test_results([arg_hash[:result_file]])
-    avg_duration = (duration / [1, results[:counts][:passed] + results[:counts][:failed]].max).round
-
-    results[:successes].each do |success|
-      success[:collection].each do |test|
-        teamcity_message "testStarted name='#{test[:test]}'"
-        teamcity_message "testFinished name='#{test[:test]}' duration='#{avg_duration}'"
-      end
-    end
-
-    results[:failures].each do |failure|
-      failure[:collection].each do |test|
-        teamcity_message "testStarted name='#{test[:test]}'"
-        teamcity_message "testFailed name='#{test[:test]}' message='#{escape(test[:message])}' details='File: #{failure[:source][:path]}/#{failure[:source][:file]} Line: #{test[:line]}'"
-        teamcity_message "testFinished name='#{test[:test]}' duration='#{avg_duration}'"
-      end
-    end
-
-    results[:ignores].each do |failure|
-      failure[:collection].each do |test|
-        teamcity_message "testIgnored name='#{test[:test]}' message='#{escape(test[:message])}'"
-      end
-    end
-
-    # We ignore stdout
-  end
-
-  def teamcity_message(content)
-    puts "##teamcity[#{content}]" unless !@output_enabled
-  end
-
-end

data/plugins/warnings_report/README.md

@@ -1,19 +0,0 @@
-warnings-report
-===============
-
-## Overview
-
-The warnings_report captures all warnings throughout the build process
-and collects them into a single report at the end of execution. It places all
-of this into a warnings file in the output artifact directory.
-
-## Setup
-
-Enable the plugin in your project.yml by adding `warnings_report`
-to the list of enabled plugins.
-
-``` YAML
-:plugins:
-  :enabled:
-    - warnings_report
-```

data/plugins/warnings_report/lib/warnings_report.rb

@@ -1,69 +0,0 @@
-require 'ceedling/plugin'
-require 'ceedling/constants'
-
-class WarningsReport < Plugin
-  def setup
-    @stderr_redirect = nil
-    @log_paths = {}
-  end
-
-  def pre_compile_execute(arg_hash)
-    # at beginning of compile, override tool's stderr_redirect so we can parse $stderr + $stdout
-    set_stderr_redirect(arg_hash)
-  end
-
-  def post_compile_execute(arg_hash)
-    # after compilation, grab output for parsing/logging, restore stderr_redirect, log warning if it exists
-    output = arg_hash[:shell_result][:output]
-    restore_stderr_redirect(arg_hash)
-    write_warning_log(arg_hash[:context], output)
-  end
-
-  def pre_link_execute(arg_hash)
-    # at beginning of link, override tool's stderr_redirect so we can parse $stderr + $stdout
-    set_stderr_redirect(arg_hash)
-  end
-
-  def post_link_execute(arg_hash)
-    # after linking, grab output for parsing/logging, restore stderr_redirect, log warning if it exists
-    output = arg_hash[:shell_result][:output]
-    restore_stderr_redirect(arg_hash)
-    write_warning_log(arg_hash[:context], output)
-  end
-
-  private
-
-  def set_stderr_redirect(hash)
-    @stderr_redirect = hash[:tool][:stderr_redirect]
-    hash[:tool][:stderr_redirect] = StdErrRedirect::AUTO
-  end
-
-  def restore_stderr_redirect(hash)
-    hash[:tool][:stderr_redirect] = @stderr_redirect
-  end
-
-  def write_warning_log(context, output)
-    # if $stderr/$stdout contain "warning", log it
-    if output =~ /warning/i
-      # generate a log path & file io write flags
-      logging = generate_log_path(context)
-      @ceedling[:file_wrapper].write(logging[:path], output + "\n", logging[:flags]) unless logging.nil?
-    end
-  end
-
-  def generate_log_path(context)
-    # if path has already been generated, return it & 'append' file io flags (append to log)
-    return { path: @log_paths[context], flags: 'a' } unless @log_paths[context].nil?
-
-    # first time through, generate path & 'write' file io flags (create new log)
-    base_path = File.join(PROJECT_BUILD_ARTIFACTS_ROOT, context.to_s)
-    file_path = File.join(base_path, 'warnings.log')
-
-    if @ceedling[:file_wrapper].exist?(base_path)
-      @log_paths[context] = file_path
-      return { path: file_path, flags: 'w' }
-    end
-
-    nil
-  end
-end

data/plugins/xml_tests_report/README.md

@@ -1,36 +0,0 @@
-xml_tests_report
-================
-
-## Overview
-
-The xml_tests_report plugin creates an XML file of test results in xUnit
-format, which is handy for Continuous Integration build servers or as input
-into other reporting tools. The XML file is output to the appropriate
-`<build_root>/artifacts/` directory (e.g. `artifacts/test/` for test tasks,
-`artifacts/gcov/` for gcov, or `artifacts/bullseye/` for bullseye runs).
-
-## Setup
-
-Enable the plugin in your project.yml by adding `xml_tests_report` to the list
-of enabled plugins.
-
-``` YAML
-:plugins:
-  :enabled:
-    - xml_tests_report
-```
-
-## Configuration
-
-Optionally configure the output / artifact filename in your project.yml with
-the `artifact_filename` configuration option. The default filename is
-`report.xml`.
-
-You can also configure the path that this artifact is stored. This can be done
-by setting `path`. The default is that it will be placed in a subfolder under
-the `build` directory.
-
-``` YAML
-:xml_tests_report:
-  :artifact_filename: report_xunit.xml
-```

data/plugins/xml_tests_report/lib/xml_tests_report.rb

@@ -1,110 +0,0 @@
-require 'ceedling/plugin'
-require 'ceedling/constants'
-
-class XmlTestsReport < Plugin
-  def setup
-    @results_list = {}
-    @test_counter = 0
-  end
-
-  def post_test_fixture_execute(arg_hash)
-    context = arg_hash[:context]
-
-    @results_list[context] = [] if @results_list[context].nil?
-
-    @results_list[context] << arg_hash[:result_file]
-  end
-
-  def post_build
-    @results_list.each_key do |context|
-      results = @ceedling[:plugin_reportinator].assemble_test_results(@results_list[context])
-
-      artifact_filename = @ceedling[:configurator].project_config_hash[:xml_tests_report_artifact_filename] || 'report.xml'
-      artifact_fullpath = @ceedling[:configurator].project_config_hash[:xml_tests_report_path] || File.join(PROJECT_BUILD_ARTIFACTS_ROOT, context.to_s)
-      file_path = File.join(artifact_fullpath, artifact_filename)
-
-      @ceedling[:file_wrapper].open(file_path, 'w') do |f|
-        @test_counter = 1
-        write_results(results, f)
-      end
-    end
-  end
-
-  private
-
-  def write_results(results, stream)
-    write_header(stream)
-    write_failures(results[:failures], stream)
-    write_tests(results[:successes], stream, 'SuccessfulTests')
-    write_tests(results[:ignores], stream, 'IgnoredTests')
-    write_statistics(results[:counts], stream)
-    write_footer(stream)
-  end
-
-  def write_header(stream)
-    stream.puts "<?xml version='1.0' encoding='utf-8' ?>"
-    stream.puts '<TestRun>'
-  end
-
-  def write_failures(results, stream)
-    if results.size.zero?
-      stream.puts "\t<FailedTests/>"
-      return
-    end
-
-    stream.puts "\t<FailedTests>"
-
-    results.each do |result|
-      result[:collection].each do |item|
-        filename = File.join(result[:source][:path], result[:source][:file])
-
-        stream.puts "\t\t<Test id=\"#{@test_counter}\">"
-        stream.puts "\t\t\t<Name>#{filename}::#{item[:test]}</Name>"
-        stream.puts "\t\t\t<FailureType>Assertion</FailureType>"
-        stream.puts "\t\t\t<Location>"
-        stream.puts "\t\t\t\t<File>#{filename}</File>"
-        stream.puts "\t\t\t\t<Line>#{item[:line]}</Line>"
-        stream.puts "\t\t\t</Location>"
-        stream.puts "\t\t\t<Message>#{item[:message]}</Message>"
-        stream.puts "\t\t</Test>"
-        @test_counter += 1
-      end
-    end
-
-    stream.puts "\t</FailedTests>"
-  end
-
-  def write_tests(results, stream, tag)
-    if results.size.zero?
-      stream.puts "\t<#{tag}/>"
-      return
-    end
-
-    stream.puts "\t<#{tag}>"
-
-    results.each do |result|
-      result[:collection].each do |item|
-        stream.puts "\t\t<Test id=\"#{@test_counter}\">"
-        stream.puts "\t\t\t<Name>#{File.join(result[:source][:path], result[:source][:file])}::#{item[:test]}</Name>"
-        stream.puts "\t\t</Test>"
-        @test_counter += 1
-      end
-    end
-
-    stream.puts "\t</#{tag}>"
-  end
-
-  def write_statistics(counts, stream)
-    stream.puts "\t<Statistics>"
-    stream.puts "\t\t<Tests>#{counts[:total]}</Tests>"
-    stream.puts "\t\t<Ignores>#{counts[:ignored]}</Ignores>"
-    stream.puts "\t\t<FailuresTotal>#{counts[:failed]}</FailuresTotal>"
-    stream.puts "\t\t<Errors>0</Errors>"
-    stream.puts "\t\t<Failures>#{counts[:failed]}</Failures>"
-    stream.puts "\t</Statistics>"
-  end
-
-  def write_footer(stream)
-    stream.puts '</TestRun>'
-  end
-end

data/spec/build_invoker_utils_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'ceedling/build_invoker_utils'
-require 'ceedling/constants'
-require 'ceedling/streaminator'
-require 'ceedling/configurator'
-
-describe BuildInvokerUtils do
-  before(:each) do
-    # this will always be mocked
-    @configurator = Configurator.new({:configurator_setup => nil, :configurator_builder => nil,
-                                      :configurator_plugins => nil, :cmock_builder => nil,
-                                      :yaml_wrapper => nil, :system_wrapper => nil})
-    @streaminator = Streaminator.new({:streaminator_helper => nil, :verbosinator => nil,
-                                      :loginator => nil, :stream_wrapper => nil})
-
-    # this is what is being tested
-    @bi_utils = described_class.new({:configurator => @configurator, :streaminator => @streaminator})
- 
-    # these keep the actual test cleaner
-    @exception_msg = 'Don\'t know how to build task \'xyz\''
-    @basic_msg =  "ERROR: Rake could not find file referenced in source or test: 'xyz'. Possible stale dependency."
-    @deep_dep_msg = "Try fixing #include statements or adding missing file. Then run '#{REFRESH_TASK_ROOT}#{TEST_SYM.to_s}' task and try again."
-    @exception = RuntimeError.new(@exception_msg)
-  end
-  
-  describe '#process_exception' do
-
-    it 'passes given error if message does not contain handled messagr' do
-      expect{@bi_utils.process_exception(ArgumentError.new('oops...'), TEST_SYM)}.to raise_error(ArgumentError)
-    end
-
-    it 'prints to stderr for test with test_build flag set true' do
-      allow(@streaminator).to receive(:stderr_puts).with(@basic_msg)
-      allow(@configurator).to receive(:project_use_deep_dependencies).and_return(false)
-      expect{@bi_utils.process_exception(@exception, TEST_SYM, true)}.to raise_error(RuntimeError)
-    end
-
-    it 'prints to stderr for test with test_build flag set false' do
-      allow(@streaminator).to receive(:stderr_puts).with(@basic_msg.sub(' or test', ''))
-      allow(@configurator).to receive(:project_use_deep_dependencies).and_return(false)
-      expect{@bi_utils.process_exception(@exception, TEST_SYM, false)}.to raise_error(RuntimeError)
-    end
-
-    it 'prints to stderr with extra message when deep dependencies is true' do
-      allow(@streaminator).to receive(:stderr_puts).with(@basic_msg.sub(' or test', ''))
-      allow(@configurator).to receive(:project_use_deep_dependencies).and_return(true)
-      allow(@streaminator).to receive(:stderr_puts).with(@deep_dep_msg)
-      
-      expect{@bi_utils.process_exception(@exception, TEST_SYM, false)}.to raise_error(RuntimeError)
-    end
-
-
-  end
-end

data/spec/ceedling_spec.rb

@@ -1,154 +0,0 @@
-require 'spec_helper'
-require 'ceedling'
-
-describe 'Ceedling' do
-  context 'location' do
-    it 'should return the location of the ceedling gem directory' do
-      # create test state/variables
-      ceedling_path = File.join(File.dirname(__FILE__), '..').gsub('spec','lib')
-      # mocks/stubs/expected calls
-      # execute method
-      location = Ceedling.location
-      # validate results
-      expect(location).to eq(ceedling_path)
-    end
-  end
-
-  context 'load_path' do
-    it 'should return the location of the plugins directory' do
-      # create test state/variables
-      load_path = File.join(File.dirname(__FILE__), '..').gsub('spec','lib')
-      load_path = File.join( load_path, 'plugins' )
-      # mocks/stubs/expected calls
-      # execute method
-      location = Ceedling.load_path
-      # validate results
-      expect(location).to eq(load_path)
-    end
-  end
-
-  context 'rakefile' do
-    it 'should return the location of the ceedling rakefile' do
-      # create test state/variables
-      rakefile_path = File.join(File.dirname(__FILE__), '..').gsub('spec','lib')
-      rakefile_path = File.join( rakefile_path, 'lib', 'ceedling', 'rakefile.rb' )
-      # mocks/stubs/expected calls
-      # execute method
-      location = Ceedling.rakefile
-      # validate results
-      expect(location).to eq(rakefile_path)
-    end
-  end
-
-  context 'load_project' do
-    it 'should load the project with the default yaml file' do
-      # create test state/variables
-      ENV.delete('CEEDLING_MAIN_PROJECT_FILE')
-      rakefile_path = File.join(File.dirname(__FILE__), '..').gsub('spec','lib')
-      rakefile_path = File.join( rakefile_path, 'lib', 'ceedling', 'rakefile.rb' )
-      # mocks/stubs/expected calls
-      expect(Ceedling).to receive(:load).with(rakefile_path)
-      # execute method
-      Ceedling.load_project
-      # validate results
-      expect(ENV['CEEDLING_MAIN_PROJECT_FILE']).to eq('./project.yml')
-    end
-
-    it 'should load the project with the specified yaml file' do
-      # create test state/variables
-      ENV.delete('CEEDLING_MAIN_PROJECT_FILE')
-      rakefile_path = File.join(File.dirname(__FILE__), '..').gsub('spec','lib')
-      rakefile_path = File.join( rakefile_path, 'lib', 'ceedling', 'rakefile.rb' )
-      # mocks/stubs/expected calls
-      expect(Ceedling).to receive(:load).with(rakefile_path)
-      # execute method
-      Ceedling.load_project(config: './foo.yml')
-      # validate results
-      expect(ENV['CEEDLING_MAIN_PROJECT_FILE']).to eq('./foo.yml')
-    end
-
-    it 'should load the project with the yaml file specified by the existing environment variable' do
-      # create test state/variables
-      ENV['CEEDLING_MAIN_PROJECT_FILE'] = './bar.yml'
-      rakefile_path = File.join(File.dirname(__FILE__), '..').gsub('spec','lib')
-      rakefile_path = File.join( rakefile_path, 'lib', 'ceedling', 'rakefile.rb' )
-      # mocks/stubs/expected calls
-      expect(Ceedling).to receive(:load).with(rakefile_path)
-      # execute method
-      Ceedling.load_project
-      # validate results
-      expect(ENV['CEEDLING_MAIN_PROJECT_FILE']).to eq('./bar.yml')
-    end
-
-    it 'should load the project with the specified plugins enabled' do
-      # create test state/variables
-      DEFAULT_CEEDLING_CONFIG[:plugins][:enabled].clear()
-      DEFAULT_CEEDLING_CONFIG[:plugins][:load_paths].clear()
-      spec_double = double('spec-double')
-      rakefile_path = File.join(File.dirname(__FILE__), '..').gsub('spec','lib')
-      rakefile_path = File.join( rakefile_path, 'lib', 'ceedling', 'rakefile.rb' )
-      # mocks/stubs/expected calls
-      expect(Gem::Specification).to receive(:find_by_name).with('ceedling-foo').and_return(spec_double)
-      expect(spec_double).to receive(:gem_dir).and_return('dummy/path')
-      expect(Ceedling).to receive(:require).with('ceedling/defaults')
-      expect(Ceedling).to receive(:load).with(rakefile_path)
-      # execute method
-      Ceedling.load_project( config:  './foo.yml',
-                             plugins: ['foo'])
-      # validate results
-      expect(ENV['CEEDLING_MAIN_PROJECT_FILE']).to eq('./foo.yml')
-    end
-
-    it 'should set the project root if the root key is provided' do
-      # create test state/variables
-      Object.send(:remove_const, :PROJECT_ROOT)
-      DEFAULT_CEEDLING_CONFIG[:plugins][:enabled].clear()
-      DEFAULT_CEEDLING_CONFIG[:plugins][:load_paths].clear()
-      rakefile_path = File.join(File.dirname(__FILE__), '..').gsub('spec','lib')
-      rakefile_path = File.join( rakefile_path, 'lib', 'ceedling', 'rakefile.rb' )
-      # mocks/stubs/expected calls
-      expect(Ceedling).to receive(:load).with(rakefile_path)
-      # execute method
-      Ceedling.load_project( config:  './foo.yml',
-                             root:    './')
-      # validate results
-      expect(ENV['CEEDLING_MAIN_PROJECT_FILE']).to eq('./foo.yml')
-      expect(PROJECT_ROOT).to eq('./')
-    end
-  end
-
-  context 'register_plugin' do
-    it 'should register a plugin' do
-      # create test state/variables
-      DEFAULT_CEEDLING_CONFIG[:plugins][:enabled].clear()
-      DEFAULT_CEEDLING_CONFIG[:plugins][:load_paths].clear()
-      spec_double = double('spec-double')
-      # mocks/stubs/expected calls
-      expect(Gem::Specification).to receive(:find_by_name).with('ceedling-foo').and_return(spec_double)
-      expect(spec_double).to receive(:gem_dir).and_return('dummy/path')
-      expect(Ceedling).to receive(:require).with('ceedling/defaults')
-      # execute method
-      Ceedling.register_plugin('foo')
-      # validate results
-      expect(DEFAULT_CEEDLING_CONFIG[:plugins][:enabled]).to eq ["foo"]
-      expect(DEFAULT_CEEDLING_CONFIG[:plugins][:load_paths]).to eq(["dummy/path"])
-    end
-
-    it 'should register a plugin with an alternative prefix' do
-      # create test state/variables
-      DEFAULT_CEEDLING_CONFIG[:plugins][:enabled].clear()
-      DEFAULT_CEEDLING_CONFIG[:plugins][:load_paths].clear()
-      spec_double = double('spec-double')
-      # mocks/stubs/expected calls
-      expect(Gem::Specification).to receive(:find_by_name).with('prefix-foo').and_return(spec_double)
-      expect(spec_double).to receive(:gem_dir).and_return('dummy/path')
-      expect(Ceedling).to receive(:require).with('ceedling/defaults')
-      # execute method
-      Ceedling.register_plugin('foo','prefix-')
-      # validate results
-      expect(DEFAULT_CEEDLING_CONFIG[:plugins][:enabled]).to eq(["foo"])
-      expect(DEFAULT_CEEDLING_CONFIG[:plugins][:load_paths]).to eq(["dummy/path"])
-    end
-  end
-end
-

data/spec/par_map_spec.rb

@@ -1,57 +0,0 @@
-require 'ceedling/par_map'
-
-def short_task_should(n)
-  done_count = 0
-  par_map(n, [0.01] * (n - 1) + [0] * 10) do |seconds|
-    sleep(seconds)
-    if seconds == 1 then
-      done_count.should >= 10
-    else
-      done_count += 1
-    end
-  end
-end
-
-describe "par_map" do
-  it "should run shorter tasks while larger tasks are blocking (with 2 threads)" do
-    short_task_should(2)
-  end
-
-  it "should run shorter tasks while larger tasks are blocking (with 3 threads)" do
-    short_task_should(3)
-  end
-
-  it "should run shorter tasks while larger tasks are blocking (with 4 threads)" do
-    short_task_should(4)
-  end
-
-  #the following two tests are still slightly nondeterministic and may occasionally
-  #  show false positives (though we think we've gotten it pretty stable)
-  it "should collide if multiple threads are used" do
-    is_running = false
-    # we are trying to maximize the potential for collision by varying the sleep
-    #  delay between threads
-    collision = false
-    par_map(4, (1..5).to_a) do |x|
-      if is_running then
-        collision = true
-      end
-      is_running = true
-      sleep(0.01 * x)
-      is_running = false
-    end
-    expect(collision).to eq true
-  end
-
-  it "should be serial if only one thread is used" do
-    is_running = false
-    par_map(1, (1..5).to_a) do |x|
-      expect(is_running).to eq false
-      is_running = true
-      sleep(0.01 * x)
-      is_running = false
-    end
-  end
-
-
-end