/*

 * Copyright (c) 2015, 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

 * @summary Test imports

 * @library /tools/lib

 * @build KullaTesting TestingInputStream ToolBox ExpectedDiagnostic

 * @run testng ImportTest

 */

import java.nio.file.Path;

import java.nio.file.Paths;

import javax.tools.Diagnostic;

import jdk.jshell.Snippet;

import org.testng.annotations.Test;

import static jdk.jshell.Snippet.Status.VALID;

import static jdk.jshell.Snippet.Status.OVERWRITTEN;

import static jdk.jshell.Snippet.SubKind.SINGLE_TYPE_IMPORT_SUBKIND;

import static jdk.jshell.Snippet.SubKind.SINGLE_STATIC_IMPORT_SUBKIND;

import static jdk.jshell.Snippet.SubKind.TYPE_IMPORT_ON_DEMAND_SUBKIND;

import static jdk.jshell.Snippet.SubKind.STATIC_IMPORT_ON_DEMAND_SUBKIND;

@Test

public class ImportTest extends KullaTesting {

    public void testImport() {

        assertImportKeyMatch("import java.util.List;", "List", SINGLE_TYPE_IMPORT_SUBKIND, added(VALID));

        assertImportKeyMatch("import java.util.ArrayList;", "ArrayList", SINGLE_TYPE_IMPORT_SUBKIND, added(VALID));

        assertEval("List<Integer> list = new ArrayList<>();");

        assertEval("list.add(45);");

        assertEval("list.size();", "1");

    }

    public void testImportOnDemand() {

        assertImportKeyMatch("import java.util.*;", "java.util.*", TYPE_IMPORT_ON_DEMAND_SUBKIND, added(VALID));

        assertEval("List<Integer> list = new ArrayList<>();");

        assertEval("list.add(45);");

        assertEval("list.size();", "1");

    }

    public void testImportStatic() {

        assertImportKeyMatch("import static java.lang.Math.PI;", "PI", SINGLE_STATIC_IMPORT_SUBKIND, added(VALID));

        assertEval("new Double(PI).toString().substring(0, 16).equals(\"3.14159265358979\");", "true");

    }

    public void testImportStaticOnDemand() {

        assertImportKeyMatch("import static java.lang.Math.*;", "java.lang.Math.*", STATIC_IMPORT_ON_DEMAND_SUBKIND, added(VALID));

        assertEval("abs(cos(PI / 2)) < 0.00001;", "true");

    }

    @Test(enabled = false) // TODO 8129418

    public void testUnknownPackage() {

        assertDeclareFail("import unknown.qqq;",

                new ExpectedDiagnostic("compiler.err.doesnt.exist", 7, 18, 14, -1, -1, Diagnostic.Kind.ERROR));

        assertDeclareFail("import unknown.*;",

                new ExpectedDiagnostic("compiler.err.doesnt.exist", 7, 15, 7, -1, -1, Diagnostic.Kind.ERROR));

    }

    public void testBogusImportIgnoredInFuture() {

        assertDeclareFail("import unknown.qqq;", "compiler.err.doesnt.exist");

        assertDeclareFail("import unknown.*;", "compiler.err.doesnt.exist");

        assertEval("2 + 2;");

    }

    public void testBadImport() {

        assertDeclareFail("import static java.lang.reflect.Modifier;",

                new ExpectedDiagnostic("compiler.err.cant.resolve.location", 14, 31, 23, -1, -1, Diagnostic.Kind.ERROR));

    }

    public void testBadSyntaxImport() {

        assertDeclareFail("import not found.*;",

                new ExpectedDiagnostic("compiler.err.expected", 10, 10, 10, -1, -1, Diagnostic.Kind.ERROR));

    }

    public void testImportRedefinition() {

        Compiler compiler = new Compiler();

        Path path = Paths.get("testImport");

        compiler.compile(path, "package util; public class ArrayList { public String toString() { return \"MyList\"; } }");

        compiler.compile(path, "package util; public class A { public static class ArrayList {\n" +

                "public String toString() { return \"MyInnerList\"; } } }");

        addToClasspath(compiler.getPath(path));

        assertImportKeyMatch("import util.*;", "util.*", TYPE_IMPORT_ON_DEMAND_SUBKIND, added(VALID));

        assertEval("new ArrayList();", "MyList", added(VALID));

        Snippet import0 = assertImportKeyMatch("import java.util.ArrayList;", "ArrayList", SINGLE_TYPE_IMPORT_SUBKIND, added(VALID));

        assertEval("new ArrayList();", "[]");

        Snippet import1 = assertImportKeyMatch("import util.ArrayList;", "ArrayList", SINGLE_TYPE_IMPORT_SUBKIND,

                ste(MAIN_SNIPPET, VALID, VALID, false, null),

                ste(import0, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

        assertEval("new ArrayList();", "MyList");

        Snippet import2 = assertImportKeyMatch("import java.util.ArrayList;", "ArrayList", SINGLE_TYPE_IMPORT_SUBKIND,

                ste(MAIN_SNIPPET, VALID, VALID, false, null),

                ste(import1, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

        assertEval("new ArrayList();", "[]");

        Snippet import3 = assertImportKeyMatch("import util.A.ArrayList;", "ArrayList", SINGLE_TYPE_IMPORT_SUBKIND,

                ste(MAIN_SNIPPET, VALID, VALID, false, null),

                ste(import2, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

        assertEval("new ArrayList();", "MyInnerList");

        Snippet import4 = assertImportKeyMatch("import java.util.ArrayList;", "ArrayList", SINGLE_TYPE_IMPORT_SUBKIND,

                ste(MAIN_SNIPPET, VALID, VALID, false, null),

                ste(import3, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

        assertEval("new ArrayList();", "[]");

        Snippet import5 = assertImportKeyMatch("import static util.A.ArrayList;", "ArrayList", SINGLE_STATIC_IMPORT_SUBKIND,

                ste(MAIN_SNIPPET, VALID, VALID, false, null),

                ste(import4, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

        assertEval("new ArrayList();", "MyInnerList");

    }

    public void testImportMemberRedefinition() {

        Compiler compiler = new Compiler();

        Path path = Paths.get("testImport");

        compiler.compile(path, "package util; public class A {" +

                "public static String field = \"A\";" +

                "public static String method() { return \"A\"; } }");

        compiler.compile(path, "package util; public class B {" +

                "public static String field = \"B\";" +

                "public static String method() { return \"B\"; } }");

        addToClasspath(compiler.getPath(path));

        assertImportKeyMatch("import static util.B.*;", "util.B.*", STATIC_IMPORT_ON_DEMAND_SUBKIND, added(VALID));

        assertEval("field;", "\"B\"");

        assertEval("method();", "\"B\"");

        assertImportKeyMatch("import static util.A.method;", "method", SINGLE_STATIC_IMPORT_SUBKIND, added(VALID));

        assertEval("field;", "\"B\"");

        assertEval("method();", "\"A\"");

        assertImportKeyMatch("import static util.A.field;", "field", SINGLE_STATIC_IMPORT_SUBKIND, added(VALID));

        assertEval("field;", "\"A\"");

        assertEval("method();", "\"A\"");

    }

}