google3/third_party/java_src/junit/test/java/org/junit/AssumptionViolatedExceptionTest.java

package org.junit;

import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsNot.not;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assume.assumeThat;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.StringDescription;
import org.junit.experimental.theories.DataPoint;
import org.junit.experimental.theories.Theories;
import org.junit.experimental.theories.Theory;
import org.junit.rules.TestName;
import org.junit.runner.RunWith;

@RunWith(Theories.class)
public class AssumptionViolatedExceptionTest {
    @DataPoint
    public static Integer TWO = 2;

    @DataPoint
    public static Matcher<Integer> IS_THREE = is(3);

    @DataPoint
    public static Matcher<Integer> NULL = null;

    @Rule
    public TestName name = new TestName();

    private static final String MESSAGE = "Assumption message";
    private static Matcher<Integer> SERIALIZABLE_IS_THREE = new SerializableIsThreeMatcher<Integer>();
    private static final UnserializableClass UNSERIALIZABLE_VALUE = new UnserializableClass();
    private static final Matcher<UnserializableClass> UNSERIALIZABLE_MATCHER = not(is(UNSERIALIZABLE_VALUE));

    @Theory
    public void toStringReportsMatcher(Integer actual, Matcher<Integer> matcher) {
        assumeThat(matcher, notNullValue());
        assertThat(new AssumptionViolatedException(actual, matcher).toString(),
                containsString(matcher.toString()));
    }

    @Theory
    public void toStringReportsValue(Integer actual, Matcher<Integer> matcher) {
        assertThat(new AssumptionViolatedException(actual, matcher).toString(),
                containsString(String.valueOf(actual)));
    }

    @Test
    public void assumptionViolatedExceptionWithMatcherDescribesItself() {
        AssumptionViolatedException e = new AssumptionViolatedException(3, is(2));
        assertThat(StringDescription.asString(e), is("got: <3>, expected: is <2>"));
    }

    @Test
    public void simpleAssumptionViolatedExceptionDescribesItself() {
        AssumptionViolatedException e = new AssumptionViolatedException("not enough money");
        assertThat(StringDescription.asString(e), is("not enough money"));
    }

    @Test
    public void canInitCauseWithInstanceCreatedWithString() {
      AssumptionViolatedException e = new AssumptionViolatedException("invalid number");
      Throwable cause = new RuntimeException("cause");
      e.initCause(cause);
      assertThat(e.getCause(), is(cause));
    }

    @Test
    @SuppressWarnings("deprecation")
    public void canSetCauseWithInstanceCreatedWithObjectAndMatcher() {
      Throwable testObject = new Exception();
      org.junit.internal.AssumptionViolatedException e
              = new org.junit.internal.AssumptionViolatedException(
                      testObject, containsString("test matcher"));
      assertThat(e.getCause(), is(testObject));
    }

    @Test
    @SuppressWarnings("deprecation")
    public void canSetCauseWithInstanceCreatedWithAssumptionObjectAndMatcher() {
      Throwable testObject = new Exception();
      org.junit.internal.AssumptionViolatedException e
              = new org.junit.internal.AssumptionViolatedException(
                      "sample assumption", testObject, containsString("test matcher"));
      assertThat(e.getCause(), is(testObject));
    }

    @Test
    @SuppressWarnings("deprecation")
    public void canSetCauseWithInstanceCreatedWithMainConstructor() {
      Throwable testObject = new Exception();
      org.junit.internal.AssumptionViolatedException e
              = new org.junit.internal.AssumptionViolatedException(
                      "sample assumption", false, testObject, containsString("test matcher"));
      assertThat(e.getCause(), is(testObject));
    }

    @Test
    public void canSetCauseWithInstanceCreatedWithExplicitThrowableConstructor() {
      Throwable cause = new Exception();
      AssumptionViolatedException e = new AssumptionViolatedException("invalid number", cause);
      assertThat(e.getCause(), is(cause));
    }

    @Test
    public void assumptionViolatedExceptionWithoutValueAndMatcherCanBeReserialized_v4_13()
            throws IOException, ClassNotFoundException {
        assertReserializable(new AssumptionViolatedException(MESSAGE));
    }

    @Test
    public void assumptionViolatedExceptionWithValueAndMatcherCanBeReserialized_v4_13()
            throws IOException, ClassNotFoundException {
        assertReserializable(new AssumptionViolatedException(MESSAGE, TWO, SERIALIZABLE_IS_THREE));
    }

    @Test
    public void unserializableValueAndMatcherCanBeSerialized() throws IOException, ClassNotFoundException {
        AssumptionViolatedException exception = new AssumptionViolatedException(MESSAGE,
                UNSERIALIZABLE_VALUE, UNSERIALIZABLE_MATCHER);

        assertCanBeSerialized(exception);
    }

    @Test
    public void nullValueAndMatcherCanBeSerialized() throws IOException, ClassNotFoundException {
        AssumptionViolatedException exception = new AssumptionViolatedException(MESSAGE);

        assertCanBeSerialized(exception);
    }

    @Test
    public void serializableValueAndMatcherCanBeSerialized() throws IOException, ClassNotFoundException {
        AssumptionViolatedException exception = new AssumptionViolatedException(MESSAGE,
                TWO, SERIALIZABLE_IS_THREE);

        assertCanBeSerialized(exception);
    }

    private void assertCanBeSerialized(AssumptionViolatedException exception)
            throws IOException, ClassNotFoundException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(exception);

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);
        AssumptionViolatedException fromStream = (AssumptionViolatedException) ois.readObject();

        assertSerializedCorrectly(exception, fromStream);
    }

    private void assertReserializable(AssumptionViolatedException expected)
            throws IOException, ClassNotFoundException {
        String resourceName = name.getMethodName();
        InputStream resource = getClass().getResourceAsStream(resourceName);
        assertNotNull("Could not read resource " + resourceName, resource);
        ObjectInputStream objectInputStream = new ObjectInputStream(resource);
        AssumptionViolatedException fromStream = (AssumptionViolatedException) objectInputStream.readObject();

        assertSerializedCorrectly(expected, fromStream);
    }

    private void assertSerializedCorrectly(
            AssumptionViolatedException expected, AssumptionViolatedException fromStream) {
        assertNotNull(fromStream);

        // Exceptions don't implement equals() so we need to compare field by field
        assertEquals("message", expected.getMessage(), fromStream.getMessage());
        assertEquals("description", StringDescription.asString(expected), StringDescription.asString(fromStream));
        // We don't check the stackTrace as that will be influenced by how the test was started
        // (e.g. by maven or directly from IDE)
        // We also don't check the cause as that should already be serialized correctly by the superclass
    }

    private static class SerializableIsThreeMatcher<T> extends BaseMatcher<T> implements Serializable {

        public boolean matches(Object item) {
            return IS_THREE.matches(item);
        }

        public void describeTo(Description description) {
            IS_THREE.describeTo(description);
        }
    }

    private static class UnserializableClass {
        @Override
        public String toString() {
            return "I'm not serializable";
        }
    }
}