Add test cases for concurrent reductions (#150)

yiming-tang-cs · khatchad · commit 2c307de69eea · 2018-01-05T18:34:58.000-05:00
* add test cases and fail the stream * calculate LOC * Revert "calculate LOC" This reverts commit 034b677. * revert changing functional code * change test cases * change test * change test cases * change refactoring * delete useless importation * Remove extra space. * change name and collections * Add collector kind * remove duplication * improve format * remove overloading helper * format * remove duplication * Remove whitespace addition.
diff --git a/edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/CollectorKind.java b/edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/CollectorKind.java
@@ -0,0 +1,6 @@
+package edu.cuny.hunter.streamrefactoring.core.analysis;
+
+public enum CollectorKind {
+	CONCURRENT,
+	NONCONCURRENT
+}
diff --git a/edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/PreconditionSuccess.java b/edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/PreconditionSuccess.java
@@ -5,6 +5,11 @@ public enum PreconditionSuccess {
 	P2,
 	P3,
 	P4,
-	P5
-
+	P5,
+	P6,
+	P7,
+	P8,
+	P9,
+	P10,
+	P11
 }
diff --git a/edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/Refactoring.java b/edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/Refactoring.java
@@ -7,5 +7,6 @@
  */
 public enum Refactoring {
 	CONVERT_SEQUENTIAL_STREAM_TO_PARALLEL,
-	OPTIMIZE_PARALLEL_STREAM
+	OPTIMIZE_PARALLEL_STREAM,
+	OPTIMIZE_COMPLEX_MUTABLE_REDUCTION
 }
diff --git a/edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/Stream.java b/edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/Stream.java
@@ -100,6 +100,8 @@ public class Stream {
 	private IR enclosingMethodDeclarationIR;
 
 	private final TypeDeclaration enclosingTypeDeclaration;
+	
+	private CollectorKind collectorKind;
 
 	private boolean hasPossibleSideEffects;
 
@@ -480,6 +482,10 @@ public Set<Ordering> getPossibleOrderings() {
 		return possibleOrderings.stream().map(e -> e == null ? initialOrdering : e).collect(Collectors.toSet());
 	}
 
+	public CollectorKind getCollectorKind() {
+		return this.collectorKind;
+	}
+	
 	public Refactoring getRefactoring() {
 		return this.refactoring;
 	}
@@ -667,6 +673,10 @@ protected void setInitialOrdering(Ordering initialOrdering) {
 		Objects.requireNonNull(initialOrdering);
 		this.initialOrdering = initialOrdering;
 	}
+	
+	protected void setCollectorKind(CollectorKind collectorKind) {
+		this.collectorKind = collectorKind;
+	}
 
 	private void setPassingPrecondition(PreconditionSuccess succcess) {
 		if (this.passingPrecondition == null)
diff --git a/edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/TransformationAction.java b/edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/TransformationAction.java
@@ -3,6 +3,7 @@
 public enum TransformationAction {
 	CONVERT_TO_PARALLEL,
 	UNORDER,
-	CONVERT_TO_SEQUENTIAL
-
+	CONVERT_TO_SEQUENTIAL,
+	CONVERT_COLLECTOR_TO_CONCURRENT,
+	CONVERT_COLLECTOR_TO_NON_CONCURRENT
 }
diff --git a/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction/in/A.java b/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction/in/A.java
@@ -0,0 +1,33 @@
+package p;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import edu.cuny.hunter.streamrefactoring.annotations.*;
+import p.A.Widget.Color;
+
+public class A {
+
+	static class Widget {
+		enum Color {
+			RED, BLUE, GREEN, PINK, ORANGE, YELLOW
+		};
+
+		public Color getColor() {
+			return this.getColor();
+		}
+	}
+
+	/**
+	 * P6 in table 3
+	 */
+	@EntryPoint
+	void m() {
+		Collection<Widget> orderedWidgets = new ArrayList<>();
+		Map<Color, List<Widget>> widgetsByColor = orderedWidgets.stream()
+				.collect(Collectors.groupingByConcurrent(Widget::getColor));
+	}
+}
diff --git a/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction1/in/A.java b/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction1/in/A.java
@@ -0,0 +1,33 @@
+package p;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import edu.cuny.hunter.streamrefactoring.annotations.*;
+import p.A.Widget.Color;
+
+public class A {
+
+	static class Widget {
+		enum Color {
+			RED, BLUE, GREEN, PINK, ORANGE, YELLOW
+		};
+
+		public Color getColor() {
+			return this.getColor();
+		}
+	}
+
+	/**
+	 * P7 in table 3
+	 */
+	@EntryPoint
+	void m() {
+		Collection<Widget> orderedWidgets = new ArrayList<>();
+		Map<Color, List<Widget>> widgetsByColor = orderedWidgets.parallelStream()
+				.collect(Collectors.groupingBy(Widget::getColor));
+	}
+}
diff --git a/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction2/in/A.java b/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction2/in/A.java
@@ -0,0 +1,33 @@
+package p;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import edu.cuny.hunter.streamrefactoring.annotations.*;
+import p.A.Widget.Color;
+
+public class A {
+
+	static class Widget {
+		enum Color {
+			RED, BLUE, GREEN, PINK, ORANGE, YELLOW
+		};
+
+		public Color getColor() {
+			return this.getColor();
+		}
+	}
+
+	/**
+	 * P8 in table 3
+	 */
+	@EntryPoint
+	void m() {
+		Collection<Widget> orderedWidgets = new ArrayList<>();
+		Map<Color, List<Widget>> widgetsByColor = orderedWidgets.parallelStream()
+				.collect(Collectors.groupingByConcurrent(Widget::getColor));
+	}
+}
diff --git a/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction3/in/A.java b/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction3/in/A.java
@@ -0,0 +1,34 @@
+package p;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import edu.cuny.hunter.streamrefactoring.annotations.*;
+import p.A.Widget.Color;
+
+public class A {
+
+	static class Widget {
+		enum Color {
+			RED, BLUE, GREEN, PINK, ORANGE, YELLOW
+		};
+
+		public Color getColor() {
+			return this.getColor();
+		}
+	}
+
+	/**
+	 * P9 in table 3
+	 */
+	@EntryPoint
+	void m() {
+		Collection<Widget> orderedWidgets = new ArrayList<>();
+		Map<Color, Set<Widget>> widgetsByColor = orderedWidgets.stream()
+				.collect(Collectors.groupingBy(Widget::getColor, HashMap::new, Collectors.toSet()));
+	}
+}
diff --git a/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction4/in/A.java b/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction4/in/A.java
@@ -0,0 +1,35 @@
+package p;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+import edu.cuny.hunter.streamrefactoring.annotations.*;
+import p.A.Widget.Color;
+
+public class A {
+
+	static class Widget {
+		enum Color {
+			RED, BLUE, GREEN, PINK, ORANGE, YELLOW
+		};
+
+		public Color getColor() {
+			return this.getColor();
+		}
+	}
+
+	/**
+	 * P10 in table 3
+	 */
+	@EntryPoint
+	void m() {
+		Collection<Widget> orderedWidgets = new ArrayList<>();
+		Map<Color, Set<Widget>> widgetsByColor = orderedWidgets.stream().collect(Collectors.groupingByConcurrent(
+				Widget::getColor, ConcurrentHashMap::new, Collectors.toCollection(LinkedHashSet::new)));
+	}
+}
diff --git a/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction5/in/A.java b/edu.cuny.hunter.streamrefactoring.tests/resources/ConvertStreamToParallel/testConcurrentReduction5/in/A.java
@@ -0,0 +1,34 @@
+package p;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import edu.cuny.hunter.streamrefactoring.annotations.*;
+import p.A.Widget.Color;
+
+public class A {
+
+	static class Widget {
+		enum Color {
+			RED, BLUE, GREEN, PINK, ORANGE, YELLOW
+		};
+
+		public Color getColor() {
+			return this.getColor();
+		}
+	}
+
+	/**
+	 * P11 in table 3
+	 */
+	@EntryPoint
+	void m() {
+		Collection<Widget> orderedWidgets = new ArrayList<>();
+		Map<Color, Set<Widget>> widgetsByColor = orderedWidgets.parallelStream()
+				.collect(Collectors.groupingBy(Widget::getColor, HashMap::new, Collectors.toSet()));
+	}
+}
diff --git a/edu.cuny.hunter.streamrefactoring.tests/test cases/edu/cuny/hunter/streamrefactoring/ui/tests/ConvertStreamToParallelRefactoringTest.java b/edu.cuny.hunter.streamrefactoring.tests/test cases/edu/cuny/hunter/streamrefactoring/ui/tests/ConvertStreamToParallelRefactoringTest.java
@@ -39,6 +39,7 @@
 import org.eclipse.jdt.ui.tests.refactoring.RefactoringTest;
 import org.eclipse.ltk.core.refactoring.RefactoringStatus;
 
+import edu.cuny.hunter.streamrefactoring.core.analysis.CollectorKind;
 import edu.cuny.hunter.streamrefactoring.core.analysis.ExecutionMode;
 import edu.cuny.hunter.streamrefactoring.core.analysis.Ordering;
 import edu.cuny.hunter.streamrefactoring.core.analysis.PreconditionFailure;
@@ -288,6 +289,12 @@ private void helper(StreamAnalysisExpectedResult... expectedResults) throws Exce
 
 			Set<Ordering> orderings = stream.getPossibleOrderings();
 			assertEquals(errorMessage("orderings", result), result.getExpectedOrderings(), orderings);
+			
+			// exceptedCollecterKind is initialized in the excepted result class
+			if (result.getExceptedCollectorKind() != null) {
+				CollectorKind collectorKind = stream.getCollectorKind();
+				assertEquals(errorMessage("collector kind", result), result.getExceptedCollectorKind(), collectorKind);
+			}
 
 			assertEquals(errorMessage("side effects", result), result.isExpectingSideEffects(),
 					stream.hasPossibleSideEffects());
@@ -704,4 +711,73 @@ public void testField() throws Exception {
 				false, EnumSet.of(TransformationAction.CONVERT_TO_PARALLEL), PreconditionSuccess.P1,
 				Refactoring.CONVERT_SEQUENTIAL_STREAM_TO_PARALLEL, RefactoringStatus.OK, Collections.emptySet()));
 	}
+	
+	/**
+	 * Test #64. Test P6 in table3.
+	 */
+	public void testConcurrentReduction() throws Exception {
+		helper(new StreamAnalysisExpectedResult("orderedWidgets.stream()", EnumSet.of(ExecutionMode.SEQUENTIAL),
+				EnumSet.of(Ordering.ORDERED), CollectorKind.CONCURRENT, false, false, true,
+				EnumSet.of(TransformationAction.CONVERT_COLLECTOR_TO_NON_CONCURRENT), PreconditionSuccess.P6,
+				Refactoring.OPTIMIZE_COMPLEX_MUTABLE_REDUCTION, RefactoringStatus.OK, Collections.emptySet()));
+	}
+
+	/**
+	 * Test #64. Test P7 in table 3.
+	 */
+	public void testConcurrentReduction1() throws Exception {
+		helper(new StreamAnalysisExpectedResult("orderedWidgets.stream()", EnumSet.of(ExecutionMode.PARALLEL),
+				EnumSet.of(Ordering.ORDERED), CollectorKind.NONCONCURRENT, false, false, true,
+				EnumSet.of(TransformationAction.CONVERT_TO_SEQUENTIAL), PreconditionSuccess.P7,
+				Refactoring.OPTIMIZE_COMPLEX_MUTABLE_REDUCTION, RefactoringStatus.OK, Collections.emptySet()));
+	}
+
+	/**
+	 * Test #64. Test P8 in table 3.
+	 */
+	public void testConcurrentReduction2() throws Exception {
+		HashSet<TransformationAction> transformations = new HashSet<>();
+		transformations.add(TransformationAction.CONVERT_COLLECTOR_TO_NON_CONCURRENT);
+		transformations.add(TransformationAction.CONVERT_TO_SEQUENTIAL);
+
+		helper(new StreamAnalysisExpectedResult("orderedWidgets.stream()", EnumSet.of(ExecutionMode.PARALLEL),
+				EnumSet.of(Ordering.ORDERED), CollectorKind.CONCURRENT, false, false, true, transformations,
+				PreconditionSuccess.P8, Refactoring.OPTIMIZE_COMPLEX_MUTABLE_REDUCTION, RefactoringStatus.OK,
+				Collections.emptySet()));
+	}
+
+	/**
+	 * Test #64. Test P9 in table 3.
+	 */
+	public void testConcurrentReduction3() throws Exception {
+		HashSet<TransformationAction> transformations = new HashSet<>();
+		transformations.add(TransformationAction.CONVERT_COLLECTOR_TO_CONCURRENT);
+		transformations.add(TransformationAction.CONVERT_TO_PARALLEL);
+
+		helper(new StreamAnalysisExpectedResult("orderedWidgets.stream()", EnumSet.of(ExecutionMode.SEQUENTIAL),
+				EnumSet.of(Ordering.ORDERED), CollectorKind.NONCONCURRENT, false, false, false, transformations,
+				PreconditionSuccess.P9, Refactoring.OPTIMIZE_COMPLEX_MUTABLE_REDUCTION, RefactoringStatus.OK,
+				Collections.emptySet()));
+	}
+
+	/**
+	 * Test #64. Test P10 in table 3.
+	 */
+	public void testConcurrentReduction4() throws Exception {
+		helper(new StreamAnalysisExpectedResult("orderedWidgets.stream()", EnumSet.of(ExecutionMode.SEQUENTIAL),
+				EnumSet.of(Ordering.ORDERED), CollectorKind.CONCURRENT, false, false, false,
+				EnumSet.of(TransformationAction.CONVERT_TO_PARALLEL), PreconditionSuccess.P10,
+				Refactoring.OPTIMIZE_COMPLEX_MUTABLE_REDUCTION, RefactoringStatus.OK, Collections.emptySet()));
+	}
+
+	/**
+	 * Test #64. Test P11 in table 3.
+	 */
+	public void testConcurrentReduction5() throws Exception {
+		helper(new StreamAnalysisExpectedResult("orderedWidgets.stream()", EnumSet.of(ExecutionMode.PARALLEL),
+				EnumSet.of(Ordering.ORDERED), CollectorKind.NONCONCURRENT, false, false, false,
+				EnumSet.of(TransformationAction.CONVERT_COLLECTOR_TO_CONCURRENT), PreconditionSuccess.P11,
+				Refactoring.OPTIMIZE_COMPLEX_MUTABLE_REDUCTION, RefactoringStatus.OK, Collections.emptySet()));
+	}
+
 }
diff --git a/edu.cuny.hunter.streamrefactoring.tests/test cases/edu/cuny/hunter/streamrefactoring/ui/tests/StreamAnalysisExpectedResult.java b/edu.cuny.hunter.streamrefactoring.tests/test cases/edu/cuny/hunter/streamrefactoring/ui/tests/StreamAnalysisExpectedResult.java

-Original file line number
+Diff line change
 	P2,
 	P3,
 	P4,
 -	P5
+-
 +	P5,
 +	P6,
 +	P7,
 +	P8,
 +	P9,
 +	P10,
 +	P11
+}
Original file line number	Diff line number	Diff line change
`@@ -7,5 +7,6 @@`
`7`	`7`	`*/`
`8`	`8`	`public enum Refactoring {`
`9`	`9`	`CONVERT_SEQUENTIAL_STREAM_TO_PARALLEL,`
`10`		`- OPTIMIZE_PARALLEL_STREAM`
	`10`	`+ OPTIMIZE_PARALLEL_STREAM,`
	`11`	`+ OPTIMIZE_COMPLEX_MUTABLE_REDUCTION`
`11`	`12`	`}`