Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2015-2020 the original author or authors.
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v2.0 which
* accompanies this distribution and is available at
*
* https://www.eclipse.org/legal/epl-v20.html
*/
@file:API(status = STABLE, since = "5.7")
package org.junit.jupiter.api
import java.time.Duration
import java.util.function.Supplier
import java.util.stream.Stream
import org.apiguardian.api.API
import org.apiguardian.api.API.Status.EXPERIMENTAL
import org.apiguardian.api.API.Status.STABLE
import org.junit.jupiter.api.function.Executable
import org.junit.jupiter.api.function.ThrowingSupplier
/**
* @see Assertions.fail
*/
fun fail(message: String?, throwable: Throwable? = null): Nothing =
Assertions.fail(message, throwable)
/**
* @see Assertions.fail
*/
fun fail(message: (() -> String)?): Nothing =
Assertions.fail(message)
/**
* @see Assertions.fail
*/
fun fail(throwable: Throwable?): Nothing =
Assertions.fail(throwable)
/**
* [Stream] of functions to be executed.
*/
private typealias ExecutableStream = Stream<() -> Unit>
private fun ExecutableStream.convert() = map { Executable(it) }
/**
* @see Assertions.assertAll
*/
fun assertAll(executables: ExecutableStream) =
Assertions.assertAll(executables.convert())
/**
* @see Assertions.assertAll
*/
fun assertAll(heading: String?, executables: ExecutableStream) =
Assertions.assertAll(heading, executables.convert())
/**
* [Collection] of functions to be executed.
*/
private typealias ExecutableCollection = Collection<() -> Unit>
private fun ExecutableCollection.convert() = map { Executable(it) }
/**
* @see Assertions.assertAll
*/
fun assertAll(executables: ExecutableCollection) =
Assertions.assertAll(executables.convert())
/**
* @see Assertions.assertAll
*/
fun assertAll(heading: String?, executables: ExecutableCollection) =
Assertions.assertAll(heading, executables.convert())
/**
* @see Assertions.assertAll
*/
fun assertAll(vararg executables: () -> Unit) =
assertAll(executables.toList().stream())
/**
* @see Assertions.assertAll
*/
fun assertAll(heading: String?, vararg executables: () -> Unit) =
assertAll(heading, executables.toList().stream())
/**
* Example usage:
* ```kotlin
* val exception = assertThrows {
* throw IllegalArgumentException("Talk to a duck")
* }
* assertEquals("Talk to a duck", exception.message)
* ```
* @see Assertions.assertThrows
*/
inline fun assertThrows(executable: () -> Unit): T {
val throwable: Throwable? = try {
executable()
} catch (caught: Throwable) {
caught
} as? Throwable
return Assertions.assertThrows(T::class.java) {
if (throwable != null) {
throw throwable
}
}
}
/**
* Example usage:
* ```kotlin
* val exception = assertThrows("Should throw an Exception") {
* throw IllegalArgumentException("Talk to a duck")
* }
* assertEquals("Talk to a duck", exception.message)
* ```
* @see Assertions.assertThrows
*/
inline fun assertThrows(message: String, executable: () -> Unit): T =
assertThrows({ message }, executable)
/**
* Example usage:
* ```kotlin
* val exception = assertThrows({ "Should throw an Exception" }) {
* throw IllegalArgumentException("Talk to a duck")
* }
* assertEquals("Talk to a duck", exception.message)
* ```
* @see Assertions.assertThrows
*/
inline fun assertThrows(noinline message: () -> String, executable: () -> Unit): T {
val throwable: Throwable? = try {
executable()
} catch (caught: Throwable) {
caught
} as? Throwable
return Assertions.assertThrows(T::class.java, Executable {
if (throwable != null) {
throw throwable
}
}, Supplier(message))
}
/**
* Example usage:
* ```kotlin
* val result = assertDoesNotThrow {
* // Code block that is expected to not throw an exception
* }
* ```
* @see Assertions.assertDoesNotThrow
* @param R the result type of the [executable]
*/
@API(status = EXPERIMENTAL, since = "5.5")
fun assertDoesNotThrow(executable: () -> R): R =
Assertions.assertDoesNotThrow(ThrowingSupplier(executable))
/**
* Example usage:
* ```kotlin
* val result = assertDoesNotThrow("Should not throw an exception") {
* // Code block that is expected to not throw an exception
* }
* ```
* @see Assertions.assertDoesNotThrow
* @param R the result type of the [executable]
*/
@API(status = EXPERIMENTAL, since = "5.5")
fun assertDoesNotThrow(message: String, executable: () -> R): R =
assertDoesNotThrow({ message }, executable)
/**
* Example usage:
* ```kotlin
* val result = assertDoesNotThrow({ "Should not throw an exception" }) {
* // Code block that is expected to not throw an exception
* }
* ```
* @see Assertions.assertDoesNotThrow
* @param R the result type of the [executable]
*/
@API(status = EXPERIMENTAL, since = "5.5")
fun assertDoesNotThrow(message: () -> String, executable: () -> R): R =
Assertions.assertDoesNotThrow(ThrowingSupplier(executable), Supplier(message))
/**
* Example usage:
* ```kotlin
* val result = assertTimeout(Duration.seconds(1)) {
* // Code block that is being timed.
* }
* ```
* @see Assertions.assertTimeout
* @paramR the result of the [executable].
*/
@API(status = EXPERIMENTAL, since = "5.5")
fun assertTimeout(timeout: Duration, executable: () -> R): R =
Assertions.assertTimeout(timeout, executable)
/**
* Example usage:
* ```kotlin
* val result = assertTimeout(Duration.seconds(1), "Should only take one second") {
* // Code block that is being timed.
* }
* ```
* @see Assertions.assertTimeout
* @paramR the result of the [executable].
*/
@API(status = EXPERIMENTAL, since = "5.5")
fun assertTimeout(timeout: Duration, message: String, executable: () -> R): R =
Assertions.assertTimeout(timeout, executable, message)
/**
* Example usage:
* ```kotlin
* val result = assertTimeout(Duration.seconds(1), { "Should only take one second" }) {
* // Code block that is being timed.
* }
* ```
* @see Assertions.assertTimeout
* @paramR the result of the [executable].
*/
@API(status = EXPERIMENTAL, since = "5.5")
fun assertTimeout(timeout: Duration, message: () -> String, executable: () -> R): R =
Assertions.assertTimeout(timeout, executable, message)
/**
* Example usage:
* ```kotlin
* val result = assertTimeoutPreemptively(Duration.seconds(1)) {
* // Code block that is being timed.
* }
* ```
* @see Assertions.assertTimeoutPreemptively
* @paramR the result of the [executable].
*/
@API(status = EXPERIMENTAL, since = "5.5")
fun assertTimeoutPreemptively(timeout: Duration, executable: () -> R): R =
Assertions.assertTimeoutPreemptively(timeout, executable)
/**
* Example usage:
* ```kotlin
* val result = assertTimeoutPreemptively(Duration.seconds(1), "Should only take one second") {
* // Code block that is being timed.
* }
* ```
* @see Assertions.assertTimeoutPreemptively
* @paramR the result of the [executable].
*/
@API(status = EXPERIMENTAL, since = "5.5")
fun assertTimeoutPreemptively(timeout: Duration, message: String, executable: () -> R): R =
Assertions.assertTimeoutPreemptively(timeout, executable, message)
/**
* Example usage:
* ```kotlin
* val result = assertTimeoutPreemptively(Duration.seconds(1), { "Should only take one second" }) {
* // Code block that is being timed.
* }
* ```
* @see Assertions.assertTimeoutPreemptively
* @paramR the result of the [executable].
*/
@API(status = EXPERIMENTAL, since = "5.5")
fun assertTimeoutPreemptively(timeout: Duration, message: () -> String, executable: () -> R): R =
Assertions.assertTimeoutPreemptively(timeout, executable, message)
