Add assertEqWithTolerance for Instant, and assertThrows{,A}

Closes #180

Author: japgolly

project/Build.scala

@@ -217,6 +217,7 @@ object Microlibs {
         Dep.univEq    .value,
         Dep.univEqCats.value,
       ))
+    .jsSettings(libraryDependencies += Dep.scalaJsJavaTime.value % Test)
 
   lazy val typesJVM = types.jvm
   lazy val typesJS  = types.js

project/Dependencies.scala

@@ -18,7 +18,7 @@ object Dependencies {
     def kindProjector   = "0.13.2"
     def nyaya           = "1.0.0"
     def scalaCheck      = "1.15.4"
-    def scalaJsJavaTime = "1.0.0"
+    def scalaJsJavaTime = "2.4.0"
     def utest           = "0.8.0"
   }
 
@@ -31,7 +31,7 @@ object Dependencies {
     val nyayaTest       = Def.setting("com.github.japgolly.nyaya"     %%% "nyaya-test"              % Ver.nyaya)
     val scalaCheck      = Def.setting("org.scalacheck"                %%% "scalacheck"              % Ver.scalaCheck)
     val scalaCompiler   = Def.setting("org.scala-lang"                  % "scala-compiler"          % scalaVersion.value)
-    val scalaJsJavaTime = Def.setting("org.scala-js"                  %%% "scalajs-java-time"       % Ver.scalaJsJavaTime cross CrossVersion.for3Use2_13)
+    val scalaJsJavaTime = Def.setting("io.github.cquiroz"             %%% "scala-java-time"         % Ver.scalaJsJavaTime)
     val sourceCode      = Def.setting("com.lihaoyi"                   %%% "sourcecode"              % Ver.sourceCode)
     val univEq          = Def.setting("com.github.japgolly.univeq"    %%% "univeq"                  % Ver.univEq)
     val univEqCats      = Def.setting("com.github.japgolly.univeq"    %%% "univeq-cats"             % Ver.univEq)

test-util/shared/src/main/scala/japgolly/microlibs/testutil/TestUtil.scala

@@ -6,8 +6,10 @@ import japgolly.microlibs.testutil.TestUtilInternals._
 import japgolly.univeq.UnivEq
 import japgolly.univeq.UnivEqCats.catsEqFromUnivEq
 import java.io.ByteArrayOutputStream
+import java.time.{Duration, Instant}
 import scala.annotation.tailrec
 import scala.io.AnsiColor._
+import scala.reflect.ClassTag
 import sourcecode.Line
 
 trait TestUtilWithoutUnivEq
@@ -442,15 +444,81 @@ trait TestUtilWithoutUnivEq
       println(
         s"""
            |${YELLOW_B}${BLACK}assertEqWithTolerance failed:$RESET$titleSuffix
-           |${BOLD_BRIGHT_GREEN}expect: $expect$RESET
-           |${BOLD_BRIGHT_RED}actual: $actual$RESET
-           |${BOLD_BRIGHT_RED} delta: $d$RESET
-           |$YELLOW   tol: $tolerance$RESET
+           |${BOLD_BRIGHT_GREEN}   expect: $expect$RESET
+           |${BOLD_BRIGHT_RED}   actual: $actual$RESET
+           |${BOLD_BRIGHT_RED}    delta: $d$RESET
+           |${YELLOW}tolerance: $tolerance$RESET
            |""".stripMargin)
       fail(s"$errorPrefix$actual ≠ $expect by $d which exceeds tolerance of $tolerance")
     }
   }
 
+
+  def assertEqWithTolerance(actual: Instant, expect: Instant)(implicit l: Line): Unit =
+    _assertEqWithToleranceInstant(None, actual, expect)
+
+  def assertEqWithTolerance(name: => String, actual: Instant, expect: Instant)(implicit l: Line): Unit =
+    _assertEqWithToleranceInstant(Some(name), actual, expect)
+
+  def assertEqWithTolerance(actual: Instant, expect: Instant, tolerance: Duration)(implicit l: Line): Unit =
+    _assertEqWithToleranceInstant(None, actual, expect, tolerance)
+
+  def assertEqWithTolerance(name: => String, actual: Instant, expect: Instant, tolerance: Duration)(implicit l: Line): Unit =
+    _assertEqWithToleranceInstant(Some(name), actual, expect, tolerance)
+
+  private def _assertEqWithToleranceInstant(_name: => Option[String], actual: Instant, expect: Instant, tolerance: Duration = Duration.ofMillis(100))(implicit l: Line): Unit = {
+    val d = Duration.between(actual, expect).abs()
+    if (d.compareTo(tolerance) > 0) {
+      val name = _name
+      val titleSuffix = name.fold("")(n => s" ${BOLD_BRIGHT_YELLOW}$n$RESET")
+      val errorPrefix = name.fold("")(n => s"[$n] ")
+      println(
+        s"""
+           |${YELLOW_B}${BLACK}assertEqWithTolerance failed:$RESET$titleSuffix
+           |${BOLD_BRIGHT_GREEN}   expect: $expect$RESET
+           |${BOLD_BRIGHT_RED}   actual: $actual$RESET
+           |${BOLD_BRIGHT_RED}    delta: $d$RESET
+           |${YELLOW}tolernace: $tolerance$RESET
+           |""".stripMargin)
+      fail(s"$errorPrefix$actual ≠ $expect by $d which exceeds tolerance of $tolerance")
+    }
+  }
+
+  def assertThrows(body: => Any)(implicit l: Line): Throwable =
+    _assertThrows("assertThrows", None, body)
+
+  def assertThrows(name: => String, body: => Any)(implicit l: Line): Throwable =
+    _assertThrows("assertThrows", Some(name), body)
+
+  private def _assertThrows(method: String, name: => Option[String], body: => Any)(implicit l: Line): Throwable = {
+    val error: Throwable =
+      try {
+        body
+        null
+      } catch {
+        case t: Throwable => t
+      }
+    if (error eq null)
+      fail(s"${descMethod(method, name)} failed. No exception was thrown.")
+    else
+      error
+  }
+
+  def assertThrowsA[T <: Throwable: ClassTag](body: => Any)(implicit l: Line): T =
+    _assertThrowsA[T](None, body)
+
+  def assertThrowsA[T <: Throwable: ClassTag](name: => String, body: => Any)(implicit l: Line): T =
+    _assertThrowsA[T](Some(name), body)
+
+  private def _assertThrowsA[T <: Throwable](name: => Option[String], body: => Any)(implicit l: Line, ct: ClassTag[T]): T = {
+    val method = "assertThrowsA"
+    _assertThrows(method, name, body) match {
+      case t: T => t
+      case t    =>
+        t.printStackTrace()
+        fail(s"${descMethod(method, name)} failed. ${t.getClass.getName} is not an instance of ${ct.runtimeClass.getName}")
+    }
+  }
 }
 
 trait TestUtil

test-util/shared/src/test/scala/japgolly/microlibs/testutil/TestUtilTest.scala

@@ -1,5 +1,6 @@
 package japgolly.microlibs.testutil
 
+import java.time.{Duration, Instant}
 import utest._
 
 object TestUtilTest extends TestSuite {
@@ -20,7 +21,20 @@ object TestUtilTest extends TestSuite {
           case _: java.lang.AssertionError => ()
         }
       }
+    }
+
+    "assertEqWithToleranceDouble" - {
+      assertEqWithTolerance(10, 12, 2)
+      assertEqWithTolerance(10, 12, 3)
+      assertThrows(assertEqWithTolerance(10, 12, 1))
+    }
 
+    "assertEqWithToleranceInstant" - {
+      val a = Instant.now()
+      val b = a.plus(Duration.ofSeconds(2))
+      assertEqWithTolerance(a, b, Duration.ofSeconds(2))
+      assertEqWithTolerance(a, b, Duration.ofSeconds(3))
+      assertThrows(assertEqWithTolerance(a, b, Duration.ofSeconds(1)))
     }
   }
 }