minitest 5.11.3 → 5.25.4

data/lib/minitest/benchmark.rb

@@ -47,8 +47,6 @@ module Minitest
 
     def self.bench_linear min, max, step = 10
       (min..max).step(step).to_a
-    rescue LocalJumpError # 1.8.6
-      r = []; (min..max).step(step) { |n| r << n }; r
     end
 
     ##
@@ -83,7 +81,7 @@ module Minitest
     def assert_performance validation, &work
       range = self.class.bench_range
 
-      io.print "#{self.name}"
+      io.print self.name
 
       times = []
 
@@ -109,8 +107,8 @@ module Minitest
     # is applied against the slope itself. As such, you probably want
     # to tighten it from the default.
     #
-    # See http://www.graphpad.com/curvefit/goodness_of_fit.htm for
-    # more details.
+    # See https://www.graphpad.com/guides/prism/8/curve-fitting/reg_intepretingnonlinr2.htm
+    # for more details.
     #
     # Fit is calculated by #fit_linear.
     #
@@ -217,7 +215,7 @@ module Minitest
     ##
     # Takes an array of x/y pairs and calculates the general R^2 value.
     #
-    # See: http://en.wikipedia.org/wiki/Coefficient_of_determination
+    # See: https://en.wikipedia.org/wiki/Coefficient_of_determination
 
     def fit_error xys
       y_bar  = sigma(xys) { |_, y| y } / xys.size.to_f
@@ -232,11 +230,11 @@ module Minitest
     #
     # Takes x and y values and returns [a, b, r^2].
     #
-    # See: http://mathworld.wolfram.com/LeastSquaresFittingExponential.html
+    # See: https://mathworld.wolfram.com/LeastSquaresFittingExponential.html
 
     def fit_exponential xs, ys
       n     = xs.size
-      xys   = xs.zip(ys)
+      xys   = xs.zip ys
       sxlny = sigma(xys) { |x, y| x * Math.log(y) }
       slny  = sigma(xys) { |_, y| Math.log(y)     }
       sx2   = sigma(xys) { |x, _| x * x           }
@@ -254,11 +252,11 @@ module Minitest
     #
     # Takes x and y values and returns [a, b, r^2].
     #
-    # See: http://mathworld.wolfram.com/LeastSquaresFittingLogarithmic.html
+    # See: https://mathworld.wolfram.com/LeastSquaresFittingLogarithmic.html
 
     def fit_logarithmic xs, ys
       n     = xs.size
-      xys   = xs.zip(ys)
+      xys   = xs.zip ys
       slnx2 = sigma(xys) { |x, _| Math.log(x) ** 2 }
       slnx  = sigma(xys) { |x, _| Math.log(x)      }
       sylnx = sigma(xys) { |x, y| y * Math.log(x)  }
@@ -276,11 +274,11 @@ module Minitest
     #
     # Takes x and y values and returns [a, b, r^2].
     #
-    # See: http://mathworld.wolfram.com/LeastSquaresFitting.html
+    # See: https://mathworld.wolfram.com/LeastSquaresFitting.html
 
     def fit_linear xs, ys
       n   = xs.size
-      xys = xs.zip(ys)
+      xys = xs.zip ys
       sx  = sigma xs
       sy  = sigma ys
       sx2 = sigma(xs)  { |x|   x ** 2 }
@@ -298,11 +296,11 @@ module Minitest
     #
     # Takes x and y values and returns [a, b, r^2].
     #
-    # See: http://mathworld.wolfram.com/LeastSquaresFittingPowerLaw.html
+    # See: https://mathworld.wolfram.com/LeastSquaresFittingPowerLaw.html
 
     def fit_power xs, ys
       n       = xs.size
-      xys     = xs.zip(ys)
+      xys     = xs.zip ys
       slnxlny = sigma(xys) { |x, y| Math.log(x) * Math.log(y) }
       slnx    = sigma(xs)  { |x   | Math.log(x)               }
       slny    = sigma(ys)  { |   y| Math.log(y)               }
@@ -323,7 +321,7 @@ module Minitest
 
     def sigma enum, &block
       enum = enum.map(&block) if block
-      enum.inject { |sum, n| sum + n }
+      enum.sum
     end
 
     ##
@@ -419,7 +417,6 @@ module Minitest
       end
     end
 
-
     ##
     # Create a benchmark that verifies that the performance is logarithmic.
     #

data/lib/minitest/compress.rb

@@ -0,0 +1,94 @@
+module Minitest
+  ##
+  # Compresses backtraces.
+
+  module Compress
+
+    ##
+    # Takes a backtrace (array of strings) and compresses repeating
+    # cycles in it to make it more readable.
+
+    def compress orig
+      ary = orig
+
+      eswo = ->(a, n, off) { # each_slice_with_offset
+        if off.zero? then
+          a.each_slice n
+        else
+          # [ ...off... [...n...] [...n...] ... ]
+          front, back = a.take(off), a.drop(off)
+          [front].chain back.each_slice n
+        end
+      }
+
+      3.times do # maybe don't use loop do here?
+        index = ary                               # [ a b c b c b c d ]
+          .size
+          .times                                  # 0...size
+          .group_by { |i| ary[i] }                # { a: [0] b: [1 3 5], c: [2 4 6], d: [7] }
+
+        order = index
+          .reject { |k, v| v.size == 1 }          # { b: [1 3 5], c: [2 4 6] }
+          .sort_by { |k, a1|                      ### sort by max dist + min offset
+            d = a1.each_cons(2).sum { |a2, b| b-a2 }
+            [-d, a1.first]
+          }                                       # b: [1 3 5] c: [2 4 6]
+
+        ranges = order
+          .map { |k, a1|                          # [[1..2 3..4] [2..3 4..5]]
+            a1
+              .each_cons(2)
+              .map { |a2, b| a2..b-1 }
+          }
+
+        big_ranges = ranges
+          .flat_map { |a|                         # [1..2 3..4 2..3 4..5]
+            a.sort_by { |r| [-r.size, r.first] }.first 5
+          }
+          .first(100)
+
+        culprits = big_ranges
+          .map { |r|
+            eswo[ary, r.size, r.begin]            # [o1 s1 s1 s2 s2]
+              .chunk_while { |a, b| a == b }      # [[o1] [s1 s1] [s2 s2]]
+              .map { |a| [a.size, a.first] }      # [[1 o1] [2 s1] [2 s2]]
+          }
+          .select { |chunks|
+            chunks.any? { |a| a.first > 1 }       # compressed anything?
+          }
+
+        min = culprits
+          .min_by { |a| a.flatten.size }          # most compressed
+
+        break unless min
+
+        ary = min.flat_map { |(n, lines)|
+          if n > 1 then
+            [[n, compress(lines)]]                # [o1 [2 s1] [2 s2]]
+          else
+            lines
+          end
+        }
+      end
+
+      format = ->(lines) {
+        lines.flat_map { |line|
+          case line
+          when Array then
+            n, lines = line
+            lines = format[lines]
+            [
+              " +->> #{n} cycles of #{lines.size} lines:",
+              *lines.map { |s| " | #{s}" },
+              " +-<<",
+            ]
+          else
+            line
+          end
+        }
+      }
+
+      format[ary]
+    end
+  end
+end

data/lib/minitest/error_on_warning.rb

@@ -0,0 +1,11 @@
+module Minitest
+
+  module ErrorOnWarning # :nodoc:
+    def warn message, category: nil
+      message = "[#{category}] #{message}" if category
+      raise UnexpectedWarning, message
+    end
+  end
+
+  ::Warning.singleton_class.prepend ErrorOnWarning
+end

data/lib/minitest/expectations.rb

@@ -9,10 +9,11 @@
 #
 #     it "should still work in threads" do
 #       my_threaded_thingy do
-#         (1+1).must_equal 2         # bad
-#         assert_equal 2, 1+1        # good
-#         _(1 + 1).must_equal 2      # good
-#         value(1 + 1).must_equal 2  # good, also #expect
+#         (1+1).must_equal 2                  # bad
+#         assert_equal 2, 1+1                 # good
+#         _(1 + 1).must_equal 2               # good
+#         value(1 + 1).must_equal 2           # good, also #expect
+#         _ { 1 + "1" }.must_raise TypeError  # good
 #       end
 #     end
 
@@ -21,7 +22,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_empty.
   #
-  #    collection.must_be_empty
+  #    _(collection).must_be_empty
   #
   # :method: must_be_empty
 
@@ -30,7 +31,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_equal
   #
-  #    a.must_equal b
+  #    _(a).must_equal b
   #
   # :method: must_equal
 
@@ -39,18 +40,18 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_in_delta
   #
-  #    n.must_be_close_to m [, 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:
+  infect_an_assertion :assert_in_delta, :must_be_within_delta # :nodoc:
 
   ##
   # See Minitest::Assertions#assert_in_epsilon
   #
-  #    n.must_be_within_epsilon m [, epsilon]
+  #    _(n).must_be_within_epsilon m [, epsilon]
   #
   # :method: must_be_within_epsilon
 
@@ -59,7 +60,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_includes
   #
-  #    collection.must_include obj
+  #    _(collection).must_include obj
   #
   # :method: must_include
 
@@ -68,7 +69,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_instance_of
   #
-  #    obj.must_be_instance_of klass
+  #    _(obj).must_be_instance_of klass
   #
   # :method: must_be_instance_of
 
@@ -77,7 +78,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_kind_of
   #
-  #    obj.must_be_kind_of mod
+  #    _(obj).must_be_kind_of mod
   #
   # :method: must_be_kind_of
 
@@ -86,7 +87,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_match
   #
-  #    a.must_match b
+  #    _(a).must_match b
   #
   # :method: must_match
 
@@ -95,7 +96,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_nil
   #
-  #    obj.must_be_nil
+  #    _(obj).must_be_nil
   #
   # :method: must_be_nil
 
@@ -104,11 +105,11 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_operator
   #
-  #    n.must_be :<=, 42
+  #    _(n).must_be :<=, 42
   #
   # This can also do predicates:
   #
-  #    str.must_be :empty?
+  #    _(str).must_be :empty?
   #
   # :method: must_be
 
@@ -117,16 +118,25 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_output
   #
-  #    proc { ... }.must_output out_or_nil [, err]
+  #    _ { ... }.must_output out_or_nil [, err]
   #
   # :method: must_output
 
   infect_an_assertion :assert_output, :must_output, :block
 
+  ##
+  # See Minitest::Assertions#assert_pattern_match
+  #
+  #    _ { ... }.must_pattern_match [...]
+  #
+  # :method: must_pattern_match
+
+  infect_an_assertion :assert_pattern, :must_pattern_match, :block
+
   ##
   # See Minitest::Assertions#assert_raises
   #
-  #    proc { ... }.must_raise exception
+  #    _ { ... }.must_raise exception
   #
   # :method: must_raise
 
@@ -135,7 +145,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_respond_to
   #
-  #    obj.must_respond_to msg
+  #    _(obj).must_respond_to msg
   #
   # :method: must_respond_to
 
@@ -144,7 +154,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_same
   #
-  #    a.must_be_same_as b
+  #    _(a).must_be_same_as b
   #
   # :method: must_be_same_as
 
@@ -153,7 +163,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_silent
   #
-  #    proc { ... }.must_be_silent
+  #    _ { ... }.must_be_silent
   #
   # :method: must_be_silent
 
@@ -162,16 +172,34 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#assert_throws
   #
-  #    proc { ... }.must_throw sym
+  #    _ { ... }.must_throw sym
   #
   # :method: must_throw
 
   infect_an_assertion :assert_throws, :must_throw, :block
 
+  ##
+  # See Minitest::Assertions#assert_path_exists
+  #
+  #   _(some_path).path_must_exist
+  #
+  # :method: path_must_exist
+
+  infect_an_assertion :assert_path_exists, :path_must_exist, :unary
+
+  ##
+  # See Minitest::Assertions#refute_path_exists
+  #
+  #   _(some_path).path_wont_exist
+  #
+  # :method: path_wont_exist
+
+  infect_an_assertion :refute_path_exists, :path_wont_exist, :unary
+
   ##
   # See Minitest::Assertions#refute_empty
   #
-  #    collection.wont_be_empty
+  #    _(collection).wont_be_empty
   #
   # :method: wont_be_empty
 
@@ -180,7 +208,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_equal
   #
-  #    a.wont_equal b
+  #    _(a).wont_equal b
   #
   # :method: wont_equal
 
@@ -189,18 +217,18 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_in_delta
   #
-  #    n.wont_be_close_to m [, 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:
+  infect_an_assertion :refute_in_delta, :wont_be_within_delta # :nodoc:
 
   ##
   # See Minitest::Assertions#refute_in_epsilon
   #
-  #    n.wont_be_within_epsilon m [, epsilon]
+  #    _(n).wont_be_within_epsilon m [, epsilon]
   #
   # :method: wont_be_within_epsilon
 
@@ -209,7 +237,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_includes
   #
-  #    collection.wont_include obj
+  #    _(collection).wont_include obj
   #
   # :method: wont_include
 
@@ -218,7 +246,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_instance_of
   #
-  #    obj.wont_be_instance_of klass
+  #    _(obj).wont_be_instance_of klass
   #
   # :method: wont_be_instance_of
 
@@ -227,7 +255,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_kind_of
   #
-  #    obj.wont_be_kind_of mod
+  #    _(obj).wont_be_kind_of mod
   #
   # :method: wont_be_kind_of
 
@@ -236,7 +264,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_match
   #
-  #    a.wont_match b
+  #    _(a).wont_match b
   #
   # :method: wont_match
 
@@ -245,7 +273,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_nil
   #
-  #    obj.wont_be_nil
+  #    _(obj).wont_be_nil
   #
   # :method: wont_be_nil
 
@@ -254,7 +282,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_operator
   #
-  #    n.wont_be :<=, 42
+  #    _(n).wont_be :<=, 42
   #
   # This can also do predicates:
   #
@@ -264,10 +292,19 @@ module Minitest::Expectations
 
   infect_an_assertion :refute_operator, :wont_be, :reverse
 
+  ##
+  # See Minitest::Assertions#refute_pattern_match
+  #
+  #    _ { ... }.wont_pattern_match [...]
+  #
+  # :method: wont_pattern_match
+
+  infect_an_assertion :refute_pattern, :wont_pattern_match, :block
+
   ##
   # See Minitest::Assertions#refute_respond_to
   #
-  #    obj.wont_respond_to msg
+  #    _(obj).wont_respond_to msg
   #
   # :method: wont_respond_to
 
@@ -276,7 +313,7 @@ module Minitest::Expectations
   ##
   # See Minitest::Assertions#refute_same
   #
-  #    a.wont_be_same_as b
+  #    _(a).wont_be_same_as b
   #
   # :method: wont_be_same_as
 

data/lib/minitest/manual_plugins.rb

@@ -0,0 +1,16 @@
+require "minitest"
+
+ARGV << "--no-plugins"
+
+module Minitest
+  ##
+  # Manually load plugins by name.
+
+  def self.load *names
+    names.each do |name|
+      require "minitest/#{name}_plugin"
+
+      self.extensions << name.to_s
+    end
+  end
+end