Merge pull request #184 from ponder-lab/entry_points_txt

Clean up entry point file code.

Author: khatchad

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/StreamAnalyzer.java

@@ -11,6 +11,7 @@
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Scanner;
 import java.util.Set;
 import java.util.logging.Level;
@@ -42,6 +43,7 @@
 import com.ibm.wala.util.scope.JUnitEntryPoints;
 
 import edu.cuny.hunter.streamrefactoring.core.utils.LoggerNames;
+import edu.cuny.hunter.streamrefactoring.core.utils.TimeCollector;
 import edu.cuny.hunter.streamrefactoring.core.wala.EclipseProjectAnalysisEngine;
 
 @SuppressWarnings("restriction")
@@ -51,7 +53,7 @@ public class StreamAnalyzer extends ASTVisitor {
 
 	private static final int N_FOR_STREAMS_DEFAULT = 2;
 
-	private static final String ENTRY_POINT_FILE = "entry_points.txt";
+	private static final String ENTRY_POINT_FILENAME = "entry_points.txt";
 
 	private static void addImplicitEntryPoints(Collection<Entrypoint> target, Iterable<Entrypoint> source) {
 		for (Entrypoint implicitEntryPoint : source)
@@ -117,11 +119,24 @@ public StreamAnalyzer(boolean visitDocTags, int nForStreams, boolean findImplici
 
 	/**
 	 * Analyzes this {@link StreamAnalyzer}'s streams.
-	 *
-	 * @return {@link Map} of project's analyzed along with the entry points used.
+	 * 
+	 * @return A {@link Map} of project's analyzed along with the entry points used.
+	 * @see #analyze(Optional).
 	 */
 	public Map<IJavaProject, Collection<Entrypoint>> analyze() throws CoreException {
-		LOGGER.info(() -> "Using N = " + this.getNForStreams());
+		return this.analyze(Optional.empty());
+	}
+
+	/**
+	 * Analyzes this {@link StreamAnalyzer}'s streams.
+	 *
+	 * @param collector
+	 *            To exclude from the time certain parts of the analysis.
+	 * @return A {@link Map} of project's analyzed along with the entry points used.
+	 * @see #analyze().
+	 */
+	public Map<IJavaProject, Collection<Entrypoint>> analyze(Optional<TimeCollector> collector) throws CoreException {
+		LOGGER.info(() -> "Using N = " + this.getNForStreams() + ".");
 
 		Map<IJavaProject, Collection<Entrypoint>> ret = new HashMap<>();
 
@@ -132,6 +147,9 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze() throws CoreException
 		// process each project.
 		for (IJavaProject project : projectToStreams.keySet()) {
 			// create the analysis engine for the project.
+			// exclude from the analysis because the IR will be built here.
+
+			collector.ifPresent(TimeCollector::start);
 			EclipseProjectAnalysisEngine<InstanceKey> engine = null;
 			try {
 				engine = new EclipseProjectAnalysisEngine<>(project, this.getNForStreams());
@@ -140,11 +158,12 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze() throws CoreException
 				LOGGER.log(Level.SEVERE, "Could not create analysis engine for: " + project.getElementName(), e);
 				throw new RuntimeException(e);
 			}
+			collector.ifPresent(TimeCollector::stop);
 
 			// build the call graph for the project.
 			Collection<Entrypoint> entryPoints = null;
 			try {
-				entryPoints = this.buildCallGraph(engine);
+				entryPoints = this.buildCallGraph(engine, collector);
 			} catch (IOException | CoreException | CancelException e) {
 				LOGGER.log(Level.SEVERE,
 						"Exception encountered while building call graph for: " + project.getElementName() + ".", e);
@@ -213,18 +232,27 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze() throws CoreException
 	 * @param engine
 	 *            The EclipseProjectAnalysisEngine for which to build the call
 	 *            graph.
+	 * @param collector
+	 *            A {@link TimeCollector} to exclude entry point finding.
 	 * @return The {@link Entrypoint}s used in building the {@link CallGraph}.
 	 */
-	protected Collection<Entrypoint> buildCallGraph(EclipseProjectAnalysisEngine<InstanceKey> engine)
+	protected Collection<Entrypoint> buildCallGraph(EclipseProjectAnalysisEngine<InstanceKey> engine,
+			Optional<TimeCollector> collector)
 			throws IOException, CoreException, CallGraphBuilderCancelException, CancelException {
 		// if we haven't built the call graph yet.
 		if (!this.enginesWithBuiltCallGraphsToEntrypointsUsed.keySet().contains(engine)) {
-
+			// find entry points (but exclude it from the time).
+			collector.ifPresent(TimeCollector::start);
 			Set<Entrypoint> entryPoints;
+
 			// find the entry_points.txt in the project directory
-			File entryPointFile = getEntryPointsFile(engine.getProject().getResource().getLocation(), ENTRY_POINT_FILE);
+			File entryPointFile = getEntryPointsFile(engine.getProject().getResource().getLocation(),
+					ENTRY_POINT_FILENAME);
+
+			// if the file was found,
 			if (entryPointFile != null) {
-				// find explicit entry points from entry_points.txt
+				// find explicit entry points from entry_points.txt. Ignore the explicit
+				// (annotation-based) entry points.
 				entryPoints = findEntryPointsFromFile(engine.getClassHierarchy(), entryPointFile);
 				entryPoints.forEach(ep -> LOGGER.info(() -> "Adding explicit entry point from file: " + ep));
 			} else {
@@ -233,7 +261,7 @@ protected Collection<Entrypoint> buildCallGraph(EclipseProjectAnalysisEngine<Ins
 				entryPoints.forEach(ep -> LOGGER.info(() -> "Adding explicit entry point: " + ep));
 			}
 
-			if (this.findImplicitEntryPoints) {
+			if (this.shouldFindImplicitEntryPoints()) {
 				// also find implicit entry points.
 				Iterable<Entrypoint> mainEntrypoints = makeMainEntrypoints(engine.getClassHierarchy().getScope(),
 						engine.getClassHierarchy());
@@ -242,15 +270,15 @@ protected Collection<Entrypoint> buildCallGraph(EclipseProjectAnalysisEngine<Ins
 				addImplicitEntryPoints(entryPoints, mainEntrypoints);
 			}
 
-			if (this.findImplicitTestEntryPoints) {
+			if (this.shouldFindImplicitTestEntryPoints()) {
 				// try to find test entry points.
 				Iterable<Entrypoint> jUnitEntryPoints = JUnitEntryPoints.make(engine.getClassHierarchy());
 
 				// add them as well.
 				addImplicitEntryPoints(entryPoints, jUnitEntryPoints);
 			}
 
-			if (this.findImplicitBenchmarkEntryPoints) {
+			if (this.shouldFindImplicitBenchmarkEntryPoints()) {
 				// try to find benchmark entry points.
 				Set<Entrypoint> benchmarkEntryPoints = Util.findBenchmarkEntryPoints(engine.getClassHierarchy());
 
@@ -263,6 +291,8 @@ protected Collection<Entrypoint> buildCallGraph(EclipseProjectAnalysisEngine<Ins
 				return entryPoints;
 			}
 
+			collector.ifPresent(TimeCollector::stop);
+
 			// set options.
 			AnalysisOptions options = engine.getDefaultOptions(entryPoints);
 			// Turn off reflection analysis.
@@ -306,20 +336,21 @@ private static Set<Entrypoint> findEntryPointsFromFile(IClassHierarchy classHier
 	}
 
 	/**
-	 * Search entry_points.txt in project directory recursively
+	 * Search entry_points.txt in project directory recursively.
 	 * 
-	 * @param directory:
-	 *            project directory
-	 * @param fileName:
-	 *            the target file
-	 * @return null: the file does not exist / file: find the file
+	 * @param directory
+	 *            Project directory.
+	 * @param fileName
+	 *            The target file.
+	 * @return null if the file does not exist and file if we found the file.
 	 */
 	private static File getEntryPointsFile(IPath directory, String fileName) {
-		// If file does not exist, find the file in upper level
+		// If file does not exist, find the file in upper level.
 		Path directoryPath = Paths.get(directory.toString());
+
 		File file;
 		do {
-			file = new File(directoryPath.resolve(ENTRY_POINT_FILE).toString());
+			file = new File(directoryPath.resolve(ENTRY_POINT_FILENAME).toString());
 			directoryPath = directoryPath.getParent();
 		} while (!file.exists() && directoryPath != null);
 
@@ -337,10 +368,26 @@ public void setFindImplicitEntryPoints(boolean findImplicitEntryPoints) {
 		this.findImplicitEntryPoints = findImplicitEntryPoints;
 	}
 
+	public boolean shouldFindImplicitEntryPoints() {
+		return findImplicitEntryPoints;
+	}
+
 	public void setFindImplicitTestEntryPoints(boolean findImplicitTestEntryPoints) {
 		this.findImplicitTestEntryPoints = findImplicitTestEntryPoints;
 	}
 
+	public boolean shouldFindImplicitTestEntryPoints() {
+		return findImplicitTestEntryPoints;
+	}
+
+	public boolean shouldFindImplicitBenchmarkEntryPoints() {
+		return findImplicitBenchmarkEntryPoints;
+	}
+
+	public void setFindImplicitBenchmarkEntryPoints(boolean findImplicitBenchmarkEntryPoints) {
+		this.findImplicitBenchmarkEntryPoints = findImplicitBenchmarkEntryPoints;
+	}
+
 	/**
 	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
 	 */

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/refactorings/ConvertToParallelStreamRefactoringProcessor.java

@@ -240,7 +240,7 @@ public RefactoringStatus checkFinalConditions(final IProgressMonitor monitor, fi
 			}
 
 			// analyze and set entry points.
-			this.projectToEntryPoints = analyzer.analyze();
+			this.projectToEntryPoints = analyzer.analyze(Optional.of(this.getExcludedTimeCollector()));
 
 			// map empty set to unprocessed projects.
 			for (IJavaProject project : this.getJavaProjects())

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/utils/TimeCollector.java

@@ -11,12 +11,19 @@ public class TimeCollector {
 
 	private long collectedTime;
 	private long start;
+	private boolean started;
 
 	public void start() {
+		assert !started : "Time colletor is already started.";
+		started = true;
+
 		start = System.currentTimeMillis();
 	}
 
 	public void stop() {
+		assert started : "Trying to stop a time collector that isn't started.";
+		started = false;
+
 		final long elapsed = System.currentTimeMillis() - start;
 		collectedTime += elapsed;
 	}
@@ -26,6 +33,8 @@ public long getCollectedTime() {
 	}
 
 	public void clear() {
+		assert !started : "Shouldn't clear a running time collector.";
+		
 		collectedTime = 0;
 	}
 }

edu.cuny.hunter.streamrefactoring.tests/test cases/edu/cuny/hunter/streamrefactoring/ui/tests/ConvertStreamToParallelRefactoringTest.java

@@ -1,6 +1,3 @@
-/**
- *
- */
 package edu.cuny.hunter.streamrefactoring.ui.tests;
 
 import java.io.File;
@@ -75,7 +72,7 @@ public class ConvertStreamToParallelRefactoringTest extends RefactoringTest {
 
 	private static final int RETRY_DELAY = 1000;
 
-	private static final String ENTRY_POINT_FILE = "entry_points.txt";
+	private static final String ENTRY_POINT_FILENAME = "entry_points.txt";
 
 	private static final int N_TO_USE_FOR_STREAMS_DEFAULT = 2;
 
@@ -135,49 +132,61 @@ public static Test setUpTest(Test test) {
 	}
 
 	/**
-	 * @return Path: an absolute path of entry_points.txt in the project directory
+	 * @return an absolute path of entry_points.txt in the project directory.
 	 */
-	private Path getAbsoluteProjectPath() {
-		return this.getAbsolutePath(this.getTestPath() + this.getName()).resolve(ENTRY_POINT_FILE);
+	private Path getEntryPointFileProjectSourcePath() {
+		return getAbsolutePath(this.getTestPath() + this.getName()).resolve(ENTRY_POINT_FILENAME);
 	}
 
 	/**
-	 * @return Path: an absolute path of entry_points.txt in the project directory
-	 *         of junit workspace
+	 * @return The {@link Path} of where the entry points file should be copied to
+	 *         for the current project under test.
 	 */
-	private Path getDestinationProjectPath() {
-		return getDestinationPath(this.getPackageP().getJavaProject());
+	private Path getEntryPointFileProjectDestinationPath() {
+		return getEntryPointFileDestinationPath(this.getPackageP().getJavaProject());
 	}
 
 	/**
-	 * @return Path: an absolute path of entry_points.txt in the junit workspace
+	 * @return The {@link Path} of where the entry_points.txt file should be copied
+	 *         to in the junit workspace.
 	 */
-	private Path getDestinationWorkSpacePath() {
-		return getDestinationPath(this.getPackageP().getJavaProject().getParent());
+	@SuppressWarnings("unused")
+	private Path getDestinationWorkspacePath() {
+		return getEntryPointFileDestinationPath(this.getPackageP().getJavaProject().getParent());
 	}
 
-	private Path getDestinationPath(IJavaElement element) {
-		return Paths.get(element.getResource().getLocation().toString() + File.separator + ENTRY_POINT_FILE);
+	/**
+	 * Returns the path of where the entry points file should be copied relative to
+	 * the given {@link IJavaElement}.
+	 * 
+	 * @param element
+	 *            The {@link IJavaElement} in question.
+	 * @return The {@link Path} where the entry points file should be copied
+	 *         relative to the given {@link IJavaElement}.
+	 */
+	private static Path getEntryPointFileDestinationPath(IJavaElement element) {
+		return Paths.get(element.getResource().getLocation().toString() + File.separator + ENTRY_POINT_FILENAME);
 	}
 
 	@Override
 	protected void setUp() throws Exception {
 		super.setUp();
 
 		// this is the source path.
-		Path absoluteProjectPath = getAbsoluteProjectPath();
+		Path entryPointFileProjectSourcePath = getEntryPointFileProjectSourcePath();
+		Path entryPointFileProjectDestinationPath = getEntryPointFileProjectDestinationPath();
 
 		// TODO: we also need to copy entry_points.txt to workspace directory here
 		// something like copyEntryPointFile(absoluteProjectPath,
 		// getDestinationWorkSpacePath())
-		if (copyEntryPointFile(absoluteProjectPath, getDestinationProjectPath()))
-			LOGGER.info(() -> "Copy entry_points.txt successfully");
+		if (copyEntryPointFile(entryPointFileProjectSourcePath, entryPointFileProjectDestinationPath))
+			LOGGER.info("Copied " + ENTRY_POINT_FILENAME + " successfully.");
 		else
-			LOGGER.info(() -> "entry_points.txt does not exist");
+			LOGGER.info(ENTRY_POINT_FILENAME + " does not exist.");
 	}
 
 	/**
-	 * Copy entry_points.txt from cuurent directory to the corresponding directory
+	 * Copy entry_points.txt from current directory to the corresponding directory
 	 * in junit-workspace
 	 * 
 	 * @return true: copy successfully / false: the source file does not exist
@@ -429,7 +438,7 @@ protected void tearDown() throws Exception {
 		final boolean pExists = getPackageP().exists();
 
 		// this is destination path.
-		Path destinationProjectPath = getDestinationProjectPath();
+		Path destinationProjectPath = getEntryPointFileProjectDestinationPath();
 
 		if (getEntryPointFile(destinationProjectPath) != null)
 			Files.delete(destinationProjectPath);