challah 1.0.0.beta2 → 1.0.0.beta3

data/vendor/bundle/gems/minitest-4.7.4/test/minitest/metametameta.rb

@@ -0,0 +1,67 @@
+require 'tempfile'
+require 'stringio'
+require 'minitest/autorun'
+
+class MiniTest::Unit::TestCase
+  def clean s
+    s.gsub(/^ {6}/, '')
+  end
+end
+
+class MetaMetaMetaTestCase < MiniTest::Unit::TestCase
+  def assert_report expected, flags = %w[--seed 42]
+    header = clean <<-EOM
+      Run options: #{flags.map { |s| s =~ /\|/ ? s.inspect : s }.join " "}
+
+      # Running tests:
+
+    EOM
+
+    with_output do
+      @tu.run flags
+    end
+
+    output = @output.string.dup
+    output.sub!(/Finished tests in .*/, "Finished tests 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')
+
+    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
+
+    assert_equal header + expected, output
+  end
+
+  def setup
+    super
+    srand 42
+    MiniTest::Unit::TestCase.reset
+    @tu = MiniTest::Unit.new
+
+    MiniTest::Unit.runner = nil # protect the outer runner from the inner tests
+  end
+
+  def teardown
+    super
+  end
+
+  def with_output
+    synchronize do
+      begin
+        @output = StringIO.new("")
+        MiniTest::Unit.output = @output
+
+        yield
+      ensure
+        MiniTest::Unit.output = STDOUT
+      end
+    end
+  end
+end

data/vendor/bundle/gems/minitest-4.7.4/test/minitest/test_minitest_benchmark.rb

@@ -0,0 +1,128 @@
+require 'minitest/autorun'
+require 'minitest/benchmark'
+
+##
+# Used to verify data:
+# http://www.wolframalpha.com/examples/RegressionAnalysis.html
+
+class TestMiniTestBenchmark < MiniTest::Unit::TestCase
+  def test_cls_bench_exp
+    assert_equal [2, 4, 8, 16, 32], self.class.bench_exp(2, 32, 2)
+  end
+
+  def test_cls_bench_linear
+    assert_equal [2, 4, 6, 8, 10], self.class.bench_linear(2, 10, 2)
+  end
+
+  def test_cls_benchmark_methods
+    assert_equal [], self.class.benchmark_methods
+
+    c = Class.new(MiniTest::Unit::TestCase) do
+      def bench_blah
+      end
+    end
+
+    assert_equal ["bench_blah"], c.benchmark_methods
+  end
+
+  def test_cls_bench_range
+    assert_equal [1, 10, 100, 1_000, 10_000], self.class.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 = [15000, 25000, 35000, 50000, 75000, 100000]
+    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
+    a, b, rr = 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

data/vendor/bundle/gems/minitest-4.7.4/test/minitest/test_minitest_mock.rb

@@ -0,0 +1,403 @@
+require 'minitest/autorun'
+
+class TestMiniTestMock < MiniTest::Unit::TestCase
+  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, got []"
+  end
+
+  def test_not_blow_up_if_everything_called
+    @mock.foo
+    @mock.meaning_of_life
+
+    assert @mock.verify
+  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, got []"
+  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.verify
+  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.verify
+  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.verify
+  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.verify
+  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_verify_passes_when_mock_block_returns_true
+    mock = MiniTest::Mock.new
+    mock.expect :foo, nil do
+      true
+    end
+
+    mock.foo
+
+    assert mock.verify
+  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.verify
+  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
+end
+
+require "minitest/metametameta"
+
+class TestMiniTestStub < MiniTest::Unit::TestCase
+  parallelize_me!
+
+  def setup
+    super
+    MiniTest::Unit::TestCase.reset
+
+    @tc = MiniTest::Unit::TestCase.new 'fake tc'
+    @assertion_count = 1
+  end
+
+  def teardown
+    super
+    assert_equal @assertion_count, @tc._assertions
+  end
+
+  def assert_stub val_or_callable
+    @assertion_count += 1
+
+    synchronize do
+      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
+  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
+
+    slow_clapper = Class.new do
+      def slow_clap
+        sleep 3
+        :clap
+      end
+    end.new
+
+    slow_clapper.stub :sleep, nil do |fast_clapper|
+      @tc.assert_equal :clap, fast_clapper.slow_clap # either form works
+      @tc.assert_equal :clap, slow_clapper.slow_clap # yay closures
+    end
+  end
+
+  def test_stub_public_module_method
+    Math.stub(:log10, 42.0) do
+      @tc.assert_in_delta 42.0, 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
+
+    synchronize do
+      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
+  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
+end