package org.junit.tests.experimental;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeNoException;
import static org.junit.Assume.assumeNotNull;
import static org.junit.Assume.assumeThat;
import static org.junit.Assume.assumeTrue;
import static org.junit.experimental.results.PrintableResult.testResult;
import static org.junit.experimental.results.ResultMatchers.isSuccessful;
import java.util.ArrayList;
import java.util.List;
import org.junit.Assume;
import org.junit.AssumptionViolatedException;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
import org.junit.runner.notification.RunListener;
public class AssumptionTest {
public static class HasFailingAssumption {
@Test
public void assumptionsFail() {
assumeThat(3, is(4));
fail();
}
}
@Test
public void failedAssumptionsMeanPassing() {
Result result = JUnitCore.runClasses(HasFailingAssumption.class);
assertThat(result.getRunCount(), is(1));
assertThat(result.getIgnoreCount(), is(0));
assertThat(result.getFailureCount(), is(0));
}
private static int assumptionFailures = 0;
@Test
public void failedAssumptionsCanBeDetectedByListeners() {
assumptionFailures = 0;
JUnitCore core = new JUnitCore();
core.addListener(new RunListener() {
@Override
public void testAssumptionFailure(Failure failure) {
assumptionFailures++;
}
});
core.run(HasFailingAssumption.class);
assertThat(assumptionFailures, is(1));
}
public static class HasPassingAssumption {
@Test
public void assumptionsFail() {
assumeThat(3, is(3));
fail();
}
}
@Test
public void passingAssumptionsScootThrough() {
Result result = JUnitCore.runClasses(HasPassingAssumption.class);
assertThat(result.getRunCount(), is(1));
assertThat(result.getIgnoreCount(), is(0));
assertThat(result.getFailureCount(), is(1));
}
@Test(expected = AssumptionViolatedException.class)
public void assumeThatWorks() {
assumeThat(1, is(2));
}
@Test
public void assumeThatPasses() {
assumeThat(1, is(1));
assertCompletesNormally();
}
@Test
public void assumeThatPassesOnStrings() {
assumeThat("x", is("x"));
assertCompletesNormally();
}
@Test(expected = AssumptionViolatedException.class)
public void assumeNotNullThrowsException() {
Object[] objects = {1, 2, null};
assumeNotNull(objects);
}
@Test
public void assumeNotNullPasses() {
Object[] objects = {1, 2};
assumeNotNull(objects);
assertCompletesNormally();
}
@Test
public void assumeNotNullIncludesParameterList() {
try {
Object[] objects = {1, 2, null};
assumeNotNull(objects);
} catch (AssumptionViolatedException e) {
assertThat(e.getMessage(), containsString("1, 2, null"));
} catch (Exception e) {
fail("Should have thrown AssumptionViolatedException");
}
}
@Test
public void assumeNoExceptionThrows() {
final Throwable exception = new NullPointerException();
try {
assumeNoException(exception);
fail("Should have thrown exception");
} catch (AssumptionViolatedException e) {
assertThat(e.getCause(), is(exception));
}
}
private void assertCompletesNormally() {
}
@Test(expected = AssumptionViolatedException.class)
public void assumeTrueWorks() {
Assume.assumeTrue(false);
}
public static class HasFailingAssumeInBefore {
@Before
public void checkForSomethingThatIsntThere() {
assumeTrue(false);
}
@Test
public void failing() {
fail();
}
}
@Test
public void failingAssumptionInBeforePreventsTestRun() {
assertThat(testResult(HasFailingAssumeInBefore.class), isSuccessful());
}
public static class HasFailingAssumeInBeforeClass {
@BeforeClass
public static void checkForSomethingThatIsntThere() {
assumeTrue(false);
}
@Test
public void failing() {
fail();
}
}
@Test
public void failingAssumptionInBeforeClassIgnoresClass() {
assertThat(testResult(HasFailingAssumeInBeforeClass.class), isSuccessful());
}
public static class AssumptionFailureInConstructor {
public AssumptionFailureInConstructor() {
assumeTrue(false);
}
@Test
public void shouldFail() {
fail();
}
}
@Test
public void failingAssumptionInConstructorIgnoresClass() {
assertThat(testResult(AssumptionFailureInConstructor.class), isSuccessful());
}
@Test(expected = IllegalArgumentException.class)
public void assumeWithExpectedException() {
assumeTrue(false);
}
final static String message = "Some random message string.";
final static Throwable e = new Throwable();
/**
* @see AssumptionTest#assumptionsWithMessage()
*/
public static class HasAssumeWithMessage {
@Test
public void testMethod() {
assumeTrue(message, false);
}
}
@Test
public void assumptionsWithMessage() {
final List<Failure> failures =
runAndGetAssumptionFailures(HasAssumeWithMessage.class);
assertTrue(failures.get(0).getMessage().contains(message));
}
/**
* @see AssumptionTest#assumptionsWithMessageAndCause()
*/
public static class HasAssumeWithMessageAndCause {
@Test
public void testMethod() {
assumeNoException(message, e);
}
}
@Test
public void assumptionsWithMessageAndCause() {
final List<Failure> failures =
runAndGetAssumptionFailures(HasAssumeWithMessageAndCause.class);
assertTrue(failures.get(0).getMessage().contains(message));
assertSame(failures.get(0).getException().getCause(), e);
}
public static class HasFailingAssumptionWithMessage {
@Test
public void assumptionsFail() {
assumeThat(message, 3, is(4));
fail();
}
}
@Test
public void failedAssumptionsWithMessage() {
final List<Failure> failures =
runAndGetAssumptionFailures(HasFailingAssumptionWithMessage.class);
assertEquals(failures.size(), 1);
assertTrue(failures.get(0).getMessage().contains(message));
}
/**
* Helper method that runs tests on <code>clazz</code> and returns any
* {@link Failure} objects that were {@link AssumptionViolatedException}s.
*/
private static List<Failure> runAndGetAssumptionFailures(Class<?> clazz) {
final List<Failure> failures = new ArrayList<Failure>();
final JUnitCore core = new JUnitCore();
core.addListener(new RunListener() {
@Override
public void testAssumptionFailure(Failure failure) {
failures.add(failure);
}
});
core.run(clazz);
return failures;
}
}