HedgehogSuite

Runs a hedgehog property-based test.

Alias for Result.Failure

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

Runs after each individual test case.

Alias for Result.all

Alias for Result.any

Fails the test with a failure Result when cond is false.

Fails the test if obtained and expected are non-equal using ==.

Asserts that two elements are equal using == equality.

The "expected" value (second argument) must have the same type or be a subtype of the "obtained" value (first argument). For example:

 assertEquals(Option(1), Some(1)) // OK
 assertEquals(Some(1), Option(1)) // Error: Option[Int] is not a subtype of Some[Int]

Use assertEquals[Any, Any](a, b) as an escape hatch to compare two values of different types. For example:

 val a: Either[List[String], Int] = Right(42)
 val b: Either[String, Int]       = Right(42)
 assertEquals[Any, Any](a, b) // OK
 assertEquals(a, b) // Error: Either[String, Int] is not a subtype of Either[List[String], Int]

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.

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.

Asserts two strings are equal.

Asserts two values are nonequal.

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

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

Alias for Result.diff

Asserts two doubles are equal +- some erorr value.

Float specialized version of HedgehogAssertions.assertEquals.

Asserts two floats are equal within +- some error value.

Alias for Result.diffNamed

Alias for Result.error

Fails a test with the given message

Fails a test.

Analagous to munit.Assertions.fail.

Alias for Result.failure

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

Alias for Result.success

Turns off hedgehog munit-like assertions, so users can use both property- and non-property- based-tests in their test suites. By using the passed assertions parameter, all the standard munit assertions that do not return unit are available, despite name ambiguities.

==Usage==

 test("1 + 1 is 2"){
   withMunitAssertions{ assertions =>
     assertEquals(1 + 1, 2)
   }
 }

Fails the test with a failure Result when cond is false.

Analagous to munit.Assertions.assert.

Only the condition is used. Clues are ignored.

Fails the test if obtained and expected are non-equal using ==.

Analagous to munit.Assertions.assert.

Only the obtained and expected values are used.

Double specialized version of HedgehogAssertions.assertEquals.

Asserts two double values are equal +- some error value.

Analagous to munit.Assertions.assertEqualsDouble.

Only the obtained, expected and delta parameters are used.

Float specialized version of assertEquals.

Asserts two floats are equal within +- some error value.

Analagous to munit.Assertions.assertEqualsFloat.

Asserts two strings are equal without outputting a diff.

Analagous to munit.Assertions.assertNoDiff.

Asserts obtained is not equal to expected using ==.

Analagous to munit.Assertions.notEquals.

Alias for Result.Success

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