Fix: MT support (synchronization of Reporter#record)

src/minitest.cr

@@ -93,19 +93,13 @@ module Minitest
     end
   end
 
-  @@reporter : AbstractReporter?
-
-  def self.reporter
-    @@reporter ||= CompositeReporter.new(options).tap do |reporter|
+  class_property reporter : AbstractReporter do
+    CompositeReporter.new(options).tap do |reporter|
       reporter << SummaryReporter.new(options)
       reporter << ProgressReporter.new(options)
     end
   end
 
-  def self.reporter=(reporter)
-    @@reporter = reporter
-  end
-
   def self.run(args = nil)
     process_args(args) if args
     puts options
@@ -114,6 +108,9 @@ module Minitest
     channel = Channel(Array(Runnable::Data) | Runnable::Data | Nil).new(options.fibers * 4)
     completed = Channel(Nil).new
 
+    # makes sure that reporter is initialized before spawning worker fibers:
+    raise "BUG: no minitest reporter" unless self.reporter
+
     options.fibers.times do
       spawn do
         loop do

src/reporter.cr

@@ -5,6 +5,7 @@ module Minitest
     getter options : Options
 
     def initialize(@options)
+      @mutex = Mutex.new
     end
 
     def start
@@ -19,13 +20,22 @@ module Minitest
     def passed?
       true
     end
+
+    def pause
+      @mutex.lock
+    end
+
+    def resume
+      @mutex.unlock
+    end
   end
 
   class CompositeReporter < AbstractReporter
     getter reporters
 
     def initialize(@options)
       @reporters = [] of AbstractReporter
+      super
     end
 
     def <<(reporter)
@@ -47,10 +57,20 @@ module Minitest
     def passed?
       reporters.all?(&.passed?)
     end
+
+    def pause
+      reporters.all?(&.pause)
+    end
+
+    def resume
+      reporters.all?(&.resume)
+    end
   end
 
   class ProgressReporter < AbstractReporter
     def record(result)
+      @mutex.lock
+
       if options.verbose
         if time = result.time
           print "%s#%s = %.3f s = " % {result.class_name, result.name, result.time.to_f}
@@ -70,6 +90,8 @@ module Minitest
     rescue ex
       puts ex
       puts ex.backtrace.join("\n")
+    ensure
+      @mutex.unlock
     end
   end
 
@@ -93,8 +115,13 @@ module Minitest
     end
 
     def record(result)
-      @count += 1
-      results << result if !result.passed? || result.skipped?
+      @mutex.synchronize do
+        @count += 1
+
+        if !result.passed? || result.skipped?
+          @mutex.synchronize { results << result }
+        end
+      end
     end
 
     def report

src/runnable.cr

@@ -27,17 +27,17 @@ module Minitest
       tests
     end
 
-    getter reporter : AbstractReporter
+    getter __reporter : AbstractReporter
 
-    def initialize(@reporter)
+    def initialize(@__reporter)
     end
 
     def should_run?(name) : Bool
       matches_pattern?(name)
     end
 
     def matches_pattern?(name) : Bool
-      case pattern = reporter.options.pattern
+      case pattern = __reporter.options.pattern
       when Regex
         !(name =~ pattern).nil?
       when String

src/test.cr

@@ -43,7 +43,7 @@ module Minitest
         capture_exception(result) { after_teardown }
       end
 
-      reporter.record(result)
+      __reporter.record(result)
     end
 
     def capture_exception(result)

test/assertions_test.cr

@@ -220,12 +220,17 @@ class AssertionsTest < Minitest::Test
   end
 
   def test_assert_silent
+    @__reporter.pause
     assert_silent { }
     assert_raises(Minitest::Assertion) { assert_silent { STDOUT << "hello" } }
     assert_raises(Minitest::Assertion) { assert_silent { STDERR << "world" } }
+  ensure
+    @__reporter.resume
   end
 
   def test_assert_output
+    @__reporter.pause
+
     assert_output("hello", "world") do
       STDOUT << "hello"
       STDERR << "world"
@@ -295,6 +300,8 @@ class AssertionsTest < Minitest::Test
         STDERR << "world"
       end
     end
+  ensure
+    @__reporter.resume
   end