dohtest 0.1.54 → 0.1.56

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f671b0ee5564d932bd5cf2edd188c31292a0fee261a8ad5207e446450b93cb1e
-  data.tar.gz: 92e6b918b818a6e1b3824cde7e08c7964999a1e8088d024ed3f7b6ee2f365a14
+  metadata.gz: feef508b9e97ca382ecec3b01e7cb0c3ff609ab1e0e010e1d7676b94220f4840
+  data.tar.gz: 4fadcdffa88dc7d3d958c1f7b73a38a8897c3cfc9427ac32bc12031f2cc00fa1
 SHA512:
-  metadata.gz: 98d77e960acc16540bd4e52588af6cb0a98c051d3d068b4cdd49632b247bc46ce164c55cffa0927622b0f28a01d33ab66f7ee171623e798da435203adacf75a3
-  data.tar.gz: 7a64336cbb411d9056253ba1e2c9ab8a0d99ed857ffea18751272a8ede1b38bc8838f04e2133caf53ed0ac4aa64753869a5cbcb49c08d7e354d332e00f07200b
+  metadata.gz: fe2f5fece8efb09b7fd77bbcf4169b992b22b73f66e876fba4763a23353763c1c291d08c9988e5852cd12710d48fe079e13f24f86e9a2995cac3941da0515d82
+  data.tar.gz: a36eaf21dbf9bc595fbf1a3eee95a77066d00dadc76bf5ecec20bb00ba8b81f8b809eb0a031e1f9df0d69044a90d59fd59ca0effe37edccbf43afb0ed16d5361

data/bin/dohtest_repeat

@@ -3,3 +3,4 @@
 cmd = "dohtest #{ARGV.join(' ')}"
 while(system(cmd)) do
 end
+exit($?.exitstatus || 1)

data/lib/dohtest/assertions.rb

@@ -19,20 +19,30 @@ class TestGroup
     end
   end
 
+  # expected arguments:
+  # one or more exception classes (or modules); a class matches only exactly, not a subclass
+  # then optionally a regex the exception's message must match
+  # then optionally a failure message to display if the assertion fails
   def assert_raises(*expected)
     msg = expected.pop if expected.last.is_a?(String)
+    message_regex = expected.pop if expected.last.is_a?(Regexp)
+    if expected.empty? || !expected.all? { |elem| elem.is_a?(Module) }
+      raise ArgumentError, "assert_raises takes exception classes, then an optional regex, then an optional failure message; got: #{expected.inspect}"
+    end
+    failure_expected = {:classes => expected, :message_regex => message_regex}
     begin
       yield
       no_exception = true
     rescue Exception => actual_excpt
       actual_class = actual_excpt.class
-      if expected.any? { |elem| elem.instance_of?(Module) ? actual_excpt.kind_of?(elem) : elem == actual_class }
+      class_matched = expected.any? { |elem| elem.instance_of?(Module) ? actual_excpt.kind_of?(elem) : elem == actual_class }
+      if class_matched && (message_regex.nil? || actual_excpt.message.match?(message_regex))
         @runner.assertion_passed
       else
-        raise DohTest::Failure.new(msg, :raises, expected, actual_excpt)
+        raise DohTest::Failure.new(msg, :raises, failure_expected, actual_excpt)
       end
     end
-    raise DohTest::Failure.new(msg, :raises, expected, nil) if no_exception
+    raise DohTest::Failure.new(msg, :raises, failure_expected, nil) if no_exception
   end
 
   def assert_instance_of(expected_class, actual_object, msg = nil)

data/lib/dohtest/capture_output.rb

@@ -35,17 +35,25 @@ class CaptureOutput
     add(:group_name => group_name, :test_name => test_name, :error => error, :seed => seed)
   end
 
-  def assertion_failed(group_name, test_name, failure)
-    add(:group_name => group_name, :test_name => test_name, :failure => failure)
+  def assertion_failed(group_name, test_name, failure, seed)
+    add(:group_name => group_name, :test_name => test_name, :failure => failure, :seed => seed)
   end
 
   def assertion_passed(group_name, test_name)
     add(:group_name => group_name, :test_name => test_name)
   end
 
+  def callback_failed(proc_name)
+    add(:proc_name => proc_name)
+  end
+
+  def no_tests_found
+    add({})
+  end
+
 private
   def add(args)
-    args[:name] = caller.first.rpartition(':in ').last[1..-2]
+    args[:name] = caller_locations(1, 1).first.base_label
     @events.push(args)
   end
 end

data/lib/dohtest/group_runner.rb

@@ -187,6 +187,10 @@ class GroupRunner
   def total_problems
     @error_count + @assertions_failed
   end
+
+  def total_assertions
+    return @assertions_passed + @assertions_failed
+  end
 end
 
 end

data/lib/dohtest/master_runner.rb

@@ -26,19 +26,30 @@ class MasterRunner
     end
 
     total_problems = 0
+    total_assertions = 0
+    callbacks_succeeded = true
     # sort them to be the same order no matter what (different machines were returning different results)
     TestGroup.descendants.sort{|a,b|a.to_s<=>b.to_s}.shuffle.each do |group_class|
       runner = GroupRunner.new(group_class, @output, @config)
       brink_hit = runner.run
       total_problems += runner.total_problems
+      total_assertions += runner.total_assertions
       break if brink_hit
     end
     @config[:post_all_callback].each do |proc|
       if !proc.call(total_problems)
+        callbacks_succeeded = false
         @output.callback_failed(proc.inspect)
       end
     end
     @output.run_end(Time.now - start_time)
+
+    success = (total_assertions > 0) && (total_problems == 0) && callbacks_succeeded
+    if success
+      return 0
+    else
+      return 1
+    end
   end
 end
 

data/lib/dohtest/stream_output.rb

@@ -72,9 +72,6 @@ class StreamOutput
     msg = "#{error_str}; #{group_str}; #{test_str}; #{assertion_str}"
     msg = colorize(:success, msg) if success
     @std_ios.puts msg
-
-    # this is to generate an exit code; true translates to 0, false to 1
-    success
   end
 
   def group_begin(group_name)
@@ -171,14 +168,25 @@ private
   end
 
   def display_raises_failure(failure)
+    classes = failure.expected.fetch(:classes)
+    message_regex = failure.expected.fetch(:message_regex)
+
+    if classes.size == 1
+      expected_str = classes.first.to_s
+    else
+      expected_str = "one of #{classes.join(',')}"
+    end
+
+    if message_regex
+      expected_str += " with message matching #{message_regex.inspect}"
+    end
     if failure.actual
-      expected_str = if (failure.expected.size == 1) then failure.expected.first else "one of #{failure.expected.join(',')}" end
       @err_ios.puts colorize(:info, "expected: #{expected_str}; actual: #{failure.actual.class}: #{failure.actual.message}")
       DohTest::BacktraceParser.new(failure.actual.backtrace).relevant_stack.each do |path, line|
         @err_ios.puts "#{path}:#{line}"
       end
     else
-      @err_ios.puts colorize(:info, "expected: #{failure.expected}, but no exception was raised")
+      @err_ios.puts colorize(:info, "expected: #{expected_str}, but no exception was raised")
     end
   end
 

data/test/support/group_runner_helper.rb

@@ -0,0 +1,25 @@
+require 'dohtest/group_runner'
+require 'dohtest/capture_output'
+
+module DohTest
+
+# runs a test group with CaptureOutput, so a Minitest::Test can check the events it reports
+module GroupRunnerHelper
+  def verify_event(expected_pairs, event)
+    expected_pairs.each_pair do |key, value|
+      assert_equal(value, event[key])
+    end
+  end
+
+  def run_group(group_klass, config_overrides = {})
+    @group_klass = group_klass
+    @output = CaptureOutput.new
+    @runner = GroupRunner.new(@group_klass, @output, DohTest.config.merge(config_overrides))
+    @runner.run
+    @events = @output.events
+    assert_equal({:name => 'group_begin', :group_name => @group_klass.to_s}, @events.shift)
+    verify_event({:name => 'group_end', :group_name => @group_klass.to_s}, @events.last)
+  end
+end
+
+end

data/test/test_assertions.rb

@@ -0,0 +1,239 @@
+require 'dohroot'; Doh.find_root_from_file
+require 'minitest/autorun'
+require 'dohtest/group_runner'
+require 'dohtest/capture_output'
+require File.join(Doh.root, 'test/support/group_runner_helper')
+
+module DohTest
+
+class TestAssertions < Minitest::Test
+  include GroupRunnerHelper
+
+  def verify_passed(group_klass)
+    run_group(group_klass)
+    assert_equal(4, @events.size)
+    assert_equal('test_begin', @events.shift[:name])
+    assert_equal('assertion_passed', @events.shift[:name])
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 1, :assertions_failed => 0}, @events.shift)
+  end
+
+  def run_failed_group(group_klass)
+    run_group(group_klass)
+    assert_equal(4, @events.size)
+    assert_equal('test_begin', @events.shift[:name])
+    event = @events.shift
+    assert_equal('assertion_failed', event[:name])
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 0, :assertions_failed => 1}, @events.shift)
+    assert_equal(:raises, event[:failure].assert)
+    return event[:failure]
+  end
+
+  def verify_argument_error(group_klass)
+    run_group(group_klass)
+    assert_equal(4, @events.size)
+    assert_equal('test_begin', @events.shift[:name])
+    event = @events.shift
+    assert_equal('test_error', event[:name])
+    assert_equal(ArgumentError, event[:error].class)
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 0, :assertions_failed => 0}, @events.shift)
+  end
+
+  class RaisesClass < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError) { raise ArgumentError }
+    end
+  end
+
+  def test_raises_class
+    verify_passed(RaisesClass)
+  end
+
+  class RaisesOneOfSeveralClasses < DohTest::TestGroup
+    def test_raises
+      assert_raises(TypeError, ArgumentError) { raise ArgumentError }
+    end
+  end
+
+  def test_raises_one_of_several_classes
+    verify_passed(RaisesOneOfSeveralClasses)
+  end
+
+  module TaggedError; end
+  class TaggedRuntimeError < RuntimeError
+    include TaggedError
+  end
+
+  class RaisesModule < DohTest::TestGroup
+    def test_raises
+      assert_raises(TaggedError) { raise TaggedRuntimeError }
+    end
+  end
+
+  def test_raises_module
+    verify_passed(RaisesModule)
+  end
+
+  class RaisesWrongClass < DohTest::TestGroup
+    def test_raises
+      assert_raises(TypeError) { raise ArgumentError }
+    end
+  end
+
+  def test_raises_wrong_class
+    failure = run_failed_group(RaisesWrongClass)
+    assert_equal(ArgumentError, failure.actual.class)
+  end
+
+  class RaisesSubclass < DohTest::TestGroup
+    def test_raises
+      assert_raises(StandardError) { raise ArgumentError }
+    end
+  end
+
+  def test_raises_subclass
+    failure = run_failed_group(RaisesSubclass)
+    assert_equal(ArgumentError, failure.actual.class)
+  end
+
+  class RaisesNothing < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError) { nil }
+    end
+  end
+
+  def test_raises_nothing
+    failure = run_failed_group(RaisesNothing)
+    assert_nil(failure.actual)
+  end
+
+  class RaisesMatchingMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, /abc/) { raise ArgumentError, 'xx abc xx' }
+    end
+  end
+
+  def test_raises_matching_message
+    verify_passed(RaisesMatchingMessage)
+  end
+
+  class RaisesNonMatchingMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, /abc/) { raise ArgumentError, 'xyz' }
+    end
+  end
+
+  def test_raises_non_matching_message
+    failure = run_failed_group(RaisesNonMatchingMessage)
+    assert_equal('xyz', failure.actual.message)
+    assert_equal({:classes => [ArgumentError], :message_regex => /abc/}, failure.expected)
+  end
+
+  class RaisesMatchingMessageWrongClass < DohTest::TestGroup
+    def test_raises
+      assert_raises(TypeError, /abc/) { raise ArgumentError, 'abc' }
+    end
+  end
+
+  def test_raises_matching_message_wrong_class
+    failure = run_failed_group(RaisesMatchingMessageWrongClass)
+    assert_equal(ArgumentError, failure.actual.class)
+  end
+
+  class RaisesNothingWithRegex < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, /abc/) { nil }
+    end
+  end
+
+  def test_raises_nothing_with_regex
+    failure = run_failed_group(RaisesNothingWithRegex)
+    assert_nil(failure.actual)
+  end
+
+  class RaisesWithFailureMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises(TypeError, 'custom message') { raise ArgumentError }
+    end
+  end
+
+  def test_raises_with_failure_message
+    failure = run_failed_group(RaisesWithFailureMessage)
+    assert_equal('custom message', failure.message)
+  end
+
+  class RaisesWithRegexAndFailureMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, /abc/, 'custom message') { raise ArgumentError, 'xyz' }
+    end
+  end
+
+  def test_raises_with_regex_and_failure_message
+    failure = run_failed_group(RaisesWithRegexAndFailureMessage)
+    assert_equal('custom message', failure.message)
+  end
+
+  class RaisesNoArguments < DohTest::TestGroup
+    def test_raises
+      assert_raises { nil }
+    end
+  end
+
+  def test_raises_no_arguments
+    verify_argument_error(RaisesNoArguments)
+  end
+
+  class RaisesOnlyRegex < DohTest::TestGroup
+    def test_raises
+      assert_raises(/abc/) { nil }
+    end
+  end
+
+  def test_raises_only_regex
+    verify_argument_error(RaisesOnlyRegex)
+  end
+
+  class RaisesOnlyFailureMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises('custom message') { nil }
+    end
+  end
+
+  def test_raises_only_failure_message
+    verify_argument_error(RaisesOnlyFailureMessage)
+  end
+
+  class RaisesRegexBeforeClass < DohTest::TestGroup
+    def test_raises
+      assert_raises(/abc/, ArgumentError) { nil }
+    end
+  end
+
+  def test_raises_regex_before_class
+    verify_argument_error(RaisesRegexBeforeClass)
+  end
+
+  class RaisesRegexAfterFailureMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, 'custom message', /abc/) { nil }
+    end
+  end
+
+  def test_raises_regex_after_failure_message
+    verify_argument_error(RaisesRegexAfterFailureMessage)
+  end
+
+  class RaisesNonClassArgument < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, 5) { nil }
+    end
+  end
+
+  def test_raises_non_class_argument
+    verify_argument_error(RaisesNonClassArgument)
+  end
+end
+
+end

data/test/test_backtrace_parser.rb

@@ -4,7 +4,7 @@ require 'dohtest/backtrace_parser'
 
 module DohTest
 
-class TestBacktraceParser < MiniTest::Test
+class TestBacktraceParser < Minitest::Test
   def create_single_stack
     retval = []
     retval << "/Users/somebody/dohtest/lib/doh/test/assertions.rb:10:in `assert'"

data/test/test_exit_codes.rb

@@ -0,0 +1,106 @@
+require 'dohroot'; Doh.find_root_from_file
+require 'minitest/autorun'
+require 'tmpdir'
+
+module DohTest
+
+# runs bin/dohtest and bin/dohtest_repeat as subprocesses against generated
+# fixture suites, pinning the exit-code contract: 0 only when tests ran and
+# every assertion passed, 1 otherwise
+class TestExitCodes < Minitest::Test
+  BIN_DIR = File.join(Doh.root, 'bin')
+  LIB_DIR = File.join(Doh.root, 'lib')
+
+  PASSING_GROUP = <<~EOT
+    class TestExitPass < DohTest::TestGroup
+      def test_pass
+        assert_equal(4, 2 + 2)
+      end
+    end
+  EOT
+
+  FAILING_GROUP = <<~EOT
+    class TestExitFail < DohTest::TestGroup
+      def test_pass
+        assert_equal(4, 2 + 2)
+      end
+      def test_fail
+        assert_equal(5, 2 + 2)
+      end
+    end
+  EOT
+
+  ERROR_GROUP = <<~EOT
+    class TestExitError < DohTest::TestGroup
+      def test_error
+        raise 'boom'
+      end
+    end
+  EOT
+
+  NO_ASSERTION_GROUP = <<~EOT
+    class TestExitNoAssertions < DohTest::TestGroup
+      def test_nothing
+      end
+    end
+  EOT
+
+  def run_dohtest(path)
+    system('ruby', "-I#{LIB_DIR}", File.join(BIN_DIR, 'dohtest'), '-q', path, :out => File::NULL, :err => File::NULL)
+    return $?.exitstatus
+  end
+
+  def run_dohtest_repeat(path)
+    env = {'PATH' => "#{BIN_DIR}:#{ENV['PATH']}", 'RUBYLIB' => LIB_DIR}
+    system(env, 'ruby', File.join(BIN_DIR, 'dohtest_repeat'), '-q', path, :out => File::NULL, :err => File::NULL)
+    return $?.exitstatus
+  end
+
+  def with_fixture(group_source)
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, 'dohroot'), '')
+      path = File.join(dir, 'fixture.dt.rb')
+      File.write(path, group_source)
+      yield path
+    end
+  end
+
+  def test_all_assertions_passing_exits_zero
+    with_fixture(PASSING_GROUP) do |path|
+      assert_equal(0, run_dohtest(path))
+    end
+  end
+
+  def test_assertion_failure_exits_one
+    with_fixture(FAILING_GROUP) do |path|
+      assert_equal(1, run_dohtest(path))
+    end
+  end
+
+  def test_error_exits_one
+    with_fixture(ERROR_GROUP) do |path|
+      assert_equal(1, run_dohtest(path))
+    end
+  end
+
+  def test_no_assertions_exits_one
+    with_fixture(NO_ASSERTION_GROUP) do |path|
+      assert_equal(1, run_dohtest(path))
+    end
+  end
+
+  def test_no_test_files_exits_one
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, 'dohroot'), '')
+      assert_equal(1, run_dohtest(dir))
+    end
+  end
+
+  def test_dohtest_repeat_propagates_failure
+    with_fixture(FAILING_GROUP) do |path|
+      assert_equal(1, run_dohtest_repeat(path))
+    end
+  end
+end
+
+end

data/test/test_group_runner.rb

@@ -2,27 +2,12 @@ require 'dohroot'; Doh.find_root_from_file
 require 'minitest/autorun'
 require 'dohtest/group_runner'
 require 'dohtest/capture_output'
+require File.join(Doh.root, 'test/support/group_runner_helper')
 
 module DohTest
 
-class TestGroupRunner < MiniTest::Test
-  def verify_event(expected_pairs, event)
-    expected_pairs.each_pair do |key, value|
-      assert_equal(value, event[key])
-    end
-  end
-
-  def run_group(group_klass, grepstr = nil)
-    @group_klass = group_klass
-    @output = CaptureOutput.new
-    config = if grepstr then DohTest.config.merge({:grep => grepstr}) else nil end
-    @runner = GroupRunner.new(@group_klass, @output, config)
-    @runner.run
-    @events = @output.events
-    assert_equal({:name => 'group_begin', :group_name => @group_klass.to_s}, @events.shift)
-    verify_event({:name => 'group_end', :group_name => @group_klass.to_s}, @events.last)
-  end
-
+class TestGroupRunner < Minitest::Test
+  include GroupRunnerHelper
 
   class EmptyTestGroup < DohTest::TestGroup; end
   def test_empty_group
@@ -120,6 +105,39 @@ class TestGroupRunner < MiniTest::Test
     assert(@group_klass.class_variable_get(:@@ran_after))
   end
 
+  class AssertionFailureGroup < DohTest::TestGroup
+    def test_failed_assertion
+      assert_equal(1, 2)
+    end
+  end
+
+  def test_assertion_failure
+    run_group(AssertionFailureGroup)
+    assert_equal(4, @events.size)
+    assert_equal('test_begin', @events.shift[:name])
+    event = @events.shift
+    assert_equal('assertion_failed', event[:name])
+    assert_equal(:equal, event[:failure].assert)
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 0, :assertions_failed => 1}, @events.shift)
+  end
+
+  class CallbackFailureGroup < DohTest::TestGroup
+    def test_pass
+      assert(true)
+    end
+  end
+
+  def test_callback_failure
+    run_group(CallbackFailureGroup, :pre_group_callback => [proc { false }])
+    assert_equal(5, @events.size)
+    assert_equal('callback_failed', @events.shift[:name])
+    assert_equal('test_begin', @events.shift[:name])
+    assert_equal('assertion_passed', @events.shift[:name])
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 1, :assertions_failed => 0}, @events.shift)
+  end
+
   class GreppingWithPass < DohTest::TestGroup
     def test_blah
       assert(true)
@@ -146,22 +164,22 @@ class TestGroupRunner < MiniTest::Test
   end
 
   def test_grepping_with_pass_grep_blah
-    run_group(GreppingWithPass, 'blah')
+    run_group(GreppingWithPass, :grep => 'blah')
     verify_event({:tests_ran => 4, :tests_skipped => 1, :assertions_passed => 13, :assertions_failed => 0}, @events.last)
   end
 
   def test_grepping_with_pass_grep_blee
-    run_group(GreppingWithPass, 'blee')
+    run_group(GreppingWithPass, :grep => 'blee')
     verify_event({:tests_ran => 2, :tests_skipped => 3, :assertions_passed => 6, :assertions_failed => 0}, @events.last)
   end
 
   def test_grepping_with_pass_grep_bloo
-    run_group(GreppingWithPass, 'bloo')
+    run_group(GreppingWithPass, :grep => 'bloo')
     verify_event({:tests_ran => 1, :tests_skipped => 4, :assertions_passed => 5, :assertions_failed => 0}, @events.last)
   end
 
   def test_grepping_with_pass_grep_zzz
-    run_group(GreppingWithPass, 'zzz')
+    run_group(GreppingWithPass, :grep => 'zzz')
     verify_event({:tests_ran => 0, :tests_skipped => 5, :assertions_passed => 0, :assertions_failed => 0}, @events.last)
   end
 end

data/test/test_master_runner.rb

@@ -0,0 +1,20 @@
+require 'dohroot'; Doh.find_root_from_file
+require 'minitest/autorun'
+require 'dohtest/master_runner'
+require 'dohtest/capture_output'
+
+module DohTest
+
+class TestMasterRunner < Minitest::Test
+  def test_no_tests_found
+    output = CaptureOutput.new
+    runner = MasterRunner.new(output, DohTest.config.merge(:test_files => [], :seed => 1))
+    assert_equal(1, runner.run)
+    events = output.events
+    assert_equal(2, events.size)
+    assert_equal('run_begin', events.shift[:name])
+    assert_equal('no_tests_found', events.shift[:name])
+  end
+end
+
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dohtest
 version: !ruby/object:Gem::Version
-  version: 0.1.54
+  version: 0.1.56
 platform: ruby
 authors:
 - ATPSoft
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-03 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dohroot
@@ -63,13 +62,16 @@ files:
 - lib/dohtest/master_runner.rb
 - lib/dohtest/stream_output.rb
 - lib/dohtest/test_group.rb
+- test/support/group_runner_helper.rb
+- test/test_assertions.rb
 - test/test_backtrace_parser.rb
+- test/test_exit_codes.rb
 - test/test_group_runner.rb
+- test/test_master_runner.rb
 homepage: https://github.com/atpsoft/dohtest
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -84,10 +86,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.11
-signing_key: 
+rubygems_version: 4.0.17
 specification_version: 4
 summary: minimalist unit test framework
 test_files:
+- test/support/group_runner_helper.rb
+- test/test_assertions.rb
 - test/test_backtrace_parser.rb
+- test/test_exit_codes.rb
 - test/test_group_runner.rb
+- test/test_master_runner.rb