RubyGems - windows-pr - Versions diffs - 1.2.5 → 1.2.6 - Mend

windows-pr 1.2.5 → 1.2.6

Files changed (505) hide show

data/vendor/bundle/ruby/2.2.0/gems/minitest-5.9.0/lib/minitest/unit.rb DELETED

@@ -1,45 +0,0 @@
-# :stopdoc:
-unless defined?(Minitest) then
-  # all of this crap is just to avoid circular requires and is only
-  # needed if a user requires "minitest/unit" directly instead of
-  # "minitest/autorun", so we also warn
-  from = caller.reject { |s| s =~ /rubygems/ }.join("\n  ")
-  warn "Warning: you should require 'minitest/autorun' instead."
-  warn %(Warning: or add 'gem "minitest"' before 'require "minitest/autorun"')
-  warn "From:\n  #{from}"
-  module Minitest; end
-  MiniTest = Minitest # prevents minitest.rb from requiring back to us
-  require "minitest"
-end
-MiniTest = Minitest unless defined?(MiniTest)
-module Minitest
-  class Unit
-    VERSION = Minitest::VERSION
-    class TestCase < Minitest::Test
-      def self.inherited klass # :nodoc:
-        from = caller.first
-        warn "MiniTest::Unit::TestCase is now Minitest::Test. From #{from}"
-        super
-      end
-    end
-    def self.autorun # :nodoc:
-      from = caller.first
-      warn "MiniTest::Unit.autorun is now Minitest.autorun. From #{from}"
-      Minitest.autorun
-    end
-    def self.after_tests(&b) # :nodoc:
-      from = caller.first
-      warn "MiniTest::Unit.after_tests is now Minitest.after_run. From #{from}"
-      Minitest.after_run(&b)
-    end
-  end
-end
-# :startdoc:

data/vendor/bundle/ruby/2.2.0/gems/minitest-5.9.0/test/minitest/metametameta.rb DELETED

@@ -1,90 +0,0 @@
-require "tempfile"
-require "stringio"
-require "minitest/autorun"
-class Minitest::Test
-  def clean s
-    s.gsub(/^ {6}/, "")
-  end
-end
-class MetaMetaMetaTestCase < Minitest::Test
-  attr_accessor :reporter, :output, :tu
-  def run_tu_with_fresh_reporter flags = %w[--seed 42]
-    options = Minitest.process_args flags
-    @output = StringIO.new("")
-    self.reporter = Minitest::CompositeReporter.new
-    reporter << Minitest::SummaryReporter.new(@output, options)
-    reporter << Minitest::ProgressReporter.new(@output, options)
-    reporter.start
-    yield(reporter) if block_given?
-    @tus ||= [@tu]
-    @tus.each do |tu|
-      Minitest::Runnable.runnables.delete tu
-      tu.run reporter, options
-    end
-    reporter.report
-  end
-  def first_reporter
-    reporter.reporters.first
-  end
-  def assert_report expected, flags = %w[--seed 42], &block
-    header = clean <<-EOM
-      Run options: #{flags.map { |s| s =~ /\|/ ? s.inspect : s }.join " "}
-      # Running:
-    EOM
-    run_tu_with_fresh_reporter flags, &block
-    output = normalize_output @output.string.dup
-    assert_equal header + expected, output
-  end
-  def normalize_output output
-    output.sub!(/Finished in .*/, "Finished in 0.00")
-    output.sub!(/Loaded suite .*/, "Loaded suite blah")
-    output.gsub!(/ = \d+.\d\d s = /, " = 0.00 s = ")
-    output.gsub!(/0x[A-Fa-f0-9]+/, "0xXXX")
-    output.gsub!(/ +$/, "")
-    if windows? then
-      output.gsub!(/\[(?:[A-Za-z]:)?[^\]:]+:\d+\]/, "[FILE:LINE]")
-      output.gsub!(/^(\s+)(?:[A-Za-z]:)?[^:]+:\d+:in/, '\1FILE:LINE:in')
-    else
-      output.gsub!(/\[[^\]:]+:\d+\]/, "[FILE:LINE]")
-      output.gsub!(/^(\s+)[^:]+:\d+:in/, '\1FILE:LINE:in')
-    end
-    output
-  end
-  def restore_env
-    old_value = ENV["MT_NO_SKIP_MSG"]
-    ENV.delete "MT_NO_SKIP_MSG"
-    yield
-  ensure
-    ENV["MT_NO_SKIP_MSG"] = old_value
-  end
-  def setup
-    super
-    srand 42
-    Minitest::Test.reset
-    @tu = nil
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/minitest-5.9.0/test/minitest/test_minitest_benchmark.rb DELETED

@@ -1,137 +0,0 @@
-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.2.0/gems/minitest-5.9.0/test/minitest/test_minitest_mock.rb DELETED

@@ -1,512 +0,0 @@
-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
-    skip "non-opaque use of ==" if maglev?
-    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, [Fixnum]
-    @mock.expect :==, true, [1]
-    assert @mock.kind_of?(Fixnum), "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
-  parallelize_me!
-  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
-  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_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
-end