/*

 * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * @test

 * @bug 8144903 8171981 8191802 8191842

 * @summary Tests for determining the type from the expression

 * @build KullaTesting TestingInputStream

 * @run testng TypeNameTest

 */

import org.testng.annotations.Test;

import static org.testng.Assert.assertEquals;

@Test

public class TypeNameTest extends KullaTesting {

    private void assertType(String expr, String type) {

        assertType(expr, type, type);

    }

    private void assertType(String expr, String type, String inferType) {

        assertEquals(varKey(assertEval(expr)).typeName(), type);

        assertInferredType(expr, inferType);

    }

    public void testTypeInference() {

        assertEval("import java.util.List;");

        assertEval("import java.util.ArrayList;");

        assertEval("import java.util.Arrays;");

        assertType("new Object().getClass().getSuperclass() ", "Class<?>");

        assertType("new ArrayList().getClass().getSuperclass()", "Class<?>");

        assertType("new ArrayList().getClass()", "Class<? extends ArrayList>");

        assertType("ArrayList.class", "Class<ArrayList>");

        assertType("ArrayList.class.getSuperclass()", "Class<? super ArrayList>");

        assertEval("class D<T extends CharSequence> { D<? super T> getS() { return null; } }");

        assertEval("D<?> d = new D<String>();");

        assertType("d.getS()", "D<?>");

        assertType("null", "Object");

        assertType("Class.forName( \"java.util.ArrayList\" )", "Class<?>");

        assertType("new ArrayList<Boolean>() {}", "<anonymous class extending ArrayList<Boolean>>", "ArrayList<Boolean>");

        assertType("new ArrayList<String>().stream()", "java.util.stream.Stream<String>");

        assertType("Arrays.asList( 1, 2, 3)", "List<Integer>");

        assertType("new ArrayList().getClass().getClass()", "Class<? extends Class>");

        assertEval("interface A {}");

        assertEval("interface I {}");

        assertEval("interface J extends A, I {}");

        assertEval("interface K extends A, I {}");

        assertEval("class P<T extends A & I> {}");

        assertType("(P<?>) null", "P<?>");

    }

    public void testConditionals() {

        assertEval("import java.util.List;");

        assertEval("import java.util.ArrayList;");

        assertEval("import java.util.Arrays;");

        assertEval("CharSequence cs = \"hi\";");

        assertEval("String st = \"low\";");

        assertEval("boolean b;");

        assertType("b? cs : st", "CharSequence");

        assertEval("List<String> l1 = Arrays.asList(\"hi\");");

        assertEval("List<? extends String> l2 = Arrays.asList(\"po\");");

        assertType("b? l1.get(0) : l2.get(0)", "String");

        assertEval("class X {}");

        assertEval("class B extends X {}");

        assertEval("class C extends X {}");

        assertType("b? new B() : new C()", "X");

    }

    public void testJEP286NonDenotable() {

        assertEval("import java.util.List;");

        assertEval("import java.util.Arrays;");

        assertEval("import java.util.Iterator;");

        assertEval("List<? extends String> extString() { return Arrays.asList( \"hi\", \"low\" ); }");

        assertEval("List<? super String> supString() { return Arrays.asList( \"hi\", \"low\" ); }");

        assertEval("List<?> unbString() { return Arrays.asList( \"hi\", \"low\" ); }");

        assertEval("List<? extends String>[] extStringArr() {" +

                " @SuppressWarnings(\"unchecked\") " +

                "List<? extends String>[] a = new List[1]; a[0] = Arrays.asList(\"hi\"); return a; }");

        assertEval("List<? super String>[] supStringArr() {" +

                " @SuppressWarnings(\"unchecked\") " +

                "List<? super String>[] a = new List[1]; a[0] = Arrays.asList(\"hi\"); return a; }");

        assertEval("List<?>[] unbStringArr() {" +

                " @SuppressWarnings(\"unchecked\") " +

                "List<?>[] a = new List[1]; a[0] = Arrays.asList(\"hi\"); return a; }");

        assertEval("Iterable<? extends List<? extends String>> extStringIter() {" +

                "return Arrays.asList( Arrays.asList( \"hi\" ) ); }");

        assertEval("Iterable<? extends List<? super String>> supStringIter() {" +

                "return Arrays.asList( Arrays.asList( \"hi\" ) ); }");

        assertEval("Iterable<? extends List<?>> unbStringIter() {" +

                "return Arrays.asList( Arrays.asList( \"hi\" ) ); }");

        assertType("extString()", "List<? extends String>");

        assertType("extString().get(0)", "String");

        assertType("supString()", "List<? super String>");

        assertType("supString().get(0)", "Object");

        assertType("unbString()", "List<?>");

        assertType("unbString().get(0)", "Object");

        assertType("supStringArr()", "List<? super String>[]");

        assertType("supStringArr()[0]", "List<? super String>");

        assertType("supStringArr()[0].get(0)", "Object");

        assertType("unbStringArr()", "List<?>[]");

        assertType("unbStringArr()[0]", "List<?>");

        assertType("unbStringArr()[0].get(0)", "Object");

        assertType("extStringIter()", "Iterable<? extends List<? extends String>>");

        assertType("extStringIter().iterator()", "Iterator<? extends List<? extends String>>");

        assertType("extStringIter().iterator().next()", "List<? extends String>");

        assertType("extStringIter().iterator().next().get(0)", "String");

        assertType("supStringIter()", "Iterable<? extends List<? super String>>");

        assertType("supStringIter().iterator()", "Iterator<? extends List<? super String>>");

        assertType("supStringIter().iterator().next()", "List<? super String>");

        assertType("supStringIter().iterator().next().get(0)", "Object");

        assertType("unbStringIter()", "Iterable<? extends List<?>>");

        assertType("unbStringIter().iterator()", "Iterator<? extends List<?>>");

        assertType("unbStringIter().iterator().next()", "List<?>");

        assertType("unbStringIter().iterator().next().get(0)", "Object");

    }

    public void testJEP286NonDenotable2() {

        assertEval("import java.util.List;");

        assertEval("import java.util.Arrays;");

        assertEval("import java.lang.reflect.Array;");

        assertEval("<Z extends Comparable<Z>> List<? extends Z> extFbound() {" +

                "return Arrays.asList( (Z)null ); }");

        assertEval("<Z extends Comparable<Z>> List<? super Z> supFbound() {" +

                "return Arrays.asList( (Z)null ); }");

        assertEval("<Z extends Comparable<Z>> List<? extends Z>[] extFboundArr() {" +

                "@SuppressWarnings(\"unchecked\")" +

                "List<? extends Z>[] a = new List[1]; a[0] = Arrays.asList( (Z)null ); return a; }");

        assertEval("<Z extends Comparable<Z>> List<? super Z>[] supFboundArr() {" +

                "@SuppressWarnings(\"unchecked\")" +

                "List<? super Z>[] a = new List[1]; a[0] = Arrays.asList( (Z)null ); return a; }");

        assertEval("<Z extends Comparable<Z>> Iterable<? extends List<? extends Z>> extFboundIter() {" +

                "return Arrays.asList( Arrays.asList( (Z)null ) ); }");

        assertEval("<Z extends Comparable<Z>> Iterable<? extends List<? super Z>> supFboundIter() {" +

                "return Arrays.asList( Arrays.asList( (Z)null ) ); }");

        assertEval("<Z> List<Z> listOf(Z z) { return Arrays.asList( z ); }");

        assertEval("<Z> Z[] arrayOf(Z z) {" +

                "@SuppressWarnings(\"unchecked\")" +

                "final Z[] a = (Z[]) Array.newInstance(z.getClass(), 1); a[0] = z; return a; }");

        assertType("extFbound()", "List<? extends Comparable<?>>");

        assertType("extFbound().get(0)", "Comparable<?>");

        assertType("supFbound()", "List<?>");

        assertType("supFbound().get(0)", "Object");

        assertType("extFboundArr()", "List<? extends Comparable<?>>[]");

        assertType("extFboundArr()[0]", "List<? extends Comparable<?>>");

        assertType("extFboundArr()[0].get(0)", "Comparable<?>");

        assertType("supFboundArr()", "List<?>[]");

        assertType("supFboundArr()[0]", "List<?>");

        assertType("supFboundArr()[0].get(0)", "Object");

        assertType("extFboundIter()", "Iterable<? extends List<? extends Comparable<?>>>");

        assertType("extFboundIter().iterator()", "java.util.Iterator<? extends List<? extends Comparable<?>>>");

        assertType("extFboundIter().iterator().next()", "List<? extends Comparable<?>>");

        assertType("extFboundIter().iterator().next().get(0)", "Comparable<?>");

        assertType("supFboundIter()", "Iterable<? extends List<?>>");

        assertType("supFboundIter().iterator()", "java.util.Iterator<? extends List<?>>");

        assertType("supFboundIter().iterator().next()", "List<?>");

        assertType("supFboundIter().iterator().next().get(0)", "Object");

        assertType("listOf(23)", "List<Integer>");

        assertType("listOf(true)", "List<Boolean>");

        assertType("listOf(true).get(0)", "Boolean");

        assertType("arrayOf(99)", "Integer[]");

        assertType("arrayOf(99)[0]", "Integer");

        assertEval("<Z> Z choose(Z z1, Z z2) { return z1; }");

        assertType("choose(1, 1L);", "Number&Comparable<? extends Number&Comparable<?>>", "Object");

    }

    public void testVariableTypeName() {

        assertType("\"x\"", "String");

        assertType("java.util.regex.Pattern.compile(\"x\")", "java.util.regex.Pattern");

        assertEval("import java.util.regex.*;");

        assertType("java.util.regex.Pattern.compile(\"x\")", "Pattern");

        assertType("new java.util.ArrayList()", "java.util.ArrayList");

        assertEval("import java.util.ArrayList;");

        assertType("new java.util.ArrayList()", "ArrayList");

        assertType("java.util.Locale.Category.FORMAT", "java.util.Locale.Category");

        assertEval("import static java.util.Locale.Category;");

        assertType("java.util.Locale.Category.FORMAT", "Category");

    }

    public void testReplNestedClassName() {

        assertEval("class D { static class E {} }");

        assertType("new D.E();", "D.E");

    }

    public void testAnonymousClassName() {

        assertEval("class C {}");

        assertType("new C();", "C");

        assertType("new C() { int x; };", "<anonymous class extending C>", "C");

    }

    public void testCapturedTypeName() {

        assertType("\"\".getClass();", "Class<? extends String>");

        assertType("\"\".getClass().getEnumConstants();", "String[]");

    }

    public void testJavaLang() {

        assertType("\"\";", "String");

    }

    public void testNotOverEagerPackageEating() {

        assertType("\"\".getClass().getDeclaredMethod(\"hashCode\");", "java.lang.reflect.Method");

    }

    public void testBounds() {

        assertEval("java.util.List<? extends String> list1 = java.util.Arrays.asList(\"\");");

        assertType("list1.iterator().next()", "String");

        assertEval("java.util.List<? super String> list2 = java.util.Arrays.asList(\"\");");

        assertType("list2.iterator().next()", "Object");

        assertEval("java.util.List<?> list3 = java.util.Arrays.asList(\"\");");

        assertType("list3.iterator().next()", "Object");

        assertEval("class Test1<X extends CharSequence> { public X get() { return null; } }");

        assertEval("Test1<?> test1 = new Test1<>();");

        assertType("test1.get()", "CharSequence");

        assertEval("class Test2<X extends Number & CharSequence> { public X get() { return null; } }");

        assertEval("Test2<?> test2 = new Test2<>();");

        assertType("test2.get()", "Number&CharSequence", "Object");

        assertEval("class Test3<T> { T[][] get() { return null; } }");

        assertEval("Test3<? extends String> test3 = new Test3<>();");

        assertType("test3.get()", "String[][]");

    }

}