test/langtools/jdk/jshell/CompletenessStressTest.java - platform/libcore - Git at Google

 /*
  * 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, "nashorn/src"),
                 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;
     }
 }
	/*
	* 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, "nashorn/src"),
	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;
	}
	}