win32-api 1.5.3-universal-mingw32 → 1.6.0-universal-mingw32

data/vendor/bundle/ruby/2.2.0/gems/rake-11.1.2/test/test_rake_backtrace.rb

@@ -0,0 +1,119 @@
+require File.expand_path('../helper', __FILE__)
+require 'open3'
+
+class TestBacktraceSuppression < Rake::TestCase
+  def test_bin_rake_suppressed
+    paths = ["something/bin/rake:12"]
+
+    actual = Rake::Backtrace.collapse(paths)
+
+    assert_equal [], actual
+  end
+
+  def test_system_dir_suppressed
+    path = RbConfig::CONFIG['rubylibprefix']
+    skip if path.nil?
+    path = File.expand_path path
+
+    paths = [path + ":12"]
+
+    actual = Rake::Backtrace.collapse(paths)
+
+    assert_equal [], actual
+  end
+
+  def test_near_system_dir_isnt_suppressed
+    path = RbConfig::CONFIG['rubylibprefix']
+    skip if path.nil?
+    path = File.expand_path path
+
+    paths = [" " + path + ":12"]
+
+    actual = Rake::Backtrace.collapse(paths)
+
+    assert_equal paths, actual
+  end
+end
+
+class TestRakeBacktrace < Rake::TestCase
+  include RubyRunner
+
+  def setup
+    super
+
+    skip 'tmpdir is suppressed in backtrace' if
+      Rake::Backtrace::SUPPRESS_PATTERN =~ Dir.pwd
+  end
+
+  def invoke(*args)
+    rake(*args)
+    @err
+  end
+
+  def test_single_collapse
+    rakefile %q{
+      task :foo do
+        raise "foooo!"
+      end
+    }
+
+    lines = invoke("foo").split("\n")
+
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "foooo!", lines[1]
+    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!i, lines
+    assert_something_matches %r!\ATasks:!, lines
+  end
+
+  def test_multi_collapse
+    rakefile %q{
+      task :foo do
+        Rake.application.invoke_task(:bar)
+      end
+      task :bar do
+        raise "barrr!"
+      end
+    }
+
+    lines = invoke("foo").split("\n")
+
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "barrr!", lines[1]
+    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:6!i, lines
+    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!i, lines
+    assert_something_matches %r!\ATasks:!, lines
+  end
+
+  def test_suppress_option
+    rakefile %q{
+      task :baz do
+        raise "bazzz!"
+      end
+    }
+
+    lines = invoke("baz").split("\n")
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "bazzz!", lines[1]
+    assert_something_matches %r!Rakefile!i, lines
+
+    lines = invoke("--suppress-backtrace", ".ak.file", "baz").split("\n")
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "bazzz!", lines[1]
+    refute_match %r!Rakefile!i, lines[2]
+  end
+
+  private
+
+  # Assert that the pattern matches at least one line in +lines+.
+  def assert_something_matches(pattern, lines)
+    lines.each do |ln|
+      if pattern =~ ln
+        assert_match pattern, ln
+        return
+      end
+    end
+    flunk "expected #{pattern.inspect} to match something in:\n" +
+      "#{lines.join("\n    ")}"
+  end
+
+end

data/vendor/bundle/ruby/2.2.0/gems/rake-11.1.2/test/test_rake_clean.rb

@@ -0,0 +1,61 @@
+require File.expand_path('../helper', __FILE__)
+require 'rake/clean'
+
+class TestRakeClean < Rake::TestCase
+  def test_clean
+    load 'rake/clean.rb', true
+
+    assert Rake::Task['clean'], "Should define clean"
+    assert Rake::Task['clobber'], "Should define clobber"
+    assert Rake::Task['clobber'].prerequisites.include?("clean"),
+      "Clobber should require clean"
+  end
+
+  def test_cleanup
+    file_name = create_undeletable_file
+
+    out, _ = capture_io do
+      Rake::Cleaner.cleanup(file_name, :verbose => false)
+    end
+    assert_match(/failed to remove/i, out)
+
+  ensure
+    remove_undeletable_file
+  end
+
+  def test_cleanup_ignores_missing_files
+    file_name = File.join(@tempdir, "missing_directory", "no_such_file")
+
+    out, _ = capture_io do
+      Rake::Cleaner.cleanup(file_name, :verbose => false)
+    end
+    refute_match(/failed to remove/i, out)
+  end
+
+  private
+
+  def create_undeletable_file
+    dir_name = File.join(@tempdir, "deletedir")
+    file_name = File.join(dir_name, "deleteme")
+    FileUtils.mkdir(dir_name)
+    FileUtils.touch(file_name)
+    FileUtils.chmod(0, file_name)
+    FileUtils.chmod(0, dir_name)
+    begin
+      FileUtils.chmod(0644, file_name)
+    rescue
+      file_name
+    else
+      skip "Permission to delete files is different on thie system"
+    end
+  end
+
+  def remove_undeletable_file
+    dir_name = File.join(@tempdir, "deletedir")
+    file_name = File.join(dir_name, "deleteme")
+    FileUtils.chmod(0777, dir_name)
+    FileUtils.chmod(0777, file_name)
+    Rake::Cleaner.cleanup(file_name, :verbose => false)
+    Rake::Cleaner.cleanup(dir_name, :verbose => false)
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/rake-11.1.2/test/test_rake_cpu_counter.rb

@@ -0,0 +1,68 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeCpuCounter < Rake::TestCase
+
+  def setup
+    super
+
+    @cpu_counter = Rake::CpuCounter.new
+  end
+
+  def test_count
+    num = @cpu_counter.count
+    skip 'cannot count CPU' if num == nil
+    assert_kind_of Numeric, num
+    assert_operator num, :>=, 1
+  end
+
+  def test_count_with_default_nil
+    def @cpu_counter.count; nil; end
+    assert_equal(8, @cpu_counter.count_with_default(8))
+    assert_equal(4, @cpu_counter.count_with_default)
+  end
+
+  def test_count_with_default_raise
+    def @cpu_counter.count; raise; end
+    assert_equal(8, @cpu_counter.count_with_default(8))
+    assert_equal(4, @cpu_counter.count_with_default)
+  end
+
+  class TestClassMethod < Rake::TestCase
+    def setup
+      super
+
+      @klass = Class.new(Rake::CpuCounter)
+    end
+
+    def test_count
+      @klass.class_eval do
+        def count; 8; end
+      end
+      assert_equal(8, @klass.count)
+    end
+
+    def test_count_nil
+      counted = false
+      @klass.class_eval do
+        define_method(:count) do
+          counted = true
+          nil
+        end
+      end
+      assert_equal(4, @klass.count)
+      assert_equal(true, counted)
+    end
+
+    def test_count_raise
+      counted = false
+      @klass.class_eval do
+        define_method(:count) do
+          counted = true
+          raise
+        end
+      end
+      assert_equal(4, @klass.count)
+      assert_equal(true, counted)
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/rake-11.1.2/test/test_rake_definitions.rb

@@ -0,0 +1,84 @@
+require File.expand_path('../helper', __FILE__)
+require 'fileutils'
+
+class TestRakeDefinitions < Rake::TestCase
+  include Rake
+
+  EXISTINGFILE = "existing"
+
+  def setup
+    super
+
+    Task.clear
+  end
+
+  def test_task
+    done = false
+    task :one => [:two] do done = true end
+    task :two
+    task :three => [:one, :two]
+    check_tasks(:one, :two, :three)
+    assert done, "Should be done"
+  end
+
+  def test_file_task
+    done = false
+    file "one" => "two" do done = true end
+    file "two"
+    file "three" => ["one", "two"]
+    check_tasks("one", "two", "three")
+    assert done, "Should be done"
+  end
+
+  def check_tasks(n1, n2, n3)
+    t = Task[n1]
+    assert Task === t, "Should be a Task"
+    assert_equal n1.to_s, t.name
+    assert_equal [n2.to_s], t.prerequisites.map { |n| n.to_s }
+    t.invoke
+    t2 = Task[n2]
+    assert_equal FileList[], t2.prerequisites
+    t3 = Task[n3]
+    assert_equal [n1.to_s, n2.to_s], t3.prerequisites.map { |n| n.to_s }
+  end
+
+  def test_incremental_definitions
+    runs = []
+    task :t1 => [:t2] do runs << "A"; 4321 end
+    task :t1 => [:t3] do runs << "B"; 1234 end
+    task :t1 => [:t3]
+    task :t2
+    task :t3
+    Task[:t1].invoke
+    assert_equal ["A", "B"], runs
+    assert_equal ["t2", "t3"], Task[:t1].prerequisites
+  end
+
+  def test_missing_dependencies
+    task :x => ["missing"]
+    assert_raises(RuntimeError) { Task[:x].invoke }
+  end
+
+  def test_falsey_dependencies
+    task :x => nil
+    assert_equal [], Task[:x].prerequisites
+  end
+
+  def test_implicit_file_dependencies
+    runs = []
+    create_existing_file
+    task :y => [EXISTINGFILE] do |t| runs << t.name end
+    Task[:y].invoke
+    assert_equal runs, ['y']
+  end
+
+  private # ----------------------------------------------------------
+
+  def create_existing_file
+    Dir.mkdir File.dirname(EXISTINGFILE) unless
+      File.exist?(File.dirname(EXISTINGFILE))
+    open(EXISTINGFILE, "w") do |f| f.puts "HI" end unless
+      File.exist?(EXISTINGFILE)
+  end
+
+end

data/vendor/bundle/ruby/2.2.0/gems/rake-11.1.2/test/test_rake_directory_task.rb

@@ -0,0 +1,76 @@
+require File.expand_path('../helper', __FILE__)
+require 'fileutils'
+require 'pathname'
+
+class TestRakeDirectoryTask < Rake::TestCase
+  include Rake
+
+  def test_directory
+    desc "DESC"
+
+    directory "a/b/c"
+
+    assert_equal FileCreationTask, Task["a"].class
+    assert_equal FileCreationTask, Task["a/b"].class
+    assert_equal FileCreationTask, Task["a/b/c"].class
+
+    assert_nil             Task["a"].comment
+    assert_nil             Task["a/b"].comment
+    assert_equal "DESC",   Task["a/b/c"].comment
+
+    verbose(false) {
+      Task['a/b'].invoke
+    }
+
+    assert File.exist?("a/b")
+    refute File.exist?("a/b/c")
+  end
+
+  def test_directory_colon
+    directory "a:b"
+
+    assert_equal FileCreationTask, Task['a:b'].class
+  end unless Rake::Win32.windows?
+
+  if Rake::Win32.windows?
+    def test_directory_win32
+      desc "WIN32 DESC"
+      directory 'c:/a/b/c'
+      assert_equal FileTask, Task['c:'].class
+      assert_equal FileCreationTask, Task['c:/a'].class
+      assert_equal FileCreationTask, Task['c:/a/b'].class
+      assert_equal FileCreationTask, Task['c:/a/b/c'].class
+      assert_nil             Task['c:/'].comment
+      assert_equal "WIN32 DESC",   Task['c:/a/b/c'].comment
+      assert_nil             Task['c:/a/b'].comment
+    end
+  end
+
+  def test_can_use_blocks
+    runlist = []
+
+    t1 = directory("a/b/c" => :t2) { |t| runlist << t.name }
+    task(:t2) { |t| runlist << t.name }
+
+    verbose(false) {
+      t1.invoke
+    }
+
+    assert_equal Task["a/b/c"], t1
+    assert_equal FileCreationTask, Task["a/b/c"].class
+    assert_equal ["t2", "a/b/c"], runlist
+    assert File.directory?("a/b/c")
+  end
+
+  def test_can_use_pathname
+    directory Pathname.new "a/b/c"
+
+    assert_equal FileCreationTask, Task["a/b/c"].class
+
+    verbose(false) {
+      Task['a/b/c'].invoke
+    }
+
+    assert File.directory?("a/b/c")
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/rake-11.1.2/test/test_rake_dsl.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeDsl < Rake::TestCase
+
+  def setup
+    super
+    Rake::Task.clear
+  end
+
+  def test_namespace_command
+    namespace "n" do
+      task "t"
+    end
+    refute_nil Rake::Task["n:t"]
+  end
+
+  def test_namespace_command_with_bad_name
+    ex = assert_raises(ArgumentError) do
+      namespace 1 do end
+    end
+    assert_match(/string/i, ex.message)
+    assert_match(/symbol/i, ex.message)
+  end
+
+  def test_namespace_command_with_a_string_like_object
+    name = Object.new
+    def name.to_str
+      "bob"
+    end
+    namespace name do
+      task "t"
+    end
+    refute_nil Rake::Task["bob:t"]
+  end
+
+  def test_no_commands_constant
+    assert ! defined?(Commands), "should not define Commands"
+  end
+
+end