http://git-wip-us.apache.org/repos/asf/flink/blob/cb282067/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/GraphOperationsITCase.java ---------------------------------------------------------------------- diff --git a/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/GraphOperationsITCase.java b/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/GraphOperationsITCase.java index 4d7153d..e03e8cf 100644 --- a/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/GraphOperationsITCase.java +++ b/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/GraphOperationsITCase.java @@ -40,11 +40,11 @@ import java.util.List; @RunWith(Parameterized.class) public class GraphOperationsITCase extends MultipleProgramsTestBase { - public GraphOperationsITCase(TestExecutionMode mode){ + public GraphOperationsITCase(TestExecutionMode mode) { super(mode); } - private String expectedResult; + private String expectedResult; @Test public void testUndirected() throws Exception { @@ -54,19 +54,19 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + TestGraphUtils.getLongLongEdgeData(env), env); + + DataSet<Edge<Long, Long>> data = graph.getUndirected().getEdges(); + List<Edge<Long, Long>> result = data.collect(); - DataSet<Edge<Long, Long>> data = graph.getUndirected().getEdges(); - List<Edge<Long, Long>> result= data.collect(); - expectedResult = "1,2,12\n" + "2,1,12\n" + - "1,3,13\n" + "3,1,13\n" + - "2,3,23\n" + "3,2,23\n" + - "3,4,34\n" + "4,3,34\n" + - "3,5,35\n" + "5,3,35\n" + - "4,5,45\n" + "5,4,45\n" + - "5,1,51\n" + "1,5,51\n"; - + "1,3,13\n" + "3,1,13\n" + + "2,3,23\n" + "3,2,23\n" + + "3,4,34\n" + "4,3,34\n" + + "3,5,35\n" + "5,3,35\n" + + "4,5,45\n" + "5,4,45\n" + + "5,1,51\n" + "1,5,51\n"; + compareResultAsTuples(result, expectedResult); } @@ -78,19 +78,19 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + TestGraphUtils.getLongLongEdgeData(env), env); + + DataSet<Edge<Long, Long>> data = graph.reverse().getEdges(); + List<Edge<Long, Long>> result = data.collect(); - DataSet<Edge<Long, Long>> data = graph.reverse().getEdges(); - List<Edge<Long, Long>> result= data.collect(); - expectedResult = "2,1,12\n" + - "3,1,13\n" + - "3,2,23\n" + - "4,3,34\n" + - "5,3,35\n" + - "5,4,45\n" + - "1,5,51\n"; - + "3,1,13\n" + + "3,2,23\n" + + "4,3,34\n" + + "5,3,35\n" + + "5,4,45\n" + + "1,5,51\n"; + compareResultAsTuples(result, expectedResult); } @@ -103,24 +103,25 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - - DataSet<Edge<Long, Long>> data= graph.subgraph(new FilterFunction<Vertex<Long, Long>>() { - public boolean filter(Vertex<Long, Long> vertex) throws Exception { - return (vertex.getValue() > 2); - } - }, - new FilterFunction<Edge<Long, Long>>() { - public boolean filter(Edge<Long, Long> edge) throws Exception { - return (edge.getValue() > 34); - } - }).getEdges(); - - List<Edge<Long, Long>> result= data.collect(); - + TestGraphUtils.getLongLongEdgeData(env), env); + + DataSet<Edge<Long, Long>> data = graph.subgraph( + new FilterFunction<Vertex<Long, Long>>() { + public boolean filter(Vertex<Long, Long> vertex) throws Exception { + return (vertex.getValue() > 2); + } + }, + new FilterFunction<Edge<Long, Long>>() { + public boolean filter(Edge<Long, Long> edge) throws Exception { + return (edge.getValue() > 34); + } + }).getEdges(); + + List<Edge<Long, Long>> result = data.collect(); + expectedResult = "3,5,35\n" + - "4,5,45\n"; - + "4,5,45\n"; + compareResultAsTuples(result, expectedResult); } @@ -133,20 +134,20 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Edge<Long, Long>> data = graph.filterOnVertices(new FilterFunction<Vertex<Long, Long>>() { public boolean filter(Vertex<Long, Long> vertex) throws Exception { return (vertex.getValue() > 2); } }).getEdges(); - List<Edge<Long, Long>> result= data.collect(); - - expectedResult = "3,4,34\n" + - "3,5,35\n" + - "4,5,45\n"; - + List<Edge<Long, Long>> result = data.collect(); + + expectedResult = "3,4,34\n" + + "3,5,35\n" + + "4,5,45\n"; + compareResultAsTuples(result, expectedResult); } @@ -159,20 +160,20 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Edge<Long, Long>> data = graph.filterOnEdges(new FilterFunction<Edge<Long, Long>>() { public boolean filter(Edge<Long, Long> edge) throws Exception { return (edge.getValue() > 34); } }).getEdges(); - List<Edge<Long, Long>> result = data.collect(); - + List<Edge<Long, Long>> result = data.collect(); + expectedResult = "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n"; - + "4,5,45\n" + + "5,1,51\n"; + compareResultAsTuples(result, expectedResult); } @@ -184,13 +185,13 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + TestGraphUtils.getLongLongEdgeData(env), env); DataSet<Long> data = env.fromElements(graph.numberOfVertices()); - List<Long> result= data.collect(); - + List<Long> result = data.collect(); + expectedResult = "5"; - + compareResultAsText(result, expectedResult); } @@ -202,13 +203,13 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + TestGraphUtils.getLongLongEdgeData(env), env); DataSet<Long> data = env.fromElements(graph.numberOfEdges()); - List<Long> result= data.collect(); - + List<Long> result = data.collect(); + expectedResult = "7"; - + compareResultAsText(result, expectedResult); } @@ -220,13 +221,13 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Long> data = graph.getVertexIds(); - List<Long> result= data.collect(); - + List<Long> result = data.collect(); + expectedResult = "1\n2\n3\n4\n5\n"; - + compareResultAsText(result, expectedResult); } @@ -238,16 +239,16 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Tuple2<Long, Long>> data = graph.getEdgeIds(); - List<Tuple2<Long, Long>> result= data.collect(); - + List<Tuple2<Long, Long>> result = data.collect(); + expectedResult = "1,2\n" + "1,3\n" + - "2,3\n" + "3,4\n" + - "3,5\n" + "4,5\n" + - "5,1\n"; - + "2,3\n" + "3,4\n" + + "3,5\n" + "4,5\n" + + "5,1\n"; + compareResultAsTuples(result, expectedResult); } @@ -259,7 +260,7 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + TestGraphUtils.getLongLongEdgeData(env), env); List<Vertex<Long, Long>> vertices = new ArrayList<>(); List<Edge<Long, Long>> edges = new ArrayList<>(); @@ -269,18 +270,18 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { graph = graph.union(Graph.fromCollection(vertices, edges, env)); - DataSet<Edge<Long, Long>> data = graph.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + DataSet<Edge<Long, Long>> data = graph.getEdges(); + List<Edge<Long, Long>> result = data.collect(); expectedResult = "1,2,12\n" + - "1,3,13\n" + - "2,3,23\n" + - "3,4,34\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n" + - "6,1,61\n"; - + "1,3,13\n" + + "2,3,23\n" + + "3,4,34\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,51\n" + + "6,1,61\n"; + compareResultAsTuples(result, expectedResult); } @@ -291,10 +292,10 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + TestGraphUtils.getLongLongEdgeData(env), env); Graph<Long, Long, Long> graph2 = Graph.fromDataSet(TestGraphUtils.getLongLongVertexDataDifference(env), - TestGraphUtils.getLongLongEdgeDataDifference(env), env); + TestGraphUtils.getLongLongEdgeDataDifference(env), env); graph = graph.difference(graph2); @@ -305,24 +306,24 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { } @Test - public void testDifferenceVertices() throws Exception{ + public void testDifferenceVertices() throws Exception { /*Test difference() method by checking the output for getVertices() on the resultant graph */ final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + TestGraphUtils.getLongLongEdgeData(env), env); Graph<Long, Long, Long> graph2 = Graph.fromDataSet(TestGraphUtils.getLongLongVertexDataDifference(env), - TestGraphUtils.getLongLongEdgeDataDifference(env), env); + TestGraphUtils.getLongLongEdgeDataDifference(env), env); graph = graph.difference(graph2); List<Vertex<Long, Long>> result = graph.getVertices().collect(); - expectedResult = "2,2\n" + - "4,4\n" + - "5,5\n" ; + expectedResult = "2,2\n" + + "4,4\n" + + "5,5\n"; compareResultAsTuples(result, expectedResult); } @@ -335,7 +336,7 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + TestGraphUtils.getLongLongEdgeData(env), env); DataSet<Vertex<Long, Long>> vertex = env.fromElements(new Vertex<>(6L, 6L)); @@ -345,13 +346,13 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { List<Edge<Long, Long>> result = graph.getEdges().collect(); - expectedResult = "1,2,12\n" + - "1,3,13\n" + - "2,3,23\n" + - "3,4,34\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n" ; + expectedResult = "1,2,12\n" + + "1,3,13\n" + + "2,3,23\n" + + "3,4,34\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,51\n"; compareResultAsTuples(result, expectedResult); } @@ -423,14 +424,14 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { env.execute(); String expectedVertices = "1,(null)\n" + - "3,(null)\n"; + "3,(null)\n"; String expectedEdges = "1,3,13\n" + - "1,3,13\n" + - "1,3,13\n" + - "1,3,13\n" + - "1,3,14\n" + - "1,3,14"; + "1,3,13\n" + + "1,3,13\n" + + "1,3,13\n" + + "1,3,14\n" + + "1,3,14"; compareResultAsTuples(vertices, expectedVertices); compareResultAsTuples(edges, expectedEdges); @@ -444,16 +445,16 @@ public class GraphOperationsITCase extends MultipleProgramsTestBase { final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + TestGraphUtils.getLongLongEdgeData(env), env); - DataSet<Triplet<Long, Long, Long>> data = graph.getTriplets(); - List<Triplet<Long, Long, Long>> result= data.collect(); + DataSet<Triplet<Long, Long, Long>> data = graph.getTriplets(); + List<Triplet<Long, Long, Long>> result = data.collect(); expectedResult = "1,2,1,2,12\n" + "1,3,1,3,13\n" + - "2,3,2,3,23\n" + "3,4,3,4,34\n" + - "3,5,3,5,35\n" + "4,5,4,5,45\n" + - "5,1,5,1,51\n"; - + "2,3,2,3,23\n" + "3,4,3,4,34\n" + + "3,5,3,5,35\n" + "4,5,4,5,45\n" + + "5,1,5,1,51\n"; + compareResultAsTuples(result, expectedResult); } } \ No newline at end of file
http://git-wip-us.apache.org/repos/asf/flink/blob/cb282067/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/JoinWithEdgesITCase.java ---------------------------------------------------------------------- diff --git a/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/JoinWithEdgesITCase.java b/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/JoinWithEdgesITCase.java index cb83b33..6988218 100644 --- a/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/JoinWithEdgesITCase.java +++ b/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/JoinWithEdgesITCase.java @@ -39,11 +39,11 @@ import java.util.List; @RunWith(Parameterized.class) public class JoinWithEdgesITCase extends MultipleProgramsTestBase { - public JoinWithEdgesITCase(TestExecutionMode mode){ + public JoinWithEdgesITCase(TestExecutionMode mode) { super(mode); } - private String expectedResult; + private String expectedResult; @Test public void testWithEdgesInputDataset() throws Exception { @@ -51,416 +51,416 @@ public class JoinWithEdgesITCase extends MultipleProgramsTestBase { * Test joinWithEdges with the input DataSet parameter identical * to the edge DataSet */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithEdges(graph.getEdges() - .map(new EdgeToTuple3Map<Long, Long>()), new AddValuesMapper()); + Graph<Long, Long, Long> res = graph.joinWithEdges(graph.getEdges() + .map(new EdgeToTuple3Map<Long, Long>()), new AddValuesMapper()); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); + + expectedResult = "1,2,24\n" + + "1,3,26\n" + + "2,3,46\n" + + "3,4,68\n" + + "3,5,70\n" + + "4,5,90\n" + + "5,1,102\n"; - expectedResult = "1,2,24\n" + - "1,3,26\n" + - "2,3,46\n" + - "3,4,68\n" + - "3,5,70\n" + - "4,5,90\n" + - "5,1,102\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testWithLessElements() throws Exception { - /* + /* * Test joinWithEdges with the input DataSet passed as a parameter containing * less elements than the edge DataSet, but of the same type */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> res = graph.joinWithEdges(graph.getEdges().first(3) + .map(new EdgeToTuple3Map<Long, Long>()), new AddValuesMapper()); - Graph<Long, Long, Long> res = graph.joinWithEdges(graph.getEdges().first(3) - .map(new EdgeToTuple3Map<Long, Long>()), new AddValuesMapper()); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + expectedResult = "1,2,24\n" + + "1,3,26\n" + + "2,3,46\n" + + "3,4,34\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,51\n"; - expectedResult = "1,2,24\n" + - "1,3,26\n" + - "2,3,46\n" + - "3,4,34\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testWithLessElementsDifferentType() throws Exception { - /* + /* * Test joinWithEdges with the input DataSet passed as a parameter containing * less elements than the edge DataSet and of a different type(Boolean) */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithEdges(graph.getEdges().first(3) - .map(new BooleanEdgeValueMapper()), new DoubleIfTrueMapper()); + Graph<Long, Long, Long> res = graph.joinWithEdges(graph.getEdges().first(3) + .map(new BooleanEdgeValueMapper()), new DoubleIfTrueMapper()); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); + + expectedResult = "1,2,24\n" + + "1,3,26\n" + + "2,3,46\n" + + "3,4,34\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,51\n"; - expectedResult = "1,2,24\n" + - "1,3,26\n" + - "2,3,46\n" + - "3,4,34\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testWithNoCommonKeys() throws Exception { - /* + /* * Test joinWithEdges with the input DataSet containing different keys than the edge DataSet * - the iterator becomes empty. */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> res = graph.joinWithEdges(TestGraphUtils.getLongLongLongTuple3Data(env), + new DoubleValueMapper()); - Graph<Long, Long, Long> res = graph.joinWithEdges(TestGraphUtils.getLongLongLongTuple3Data(env), - new DoubleValueMapper()); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + expectedResult = "1,2,24\n" + + "1,3,26\n" + + "2,3,46\n" + + "3,4,68\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,51\n"; - expectedResult = "1,2,24\n" + - "1,3,26\n" + - "2,3,46\n" + - "3,4,68\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testWithCustomType() throws Exception { - /* + /* * Test joinWithEdges with a DataSet containing custom parametrised type input values */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithEdges(TestGraphUtils.getLongLongCustomTuple3Data(env), - new CustomValueMapper()); + Graph<Long, Long, Long> res = graph.joinWithEdges(TestGraphUtils.getLongLongCustomTuple3Data(env), + new CustomValueMapper()); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); + + expectedResult = "1,2,10\n" + + "1,3,20\n" + + "2,3,30\n" + + "3,4,40\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,51\n"; - expectedResult = "1,2,10\n" + - "1,3,20\n" + - "2,3,30\n" + - "3,4,40\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testWithEdgesOnSource() throws Exception { - /* + /* * Test joinWithEdgesOnSource with the input DataSet parameter identical * to the edge DataSet */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> res = graph.joinWithEdgesOnSource(graph.getEdges() + .map(new ProjectSourceAndValueMapper()), new AddValuesMapper()); - Graph<Long, Long, Long> res = graph.joinWithEdgesOnSource(graph.getEdges() - .map(new ProjectSourceAndValueMapper()), new AddValuesMapper()); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + expectedResult = "1,2,24\n" + + "1,3,25\n" + + "2,3,46\n" + + "3,4,68\n" + + "3,5,69\n" + + "4,5,90\n" + + "5,1,102\n"; - expectedResult = "1,2,24\n" + - "1,3,25\n" + - "2,3,46\n" + - "3,4,68\n" + - "3,5,69\n" + - "4,5,90\n" + - "5,1,102\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testOnSourceWithLessElements() throws Exception { - /* + /* * Test joinWithEdgesOnSource with the input DataSet passed as a parameter containing * less elements than the edge DataSet, but of the same type */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithEdgesOnSource(graph.getEdges().first(3) - .map(new ProjectSourceAndValueMapper()), new AddValuesMapper()); + Graph<Long, Long, Long> res = graph.joinWithEdgesOnSource(graph.getEdges().first(3) + .map(new ProjectSourceAndValueMapper()), new AddValuesMapper()); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); + + expectedResult = "1,2,24\n" + + "1,3,25\n" + + "2,3,46\n" + + "3,4,34\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,51\n"; - expectedResult = "1,2,24\n" + - "1,3,25\n" + - "2,3,46\n" + - "3,4,34\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testOnSourceWithDifferentType() throws Exception { - /* + /* * Test joinWithEdgesOnSource with the input DataSet passed as a parameter containing * less elements than the edge DataSet and of a different type(Boolean) */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> res = graph.joinWithEdgesOnSource(graph.getEdges().first(3) + .map(new ProjectSourceWithTrueMapper()), new DoubleIfTrueMapper()); - Graph<Long, Long, Long> res = graph.joinWithEdgesOnSource(graph.getEdges().first(3) - .map(new ProjectSourceWithTrueMapper()), new DoubleIfTrueMapper()); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + expectedResult = "1,2,24\n" + + "1,3,26\n" + + "2,3,46\n" + + "3,4,34\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,51\n"; - expectedResult = "1,2,24\n" + - "1,3,26\n" + - "2,3,46\n" + - "3,4,34\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testOnSourceWithNoCommonKeys() throws Exception { - /* + /* * Test joinWithEdgesOnSource with the input DataSet containing different keys than the edge DataSet * - the iterator becomes empty. */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithEdgesOnSource(TestGraphUtils.getLongLongTuple2SourceData(env), - new DoubleValueMapper()); + Graph<Long, Long, Long> res = graph.joinWithEdgesOnSource(TestGraphUtils.getLongLongTuple2SourceData(env), + new DoubleValueMapper()); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); + + expectedResult = "1,2,20\n" + + "1,3,20\n" + + "2,3,60\n" + + "3,4,80\n" + + "3,5,80\n" + + "4,5,120\n" + + "5,1,51\n"; - expectedResult = "1,2,20\n" + - "1,3,20\n" + - "2,3,60\n" + - "3,4,80\n" + - "3,5,80\n" + - "4,5,120\n" + - "5,1,51\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testOnSourceWithCustom() throws Exception { - /* + /* * Test joinWithEdgesOnSource with a DataSet containing custom parametrised type input values */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> res = graph.joinWithEdgesOnSource(TestGraphUtils.getLongCustomTuple2SourceData(env), + new CustomValueMapper()); - Graph<Long, Long, Long> res = graph.joinWithEdgesOnSource(TestGraphUtils.getLongCustomTuple2SourceData(env), - new CustomValueMapper()); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + expectedResult = "1,2,10\n" + + "1,3,10\n" + + "2,3,30\n" + + "3,4,40\n" + + "3,5,40\n" + + "4,5,45\n" + + "5,1,51\n"; - expectedResult = "1,2,10\n" + - "1,3,10\n" + - "2,3,30\n" + - "3,4,40\n" + - "3,5,40\n" + - "4,5,45\n" + - "5,1,51\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testWithEdgesOnTarget() throws Exception { - /* - * Test joinWithEdgesOnTarget with the input DataSet parameter identical - * to the edge DataSet - */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - - Graph<Long, Long, Long> res = graph.joinWithEdgesOnTarget(graph.getEdges() - .map(new ProjectTargetAndValueMapper()), new AddValuesMapper()); - - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); - - expectedResult = "1,2,24\n" + - "1,3,26\n" + - "2,3,36\n" + - "3,4,68\n" + - "3,5,70\n" + - "4,5,80\n" + - "5,1,102\n"; - + /* + * Test joinWithEdgesOnTarget with the input DataSet parameter identical + * to the edge DataSet + */ + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); + + Graph<Long, Long, Long> res = graph.joinWithEdgesOnTarget(graph.getEdges() + .map(new ProjectTargetAndValueMapper()), new AddValuesMapper()); + + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); + + expectedResult = "1,2,24\n" + + "1,3,26\n" + + "2,3,36\n" + + "3,4,68\n" + + "3,5,70\n" + + "4,5,80\n" + + "5,1,102\n"; + compareResultAsTuples(result, expectedResult); - } + } @Test public void testWithOnTargetWithLessElements() throws Exception { - /* + /* * Test joinWithEdgesOnTarget with the input DataSet passed as a parameter containing * less elements than the edge DataSet, but of the same type */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> res = graph.joinWithEdgesOnTarget(graph.getEdges().first(3) + .map(new ProjectTargetAndValueMapper()), new AddValuesMapper()); - Graph<Long, Long, Long> res = graph.joinWithEdgesOnTarget(graph.getEdges().first(3) - .map(new ProjectTargetAndValueMapper()), new AddValuesMapper()); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + expectedResult = "1,2,24\n" + + "1,3,26\n" + + "2,3,36\n" + + "3,4,34\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,51\n"; - expectedResult = "1,2,24\n" + - "1,3,26\n" + - "2,3,36\n" + - "3,4,34\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testOnTargetWithDifferentType() throws Exception { - /* + /* * Test joinWithEdgesOnTarget with the input DataSet passed as a parameter containing * less elements than the edge DataSet and of a different type(Boolean) */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithEdgesOnTarget(graph.getEdges().first(3) - .map(new ProjectTargetWithTrueMapper()), new DoubleIfTrueMapper()); + Graph<Long, Long, Long> res = graph.joinWithEdgesOnTarget(graph.getEdges().first(3) + .map(new ProjectTargetWithTrueMapper()), new DoubleIfTrueMapper()); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); + + expectedResult = "1,2,24\n" + + "1,3,26\n" + + "2,3,46\n" + + "3,4,34\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,51\n"; - expectedResult = "1,2,24\n" + - "1,3,26\n" + - "2,3,46\n" + - "3,4,34\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testOnTargetWithNoCommonKeys() throws Exception { - /* + /* * Test joinWithEdgesOnTarget with the input DataSet containing different keys than the edge DataSet * - the iterator becomes empty. */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> res = graph.joinWithEdgesOnTarget(TestGraphUtils.getLongLongTuple2TargetData(env), + new DoubleValueMapper()); - Graph<Long, Long, Long> res = graph.joinWithEdgesOnTarget(TestGraphUtils.getLongLongTuple2TargetData(env), - new DoubleValueMapper()); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + expectedResult = "1,2,20\n" + + "1,3,40\n" + + "2,3,40\n" + + "3,4,80\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,140\n"; - expectedResult = "1,2,20\n" + - "1,3,40\n" + - "2,3,40\n" + - "3,4,80\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,140\n"; - compareResultAsTuples(result, expectedResult); - } + } @Test public void testOnTargetWithCustom() throws Exception { - /* + /* * Test joinWithEdgesOnTarget with a DataSet containing custom parametrised type input values */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithEdgesOnTarget(TestGraphUtils.getLongCustomTuple2TargetData(env), - new CustomValueMapper()); + Graph<Long, Long, Long> res = graph.joinWithEdgesOnTarget(TestGraphUtils.getLongCustomTuple2TargetData(env), + new CustomValueMapper()); - DataSet<Edge<Long, Long>> data = res.getEdges(); - List<Edge<Long, Long>> result= data.collect(); + DataSet<Edge<Long, Long>> data = res.getEdges(); + List<Edge<Long, Long>> result = data.collect(); + + expectedResult = "1,2,10\n" + + "1,3,20\n" + + "2,3,20\n" + + "3,4,40\n" + + "3,5,35\n" + + "4,5,45\n" + + "5,1,51\n"; - expectedResult = "1,2,10\n" + - "1,3,20\n" + - "2,3,20\n" + - "3,4,40\n" + - "3,5,35\n" + - "4,5,45\n" + - "5,1,51\n"; - compareResultAsTuples(result, expectedResult); - } + } @SuppressWarnings("serial") private static final class AddValuesMapper implements EdgeJoinFunction<Long, Long> { @@ -472,67 +472,64 @@ public class JoinWithEdgesITCase extends MultipleProgramsTestBase { @SuppressWarnings("serial") private static final class BooleanEdgeValueMapper implements MapFunction<Edge<Long, Long>, Tuple3<Long, Long, Boolean>> { - public Tuple3<Long, Long, Boolean> map(Edge<Long, Long> edge) throws Exception { - return new Tuple3<>(edge.getSource(), edge.getTarget(), true); - } - } + public Tuple3<Long, Long, Boolean> map(Edge<Long, Long> edge) throws Exception { + return new Tuple3<>(edge.getSource(), edge.getTarget(), true); + } + } @SuppressWarnings("serial") private static final class DoubleIfTrueMapper implements EdgeJoinFunction<Long, Boolean> { public Long edgeJoin(Long edgeValue, Boolean inputValue) { - if(inputValue) { - return edgeValue * 2; - } - else { - return edgeValue; - } + if (inputValue) { + return edgeValue * 2; + } else { + return edgeValue; + } } - } + } @SuppressWarnings("serial") private static final class DoubleValueMapper implements EdgeJoinFunction<Long, Long> { - + public Long edgeJoin(Long edgeValue, Long inputValue) { - return inputValue*2; + return inputValue * 2; } - } + } @SuppressWarnings("serial") - private static final class CustomValueMapper implements EdgeJoinFunction< - Long, DummyCustomParameterizedType<Float>> { + private static final class CustomValueMapper implements EdgeJoinFunction<Long, DummyCustomParameterizedType<Float>> { - public Long edgeJoin(Long edgeValue, - DummyCustomParameterizedType<Float> inputValue) { + public Long edgeJoin(Long edgeValue, DummyCustomParameterizedType<Float> inputValue) { return (long) inputValue.getIntField(); } - } + } @SuppressWarnings("serial") private static final class ProjectSourceAndValueMapper implements MapFunction<Edge<Long, Long>, Tuple2<Long, Long>> { - public Tuple2<Long, Long> map(Edge<Long, Long> edge) throws Exception { - return new Tuple2<>(edge.getSource(), edge.getValue()); - } - } + public Tuple2<Long, Long> map(Edge<Long, Long> edge) throws Exception { + return new Tuple2<>(edge.getSource(), edge.getValue()); + } + } @SuppressWarnings("serial") private static final class ProjectSourceWithTrueMapper implements MapFunction<Edge<Long, Long>, Tuple2<Long, Boolean>> { - public Tuple2<Long, Boolean> map(Edge<Long, Long> edge) throws Exception { - return new Tuple2<>(edge.getSource(), true); - } - } + public Tuple2<Long, Boolean> map(Edge<Long, Long> edge) throws Exception { + return new Tuple2<>(edge.getSource(), true); + } + } @SuppressWarnings("serial") private static final class ProjectTargetAndValueMapper implements MapFunction<Edge<Long, Long>, Tuple2<Long, Long>> { - public Tuple2<Long, Long> map(Edge<Long, Long> edge) throws Exception { - return new Tuple2<>(edge.getTarget(), edge.getValue()); - } - } + public Tuple2<Long, Long> map(Edge<Long, Long> edge) throws Exception { + return new Tuple2<>(edge.getTarget(), edge.getValue()); + } + } @SuppressWarnings("serial") private static final class ProjectTargetWithTrueMapper implements MapFunction<Edge<Long, Long>, Tuple2<Long, Boolean>> { - public Tuple2<Long, Boolean> map(Edge<Long, Long> edge) throws Exception { - return new Tuple2<>(edge.getTarget(), true); - } - } + public Tuple2<Long, Boolean> map(Edge<Long, Long> edge) throws Exception { + return new Tuple2<>(edge.getTarget(), true); + } + } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/flink/blob/cb282067/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/JoinWithVerticesITCase.java ---------------------------------------------------------------------- diff --git a/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/JoinWithVerticesITCase.java b/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/JoinWithVerticesITCase.java index 29badba..7676e8c 100644 --- a/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/JoinWithVerticesITCase.java +++ b/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/JoinWithVerticesITCase.java @@ -38,11 +38,11 @@ import java.util.List; @RunWith(Parameterized.class) public class JoinWithVerticesITCase extends MultipleProgramsTestBase { - public JoinWithVerticesITCase(TestExecutionMode mode){ + public JoinWithVerticesITCase(TestExecutionMode mode) { super(mode); } - private String expectedResult; + private String expectedResult; @Test public void testJoinWithVertexSet() throws Exception { @@ -50,77 +50,77 @@ public class JoinWithVerticesITCase extends MultipleProgramsTestBase { * Test joinWithVertices with the input DataSet parameter identical * to the vertex DataSet */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithVertices(graph.getVertices() - .map(new VertexToTuple2Map<Long, Long>()), new AddValuesMapper()); + Graph<Long, Long, Long> res = graph.joinWithVertices(graph.getVertices() + .map(new VertexToTuple2Map<Long, Long>()), new AddValuesMapper()); DataSet<Vertex<Long, Long>> data = res.getVertices(); - List<Vertex<Long, Long>> result= data.collect(); - - expectedResult = "1,2\n" + - "2,4\n" + - "3,6\n" + - "4,8\n" + - "5,10\n"; - + List<Vertex<Long, Long>> result = data.collect(); + + expectedResult = "1,2\n" + + "2,4\n" + + "3,6\n" + + "4,8\n" + + "5,10\n"; + compareResultAsTuples(result, expectedResult); - } + } @Test public void testWithLessElements() throws Exception { - /* - * Test joinWithVertices with the input DataSet passed as a parameter containing - * less elements than the vertex DataSet, but of the same type - */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + /* + * Test joinWithVertices with the input DataSet passed as a parameter containing + * less elements than the vertex DataSet, but of the same type + */ + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithVertices(graph.getVertices().first(3) - .map(new VertexToTuple2Map<Long, Long>()), new AddValuesMapper()); + Graph<Long, Long, Long> res = graph.joinWithVertices(graph.getVertices().first(3) + .map(new VertexToTuple2Map<Long, Long>()), new AddValuesMapper()); DataSet<Vertex<Long, Long>> data = res.getVertices(); - List<Vertex<Long, Long>> result= data.collect(); - - expectedResult = "1,2\n" + - "2,4\n" + - "3,6\n" + - "4,4\n" + - "5,5\n"; - + List<Vertex<Long, Long>> result = data.collect(); + + expectedResult = "1,2\n" + + "2,4\n" + + "3,6\n" + + "4,4\n" + + "5,5\n"; + compareResultAsTuples(result, expectedResult); - } + } @Test public void testWithDifferentType() throws Exception { - /* - * Test joinWithVertices with the input DataSet passed as a parameter containing - * less elements than the vertex DataSet and of a different type(Boolean) - */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + /* + * Test joinWithVertices with the input DataSet passed as a parameter containing + * less elements than the vertex DataSet and of a different type(Boolean) + */ + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithVertices(graph.getVertices().first(3) - .map(new ProjectIdWithTrue()), new DoubleIfTrueMapper()); + Graph<Long, Long, Long> res = graph.joinWithVertices(graph.getVertices().first(3) + .map(new ProjectIdWithTrue()), new DoubleIfTrueMapper()); DataSet<Vertex<Long, Long>> data = res.getVertices(); - List<Vertex<Long, Long>> result= data.collect(); - - expectedResult = "1,2\n" + - "2,4\n" + - "3,6\n" + - "4,4\n" + - "5,5\n"; - + List<Vertex<Long, Long>> result = data.collect(); + + expectedResult = "1,2\n" + + "2,4\n" + + "3,6\n" + + "4,4\n" + + "5,5\n"; + compareResultAsTuples(result, expectedResult); - } + } @Test public void testWithDifferentKeys() throws Exception { @@ -128,50 +128,50 @@ public class JoinWithVerticesITCase extends MultipleProgramsTestBase { * Test joinWithVertices with an input DataSet containing different keys than the vertex DataSet * - the iterator becomes empty. */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithVertices(TestGraphUtils.getLongLongTuple2Data(env), - new ProjectSecondMapper()); + Graph<Long, Long, Long> res = graph.joinWithVertices(TestGraphUtils.getLongLongTuple2Data(env), + new ProjectSecondMapper()); DataSet<Vertex<Long, Long>> data = res.getVertices(); - List<Vertex<Long, Long>> result= data.collect(); - - expectedResult = "1,10\n" + - "2,20\n" + - "3,30\n" + - "4,40\n" + - "5,5\n"; - + List<Vertex<Long, Long>> result = data.collect(); + + expectedResult = "1,10\n" + + "2,20\n" + + "3,30\n" + + "4,40\n" + + "5,5\n"; + compareResultAsTuples(result, expectedResult); - } + } @Test public void testWithCustomType() throws Exception { /* * Test joinWithVertices with a DataSet containing custom parametrised type input values */ - final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); + final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), + TestGraphUtils.getLongLongEdgeData(env), env); - Graph<Long, Long, Long> res = graph.joinWithVertices(TestGraphUtils.getLongCustomTuple2Data(env), - new CustomValueMapper()); + Graph<Long, Long, Long> res = graph.joinWithVertices(TestGraphUtils.getLongCustomTuple2Data(env), + new CustomValueMapper()); DataSet<Vertex<Long, Long>> data = res.getVertices(); - List<Vertex<Long, Long>> result= data.collect(); - - expectedResult = "1,10\n" + - "2,20\n" + - "3,30\n" + - "4,40\n" + - "5,5\n"; - + List<Vertex<Long, Long>> result = data.collect(); + + expectedResult = "1,10\n" + + "2,20\n" + + "3,30\n" + + "4,40\n" + + "5,5\n"; + compareResultAsTuples(result, expectedResult); - } + } @SuppressWarnings("serial") private static final class AddValuesMapper implements VertexJoinFunction<Long, Long> { @@ -183,23 +183,22 @@ public class JoinWithVerticesITCase extends MultipleProgramsTestBase { @SuppressWarnings("serial") private static final class ProjectIdWithTrue implements MapFunction<Vertex<Long, Long>, Tuple2<Long, Boolean>> { - public Tuple2<Long, Boolean> map(Vertex<Long, Long> vertex) throws Exception { - return new Tuple2<>(vertex.getId(), true); - } - } + public Tuple2<Long, Boolean> map(Vertex<Long, Long> vertex) throws Exception { + return new Tuple2<>(vertex.getId(), true); + } + } @SuppressWarnings("serial") private static final class DoubleIfTrueMapper implements VertexJoinFunction<Long, Boolean> { public Long vertexJoin(Long vertexValue, Boolean inputValue) { - if(inputValue) { - return vertexValue * 2; - } - else { - return vertexValue; - } + if (inputValue) { + return vertexValue * 2; + } else { + return vertexValue; + } } - } + } @SuppressWarnings("serial") private static final class ProjectSecondMapper implements VertexJoinFunction<Long, Long> { @@ -207,7 +206,7 @@ public class JoinWithVerticesITCase extends MultipleProgramsTestBase { public Long vertexJoin(Long vertexValue, Long inputValue) { return inputValue; } - } + } @SuppressWarnings("serial") private static final class CustomValueMapper implements VertexJoinFunction<Long, @@ -216,5 +215,5 @@ public class JoinWithVerticesITCase extends MultipleProgramsTestBase { public Long vertexJoin(Long vertexValue, DummyCustomParameterizedType<Float> inputValue) { return (long) inputValue.getIntField(); } - } + } } http://git-wip-us.apache.org/repos/asf/flink/blob/cb282067/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/MapEdgesITCase.java ---------------------------------------------------------------------- diff --git a/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/MapEdgesITCase.java b/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/MapEdgesITCase.java index 5e751a5..34a2518 100644 --- a/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/MapEdgesITCase.java +++ b/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/MapEdgesITCase.java @@ -18,8 +18,6 @@ package org.apache.flink.graph.test.operations; -import java.util.List; - import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.api.java.DataSet; import org.apache.flink.api.java.ExecutionEnvironment; @@ -34,14 +32,16 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; +import java.util.List; + @RunWith(Parameterized.class) public class MapEdgesITCase extends MultipleProgramsTestBase { - public MapEdgesITCase(TestExecutionMode mode){ + public MapEdgesITCase(TestExecutionMode mode) { super(mode); } - private String expectedResult; + private String expectedResult; @Test public void testWithSameValue() throws Exception { @@ -49,21 +49,21 @@ public class MapEdgesITCase extends MultipleProgramsTestBase { * Test mapEdges() keeping the same value type */ final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Edge<Long, Long>> mappedEdges = graph.mapEdges(new AddOneMapper()).getEdges(); - List<Edge<Long, Long>> result= mappedEdges.collect(); - + List<Edge<Long, Long>> result = mappedEdges.collect(); + expectedResult = "1,2,13\n" + - "1,3,14\n" + - "2,3,24\n" + - "3,4,35\n" + - "3,5,36\n" + - "4,5,46\n" + - "5,1,52\n"; - + "1,3,14\n" + + "2,3,24\n" + + "3,4,35\n" + + "3,5,36\n" + + "4,5,46\n" + + "5,1,52\n"; + compareResultAsTuples(result, expectedResult); } @@ -73,21 +73,21 @@ public class MapEdgesITCase extends MultipleProgramsTestBase { * Test mapEdges() and change the value type to String */ final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Edge<Long, String>> mappedEdges = graph.mapEdges(new ToStringMapper()).getEdges(); - List<Edge<Long, String>> result= mappedEdges.collect(); - + List<Edge<Long, String>> result = mappedEdges.collect(); + expectedResult = "1,2,string(12)\n" + - "1,3,string(13)\n" + - "2,3,string(23)\n" + - "3,4,string(34)\n" + - "3,5,string(35)\n" + - "4,5,string(45)\n" + - "5,1,string(51)\n"; - + "1,3,string(13)\n" + + "2,3,string(23)\n" + + "3,4,string(34)\n" + + "3,5,string(35)\n" + + "4,5,string(45)\n" + + "5,1,string(51)\n"; + compareResultAsTuples(result, expectedResult); } @@ -97,21 +97,21 @@ public class MapEdgesITCase extends MultipleProgramsTestBase { * Test mapEdges() and change the value type to a Tuple1 */ final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Edge<Long, Tuple1<Long>>> mappedEdges = graph.mapEdges(new ToTuple1Mapper()).getEdges(); - List<Edge<Long, Tuple1<Long>>> result= mappedEdges.collect(); + List<Edge<Long, Tuple1<Long>>> result = mappedEdges.collect(); expectedResult = "1,2,(12)\n" + - "1,3,(13)\n" + - "2,3,(23)\n" + - "3,4,(34)\n" + - "3,5,(35)\n" + - "4,5,(45)\n" + - "5,1,(51)\n"; - + "1,3,(13)\n" + + "2,3,(23)\n" + + "3,4,(34)\n" + + "3,5,(35)\n" + + "4,5,(45)\n" + + "5,1,(51)\n"; + compareResultAsTuples(result, expectedResult); } @@ -121,21 +121,21 @@ public class MapEdgesITCase extends MultipleProgramsTestBase { * Test mapEdges() and change the value type to a custom type */ final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Edge<Long, DummyCustomType>> mappedEdges = graph.mapEdges(new ToCustomTypeMapper()).getEdges(); - List<Edge<Long, DummyCustomType>> result= mappedEdges.collect(); + List<Edge<Long, DummyCustomType>> result = mappedEdges.collect(); expectedResult = "1,2,(T,12)\n" + "1,3,(T,13)\n" + "2,3,(T,23)\n" + "3,4,(T,34)\n" + - "3,5,(T,35)\n" + - "4,5,(T,45)\n" + + "3,5,(T,35)\n" + + "4,5,(T,45)\n" + "5,1,(T,51)\n"; - + compareResultAsTuples(result, expectedResult); } @@ -145,29 +145,29 @@ public class MapEdgesITCase extends MultipleProgramsTestBase { * Test mapEdges() and change the value type to a parameterized custom type */ final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Edge<Long, DummyCustomParameterizedType<Double>>> mappedEdges = graph.mapEdges( - new ToCustomParametrizedTypeMapper()).getEdges(); - List<Edge<Long, DummyCustomParameterizedType<Double>>> result= mappedEdges.collect(); - + new ToCustomParametrizedTypeMapper()).getEdges(); + List<Edge<Long, DummyCustomParameterizedType<Double>>> result = mappedEdges.collect(); + expectedResult = "1,2,(12.0,12)\n" + "1,3,(13.0,13)\n" + "2,3,(23.0,23)\n" + "3,4,(34.0,34)\n" + - "3,5,(35.0,35)\n" + - "4,5,(45.0,45)\n" + + "3,5,(35.0,35)\n" + + "4,5,(45.0,45)\n" + "5,1,(51.0,51)\n"; - + compareResultAsTuples(result, expectedResult); } @SuppressWarnings("serial") private static final class AddOneMapper implements MapFunction<Edge<Long, Long>, Long> { public Long map(Edge<Long, Long> edge) throws Exception { - return edge.getValue()+1; + return edge.getValue() + 1; } } @@ -191,19 +191,19 @@ public class MapEdgesITCase extends MultipleProgramsTestBase { private static final class ToCustomTypeMapper implements MapFunction<Edge<Long, Long>, DummyCustomType> { public DummyCustomType map(Edge<Long, Long> edge) throws Exception { DummyCustomType dummyValue = new DummyCustomType(); - dummyValue.setIntField(edge.getValue().intValue()); + dummyValue.setIntField(edge.getValue().intValue()); return dummyValue; } } @SuppressWarnings("serial") - private static final class ToCustomParametrizedTypeMapper implements MapFunction<Edge<Long, Long>, + private static final class ToCustomParametrizedTypeMapper implements MapFunction<Edge<Long, Long>, DummyCustomParameterizedType<Double>> { public DummyCustomParameterizedType<Double> map(Edge<Long, Long> edge) throws Exception { DummyCustomParameterizedType<Double> dummyValue = new DummyCustomParameterizedType<>(); dummyValue.setIntField(edge.getValue().intValue()); - dummyValue.setTField(new Double(edge.getValue())); + dummyValue.setTField(new Double(edge.getValue())); return dummyValue; } } http://git-wip-us.apache.org/repos/asf/flink/blob/cb282067/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/MapVerticesITCase.java ---------------------------------------------------------------------- diff --git a/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/MapVerticesITCase.java b/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/MapVerticesITCase.java index 108be3e..24aae7b 100644 --- a/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/MapVerticesITCase.java +++ b/flink-libraries/flink-gelly/src/test/java/org/apache/flink/graph/test/operations/MapVerticesITCase.java @@ -18,8 +18,6 @@ package org.apache.flink.graph.test.operations; -import java.util.List; - import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.api.java.DataSet; import org.apache.flink.api.java.ExecutionEnvironment; @@ -34,14 +32,16 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; +import java.util.List; + @RunWith(Parameterized.class) public class MapVerticesITCase extends MultipleProgramsTestBase { - public MapVerticesITCase(TestExecutionMode mode){ + public MapVerticesITCase(TestExecutionMode mode) { super(mode); } - private String expectedResult; + private String expectedResult; @Test public void testWithSameValue() throws Exception { @@ -49,19 +49,19 @@ public class MapVerticesITCase extends MultipleProgramsTestBase { * Test mapVertices() keeping the same value type */ final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - - DataSet<Vertex<Long, Long>> mappedVertices = graph.mapVertices(new AddOneMapper()).getVertices(); - List<Vertex<Long, Long>> result= mappedVertices.collect(); - + TestGraphUtils.getLongLongEdgeData(env), env); + + DataSet<Vertex<Long, Long>> mappedVertices = graph.mapVertices(new AddOneMapper()).getVertices(); + List<Vertex<Long, Long>> result = mappedVertices.collect(); + expectedResult = "1,2\n" + "2,3\n" + "3,4\n" + "4,5\n" + "5,6\n"; - + compareResultAsTuples(result, expectedResult); } @@ -71,19 +71,19 @@ public class MapVerticesITCase extends MultipleProgramsTestBase { * Test mapVertices() and change the value type to String */ final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Vertex<Long, String>> mappedVertices = graph.mapVertices(new ToStringMapper()).getVertices(); - List<Vertex<Long, String>> result= mappedVertices.collect(); + List<Vertex<Long, String>> result = mappedVertices.collect(); expectedResult = "1,one\n" + "2,two\n" + "3,three\n" + "4,four\n" + "5,five\n"; - + compareResultAsTuples(result, expectedResult); } @@ -93,19 +93,19 @@ public class MapVerticesITCase extends MultipleProgramsTestBase { * Test mapVertices() and change the value type to a Tuple1 */ final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Vertex<Long, Tuple1<Long>>> mappedVertices = graph.mapVertices(new ToTuple1Mapper()).getVertices(); - List<Vertex<Long, Tuple1<Long>>> result= mappedVertices.collect(); + List<Vertex<Long, Tuple1<Long>>> result = mappedVertices.collect(); expectedResult = "1,(1)\n" + "2,(2)\n" + "3,(3)\n" + "4,(4)\n" + "5,(5)\n"; - + compareResultAsTuples(result, expectedResult); } @@ -115,19 +115,19 @@ public class MapVerticesITCase extends MultipleProgramsTestBase { * Test mapVertices() and change the value type to a custom type */ final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Vertex<Long, DummyCustomType>> mappedVertices = graph.mapVertices(new ToCustomTypeMapper()).getVertices(); - List<Vertex<Long, DummyCustomType>> result= mappedVertices.collect(); + List<Vertex<Long, DummyCustomType>> result = mappedVertices.collect(); expectedResult = "1,(T,1)\n" + "2,(T,2)\n" + "3,(T,3)\n" + "4,(T,4)\n" + "5,(T,5)\n"; - + compareResultAsTuples(result, expectedResult); } @@ -137,27 +137,27 @@ public class MapVerticesITCase extends MultipleProgramsTestBase { * Test mapVertices() and change the value type to a parameterized custom type */ final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); - + Graph<Long, Long, Long> graph = Graph.fromDataSet(TestGraphUtils.getLongLongVertexData(env), - TestGraphUtils.getLongLongEdgeData(env), env); - + TestGraphUtils.getLongLongEdgeData(env), env); + DataSet<Vertex<Long, DummyCustomParameterizedType<Double>>> mappedVertices = graph.mapVertices( - new ToCustomParametrizedTypeMapper()).getVertices(); - List<Vertex<Long, DummyCustomParameterizedType<Double>>> result= mappedVertices.collect(); - + new ToCustomParametrizedTypeMapper()).getVertices(); + List<Vertex<Long, DummyCustomParameterizedType<Double>>> result = mappedVertices.collect(); + expectedResult = "1,(1.0,1)\n" + "2,(2.0,2)\n" + "3,(3.0,3)\n" + "4,(4.0,4)\n" + "5,(5.0,5)\n"; - + compareResultAsTuples(result, expectedResult); } @SuppressWarnings("serial") private static final class AddOneMapper implements MapFunction<Vertex<Long, Long>, Long> { public Long map(Vertex<Long, Long> value) throws Exception { - return value.getValue()+1; + return value.getValue() + 1; } } @@ -167,20 +167,15 @@ public class MapVerticesITCase extends MultipleProgramsTestBase { String stringValue; if (vertex.getValue() == 1) { stringValue = "one"; - } - else if (vertex.getValue() == 2) { + } else if (vertex.getValue() == 2) { stringValue = "two"; - } - else if (vertex.getValue() == 3) { + } else if (vertex.getValue() == 3) { stringValue = "three"; - } - else if (vertex.getValue() == 4) { + } else if (vertex.getValue() == 4) { stringValue = "four"; - } - else if (vertex.getValue() == 5) { + } else if (vertex.getValue() == 5) { stringValue = "five"; - } - else { + } else { stringValue = ""; } return stringValue; @@ -200,19 +195,19 @@ public class MapVerticesITCase extends MultipleProgramsTestBase { private static final class ToCustomTypeMapper implements MapFunction<Vertex<Long, Long>, DummyCustomType> { public DummyCustomType map(Vertex<Long, Long> vertex) throws Exception { DummyCustomType dummyValue = new DummyCustomType(); - dummyValue.setIntField(vertex.getValue().intValue()); + dummyValue.setIntField(vertex.getValue().intValue()); return dummyValue; } } @SuppressWarnings("serial") - private static final class ToCustomParametrizedTypeMapper implements MapFunction<Vertex<Long, Long>, + private static final class ToCustomParametrizedTypeMapper implements MapFunction<Vertex<Long, Long>, DummyCustomParameterizedType<Double>> { - + public DummyCustomParameterizedType<Double> map(Vertex<Long, Long> vertex) throws Exception { DummyCustomParameterizedType<Double> dummyValue = new DummyCustomParameterizedType<>(); dummyValue.setIntField(vertex.getValue().intValue()); - dummyValue.setTField(new Double(vertex.getValue())); + dummyValue.setTField(new Double(vertex.getValue())); return dummyValue; } }
