megatest 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dce0e1b9ec47a98020fabc266db9d93f73961574ed6ef0bf29b4885064114216
-  data.tar.gz: c4dd6ed24dea6de74effca99474a850af28b77142a0c388dff2f4faf2f4b5338
+  metadata.gz: b0be0dcf9dd26312cec897081522ae6ac404db5447b26d50286ccc8720422743
+  data.tar.gz: 2580f85814d9469dfd1df3c8d3601c8b5ac89b4e4faaf706b4af47154d3c9bdb
 SHA512:
-  metadata.gz: 827fa2e37b36c4e8d7fae1317be65d259bac20210276245c119cbf33d506e967514295d4d74cc9fefd499e60aefacfd4a752f17f83feb58a46387af3d516c302
-  data.tar.gz: 3bfe1897107565dd27ae0eef08857b123eea0f181009669ab3e6c676f7fcbed7266fa3708f7b88589aadd518cb43cfaff8402a9648db5828373759b8219e2f6f
+  metadata.gz: ef25ab7ecc09133635d0ffaef659ce02574f01fd558f2437c187fd3f4f362b40cd13dfcb6d6ac455e0a1462b507dfb6e27efd74e72d18ed57e68f8c1434b25e2
+  data.tar.gz: 68b8dc14b4869a5dea9d51f2c507287acb5bbcce709b1514c965f2b0cc9a0d8edd4da82a89b8e120427e63ece0c159a2f4f27d92362f1b25ded3f9cbdd05c402

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.5.0] - 2025-01-17
+
+- Adds `megatest/autorun`
+- Adds `assert_nothing_raised`.
+- Adds `assert_difference`.
+- Adds `assert_changes`.
+- Adds `assert_not_*` aliases.
+- Adds `match:` argument to `assert_raises`.
+
+## [0.4.0] - 2025-11-12
+
+- Allow configuring the test glob via `config.test_globs`.
+
 ## [0.3.0] - 2025-06-20
 
 - Added missing MIT license.

data/lib/megatest/assertions.rb

@@ -67,6 +67,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not, :refute
 
     def assert_nil(actual, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -85,6 +86,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_nil, :refute_nil
 
     def assert_equal(expected, actual, msg = nil, message: nil, allow_nil: false)
       message = @__m.msg(msg, message)
@@ -116,6 +118,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_equal, :refute_equal
 
     def assert_includes(collection, object, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -134,6 +137,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_includes, :refute_includes
 
     def assert_empty(object, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -152,6 +156,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_empty, :refute_empty
 
     def assert_instance_of(klass, actual, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -170,6 +175,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_instance_of, :refute_instance_of
 
     def assert_kind_of(klass, actual, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -188,6 +194,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_kind_of, :refute_kind_of
 
     def assert_predicate(actual, predicate, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -206,6 +213,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_predicate, :refute_predicate
 
     def assert_match(original_matcher, obj, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -238,6 +246,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_no_match, :refute_match
 
     def assert_respond_to(object, method, msg = nil, message: nil, include_all: false)
       message = @__m.msg(msg, message)
@@ -256,6 +265,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_respond_to, :refute_respond_to
 
     def assert_same(expected, actual, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -294,21 +304,36 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_same, :refute_same
 
-    def assert_raises(expected = StandardError, *expected_exceptions, message: nil)
+    def assert_raises(expected = StandardError, *expected_exceptions, match: nil, message: nil)
       msg = expected_exceptions.pop if expected_exceptions.last.is_a?(String)
       message = @__m.msg(msg, message)
+
+      matcher = if match
+        if ::String === match
+          ::Regexp.new(::Regexp.escape(match))
+        else
+          match
+        end
+      end
+
       @__m.assert do
         @__m.fail("assert_raises requires a block to capture errors.") unless block_given?
 
         begin
+          before_yield = __LINE__
           yield
         rescue expected, *expected_exceptions => exception
+          if matcher && !matcher.match?(exception.message)
+            @__m.fail(message, "Expected", @__m.pp(match), "to match", @__m.pp(exception.message))
+          end
+
           return exception
         rescue ::Megatest::Assertion, *::Megatest::IGNORED_ERRORS
           raise # Pass through
         rescue ::Exception => unexepected_exception
-          error = @__m.strip_backtrace(unexepected_exception, __FILE__, __LINE__ - 6, 0)
+          error = @__m.strip_backtrace(unexepected_exception, __FILE__, before_yield + 1, 0)
 
           expected_pp = if expected_exceptions.empty?
             @__m.pp(expected)
@@ -317,15 +342,26 @@ module Megatest
           end
 
           @__m.fail(message, "#{expected_pp} exception expected, not:\n#{@__m.pp(error)}")
-        end
-
-        expected_pp = if expected_exceptions.empty?
-          @__m.pp(expected)
         else
-          expected_exceptions.map { |e| @__m.pp(e) }.join(", ") << " or #{@__m.pp(expected)}"
+          expected_pp = if expected_exceptions.empty?
+            @__m.pp(expected)
+          else
+            expected_exceptions.map { |e| @__m.pp(e) }.join(", ") << " or #{@__m.pp(expected)}"
+          end
+
+          @__m.fail(message, "Expected", expected_pp, "but nothing was raised.")
         end
+      end
+    end
+    alias :assert_raise :assert_raises
 
-        @__m.fail(message, "Expected", expected_pp, "but nothing was raised.")
+    def assert_nothing_raised
+      @__m.assert do
+        yield
+      rescue ::Megatest::Assertion, *::Megatest::IGNORED_ERRORS
+        raise # Pass through
+      rescue Exception => unexepected_exception
+        raise ::Megatest::UnexpectedError, unexepected_exception
       end
     end
 
@@ -367,6 +403,114 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_operator, :refute_operator
+
+    def assert_difference(expression, difference = @__m.unset, message: nil, &block)
+      expressions = if @__m.set?(difference)
+        Array(expression).to_h { |e| [e, difference] }
+      elsif Hash === expression
+        expression
+      else
+        Array(expression).to_h { |e| [e, 1] }
+      end
+
+      exps = expressions.keys.map { |e| @__m.expression(e, block) }
+
+      @__m.assert do
+        before = exps.map(&:call)
+
+        retval = @__m.safe_yield(&block)
+
+        expressions.zip(exps, before) do |(code, diff), exp, before_value|
+          actual = exp.call
+          expected = before_value + diff
+          unless expected == actual
+            error = "`#{@__m.pp_expression(code)}` didn't change by #{diff}, but by #{actual - before_value}."
+            @__m.fail(message, error)
+          end
+        end
+
+        retval
+      end
+    end
+
+    def refute_difference(expressions, message: nil, &block)
+      exps = Array(expressions).map { |e| @__m.expression(e, block) }
+
+      @__m.assert do
+        before = exps.map(&:call)
+
+        retval = @__m.safe_yield(&block)
+
+        exps.zip(before) do |exp, before_value|
+          actual = exp.call
+          unless before_value == actual
+            error = "Expected `#{@__m.pp_expression(exp)}` to not change, but it changed from #{@__m.pp(before_value)} to #{@__m.pp(actual)}."
+            @__m.fail(message, error)
+          end
+        end
+
+        retval
+      end
+    end
+    alias_method :assert_no_difference, :refute_difference
+
+    def assert_changes(expression, msg = nil, message: nil, from: @__m.unset, to: @__m.unset, &block)
+      message = @__m.msg(msg, message)
+      exp = @__m.expression(expression, block)
+      @__m.assert do
+        before = exp.call
+        if @__m.set?(from) && !(from === before)
+          @__m.fail(message, "Expected `#{@__m.pp_expression(exp)}` to starts from #{@__m.pp(from)}, but was #{@__m.pp(before)}")
+        end
+
+        retval = assert_nothing_raised(&block)
+
+        after = exp.call
+
+        if before == after
+          details = "Expected `#{@__m.pp_expression(exp)}` to change"
+          if @__m.set?(to)
+            details = "#{details} to #{@__m.pp(to)}"
+          end
+
+          if before == to
+            details = "#{details}, but it was already #{@__m.pp(to)}."
+          else
+            details = "#{details}, but it stayed #{@__m.pp(before)}"
+          end
+
+          @__m.fail(message, details)
+        end
+
+        if @__m.set?(to) && !(to === after)
+          @__m.fail(message, "Expected `#{@__m.pp_expression(exp)}` to change to #{@__m.pp(to)}, got #{@__m.pp(after)}")
+        end
+
+        retval
+      end
+    end
+
+    def refute_changes(expression, msg = nil, message: nil, from: @__m.unset, &block)
+      message = @__m.msg(msg, message)
+      exp = @__m.expression(expression, block)
+      @__m.assert do
+        before = exp.call
+        if @__m.set?(from) && !(from === before)
+          @__m.fail(message, "Expected `#{@__m.pp_expression(exp)}` to start from #{@__m.pp(from)}, but was #{@__m.pp(before)}.")
+        end
+
+        retval = assert_nothing_raised(&block)
+
+        after = exp.call
+        unless before == after
+          @__m.fail(message, "Expected `#{@__m.pp_expression(exp)}` to not change, but it changed from #{@__m.pp(before)} to #{@__m.pp(after)}.")
+        end
+
+        retval
+      end
+    end
+    alias_method :assert_no_changes, :refute_changes
 
     def assert_in_delta(expected, actual, delta = 0.001, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -387,6 +531,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_in_delta, :refute_in_delta
 
     def assert_in_epsilon(expected, actual, epsilon = 0.001, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -409,6 +554,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_epsilon, :refute_in_epsilon
 
     def skip(message = nil)
       message ||= "Skipped, no message given"

data/lib/megatest/autorun.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "megatest"
+
+unless Megatest.running
+  root = File.expand_path("../../", __dir__)
+  rubyopt = "#{ENV.fetch("RUBYOPT", nil)} -I#{root}/lib"
+  exec({ "RUBYOPT" => rubyopt }, "#{root}/exe/megatest", $PROGRAM_NAME, *ARGV)
+end

data/lib/megatest/cli.rb

@@ -10,7 +10,7 @@ module Megatest
 
     class << self
       def run!
-        program_name = $PROGRAM_NAME
+        program_name = ENV.fetch("MEGATEST_PROGRAM_NAME", $PROGRAM_NAME)
         if paths = ENV["PATH"]
           paths.split(":").each do |path|
             if program_name.start_with?(path)
@@ -69,6 +69,8 @@ module Megatest
     end
 
     def configure
+      Megatest.running = true
+
       if @runner = RUNNERS[@argv.first]
         @argv.shift
       end
@@ -92,7 +94,7 @@ module Megatest
         end
       end
 
-      @config.selectors = Selector.parse(@argv)
+      @config.selectors = Selector.new(@config).parse(@argv)
       Megatest.load_config(@config)
       Megatest.init(@config)
       test_cases = Megatest.load_tests(@config)
@@ -125,7 +127,7 @@ module Megatest
       queue = @config.build_queue
       raise InvalidArgument, "Distributed queues can't be bisected" if queue.distributed?
 
-      @config.selectors = Selector.parse(@argv)
+      @config.selectors = Selector.new(@config).parse(@argv)
       Megatest.load_config(@config)
       Megatest.init(@config)
       test_cases = Megatest.load_tests(@config)

data/lib/megatest/config.rb

@@ -139,7 +139,7 @@ module Megatest
     attr_accessor :queue_url, :retry_tolerance, :max_retries, :jobs_count, :job_index, :load_paths, :deprecations,
                   :build_id, :heartbeat_frequency, :minitest_compatibility, :ci, :selectors
     attr_reader :before_fork_callbacks, :global_setup_callbacks, :backtrace, :circuit_breaker, :seed,
-                :worker_id, :workers_count
+                :worker_id, :workers_count, :test_globs
     attr_writer :differ, :pretty_printer, :program_name, :colors
 
     def initialize(env)
@@ -168,12 +168,18 @@ module Megatest
       @pretty_printer = PrettyPrint.new(self)
       @minitest_compatibility = false
       @selectors = nil
+      @test_globs = [DEFAULT_TEST_GLOB]
       CIService.configure(self, env)
     end
 
+    def test_globs=(patterns)
+      @test_globs = normalize_test_glob(patterns)
+    end
+
     def initialize_dup(_)
       super
       @circuit_breaker = @circuit_breaker.dup
+      @test_globs = @test_globs.dup
     end
 
     def program_name
@@ -305,6 +311,16 @@ module Megatest
         instance_variable_set(name, value)
       end
     end
+
+    private
+
+    def normalize_test_glob(patterns)
+      if patterns
+        Array(patterns).compact.map(&:to_s)
+      else
+        [DEFAULT_TEST_GLOB]
+      end
+    end
   end
 
   @config = Config.new({})

data/lib/megatest/redis_queue.rb

@@ -232,11 +232,14 @@ module Megatest
     def populate(test_cases)
       super
 
-      leader_key_set, = @redis.pipelined do |pipeline|
-        pipeline.call("setnx", key("leader-status"), "setup")
+      value = key("leader-setup", worker_id)
+      # NB: If we assumed redis 7+ this could be a single command: `SET <key> NX GET EX @ttl <value>`.
+      _, _, leader = @redis.multi do |pipeline|
+        pipeline.call("setnx", key("leader-status"), value)
         pipeline.call("expire", key("leader-status"), @ttl)
+        pipeline.call("get", key("leader-status"))
       end
-      @leader = leader_key_set == 1
+      @leader = leader == value
 
       if @leader
         @redis.multi do |transaction|

data/lib/megatest/reporters.rb

@@ -113,8 +113,8 @@ module Megatest
           p99 = sorted_results[(size * 0.99).to_i].duration
 
           @out.puts "Finished in #{s(executor.wall_time.to_f)}, average: #{ms(average)}, median: #{ms(median)}, p90: #{ms(p90)}, p99: #{ms(p99)}"
-          cuttoff = p90 * 10
-          slowest_tests = sorted_results.last(5).select { |r| r.duration > cuttoff }
+          cutoff = p90 * 10
+          slowest_tests = sorted_results.last(5).select { |r| r.duration > cutoff }
           unless slowest_tests.empty?
             @out.puts "Slowest tests:"
             slowest_tests.reverse_each do |result|

data/lib/megatest/runtime.rb

@@ -139,6 +139,49 @@ module Megatest
       end
     end
 
+    def safe_yield
+      yield
+    rescue Assertion, *IGNORED_ERRORS
+      raise
+    rescue ::Exception => unexepected_exception
+      raise UnexpectedError, unexepected_exception
+    end
+
+    UNSET = BasicObject.new
+
+    def unset
+      UNSET
+    end
+
+    def unset?(arg)
+      UNSET.equal?(arg)
+    end
+
+    def set?(arg)
+      !UNSET.equal?(arg)
+    end
+
+    class Expression
+      attr_reader :string
+
+      def initialize(string, block)
+        @string = string
+        @block = block
+      end
+
+      def call
+        eval(@string, @block.binding)
+      end
+    end
+
+    def expression(expression, block)
+      if String === expression
+        Expression.new(expression, block)
+      else
+        expression
+      end
+    end
+
     def minitest_compatibility?
       @config.minitest_compatibility
     end
@@ -147,6 +190,53 @@ module Megatest
       @config.render_object(object)
     end
 
+    def pp_expression(callable)
+      case callable
+      when Expression
+        callable.string
+      when Proc
+        # Logic borrowed from Active Support.
+        if defined?(RubyVM::InstructionSequence)
+          iseq = RubyVM::InstructionSequence.of(callable)
+          return pp(callable) unless iseq
+
+          source = if RubyVM::InstructionSequence.method_defined?(:script_lines) && iseq.script_lines
+            iseq.script_lines.join("\n")
+          elsif File.readable?(iseq.absolute_path)
+            File.read(iseq.absolute_path)
+          end
+          return pp(callable) unless source
+
+          location = iseq.to_a[4][:code_location]
+          return pp(callable) unless location
+
+          lines = source.lines[(location[0] - 1)..(location[2] - 1)]
+          lines[-1] = lines[-1].byteslice(0...location[3])
+          lines[0] = lines[0].byteslice(location[1]...-1)
+          source = lines.join.strip
+
+          # Ruby 4.1.0dev includes the `->`
+          source.delete_prefix!("->")
+          source.strip!
+
+          # We ignore procs defined with do/end as they are likely multi-line anyway.
+          if source.start_with?("{")
+            source.delete_suffix!("}")
+            source.delete_prefix!("{")
+            source.strip!
+            # It won't read nice if the callable contains multiple
+            # lines, and it should be a rare occurrence anyway.
+            # Same if it takes arguments.
+            if !source.include?("\n") && !source.start_with?("|")
+              return source
+            end
+          end
+        end
+      end
+
+      pp(callable)
+    end
+
     def diff(expected, actual)
       @config.diff(expected, actual)
     end

data/lib/megatest/selector.rb

@@ -3,12 +3,12 @@
 # :stopdoc:
 
 module Megatest
-  module Selector
+  class Selector
     class List
-      def initialize(loaders, filters)
+      def initialize(config, loaders, filters)
         @loaders = loaders
         if loaders.empty?
-          @loaders = [Loader.new("test")]
+          @loaders = [Loader.new(config, "test")]
         end
         @filters = filters
       end
@@ -56,14 +56,13 @@ module Megatest
     class Loader
       attr_reader :path
 
-      def initialize(path, filter = nil)
+      def initialize(config, path, filter = nil)
+        @config = config
         @path = File.expand_path(path)
         if @directory = File.directory?(@path)
           @path = File.join(@path, "/")
-          @paths = Megatest.glob(@path)
-        else
-          @paths = [@path]
         end
+        @paths = nil
         @filter = filter
       end
 
@@ -81,7 +80,7 @@ module Megatest
       end
 
       def append_paths(paths_to_load)
-        paths_to_load.concat(@paths)
+        paths_to_load.concat(paths)
       end
 
       def select(registry)
@@ -99,6 +98,16 @@ module Megatest
           test_cases
         end
       end
+
+      private
+
+      def paths
+        @paths ||= if @directory
+          Megatest.glob(@config.test_globs.map { |pattern| File.join(@path, pattern) })
+        else
+          [@path]
+        end
+      end
     end
 
     class NegativeLoader
@@ -244,54 +253,56 @@ module Megatest
       NameFilter,
     ].freeze
 
-    class << self
-      def parse(argv)
-        if argv.empty?
-          return List.new([], [])
-        end
+    def initialize(config)
+      @config = config
+    end
 
-        argv = argv.dup
-        loaders = []
-        filters = []
+    def parse(argv)
+      if argv.empty?
+        return List.new(@config, [], [])
+      end
 
-        negative = false
+      argv = argv.dup
+      loaders = []
+      filters = []
 
-        until argv.empty?
-          case argument = argv.shift
-          when "!"
-            negative = true
-          else
-            loader_str, filter_str = argument.split(":", 2)
-            loader_str = nil if loader_str.empty?
-
-            filter = nil
-            if filter_str
-              FILTERS.each do |filter_class|
-                if filter = filter_class.parse(filter_str)
-                  break
-                end
+      negative = false
+
+      until argv.empty?
+        case argument = argv.shift
+        when "!"
+          negative = true
+        else
+          loader_str, filter_str = argument.split(":", 2)
+          loader_str = nil if loader_str.empty?
+
+          filter = nil
+          if filter_str
+            FILTERS.each do |filter_class|
+              if filter = filter_class.parse(filter_str)
+                break
               end
             end
+          end
 
-            if loader_str
-              loader = Loader.new(loader_str, filter)
-              if negative
-                loader = NegativeLoader.new(loader)
-                negative = false
-              end
-              loaders << loader
-            else
-              if negative
-                filter = NegativeFilter.new(filter)
-                negative = false
-              end
-              filters << filter
+          if loader_str
+            loader = Loader.new(@config, loader_str, filter)
+            if negative
+              loader = NegativeLoader.new(loader)
+              negative = false
             end
+            loaders << loader
+          else
+            if negative
+              filter = NegativeFilter.new(filter)
+              negative = false
+            end
+            filters << filter
           end
         end
-
-        List.new(loaders, filters)
       end
+
+      List.new(@config, loaders, filters)
     end
   end
 end

data/lib/megatest/state.rb

@@ -101,7 +101,9 @@ module Megatest
       end
 
       def on_teardown(block)
-        raise Error, "The teardown block is already defined" if @teardown_callback
+        if @teardown_callback
+          raise Error, "The teardown block was already defined as #{@teardown_callback}"
+        end
         raise Error, "teardown blocks can't be defined in context blocks" if @current_context
 
         @teardown_callback = block

data/lib/megatest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Megatest
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end

data/lib/megatest.rb

@@ -12,8 +12,13 @@ module Megatest
   ROOT = -File.expand_path("../", __FILE__)
   PWD = File.join(Dir.pwd, "/")
   IGNORED_ERRORS = [NoMemoryError, SignalException, SystemExit].freeze
+  DEFAULT_TEST_GLOB = "**/{test_*,*_test}.rb"
+
+  @running = false
 
   class << self
+    attr_accessor :running
+
     def fork?
       Process.respond_to?(:fork) && !ENV["NO_FORK"]
     end
@@ -90,12 +95,12 @@ module Megatest
     end
 
     if Dir.method(:glob).parameters.include?(%i(key sort)) # Ruby 2.7+
-      def glob(path)
-        Dir.glob(File.join(path, "**/{test_*,*_test}.rb"))
+      def glob(pattern)
+        Dir.glob(pattern)
       end
     else
-      def glob(path)
-        paths = Dir.glob(File.join(path, "**/{test_*,*_test}.rb"))
+      def glob(pattern)
+        paths = Dir.glob(pattern)
         paths.sort!
         paths
       end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: megatest
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Jean Boussier
 bindir: exe
 cert_chain: []
-date: 2025-06-20 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Largely API compatible with test-unit / minitest, but with lots of extra
   modern niceties like a proper CLI, test distribution, etc.
@@ -25,6 +25,7 @@ files:
 - exe/megatest
 - lib/megatest.rb
 - lib/megatest/assertions.rb
+- lib/megatest/autorun.rb
 - lib/megatest/backtrace.rb
 - lib/megatest/cli.rb
 - lib/megatest/compat.rb
@@ -74,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Modern test-unit style test framework
 test_files: []