You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by sp...@apache.org on 2021/03/04 23:31:14 UTC
[tinkerpop] branch TINKERPOP-1994 updated (2b76b1b -> ecd225d)
This is an automated email from the ASF dual-hosted git repository.
spmallette pushed a change to branch TINKERPOP-1994
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git.
discard 2b76b1b TINKERPOP-1994 Refactored tests to use Translator
discard 8cc36b8 TINKERPOP-1994 Moved barrier() addition from PathRetractionStrategy to LazyBarrierStrategy
new e3965c2 TINKERPOP-1994 Refactored tests to use Translator
new ecd225d TINKERPOP-1994 Used LazyBarrierStrategy to control barrier() insertion in other strategies.
This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version. This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:
* -- * -- B -- O -- O -- O (2b76b1b)
\
N -- N -- N refs/heads/TINKERPOP-1994 (ecd225d)
You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.
Any revisions marked "omit" are not gone; other references still
refer to them. Any revisions marked "discard" are gone forever.
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
CHANGELOG.asciidoc | 2 +-
docs/src/upgrade/release-3.4.x.asciidoc | 73 ++++++++++++++++++++++
.../process/traversal/step/map/MatchStep.java | 4 +-
.../strategy/optimization/LazyBarrierStrategy.java | 33 +++++-----
.../optimization/PathRetractionStrategy.java | 30 +++++++--
.../optimization/RepeatUnrollStrategy.java | 21 +++++--
.../strategy/decoration/SubgraphStrategyTest.java | 3 +-
.../optimization/LazyBarrierStrategyTest.java | 24 +++----
.../optimization/PathRetractionStrategyTest.java | 19 +++---
.../optimization/RepeatUnrollStrategyTest.java | 45 +++++++------
10 files changed, 180 insertions(+), 74 deletions(-)
[tinkerpop] 01/02: TINKERPOP-1994 Refactored tests to use Translator
Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
spmallette pushed a commit to branch TINKERPOP-1994
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit e3965c2570a18d09542b781ef592373ff5f07518
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Thu Mar 4 12:01:51 2021 -0500
TINKERPOP-1994 Refactored tests to use Translator
The Translator lets us get better output on errors and allows us to avoid having to manually name tests. Merged some tests using the Enclosed runner to match how other tests of this type were organized.
---
.../traversal/step/filter/TraversalFilterStep.java | 4 +
.../decoration/ConnectiveStrategyTest.java | 11 +-
.../decoration/ElementIdStrategyTraverseTest.java | 45 ++---
.../strategy/decoration/EventStrategyTest.java | 40 ++---
.../strategy/decoration/OptionsStrategyTest.java | 2 +-
.../strategy/decoration/PartitionStrategyTest.java | 185 ++++++++++++++++++---
.../decoration/PartitionStrategyTraverseTest.java | 155 -----------------
.../strategy/decoration/SackStrategyTest.java | 2 +-
.../strategy/decoration/SubgraphStrategyTest.java | 62 ++++++-
.../decoration/SubgraphStrategyTraverseTest.java | 100 -----------
.../decoration/VertexProgramStrategyTest.java | 8 +-
.../AdjacentToIncidentStrategyTest.java | 8 +-
.../strategy/optimization/CountStrategyTest.java | 8 +-
.../optimization/EarlyLimitStrategyTest.java | 8 +-
.../optimization/FilterRankingStrategyTest.java | 8 +-
.../optimization/IdentityRemovalStrategyTest.java | 9 +-
.../IncidentToAdjacentStrategyTest.java | 8 +-
.../optimization/InlineFilterStrategyTest.java | 8 +-
.../optimization/LazyBarrierStrategyTest.java | 4 +-
.../optimization/MatchPredicateStrategyTest.java | 9 +-
.../optimization/OrderLimitStrategyTest.java | 8 +-
.../optimization/PathProcessorStrategyTest.java | 8 +-
.../optimization/PathRetractionStrategyTest.java | 11 +-
.../optimization/RepeatUnrollStrategyTest.java | 8 +-
.../ComputerVerificationStrategyTest.java | 27 ++-
.../EdgeLabelVerificationStrategyTest.java | 52 +++---
.../LambdaRestrictionStrategyTest.java | 54 +++---
.../verification/ReadOnlyStrategyTest.java | 37 +++--
.../ReservedKeysVerificationStrategyTest.java | 56 ++++---
.../StandardVerificationStrategyTest.java | 30 ++--
30 files changed, 490 insertions(+), 485 deletions(-)
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/TraversalFilterStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/TraversalFilterStep.java
index ec37a3f..773e389 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/TraversalFilterStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/TraversalFilterStep.java
@@ -44,6 +44,10 @@ public final class TraversalFilterStep<S> extends FilterStep<S> implements Trave
this.filterTraversal = this.integrateChild(filterTraversal.asAdmin());
}
+ public Traversal.Admin<S, ?> getFilterTraversal() {
+ return filterTraversal;
+ }
+
@Override
public Parameters getParameters() {
return this.parameters;
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/ConnectiveStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/ConnectiveStrategyTest.java
index 13ccd80..a8211e0 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/ConnectiveStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/ConnectiveStrategyTest.java
@@ -18,9 +18,11 @@
*/
package org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -28,8 +30,6 @@ import org.junit.runners.Parameterized;
import java.util.Arrays;
-import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.V;
-import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.filter;
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has;
import static org.junit.Assert.assertEquals;
@@ -39,8 +39,10 @@ import static org.junit.Assert.assertEquals;
@RunWith(Parameterized.class)
public class ConnectiveStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
+
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@@ -54,8 +56,9 @@ public class ConnectiveStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
applyConnectiveStrategy(original);
- assertEquals(optimized, original);
+ assertEquals(repr, optimized, original);
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/ElementIdStrategyTraverseTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/ElementIdStrategyTraverseTest.java
index d782d4b..b4b20c8 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/ElementIdStrategyTraverseTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/ElementIdStrategyTraverseTest.java
@@ -19,6 +19,7 @@
package org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration;
import org.apache.tinkerpop.gremlin.process.traversal.Step;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
@@ -27,6 +28,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexStartSte
import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertiesStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.junit.Test;
@@ -36,9 +38,9 @@ import org.junit.runners.Parameterized;
import java.util.Arrays;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
+import static org.hamcrest.MatcherAssert.assertThat;
/**
* @author Stephen Mallette (http://stephen.genoprime.com)
@@ -47,6 +49,7 @@ import static org.mockito.Mockito.mock;
@RunWith(Parameterized.class)
public class ElementIdStrategyTraverseTest {
private static Traversal traversalWithAddV;
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
static {
final Graph mockedGraph = mock(Graph.class);
@@ -58,45 +61,43 @@ public class ElementIdStrategyTraverseTest {
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> data() {
return Arrays.asList(new Object[][]{
- {"addV()", traversalWithAddV, 1},
- {"addE(test).from(x)", __.addE("test").from("x"), 0},
- {"addE(test).to(x)", __.addE("test").to("x"), 0},
- {"addE(test).from(x).property(key,value)", __.addE("test").from("x").property("key", "value"), 0},
- {"addE(test).to(x).property(key,value)", __.addE("test").to("x").property("key", "value"), 0},
- {"out().id()", __.out().id(), 1},
- {"in().id()", __.in().id(), 1},
- {"outE().id()", __.outE().id(), 1},
- {"inE().id()", __.inE().id(), 1},
- {"bothE().id()", __.bothE().id(), 1},
- {"bothE().otherV().id()", __.bothE().otherV().id(), 2},
- {"in().out().addE(test).from(x)", __.in().out().addE("test").from("x"), 2},
- {"in().out().addE(test).to(x)", __.in().out().addE("test").to("x"), 2},
+ {traversalWithAddV, 1},
+ {__.addE("test").from("x"), 0},
+ {__.addE("test").to("x"), 0},
+ {__.addE("test").from("x").property("key", "value"), 0},
+ {__.addE("test").to("x").property("key", "value"), 0},
+ {__.out().id(), 1},
+ {__.in().id(), 1},
+ {__.outE().id(), 1},
+ {__.inE().id(), 1},
+ {__.bothE().id(), 1},
+ {__.bothE().otherV().id(), 2},
+ {__.in().out().addE("test").from("x"), 2},
+ {__.in().out().addE("test").to("x"), 2},
});
}
@Parameterized.Parameter(value = 0)
- public String name;
+ public Traversal.Admin traversal;
@Parameterized.Parameter(value = 1)
- public Traversal traversal;
-
- @Parameterized.Parameter(value = 2)
public int expectedInsertedSteps;
@Test
public void shouldAlterTraversalToIncludeIdWhereNecessary() {
+ final String repr = translator.translate(traversal.getBytecode());
final ElementIdStrategy strategy = ElementIdStrategy.build().create();
strategy.apply(traversal.asAdmin());
final Step step = (Step) traversal.asAdmin().getSteps().get(expectedInsertedSteps);
if (step instanceof AddVertexStep)
- assertTrue(((AddVertexStep) step).getParameters().contains(strategy.getIdPropertyKey()));
+ assertThat(repr, ((AddVertexStep) step).getParameters().contains(strategy.getIdPropertyKey()));
else if (step instanceof AddVertexStartStep)
- assertTrue(((AddVertexStartStep) step).getParameters().contains(strategy.getIdPropertyKey()));
+ assertThat(repr, ((AddVertexStartStep) step).getParameters().contains(strategy.getIdPropertyKey()));
else if (step instanceof AddEdgeStep)
- assertTrue(((AddEdgeStep) step).getParameters().contains(strategy.getIdPropertyKey()));
+ assertThat(repr, ((AddEdgeStep) step).getParameters().contains(strategy.getIdPropertyKey()));
else if (step instanceof PropertiesStep)
- assertEquals(strategy.getIdPropertyKey(), ((PropertiesStep) step).getPropertyKeys()[0]);
+ assertEquals(repr, strategy.getIdPropertyKey(), ((PropertiesStep) step).getPropertyKeys()[0]);
else
fail("Check test definition - the expectedInsertedSteps should be the index of the step to trigger the ID substitution");
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/EventStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/EventStrategyTest.java
index 911ef41..f06b1a8 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/EventStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/EventStrategyTest.java
@@ -18,11 +18,13 @@
*/
package org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.step.Mutating;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.ConsoleMutationListener;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.MutationListener;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -39,35 +41,35 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class EventStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
+
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> data() {
return Arrays.asList(new Object[][]{
- {"addE(test).from(x)", new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").from("x"), 1},
- {"addE(test).from(x).property(this,that)", new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").from("x").property("this", "that"), 1},
- {"addE(test).to(x)", new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").to("x"), 1},
- {"addE(test).to(x).property(this,that)", new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").to("x").property("this", "that"), 1},
- {"addV()", new DefaultGraphTraversal<>(EmptyGraph.instance()).addV(), 1},
- {"addV().property(k,v)", new DefaultGraphTraversal<>(EmptyGraph.instance()).addV().property("test", "that"), 1},
- {"properties().drop()", new DefaultGraphTraversal<>(EmptyGraph.instance()).properties().drop(), 1},
- {"properties(k).drop()", new DefaultGraphTraversal<>(EmptyGraph.instance()).properties("test").drop(), 1},
- {"out().drop()", new DefaultGraphTraversal<>(EmptyGraph.instance()).out().drop(), 1},
- {"out(args).drop()", new DefaultGraphTraversal<>(EmptyGraph.instance()).out("test").drop(), 1},
- {"outE().drop()", new DefaultGraphTraversal<>(EmptyGraph.instance()).outE().drop(), 1},
- {"outE().properties().drop()", new DefaultGraphTraversal<>(EmptyGraph.instance()).outE().properties().drop(), 1},
- {"outE(args).drop()", new DefaultGraphTraversal<>(EmptyGraph.instance()).outE("test").drop(), 1}});
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").from("x"), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").from("x").property("this", "that"), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").to("x"), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").to("x").property("this", "that"), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addV(), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addV().property("test", "that"), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).properties().drop(), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).properties("test").drop(), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).out().drop(), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).out("test").drop(), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).outE().drop(), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).outE().properties().drop(), 1},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).outE("test").drop(), 1}});
}
@Parameterized.Parameter(value = 0)
- public String name;
+ public Traversal.Admin traversal;
@Parameterized.Parameter(value = 1)
- public Traversal traversal;
-
- @Parameterized.Parameter(value = 2)
public int expectedMutatingStepsFound;
@Test
public void shouldEventOnMutatingSteps() {
+ final String repr = translator.translate(traversal.getBytecode());
final MutationListener listener1 = new ConsoleMutationListener(EmptyGraph.instance());
final EventStrategy eventStrategy = EventStrategy.build()
.addListener(listener1).create();
@@ -79,10 +81,10 @@ public class EventStrategyTest {
.filter(s -> s instanceof Mutating)
.forEach(s -> {
final Mutating mutating = (Mutating) s;
- assertEquals(1, mutating.getMutatingCallbackRegistry().getCallbacks().size());
+ assertEquals(repr, 1, mutating.getMutatingCallbackRegistry().getCallbacks().size());
mutatingStepsFound.incrementAndGet();
});
- assertEquals(expectedMutatingStepsFound, mutatingStepsFound.get());
+ assertEquals(repr, expectedMutatingStepsFound, mutatingStepsFound.get());
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/OptionsStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/OptionsStrategyTest.java
index c25c39f..c653f21 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/OptionsStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/OptionsStrategyTest.java
@@ -22,7 +22,7 @@ import org.junit.Test;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
/**
* @author Stephen Mallette (http://stephen.genoprime.com)
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/PartitionStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/PartitionStrategyTest.java
index 071706a..afcd4a6 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/PartitionStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/PartitionStrategyTest.java
@@ -18,43 +18,176 @@
*/
package org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration;
-import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
+import org.apache.tinkerpop.gremlin.process.traversal.Contains;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddEdgeStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexStartStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
+import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Element;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.T;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsCollectionContaining.hasItem;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
/**
* @author Stephen Mallette (http://stephen.genoprime.com)
*/
+@RunWith(Enclosed.class)
public class PartitionStrategyTest {
- @Test(expected = IllegalStateException.class)
- public void shouldNotConstructWithoutPartitionKey() {
- PartitionStrategy.build().create();
- }
+ @RunWith(Parameterized.class)
+ public static class PartitionStrategyTraverseTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
+
+ @Parameterized.Parameters(name = "{0}")
+ public static Iterable<Object[]> data() {
+ return Arrays.asList(new Object[][]{
+ {create().bothV(), 1, false},
+ {create().inV(), 1, false},
+ {create().outV(), 1, false},
+ {create().in(), 1, false},
+ {create().in("test"), 1, false},
+ {create().both(), 1, false},
+ {create().both("test"), 1, false},
+ {create().out(), 1, false},
+ {create().out("test"), 1, false},
+ {create().out().inE().otherV(), 3, false},
+ {create(Vertex.class).addV(), 1, true},
+ {create().addE("test").from("x"), 0, true},
+ {create().addE("test").to("x"), 0, true},
+ {create().addE("test").from("x").property("other", "args"), 0, true},
+ {create().addE("test").to("x").property("other", "args"), 0, true},
+ {create().in().out(), 2, false},
+ {create().in().out().addE("test").from("x"), 2, true},
+ {create().in().out().addE("test").to("x"), 2, true},
+ {create().out().out().out(), 3, false},
+ {create().in().out().in(), 3, false},
+ {create().inE().outV().inE().outV(), 4, false}});
+ }
+
+ @Parameterized.Parameter(value = 0)
+ public Traversal.Admin traversal;
+
+ @Parameterized.Parameter(value = 1)
+ public int expectedInsertedSteps;
+
+ @Parameterized.Parameter(value = 2)
+ public boolean hasMutatingStep;
+
+ @Test
+ public void shouldIncludeAdditionalHasStepsAndAppendPartitionOnMutatingSteps() {
+ final String repr = translator.translate(traversal.getBytecode());
+ final PartitionStrategy strategy = PartitionStrategy.build()
+ .partitionKey("p").writePartition("a").readPartitions("a").create();
- @Test
- public void shouldConstructPartitionStrategy() {
- final PartitionStrategy strategy = PartitionStrategy.build()
- .partitionKey("p").writePartition("a").readPartitions("a").create();
- assertEquals("a", strategy.getReadPartitions().iterator().next());
- assertEquals(1, strategy.getReadPartitions().size());
- assertEquals("p", strategy.getPartitionKey());
+ if (hasMutatingStep) {
+ if (TraversalHelper.hasStepOfAssignableClass(AddEdgeStep.class, traversal.asAdmin())) {
+ strategy.apply(traversal.asAdmin());
+ final List<AddEdgeStep> addEdgeSteps = TraversalHelper.getStepsOfAssignableClass(AddEdgeStep.class, traversal.asAdmin());
+ assertEquals(1, addEdgeSteps.size());
+ addEdgeSteps.forEach(s -> {
+ assertEquals(repr, "test", s.getParameters().get(T.label, () -> Edge.DEFAULT_LABEL).get(0));
+ assertEquals(repr, "a", s.getParameters().get("p", null).get(0));
+ });
+ } else if (TraversalHelper.hasStepOfAssignableClass(AddVertexStep.class, traversal.asAdmin())) {
+ strategy.apply(traversal.asAdmin());
+ final List<AddVertexStep> addVertexSteps = TraversalHelper.getStepsOfAssignableClass(AddVertexStep.class, traversal.asAdmin());
+ assertEquals(repr, 1, addVertexSteps.size());
+ addVertexSteps.forEach(s -> assertEquals(repr, "a", s.getParameters().get("p", null).get(0)));
+ } else if (TraversalHelper.hasStepOfAssignableClass(AddVertexStartStep.class, traversal.asAdmin())) {
+ strategy.apply(traversal.asAdmin());
+ final List<AddVertexStartStep> addVertexSteps = TraversalHelper.getStepsOfAssignableClass(AddVertexStartStep.class, traversal.asAdmin());
+ assertEquals(repr, 1, addVertexSteps.size());
+ addVertexSteps.forEach(s -> assertEquals(repr, "a", s.getParameters().get("p", null).get(0)));
+ } else
+ fail("This test should not be marked as having a mutating step or there is something else amiss.");
+ } else {
+ strategy.apply(traversal.asAdmin());
+ }
+
+ final List<HasStep> steps = TraversalHelper.getStepsOfClass(HasStep.class, traversal.asAdmin());
+ assertEquals(repr, expectedInsertedSteps, steps.size());
+
+ final List<String> keySet = new ArrayList<>(strategy.getReadPartitions());
+ steps.forEach(s -> {
+ assertEquals(repr, 1, s.getHasContainers().size());
+ final HasContainer hasContainer = (HasContainer) s.getHasContainers().get(0);
+ assertEquals(repr, "p", hasContainer.getKey());
+ assertEquals(repr, keySet, hasContainer.getValue());
+ assertEquals(repr, Contains.within, hasContainer.getBiPredicate());
+ });
+ }
+
+ public static GraphTraversal create() {
+ return create(null);
+ }
+
+ public static GraphTraversal create(final Class<? extends Element> clazz) {
+ final Graph mockedGraph = mock(Graph.class);
+ final Graph.Features features = mock(Graph.Features.class);
+ final Graph.Features.VertexFeatures vertexFeatures = mock(Graph.Features.VertexFeatures.class);
+ when(mockedGraph.features()).thenReturn(features);
+ when(features.vertex()).thenReturn(vertexFeatures);
+ when(vertexFeatures.getCardinality(any())).thenReturn(VertexProperty.Cardinality.single);
+ final DefaultGraphTraversal t = new DefaultGraphTraversal<>(mockedGraph);
+ if (clazz != null) t.asAdmin().addStep(new GraphStep<>(t.asAdmin(), clazz, true));
+ return t;
+ }
}
- @Test
- public void shouldConstructPartitionStrategyWithMultipleReadPartitions() {
- final PartitionStrategy strategy = PartitionStrategy.build()
- .partitionKey("p").writePartition("a")
- .readPartitions("a")
- .readPartitions("b")
- .readPartitions("c").create();
-
- assertTrue(IteratorUtils.asList(strategy.getReadPartitions().iterator()).contains("a"));
- assertTrue(IteratorUtils.asList(strategy.getReadPartitions().iterator()).contains("b"));
- assertTrue(IteratorUtils.asList(strategy.getReadPartitions().iterator()).contains("c"));
- assertEquals(3, strategy.getReadPartitions().size());
- assertEquals("p", strategy.getPartitionKey());
+ public static class RewriteTest {
+ @Test(expected = IllegalStateException.class)
+ public void shouldNotConstructWithoutPartitionKey() {
+ PartitionStrategy.build().create();
+ }
+
+ @Test
+ public void shouldConstructPartitionStrategy() {
+ final PartitionStrategy strategy = PartitionStrategy.build()
+ .partitionKey("p").writePartition("a").readPartitions("a").create();
+ assertEquals("a", strategy.getReadPartitions().iterator().next());
+ assertEquals(1, strategy.getReadPartitions().size());
+ assertEquals("p", strategy.getPartitionKey());
+ }
+
+ @Test
+ public void shouldConstructPartitionStrategyWithMultipleReadPartitions() {
+ final PartitionStrategy strategy = PartitionStrategy.build()
+ .partitionKey("p").writePartition("a")
+ .readPartitions("a")
+ .readPartitions("b")
+ .readPartitions("c").create();
+
+ assertThat(strategy.getReadPartitions(), hasItem("a"));
+ assertThat(strategy.getReadPartitions(), hasItem("b"));
+ assertThat(strategy.getReadPartitions(), hasItem("c"));
+ assertEquals(3, strategy.getReadPartitions().size());
+ assertEquals("p", strategy.getPartitionKey());
+ }
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/PartitionStrategyTraverseTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/PartitionStrategyTraverseTest.java
deleted file mode 100644
index c137099..0000000
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/PartitionStrategyTraverseTest.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * 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.strategy.decoration;
-
-import org.apache.tinkerpop.gremlin.process.traversal.Contains;
-import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddEdgeStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexStartStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer;
-import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
-import org.apache.tinkerpop.gremlin.structure.Edge;
-import org.apache.tinkerpop.gremlin.structure.Element;
-import org.apache.tinkerpop.gremlin.structure.Graph;
-import org.apache.tinkerpop.gremlin.structure.T;
-import org.apache.tinkerpop.gremlin.structure.Vertex;
-import org.apache.tinkerpop.gremlin.structure.VertexProperty;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-/**
- * @author Stephen Mallette (http://stephen.genoprime.com)
- */
-@RunWith(Parameterized.class)
-public class PartitionStrategyTraverseTest {
-
- @Parameterized.Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Arrays.asList(new Object[][]{
- {"bothV()", create().bothV(), 1, false},
- {"inV()", create().inV(), 1, false},
- {"outV()", create().outV(), 1, false},
- {"in()", create().in(), 1, false},
- {"in(args)", create().in("test"), 1, false},
- {"both()", create().both(), 1, false},
- {"both(args)", create().both("test"), 1, false},
- {"out()", create().out(), 1, false},
- {"out(args)", create().out("test"), 1, false},
- {"out().inE().otherV", create().out().inE().otherV(), 3, false},
- {"addV()", create(Vertex.class).addV(), 1, true},
- {"addE(test).from(x)", create().addE("test").from("x"), 0, true},
- {"addE(test).to(x)", create().addE("test").to("x"), 0, true},
- {"addE(test).from(x).property(other,args)", create().addE("test").from("x").property("other", "args"), 0, true},
- {"addE(test).to(x).property(other,args)", create().addE("test").to("x").property("other", "args"), 0, true},
- {"in().out()", create().in().out(), 2, false},
- {"in().out().addE(test).from(x)", create().in().out().addE("test").from("x"), 2, true},
- {"in().out().addE(test).to(x)", create().in().out().addE("test").to("x"), 2, true},
- {"out().out().out()", create().out().out().out(), 3, false},
- {"in().out().in()", create().in().out().in(), 3, false},
- {"inE().outV().inE().outV()", create().inE().outV().inE().outV(), 4, false}});
- }
-
- @Parameterized.Parameter(value = 0)
- public String name;
-
- @Parameterized.Parameter(value = 1)
- public Traversal traversal;
-
- @Parameterized.Parameter(value = 2)
- public int expectedInsertedSteps;
-
- @Parameterized.Parameter(value = 3)
- public boolean hasMutatingStep;
-
- @Test
- public void shouldIncludeAdditionalHasStepsAndAppendPartitionOnMutatingSteps() {
- final PartitionStrategy strategy = PartitionStrategy.build()
- .partitionKey("p").writePartition("a").readPartitions("a").create();
-
- if (hasMutatingStep) {
- if (TraversalHelper.hasStepOfAssignableClass(AddEdgeStep.class, traversal.asAdmin())) {
- strategy.apply(traversal.asAdmin());
- final List<AddEdgeStep> addEdgeSteps = TraversalHelper.getStepsOfAssignableClass(AddEdgeStep.class, traversal.asAdmin());
- assertEquals(1, addEdgeSteps.size());
- addEdgeSteps.forEach(s -> {
- assertEquals("test", s.getParameters().get(T.label, () -> Edge.DEFAULT_LABEL).get(0));
- assertEquals("a", s.getParameters().get("p", null).get(0));
- });
- } else if (TraversalHelper.hasStepOfAssignableClass(AddVertexStep.class, traversal.asAdmin())) {
- strategy.apply(traversal.asAdmin());
- final List<AddVertexStep> addVertexSteps = TraversalHelper.getStepsOfAssignableClass(AddVertexStep.class, traversal.asAdmin());
- assertEquals(1, addVertexSteps.size());
- addVertexSteps.forEach(s -> assertEquals("a", s.getParameters().get("p", null).get(0)));
- } else if (TraversalHelper.hasStepOfAssignableClass(AddVertexStartStep.class, traversal.asAdmin())) {
- strategy.apply(traversal.asAdmin());
- final List<AddVertexStartStep> addVertexSteps = TraversalHelper.getStepsOfAssignableClass(AddVertexStartStep.class, traversal.asAdmin());
- assertEquals(1, addVertexSteps.size());
- addVertexSteps.forEach(s -> assertEquals("a", s.getParameters().get("p", null).get(0)));
- } else
- fail("This test should not be marked as having a mutating step or there is something else amiss.");
- } else {
- strategy.apply(traversal.asAdmin());
- }
- //System.out.println(name + "::::::" + traversal.toString());
-
- final List<HasStep> steps = TraversalHelper.getStepsOfClass(HasStep.class, traversal.asAdmin());
- assertEquals(expectedInsertedSteps, steps.size());
-
- final List<String> keySet = new ArrayList<>(strategy.getReadPartitions());
- steps.forEach(s -> {
- assertEquals(1, s.getHasContainers().size());
- final HasContainer hasContainer = (HasContainer) s.getHasContainers().get(0);
- assertEquals("p", hasContainer.getKey());
- assertEquals(keySet, hasContainer.getValue());
- assertEquals(Contains.within, hasContainer.getBiPredicate());
- });
- }
-
- public static GraphTraversal create() {
- return create(null);
- }
-
- public static GraphTraversal create(final Class<? extends Element> clazz) {
- final Graph mockedGraph = mock(Graph.class);
- final Graph.Features features = mock(Graph.Features.class);
- final Graph.Features.VertexFeatures vertexFeatures = mock(Graph.Features.VertexFeatures.class);
- when(mockedGraph.features()).thenReturn(features);
- when(features.vertex()).thenReturn(vertexFeatures);
- when(vertexFeatures.getCardinality(any())).thenReturn(VertexProperty.Cardinality.single);
- final DefaultGraphTraversal t = new DefaultGraphTraversal<>(mockedGraph);
- if (clazz != null) t.asAdmin().addStep(new GraphStep<>(t.asAdmin(), clazz, true));
- return t;
- }
-}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SackStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SackStrategyTest.java
index 7576e9a..4951131 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SackStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SackStrategyTest.java
@@ -32,7 +32,7 @@ import java.util.stream.IntStream;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.greaterThan;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
/**
* @author Daniel Kuppitz (http://gremlin.guru)
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
index 901d3a5..bb51103 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
@@ -20,21 +20,29 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration;
import org.apache.tinkerpop.gremlin.process.traversal.P;
import org.apache.tinkerpop.gremlin.process.traversal.Step;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.AndStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.TraversalFilterStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexStartStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.EdgeVertexStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.VertexStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.IdentityStep;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.InlineFilterStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.StandardVerificationStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
+import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
import org.hamcrest.CoreMatchers;
import org.junit.Test;
import org.junit.experimental.runners.Enclosed;
@@ -42,6 +50,8 @@ import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has;
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.hasLabel;
@@ -53,24 +63,70 @@ import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.values
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
/**
* @author Stephen Mallette (http://stephen.genoprime.com)
*/
@RunWith(Enclosed.class)
public class SubgraphStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@RunWith(Parameterized.class)
- public static class ParameterizedTests {
+ public static class TraverseTest {
+ private static final GraphTraversalSource g = EmptyGraph.instance().traversal();
+
+ @Parameterized.Parameters(name = "{0}")
+ public static Iterable<Object[]> data() {
+ return Arrays.asList(new Object[][]{
+ {__.bothV(), 1},
+ {__.inV(), 1},
+ {__.outV(), 1},
+ {__.in(), 2},
+ {__.in("test"), 2},
+ {__.both(), 2},
+ {__.both("test"), 2},
+ {__.out(), 2},
+ {__.out("test"), 2},
+ {__.out().inE().otherV(), 4},
+ {g.addV(), 1},
+ {g.V(1).addE("test"), 2},
+ {__.in().out(), 4},
+ {__.out().out().out(), 6},
+ {__.in().out().in(), 6},
+ {__.inE().outV().inE().outV(), 4}});
+ }
+
+ @Parameterized.Parameter(value = 0)
+ public Traversal.Admin traversal;
+
+ @Parameterized.Parameter(value = 1)
+ public int expectedInsertedSteps;
+
+ @Test
+ public void shouldSubgraph() {
+ final String repr = translator.translate(traversal.getBytecode());
+ final SubgraphStrategy strategy = SubgraphStrategy.build().edges(__.has("edge")).vertices(__.has("vertex")).create();
+ strategy.apply(traversal);
+
+ final List<TraversalFilterStep> steps = TraversalHelper.getStepsOfClass(TraversalFilterStep.class, traversal);
+ System.out.println(repr + "+" + steps.stream().map(s -> s.getFilterTraversal().toString()).collect(Collectors.joining()));
+ assertEquals(repr + ":" + traversal.toString(), expectedInsertedSteps, steps.size());
+ }
+ }
+
+ @RunWith(Parameterized.class)
+ public static class MixedStrategiesTests {
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
final TraversalStrategies originalStrategies = new DefaultTraversalStrategies();
originalStrategies.addStrategies(SubgraphStrategy.build().
vertices(__.and(has("name", "marko"), has("age", 29))).
@@ -84,7 +140,7 @@ public class SubgraphStrategyTest {
optimizedStrategies.addStrategies(InlineFilterStrategy.instance());
this.optimized.asAdmin().setStrategies(optimizedStrategies);
this.optimized.asAdmin().applyStrategies();
- assertEquals(this.optimized, this.original);
+ assertEquals(repr, this.optimized, this.original);
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTraverseTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTraverseTest.java
deleted file mode 100644
index ad5686e..0000000
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTraverseTest.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * 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.strategy.decoration;
-
-import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.TraversalFilterStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
-import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
-import org.apache.tinkerpop.gremlin.structure.Graph;
-import org.apache.tinkerpop.gremlin.structure.Vertex;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
-
-/**
- * @author Stephen Mallette (http://stephen.genoprime.com)
- */
-@RunWith(Parameterized.class)
-public class SubgraphStrategyTraverseTest {
- private static Traversal traversalWithAddV;
-
- static {
- final Graph mockedGraph = mock(Graph.class);
- final DefaultGraphTraversal t = new DefaultGraphTraversal<>(mockedGraph);
- t.asAdmin().addStep(new GraphStep<>(t.asAdmin(), Vertex.class, true));
- traversalWithAddV = t.addV();
- }
-
- @Parameterized.Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Arrays.asList(new Object[][]{
- {"bothV()", __.bothV(), 1},
- {"inV()", __.inV(), 1},
- {"outV()", __.outV(), 1},
- {"in()", __.in(), 2},
- {"in(args)", __.in("test"), 2},
- {"both()", __.both(), 2},
- {"both(args)", __.both("test"), 2},
- {"out()", __.out(), 2},
- {"out(args)", __.out("test"), 2},
- {"out().inE().otherV", __.out().inE().otherV(), 4},
- {"addV()", traversalWithAddV, 2},
- // {"addInE()", __.addInE("test", "x"), 1},
- // {"addOutE()", __.addOutE("test", "x"), 1},
- // {"addInE()", __.addInE("test", "x", "other", "args"), 1},
- // {"addOutE()", __.addOutE("test", "x", "other", "args"), 1},
- // {"addE(OUT)", __.addE(Direction.OUT, "test", "x"), 1},
- // {"addE(IN)", __.addE(Direction.IN, "test", "x"), 1},
- {"in().out()", __.in().out(), 4},
- // {"in().out().addInE()", __.in().out().addInE("test", "x"), 5},
- // {"in().out().addOutE()", __.in().out().addOutE("test", "x"), 5},
- // {"in().out().addE(OUT)", __.in().out().addE(Direction.OUT, "test", "x"), 5},
- // {"in().out().addE(IN)", __.in().out().addE(Direction.IN, "test", "x"), 5},
- {"out().out().out()", __.out().out().out(), 6},
- {"in().out().in()", __.in().out().in(), 6},
- {"inE().outV().inE().outV()", __.inE().outV().inE().outV(), 4}});
- }
-
- @Parameterized.Parameter(value = 0)
- public String name;
-
- @Parameterized.Parameter(value = 1)
- public Traversal traversal;
-
- @Parameterized.Parameter(value = 2)
- public int expectedInsertedSteps;
-
- @Test
- public void shouldSubgraph() {
- final SubgraphStrategy strategy = SubgraphStrategy.build().edges(__.identity()).vertices(__.identity()).create();
- strategy.apply(traversal.asAdmin());
-
- final List<TraversalFilterStep> steps = TraversalHelper.getStepsOfClass(TraversalFilterStep.class, traversal.asAdmin());
- assertEquals(expectedInsertedSteps, steps.size());
- }
-}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/VertexProgramStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/VertexProgramStrategyTest.java
index 8ceef48..ecc4708 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/VertexProgramStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/VertexProgramStrategyTest.java
@@ -24,12 +24,14 @@ import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.Computer
import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.TraversalVertexProgramStep;
import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.decoration.VertexProgramStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.Step;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ComputerVerificationStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.util.EmptyTraversal;
import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
@@ -46,9 +48,10 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class VertexProgramStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@@ -56,11 +59,12 @@ public class VertexProgramStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(new VertexProgramStrategy(Computer.compute()), ComputerVerificationStrategy.instance());
original.asAdmin().setStrategies(strategies);
original.asAdmin().applyStrategies();
- assertEquals(optimized, original);
+ assertEquals(repr, optimized, original);
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/AdjacentToIncidentStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/AdjacentToIncidentStrategyTest.java
index c791cd5..62345ab 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/AdjacentToIncidentStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/AdjacentToIncidentStrategyTest.java
@@ -18,9 +18,11 @@
*/
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -35,9 +37,10 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class AdjacentToIncidentStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@@ -52,8 +55,9 @@ public class AdjacentToIncidentStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
applyAdjacentToIncidentStrategy(original);
- assertEquals(optimized, original);
+ assertEquals(repr, optimized, original);
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/CountStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/CountStrategyTest.java
index 0271274..b4d14d7 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/CountStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/CountStrategyTest.java
@@ -18,9 +18,11 @@
*/
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -45,9 +47,10 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class CountStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@@ -114,7 +117,8 @@ public class CountStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
applyCountStrategy(original);
- assertEquals(optimized, original);
+ assertEquals(repr, optimized, original);
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/EarlyLimitStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/EarlyLimitStrategyTest.java
index bb5d85d..ea0b95c 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/EarlyLimitStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/EarlyLimitStrategyTest.java
@@ -19,12 +19,14 @@
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.ProfileStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -41,9 +43,10 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class EarlyLimitStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameter()
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@@ -53,6 +56,7 @@ public class EarlyLimitStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(EarlyLimitStrategy.instance());
for (final TraversalStrategy strategy : this.otherStrategies) {
@@ -66,7 +70,7 @@ public class EarlyLimitStrategyTest {
}
this.original.asAdmin().setStrategies(strategies);
this.original.asAdmin().applyStrategies();
- assertEquals(this.optimized, this.original);
+ assertEquals(repr, this.optimized, this.original);
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
index 11f390b..d7e1a33 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
@@ -19,10 +19,12 @@
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.junit.Test;
@@ -52,13 +54,14 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class FilterRankingStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
public static Iterable<Object[]> data() {
return generateTestParameters();
}
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@@ -68,6 +71,7 @@ public class FilterRankingStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(FilterRankingStrategy.instance());
for (final TraversalStrategy strategy : this.otherStrategies) {
@@ -75,7 +79,7 @@ public class FilterRankingStrategyTest {
}
this.original.asAdmin().setStrategies(strategies);
this.original.asAdmin().applyStrategies();
- assertEquals(this.optimized, this.original);
+ assertEquals(repr, this.optimized, this.original);
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IdentityRemovalStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IdentityRemovalStrategyTest.java
index eb791af..09d9444 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IdentityRemovalStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IdentityRemovalStrategyTest.java
@@ -18,9 +18,11 @@
*/
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -35,14 +37,14 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class IdentityRemovalStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
-
private void applyIdentityRemovalStrategy(final Traversal traversal) {
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(IdentityRemovalStrategy.instance());
@@ -53,8 +55,9 @@ public class IdentityRemovalStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
applyIdentityRemovalStrategy(original);
- assertEquals(optimized, original);
+ assertEquals(repr, optimized, original);
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IncidentToAdjacentStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IncidentToAdjacentStrategyTest.java
index abf1884..ca1342b 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IncidentToAdjacentStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IncidentToAdjacentStrategyTest.java
@@ -18,10 +18,12 @@
*/
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.junit.Test;
@@ -38,9 +40,10 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class IncidentToAdjacentStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@@ -71,11 +74,12 @@ public class IncidentToAdjacentStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(IncidentToAdjacentStrategy.instance());
this.original.asAdmin().setStrategies(strategies);
this.original.asAdmin().applyStrategies();
- assertEquals(this.optimized, this.original);
+ assertEquals(repr, this.optimized, this.original);
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java
index cf54f50..e7f9835 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java
@@ -20,6 +20,7 @@
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
@@ -28,6 +29,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ConnectiveStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.util.EmptyTraversal;
import org.apache.tinkerpop.gremlin.structure.T;
@@ -65,9 +67,10 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class InlineFilterStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@@ -77,6 +80,7 @@ public class InlineFilterStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(InlineFilterStrategy.instance());
@@ -84,7 +88,7 @@ public class InlineFilterStrategyTest {
this.original.asAdmin().setStrategies(strategies);
this.original.asAdmin().applyStrategies();
- assertEquals(this.optimized, this.original);
+ assertEquals(repr, this.optimized, this.original);
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategyTest.java
index 77655dd..332a38e 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategyTest.java
@@ -39,6 +39,7 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class LazyBarrierStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> data() {
@@ -56,6 +57,7 @@ public class LazyBarrierStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(LazyBarrierStrategy.instance());
for (final TraversalStrategy strategy : this.otherStrategies) {
@@ -63,7 +65,7 @@ public class LazyBarrierStrategyTest {
}
this.original.asAdmin().setStrategies(strategies);
this.original.asAdmin().applyStrategies();
- assertEquals(this.optimized, this.original);
+ assertEquals(repr, this.optimized, this.original);
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/MatchPredicateStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/MatchPredicateStrategyTest.java
index ed248ff..cec76b6 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/MatchPredicateStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/MatchPredicateStrategyTest.java
@@ -19,12 +19,13 @@
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
-import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -42,9 +43,10 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class MatchPredicateStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@@ -54,6 +56,7 @@ public class MatchPredicateStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(MatchPredicateStrategy.instance());
for (final TraversalStrategy strategy : this.otherStrategies) {
@@ -61,7 +64,7 @@ public class MatchPredicateStrategyTest {
}
this.original.asAdmin().setStrategies(strategies);
this.original.asAdmin().applyStrategies();
- assertEquals(this.optimized, this.original);
+ assertEquals(repr, this.optimized, this.original);
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/OrderLimitStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/OrderLimitStrategyTest.java
index 641d22e..5d615ee 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/OrderLimitStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/OrderLimitStrategyTest.java
@@ -20,10 +20,12 @@
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.TraversalVertexProgramStep;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.util.EmptyTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
@@ -40,9 +42,10 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class OrderLimitStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameter(value = 0)
- public Traversal traversal;
+ public Traversal.Admin traversal;
@Parameterized.Parameter(value = 1)
public long limit;
@@ -56,9 +59,10 @@ public class OrderLimitStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(traversal.getBytecode());
traversal.asAdmin().setParent(new TraversalVertexProgramStep(EmptyTraversal.instance(), EmptyTraversal.instance())); // trick it
applyOrderLimitStrategyStrategy(traversal);
- assertEquals(limit, TraversalHelper.getFirstStepOfAssignableClass(OrderGlobalStep.class, traversal.asAdmin()).get().getLimit());
+ assertEquals(repr, limit, TraversalHelper.getFirstStepOfAssignableClass(OrderGlobalStep.class, traversal.asAdmin()).get().getLimit());
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathProcessorStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathProcessorStrategyTest.java
index 9616d5a..863f525 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathProcessorStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathProcessorStrategyTest.java
@@ -22,6 +22,7 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.TraversalVertexProgramStep;
import org.apache.tinkerpop.gremlin.process.traversal.P;
import org.apache.tinkerpop.gremlin.process.traversal.Pop;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
@@ -30,6 +31,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.process.traversal.lambda.ElementValueTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.lambda.IdentityTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.junit.Test;
@@ -47,9 +49,10 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class PathProcessorStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@@ -59,6 +62,7 @@ public class PathProcessorStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
final Traversal.Admin<?, ?> rootTraversal = new DefaultGraphTraversal<>();
final TraversalParent parent = new TraversalVertexProgramStep(rootTraversal, this.original.asAdmin());
rootTraversal.addStep(parent.asStep());
@@ -70,7 +74,7 @@ public class PathProcessorStrategyTest {
}
this.original.asAdmin().setStrategies(strategies);
this.original.asAdmin().applyStrategies();
- assertEquals(this.optimized, this.original);
+ assertEquals(repr, this.optimized, this.original);
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java
index 0669b08..1a9ae43 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java
@@ -56,7 +56,6 @@ import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.select
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.store;
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.values;
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.where;
-import static org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.PathRetractionStrategy.MAX_BARRIER_SIZE;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -67,6 +66,7 @@ import static org.mockito.Mockito.when;
*/
@RunWith(Parameterized.class)
public class PathRetractionStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
private final List<TraversalStrategies> strategies = Arrays.asList(
new DefaultTraversalStrategies().addStrategies(PathRetractionStrategy.instance()),
@@ -75,7 +75,7 @@ public class PathRetractionStrategyTest {
new DefaultTraversalStrategies().addStrategies(PathRetractionStrategy.instance(), PathProcessorStrategy.instance(), MatchPredicateStrategy.instance(), RepeatUnrollStrategy.instance()));
@Parameterized.Parameter(value = 0)
- public Traversal.Admin traversal;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public String labels;
@@ -87,13 +87,14 @@ public class PathRetractionStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
for (final TraversalStrategies currentStrategies : this.strategies) {
- final Traversal.Admin<?, ?> currentTraversal = this.traversal.clone();
+ final Traversal.Admin<?, ?> currentTraversal = this.original.clone();
currentTraversal.setStrategies(currentStrategies);
currentTraversal.applyStrategies();
- assertEquals(this.labels, getKeepLabels(currentTraversal).toString());
+ assertEquals(repr, this.labels, getKeepLabels(currentTraversal).toString());
if (null != optimized)
- assertEquals(currentTraversal, optimized);
+ assertEquals(repr, currentTraversal, optimized);
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java
index 13223cb..1ebbd3f 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java
@@ -19,11 +19,13 @@
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.junit.Test;
@@ -44,9 +46,10 @@ import static org.junit.Assert.assertEquals;
*/
@RunWith(Parameterized.class)
public class RepeatUnrollStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
@@ -56,6 +59,7 @@ public class RepeatUnrollStrategyTest {
@Test
public void doTest() {
+ final String repr = translator.translate(original.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(RepeatUnrollStrategy.instance());
for (final TraversalStrategy strategy : this.otherStrategies) {
@@ -63,7 +67,7 @@ public class RepeatUnrollStrategyTest {
}
this.original.asAdmin().setStrategies(strategies);
this.original.asAdmin().applyStrategies();
- assertEquals(this.optimized, this.original);
+ assertEquals(repr, this.optimized, this.original);
}
@Parameterized.Parameters(name = "{0}")
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyTest.java
index e594bd4..ba3ab95 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyTest.java
@@ -20,11 +20,11 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.verification;
import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.TraversalVertexProgramStep;
import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ConnectiveStrategy;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.AdjacentToIncidentStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.util.EmptyTraversal;
import org.junit.Test;
@@ -45,33 +45,32 @@ import static org.junit.Assert.fail;
*/
@RunWith(Parameterized.class)
public class ComputerVerificationStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> data() {
return Arrays.asList(new Object[][]{
// illegal
- {"__.where(__.out().values(\"name\"))", __.where(__.out().values("name")), false},
- {"__.local(out().out())", __.local(out().out()), false},
+ {__.where(__.out().values("name")), false},
+ {__.local(out().out()), false},
// legal
- {"__.values(\"age\").union(max(), min(), sum())", __.values("age").union(max(), min(), sum()), true},
- {"__.count().sum()", __.count().sum(), true},
- {"__.where(\"a\",eq(\"b\")).out()", __.where("a", P.eq("b")).out(), true},
- {"__.where(and(outE(\"knows\"),outE(\"created\"))).values(\"name\")", __.where(__.and(outE("knows"), outE("created"))).values("name"), true},
+ {__.values("age").union(max(), min(), sum()), true},
+ {__.count().sum(), true},
+ {__.where("a", P.eq("b")).out(), true},
+ {__.where(__.and(outE("knows"), outE("created"))).values("name"), true},
});
}
@Parameterized.Parameter(value = 0)
- public String name;
+ public Traversal.Admin traversal;
@Parameterized.Parameter(value = 1)
- public Traversal traversal;
-
- @Parameterized.Parameter(value = 2)
public boolean legal;
@Test
public void shouldBeVerifiedIllegal() {
+ final String repr = translator.translate(traversal.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(ComputerVerificationStrategy.instance());
@@ -80,10 +79,10 @@ public class ComputerVerificationStrategyTest {
try {
this.traversal.asAdmin().applyStrategies();
if (!this.legal)
- fail("The traversal should not be allowed: " + this.traversal);
+ fail("The traversal should not be allowed: " + repr);
} catch (final VerificationException ise) {
if (this.legal)
- fail("The traversal should be allowed: " + this.traversal);
+ fail("The traversal should be allowed: " + repr);
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/EdgeLabelVerificationStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/EdgeLabelVerificationStrategyTest.java
index b9c5330..aa8ce0a 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/EdgeLabelVerificationStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/EdgeLabelVerificationStrategyTest.java
@@ -21,9 +21,11 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.verification;
import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.junit.After;
@@ -39,7 +41,7 @@ import java.util.function.Predicate;
import java.util.regex.Pattern;
import java.util.stream.Stream;
-import static org.junit.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.fail;
/**
@@ -47,6 +49,7 @@ import static org.junit.Assert.fail;
*/
@RunWith(Parameterized.class)
public class EdgeLabelVerificationStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
private final static Predicate<String> MSG_PREDICATE = Pattern.compile(
"^The provided traversal contains a vertex step without any specified edge label: VertexStep.*")
@@ -73,40 +76,39 @@ public class EdgeLabelVerificationStrategyTest {
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> data() {
return Arrays.asList(new Object[][]{
- {"__.inE()", __.inE(), false},
- {"__.outE()", __.outE(), false},
- {"__.bothE()", __.bothE(), false},
- {"__.to(OUT)", __.to(Direction.OUT), false},
- {"__.toE(IN)", __.toE(Direction.IN), false},
- {"__.inE('knows')", __.inE("knows"), true},
- {"__.outE('knows')", __.outE("knows"), true},
- {"__.bothE('created','knows')", __.bothE("created", "knows"), true},
- {"__.to(OUT,'created','knows')", __.to(Direction.OUT, "created", "knows"), true},
- {"__.toE(IN,'knows')", __.toE(Direction.IN, "knows"), true}
+ {__.inE(), false},
+ {__.outE(), false},
+ {__.bothE(), false},
+ {__.to(Direction.OUT), false},
+ {__.toE(Direction.IN), false},
+ {__.inE("knows"), true},
+ {__.outE("knows"), true},
+ {__.bothE("created", "knows"), true},
+ {__.to(Direction.OUT, "created", "knows"), true},
+ {__.toE(Direction.IN, "knows"), true}
});
}
@Parameterized.Parameter(value = 0)
- public String name;
+ public Traversal.Admin traversal;
@Parameterized.Parameter(value = 1)
- public Traversal traversal;
-
- @Parameterized.Parameter(value = 2)
public boolean allow;
@Test
public void shouldIgnore() {
+ final String repr = translator.translate(traversal.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(EdgeLabelVerificationStrategy.build().create());
final Traversal traversal = this.traversal.asAdmin().clone();
traversal.asAdmin().setStrategies(strategies);
traversal.asAdmin().applyStrategies();
- assertTrue(logAppender.isEmpty());
+ assertThat(repr, logAppender.isEmpty());
}
@Test
public void shouldOnlyThrow() {
+ final String repr = translator.translate(traversal.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(EdgeLabelVerificationStrategy.build().throwException().create());
final Traversal traversal = this.traversal.asAdmin().clone();
@@ -116,44 +118,46 @@ public class EdgeLabelVerificationStrategyTest {
} else {
try {
traversal.asAdmin().applyStrategies();
- fail("The strategy should not allow vertex steps with unspecified edge labels: " + this.traversal);
+ fail("The strategy should not allow vertex steps with unspecified edge labels: " + repr);
} catch (VerificationException ise) {
- assertTrue(MSG_PREDICATE.test(ise.getMessage()));
+ assertThat(repr, MSG_PREDICATE.test(ise.getMessage()));
}
}
- assertTrue(logAppender.isEmpty());
+ assertThat(repr, logAppender.isEmpty());
}
@Test
public void shouldOnlyLog() {
+ final String repr = translator.translate(traversal.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(EdgeLabelVerificationStrategy.build().logWarning().create());
final Traversal traversal = this.traversal.asAdmin().clone();
traversal.asAdmin().setStrategies(strategies);
traversal.asAdmin().applyStrategies();
if (!allow) {
- assertTrue(String.format("Expected log entry not found in %s", logAppender.messages),
+ assertThat(String.format("Expected log entry not found in %s for %s", logAppender.messages, repr),
logAppender.messages().anyMatch(MSG_PREDICATE));
}
}
@Test
public void shouldThrowAndLog() {
+ final String repr = translator.translate(traversal.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(EdgeLabelVerificationStrategy.build().throwException().logWarning().create());
final Traversal traversal = this.traversal.asAdmin().clone();
traversal.asAdmin().setStrategies(strategies);
if (allow) {
traversal.asAdmin().applyStrategies();
- assertTrue(logAppender.isEmpty());
+ assertThat(repr, logAppender.isEmpty());
} else {
try {
traversal.asAdmin().applyStrategies();
- fail("The strategy should not allow vertex steps with unspecified edge labels: " + this.traversal);
+ fail("The strategy should not allow vertex steps with unspecified edge labels: " + repr);
} catch (VerificationException ise) {
- assertTrue(MSG_PREDICATE.test(ise.getMessage()));
+ assertThat(repr, MSG_PREDICATE.test(ise.getMessage()));
}
- assertTrue(String.format("Expected log entry not found in %s", logAppender.messages),
+ assertThat(String.format("Expected log entry not found in %s for %s", logAppender.messages, repr),
logAppender.messages().anyMatch(MSG_PREDICATE));
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/LambdaRestrictionStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/LambdaRestrictionStrategyTest.java
index 06309ea..6618acc 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/LambdaRestrictionStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/LambdaRestrictionStrategyTest.java
@@ -20,14 +20,14 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.verification;
import org.apache.tinkerpop.gremlin.process.traversal.Order;
import org.apache.tinkerpop.gremlin.process.traversal.Scope;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.ProfileStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
-import org.apache.tinkerpop.gremlin.structure.Column;
-import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.T;
import org.apache.tinkerpop.gremlin.util.function.Lambda;
import org.junit.Test;
@@ -39,7 +39,8 @@ import java.util.Arrays;
import static org.apache.tinkerpop.gremlin.process.traversal.Operator.sum;
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.outE;
import static org.apache.tinkerpop.gremlin.structure.Column.values;
-import static org.junit.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.StringContains.containsString;
import static org.junit.Assert.fail;
/**
@@ -47,47 +48,46 @@ import static org.junit.Assert.fail;
*/
@RunWith(Parameterized.class)
public class LambdaRestrictionStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> data() {
return Arrays.asList(new Object[][]{
- {"map(Lambda.function('true')}", __.map(Lambda.function("true")), false},
- {"filter(Lambda.predicate('true')}", __.filter(Lambda.predicate("true")), false},
- {"filter(x->true)", __.filter(x -> true), false},
- {"map(Traverser::get)", __.map(Traverser::get), false},
- {"sideEffect(x -> {int i = 1+1;})", __.sideEffect(x -> {
+ {__.map(Lambda.function("true")), false},
+ {__.filter(Lambda.predicate("true")), false},
+ {__.filter(x -> true), false},
+ {__.map(Traverser::get), false},
+ {__.sideEffect(x -> {
int i = 1 + 1;
}), false},
- {"select('a').by(values)", __.select("a").by(values), true},
- {"select('a','b').by(Object::toString)", __.select("a", "b").by(Object::toString), false},
- {"order().by((a,b)->a.compareTo(b))", __.order().by((a, b) -> ((Integer) a).compareTo((Integer) b)), false},
- {"order(local).by((a,b)->a.compareTo(b))", __.order(Scope.local).by((a, b) -> ((Integer) a).compareTo((Integer) b)), false},
- {"__.choose(v->v.toString().equals(\"marko\"),__.out(),__.in())", __.choose(v -> v.toString().equals("marko"), __.out(), __.in()), false},
- {"order().by(label,desc)", __.order().by(T.label, Order.desc), true},
- {"order(local).by(values)", __.order(Scope.local).by(values), true},
- {"order(local).by(values,desc)", __.order(Scope.local).by(values,Order.desc), true},
- {"order(local).by(values,(a,b) -> a.compareTo(b))", __.order(Scope.local).by(values, (a, b) -> ((Double) a).compareTo((Double) b)), false},
+ {__.select("a").by(values), true},
+ {__.select("a", "b").by(Object::toString), false},
+ {__.order().by((a, b) -> ((Integer) a).compareTo((Integer) b)), false},
+ {__.order(Scope.local).by((a, b) -> ((Integer) a).compareTo((Integer) b)), false},
+ {__.choose(v -> v.toString().equals("marko"), __.out(), __.in()), false},
+ {__.order().by(T.label, Order.desc), true},
+ {__.order(Scope.local).by(values), true},
+ {__.order(Scope.local).by(values,Order.desc), true},
+ {__.order(Scope.local).by(values, (a, b) -> ((Double) a).compareTo((Double) b)), false},
//
- {"groupCount().by(label)", __.groupCount().by(T.label), true},
+ {__.groupCount().by(T.label), true},
//
- {"sack(sum).by('age')", __.sack(sum).by("age"), true},
- {"sack{a,b -> a+b}.by('age')", __.sack((a, b) -> (int) a + (int) b).by("age"), false},
+ {__.sack(sum).by("age"), true},
+ {__.sack((a, b) -> (int) a + (int) b).by("age"), false},
//
- {"order().by(outE('rating').values('stars').mean()).profile()", __.order().by(outE("ratings").values("stars").mean()).profile(), true}
+ {__.order().by(outE("ratings").values("stars").mean()).profile(), true}
});
}
@Parameterized.Parameter(value = 0)
- public String name;
+ public Traversal.Admin traversal;
@Parameterized.Parameter(value = 1)
- public Traversal traversal;
-
- @Parameterized.Parameter(value = 2)
public boolean allow;
@Test
public void shouldBeVerifiedIllegal() {
+ final String repr = translator.translate(traversal.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(ProfileStrategy.instance());
strategies.addStrategies(LambdaRestrictionStrategy.instance());
@@ -97,9 +97,9 @@ public class LambdaRestrictionStrategyTest {
} else {
try {
traversal.asAdmin().applyStrategies();
- fail("The strategy should not allow lambdas: " + this.traversal);
+ fail("The strategy should not allow lambdas: " + repr);
} catch (VerificationException ise) {
- assertTrue(ise.getMessage().contains("lambda"));
+ assertThat(ise.getMessage(), containsString("lambda"));
}
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ReadOnlyStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ReadOnlyStrategyTest.java
index e36e22b..8df21cb 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ReadOnlyStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ReadOnlyStrategyTest.java
@@ -18,8 +18,10 @@
*/
package org.apache.tinkerpop.gremlin.process.traversal.strategy.verification;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.structure.VertexProperty;
import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
import org.junit.Test;
@@ -28,7 +30,8 @@ import org.junit.runners.Parameterized;
import java.util.Arrays;
-import static org.junit.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.StringStartsWith.startsWith;
import static org.junit.Assert.fail;
/**
@@ -36,34 +39,34 @@ import static org.junit.Assert.fail;
*/
@RunWith(Parameterized.class)
public class ReadOnlyStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
+
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> data() {
return Arrays.asList(new Object[][]{
- {"addE(test).from(x)", new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").from("x")},
- {"addE(test).from(x).property(this,that)", new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").from("x").property("this", "that")},
- {"addE(test).to(x)", new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").to("x")},
- {"addE(test).to(x).property(this,that)", new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").to("x").property("this", "that")},
- {"outE().property(k,v)", new DefaultGraphTraversal<>(EmptyGraph.instance()).outE().property("test", "test")},
- {"out().properties(k).property(k,v)", new DefaultGraphTraversal<>(EmptyGraph.instance()).out().properties("test").property("test", "that")},
- {"out().property(k,v)", new DefaultGraphTraversal<>(EmptyGraph.instance()).out().property("test", "test")},
- {"out().property(Cardinality,k,v)", new DefaultGraphTraversal<>(EmptyGraph.instance()).out().property(VertexProperty.Cardinality.list, "test", "test")},
- {"addV(person)", new DefaultGraphTraversal<>(EmptyGraph.instance()).addV("person")},
- {"addV()", new DefaultGraphTraversal<>(EmptyGraph.instance()).addV()}});
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").from("x")},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").from("x").property("this", "that")},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").to("x")},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addE("test").to("x").property("this", "that")},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).outE().property("test", "test")},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).out().properties("test").property("test", "that")},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).out().property("test", "test")},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).out().property(VertexProperty.Cardinality.list, "test", "test")},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addV("person")},
+ {new DefaultGraphTraversal<>(EmptyGraph.instance()).addV()}});
}
@Parameterized.Parameter(value = 0)
- public String name;
-
- @Parameterized.Parameter(value = 1)
- public Traversal traversal;
+ public Traversal.Admin traversal;
@Test
public void shouldBeVerifiedIllegal() {
+ final String repr = translator.translate(traversal.getBytecode());
try {
ReadOnlyStrategy.instance().apply(this.traversal.asAdmin());
- fail("The strategy should have found a mutating step.");
+ fail("The strategy should have found a mutating step: " + repr);
} catch (VerificationException ise) {
- assertTrue(ise.getMessage().startsWith("The provided traversal has a mutating step and thus is not read only: "));
+ assertThat(repr, ise.getMessage(), startsWith("The provided traversal has a mutating step and thus is not read only: "));
}
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ReservedKeysVerificationStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ReservedKeysVerificationStrategyTest.java
index 22dcd11..db7f47b 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ReservedKeysVerificationStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ReservedKeysVerificationStrategyTest.java
@@ -21,9 +21,11 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.verification;
import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.structure.T;
import org.junit.After;
@@ -40,6 +42,8 @@ import java.util.function.Predicate;
import java.util.regex.Pattern;
import java.util.stream.Stream;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@@ -48,6 +52,7 @@ import static org.junit.Assert.fail;
*/
@RunWith(Parameterized.class)
public class ReservedKeysVerificationStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
private final static Predicate<String> MSG_PREDICATE = Pattern.compile(
".*that is setting a property key to a reserved word.*")
@@ -74,42 +79,41 @@ public class ReservedKeysVerificationStrategyTest {
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> data() {
return Arrays.asList(new Object[][]{
- {"__.addV().property('id',123)", __.addV().property("id", 123), false},
- {"__.addE('knows').property('id',123)", __.addE("knows").property("id", 123), false},
- {"__.addV().property(T.id,123)", __.addV().property(T.id, 123), true},
- {"__.addE('knows').property(T.label,123)", __.addE("knows").property(T.label, "blah"), true},
- {"__.addV().property('label','xyz')", __.addV().property("label", "xyz"), false},
- {"__.addE('knows').property('label','xyz')", __.addE("knows").property("id", "xyz"), false},
- {"__.addV().property('x','xyz', 'label', 'xxx')", __.addV().property("x", "xyz", "label", "xxx"), false},
- {"__.addV().property('x','xyz', 'not-Label', 'xxx')", __.addV().property("x", "xyz", "not-label", "xxx"), true},
- {"__.addV().property('x','xyz', 'not-allowed', 'xxx')", __.addV().property("x", "xyz", "not-allowed", "xxx"), false},
+ {__.addV().property("id", 123), false},
+ {__.addE("knows").property("id", 123), false},
+ {__.addV().property(T.id, 123), true},
+ {__.addE("knows").property(T.label, "blah"), true},
+ {__.addV().property("label", "xyz"), false},
+ {__.addE("knows").property("id", "xyz"), false},
+ {__.addV().property("x", "xyz", "label", "xxx"), false},
+ {__.addV().property("x", "xyz", "not-label", "xxx"), true},
+ {__.addV().property("x", "xyz", "not-allowed", "xxx"), false},
});
}
@Parameterized.Parameter(value = 0)
- public String name;
+ public Traversal.Admin traversal;
@Parameterized.Parameter(value = 1)
- public Traversal traversal;
-
- @Parameterized.Parameter(value = 2)
public boolean allow;
@Test
public void shouldIgnore() {
+ final String repr = translator.translate(traversal.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(ReservedKeysVerificationStrategy.build().create());
final Traversal traversal = this.traversal.asAdmin().clone();
traversal.asAdmin().setStrategies(strategies);
traversal.asAdmin().applyStrategies();
- assertTrue(logAppender.isEmpty());
+ assertThat(repr, logAppender.isEmpty(), is(true));
}
@Test
public void shouldOnlyThrow() {
+ final String repr = translator.translate(traversal.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
final ReservedKeysVerificationStrategy.Builder builder = ReservedKeysVerificationStrategy.build().throwException();
- if (name.equals("__.addV().property('x','xyz', 'not-allowed', 'xxx')"))
+ if (repr.equals("__.addV().property(\"x\",\"xyz\",\"not-allowed\",\"xxx\")"))
builder.reservedKeys(new HashSet<>(Arrays.asList("id", "label", "not-allowed")));
strategies.addStrategies(builder.create());
final Traversal traversal = this.traversal.asAdmin().clone();
@@ -119,51 +123,53 @@ public class ReservedKeysVerificationStrategyTest {
} else {
try {
traversal.asAdmin().applyStrategies();
- fail("The strategy should not allow vertex steps with unspecified edge labels: " + this.traversal);
+ fail("The strategy should not allow vertex steps with unspecified edge labels: " + repr);
} catch (VerificationException ise) {
- assertTrue(MSG_PREDICATE.test(ise.getMessage()));
+ assertThat(repr, MSG_PREDICATE.test(ise.getMessage()));
}
}
- assertTrue(logAppender.isEmpty());
+ assertThat(repr, logAppender.isEmpty());
}
@Test
public void shouldOnlyLog() {
+ final String repr = translator.translate(traversal.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
final ReservedKeysVerificationStrategy.Builder builder = ReservedKeysVerificationStrategy.build().logWarning();
- if (name.equals("__.addV().property('x','xyz', 'not-allowed', 'xxx')"))
+ if (repr.equals("__.addV().property(\"x\",\"xyz\",\"not-allowed\",\"xxx\")"))
builder.reservedKeys(new HashSet<>(Arrays.asList("id", "label", "not-allowed")));
strategies.addStrategies(builder.create());
final Traversal traversal = this.traversal.asAdmin().clone();
traversal.asAdmin().setStrategies(strategies);
traversal.asAdmin().applyStrategies();
if (!allow) {
- assertTrue(String.format("Expected log entry not found in %s", logAppender.messages),
+ assertThat(String.format("Expected log entry not found in %s for %s", logAppender.messages, repr),
logAppender.messages().anyMatch(MSG_PREDICATE));
}
}
@Test
public void shouldThrowAndLog() {
+ final String repr = translator.translate(traversal.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
final ReservedKeysVerificationStrategy.Builder builder = ReservedKeysVerificationStrategy.build().
throwException().logWarning();
- if (name.equals("__.addV().property('x','xyz', 'not-allowed', 'xxx')"))
+ if (repr.equals("__.addV().property(\"x\",\"xyz\",\"not-allowed\",\"xxx\")"))
builder.reservedKeys(new HashSet<>(Arrays.asList("id", "label", "not-allowed")));
strategies.addStrategies(builder.create());
final Traversal traversal = this.traversal.asAdmin().clone();
traversal.asAdmin().setStrategies(strategies);
if (allow) {
traversal.asAdmin().applyStrategies();
- assertTrue(logAppender.isEmpty());
+ assertThat(repr, logAppender.isEmpty());
} else {
try {
traversal.asAdmin().applyStrategies();
- fail("The strategy should not allow vertex steps with unspecified edge labels: " + this.traversal);
+ fail("The strategy should not allow vertex steps with unspecified edge labels: " + repr);
} catch (VerificationException ise) {
- assertTrue(MSG_PREDICATE.test(ise.getMessage()));
+ assertThat(repr, MSG_PREDICATE.test(ise.getMessage()));
}
- assertTrue(String.format("Expected log entry not found in %s", logAppender.messages),
+ assertTrue(String.format("Expected log entry not found in %s for %s", logAppender.messages, repr),
logAppender.messages().anyMatch(MSG_PREDICATE));
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/StandardVerificationStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/StandardVerificationStrategyTest.java
index a3e7c07..f47d7dc 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/StandardVerificationStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/StandardVerificationStrategyTest.java
@@ -18,10 +18,12 @@
*/
package org.apache.tinkerpop.gremlin.process.traversal.strategy.verification;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.RequirementsStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.apache.tinkerpop.gremlin.util.TestSupport;
@@ -34,8 +36,9 @@ import java.util.Arrays;
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.out;
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.repeat;
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.sum;
-import static org.junit.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.fail;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
/**
* @author Marko A. Rodriguez (http://markorodriguez.com)
@@ -43,6 +46,7 @@ import static org.junit.Assert.fail;
*/
@RunWith(Parameterized.class)
public class StandardVerificationStrategyTest {
+ private static final Translator<String,String> translator = GroovyTranslator.of("__");
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> data() throws Exception {
@@ -51,27 +55,23 @@ public class StandardVerificationStrategyTest {
return Arrays.asList(new Object[][]{
// traversals that should fail verification
- {"__.repeat(out().fold().unfold()).times(2)", repeat(out().fold().unfold()).times(2), false},
- {"__.repeat(sum()).times(2)", repeat(sum()).times(2), false},
- {"__.repeat(out().count())", repeat(out().count()), false},
- {"__.V().profile()",
- __.V().profile(), true},
- {"__.V().profile('metrics').cap('metrics')",
- __.V().profile("metrics").cap("metrics"), true}
+ {repeat(out().fold().unfold()).times(2), false},
+ {repeat(sum()).times(2), false},
+ {repeat(out().count()), false},
+ {__.V().profile(), true},
+ {__.V().profile("metrics").cap("metrics"), true}
});
}
@Parameterized.Parameter(value = 0)
- public String name;
+ public Traversal.Admin traversal;
@Parameterized.Parameter(value = 1)
- public Traversal traversal;
-
- @Parameterized.Parameter(value = 2)
public Boolean legalTraversal;
@Test
public void shouldBeVerified() {
+ final String repr = translator.translate(traversal.getBytecode());
final Traversal copy = copyAndConfigureTraversal(traversal);
if (legalTraversal) {
@@ -84,9 +84,9 @@ public class StandardVerificationStrategyTest {
} else {
try {
copy.asAdmin().applyStrategies();
- fail("The strategy should not allow traversal: " + this.traversal);
- } catch (IllegalStateException ise) {
- assertTrue(true);
+ fail("The strategy should not allow traversal: " + repr);
+ } catch (Exception ise) {
+ assertThat(ise, instanceOf(VerificationException.class));
}
}
}
[tinkerpop] 02/02: TINKERPOP-1994 Used LazyBarrierStrategy to
control barrier() insertion in other strategies.
Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
spmallette pushed a commit to branch TINKERPOP-1994
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit ecd225de5b1236eb9037bd6900c5906e35b4fe31
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Thu Mar 4 18:30:01 2021 -0500
TINKERPOP-1994 Used LazyBarrierStrategy to control barrier() insertion in other strategies.
---
CHANGELOG.asciidoc | 1 +
docs/src/upgrade/release-3.4.x.asciidoc | 73 ++++++++++++++++++++++
.../strategy/optimization/LazyBarrierStrategy.java | 18 +++++-
.../optimization/PathRetractionStrategy.java | 7 ++-
.../optimization/RepeatUnrollStrategy.java | 21 +++++--
.../strategy/decoration/SubgraphStrategyTest.java | 3 +-
.../optimization/LazyBarrierStrategyTest.java | 4 +-
.../optimization/PathRetractionStrategyTest.java | 21 ++++---
.../optimization/RepeatUnrollStrategyTest.java | 45 +++++++------
9 files changed, 153 insertions(+), 40 deletions(-)
diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index e396795..54a19ea 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -31,6 +31,7 @@ image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima
* Fixed bug with Javascript Groovy `Translator` when generating Gremlin with multiple embedded traversals.
* Modified Gremlin Server `Settings` to be more extensible allowing for custom options with the YAML parser.
* Fixed `toString()` representation of `P` when string values are present in Javascript.
+* Ensured that `barrier()` additions by strategies were controlled solely by `LazyBarrierStrategy`.
[[release-3-4-10]]
=== TinkerPop 3.4.10 (Release Date: January 18, 2021)
diff --git a/docs/src/upgrade/release-3.4.x.asciidoc b/docs/src/upgrade/release-3.4.x.asciidoc
index d26adc7..f6f4883 100644
--- a/docs/src/upgrade/release-3.4.x.asciidoc
+++ b/docs/src/upgrade/release-3.4.x.asciidoc
@@ -21,6 +21,79 @@ image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima
*Avant-Gremlin Construction #3 for Theremin and Flowers*
+== TinkerPop 3.4.11
+
+*Release Date: NOT OFFICIALLY RELEASED YET*
+
+Please see the link:https://github.com/apache/tinkerpop/blob/3.4.11/CHANGELOG.asciidoc#release-3-4-11[changelog] for a
+complete list of all the modifications that are part of this release.
+
+=== Upgrading for Users
+
+==== barrier() Control
+
+Various `TraversalStrategy` implementations inject `barrier()` instances to improve traversal performance. It is often
+helpful in debugging situations or in tweaking traversal performance activities that it may be necessary to prevent
+automated `barrier()` injection. Formerly, that involved removing `LazyBarrierStrategy`, `RepeatUnrollStrategy`, and
+`PathRetractionStrategy` as all three of those strategies had the potential to add a `barrier()`. While this approach
+would work, it may be hard to recall those three strategies easily and you may be removing optimizations that might
+have been useful in addition to the `barrier()`.
+
+In 3.4.11, it is only necessary to remove `LazyBarrierStrategy`. Doing so will disable `barrier()` additions in other
+strategies and as this is the new model of execution, it can be expected to work as the approach in the future even
+if other strategies attempt to add `barrier()` steps for some reason. Note of course that this rule only applies to
+TinkerPop-enabled strategies. It is possible that provider-specific strategies could add `barrier()`-steps and thus
+still require direct removal.
+
+[source,text]
+----
+gremlin> g.V().repeat(out()).times(2).in().explain()
+==>Traversal Explanation
+====================================================================================================================================================================================
+Original Traversal [GraphStep(vertex,[]), RepeatStep([VertexStep(OUT,vertex), RepeatEndStep],until(loops(2)),emit(false)), VertexStep(IN,vertex)]
+
+ConnectiveStrategy [D] [GraphStep(vertex,[]), RepeatStep([VertexStep(OUT,vertex), RepeatEndStep],until(loops(2)),emit(false)), VertexStep(IN,vertex)]
+RepeatUnrollStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+IncidentToAdjacentStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+MatchPredicateStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+PathRetractionStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+FilterRankingStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+InlineFilterStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+AdjacentToIncidentStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+CountStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+EarlyLimitStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+LazyBarrierStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(IN,vertex)]
+TinkerGraphCountStrategy [P] [GraphStep(vertex,[]), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(IN,vertex)]
+TinkerGraphStepStrategy [P] [TinkerGraphStep(vertex,[]), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(IN,vertex)]
+ProfileStrategy [F] [TinkerGraphStep(vertex,[]), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(IN,vertex)]
+StandardVerificationStrategy [V] [TinkerGraphStep(vertex,[]), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(IN,vertex)]
+
+Final Traversal [TinkerGraphStep(vertex,[]), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(OUT,vertex), NoOpBarrierStep(2500), VertexStep(IN,vertex)]
+gremlin> g.withoutStrategies(LazyBarrierStrategy).V().repeat(out()).times(2).in().explain()
+==>Traversal Explanation
+=================================================================================================================================================================
+Original Traversal [GraphStep(vertex,[]), RepeatStep([VertexStep(OUT,vertex), RepeatEndStep],until(loops(2)),emit(false)), VertexStep(IN,vertex)]
+
+ConnectiveStrategy [D] [GraphStep(vertex,[]), RepeatStep([VertexStep(OUT,vertex), RepeatEndStep],until(loops(2)),emit(false)), VertexStep(IN,vertex)]
+RepeatUnrollStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+CountStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+EarlyLimitStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+MatchPredicateStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+FilterRankingStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+IncidentToAdjacentStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+PathRetractionStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+InlineFilterStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+AdjacentToIncidentStrategy [O] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+TinkerGraphCountStrategy [P] [GraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+TinkerGraphStepStrategy [P] [TinkerGraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+ProfileStrategy [F] [TinkerGraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+StandardVerificationStrategy [V] [TinkerGraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+
+Final Traversal [TinkerGraphStep(vertex,[]), VertexStep(OUT,vertex), VertexStep(OUT,vertex), VertexStep(IN,vertex)]
+----
+
+See: link:https://issues.apache.org/jira/browse/TINKERPOP-1994[TINKERPOP-1994]
+
== TinkerPop 3.4.10
*Release Date: January 18, 2021*
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategy.java
index b942d8f..d7cf224 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategy.java
@@ -36,6 +36,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.util.ProfileStep;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.AbstractTraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
+import org.apache.tinkerpop.gremlin.structure.Graph;
import java.util.Arrays;
import java.util.HashSet;
@@ -55,7 +56,8 @@ import java.util.Set;
*/
public final class LazyBarrierStrategy extends AbstractTraversalStrategy<TraversalStrategy.OptimizationStrategy> implements TraversalStrategy.OptimizationStrategy {
- private final boolean IS_TESTING = Boolean.valueOf(System.getProperty("is.testing", "false"));
+ public static final String BARRIER_PLACEHOLDER = Graph.Hidden.hide("gremlin.lazyBarrier.position");
+ public static final String BARRIER_COPY_LABELS = Graph.Hidden.hide("gremlin.lazyBarrier.copyLabels");
private static final LazyBarrierStrategy INSTANCE = new LazyBarrierStrategy();
private static final Set<Class<? extends OptimizationStrategy>> PRIORS = new HashSet<>(Arrays.asList(
CountStrategy.class,
@@ -65,7 +67,8 @@ public final class LazyBarrierStrategy extends AbstractTraversalStrategy<Travers
FilterRankingStrategy.class,
InlineFilterStrategy.class,
MatchPredicateStrategy.class,
- EarlyLimitStrategy.class));
+ EarlyLimitStrategy.class,
+ RepeatUnrollStrategy.class));
private static final int BIG_START_SIZE = 5;
protected static final int MAX_BARRIER_SIZE = 2500;
@@ -88,11 +91,21 @@ public final class LazyBarrierStrategy extends AbstractTraversalStrategy<Travers
for (int i = 0; i < traversal.getSteps().size(); i++) {
final Step<?, ?> step = traversal.getSteps().get(i);
+ if (step.getLabels().contains(BARRIER_PLACEHOLDER)) {
+ TraversalHelper.insertAfterStep(new NoOpBarrierStep<>(traversal, MAX_BARRIER_SIZE), step, traversal);
+ step.removeLabel(BARRIER_PLACEHOLDER);
+ if (step.getLabels().contains(BARRIER_COPY_LABELS)) {
+ step.removeLabel(BARRIER_COPY_LABELS);
+ TraversalHelper.copyLabels(step, step.getNextStep(), true);
+ }
+ }
+
if (step instanceof PathProcessor) {
final Set<String> keepLabels = ((PathProcessor) step).getKeepLabels();
if (null != keepLabels && keepLabels.isEmpty()) // if no more path data, then start barrier'ing again
labeledPath = false;
}
+
if (step instanceof FlatMapStep &&
!(step instanceof VertexStep && ((VertexStep) step).returnsEdge()) ||
(step instanceof GraphStep &&
@@ -115,6 +128,7 @@ public final class LazyBarrierStrategy extends AbstractTraversalStrategy<Travers
} else
foundFlatMap = true;
}
+
if (!step.getLabels().isEmpty())
labeledPath = true;
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategy.java
index d370c38..e6ba8f3 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategy.java
@@ -92,6 +92,8 @@ public final class PathRetractionStrategy extends AbstractTraversalStrategy<Trav
return;
}
+ final boolean lazyBarrierStrategyInstalled = traversal.getStrategies().getStrategy(LazyBarrierStrategy.class).isPresent();
+
final boolean onGraphComputer = TraversalHelper.onGraphComputer(traversal);
final Set<String> foundLabels = new HashSet<>();
final Set<String> keepLabels = new HashSet<>();
@@ -131,8 +133,9 @@ public final class PathRetractionStrategy extends AbstractTraversalStrategy<Trav
pathProcessor.getKeepLabels().addAll(((MatchStep) currentStep.getTraversal().getParent().asStep()).getMatchEndLabels());
}
- // OLTP barrier optimization that will try and bulk traversers after a path processor step to thin the stream
- if (!onGraphComputer &&
+ // LazyBarrierStrategy should control all barrier() additions. OLTP barrier optimization that will try
+ // and bulk traversers after a path processor step to thin the stream
+ if (lazyBarrierStrategyInstalled && !onGraphComputer &&
!(currentStep instanceof MatchStep) &&
!(currentStep instanceof Barrier) &&
!(currentStep.getNextStep() instanceof Barrier) &&
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategy.java
index 924b4d4..2b08f17 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategy.java
@@ -20,6 +20,7 @@
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
import org.apache.tinkerpop.gremlin.process.traversal.Scope;
+import org.apache.tinkerpop.gremlin.process.traversal.Step;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.lambda.LoopTraversal;
@@ -66,6 +67,8 @@ public final class RepeatUnrollStrategy extends AbstractTraversalStrategy<Traver
if (TraversalHelper.onGraphComputer(traversal))
return;
+ final boolean lazyBarrierStrategyInstalled = traversal.getStrategies().getStrategy(LazyBarrierStrategy.class).isPresent();
+
for (int i = 0; i < traversal.getSteps().size(); i++) {
if (traversal.getSteps().get(i) instanceof RepeatStep) {
final RepeatStep<?> repeatStep = (RepeatStep) traversal.getSteps().get(i);
@@ -82,16 +85,24 @@ public final class RepeatUnrollStrategy extends AbstractTraversalStrategy<Traver
for (int j = 0; j < loops; j++) {
TraversalHelper.insertTraversal(insertIndex, repeatTraversal.clone(), traversal);
insertIndex = insertIndex + repeatLength;
- if ((j != (loops - 1) || !(traversal.getSteps().get(insertIndex).getNextStep() instanceof Barrier)) // only add a final NoOpBarrier is subsequent step is not a barrier
- && !(traversal.getSteps().get(insertIndex) instanceof NoOpBarrierStep) // Don't add a barrier if this step is a barrier (prevents nested repeat adding the barrier multiple times)
- ) {
- traversal.addStep(++insertIndex, new NoOpBarrierStep<>(traversal, MAX_BARRIER_SIZE));
+
+ // the addition of barriers is determined by the existence of LazyBarrierStrategy
+ if (lazyBarrierStrategyInstalled) {
+ // only add a final NoOpBarrier is subsequent step is not a barrier
+ // Don't add a barrier if this step is a barrier (prevents nested repeat adding the barrier multiple times)
+ Step step = traversal.getSteps().get(insertIndex);
+ if ((j != (loops - 1) || !(step.getNextStep() instanceof Barrier)) && !(step instanceof NoOpBarrierStep)) {
+ traversal.addStep(++insertIndex, new NoOpBarrierStep<>(traversal, MAX_BARRIER_SIZE));
+ }
}
}
+
// label last step if repeat() was labeled
if (!repeatStep.getLabels().isEmpty())
TraversalHelper.copyLabels(repeatStep, traversal.getSteps().get(insertIndex), false);
- traversal.removeStep(i); // remove the RepeatStep
+
+ // remove the RepeatStep
+ traversal.removeStep(i);
}
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
index bb51103..5f6c82d 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
@@ -110,8 +110,7 @@ public class SubgraphStrategyTest {
strategy.apply(traversal);
final List<TraversalFilterStep> steps = TraversalHelper.getStepsOfClass(TraversalFilterStep.class, traversal);
- System.out.println(repr + "+" + steps.stream().map(s -> s.getFilterTraversal().toString()).collect(Collectors.joining()));
- assertEquals(repr + ":" + traversal.toString(), expectedInsertedSteps, steps.size());
+ assertEquals(repr, expectedInsertedSteps, steps.size());
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategyTest.java
index 332a38e..b6f461c 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/LazyBarrierStrategyTest.java
@@ -19,10 +19,12 @@
package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -47,7 +49,7 @@ public class LazyBarrierStrategyTest {
}
@Parameterized.Parameter(value = 0)
- public Traversal original;
+ public Traversal.Admin original;
@Parameterized.Parameter(value = 1)
public Traversal optimized;
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java
index 1a9ae43..d6130e9 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java
@@ -23,11 +23,13 @@ import org.apache.tinkerpop.gremlin.process.traversal.Order;
import org.apache.tinkerpop.gremlin.process.traversal.P;
import org.apache.tinkerpop.gremlin.process.traversal.Scope;
import org.apache.tinkerpop.gremlin.process.traversal.Step;
+import org.apache.tinkerpop.gremlin.process.traversal.Translator;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.process.traversal.step.PathProcessor;
import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
+import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
@@ -68,11 +70,14 @@ import static org.mockito.Mockito.when;
public class PathRetractionStrategyTest {
private static final Translator<String,String> translator = GroovyTranslator.of("__");
+ /**
+ * Always need LazyBarrierStrategy because it will trigger barrier() additions in PathRetractionStrategy.
+ */
private final List<TraversalStrategies> strategies = Arrays.asList(
- new DefaultTraversalStrategies().addStrategies(PathRetractionStrategy.instance()),
- new DefaultTraversalStrategies().addStrategies(PathRetractionStrategy.instance(), PathProcessorStrategy.instance()),
- new DefaultTraversalStrategies().addStrategies(PathRetractionStrategy.instance(), PathProcessorStrategy.instance(), MatchPredicateStrategy.instance()),
- new DefaultTraversalStrategies().addStrategies(PathRetractionStrategy.instance(), PathProcessorStrategy.instance(), MatchPredicateStrategy.instance(), RepeatUnrollStrategy.instance()));
+ new DefaultTraversalStrategies().addStrategies(LazyBarrierStrategy.instance(), PathRetractionStrategy.instance()),
+ new DefaultTraversalStrategies().addStrategies(LazyBarrierStrategy.instance(), PathRetractionStrategy.instance(), PathProcessorStrategy.instance()),
+ new DefaultTraversalStrategies().addStrategies(LazyBarrierStrategy.instance(), PathRetractionStrategy.instance(), PathProcessorStrategy.instance(), MatchPredicateStrategy.instance()),
+ new DefaultTraversalStrategies().addStrategies(LazyBarrierStrategy.instance(), PathRetractionStrategy.instance(), PathProcessorStrategy.instance(), MatchPredicateStrategy.instance(), RepeatUnrollStrategy.instance()));
@Parameterized.Parameter(value = 0)
public Traversal.Admin original;
@@ -161,16 +166,16 @@ public class PathRetractionStrategyTest {
{__.V().as("a").repeat(out().where(neq("a"))).emit().select("a").values("test"), "[[[a]], []]", null},
// given the way this test harness is structured, I have to manual test for RepeatUnrollStrategy (and it works) TODO: add more test parameters
// {__.V().as("a").repeat(__.out().where(neq("a"))).times(3).select("a").values("test"), Arrays.asList(Collections.singleton("a"), Collections.singleton("a"), Collections.singleton("a"), Collections.emptySet())}
- {__.V().as("a").out().as("b").select("a").out().out(), "[[]]", __.V().as("a").out().as("b").select("a").barrier(MAX_BARRIER_SIZE).out().out()},
+ {__.V().as("a").out().as("b").select("a").out().out(), "[[]]", __.V().as("a").out().as("b").select("a").barrier(PathRetractionStrategy.MAX_BARRIER_SIZE).out().barrier(LazyBarrierStrategy.MAX_BARRIER_SIZE).out()},
{__.V().as("a").out().as("b").select("a").count(), "[[]]", __.V().as("a").out().as("b").select("a").count()},
{__.V().as("a").out().as("b").select("a").barrier().count(), "[[]]", __.V().as("a").out().as("b").select("a").barrier().count()},
{__.V().as("a").out().as("b").dedup("a", "b").out(), "[[]]", __.V().as("a").out().as("b").dedup("a", "b").out()},
{__.V().as("a").out().as("b").match(as("a").out().as("b")), "[[a, b]]", __.V().as("a").out().as("b").match(as("a").out().as("b"))},
{__.V().as("a").out().as("b").match(as("a").out().as("b")).select("a"), "[[a], []]", __.V().as("a").out().as("b").match(as("a").out().as("b")).select("a")},
- {__.V().as("a").out().as("b").match(as("a").out().as("b")).select("a").out().dedup("a"), "[[a], [a], []]", __.V().as("a").out().as("b").match(as("a").out().as("b")).select("a").barrier(MAX_BARRIER_SIZE).out().dedup("a")},
- {__.V().as("a").out().as("b").where(P.gt("a")).out().out(), "[[]]", __.V().as("a").out().as("b").where(P.gt("a")).barrier(MAX_BARRIER_SIZE).out().out()},
+ {__.V().as("a").out().as("b").match(as("a").out().as("b")).select("a").out().dedup("a"), "[[a], [a], []]", __.V().as("a").out().as("b").match(as("a").out().as("b")).select("a").barrier(PathRetractionStrategy.MAX_BARRIER_SIZE).out().dedup("a")},
+ {__.V().as("a").out().as("b").where(P.gt("a")).out().out(), "[[]]", __.V().as("a").out().as("b").where(P.gt("a")).barrier(PathRetractionStrategy.MAX_BARRIER_SIZE).out().barrier(LazyBarrierStrategy.MAX_BARRIER_SIZE).out()},
{__.V().as("a").out().as("b").where(P.gt("a")).count(), "[[]]", __.V().as("a").out().as("b").where(P.gt("a")).count()},
- {__.V().as("a").out().as("b").select("a").as("c").where(P.gt("b")).out(), "[[b], []]", __.V().as("a").out().as("b").select("a").as("c").barrier(MAX_BARRIER_SIZE).where(P.gt("b")).barrier(MAX_BARRIER_SIZE).out()},
+ {__.V().as("a").out().as("b").select("a").as("c").where(P.gt("b")).out(), "[[b], []]", __.V().as("a").out().as("b").select("a").as("c").barrier(PathRetractionStrategy.MAX_BARRIER_SIZE).where(P.gt("b")).barrier(PathRetractionStrategy.MAX_BARRIER_SIZE).out()},
{__.V().select("c").map(select("c").map(select("c"))).select("c"), "[[c], [[c], [[c]]], []]", null},
{__.V().select("c").map(select("c").map(select("c"))).select("b"), "[[b, c], [[b, c], [[b]]], []]", null},
{__.V().as("a").out().as("b").select("a").select("b").union(
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java
index 1ebbd3f..4ad8d89 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java
@@ -62,6 +62,11 @@ public class RepeatUnrollStrategyTest {
final String repr = translator.translate(original.getBytecode());
final TraversalStrategies strategies = new DefaultTraversalStrategies();
strategies.addStrategies(RepeatUnrollStrategy.instance());
+
+ // adding LazyBarrierStrategy as RepeatUnrollStrategy adds barriers and the existence of this strategy
+ // triggers those additions. if they are not there they will not be present and most of these assertions
+ // assume this strategy present
+ strategies.addStrategies(LazyBarrierStrategy.instance());
for (final TraversalStrategy strategy : this.otherStrategies) {
strategies.addStrategies(strategy);
}
@@ -72,37 +77,37 @@ public class RepeatUnrollStrategyTest {
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> generateTestParameters() {
- final int maxBarrierSize = RepeatUnrollStrategy.MAX_BARRIER_SIZE;
+ final int repeatBarrierSize = RepeatUnrollStrategy.MAX_BARRIER_SIZE;
+ final int lazyBarrierSize = LazyBarrierStrategy.MAX_BARRIER_SIZE;
final Predicate<Traverser<Vertex>> predicate = t -> t.loops() > 5;
return Arrays.asList(new Object[][]{
{__.repeat(out()).times(0), __.repeat(out()).times(0), Collections.emptyList()},
{__.<Vertex>times(0).repeat(out()), __.<Vertex>times(0).repeat(out()), Collections.emptyList()},
{__.identity(), __.identity(), Collections.emptyList()},
- {out().as("a").in().repeat(__.outE("created").bothV()).times(2).in(), out().as("a").in().outE("created").bothV().barrier(maxBarrierSize).outE("created").bothV().barrier(maxBarrierSize).in(), Collections.emptyList()},
- {out().repeat(__.outE("created").bothV()).times(1).in(), out().outE("created").bothV().barrier(maxBarrierSize).in(), Collections.emptyList()},
- {__.repeat(__.outE("created").bothV()).times(1).in(), __.outE("created").bothV().barrier(maxBarrierSize).in(), Collections.emptyList()},
- {__.repeat(out()).times(2).as("x").repeat(__.in().as("b")).times(3), out().barrier(maxBarrierSize).out().barrier(maxBarrierSize).as("x").in().as("b").barrier(maxBarrierSize).in().as("b").barrier(maxBarrierSize).in().as("b").barrier(maxBarrierSize), Collections.emptyList()},
- {__.repeat(__.outE("created").inV()).times(2), __.outE("created").inV().barrier(maxBarrierSize).outE("created").inV().barrier(maxBarrierSize), Collections.emptyList()},
- {__.repeat(out()).times(3), out().barrier(maxBarrierSize).out().barrier(maxBarrierSize).out().barrier(maxBarrierSize), Collections.emptyList()},
- {__.repeat(__.local(__.select("a").out("knows"))).times(2), __.local(__.select("a").out("knows")).barrier(maxBarrierSize).local(__.select("a").out("knows")).barrier(maxBarrierSize), Collections.emptyList()},
- {__.<Vertex>times(2).repeat(out()), out().barrier(maxBarrierSize).out().barrier(maxBarrierSize), Collections.emptyList()},
- {__.<Vertex>out().times(2).repeat(out().as("a")).as("x"), out().out().as("a").barrier(maxBarrierSize).out().as("a").barrier(maxBarrierSize).as("x"), Collections.emptyList()},
+ {out().as("a").in().repeat(__.outE("created").bothV()).times(2).in(), out().as("a").in().outE("created").bothV().barrier(repeatBarrierSize).outE("created").bothV().barrier(repeatBarrierSize).in(), Collections.emptyList()},
+ {out().repeat(__.outE("created").bothV()).times(1).in(), out().outE("created").bothV().barrier(repeatBarrierSize).in(), Collections.emptyList()},
+ {__.repeat(__.outE("created").bothV()).times(1).in(), __.outE("created").bothV().barrier(repeatBarrierSize).in(), Collections.emptyList()},
+ {__.repeat(out()).times(2).as("x").repeat(__.in().as("b")).times(3), out().barrier(repeatBarrierSize).out().barrier(repeatBarrierSize).as("x").in().as("b").barrier(repeatBarrierSize).in().as("b").barrier(repeatBarrierSize).in().as("b").barrier(repeatBarrierSize), Collections.emptyList()},
+ {__.repeat(__.outE("created").inV()).times(2), __.outE("created").inV().barrier(repeatBarrierSize).outE("created").inV().barrier(repeatBarrierSize), Collections.emptyList()},
+ {__.repeat(out()).times(3), out().barrier(repeatBarrierSize).out().barrier(repeatBarrierSize).out().barrier(repeatBarrierSize), Collections.emptyList()},
+ {__.repeat(__.local(__.select("a").out("knows"))).times(2), __.local(__.select("a").out("knows")).barrier(repeatBarrierSize).local(__.select("a").out("knows")).barrier(repeatBarrierSize), Collections.emptyList()},
+ {__.<Vertex>times(2).repeat(out()), out().barrier(repeatBarrierSize).out().barrier(repeatBarrierSize), Collections.emptyList()},
+ {__.<Vertex>out().times(2).repeat(out().as("a")).as("x"), out().out().as("a").barrier(repeatBarrierSize).out().as("a").barrier(repeatBarrierSize).as("x"), Collections.emptyList()},
{__.repeat(out()).emit().times(2), __.repeat(out()).emit().times(2), Collections.emptyList()},
{__.repeat(out()).until(predicate), __.repeat(out()).until(predicate), Collections.emptyList()},
- {__.repeat(out()).until(predicate).repeat(out()).times(2), __.repeat(out()).until(predicate).out().barrier(maxBarrierSize).out().barrier(maxBarrierSize), Collections.emptyList()},
- {__.repeat(__.union(__.both(), __.identity())).times(2).out(), __.union(__.both(), __.identity()).barrier(maxBarrierSize).union(__.both(), __.identity()).barrier(maxBarrierSize).out(), Collections.emptyList()},
- {__.in().repeat(out("knows")).times(3).as("a").count().is(0), __.in().out("knows").barrier(maxBarrierSize).out("knows").barrier(maxBarrierSize).out("knows").as("a").count().is(0), Collections.emptyList()},
+ {__.repeat(out()).until(predicate).repeat(out()).times(2), __.repeat(out()).until(predicate).out().barrier(repeatBarrierSize).out().barrier(repeatBarrierSize), Collections.emptyList()},
+ {__.repeat(__.union(__.both(), __.identity())).times(2).out(), __.union(__.both(), __.identity()).barrier(repeatBarrierSize).union(__.both(), __.identity()).barrier(repeatBarrierSize).out(), Collections.emptyList()},
+ {__.in().repeat(out("knows")).times(3).as("a").count().is(0), __.in().out("knows").barrier(repeatBarrierSize).out("knows").barrier(repeatBarrierSize).out("knows").as("a").count().is(0), Collections.emptyList()},
//
- {__.repeat(__.outE().inV()).times(2), __.outE().inV().barrier(maxBarrierSize).outE().inV().barrier(maxBarrierSize), Collections.emptyList()},
- {__.repeat(__.outE().filter(path()).inV()).times(2), __.outE().filter(path()).inV().barrier(maxBarrierSize).outE().filter(path()).inV().barrier(maxBarrierSize), Collections.singletonList(IncidentToAdjacentStrategy.instance())},
- {__.repeat(__.outE().inV()).times(2), __.out().barrier(maxBarrierSize).out().barrier(maxBarrierSize), Collections.singletonList(IncidentToAdjacentStrategy.instance())},
+ {__.repeat(__.outE().inV()).times(2), __.outE().inV().barrier(repeatBarrierSize).outE().inV().barrier(repeatBarrierSize), Collections.emptyList()},
+ {__.repeat(__.outE().filter(path()).inV()).times(2), __.outE().filter(path()).inV().barrier(repeatBarrierSize).outE().filter(path()).inV().barrier(repeatBarrierSize), Collections.singletonList(IncidentToAdjacentStrategy.instance())},
+ {__.repeat(__.outE().inV()).times(2), __.out().barrier(repeatBarrierSize).out().barrier(repeatBarrierSize), Collections.singletonList(IncidentToAdjacentStrategy.instance())},
// Nested Loop tests
- {__.repeat(out().repeat(out()).times(0)).times(1), __.out().repeat(out()).times(0).barrier(maxBarrierSize), Collections.emptyList()},
- {__.repeat(out().repeat(out()).times(1)).times(1), __.out().out().barrier(maxBarrierSize), Collections.emptyList()},
+ {__.repeat(out().repeat(out()).times(0)).times(1), __.out().repeat(out()).times(0).barrier(repeatBarrierSize), Collections.emptyList()},
+ {__.repeat(out().repeat(out()).times(1)).times(1), __.out().out().barrier(repeatBarrierSize), Collections.emptyList()},
{__.repeat(out()).until(__.repeat(out()).until(predicate)), __.repeat(out()).until(__.repeat(out()).until(predicate)), Collections.emptyList()},
- {__.repeat(__.repeat(out()).times(2)).until(predicate), __.repeat(__.out().barrier(maxBarrierSize).out().barrier(maxBarrierSize)).until(predicate), Collections.emptyList()},
+ {__.repeat(__.repeat(out()).times(2)).until(predicate), __.repeat(__.out().barrier(repeatBarrierSize).out().barrier(repeatBarrierSize)).until(predicate), Collections.emptyList()},
{__.repeat(__.repeat(out("created")).until(__.has("name", "ripple"))), __.repeat(__.repeat(out("created")).until(__.has("name", "ripple"))), Collections.emptyList()},
-
});
}
}