rbs 2.5.1 → 2.6.0

data/stdlib/minitest/0/minitest.rbs

@@ -0,0 +1,966 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# # minitest/{test,spec,mock,benchmark}
+#
+# home
+# :   https://github.com/seattlerb/minitest
+# bugs
+# :   https://github.com/seattlerb/minitest/issues
+# rdoc
+# :   http://docs.seattlerb.org/minitest
+# vim
+# :   https://github.com/sunaku/vim-ruby-minitest
+# emacs
+# :   https://github.com/arthurnn/minitest-emacs
+#
+#
+# ## DESCRIPTION:
+#
+# minitest provides a complete suite of testing facilities supporting TDD, BDD,
+# mocking, and benchmarking.
+#
+#     "I had a class with Jim Weirich on testing last week and we were
+#      allowed to choose our testing frameworks. Kirk Haines and I were
+#      paired up and we cracked open the code for a few test
+#      frameworks...
+#
+#      I MUST say that minitest is *very* readable / understandable
+#      compared to the 'other two' options we looked at. Nicely done and
+#      thank you for helping us keep our mental sanity."
+#
+#     -- Wayne E. Seguin
+#
+# minitest/test is a small and incredibly fast unit testing framework. It
+# provides a rich set of assertions to make your tests clean and readable.
+#
+# minitest/spec is a functionally complete spec engine. It hooks onto
+# minitest/test and seamlessly bridges test assertions over to spec
+# expectations.
+#
+# minitest/benchmark is an awesome way to assert the performance of your
+# algorithms in a repeatable manner. Now you can assert that your newb co-worker
+# doesn't replace your linear algorithm with an exponential one!
+#
+# minitest/mock by Steven Baker, is a beautifully tiny mock (and stub) object
+# framework.
+#
+# minitest/pride shows pride in testing and adds coloring to your test output. I
+# guess it is an example of how to write IO pipes too. :P
+#
+# minitest/test is meant to have a clean implementation for language
+# implementors that need a minimal set of methods to bootstrap a working test
+# suite. For example, there is no magic involved for test-case discovery.
+#
+#     "Again, I can't praise enough the idea of a testing/specing
+#      framework that I can actually read in full in one sitting!"
+#
+#     -- Piotr Szotkowski
+#
+# Comparing to rspec:
+#
+#     rspec is a testing DSL. minitest is ruby.
+#
+#     -- Adam Hawkins, "Bow Before MiniTest"
+#
+# minitest doesn't reinvent anything that ruby already provides, like: classes,
+# modules, inheritance, methods. This means you only have to learn ruby to use
+# minitest and all of your regular OO practices like extract-method refactorings
+# still apply.
+#
+# ## FEATURES/PROBLEMS:
+#
+# *   minitest/autorun - the easy and explicit way to run all your tests.
+# *   minitest/test - a very fast, simple, and clean test system.
+# *   minitest/spec - a very fast, simple, and clean spec system.
+# *   minitest/mock - a simple and clean mock/stub system.
+# *   minitest/benchmark - an awesome way to assert your algorithm's
+#     performance.
+# *   minitest/pride - show your pride in testing!
+# *   Incredibly small and fast runner, but no bells and whistles.
+# *   Written by squishy human beings. Software can never be perfect. We will
+#     all eventually die.
+#
+#
+# ## RATIONALE:
+#
+# See design_rationale.rb to see how specs and tests work in minitest.
+#
+# ## SYNOPSIS:
+#
+# Given that you'd like to test the following class:
+#
+#     class Meme
+#       def i_can_has_cheezburger?
+#         "OHAI!"
+#       end
+#
+#       def will_it_blend?
+#         "YES!"
+#       end
+#     end
+#
+# ### Unit tests
+#
+# Define your tests as methods beginning with `test_`.
+#
+#     require "minitest/autorun"
+#
+#     class TestMeme < Minitest::Test
+#       def setup
+#         @meme = Meme.new
+#       end
+#
+#       def test_that_kitty_can_eat
+#         assert_equal "OHAI!", @meme.i_can_has_cheezburger?
+#       end
+#
+#       def test_that_it_will_not_blend
+#         refute_match /^no/i, @meme.will_it_blend?
+#       end
+#
+#       def test_that_will_be_skipped
+#         skip "test this later"
+#       end
+#     end
+#
+# ### Specs
+#
+#     require "minitest/autorun"
+#
+#     describe Meme do
+#       before do
+#         @meme = Meme.new
+#       end
+#
+#       describe "when asked about cheeseburgers" do
+#         it "must respond positively" do
+#           _(@meme.i_can_has_cheezburger?).must_equal "OHAI!"
+#         end
+#       end
+#
+#       describe "when asked about blending possibilities" do
+#         it "won't say no" do
+#           _(@meme.will_it_blend?).wont_match /^no/i
+#         end
+#       end
+#     end
+#
+# For matchers support check out:
+#
+# *   https://github.com/wojtekmach/minitest-matchers
+# *   https://github.com/rmm5t/minitest-matchers_vaccine
+#
+#
+# ### Benchmarks
+#
+# Add benchmarks to your tests.
+#
+#     # optionally run benchmarks, good for CI-only work!
+#     require "minitest/benchmark" if ENV["BENCH"]
+#
+#     class TestMeme < Minitest::Benchmark
+#       # Override self.bench_range or default range is [1, 10, 100, 1_000, 10_000]
+#       def bench_my_algorithm
+#         assert_performance_linear 0.9999 do |n| # n is a range value
+#           @obj.my_algorithm(n)
+#         end
+#       end
+#     end
+#
+# Or add them to your specs. If you make benchmarks optional, you'll need to
+# wrap your benchmarks in a conditional since the methods won't be defined. In
+# minitest 5, the describe name needs to match `/Bench(mark)?$/`.
+#
+#     describe "Meme Benchmark" do
+#       if ENV["BENCH"] then
+#         bench_performance_linear "my_algorithm", 0.9999 do |n|
+#           100.times do
+#             @obj.my_algorithm(n)
+#           end
+#         end
+#       end
+#     end
+#
+# outputs something like:
+#
+#     # Running benchmarks:
+#
+#     TestBlah    100     1000    10000
+#     bench_my_algorithm   0.006167        0.079279        0.786993
+#     bench_other_algorithm        0.061679        0.792797        7.869932
+#
+# Output is tab-delimited to make it easy to paste into a spreadsheet.
+#
+# ### Mocks
+#
+# Mocks and stubs defined using terminology by Fowler & Meszaros at
+# http://www.martinfowler.com/bliki/TestDouble.html:
+#
+# "Mocks are pre-programmed with expectations which form a specification of the
+# calls they are expected to receive. They can throw an exception if they
+# receive a call they don't expect and are checked during verification to ensure
+# they got all the calls they were expecting."
+#
+#     class MemeAsker
+#       def initialize(meme)
+#         @meme = meme
+#       end
+#
+#       def ask(question)
+#         method = question.tr(" ", "_") + "?"
+#         @meme.__send__(method)
+#       end
+#     end
+#
+#     require "minitest/autorun"
+#
+#     describe MemeAsker, :ask do
+#       describe "when passed an unpunctuated question" do
+#         it "should invoke the appropriate predicate method on the meme" do
+#           @meme = Minitest::Mock.new
+#           @meme_asker = MemeAsker.new @meme
+#           @meme.expect :will_it_blend?, :return_value
+#
+#           @meme_asker.ask "will it blend"
+#
+#           @meme.verify
+#         end
+#       end
+#     end
+#
+# #### Multi-threading and Mocks
+#
+# Minitest mocks do not support multi-threading. If it works, fine, if it
+# doesn't you can use regular ruby patterns and facilities like local variables.
+# Here's an example of asserting that code inside a thread is run:
+#
+#     def test_called_inside_thread
+#       called = false
+#       pr = Proc.new { called = true }
+#       thread = Thread.new(&pr)
+#       thread.join
+#       assert called, "proc not called"
+#     end
+#
+# ### Stubs
+#
+# Mocks and stubs are defined using terminology by Fowler & Meszaros at
+# http://www.martinfowler.com/bliki/TestDouble.html:
+#
+# "Stubs provide canned answers to calls made during the test".
+#
+# Minitest's stub method overrides a single method for the duration of the
+# block.
+#
+#     def test_stale_eh
+#       obj_under_test = Something.new
+#
+#       refute obj_under_test.stale?
+#
+#       Time.stub :now, Time.at(0) do   # stub goes away once the block is done
+#         assert obj_under_test.stale?
+#       end
+#     end
+#
+# A note on stubbing: In order to stub a method, the method must actually exist
+# prior to stubbing. Use a singleton method to create a new non-existing method:
+#
+#     def obj_under_test.fake_method
+#       ...
+#     end
+#
+# ### Running Your Tests
+#
+# Ideally, you'll use a rake task to run your tests, either piecemeal or all at
+# once. Both rake and rails ship with rake tasks for running your tests. BUT!
+# You don't have to:
+#
+#     % ruby -Ilib:test test/minitest/test_minitest_test.rb
+#     Run options: --seed 37685
+#
+#     # Running:
+#
+#     ...................................................................... (etc)
+#
+#     Finished in 0.107130s, 1446.8403 runs/s, 2959.0217 assertions/s.
+#
+#     155 runs, 317 assertions, 0 failures, 0 errors, 0 skips
+#
+# There are runtime options available, both from minitest itself, and also
+# provided via plugins. To see them, simply run with `--help`:
+#
+#     % ruby -Ilib:test test/minitest/test_minitest_test.rb --help
+#     minitest options:
+#         -h, --help                       Display this help.
+#         -s, --seed SEED                  Sets random seed. Also via env. Eg: SEED=n rake
+#         -v, --verbose                    Verbose. Show progress processing files.
+#         -n, --name PATTERN               Filter run on /regexp/ or string.
+#         -e, --exclude PATTERN            Exclude /regexp/ or string from run.
+#
+#     Known extensions: pride, autotest
+#         -p, --pride                      Pride. Show your testing pride!
+#         -a, --autotest                   Connect to autotest server.
+#
+# You can set up a rake task to run all your tests by adding this to your
+# Rakefile:
+#
+#     require "rake/testtask"
+#
+#     Rake::TestTask.new(:test) do |t|
+#       t.libs << "test"
+#       t.libs << "lib"
+#       t.test_files = FileList["test/**/test_*.rb"]
+#     end
+#
+#     task :default => :test
+#
+# ## Writing Extensions
+#
+# To define a plugin, add a file named minitest/XXX_plugin.rb to your
+# project/gem. That file must be discoverable via ruby's LOAD_PATH (via rubygems
+# or otherwise). Minitest will find and require that file using Gem.find_files.
+# It will then try to call `plugin_XXX_init` during startup. The option
+# processor will also try to call `plugin_XXX_options` passing the OptionParser
+# instance and the current options hash. This lets you register your own
+# command-line options. Here's a totally bogus example:
+#
+#     # minitest/bogus_plugin.rb:
+#
+#     module Minitest
+#       def self.plugin_bogus_options(opts, options)
+#         opts.on "--myci", "Report results to my CI" do
+#           options[:myci] = true
+#           options[:myci_addr] = get_myci_addr
+#           options[:myci_port] = get_myci_port
+#         end
+#       end
+#
+#       def self.plugin_bogus_init(options)
+#         self.reporter << MyCI.new(options) if options[:myci]
+#       end
+#     end
+#
+# ### Adding custom reporters
+#
+# Minitest uses composite reporter to output test results using multiple
+# reporter instances. You can add new reporters to the composite during the
+# init_plugins phase. As we saw in `plugin_bogus_init` above, you simply add
+# your reporter instance to the composite via `<<`.
+#
+# `AbstractReporter` defines the API for reporters. You may subclass it and
+# override any method you want to achieve your desired behavior.
+#
+# start
+# :   Called when the run has started.
+# record
+# :   Called for each result, passed or otherwise.
+# report
+# :   Called at the end of the run.
+# passed?
+# :   Called to see if you detected any problems.
+#
+#
+# Using our example above, here is how we might implement MyCI:
+#
+#     # minitest/bogus_plugin.rb
+#
+#     module Minitest
+#       class MyCI < AbstractReporter
+#         attr_accessor :results, :addr, :port
+#
+#         def initialize options
+#           self.results = []
+#           self.addr = options[:myci_addr]
+#           self.port = options[:myci_port]
+#         end
+#
+#         def record result
+#           self.results << result
+#         end
+#
+#         def report
+#           CI.connect(addr, port).send_results self.results
+#         end
+#       end
+#
+#       # code from above...
+#     end
+#
+# ## FAQ
+#
+# ### What versions are compatible with what? Or what versions are supported?
+#
+# Minitest is a dependency of rails, which until fairly recently had an
+# overzealous backwards compatibility policy. As such, I'm stuck supporting
+# versions of ruby that are long past EOL. Once rails 5.2 is dropped (hopefully
+# April 2021), I get to drop a bunch of versions of ruby that I have to
+# currently test against.
+#
+# (As of 2021-01-31)
+#
+# Current versions of rails: (https://endoflife.date/rails)
+#
+#     | rails | min ruby | rec ruby | minitest | status   |
+#     |-------+----------+----------+----------+----------|
+#     |   7.0 | >= 2.7   |      3.0 | >= 5.1   | Future   |
+#     |   6.1 | >= 2.5   |      3.0 | >= 5.1   | Current  |
+#     |   6.0 | >= 2.5   |      2.6 | >= 5.1   | Security |
+#     |   5.2 | >= 2.2.2 |      2.5 | ~> 5.1   | Security | EOL @railsconf 2021?
+#
+# Current versions of ruby: (https://endoflife.date/ruby)
+#
+#     | ruby | Status  |   EOL Date |
+#     |------+---------+------------|
+#     |  3.0 | Current | 2024-03-31 |
+#     |  2.7 | Maint   | 2023-03-31 |
+#     |  2.6 | Maint*  | 2022-03-31 |
+#     |  2.5 | EOL     | 2021-03-31 |
+#     |  2.4 | EOL     | 2020-03-31 |
+#     |  2.3 | EOL     | 2019-03-31 |
+#     |  2.2 | EOL     | 2018-03-31 |
+#
+# See also:
+#
+# *   https://www.fastruby.io/blog/ruby/rails/versions/compatibility-table.html
+# *   https://jamesjeffersconsulting.com/ruby-rails-version-matrix/
+#
+#
+# ### How to test SimpleDelegates?
+#
+# The following implementation and test:
+#
+#     class Worker < SimpleDelegator
+#       def work
+#       end
+#     end
+#
+#     describe Worker do
+#       before do
+#         @worker = Worker.new(Object.new)
+#       end
+#
+#       it "must respond to work" do
+#         _(@worker).must_respond_to :work
+#       end
+#     end
+#
+# outputs a failure:
+#
+#       1) Failure:
+#     Worker#test_0001_must respond to work [bug11.rb:16]:
+#     Expected #<Object:0x007f9e7184f0a0> (Object) to respond to #work.
+#
+# Worker is a SimpleDelegate which in 1.9+ is a subclass of BasicObject.
+# Expectations are put on Object (one level down) so the Worker (SimpleDelegate)
+# hits `method_missing` and delegates down to the `Object.new` instance. That
+# object doesn't respond to work so the test fails.
+#
+# You can bypass `SimpleDelegate#method_missing` by extending the worker with
+# `Minitest::Expectations`. You can either do that in your setup at the instance
+# level, like:
+#
+#     before do
+#       @worker = Worker.new(Object.new)
+#       @worker.extend Minitest::Expectations
+#     end
+#
+# or you can extend the Worker class (within the test file!), like:
+#
+#     class Worker
+#       include ::Minitest::Expectations
+#     end
+#
+# ### How to share code across test classes?
+#
+# Use a module. That's exactly what they're for:
+#
+#     module UsefulStuff
+#       def useful_method
+#         # ...
+#       end
+#     end
+#
+#     describe Blah do
+#       include UsefulStuff
+#
+#       def test_whatever
+#         # useful_method available here
+#       end
+#     end
+#
+# Remember, `describe` simply creates test classes. It's just ruby at the end of
+# the day and all your normal Good Ruby Rules (tm) apply. If you want to extend
+# your test using setup/teardown via a module, just make sure you ALWAYS call
+# super. before/after automatically call super for you, so make sure you don't
+# do it twice.
+#
+# ### How to run code before a group of tests?
+#
+# Use a constant with begin...end like this:
+#
+#     describe Blah do
+#       SETUP = begin
+#          # ... this runs once when describe Blah starts
+#       end
+#       # ...
+#     end
+#
+# This can be useful for expensive initializations or sharing state. Remember,
+# this is just ruby code, so you need to make sure this technique and sharing
+# state doesn't interfere with your tests.
+#
+# ### Why am I seeing `uninitialized constant MiniTest::Test (NameError)`?
+#
+# Are you running the test with Bundler (e.g. via `bundle exec` )? If so, in
+# order to require minitest, you must first add the `gem 'minitest'` to your
+# Gemfile and run `bundle`. Once it's installed, you should be able to require
+# minitest and run your tests.
+#
+# ## Prominent Projects using Minitest:
+#
+# *   arel
+# *   journey
+# *   mime-types
+# *   nokogiri
+# *   rails (active_support et al)
+# *   rake
+# *   rdoc
+# *   ...and of course, everything from seattle.rb...
+#
+#
+# ## Developing Minitest:
+#
+# Minitest requires [Hoe](https://rubygems.org/gems/hoe).
+#
+# ### Minitest's own tests require UTF-8 external encoding.
+#
+# This is a common problem in Windows, where the default external Encoding is
+# often CP850, but can affect any platform. Minitest can run test suites using
+# any Encoding, but to run Minitest's own tests you must have a default external
+# Encoding of UTF-8.
+#
+# If your encoding is wrong, you'll see errors like:
+#
+#     --- expected
+#     +++ actual
+#     @@ -1,2 +1,3 @@
+#      # encoding: UTF-8
+#      -"Expected /\\w+/ to not match \"blah blah blah\"."
+#      +"Expected /\\w+/ to not match # encoding: UTF-8
+#      +\"blah blah blah\"."
+#
+# To check your current encoding, run:
+#
+#     ruby -e 'puts Encoding.default_external'
+#
+# If your output is something other than UTF-8, you can set the RUBYOPTS env
+# variable to a value of '-Eutf-8'. Something like:
+#
+#     RUBYOPT='-Eutf-8' ruby -e 'puts Encoding.default_external'
+#
+# Check your OS/shell documentation for the precise syntax (the above will not
+# work on a basic Windows CMD prompt, look for the SET command). Once you've got
+# it successfully outputing UTF-8, use the same setting when running rake in
+# Minitest.
+#
+# ### Minitest's own tests require GNU (or similar) diff.
+#
+# This is also a problem primarily affecting Windows developers. PowerShell has
+# a command called diff, but it is not suitable for use with Minitest.
+#
+# If you see failures like either of these, you are probably missing diff tool:
+#
+#       4) Failure:
+#     TestMinitestUnitTestCase#test_assert_equal_different_long [D:/ruby/seattlerb/minitest/test/minitest/test_minitest_test.rb:936]:
+#     Expected: "--- expected\n+++ actual\n@@ -1 +1 @@\n-\"hahahahahahahahahahahahahahahahahahahaha\"\n+\"blahblahblahblahblahblahblahblahblahblah\"\n"
+#       Actual: "Expected: \"hahahahahahahahahahahahahahahahahahahaha\"\n  Actual: \"blahblahblahblahblahblahblahblahblahblah\""
+#
+#       5) Failure:
+#     TestMinitestUnitTestCase#test_assert_equal_different_collection_hash_hex_invisible [D:/ruby/seattlerb/minitest/test/minitest/test_minitest_test.rb:845]:
+#     Expected: "No visible difference in the Hash#inspect output.\nYou should look at the implementation of #== on Hash or its members.\n
+#     {1=>#<Object:0xXXXXXX>}"
+#       Actual: "Expected: {1=>#<Object:0x00000003ba0470>}\n  Actual: {1=>#<Object:0x00000003ba0448>}"
+#
+# If you use Cygwin or MSYS2 or similar there are packages that include a GNU
+# diff for Windows. If you don't, you can download GNU diffutils from
+# http://gnuwin32.sourceforge.net/packages/diffutils.htm (make sure to add it to
+# your PATH).
+#
+# You can make sure it's installed and path is configured properly with:
+#
+#     diff.exe -v
+#
+# There are multiple lines of output, the first should be something like:
+#
+#     diff (GNU diffutils) 2.8.1
+#
+# If you are using PowerShell make sure you run diff.exe, not just diff, which
+# will invoke the PowerShell built in function.
+#
+# ## Known Extensions:
+#
+# capybara_minitest_spec
+# :   Bridge between Capybara RSpec matchers and Minitest::Spec expectations
+#     (e.g. `page.must_have_content("Title")`).
+# color_pound_spec_reporter
+# :   Test names print Ruby Object types in color with your Minitest Spec style
+#     tests.
+# minispec-metadata
+# :   Metadata for describe/it blocks & CLI tag filter. E.g. `it "requires JS
+#     driver", js: true do` & `ruby test.rb --tag js` runs tests tagged :js.
+# minispec-rails
+# :   Minimal support to use Spec style in Rails 5+.
+# mini-apivore
+# :   for swagger based automated API testing.
+# minitest-around
+# :   Around block for minitest. An alternative to setup/teardown dance.
+# minitest-assert_errors
+# :   Adds Minitest assertions to test for errors raised or not raised by
+#     Minitest itself.
+# minitest-autotest
+# :   autotest is a continuous testing facility meant to be used during
+#     development.
+# minitest-bacon
+# :   minitest-bacon extends minitest with bacon-like functionality.
+# minitest-bang
+# :   Adds support for RSpec-style let! to immediately invoke let statements
+#     before each test.
+# minitest-bisect
+# :   Helps you isolate and debug random test failures.
+# minitest-blink1_reporter
+# :   Display test results with a Blink1.
+# minitest-capistrano
+# :   Assertions and expectations for testing Capistrano recipes.
+# minitest-capybara
+# :   Capybara matchers support for minitest unit and spec.
+# minitest-chef-handler
+# :   Run Minitest suites as Chef report handlers
+# minitest-ci
+# :   CI reporter plugin for Minitest.
+# minitest-context
+# :   Defines contexts for code reuse in Minitest specs that share common
+#     expectations.
+# minitest-debugger
+# :   Wraps assert so failed assertions drop into the ruby debugger.
+# minitest-display
+# :   Patches Minitest to allow for an easily configurable output.
+# minitest-documentation
+# :   Minimal documentation format inspired by rspec's.
+# minitest-doc_reporter
+# :   Detailed output inspired by rspec's documentation format.
+# minitest-emoji
+# :   Print out emoji for your test passes, fails, and skips.
+# minitest-english
+# :   Semantically symmetric aliases for assertions and expectations.
+# minitest-excludes
+# :   Clean API for excluding certain tests you don't want to run under certain
+#     conditions.
+# minitest-fail-fast
+# :   Reimplements RSpec's "fail fast" feature
+# minitest-filecontent
+# :   Support unit tests with expectation results in files. Differing results
+#     will be stored again in files.
+# minitest-filesystem
+# :   Adds assertion and expectation to help testing filesystem contents.
+# minitest-firemock
+# :   Makes your Minitest mocks more resilient.
+# minitest-focus
+# :   Focus on one test at a time.
+# minitest-gcstats
+# :   A minitest plugin that adds a report of the top tests by number of objects
+#     allocated.
+# minitest-global_expectations
+# :   Support minitest expectation methods for all objects
+# minitest-great_expectations
+# :   Generally useful additions to minitest's assertions and expectations.
+# minitest-growl
+# :   Test notifier for minitest via growl.
+# minitest-happy
+# :   GLOBALLY ACTIVATE MINITEST PRIDE! RAWR!
+# minitest-have_tag
+# :   Adds Minitest assertions to test for the existence of HTML tags, including
+#     contents, within a provided string.
+# minitest-heat
+# :   Reporting that builds a heat map of failure locations
+# minitest-hooks
+# :   Around and before_all/after_all/around_all hooks
+# minitest-hyper
+# :   Pretty, single-page HTML reports for your Minitest runs
+# minitest-implicit-subject
+# :   Implicit declaration of the test subject.
+# minitest-instrument
+# :   Instrument ActiveSupport::Notifications when test method is executed.
+# minitest-instrument-db
+# :   Store information about speed of test execution provided by
+#     minitest-instrument in database.
+# minitest-junit
+# :   JUnit-style XML reporter for minitest.
+# minitest-keyword
+# :   Use Minitest assertions with keyword arguments.
+# minitest-libnotify
+# :   Test notifier for minitest via libnotify.
+# minitest-line
+# :   Run test at line number.
+# minitest-logger
+# :   Define assert_log and enable minitest to test log messages. Supports
+#     Logger and Log4r::Logger.
+# minitest-macruby
+# :   Provides extensions to minitest for macruby UI testing.
+# minitest-matchers
+# :   Adds support for RSpec-style matchers to minitest.
+# minitest-matchers_vaccine
+# :   Adds assertions that adhere to the matcher spec, but without any
+#     expectation infections.
+# minitest-metadata
+# :   Annotate tests with metadata (key-value).
+# minitest-mock_expectations
+# :   Provides method call assertions for minitest.
+# minitest-mongoid
+# :   Mongoid assertion matchers for Minitest.
+# minitest-must_not
+# :   Provides must_not as an alias for wont in Minitest.
+# minitest-optional_retry
+# :   Automatically retry failed test to help with flakiness.
+# minitest-osx
+# :   Reporter for the Mac OS X notification center.
+# minitest-parallel_fork
+# :   Fork-based parallelization
+# minitest-parallel-db
+# :   Run tests in parallel with a single database.
+# minitest-power_assert
+# :   PowerAssert for Minitest.
+# minitest-predicates
+# :   Adds support for .predicate? methods.
+# minitest-profile
+# :   List the 10 slowest tests in your suite.
+# minitest-rails
+# :   Minitest integration for Rails 3.x.
+# minitest-rails-capybara
+# :   Capybara integration for Minitest::Rails.
+# minitest-reporters
+# :   Create customizable Minitest output formats.
+# minitest-rg
+# :   Colored red/green output for Minitest.
+# minitest-rspec_mocks
+# :   Use RSpec Mocks with Minitest.
+# minitest-server
+# :   minitest-server provides a client/server setup with your minitest process,
+#     allowing your test run to send its results directly to a handler.
+# minitest-sequel
+# :   Minitest assertions to speed-up development and testing of Ruby Sequel
+#     database setups.
+# minitest-shared_description
+# :   Support for shared specs and shared spec subclasses
+# minitest-should_syntax
+# :   RSpec-style `x.should == y` assertions for Minitest.
+# minitest-shouldify
+# :   Adding all manner of shoulds to Minitest (bad idea)
+# minitest-snail
+# :   Print a list of tests that take too long
+# minitest-spec-context
+# :   Provides rspec-ish context method to Minitest::Spec.
+# minitest-spec-expect
+# :   Expect syntax for Minitest::Spec (e.g. expect(sequences).to_include
+#     :celery_man).
+# minitest-spec-magic
+# :   Minitest::Spec extensions for Rails and beyond.
+# minitest-spec-rails
+# :   Drop in Minitest::Spec superclass for ActiveSupport::TestCase.
+# minitest-sprint
+# :   Runs (Get it? It's fast!) your tests and makes it easier to rerun
+#     individual failures.
+# minitest-stately
+# :   Find leaking state between tests
+# minitest-stub_any_instance
+# :   Stub any instance of a method on the given class for the duration of a
+#     block.
+# minitest-stub-const
+# :   Stub constants for the duration of a block.
+# minitest-tags
+# :   Add tags for minitest.
+# minitest-unordered
+# :   Adds a new assertion to minitest for checking the contents of a
+#     collection, ignoring element order.
+# minitest-vcr
+# :   Automatic cassette managment with Minitest::Spec and VCR.
+# minitest_log
+# :   Adds structured logging, data explication, and verdicts.
+# minitest_owrapper
+# :   Get tests results as a TestResult object.
+# minitest_should
+# :   Shoulda style syntax for minitest test::unit.
+# minitest_tu_shim
+# :   Bridges between test/unit and minitest.
+# mongoid-minitest
+# :   Minitest matchers for Mongoid.
+# mutant-minitest
+# :   Minitest integration for mutant.
+# pry-rescue
+# :   A pry plugin w/ minitest support. See pry-rescue/minitest.rb.
+# rematch
+# :   Declutter your test files from large hardcoded data and update them
+#     automatically when your code changes.
+# rspec2minitest
+# :   Easily translate any RSpec matchers to Minitest assertions and
+#     expectations.
+#
+#
+# ## Unknown Extensions:
+#
+# Authors... Please send me a pull request with a description of your minitest
+# extension.
+#
+# *   assay-minitest
+# *   detroit-minitest
+# *   em-minitest-spec
+# *   flexmock-minitest
+# *   guard-minitest
+# *   guard-minitest-decisiv
+# *   minitest-activemodel
+# *   minitest-ar-assertions
+# *   minitest-capybara-unit
+# *   minitest-colorer
+# *   minitest-deluxe
+# *   minitest-extra-assertions
+# *   minitest-rails-shoulda
+# *   minitest-spec
+# *   minitest-spec-should
+# *   minitest-sugar
+# *   spork-minitest
+#
+#
+# ## Minitest related goods
+#
+# *   minitest/pride fabric:
+#     http://www.spoonflower.com/fabric/3928730-again-by-katie_allen
+#
+#
+# ## REQUIREMENTS:
+#
+# *   Ruby 2.3+. No magic is involved. I hope.
+#
+#
+# ## INSTALL:
+#
+#     sudo gem install minitest
+#
+# On 1.9, you already have it. To get newer candy you can still install the gem,
+# and then requiring "minitest/autorun" should automatically pull it in. If not,
+# you'll need to do it yourself:
+#
+#     gem "minitest"     # ensures you"re using the gem, and not the built-in MT
+#     require "minitest/autorun"
+#
+#     # ... usual testing stuffs ...
+#
+# DO NOTE: There is a serious problem with the way that ruby 1.9/2.0 packages
+# their own gems. They install a gem specification file, but don't install the
+# gem contents in the gem path. This messes up Gem.find_files and many other
+# things (gem which, gem contents, etc).
+#
+# Just install minitest as a gem for real and you'll be happier.
+#
+# ## LICENSE:
+#
+# (The MIT License)
+#
+# Copyright (c) Ryan Davis, seattle.rb
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the 'Software'), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+module Minitest
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - autorun()
+  # -->
+  # Registers Minitest to run at process exit
+  #
+  def self.autorun: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - after_run(&block)
+  # -->
+  # A simple hook allowing you to run a block of code after everything is done
+  # running. Eg:
+  #
+  #     Minitest.after_run { p $debugging_info }
+  #
+  def self.after_run: () ?{ () -> untyped } -> untyped
+
+  def self.init_plugins: (untyped options) -> untyped
+
+  def self.load_plugins: () -> (nil | untyped)
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - run(args = [])
+  # -->
+  # This is the top-level run method. Everything starts from here. It tells each
+  # Runnable sub-class to run, and each of those are responsible for doing
+  # whatever they do.
+  #
+  # The overall structure of a run looks like this:
+  #
+  #     Minitest.autorun
+  #       Minitest.run(args)
+  #         Minitest.__run(reporter, options)
+  #           Runnable.runnables.each
+  #             runnable.run(reporter, options)
+  #               self.runnable_methods.each
+  #                 self.run_one_method(self, runnable_method, reporter)
+  #                   Minitest.run_one_method(klass, runnable_method)
+  #                     klass.new(runnable_method).run
+  #
+  def self.run: (?untyped args) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - __run(reporter, options)
+  # -->
+  # Internal run method. Responsible for telling all Runnable sub-classes to run.
+  #
+  def self.__run: (untyped reporter, untyped options) -> untyped
+
+  def self.process_args: (?untyped args) -> untyped
+
+  def self.filter_backtrace: (untyped bt) -> untyped
+
+  def self.run_one_method: (untyped klass, untyped method_name) -> untyped
+
+  # :nodoc:
+  def self.clock_time: () -> untyped
+
+  def self.plugin_pride_options: (untyped opts, untyped _options) -> untyped
+
+  def self.plugin_pride_init: (untyped options) -> (untyped | nil)
+
+  attr_accessor self.parallel_executor: untyped
+
+  attr_accessor self.backtrace_filter: untyped
+
+  attr_accessor self.reporter: untyped
+
+  attr_accessor self.extensions: untyped
+
+  attr_accessor self.info_signal: untyped
+
+  VERSION: String
+
+  ENCS: true
+end