Test Case Characteristics: Parameterized type, Parameterized class, Wildcard typeimport java.util.* class Main { static final void test() { List<? extends Number> list = new LinkedList<Number>(); List<Number> x = list; // types are not compatible. List<Number> y = (List<? extends Object>) null // types are not compatible; list.add(1); // method call is not permitted. } }
Test Case Characteristics: Overloading, Inheritance / Implementation of multiple interfaces, Subtypingimport java.io.*; import java.util.*; class Main { void test() { ObjectOutputStream y = null; m(y); } Number m(OutputStream x) { return 1; } Number m(DataOutput x) { return 2; } }
Test Case Characteristics: Parameterized type, Parameterized classclass Main { static final void test() { org.apache.commons.collections4.iterators.ZippingIterator< org.apache.commons.collections4.iterators.ZippingIterator<String> > x = null; } }
Test Case Characteristics: Single Abstract Method (SAM), Parameterized function, Lambdaclass Main { static final void test() { java.util.stream.StreamSupport.<Process>stream(()-> 1, 1, false); // Error, the return type of lamba is not compatible with the expected type. } }
Test Case Characteristics: Inheritance / Implementation of multiple interfacesinterface Bar {} interface Foo extends Foo, Bar {}
Test Case Characteristics: Parameterized functionclass Test { static <T extends T> void test() {} }
Test Case Characteristics: Overloading, Parameterized type, Parameterized class, Bounded type parameterimport java.util.*; public class Test { public static <T extends Number> void test() { List<T> d = null; d.add(false); } }
Test Case Characteristics: Overloading, Parameterized type, Parameterized class, Function reference, Single Abstract Method (SAM)import java.util.function.Function; import java.util.LinkedList; class Foo {} class Test { public static void main(String[] args) { LinkedList<Foo> x = new LinkedList(); x.add(new Foo()); Function<Integer, Foo> z = x::remove; Foo k = z.apply(0); // ClassCastException boolean cannot be cast to Foo. } }
Test Case Characteristics: Function reference, Single Abstract Method (SAM)import java.util.function.*; class Bar {} public class Test { public static void main(String[] args) { m(Bar::new); } static <X> void m(Function<String, X> d) { d.apply("dfa") } }
Test Case Characteristics: Parameterized class, Bounded type parameter, Inheritance / Implementation of multiple interfaces, Subtypingclass A<T> { T x; A(T x) {this.x = x;} A() {} } class B<T extends Object> extends A<T> { B(T x) { super(x); } B() {} T m() { A<T> x = new B<Object>("fd"); // Misses type error: B<Object> is not a subtype of A<T> return x.x; } } class Test { public static void main(String[] args) { Integer x = new B<Integer>().m(); } }
Test Case Characteristics: Parameterized class, Inheritance / Implementation of multiple interfaces, Parameterized type, Use-site varianceclass A<T> {} class B<T> extends A<T> {} class Test { B<? extends Number> x = new B<Double>(); A<Number> y = x; }
Test Case Characteristics: Parameterized functionclass A {} class Test { public static void main(String[] args) { A x = m(1) System.out.println(x) } static <T> A m(T x) { return x; } }
Test Case Characteristics: Parameterized class, Parameterized type, Bounded type parameterclass B<T1, T2 extends T1> {} class Test { public static void main(String[] args) { var x = new B<Number, Boolean>(); } }
Test Case Characteristics: Subtypingclass A { void m() {} } class Test { public static void main(String[] args) { final Object x = foo(); x.m(); // should report an error. method `m` is not found in class Object. } public static A foo() { return new A(); } }
Test Case Characteristics: Primitive typeclass Test { public static void main(String[] args) { char f = (Integer) null; } }
Test Case Characteristics: Parameterized function, Type argument inferenceclass Test { static <T> T bar(T x, T y) { return x; } static String m() { return ""; } static void main(String[] args) { Integer x = bar(m(), 1); // STC misses the error. } }
Test Case Characteristics: Lambda, Function typeimport java.util.function.Supplier; class Main { static void main(String[] args) { bar({ -> true}); // should not type-check bar({ -> true} as Supplier<Long>); // should not type-check. } static Long bar(Supplier<Long> x) { x.get() } }
Test Case Characteristics: Parameterized class, Parameterized function, Bounded type parameter, Type argument inference, Inheritance / Implementation of multiple interfaces, Subtypingclass A<T1, T2> { T2 x; A(T2 x) { this.x = x; } } class B { <T1 extends Number, T2 extends A<Float, T1>> void foo(T2 x1, T1 x2) { T1 y = x1.x; // CCE at runtime } } class C<T extends D> { T x; C(T x) { this.x = x; } void test() { (new B()).foo(x, foo()); } static <X extends Number> X foo() { return null; } } class D extends A<Float, String> { D() { super(""); } } class Main { public static void main(String[] args) { (new C<D>(new D())).test(); } }
Test Case Characteristics: Parameterized class, Bounded type parameter, Inheritance / Implementation of multiple interfaces, Array, Parameterized typeclass A<T> {} class B {} @groovy.transform.TypeChecked class C<G extends B[]> extends A<G> {} // It works if G extends B
Test Case Characteristics: Parameterized class, Parameterized type, Inheritance / Implementation of multiple interfaces, Bounded type parameterpublic class Main { public static void main(String[] args) { new Foo<B>().foo(new B()).m() } } class A{} class B extends A{ void m() {} } @groovy.transform.TypeChecked class Foo<T extends A> { T foo(T x) { x = new A(); // does not catch the error; } }
Test Case Characteristics: Flow typing, Subtyping, Conditionals, Inheritance / Implementation of multiple interfaces@groovy.transform.TypeChecked class Main { public static Bar buz(Foo bux) { (((true || bux instanceof Bar)) ? bux : new Bar()) } public static void main(String[] args) { buz(new Foo()).bar() } } class Foo { public void foo() {} } class Bar extends Foo { public void bar() {} }
Test Case Characteristics: Conditionals, Primitive typeclass Foo { void foo() { float x = (false) ? 10.4: null; } } public class Main { public static void main(String[] args) { new Foo().foo(); } }
Test Case Characteristics: Named argumentsclass Foo { void bar(int x = "str") { System.out.println(x) } } class Main { public static void main(String[] args) { (new Foo()).bar() } }
Test Case Characteristics: Primitive type@groovy.transform.CompileStatic class Main { void foo() { float x = true } }
Test Case Characteristics: Arraypublic class Main { public static void main(String[] args) { Integer[] arr = new Integer[] {new Object(), 1}; // STC misses the error here Integer y = arr[0]; // ClassCastException at runtime } }
Test Case Characteristics: Array, Castpublic class Main { public static void main(String[] args) { // Integer[] arr = new Integer[]{1, "str"}; // does not report error (see GROOVY-9985) Integer[] arr2 = [1, "fda"] as Integer[] // does not report error } }
Test Case Characteristics: Arraypublic class Main { public static void main(String[] args) { Integer[] arr = new Integer[]{1, "str"}; // does not report error // Integer[] arr2 = [1, "fda"] as Integer[] // does not report error (see GROOVY-9986) } }
Test Case Characteristics: Inheritance / Implementation of multiple interfacesclass A { String x; public A(String x) { this.x = x; } } class B extends A {} public class Main { public static void main(String[] args) { B x = new B(); } }
Test Case Characteristics: Parameterized class, Parameterized typeclass Y {} class X<T> { T x; public X() { this.x = new Y() } T foo() { return this.x } } class Main { public static void main(String[] args) { bar(new X<Integer>()); } public static Integer bar(X<Integer> y) { return y.foo() } }
class Foo { static void foo() { return 1 } }
Test Case Characteristics: Inner classScala import org.apache.logging.log4j.core.message._ def test(): Unit = { val x: ExtendedThreadInfoFactory = ??? }
Test Case Characteristics: Parameterized class, Declaration-site variance, Bounded type parameter, Use-site variance, Parameterized type, Inheritance / Implementation of multiple interfacesclass Foo<out Y, Z: Y> open class A class B : A() fun main() { val x: Foo<A, in A> = Foo<B, B>() }
Test Case Characteristics: Parameterized class, Parameterized typeclass Foo<J>() {} class Bar<H, N>(val x: Foo<N>) {} fun foo(): Unit { val y = Bar<Any, Any>(Foo<N>()) }
Test Case Characteristics: Parameterized class, Bounded type parameter, Use-site variance, Parameterized type, Parameterized function, Type argument inferenceclass A<T: B<out Number>>(val x: T) { fun test() { val y: Int = x.m<C<out Number>>() } } class B<T1> { fun <X1: C<T1>> m(): Int = 1 } class C<T>
Test Case Characteristics: Function type, Flow typing, Lambda, Conditionalsimport java.util.function.Supplier; class Main { public Integer foo(Object x) { Integer bar = 1; return ((x instanceof Number y) ? ((Supplier<Integer>) (() -> { return ((y instanceof Integer z) ? z : bar); })).get() : bar); } }