263 lines
11 KiB
Java
263 lines
11 KiB
Java
/*
|
|
* 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.
|
|
*/
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.StringWriter;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.stream.Collectors;
|
|
|
|
import javax.lang.model.element.Modifier;
|
|
import javax.tools.JavaCompiler;
|
|
import javax.tools.JavaFileObject;
|
|
import javax.tools.StandardJavaFileManager;
|
|
import javax.tools.ToolProvider;
|
|
|
|
import com.sun.source.tree.BlockTree;
|
|
import com.sun.source.tree.BreakTree;
|
|
import com.sun.source.tree.CaseTree;
|
|
import com.sun.source.tree.ClassTree;
|
|
import com.sun.source.tree.CompilationUnitTree;
|
|
import com.sun.source.tree.ContinueTree;
|
|
import com.sun.source.tree.DoWhileLoopTree;
|
|
import com.sun.source.tree.ExpressionStatementTree;
|
|
import com.sun.source.tree.ForLoopTree;
|
|
import com.sun.source.tree.IfTree;
|
|
import com.sun.source.tree.ImportTree;
|
|
import com.sun.source.tree.LabeledStatementTree;
|
|
import com.sun.source.tree.LineMap;
|
|
import com.sun.source.tree.MethodTree;
|
|
import com.sun.source.tree.ReturnTree;
|
|
import com.sun.source.tree.StatementTree;
|
|
import com.sun.source.tree.SwitchTree;
|
|
import com.sun.source.tree.Tree;
|
|
import com.sun.source.tree.WhileLoopTree;
|
|
import com.sun.source.util.SourcePositions;
|
|
import com.sun.source.util.Trees;
|
|
import com.sun.tools.javac.api.JavacTaskImpl;
|
|
|
|
import jdk.jshell.SourceCodeAnalysis;
|
|
|
|
import org.testng.annotations.DataProvider;
|
|
import org.testng.annotations.Test;
|
|
|
|
import static java.lang.Integer.max;
|
|
import static java.lang.Integer.min;
|
|
import static jdk.jshell.SourceCodeAnalysis.Completeness.*;
|
|
|
|
public class CompletenessStressTest extends KullaTesting {
|
|
public final static String JDK_ROOT_SRC_PROP = "jdk.root.src";
|
|
public final static String JDK_ROOT_SRC;
|
|
|
|
static {
|
|
JDK_ROOT_SRC = System.getProperty(JDK_ROOT_SRC_PROP);
|
|
}
|
|
|
|
public File getSourceFile(String fileName) {
|
|
for (File dir : getDirectoriesToTest()) {
|
|
File file = new File(dir, fileName);
|
|
if (file.exists()) {
|
|
return file;
|
|
}
|
|
}
|
|
throw new AssertionError("File not found: " + fileName);
|
|
}
|
|
|
|
public File[] getDirectoriesToTest() {
|
|
return new File[]{
|
|
new File(JDK_ROOT_SRC, "langtools/src"),
|
|
new File(JDK_ROOT_SRC, "jaxp/src"),
|
|
new File(JDK_ROOT_SRC, "jaxws/src"),
|
|
new File(JDK_ROOT_SRC, "jdk/src"),
|
|
new File(JDK_ROOT_SRC, "corba/src")
|
|
};
|
|
}
|
|
|
|
@DataProvider(name = "crawler")
|
|
public Object[][] dataProvider() throws IOException {
|
|
File[] srcDirs = getDirectoriesToTest();
|
|
List<String[]> list = new ArrayList<>();
|
|
for (File srcDir : srcDirs) {
|
|
String srcDirName = srcDir.getAbsolutePath();
|
|
// this is just to obtain pretty test names for testng tests
|
|
List<String[]> a = Files.walk(Paths.get(srcDirName))
|
|
.map(Path::toFile)
|
|
.map(File::getAbsolutePath)
|
|
.filter(n -> n.endsWith(".java"))
|
|
.map(n -> n.replace(srcDirName, ""))
|
|
.map(n -> new String[]{n})
|
|
.collect(Collectors.toList());
|
|
if (a.isEmpty()) {
|
|
throw new AssertionError("Java sources have not been found in directory: " + srcDirName);
|
|
}
|
|
list.addAll(a);
|
|
}
|
|
return list.toArray(new String[list.size()][]);
|
|
}
|
|
|
|
@Test(dataProvider = "crawler")
|
|
public void testFile(String fileName) throws IOException {
|
|
File file = getSourceFile(fileName);
|
|
final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
|
|
final StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
|
|
boolean success = true;
|
|
StringWriter writer = new StringWriter();
|
|
writer.write("Testing : " + file.toString() + "\n");
|
|
String text = new String(Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8);
|
|
Iterable<? extends JavaFileObject> compilationUnits = fileManager.getJavaFileObjects(file);
|
|
JavacTaskImpl task = (JavacTaskImpl) compiler.getTask(null, fileManager, null, null, null, compilationUnits);
|
|
Iterable<? extends CompilationUnitTree> asts = task.parse();
|
|
Trees trees = Trees.instance(task);
|
|
SourcePositions sp = trees.getSourcePositions();
|
|
|
|
for (CompilationUnitTree cut : asts) {
|
|
for (ImportTree imp : cut.getImports()) {
|
|
success &= testStatement(writer, sp, text, cut, imp);
|
|
}
|
|
for (Tree decl : cut.getTypeDecls()) {
|
|
success &= testStatement(writer, sp, text, cut, decl);
|
|
if (decl instanceof ClassTree) {
|
|
ClassTree ct = (ClassTree) decl;
|
|
for (Tree mem : ct.getMembers()) {
|
|
if (mem instanceof MethodTree) {
|
|
MethodTree mt = (MethodTree) mem;
|
|
BlockTree bt = mt.getBody();
|
|
// No abstract methods or constructors
|
|
if (bt != null && mt.getReturnType() != null) {
|
|
// The modifiers synchronized, abstract, and default are not allowed on
|
|
// top-level declarations and are errors.
|
|
Set<Modifier> modifier = mt.getModifiers().getFlags();
|
|
if (!modifier.contains(Modifier.ABSTRACT)
|
|
&& !modifier.contains(Modifier.SYNCHRONIZED)
|
|
&& !modifier.contains(Modifier.DEFAULT)) {
|
|
success &= testStatement(writer, sp, text, cut, mt);
|
|
}
|
|
testBlock(writer, sp, text, cut, bt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fileManager.close();
|
|
if (!success) {
|
|
throw new AssertionError(writer.toString());
|
|
}
|
|
}
|
|
|
|
private boolean isLegal(StatementTree st) {
|
|
return !(st instanceof ReturnTree) &&
|
|
!(st instanceof ContinueTree) && !(st instanceof BreakTree);
|
|
}
|
|
|
|
private boolean testBranch(StringWriter writer, SourcePositions sp, String text, CompilationUnitTree cut, StatementTree statementTree) {
|
|
if (statementTree instanceof BlockTree) {
|
|
return testBlock(writer, sp, text, cut, (BlockTree) statementTree);
|
|
} else if (isLegal(statementTree)) {
|
|
return testStatement(writer, sp, text, cut, statementTree);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private boolean testBlock(StringWriter writer, SourcePositions sp, String text, CompilationUnitTree cut, BlockTree blockTree) {
|
|
boolean success = true;
|
|
for (StatementTree st : blockTree.getStatements()) {
|
|
if (isLegal(st)) {
|
|
success &= testStatement(writer, sp, text, cut, st);
|
|
}
|
|
if (st instanceof IfTree) {
|
|
IfTree ifTree = (IfTree) st;
|
|
success &= testBranch(writer, sp, text, cut, ifTree.getThenStatement());
|
|
success &= testBranch(writer, sp, text, cut, ifTree.getElseStatement());
|
|
} else if (st instanceof WhileLoopTree) {
|
|
WhileLoopTree whileLoopTree = (WhileLoopTree) st;
|
|
success &= testBranch(writer, sp, text, cut, whileLoopTree.getStatement());
|
|
} else if (st instanceof DoWhileLoopTree) {
|
|
DoWhileLoopTree doWhileLoopTree = (DoWhileLoopTree) st;
|
|
success &= testBranch(writer, sp, text, cut, doWhileLoopTree.getStatement());
|
|
} else if (st instanceof ForLoopTree) {
|
|
ForLoopTree forLoopTree = (ForLoopTree) st;
|
|
success &= testBranch(writer, sp, text, cut, forLoopTree.getStatement());
|
|
} else if (st instanceof LabeledStatementTree) {
|
|
LabeledStatementTree labelTree = (LabeledStatementTree) st;
|
|
success &= testBranch(writer, sp, text, cut, labelTree.getStatement());
|
|
} else if (st instanceof SwitchTree) {
|
|
SwitchTree switchTree = (SwitchTree) st;
|
|
for (CaseTree caseTree : switchTree.getCases()) {
|
|
for (StatementTree statementTree : caseTree.getStatements()) {
|
|
success &= testBranch(writer, sp, text, cut, statementTree);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
|
|
private boolean testStatement(StringWriter writer, SourcePositions sp, String text, CompilationUnitTree cut, Tree statement) {
|
|
if (statement == null) {
|
|
return true;
|
|
}
|
|
int start = (int) sp.getStartPosition(cut, statement);
|
|
int end = (int) sp.getEndPosition(cut, statement);
|
|
char ch = text.charAt(end - 1);
|
|
SourceCodeAnalysis.Completeness expected = COMPLETE;
|
|
LineMap lineMap = cut.getLineMap();
|
|
int row = (int) lineMap.getLineNumber(start);
|
|
int column = (int) lineMap.getColumnNumber(start);
|
|
switch (ch) {
|
|
case ',':
|
|
case ';':
|
|
expected = (statement instanceof ExpressionStatementTree)
|
|
? COMPLETE
|
|
: COMPLETE_WITH_SEMI;
|
|
--end;
|
|
break;
|
|
case '}':
|
|
break;
|
|
default:
|
|
writer.write(String.format("Unexpected end: row %d, column %d: '%c' -- %s\n",
|
|
row, column, ch, text.substring(start, end)));
|
|
return true;
|
|
}
|
|
String unit = text.substring(start, end);
|
|
SourceCodeAnalysis.CompletionInfo ci = getAnalysis().analyzeCompletion(unit);
|
|
if (ci.completeness() != expected) {
|
|
if (expected == COMPLETE_WITH_SEMI && (ci.completeness() == CONSIDERED_INCOMPLETE || ci.completeness() == EMPTY)) {
|
|
writer.write(String.format("Empty statement: row %d, column %d: -- %s\n",
|
|
start, end, unit));
|
|
} else {
|
|
writer.write(String.format("Expected %s got %s: '%s' row %d, column %d: -- %s\n",
|
|
expected, ci.completeness(), unit, row, column, unit));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|