Repository: tinkerpop Updated Branches: refs/heads/TINKERPOP-1643 9e80e420f -> d64efe528 (forced update)
Added failing tests for TINKERPOP-1643. Also simplified a few test queries and tweaked the assertions so that they should now work in STANDARD and COMPUTER mode. Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/d64efe52 Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/d64efe52 Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/d64efe52 Branch: refs/heads/TINKERPOP-1643 Commit: d64efe528aa33578830d6c74d7ae5e04d2d90242 Parents: 891bfa3 Author: Daniel Kuppitz <[email protected]> Authored: Thu Mar 2 12:41:48 2017 +0100 Committer: Daniel Kuppitz <[email protected]> Committed: Mon Jun 18 14:25:03 2018 -0700 ---------------------------------------------------------------------- .../step/branch/GroovyRepeatTest.groovy | 24 ++- gremlin-test/features/branch/Repeat.feature | 66 ++++++++ .../traversal/step/branch/RepeatTest.java | 165 +++++++++++++++---- 3 files changed, 224 insertions(+), 31 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/d64efe52/gremlin-groovy-test/src/main/groovy/org/apache/tinkerpop/gremlin/process/traversal/step/branch/GroovyRepeatTest.groovy ---------------------------------------------------------------------- diff --git a/gremlin-groovy-test/src/main/groovy/org/apache/tinkerpop/gremlin/process/traversal/step/branch/GroovyRepeatTest.groovy b/gremlin-groovy-test/src/main/groovy/org/apache/tinkerpop/gremlin/process/traversal/step/branch/GroovyRepeatTest.groovy index 581c511..ca103df 100644 --- a/gremlin-groovy-test/src/main/groovy/org/apache/tinkerpop/gremlin/process/traversal/step/branch/GroovyRepeatTest.groovy +++ b/gremlin-groovy-test/src/main/groovy/org/apache/tinkerpop/gremlin/process/traversal/step/branch/GroovyRepeatTest.groovy @@ -23,8 +23,6 @@ import org.apache.tinkerpop.gremlin.process.traversal.Traversal import org.apache.tinkerpop.gremlin.process.traversal.util.ScriptTraversal import org.apache.tinkerpop.gremlin.structure.Vertex -import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.both - /** * @author Marko A. Rodriguez (http://markorodriguez.com) */ @@ -79,7 +77,7 @@ public abstract class GroovyRepeatTest { @Override public Traversal<Vertex, Map<String, Vertex>> get_g_V_repeatXbothX_timesX10X_asXaX_out_asXbX_selectXa_bX() { - new ScriptTraversal<>(g, "gremlin-groovy", "g.V.repeat(both()).times(10).as('a').out().as('b').select('a', 'b')"); + new ScriptTraversal<>(g, "gremlin-groovy", "g.V.repeat(both()).times(10).as('a').out().as('b').select('a', 'b')") } @Override @@ -107,5 +105,25 @@ public abstract class GroovyRepeatTest { public Traversal<Vertex, Path> get_g_V_hasXloop_name_loopX_repeatXinX_timesX5X_path_by_name() { new ScriptTraversal<>(g, "gremlin-groovy", "g.V().has('loops','name','loop').repeat(__.in()).times(5).path().by('name')") } + + @Override + public Traversal<Vertex, Long> get_g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXvX_count() { + new ScriptTraversal<>(g, "gremlin-groovy", "g.V.as('v').emit.repeat(both.as('v').dedup).select('v').count") + } + + @Override + public Traversal<Vertex, List<Vertex>> get_g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXall_vX_order_byXcountXlocalXX_byXlimitXlocal_1X_idX_byXtailXlocal_1X_idX() { + new ScriptTraversal<>(g, "gremlin-groovy", "g.V.as('v').emit.repeat(both.as('v').dedup).select(all, 'v').order.by(count(local)).by(limit(local, 1).id).by(tail(local, 1).id)") + } + + @Override + public Traversal<Vertex, Long> get_g_V_emit_repeatXboth_dedupX_count() { + new ScriptTraversal<>(g, "gremlin-groovy", "g.V.emit.repeat(both.dedup).count") + } + + @Override + public Traversal<Vertex, Vertex> get_g_V_emit_repeatXboth_dedupX_order_byXcountXlocalXX() { + new ScriptTraversal<>(g, "gremlin-groovy", "g.V.emit.repeat(both.dedup).order.by(count(local))") + } } } http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/d64efe52/gremlin-test/features/branch/Repeat.feature ---------------------------------------------------------------------- diff --git a/gremlin-test/features/branch/Repeat.feature b/gremlin-test/features/branch/Repeat.feature index 6175519..447c2d6 100644 --- a/gremlin-test/features/branch/Repeat.feature +++ b/gremlin-test/features/branch/Repeat.feature @@ -244,3 +244,69 @@ Feature: Step - repeat() | loop | | loop | | loop | + + Scenario: g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXvX_count + Given the modern graph + And the traversal of + """ + g.V().as("v").emit().repeat(both().as("v").dedup()).select("v").count() + """ + When iterated next + Then the result should be unordered + | result | + | d[12].l | + + Scenario: g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXall_vX_order_byXcountXlocalXX_byXlimitXlocal_1X_idX_byXtailXlocal_1X_idX + Given the modern graph + And the traversal of + """ + g.V().as("v").emit().repeat(both().as("v").dedup()).select(Pop.all, "v").order().by(count(local)).by(limit(local, 1).id()).by(tail(local, 1).id()); + """ + When iterated next + Then the result should be unordered + | result | + | l[v[marko]] | + | l[v[vadas]] | + | l[v[lop]] | + | l[v[josh]] | + | l[v[ripple]] | + | l[v[peter]] | + | l[v[marko], v[vadas]] | + | l[v[marko], v[lop]] | + | l[v[marko], v[josh]] | + | l[v[vadas], v[marko]] | + | l[v[lop], v[ripple]] | + | l[v[josh], v[peter]] | + + Scenario: g_V_emit_repeatXboth_dedupX_count + Given the modern graph + And the traversal of + """ + g.V().emit().repeat(both().dedup()).count() + """ + When iterated next + Then the result should be unordered + | result | + | d[12].l | + + Scenario: g_V_emit_repeatXboth_dedupX_order_byXcountXlocalXX + Given the modern graph + And the traversal of + """ + g.V().emit().repeat(both().dedup()).order().by(count(local)) + """ + When iterated next + Then the result should be unordered + | result | + | v[1] | + | v[1] | + | v[2] | + | v[2] | + | v[3] | + | v[3] | + | v[4] | + | v[4] | + | v[5] | + | v[5] | + | v[6] | + | v[6] | http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/d64efe52/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/RepeatTest.java ---------------------------------------------------------------------- diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/RepeatTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/RepeatTest.java index 6d90687..55c897f 100644 --- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/RepeatTest.java +++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/RepeatTest.java @@ -22,6 +22,8 @@ import org.apache.tinkerpop.gremlin.LoadGraphWith; import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest; import org.apache.tinkerpop.gremlin.process.GremlinProcessRunner; import org.apache.tinkerpop.gremlin.process.traversal.Path; +import org.apache.tinkerpop.gremlin.process.traversal.Pop; +import org.apache.tinkerpop.gremlin.process.traversal.Scope; import org.apache.tinkerpop.gremlin.process.traversal.Traversal; import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__; import org.apache.tinkerpop.gremlin.process.traversal.step.util.MapHelper; @@ -39,12 +41,15 @@ import java.util.Map; import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN; import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.SINK; import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.both; +import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.count; import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.groupCount; import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has; import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.in; +import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.limit; import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.loops; import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.out; import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.outE; +import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.tail; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.core.Is.is; import static org.hamcrest.collection.IsIterableContainingInOrder.contains; @@ -62,6 +67,27 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest { // DO/WHILE + private static void assertPath(final Traversal<Vertex, Path> traversal) { + int path1 = 0; + int path2 = 0; + int path3 = 0; + while (traversal.hasNext()) { + final Path path = traversal.next(); + if (path.size() == 1) { + path1++; + } else if (path.size() == 2) { + path2++; + } else if (path.size() == 3) { + path3++; + } else { + fail("Only path lengths of 1, 2, or 3 should be seen"); + } + } + assertEquals(6, path1); + assertEquals(6, path2); + assertEquals(2, path3); + } + public abstract Traversal<Vertex, Path> get_g_V_repeatXoutX_timesX2X_emit_path(); public abstract Traversal<Vertex, String> get_g_V_repeatXoutX_timesX2X_repeatXinX_timesX2X_name(); @@ -80,16 +106,16 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest { public abstract Traversal<Vertex, Path> get_g_V_emit_repeatXoutX_timesX2X_path(); - public abstract Traversal<Vertex, String> get_g_VX1X_emitXhasXlabel_personXX_repeatXoutX_name(final Object v1Id); - // SIDE-EFFECTS - public abstract Traversal<Vertex, Map<String, Long>> get_g_V_repeatXgroupCountXmX_byXnameX_outX_timesX2X_capXmX(); + public abstract Traversal<Vertex, String> get_g_VX1X_emitXhasXlabel_personXX_repeatXoutX_name(final Object v1Id); public abstract Traversal<Vertex, Map<Integer, Long>> get_g_VX1X_repeatXgroupCountXmX_byXloopsX_outX_timesX3X_capXmX(final Object v1Id); // + public abstract Traversal<Vertex, Map<String, Long>> get_g_V_repeatXgroupCountXmX_byXnameX_outX_timesX2X_capXmX(); + public abstract Traversal<Vertex, Map<String, Vertex>> get_g_V_repeatXbothX_timesX10X_asXaX_out_asXbX_selectXa_bX(); public abstract Traversal<Vertex, String> get_g_VX1X_repeatXoutX_untilXoutE_count_isX0XX_name(final Object v1Id); @@ -98,6 +124,14 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest { public abstract Traversal<Vertex, Path> get_g_V_hasXname_markoX_repeatXoutE_inV_simplePathX_untilXhasXname_rippleXX_path_byXnameX_byXlabelX(); + public abstract Traversal<Vertex, Long> get_g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXvX_count(); + + public abstract Traversal<Vertex, List<Vertex>> get_g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXall_vX_order_byXcountXlocalXX_byXlimitXlocal_1X_idX_byXtailXlocal_1X_idX(); + + public abstract Traversal<Vertex, Long> get_g_V_emit_repeatXboth_dedupX_count(); + + public abstract Traversal<Vertex, Vertex> get_g_V_emit_repeatXboth_dedupX_order_byXcountXlocalXX(); + @Test @LoadGraphWith(MODERN) public void g_V_repeatXoutX_timesX2X_emit_path() { @@ -186,27 +220,6 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest { assertPath(traversal); } - private static void assertPath(final Traversal<Vertex, Path> traversal) { - int path1 = 0; - int path2 = 0; - int path3 = 0; - while (traversal.hasNext()) { - final Path path = traversal.next(); - if (path.size() == 1) { - path1++; - } else if (path.size() == 2) { - path2++; - } else if (path.size() == 3) { - path3++; - } else { - fail("Only path lengths of 1, 2, or 3 should be seen"); - } - } - assertEquals(6, path1); - assertEquals(6, path2); - assertEquals(2, path3); - } - @Test @LoadGraphWith(SINK) public void g_V_hasXloop_name_loopX_repeatXinX_timesX5X_path_by_name() { @@ -282,6 +295,26 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest { @Test @LoadGraphWith(MODERN) + public void g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXvX_count() { + final Traversal<Vertex, Long> traversal = get_g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXvX_count(); + printTraversalForm(traversal); + assertTrue(traversal.hasNext()); + assertEquals(12L, traversal.next().longValue()); + assertFalse(traversal.hasNext()); + } + + @Test + @LoadGraphWith(MODERN) + public void g_V_emit_repeatXboth_dedupX_count() { + final Traversal<Vertex, Long> traversal = get_g_V_emit_repeatXboth_dedupX_count(); + printTraversalForm(traversal); + assertTrue(traversal.hasNext()); + assertEquals(12L, traversal.next().longValue()); + assertFalse(traversal.hasNext()); + } + + @Test + @LoadGraphWith(MODERN) public void g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX() { final Traversal<Vertex, Map<String, Long>> traversal = get_g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX(); printTraversalForm(traversal); @@ -310,6 +343,62 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest { assertEquals("ripple", path.get(4)); } + @Test + @LoadGraphWith(MODERN) + public void g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXall_vX_order_byXcountXlocalXX_byXlimitXlocal_1X_idX_byXtailXlocal_1X_idX() { + final Traversal<Vertex, List<Vertex>> traversal = get_g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXall_vX_order_byXcountXlocalXX_byXlimitXlocal_1X_idX_byXtailXlocal_1X_idX(); + printTraversalForm(traversal); + final Vertex marko = convertToVertex(graph, "marko"); + final Vertex vadas = convertToVertex(graph, "vadas"); + final Vertex lop = convertToVertex(graph, "lop"); + final Vertex josh = convertToVertex(graph, "josh"); + final Vertex ripple = convertToVertex(graph, "ripple"); + final Vertex peter = convertToVertex(graph, "peter"); + List<Vertex> vertices; + assertEquals(1, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), marko); + assertEquals(1, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), vadas); + assertEquals(1, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), lop); + assertEquals(1, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), josh); + assertEquals(1, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), ripple); + assertEquals(1, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), peter); + assertEquals(2, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), marko); assertEquals(vertices.get(1), vadas); + assertEquals(2, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), marko); assertEquals(vertices.get(1), lop); + assertEquals(2, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), marko); assertEquals(vertices.get(1), josh); + assertEquals(2, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), vadas); assertEquals(vertices.get(1), marko); + assertEquals(2, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), lop); assertEquals(vertices.get(1), ripple); + assertEquals(2, (vertices = traversal.next()).size()); + assertEquals(vertices.get(0), josh); assertEquals(vertices.get(1), peter); + assertFalse(traversal.hasNext()); + } + + @Test + @LoadGraphWith(MODERN) + public void g_V_emit_repeatXboth_dedupX_order_byXcountXlocalXX() { + final Traversal<Vertex, Vertex> traversal = get_g_V_emit_repeatXboth_dedupX_order_byXcountXlocalXX(); + printTraversalForm(traversal); + final Map<Vertex, Integer> tmp = new HashMap<>(6); + for (int j = 0; j < 2; j++) { + for (int i = 0; i < 6; i++) { + assertTrue(traversal.hasNext()); + tmp.compute(traversal.next(), (k, v) -> v != null ? v + 1 : 1); + } + } + assertFalse(traversal.hasNext()); + assertEquals(6, tmp.size()); + assertTrue(tmp.values().stream().noneMatch(v -> v != 2)); + } + public static class Traversals extends RepeatTest { @Override @@ -338,13 +427,13 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest { } @Override - public Traversal<Vertex, Path> get_g_V_emit_repeatXoutX_timesX2X_path() { - return g.V().emit().repeat(out()).times(2).path(); + public Traversal<Vertex, Path> get_g_V_emit_timesX2X_repeatXoutX_path() { + return g.V().emit().times(2).repeat(out()).path(); } @Override - public Traversal<Vertex, Path> get_g_V_emit_timesX2X_repeatXoutX_path() { - return g.V().emit().times(2).repeat(out()).path(); + public Traversal<Vertex, Path> get_g_V_emit_repeatXoutX_timesX2X_path() { + return g.V().emit().repeat(out()).times(2).path(); } @Override @@ -386,5 +475,25 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest { public Traversal<Vertex, Path> get_g_V_hasXloop_name_loopX_repeatXinX_timesX5X_path_by_name() { return g.V().has("loops","name","loop").repeat(__.in()).times(5).path().by("name"); } + + @Override + public Traversal<Vertex, Long> get_g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXvX_count() { + return g.V().as("v").emit().repeat(both().as("v").dedup()).select("v").count(); + } + + @Override + public Traversal<Vertex, List<Vertex>> get_g_V_asXvX_emit_repeatXboth_asXvX_dedupX_selectXall_vX_order_byXcountXlocalXX_byXlimitXlocal_1X_idX_byXtailXlocal_1X_idX() { + return g.V().as("v").emit().repeat(both().as("v").dedup()).<List<Vertex>>select(Pop.all, "v").order().by(count(Scope.local)).by(limit(Scope.local, 1).id()).by(tail(Scope.local, 1).id()); + } + + @Override + public Traversal<Vertex, Long> get_g_V_emit_repeatXboth_dedupX_count() { + return g.V().emit().repeat(both().dedup()).count(); + } + + @Override + public Traversal<Vertex, Vertex> get_g_V_emit_repeatXboth_dedupX_order_byXcountXlocalXX() { + return g.V().emit().repeat(both().dedup()).order().by(count(Scope.local)); + } } }
