You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by ok...@apache.org on 2015/03/19 19:26:25 UTC
[07/40] incubator-tinkerpop git commit: the traversal steps provided
by TinkerPop are the foundation for all dsl. GraphTraversal is just a dsl of
traversal. Refactored the process API to reflect this concept. Fixed #592.
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/4c97e964/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/LocalTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/LocalTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/LocalTest.java
new file mode 100644
index 0000000..f88ff13
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/LocalTest.java
@@ -0,0 +1,255 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step.branch;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.traversal.T;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.UseEngine;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Order;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Map;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.CREW;
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.*;
+import static org.junit.Assert.*;
+
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ */
+public abstract class LocalTest extends AbstractGremlinProcessTest {
+
+ public abstract Traversal<Vertex, String> get_g_V_localXpropertiesXlocationX_order_byXvalueX_limitX2XX_value();
+
+ public abstract Traversal<Vertex, Map<String, Object>> get_g_V_hasXlabel_personX_asXaX_localXoutXcreatedX_asXbXX_selectXa_bX_byXnameX_byXidX();
+
+ public abstract Traversal<Vertex, Long> get_g_V_localXoutE_countX();
+
+ public abstract Traversal<Vertex, String> get_g_VX1X_localXoutEXknowsX_limitX1XX_inV_name(final Object v1Id);
+
+ public abstract Traversal<Vertex, String> get_g_V_localXbothEXcreatedX_limitX1XX_otherV_name();
+
+ public abstract Traversal<Vertex, Edge> get_g_VX4X_localXbothEX1_createdX_limitX1XX(final Object v4Id);
+
+ public abstract Traversal<Vertex, Edge> get_g_VX4X_localXbothEXknows_createdX_limitX1XX(final Object v4Id);
+
+ public abstract Traversal<Vertex, String> get_g_VX4X_localXbothE_limitX1XX_otherV_name(final Object v4Id);
+
+ public abstract Traversal<Vertex, String> get_g_VX4X_localXbothE_limitX2XX_otherV_name(final Object v4Id);
+
+ public abstract Traversal<Vertex, String> get_g_V_localXinEXknowsX_limitX2XX_outV_name();
+
+ @Test
+ @LoadGraphWith(CREW)
+ public void g_V_localXpropertiesXlocationX_order_byXvalueX_limitX2XX_value() {
+ final Traversal<Vertex, String> traversal = get_g_V_localXpropertiesXlocationX_order_byXvalueX_limitX2XX_value();
+ printTraversalForm(traversal);
+ checkResults(Arrays.asList("brussels", "san diego", "centreville", "dulles", "baltimore", "bremen", "aachen", "kaiserslautern"), traversal);
+
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_hasXlabel_personX_asXaX_localXoutXcreatedX_asXbXX_selectXa_bX_byXnameX_by() {
+ final Traversal<Vertex, Map<String, Object>> traversal = get_g_V_hasXlabel_personX_asXaX_localXoutXcreatedX_asXbXX_selectXa_bX_byXnameX_byXidX();
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ final Map<String, Object> map = traversal.next();
+ counter++;
+ assertEquals(2, map.size());
+ if (map.get("a").equals("marko")) {
+ assertEquals(convertToVertexId("lop"), map.get("b"));
+ } else if (map.get("a").equals("josh")) {
+ assertTrue(convertToVertexId("lop").equals(map.get("b")) || convertToVertexId("ripple").equals(map.get("b")));
+ } else if (map.get("a").equals("peter")) {
+ assertEquals(convertToVertexId("lop"), map.get("b"));
+ } else {
+ fail("The following map should not have been returned: " + map);
+ }
+ }
+ assertEquals(4, counter);
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_localXoutE_countX() {
+ final Traversal<Vertex, Long> traversal = get_g_V_localXoutE_countX();
+ printTraversalForm(traversal);
+ checkResults(Arrays.asList(3l, 0l, 0l, 0l, 1l, 2l), traversal);
+
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX4X_localXbothEXknows_createdX_limitX1XX() {
+ final Traversal<Vertex, Edge> traversal = get_g_VX4X_localXbothEXknows_createdX_limitX1XX(convertToVertexId("josh"));
+ printTraversalForm(traversal);
+ final Edge edge = traversal.next();
+ assertTrue(edge.label().equals("created") || edge.label().equals("knows"));
+ assertTrue(edge.value("weight").equals(1.0d) || edge.value("weight").equals(0.4d));
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX4X_localXbothE_limitX1XX_otherV_name() {
+ final Traversal<Vertex, String> traversal = get_g_VX4X_localXbothE_limitX1XX_otherV_name(convertToVertexId("josh"));
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ final String name = traversal.next();
+ assertTrue(name.equals("marko") || name.equals("ripple") || name.equals("lop"));
+ }
+ assertEquals(1, counter);
+ assertFalse(traversal.hasNext());
+
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX4X_localXbothE_limitX2XX_otherV_name() {
+ final Traversal<Vertex, String> traversal = get_g_VX4X_localXbothE_limitX2XX_otherV_name(convertToVertexId("josh"));
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ final String name = traversal.next();
+ assertTrue(name.equals("marko") || name.equals("ripple") || name.equals("lop"));
+ }
+ assertEquals(2, counter);
+ assertFalse(traversal.hasNext());
+ }
+
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_localXinEXknowsX_limitX2XX_outV_name() {
+ final Traversal<Vertex, String> traversal = get_g_V_localXinEXknowsX_limitX2XX_outV_name();
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ assertEquals(traversal.next(), "marko");
+ }
+ assertFalse(traversal.hasNext());
+ assertEquals(2, counter);
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX4X_localXbothEX1_createdX_limitX1XX() {
+ final Traversal<Vertex, Edge> traversal = get_g_VX4X_localXbothEX1_createdX_limitX1XX(convertToVertexId("josh"));
+ printTraversalForm(traversal);
+ final Edge edge = traversal.next();
+ assertEquals("created", edge.label());
+ assertTrue(edge.value("weight").equals(1.0d) || edge.value("weight").equals(0.4d));
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_localXoutEXknowsX_limitX1XX_inV_name() {
+ final Traversal<Vertex, String> traversal = get_g_VX1X_localXoutEXknowsX_limitX1XX_inV_name(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ final String name = traversal.next();
+ assertTrue(name.equals("vadas") || name.equals("josh"));
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_localXbothEXcreatedX_limitX1XX_otherV_name() {
+ final Traversal<Vertex, String> traversal = get_g_V_localXbothEXcreatedX_limitX1XX_otherV_name();
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ final String name = traversal.next();
+ assertTrue(name.equals("marko") || name.equals("lop") || name.equals("josh") || name.equals("ripple") || name.equals("peter"));
+ }
+ assertEquals(5, counter);
+ }
+
+ @UseEngine(TraversalEngine.Type.STANDARD)
+ @UseEngine(TraversalEngine.Type.COMPUTER)
+ public static class Traversals extends LocalTest {
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_localXpropertiesXlocationX_order_byXvalueX_limitX2XX_value() {
+ return g.V().local(properties("location").order().by(T.value, Order.incr).range(0, 2)).value();
+ }
+
+ @Override
+ public Traversal<Vertex, Map<String, Object>> get_g_V_hasXlabel_personX_asXaX_localXoutXcreatedX_asXbXX_selectXa_bX_byXnameX_byXidX() {
+ return g.V().has(T.label, "person").as("a").local(out("created").as("b")).select("a", "b").by("name").by(T.id);
+ }
+
+ @Override
+ public Traversal<Vertex, Long> get_g_V_localXoutE_countX() {
+ return g.V().local(outE().count());
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_VX1X_localXoutEXknowsX_limitX1XX_inV_name(final Object v1Id) {
+ return g.V(v1Id).local(outE("knows").limit(1)).inV().values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_localXbothEXcreatedX_limitX1XX_otherV_name() {
+ return g.V().local(bothE("created").limit(1)).otherV().values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, Edge> get_g_VX4X_localXbothEX1_createdX_limitX1XX(final Object v4Id) {
+ return g.V(v4Id).local(bothE("created").limit(1));
+ }
+
+ @Override
+ public Traversal<Vertex, Edge> get_g_VX4X_localXbothEXknows_createdX_limitX1XX(final Object v4Id) {
+ return g.V(v4Id).local(bothE("knows", "created").limit(1));
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_VX4X_localXbothE_limitX1XX_otherV_name(final Object v4Id) {
+ return g.V(v4Id).local(bothE().limit(1)).otherV().values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_VX4X_localXbothE_limitX2XX_otherV_name(final Object v4Id) {
+ return g.V(v4Id).local(bothE().limit(2)).otherV().values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_localXinEXknowsX_limitX2XX_outV_name() {
+ return g.V().local(inE("knows").limit(2)).outV().values("name");
+ }
+
+
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/4c97e964/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
new file mode 100644
index 0000000..1d26d88
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/RepeatTest.java
@@ -0,0 +1,272 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step.branch;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
+import org.apache.tinkerpop.gremlin.process.traversal.T;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.UseEngine;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.MapHelper;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.*;
+import static org.junit.Assert.*;
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ */
+public abstract class RepeatTest extends AbstractGremlinProcessTest {
+
+ // DO/WHILE
+
+ 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();
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_repeatXoutX_timesX2X();
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_repeatXoutX_timesX2X_emit();
+
+ // WHILE/DO
+
+ public abstract Traversal<Vertex, String> get_g_VX1X_timesX2X_repeatXoutX_name(final Object v1Id);
+
+ public abstract Traversal<Vertex, Path> get_g_V_emit_timesX2X_repeatXoutX_path();
+
+ public abstract Traversal<Vertex, Path> get_g_V_emit_repeatXoutX_timesX2X_path();
+
+ public abstract Traversal<Vertex, String> get_g_V_emitXhasXlabel_personXX_repeatXoutX_name(final Object v1Id);
+
+ // SIDE-EFFECTS
+
+ public abstract Traversal<Vertex, Map<String, Long>> get_g_V_repeatXgroupCountXmX_byXnameX_outX_timesX2X_capXmX();
+
+ // TODO:
+ /*
+ gremlin> g.V(1).repeat(out()).until(outE().count().cap().filter{it.get() == 0}).path().by('name') (3)
+ ==>[marko, lop]
+ ==>[marko, vadas]
+ ==>[marko, josh, ripple]
+ ==>[marko, josh, lop]
+ */
+
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_repeatXoutX_timesX2X_emit_path() {
+ final List<Traversal<Vertex, Path>> traversals = new ArrayList<>();
+ traversals.add(get_g_V_repeatXoutX_timesX2X_emit_path());
+ traversals.forEach(traversal -> {
+ printTraversalForm(traversal);
+ final Map<Integer, Long> pathLengths = new HashMap<>();
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ MapHelper.incr(pathLengths, traversal.next().size(), 1l);
+ }
+ assertEquals(2, pathLengths.size());
+ assertEquals(8, counter);
+ assertEquals(new Long(6), pathLengths.get(2));
+ assertEquals(new Long(2), pathLengths.get(3));
+ });
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_repeatXoutX_timesX2X_repeatXinX_timesX2X_name() {
+ final List<Traversal<Vertex, String>> traversals = new ArrayList<>();
+ traversals.add(get_g_V_repeatXoutX_timesX2X_repeatXinX_timesX2X_name());
+ traversals.forEach(traversal -> {
+ printTraversalForm(traversal);
+ checkResults(Arrays.asList("marko", "marko"), traversal);
+ });
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_repeatXoutX_timesX2X() {
+ final List<Traversal<Vertex, Vertex>> traversals = new ArrayList<>();
+ traversals.add(get_g_V_repeatXoutX_timesX2X());
+ traversals.forEach(traversal -> {
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ Vertex vertex = traversal.next();
+ assertTrue(vertex.value("name").equals("lop") || vertex.value("name").equals("ripple"));
+ }
+ assertEquals(2, counter);
+ assertFalse(traversal.hasNext());
+ });
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_repeatXoutX_timesX2X_emit() {
+ final List<Traversal<Vertex, Vertex>> traversals = new ArrayList<>();
+ traversals.add(get_g_V_repeatXoutX_timesX2X_emit());
+ traversals.forEach(traversal -> {
+ printTraversalForm(traversal);
+ Map<String, Long> map = new HashMap<>();
+ while (traversal.hasNext()) {
+ Vertex vertex = traversal.next();
+ MapHelper.incr(map, vertex.value("name"), 1l);
+ }
+ assertEquals(4, map.size());
+ assertTrue(map.containsKey("vadas"));
+ assertTrue(map.containsKey("josh"));
+ assertTrue(map.containsKey("ripple"));
+ assertTrue(map.containsKey("lop"));
+ assertEquals(new Long(1), map.get("vadas"));
+ assertEquals(new Long(1), map.get("josh"));
+ assertEquals(new Long(2), map.get("ripple"));
+ assertEquals(new Long(4), map.get("lop"));
+ });
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_timesX2X_repeatXoutX_name() {
+ final List<Traversal<Vertex, String>> traversals = Arrays.asList(
+ get_g_VX1X_timesX2X_repeatXoutX_name(convertToVertexId("marko")));
+ traversals.forEach(traversal -> {
+ printTraversalForm(traversal);
+ checkResults(Arrays.asList("lop", "ripple"), traversal);
+ });
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_emit_timesX2X_repeatXoutX_path() {
+ final List<Traversal<Vertex, Path>> traversals = Arrays.asList(
+ get_g_V_emit_timesX2X_repeatXoutX_path(),
+ get_g_V_emit_repeatXoutX_timesX2X_path());
+ traversals.forEach(traversal -> {
+ printTraversalForm(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(MODERN)
+ public void g_V_emitXhasXlabel_personXX_repeatXoutX_name() {
+ final List<Traversal<Vertex, String>> traversals = Arrays.asList(get_g_V_emitXhasXlabel_personXX_repeatXoutX_name(convertToVertexId("marko")));
+ traversals.forEach(traversal -> {
+ printTraversalForm(traversal);
+ checkResults(Arrays.asList("marko", "josh", "vadas"), traversal);
+ });
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_repeatXgroupCountXmX_byXnameX_outX_timesX2X_capXmX() {
+ final List<Traversal<Vertex, Map<String, Long>>> traversals = Arrays.asList(get_g_V_repeatXgroupCountXmX_byXnameX_outX_timesX2X_capXmX());
+ traversals.forEach(traversal -> {
+ printTraversalForm(traversal);
+ final Map<String, Long> map = traversal.next();
+ assertFalse(traversal.hasNext());
+ //[ripple:2, peter:1, vadas:2, josh:2, lop:4, marko:1]
+ assertEquals(6, map.size());
+ assertEquals(1l, map.get("marko").longValue());
+ assertEquals(2l, map.get("vadas").longValue());
+ assertEquals(2l, map.get("josh").longValue());
+ assertEquals(4l, map.get("lop").longValue());
+ assertEquals(2l, map.get("ripple").longValue());
+ assertEquals(1l, map.get("peter").longValue());
+ });
+ }
+
+ @UseEngine(TraversalEngine.Type.STANDARD)
+ @UseEngine(TraversalEngine.Type.COMPUTER)
+ public static class Traversals extends RepeatTest {
+
+ @Override
+ public Traversal<Vertex, Path> get_g_V_repeatXoutX_timesX2X_emit_path() {
+ return g.V().repeat(out()).times(2).emit().path();
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_repeatXoutX_timesX2X_repeatXinX_timesX2X_name() {
+ return g.V().repeat(out()).times(2).repeat(in()).times(2).values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_repeatXoutX_timesX2X() {
+ return g.V().repeat(out()).times(2);
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_repeatXoutX_timesX2X_emit() {
+ return g.V().repeat(out()).times(2).emit();
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_VX1X_timesX2X_repeatXoutX_name(Object v1Id) {
+ return g.V(v1Id).times(2).repeat(out()).values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, Path> get_g_V_emit_repeatXoutX_timesX2X_path() {
+ return g.V().emit().repeat(out()).times(2).path();
+ }
+
+ @Override
+ public Traversal<Vertex, Path> get_g_V_emit_timesX2X_repeatXoutX_path() {
+ return g.V().emit().times(2).repeat(out()).path();
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_emitXhasXlabel_personXX_repeatXoutX_name(final Object v1Id) {
+ return g.V(v1Id).emit(has(T.label, "person")).repeat(out()).values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, Map<String, Long>> get_g_V_repeatXgroupCountXmX_byXnameX_outX_timesX2X_capXmX() {
+ return g.V().repeat(groupCount("m").by("name").out()).times(2).cap("m");
+ }
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/4c97e964/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/UnionTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/UnionTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/UnionTest.java
new file mode 100644
index 0000000..6c90288
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/UnionTest.java
@@ -0,0 +1,194 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step.branch;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.IgnoreEngine;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.UseEngine;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.*;
+import static org.junit.Assert.*;
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ */
+public abstract class UnionTest extends AbstractGremlinProcessTest {
+
+ public abstract Traversal<Vertex, String> get_g_V_unionXout__inX_name();
+
+ public abstract Traversal<Vertex, String> get_g_VX1X_unionXrepeatXoutX_timesX2X__outX_name(final Object v1Id);
+
+ public abstract Traversal<Vertex, String> get_g_V_chooseXlabel_is_person__unionX__out_lang__out_nameX__in_labelX();
+
+ public abstract Traversal<Vertex, Map<String, Long>> get_g_V_chooseXlabel_is_person__unionX__out_lang__out_nameX__in_labelX_groupCount();
+
+ public abstract Traversal<Vertex, Map<String, Long>> get_g_V_unionXrepeatXunionXoutXcreatedX__inXcreatedXX_timesX2X__repeatXunionXinXcreatedX__outXcreatedXX_timesX2XX_label_groupCount();
+
+ public abstract Traversal<Vertex, Number> get_g_VX1_2X_unionXoutE_count__inE_count__outE_weight_sumX(final Object v1Id, final Object v2Id);
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_unionXout__inX_name() {
+ final Traversal<Vertex, String> traversal = get_g_V_unionXout__inX_name();
+ printTraversalForm(traversal);
+ checkResults(new HashMap<String, Long>() {{
+ put("marko", 3l);
+ put("lop", 3l);
+ put("peter", 1l);
+ put("ripple", 1l);
+ put("josh", 3l);
+ put("vadas", 1l);
+ }}, traversal);
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_unionXrepeatXoutX_timesX2X__outX_name() {
+ final Traversal<Vertex, String> traversal = get_g_VX1X_unionXrepeatXoutX_timesX2X__outX_name(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ checkResults(new HashMap<String, Long>() {{
+ put("lop", 2l);
+ put("ripple", 1l);
+ put("josh", 1l);
+ put("vadas", 1l);
+ }}, traversal);
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_chooseXlabel_eq_person__unionX__out_lang__out_nameX__in_labelX() {
+ final Traversal<Vertex, String> traversal = get_g_V_chooseXlabel_is_person__unionX__out_lang__out_nameX__in_labelX();
+ printTraversalForm(traversal);
+ checkResults(new HashMap<String, Long>() {{
+ put("lop", 3l);
+ put("ripple", 1l);
+ put("java", 4l);
+ put("josh", 1l);
+ put("vadas", 1l);
+ put("person", 4l);
+ }}, traversal);
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_chooseXlabel_eq_person__unionX__out_lang__out_nameX__in_labelX_groupCount() {
+ final Traversal<Vertex, Map<String, Long>> traversal = get_g_V_chooseXlabel_is_person__unionX__out_lang__out_nameX__in_labelX_groupCount();
+ printTraversalForm(traversal);
+ final Map<String, Long> groupCount = traversal.next();
+ assertFalse(traversal.hasNext());
+ assertEquals(3l, groupCount.get("lop").longValue());
+ assertEquals(1l, groupCount.get("ripple").longValue());
+ assertEquals(4l, groupCount.get("java").longValue());
+ assertEquals(1l, groupCount.get("josh").longValue());
+ assertEquals(1l, groupCount.get("vadas").longValue());
+ assertEquals(4l, groupCount.get("person").longValue());
+ assertEquals(6, groupCount.size());
+
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_unionXrepeatXunionXoutXcreatedX__inXcreatedXX_timesX2X__repeatXunionXinXcreatedX__outXcreatedXX_timesX2XX_label_groupCount() {
+ final Traversal<Vertex, Map<String, Long>> traversal = get_g_V_unionXrepeatXunionXoutXcreatedX__inXcreatedXX_timesX2X__repeatXunionXinXcreatedX__outXcreatedXX_timesX2XX_label_groupCount();
+ printTraversalForm(traversal);
+ final Map<String, Long> groupCount = traversal.next();
+ assertFalse(traversal.hasNext());
+ assertEquals(12l, groupCount.get("software").longValue());
+ assertEquals(20l, groupCount.get("person").longValue());
+ assertEquals(2, groupCount.size());
+
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_VX1_2X_unionXoutE_count__inE_count__outE_weight_sumX() {
+ final Traversal<Vertex, Number> traversal = get_g_VX1_2X_unionXoutE_count__inE_count__outE_weight_sumX(convertToVertexId("marko"), convertToVertexId("vadas"));
+ printTraversalForm(traversal);
+ assertTrue(traversal.hasNext());
+ final Number startNumber = traversal.next();
+ assertTrue(traversal.hasNext());
+ if (startNumber.longValue() == 3l) {
+ assertEquals(0l, traversal.next().longValue());
+ assertEquals(1.9d, traversal.next().doubleValue(), 0.1d);
+ //
+ assertEquals(0l, traversal.next().longValue());
+ assertEquals(1l, traversal.next().longValue());
+ assertEquals(0.0d, traversal.next().doubleValue(), 0.1d);
+ } else {
+ assertEquals(1l, traversal.next().longValue());
+ assertEquals(0.0d, traversal.next().doubleValue(), 0.1d);
+ //
+ assertEquals(3l, traversal.next().longValue());
+ assertEquals(0l, traversal.next().longValue());
+ assertEquals(1.9d, traversal.next().doubleValue(), 0.1d);
+ }
+ assertFalse(traversal.hasNext());
+ }
+
+ @UseEngine(TraversalEngine.Type.STANDARD)
+ @UseEngine(TraversalEngine.Type.COMPUTER)
+ public static class Traversals extends UnionTest {
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_unionXout__inX_name() {
+ return g.V().union(out(), in()).values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_VX1X_unionXrepeatXoutX_timesX2X__outX_name(final Object v1Id) {
+ return g.V(v1Id).union(repeat(out()).times(2), out()).values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_chooseXlabel_is_person__unionX__out_lang__out_nameX__in_labelX() {
+ return g.V().choose(label().is("person"), union(out().values("lang"), out().values("name")), in().label());
+ }
+
+ @Override
+ public Traversal<Vertex, Map<String, Long>> get_g_V_chooseXlabel_is_person__unionX__out_lang__out_nameX__in_labelX_groupCount() {
+ return (Traversal) g.V().choose(label().is("person"), union(out().values("lang"), out().values("name")), in().label()).groupCount();
+ }
+
+ @Override
+ public Traversal<Vertex, Map<String, Long>> get_g_V_unionXrepeatXunionXoutXcreatedX__inXcreatedXX_timesX2X__repeatXunionXinXcreatedX__outXcreatedXX_timesX2XX_label_groupCount() {
+ return (Traversal) g.V().union(
+ repeat(union(
+ out("created"),
+ in("created"))).times(2),
+ repeat(union(
+ in("created"),
+ out("created"))).times(2)).label().groupCount();
+ }
+
+ @Override
+ public Traversal<Vertex, Number> get_g_VX1_2X_unionXoutE_count__inE_count__outE_weight_sumX(final Object v1Id, final Object v2Id) {
+ return g.V(v1Id, v2Id).union(outE().count(), inE().count(), (Traversal) outE().values("weight").sum());
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/4c97e964/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/AndTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/AndTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/AndTest.java
new file mode 100644
index 0000000..baf5e4f
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/AndTest.java
@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step.filter;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.traversal.T;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.UseEngine;
+import org.apache.tinkerpop.gremlin.structure.Compare;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.*;
+import static org.apache.tinkerpop.gremlin.structure.Compare.gt;
+import static org.apache.tinkerpop.gremlin.structure.Compare.gte;
+
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ */
+public abstract class AndTest extends AbstractGremlinProcessTest {
+
+ public abstract Traversal<Vertex, String> get_g_V_andXhasXage_gt_27X__outE_count_gt_2X_name();
+
+ public abstract Traversal<Vertex, String> get_g_V_andXoutE__hasXlabel_personX_and_hasXage_gte_32XX_name();
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_andXhasXage_gt_27X__outE_count_gt_2X_name() {
+ final Traversal<Vertex, String> traversal = get_g_V_andXhasXage_gt_27X__outE_count_gt_2X_name();
+ printTraversalForm(traversal);
+ checkResults(Arrays.asList("marko", "josh"), traversal);
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_andXout__hasXlabel_personX_and_hasXage_gte_32XX_name() {
+ final Traversal<Vertex, String> traversal = get_g_V_andXoutE__hasXlabel_personX_and_hasXage_gte_32XX_name();
+ printTraversalForm(traversal);
+ checkResults(Arrays.asList("josh", "peter"), traversal);
+ }
+
+
+ @UseEngine(TraversalEngine.Type.STANDARD)
+ @UseEngine(TraversalEngine.Type.COMPUTER)
+ public static class Traversals extends AndTest {
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_andXhasXage_gt_27X__outE_count_gt_2X_name() {
+ return g.V().and(has("age", gt, 27), outE().count().is(gte, 2l)).values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_andXoutE__hasXlabel_personX_and_hasXage_gte_32XX_name() {
+ return g.V().and(outE(), has(T.label, "person").and().has("age", Compare.gte, 32)).values("name");
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/4c97e964/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CoinTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CoinTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CoinTest.java
new file mode 100644
index 0000000..40a8eb2
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CoinTest.java
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step.filter;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.UseEngine;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.Test;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ */
+public abstract class CoinTest extends AbstractGremlinProcessTest {
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_coinX1X();
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_coinX0X();
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_coinX1X() {
+ final Traversal<Vertex, Vertex> traversal = get_g_V_coinX1X();
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ traversal.next();
+ }
+ assertEquals(6, counter);
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_coinX0X() {
+ final Traversal<Vertex, Vertex> traversal = get_g_V_coinX0X();
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ traversal.next();
+ }
+ assertEquals(0, counter);
+ assertFalse(traversal.hasNext());
+ }
+
+
+ @UseEngine(TraversalEngine.Type.STANDARD)
+ @UseEngine(TraversalEngine.Type.COMPUTER)
+ public static class Traversals extends CoinTest {
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_coinX1X() {
+ return g.V().coin(1.0d);
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_coinX0X() {
+ return g.V().coin(0.0d);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/4c97e964/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CyclicPathTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CyclicPathTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CyclicPathTest.java
new file mode 100644
index 0000000..6dce036
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CyclicPathTest.java
@@ -0,0 +1,86 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step.filter;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.UseEngine;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.Test;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ */
+public abstract class CyclicPathTest extends AbstractGremlinProcessTest {
+
+ public abstract Traversal<Vertex, Vertex> get_g_VX1X_outXcreatedX_inXcreatedX_cyclicPath(final Object v1);
+
+ public abstract Traversal<Vertex, Path> get_g_VX1X_outXcreatedX_inXcreatedX_cyclicPath_path(final Object v1);
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_outXcreatedX_inXcreatedX_cyclicPath() {
+ final Traversal<Vertex, Vertex> traversal = get_g_VX1X_outXcreatedX_inXcreatedX_cyclicPath(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ Vertex vertex = traversal.next();
+ assertEquals("marko", vertex.<String>value("name"));
+ }
+ assertEquals(1, counter);
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_outXcreatedX_inXcreatedX_cyclicPath_path() {
+ final Traversal<Vertex, Path> traversal = get_g_VX1X_outXcreatedX_inXcreatedX_cyclicPath_path(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ Path path = traversal.next();
+ assertFalse(path.isSimple());
+ }
+ assertEquals(1, counter);
+ assertFalse(traversal.hasNext());
+ }
+
+ @UseEngine(TraversalEngine.Type.STANDARD)
+ @UseEngine(TraversalEngine.Type.COMPUTER)
+ public static class Traversals extends CyclicPathTest {
+ @Override
+ public Traversal<Vertex, Vertex> get_g_VX1X_outXcreatedX_inXcreatedX_cyclicPath(final Object v1Id) {
+ return g.V(v1Id).out("created").in("created").cyclicPath();
+ }
+
+ @Override
+ public Traversal<Vertex, Path> get_g_VX1X_outXcreatedX_inXcreatedX_cyclicPath_path(final Object v1Id) {
+ return g.V(v1Id).out("created").in("created").cyclicPath().path();
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/4c97e964/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/DedupTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/DedupTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/DedupTest.java
new file mode 100644
index 0000000..fd199c5
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/DedupTest.java
@@ -0,0 +1,146 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step.filter;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.IgnoreEngine;
+import org.apache.tinkerpop.gremlin.process.traversal.Scope;
+import org.apache.tinkerpop.gremlin.process.traversal.T;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.UseEngine;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.util.StreamFactory;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.bothE;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.dedup;
+import static org.junit.Assert.*;
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ * @author Stephen Mallette (http://stephen.genoprime.com)
+ * @author Daniel Kuppitz (http://gremlin.guru)
+ */
+public abstract class DedupTest extends AbstractGremlinProcessTest {
+
+ public abstract Traversal<Vertex, String> get_g_V_both_dedup_name();
+
+ public abstract Traversal<Vertex, String> get_g_V_both_hasXlabel_softwareX_dedup_byXlangX_name();
+
+ public abstract Traversal<Vertex, String> get_g_V_both_name_orderXa_bX_dedup();
+
+ public abstract Traversal<Vertex, Map<String, Set<Double>>> get_g_V_group_byXlabelX_byXbothE_valuesXweightX_foldX_byXdedupXlocalXX();
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_V_both_dedup_name() {
+ final Traversal<Vertex, String> traversal = get_g_V_both_dedup_name();
+ printTraversalForm(traversal);
+ final List<String> names = StreamFactory.stream(traversal).collect(Collectors.toList());
+ assertEquals(6, names.size());
+ assertTrue(names.contains("marko"));
+ assertTrue(names.contains("vadas"));
+ assertTrue(names.contains("lop"));
+ assertTrue(names.contains("josh"));
+ assertTrue(names.contains("ripple"));
+ assertTrue(names.contains("peter"));
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_V_both_hasXlabel_softwareX_dedup_byXlangX_name() {
+ final Traversal<Vertex, String> traversal = get_g_V_both_hasXlabel_softwareX_dedup_byXlangX_name();
+ printTraversalForm(traversal);
+ final List<String> names = StreamFactory.stream(traversal).collect(Collectors.toList());
+ assertEquals(1, names.size());
+ assertTrue(names.contains("lop") || names.contains("ripple"));
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_V_both_name_orderXa_bX_dedup() {
+ final Traversal<Vertex, String> traversal = get_g_V_both_name_orderXa_bX_dedup();
+ printTraversalForm(traversal);
+ final List<String> names = StreamFactory.stream(traversal).collect(Collectors.toList());
+ assertEquals(6, names.size());
+ assertEquals("josh", names.get(0));
+ assertEquals("lop", names.get(1));
+ assertEquals("marko", names.get(2));
+ assertEquals("peter", names.get(3));
+ assertEquals("ripple", names.get(4));
+ assertEquals("vadas", names.get(5));
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_group_byXlabelX_byXbothE_valuesXweightX_foldX_byXdedupXlocalXX() {
+ final Traversal<Vertex, Map<String, Set<Double>>> traversal =
+ get_g_V_group_byXlabelX_byXbothE_valuesXweightX_foldX_byXdedupXlocalXX();
+ printTraversalForm(traversal);
+ assertTrue(traversal.hasNext());
+ final Map<String, Set<Double>> map = traversal.next();
+ assertFalse(traversal.hasNext());
+ assertEquals(2, map.size());
+ assertEquals(3, map.get("software").size());
+ assertEquals(4, map.get("person").size());
+ assertEquals(new HashSet<>(Arrays.asList(0.2, 0.4, 1.0)), map.get("software"));
+ assertEquals(new HashSet<>(Arrays.asList(0.2, 0.4, 0.5, 1.0)), map.get("person"));
+ }
+
+
+ @UseEngine(TraversalEngine.Type.STANDARD)
+ @UseEngine(TraversalEngine.Type.COMPUTER)
+ public static class Traversals extends DedupTest {
+ @Override
+ public Traversal<Vertex, String> get_g_V_both_dedup_name() {
+ return g.V().both().dedup().values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_both_hasXlabel_softwareX_dedup_byXlangX_name() {
+ return g.V().both().has(T.label, "software").dedup().by("lang").values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_both_name_orderXa_bX_dedup() {
+ return g.V().both().<String>properties("name").order().by((a, b) -> a.value().compareTo(b.value())).dedup().value();
+ }
+
+ @Override
+ public Traversal<Vertex, Map<String, Set<Double>>> get_g_V_group_byXlabelX_byXbothE_valuesXweightX_foldX_byXdedupXlocalXX() {
+ return g.V().<String, Set<Double>>group().by(T.label).by(bothE().values("weight").fold()).by(dedup(Scope.local));
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/4c97e964/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/ExceptTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/ExceptTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/ExceptTest.java
new file mode 100644
index 0000000..c7bce37
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/ExceptTest.java
@@ -0,0 +1,186 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step.filter;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.IgnoreEngine;
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.UseEngine;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.util.StreamFactory;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.bothE;
+import static org.junit.Assert.*;
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ * @author Stephen Mallette (http://stephen.genoprime.com)
+ * @author Daniel Kuppitz (http://gremlin.guru)
+ */
+public abstract class ExceptTest extends AbstractGremlinProcessTest {
+
+ public abstract Traversal<Vertex, Vertex> get_g_VX1X_out_exceptXg_v2X(final Object v1Id, final Object v2Id);
+
+ public abstract Traversal<Vertex, Vertex> get_g_VX1X_out_aggregateXxX_out_exceptXxX(final Object v1Id);
+
+ public abstract Traversal<Vertex, String> get_g_VX1X_outXcreatedX_inXcreatedX_exceptXg_v1X_name(final Object v1Id);
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_exceptXg_V_toListX();
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_exceptXX();
+
+ public abstract Traversal<Vertex, Path> get_g_VX1X_repeatXbothEXcreatedX_exceptXeX_aggregateXeX_otherVX_emit_path(final Object v1Id);
+
+ public abstract Traversal<Vertex, String> get_g_VX1X_asXaX_outXcreatedX_inXcreatedX_exceptXaX_name(final Object v1Id);
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_VX1X_out_exceptXg_v2X() {
+ final Traversal<Vertex, Vertex> traversal = get_g_VX1X_out_exceptXg_v2X(convertToVertexId("marko"), convertToVertexId("vadas"));
+ printTraversalForm(traversal);
+ int counter = 0;
+ Set<Vertex> vertices = new HashSet<>();
+ while (traversal.hasNext()) {
+ counter++;
+ Vertex vertex = traversal.next();
+ vertices.add(vertex);
+ assertTrue(vertex.value("name").equals("josh") || vertex.value("name").equals("lop"));
+ }
+ assertEquals(2, counter);
+ assertEquals(2, vertices.size());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_out_aggregateXxX_out_exceptXxX() {
+ Traversal<Vertex, Vertex> traversal = get_g_VX1X_out_aggregateXxX_out_exceptXxX(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ assertEquals("ripple", traversal.next().<String>value("name"));
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_VX1X_outXcreatedX_inXcreatedX_exceptXg_v1X_name() {
+ Traversal<Vertex, String> traversal = get_g_VX1X_outXcreatedX_inXcreatedX_exceptXg_v1X_name(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ List<String> names = Arrays.asList(traversal.next(), traversal.next());
+ assertFalse(traversal.hasNext());
+ assertEquals(2, names.size());
+ assertTrue(names.contains("peter"));
+ assertTrue(names.contains("josh"));
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_V_exceptXg_V_toListX() {
+ Traversal<Vertex, Vertex> traversal = get_g_V_exceptXg_V_toListX();
+ printTraversalForm(traversal);
+ final List<Vertex> vertices = StreamFactory.stream(traversal).collect(Collectors.toList());
+ assertEquals(0, vertices.size());
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_V_exceptXX() {
+ Traversal<Vertex, Vertex> traversal = get_g_V_exceptXX();
+ printTraversalForm(traversal);
+ final List<Vertex> vertices = StreamFactory.stream(traversal).collect(Collectors.toList());
+ assertEquals(6, vertices.size());
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_repeatXbothEXcreatedX_exceptXeX_aggregateXeX_otherVX_emit_path() {
+ Traversal<Vertex, Path> traversal = get_g_VX1X_repeatXbothEXcreatedX_exceptXeX_aggregateXeX_otherVX_emit_path(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ final List<Path> paths = StreamFactory.stream(traversal).collect(Collectors.toList());
+ assertEquals(4, paths.size());
+ assertEquals(1, paths.stream().filter(path -> path.size() == 3).count());
+ assertEquals(2, paths.stream().filter(path -> path.size() == 5).count());
+ assertEquals(1, paths.stream().filter(path -> path.size() == 7).count());
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_asXaX_outXcreatedX_inXcreatedX_exceptXaX_name() {
+ final Traversal<Vertex, String> traversal = get_g_VX1X_asXaX_outXcreatedX_inXcreatedX_exceptXaX_name(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ checkResults(Arrays.asList("peter", "josh"), traversal);
+ }
+
+ @UseEngine(TraversalEngine.Type.STANDARD)
+ @UseEngine(TraversalEngine.Type.COMPUTER)
+ public static class StandardTest extends ExceptTest {
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_VX1X_out_exceptXg_v2X(final Object v1Id, final Object v2Id) {
+ return g.V(v1Id).out().except(g.V(v2Id).next());
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_VX1X_out_aggregateXxX_out_exceptXxX(final Object v1Id) {
+ return g.V(v1Id).out().aggregate("x").out().except("x");
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_VX1X_outXcreatedX_inXcreatedX_exceptXg_v1X_name(final Object v1Id) {
+ return g.V(v1Id).out("created").in("created").except(g.V(v1Id).next()).values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_exceptXg_V_toListX() {
+ return g.V().except(g.V().toList());
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_exceptXX() {
+ return g.V().except(Collections.emptyList());
+ }
+
+ @Override
+ public Traversal<Vertex, Path> get_g_VX1X_repeatXbothEXcreatedX_exceptXeX_aggregateXeX_otherVX_emit_path(final Object v1Id) {
+ return g.V(v1Id).repeat(bothE("created").except("e").aggregate("e").otherV()).emit().path();
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_VX1X_asXaX_outXcreatedX_inXcreatedX_exceptXaX_name(final Object v1Id) {
+ return g.V(v1Id).as("a").out("created").in("created").except("a").values("name");
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/4c97e964/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/FilterTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/FilterTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/FilterTest.java
new file mode 100644
index 0000000..eff88b8
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/FilterTest.java
@@ -0,0 +1,221 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step.filter;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.IgnoreEngine;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.UseEngine;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.Test;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.junit.Assert.*;
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ * @author Stephen Mallette (http://stephen.genoprime.com)
+ */
+public abstract class FilterTest extends AbstractGremlinProcessTest {
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_filterXfalseX();
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_filterXtrueX();
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_filterXlang_eq_javaX();
+
+ public abstract Traversal<Vertex, Vertex> get_g_VX1X_filterXage_gt_30X(final Object v1Id);
+
+ public abstract Traversal<Vertex, Vertex> get_g_VX1X_out_filterXage_gt_30X(final Object v1Id);
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_filterXname_startsWith_m_OR_name_startsWith_pX();
+
+ public abstract Traversal<Edge, Edge> get_g_E_filterXfalseX();
+
+ public abstract Traversal<Edge, Edge> get_g_E_filterXtrueX();
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_V_filterXfalseX() {
+ final Traversal<Vertex, Vertex> traversal = get_g_V_filterXfalseX();
+ printTraversalForm(traversal);
+ assertFalse(traversal.hasNext());
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_V_filterXtrueX() {
+ final Traversal<Vertex, Vertex> traversal = get_g_V_filterXtrueX();
+ printTraversalForm(traversal);
+ int counter = 0;
+ final Set<Vertex> vertices = new HashSet<>();
+ while (traversal.hasNext()) {
+ counter++;
+ vertices.add(traversal.next());
+ }
+ assertEquals(6, counter);
+ assertEquals(6, vertices.size());
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_V_filterXlang_eq_javaX() {
+ final Traversal<Vertex, Vertex> traversal = get_g_V_filterXlang_eq_javaX();
+ printTraversalForm(traversal);
+ int counter = 0;
+ Set<Vertex> vertices = new HashSet<>();
+ while (traversal.hasNext()) {
+ counter++;
+ Vertex vertex = traversal.next();
+ vertices.add(vertex);
+ assertTrue(vertex.value("name").equals("ripple") ||
+ vertex.value("name").equals("lop"));
+ }
+ assertEquals(2, counter);
+ assertEquals(2, vertices.size());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_VX1X_filterXage_gt_30X() {
+ Traversal<Vertex, Vertex> traversal = get_g_VX1X_filterXage_gt_30X(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ assertFalse(traversal.hasNext());
+ traversal = get_g_VX1X_filterXage_gt_30X(convertToVertexId("josh"));
+ printTraversalForm(traversal);
+ assertTrue(traversal.hasNext());
+ assertEquals(Integer.valueOf(32), traversal.next().<Integer>value("age"));
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_VX1X_out_filterXage_gt_30X() {
+ final Traversal<Vertex, Vertex> traversal = get_g_VX1X_out_filterXage_gt_30X(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ assertEquals(Integer.valueOf(32), traversal.next().<Integer>value("age"));
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_V_filterXname_startsWith_m_OR_name_startsWith_pX() {
+ final Traversal<Vertex, Vertex> traversal = get_g_V_filterXname_startsWith_m_OR_name_startsWith_pX();
+ printTraversalForm(traversal);
+ int counter = 0;
+ Set<Vertex> vertices = new HashSet<>();
+ while (traversal.hasNext()) {
+ counter++;
+ Vertex vertex = traversal.next();
+ vertices.add(vertex);
+ assertTrue(vertex.value("name").equals("marko") ||
+ vertex.value("name").equals("peter"));
+ }
+ assertEquals(counter, 2);
+ assertEquals(vertices.size(), 2);
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_E_filterXfalseX() {
+ final Traversal<Edge, Edge> traversal = get_g_E_filterXfalseX();
+ printTraversalForm(traversal);
+ assertFalse(traversal.hasNext());
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+ public void g_E_filterXtrueX() {
+ final Traversal<Edge, Edge> traversal = get_g_E_filterXtrueX();
+ printTraversalForm(traversal);
+ int counter = 0;
+ final Set<Edge> edges = new HashSet<>();
+ while (traversal.hasNext()) {
+ counter++;
+ edges.add(traversal.next());
+ }
+ assertEquals(6, counter);
+ assertEquals(6, edges.size());
+ assertFalse(traversal.hasNext());
+ }
+
+ @UseEngine(TraversalEngine.Type.STANDARD)
+ @UseEngine(TraversalEngine.Type.COMPUTER)
+ public static class Traversals extends FilterTest {
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_filterXfalseX() {
+ return g.V().filter(v -> false);
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_filterXtrueX() {
+ return g.V().filter(v -> true);
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_filterXlang_eq_javaX() {
+ return g.V().filter(v -> v.get().<String>property("lang").orElse("none").equals("java"));
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_VX1X_filterXage_gt_30X(final Object v1Id) {
+ return g.V(v1Id).filter(v -> v.get().<Integer>property("age").orElse(0) > 30);
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_VX1X_out_filterXage_gt_30X(final Object v1Id) {
+ return g.V(v1Id).out().filter(v -> v.get().<Integer>property("age").orElse(0) > 30);
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_filterXname_startsWith_m_OR_name_startsWith_pX() {
+ return g.V().filter(v -> {
+ final String name = v.get().value("name");
+ return name.startsWith("m") || name.startsWith("p");
+ });
+ }
+
+ @Override
+ public Traversal<Edge, Edge> get_g_E_filterXfalseX() {
+ return g.E().filter(e -> false);
+ }
+
+ @Override
+ public Traversal<Edge, Edge> get_g_E_filterXtrueX() {
+ return g.E().filter(e -> true);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/4c97e964/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasNotTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasNotTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasNotTest.java
new file mode 100644
index 0000000..e7b5b8b
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasNotTest.java
@@ -0,0 +1,98 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step.filter;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.UseEngine;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.structure.Element;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.util.StreamFactory;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+/**
+ * @author Joshua Shinavier (http://fortytwo.net)
+ */
+public abstract class HasNotTest extends AbstractGremlinProcessTest {
+
+ public abstract Traversal<Vertex, Vertex> get_g_VX1X_hasNotXprop(final Object v1Id, final String propertyKey);
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_hasNotXprop(final String propertyKey);
+
+ public abstract Traversal<Vertex, String> get_g_V_hasNotXoutXcreatedXX();
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_hasNotXprop() {
+ Traversal<Vertex, Vertex> traversal = get_g_VX1X_hasNotXprop(convertToVertexId("marko"), "circumference");
+ printTraversalForm(traversal);
+ assertEquals("marko", traversal.next().<String>value("name"));
+ assertFalse(traversal.hasNext());
+ traversal = get_g_VX1X_hasNotXprop(convertToVertexId("marko"), "name");
+ printTraversalForm(traversal);
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_hasNotXprop() {
+ Traversal<Vertex, Vertex> traversal = get_g_V_hasNotXprop("circumference");
+ printTraversalForm(traversal);
+ final List<Element> list = StreamFactory.stream(traversal).collect(Collectors.toList());
+ assertEquals(6, list.size());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_hasNotXoutXcreatedXX() {
+ Traversal<Vertex, String> traversal = get_g_V_hasNotXoutXcreatedXX();
+ checkResults(Arrays.asList("vadas", "lop", "ripple"), traversal);
+ }
+
+ @UseEngine(TraversalEngine.Type.STANDARD)
+ @UseEngine(TraversalEngine.Type.COMPUTER)
+ public static class Traversals extends HasNotTest {
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_VX1X_hasNotXprop(final Object v1Id, final String propertyKey) {
+ return g.V(v1Id).hasNot(propertyKey);
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_hasNotXprop(final String propertyKey) {
+ return g.V().hasNot(propertyKey);
+ }
+
+ @Override
+ public Traversal<Vertex, String> get_g_V_hasNotXoutXcreatedXX() {
+ return g.V().hasNot(__.out("created")).values("name");
+ }
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/4c97e964/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasTest.java
new file mode 100644
index 0000000..ad5db85
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasTest.java
@@ -0,0 +1,325 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step.filter;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.UseEngine;
+import org.apache.tinkerpop.gremlin.structure.Compare;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Element;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.util.StreamFactory;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.CREW;
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.*;
+import static org.junit.Assert.*;
+import static org.junit.Assume.assumeTrue;
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ * @author Stephen Mallette (http://stephen.genoprime.com)
+ */
+public abstract class HasTest extends AbstractGremlinProcessTest {
+
+ public abstract Traversal<Vertex, String> get_g_V_outXknowsX_hasXoutXcreatedXX_name();
+
+ public abstract Traversal<Vertex, Vertex> get_g_VX1X_hasXkeyX(final Object v1Id, final String key);
+
+ public abstract Traversal<Vertex, Vertex> get_g_VX1X_hasXname_markoX(final Object v1Id);
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_hasXname_markoX();
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_hasXname_blahX();
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_hasXblahX();
+
+ public abstract Traversal<Vertex, Vertex> get_g_VX1X_hasXage_gt_30X(final Object v1Id);
+
+ public abstract Traversal<Vertex, Vertex> get_g_VX1X_out_hasIdX2X(final Object v1Id, final Object v2Id);
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_hasXage_gt_30X();
+
+ public abstract Traversal<Edge, Edge> get_g_EX7X_hasLabelXknowsX(final Object e7Id);
+
+ public abstract Traversal<Edge, Edge> get_g_E_hasLabelXknowsX();
+
+ public abstract Traversal<Edge, Edge> get_g_E_hasLabelXuses_traversesX();
+
+ public abstract Traversal<Vertex, Vertex> get_g_V_hasLabelXperson_software_blahX();
+
+ public abstract Traversal<Vertex, Integer> get_g_V_hasXperson_name_markoX_age();
+
+ public abstract Traversal<Vertex, Vertex> get_g_VX1X_outE_hasXweight_inside_0_06X_inV(final Object v1Id);
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_outXknowsX_hasXoutXcreatedXX_valuesXnameX() {
+ Traversal<Vertex, String> traversal = get_g_V_outXknowsX_hasXoutXcreatedXX_name();
+ printTraversalForm(traversal);
+ checkResults(Arrays.asList("josh"), traversal);
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_hasXkeyX() {
+ Traversal<Vertex, Vertex> traversal = get_g_VX1X_hasXkeyX(convertToVertexId("marko"), "name");
+ printTraversalForm(traversal);
+ assertEquals("marko", traversal.next().<String>value("name"));
+ assertFalse(traversal.hasNext());
+ //
+ traversal = get_g_VX1X_hasXkeyX(convertToVertexId("marko"), "circumference");
+ printTraversalForm(traversal);
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_hasXname_markoX() {
+ Traversal<Vertex, Vertex> traversal = get_g_VX1X_hasXname_markoX(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ assertEquals("marko", traversal.next().<String>value("name"));
+ assertFalse(traversal.hasNext());
+ traversal = get_g_VX1X_hasXname_markoX(convertToVertexId("vadas"));
+ printTraversalForm(traversal);
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_hasXname_markoX() {
+ final Traversal<Vertex, Vertex> traversal = get_g_V_hasXname_markoX();
+ printTraversalForm(traversal);
+ assertEquals("marko", traversal.next().<String>value("name"));
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_hasXname_blahX() {
+ final Traversal<Vertex, Vertex> traversal = get_g_V_hasXname_blahX();
+ printTraversalForm(traversal);
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_hasXage_gt_30X() {
+ final Traversal<Vertex, Vertex> traversal = get_g_V_hasXage_gt_30X();
+ printTraversalForm(traversal);
+ final List<Element> list = StreamFactory.stream(traversal).collect(Collectors.toList());
+ assertEquals(2, list.size());
+ for (final Element v : list) {
+ assertTrue(v.<Integer>value("age") > 30);
+ }
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_hasXage_gt_30X() {
+ Traversal<Vertex, Vertex> traversal = get_g_VX1X_hasXage_gt_30X(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ assertFalse(traversal.hasNext());
+ traversal = get_g_VX1X_hasXage_gt_30X(convertToVertexId("josh"));
+ printTraversalForm(traversal);
+ assertTrue(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_out_hasXid_2X() {
+ final Traversal<Vertex, Vertex> traversal = get_g_VX1X_out_hasIdX2X(convertToVertexId("marko"), convertToVertexId("vadas"));
+ printTraversalForm(traversal);
+ assertTrue(traversal.hasNext());
+ assertEquals(convertToVertexId("vadas"), traversal.next().id());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_hasXblahX() {
+ assumeTrue(graphMeetsTestRequirements());
+ final Traversal<Vertex, Vertex> traversal = get_g_V_hasXblahX();
+ printTraversalForm(traversal);
+ assertFalse(traversal.hasNext());
+ }
+
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_EX7X_hasXlabelXknowsX() {
+ //System.out.println(convertToEdgeId("marko", "knows", "vadas"));
+ Traversal<Edge, Edge> traversal = get_g_EX7X_hasLabelXknowsX(convertToEdgeId("marko", "knows", "vadas"));
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ assertEquals("knows", traversal.next().label());
+ }
+ assertEquals(1, counter);
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_E_hasXlabelXknowsX() {
+ final Traversal<Edge, Edge> traversal = get_g_E_hasLabelXknowsX();
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ assertEquals("knows", traversal.next().label());
+ }
+ assertEquals(2, counter);
+ }
+
+ @Test
+ @LoadGraphWith(CREW)
+ public void g_E_hasXlabelXuses_traversesX() {
+ final Traversal<Edge, Edge> traversal = get_g_E_hasLabelXuses_traversesX();
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ final String label = traversal.next().label();
+ assertTrue(label.equals("uses") || label.equals("traverses"));
+ }
+ assertEquals(9, counter);
+ }
+
+ @Test
+ @LoadGraphWith(CREW)
+ public void g_V_hasXlabelXperson_software_blahX() {
+ final Traversal<Vertex, Vertex> traversal = get_g_V_hasLabelXperson_software_blahX();
+ printTraversalForm(traversal);
+ int counter = 0;
+ while (traversal.hasNext()) {
+ counter++;
+ final String label = traversal.next().label();
+ assertTrue(label.equals("software") || label.equals("person"));
+ }
+ assertEquals(6, counter);
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_V_hasXperson_name_markoX_age() {
+ final Traversal<Vertex, Integer> traversal = get_g_V_hasXperson_name_markoX_age();
+ printTraversalForm(traversal);
+ assertEquals(29, traversal.next().intValue());
+ assertFalse(traversal.hasNext());
+ }
+
+ @Test
+ @LoadGraphWith(MODERN)
+ public void g_VX1X_outE_hasXweight_inside_0_06X_inV() {
+ final Traversal<Vertex, Vertex> traversal = get_g_VX1X_outE_hasXweight_inside_0_06X_inV(convertToVertexId("marko"));
+ printTraversalForm(traversal);
+ while (traversal.hasNext()) {
+ Vertex vertex = traversal.next();
+ assertTrue(vertex.value("name").equals("vadas") || vertex.value("name").equals("lop"));
+ }
+ assertFalse(traversal.hasNext());
+ }
+
+ @UseEngine(TraversalEngine.Type.STANDARD)
+ @UseEngine(TraversalEngine.Type.COMPUTER)
+ public static class Traversals extends HasTest {
+ @Override
+ public Traversal<Vertex, String> get_g_V_outXknowsX_hasXoutXcreatedXX_name() {
+ return g.V().out("knows").has(out("created")).values("name");
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_VX1X_hasXkeyX(final Object v1Id, final String key) {
+ return g.V(v1Id).has(key);
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_VX1X_hasXname_markoX(final Object v1Id) {
+ return g.V(v1Id).has("name", "marko");
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_hasXname_markoX() {
+ return g.V().has("name", "marko");
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_hasXname_blahX() {
+ return g.V().has("name", "blah");
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_hasXblahX() {
+ return g.V().has("blah");
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_VX1X_hasXage_gt_30X(final Object v1Id) {
+ return g.V(v1Id).has("age", Compare.gt, 30);
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_VX1X_out_hasIdX2X(final Object v1Id, final Object v2Id) {
+ return g.V(v1Id).out().hasId(v2Id);
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_hasXage_gt_30X() {
+ return g.V().has("age", Compare.gt, 30);
+ }
+
+ @Override
+ public Traversal<Edge, Edge> get_g_EX7X_hasLabelXknowsX(final Object e7Id) {
+ return g.E(e7Id).hasLabel("knows");
+ }
+
+ @Override
+ public Traversal<Edge, Edge> get_g_E_hasLabelXknowsX() {
+ return g.E().hasLabel("knows");
+ }
+
+ @Override
+ public Traversal<Edge, Edge> get_g_E_hasLabelXuses_traversesX() {
+ return g.E().hasLabel("uses", "traverses");
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_V_hasLabelXperson_software_blahX() {
+ return g.V().hasLabel("person", "software", "blah");
+ }
+
+ @Override
+ public Traversal<Vertex, Integer> get_g_V_hasXperson_name_markoX_age() {
+ return g.V().has("person", "name", "marko").values("age");
+ }
+
+ @Override
+ public Traversal<Vertex, Vertex> get_g_VX1X_outE_hasXweight_inside_0_06X_inV(final Object v1Id) {
+ return g.V(v1Id).outE().has("weight", Compare.inside, Arrays.asList(0.0d, 0.6d)).inV();
+ }
+ }
+}
\ No newline at end of file