Class: Minitest::BenchSpec

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain: self, `Spec::DSL`, `Benchmark`, `Test`, `Guard`, `Runnable`
Instance Chain: self, `Benchmark`, `Test`, `Guard`, `Test::LifecycleHooks`, `Assertions`, `Reportable`, `Runnable`
Inherits:	Minitest::Benchmark Object Minitest::Runnable Minitest::Test Minitest::Benchmark Minitest::BenchSpec
Defined in:	lib/minitest/benchmark.rb

Overview

The spec version of Benchmark.

Constant Summary

Class Attribute Summary

`Spec::DSL` - Extended

desc

`Test` - Inherited

.io_lock

Class Method Summary

.bench(name, &block)

This is used to define a new benchmark method.
.bench_performance_constant(name, threshold = 0.99, &work)

Create a benchmark that verifies that the performance is constant.
.bench_performance_exponential(name, threshold = 0.99, &work)

Create a benchmark that verifies that the performance is exponential.
.bench_performance_linear(name, threshold = 0.99, &work)

Create a benchmark that verifies that the performance is linear.
.bench_performance_logarithmic(name, threshold = 0.99, &work)

Create a benchmark that verifies that the performance is logarithmic.
.bench_performance_power(name, threshold = 0.99, &work)

Create a benchmark that verifies that the performance is power.
.bench_range(&block)

Specifies the ranges used for benchmarking for that class.

`Spec::DSL` - Extended

after	Define an ‘after’ action.
before	Define a ‘before’ action.
inspect	Alias for Spec::DSL#name.
it	Define an expectation with name `desc`.
let	Essentially, define an accessor for `name` with `block`.
register_spec_type	Register a new type of spec that matches the spec’s description.
spec_type	Figure out the spec class to use based on a spec’s description.
specify	Alias for Spec::DSL#it.
subject	Another lazy man’s accessor generator.
to_s	Alias for Spec::DSL#name.
children, create, describe_stack, name, nuke_test_methods!

`Benchmark` - Inherited

.bench_exp	Returns a set of ranges stepped exponentially from `min` to `max` by powers of `base`.
.bench_linear	Returns a set of ranges stepped linearly from `min` to `max` by `step`.
.bench_range	Specifies the ranges used for benchmarking for that class.
.io, .run, .runnable_methods

`Test` - Inherited

.i_suck_and_my_tests_are_order_dependent!	Call this at the top of your tests when you absolutely positively need to have ordered tests.
.make_my_diffs_pretty!	Make diffs for this `Test` use `#pretty_inspect` so that diff in assert_equal can have more details.
.parallelize_me!	Call this at the top of your tests (inside the `Test` subclass or `describe` block) when you want to run your tests in parallel.
.runnable_methods	Returns all instance methods starting with “test_”.

`Guard` - Extended

jruby?	Is this running on jruby?
mri?	Is this running on mri?
osx?	Is this running on macOS?
windows?	Is this running on windows?

`Runnable` - Inherited

.filter_runnable_methods	Returns an array of filtered `runnable_methods`.
.methods_matching	Returns all instance methods matching the pattern `re`.
.run	Runs a single method and has the reporter record the result.
.run_order	Defines the order to run tests (:random by default).
.run_suite	Responsible for running all runnable methods in a given class, each in its own instance.
.runnable_methods	Each subclass of `Runnable` is responsible for overriding this method to return all runnable methods.
.runnables	Returns all subclasses of `Runnable`.
.inherited, .new, .on_signal, .reset, .with_info_handler

Instance Attribute Summary

`Assertions` - Included

#skipped?

Was this testcase skipped? Meant for #teardown.

`Reportable` - Included

#error?	Did this run error?
#passed?	Did this run pass?
#skipped?	Was this run skipped?

`Runnable` - Inherited

#assertions	Number of assertions executed in this run.
#failures	An assertion raised during the run, if any.
#metadata	Metadata you attach to the test results that get sent to the reporter.
#metadata=	Sets metadata, mainly used for Result.from.
#metadata?	Returns true if metadata exists.
#name	Name of the run.
#name=	Set the name of the run.
#passed?	Did this run pass?
#skipped?	Was this run skipped? See `#passed?` for more information.
#time	The time it took to run.

Instance Method Summary

`Benchmark` - Inherited

#assert_performance	Runs the given `work`, gathering the times of each run.
#assert_performance_constant	Runs the given `work` and asserts that the times gathered fit to match a constant rate (eg, linear slope == 0) within a given `threshold`.
#assert_performance_exponential	Runs the given `work` and asserts that the times gathered fit to match a exponential curve within a given error `threshold`.
#assert_performance_linear	Runs the given `work` and asserts that the times gathered fit to match a straight line within a given error `threshold`.
#assert_performance_logarithmic	Runs the given `work` and asserts that the times gathered fit to match a logarithmic curve within a given error `threshold`.
#assert_performance_power	Runs the given `work` and asserts that the times gathered curve fit to match a power curve within a given error `threshold`.
#fit_error	Takes an array of x/y pairs and calculates the general R^2 value.
#fit_exponential	To fit a functional form: y = ae^(bx).
#fit_linear	Fits the functional form: a + bx.
#fit_logarithmic	To fit a functional form: y = a + b*ln(x).
#fit_power	To fit a functional form: y = ax^b.
#sigma	Enumerates over `enum` mapping `block` if given, returning the sum of the result.
#validation_for_fit	Returns a proc that calls the specified fit method and asserts that the error is within a tolerable threshold.
#io

`Test` - Inherited

#run	Runs a single test with setup/teardown hooks.
#capture_exceptions	LifecycleHooks.
#neuter_exception, #new_exception, #sanitize_exception

`Guard` - Included

#jruby?	Is this running on jruby?
#mri?	Is this running on mri?
#osx?	Is this running on macOS?
#windows?	Is this running on windows?

`Test::LifecycleHooks` - Included

#after_setup	Runs before every test, after setup.
#after_teardown	Runs after every test, after teardown.
#before_setup	Runs before every test, before setup.
#before_teardown	Runs after every test, before teardown.
#setup	Runs before every test.
#teardown	Runs after every test.

`Assertions` - Included

#assert	Fails unless `test` is truthy.
#assert_empty	Fails unless `obj` is empty.
#assert_equal	Fails unless `exp == act` printing the difference between the two, if possible.
#assert_in_delta	For comparing Floats.
#assert_in_epsilon	For comparing Floats.
#assert_includes	Fails unless `collection` includes `obj`.
#assert_instance_of	Fails unless `obj` is an instance of `cls`.
#assert_kind_of	Fails unless `obj` is a kind of `cls`.
#assert_match	Fails unless `matcher` `=~` `obj`.
#assert_nil	Fails unless `obj` is nil.
#assert_operator	For testing with binary operators.
#assert_output	Fails if stdout or stderr do not output the expected results.
#assert_path_exists	Fails unless `path` exists.
#assert_pattern	For testing with pattern matching (only supported with Ruby 3.0 and later).
#assert_predicate	For testing with predicates.
#assert_raises	Fails unless the block raises one of `exp`.
#assert_respond_to	Fails unless `obj` responds to `meth`.
#assert_same	Fails unless `exp` and `act` are `#equal?`
#assert_silent	Fails if the block outputs anything to stderr or stdout.
#assert_throws	Fails unless the block throws `sym`
#capture_io	Captures $stdout and $stderr into strings:
#capture_subprocess_io	Captures $stdout and $stderr into strings, using Tempfile to ensure that subprocess IO is captured as well.
#diff	Returns a diff between `exp` and `act`.
#exception_details	Returns details for exception `e`.
#fail_after	Fails after a given date (in the local time zone).
#flunk	Fails with `msg`.
#message	Returns a proc that delays generation of an output message.
#mu_pp	This returns a human-readable version of `obj`.
#mu_pp_for_diff	This returns a diff-able more human-readable version of `obj`.
#pass	used for counting assertions.
#refute	Fails if `test` is truthy.
#refute_empty	Fails if `obj` is empty.
#refute_equal	Fails if `exp == act`.
#refute_in_delta	For comparing Floats.
#refute_in_epsilon	For comparing Floats.
#refute_includes	Fails if `obj` includes `sub`.
#refute_instance_of	Fails if `obj` is an instance of `cls`.
#refute_kind_of	Fails if `obj` is a kind of `cls`.
#refute_match	Fails if `matcher` `=~` `obj`.
#refute_nil	Fails if `obj` is nil.
#refute_operator	Fails if `o1` is not `op` `o2`.
#refute_path_exists	Fails if `path` exists.
#refute_pattern	For testing with pattern matching (only supported with Ruby 3.0 and later).
#refute_predicate	For testing with predicates.
#refute_respond_to	Fails if `obj` responds to the message `meth`.
#refute_same	Fails if `exp` is the same (by object identity) as `act`.
#skip	Skips the current run.
#skip_until	Skips the current run until a given date (in the local time zone).
#things_to_diff	Returns things to diff [expect, butwas], or [nil, nil] if nothing to diff.
#_synchronize, #_where

`Reportable` - Included

#location	The location identifier of this test.
#result_code	Returns “.”, “F”, or “E” based on the result of the run.
#class_name

`Runnable` - Inherited

#result_code	Returns a single character string to print based on the result of the run.
#run	Runs a single method.
#failure, #time_it

Constructor Details

This class inherits a constructor from Minitest::Runnable

Class Method Details

.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.

[ GitHub ]

# File 'lib/minitest/benchmark.rb', line 355


def self.bench name, &block
  define_method "bench_#{name.gsub(/\W+/, "_")}", &block
end

.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

[ GitHub ]

# File 'lib/minitest/benchmark.rb', line 399


def self.bench_performance_constant name, threshold = 0.99, &work
  bench name do
    assert_performance_constant threshold, &work
  end
end

.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

[ GitHub ]

# File 'lib/minitest/benchmark.rb', line 414


def self.bench_performance_exponential name, threshold = 0.99, &work
  bench name do
    assert_performance_exponential threshold, &work
  end
end

.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

[ GitHub ]

# File 'lib/minitest/benchmark.rb', line 384


def self.bench_performance_linear name, threshold = 0.99, &work
  bench name do
    assert_performance_linear threshold, &work
  end
end

.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

[ GitHub ]

# File 'lib/minitest/benchmark.rb', line 429


def self.bench_performance_logarithmic name, threshold = 0.99, &work
  bench name do
    assert_performance_logarithmic threshold, &work
  end
end

.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

[ GitHub ]

# File 'lib/minitest/benchmark.rb', line 444


def self.bench_performance_power name, threshold = 0.99, &work
  bench name do
    assert_performance_power threshold, &work
  end
end

.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.

[ GitHub ]

# File 'lib/minitest/benchmark.rb', line 368


def self.bench_range &block
  return super unless block

  meta = (class << self; self; end)
  meta.send :define_method, "bench_range", &block
end

Class: Minitest::BenchSpec

Overview

Constant Summary

Runnable - Inherited

Reportable - Included

Assertions - Included

Test - Inherited

Class Attribute Summary

Spec::DSL - Extended

Test - Inherited

Class Method Summary

Spec::DSL - Extended

Benchmark - Inherited

Test - Inherited

Guard - Extended

Runnable - Inherited

Instance Attribute Summary

Assertions - Included

Reportable - Included

Runnable - Inherited

Instance Method Summary

Benchmark - Inherited

Test - Inherited

Guard - Included

Test::LifecycleHooks - Included

Assertions - Included

Reportable - Included

Runnable - Inherited

Constructor Details

Class Method Details

.bench(name, &block)

.bench_performance_constant(name, threshold = 0.99, &work)

.bench_performance_exponential(name, threshold = 0.99, &work)

.bench_performance_linear(name, threshold = 0.99, &work)

.bench_performance_logarithmic(name, threshold = 0.99, &work)

.bench_performance_power(name, threshold = 0.99, &work)

.bench_range(&block)

`Runnable` - Inherited

`Reportable` - Included

`Assertions` - Included

`Test` - Inherited

`Spec::DSL` - Extended

`Test` - Inherited

`Spec::DSL` - Extended

`Benchmark` - Inherited

`Test` - Inherited

`Guard` - Extended

`Runnable` - Inherited

`Assertions` - Included

`Reportable` - Included

`Runnable` - Inherited

`Benchmark` - Inherited

`Test` - Inherited

`Guard` - Included

`Test::LifecycleHooks` - Included

`Assertions` - Included

`Reportable` - Included

`Runnable` - Inherited