guesswhat 0.1.0

data/vendor/bundle/gems/rake-10.5.0/test/test_rake_task_manager.rb

@@ -0,0 +1,178 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeTaskManager < Rake::TestCase
+
+  def setup
+    super
+
+    @tm = Rake::TestCase::TaskManager.new
+  end
+
+  def test_create_task_manager
+    refute_nil @tm
+    assert_equal [], @tm.tasks
+  end
+
+  def test_define_task
+    t = @tm.define_task(Rake::Task, :t)
+    assert_equal "t", t.name
+    assert_equal @tm, t.application
+  end
+
+  def test_index
+    e = assert_raises RuntimeError do
+      @tm['bad']
+    end
+
+    assert_equal "Don't know how to build task 'bad' (see --tasks)", e.message
+  end
+
+  def test_name_lookup
+    t = @tm.define_task(Rake::Task, :t)
+    assert_equal t, @tm[:t]
+  end
+
+  def test_namespace_task_create
+    @tm.in_namespace("x") do
+      t = @tm.define_task(Rake::Task, :t)
+      assert_equal "x:t", t.name
+    end
+    assert_equal ["x:t"], @tm.tasks.map { |t| t.name }
+  end
+
+  def test_define_namespaced_task
+    t = @tm.define_task(Rake::Task, 'n:a:m:e:t')
+    assert_equal Rake::Scope.make("e", "m", "a", "n"), t.scope
+    assert_equal "n:a:m:e:t", t.name
+    assert_equal @tm, t.application
+  end
+
+  def test_define_namespace_in_namespace
+    t = nil
+    @tm.in_namespace("n") do
+      t = @tm.define_task(Rake::Task, 'a:m:e:t')
+    end
+    assert_equal Rake::Scope.make("e", "m", "a", "n"), t.scope
+    assert_equal "n:a:m:e:t", t.name
+    assert_equal @tm, t.application
+  end
+
+  def test_anonymous_namespace
+    anon_ns = @tm.in_namespace(nil) do
+      t = @tm.define_task(Rake::Task, :t)
+      assert_equal "_anon_1:t", t.name
+    end
+    task = anon_ns[:t]
+    assert_equal "_anon_1:t", task.name
+  end
+
+  def test_create_filetask_in_namespace
+    @tm.in_namespace("x") do
+      t = @tm.define_task(Rake::FileTask, "fn")
+      assert_equal "fn", t.name
+    end
+
+    assert_equal ["fn"], @tm.tasks.map { |t| t.name }
+  end
+
+  def test_namespace_yields_same_namespace_as_returned
+    yielded_namespace = nil
+    returned_namespace = @tm.in_namespace("x") do |ns|
+      yielded_namespace = ns
+    end
+    assert_equal returned_namespace, yielded_namespace
+  end
+
+  def test_name_lookup_with_implicit_file_tasks
+    FileUtils.touch 'README.rdoc'
+
+    t = @tm["README.rdoc"]
+
+    assert_equal "README.rdoc", t.name
+    assert Rake::FileTask === t
+  end
+
+  def test_name_lookup_with_nonexistent_task
+    assert_raises(RuntimeError) {
+      @tm["DOES NOT EXIST"]
+    }
+  end
+
+  def test_name_lookup_in_multiple_scopes
+    aa = nil
+    bb = nil
+    xx = @tm.define_task(Rake::Task, :xx)
+    top_z = @tm.define_task(Rake::Task, :z)
+    @tm.in_namespace("a") do
+      aa = @tm.define_task(Rake::Task, :aa)
+      mid_z = @tm.define_task(Rake::Task, :z)
+      ns_d = @tm.define_task(Rake::Task, "n:t")
+      @tm.in_namespace("b") do
+        bb = @tm.define_task(Rake::Task, :bb)
+        bot_z = @tm.define_task(Rake::Task, :z)
+
+        assert_equal Rake::Scope.make("b", "a"), @tm.current_scope
+
+        assert_equal bb, @tm["a:b:bb"]
+        assert_equal aa, @tm["a:aa"]
+        assert_equal xx, @tm["xx"]
+        assert_equal bot_z, @tm["z"]
+        assert_equal mid_z, @tm["^z"]
+        assert_equal top_z, @tm["^^z"]
+        assert_equal top_z, @tm["^^^z"] # Over the top
+        assert_equal top_z, @tm["rake:z"]
+      end
+
+      assert_equal Rake::Scope.make("a"), @tm.current_scope
+
+      assert_equal bb, @tm["a:b:bb"]
+      assert_equal aa, @tm["a:aa"]
+      assert_equal xx, @tm["xx"]
+      assert_equal bb, @tm["b:bb"]
+      assert_equal aa, @tm["aa"]
+      assert_equal mid_z, @tm["z"]
+      assert_equal top_z, @tm["^z"]
+      assert_equal top_z, @tm["^^z"] # Over the top
+      assert_equal top_z, @tm["rake:z"]
+      assert_equal ns_d, @tm["n:t"]
+      assert_equal ns_d, @tm["a:n:t"]
+    end
+
+    assert_equal Rake::Scope.make, @tm.current_scope
+
+    assert_equal Rake::Scope.make, xx.scope
+    assert_equal Rake::Scope.make('a'), aa.scope
+    assert_equal Rake::Scope.make('b', 'a'), bb.scope
+  end
+
+  def test_lookup_with_explicit_scopes
+    t1, t2, t3, s = (0...4).map { nil }
+    t1 = @tm.define_task(Rake::Task, :t)
+    @tm.in_namespace("a") do
+      t2 = @tm.define_task(Rake::Task, :t)
+      s =  @tm.define_task(Rake::Task, :s)
+      @tm.in_namespace("b") do
+        t3 = @tm.define_task(Rake::Task, :t)
+      end
+    end
+    assert_equal t1, @tm[:t, Rake::Scope.make]
+    assert_equal t2, @tm[:t, Rake::Scope.make("a")]
+    assert_equal t3, @tm[:t, Rake::Scope.make("b", "a")]
+    assert_equal s,  @tm[:s, Rake::Scope.make("b", "a")]
+    assert_equal s,  @tm[:s, Rake::Scope.make("a")]
+  end
+
+  def test_correctly_scoped_prerequisites_are_invoked
+    values = []
+    @tm = Rake::Application.new
+    @tm.define_task(Rake::Task, :z) do values << "top z" end
+    @tm.in_namespace("a") do
+      @tm.define_task(Rake::Task, :z) do values << "next z" end
+      @tm.define_task(Rake::Task, :x => :z)
+    end
+
+    @tm["a:x"].invoke
+    assert_equal ["next z"], values
+  end
+
+end

data/vendor/bundle/gems/rake-10.5.0/test/test_rake_task_manager_argument_resolution.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeTaskManagerArgumentResolution < Rake::TestCase
+
+  def test_good_arg_patterns
+    assert_equal [:t, [], []],       task(:t)
+    assert_equal [:t, [], [:x]],     task(:t => :x)
+    assert_equal [:t, [], [:x, :y]], task(:t => [:x, :y])
+
+    assert_equal [:t, [:a, :b], []],       task(:t, [:a, :b])
+    assert_equal [:t, [:a, :b], [:x]],     task(:t, [:a, :b] => :x)
+    assert_equal [:t, [:a, :b], [:x, :y]], task(:t, [:a, :b] => [:x, :y])
+  end
+
+  def task(*args)
+    tm = Rake::TestCase::TaskManager.new
+    tm.resolve_args(args)
+  end
+end

data/vendor/bundle/gems/rake-10.5.0/test/test_rake_task_with_arguments.rb

@@ -0,0 +1,172 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeTaskWithArguments < Rake::TestCase
+  include Rake
+
+  def setup
+    super
+
+    Task.clear
+    Rake::TaskManager.record_task_metadata = true
+  end
+
+  def teardown
+    Rake::TaskManager.record_task_metadata = false
+    Rake.application.thread_pool.join
+
+    super
+  end
+
+  def test_no_args_given
+    t = task :t
+    assert_equal [], t.arg_names
+  end
+
+  def test_args_given
+    t = task :t, :a, :b
+    assert_equal [:a, :b], t.arg_names
+  end
+
+  def test_name_and_needs
+    t = task(:t => [:pre])
+    assert_equal "t", t.name
+    assert_equal [], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+  end
+
+  def test_name_args_and_prereqs
+    t = task(:t, [:x, :y] => [:pre])
+    assert_equal "t", t.name
+    assert_equal [:x, :y], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+  end
+
+  def test_arg_list_is_empty_if_no_args_given
+    t = task(:t) { |tt, args| assert_equal({}, args.to_hash) }
+    t.invoke(1, 2, 3)
+  end
+
+  def test_tasks_can_access_arguments_as_hash
+    t = task :t, :a, :b, :c do |tt, args|
+      assert_equal({:a => 1, :b => 2, :c => 3}, args.to_hash)
+      assert_equal 1, args[:a]
+      assert_equal 2, args[:b]
+      assert_equal 3, args[:c]
+      assert_equal 1, args.a
+      assert_equal 2, args.b
+      assert_equal 3, args.c
+    end
+    t.invoke(1, 2, 3)
+  end
+
+  def test_actions_of_various_arity_are_ok_with_args
+    notes = []
+    t = task(:t, :x) do
+      notes << :a
+    end
+    t.enhance do | |
+      notes << :b
+    end
+    t.enhance do |task|
+      notes << :c
+      assert_kind_of Task, task
+    end
+    t.enhance do |t2, args|
+      notes << :d
+      assert_equal t, t2
+      assert_equal({:x => 1}, args.to_hash)
+    end
+    t.invoke(1)
+    assert_equal [:a, :b, :c, :d], notes
+  end
+
+  def test_arguments_are_passed_to_block
+    t = task(:t, :a, :b) { |tt, args|
+      assert_equal({ :a => 1, :b => 2 }, args.to_hash)
+    }
+    t.invoke(1, 2)
+  end
+
+  def test_extra_parameters_are_ignored
+    t = task(:t, :a) { |tt, args|
+      assert_equal 1, args.a
+      assert_nil args.b
+    }
+    t.invoke(1, 2)
+  end
+
+  def test_arguments_are_passed_to_all_blocks
+    counter = 0
+    t = task :t, :a
+    task :t do |tt, args|
+      assert_equal 1, args.a
+      counter += 1
+    end
+    task :t do |tt, args|
+      assert_equal 1, args.a
+      counter += 1
+    end
+    t.invoke(1)
+    assert_equal 2, counter
+  end
+
+  def test_block_with_no_parameters_is_ok
+    t = task(:t) { }
+    t.invoke(1, 2)
+  end
+
+  def test_name_with_args
+    desc "T"
+    t = task(:tt, :a, :b)
+    assert_equal "tt", t.name
+    assert_equal "T", t.comment
+    assert_equal "[a,b]", t.arg_description
+    assert_equal "tt[a,b]", t.name_with_args
+    assert_equal [:a, :b], t.arg_names
+  end
+
+  def test_named_args_are_passed_to_prereqs
+    value = nil
+    task(:pre, :rev) { |t, args| value = args.rev }
+    t = task(:t, [:name, :rev] => [:pre])
+    t.invoke("bill", "1.2")
+    assert_equal "1.2", value
+  end
+
+  def test_args_not_passed_if_no_prereq_names_on_task
+    task(:pre) { |t, args|
+      assert_equal({}, args.to_hash)
+      assert_equal "bill", args.name
+    }
+    t = task(:t, [:name, :rev] => [:pre])
+    t.invoke("bill", "1.2")
+  end
+
+  def test_args_not_passed_if_no_prereq_names_on_multitask
+    task(:pre) { |t, args|
+      assert_equal({}, args.to_hash)
+      assert_equal "bill", args.name
+    }
+    t = multitask(:t, [:name, :rev] => [:pre])
+    t.invoke("bill", "1.2")
+  end
+
+  def test_args_not_passed_if_no_arg_names
+    task(:pre, :rev) { |t, args|
+      assert_equal({}, args.to_hash)
+    }
+    t = task(:t  => [:pre])
+    t.invoke("bill", "1.2")
+  end
+
+  def test_values_at
+    t = task(:pre, [:a, :b, :c]) { |task, args|
+      a, b, c = args.values_at(:a, :b, :c)
+      assert_equal %w[1 2 3], [a, b, c]
+    }
+
+    t.invoke(*%w[1 2 3])
+
+    # HACK no assertions
+  end
+end

data/vendor/bundle/gems/rake-10.5.0/test/test_rake_test_task.rb

@@ -0,0 +1,146 @@
+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/vendor/bundle/gems/rake-10.5.0/test/test_rake_thread_pool.rb

@@ -0,0 +1,145 @@
+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