FunSuite

Instance Constructors

new FunSuite()

Type Members

final type AfterEach = munit.AfterEach

Definition Classes
Suite
final type BeforeEach = munit.BeforeEach

Definition Classes
Suite
final type Fixture[T] = munit.Fixture[T]

Definition Classes
Suite
class FunFixture[T] extends AnyRef

Definition Classes
FunFixtures
final class SuiteTransform extends (List[BaseFunSuite.Test]) ⇒ List[BaseFunSuite.Test]

Definition Classes
SuiteTransforms
final type Test = munit.Test

Definition Classes
Suite
final class TestTransform extends (BaseFunSuite.Test) ⇒ BaseFunSuite.Test

Definition Classes
TestTransforms
final type TestValue = Future[Any]

The value produced by test bodies.
The value produced by test bodies.

Definition Classes
Suite
final class ValueTransform extends (Any) ⇒ Option[Future[Any]]

Definition Classes
ValueTransforms

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object FunFixture

Definition Classes
FunFixtures
def afterAll(): Unit

Runs once after all test cases and after all suite-local fixtures have been tear down.
Runs once after all test cases and after all suite-local fixtures have been tear down.

Definition Classes
Suite
def afterEach(context: AfterEach): Unit

Runs after each individual test case.
Runs after each individual test case.

Definition Classes
Suite
final def asInstanceOf[T0]: T0

Definition Classes
Any
def assert(cond: ⇒ Boolean, clue: ⇒ Any = "assertion failed")(implicit loc: Location): Unit

Definition Classes
Assertions
def assertEquals[A, B](obtained: A, expected: B, clue: ⇒ Any = "values are not the same")(implicit loc: Location, compare: Compare[A, B]): Unit

Asserts that two elements are equal according to the Compare[A, B] type-class.
Asserts that two elements are equal according to the Compare[A, B] type-class.
By default, uses == to compare values.

Definition Classes
Assertions
def assertEqualsDouble(obtained: Double, expected: Double, delta: Double, clue: ⇒ Any = "values are not the same")(implicit loc: Location): Unit

Asserts that two doubles are equal to within a positive delta.
Asserts that two doubles are equal to within a positive delta. If the expected value is infinity then the delta value is ignored. NaNs are considered equal: assertEquals(Double.NaN, Double.NaN, *) passes.

Definition Classes
Assertions
def assertEqualsFloat(obtained: Float, expected: Float, delta: Float, clue: ⇒ Any = "values are not the same")(implicit loc: Location): Unit

Asserts that two floats are equal to within a positive delta.
Asserts that two floats are equal to within a positive delta. If the expected value is infinity then the delta value is ignored. NaNs are considered equal: assertEquals(Float.NaN, Float.NaN, *) passes.

Definition Classes
Assertions
def assertNoDiff(obtained: String, expected: String, clue: ⇒ Any = "diff assertion failed")(implicit loc: Location): Unit

Definition Classes
Assertions
def assertNotEquals[A, B](obtained: A, expected: B, clue: ⇒ Any = "values are the same")(implicit loc: Location, compare: Compare[A, B]): Unit

Asserts that two elements are not equal according to the Compare[A, B] type-class.
Asserts that two elements are not equal according to the Compare[A, B] type-class.
By default, uses == to compare values.

Definition Classes
Assertions
def assume(cond: Boolean, clue: ⇒ Any = "assumption failed")(implicit loc: Location): Unit

Definition Classes
Assertions
def beforeAll(): Unit

Runs once before all test cases and before all suite-local fixtures are setup.
Runs once before all test cases and before all suite-local fixtures are setup. An error in this method aborts the test suite.

Definition Classes
Suite
def beforeEach(context: BeforeEach): Unit

Runs before each individual test case.
Runs before each individual test case. An error in this method aborts the test case.

Definition Classes
Suite
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def clue[T](c: Clue[T]): T

Definition Classes
Assertions
def clues(clue: Clue[_]*): Clues

Definition Classes
Assertions
macro def compileErrors(code: String): String

Definition Classes
CompileErrorMacro
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def fail(message: String, clues: Clues = new Clues(Nil))(implicit loc: Location): Nothing

Unconditionally fails this test with the given message and optional clues.
Unconditionally fails this test with the given message and optional clues.

Definition Classes
Assertions
def fail(message: String, cause: Throwable)(implicit loc: Location): Nothing

Unconditionally fails this test with the given message and exception marked as the cause.
Unconditionally fails this test with the given message and exception marked as the cause.

Definition Classes
Assertions
def failComparison(message: String, obtained: Any, expected: Any, clues: Clues = new Clues(Nil))(implicit loc: Location): Nothing

Unconditionally fails this test due to result of comparing two values.
Unconditionally fails this test due to result of comparing two values.
The only reason to use this method instead of fail() is if you want to allow comparing the two different values in the the IntelliJ GUI diff viewer.

Definition Classes
Assertions
def failSuite(message: String, clues: Clues = new Clues(Nil))(implicit loc: Location): Nothing

Unconditionally fail this test case and cancel all the subsequent tests in this suite.
Unconditionally fail this test case and cancel all the subsequent tests in this suite.

Definition Classes
Assertions
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def intercept[T <: Throwable](body: ⇒ Any)(implicit T: ClassTag[T], loc: Location): T

Evalutes the given expression and asserts that an exception of type T is thrown.
Evalutes the given expression and asserts that an exception of type T is thrown.

Definition Classes
Assertions
def interceptMessage[T <: Throwable](expectedExceptionMessage: String)(body: ⇒ Any)(implicit T: ClassTag[T], loc: Location): T

Evalutes the given expression and asserts that an exception of type T with the expected message is thrown.
Evalutes the given expression and asserts that an exception of type T with the expected message is thrown.

Definition Classes
Assertions
def isCI: Boolean

Definition Classes
SuiteTransforms
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def munitAnsiColors: Boolean

Definition Classes
Assertions
def munitCaptureClues[T](thunk: ⇒ T): (T, Clues)

Definition Classes
Assertions
def munitExecutionContext: ExecutionContext

Definition Classes
Suite
final def munitFailTransform: TestTransform

Definition Classes
TestTransforms
def munitFixtures: Seq[AnyFixture[_]]

Fixtures that can be reused for individual test cases or entire suites.
Fixtures that can be reused for individual test cases or entire suites.

Definition Classes
Suite
def munitFlakyOK: Boolean

Definition Classes
TestTransforms
final def munitFlakyTransform: TestTransform

Definition Classes
TestTransforms
final def munitFutureTransform: ValueTransform

Definition Classes
ValueTransforms
def munitIgnore: Boolean

Definition Classes
SuiteTransforms
final def munitIgnoreSuiteTransform: SuiteTransform

Definition Classes
SuiteTransforms
val munitLines: Lines

Definition Classes
Assertions
final def munitOnlySuiteTransform: SuiteTransform

Definition Classes
SuiteTransforms
def munitPrint(clue: ⇒ Any): String

Definition Classes
Assertions
final def munitSuiteTransform(tests: List[Test]): List[Test]

Definition Classes
SuiteTransforms
def munitSuiteTransforms: List[SuiteTransform]

Definition Classes
SuiteTransforms
final def munitTestTransform(test: Test): Test

Definition Classes
TestTransforms
def munitTestTransforms: List[TestTransform]

Definition Classes
TestTransforms
def munitTests(): Seq[Test]

The base class for all test suites
The base class for all test suites

Definition Classes
BaseFunSuite → Suite
final val munitTestsBuffer: ListBuffer[Test]

Definition Classes
BaseFunSuite
def munitTimeout: Duration

Definition Classes
BaseFunSuite
final def munitValueTransform(testValue: ⇒ Any): Future[Any]

Definition Classes
ValueTransforms
def munitValueTransforms: List[ValueTransform]

Definition Classes
ValueTransforms
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def test(options: TestOptions)(body: ⇒ Any)(implicit loc: Location): Unit

Definition Classes
BaseFunSuite
def test(name: String)(body: ⇒ Any)(implicit loc: Location): Unit

Definition Classes
BaseFunSuite
implicit def testOptionsFromString(name: String)(implicit loc: Location): TestOptions

Implicitly create a TestOptions given a test name.
Implicitly create a TestOptions given a test name. This allows writing test("name") { ... } even if test accepts a TestOptions

Definition Classes
TestOptionsConversions
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package munit

abstract class FunSuite extends Suite with BaseFunSuite

Instance Constructors

new FunSuite()

Type Members

final type AfterEach = munit.AfterEach

final type BeforeEach = munit.BeforeEach

final type Fixture[T] = munit.Fixture[T]

class FunFixture[T] extends AnyRef

final class SuiteTransform extends (List[BaseFunSuite.Test]) ⇒ List[BaseFunSuite.Test]

final type Test = munit.Test

final class TestTransform extends (BaseFunSuite.Test) ⇒ BaseFunSuite.Test

final type TestValue = Future[Any]

final class ValueTransform extends (Any) ⇒ Option[Future[Any]]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object FunFixture

def afterAll(): Unit

def afterEach(context: AfterEach): Unit

final def asInstanceOf[T0]: T0

def assert(cond: ⇒ Boolean, clue: ⇒ Any = "assertion failed")(implicit loc: Location): Unit

def assertEquals[A, B](obtained: A, expected: B, clue: ⇒ Any = "values are not the same")(implicit loc: Location, compare: Compare[A, B]): Unit

def assertEqualsDouble(obtained: Double, expected: Double, delta: Double, clue: ⇒ Any = "values are not the same")(implicit loc: Location): Unit

def assertEqualsFloat(obtained: Float, expected: Float, delta: Float, clue: ⇒ Any = "values are not the same")(implicit loc: Location): Unit

def assertNoDiff(obtained: String, expected: String, clue: ⇒ Any = "diff assertion failed")(implicit loc: Location): Unit

def assertNotEquals[A, B](obtained: A, expected: B, clue: ⇒ Any = "values are the same")(implicit loc: Location, compare: Compare[A, B]): Unit

def assume(cond: Boolean, clue: ⇒ Any = "assumption failed")(implicit loc: Location): Unit

def beforeAll(): Unit

def beforeEach(context: BeforeEach): Unit

def clone(): AnyRef

def clue[T](c: Clue[T]): T

def clues(clue: Clue[_]*): Clues

macro def compileErrors(code: String): String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail(message: String, clues: Clues = new Clues(Nil))(implicit loc: Location): Nothing

def fail(message: String, cause: Throwable)(implicit loc: Location): Nothing

def failComparison(message: String, obtained: Any, expected: Any, clues: Clues = new Clues(Nil))(implicit loc: Location): Nothing

def failSuite(message: String, clues: Clues = new Clues(Nil))(implicit loc: Location): Nothing

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def intercept[T <: Throwable](body: ⇒ Any)(implicit T: ClassTag[T], loc: Location): T

def interceptMessage[T <: Throwable](expectedExceptionMessage: String)(body: ⇒ Any)(implicit T: ClassTag[T], loc: Location): T

def isCI: Boolean

final def isInstanceOf[T0]: Boolean

def munitAnsiColors: Boolean

def munitCaptureClues[T](thunk: ⇒ T): (T, Clues)

def munitExecutionContext: ExecutionContext

final def munitFailTransform: TestTransform

def munitFixtures: Seq[AnyFixture[_]]

def munitFlakyOK: Boolean

final def munitFlakyTransform: TestTransform

final def munitFutureTransform: ValueTransform

def munitIgnore: Boolean

final def munitIgnoreSuiteTransform: SuiteTransform

val munitLines: Lines

final def munitOnlySuiteTransform: SuiteTransform

def munitPrint(clue: ⇒ Any): String

final def munitSuiteTransform(tests: List[Test]): List[Test]

def munitSuiteTransforms: List[SuiteTransform]

final def munitTestTransform(test: Test): Test

def munitTestTransforms: List[TestTransform]

def munitTests(): Seq[Test]

final val munitTestsBuffer: ListBuffer[Test]

def munitTimeout: Duration

final def munitValueTransform(testValue: ⇒ Any): Future[Any]

def munitValueTransforms: List[ValueTransform]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def test(options: TestOptions)(body: ⇒ Any)(implicit loc: Location): Unit

def test(name: String)(body: ⇒ Any)(implicit loc: Location): Unit

implicit def testOptionsFromString(name: String)(implicit loc: Location): TestOptions

def toString(): String

final def wait(): Unit