DRY tests

Author: mikkolaj

monix-execution/jvm/src/test/scala/monix/execution/schedulers/ExecutorSchedulerSuite.scala

@@ -18,14 +18,15 @@
 package monix.execution.schedulers
 
 import minitest.TestSuite
-import monix.execution.ExecutionModel.{AlwaysAsyncExecution, Default => DefaultExecutionModel}
+import monix.execution.ExecutionModel.{ AlwaysAsyncExecution, Default => DefaultExecutionModel }
 import monix.execution.cancelables.SingleAssignCancelable
 import monix.execution.exceptions.DummyException
-import monix.execution.{Cancelable, Scheduler, UncaughtExceptionReporter}
+import monix.execution.schedulers.ExecutorSchedulerSuite.TestException
+import monix.execution.{ Cancelable, Scheduler, UncaughtExceptionReporter }
 
-import java.util.concurrent.{CountDownLatch, Executors, TimeUnit, TimeoutException}
+import java.util.concurrent.{ CountDownLatch, Executors, TimeUnit, TimeoutException }
 import scala.concurrent.duration._
-import scala.concurrent.{Await, Promise, blocking}
+import scala.concurrent.{ blocking, Await, Promise }
 
 abstract class ExecutorSchedulerSuite extends TestSuite[SchedulerService] { self =>
   var lastReportedFailure = null: Throwable
@@ -152,108 +153,77 @@ abstract class ExecutorSchedulerSuite extends TestSuite[SchedulerService] { self
   }
 
   test("reports errors on execute") { scheduler =>
-    val latch = new CountDownLatch(1)
-    self.synchronized {
-      lastReportedFailure = null
-      lastReportedFailureLatch = latch
-    }
+    val latch: CountDownLatch = setupReporterLatch()
 
     try {
-      val ex = DummyException("dummy")
-
-      scheduler.execute(new Runnable {
-        override def run() =
-          throw ex
-      })
+      scheduler.execute(() => throw TestException)
 
-      assert(latch.await(15, TimeUnit.MINUTES), "lastReportedFailureLatch.await")
-      self.synchronized(assertEquals(lastReportedFailure, ex))
+      assertTestExceptionCaught(latch)
     } finally {
-      self.synchronized {
-        lastReportedFailure = null
-        lastReportedFailureLatch = null
-      }
+      clearReporterLatch()
     }
   }
 
   test("reports errors on scheduleOnce") { scheduler =>
-    val latch = new CountDownLatch(1)
-    self.synchronized {
-      lastReportedFailure = null
-      lastReportedFailureLatch = latch
-    }
-
-    try {
-      val ex = DummyException("dummy")
+    testScheduledErrorReporting(
+      scheduleFailure = () => scheduler.scheduleOnce(1.milli)(throw TestException)
+    )
+  }
 
-      scheduler.scheduleOnce(
-        1,
-        TimeUnit.MILLISECONDS,
-        () => throw ex,
-      )
+  test("reports errors on scheduleAtFixedRate") { scheduler =>
+    testScheduledErrorReporting(
+      scheduleFailure = () => scheduler.scheduleAtFixedRate(0.seconds, 1.second)(throw TestException)
+    )
+  }
 
-      assert(latch.await(15, TimeUnit.MINUTES), "lastReportedFailureLatch.await")
-      self.synchronized(assertEquals(lastReportedFailure, ex))
-    } finally {
-      self.synchronized {
-        lastReportedFailure = null
-        lastReportedFailureLatch = null
-      }
-    }
+  test("reports errors on scheduleWithFixedDelay") { scheduler =>
+    testScheduledErrorReporting(
+      scheduleFailure = () => scheduler.scheduleWithFixedDelay(0.seconds, 1.second)(throw TestException),
+    )
   }
 
-  test("reports errors on scheduleAtFixedRate") { scheduler =>
-    val latch = new CountDownLatch(1)
-    self.synchronized {
-      lastReportedFailure = null
-      lastReportedFailureLatch = latch
-    }
+  private def testScheduledErrorReporting(scheduleFailure: () => Cancelable): Unit = {
+    val latch = setupReporterLatch()
 
-    val ex = DummyException("dummy")
-    val schedule = scheduler.scheduleAtFixedRate(0.seconds, 1.second) {
-      throw ex
-    }
+    val schedule = scheduleFailure()
 
     try {
-      assert(latch.await(15, TimeUnit.MINUTES), "lastReportedFailureLatch.await")
-      self.synchronized(assertEquals(lastReportedFailure, ex))
+      assertTestExceptionCaught(latch)
     } finally {
       schedule.cancel()
-      self.synchronized {
-        lastReportedFailure = null
-        lastReportedFailureLatch = null
-      }
+      clearReporterLatch()
     }
   }
 
-  test("reports errors on scheduleWithFixedDelay") { scheduler =>
+  private def setupReporterLatch() = {
     val latch = new CountDownLatch(1)
     self.synchronized {
       lastReportedFailure = null
       lastReportedFailureLatch = latch
     }
+    latch
+  }
 
-    val ex = DummyException("dummy")
-    val schedule = scheduler.scheduleWithFixedDelay(0.seconds, 1.second) {
-      throw ex
-    }
+  private def assertTestExceptionCaught(latch: CountDownLatch): Unit = {
+    assert(latch.await(15, TimeUnit.MINUTES), "lastReportedFailureLatch.await")
+    self.synchronized(assertEquals(lastReportedFailure, TestException))
+  }
 
-    try {
-      assert(latch.await(15, TimeUnit.MINUTES), "lastReportedFailureLatch.await")
-      self.synchronized(assertEquals(lastReportedFailure, ex))
-    } finally {
-      schedule.cancel()
-      self.synchronized {
-        lastReportedFailure = null
-        lastReportedFailureLatch = null
-      }
+  private def clearReporterLatch(): Unit = {
+    self.synchronized {
+      lastReportedFailure = null
+      lastReportedFailureLatch = null
     }
   }
 
   def runnableAction(f: => Unit): Runnable =
     new Runnable { def run() = f }
 }
 
+object ExecutorSchedulerSuite {
+  private val TestException = DummyException("dummy")
+}
+
 object ComputationSchedulerSuite extends ExecutorSchedulerSuite {
   def setup(): SchedulerService =
     monix.execution.Scheduler