Allow classes to be used as test suite (#393)

Fixes #173

Probably should be the default way of defining test suites going
forward, since `class`es are more hermetic than `object`s as by default
any local members are not accessible outside the `class` whereas an
`object`s local members are global

Needed to vendor a bit more code fro
https://github.com/portable-scala/portable-scala-reflect to make
`lookupInstantiatableClass` work in Scala 3

Author: lihaoyi

readme.md

@@ -161,7 +161,7 @@ package test.utest.examples
 
 import utest._
 
-object HelloTests extends TestSuite{
+class HelloTests extends TestSuite{
   val tests = Tests{
     test("test1"){
       throw new Exception("test1")
@@ -205,6 +205,7 @@ Tests: 3, Passed: 1, Failed: 2
 The tests are run one at a time, and any tests that fail with an exception have
 their stack trace printed. If the number of tests is large, a separate
 results-summary and failures-summary will be shown after all tests have run.
+Tests can either be inside zero-parameter `class`es (as shown above) or static `object`s.
 
 Nesting Tests
 -------------
@@ -220,7 +221,7 @@ package test.utest.examples
 
 import utest._
 
-object NestedTests extends TestSuite{
+class NestedTests extends TestSuite{
   val tests =  Tests{
     val x = 1
     test("outer1"){

utest/src-3-jvm/utest/PortableScalaReflectExcerpts.scala

@@ -56,6 +56,25 @@ object PortableScalaReflectExcerpts {
     c(clazz)
   }
 
+  private def isInstantiatableClass(clazz: Class[_]): Boolean = {
+    /* A local class will have a non-null *enclosing* class, but a null
+     * *declaring* class. For a top-level class, both are null, and for an
+     * inner class (non-local), both are the same non-null class.
+     */
+    def isLocalClass: Boolean =
+      clazz.getEnclosingClass() != clazz.getDeclaringClass()
+
+    (clazz.getModifiers() & Modifier.ABSTRACT) == 0 &&
+      clazz.getConstructors().length > 0 &&
+      !isModuleClass(clazz) &&
+      !isLocalClass
+  }
+
+  def lookupInstantiatableClass(fqcn: String,
+                                loader: ClassLoader): Option[InstantiatableClass] = {
+    load(fqcn, loader).filter(isInstantiatableClass).map(new InstantiatableClass(_))
+  }
+
   final class LoadableModuleClass private[PortableScalaReflectExcerpts] (val runtimeClass: Class[_]) {
     /** Loads the module instance and returns it.
      *
@@ -76,4 +95,32 @@ object PortableScalaReflectExcerpts {
       }
     }
   }
+
+  /** A wrapper for a class that can be instantiated.
+   *
+   * @param runtimeClass
+   * The `java.lang.Class[_]` representing the class.
+   */
+  final class InstantiatableClass (val runtimeClass: Class[_]) {
+
+    /** Instantiates this class using its zero-argument constructor.
+     *
+     * @throws java.lang.InstantiationException
+     * (caused by a `NoSuchMethodException`)
+     * If this class does not have a public zero-argument constructor.
+     */
+    def newInstance(): Any = {
+      try {
+        runtimeClass.newInstance()
+      } catch {
+        case e: IllegalAccessException =>
+          /* The constructor exists but is private; make it look like it does not
+           * exist at all.
+           */
+          throw new InstantiationException(runtimeClass.getName).initCause(
+            new NoSuchMethodException(runtimeClass.getName + ".<init>()"))
+      }
+    }
+
+  }
 }

utest/src-js/utest/PlatformShims.scala

@@ -22,7 +22,8 @@ object PlatformShims {
   def loadModule(name: String, loader: ClassLoader): Any = {
     Reflect
       .lookupLoadableModuleClass(name + "$", loader)
+      .map(_.loadModule())
+      .orElse(Reflect.lookupInstantiatableClass(name, loader).map(_.newInstance()))
       .getOrElse(throw new ClassNotFoundException(name))
-      .loadModule()
   }
 }

utest/src-jvm/utest/PlatformShims.scala

@@ -12,6 +12,7 @@ object PlatformShims extends PlatformShimsVersionSpecific {
   def loadModule(name: String, loader: ClassLoader): Any =
     Reflect
       .lookupLoadableModuleClass(name + "$", loader)
+      .map(_.loadModule())
+      .orElse(Reflect.lookupInstantiatableClass(name, loader).map(_.newInstance()))
       .getOrElse(throw new ClassNotFoundException(name))
-      .loadModule()
 }

utest/src-native/utest/PlatformShims.scala

@@ -18,7 +18,8 @@ object PlatformShims {
   def loadModule(name: String, loader: ClassLoader): Any = {
     Reflect
       .lookupLoadableModuleClass(name + "$")
+      .map(_.loadModule())
+      .orElse(Reflect.lookupInstantiatableClass(name).map(_.newInstance()))
       .getOrElse(throw new ClassNotFoundException(name))
-      .loadModule()
   }
 }

utest/src/utest/runner/Fingerprint.scala

@@ -8,3 +8,9 @@ object Fingerprint extends SubclassFingerprint {
   def isModule() = true
   def requireNoArgConstructor() = true
 }
+
+object ClassFingerprint extends SubclassFingerprint {
+  def superclassName() = "utest.TestSuite"
+  def isModule() = false
+  def requireNoArgConstructor() = true
+}

utest/src/utest/runner/Framework.scala

@@ -56,7 +56,7 @@ class Framework extends sbt.testing.Framework with framework.Formatter {
   def startHeader(path: String) = DefaultFormatters.renderBanner("Running Tests" + path)
 
 
-  final def fingerprints(): Array[sbt.testing.Fingerprint] = Array(Fingerprint)
+  final def fingerprints(): Array[sbt.testing.Fingerprint] = Array(Fingerprint, ClassFingerprint)
 
   final def runner(args: Array[String],
              remoteArgs: Array[String],

utest/test/src/test/utest/AfterEachOnFailureTest.scala

@@ -6,7 +6,7 @@ import utest.framework.ExecutionContext.RunNow
 /**
  * Put executor.utestAfterEach(path) into finally block to make sure it will be executed regardless of the test failing.
  */
-object AfterEachOnFailureTest extends TestSuite {
+class AfterEachOnFailureTest extends TestSuite{
 
   private var res:SomeResource = _
 

utest/test/src/test/utest/AssertsTests.scala

@@ -8,7 +8,7 @@ import utest._
 * since it is the thing that is meant to be *testing* all the fancy uTest
 * asserts, we can't assume they work.
 */
-object AssertsTests extends utest.TestSuite{
+class AssertsTests extends utest.TestSuite{
 
   implicit val colors: shaded.pprint.TPrintColors = shaded.pprint.TPrintColors.Colors
   def tests = Tests{

utest/test/src/test/utest/BeforeAfterAllFailureTest.scala

@@ -4,11 +4,11 @@ import utest._
 import utest.framework.StackMarker
 
 
-object BeforeAfterAllFailureTest extends TestSuite {
+class BeforeAfterAllFailureTest extends TestSuite{
 
   // Hide this fella inside the outer object, because we don't want uTest's own
   // test suite to discover him: we want to run him manually
-  object AfterAllFailureTest extends TestSuite {
+  object AfterAllFailureTest extends TestSuite{
 
     override def utestAfterAll(): Unit = {
       throw new Exception("Failed After!")
@@ -26,7 +26,7 @@ object BeforeAfterAllFailureTest extends TestSuite {
 
   // No tests for this fella because currently, error handling of test suite
   // initialization is paid done in the SBT logic, not in TestRunner
-  object BeforeAllFailureTest extends TestSuite {
+  class BeforeAllFailureTest extends TestSuite{
     throw new Exception("Failed Before!")
     val tests = Tests {
       test("test"){