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:15 UTC
[tinkerpop] 01/02: TINKERPOP-1994 Refactored tests to use Translator
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));
}
}
}