From 9698217cda5089178e7c6cd73d00be15e2e24e0d Mon Sep 17 00:00:00 2001
From: ryan <ryan@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>
Date: Sat, 25 Dec 2010 04:55:15 +0000
Subject: Imported minitest 2.0.2 r6093

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@30347 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
---
 lib/minitest/benchmark.rb | 40 ++++++++++++++++++++++++++++++++++++++--
 lib/minitest/mock.rb      | 28 +++++++++++++++++++++++++---
 lib/minitest/unit.rb      |  2 +-
 3 files changed, 64 insertions(+), 6 deletions(-)

(limited to 'lib')

diff --git a/lib/minitest/benchmark.rb b/lib/minitest/benchmark.rb
index 2bf8dd9c00..f8dcee745e 100644
--- a/lib/minitest/benchmark.rb
+++ b/lib/minitest/benchmark.rb
@@ -10,11 +10,11 @@ require 'minitest/spec'
 class MiniTest::Unit
   attr_accessor :runner
 
-  def run_benchmarks
+  def run_benchmarks # :nodoc:
     _run_anything :benchmark
   end
 
-  def benchmark_suite_header suite
+  def benchmark_suite_header suite # :nodoc:
     "\n#{suite}\t#{suite.bench_range.join("\t")}"
   end
 
@@ -301,27 +301,63 @@ class MiniTest::Unit
 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.
+
   def self.bench name, &block
     define_method "bench_#{name.gsub(/\W+/, '_')}", &block
   end
 
   def self.bench_range &block
+    return super unless block
+
     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
+  #       @obj.fast_algorithm
+  #     end
+  #   end
+
   def self.bench_performance_linear name, threshold = 0.9, &work
     bench name do
       assert_performance_linear threshold, &work
     end
   end
 
+  ##
+  # Create a benchmark that verifies that the performance is constant.
+  #
+  #   describe "my class" do
+  #     bench_performance_constant "zoom_algorithm!" do
+  #       @obj.zoom_algorithm!
+  #     end
+  #   end
+
   def self.bench_performance_constant name, threshold = 0.99, &work
     bench name do
       assert_performance_constant threshold, &work
     end
   end
 
+  ##
+  # Create a benchmark that verifies that the performance is exponential.
+  #
+  #   describe "my class" do
+  #     bench_performance_exponential "algorithm" do
+  #       @obj.algorithm
+  #     end
+  #   end
+
   def self.bench_performance_exponential name, threshold = 0.99, &work
     bench name do
       assert_performance_exponential threshold, &work
diff --git a/lib/minitest/mock.rb b/lib/minitest/mock.rb
index 99f7992aa9..adff7455a7 100644
--- a/lib/minitest/mock.rb
+++ b/lib/minitest/mock.rb
@@ -6,18 +6,40 @@
 
 class MockExpectationError < StandardError; end
 
+##
+# A simple and clean mock object framework.
+
 module MiniTest
+
+  ##
+  # All mock objects are an instance of Mock
+
   class Mock
-    def initialize
+    def initialize # :nodoc:
       @expected_calls = {}
       @actual_calls = Hash.new {|h,k| h[k] = [] }
     end
 
+    ##
+    # Expect that method +name+ is called, optionally with +args+, and
+    # returns +retval+.
+    #
+    #   @mock.expect(:meaning_of_life, 42)
+    #   @mock.meaning_of_life # => 42
+    #
+    #   @mock.expect(:do_something_with, true, [some_obj, true])
+    #   @mock.do_something_with(some_obj, true) # => true
+
     def expect(name, retval, args=[])
       @expected_calls[name] = { :retval => retval, :args => args }
       self
     end
 
+    ##
+    # Verify that all methods were called as expected. Raises
+    # +MockExpectationError+ if the mock object was not called as
+    # expected.
+
     def verify
       @expected_calls.each_key do |name|
         expected = @expected_calls[name]
@@ -28,7 +50,7 @@ module MiniTest
       true
     end
 
-    def method_missing(sym, *args)
+    def method_missing(sym, *args) # :nodoc:
       raise NoMethodError unless @expected_calls.has_key?(sym)
       raise ArgumentError unless @expected_calls[sym][:args].size == args.size
       retval = @expected_calls[sym][:retval]
@@ -37,7 +59,7 @@ module MiniTest
     end
 
     alias :original_respond_to? :respond_to?
-    def respond_to?(sym)
+    def respond_to?(sym) # :nodoc:
       return true if @expected_calls.has_key?(sym)
       return original_respond_to?(sym)
     end
diff --git a/lib/minitest/unit.rb b/lib/minitest/unit.rb
index e8013155fe..edb07e8e67 100644
--- a/lib/minitest/unit.rb
+++ b/lib/minitest/unit.rb
@@ -520,7 +520,7 @@ module MiniTest
   end
 
   class Unit
-    VERSION = "2.0.1" # :nodoc:
+    VERSION = "2.0.2" # :nodoc:
 
     attr_accessor :report, :failures, :errors, :skips # :nodoc:
     attr_accessor :test_count, :assertion_count       # :nodoc:
-- 
cgit v1.2.3