1 /*

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

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

     4  *

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

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

     7  * published by the Free Software Foundation.

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

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

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

    21  * questions.

    22  */

    23 

    24 /*

    25  * @test

    26  * @bug 8131025 8141092 8153761 8145263 8131019 8175886 8176184 8176241 8176110

    27  * @summary Test Completion and Documentation

    28  * @library /tools/lib

    29  * @modules jdk.compiler/com.sun.tools.javac.api

    30  *          jdk.compiler/com.sun.tools.javac.main

    31  *          jdk.jdeps/com.sun.tools.javap

    32  *          jdk.jshell/jdk.jshell:open

    33  * @build toolbox.ToolBox toolbox.JarTask toolbox.JavacTask

    34  * @build KullaTesting TestingInputStream Compiler

    35  * @run testng CompletionSuggestionTest

    36  */

    37 

    38 import java.io.IOException;

    39 import java.lang.reflect.Field;

    40 import java.nio.file.Files;

    41 import java.nio.file.Path;

    42 import java.nio.file.Paths;

    43 import java.util.Arrays;

    44 import java.util.Collections;

    45 import java.util.Set;

    46 import java.util.HashSet;

    47 import java.util.function.BiFunction;

    48 import java.util.function.Function;

    49 import java.util.jar.JarEntry;

    50 import java.util.jar.JarOutputStream;

    51 

    52 import jdk.jshell.Snippet;

    53 import org.testng.annotations.BeforeMethod;

    54 import org.testng.annotations.Test;

    55 

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

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

    58 

    59 @Test

    60 public class CompletionSuggestionTest extends KullaTesting {

    61 

    62     private final Compiler compiler = new Compiler();

    63     private final Path outDir = Paths.get("completion_suggestion_test");

    64 

    65     public void testMemberExpr() {

    66         assertEval("class Test { static void test() { } }");

    67         assertCompletion("Test.t|", "test()");

    68         assertEval("Test ccTestInstance = new Test();");

    69         assertCompletion("ccTestInstance.t|", "toString()");

    70         assertCompletion(" ccTe|", "ccTestInstance");

    71         assertCompletion("String value = ccTestInstance.to|", "toString()");

    72         assertCompletion("java.util.Coll|", "Collection", "Collections");

    73         assertCompletion("String.cla|", "class");

    74         assertCompletion("boolean.cla|", "class");

    75         assertCompletion("byte.cla|", "class");

    76         assertCompletion("short.cla|", "class");

    77         assertCompletion("char.cla|", "class");

    78         assertCompletion("int.cla|", "class");

    79         assertCompletion("float.cla|", "class");

    80         assertCompletion("long.cla|", "class");

    81         assertCompletion("double.cla|", "class");

    82         assertCompletion("void.cla|", "class");

    83         assertCompletion("Object[].|", "class");

    84         assertCompletion("int[].|", "class");

    85         assertEval("Object[] ao = null;");

    86         assertCompletion("int i = ao.|", "length");

    87         assertEval("int[] ai = null;");

    88         assertCompletion("int i = ai.|", "length");

    89         assertCompletionIncludesExcludes("\"\".|",

    90                 new HashSet<>(Collections.emptyList()),

    91                 new HashSet<>(Arrays.asList("String(")));

    92         assertEval("double d = 0;");

    93         assertEval("void m() {}");

    94         assertCompletionIncludesExcludes("d.|",

    95                 new HashSet<>(Collections.emptyList()),

    96                 new HashSet<>(Arrays.asList("class")));

    97         assertCompletionIncludesExcludes("m().|",

    98                 new HashSet<>(Collections.emptyList()),

    99                 new HashSet<>(Arrays.asList("class")));

   100         assertEval("class C {class D {} static class E {} enum F {} interface H {} void method() {} int number;}");

   101         assertCompletionIncludesExcludes("C.|",

   102                 new HashSet<>(Arrays.asList("D", "E", "F", "H", "class")),

   103                 new HashSet<>(Arrays.asList("method()", "number")));

   104         assertCompletionIncludesExcludes("new C().|",

   105                 new HashSet<>(Arrays.asList("method()", "number")),

   106                 new HashSet<>(Arrays.asList("D", "E", "F", "H", "class")));

   107         assertCompletionIncludesExcludes("new C() {}.|",

   108                 new HashSet<>(Arrays.asList("method()", "number")),

   109                 new HashSet<>(Arrays.asList("D", "E", "F", "H", "class")));

   110     }

   111 

   112     public void testStartOfExpression() {

   113         assertEval("int ccTest = 0;");

   114         assertCompletion("System.err.println(cc|", "ccTest");

   115         assertCompletion("for (int i = cc|", "ccTest");

   116     }

   117 

   118     public void testParameter() {

   119         assertCompletion("class C{void method(int num){num|", "num");

   120     }

   121 

   122     public void testPrimitive() {

   123         Set<String> primitives = new HashSet<>(Arrays.asList("boolean", "char", "byte", "short", "int", "long", "float", "double"));

   124         Set<String> onlyVoid = new HashSet<>(Collections.singletonList("void"));

   125         Set<String> primitivesOrVoid = new HashSet<>(primitives);

   126         primitivesOrVoid.addAll(onlyVoid);

   127 

   128         assertCompletionIncludesExcludes("|",

   129                 primitivesOrVoid,

   130                 new HashSet<>(Collections.emptyList()));

   131         assertCompletionIncludesExcludes("int num = |",

   132                 primitivesOrVoid,

   133                 new HashSet<>(Collections.emptyList()));

   134         assertCompletionIncludesExcludes("num = |",

   135                 primitivesOrVoid,

   136                 new HashSet<>(Collections.emptyList()));

   137         assertCompletionIncludesExcludes("class C{void m() {|",

   138                 primitivesOrVoid,

   139                 new HashSet<>(Collections.emptyList()));

   140         assertCompletionIncludesExcludes("void method(|",

   141                 primitives,

   142                 onlyVoid);

   143         assertCompletionIncludesExcludes("void method(int num, |",

   144                 primitives,

   145                 onlyVoid);

   146         assertCompletion("new java.util.ArrayList<doub|");

   147         assertCompletion("class A extends doubl|");

   148         assertCompletion("class A implements doubl|");

   149         assertCompletion("interface A extends doubl|");

   150         assertCompletion("enum A implements doubl|");

   151         assertCompletion("class A<T extends doubl|");

   152     }

   153 

   154     public void testEmpty() {

   155         assertCompletionIncludesExcludes("|",

   156                 new HashSet<>(Arrays.asList("Object", "Void")),

   157                 new HashSet<>(Arrays.asList("$REPL00DOESNOTMATTER")));

   158         assertCompletionIncludesExcludes("V|",

   159                 new HashSet<>(Collections.singletonList("Void")),

   160                 new HashSet<>(Collections.singletonList("Object")));

   161         assertCompletionIncludesExcludes("{ |",

   162                 new HashSet<>(Arrays.asList("Object", "Void")),

   163                 new HashSet<>(Arrays.asList("$REPL00DOESNOTMATTER")));

   164     }

   165 

   166     public void testSmartCompletion() {

   167         assertEval("int ccTest1 = 0;");

   168         assertEval("int ccTest2 = 0;");

   169         assertEval("String ccTest3 = null;");

   170         assertEval("void method(int i, String str) { }");

   171         assertEval("void method(String str, int i) { }");

   172         assertEval("java.util.List<String> list = null;");

   173         assertCompletion("int ccTest4 = |", true, "ccTest1", "ccTest2");

   174         assertCompletion("ccTest2 = |", true, "ccTest1", "ccTest2");

   175         assertCompletion("int ccTest4 = ccTe|", "ccTest1", "ccTest2", "ccTest3");

   176         assertCompletion("int ccTest4 = ccTest3.len|", true, "length()");

   177         assertCompletion("method(|", true, "ccTest1", "ccTest2", "ccTest3");

   178         assertCompletion("method(0, |", true, "ccTest3");

   179         assertCompletion("list.add(|", true, "ccTest1", "ccTest2", "ccTest3");

   180         assertCompletion("list.add(0, |", true, "ccTest3");

   181         assertCompletion("new String(|", true, "ccTest3");

   182         assertCompletion("new String(new char[0], |", true, "ccTest1", "ccTest2");

   183         assertCompletionIncludesExcludes("new jav|", new HashSet<>(Arrays.asList("java.", "javax.")), Collections.emptySet());

   184         assertCompletion("Class<String> clazz = String.c|", true, "class");

   185 

   186         Snippet klass = classKey(assertEval("class Klass {void method(int n) {} private void method(String str) {}}"));

   187         assertCompletion("new Klass().method(|", true, "ccTest1", "ccTest2");

   188         Snippet klass2 = classKey(assertEval("class Klass {static void method(int n) {} void method(String str) {}}",

   189                 ste(MAIN_SNIPPET, VALID, VALID, true, null),

   190                 ste(klass, VALID, OVERWRITTEN, false, MAIN_SNIPPET)));

   191         assertCompletion("Klass.method(|", true, "ccTest1", "ccTest2");

   192         assertEval("class Klass {Klass(int n) {} private Klass(String str) {}}",

   193                 ste(MAIN_SNIPPET, VALID, VALID, true, null),

   194                 ste(klass2, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

   195         assertCompletion("new Klass(|", true, "ccTest1", "ccTest2");

   196     }

   197 

   198     public void testSmartCompletionInOverriddenMethodInvocation() {

   199         assertEval("int ccTest1 = 0;");

   200         assertEval("int ccTest2 = 0;");

   201         assertEval("String ccTest3 = null;");

   202         assertCompletion("\"\".wait(|", true, "ccTest1", "ccTest2");

   203         assertEval("class Base {void method(int n) {}}");

   204         assertEval("class Extend extends Base {}");

   205         assertCompletion("new Extend().method(|", true, "ccTest1", "ccTest2");

   206     }

   207 

   208     public void testSmartCompletionForBoxedType() {

   209         assertEval("int ccTest1 = 0;");

   210         assertEval("Integer ccTest2 = 0;");

   211         assertEval("Object ccTest3 = null;");

   212         assertEval("int method1(int n) {return n;}");

   213         assertEval("Integer method2(Integer n) {return n;}");

   214         assertEval("Object method3(Object o) {return o;}");

   215         assertCompletion("int ccTest4 = |", true, "ccTest1", "ccTest2", "method1(", "method2(");

   216         assertCompletion("Integer ccTest4 = |", true, "ccTest1", "ccTest2", "method1(", "method2(");

   217         assertCompletion("Object ccTest4 = |", true, "ccTest1", "ccTest2", "ccTest3", "method1(", "method2(", "method3(");

   218         assertCompletion("method1(|", true, "ccTest1", "ccTest2", "method1(", "method2(");

   219         assertCompletion("method2(|", true, "ccTest1", "ccTest2", "method1(", "method2(");

   220         assertCompletion("method3(|", true, "ccTest1", "ccTest2", "ccTest3", "method1(", "method2(", "method3(");

   221     }

   222 

   223     public void testNewClass() {

   224         assertCompletion("String str = new Strin|", "String(", "StringBuffer(", "StringBuilder(", "StringIndexOutOfBoundsException(");

   225         assertCompletion("String str = new java.lang.Strin|", "String(", "StringBuffer(", "StringBuilder(", "StringIndexOutOfBoundsException(");

   226         assertCompletion("String str = new |", true, "String(");

   227         assertCompletion("String str = new java.lang.|", true, "String(");

   228         assertCompletion("throw new Strin|", true, "StringIndexOutOfBoundsException(");

   229 

   230         assertEval("class A{class B{} class C {C(int n) {}} static class D {} interface I {}}");

   231         assertEval("A a;");

   232         assertCompletion("new A().new |", "B()", "C(");

   233         assertCompletion("a.new |", "B()", "C(");

   234         assertCompletion("new A.|", "D()");

   235 

   236         assertEval("enum E{; class A {}}");

   237         assertEval("interface I{; class A {}}");

   238         assertCompletion("new E.|", "A()");

   239         assertCompletion("new I.|", "A()");

   240         assertCompletion("new String(I.A|", "A");

   241     }

   242 

   243     public void testFullyQualified() {

   244         assertCompletion("Optional<String> opt = java.u|", "util.");

   245         assertCompletionIncludesExcludes("Optional<Strings> opt = java.util.O|", new HashSet<>(Collections.singletonList("Optional")), Collections.emptySet());

   246 

   247         assertEval("void method(java.util.Optional<String> opt) {}");

   248         assertCompletion("method(java.u|", "util.");

   249 

   250         assertCompletion("Object.notElement.|");

   251         assertCompletion("Object o = com.su|", "sun.");

   252 

   253         Path p1 = outDir.resolve("dir1");

   254         compiler.compile(p1,

   255                 "package p1.p2;\n" +

   256                 "public class Test {\n" +

   257                 "}",

   258                 "package p1.p3;\n" +

   259                 "public class Test {\n" +

   260                 "}");

   261         String jarName = "test.jar";

   262         compiler.jar(p1, jarName, "p1/p2/Test.class", "p1/p3/Test.class");

   263         addToClasspath(compiler.getPath(p1.resolve(jarName)));

   264 

   265         assertCompletionIncludesExcludes("|", new HashSet<>(Collections.singletonList("p1.")), Collections.emptySet());

   266         assertCompletion("p1.|", "p2.", "p3.");

   267         assertCompletion("p1.p2.|", "Test");

   268         assertCompletion("p1.p3.|", "Test");

   269     }

   270 

   271     public void testCheckAccessibility() {

   272         assertCompletion("java.util.regex.Pattern.co|", "compile(");

   273     }

   274 

   275     public void testCompletePackages() {

   276         assertCompletion("java.u|", "util.");

   277         assertCompletionIncludesExcludes("jav|", new HashSet<>(Arrays.asList("java.", "javax.")), Collections.emptySet());

   278     }

   279 

   280     public void testImports() {

   281         assertCompletion("import java.u|", "util.");

   282         assertCompletionIncludesExcludes("import jav|", new HashSet<>(Arrays.asList("java.", "javax.")), Collections.emptySet());

   283         assertCompletion("import static java.u|", "util.");

   284         assertCompletionIncludesExcludes("import static jav|", new HashSet<>(Arrays.asList("java.", "javax.")), Collections.emptySet());

   285         assertCompletion("import static java.lang.Boolean.g|", "getBoolean");

   286         assertCompletion("import java.util.*|");

   287         assertCompletionIncludesExcludes("import java.lang.String.|",

   288                 Collections.emptySet(),

   289                 new HashSet<>(Arrays.asList("CASE_INSENSITIVE_ORDER", "copyValueOf", "format", "join", "valueOf", "class", "length")));

   290         assertCompletionIncludesExcludes("import static java.lang.String.|",

   291                 new HashSet<>(Arrays.asList("CASE_INSENSITIVE_ORDER", "copyValueOf", "format", "join", "valueOf")),

   292                 new HashSet<>(Arrays.asList("class", "length")));

   293         assertCompletionIncludesExcludes("import java.util.Map.|",

   294                 new HashSet<>(Arrays.asList("Entry")),

   295                 new HashSet<>(Arrays.asList("class")));

   296     }

   297 

   298     public void testImportStart() {

   299         assertCompletionIncludesExcludes("import c|", Set.of("com."), Set.of());

   300     }

   301 

   302     public void testBrokenClassFile() throws Exception {

   303         Compiler compiler = new Compiler();

   304         Path testOutDir = Paths.get("CompletionTestBrokenClassFile");

   305         String input = "package test.inner; public class Test {}";

   306         compiler.compile(testOutDir, input);

   307         addToClasspath(compiler.getPath(testOutDir).resolve("test"));

   308         assertCompletion("import inner.|");

   309     }

   310 

   311     public void testDocumentation() throws Exception {

   312         dontReadParameterNamesFromClassFile();

   313         assertSignature("System.getProperty(|",

   314                 "String System.getProperty(String key)",

   315                 "String System.getProperty(String key, String def)");

   316         assertEval("char[] chars = null;");

   317         assertSignature("new String(chars, |",

   318                 "String(char[], int, int)");

   319         assertSignature("String.format(|",

   320                 "String String.format(String, Object...)",

   321                 "String String.format(java.util.Locale, String, Object...)");

   322         assertSignature("\"\".getBytes(\"\"|", "void String.getBytes(int, int, byte[], int)",

   323                                                     "byte[] String.getBytes(String) throws java.io.UnsupportedEncodingException",

   324                                                     "byte[] String.getBytes(java.nio.charset.Charset)");

   325         assertSignature("\"\".getBytes(\"\" |", "void String.getBytes(int, int, byte[], int)",

   326                                                      "byte[] String.getBytes(String) throws java.io.UnsupportedEncodingException",

   327                                                      "byte[] String.getBytes(java.nio.charset.Charset)");

   328     }

   329 

   330     public void testMethodsWithNoArguments() throws Exception {

   331         dontReadParameterNamesFromClassFile();

   332         assertSignature("System.out.println(|",

   333                 "void java.io.PrintStream.println()",

   334                 "void java.io.PrintStream.println(boolean)",

   335                 "void java.io.PrintStream.println(char)",

   336                 "void java.io.PrintStream.println(int)",

   337                 "void java.io.PrintStream.println(long)",

   338                 "void java.io.PrintStream.println(float)",

   339                 "void java.io.PrintStream.println(double)",

   340                 "void java.io.PrintStream.println(char[])",

   341                 "void java.io.PrintStream.println(String)",

   342                 "void java.io.PrintStream.println(Object)");

   343     }

   344 

   345     public void testErroneous() {

   346         assertCompletion("Undefined.|");

   347         assertSignature("does.not.exist|");

   348     }

   349 

   350     public void testClinit() {

   351         assertEval("enum E{;}");

   352         assertEval("class C{static{}}");

   353         assertCompletionIncludesExcludes("E.|", Collections.emptySet(), new HashSet<>(Collections.singletonList("<clinit>")));

   354         assertCompletionIncludesExcludes("C.|", Collections.emptySet(), new HashSet<>(Collections.singletonList("<clinit>")));

   355     }

   356 

   357     public void testMethodHeaderContext() {

   358         assertCompletion("private void f(Runn|", "Runnable");

   359         assertCompletion("void f(Runn|", "Runnable");

   360         assertCompletion("void f(Object o1, Runn|", "Runnable");

   361         assertCompletion("void f(Object o1) throws Num|", true, "NumberFormatException");

   362         assertCompletion("void f(Object o1) throws java.lang.Num|", true, "NumberFormatException");

   363         assertEval("class HogeHoge {static class HogeHogeException extends Exception {}}");

   364         assertCompletion("void f(Object o1) throws Hoge|", "HogeHoge");

   365         assertCompletion("void f(Object o1) throws HogeHoge.|", true, "HogeHogeException");

   366     }

   367 

   368     public void testTypeVariables() {

   369         assertCompletion("class A<TYPE> { public void test() { TY|", "TYPE");

   370         assertCompletion("class A<TYPE> { public static void test() { TY|");

   371         assertCompletion("class A<TYPE> { public <TYPE> void test() { TY|", "TYPE");

   372         assertCompletion("class A<TYPE> { public static <TYPE> void test() { TY|", "TYPE");

   373     }

   374 

   375     public void testGeneric() {

   376         assertEval("import java.util.concurrent.*;");

   377         assertCompletion("java.util.List<Integ|", "Integer");

   378         assertCompletion("class A<TYPE extends Call|", "Callable");

   379         assertCompletion("class A<TYPE extends Callable<TY|", "TYPE");

   380         assertCompletion("<TYPE> void f(TY|", "TYPE");

   381         assertCompletion("class A<TYPE extends Callable<? sup|", "super");

   382         assertCompletion("class A<TYPE extends Callable<? super TY|", "TYPE");

   383     }

   384 

   385     public void testFields() {

   386         assertEval("interface Interface { int field = 0; }");

   387         Snippet clazz = classKey(assertEval("class Clazz {" +

   388                 "static int staticField = 0;" +

   389                 "int field = 0;" +

   390                 " }"));

   391         assertCompletion("Interface.fiel|", "field");

   392         assertCompletion("Clazz.staticFiel|", "staticField");

   393         assertCompletion("new Interface() {}.fiel|");

   394         assertCompletion("new Clazz().staticFiel|");

   395         assertCompletion("new Clazz().fiel|", "field");

   396         assertCompletion("new Clazz() {}.fiel|", "field");

   397         assertEval("class Clazz implements Interface {}",

   398                 ste(MAIN_SNIPPET, VALID, VALID, true, null),

   399                 ste(clazz, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

   400         assertCompletion("Clazz.fiel|", "field");

   401         assertCompletion("new Clazz().fiel|");

   402         assertCompletion("new Clazz() {}.fiel|");

   403     }

   404 

   405     public void testMethods() {

   406         assertEval("interface Interface {" +

   407                 "default int defaultMethod() { return 0; }" +

   408                 "static int staticMethod() { return 0; }" +

   409                 "}");

   410         Snippet clazz = classKey(assertEval("class Clazz {" +

   411                 "static int staticMethod() { return 0; }" +

   412                 "int method() { return 0; }" +

   413                 "}"));

   414         assertCompletion("Interface.staticMeth|", "staticMethod()");

   415         assertCompletion("Clazz.staticMeth|", "staticMethod()");

   416         assertCompletion("new Interface() {}.defaultMe||", "defaultMethod()");

   417         assertCompletion("new Clazz().staticMeth|");

   418         assertCompletion("new Clazz().meth|", "method()");

   419         assertEval("class Clazz implements Interface {}",

   420                 ste(MAIN_SNIPPET, VALID, VALID, true, null),

   421                 ste(clazz, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

   422         assertCompletion("Clazz.staticMeth|");

   423         assertCompletion("new Clazz() {}.defaultM|", "defaultMethod()");

   424     }

   425 

   426     @Test

   427     public void testUncompletedDeclaration() {

   428         assertCompletion("class Clazz { Claz|", "Clazz");

   429         assertCompletion("class Clazz { class A extends Claz|", "Clazz");

   430         assertCompletion("class Clazz { Clazz clazz; Object o = claz|", "clazz");

   431         assertCompletion("class Clazz { static Clazz clazz; Object o = claz|", "clazz");

   432         assertCompletion("class Clazz { Clazz clazz; static Object o = claz|", true);

   433         assertCompletion("class Clazz { void method(Claz|", "Clazz");

   434         assertCompletion("class A { int method() { return 0; } int a = meth|", "method()");

   435         assertCompletion("class A { int field = 0; int method() { return fiel|", "field");

   436         assertCompletion("class A { static int method() { return 0; } int a = meth|", "method()");

   437         assertCompletion("class A { static int field = 0; int method() { return fiel|", "field");

   438         assertCompletion("class A { int method() { return 0; } static int a = meth|", true);

   439         assertCompletion("class A { int field = 0; static int method() { return fiel|", true);

   440     }

   441 

   442     @Test

   443     public void testClassDeclaration() {

   444         assertEval("void ClazzM() {}");

   445         assertEval("void InterfaceM() {}");

   446         assertEval("interface Interface {}");

   447         assertCompletion("interface A extends Interf|", "Interface");

   448         assertCompletion("class A implements Interf|", "Interface");

   449         assertEval("class Clazz {}");

   450         assertCompletion("class A extends Claz|", "Clazz");

   451         assertCompletion("class A extends Clazz implements Interf|", "Interface");

   452         assertEval("interface Interface1 {}");

   453         assertCompletion("class A extends Clazz implements Interface, Interf|", "Interface", "Interface1");

   454         assertCompletion("interface A implements Claz|");

   455         assertCompletion("interface A implements Inter|");

   456         assertCompletion("class A implements Claz|", true);

   457         assertCompletion("class A extends Clazz implements Interface, Interf|", true, "Interface1");

   458         assertCompletion("class A extends Clazz implements Interface, Interf|", true, "Interface1");

   459         assertEval("class InterfaceClazz {}");

   460         assertCompletion("class A <T extends Claz|", "Clazz");

   461         assertCompletion("class A <T extends Interf|", "Interface", "Interface1", "InterfaceClazz");

   462         assertCompletion("class A <T extends Interface & Interf|", "Interface", "Interface1", "InterfaceClazz");

   463         assertCompletion("class A <T extends Clazz & Interf|", "Interface", "Interface1", "InterfaceClazz");

   464         assertCompletion("class A <T extends Claz|", true, "Clazz");

   465         assertCompletion("class A <T extends Interf|", true, "Interface", "Interface1", "InterfaceClazz");

   466         assertCompletion("class A <T extends Interface & Interf|", true, "Interface1");

   467         assertCompletion("class A <T extends Clazz & Interf|", true, "Interface", "Interface1");

   468     }

   469 

   470     public void testMethodDeclaration() {

   471         assertEval("void ClazzM() {}");

   472         assertEval("void InterfaceM() {}");

   473         assertEval("interface Interface {}");

   474         assertCompletion("void m(Interf|", "Interface");

   475         assertCompletion("void m(Interface i1, Interf|", "Interface");

   476         assertEval("class InterfaceException extends Exception {}");

   477         assertCompletion("void m(Interface i1) throws Interf|", "Interface", "InterfaceException");

   478         assertCompletion("void m(Interface i1) throws Interf|", true, "InterfaceException");

   479     }

   480 

   481     public void testDocumentationOfUserDefinedMethods() {

   482         assertEval("void f() {}");

   483         assertSignature("f(|", "void f()");

   484         assertEval("void f(int i) {}");

   485         assertSignature("f(|", "void f()", "void f(int i)");

   486         assertEval("<T> void f(T... ts) {}", DiagCheck.DIAG_WARNING, DiagCheck.DIAG_OK);

   487         assertSignature("f(|", "void f()", "void f(int i)", "void <T>f(T... ts)");

   488         assertEval("class A {}");

   489         assertEval("void f(A a) {}");

   490         assertSignature("f(|", "void f()", "void f(int i)", "void <T>f(T... ts)", "void f(A a)");

   491     }

   492 

   493     public void testClass() {

   494         assertSignature("String|", "java.lang.String");

   495     }

   496 

   497     public void testDocumentationOfUserDefinedConstructors() {

   498         Snippet a = classKey(assertEval("class A {}"));

   499         assertSignature("new A(|", "A()");

   500         Snippet a2 = classKey(assertEval("class A { A() {} A(int i) {}}",

   501                 ste(MAIN_SNIPPET, VALID, VALID, true, null),

   502                 ste(a, VALID, OVERWRITTEN, false, MAIN_SNIPPET)));

   503         assertSignature("new A(|", "A()", "A(int i)");

   504         assertEval("class A<T> { A(T a) {} A(int i) {} <U> A(T t, U u) {}}",

   505                 ste(MAIN_SNIPPET, VALID, VALID, true, null),

   506                 ste(a2, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

   507         assertSignature("new A(|", "A<T>(T a)", "A<T>(int i)", "<U> A<T>(T t, U u)");

   508     }

   509 

   510     public void testDocumentationOfOverriddenMethods() throws Exception {

   511         dontReadParameterNamesFromClassFile();

   512         assertSignature("\"\".wait(|",

   513             "void Object.wait(long) throws InterruptedException",

   514             "void Object.wait(long, int) throws InterruptedException",

   515             "void Object.wait() throws InterruptedException");

   516         assertEval("class Base {void method() {}}");

   517         Snippet e = classKey(assertEval("class Extend extends Base {}"));

   518         assertSignature("new Extend().method(|", "void Base.method()");

   519         assertEval("class Extend extends Base {void method() {}}",

   520                 ste(MAIN_SNIPPET, VALID, VALID, true, null),

   521                 ste(e, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

   522         assertSignature("new Extend().method(|", "void Extend.method()");

   523     }

   524 

   525     public void testDocumentationOfInvisibleMethods() {

   526         assertSignature("Object.wait(|");

   527         assertSignature("\"\".indexOfSupplementary(|");

   528         Snippet a = classKey(assertEval("class A {void method() {}}"));

   529         assertSignature("A.method(|");

   530         assertEval("class A {private void method() {}}",

   531                 ste(MAIN_SNIPPET, VALID, VALID, true, null),

   532                 ste(a, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

   533         assertSignature("new A().method(|");

   534     }

   535 

   536     public void testDocumentationOfInvisibleConstructors() {

   537         assertSignature("new Compiler(|");

   538         assertEval("class A { private A() {} }");

   539         assertSignature("new A(|");

   540     }

   541 

   542     public void testDocumentationWithBoxing() {

   543         assertEval("int primitive = 0;");

   544         assertEval("Integer boxed = 0;");

   545         assertEval("Object object = null;");

   546         assertEval("void method(int n, Object o) { }");

   547         assertEval("void method(Object n, int o) { }");

   548         assertSignature("method(primitive,|",

   549                 "void method(int n, Object o)",

   550                 "void method(Object n, int o)");

   551         assertSignature("method(boxed,|",

   552                 "void method(int n, Object o)",

   553                 "void method(Object n, int o)");

   554         assertSignature("method(object,|",

   555                 "void method(Object n, int o)");

   556     }

   557 

   558     public void testDocumentationWithGenerics() {

   559         class TestDocumentationWithGenerics {

   560             private final Function<Integer, String> codeFacotry;

   561             private final BiFunction<String, Integer, String> evalFormatter;

   562             private final BiFunction<String, Integer, String> docFormatter;

   563             int count;

   564 

   565             TestDocumentationWithGenerics(

   566                     Function<Integer, String> codeFactory,

   567                     BiFunction<String, Integer, String> evalFormatter,

   568                     BiFunction<String, Integer, String> documentationFormatter) {

   569                 this.codeFacotry = codeFactory;

   570                 this.evalFormatter = evalFormatter;

   571                 this.docFormatter = documentationFormatter;

   572             }

   573 

   574             void assertDoc(String generics) {

   575                 assertDoc(generics, generics);

   576             }

   577 

   578             void assertDoc(String generics, String expectedGenerics) {

   579                 assertEval(evalFormatter.apply(generics, count));

   580                 assertSignature(codeFacotry.apply(count), docFormatter.apply(expectedGenerics, count));

   581                 count++;

   582             }

   583         }

   584 

   585         TestDocumentationWithGenerics[] tests = {

   586             new TestDocumentationWithGenerics(

   587                     i -> "f" + i + "(|",

   588                     (g, i) -> "<" + g + "> void f" + i + "() {}",

   589                     (g, i) -> "void <" + g + ">f" + i + "()"

   590             ),

   591             new TestDocumentationWithGenerics(

   592                     i -> "new C" + i + "().f(|",

   593                     (g, i) -> "class C" + i + "<" + g + "> { void f() {} }",

   594                     (g, i) -> "void C" + i + "<" + g + ">.f()"

   595             )

   596         };

   597 

   598         Arrays.stream(tests).forEach(t -> {

   599                 t.assertDoc("T");

   600                 t.assertDoc("T extends Object",

   601                         "T");

   602                 t.assertDoc("T extends String");

   603                 t.assertDoc("T extends java.lang.String",

   604                         "T extends String");

   605                 t.assertDoc("T extends Number & Comparable<T>");

   606                 t.assertDoc("T extends java.io.Serializable & CharSequence");

   607                 t.assertDoc("K, D, M extends java.util.Map<K, D>",

   608                         "K, D, M extends java.util.Map<K,D>");

   609         });

   610     }

   611 

   612     public void testVarArgs() {

   613         assertEval("int i = 0;");

   614         assertEval("class Foo1 { static void m(int... i) { } } ");

   615         assertCompletion("Foo1.m(|", true, "i");

   616         assertCompletion("Foo1.m(i, |", true, "i");

   617         assertCompletion("Foo1.m(i, i, |", true, "i");

   618         assertEval("class Foo2 { static void m(String s, int... i) { } } ");

   619         assertCompletion("Foo2.m(|", true);

   620         assertCompletion("Foo2.m(i, |", true);

   621         assertCompletion("Foo2.m(\"\", |", true, "i");

   622         assertCompletion("Foo2.m(\"\", i, |", true, "i");

   623         assertCompletion("Foo2.m(\"\", i, i, |", true, "i");

   624         assertEval("class Foo3 { Foo3(String s, int... i) { } } ");

   625         assertCompletion("new Foo3(|", true);

   626         assertCompletion("new Foo3(i, |", true);

   627         assertCompletion("new Foo3(\"\", |", true, "i");

   628         assertCompletion("new Foo3(\"\", i, |", true, "i");

   629         assertCompletion("new Foo3(\"\", i, i, |", true, "i");

   630         assertEval("int[] ia = null;");

   631         assertCompletion("Foo1.m(ia, |", true);

   632         assertEval("class Foo4 { static void m(int... i) { } static void m(int[] ia, String str) { } } ");

   633         assertEval("String str = null;");

   634         assertCompletion("Foo4.m(ia, |", true, "str");

   635     }

   636 

   637     public void testConstructorAsMemberOf() {

   638         assertEval("class Baz<X> { Baz(X x) { } } ");

   639         assertEval("String str = null;");

   640         assertEval("Integer i = null;");

   641         assertCompletion("new Baz(|", true, "i", "str");

   642         assertCompletion("new Baz<String>(|", true, "str");

   643         assertCompletion("Baz<String> bz = new Baz<>(|", true, "str");

   644         assertEval("class Foo { static void m(String str) {} static void m(Baz<String> baz) {} }");

   645         assertCompletion("Foo.m(new Baz<>(|", true, "str");

   646     }

   647 

   648     @BeforeMethod

   649     public void setUp() {

   650         super.setUp();

   651 

   652         Path srcZip = Paths.get("src.zip");

   653 

   654         try (JarOutputStream out = new JarOutputStream(Files.newOutputStream(srcZip))) {

   655             out.putNextEntry(new JarEntry("java/lang/System.java"));

   656             out.write(("package java.lang;\n" +

   657                        "public class System {\n" +

   658                        "    public String getProperty(String key) { return null; }\n" +

   659                        "    public String getProperty(String key, String def) { return def; }\n" +

   660                        "}\n").getBytes());

   661         } catch (IOException ex) {

   662             throw new IllegalStateException(ex);

   663         }

   664 

   665         try {

   666             Field availableSources = getAnalysis().getClass().getDeclaredField("availableSources");

   667             availableSources.setAccessible(true);

   668             availableSources.set(getAnalysis(), Arrays.asList(srcZip));

   669         } catch (NoSuchFieldException | IllegalArgumentException | IllegalAccessException ex) {

   670             throw new IllegalStateException(ex);

   671         }

   672     }

   673 

   674     private void dontReadParameterNamesFromClassFile() throws Exception {

   675         Field keepParameterNames = getAnalysis().getClass().getDeclaredField("keepParameterNames");

   676         keepParameterNames.setAccessible(true);

   677         keepParameterNames.set(getAnalysis(), new String[0]);

   678     }

   679 

   680     @Test(enabled = false) //TODO 8171829

   681     public void testBrokenClassFile2() throws IOException {

   682         Path broken = outDir.resolve("broken");

   683         compiler.compile(broken,

   684                 "package p;\n" +

   685                 "public class BrokenA {\n" +

   686                 "}",

   687                 "package p.q;\n" +

   688                 "public class BrokenB {\n" +

   689                 "}",

   690                 "package p;\n" +

   691                 "public class BrokenC {\n" +

   692                 "}");

   693         Path cp = compiler.getPath(broken);

   694         Path target = cp.resolve("p").resolve("BrokenB.class");

   695         Files.deleteIfExists(target);

   696         Files.move(cp.resolve("p").resolve("q").resolve("BrokenB.class"), target);

   697         addToClasspath(cp);

   698 

   699         assertEval("import p.*;");

   700         assertCompletion("Broke|", "BrokenA", "BrokenC");

   701     }

   702 }