minitest 4.7.5 → 5.0.0

data/lib/minitest/autorun.rb

@@ -1,12 +1,12 @@
 begin
-  require 'rubygems'
-  gem 'minitest'
+  require "rubygems"
+  gem "minitest"
 rescue Gem::LoadError
   # do nothing
 end
 
-require 'minitest/unit'
-require 'minitest/spec'
-require 'minitest/mock'
+require "minitest"
+require "minitest/spec"
+require "minitest/mock"
 
-MiniTest::Unit.autorun
+Minitest.autorun

data/lib/minitest/benchmark.rb

@@ -1,16 +1,32 @@
 require 'minitest/unit'
 require 'minitest/spec'
 
-class MiniTest::Unit # :nodoc:
-  def run_benchmarks # :nodoc:
-    _run_anything :benchmark
-  end
+module Minitest
+  ##
+  # Subclass Benchmark to create your own benchmark runs. Methods
+  # starting with "bench_" get executed on a per-class.
+  #
+  # See Minitest::Assertions
 
-  def benchmark_suite_header suite # :nodoc:
-    "\n#{suite}\t#{suite.bench_range.join("\t")}"
-  end
+  class Benchmark < Test
+    def self.io # :nodoc:
+      @io
+    end
+
+    def io # :nodoc:
+      self.class.io
+    end
+
+    def self.run reporter, options = {} # :nodoc:
+      # NOTE: this is truly horrible... but I don't see a way around this ATM.
+      @io = reporter.reporters.first.io
+      super
+    end
+
+    def self.runnable_methods # :nodoc:
+      methods_matching(/^bench_/)
+    end
 
-  class TestCase
     ##
     # Returns a set of ranges stepped exponentially from +min+ to
     # +max+ by powers of +base+. Eg:
@@ -36,21 +52,6 @@ class MiniTest::Unit # :nodoc:
       r = []; (min..max).step(step) { |n| r << n }; r
     end
 
-    ##
-    # Returns the benchmark methods (methods that start with bench_)
-    # for that class.
-
-    def self.benchmark_methods # :nodoc:
-      public_instance_methods(true).grep(/^bench_/).map { |m| m.to_s }.sort
-    end
-
-    ##
-    # Returns all test suites that have benchmark methods.
-
-    def self.benchmark_suites
-      TestCase.test_suites.reject { |s| s.benchmark_methods.empty? }
-    end
-
     ##
     # Specifies the ranges used for benchmarking for that class.
     # Defaults to exponential growth from 1 to 10k by powers of 10.
@@ -83,7 +84,7 @@ class MiniTest::Unit # :nodoc:
     def assert_performance validation, &work
       range = self.class.bench_range
 
-      io.print "#{__name__}"
+      io.print "#{self.name}"
 
       times = []
 
@@ -341,76 +342,82 @@ class MiniTest::Unit # :nodoc:
   end
 end
 
-class MiniTest::Spec
-  ##
-  # This is used to define a new benchmark method. You usually don't
-  # use this directly and is intended for those needing to write new
-  # performance curve fits (eg: you need a specific polynomial fit).
-  #
-  # See ::bench_performance_linear for an example of how to use this.
+module Minitest
+  class BenchSpec < Benchmark
+    extend Minitest::Spec::DSL
 
-  def self.bench name, &block
-    define_method "bench_#{name.gsub(/\W+/, '_')}", &block
-  end
+    ##
+    # This is used to define a new benchmark method. You usually don't
+    # use this directly and is intended for those needing to write new
+    # performance curve fits (eg: you need a specific polynomial fit).
+    #
+    # See ::bench_performance_linear for an example of how to use this.
 
-  ##
-  # Specifies the ranges used for benchmarking for that class.
-  #
-  #   bench_range do
-  #     bench_exp(2, 16, 2)
-  #   end
-  #
-  # See Unit::TestCase.bench_range for more details.
+    def self.bench name, &block
+      define_method "bench_#{name.gsub(/\W+/, '_')}", &block
+    end
+
+    ##
+    # Specifies the ranges used for benchmarking for that class.
+    #
+    #   bench_range do
+    #     bench_exp(2, 16, 2)
+    #   end
+    #
+    # See Minitest::Benchmark#bench_range for more details.
 
-  def self.bench_range &block
-    return super unless block
+    def self.bench_range &block
+      return super unless block
 
-    meta = (class << self; self; end)
-    meta.send :define_method, "bench_range", &block
-  end
+      meta = (class << self; self; end)
+      meta.send :define_method, "bench_range", &block
+    end
 
-  ##
-  # Create a benchmark that verifies that the performance is linear.
-  #
-  #   describe "my class" do
-  #     bench_performance_linear "fast_algorithm", 0.9999 do |n|
-  #       @obj.fast_algorithm(n)
-  #     end
-  #   end
-
-  def self.bench_performance_linear name, threshold = 0.99, &work
-    bench name do
-      assert_performance_linear threshold, &work
+    ##
+    # Create a benchmark that verifies that the performance is linear.
+    #
+    #   describe "my class" do
+    #     bench_performance_linear "fast_algorithm", 0.9999 do |n|
+    #       @obj.fast_algorithm(n)
+    #     end
+    #   end
+
+    def self.bench_performance_linear name, threshold = 0.99, &work
+      bench name do
+        assert_performance_linear threshold, &work
+      end
     end
-  end
 
-  ##
-  # Create a benchmark that verifies that the performance is constant.
-  #
-  #   describe "my class" do
-  #     bench_performance_constant "zoom_algorithm!" do |n|
-  #       @obj.zoom_algorithm!(n)
-  #     end
-  #   end
-
-  def self.bench_performance_constant name, threshold = 0.99, &work
-    bench name do
-      assert_performance_constant threshold, &work
+    ##
+    # Create a benchmark that verifies that the performance is constant.
+    #
+    #   describe "my class" do
+    #     bench_performance_constant "zoom_algorithm!" do |n|
+    #       @obj.zoom_algorithm!(n)
+    #     end
+    #   end
+
+    def self.bench_performance_constant name, threshold = 0.99, &work
+      bench name do
+        assert_performance_constant threshold, &work
+      end
     end
-  end
 
-  ##
-  # Create a benchmark that verifies that the performance is exponential.
-  #
-  #   describe "my class" do
-  #     bench_performance_exponential "algorithm" do |n|
-  #       @obj.algorithm(n)
-  #     end
-  #   end
-
-  def self.bench_performance_exponential name, threshold = 0.99, &work
-    bench name do
-      assert_performance_exponential threshold, &work
+    ##
+    # Create a benchmark that verifies that the performance is exponential.
+    #
+    #   describe "my class" do
+    #     bench_performance_exponential "algorithm" do |n|
+    #       @obj.algorithm(n)
+    #     end
+    #   end
+
+    def self.bench_performance_exponential name, threshold = 0.99, &work
+      bench name do
+        assert_performance_exponential threshold, &work
+      end
     end
   end
+
+  Minitest::Spec.register_spec_type(/Bench(mark)?$/, Minitest::BenchSpec)
 end

data/lib/minitest/expectations.rb

@@ -0,0 +1,268 @@
+##
+# It's where you hide your "assertions".
+
+module Minitest::Expectations
+  ##
+  # See Minitest::Assertions#assert_empty.
+  #
+  #    collection.must_be_empty
+  #
+  # :method: must_be_empty
+
+  infect_an_assertion :assert_empty, :must_be_empty, :unary
+
+  ##
+  # See Minitest::Assertions#assert_equal
+  #
+  #    a.must_equal b
+  #
+  # :method: must_equal
+
+  infect_an_assertion :assert_equal, :must_equal
+
+  ##
+  # See Minitest::Assertions#assert_in_delta
+  #
+  #    n.must_be_close_to m [, delta]
+  #
+  # :method: must_be_close_to
+
+  infect_an_assertion :assert_in_delta, :must_be_close_to
+
+  alias :must_be_within_delta :must_be_close_to # :nodoc:
+
+  ##
+  # See Minitest::Assertions#assert_in_epsilon
+  #
+  #    n.must_be_within_epsilon m [, epsilon]
+  #
+  # :method: must_be_within_epsilon
+
+  infect_an_assertion :assert_in_epsilon, :must_be_within_epsilon
+
+  ##
+  # See Minitest::Assertions#assert_includes
+  #
+  #    collection.must_include obj
+  #
+  # :method: must_include
+
+  infect_an_assertion :assert_includes, :must_include, :reverse
+
+  ##
+  # See Minitest::Assertions#assert_instance_of
+  #
+  #    obj.must_be_instance_of klass
+  #
+  # :method: must_be_instance_of
+
+  infect_an_assertion :assert_instance_of, :must_be_instance_of
+
+  ##
+  # See Minitest::Assertions#assert_kind_of
+  #
+  #    obj.must_be_kind_of mod
+  #
+  # :method: must_be_kind_of
+
+  infect_an_assertion :assert_kind_of, :must_be_kind_of
+
+  ##
+  # See Minitest::Assertions#assert_match
+  #
+  #    a.must_match b
+  #
+  # :method: must_match
+
+  infect_an_assertion :assert_match, :must_match
+
+  ##
+  # See Minitest::Assertions#assert_nil
+  #
+  #    obj.must_be_nil
+  #
+  # :method: must_be_nil
+
+  infect_an_assertion :assert_nil, :must_be_nil, :unary
+
+  ##
+  # See Minitest::Assertions#assert_operator
+  #
+  #    n.must_be :<=, 42
+  #
+  # This can also do predicates:
+  #
+  #    str.must_be :empty?
+  #
+  # :method: must_be
+
+  infect_an_assertion :assert_operator, :must_be, :reverse
+
+  ##
+  # See Minitest::Assertions#assert_output
+  #
+  #    proc { ... }.must_output out_or_nil [, err]
+  #
+  # :method: must_output
+
+  infect_an_assertion :assert_output, :must_output
+
+  ##
+  # See Minitest::Assertions#assert_raises
+  #
+  #    proc { ... }.must_raise exception
+  #
+  # :method: must_raise
+
+  infect_an_assertion :assert_raises, :must_raise
+
+  ##
+  # See Minitest::Assertions#assert_respond_to
+  #
+  #    obj.must_respond_to msg
+  #
+  # :method: must_respond_to
+
+  infect_an_assertion :assert_respond_to, :must_respond_to, :reverse
+
+  ##
+  # See Minitest::Assertions#assert_same
+  #
+  #    a.must_be_same_as b
+  #
+  # :method: must_be_same_as
+
+  infect_an_assertion :assert_same, :must_be_same_as
+
+  ##
+  # See Minitest::Assertions#assert_silent
+  #
+  #    proc { ... }.must_be_silent
+  #
+  # :method: must_be_silent
+
+  infect_an_assertion :assert_silent, :must_be_silent
+
+  ##
+  # See Minitest::Assertions#assert_throws
+  #
+  #    proc { ... }.must_throw sym
+  #
+  # :method: must_throw
+
+  infect_an_assertion :assert_throws, :must_throw
+
+  ##
+  # See Minitest::Assertions#refute_empty
+  #
+  #    collection.wont_be_empty
+  #
+  # :method: wont_be_empty
+
+  infect_an_assertion :refute_empty, :wont_be_empty, :unary
+
+  ##
+  # See Minitest::Assertions#refute_equal
+  #
+  #    a.wont_equal b
+  #
+  # :method: wont_equal
+
+  infect_an_assertion :refute_equal, :wont_equal
+
+  ##
+  # See Minitest::Assertions#refute_in_delta
+  #
+  #    n.wont_be_close_to m [, delta]
+  #
+  # :method: wont_be_close_to
+
+  infect_an_assertion :refute_in_delta, :wont_be_close_to
+
+  alias :wont_be_within_delta :wont_be_close_to # :nodoc:
+
+  ##
+  # See Minitest::Assertions#refute_in_epsilon
+  #
+  #    n.wont_be_within_epsilon m [, epsilon]
+  #
+  # :method: wont_be_within_epsilon
+
+  infect_an_assertion :refute_in_epsilon, :wont_be_within_epsilon
+
+  ##
+  # See Minitest::Assertions#refute_includes
+  #
+  #    collection.wont_include obj
+  #
+  # :method: wont_include
+
+  infect_an_assertion :refute_includes, :wont_include, :reverse
+
+  ##
+  # See Minitest::Assertions#refute_instance_of
+  #
+  #    obj.wont_be_instance_of klass
+  #
+  # :method: wont_be_instance_of
+
+  infect_an_assertion :refute_instance_of, :wont_be_instance_of
+
+  ##
+  # See Minitest::Assertions#refute_kind_of
+  #
+  #    obj.wont_be_kind_of mod
+  #
+  # :method: wont_be_kind_of
+
+  infect_an_assertion :refute_kind_of, :wont_be_kind_of
+
+  ##
+  # See Minitest::Assertions#refute_match
+  #
+  #    a.wont_match b
+  #
+  # :method: wont_match
+
+  infect_an_assertion :refute_match, :wont_match
+
+  ##
+  # See Minitest::Assertions#refute_nil
+  #
+  #    obj.wont_be_nil
+  #
+  # :method: wont_be_nil
+
+  infect_an_assertion :refute_nil, :wont_be_nil, :unary
+
+  ##
+  # See Minitest::Assertions#refute_operator
+  #
+  #    n.wont_be :<=, 42
+  #
+  # This can also do predicates:
+  #
+  #    str.wont_be :empty?
+  #
+  # :method: wont_be
+
+  infect_an_assertion :refute_operator, :wont_be, :reverse
+
+  ##
+  # See Minitest::Assertions#refute_respond_to
+  #
+  #    obj.wont_respond_to msg
+  #
+  # :method: wont_respond_to
+
+  infect_an_assertion :refute_respond_to, :wont_respond_to, :reverse
+
+  ##
+  # See Minitest::Assertions#refute_same
+  #
+  #    a.wont_be_same_as b
+  #
+  # :method: wont_be_same_as
+
+  infect_an_assertion :refute_same, :wont_be_same_as
+end