rbs-relaxed 3.9.0.1

data/stdlib/minitest/0/minitest/assertions.rbs

@@ -0,0 +1,590 @@
+# <!-- rdoc-file=lib/minitest/assertions.rb -->
+# Minitest Assertions.  All assertion methods accept a `msg` which is printed if
+# the assertion fails.
+#
+# Protocol: Nearly everything here boils up to `assert`, which expects to be
+# able to increment an instance accessor named `assertions`. This is not
+# provided by Assertions and must be provided by the thing including Assertions.
+# See Minitest::Runnable for an example.
+#
+module Minitest::Assertions
+  self.@diff: untyped
+
+  @skip: untyped
+
+  def self.inspect: () -> "UNDEFINED"
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - diff()
+  # -->
+  # Returns the diff command to use in #diff. Tries to intelligently figure out
+  # what diff to use.
+  #
+  def self.diff: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - diff=(o)
+  # -->
+  # Set the diff command to use in #diff.
+  #
+  def self.diff=: (untyped o) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - diff(exp, act)
+  # -->
+  # Returns a diff between `exp` and `act`. If there is no known diff command or
+  # if it doesn't make sense to diff the output (single line, short output), then
+  # it simply returns a basic comparison between the two.
+  #
+  # See `things_to_diff` for more info.
+  #
+  def diff: (untyped exp, untyped act) -> (::String | untyped)
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - things_to_diff(exp, act)
+  # -->
+  # Returns things to diff [expect, butwas], or [nil, nil] if nothing to diff.
+  #
+  # Criterion:
+  #
+  # 1.  Strings include newlines or escaped newlines, but not both.
+  # 2.  or:  String lengths are > 30 characters.
+  # 3.  or:  Strings are equal to each other (but maybe different encodings?).
+  # 4.  and: we found a diff executable.
+  #
+  def things_to_diff: (untyped exp, untyped act) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - mu_pp(obj)
+  # -->
+  # This returns a human-readable version of `obj`. By default #inspect is called.
+  # You can override this to use #pretty_inspect if you want.
+  #
+  # See Minitest::Test.make_my_diffs_pretty!
+  #
+  def mu_pp: (untyped obj) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - mu_pp_for_diff(obj)
+  # -->
+  # This returns a diff-able more human-readable version of `obj`. This differs
+  # from the regular mu_pp because it expands escaped newlines and makes
+  # hex-values (like object_ids) generic. This uses mu_pp to do the first pass and
+  # then cleans it up.
+  #
+  def mu_pp_for_diff: (untyped obj) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert(test, msg = nil)
+  # -->
+  # Fails unless `test` is truthy.
+  #
+  def assert: (untyped test, ?untyped? msg) -> true
+
+  def _synchronize: () { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_empty(obj, msg = nil)
+  # -->
+  # Fails unless `obj` is empty.
+  #
+  def assert_empty: (untyped obj, ?untyped? msg) -> untyped
+
+  def _where: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_equal(exp, act, msg = nil)
+  # -->
+  # Fails unless `exp == act` printing the difference between the two, if
+  # possible.
+  #
+  # If there is no visible difference but the assertion fails, you should suspect
+  # that your #== is buggy, or your inspect output is missing crucial details.
+  # For nicer structural diffing, set Minitest::Test.make_my_diffs_pretty!
+  #
+  # For floats use assert_in_delta.
+  #
+  # See also: Minitest::Assertions.diff
+  #
+  def assert_equal: (untyped exp, untyped act, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_in_delta(exp, act, delta = 0.001, msg = nil)
+  # -->
+  # For comparing Floats.  Fails unless `exp` and `act` are within `delta` of each
+  # other.
+  #
+  #     assert_in_delta Math::PI, (22.0 / 7.0), 0.01
+  #
+  def assert_in_delta: (untyped exp, untyped act, ?::Float delta, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_in_epsilon(exp, act, epsilon = 0.001, msg = nil)
+  # -->
+  # For comparing Floats.  Fails unless `exp` and `act` have a relative error less
+  # than `epsilon`.
+  #
+  def assert_in_epsilon: (untyped exp, untyped act, ?::Float epsilon, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_includes(collection, obj, msg = nil)
+  # -->
+  # Fails unless `collection` includes `obj`.
+  #
+  def assert_includes: (untyped collection, untyped obj, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_instance_of(cls, obj, msg = nil)
+  # -->
+  # Fails unless `obj` is an instance of `cls`.
+  #
+  def assert_instance_of: (untyped cls, untyped obj, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_kind_of(cls, obj, msg = nil)
+  # -->
+  # Fails unless `obj` is a kind of `cls`.
+  #
+  def assert_kind_of: (untyped cls, untyped obj, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_match(matcher, obj, msg = nil)
+  # -->
+  # Fails unless `matcher` `=~` `obj`.
+  #
+  def assert_match: (untyped matcher, untyped obj, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_nil(obj, msg = nil)
+  # -->
+  # Fails unless `obj` is nil
+  #
+  def assert_nil: (untyped obj, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_operator(o1, op, o2 = UNDEFINED, msg = nil)
+  # -->
+  # For testing with binary operators. Eg:
+  #
+  #     assert_operator 5, :<=, 4
+  #
+  def assert_operator: (untyped o1, untyped op, ?untyped o2, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_output(stdout = nil, stderr = nil) { || ... }
+  # -->
+  # Fails if stdout or stderr do not output the expected results. Pass in nil if
+  # you don't care about that streams output. Pass in "" if you require it to be
+  # silent. Pass in a regexp if you want to pattern match.
+  #
+  #     assert_output(/hey/) { method_with_output }
+  #
+  # NOTE: this uses #capture_io, not #capture_subprocess_io.
+  #
+  # See also: #assert_silent
+  #
+  def assert_output: (?untyped? stdout, ?untyped? stderr) ?{ () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_path_exists(path, msg = nil)
+  # -->
+  # Fails unless `path` exists.
+  #
+  def assert_path_exists: (untyped path, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_pattern() { || ... }
+  # -->
+  # For testing with pattern matching (only supported with Ruby 3.0 and later)
+  #
+  #     # pass
+  #     assert_pattern { [1,2,3] => [Integer, Integer, Integer] }
+  #
+  #     # fail "length mismatch (given 3, expected 1)"
+  #     assert_pattern { [1,2,3] => [Integer] }
+  #
+  # The bare `=>` pattern will raise a NoMatchingPatternError on failure, which
+  # would normally be counted as a test error. This assertion rescues
+  # NoMatchingPatternError and generates a test failure. Any other exception will
+  # be raised as normal and generate a test error.
+  #
+  def assert_pattern: () ?{ () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_predicate(o1, op, msg = nil)
+  # -->
+  # For testing with predicates. Eg:
+  #
+  #     assert_predicate str, :empty?
+  #
+  # This is really meant for specs and is front-ended by assert_operator:
+  #
+  #     str.must_be :empty?
+  #
+  def assert_predicate: (untyped o1, untyped op, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_raises(*exp) { || ... }
+  # -->
+  # Fails unless the block raises one of `exp`. Returns the exception matched so
+  # you can check the message, attributes, etc.
+  #
+  # `exp` takes an optional message on the end to help explain failures and
+  # defaults to StandardError if no exception class is passed. Eg:
+  #
+  #     assert_raises(CustomError) { method_with_custom_error }
+  #
+  # With custom error message:
+  #
+  #     assert_raises(CustomError, 'This should have raised CustomError') { method_with_custom_error }
+  #
+  # Using the returned object:
+  #
+  #     error = assert_raises(CustomError) do
+  #       raise CustomError, 'This is really bad'
+  #     end
+  #
+  #     assert_equal 'This is really bad', error.message
+  #
+  def assert_raises: (*untyped exp) ?{ () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_respond_to(obj, meth, msg = nil, include_all: false)
+  # -->
+  # Fails unless `obj` responds to `meth`. include_all defaults to false to match
+  # Object#respond_to?
+  #
+  def assert_respond_to: (untyped obj, untyped meth, ?untyped? msg, ?include_all: bool) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_same(exp, act, msg = nil)
+  # -->
+  # Fails unless `exp` and `act` are #equal?
+  #
+  def assert_same: (untyped exp, untyped act, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_send(send_ary, m = nil)
+  # -->
+  # `send_ary` is a receiver, message and arguments.
+  #
+  # Fails unless the call returns a true value
+  #
+  def assert_send: (untyped send_ary, ?untyped? m) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_silent() { || ... }
+  # -->
+  # Fails if the block outputs anything to stderr or stdout.
+  #
+  # See also: #assert_output
+  #
+  def assert_silent: () { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - assert_throws(sym, msg = nil) { || ... }
+  # -->
+  # Fails unless the block throws `sym`
+  #
+  def assert_throws: (untyped sym, ?untyped? msg) { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - capture_io() { || ... }
+  # -->
+  # Captures $stdout and $stderr into strings:
+  #
+  #     out, err = capture_io do
+  #       puts "Some info"
+  #       warn "You did a bad thing"
+  #     end
+  #
+  #     assert_match %r%info%, out
+  #     assert_match %r%bad%, err
+  #
+  # NOTE: For efficiency, this method uses StringIO and does not capture IO for
+  # subprocesses. Use #capture_subprocess_io for that.
+  #
+  def capture_io: () { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - capture_subprocess_io() { || ... }
+  # -->
+  # Captures $stdout and $stderr into strings, using Tempfile to ensure that
+  # subprocess IO is captured as well.
+  #
+  #     out, err = capture_subprocess_io do
+  #       system "echo Some info"
+  #       system "echo You did a bad thing 1>&2"
+  #     end
+  #
+  #     assert_match %r%info%, out
+  #     assert_match %r%bad%, err
+  #
+  # NOTE: This method is approximately 10x slower than #capture_io so only use it
+  # when you need to test the output of a subprocess.
+  #
+  def capture_subprocess_io: () { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - exception_details(e, msg)
+  # -->
+  # Returns details for exception `e`
+  #
+  def exception_details: (untyped e, untyped msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - fail_after(y, m, d, msg)
+  # -->
+  # Fails after a given date (in the local time zone). This allows you to put
+  # time-bombs in your tests if you need to keep something around until a later
+  # date lest you forget about it.
+  #
+  def fail_after: (untyped y, untyped m, untyped d, untyped msg) -> (untyped | nil)
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - flunk(msg = nil)
+  # -->
+  # Fails with `msg`.
+  #
+  def flunk: (?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - message(msg = nil, ending = nil, &default)
+  # -->
+  # Returns a proc that will output `msg` along with the default message.
+  #
+  def message: (?untyped? msg, ?untyped? ending) { (?) -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - pass(_msg = nil)
+  # -->
+  # used for counting assertions
+  #
+  def pass: (?untyped? _msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute(test, msg = nil)
+  # -->
+  # Fails if `test` is truthy.
+  #
+  def refute: (untyped test, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_empty(obj, msg = nil)
+  # -->
+  # Fails if `obj` is empty.
+  #
+  def refute_empty: (untyped obj, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_equal(exp, act, msg = nil)
+  # -->
+  # Fails if `exp == act`.
+  #
+  # For floats use refute_in_delta.
+  #
+  def refute_equal: (untyped exp, untyped act, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_in_delta(exp, act, delta = 0.001, msg = nil)
+  # -->
+  # For comparing Floats.  Fails if `exp` is within `delta` of `act`.
+  #
+  #     refute_in_delta Math::PI, (22.0 / 7.0)
+  #
+  def refute_in_delta: (untyped exp, untyped act, ?::Float delta, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_in_epsilon(a, b, epsilon = 0.001, msg = nil)
+  # -->
+  # For comparing Floats.  Fails if `exp` and `act` have a relative error less
+  # than `epsilon`.
+  #
+  def refute_in_epsilon: (untyped a, untyped b, ?::Float epsilon, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_includes(collection, obj, msg = nil)
+  # -->
+  # Fails if `collection` includes `obj`.
+  #
+  def refute_includes: (untyped collection, untyped obj, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_instance_of(cls, obj, msg = nil)
+  # -->
+  # Fails if `obj` is an instance of `cls`.
+  #
+  def refute_instance_of: (untyped cls, untyped obj, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_kind_of(cls, obj, msg = nil)
+  # -->
+  # Fails if `obj` is a kind of `cls`.
+  #
+  def refute_kind_of: (untyped cls, untyped obj, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_match(matcher, obj, msg = nil)
+  # -->
+  # Fails if `matcher` `=~` `obj`.
+  #
+  def refute_match: (untyped matcher, untyped obj, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_nil(obj, msg = nil)
+  # -->
+  # Fails if `obj` is nil.
+  #
+  def refute_nil: (untyped obj, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_pattern() { || ... }
+  # -->
+  # For testing with pattern matching (only supported with Ruby 3.0 and later)
+  #
+  #     # pass
+  #     refute_pattern { [1,2,3] => [String] }
+  #
+  #     # fail "NoMatchingPatternError expected, but nothing was raised."
+  #     refute_pattern { [1,2,3] => [Integer, Integer, Integer] }
+  #
+  # This assertion expects a NoMatchingPatternError exception, and will fail if
+  # none is raised. Any other exceptions will be raised as normal and generate a
+  # test error.
+  #
+  def refute_pattern: () ?{ () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_operator(o1, op, o2 = UNDEFINED, msg = nil)
+  # -->
+  # Fails if `o1` is not `op` `o2`. Eg:
+  #
+  #     refute_operator 1, :>, 2 #=> pass
+  #     refute_operator 1, :<, 2 #=> fail
+  #
+  def refute_operator: (untyped o1, untyped op, ?untyped o2, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_path_exists(path, msg = nil)
+  # -->
+  # Fails if `path` exists.
+  #
+  def refute_path_exists: (untyped path, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_predicate(o1, op, msg = nil)
+  # -->
+  # For testing with predicates.
+  #
+  #     refute_predicate str, :empty?
+  #
+  # This is really meant for specs and is front-ended by refute_operator:
+  #
+  #     str.wont_be :empty?
+  #
+  def refute_predicate: (untyped o1, untyped op, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_respond_to(obj, meth, msg = nil, include_all: false)
+  # -->
+  # Fails if `obj` responds to the message `meth`. include_all defaults to false
+  # to match Object#respond_to?
+  #
+  def refute_respond_to: (untyped obj, untyped meth, ?untyped? msg, ?include_all: bool) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - refute_same(exp, act, msg = nil)
+  # -->
+  # Fails if `exp` is the same (by object identity) as `act`.
+  #
+  def refute_same: (untyped exp, untyped act, ?untyped? msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - skip(msg = nil, _ignored = nil)
+  # -->
+  # Skips the current run. If run in verbose-mode, the skipped run gets listed at
+  # the end of the run but doesn't cause a failure exit code.
+  #
+  def skip: (?untyped? msg, ?untyped? _ignored) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - skip_until(y, m, d, msg)
+  # -->
+  # Skips the current run until a given date (in the local time zone). This allows
+  # you to put some fixes on hold until a later date, but still holds you
+  # accountable and prevents you from forgetting it.
+  #
+  def skip_until: (untyped y, untyped m, untyped d, untyped msg) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/assertions.rb
+  #   - skipped?()
+  # -->
+  # Was this testcase skipped? Meant for #teardown.
+  #
+  def skipped?: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/mock.rb
+  #   - assert_mock(mock)
+  # -->
+  # Assert that the mock verifies correctly.
+  #
+  def assert_mock: (untyped mock) -> untyped
+
+  E: String
+
+  UNDEFINED: Object
+end

data/stdlib/minitest/0/minitest/backtrace_filter.rbs

@@ -0,0 +1,23 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# The standard backtrace filter for minitest.
+#
+# See Minitest.backtrace_filter=.
+#
+class Minitest::BacktraceFilter
+  def initialize: (?untyped regexp) -> void
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - filter(bt)
+  # -->
+  # Filter `bt` to something useful. Returns the whole thing if $DEBUG (ruby) or
+  # $MT_DEBUG (env).
+  #
+  def filter: (untyped bt) -> (::Array["No backtrace"] | untyped)
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # The regular expression to use to filter backtraces. Defaults to `MT_RE`.
+  #
+  attr_accessor regexp: untyped
+  MT_RE: Regexp
+end

data/stdlib/minitest/0/minitest/bench_spec.rbs

@@ -0,0 +1,102 @@
+# <!-- rdoc-file=lib/minitest/benchmark.rb -->
+# The spec version of Minitest::Benchmark.
+#
+class Minitest::BenchSpec < ::Minitest::Benchmark
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - bench(name, &block)
+  # -->
+  # 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: (untyped name) { (?) -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - bench_range(&block)
+  # -->
+  # 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: () ?{ (?) -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - bench_performance_linear(name, threshold = 0.99, &work)
+  # -->
+  # Create a benchmark that verifies that the performance is linear.
+  #
+  #     describe "my class Bench" do
+  #       bench_performance_linear "fast_algorithm", 0.9999 do |n|
+  #         @obj.fast_algorithm(n)
+  #       end
+  #     end
+  #
+  def self.bench_performance_linear: (untyped name, ?::Float threshold) { (?) -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - bench_performance_constant(name, threshold = 0.99, &work)
+  # -->
+  # Create a benchmark that verifies that the performance is constant.
+  #
+  #     describe "my class Bench" do
+  #       bench_performance_constant "zoom_algorithm!" do |n|
+  #         @obj.zoom_algorithm!(n)
+  #       end
+  #     end
+  #
+  def self.bench_performance_constant: (untyped name, ?::Float threshold) { (?) -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - bench_performance_exponential(name, threshold = 0.99, &work)
+  # -->
+  # Create a benchmark that verifies that the performance is exponential.
+  #
+  #     describe "my class Bench" do
+  #       bench_performance_exponential "algorithm" do |n|
+  #         @obj.algorithm(n)
+  #       end
+  #     end
+  #
+  def self.bench_performance_exponential: (untyped name, ?::Float threshold) { (?) -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - bench_performance_logarithmic(name, threshold = 0.99, &work)
+  # -->
+  # Create a benchmark that verifies that the performance is logarithmic.
+  #
+  #     describe "my class Bench" do
+  #       bench_performance_logarithmic "algorithm" do |n|
+  #         @obj.algorithm(n)
+  #       end
+  #     end
+  #
+  def self.bench_performance_logarithmic: (untyped name, ?::Float threshold) { (?) -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - bench_performance_power(name, threshold = 0.99, &work)
+  # -->
+  # Create a benchmark that verifies that the performance is power.
+  #
+  #     describe "my class Bench" do
+  #       bench_performance_power "algorithm" do |n|
+  #         @obj.algorithm(n)
+  #       end
+  #     end
+  #
+  def self.bench_performance_power: (untyped name, ?::Float threshold) { (?) -> untyped } -> untyped
+  extend Minitest::Spec::DSL
+  include Minitest::Spec::DSL::InstanceMethods
+end