static void fail(String message, Object expected, Object actual) { throw new AssertionFailedError(message, expected, actual); }
private static void throwTestAbortedException(String message) { throw new TestAbortedException( StringUtils.isNotBlank(message) ? ("Assumption failed: " + message) : "Assumption failed"); }
TestExecutionResult getStoredResultOrSuccessful(TestDescriptor testDescriptor) { List<TestExecutionResult> testExecutionResults = executionResults.get(testDescriptor); if (testExecutionResults == null) { return successful(); } if (testExecutionResults.size() == 1) { return testExecutionResults.get(0); } // @formatter:off List<Throwable> failures = testExecutionResults .stream() .map(TestExecutionResult::getThrowable) .map(Optional::get) .collect(toList()); // @formatter:on return failed(new MultipleFailuresError("", failures)); } }
/** * Constructs an {@code AssertionFailedError} with a message, * expected/actual values, and a cause. * * @param message the detail message; {@code null} or blank will be * converted to the empty {@code String} because the {@link AssertionError} * superclass does not support {@code null} messages. */ public AssertionFailedError(String message, Object expected, Object actual, Throwable cause) { this(message, ValueWrapper.create(expected), ValueWrapper.create(actual), cause); }
/** * Factory for creating a new {@code ValueWrapper} for the supplied {@code value}. * * <p>If the supplied {@code value} is {@code null}, this method will return a * cached {@code ValueWrapper} suitable for all null values. * * @param value the value to wrap * @return a wrapper for the supplied value */ public static ValueWrapper create(Object value) { return (value == null ? nullValueWrapper : new ValueWrapper(value)); }
private AssertionFailedError(String message, ValueWrapper expected, ValueWrapper actual, Throwable cause) { super((message == null || message.trim().length() == 0) ? "" : message); this.expected = expected; this.actual = actual; initCause(cause); }
static void fail() { throw new AssertionFailedError(); }
private static void throwTestAbortedException(String message) { throw new TestAbortedException( StringUtils.isNotBlank(message) ? ("Assumption failed: " + message) : "Assumption failed"); }
static void assertAll(String heading, Stream<Executable> executables) { Preconditions.notNull(executables, "executables stream must not be null"); List<Throwable> failures = executables // .peek(executable -> Preconditions.notNull(executable, "individual executables must not be null"))// .map(executable -> { try { executable.execute(); return null; } catch (Throwable t) { BlacklistedExceptions.rethrowIfBlacklisted(t); return t; } }) // .filter(Objects::nonNull) // .collect(Collectors.toList()); if (!failures.isEmpty()) { MultipleFailuresError multipleFailuresError = new MultipleFailuresError(heading, failures); failures.forEach(multipleFailuresError::addSuppressed); throw multipleFailuresError; } }
static void fail(String message) { throw new AssertionFailedError(message); }
@Example void testAbortMakesCheckExhausted() { RuntimeException toThrow = new TestAbortedException("test"); intOnlyExample("prop0", params -> { throw toThrow; }, EXHAUSTED); intOnlyExample("prop8", params -> { throw toThrow; }, EXHAUSTED); }
static void fail(String message, Throwable cause) { throw new AssertionFailedError(message, cause); }
static void fail(Throwable cause) { throw new AssertionFailedError(null, cause); }
static void fail(Supplier<String> messageSupplier) { throw new AssertionFailedError(nullSafeGet(messageSupplier)); }
@Override public void handleTestExecutionException( ExtensionContext context, Throwable t ) { if ( t instanceof TestAbortedException ) { return; } final long seed = getStoredValue( context ).seed(); // The reason we throw a new exception wrapping the actual exception here, instead of simply enhancing the message is: // - AssertionFailedError has its own 'message' field, in addition to Throwable's 'detailedMessage' field // - Even if 'message' field is updated the test doesn't seem to print the updated message on assertion failure throw new AssertionFailedError( format( "%s [ random seed used: %dL ]", t.getMessage(), seed ), t ); } }
private static AssertionFailedError createAssertionFailedError(Object messageOrSupplier, Throwable t) { String message = buildPrefix(nullSafeGet(messageOrSupplier)) + "Unexpected exception thrown: " + t.getClass().getName() + buildSuffix(t.getMessage()); return new AssertionFailedError(message, t); }
@SuppressWarnings("unchecked") private static <T extends Throwable> T assertThrows(Class<T> expectedType, Executable executable, Object messageOrSupplier) { try { executable.execute(); } catch (Throwable actualException) { if (expectedType.isInstance(actualException)) { return (T) actualException; } else { BlacklistedExceptions.rethrowIfBlacklisted(actualException); String message = buildPrefix(nullSafeGet(messageOrSupplier)) + format(expectedType, actualException.getClass(), "Unexpected exception type thrown"); throw new AssertionFailedError(message, actualException); } } String message = buildPrefix(nullSafeGet(messageOrSupplier)) + String.format("Expected %s to be thrown, but nothing was thrown.", getCanonicalName(expectedType)); throw new AssertionFailedError(message); }
throw new AssertionFailedError(buildPrefix(nullSafeGet(messageOrSupplier)) + "execution timed out after " + timeoutInMillis + " ms");
Throwable exception = listener.exceptions.get(0); if (!(exception instanceof AssertionFailedError)) { throw new AssertionFailedError( exception.getClass().getName() + " is not an instance of " + AssertionFailedError.class.getName(), exception);
/** * <em>Fails</em> a test with a given {@code message}. */ public static void fail(String message) { throw new AssertionFailedError(message); }