Test Suites

/**
 * Main test suite class for function-style tests
 */
abstract class FunSuite extends BaseFunSuite

trait BaseFunSuite 
    extends Suite 
    with Assertions 
    with FunFixtures 
    with TestOptionsConversions 
    with TestTransforms 
    with SuiteTransforms 
    with ValueTransforms {
  
  /** Define a test with a name and body */
  def test(name: String)(body: => Any)(implicit loc: Location): Unit
  
  /** Define a test with options and body */
  def test(options: TestOptions)(body: => Any)(implicit loc: Location): Unit
  
  /** Configure test timeout (default: 30 seconds) */
  def munitTimeout: Duration
  
  /** Get all tests in this suite */
  def munitTests(): Seq[Test]
}

import munit.FunSuite
import scala.concurrent.Future

class MyTestSuite extends FunSuite {
  test("simple test") {
    assertEquals(2 + 2, 4)
  }
  
  test("test with custom options".tag(Slow)) {
    // This test is marked as slow
    Thread.sleep(1000)
    assert(true)
  }
  
  test("async test") {
    Future.successful(42).map { result =>
      assertEquals(result, 42)
    }
  }
  
  test("test that should fail".fail) {
    // This test is expected to fail
    assertEquals(1, 2)
  }
}

/**
 * Base class for all test suites with minimal functionality
 */
@RunWith(classOf[MUnitRunner])
abstract class Suite extends PlatformSuite {
  
  // Type aliases for convenience
  final type TestValue = Future[Any]
  final type Fixture[T] = munit.Fixture[T]
  final type Test = munit.Test
  final type BeforeEach = munit.BeforeEach
  final type AfterEach = munit.AfterEach
  
  /** Abstract method to return all tests in the suite */
  def munitTests(): Seq[Test]
  
  /** Suite-level fixtures for resource management */
  def munitFixtures: Seq[AnyFixture[_]] = Nil
  
  /** Execution context for async operations */
  def munitExecutionContext: ExecutionContext
  
  /** Runs once before all tests in the suite */
  def beforeAll(): Unit = ()
  
  /** Runs once after all tests in the suite */
  def afterAll(): Unit = ()
  
  /** Runs before each individual test */
  def beforeEach(context: BeforeEach): Unit = ()
  
  /** Runs after each individual test */
  def afterEach(context: AfterEach): Unit = ()
}

import munit._
import scala.concurrent.Future

class CustomSuite extends Suite {
  private val tests = List(
    new Test("custom test 1", () => Future.successful(assert(true)), Set.empty, Location.empty),
    new Test("custom test 2", () => Future.successful(assertEquals(1 + 1, 2)), Set.empty, Location.empty)
  )
  
  def munitTests(): Seq[Test] = tests
  
  override def beforeAll(): Unit = {
    println("Setting up test suite")
  }
  
  override def afterAll(): Unit = {
    println("Tearing down test suite")
  }
  
  override def beforeEach(context: BeforeEach): Unit = {
    println(s"Running test: ${context.test.name}")
  }
}

/**
 * Platform-specific base functionality
 * Implementation varies by platform (JVM/JS/Native)
 */
trait PlatformSuite

/**
 * Annotation to ignore an entire test suite (JS/Native only)
 */
class IgnoreSuite extends Annotation