Framework Implementation

/**
 * Interface implemented by test frameworks.
 * Must be annotated with @EnableReflectiveInstantiation for Scala.js compatibility.
 */
trait Framework {
  /** A human-friendly name of the test framework that this object represents. */
  def name(): String
  
  /** An array of Fingerprints that specify how to identify test classes during discovery. */
  def fingerprints(): Array[Fingerprint]
  
  /** 
   * Initiates a run.
   * @param args the test-framework-specific arguments for the new run
   * @param remoteArgs the test-framework-specific remote arguments for the run in a forked JVM
   * @param testClassLoader a class loader to use when loading test classes during the run
   * @return a Runner representing the newly started run
   * @throws IllegalStateException if unable to initiate run due to concurrent execution
   */
  def runner(args: Array[String], remoteArgs: Array[String],
            testClassLoader: ClassLoader): Runner
  
  /**
   * Scala.js specific: Creates a worker runner for a given run.
   * The worker may send a message to the controller runner by calling `send`.
   * Note: This method is called `slaveRunner` rather than `workerRunner` for historical reasons.
   * @param args the test-framework-specific arguments
   * @param remoteArgs the test-framework-specific remote arguments
   * @param testClassLoader class loader for test classes
   * @param send function to send messages to the controller runner
   * @return a Runner for worker execution
   */
  def slaveRunner(args: Array[String], remoteArgs: Array[String],
                 testClassLoader: ClassLoader, send: String => Unit): Runner
}

import sbt.testing._
import scala.scalajs.reflect.annotation.EnableReflectiveInstantiation

@EnableReflectiveInstantiation
class MyTestFramework extends Framework {
  def name(): String = "MyFramework"
  
  def fingerprints(): Array[Fingerprint] = Array(
    // Discover classes extending MyTestSuite
    new SubclassFingerprint {
      def isModule() = false
      def superclassName() = "com.example.MyTestSuite"
      def requireNoArgConstructor() = true
    },
    // Discover objects with @Test annotation
    new AnnotatedFingerprint {
      def isModule() = true
      def annotationName() = "com.example.Test"
    }
  )
  
  def runner(args: Array[String], remoteArgs: Array[String], 
            testClassLoader: ClassLoader): Runner = {
    new MyTestRunner(args, remoteArgs, testClassLoader, isWorker = false)
  }
  
  def slaveRunner(args: Array[String], remoteArgs: Array[String],
                 testClassLoader: ClassLoader, send: String => Unit): Runner = {
    new MyWorkerRunner(args, remoteArgs, testClassLoader, send)
  }
}

// Controller runner implementation
class MyTestRunner(
  val args: Array[String],
  remoteArgs: Array[String], 
  testClassLoader: ClassLoader,
  isWorker: Boolean
) extends Runner {
  // ... implementation
}

// Worker runner with message passing
class MyWorkerRunner(
  val args: Array[String],
  remoteArgs: Array[String],
  testClassLoader: ClassLoader,
  send: String => Unit
) extends Runner {
  
  def receiveMessage(msg: String): Option[String] = {
    msg match {
      case "status" => Some("worker-ready")
      case "shutdown" => 
        cleanup()
        None
      case _ => None
    }
  }
  
  // ... other implementations
}

/**
 * Annotation from scala.scalajs.reflect.annotation package
 * Must be applied to Framework implementations for Scala.js compatibility
 */
@EnableReflectiveInstantiation

import scala.scalajs.reflect.annotation.EnableReflectiveInstantiation

@EnableReflectiveInstantiation
class MyFramework extends Framework {
  // Implementation
}

def runner(args: Array[String], remoteArgs: Array[String],
          testClassLoader: ClassLoader): Runner = {
  if (isRunning) {
    throw new IllegalStateException(
      "Cannot initiate new run while previous run is active"
    )
  }
  // ... create runner
}