Remove ambigouity in AssertThrows.expectThrows overloads.

Author: nicolasstucki

test-suite/shared/src/test/scala/org/scalajs/testsuite/javalib/net/URLDecoderTest.scala

@@ -36,8 +36,7 @@ class URLDecoderTest {
 
     def unsupportedEncoding(encoded: String, enc: String = utf8): Unit = {
       val exception = classOf[UnsupportedEncodingException]
-      val runnable = throwingRunnable { URLDecoder.decode(encoded, enc) }
-      assertThrows(exception, runnable)
+      assertThrows(exception, URLDecoder.decode(encoded, enc))
     }
 
     // empty string

test-suite/shared/src/test/scala/org/scalajs/testsuite/junit/JUnitAssertionsTest.scala

@@ -329,33 +329,30 @@ class JUnitAssertionsTest {
 
   @Test
   def testExpectThrows(): Unit = {
-    testIfAsserts(expectThrows(classOf[Exception],
-        throwingRunnable { throw new Exception }))
+    testIfAsserts(expectThrows(classOf[Exception], throw new Exception))
     testIfAsserts(expectThrows(classOf[IndexOutOfBoundsException],
-        throwingRunnable { throw new IndexOutOfBoundsException }))
+        throw new IndexOutOfBoundsException))
 
     testIfAsserts {
-      val ex = expectThrows(classOf[Exception],
-          throwingRunnable { throw new Exception("abc") })
+      val ex = expectThrows(classOf[Exception], throw new Exception("abc"))
       assertEquals(ex.getMessage, "abc")
     }
 
     testIfAsserts(expectThrows(classOf[IndexOutOfBoundsException],
-        throwingRunnable { throw new Exception }), ShallNotPass)
-    testIfAsserts(expectThrows(classOf[IndexOutOfBoundsException],
-        throwingRunnable { }), ShallNotPass)
+        throw new Exception), ShallNotPass)
+    testIfAsserts(expectThrows(classOf[IndexOutOfBoundsException],()),
+        ShallNotPass)
   }
 
   @Test
   def testAssertThrows(): Unit = {
-    testIfAsserts(assertThrows(classOf[Exception],
-        throwingRunnable { throw new Exception }))
+    testIfAsserts(assertThrows(classOf[Exception], throw new Exception))
     testIfAsserts(assertThrows(classOf[IndexOutOfBoundsException],
-        throwingRunnable { throw new IndexOutOfBoundsException }))
+        throw new IndexOutOfBoundsException))
 
     testIfAsserts(assertThrows(classOf[IndexOutOfBoundsException],
-        throwingRunnable { throw new Exception }), ShallNotPass)
-    testIfAsserts(assertThrows(classOf[IndexOutOfBoundsException],
-        throwingRunnable { }), ShallNotPass)
+        throw new Exception), ShallNotPass)
+    testIfAsserts(assertThrows(classOf[IndexOutOfBoundsException], ()),
+        ShallNotPass)
   }
 }

test-suite/shared/src/test/scala/org/scalajs/testsuite/utils/AssertThrows.scala

@@ -4,15 +4,16 @@ object AssertThrows {
   /** Backport implementation of Assert.assertThrows to be used until JUnit 4.13 is
    *  released. See org.junit.Assert.scala in jUnitRuntime.
    */
-  def assertThrows(expectedThrowable: Class[_ <: Throwable],
+  private def assertThrowsBackport(expectedThrowable: Class[_ <: Throwable],
       runnable: ThrowingRunnable): Unit = {
-    expectThrows(expectedThrowable, runnable)
+    expectThrowsBackport(expectedThrowable, runnable)
   }
 
   /** Backport implementation of Assert.expectThrows to be used until JUnit 4.13 is
    *  released. See org.junit.Assert.scala in jUnitRuntime.
    */
-  def expectThrows[T <: Throwable](expectedThrowable: Class[T], runnable: ThrowingRunnable): T = {
+  private def expectThrowsBackport[T <: Throwable](expectedThrowable: Class[T],
+      runnable: ThrowingRunnable): T = {
     try {
       runnable.run()
       val message =
@@ -37,16 +38,19 @@ object AssertThrows {
   /** Backport implementation of Assert.ThrowingRunnable to be used until
    *  JUnit 4.13 is released. See org.junit.Assert.scala in jUnitRuntime.
    */
-  trait ThrowingRunnable {
+  private trait ThrowingRunnable {
     def run(): Unit
   }
 
-  def throwingRunnable(code: => Unit): ThrowingRunnable = {
+  private def throwingRunnable(code: => Unit): ThrowingRunnable = {
     new ThrowingRunnable {
       def run(): Unit = code
     }
   }
 
+  def assertThrows[T <: Throwable, U](expectedThrowable: Class[T], code: => U): Unit =
+    assertThrowsBackport(expectedThrowable, throwingRunnable(code.asInstanceOf[Unit]))
+
   def expectThrows[T <: Throwable, U](expectedThrowable: Class[T], code: => U): T =
-    expectThrows(expectedThrowable, throwingRunnable(code.asInstanceOf[Unit]))
+    expectThrowsBackport(expectedThrowable, throwingRunnable(code.asInstanceOf[Unit]))
 }