Enum `TestCaseError`

enum TestCaseError

Errors which can be returned from test cases to indicate non-successful completion.

Note that in spite of the name, TestCaseError is currently not an instance of Error, since otherwise impl<E : Error> From<E> could not be provided.

Any Error can be converted to a TestCaseError, which places Error::display() into the Fail case.

Variants

Reject(crate::test_runner::Reason): The input was not valid for the test case. This does not count as a test failure (nor a success); rather, it simply signals to generate a new input and try again.
Fail(crate::test_runner::Reason): The code under test failed the test.

Implementations

`impl TestCaseError`

fn reject<impl Into<Reason>: Into<Reason>>(reason: impl Into<Reason>) -> Self

Rejects the generated test input as invalid for this test case. This does not count as a test failure (nor a success); rather, it simply signals to generate a new input and try again.

The string gives the location and context of the rejection, and should be suitable for formatting like Foo did X at {whence}.

fn fail<impl Into<Reason>: Into<Reason>>(reason: impl Into<Reason>) -> Self

The code under test failed the test.

The string should indicate the location of the failure, but may generally be any string.

`impl Clone for TestCaseError`

fn clone(self: &Self) -> TestCaseError

`impl Debug for TestCaseError`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

`impl Display for TestCaseError`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

`impl Freeze for TestCaseError`

`impl RefUnwindSafe for TestCaseError`

`impl Send for TestCaseError`

`impl Sync for TestCaseError`

`impl Unpin for TestCaseError`

`impl UnsafeUnpin for TestCaseError`

`impl UnwindSafe for TestCaseError`

`impl<E: ::std::error::Error> From for TestCaseError`

fn from(cause: E) -> Self

`impl<T> Any for TestCaseError`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for TestCaseError`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for TestCaseError`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for TestCaseError`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for TestCaseError`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> From for TestCaseError`

fn from(t: never) -> T

`impl<T> ToOwned for TestCaseError`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T> ToString for TestCaseError`

fn to_string(self: &Self) -> String

`impl<T, U> Into for TestCaseError`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for TestCaseError`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for TestCaseError`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

`impl<V, T> VZip for TestCaseError`

fn vzip(self: Self) -> V