colorcode_convert_rgb 0.1.0

data/vendor/bundle/ruby/2.5.0/gems/minitest-5.14.2/test/minitest/test_minitest_benchmark.rb

@@ -0,0 +1,137 @@
+require "minitest/autorun"
+require "minitest/benchmark"
+
+##
+# Used to verify data:
+# http://www.wolframalpha.com/examples/RegressionAnalysis.html
+
+class TestMinitestBenchmark < Minitest::Test
+  def test_cls_bench_exp
+    assert_equal [2, 4, 8, 16, 32], Minitest::Benchmark.bench_exp(2, 32, 2)
+  end
+
+  def test_cls_bench_linear
+    assert_equal [2, 4, 6, 8, 10], Minitest::Benchmark.bench_linear(2, 10, 2)
+  end
+
+  def test_cls_runnable_methods
+    assert_equal [], Minitest::Benchmark.runnable_methods
+
+    c = Class.new(Minitest::Benchmark) do
+      def bench_blah
+      end
+    end
+
+    assert_equal ["bench_blah"], c.runnable_methods
+  end
+
+  def test_cls_bench_range
+    assert_equal [1, 10, 100, 1_000, 10_000], Minitest::Benchmark.bench_range
+  end
+
+  def test_fit_exponential_clean
+    x = [1.0, 2.0, 3.0, 4.0, 5.0]
+    y = x.map { |n| 1.1 * Math.exp(2.1 * n) }
+
+    assert_fit :exponential, x, y, 1.0, 1.1, 2.1
+  end
+
+  def test_fit_exponential_noisy
+    x = [1.0, 1.9, 2.6, 3.4, 5.0]
+    y = [12, 10, 8.2, 6.9, 5.9]
+
+    # verified with Numbers and R
+    assert_fit :exponential, x, y, 0.95, 13.81148, -0.1820
+  end
+
+  def test_fit_logarithmic_clean
+    x = [1.0, 2.0, 3.0, 4.0, 5.0]
+    y = x.map { |n| 1.1 + 2.1 * Math.log(n) }
+
+    assert_fit :logarithmic, x, y, 1.0, 1.1, 2.1
+  end
+
+  def test_fit_logarithmic_noisy
+    x = [1.0, 2.0, 3.0, 4.0, 5.0]
+    # Generated with
+    # y = x.map { |n| jitter = 0.999 + 0.002 * rand; (Math.log(n) ) * jitter }
+    y = [0.0, 0.6935, 1.0995, 1.3873, 1.6097]
+
+    assert_fit :logarithmic, x, y, 0.95, 0, 1
+  end
+
+  def test_fit_constant_clean
+    x = (1..5).to_a
+    y = [5.0, 5.0, 5.0, 5.0, 5.0]
+
+    assert_fit :linear, x, y, nil, 5.0, 0
+  end
+
+  def test_fit_constant_noisy
+    x = (1..5).to_a
+    y = [1.0, 1.2, 1.0, 0.8, 1.0]
+
+    # verified in numbers and R
+    assert_fit :linear, x, y, nil, 1.12, -0.04
+  end
+
+  def test_fit_linear_clean
+    # y = m * x + b where m = 2.2, b = 3.1
+    x = (1..5).to_a
+    y = x.map { |n| 2.2 * n + 3.1 }
+
+    assert_fit :linear, x, y, 1.0, 3.1, 2.2
+  end
+
+  def test_fit_linear_noisy
+    x = [ 60,  61,  62,  63,  65]
+    y = [3.1, 3.6, 3.8, 4.0, 4.1]
+
+    # verified in numbers and R
+    assert_fit :linear, x, y, 0.8315, -7.9635, 0.1878
+  end
+
+  def test_fit_power_clean
+    # y = A x ** B, where B = b and A = e ** a
+    # if, A = 1, B = 2, then
+
+    x = [1.0, 2.0, 3.0, 4.0, 5.0]
+    y = [1.0, 4.0, 9.0, 16.0, 25.0]
+
+    assert_fit :power, x, y, 1.0, 1.0, 2.0
+  end
+
+  def test_fit_power_noisy
+    # from www.engr.uidaho.edu/thompson/courses/ME330/lecture/least_squares.html
+    x = [10, 12, 15, 17, 20, 22, 25, 27, 30, 32, 35]
+    y = [95, 105, 125, 141, 173, 200, 253, 298, 385, 459, 602]
+
+    # verified in numbers
+    assert_fit :power, x, y, 0.90, 2.6217, 1.4556
+
+    # income to % of households below income amount
+    # http://library.wolfram.com/infocenter/Conferences/6461/PowerLaws.nb
+    x = [15_000, 25_000, 35_000, 50_000, 75_000, 100_000]
+    y = [0.154, 0.283, 0.402, 0.55, 0.733, 0.843]
+
+    # verified in numbers
+    assert_fit :power, x, y, 0.96, 3.119e-5, 0.8959
+  end
+
+  def assert_fit msg, x, y, fit, exp_a, exp_b
+    bench = Minitest::Benchmark.new :blah
+
+    a, b, rr = bench.send "fit_#{msg}", x, y
+
+    assert_operator rr, :>=, fit if fit
+    assert_in_delta exp_a, a
+    assert_in_delta exp_b, b
+  end
+end
+
+describe "my class Bench" do
+  klass = self
+  it "should provide bench methods" do
+    klass.must_respond_to :bench
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/minitest-5.14.2/test/minitest/test_minitest_mock.rb

@@ -0,0 +1,872 @@
+require "minitest/autorun"
+
+class TestMinitestMock < Minitest::Test
+  parallelize_me!
+
+  def setup
+    @mock = Minitest::Mock.new.expect(:foo, nil)
+    @mock.expect(:meaning_of_life, 42)
+  end
+
+  def test_create_stub_method
+    assert_nil @mock.foo
+  end
+
+  def test_allow_return_value_specification
+    assert_equal 42, @mock.meaning_of_life
+  end
+
+  def test_blow_up_if_not_called
+    @mock.foo
+
+    util_verify_bad "expected meaning_of_life() => 42"
+  end
+
+  def test_not_blow_up_if_everything_called
+    @mock.foo
+    @mock.meaning_of_life
+
+    assert_mock @mock
+  end
+
+  def test_allow_expectations_to_be_added_after_creation
+    @mock.expect(:bar, true)
+    assert @mock.bar
+  end
+
+  def test_not_verify_if_new_expected_method_is_not_called
+    @mock.foo
+    @mock.meaning_of_life
+    @mock.expect(:bar, true)
+
+    util_verify_bad "expected bar() => true"
+  end
+
+  def test_blow_up_on_wrong_number_of_arguments
+    @mock.foo
+    @mock.meaning_of_life
+    @mock.expect(:sum, 3, [1, 2])
+
+    e = assert_raises ArgumentError do
+      @mock.sum
+    end
+
+    assert_equal "mocked method :sum expects 2 arguments, got 0", e.message
+  end
+
+  def test_return_mock_does_not_raise
+    retval = Minitest::Mock.new
+    mock = Minitest::Mock.new
+    mock.expect(:foo, retval)
+    mock.foo
+
+    assert_mock mock
+  end
+
+  def test_mock_args_does_not_raise
+    arg = Minitest::Mock.new
+    mock = Minitest::Mock.new
+    mock.expect(:foo, nil, [arg])
+    mock.foo(arg)
+
+    assert_mock mock
+  end
+
+  def test_set_expectation_on_special_methods
+    mock = Minitest::Mock.new
+
+    mock.expect :object_id, "received object_id"
+    assert_equal "received object_id", mock.object_id
+
+    mock.expect :respond_to_missing?, "received respond_to_missing?"
+    assert_equal "received respond_to_missing?", mock.respond_to_missing?
+
+    mock.expect :===, "received ==="
+    assert_equal "received ===", mock.===
+
+    mock.expect :inspect, "received inspect"
+    assert_equal "received inspect", mock.inspect
+
+    mock.expect :to_s, "received to_s"
+    assert_equal "received to_s", mock.to_s
+
+    mock.expect :public_send, "received public_send"
+    assert_equal "received public_send", mock.public_send
+
+    mock.expect :send, "received send"
+    assert_equal "received send", mock.send
+
+    assert_mock mock
+  end
+
+  def test_expectations_can_be_satisfied_via_send
+    @mock.send :foo
+    @mock.send :meaning_of_life
+
+    assert_mock @mock
+  end
+
+  def test_expectations_can_be_satisfied_via_public_send
+    skip "Doesn't run on 1.8" if RUBY_VERSION < "1.9"
+
+    @mock.public_send :foo
+    @mock.public_send :meaning_of_life
+
+    assert_mock @mock
+  end
+
+  def test_blow_up_on_wrong_arguments
+    @mock.foo
+    @mock.meaning_of_life
+    @mock.expect(:sum, 3, [1, 2])
+
+    e = assert_raises MockExpectationError do
+      @mock.sum(2, 4)
+    end
+
+    exp = "mocked method :sum called with unexpected arguments [2, 4]"
+    assert_equal exp, e.message
+  end
+
+  def test_expect_with_non_array_args
+    e = assert_raises ArgumentError do
+      @mock.expect :blah, 3, false
+    end
+
+    assert_equal "args must be an array", e.message
+  end
+
+  def test_respond_appropriately
+    assert @mock.respond_to?(:foo)
+    assert @mock.respond_to?(:foo, true)
+    assert @mock.respond_to?("foo")
+    assert !@mock.respond_to?(:bar)
+  end
+
+  def test_no_method_error_on_unexpected_methods
+    e = assert_raises NoMethodError do
+      @mock.bar
+    end
+
+    expected = "unmocked method :bar, expected one of [:foo, :meaning_of_life]"
+
+    assert_equal expected, e.message
+  end
+
+  def test_assign_per_mock_return_values
+    a = Minitest::Mock.new
+    b = Minitest::Mock.new
+
+    a.expect(:foo, :a)
+    b.expect(:foo, :b)
+
+    assert_equal :a, a.foo
+    assert_equal :b, b.foo
+  end
+
+  def test_do_not_create_stub_method_on_new_mocks
+    a = Minitest::Mock.new
+    a.expect(:foo, :a)
+
+    assert !Minitest::Mock.new.respond_to?(:foo)
+  end
+
+  def test_mock_is_a_blank_slate
+    @mock.expect :kind_of?, true, [String]
+    @mock.expect :==, true, [1]
+
+    assert @mock.kind_of?(String), "didn't mock :kind_of\?"
+    assert @mock == 1, "didn't mock :=="
+  end
+
+  def test_verify_allows_called_args_to_be_loosely_specified
+    mock = Minitest::Mock.new
+    mock.expect :loose_expectation, true, [Integer]
+    mock.loose_expectation 1
+
+    assert_mock mock
+  end
+
+  def test_verify_raises_with_strict_args
+    mock = Minitest::Mock.new
+    mock.expect :strict_expectation, true, [2]
+
+    e = assert_raises MockExpectationError do
+      mock.strict_expectation 1
+    end
+
+    exp = "mocked method :strict_expectation called with unexpected arguments [1]"
+    assert_equal exp, e.message
+  end
+
+  def test_method_missing_empty
+    mock = Minitest::Mock.new
+
+    mock.expect :a, nil
+
+    mock.a
+
+    e = assert_raises MockExpectationError do
+      mock.a
+    end
+
+    assert_equal "No more expects available for :a: []", e.message
+  end
+
+  def test_same_method_expects_are_verified_when_all_called
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, [:bar]
+    mock.expect :foo, nil, [:baz]
+
+    mock.foo :bar
+    mock.foo :baz
+
+    assert_mock mock
+  end
+
+  def test_same_method_expects_blow_up_when_not_all_called
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, [:bar]
+    mock.expect :foo, nil, [:baz]
+
+    mock.foo :bar
+
+    e = assert_raises(MockExpectationError) { mock.verify }
+
+    exp = "expected foo(:baz) => nil, got [foo(:bar) => nil]"
+
+    assert_equal exp, e.message
+  end
+
+  def test_same_method_expects_with_same_args_blow_up_when_not_all_called
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, [:bar]
+    mock.expect :foo, nil, [:bar]
+
+    mock.foo :bar
+
+    e = assert_raises(MockExpectationError) { mock.verify }
+
+    exp = "expected foo(:bar) => nil, got [foo(:bar) => nil]"
+
+    assert_equal exp, e.message
+  end
+
+  def test_verify_passes_when_mock_block_returns_true
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil do
+      true
+    end
+
+    mock.foo
+
+    assert_mock mock
+  end
+
+  def test_mock_block_is_passed_function_params
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil do |a1, a2, a3|
+      a1 == arg1 && a2 == arg2 && a3 == arg3
+    end
+
+    mock.foo arg1, arg2, arg3
+
+    assert_mock mock
+  end
+
+  def test_mock_block_is_passed_function_block
+    mock = Minitest::Mock.new
+    block = proc { "bar" }
+    mock.expect :foo, nil do |arg, &blk|
+      arg == "foo" &&
+      blk == block
+    end
+    mock.foo "foo", &block
+    assert_mock mock
+  end
+
+  def test_verify_fails_when_mock_block_returns_false
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil do
+      false
+    end
+
+    e = assert_raises(MockExpectationError) { mock.foo }
+    exp = "mocked method :foo failed block w/ []"
+
+    assert_equal exp, e.message
+  end
+
+  def test_mock_block_throws_if_args_passed
+    mock = Minitest::Mock.new
+
+    e = assert_raises(ArgumentError) do
+      mock.expect :foo, nil, [:a, :b, :c] do
+        true
+      end
+    end
+
+    exp = "args ignored when block given"
+
+    assert_equal exp, e.message
+  end
+
+  def test_mock_returns_retval_when_called_with_block
+    mock = Minitest::Mock.new
+    mock.expect(:foo, 32) do
+      true
+    end
+
+    rs = mock.foo
+
+    assert_equal rs, 32
+  end
+
+  def util_verify_bad exp
+    e = assert_raises MockExpectationError do
+      @mock.verify
+    end
+
+    assert_equal exp, e.message
+  end
+
+  def test_mock_called_via_send
+    mock = Minitest::Mock.new
+    mock.expect(:foo, true)
+
+    mock.send :foo
+    assert_mock mock
+  end
+
+  def test_mock_called_via___send__
+    mock = Minitest::Mock.new
+    mock.expect(:foo, true)
+
+    mock.__send__ :foo
+    assert_mock mock
+  end
+
+  def test_mock_called_via_send_with_args
+    mock = Minitest::Mock.new
+    mock.expect(:foo, true, [1, 2, 3])
+
+    mock.send(:foo, 1, 2, 3)
+    assert_mock mock
+  end
+
+end
+
+require "minitest/metametameta"
+
+class TestMinitestStub < Minitest::Test
+  # Do not parallelize since we're calling stub on class methods
+
+  def setup
+    super
+    Minitest::Test.reset
+
+    @tc = Minitest::Test.new "fake tc"
+    @assertion_count = 1
+  end
+
+  def teardown
+    super
+    assert_equal @assertion_count, @tc.assertions if self.passed?
+  end
+
+  class Time
+    def self.now
+      24
+    end
+  end
+
+  def assert_stub val_or_callable
+    @assertion_count += 1
+
+    t = Time.now.to_i
+
+    Time.stub :now, val_or_callable do
+      @tc.assert_equal 42, Time.now
+    end
+
+    @tc.assert_operator Time.now.to_i, :>=, t
+  end
+
+  def test_stub_private_module_method
+    @assertion_count += 1
+
+    t0 = Time.now
+
+    self.stub :sleep, nil do
+      @tc.assert_nil sleep(10)
+    end
+
+    @tc.assert_operator Time.now - t0, :<=, 1
+  end
+
+  def test_stub_private_module_method_indirect
+    @assertion_count += 1
+
+    fail_clapper = Class.new do
+      def fail_clap
+        raise
+        :clap
+      end
+    end.new
+
+    fail_clapper.stub :raise, nil do |safe_clapper|
+      @tc.assert_equal :clap, safe_clapper.fail_clap # either form works
+      @tc.assert_equal :clap, fail_clapper.fail_clap # yay closures
+    end
+  end
+
+  def test_stub_public_module_method
+    Math.stub :log10, :stubbed do
+      @tc.assert_equal :stubbed, Math.log10(1000)
+    end
+  end
+
+  def test_stub_value
+    assert_stub 42
+  end
+
+  def test_stub_block
+    assert_stub lambda { 42 }
+  end
+
+  def test_stub_block_args
+    @assertion_count += 1
+
+    t = Time.now.to_i
+
+    Time.stub :now,  lambda { |n| n * 2 } do
+      @tc.assert_equal 42, Time.now(21)
+    end
+
+    @tc.assert_operator Time.now.to_i, :>=, t
+  end
+
+  def test_stub_callable
+    obj = Object.new
+
+    def obj.call
+      42
+    end
+
+    assert_stub obj
+  end
+
+  def test_stub_yield_self
+    obj = "foo"
+
+    val = obj.stub :to_s, "bar" do |s|
+      s.to_s
+    end
+
+    @tc.assert_equal "bar", val
+  end
+
+  def test_dynamic_method
+    @assertion_count = 2
+
+    dynamic = Class.new do
+      def self.respond_to? meth
+        meth == :found
+      end
+
+      def self.method_missing meth, *args, &block
+        if meth == :found
+          false
+        else
+          super
+        end
+      end
+    end
+
+    val = dynamic.stub(:found, true) do |s|
+      s.found
+    end
+
+    @tc.assert_equal true, val
+    @tc.assert_equal false, dynamic.found
+  end
+
+  def test_stub_NameError
+    e = @tc.assert_raises NameError do
+      Time.stub :nope_nope_nope, 42 do
+        # do nothing
+      end
+    end
+
+    exp = /undefined method `nope_nope_nope' for( class)? `#{self.class}::Time'/
+    assert_match exp, e.message
+  end
+
+  def test_mock_with_yield
+    mock = Minitest::Mock.new
+    mock.expect(:write, true) do
+      true
+    end
+    rs = nil
+
+    File.stub :open, true, mock do
+      File.open "foo.txt", "r" do |f|
+        rs = f.write
+      end
+    end
+    @tc.assert_equal true, rs
+  end
+
+  alias test_stub_value__old test_stub_value # TODO: remove/rename
+
+  ## Permutation Sets:
+
+  # [:value, :lambda]
+  # [:*,     :block,     :block_call]
+  # [:**,    :block_args]
+  #
+  # Where:
+  #
+  # :value      = a normal value
+  # :lambda     = callable or lambda
+  # :*          = no block
+  # :block      = normal block
+  # :block_call = :lambda invokes the block (N/A for :value)
+  # :**         = no args
+  # :args       = args passed to stub
+
+  ## Permutations
+
+  # [:call,   :*,          :**]   =>5 callable+block FIX: CALL BOTH (bug)
+  # [:call,   :*,          :**]   =>6 callable
+
+  # [:lambda, :*,          :**]   =>  lambda result
+
+  # [:lambda, :*,          :args] =>  lambda result NO ARGS
+
+  # [:lambda, :block,      :**]   =>5 lambda result FIX: CALL BOTH (bug)
+  # [:lambda, :block,      :**]   =>6 lambda result
+
+  # [:lambda, :block,      :args] =>5 lambda result FIX: CALL BOTH (bug)
+  # [:lambda, :block,      :args] =>6 lambda result
+  # [:lambda, :block,      :args] =>7 raise ArgumentError
+
+  # [:lambda, :block_call, :**]   =>5 lambda FIX: BUG!-not passed block to lambda
+  # [:lambda, :block_call, :**]   =>6 lambda+block result
+
+  # [:lambda, :block_call, :args] =>5 lambda FIX: BUG!-not passed block to lambda
+  # [:lambda, :block_call, :args] =>6 lambda+block result
+
+  # [:value,  :*,          :**]   =>  value
+
+  # [:value,  :*,          :args] =>  value, ignore args
+
+  # [:value,  :block,      :**]   =>5 value, call block
+  # [:value,  :block,      :**]   =>6 value
+
+  # [:value,  :block,      :args] =>5 value, call block w/ args
+  # [:value,  :block,      :args] =>6 value, call block w/ args, deprecated
+  # [:value,  :block,      :args] =>7 raise ArgumentError
+
+  # [:value,  :block_call, :**]   =>  N/A
+
+  # [:value,  :block_call, :args] =>  N/A
+
+  class Bar
+    def call
+      puts "hi"
+    end
+  end
+
+  class Foo
+    def self.blocking
+      yield
+    end
+  end
+
+  class Thingy
+    def self.identity arg
+      arg
+    end
+  end
+
+  def test_stub_callable_block_5 # from tenderlove
+    @assertion_count += 1
+    Foo.stub5 :blocking, Bar.new do
+      @tc.assert_output "hi\n", "" do
+        Foo.blocking do
+          @tc.flunk "shouldn't ever hit this"
+        end
+      end
+    end
+  end
+
+  def test_stub_callable_block_6 # from tenderlove
+    skip_stub6
+
+    @assertion_count += 1
+    Foo.stub6 :blocking, Bar.new do
+      @tc.assert_output "hi\n", "" do
+        Foo.blocking do
+          @tc.flunk "shouldn't ever hit this"
+        end
+      end
+    end
+  end
+
+  def test_stub_lambda
+    Thread.stub :new, lambda { 21+21 } do
+      @tc.assert_equal 42, Thread.new
+    end
+  end
+
+  def test_stub_lambda_args
+    Thread.stub :new, lambda { 21+21 }, :wtf do
+      @tc.assert_equal 42, Thread.new
+    end
+  end
+
+  def test_stub_lambda_block_5
+    Thread.stub5 :new, lambda { 21+21 } do
+      result = Thread.new do
+        @tc.flunk "shouldn't ever hit this"
+      end
+      @tc.assert_equal 42, result
+    end
+  end
+
+  def test_stub_lambda_block_6
+    skip_stub6
+
+    Thread.stub6 :new, lambda { 21+21 } do
+      result = Thread.new do
+        @tc.flunk "shouldn't ever hit this"
+      end
+      @tc.assert_equal 42, result
+    end
+  end
+
+  def test_stub_lambda_block_args_5
+    @assertion_count += 1
+    Thingy.stub5 :identity, lambda { |y| @tc.assert_equal :nope, y; 21+21 }, :WTF? do
+      result = Thingy.identity :nope do |x|
+        @tc.flunk "shouldn't reach this"
+      end
+      @tc.assert_equal 42, result
+    end
+  end
+
+  def test_stub_lambda_block_args_6
+    skip_stub6
+
+    @assertion_count += 1
+    Thingy.stub6 :identity, lambda { |y| @tc.assert_equal :nope, y; 21+21 }, :WTF? do
+      result = Thingy.identity :nope do |x|
+        @tc.flunk "shouldn't reach this"
+      end
+      @tc.assert_equal 42, result
+    end
+  end
+
+  def test_stub_lambda_block_args_6_2
+    skip_stub6
+
+    @tc.assert_raises ArgumentError do
+      Thingy.stub6_2 :identity, lambda { |y| :__not_run__ }, :WTF? do
+        # doesn't matter
+      end
+    end
+  end
+
+  def test_stub_lambda_block_call_5
+    @assertion_count += 1
+    rs = nil
+    io = StringIO.new "", "w"
+    File.stub5 :open, lambda { |p, m, &blk| blk and blk.call io } do
+      File.open "foo.txt", "r" do |f|
+        rs = f && f.write("woot")
+      end
+    end
+    @tc.assert_equal 4, rs
+    @tc.assert_equal "woot", io.string
+  end
+
+  def test_stub_lambda_block_call_6
+    skip_stub6
+
+    @assertion_count += 1
+    rs = nil
+    io = StringIO.new "", "w"
+    File.stub6 :open, lambda { |p, m, &blk| blk.call io } do
+      File.open "foo.txt", "r" do |f|
+        rs = f.write("woot")
+      end
+    end
+    @tc.assert_equal 4, rs
+    @tc.assert_equal "woot", io.string
+  end
+
+  def test_stub_lambda_block_call_args_5
+    @assertion_count += 1
+    rs = nil
+    io = StringIO.new "", "w"
+    File.stub5(:open, lambda { |p, m, &blk| blk and blk.call io }, :WTF?) do
+      File.open "foo.txt", "r" do |f|
+        rs = f.write("woot")
+      end
+    end
+    @tc.assert_equal 4, rs
+    @tc.assert_equal "woot", io.string
+  end
+
+  def test_stub_lambda_block_call_args_6
+    skip_stub6
+
+    @assertion_count += 1
+    rs = nil
+    io = StringIO.new "", "w"
+    File.stub6(:open, lambda { |p, m, &blk| blk.call io }, :WTF?) do
+      File.open "foo.txt", "r" do |f|
+        rs = f.write("woot")
+      end
+    end
+    @tc.assert_equal 4, rs
+    @tc.assert_equal "woot", io.string
+  end
+
+  def test_stub_lambda_block_call_args_6_2
+    skip_stub6
+
+    @assertion_count += 2
+    rs = nil
+    io = StringIO.new "", "w"
+    @tc.assert_raises ArgumentError do
+      File.stub6_2(:open, lambda { |p, m, &blk| blk.call io }, :WTF?) do
+        File.open "foo.txt", "r" do |f|
+          rs = f.write("woot")
+        end
+      end
+    end
+    @tc.assert_nil rs
+    @tc.assert_equal "", io.string
+  end
+
+  def test_stub_value
+    Thread.stub :new, 42 do
+      result = Thread.new
+      @tc.assert_equal 42, result
+    end
+  end
+
+  def test_stub_value_args
+    Thread.stub :new, 42, :WTF? do
+      result = Thread.new
+      @tc.assert_equal 42, result
+    end
+  end
+
+  def test_stub_value_block_5
+    @assertion_count += 1
+    Thread.stub5 :new, 42 do
+      result = Thread.new do
+        @tc.assert true
+      end
+      @tc.assert_equal 42, result
+    end
+  end
+
+  def test_stub_value_block_6
+    skip_stub6
+
+    Thread.stub6 :new, 42 do
+      result = Thread.new do
+        @tc.flunk "shouldn't hit this"
+      end
+      @tc.assert_equal 42, result
+    end
+  end
+
+  def test_stub_value_block_args_5
+    @assertion_count += 2
+    rs = nil
+    io = StringIO.new "", "w"
+    File.stub5 :open, :value, io do
+      result = File.open "foo.txt", "r" do |f|
+        rs = f.write("woot")
+      end
+      @tc.assert_equal :value, result
+    end
+    @tc.assert_equal 4, rs
+    @tc.assert_equal "woot", io.string
+  end
+
+  def test_stub_value_block_args_5__break_if_not_passed
+    e = @tc.assert_raises NoMethodError do
+      File.stub5 :open, :return_value do # intentionally bad setup w/ no args
+        File.open "foo.txt", "r" do |f|
+          f.write "woot"
+        end
+      end
+    end
+    exp = "undefined method `write' for nil:NilClass"
+    assert_equal exp, e.message
+  end
+
+  def test_stub_value_block_args_6
+    skip_stub6
+
+    @assertion_count += 2
+    rs = nil
+    io = StringIO.new "", "w"
+    assert_deprecated do
+      File.stub6 :open, :value, io do
+        result = File.open "foo.txt", "r" do |f|
+          rs = f.write("woot")
+        end
+        @tc.assert_equal :value, result
+      end
+    end
+    @tc.assert_equal 4, rs
+    @tc.assert_equal "woot", io.string
+  end
+
+  def test_stub_value_block_args_6_2
+    skip_stub6
+
+    @assertion_count += 2
+    rs = nil
+    io = StringIO.new "", "w"
+    @tc.assert_raises ArgumentError do
+      File.stub6_2 :open, :value, io do
+        result = File.open "foo.txt", "r" do |f|
+          @tc.flunk "shouldn't hit this"
+        end
+        @tc.assert_equal :value, result
+      end
+    end
+    @tc.assert_nil rs
+    @tc.assert_equal "", io.string
+  end
+
+  def assert_deprecated re = /deprecated/
+    assert_output "", re do
+      yield
+    end
+  end
+
+  def skip_stub6
+    skip "not yet" unless STUB6
+  end
+end
+
+STUB6 = ENV["STUB6"]
+
+if STUB6 then
+  require "minitest/mock6" if STUB6
+else
+  class Object
+    alias stub5 stub
+    alias stub6 stub
+  end
+end