rake 10.4.2 → 13.0.3

data/test/test_rake_test_task.rb

@@ -1,146 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'rake/testtask'
-
-class TestRakeTestTask < Rake::TestCase
-  include Rake
-
-  def test_initialize
-    tt = Rake::TestTask.new do |t| end
-    refute_nil tt
-    assert_equal :test, tt.name
-    assert_equal ['lib'], tt.libs
-    assert_equal 'test/test*.rb', tt.pattern
-    assert_equal false, tt.verbose
-    assert Task.task_defined?(:test)
-  end
-
-  def test_initialize_override
-    tt = Rake::TestTask.new(:example) do |t|
-      t.description = "Run example tests"
-      t.libs = ['src', 'ext']
-      t.pattern = 'test/tc_*.rb'
-      t.verbose = true
-    end
-    refute_nil tt
-    assert_equal "Run example tests", tt.description
-    assert_equal :example, tt.name
-    assert_equal ['src', 'ext'], tt.libs
-    assert_equal 'test/tc_*.rb', tt.pattern
-    assert_equal true, tt.verbose
-    assert Task.task_defined?(:example)
-  end
-
-  def test_file_list_env_test
-    ENV['TEST'] = 'testfile.rb'
-    tt = Rake::TestTask.new do |t|
-      t.pattern = '*'
-    end
-
-    assert_equal ["testfile.rb"], tt.file_list.to_a
-  ensure
-    ENV.delete 'TEST'
-  end
-
-  def test_libs_equals
-    test_task = Rake::TestTask.new do |t|
-      t.libs << ["A", "B"]
-    end
-
-    path = %w[lib A B].join File::PATH_SEPARATOR
-
-    assert_equal "-I\"#{path}\"", test_task.ruby_opts_string
-  end
-
-  def test_libs_equals_empty
-    test_task = Rake::TestTask.new do |t|
-      t.libs = []
-    end
-
-    assert_equal '', test_task.ruby_opts_string
-  end
-
-  def test_pattern_equals
-    tt = Rake::TestTask.new do |t|
-      t.pattern = '*.rb'
-    end
-    assert_equal ['*.rb'], tt.file_list.to_a
-  end
-
-  def test_pattern_equals_test_files_equals
-    tt = Rake::TestTask.new do |t|
-      t.test_files = FileList['a.rb', 'b.rb']
-      t.pattern = '*.rb'
-    end
-    assert_equal ['a.rb', 'b.rb', '*.rb'], tt.file_list.to_a
-  end
-
-  def test_run_code_direct
-    test_task = Rake::TestTask.new do |t|
-      t.loader = :direct
-    end
-
-    assert_equal '-e "ARGV.each{|f| require f}"', test_task.run_code
-  end
-
-  def test_run_code_rake
-    spec = Gem::Specification.new 'rake', 0
-    spec.loaded_from = File.join Gem::Specification.dirs.last, 'rake-0.gemspec'
-    rake, Gem.loaded_specs['rake'] = Gem.loaded_specs['rake'], spec
-
-    test_task = Rake::TestTask.new do |t|
-      t.loader = :rake
-    end
-
-    assert_match(/\A-I".*?" ".*?"\Z/, test_task.run_code)
-  ensure
-    Gem.loaded_specs['rake'] = rake
-  end
-
-  def test_run_code_rake_default_gem
-    skip 'this ruby does not have default gems' unless
-      Gem::Specification.method_defined? :default_specifications_dir
-
-    default_spec = Gem::Specification.new 'rake', 0
-    default_spec.loaded_from = File.join Gem::Specification.default_specifications_dir, 'rake-0.gemspec'
-    begin
-      rake, Gem.loaded_specs['rake'] = Gem.loaded_specs['rake'], default_spec
-
-      test_task = Rake::TestTask.new do |t|
-        t.loader = :rake
-      end
-
-      assert_match(/\A(-I".*?" *)* ".*?"\Z/, test_task.run_code)
-    ensure
-      Gem.loaded_specs['rake'] = rake
-    end
-  end
-
-  def test_run_code_testrb_ruby_1_8_2
-    test_task = Rake::TestTask.new do |t|
-      t.loader = :testrb
-    end
-
-    def test_task.ruby_version() '1.8.2' end
-
-    assert_match(/^-S testrb +".*"$/, test_task.run_code)
-  end
-
-  def test_run_code_testrb_ruby_1_8_6
-    test_task = Rake::TestTask.new do |t|
-      t.loader = :testrb
-    end
-
-    def test_task.ruby_version() '1.8.6' end
-
-    assert_match(/^-S testrb +$/, test_task.run_code)
-  end
-
-  def test_test_files_equals
-    tt = Rake::TestTask.new do |t|
-      t.test_files = FileList['a.rb', 'b.rb']
-    end
-
-    assert_equal ["a.rb", 'b.rb'], tt.file_list.to_a
-  end
-
-end

data/test/test_rake_thread_pool.rb

@@ -1,145 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'rake/thread_pool'
-
-class TestRakeTestThreadPool < Rake::TestCase
-  include Rake
-
-  def test_pool_executes_in_current_thread_for_zero_threads
-    pool = ThreadPool.new(0)
-    f = pool.future { Thread.current }
-    pool.join
-    assert_equal Thread.current, f.value
-  end
-
-  def test_pool_executes_in_other_thread_for_pool_of_size_one
-    pool = ThreadPool.new(1)
-    f = pool.future { Thread.current }
-    pool.join
-    refute_equal Thread.current, f.value
-  end
-
-  def test_pool_executes_in_two_other_threads_for_pool_of_size_two
-    pool = ThreadPool.new(2)
-    threads = 2.times.map {
-      pool.future {
-        sleep 0.1
-        Thread.current
-      }
-    }.each { |f|
-      f.value
-    }
-
-    refute_equal threads[0], threads[1]
-    refute_equal Thread.current, threads[0]
-    refute_equal Thread.current, threads[1]
-  ensure
-    pool.join
-  end
-
-  def test_pool_creates_the_correct_number_of_threads
-    pool = ThreadPool.new(2)
-    threads = Set.new
-    t_mutex = Mutex.new
-    10.times.each do
-      pool.future do
-        sleep 0.02
-        t_mutex.synchronize { threads << Thread.current }
-      end
-    end
-    pool.join
-    assert_equal 2, threads.count
-  end
-
-  def test_pool_future_does_not_duplicate_arguments
-    pool = ThreadPool.new(2)
-    obj = Object.new
-    captured = nil
-    pool.future(obj) { |var| captured = var }
-    pool.join
-    assert_equal obj, captured
-  end
-
-  def test_pool_join_empties_queue
-    pool = ThreadPool.new(2)
-    repeat = 25
-    repeat.times {
-      pool.future do
-        repeat.times {
-          pool.future do
-            repeat.times {
-              pool.future do end
-            }
-          end
-        }
-      end
-    }
-
-    pool.join
-    assert_equal(
-      true,
-      pool.__send__(:__queue__).empty?,
-      "queue should be empty")
-  end
-
-  CustomError = Class.new(StandardError)
-
-  # test that throwing an exception way down in the blocks propagates
-  # to the top
-  def test_exceptions
-    pool = ThreadPool.new(10)
-
-    deep_exception_block = lambda do |count|
-      raise CustomError if count < 1
-      pool.future(count - 1, &deep_exception_block).value
-    end
-
-    assert_raises(CustomError) do
-      pool.future(2, &deep_exception_block).value
-    end
-  ensure
-    pool.join
-  end
-
-  def test_pool_prevents_deadlock
-    pool = ThreadPool.new(5)
-
-    common_dependency_a = pool.future { sleep 0.2 }
-    futures_a = 10.times.map {
-      pool.future {
-        common_dependency_a.value
-        sleep(rand() * 0.01)
-      }
-    }
-
-    common_dependency_b = pool.future { futures_a.each { |f| f.value } }
-    futures_b = 10.times.map {
-      pool.future {
-        common_dependency_b.value
-        sleep(rand() * 0.01)
-      }
-    }
-
-    futures_b.each { |f| f.value }
-    pool.join
-  end
-
-  def test_pool_reports_correct_results
-    pool = ThreadPool.new(7)
-
-    a = 18
-    b = 5
-    c = 3
-
-    result = a.times.map do
-      pool.future do
-        b.times.map do
-          pool.future { sleep rand * 0.001; c }
-        end.reduce(0) { |m, f| m + f.value }
-      end
-    end.reduce(0) { |m, f| m + f.value }
-
-    assert_equal a * b * c, result
-    pool.join
-  end
-
-end

data/test/test_rake_top_level_functions.rb

@@ -1,71 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestRakeTopLevelFunctions < Rake::TestCase
-
-  def setup
-    super
-
-    @app = Object.new
-
-    def @app.called
-      @called
-    end
-
-    def @app.method_missing(*a, &b)
-      @called ||= []
-      @called << [a, b]
-      nil
-    end
-
-    Rake.application = @app
-  end
-
-  def test_namespace
-    block = proc do end
-
-    namespace("xyz", &block)
-
-    expected = [
-      [[:in_namespace, 'xyz'], block]
-    ]
-
-    assert_equal expected, @app.called
-  end
-
-  def test_import
-    import('x', 'y', 'z')
-
-    expected = [
-      [[:add_import, 'x'], nil],
-      [[:add_import, 'y'], nil],
-      [[:add_import, 'z'], nil],
-    ]
-
-    assert_equal expected, @app.called
-  end
-
-  def test_when_writing
-    out, = capture_io do
-      when_writing("NOTWRITING") do
-        puts "WRITING"
-      end
-    end
-    assert_equal "WRITING\n", out
-  end
-
-  def test_when_not_writing
-    Rake::FileUtilsExt.nowrite_flag = true
-    _, err = capture_io do
-      when_writing("NOTWRITING") do
-        puts "WRITING"
-      end
-    end
-    assert_equal "DRYRUN: NOTWRITING\n", err
-  ensure
-    Rake::FileUtilsExt.nowrite_flag = false
-  end
-
-  def test_missing_other_constant
-    assert_raises(NameError) do Object.const_missing(:Xyz) end
-  end
-end

data/test/test_rake_win32.rb

@@ -1,72 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestRakeWin32 < Rake::TestCase
-
-  Win32 = Rake::Win32
-
-  def test_win32_system_dir_uses_home_if_defined
-    ENV['HOME'] = 'C:\\HP'
-
-    assert_equal "C:/HP/Rake", Win32.win32_system_dir
-  end
-
-  def test_win32_system_dir_uses_homedrive_homepath_when_no_home_defined
-    ENV['HOME']      = nil
-    ENV['HOMEDRIVE'] = 'C:'
-    ENV['HOMEPATH']  = '\\HP'
-
-    assert_equal "C:/HP/Rake", Win32.win32_system_dir
-  end
-
-  def test_win32_system_dir_uses_appdata_when_no_home_or_home_combo
-    ENV['APPDATA']   = "C:\\Documents and Settings\\HP\\Application Data"
-    ENV['HOME']      = nil
-    ENV['HOMEDRIVE'] = nil
-    ENV['HOMEPATH']  = nil
-
-    assert_equal "C:/Documents and Settings/HP/Application Data/Rake",
-                 Win32.win32_system_dir
-  end
-
-  def test_win32_system_dir_fallback_to_userprofile_otherwise
-    ENV['HOME']        = nil
-    ENV['HOMEDRIVE']   = nil
-    ENV['HOMEPATH']    = nil
-    ENV['APPDATA']     = nil
-    ENV['USERPROFILE'] = "C:\\Documents and Settings\\HP"
-
-    assert_equal "C:/Documents and Settings/HP/Rake", Win32.win32_system_dir
-  end
-
-  def test_win32_system_dir_nil_of_no_env_vars
-    ENV['APPDATA']     = nil
-    ENV['HOME']        = nil
-    ENV['HOMEDRIVE']   = nil
-    ENV['HOMEPATH']    = nil
-    ENV['RAKE_SYSTEM'] = nil
-    ENV['USERPROFILE'] = nil
-
-    assert_raises(Rake::Win32::Win32HomeError) do
-      Win32.win32_system_dir
-    end
-  end
-
-  def test_win32_backtrace_with_different_case
-    ex = nil
-    begin
-     raise 'test exception'
-    rescue => ex
-    end
-
-    ex.set_backtrace ['abc', 'rakefile']
-
-    rake = Rake::Application.new
-    rake.options.trace = true
-    rake.instance_variable_set(:@rakefile, 'Rakefile')
-
-    _, err = capture_io { rake.display_error_message(ex) }
-
-    assert_match(/rakefile/, err)
-  end
-
-end

data/test/test_thread_history_display.rb

@@ -1,101 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-require 'rake/thread_history_display'
-
-class TestThreadHistoryDisplay < Rake::TestCase
-  def setup
-    super
-    @time = 1_000_000
-    @stats = []
-    @display = Rake::ThreadHistoryDisplay.new(@stats)
-  end
-
-  def test_banner
-    out, _ = capture_io do
-      @display.show
-    end
-    assert_match(/Job History/i, out)
-  end
-
-  def test_item_queued
-    @stats << event(:item_queued,  :item_id => 123)
-    out, _ = capture_io do
-      @display.show
-    end
-    assert_match(/^ *1000000 +A +item_queued +item_id:1$/, out)
-  end
-
-  def test_item_dequeued
-    @stats << event(:item_dequeued,  :item_id => 123)
-    out, _ = capture_io do
-      @display.show
-    end
-    assert_match(/^ *1000000 +A +item_dequeued +item_id:1$/, out)
-  end
-
-  def test_multiple_items
-    @stats << event(:item_queued,  :item_id => 123)
-    @stats << event(:item_queued,  :item_id => 124)
-    out, _ = capture_io do
-      @display.show
-    end
-    assert_match(/^ *1000000 +A +item_queued +item_id:1$/, out)
-    assert_match(/^ *1000001 +A +item_queued +item_id:2$/, out)
-  end
-
-  def test_waiting
-    @stats << event(:waiting, :item_id => 123)
-    out, _ = capture_io do
-      @display.show
-    end
-    assert_match(/^ *1000000 +A +waiting +item_id:1$/, out)
-  end
-
-  def test_continue
-    @stats << event(:continue, :item_id => 123)
-    out, _ = capture_io do
-      @display.show
-    end
-    assert_match(/^ *1000000 +A +continue +item_id:1$/, out)
-  end
-
-  def test_thread_deleted
-    @stats << event(
-      :thread_deleted,
-      :deleted_thread => 123_456,
-      :thread_count => 12)
-    out, _ = capture_io do
-      @display.show
-    end
-    assert_match(
-      /^ *1000000 +A +thread_deleted( +deleted_thread:B| +thread_count:12){2}$/,
-      out)
-  end
-
-  def test_thread_created
-    @stats << event(
-      :thread_created,
-      :new_thread => 123_456,
-      :thread_count => 13)
-    out, _ = capture_io do
-      @display.show
-    end
-    assert_match(
-      /^ *1000000 +A +thread_created( +new_thread:B| +thread_count:13){2}$/,
-      out)
-  end
-
-  private
-
-  def event(type, data = {})
-    result = {
-      :event => type,
-      :time  => @time / 1_000_000.0,
-      :data  => data,
-      :thread => Thread.current.object_id
-    }
-    @time += 1
-    result
-  end
-
-end