8152897: refactor ToolBox to allow reduced documented dependencies
Reviewed-by: vromero
/*
* Copyright (c) 2015, 2016, 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 8141092
* @summary Test Completion
* @modules jdk.compiler/com.sun.tools.javac.api
* jdk.compiler/com.sun.tools.javac.main
* jdk.jdeps/com.sun.tools.javap
* @library /tools/lib
* @build toolbox.ToolBox toolbox.JarTask toolbox.JavacTask
* @build KullaTesting TestingInputStream Compiler
* @run testng CompletionSuggestionTest
*/
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Collections;
import java.util.Set;
import java.util.HashSet;
import jdk.jshell.Snippet;
import org.testng.annotations.Test;
import static jdk.jshell.Snippet.Status.VALID;
import static jdk.jshell.Snippet.Status.OVERWRITTEN;
@Test
public class CompletionSuggestionTest extends KullaTesting {
private final Compiler compiler = new Compiler();
private final Path outDir = Paths.get("completion_suggestion_test");
public void testMemberExpr() {
assertEval("class Test { static void test() { } }");
assertCompletion("Test.t|", "test()");
assertEval("Test ccTestInstance = new Test();");
assertCompletion("ccTestInstance.t|", "toString()");
assertCompletion(" ccTe|", "ccTestInstance");
assertCompletion("String value = ccTestInstance.to|", "toString()");
assertCompletion("java.util.Coll|", "Collection", "Collections");
assertCompletion("String.cla|", "class");
assertCompletion("boolean.cla|", "class");
assertCompletion("byte.cla|", "class");
assertCompletion("short.cla|", "class");
assertCompletion("char.cla|", "class");
assertCompletion("int.cla|", "class");
assertCompletion("float.cla|", "class");
assertCompletion("long.cla|", "class");
assertCompletion("double.cla|", "class");
assertCompletion("void.cla|", "class");
assertCompletion("Object[].|", "class");
assertCompletion("int[].|", "class");
assertEval("Object[] ao = null;");
assertCompletion("int i = ao.|", "length");
assertEval("int[] ai = null;");
assertCompletion("int i = ai.|", "length");
assertCompletionIncludesExcludes("\"\".|",
new HashSet<>(Collections.emptyList()),
new HashSet<>(Arrays.asList("String(")));
assertEval("double d = 0;");
assertEval("void m() {}");
assertCompletionIncludesExcludes("d.|",
new HashSet<>(Collections.emptyList()),
new HashSet<>(Arrays.asList("class")));
assertCompletionIncludesExcludes("m().|",
new HashSet<>(Collections.emptyList()),
new HashSet<>(Arrays.asList("class")));
assertEval("class C {class D {} static class E {} enum F {} interface H {} void method() {} int number;}");
assertCompletionIncludesExcludes("C.|",
new HashSet<>(Arrays.asList("D", "E", "F", "H", "class")),
new HashSet<>(Arrays.asList("method()", "number")));
assertCompletionIncludesExcludes("new C().|",
new HashSet<>(Arrays.asList("method()", "number")),
new HashSet<>(Arrays.asList("D", "E", "F", "H", "class")));
assertCompletionIncludesExcludes("new C() {}.|",
new HashSet<>(Arrays.asList("method()", "number")),
new HashSet<>(Arrays.asList("D", "E", "F", "H", "class")));
}
public void testStartOfExpression() {
assertEval("int ccTest = 0;");
assertCompletion("System.err.println(cc|", "ccTest");
assertCompletion("for (int i = cc|", "ccTest");
}
public void testParameter() {
assertCompletion("class C{void method(int num){num|", "num");
}
public void testPrimitive() {
Set<String> primitives = new HashSet<>(Arrays.asList("boolean", "char", "byte", "short", "int", "long", "float", "double"));
Set<String> onlyVoid = new HashSet<>(Collections.singletonList("void"));
Set<String> primitivesOrVoid = new HashSet<>(primitives);
primitivesOrVoid.addAll(onlyVoid);
assertCompletionIncludesExcludes("|",
primitivesOrVoid,
new HashSet<>(Collections.emptyList()));
assertCompletionIncludesExcludes("int num = |",
primitivesOrVoid,
new HashSet<>(Collections.emptyList()));
assertCompletionIncludesExcludes("num = |",
primitivesOrVoid,
new HashSet<>(Collections.emptyList()));
assertCompletionIncludesExcludes("class C{void m() {|",
primitivesOrVoid,
new HashSet<>(Collections.emptyList()));
assertCompletionIncludesExcludes("void method(|",
primitives,
onlyVoid);
assertCompletionIncludesExcludes("void method(int num, |",
primitives,
onlyVoid);
assertCompletion("new java.util.ArrayList<doub|");
assertCompletion("class A extends doubl|");
assertCompletion("class A implements doubl|");
assertCompletion("interface A extends doubl|");
assertCompletion("enum A implements doubl|");
assertCompletion("class A<T extends doubl|");
}
public void testEmpty() {
assertCompletionIncludesExcludes("|",
new HashSet<>(Arrays.asList("Object", "Void")),
new HashSet<>(Arrays.asList("$REPL00DOESNOTMATTER")));
assertCompletionIncludesExcludes("V|",
new HashSet<>(Collections.singletonList("Void")),
new HashSet<>(Collections.singletonList("Object")));
assertCompletionIncludesExcludes("{ |",
new HashSet<>(Arrays.asList("Object", "Void")),
new HashSet<>(Arrays.asList("$REPL00DOESNOTMATTER")));
}
public void testSmartCompletion() {
assertEval("int ccTest1 = 0;");
assertEval("int ccTest2 = 0;");
assertEval("String ccTest3 = null;");
assertEval("void method(int i, String str) { }");
assertEval("void method(String str, int i) { }");
assertEval("java.util.List<String> list = null;");
assertCompletion("int ccTest4 = |", true, "ccTest1", "ccTest2");
assertCompletion("ccTest2 = |", true, "ccTest1", "ccTest2");
assertCompletion("int ccTest4 = ccTe|", "ccTest1", "ccTest2", "ccTest3");
assertCompletion("int ccTest4 = ccTest3.len|", true, "length()");
assertCompletion("method(|", true, "ccTest1", "ccTest2", "ccTest3");
assertCompletion("method(0, |", true, "ccTest3");
assertCompletion("list.add(|", true, "ccTest1", "ccTest2", "ccTest3");
assertCompletion("list.add(0, |", true, "ccTest3");
assertCompletion("new String(|", true, "ccTest3");
assertCompletion("new String(new char[0], |", true, "ccTest1", "ccTest2");
assertCompletionIncludesExcludes("new jav|", new HashSet<>(Arrays.asList("java", "javax")), Collections.emptySet());
assertCompletion("Class<String> clazz = String.c|", true, "class");
Snippet klass = classKey(assertEval("class Klass {void method(int n) {} private void method(String str) {}}"));
assertCompletion("new Klass().method(|", true, "ccTest1", "ccTest2");
Snippet klass2 = classKey(assertEval("class Klass {static void method(int n) {} void method(String str) {}}",
ste(MAIN_SNIPPET, VALID, VALID, true, null),
ste(klass, VALID, OVERWRITTEN, false, MAIN_SNIPPET)));
assertCompletion("Klass.method(|", true, "ccTest1", "ccTest2");
assertEval("class Klass {Klass(int n) {} private Klass(String str) {}}",
ste(MAIN_SNIPPET, VALID, VALID, true, null),
ste(klass2, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
assertCompletion("new Klass(|", true, "ccTest1", "ccTest2");
}
public void testSmartCompletionInOverriddenMethodInvocation() {
assertEval("int ccTest1 = 0;");
assertEval("int ccTest2 = 0;");
assertEval("String ccTest3 = null;");
assertCompletion("\"\".wait(|", true, "ccTest1", "ccTest2");
assertEval("class Base {void method(int n) {}}");
assertEval("class Extend extends Base {}");
assertCompletion("new Extend().method(|", true, "ccTest1", "ccTest2");
}
public void testSmartCompletionForBoxedType() {
assertEval("int ccTest1 = 0;");
assertEval("Integer ccTest2 = 0;");
assertEval("Object ccTest3 = null;");
assertEval("int method1(int n) {return n;}");
assertEval("Integer method2(Integer n) {return n;}");
assertEval("Object method3(Object o) {return o;}");
assertCompletion("int ccTest4 = |", true, "ccTest1", "ccTest2", "method1(", "method2(");
assertCompletion("Integer ccTest4 = |", true, "ccTest1", "ccTest2", "method1(", "method2(");
assertCompletion("Object ccTest4 = |", true, "ccTest1", "ccTest2", "ccTest3", "method1(", "method2(", "method3(");
assertCompletion("method1(|", true, "ccTest1", "ccTest2", "method1(", "method2(");
assertCompletion("method2(|", true, "ccTest1", "ccTest2", "method1(", "method2(");
assertCompletion("method3(|", true, "ccTest1", "ccTest2", "ccTest3", "method1(", "method2(", "method3(");
}
public void testNewClass() {
assertCompletion("String str = new Strin|", "String(", "StringBuffer(", "StringBuilder(", "StringIndexOutOfBoundsException(");
assertCompletion("String str = new java.lang.Strin|", "String(", "StringBuffer(", "StringBuilder(", "StringIndexOutOfBoundsException(");
assertCompletion("String str = new |", true, "String(");
assertCompletion("String str = new java.lang.|", true, "String(");
assertCompletion("throw new Strin|", true, "StringIndexOutOfBoundsException(");
assertEval("class A{class B{} class C {C(int n) {}} static class D {} interface I {}}");
assertEval("A a;");
assertCompletion("new A().new |", "B()", "C(");
assertCompletion("a.new |", "B()", "C(");
assertCompletion("new A.|", "D()");
assertEval("enum E{; class A {}}");
assertEval("interface I{; class A {}}");
assertCompletion("new E.|", "A()");
assertCompletion("new I.|", "A()");
assertCompletion("new String(I.A|", "A");
}
public void testFullyQualified() {
assertCompletion("Optional<String> opt = java.u|", "util");
assertCompletionIncludesExcludes("Optional<Strings> opt = java.util.O|", new HashSet<>(Collections.singletonList("Optional")), Collections.emptySet());
assertEval("void method(java.util.Optional<String> opt) {}");
assertCompletion("method(java.u|", "util");
assertCompletion("Object.notElement.|");
assertCompletion("Object o = com.su|", "sun");
Path p1 = outDir.resolve("dir1");
compiler.compile(p1,
"package p1.p2;\n" +
"public class Test {\n" +
"}",
"package p1.p3;\n" +
"public class Test {\n" +
"}");
String jarName = "test.jar";
compiler.jar(p1, jarName, "p1/p2/Test.class", "p1/p3/Test.class");
addToClasspath(compiler.getPath(p1.resolve(jarName)));
assertCompletionIncludesExcludes("|", new HashSet<>(Collections.singletonList("p1")), Collections.emptySet());
assertCompletion("p1.|", "p2", "p3");
assertCompletion("p1.p2.|", "Test");
assertCompletion("p1.p3.|", "Test");
}
public void testCheckAccessibility() {
assertCompletion("java.util.regex.Pattern.co|", "compile(");
}
public void testCompletePackages() {
assertCompletion("java.u|", "util");
assertCompletionIncludesExcludes("jav|", new HashSet<>(Arrays.asList("java", "javax")), Collections.emptySet());
}
public void testImports() {
assertCompletion("import java.u|", "util");
assertCompletionIncludesExcludes("import jav|", new HashSet<>(Arrays.asList("java", "javax")), Collections.emptySet());
assertCompletion("import static java.u|", "util");
assertCompletionIncludesExcludes("import static jav|", new HashSet<>(Arrays.asList("java", "javax")), Collections.emptySet());
assertCompletion("import static java.lang.Boolean.g|", "getBoolean");
assertCompletion("import java.util.*|");
assertCompletionIncludesExcludes("import java.lang.String.|",
Collections.emptySet(),
new HashSet<>(Arrays.asList("CASE_INSENSITIVE_ORDER", "copyValueOf", "format", "join", "valueOf", "class", "length")));
assertCompletionIncludesExcludes("import static java.lang.String.|",
new HashSet<>(Arrays.asList("CASE_INSENSITIVE_ORDER", "copyValueOf", "format", "join", "valueOf")),
new HashSet<>(Arrays.asList("class", "length")));
assertCompletionIncludesExcludes("import java.util.Map.|",
new HashSet<>(Arrays.asList("Entry")),
new HashSet<>(Arrays.asList("class")));
}
public void testBrokenClassFile() throws Exception {
Compiler compiler = new Compiler();
Path testOutDir = Paths.get("CompletionTestBrokenClassFile");
String input = "package test.inner; public class Test {}";
compiler.compile(testOutDir, input);
addToClasspath(compiler.getPath(testOutDir).resolve("test"));
assertCompletion("import inner.|");
}
public void testDocumentation() {
assertDocumentation("System.getProperty(|",
"java.lang.System.getProperty(java.lang.String arg0)",
"java.lang.System.getProperty(java.lang.String arg0, java.lang.String arg1)");
assertEval("char[] chars = null;");
assertDocumentation("new String(chars, |",
"java.lang.String(char[] arg0, int arg1, int arg2)");
assertDocumentation("String.format(|",
"java.lang.String.format(java.lang.String arg0, java.lang.Object... arg1)",
"java.lang.String.format(java.util.Locale arg0, java.lang.String arg1, java.lang.Object... arg2)");
assertDocumentation("\"\".getBytes(\"\"|", "java.lang.String.getBytes(int arg0, int arg1, byte[] arg2, int arg3)",
"java.lang.String.getBytes(java.lang.String arg0)",
"java.lang.String.getBytes(java.nio.charset.Charset arg0)");
assertDocumentation("\"\".getBytes(\"\" |", "java.lang.String.getBytes(int arg0, int arg1, byte[] arg2, int arg3)",
"java.lang.String.getBytes(java.lang.String arg0)",
"java.lang.String.getBytes(java.nio.charset.Charset arg0)");
}
public void testMethodsWithNoArguments() {
assertDocumentation("System.out.println(|",
"java.io.PrintStream.println()",
"java.io.PrintStream.println(boolean arg0)",
"java.io.PrintStream.println(char arg0)",
"java.io.PrintStream.println(int arg0)",
"java.io.PrintStream.println(long arg0)",
"java.io.PrintStream.println(float arg0)",
"java.io.PrintStream.println(double arg0)",
"java.io.PrintStream.println(char[] arg0)",
"java.io.PrintStream.println(java.lang.String arg0)",
"java.io.PrintStream.println(java.lang.Object arg0)");
}
public void testErroneous() {
assertCompletion("Undefined.|");
}
public void testClinit() {
assertEval("enum E{;}");
assertEval("class C{static{}}");
assertCompletionIncludesExcludes("E.|", Collections.emptySet(), new HashSet<>(Collections.singletonList("<clinit>")));
assertCompletionIncludesExcludes("C.|", Collections.emptySet(), new HashSet<>(Collections.singletonList("<clinit>")));
}
public void testMethodHeaderContext() {
assertCompletion("private void f(Runn|", "Runnable");
assertCompletion("void f(Runn|", "Runnable");
assertCompletion("void f(Object o1, Runn|", "Runnable");
assertCompletion("void f(Object o1) throws Num|", true, "NumberFormatException");
assertCompletion("void f(Object o1) throws java.lang.Num|", true, "NumberFormatException");
assertEval("class HogeHoge {static class HogeHogeException extends Exception {}}");
assertCompletion("void f(Object o1) throws Hoge|", "HogeHoge");
assertCompletion("void f(Object o1) throws HogeHoge.|", true, "HogeHogeException");
}
public void testTypeVariables() {
assertCompletion("class A<TYPE> { public void test() { TY|", "TYPE");
assertCompletion("class A<TYPE> { public static void test() { TY|");
assertCompletion("class A<TYPE> { public <TYPE> void test() { TY|", "TYPE");
assertCompletion("class A<TYPE> { public static <TYPE> void test() { TY|", "TYPE");
}
public void testGeneric() {
assertEval("import java.util.concurrent.*;");
assertCompletion("java.util.List<Integ|", "Integer");
assertCompletion("class A<TYPE extends Call|", "Callable");
assertCompletion("class A<TYPE extends Callable<TY|", "TYPE");
assertCompletion("<TYPE> void f(TY|", "TYPE");
assertCompletion("class A<TYPE extends Callable<? sup|", "super");
assertCompletion("class A<TYPE extends Callable<? super TY|", "TYPE");
}
public void testFields() {
assertEval("interface Interface { int field = 0; }");
Snippet clazz = classKey(assertEval("class Clazz {" +
"static int staticField = 0;" +
"int field = 0;" +
" }"));
assertCompletion("Interface.fiel|", "field");
assertCompletion("Clazz.staticFiel|", "staticField");
assertCompletion("new Interface() {}.fiel|");
assertCompletion("new Clazz().staticFiel|");
assertCompletion("new Clazz().fiel|", "field");
assertCompletion("new Clazz() {}.fiel|", "field");
assertEval("class Clazz implements Interface {}",
ste(MAIN_SNIPPET, VALID, VALID, true, null),
ste(clazz, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
assertCompletion("Clazz.fiel|", "field");
assertCompletion("new Clazz().fiel|");
assertCompletion("new Clazz() {}.fiel|");
}
public void testMethods() {
assertEval("interface Interface {" +
"default int defaultMethod() { return 0; }" +
"static int staticMethod() { return 0; }" +
"}");
Snippet clazz = classKey(assertEval("class Clazz {" +
"static int staticMethod() { return 0; }" +
"int method() { return 0; }" +
"}"));
assertCompletion("Interface.staticMeth|", "staticMethod()");
assertCompletion("Clazz.staticMeth|", "staticMethod()");
assertCompletion("new Interface() {}.defaultMe||", "defaultMethod()");
assertCompletion("new Clazz().staticMeth|");
assertCompletion("new Clazz().meth|", "method()");
assertEval("class Clazz implements Interface {}",
ste(MAIN_SNIPPET, VALID, VALID, true, null),
ste(clazz, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
assertCompletion("Clazz.staticMeth|");
assertCompletion("new Clazz() {}.defaultM|", "defaultMethod()");
}
@Test(enabled = false) // TODO 8129422
public void testUncompletedDeclaration() {
assertCompletion("class Clazz { Claz|", "Clazz");
assertCompletion("class Clazz { class A extends Claz|", "Clazz");
assertCompletion("class Clazz { Clazz clazz; Object o = cla|", "clazz");
assertCompletion("class Clazz { static Clazz clazz; Object o = cla|", "clazz");
assertCompletion("class Clazz { Clazz clazz; static Object o = cla|", true);
assertCompletion("class Clazz { void method(Claz|", "Clazz");
assertCompletion("class A { int method() { return 0; } int a = meth|", "method");
assertCompletion("class A { int field = 0; int method() { return fiel|", "field");
assertCompletion("class A { static int method() { return 0; } int a = meth|", "method");
assertCompletion("class A { static int field = 0; int method() { return fiel|", "field");
assertCompletion("class A { int method() { return 0; } static int a = meth|", true);
assertCompletion("class A { int field = 0; static int method() { return fiel|", true);
}
@Test(enabled = false) // TODO 8129421
public void testClassDeclaration() {
assertEval("interface Interface {}");
assertCompletion("interface A extends Interf|", "Interface");
assertCompletion("class A implements Interf|", "Interface");
assertEval("class Clazz {}");
assertCompletion("class A extends Claz|", "Clazz");
assertCompletion("class A extends Clazz implements Interf|", "Interface");
assertEval("interface Interface1 {}");
assertCompletion("class A extends Clazz implements Interface, Interf|", "Interface", "Interface1");
assertCompletion("interface A implements Claz|");
assertCompletion("interface A implements Inter|");
assertCompletion("class A implements Claz|", true);
assertCompletion("class A extends Clazz implements Interface, Interf|", true, "Interface1");
}
public void testDocumentationOfUserDefinedMethods() {
assertEval("void f() {}");
assertDocumentation("f(|", "f()");
assertEval("void f(int a) {}");
assertDocumentation("f(|", "f()", "f(int arg0)");
assertEval("<T> void f(T... a) {}", DiagCheck.DIAG_WARNING, DiagCheck.DIAG_OK);
assertDocumentation("f(|", "f()", "f(int arg0)", "f(T... arg0)");
assertEval("class A {}");
assertEval("void f(A a) {}");
assertDocumentation("f(|", "f()", "f(int arg0)", "f(T... arg0)", "f(A arg0)");
}
public void testDocumentationOfUserDefinedConstructors() {
Snippet a = classKey(assertEval("class A {}"));
assertDocumentation("new A(|", "A()");
Snippet a2 = classKey(assertEval("class A { A() {} A(int a) {}}",
ste(MAIN_SNIPPET, VALID, VALID, true, null),
ste(a, VALID, OVERWRITTEN, false, MAIN_SNIPPET)));
assertDocumentation("new A(|", "A()", "A(int arg0)");
assertEval("class A<T> { A(T a) {} A(int a) {}}",
ste(MAIN_SNIPPET, VALID, VALID, true, null),
ste(a2, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
assertDocumentation("new A(|", "A(T arg0)", "A(int arg0)");
}
public void testDocumentationOfOverriddenMethods() {
assertDocumentation("\"\".wait(|",
"java.lang.Object.wait(long arg0)",
"java.lang.Object.wait(long arg0, int arg1)",
"java.lang.Object.wait()");
assertEval("class Base {void method() {}}");
Snippet e = classKey(assertEval("class Extend extends Base {}"));
assertDocumentation("new Extend().method(|", "Base.method()");
assertEval("class Extend extends Base {void method() {}}",
ste(MAIN_SNIPPET, VALID, VALID, true, null),
ste(e, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
assertDocumentation("new Extend().method(|", "Extend.method()");
}
public void testDocumentationOfInvisibleMethods() {
assertDocumentation("Object.wait(|", "");
assertDocumentation("\"\".indexOfSupplementary(|", "");
Snippet a = classKey(assertEval("class A {void method() {}}"));
assertDocumentation("A.method(|", "");
assertEval("class A {private void method() {}}",
ste(MAIN_SNIPPET, VALID, VALID, true, null),
ste(a, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
assertDocumentation("new A().method(|", "");
}
public void testDocumentationOfInvisibleConstructors() {
assertDocumentation("new Compiler(|", "");
assertEval("class A { private A() {} }");
assertDocumentation("new A(|", "");
}
public void testDocumentationWithBoxing() {
assertEval("int primitive = 0;");
assertEval("Integer boxed = 0;");
assertEval("Object object = null;");
assertEval("void method(int n, Object o) { }");
assertEval("void method(Object n, int o) { }");
assertDocumentation("method(primitive,|",
"method(int arg0, java.lang.Object arg1)",
"method(java.lang.Object arg0, int arg1)");
assertDocumentation("method(boxed,|",
"method(int arg0, java.lang.Object arg1)",
"method(java.lang.Object arg0, int arg1)");
assertDocumentation("method(object,|",
"method(java.lang.Object arg0, int arg1)");
}
public void testVarArgs() {
assertEval("int i = 0;");
assertEval("class Foo1 { static void m(int... i) { } } ");
assertCompletion("Foo1.m(|", true, "i");
assertCompletion("Foo1.m(i, |", true, "i");
assertCompletion("Foo1.m(i, i, |", true, "i");
assertEval("class Foo2 { static void m(String s, int... i) { } } ");
assertCompletion("Foo2.m(|", true);
assertCompletion("Foo2.m(i, |", true);
assertCompletion("Foo2.m(\"\", |", true, "i");
assertCompletion("Foo2.m(\"\", i, |", true, "i");
assertCompletion("Foo2.m(\"\", i, i, |", true, "i");
assertEval("class Foo3 { Foo3(String s, int... i) { } } ");
assertCompletion("new Foo3(|", true);
assertCompletion("new Foo3(i, |", true);
assertCompletion("new Foo3(\"\", |", true, "i");
assertCompletion("new Foo3(\"\", i, |", true, "i");
assertCompletion("new Foo3(\"\", i, i, |", true, "i");
assertEval("int[] ia = null;");
assertCompletion("Foo1.m(ia, |", true);
assertEval("class Foo4 { static void m(int... i) { } static void m(int[] ia, String str) { } } ");
assertEval("String str = null;");
assertCompletion("Foo4.m(ia, |", true, "str");
}
public void testConstructorAsMemberOf() {
assertEval("class Baz<X> { Baz(X x) { } } ");
assertEval("String str = null;");
assertEval("Integer i = null;");
assertCompletion("new Baz(|", true, "i", "str");
assertCompletion("new Baz<String>(|", true, "str");
assertCompletion("Baz<String> bz = new Baz<>(|", true, "str");
assertEval("class Foo { static void m(String str) {} static void m(Baz<String> baz) {} }");
assertCompletion("Foo.m(new Baz<>(|", true, "str");
}
}