package org.junit.tests.experimental.theories.runner;
import static org.junit.Assert.assertThat;
import static org.junit.experimental.results.PrintableResult.testResult;
import static org.junit.experimental.results.ResultMatchers.failureCountIs;
import static org.junit.experimental.results.ResultMatchers.hasFailureContaining;
import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining;
import static org.junit.experimental.results.ResultMatchers.isSuccessful;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.junit.experimental.results.PrintableResult;
import org.junit.experimental.theories.DataPoint;
import org.junit.experimental.theories.DataPoints;
import org.junit.experimental.theories.Theories;
import org.junit.experimental.theories.Theory;
import org.junit.runner.RunWith;
public class WithUnresolvedGenericTypeVariablesOnTheoryParms {
@Test
public void whereTypeVariableIsOnTheTheory() {
PrintableResult result = testResult(TypeVariableOnTheoryOnly.class);
assertThat(result, isSuccessful());
}
@RunWith(Theories.class)
public static class TypeVariableOnTheoryOnly {
@DataPoint
public static List<String> strings = Arrays.asList("foo", "bar");
@Theory
public <T> void forItems(Collection<?> items) {
}
}
@Test
public void whereTypeVariableIsOnTheoryParm() {
PrintableResult result = testResult(TypeVariableOnTheoryParm.class);
assertThat(result, hasSingleFailureContaining("unresolved type variable T"));
}
@RunWith(Theories.class)
public static class TypeVariableOnTheoryParm {
@DataPoint
public static String string = "foo";
@Theory
public <T> void forItem(T item) {
}
}
@Test
public void whereTypeVariableIsOnParameterizedTheoryParm() {
PrintableResult result = testResult(TypeVariableOnParameterizedTheoryParm.class);
assertThat(result, hasSingleFailureContaining("unresolved type variable T"));
}
@RunWith(Theories.class)
public static class TypeVariableOnParameterizedTheoryParm {
@DataPoint
public static List<String> strings = Arrays.asList("foo", "bar");
@Theory
public <T> void forItems(Collection<T> items) {
}
}
@Test
public void whereTypeVariableIsOnWildcardUpperBoundOnTheoryParm() {
PrintableResult result = testResult(TypeVariableOnWildcardUpperBoundOnTheoryParm.class);
assertThat(result, hasSingleFailureContaining("unresolved type variable U"));
}
@RunWith(Theories.class)
public static class TypeVariableOnWildcardUpperBoundOnTheoryParm {
@DataPoint
public static List<String> strings = Arrays.asList("foo", "bar");
@Theory
public <U> void forItems(Collection<? extends U> items) {
}
}
@Test
public void whereTypeVariableIsOnWildcardLowerBoundOnTheoryParm() {
PrintableResult result = testResult(TypeVariableOnWildcardLowerBoundOnTheoryParm.class);
assertThat(result, hasSingleFailureContaining("unresolved type variable V"));
}
@RunWith(Theories.class)
public static class TypeVariableOnWildcardLowerBoundOnTheoryParm {
@DataPoint
public static List<String> strings = Arrays.asList("foo", "bar");
@Theory
public <V> void forItems(Collection<? super V> items) {
}
}
@Test
public void whereTypeVariableIsOnArrayTypeOnTheoryParm() {
PrintableResult result = testResult(TypeVariableOnArrayTypeOnTheoryParm.class);
assertThat(result, hasSingleFailureContaining("unresolved type variable T"));
}
@RunWith(Theories.class)
public static class TypeVariableOnArrayTypeOnTheoryParm {
@DataPoints
public static String[][] items() {
return new String[][]{new String[]{"foo"}, new String[]{"bar"}};
}
@Theory
public <T> void forItems(T[] items) {
}
}
@Test
public void whereTypeVariableIsOnComponentOfArrayTypeOnTheoryParm() {
PrintableResult result = testResult(TypeVariableOnComponentOfArrayTypeOnTheoryParm.class);
assertThat(result, hasSingleFailureContaining("unresolved type variable U"));
}
@RunWith(Theories.class)
public static class TypeVariableOnComponentOfArrayTypeOnTheoryParm {
@DataPoints
public static List<?>[][] items() {
return new List<?>[][]{
new List<?>[]{Arrays.asList("foo")},
new List<?>[]{Arrays.asList("bar")}
};
}
@Theory
public <U> void forItems(Collection<U>[] items) {
}
}
@Test
public void whereTypeVariableIsOnTheoryClass() {
PrintableResult result = testResult(TypeVariableOnTheoryClass.class);
assertThat(result, hasSingleFailureContaining("unresolved type variable T"));
}
@RunWith(Theories.class)
public static class TypeVariableOnTheoryClass<T> {
@DataPoint
public static String item = "bar";
@Theory
public void forItem(T item) {
}
}
@Test
public void whereTypeVariablesAbound() {
PrintableResult result = testResult(TypeVariablesAbound.class);
assertThat(result, failureCountIs(7));
assertThat(result, hasFailureContaining("unresolved type variable A"));
assertThat(result, hasFailureContaining("unresolved type variable B"));
assertThat(result, hasFailureContaining("unresolved type variable C"));
assertThat(result, hasFailureContaining("unresolved type variable D"));
assertThat(result, hasFailureContaining("unresolved type variable E"));
assertThat(result, hasFailureContaining("unresolved type variable F"));
assertThat(result, hasFailureContaining("unresolved type variable G"));
}
@RunWith(Theories.class)
public static class TypeVariablesAbound<A, B extends A, C extends Collection<B>> {
@Theory
public <D, E extends D, F, G> void forItem(A first, Collection<B> second,
Map<C, ? extends D> third, List<? super E> fourth, F[] fifth,
Collection<G>[] sixth) {
}
}
}