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 2025/04/22 11:32:24 UTC

(tinkerpop) branch TINKERPOP-3136 updated (91611da990 -> 6b3ca55346)

This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a change to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git


    omit 91611da990 address feedback
    omit 0fa217d311 Deprecated ProcessComputerSuite and ProcessStandardSuite
    omit cb4012a373 Remvoed RemoteOnly tag from gherkin
    omit 942c227ed6 Added tree() tests to gherkin. Added prettyPrint() to Tree.
    omit abdd9d53d1 f
    omit b0cde9b74d f
    omit 55df4fd2c4 Centralized graph computer test tag set
    omit 1f97eecf28 TINKERPOP-3136 Added subgraph() tests to gherkin
    omit 72368aa5ff f ComplexTest changes
    omit 371c9c4893 TINKERPOP-3136 Setup embedded test suite
    omit 8e18b52b90 TINKERPOP-3136 Deprecated the "limited" test suites
     add a0c5851521 Backport OffsetDateTime changes from 4.0 (#3090)
     add db8239f1df TINKERPOP-3155 Fixed typo for Operator.addAll to check that all args are collections instead of just one. (#3095)
     add 607becae1a Merge branch '3.7-dev' into 3.8-dev
     add 38ed5e7cd8 Update feature tests to assert traversal construction exceptions. (#3094)
     new 678b54d7b6 TINKERPOP-3136 Deprecated the "limited" test suites
     new 0852cad54c TINKERPOP-3136 Setup embedded test suite
     new 7c9fa7b491 f ComplexTest changes
     new 6d0b744a66 TINKERPOP-3136 Added subgraph() tests to gherkin
     new 04bb293ee8 Centralized graph computer test tag set
     new f9a749ce30 f
     new 2aa85ac875 f
     new 8609566681 Added tree() tests to gherkin. Added prettyPrint() to Tree.
     new 7620060b11 Remvoed RemoteOnly tag from gherkin
     new b33965337e Deprecated ProcessComputerSuite and ProcessStandardSuite
     new 6b3ca55346 address feedback

This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version.  This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:

 * -- * -- B -- O -- O -- O   (91611da990)
            \
             N -- N -- N   refs/heads/TINKERPOP-3136 (6b3ca55346)

You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.

Any revisions marked "omit" are not gone; other references still
refer to them.  Any revisions marked "discard" are gone forever.

The 11 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 CHANGELOG.asciidoc                                 |  4 ++
 docs/src/reference/the-traversal.asciidoc          |  7 +-
 docs/src/upgrade/release-3.8.x.asciidoc            | 25 +++++++
 .../tinkerpop/gremlin/jsr223/CoreImports.java      |  1 +
 .../tinkerpop/gremlin/jsr223/JavaTranslator.java   | 14 +++-
 .../gremlin/language/grammar/ArgumentVisitor.java  |  7 +-
 .../language/grammar/GenericLiteralVisitor.java    |  6 +-
 .../translator/AnonymizedTranslatorVisitor.java    |  4 +-
 .../translator/DotNetTranslateVisitor.java         | 10 +--
 .../language/translator/GoTranslateVisitor.java    | 15 +++-
 .../language/translator/JavaTranslateVisitor.java  | 10 +--
 .../translator/JavascriptTranslateVisitor.java     | 11 +--
 .../translator/PythonTranslateVisitor.java         |  8 ++-
 .../gremlin/process/traversal/Operator.java        |  2 +-
 .../gremlin/process/traversal/Translator.java      |  9 +++
 .../traversal/dsl/graph/GraphTraversal.java        | 28 ++++++--
 .../gremlin/process/traversal/dsl/graph/__.java    | 18 +++--
 .../process/traversal/step/map/AsDateStep.java     | 29 ++++----
 .../process/traversal/step/map/DateAddStep.java    | 60 ++++++++++------
 .../process/traversal/step/map/DateDiffStep.java   | 61 +++++++++++++----
 .../translator/AnonymizingTypeTranslator.java      |  8 +++
 .../traversal/translator/DotNetTranslator.java     |  6 ++
 .../traversal/translator/GolangTranslator.java     | 14 ++++
 .../traversal/translator/GroovyTranslator.java     | 11 +++
 .../traversal/translator/JavascriptTranslator.java |  6 ++
 .../traversal/translator/PythonTranslator.java     |  8 +++
 .../tinkerpop/gremlin/util/DatetimeHelper.java     | 32 ++++-----
 .../grammar/GeneralLiteralVisitorTest.java         | 37 +++++-----
 .../language/translator/GremlinTranslatorTest.java | 23 +++++--
 .../process/traversal/OperatorExceptionTest.java   |  6 ++
 .../process/traversal/step/map/AsDateStepTest.java | 26 +++++--
 .../traversal/step/map/DateAddStepTest.java        | 62 ++++++++++++++---
 .../traversal/step/map/DateDiffStepTest.java       | 62 ++++++++++++++---
 .../translator/AnonymizingTypeTranslatorTest.java  |  9 +++
 .../traversal/translator/DotNetTranslatorTest.java |  9 +--
 .../traversal/translator/GolangTranslatorTest.java | 15 ++++
 .../traversal/translator/GroovyTranslatorTest.java | 15 ++--
 .../translator/JavascriptTranslatorTest.java       |  9 +--
 .../traversal/translator/PythonTranslatorTest.java | 15 ++++
 .../tinkerpop/gremlin/util/DatetimeHelperTest.java | 54 +++++++--------
 .../Structure/IO/GraphBinary/DataType.cs           |  1 +
 .../IO/GraphBinary/TypeSerializerRegistry.cs       |  7 +-
 ...meOffsetSerializer.cs => DateTimeSerializer.cs} | 10 +--
 .../GraphBinary/Types/OffsetDateTimeSerializer.cs  | 80 ++++++++++++++++++++++
 .../Structure/IO/GraphSON/GraphSONReader.cs        |  1 +
 .../Structure/IO/GraphSON/GraphSONWriter.cs        |  2 +-
 ...serializer.cs => OffsetDateTimeDeserializer.cs} |  9 ++-
 ...teSerializer.cs => OffsetDateTimeSerializer.cs} |  4 +-
 .../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs | 21 +++---
 .../Structure/IO/GraphSON/GraphSONWriterTests.cs   |  2 +-
 gremlin-go/driver/cucumber/cucumberSteps_test.go   |  7 +-
 gremlin-go/driver/cucumber/gremlin.go              | 21 +++---
 gremlin-go/driver/graphBinary.go                   | 73 +++++++++++++++++++-
 gremlin-go/driver/graphBinary_test.go              | 33 +++++++++
 gremlin-go/driver/serializer.go                    |  8 ++-
 gremlin-go/driver/traversal.go                     |  6 +-
 .../lib/structure/io/binary/GraphBinary.js         |  1 +
 .../structure/io/binary/internals/AnySerializer.js |  1 +
 ...teSerializer.js => OffsetDateTimeSerializer.js} | 64 ++++++++++++++---
 .../lib/structure/io/graph-serializer.js           |  3 +-
 .../lib/structure/io/type-serializers.js           | 13 +++-
 .../gremlin-javascript/test/cucumber/gremlin.js    | 21 +++---
 .../test/unit/graphbinary/AnySerializer-test.js    | 16 ++++-
 .../gremlin-javascript/test/unit/graphson-test.js  |  4 +-
 .../gremlin_python/structure/io/graphbinaryV1.py   | 40 ++++++++++-
 .../gremlin_python/structure/io/graphsonV2d0.py    | 19 ++++-
 .../gremlin_python/structure/io/graphsonV3d0.py    | 19 ++++-
 .../src/main/python/radish/feature_steps.py        |  2 +-
 gremlin-python/src/main/python/radish/gremlin.py   | 21 +++---
 .../main/python/tests/process/test_traversal.py    |  3 +-
 .../tests/structure/io/test_functionalityio.py     | 14 ++++
 .../tests/structure/io/test_graphbinaryV1.py       | 32 +++++++--
 .../python/tests/structure/io/test_graphsonV2d0.py | 24 ++++++-
 .../python/tests/structure/io/test_graphsonV3d0.py | 24 ++++++-
 .../server/GremlinServerHttpIntegrateTest.java     |  2 +-
 .../tinkerpop/gremlin/features/StepDefinition.java |  8 +++
 .../process/traversal/step/OrderabilityTest.java   | 13 ++--
 .../gremlin/test/features/filter/Range.feature     | 19 +++++
 .../gremlin/test/features/map/AsDate.feature       | 12 ++++
 .../util/ser/binary/types/sample/SamplePerson.java |  8 +--
 .../types/sample/SamplePersonSerializer.java       |  4 +-
 .../types/sample/SamplePersonSerializerTest.java   |  5 +-
 82 files changed, 1115 insertions(+), 318 deletions(-)
 rename gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphBinary/Types/{DateTimeOffsetSerializer.cs => DateTimeSerializer.cs} (84%)
 create mode 100644 gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphBinary/Types/OffsetDateTimeSerializer.cs
 copy gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphSON/{MergeDeserializer.cs => OffsetDateTimeDeserializer.cs} (79%)
 rename gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphSON/{DateSerializer.cs => OffsetDateTimeSerializer.cs} (87%)
 copy gremlin-javascript/src/main/javascript/gremlin-javascript/lib/structure/io/binary/internals/{DateSerializer.js => OffsetDateTimeSerializer.js} (55%)


(tinkerpop) 06/11: f

Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit f9a749ce30d91a949306b44a57e66b603595bba9
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Wed Apr 16 08:20:54 2025 -0400

    f
---
 docs/src/dev/provider/index.asciidoc                               | 7 +++++++
 neo4j-gremlin/pom.xml                                              | 5 +++++
 .../org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java  | 4 +++-
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/docs/src/dev/provider/index.asciidoc b/docs/src/dev/provider/index.asciidoc
index 1e49614a26..ccf83a5b95 100644
--- a/docs/src/dev/provider/index.asciidoc
+++ b/docs/src/dev/provider/index.asciidoc
@@ -629,11 +629,18 @@ image:gremlin-edumacated.png[width=225]
 
 [source,xml]
 ----
+<!-- gremlin-tests contains test classes and gherkin tests -->
 <dependency>
   <groupId>org.apache.tinkerpop</groupId>
   <artifactId>gremlin-test</artifactId>
   <version>x.y.z</version>
 </dependency>
+<!-- TinkerGraph is required for validating subgraph() tests -->
+<dependency>
+  <groupId>org.apache.tinkerpop</groupId>
+  <artifactId>tinkergraph-gremlin</artifactId>
+  <version>x.y.z</version>
+</dependency>
 ----
 
 TinkerPop provides `gremlin-test`, a technology test kit, that helps validate provider implementations. There is a
diff --git a/neo4j-gremlin/pom.xml b/neo4j-gremlin/pom.xml
index ab8b900342..c0e7091dc6 100644
--- a/neo4j-gremlin/pom.xml
+++ b/neo4j-gremlin/pom.xml
@@ -50,6 +50,11 @@ limitations under the License.
                 </exclusion>
             </exclusions>
         </dependency>
+        <dependency>
+            <groupId>org.apache.tinkerpop</groupId>
+            <artifactId>tinkergraph-gremlin</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>com.google.inject</groupId>
             <artifactId>guice</artifactId>
diff --git a/neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java b/neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java
index b02a9fb7e0..06cd60bfb3 100644
--- a/neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java
+++ b/neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java
@@ -50,7 +50,9 @@ import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @MultiProperties and not @MetaProperties and not @GraphComputerOnly and not @AllowNullPropertyValues and not @UserSuppliedVertexPropertyIds and not @UserSuppliedEdgeIds and not @UserSuppliedVertexIds and not @TinkerServiceRegistry",
+        tags = "not @RemoteOnly and not @MultiProperties and not @MetaProperties and not @GraphComputerOnly and " +
+               "not @AllowNullPropertyValues and not @UserSuppliedVertexPropertyIds and not @UserSuppliedEdgeIds and " +
+               "not @UserSuppliedVertexIds and not @TinkerServiceRegistry and not @InsertionOrderingRequired",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = GuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },


(tinkerpop) 03/11: f ComplexTest changes

Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 7c9fa7b491ed80322ce1e93c0af1966dab54e7df
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Sat Apr 12 10:34:33 2025 -0400

    f ComplexTest changes
---
 .../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs |  3 +-
 gremlin-go/driver/cucumber/gremlin.go              |  3 +-
 .../gremlin-javascript/test/cucumber/gremlin.js    |  3 +-
 gremlin-python/src/main/python/radish/gremlin.py   |  3 +-
 .../process/ProcessEmbeddedComputerSuite.java      |  1 -
 .../process/ProcessEmbeddedStandardSuite.java      |  1 -
 .../test/features/integrated/Miscellaneous.feature | 12 --------
 .../gremlin/test/features/integrated/Paths.feature | 32 ++++++++++++++++++-
 .../features/integrated/Recommendation.feature     | 36 +++++++++++++++++++---
 .../TinkerTransactionGraphFeatureTest.java         |  2 +-
 10 files changed, 71 insertions(+), 25 deletions(-)

diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
index e1180b9479..aec6a2f218 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
@@ -443,7 +443,6 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_withoutStrategiesXMatchPredicateStrategyX_V_matchXa_created_lop_b__b_0created_29_cX_whereXc_repeatXoutX_timesX2XX_selectXa_b_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(MatchPredicateStrategy)).V().Match<object>(__.As("a").Out("created").Has("name", "lop").As("b"), __.As("b").In("created").Has("age", 29).As("c")).Where(__.As("c").Repeat(__.Out()).Times(2)).Select<object>("a", "b", "c")}}, 
                {"g_withStrategiesXMessagePassingReductionStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new MessagePassingReductionStrategy()).V()}}, 
                {"g_withoutStrategiesXMessagePassingReductionStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(MessagePassingReductionStrategy)).V()}}, 
-               {"g_withoutStrategiesXCountStrategyX_V_count", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(CountStrategy)).V().Count()}}, 
                {"g_V_coworker", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").Filter(__.OutE("created")).Aggregate("p").As("p1").Values<object>("name").As("p1n").Select<object>("p").Unfold<object>().Where(P.Neq("p1")).As("p2").Values<object>("name").As("p2n").Select<object>("p2").Out("created").Choose<object>(__.In("created").Where(P.Eq("p1")), __.Values<object>("name"), __.Constant<object>(p["xx1"])).Group<object, object> [...]
                {"g_V_coworker_with_midV", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").Filter(__.OutE("created")).As("p1").V().HasLabel("person").Where(P.Neq("p1")).Filter(__.OutE("created")).As("p2").Map<object>(__.Out("created").Where(__.In("created").As("p1")).Values<object>("name").Fold()).Group<object, object>().By(__.Select<object>("p1").By("name")).By(__.Group<object, object>().By(__.Select<object>("p2").By("name") [...]
                {"g_withStrategiesXOptionsStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new OptionsStrategy()).V()}}, 
@@ -480,6 +479,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_withStrategiesXPathRetractionStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new PathRetractionStrategy()).V()}}, 
                {"g_withoutStrategiesXPathRetractionStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(PathRetractionStrategy)).V()}}, 
                {"g_V_shortestpath", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("v").Both().As("v").Project<object>("src", "tgt", "p").By(__.Select<object>(Pop.First, "v")).By(__.Select<object>(Pop.Last, "v")).By(__.Select<object>(Pop.All, "v")).As("triple").Group("x").By(__.Select<object>("src", "tgt")).By(__.Select<object>("p").Fold()).Select<object>("tgt").Barrier().Repeat(__.Both().As("v").Project<object>("src", "tgt", "p").By(__.Se [...]
+               {"g_V_playlist_paths", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new SeedStrategy(seed: 99999)).V().Has("name", "Bob_Dylan").In("sungBy").As("a").Repeat(__.Out().Order().By(Order.Shuffle).SimplePath().From("a")).Until(__.Out("writtenBy").Has("name", "Johnny_Cash")).Limit<object>(1).As("b").Repeat(__.Out().Order().By(Order.Shuffle).As("c").SimplePath().From("b").To("c")).Until(__.Out("sungBy").Has("name", "Gratef [...]
                {"g_withStrategiesXProductiveByStrategyX_V_group_byXageX_byXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new ProductiveByStrategy()).V().Group<object, object>().By("age").By("name")}}, 
                {"g_withoutStrategiesXProductiveByStrategyX_V_group_byXageX_byXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(ProductiveByStrategy)).V().Group<object, object>().By("age").By("name")}}, 
                {"g_withStrategiesXProfileStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new ProfileStrategy()).V()}}, 
@@ -492,6 +492,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_withStrategiesXReadOnlyStrategyX_V_propertyXname_joshX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new ReadOnlyStrategy()).V().Property("name", "josh")}}, 
                {"g_withStrategiesXReadOnlyStrategyX_E_propertyXweight_0X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new ReadOnlyStrategy()).E().Property("weight", 0)}}, 
                {"g_V_classic_recommendation", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("name", "DARK STAR").As("a").Out("followedBy").Aggregate("stash").In("followedBy").Where(P.Neq("a").And(P.Not(P.Within("stash")))).GroupCount<object>().Unfold<object>().Project<object>("x", "y", "z").By(__.Select<object>(Column.Keys).Values<object>("name")).By(__.Select<object>(Column.Keys).Values<object>("performances")).By(__.Select<object>(Colu [...]
+               {"g_V_classic_recommendation_ranked", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("name", "DARK STAR").As("a").Out("followedBy").Aggregate("stash").In("followedBy").Where(P.Neq("a").And(P.Not(P.Within("stash")))).GroupCount<object>().Unfold<object>().Project<object>("x", "y", "z").By(__.Select<object>(Column.Keys).Values<object>("name")).By(__.Select<object>(Column.Keys).Values<object>("performances")).By(__.Select<objec [...]
                {"g_withStrategiesXReferenceElementStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new ReferenceElementStrategy()).V()}}, 
                {"g_withoutStrategiesXReferenceElementStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(ReferenceElementStrategy)).V()}}, 
                {"g_withStrategiesXRepeatUnrollStrategyX_V_repeatXoutX_timesX2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new RepeatUnrollStrategy()).V().Repeat(__.Out()).Times(2)}}, 
diff --git a/gremlin-go/driver/cucumber/gremlin.go b/gremlin-go/driver/cucumber/gremlin.go
index 6c17b89260..89eb923edb 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -412,7 +412,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_withoutStrategiesXMatchPredicateStrategyX_V_matchXa_created_lop_b__b_0created_29_cX_whereXc_repeatXoutX_timesX2XX_selectXa_b_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(gremlingo.MatchPredicateStrategy()).V().Match(gremlingo.T__.As("a").Out("created").Has("name", "lop").As("b"), gremlingo.T__.As("b").In("created").Has("age", 29).As("c")).Where(gremlingo.T__.As("c").Repeat(gremlingo.T__.Out()).Times(2 [...]
     "g_withStrategiesXMessagePassingReductionStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.MessagePassingReductionStrategy()).V()}}, 
     "g_withoutStrategiesXMessagePassingReductionStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(gremlingo.MessagePassingReductionStrategy()).V()}}, 
-  "g_withoutStrategiesXCountStrategyX_V_count": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(6)}}, 
     "g_V_coworker": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Filter(gremlingo.T__.OutE("created")).Aggregate("p").As("p1").Values("name").As("p1n").Select("p").Unfold().Where(gremlingo.P.Neq("p1")).As("p2").Values("name").As("p2n").Select("p2").Out("created").Choose(gremlingo.T__.In("created").Where(gremlingo.P.Eq("p1")), gremlingo.T__.Values("name"), gremlingo.T__.Constant(p["xx1"])).Group().By(gremling [...]
     "g_V_coworker_with_midV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Filter(gremlingo.T__.OutE("created")).As("p1").V().HasLabel("person").Where(gremlingo.P.Neq("p1")).Filter(gremlingo.T__.OutE("created")).As("p2").Map(gremlingo.T__.Out("created").Where(gremlingo.T__.In("created").As("p1")).Values("name").Fold()).Group().By(gremlingo.T__.Select("p1").By("name")).By(gremlingo.T__.Group().By(gremlingo.T_ [...]
     "g_withStrategiesXOptionsStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.OptionsStrategy()).V()}}, 
@@ -449,6 +448,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_withStrategiesXPathRetractionStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.PathRetractionStrategy()).V()}}, 
     "g_withoutStrategiesXPathRetractionStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(gremlingo.PathRetractionStrategy()).V()}}, 
     "g_V_shortestpath": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("v").Both().As("v").Project("src", "tgt", "p").By(gremlingo.T__.Select(gremlingo.Pop.First, "v")).By(gremlingo.T__.Select(gremlingo.Pop.Last, "v")).By(gremlingo.T__.Select(gremlingo.Pop.All, "v")).As("triple").Group("x").By(gremlingo.T__.Select("src", "tgt")).By(gremlingo.T__.Select("p").Fold()).Select("tgt").Barrier().Repeat(gremlingo.T__.Both().As("v").P [...]
+    "g_V_playlist_paths": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.SeedStrategy(gremlingo.SeedStrategyConfig{Seed: 99999})).V().Has("name", "Bob_Dylan").In("sungBy").As("a").Repeat(gremlingo.T__.Out().Order().By(gremlingo.Order.Shuffle).SimplePath().From("a")).Until(gremlingo.T__.Out("writtenBy").Has("name", "Johnny_Cash")).Limit(1).As("b").Repeat(gremlingo.T__.Out().Order().By(gremlingo.Order.Shuffle) [...]
     "g_withStrategiesXProductiveByStrategyX_V_group_byXageX_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.ProductiveByStrategy()).V().Group().By("age").By("name")}}, 
     "g_withoutStrategiesXProductiveByStrategyX_V_group_byXageX_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(gremlingo.ProductiveByStrategy()).V().Group().By("age").By("name")}}, 
     "g_withStrategiesXProfileStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.ProfileStrategy()).V()}}, 
@@ -461,6 +461,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_withStrategiesXReadOnlyStrategyX_V_propertyXname_joshX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.ReadOnlyStrategy()).V().Property("name", "josh")}}, 
     "g_withStrategiesXReadOnlyStrategyX_E_propertyXweight_0X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.ReadOnlyStrategy()).E().Property("weight", 0)}}, 
     "g_V_classic_recommendation": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("name", "DARK STAR").As("a").Out("followedBy").Aggregate("stash").In("followedBy").Where(gremlingo.P.Neq("a").And(gremlingo.P.Not(gremlingo.P.Within("stash")))).GroupCount().Unfold().Project("x", "y", "z").By(gremlingo.T__.Select(gremlingo.Column.Keys).Values("name")).By(gremlingo.T__.Select(gremlingo.Column.Keys).Values("performances")).By(grem [...]
+    "g_V_classic_recommendation_ranked": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("name", "DARK STAR").As("a").Out("followedBy").Aggregate("stash").In("followedBy").Where(gremlingo.P.Neq("a").And(gremlingo.P.Not(gremlingo.P.Within("stash")))).GroupCount().Unfold().Project("x", "y", "z").By(gremlingo.T__.Select(gremlingo.Column.Keys).Values("name")).By(gremlingo.T__.Select(gremlingo.Column.Keys).Values("performances")). [...]
     "g_withStrategiesXReferenceElementStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.ReferenceElementStrategy()).V()}}, 
     "g_withoutStrategiesXReferenceElementStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(gremlingo.ReferenceElementStrategy()).V()}}, 
     "g_withStrategiesXRepeatUnrollStrategyX_V_repeatXoutX_timesX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.RepeatUnrollStrategy()).V().Repeat(gremlingo.T__.Out()).Times(2)}}, 
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
index a91b8b8908..866632b370 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
@@ -433,7 +433,6 @@ const gremlins = {
     g_withoutStrategiesXMatchPredicateStrategyX_V_matchXa_created_lop_b__b_0created_29_cX_whereXc_repeatXoutX_timesX2XX_selectXa_b_cX: [function({g}) { return g.withoutStrategies(MatchPredicateStrategy).V().match(__.as("a").out("created").has("name", "lop").as("b"), __.as("b").in_("created").has("age", 29).as("c")).where(__.as("c").repeat(__.out()).times(2)).select("a", "b", "c") }], 
     g_withStrategiesXMessagePassingReductionStrategyX_V: [function({g}) { return g.withStrategies(new MessagePassingReductionStrategy()).V() }], 
     g_withoutStrategiesXMessagePassingReductionStrategyX_V: [function({g}) { return g.withoutStrategies(MessagePassingReductionStrategy).V() }], 
-    g_withoutStrategiesXCountStrategyX_V_count: [function({g}) { return g.withoutStrategies(CountStrategy).V().count() }], 
     g_V_coworker: [function({g, xx1}) { return g.V().hasLabel("person").filter(__.outE("created")).aggregate("p").as("p1").values("name").as("p1n").select("p").unfold().where(P.neq("p1")).as("p2").values("name").as("p2n").select("p2").out("created").choose(__.in_("created").where(P.eq("p1")), __.values("name"), __.constant(xx1)).group().by(__.select("p1n")).by(__.group().by(__.select("p2n")).by(__.unfold().fold().project("numCoCreated", "coCreated").by(__.count(Scope.local)).by())).unfol [...]
     g_V_coworker_with_midV: [function({g}) { return g.V().hasLabel("person").filter(__.outE("created")).as("p1").V().hasLabel("person").where(P.neq("p1")).filter(__.outE("created")).as("p2").map(__.out("created").where(__.in_("created").as("p1")).values("name").fold()).group().by(__.select("p1").by("name")).by(__.group().by(__.select("p2").by("name")).by(__.project("numCoCreated", "coCreated").by(__.count(Scope.local)).by())).unfold() }], 
     g_withStrategiesXOptionsStrategyX_V: [function({g}) { return g.withStrategies(new OptionsStrategy()).V() }], 
@@ -470,6 +469,7 @@ const gremlins = {
     g_withStrategiesXPathRetractionStrategyX_V: [function({g}) { return g.withStrategies(new PathRetractionStrategy()).V() }], 
     g_withoutStrategiesXPathRetractionStrategyX_V: [function({g}) { return g.withoutStrategies(PathRetractionStrategy).V() }], 
     g_V_shortestpath: [function({g}) { return g.V().as("v").both().as("v").project("src", "tgt", "p").by(__.select(Pop.first, "v")).by(__.select(Pop.last, "v")).by(__.select(Pop.all, "v")).as("triple").group("x").by(__.select("src", "tgt")).by(__.select("p").fold()).select("tgt").barrier().repeat(__.both().as("v").project("src", "tgt", "p").by(__.select(Pop.first, "v")).by(__.select(Pop.last, "v")).by(__.select(Pop.all, "v")).as("t").filter(__.select(Pop.all, "p").count(Scope.local).as(" [...]
+    g_V_playlist_paths: [function({g}) { return g.withStrategies(new SeedStrategy({seed: 99999})).V().has("name", "Bob_Dylan").in_("sungBy").as("a").repeat(__.out().order().by(Order.shuffle).simplePath().from_("a")).until(__.out("writtenBy").has("name", "Johnny_Cash")).limit(1).as("b").repeat(__.out().order().by(Order.shuffle).as("c").simplePath().from_("b").to("c")).until(__.out("sungBy").has("name", "Grateful_Dead")).limit(1).path().from_("a").unfold().project("song", "artists").by("na [...]
     g_withStrategiesXProductiveByStrategyX_V_group_byXageX_byXnameX: [function({g}) { return g.withStrategies(new ProductiveByStrategy()).V().group().by("age").by("name") }], 
     g_withoutStrategiesXProductiveByStrategyX_V_group_byXageX_byXnameX: [function({g}) { return g.withoutStrategies(ProductiveByStrategy).V().group().by("age").by("name") }], 
     g_withStrategiesXProfileStrategyX_V: [function({g}) { return g.withStrategies(new ProfileStrategy()).V() }], 
@@ -482,6 +482,7 @@ const gremlins = {
     g_withStrategiesXReadOnlyStrategyX_V_propertyXname_joshX: [function({g}) { return g.withStrategies(new ReadOnlyStrategy()).V().property("name", "josh") }], 
     g_withStrategiesXReadOnlyStrategyX_E_propertyXweight_0X: [function({g}) { return g.withStrategies(new ReadOnlyStrategy()).E().property("weight", 0) }], 
     g_V_classic_recommendation: [function({g}) { return g.V().has("name", "DARK STAR").as("a").out("followedBy").aggregate("stash").in_("followedBy").where(P.neq("a").and(P.not(P.within("stash")))).groupCount().unfold().project("x", "y", "z").by(__.select(Column.keys).values("name")).by(__.select(Column.keys).values("performances")).by(__.select(Column.values)).order().by(__.select("z"), Order.desc).by(__.select("y"), Order.asc).limit(5).aggregate(Scope.local, "m").select("x") }], 
+    g_V_classic_recommendation_ranked: [function({g}) { return g.V().has("name", "DARK STAR").as("a").out("followedBy").aggregate("stash").in_("followedBy").where(P.neq("a").and(P.not(P.within("stash")))).groupCount().unfold().project("x", "y", "z").by(__.select(Column.keys).values("name")).by(__.select(Column.keys).values("performances")).by(__.select(Column.values)).order().by(__.select("z"), Order.desc).by(__.select("y"), Order.asc).limit(5).aggregate(Scope.local, "m") }], 
     g_withStrategiesXReferenceElementStrategyX_V: [function({g}) { return g.withStrategies(new ReferenceElementStrategy()).V() }], 
     g_withoutStrategiesXReferenceElementStrategyX_V: [function({g}) { return g.withoutStrategies(ReferenceElementStrategy).V() }], 
     g_withStrategiesXRepeatUnrollStrategyX_V_repeatXoutX_timesX2X: [function({g}) { return g.withStrategies(new RepeatUnrollStrategy()).V().repeat(__.out()).times(2) }], 
diff --git a/gremlin-python/src/main/python/radish/gremlin.py b/gremlin-python/src/main/python/radish/gremlin.py
index cf73d3b836..1ecb050051 100644
--- a/gremlin-python/src/main/python/radish/gremlin.py
+++ b/gremlin-python/src/main/python/radish/gremlin.py
@@ -415,7 +415,6 @@ world.gremlins = {
     'g_withoutStrategiesXMatchPredicateStrategyX_V_matchXa_created_lop_b__b_0created_29_cX_whereXc_repeatXoutX_timesX2XX_selectXa_b_cX': [(lambda g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.MatchPredicateStrategy')]).V().match(__.as_('a').out('created').has('name', 'lop').as_('b'), __.as_('b').in_('created').has('age', 29).as_('c')).where(__.as_('c').repeat(__.out()).times(2)).select('a', 'b', 'c'))], 
     'g_withStrategiesXMessagePassingReductionStrategyX_V': [(lambda g:g.with_strategies(MessagePassingReductionStrategy()).V())], 
     'g_withoutStrategiesXMessagePassingReductionStrategyX_V': [(lambda g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.optimization.MessagePassingReductionStrategy')]).V())], 
-    'g_withoutStrategiesXCountStrategyX_V_count': [(lambda g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.CountStrategy')]).V().count())], 
     'g_V_coworker': [(lambda g, xx1=None:g.V().has_label('person').filter_(__.out_e('created')).aggregate('p').as_('p1').values('name').as_('p1n').select('p').unfold().where(P.neq('p1')).as_('p2').values('name').as_('p2n').select('p2').out('created').choose(__.in_('created').where(P.eq('p1')), __.values('name'), __.constant(xx1)).group().by(__.select('p1n')).by(__.group().by(__.select('p2n')).by(__.unfold().fold().project('numCoCreated', 'coCreated').by(__.count(Scope.local)).by())).unfo [...]
     'g_V_coworker_with_midV': [(lambda g:g.V().has_label('person').filter_(__.out_e('created')).as_('p1').V().has_label('person').where(P.neq('p1')).filter_(__.out_e('created')).as_('p2').map(__.out('created').where(__.in_('created').as_('p1')).values('name').fold()).group().by(__.select('p1').by('name')).by(__.group().by(__.select('p2').by('name')).by(__.project('numCoCreated', 'coCreated').by(__.count(Scope.local)).by())).unfold())], 
     'g_withStrategiesXOptionsStrategyX_V': [(lambda g:g.with_strategies(OptionsStrategy()).V())], 
@@ -452,6 +451,7 @@ world.gremlins = {
     'g_withStrategiesXPathRetractionStrategyX_V': [(lambda g:g.with_strategies(PathRetractionStrategy()).V())], 
     'g_withoutStrategiesXPathRetractionStrategyX_V': [(lambda g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.PathRetractionStrategy')]).V())], 
     'g_V_shortestpath': [(lambda g:g.V().as_('v').both().as_('v').project('src', 'tgt', 'p').by(__.select(Pop.first, 'v')).by(__.select(Pop.last, 'v')).by(__.select(Pop.all_, 'v')).as_('triple').group('x').by(__.select('src', 'tgt')).by(__.select('p').fold()).select('tgt').barrier().repeat(__.both().as_('v').project('src', 'tgt', 'p').by(__.select(Pop.first, 'v')).by(__.select(Pop.last, 'v')).by(__.select(Pop.all_, 'v')).as_('t').filter_(__.select(Pop.all_, 'p').count(Scope.local).as_('l [...]
+    'g_V_playlist_paths': [(lambda g:g.with_strategies(SeedStrategy(seed=99999)).V().has('name', 'Bob_Dylan').in_('sungBy').as_('a').repeat(__.out().order().by(Order.shuffle).simple_path().from_('a')).until(__.out('writtenBy').has('name', 'Johnny_Cash')).limit(1).as_('b').repeat(__.out().order().by(Order.shuffle).as_('c').simple_path().from_('b').to('c')).until(__.out('sungBy').has('name', 'Grateful_Dead')).limit(1).path().from_('a').unfold().project('song', 'artists').by('name').by(__.c [...]
     'g_withStrategiesXProductiveByStrategyX_V_group_byXageX_byXnameX': [(lambda g:g.with_strategies(ProductiveByStrategy()).V().group().by('age').by('name'))], 
     'g_withoutStrategiesXProductiveByStrategyX_V_group_byXageX_byXnameX': [(lambda g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy')]).V().group().by('age').by('name'))], 
     'g_withStrategiesXProfileStrategyX_V': [(lambda g:g.with_strategies(ProfileStrategy()).V())], 
@@ -464,6 +464,7 @@ world.gremlins = {
     'g_withStrategiesXReadOnlyStrategyX_V_propertyXname_joshX': [(lambda g:g.with_strategies(ReadOnlyStrategy()).V().property('name', 'josh'))], 
     'g_withStrategiesXReadOnlyStrategyX_E_propertyXweight_0X': [(lambda g:g.with_strategies(ReadOnlyStrategy()).E().property('weight', 0))], 
     'g_V_classic_recommendation': [(lambda g:g.V().has('name', 'DARK STAR').as_('a').out('followedBy').aggregate('stash').in_('followedBy').where(P.neq('a').and_(P.not_(P.within('stash')))).group_count().unfold().project('x', 'y', 'z').by(__.select(Column.keys).values('name')).by(__.select(Column.keys).values('performances')).by(__.select(Column.values)).order().by(__.select('z'), Order.desc).by(__.select('y'), Order.asc).limit(5).aggregate(Scope.local, 'm').select('x'))], 
+    'g_V_classic_recommendation_ranked': [(lambda g:g.V().has('name', 'DARK STAR').as_('a').out('followedBy').aggregate('stash').in_('followedBy').where(P.neq('a').and_(P.not_(P.within('stash')))).group_count().unfold().project('x', 'y', 'z').by(__.select(Column.keys).values('name')).by(__.select(Column.keys).values('performances')).by(__.select(Column.values)).order().by(__.select('z'), Order.desc).by(__.select('y'), Order.asc).limit(5).aggregate(Scope.local, 'm'))], 
     'g_withStrategiesXReferenceElementStrategyX_V': [(lambda g:g.with_strategies(ReferenceElementStrategy()).V())], 
     'g_withoutStrategiesXReferenceElementStrategyX_V': [(lambda g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.ReferenceElementStrategy')]).V())], 
     'g_withStrategiesXRepeatUnrollStrategyX_V_repeatXoutX_timesX2X': [(lambda g:g.with_strategies(RepeatUnrollStrategy()).V().repeat(__.out()).times(2))], 
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
index cd507f5099..f85568902f 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
@@ -67,7 +67,6 @@ public class ProcessEmbeddedComputerSuite extends AbstractGremlinSuite {
             LambdaStepTest.Traversals.class,
 
             // compliance
-            ComplexTest.Traversals.class,
             TraversalInterruptionComputerTest.class,
 
             // algorithms
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
index c14139401d..2f746a49e3 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
@@ -66,7 +66,6 @@ public class ProcessEmbeddedStandardSuite extends AbstractGremlinSuite {
             TreeTest.Traversals.class,
 
             // compliance
-            ComplexTest.Traversals.class,
             CoreTraversalTest.class,
             TraversalInterruptionTest.class,
 
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Miscellaneous.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Miscellaneous.feature
index c9ca1fd811..a5ef772956 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Miscellaneous.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Miscellaneous.feature
@@ -18,18 +18,6 @@
 @StepClassIntegrated
 Feature: Step - miscellaneous
 
-  # smoke test withoutStrategies()
-  Scenario: g_withoutStrategiesXCountStrategyX_V_count
-    Given the modern graph
-    And the traversal of
-      """
-      g.withoutStrategies(CountStrategy).V().count()
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | d[6].l |
-
   Scenario: g_V_coworker
     Given the modern graph
     And using the parameter xx1 defined as "l[]"
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Paths.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Paths.feature
index 9f20091b76..172754f81a 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Paths.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Paths.feature
@@ -40,7 +40,7 @@ Feature: Step - paths
                        select(Pop.last, "t").select(Pop.all, "p").dedup(Scope.local).count(Scope.local).where(P.eq("l"))).
                 select(Pop.last, "t").
                 not(__.select(Pop.all, "p").as("p").count(local).as("l").
-                    select(Pop.all, "x").unfold().filter(select(keys).where(P.eq("t")).by(select("src", "tgt"))).
+                    select(Pop.all, "x").unfold().filter(select(keys).where(P.eq("t")).by(__.select("src", "tgt"))).
                     filter(__.select(Column.values).unfold().or(__.count(Scope.local).where(P.lt("l")), __.where(P.eq("p"))))).
                 barrier().
                 group("x").
@@ -81,3 +81,33 @@ Feature: Step - paths
       | l[lop,peter]|
       | l[lop,josh]|
       | l[marko,lop,peter]|
+
+  @GraphComputerVerificationStarGraphExceeded @WithSeedStrategy @InsertionOrderingRequired
+  Scenario: g_V_playlist_paths
+    Given the grateful graph
+    And the traversal of
+      """
+      g.withStrategies(SeedStrategy(seed: 99999)).V().has("name", "Bob_Dylan").in("sungBy").as("a").
+        repeat(__.out().order().by(Order.shuffle).simplePath().from("a")).
+          until(__.out("writtenBy").has("name", "Johnny_Cash")).
+        limit(1).as("b").
+        repeat(__.out().order().by(Order.shuffle).as("c").simplePath().from("b").to("c")).
+          until(__.out("sungBy").has("name", "Grateful_Dead")).
+        limit(1).
+        path().from("a").unfold().
+        project("song", "artists").
+          by("name").
+          by(__.coalesce(__.out("sungBy", "writtenBy").dedup().values("name"),
+                         __.constant("Unknown")).fold())
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | m[{"song":"TOMORROW IS A LONG TIME","artists":["Bob_Dylan"]}] |
+      | m[{"song":"JOHN BROWN","artists":["Bob_Dylan"]}] |
+      | m[{"song":"BABY BLUE","artists":["Unknown"]}] |
+      | m[{"song":"CANDYMAN","artists":["Garcia","Hunter"]}] |
+      | m[{"song":"BIG RIVER","artists":["Weir","Johnny_Cash"]}] |
+      | m[{"song":"TERRAPIN STATION","artists":["Garcia","Hunter"]}] |
+      | m[{"song":"DRUMS","artists":["Grateful_Dead"]}] |
+
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Recommendation.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Recommendation.feature
index eff27fa98b..bb91c948ea 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Recommendation.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/Recommendation.feature
@@ -27,13 +27,13 @@ Feature: Step - recommendation
         groupCount().
         unfold().
         project("x", "y", "z").
-          by(__.select(keys).values("name")).
-          by(__.select(keys).values("performances")).
-          by(__.select(values)).
+          by(__.select(Column.keys).values("name")).
+          by(__.select(Column.keys).values("performances")).
+          by(__.select(Column.values)).
         order().
           by(__.select("z"), Order.desc).
           by(__.select("y"), Order.asc).
-        limit(5).aggregate(local,"m").select("x")
+        limit(5).aggregate(Scope.local,"m").select("x")
       """
     When iterated to list
     Then the result should be unordered
@@ -42,4 +42,30 @@ Feature: Step - recommendation
       | UNCLE JOHNS BAND |
       | I KNOW YOU RIDER |
       | SHIP OF FOOLS |
-      | GOOD LOVING |
\ No newline at end of file
+      | GOOD LOVING |
+
+  Scenario: g_V_classic_recommendation_ranked
+    Given the grateful graph
+    And the traversal of
+      """
+      g.V().has("name", "DARK STAR").as("a").out("followedBy").aggregate("stash").
+        in("followedBy").where(P.neq("a").and(P.not(P.within("stash")))).
+        groupCount().
+        unfold().
+        project("x", "y", "z").
+          by(__.select(Column.keys).values("name")).
+          by(__.select(Column.keys).values("performances")).
+          by(__.select(Column.values)).
+        order().
+          by(__.select("z"), Order.desc).
+          by(__.select("y"), Order.asc).
+        limit(5).aggregate(Scope.local,"m")
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | m[{"x":"LET IT GROW","y":"d[276].i","z":"d[21].l"}] |
+      | m[{"x":"UNCLE JOHNS BAND","y":"d[332].i","z":"d[20].l"}] |
+      | m[{"x":"I KNOW YOU RIDER","y":"d[550].i","z":"d[20].l"}] |
+      | m[{"x":"SHIP OF FOOLS","y":"d[225].i","z":"d[18].l"}] |
+      | m[{"x":"GOOD LOVING","y":"d[428].i","z":"d[18].l"}] |
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphFeatureTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphFeatureTest.java
index 1c3dba0bec..937fdf14bb 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphFeatureTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphFeatureTest.java
@@ -30,7 +30,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerOnly and not @AllowNullPropertyValues",
+        tags = "not @RemoteOnly and not @GraphComputerOnly and not @AllowNullPropertyValues and not @InsertionOrderingRequired",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = TinkerTransactionGraphFeatureTest.TinkerGraphGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },


(tinkerpop) 07/11: f

Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 2aa85ac875bc7a96ed21a23efdc734b9b87c2219
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Wed Apr 16 08:50:22 2025 -0400

    f
---
 docs/src/dev/developer/for-committers.asciidoc                 |  2 ++
 .../org/apache/tinkerpop/gremlin/features/StepDefinition.java  | 10 ++++++++--
 .../gremlin/test/features/sideEffect/Subgraph.feature          |  1 -
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/docs/src/dev/developer/for-committers.asciidoc b/docs/src/dev/developer/for-committers.asciidoc
index 59f46161e8..067b7ae98d 100644
--- a/docs/src/dev/developer/for-committers.asciidoc
+++ b/docs/src/dev/developer/for-committers.asciidoc
@@ -502,6 +502,8 @@ of traversal iteration where "_comparison_" may be one of "containing", "startin
 * "the result should be unordered" - the exact results but can appear any order
 * "the result should be of" - results can be any of the specified values and in any order (use when guarantees
 regarding the exact results cannot be pre-determined easily - see the `range()`-step tests for examples)
+* "the result should be a graph with _xxx_" - asserts a subgraph where the _xxx_ may be "vertices" or "edges" with a
+follow-on table containing vertex or edge definitions respectively that are expected to exist in the subgraph
 
 These final three types of assertions mentioned above should be followed by a Gherkin table that has one column, where
 each row value in that column represents a value to assert in the result. These values are type notation respected as
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
index 14e115e885..9eeff82abc 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
@@ -393,6 +393,9 @@ public final class StepDefinition {
         final List<Edge> expectedEdges = dataTable.asList().stream().map(this::convertToObject).
                 map(e -> (Edge) e).collect(Collectors.toList());
 
+        // expected edges match the count in the graph
+        assertEquals(expectedEdges.size(), sg.E().count().next().intValue());
+
         // assert the structure of the subgraph. there should be no references here as this is serialized as
         // a full TinkerGraph. also, ids should be the same as they are in the source graph so we can use all
         // of this to do a complete assertion. there is only support for the modern graph right now but it
@@ -417,14 +420,17 @@ public final class StepDefinition {
         final GraphTraversalSource sg = ((Graph) result).traversal();
 
         // grab the expected vertex in the subgraph
-        final List<Vertex> expectedEdges = dataTable.asList().stream().map(this::convertToObject).
+        final List<Vertex> expectedVertices = dataTable.asList().stream().map(this::convertToObject).
                 map(v -> (Vertex) v).collect(Collectors.toList());
 
+        // expected vertices match the count in the graph
+        assertEquals(expectedVertices.size(), sg.E().count().next().intValue());
+
         // assert the structure of the subgraph. there should be no references here as this is serialized as
         // a full TinkerGraph. also, ids should be the same as they are in the source graph so we can use all
         // of this to do a complete assertion. there is only support for the modern graph right now but it
         // wouldn't be hard to add others.
-        for (Vertex vertex : expectedEdges) {
+        for (Vertex vertex : expectedVertices) {
             final String variableKey = vertex.label().equals("person") ? "age" : "lang";
 
             assertThat(sg.V(vertex.id()).has(vertex.label(), "name", eq(vertex.value("name"))).
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Subgraph.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Subgraph.feature
index 93fb651fec..1eb2edfc32 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Subgraph.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Subgraph.feature
@@ -36,7 +36,6 @@ Feature: Step - subgraph()
 
   Scenario: g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX
     Given the modern graph
-    And using the parameter vid1 defined as "v[marko].id"
     And the traversal of
       """
       g.V().repeat(__.bothE("created").subgraph("sg").outV()).times(5).values("name").dedup().cap("sg")


(tinkerpop) 10/11: Deprecated ProcessComputerSuite and ProcessStandardSuite

Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit b33965337e3a905c744ececda1575aff45641a0b
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Thu Apr 17 16:31:12 2025 -0400

    Deprecated ProcessComputerSuite and ProcessStandardSuite
---
 CHANGELOG.asciidoc                                             |  1 +
 .../java/org/apache/tinkerpop/gremlin/structure/Graph.java     | 10 ++++++++++
 .../apache/tinkerpop/gremlin/process/ProcessComputerSuite.java |  3 +++
 .../apache/tinkerpop/gremlin/process/ProcessStandardSuite.java |  3 +++
 4 files changed, 17 insertions(+)

diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index 11409cf38a..78e891901d 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -57,6 +57,7 @@ This release also includes changes from <<release-3-7-XXX, 3.7.XXX>>.
 * Fixed `BigInt` and `BigDecimal` parsing in `gremlin-go` cucumber test suite, fixed `UnscaledValue` type in `BigDecimal` struct and added `ParseBigDecimal` method.
 * Added validation to `groupCount()` to prevent an invalid usage of multiple `by()` modulators.
 * Deprecated `ProcessLimitedStandardSuite` and `ProcessLimitedComputerSuite` in favor of `ProcessEmbeddedStandardSuite` and `ProcessEmbeddedComputerSuite` respectively.
+* Deprecated `ProcessStandardSuite` and the `ProcessComputerSuite` in favor of Gherkin testing and the `ProcessEmbeddedStandardSuite` and `ProcessEmbeddedComputerSuite` for testing JVM-specific Gremlin behaviors.
 * Removed lambda oriented Gremlin testing from Gherkin test suite.
 * Moved all lambda oriented Gremlin tests to `LambdaStepTest` in the Java test suite.
 * Removed the `@RemoteOnly` testing tag in Gherkin as lambda tests have all been moved to the Java test suite.
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Graph.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Graph.java
index 6e30fdc4d2..c8266fcfc9 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Graph.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Graph.java
@@ -1272,7 +1272,17 @@ public interface Graph extends AutoCloseable, Host {
     @interface OptIn {
         String SUITE_STRUCTURE_STANDARD = "org.apache.tinkerpop.gremlin.structure.StructureStandardSuite";
         String SUITE_STRUCTURE_INTEGRATE = "org.apache.tinkerpop.gremlin.structure.StructureIntegrateSuite";
+        /**
+         * @deprecated As of release 3.8.0, prefer the Gherkin test suite for validating Gremlin behavior and the
+         * {@link #SUITE_PROCESS_EMBEDDED_COMPUTER} for JVM specific tests.
+         */
+        @Deprecated
         String SUITE_PROCESS_COMPUTER = "org.apache.tinkerpop.gremlin.process.ProcessComputerSuite";
+        /**
+         * @deprecated As of release 3.8.0, prefer the Gherkin test suite for validating Gremlin behavior and the
+         * {@link #SUITE_PROCESS_EMBEDDED_STANDARD} for JVM specific tests.
+         */
+        @Deprecated
         String SUITE_PROCESS_STANDARD = "org.apache.tinkerpop.gremlin.process.ProcessStandardSuite";
         /**
          * @deprecated As of release 3.8.0, replaced by {@link #SUITE_PROCESS_EMBEDDED_STANDARD}.
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java
index da76275f33..621d8a4647 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java
@@ -111,7 +111,10 @@ import org.junit.runners.model.RunnerBuilder;
  * For more information on the usage of this suite, please see {@link StructureStandardSuite}.
  *
  * @author Stephen Mallette (http://stephen.genoprime.com)
+ * @deprecated As of release 3.8.0, prefer the Gherkin test suite for validating Gremlin behavior and the
+ * {@link ProcessEmbeddedComputerSuite} for JVM specific tests.
  */
+@Deprecated
 public class ProcessComputerSuite extends AbstractGremlinSuite {
 
     /**
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessStandardSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessStandardSuite.java
index 127a2acc92..2e1a72f6ca 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessStandardSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessStandardSuite.java
@@ -110,7 +110,10 @@ import org.junit.runners.model.RunnerBuilder;
  * For more information on the usage of this suite, please see {@link StructureStandardSuite}.
  *
  * @author Stephen Mallette (http://stephen.genoprime.com)
+ * @deprecated As of release 3.8.0, prefer the Gherkin test suite for validating Gremlin behavior and the
+ * {@link ProcessEmbeddedStandardSuite} for JVM specific tests.
  */
+@Deprecated
 public class ProcessStandardSuite extends AbstractGremlinSuite {
 
     /**


(tinkerpop) 04/11: TINKERPOP-3136 Added subgraph() tests to gherkin

Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 6d0b744a6645a1daa9af05365c42ab8c45a27be9
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Tue Apr 15 19:28:25 2025 -0400

    TINKERPOP-3136 Added subgraph() tests to gherkin
    
    Minor restructuring to V/E tests with more specific tags for mid-traversal V/E.
---
 docs/src/dev/developer/for-committers.asciidoc     |   2 +
 .../Gherkin/GherkinTestRunner.cs                   |   2 +
 .../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs |  28 +--
 .../Gherkin/IgnoreException.cs                     |   7 +-
 gremlin-go/driver/cucumber/cucumberSteps_test.go   |   2 +-
 gremlin-go/driver/cucumber/gremlin.go              |  28 +--
 .../test/cucumber/feature-steps.js                 |  12 ++
 .../gremlin-javascript/test/cucumber/gremlin.js    |  28 +--
 .../src/main/python/radish/feature_steps.py        |   2 +
 gremlin-python/src/main/python/radish/gremlin.py   |  28 +--
 .../GraphBinaryRemoteComputerFeatureTest.java      |   3 +-
 .../remote/GraphSONRemoteComputerFeatureTest.java  |   2 +-
 .../gremlin/driver/remote/RemoteWorld.java         |  22 ++-
 .../tinkerpop/gremlin/features/StepDefinition.java |  59 ++++++
 .../process/ProcessEmbeddedComputerSuite.java      |   2 -
 .../process/ProcessEmbeddedStandardSuite.java      |   5 -
 .../gremlin/test/features/map/Edge.feature         | 120 +++++++++++-
 .../gremlin/test/features/map/Graph.feature        | 109 -----------
 .../gremlin/test/features/map/Vertex.feature       | 207 ++++++++++-----------
 .../test/features/sideEffect/Subgraph.feature      |  55 ++++++
 .../hadoop/HadoopGraphFeatureIntegrateTest.java    |   2 +-
 .../spark/SparkGraphFeatureIntegrateTest.java      |   1 +
 .../TinkerGraphComputerFeatureTest.java            |   2 +-
 .../TinkerTransactionGraphComputerFeatureTest.java |   2 +-
 .../tinkerpop/gremlin/tinkergraph/TinkerWorld.java |  10 +-
 25 files changed, 446 insertions(+), 294 deletions(-)

diff --git a/docs/src/dev/developer/for-committers.asciidoc b/docs/src/dev/developer/for-committers.asciidoc
index f0e0cda24c..59f46161e8 100644
--- a/docs/src/dev/developer/for-committers.asciidoc
+++ b/docs/src/dev/developer/for-committers.asciidoc
@@ -567,6 +567,8 @@ tag when one is necessary will cause provider tests to fail:
 * `@GraphComputerOnly` - The scenario is only supported with `GraphComputer`.
 * `@GraphComputerVerificationInjectionNotSupported` - The scenario will not work on with `GraphComputer` because the
 `inject()` step is not supported.
+* `@GraphComputerVerificationMidENotSupported` - The scenario will not work on with `GraphComputer` because the
+mid-`E()` step is not supported.
 * `@GraphComputerVerificationMidVNotSupported` - The scenario will not work on with `GraphComputer` because the
 mid-`V()` step is not supported.
 * `@GraphComputerVerificationOneBulk` - The scenario will not work because `withBulk(false)` is configured and that
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
index e12a89b64f..20272e626b 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
@@ -48,6 +48,8 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
             new Dictionary<string, IgnoreReason>
             {
                 // Add here the name of scenarios to ignore and the reason, e.g.:
+                {"g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX", IgnoreReason.SubgraphStepNotSupported},
+                {"g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX", IgnoreReason.SubgraphStepNotSupported},
                 {"g_withStrategiesXProductiveByStrategyX_V_group_byXageX", IgnoreReason.NullKeysInMapNotSupported},
                 {"g_withStrategiesXProductiveByStrategyX_V_groupCount_byXageX", IgnoreReason.NullKeysInMapNotSupported},
                 {"g_withoutStrategiesXCountStrategyX_V_count", IgnoreReason.NoReason}, // needs investigation
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
index aec6a2f218..0f7523940d 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
@@ -769,6 +769,15 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_injectXa_null_bX_disjunctXa_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Disjunct(p["xx2"])}}, 
                {"g_injectXa_null_bX_disjunctXa_null_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Disjunct(p["xx2"])}}, 
                {"g_injectX3_threeX_disjunctXfive_three_7X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"]).Disjunct(p["xx2"])}}, 
+               {"g_E", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E()}}, 
+               {"g_EX11X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["eid11"])}}, 
+               {"g_EX11AsStringX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["eid11"])}}, 
+               {"g_EXe11X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["e11"])}}, 
+               {"g_EXe7_e11X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["e7"], p["e11"])}}, 
+               {"g_EXlistXe7_e11XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["xx1"])}}, 
+               {"g_EXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(null)}}, 
+               {"g_EXlistXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["xx1"])}}, 
+               {"g_EX11_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["eid11"], null)}}, 
                {"g_V_EX11X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().E(p["eid11"])}}, 
                {"g_EX11X_E", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["eid11"]).E()}}, 
                {"g_V_EXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().E(null)}}, 
@@ -804,10 +813,6 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_elementMap_formatXstrX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ElementMap<object>().Format("%{name} is %{age} years old")}}, 
                {"g_V_hasLabelXpersonX_asXaX_valuesXnameX_asXp1X_selectXaX_inXknowsX_formatXstrX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").As("a").Values<object>("name").As("p1").Select<object>("a").In("knows").Format("%{p1} knows %{name}")}}, 
                {"g_V_asXsX_label_asXsubjectX_selectXsX_outE_asXpX_label_asXpredicateX_selectXpX_inV_label_asXobjectX_formatXstrX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("s").Label().As("subject").Select<object>("s").OutE().As("p").Label().As("predicate").Select<object>("p").InV().Label().As("object").Format("%{subject} %{predicate} %{object}")}}, 
-               {"g_VX1X_V_valuesXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).V().Values<object>("name")}}, 
-               {"g_V_outXknowsX_V_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out("knows").V().Values<object>("name")}}, 
-               {"g_V_hasXname_GarciaX_inXsungByX_asXsongX_V_hasXname_Willie_DixonX_inXwrittenByX_whereXeqXsongXX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("artist", "name", "Garcia").In("sungBy").As("song").V().Has("artist", "name", "Willie_Dixon").In("writtenBy").Where(P.Eq("song")).Values<object>("name")}}, 
-               {"g_V_hasLabelXpersonX_asXpX_VXsoftwareX_addInEXuses_pX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ri [...]
                {"g_V_hasLabelXsoftwareX_index_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("software").Index<object>().Unfold<object>()}}, 
                {"g_V_hasLabelXsoftwareX_order_byXnameX_index_withXmapX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("software").Order().By("name").Index<object>().With(WithOptions.Indexer, WithOptions.Map)}}, 
                {"g_V_hasLabelXsoftwareX_name_fold_orderXlocalX_index_unfold_order_byXtailXlocal_1XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("software").Values<object>("name").Fold().Order(Scope.Local).Index<object>().Unfold<object>().Order().By(__.Tail<object>(Scope.Local, 1))}}, 
@@ -1367,15 +1372,6 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_VX1X_out", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out()}}, 
                {"g_VX2X_in", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid2"]).In()}}, 
                {"g_VX4X_both", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid4"]).Both()}}, 
-               {"g_E", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E()}}, 
-               {"g_EX11X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["eid11"])}}, 
-               {"g_EX11AsStringX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["eid11"])}}, 
-               {"g_EXe11X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["e11"])}}, 
-               {"g_EXe7_e11X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["e7"], p["e11"])}}, 
-               {"g_EXlistXe7_e11XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["xx1"])}}, 
-               {"g_EXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(null)}}, 
-               {"g_EXlistXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["xx1"])}}, 
-               {"g_EX11_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["eid11"], null)}}, 
                {"g_VX1X_outE", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).OutE()}}, 
                {"g_VX2X_outE", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid2"]).InE()}}, 
                {"g_VX4X_bothEXcreatedX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid4"]).BothE("created")}}, 
@@ -1405,6 +1401,10 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_hasLabelXloopsX_bothXselfX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("loops").Both("self")}}, 
                {"g_injectX1X_VXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1).V(null)}}, 
                {"g_injectX1X_VX1_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1).V(p["vid1"], null)}}, 
+               {"g_VX1X_V_valuesXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).V().Values<object>("name")}}, 
+               {"g_V_outXknowsX_V_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out("knows").V().Values<object>("name")}}, 
+               {"g_V_hasXname_GarciaX_inXsungByX_asXsongX_V_hasXname_Willie_DixonX_inXwrittenByX_whereXeqXsongXX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("artist", "name", "Garcia").In("sungBy").As("song").V().Has("artist", "name", "Willie_Dixon").In("writtenBy").Where(P.Eq("song")).Values<object>("name")}}, 
+               {"g_V_hasLabelXpersonX_asXpX_VXsoftwareX_addInEXuses_pX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ri [...]
                {"InjectXnullX_eqXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).Is(P.Eq(null))}}, 
                {"InjectXnullX_neqXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).Is(P.Neq(null))}}, 
                {"InjectXnullX_ltXnullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null).Is(P.Lt(null))}}, 
@@ -1671,6 +1671,8 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithSideEffect("a", p["xx1"]).V().Both().Values<object>("name").Store("a").Cap<object>("a")}}, 
                {"g_withSideEffectXa_set_inlineX_V_both_name_storeXaX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithSideEffect("a", new HashSet<object> { "alice" }).V().Both().Values<object>("name").Store("a").Cap<object>("a")}}, 
                {"g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Store("a").By(__.OutE("created").Count()).Out().Out().Store("a").By(__.InE("created").Values<object>("weight").Sum<object>()).Cap<object>("a")}}, 
+               {"g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).OutE("knows").Subgraph("sg").Values<object>("name").Cap<object>("sg")}}, 
+               {"g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Repeat(__.BothE("created").Subgraph("sg").OutV()).Times(5).Values<object>("name").Dedup().Cap<object>("sg")}}, 
             };
 
         public static ITraversal UseTraversal(string scenarioName, GraphTraversalSource g, IDictionary<string, object> parameters)
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs
index d409cc4dec..480cf87d93 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs
@@ -65,6 +65,11 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
         /// <summary>
         /// Tests with lambdas can't be translated. This should be removed once lambdas are completely dropped.
         /// </summary>
-        LambdasNotTranslated
+        LambdasNotTranslated,
+
+        /// <summary>
+        /// subgraph() is not supported yet
+        /// </summary>
+        SubgraphStepNotSupported
     }
 }
\ No newline at end of file
diff --git a/gremlin-go/driver/cucumber/cucumberSteps_test.go b/gremlin-go/driver/cucumber/cucumberSteps_test.go
index 294bcfef54..c543e038ab 100644
--- a/gremlin-go/driver/cucumber/cucumberSteps_test.go
+++ b/gremlin-go/driver/cucumber/cucumberSteps_test.go
@@ -956,7 +956,7 @@ func TestCucumberFeatures(t *testing.T) {
 		TestSuiteInitializer: InitializeTestSuite,
 		ScenarioInitializer:  InitializeScenario,
 		Options: &godog.Options{
-			Tags:     "~@GraphComputerOnly && ~@AllowNullPropertyValues",
+			Tags:     "~@GraphComputerOnly && ~@AllowNullPropertyValues && ~@StepSubgraph",
 			Format:   "pretty",
 			Paths:    []string{getEnvOrDefaultString("CUCUMBER_FEATURE_FOLDER", "../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features")},
 			TestingT: t, // Testing instance that will run subtests.
diff --git a/gremlin-go/driver/cucumber/gremlin.go b/gremlin-go/driver/cucumber/gremlin.go
index 89eb923edb..658a2ca905 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -738,6 +738,15 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_injectXa_null_bX_disjunctXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Disjunct(p["xx2"])}}, 
     "g_injectXa_null_bX_disjunctXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Disjunct(p["xx2"])}}, 
     "g_injectX3_threeX_disjunctXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Disjunct(p["xx2"])}}, 
+    "g_E": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}}, 
+    "g_EX11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"])}}, 
+    "g_EX11AsStringX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"])}}, 
+    "g_EXe11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["e11"])}}, 
+    "g_EXe7_e11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["e7"], p["e11"])}}, 
+    "g_EXlistXe7_e11XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["xx1"])}}, 
+    "g_EXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(nil)}}, 
+    "g_EXlistXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["xx1"])}}, 
+    "g_EX11_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"], nil)}}, 
     "g_V_EX11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().E(p["eid11"])}}, 
     "g_EX11X_E": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"]).E()}}, 
     "g_V_EXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().E(nil)}}, 
@@ -773,10 +782,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_elementMap_formatXstrX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ElementMap().Format("%{name} is %{age} years old")}}, 
     "g_V_hasLabelXpersonX_asXaX_valuesXnameX_asXp1X_selectXaX_inXknowsX_formatXstrX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").As("a").Values("name").As("p1").Select("a").In("knows").Format("%{p1} knows %{name}")}}, 
     "g_V_asXsX_label_asXsubjectX_selectXsX_outE_asXpX_label_asXpredicateX_selectXpX_inV_label_asXobjectX_formatXstrX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("s").Label().As("subject").Select("s").OutE().As("p").Label().As("predicate").Select("p").InV().Label().As("object").Format("%{subject} %{predicate} %{object}")}}, 
-    "g_VX1X_V_valuesXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).V().Values("name")}}, 
-    "g_V_outXknowsX_V_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out("knows").V().Values("name")}}, 
-    "g_V_hasXname_GarciaX_inXsungByX_asXsongX_V_hasXname_Willie_DixonX_inXwrittenByX_whereXeqXsongXX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("artist", "name", "Garcia").In("sungBy").As("song").V().Has("artist", "name", "Willie_Dixon").In("writtenBy").Where(gremlingo.P.Eq("song")).Values("name")}}, 
-    "g_V_hasLabelXpersonX_asXpX_VXsoftwareX_addInEXuses_pX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", " [...]
     "g_V_hasLabelXsoftwareX_index_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("software").Index().Unfold()}}, 
     "g_V_hasLabelXsoftwareX_order_byXnameX_index_withXmapX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("software").Order().By("name").Index().With(gremlingo.WithOptions.Indexer, gremlingo.WithOptions.Map)}}, 
     "g_V_hasLabelXsoftwareX_name_fold_orderXlocalX_index_unfold_order_byXtailXlocal_1XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("software").Values("name").Fold().Order(gremlingo.Scope.Local).Index().Unfold().Order().By(gremlingo.T__.Tail(gremlingo.Scope.Local, 1))}}, 
@@ -1336,15 +1341,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_VX1X_out": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out()}}, 
     "g_VX2X_in": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid2"]).In()}}, 
     "g_VX4X_both": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid4"]).Both()}}, 
-    "g_E": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}}, 
-    "g_EX11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"])}}, 
-    "g_EX11AsStringX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"])}}, 
-    "g_EXe11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["e11"])}}, 
-    "g_EXe7_e11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["e7"], p["e11"])}}, 
-    "g_EXlistXe7_e11XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["xx1"])}}, 
-    "g_EXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(nil)}}, 
-    "g_EXlistXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["xx1"])}}, 
-    "g_EX11_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"], nil)}}, 
     "g_VX1X_outE": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE()}}, 
     "g_VX2X_outE": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid2"]).InE()}}, 
     "g_VX4X_bothEXcreatedX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid4"]).BothE("created")}}, 
@@ -1374,6 +1370,10 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_hasLabelXloopsX_bothXselfX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("loops").Both("self")}}, 
     "g_injectX1X_VXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1).V(nil)}}, 
     "g_injectX1X_VX1_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1).V(p["vid1"], nil)}}, 
+    "g_VX1X_V_valuesXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).V().Values("name")}}, 
+    "g_V_outXknowsX_V_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out("knows").V().Values("name")}}, 
+    "g_V_hasXname_GarciaX_inXsungByX_asXsongX_V_hasXname_Willie_DixonX_inXwrittenByX_whereXeqXsongXX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("artist", "name", "Garcia").In("sungBy").As("song").V().Has("artist", "name", "Willie_Dixon").In("writtenBy").Where(gremlingo.P.Eq("song")).Values("name")}}, 
+    "g_V_hasLabelXpersonX_asXpX_VXsoftwareX_addInEXuses_pX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", " [...]
     "InjectXnullX_eqXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).Is(gremlingo.P.Eq(nil))}}, 
     "InjectXnullX_neqXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).Is(gremlingo.P.Neq(nil))}}, 
     "InjectXnullX_ltXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil).Is(gremlingo.P.Lt(nil))}}, 
@@ -1640,6 +1640,8 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSideEffect("a", p["xx1"]).V().Both().Values("name").Store("a").Cap("a")}}, 
     "g_withSideEffectXa_set_inlineX_V_both_name_storeXaX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSideEffect("a", gremlingo.NewSimpleSet("alice")).V().Both().Values("name").Store("a").Cap("a")}}, 
     "g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Store("a").By(gremlingo.T__.OutE("created").Count()).Out().Out().Store("a").By(gremlingo.T__.InE("created").Values("weight").Sum()).Cap("a")}}, 
+    "g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows").Subgraph("sg").Values("name").Cap("sg")}}, 
+    "g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.BothE("created").Subgraph("sg").OutV()).Times(5).Values("name").Dedup().Cap("sg")}}, 
 }
 
    func GetTraversal(scenarioName string, g *gremlingo.GraphTraversalSource, parameters map[string]interface{}) (*gremlingo.GraphTraversal, error) {
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
index 42e3899e55..75758c8294 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
@@ -73,10 +73,14 @@ const ignoreReason = {
   classNotSupported: "Javascript does not support the class type in GraphBinary",
   nullKeysInMapNotSupportedWell: "Javascript does not nicely support 'null' as a key in Map instances",
   floatingPointIssues: "Javascript floating point numbers not working in this case",
+  subgraphStepNotSupported: "Javascript does not yet support subgraph()",
   needsFurtherInvestigation: '',
 };
 
 const ignoredScenarios = {
+  // javascript doesn't have subgraph() step yet
+  'g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX': new IgnoreError(ignoreReason.subgraphStepNotSupported),
+  'g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX': new IgnoreError(ignoreReason.subgraphStepNotSupported),
   // An associative array containing the scenario name as key, for example:
   'g_withStrategiesXProductiveByStrategyX_V_groupCount_byXageX': new IgnoreError(ignoreReason.nullKeysInMapNotSupportedWell),
   'g_withoutStrategiesXCountStrategyX_V_count': new IgnoreError(ignoreReason.classNotSupported),
@@ -279,6 +283,14 @@ Then(/^the result should be (\w+)$/, function assertResult(characterizedAs, resu
   }
 });
 
+Then('the result should be a subgraph with edges', _ => {
+  // subgraph is not supported yet in javascript
+});
+
+Then('the result should be a subgraph with vertices', _ => {
+  // subgraph is not supported yet in javascript
+});
+
 Then(/^the graph should return (\d+) for count of "(.+)"$/, function (stringCount, traversalText) {
   expect(this.result).to.not.be.a.instanceof(Error);
 
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
index 866632b370..993257eee6 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
@@ -759,6 +759,15 @@ const gremlins = {
     g_injectXa_null_bX_disjunctXa_cX: [function({g, xx1, xx2}) { return g.inject(xx1).disjunct(xx2) }], 
     g_injectXa_null_bX_disjunctXa_null_cX: [function({g, xx1, xx2}) { return g.inject(xx1).disjunct(xx2) }], 
     g_injectX3_threeX_disjunctXfive_three_7X: [function({g, xx1, xx2}) { return g.inject(xx1).disjunct(xx2) }], 
+    g_E: [function({g}) { return g.E() }], 
+    g_EX11X: [function({g, eid11}) { return g.E(eid11) }], 
+    g_EX11AsStringX: [function({g, eid11}) { return g.E(eid11) }], 
+    g_EXe11X: [function({g, e11}) { return g.E(e11) }], 
+    g_EXe7_e11X: [function({g, e7, e11}) { return g.E(e7, e11) }], 
+    g_EXlistXe7_e11XX: [function({g, xx1}) { return g.E(xx1) }], 
+    g_EXnullX: [function({g}) { return g.E(null) }], 
+    g_EXlistXnullXX: [function({g, xx1}) { return g.E(xx1) }], 
+    g_EX11_nullX: [function({g, eid11}) { return g.E(eid11, null) }], 
     g_V_EX11X: [function({g, eid11}) { return g.V().E(eid11) }], 
     g_EX11X_E: [function({g, eid11}) { return g.E(eid11).E() }], 
     g_V_EXnullX: [function({g}) { return g.V().E(null) }], 
@@ -794,10 +803,6 @@ const gremlins = {
     g_V_elementMap_formatXstrX: [function({g}) { return g.V().elementMap().format("%{name} is %{age} years old") }], 
     g_V_hasLabelXpersonX_asXaX_valuesXnameX_asXp1X_selectXaX_inXknowsX_formatXstrX: [function({g}) { return g.V().hasLabel("person").as("a").values("name").as("p1").select("a").in_("knows").format("%{p1} knows %{name}") }], 
     g_V_asXsX_label_asXsubjectX_selectXsX_outE_asXpX_label_asXpredicateX_selectXpX_inV_label_asXobjectX_formatXstrX: [function({g}) { return g.V().as("s").label().as("subject").select("s").outE().as("p").label().as("predicate").select("p").inV().label().as("object").format("%{subject} %{predicate} %{object}") }], 
-    g_VX1X_V_valuesXnameX: [function({g, vid1}) { return g.V(vid1).V().values("name") }], 
-    g_V_outXknowsX_V_name: [function({g}) { return g.V().out("knows").V().values("name") }], 
-    g_V_hasXname_GarciaX_inXsungByX_asXsongX_V_hasXname_Willie_DixonX_inXwrittenByX_whereXeqXsongXX_name: [function({g}) { return g.V().has("artist", "name", "Garcia").in_("sungBy").as("song").V().has("artist", "name", "Willie_Dixon").in_("writtenBy").where(P.eq("song")).values("name") }], 
-    g_V_hasLabelXpersonX_asXpX_VXsoftwareX_addInEXuses_pX: [function({g, xx1, vid1, vid2, vid3, vid4, vid5, vid6}) { return g.addV("person").property("name", "marko").property("age", 29).as("marko").addV("person").property("name", "vadas").property("age", 27).as("vadas").addV("software").property("name", "lop").property("lang", "java").as("lop").addV("person").property("name", "josh").property("age", 32).as("josh").addV("software").property("name", "ripple").property("lang", "java").as(" [...]
     g_V_hasLabelXsoftwareX_index_unfold: [function({g}) { return g.V().hasLabel("software").index().unfold() }], 
     g_V_hasLabelXsoftwareX_order_byXnameX_index_withXmapX: [function({g}) { return g.V().hasLabel("software").order().by("name").index().with_(WithOptions.indexer, WithOptions.map) }], 
     g_V_hasLabelXsoftwareX_name_fold_orderXlocalX_index_unfold_order_byXtailXlocal_1XX: [function({g}) { return g.V().hasLabel("software").values("name").fold().order(Scope.local).index().unfold().order().by(__.tail(Scope.local, 1)) }], 
@@ -1357,15 +1362,6 @@ const gremlins = {
     g_VX1X_out: [function({g, vid1}) { return g.V(vid1).out() }], 
     g_VX2X_in: [function({g, vid2}) { return g.V(vid2).in_() }], 
     g_VX4X_both: [function({g, vid4}) { return g.V(vid4).both() }], 
-    g_E: [function({g}) { return g.E() }], 
-    g_EX11X: [function({g, eid11}) { return g.E(eid11) }], 
-    g_EX11AsStringX: [function({g, eid11}) { return g.E(eid11) }], 
-    g_EXe11X: [function({g, e11}) { return g.E(e11) }], 
-    g_EXe7_e11X: [function({g, e7, e11}) { return g.E(e7, e11) }], 
-    g_EXlistXe7_e11XX: [function({g, xx1}) { return g.E(xx1) }], 
-    g_EXnullX: [function({g}) { return g.E(null) }], 
-    g_EXlistXnullXX: [function({g, xx1}) { return g.E(xx1) }], 
-    g_EX11_nullX: [function({g, eid11}) { return g.E(eid11, null) }], 
     g_VX1X_outE: [function({g, vid1}) { return g.V(vid1).outE() }], 
     g_VX2X_outE: [function({g, vid2}) { return g.V(vid2).inE() }], 
     g_VX4X_bothEXcreatedX: [function({g, vid4}) { return g.V(vid4).bothE("created") }], 
@@ -1395,6 +1391,10 @@ const gremlins = {
     g_V_hasLabelXloopsX_bothXselfX: [function({g}) { return g.V().hasLabel("loops").both("self") }], 
     g_injectX1X_VXnullX: [function({g}) { return g.inject(1).V(null) }], 
     g_injectX1X_VX1_nullX: [function({g, vid1}) { return g.inject(1).V(vid1, null) }], 
+    g_VX1X_V_valuesXnameX: [function({g, vid1}) { return g.V(vid1).V().values("name") }], 
+    g_V_outXknowsX_V_name: [function({g}) { return g.V().out("knows").V().values("name") }], 
+    g_V_hasXname_GarciaX_inXsungByX_asXsongX_V_hasXname_Willie_DixonX_inXwrittenByX_whereXeqXsongXX_name: [function({g}) { return g.V().has("artist", "name", "Garcia").in_("sungBy").as("song").V().has("artist", "name", "Willie_Dixon").in_("writtenBy").where(P.eq("song")).values("name") }], 
+    g_V_hasLabelXpersonX_asXpX_VXsoftwareX_addInEXuses_pX: [function({g, xx1, vid1, vid2, vid3, vid4, vid5, vid6}) { return g.addV("person").property("name", "marko").property("age", 29).as("marko").addV("person").property("name", "vadas").property("age", 27).as("vadas").addV("software").property("name", "lop").property("lang", "java").as("lop").addV("person").property("name", "josh").property("age", 32).as("josh").addV("software").property("name", "ripple").property("lang", "java").as(" [...]
     InjectXnullX_eqXnullX: [function({g}) { return g.inject(null).is(P.eq(null)) }], 
     InjectXnullX_neqXnullX: [function({g}) { return g.inject(null).is(P.neq(null)) }], 
     InjectXnullX_ltXnullX: [function({g}) { return g.inject(null).is(P.lt(null)) }], 
@@ -1661,6 +1661,8 @@ const gremlins = {
     g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX: [function({g, xx1}) { return g.withSideEffect("a", xx1).V().both().values("name").store("a").cap("a") }], 
     g_withSideEffectXa_set_inlineX_V_both_name_storeXaX_capXaX: [function({g}) { return g.withSideEffect("a", new Set(["alice"])).V().both().values("name").store("a").cap("a") }], 
     g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX: [function({g}) { return g.V().store("a").by(__.outE("created").count()).out().out().store("a").by(__.inE("created").values("weight").sum()).cap("a") }], 
+    g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX: [function({g, vid1}) { return g.V(vid1).outE("knows").subgraph("sg").values("name").cap("sg") }], 
+    g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX: [function({g}) { return g.V().repeat(__.bothE("created").subgraph("sg").outV()).times(5).values("name").dedup().cap("sg") }], 
 }
 
 exports.gremlin = gremlins
diff --git a/gremlin-python/src/main/python/radish/feature_steps.py b/gremlin-python/src/main/python/radish/feature_steps.py
index 6b1e0110c6..75659da2e7 100644
--- a/gremlin-python/src/main/python/radish/feature_steps.py
+++ b/gremlin-python/src/main/python/radish/feature_steps.py
@@ -36,6 +36,8 @@ project = __.project
 tail = __.tail
 
 ignores = [
+    "g.V(vid1).outE(\"knows\").subgraph(\"sg\").values(\"name\").cap(\"sg\")",
+    "g.V().repeat(__.bothE(\"created\").subgraph(\"sg\").outV()).times(5).values(\"name\").dedup().cap(\"sg\")",
     "g.V().choose(has(T.label, \"person\"),values(\"age\").groupCount(\"a\"), values(\"name\").groupCount(\"b\")).cap(\"a\", \"b\").unfold()", # uses embedded Map in assertion
     "g.withSideEffect(\"x\",{}).V().both().both().sideEffect(__.store(\"x\").by(\"name\")).cap(\"x\").unfold()", # Objects must be both of Map or Collection: a=LinkedHashMap b=BulkSet???
     "g.withoutStrategies(CountStrategy).V().count()" # serialization issues with Class in GraphSON
diff --git a/gremlin-python/src/main/python/radish/gremlin.py b/gremlin-python/src/main/python/radish/gremlin.py
index 1ecb050051..b9ba790cec 100644
--- a/gremlin-python/src/main/python/radish/gremlin.py
+++ b/gremlin-python/src/main/python/radish/gremlin.py
@@ -741,6 +741,15 @@ world.gremlins = {
     'g_injectXa_null_bX_disjunctXa_cX': [(lambda g, xx1=None,xx2=None:g.inject(xx1).disjunct(xx2))], 
     'g_injectXa_null_bX_disjunctXa_null_cX': [(lambda g, xx1=None,xx2=None:g.inject(xx1).disjunct(xx2))], 
     'g_injectX3_threeX_disjunctXfive_three_7X': [(lambda g, xx1=None,xx2=None:g.inject(xx1).disjunct(xx2))], 
+    'g_E': [(lambda g:g.E())], 
+    'g_EX11X': [(lambda g, eid11=None:g.E(eid11))], 
+    'g_EX11AsStringX': [(lambda g, eid11=None:g.E(eid11))], 
+    'g_EXe11X': [(lambda g, e11=None:g.E(e11))], 
+    'g_EXe7_e11X': [(lambda g, e7=None,e11=None:g.E(e7, e11))], 
+    'g_EXlistXe7_e11XX': [(lambda g, xx1=None:g.E(xx1))], 
+    'g_EXnullX': [(lambda g:g.E(None))], 
+    'g_EXlistXnullXX': [(lambda g, xx1=None:g.E(xx1))], 
+    'g_EX11_nullX': [(lambda g, eid11=None:g.E(eid11, None))], 
     'g_V_EX11X': [(lambda g, eid11=None:g.V().E(eid11))], 
     'g_EX11X_E': [(lambda g, eid11=None:g.E(eid11).E())], 
     'g_V_EXnullX': [(lambda g:g.V().E(None))], 
@@ -776,10 +785,6 @@ world.gremlins = {
     'g_V_elementMap_formatXstrX': [(lambda g:g.V().element_map().format_('%{name} is %{age} years old'))], 
     'g_V_hasLabelXpersonX_asXaX_valuesXnameX_asXp1X_selectXaX_inXknowsX_formatXstrX': [(lambda g:g.V().has_label('person').as_('a').values('name').as_('p1').select('a').in_('knows').format_('%{p1} knows %{name}'))], 
     'g_V_asXsX_label_asXsubjectX_selectXsX_outE_asXpX_label_asXpredicateX_selectXpX_inV_label_asXobjectX_formatXstrX': [(lambda g:g.V().as_('s').label().as_('subject').select('s').out_e().as_('p').label().as_('predicate').select('p').in_v().label().as_('object').format_('%{subject} %{predicate} %{object}'))], 
-    'g_VX1X_V_valuesXnameX': [(lambda g, vid1=None:g.V(vid1).V().values('name'))], 
-    'g_V_outXknowsX_V_name': [(lambda g:g.V().out('knows').V().values('name'))], 
-    'g_V_hasXname_GarciaX_inXsungByX_asXsongX_V_hasXname_Willie_DixonX_inXwrittenByX_whereXeqXsongXX_name': [(lambda g:g.V().has('artist', 'name', 'Garcia').in_('sungBy').as_('song').V().has('artist', 'name', 'Willie_Dixon').in_('writtenBy').where(P.eq('song')).values('name'))], 
-    'g_V_hasLabelXpersonX_asXpX_VXsoftwareX_addInEXuses_pX': [(lambda g, xx1=None,vid1=None,vid2=None,vid3=None,vid4=None,vid5=None,vid6=None:g.add_v('person').property('name', 'marko').property('age', 29).as_('marko').add_v('person').property('name', 'vadas').property('age', 27).as_('vadas').add_v('software').property('name', 'lop').property('lang', 'java').as_('lop').add_v('person').property('name', 'josh').property('age', 32).as_('josh').add_v('software').property('name', 'ripple').pr [...]
     'g_V_hasLabelXsoftwareX_index_unfold': [(lambda g:g.V().has_label('software').index().unfold())], 
     'g_V_hasLabelXsoftwareX_order_byXnameX_index_withXmapX': [(lambda g:g.V().has_label('software').order().by('name').index().with_(WithOptions.indexer, WithOptions.map))], 
     'g_V_hasLabelXsoftwareX_name_fold_orderXlocalX_index_unfold_order_byXtailXlocal_1XX': [(lambda g:g.V().has_label('software').values('name').fold().order(Scope.local).index().unfold().order().by(__.tail(Scope.local, 1)))], 
@@ -1339,15 +1344,6 @@ world.gremlins = {
     'g_VX1X_out': [(lambda g, vid1=None:g.V(vid1).out())], 
     'g_VX2X_in': [(lambda g, vid2=None:g.V(vid2).in_())], 
     'g_VX4X_both': [(lambda g, vid4=None:g.V(vid4).both())], 
-    'g_E': [(lambda g:g.E())], 
-    'g_EX11X': [(lambda g, eid11=None:g.E(eid11))], 
-    'g_EX11AsStringX': [(lambda g, eid11=None:g.E(eid11))], 
-    'g_EXe11X': [(lambda g, e11=None:g.E(e11))], 
-    'g_EXe7_e11X': [(lambda g, e7=None,e11=None:g.E(e7, e11))], 
-    'g_EXlistXe7_e11XX': [(lambda g, xx1=None:g.E(xx1))], 
-    'g_EXnullX': [(lambda g:g.E(None))], 
-    'g_EXlistXnullXX': [(lambda g, xx1=None:g.E(xx1))], 
-    'g_EX11_nullX': [(lambda g, eid11=None:g.E(eid11, None))], 
     'g_VX1X_outE': [(lambda g, vid1=None:g.V(vid1).out_e())], 
     'g_VX2X_outE': [(lambda g, vid2=None:g.V(vid2).in_e())], 
     'g_VX4X_bothEXcreatedX': [(lambda g, vid4=None:g.V(vid4).both_e('created'))], 
@@ -1377,6 +1373,10 @@ world.gremlins = {
     'g_V_hasLabelXloopsX_bothXselfX': [(lambda g:g.V().has_label('loops').both('self'))], 
     'g_injectX1X_VXnullX': [(lambda g:g.inject(1).V(None))], 
     'g_injectX1X_VX1_nullX': [(lambda g, vid1=None:g.inject(1).V(vid1, None))], 
+    'g_VX1X_V_valuesXnameX': [(lambda g, vid1=None:g.V(vid1).V().values('name'))], 
+    'g_V_outXknowsX_V_name': [(lambda g:g.V().out('knows').V().values('name'))], 
+    'g_V_hasXname_GarciaX_inXsungByX_asXsongX_V_hasXname_Willie_DixonX_inXwrittenByX_whereXeqXsongXX_name': [(lambda g:g.V().has('artist', 'name', 'Garcia').in_('sungBy').as_('song').V().has('artist', 'name', 'Willie_Dixon').in_('writtenBy').where(P.eq('song')).values('name'))], 
+    'g_V_hasLabelXpersonX_asXpX_VXsoftwareX_addInEXuses_pX': [(lambda g, xx1=None,vid1=None,vid2=None,vid3=None,vid4=None,vid5=None,vid6=None:g.add_v('person').property('name', 'marko').property('age', 29).as_('marko').add_v('person').property('name', 'vadas').property('age', 27).as_('vadas').add_v('software').property('name', 'lop').property('lang', 'java').as_('lop').add_v('person').property('name', 'josh').property('age', 32).as_('josh').add_v('software').property('name', 'ripple').pr [...]
     'InjectXnullX_eqXnullX': [(lambda g:g.inject(None).is_(P.eq(None)))], 
     'InjectXnullX_neqXnullX': [(lambda g:g.inject(None).is_(P.neq(None)))], 
     'InjectXnullX_ltXnullX': [(lambda g:g.inject(None).is_(P.lt(None)))], 
@@ -1643,4 +1643,6 @@ world.gremlins = {
     'g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX': [(lambda g, xx1=None:g.with_side_effect('a', xx1).V().both().values('name').store('a').cap('a'))], 
     'g_withSideEffectXa_set_inlineX_V_both_name_storeXaX_capXaX': [(lambda g:g.with_side_effect('a', {'alice'}).V().both().values('name').store('a').cap('a'))], 
     'g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX': [(lambda g:g.V().store('a').by(__.out_e('created').count()).out().out().store('a').by(__.in_e('created').values('weight').sum_()).cap('a'))], 
+    'g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX': [(lambda g, vid1=None:g.V(vid1).out_e('knows').subgraph('sg').values('name').cap('sg'))], 
+    'g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX': [(lambda g:g.V().repeat(__.both_e('created').subgraph('sg').out_v()).times(5).values('name').dedup().cap('sg'))], 
 }
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteComputerFeatureTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteComputerFeatureTest.java
index 3b610a8041..0d04270b1f 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteComputerFeatureTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteComputerFeatureTest.java
@@ -30,8 +30,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerVerificationElementSupported and " +
-        "not @GraphComputerVerificationReferenceOnly and not @InsertionOrderingRequired",
+        tags = "not @RemoteOnly",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = GraphBinaryRemoteComputerFeatureTest.RemoteGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteComputerFeatureTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteComputerFeatureTest.java
index ed170e470f..2f9b17742b 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteComputerFeatureTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteComputerFeatureTest.java
@@ -30,7 +30,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerVerificationElementSupported",
+        tags = "not @RemoteOnly",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = GraphSONRemoteComputerFeatureTest.RemoteGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/RemoteWorld.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/RemoteWorld.java
index e6a18ea753..966d50cf4a 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/RemoteWorld.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/RemoteWorld.java
@@ -114,10 +114,15 @@ public abstract class RemoteWorld implements World {
         private static final List<String> TAGS_TO_IGNORE = Arrays.asList(
                 "@StepDrop",
                 "@StepInject",
-                "@StepV",
-                "@StepE",
+                "@StepMidV",
+                "@StepMidE",
+                "@StepSubgraph",
+                "@InsertionOrderingRequired",
+                "@StepIndex",
+                "@GraphComputerVerificationElementSupported",
                 "@GraphComputerVerificationOneBulk",
                 "@GraphComputerVerificationStrategyNotSupported",
+                "@GraphComputerVerificationMidENotSupported",
                 "@GraphComputerVerificationMidVNotSupported",
                 "@GraphComputerVerificationInjectionNotSupported",
                 "@GraphComputerVerificationStarGraphExceeded",
@@ -135,6 +140,8 @@ public abstract class RemoteWorld implements World {
             final List<String> ignores = TAGS_TO_IGNORE.stream().filter(t -> scenario.getSourceTagNames().contains(t)).collect(Collectors.toList());
             if (!ignores.isEmpty())
                 throw new AssumptionViolatedException(String.format("This scenario is not supported with GraphComputer: %s", ignores));
+
+            super.beforeEachScenario(scenario);
         }
 
         @Override
@@ -173,6 +180,17 @@ public abstract class RemoteWorld implements World {
 
     public static class GraphSONRemoteWorld extends RemoteWorld {
         public GraphSONRemoteWorld() { super(createTestCluster(Serializers.GRAPHSON_V3)); }
+
+        @Override
+        public void beforeEachScenario(final Scenario scenario) {
+            // not sure if it is expected or not that subgraph() does not work with GraphSON fully.
+            // getting serialization problems
+            final List<String> ignores = Arrays.asList("@StepSubgraph").stream().filter(t -> scenario.getSourceTagNames().contains(t)).collect(Collectors.toList());
+            if (!ignores.isEmpty())
+                throw new AssumptionViolatedException(String.format("This scenario is not supported with GraphComputer: %s", ignores));
+
+            super.beforeEachScenario(scenario);
+        }
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
index cefdc619dc..14e115e885 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
@@ -39,9 +39,11 @@ import org.apache.tinkerpop.gremlin.process.traversal.Path;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 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.util.ImmutablePath;
 import org.apache.tinkerpop.gremlin.structure.Direction;
 import org.apache.tinkerpop.gremlin.structure.Edge;
+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;
@@ -58,7 +60,9 @@ import org.junit.AssumptionViolatedException;
 
 import static org.apache.commons.text.StringEscapeUtils.escapeJava;
 import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData;
+import static org.apache.tinkerpop.gremlin.process.traversal.P.eq;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsEqual.equalTo;
 import static org.hamcrest.core.Every.everyItem;
 import static org.hamcrest.core.IsInstanceOf.instanceOf;
 import static org.hamcrest.core.StringContains.containsStringIgnoringCase;
@@ -80,6 +84,7 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -374,6 +379,60 @@ public final class StepDefinition {
             fail(String.format("Missing an assert for this type", result.getClass()));
     }
 
+    @Then("the result should be a subgraph with edges")
+    public void theResultShouldBeASubgraphWithEdges(final DataTable dataTable) {
+        assertThatNoErrorWasThrown();
+
+        // result should be a graph
+        assertThat(result, instanceOf(Graph.class));
+
+        // pop a graph traversal source from what was returned so we can use it for assertions
+        final GraphTraversalSource sg = ((Graph) result).traversal();
+
+        // grab the expected edges in the subgraph
+        final List<Edge> expectedEdges = dataTable.asList().stream().map(this::convertToObject).
+                map(e -> (Edge) e).collect(Collectors.toList());
+
+        // assert the structure of the subgraph. there should be no references here as this is serialized as
+        // a full TinkerGraph. also, ids should be the same as they are in the source graph so we can use all
+        // of this to do a complete assertion. there is only support for the modern graph right now but it
+        // wouldn't be hard to add others.
+        for (Edge edge : expectedEdges) {
+            assertThat(sg.E(edge.id()).
+                          has(edge.label(), "weight", eq(edge.value("weight"))).
+                          filter(__.outV().hasId(edge.outVertex().id())).
+                          filter(__.inV().hasId(edge.inVertex().id())).hasNext(),
+                    equalTo(true));
+        }
+    }
+
+    @Then("the result should be a subgraph with vertices")
+    public void theResultShouldBeASubgraphWithVertices(final DataTable dataTable) {
+        assertThatNoErrorWasThrown();
+
+        // result should be a graph
+        assertThat(result, instanceOf(Graph.class));
+
+        // pop a graph traversal source from what was returned so we can use it for assertions
+        final GraphTraversalSource sg = ((Graph) result).traversal();
+
+        // grab the expected vertex in the subgraph
+        final List<Vertex> expectedEdges = dataTable.asList().stream().map(this::convertToObject).
+                map(v -> (Vertex) v).collect(Collectors.toList());
+
+        // assert the structure of the subgraph. there should be no references here as this is serialized as
+        // a full TinkerGraph. also, ids should be the same as they are in the source graph so we can use all
+        // of this to do a complete assertion. there is only support for the modern graph right now but it
+        // wouldn't be hard to add others.
+        for (Vertex vertex : expectedEdges) {
+            final String variableKey = vertex.label().equals("person") ? "age" : "lang";
+
+            assertThat(sg.V(vertex.id()).has(vertex.label(), "name", eq(vertex.value("name"))).
+                            has(variableKey, eq(vertex.value(variableKey))).hasNext(),
+                    equalTo(true));
+        }
+    }
+
     @Then("the graph should return {int} for count of {string}")
     public void theGraphShouldReturnForCountOf(final Integer count, final String gremlin) {
         assertThatNoErrorWasThrown();
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
index f85568902f..68b3bebbc0 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
@@ -62,7 +62,6 @@ public class ProcessEmbeddedComputerSuite extends AbstractGremlinSuite {
             ProgramTest.Traversals.class,
             WriteTest.Traversals.class,
             ExplainTest.Traversals.class,
-            SubgraphTest.Traversals.class,
             TreeTest.Traversals.class,
             LambdaStepTest.Traversals.class,
 
@@ -89,7 +88,6 @@ public class ProcessEmbeddedComputerSuite extends AbstractGremlinSuite {
             MatchTest.class,
             ProfileTest.class,
             ProgramTest.class,
-            SubgraphTest.class,
             TreeTest.class
     };
 
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
index 2f746a49e3..086fa1fcc6 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
@@ -22,19 +22,16 @@ import org.apache.tinkerpop.gremlin.AbstractGremlinSuite;
 import org.apache.tinkerpop.gremlin.process.traversal.CoreTraversalTest;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalInterruptionTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.ComplexTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.LambdaStepTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.TernaryBooleanLogicsTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProfileTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.WriteTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.ExplainTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.TreeTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ElementIdStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.EventStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.PartitionStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.TranslationStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.EarlyLimitStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IncidentToAdjacentStrategyProcessTest;
@@ -62,7 +59,6 @@ public class ProcessEmbeddedStandardSuite extends AbstractGremlinSuite {
             ProfileTest.Traversals.class,
             WriteTest.Traversals.class,
             ExplainTest.Traversals.class,
-            SubgraphTest.Traversals.class,
             TreeTest.Traversals.class,
 
             // compliance
@@ -89,7 +85,6 @@ public class ProcessEmbeddedStandardSuite extends AbstractGremlinSuite {
      */
     private static final Class<?>[] testsToEnforce = new Class<?>[]{
             ProfileTest.class,
-            SubgraphTest.class,
             TreeTest.class,
     };
 
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Edge.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Edge.feature
index f3d92320d2..70a5510558 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Edge.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Edge.feature
@@ -18,6 +18,117 @@
 @StepClassMap @StepE
 Feature: Step - E()
 
+  Scenario: g_E
+    Given the modern graph
+    And the traversal of
+      """
+      g.E()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | e[marko-created->lop] |
+      | e[marko-knows->josh] |
+      | e[marko-knows->vadas] |
+      | e[peter-created->lop] |
+      | e[josh-created->lop] |
+      | e[josh-created->ripple] |
+
+  Scenario: g_EX11X
+    Given the modern graph
+    And using the parameter eid11 defined as "e[josh-created->lop].id"
+    And the traversal of
+      """
+      g.E(eid11)
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | e[josh-created->lop] |
+
+  Scenario: g_EX11AsStringX
+    Given the modern graph
+    And using the parameter eid11 defined as "e[josh-created->lop].sid"
+    And the traversal of
+      """
+      g.E(eid11)
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | e[josh-created->lop] |
+
+  Scenario: g_EXe11X
+    Given the modern graph
+    And using the parameter e11 defined as "e[josh-created->lop]"
+    And the traversal of
+      """
+      g.E(e11)
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | e[josh-created->lop] |
+
+  Scenario: g_EXe7_e11X
+    Given the modern graph
+    And using the parameter e7 defined as "e[marko-knows->vadas]"
+    And using the parameter e11 defined as "e[josh-created->lop]"
+    And the traversal of
+      """
+      g.E(e7,e11)
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | e[marko-knows->vadas] |
+      | e[josh-created->lop] |
+
+  Scenario: g_EXlistXe7_e11XX
+    Given the modern graph
+    And using the parameter xx1 defined as "l[e[marko-knows->vadas],e[josh-created->lop]]"
+    And the traversal of
+      """
+      g.E(xx1)
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | e[marko-knows->vadas] |
+      | e[josh-created->lop] |
+
+  Scenario: g_EXnullX
+    Given the modern graph
+    And the traversal of
+      """
+      g.E(null)
+      """
+    When iterated to list
+    Then the result should be empty
+
+  Scenario: g_EXlistXnullXX
+    Given the modern graph
+    And using the parameter xx1 defined as "l[null]"
+    And the traversal of
+      """
+      g.E(xx1)
+      """
+    When iterated to list
+    Then the result should be empty
+
+  Scenario: g_EX11_nullX
+    Given the modern graph
+    And using the parameter eid11 defined as "e[josh-created->lop].id"
+    And the traversal of
+      """
+      g.E(eid11,null)
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | e[josh-created->lop] |
+
+  @GraphComputerVerificationMidENotSupported
   Scenario: g_V_EX11X
     Given the modern graph
     And using the parameter eid11 defined as "e[josh-created->lop].id"
@@ -35,6 +146,7 @@ Feature: Step - E()
       | e[josh-created->lop] |
       | e[josh-created->lop] |
 
+  @GraphComputerVerificationMidENotSupported
   Scenario: g_EX11X_E
     Given the modern graph
     And using the parameter eid11 defined as "e[josh-created->lop].id"
@@ -51,7 +163,8 @@ Feature: Step - E()
       | e[peter-created->lop] |
       | e[josh-created->lop] |
       | e[josh-created->ripple] |
-      
+
+  @GraphComputerVerificationMidENotSupported
   Scenario: g_V_EXnullX
     Given the modern graph
     And the traversal of
@@ -61,6 +174,7 @@ Feature: Step - E()
     When iterated to list
     Then the result should be empty
 
+  @GraphComputerVerificationMidENotSupported
   Scenario: g_V_EXlistXnullXX
     Given the modern graph
     And using the parameter xx1 defined as "l[null]"
@@ -71,6 +185,7 @@ Feature: Step - E()
     When iterated to list
     Then the result should be empty
 
+  @GraphComputerVerificationMidENotSupported
   Scenario: g_injectX1X_EX11_nullX
     Given the modern graph
     And using the parameter eid11 defined as "e[josh-created->lop].id"
@@ -83,7 +198,8 @@ Feature: Step - E()
       | result |
       | e[josh-created->lop] |
 
- Scenario: g_injectX1X_coalesceXEX_hasLabelXtestsX_addEXtestsX_from_V_hasXnameX_XjoshXX_toXV_hasXnameX_XvadasXXX
+  @GraphComputerVerificationMidENotSupported
+  Scenario: g_injectX1X_coalesceXEX_hasLabelXtestsX_addEXtestsX_from_V_hasXnameX_XjoshXX_toXV_hasXnameX_XvadasXXX
     Given the empty graph
     And the graph initializer of
       """
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Graph.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Graph.feature
deleted file mode 100644
index d86ae75bd4..0000000000
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Graph.feature
+++ /dev/null
@@ -1,109 +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.
-
-@StepClassMap @StepV
-Feature: Step - V()
-
-  Scenario: g_VX1X_V_valuesXnameX
-    Given the modern graph
-    And using the parameter vid1 defined as "v[marko].id"
-    And the traversal of
-      """
-      g.V(vid1).V().values("name")
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | marko  |
-      | vadas |
-      | lop   |
-      | josh |
-      | ripple |
-      | peter  |
-
-  Scenario: g_V_outXknowsX_V_name
-    Given the modern graph
-    And the traversal of
-      """
-      g.V().out("knows").V().values("name")
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | marko  |
-      | marko  |
-      | vadas |
-      | vadas |
-      | lop   |
-      | lop   |
-      | josh |
-      | josh |
-      | ripple |
-      | ripple |
-      | peter  |
-      | peter  |
-
-  Scenario: g_V_hasXname_GarciaX_inXsungByX_asXsongX_V_hasXname_Willie_DixonX_inXwrittenByX_whereXeqXsongXX_name
-    Given the grateful graph
-    And the traversal of
-      """
-      g.V().has("artist", "name", "Garcia").in("sungBy").as("song").
-        V().has("artist", "name", "Willie_Dixon").in("writtenBy").where(P.eq("song")).values("name")
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | MY BABE |
-      | HOOCHIE COOCHIE MAN |
-
-  Scenario: g_V_hasLabelXpersonX_asXpX_VXsoftwareX_addInEXuses_pX
-    Given the empty graph
-    And the graph initializer of
-      """
-      g.addV("person").property("name", "marko").property("age", 29).as("marko").
-        addV("person").property("name", "vadas").property("age", 27).as("vadas").
-        addV("software").property("name", "lop").property("lang", "java").as("lop").
-        addV("person").property("name","josh").property("age", 32).as("josh").
-        addV("software").property("name", "ripple").property("lang", "java").as("ripple").
-        addV("person").property("name", "peter").property("age", 35).as('peter').
-        addE("knows").from("marko").to("vadas").property("weight", 0.5d).
-        addE("knows").from("marko").to("josh").property("weight", 1.0d).
-        addE("created").from("marko").to("lop").property("weight", 0.4d).
-        addE("created").from("josh").to("ripple").property("weight", 1.0d).
-        addE("created").from("josh").to("lop").property("weight", 0.4d).
-        addE("created").from("peter").to("lop").property("weight", 0.2d)
-      """
-    And using the parameter xx1 defined as "l[v[lop],v[ripple]]"
-    And using the parameter vid1 defined as "v[marko].id"
-    And using the parameter vid2 defined as "v[vadas].id"
-    And using the parameter vid3 defined as "v[lop].id"
-    And using the parameter vid4 defined as "v[josh].id"
-    And using the parameter vid5 defined as "v[ripple].id"
-    And using the parameter vid6 defined as "v[peter].id"
-    And the traversal of
-      """
-      g.V().hasLabel("person").as("p").V(xx1).addE("uses").from("p")
-      """
-    When iterated to list
-    Then the result should have a count of 8
-    And the graph should return 8 for count of "g.E().hasLabel(\"uses\")"
-    And the graph should return 2 for count of "g.V(vid1).outE(\"uses\")"
-    And the graph should return 2 for count of "g.V(vid2).outE(\"uses\")"
-    And the graph should return 4 for count of "g.V(vid3).inE(\"uses\")"
-    And the graph should return 2 for count of "g.V(vid4).outE(\"uses\")"
-    And the graph should return 4 for count of "g.V(vid5).inE(\"uses\")"
-    And the graph should return 2 for count of "g.V(vid6).outE(\"uses\")"
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Vertex.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Vertex.feature
index f0b3c95a93..0d835cb5f5 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Vertex.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Vertex.feature
@@ -16,7 +16,7 @@
 # under the License.
 
 @StepClassMap @StepVertex
-Feature: Step - V(), E(), out(), in(), both(), inE(), outE(), bothE()
+Feature: Step - V(), out(), in(), both(), inE(), outE(), bothE()
 
   Scenario: g_VXnullX
     Given the modern graph
@@ -147,116 +147,6 @@ Feature: Step - V(), E(), out(), in(), both(), inE(), outE(), bothE()
       | v[lop] |
       | v[ripple] |
 
-  Scenario: g_E
-    Given the modern graph
-    And the traversal of
-      """
-      g.E()
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | e[marko-created->lop] |
-      | e[marko-knows->josh] |
-      | e[marko-knows->vadas] |
-      | e[peter-created->lop] |
-      | e[josh-created->lop] |
-      | e[josh-created->ripple] |
-
-  Scenario: g_EX11X
-    Given the modern graph
-    And using the parameter eid11 defined as "e[josh-created->lop].id"
-    And the traversal of
-      """
-      g.E(eid11)
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | e[josh-created->lop] |
-
-  Scenario: g_EX11AsStringX
-    Given the modern graph
-    And using the parameter eid11 defined as "e[josh-created->lop].sid"
-    And the traversal of
-      """
-      g.E(eid11)
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | e[josh-created->lop] |
-
-  Scenario: g_EXe11X
-    Given the modern graph
-    And using the parameter e11 defined as "e[josh-created->lop]"
-    And the traversal of
-      """
-      g.E(e11)
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | e[josh-created->lop] |
-
-  Scenario: g_EXe7_e11X
-    Given the modern graph
-    And using the parameter e7 defined as "e[marko-knows->vadas]"
-    And using the parameter e11 defined as "e[josh-created->lop]"
-    And the traversal of
-      """
-      g.E(e7,e11)
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | e[marko-knows->vadas] |
-      | e[josh-created->lop] |
-
-  Scenario: g_EXlistXe7_e11XX
-    Given the modern graph
-    And using the parameter xx1 defined as "l[e[marko-knows->vadas],e[josh-created->lop]]"
-    And the traversal of
-      """
-      g.E(xx1)
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | e[marko-knows->vadas] |
-      | e[josh-created->lop] |
-
-  Scenario: g_EXnullX
-    Given the modern graph
-    And the traversal of
-      """
-      g.E(null)
-      """
-    When iterated to list
-    Then the result should be empty
-
-  Scenario: g_EXlistXnullXX
-    Given the modern graph
-    And using the parameter xx1 defined as "l[null]"
-    And the traversal of
-      """
-      g.E(xx1)
-      """
-    When iterated to list
-    Then the result should be empty
-
-  Scenario: g_EX11_nullX
-    Given the modern graph
-    And using the parameter eid11 defined as "e[josh-created->lop].id"
-    And the traversal of
-      """
-      g.E(eid11,null)
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | e[josh-created->lop] |
-
   Scenario: g_VX1X_outE
     Given the modern graph
     And using the parameter vid1 defined as "v[marko].id"
@@ -663,4 +553,97 @@ Feature: Step - V(), E(), out(), in(), both(), inE(), outE(), bothE()
     When iterated to list
     Then the result should be unordered
       | result |
-      | v[marko] |
\ No newline at end of file
+      | v[marko] |
+
+  @GraphComputerVerificationMidENotSupported
+  Scenario: g_VX1X_V_valuesXnameX
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      g.V(vid1).V().values("name")
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | marko  |
+      | vadas |
+      | lop   |
+      | josh |
+      | ripple |
+      | peter  |
+
+  @GraphComputerVerificationMidENotSupported
+  Scenario: g_V_outXknowsX_V_name
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().out("knows").V().values("name")
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | marko  |
+      | marko  |
+      | vadas |
+      | vadas |
+      | lop   |
+      | lop   |
+      | josh |
+      | josh |
+      | ripple |
+      | ripple |
+      | peter  |
+      | peter  |
+
+  @GraphComputerVerificationMidENotSupported
+  Scenario: g_V_hasXname_GarciaX_inXsungByX_asXsongX_V_hasXname_Willie_DixonX_inXwrittenByX_whereXeqXsongXX_name
+    Given the grateful graph
+    And the traversal of
+      """
+      g.V().has("artist", "name", "Garcia").in("sungBy").as("song").
+        V().has("artist", "name", "Willie_Dixon").in("writtenBy").where(P.eq("song")).values("name")
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | MY BABE |
+      | HOOCHIE COOCHIE MAN |
+
+  Scenario: g_V_hasLabelXpersonX_asXpX_VXsoftwareX_addInEXuses_pX
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").property("name", "marko").property("age", 29).as("marko").
+        addV("person").property("name", "vadas").property("age", 27).as("vadas").
+        addV("software").property("name", "lop").property("lang", "java").as("lop").
+        addV("person").property("name","josh").property("age", 32).as("josh").
+        addV("software").property("name", "ripple").property("lang", "java").as("ripple").
+        addV("person").property("name", "peter").property("age", 35).as('peter').
+        addE("knows").from("marko").to("vadas").property("weight", 0.5d).
+        addE("knows").from("marko").to("josh").property("weight", 1.0d).
+        addE("created").from("marko").to("lop").property("weight", 0.4d).
+        addE("created").from("josh").to("ripple").property("weight", 1.0d).
+        addE("created").from("josh").to("lop").property("weight", 0.4d).
+        addE("created").from("peter").to("lop").property("weight", 0.2d)
+      """
+    And using the parameter xx1 defined as "l[v[lop],v[ripple]]"
+    And using the parameter vid1 defined as "v[marko].id"
+    And using the parameter vid2 defined as "v[vadas].id"
+    And using the parameter vid3 defined as "v[lop].id"
+    And using the parameter vid4 defined as "v[josh].id"
+    And using the parameter vid5 defined as "v[ripple].id"
+    And using the parameter vid6 defined as "v[peter].id"
+    And the traversal of
+      """
+      g.V().hasLabel("person").as("p").V(xx1).addE("uses").from("p")
+      """
+    When iterated to list
+    Then the result should have a count of 8
+    And the graph should return 8 for count of "g.E().hasLabel(\"uses\")"
+    And the graph should return 2 for count of "g.V(vid1).outE(\"uses\")"
+    And the graph should return 2 for count of "g.V(vid2).outE(\"uses\")"
+    And the graph should return 4 for count of "g.V(vid3).inE(\"uses\")"
+    And the graph should return 2 for count of "g.V(vid4).outE(\"uses\")"
+    And the graph should return 4 for count of "g.V(vid5).inE(\"uses\")"
+    And the graph should return 2 for count of "g.V(vid6).outE(\"uses\")"
\ No newline at end of file
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Subgraph.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Subgraph.feature
new file mode 100644
index 0000000000..93fb651fec
--- /dev/null
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Subgraph.feature
@@ -0,0 +1,55 @@
+# 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.
+
+@StepClassSideEffect @StepSubgraph
+Feature: Step - subgraph()
+
+  Scenario: g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      g.V(vid1).outE("knows").subgraph("sg").values("name").cap("sg")
+      """
+    When iterated next
+    Then the result should be a subgraph with edges
+      | e[marko-knows->josh] |
+      | e[marko-knows->vadas] |
+    And the result should be a subgraph with vertices
+      | v[marko] |
+      | v[vadas] |
+      | v[josh] |
+
+  Scenario: g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      g.V().repeat(__.bothE("created").subgraph("sg").outV()).times(5).values("name").dedup().cap("sg")
+      """
+    When iterated next
+    Then the result should be a subgraph with edges
+      | e[marko-created->lop] |
+      | e[josh-created->lop] |
+      | e[josh-created->ripple] |
+      | e[peter-created->lop] |
+    And the result should be a subgraph with vertices
+      | v[marko] |
+      | v[lop] |
+      | v[josh] |
+      | v[peter] |
+      | v[ripple] |
\ No newline at end of file
diff --git a/hadoop-gremlin/src/test/java/org/apache/tinkerpop/gremlin/hadoop/HadoopGraphFeatureIntegrateTest.java b/hadoop-gremlin/src/test/java/org/apache/tinkerpop/gremlin/hadoop/HadoopGraphFeatureIntegrateTest.java
index d98aa132c0..b9fad5f7c8 100644
--- a/hadoop-gremlin/src/test/java/org/apache/tinkerpop/gremlin/hadoop/HadoopGraphFeatureIntegrateTest.java
+++ b/hadoop-gremlin/src/test/java/org/apache/tinkerpop/gremlin/hadoop/HadoopGraphFeatureIntegrateTest.java
@@ -53,7 +53,7 @@ import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerOnly and not @TinkerServiceRegistry and not @GraphComputerVerificationElementSupported",
+        tags = "not @RemoteOnly and not @GraphComputerOnly and not @TinkerServiceRegistry and not @InsertionOrderingRequired",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = GuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/spark-gremlin/src/test/java/org/apache/tinkerpop/gremlin/spark/SparkGraphFeatureIntegrateTest.java b/spark-gremlin/src/test/java/org/apache/tinkerpop/gremlin/spark/SparkGraphFeatureIntegrateTest.java
index 03bd30c185..404bad3830 100644
--- a/spark-gremlin/src/test/java/org/apache/tinkerpop/gremlin/spark/SparkGraphFeatureIntegrateTest.java
+++ b/spark-gremlin/src/test/java/org/apache/tinkerpop/gremlin/spark/SparkGraphFeatureIntegrateTest.java
@@ -58,6 +58,7 @@ import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData;
 @RunWith(Cucumber.class)
 @CucumberOptions(
         tags = "not @RemoteOnly and not @StepDrop and not @StepV and not @StepE and not @StepIndex and not @StepInject and " +
+               "not @StepSubgraph and not @GraphComputerVerificationMidENotSupported and " +
                "not @GraphComputerVerificationOneBulk and not @GraphComputerVerificationStrategyNotSupported and " +
                "not @GraphComputerVerificationMidVNotSupported and not @GraphComputerVerificationElementSupported and " +
                "not @GraphComputerVerificationInjectionNotSupported and " +
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphComputerFeatureTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphComputerFeatureTest.java
index c519e1c416..51b39756e4 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphComputerFeatureTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphComputerFeatureTest.java
@@ -31,7 +31,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerVerificationElementSupported",
+        tags = "not @RemoteOnly",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = TinkerGraphComputerFeatureTest.TinkerGraphGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphComputerFeatureTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphComputerFeatureTest.java
index e0efdb9249..748c6dd609 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphComputerFeatureTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphComputerFeatureTest.java
@@ -31,7 +31,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerVerificationElementSupported",
+        tags = "not @RemoteOnly",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = TinkerTransactionGraphComputerFeatureTest.TinkerGraphGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerWorld.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerWorld.java
index 632f90e457..ca94f2d7ea 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerWorld.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerWorld.java
@@ -280,13 +280,19 @@ public abstract class TinkerWorld implements World {
     public static class ComputerWorld implements World {
         private static final Random RANDOM = TestHelper.RANDOM;
 
+        /**
+         * Defining these here allows them to be globally ignored for all {@code withComputer()} test setups.
+         */
         private static final List<String> TAGS_TO_IGNORE = Arrays.asList(
                 "@StepDrop",
                 "@StepInject",
-                "@StepV",
-                "@StepE",
+                "@StepSubgraph",
+                "@InsertionOrderingRequired",
+                "@StepIndex",
+                "@GraphComputerVerificationElementSupported",
                 "@GraphComputerVerificationOneBulk",
                 "@GraphComputerVerificationStrategyNotSupported",
+                "@GraphComputerVerificationMidENotSupported",
                 "@GraphComputerVerificationMidVNotSupported",
                 "@GraphComputerVerificationInjectionNotSupported",
                 "@GraphComputerVerificationStarGraphExceeded",


(tinkerpop) 02/11: TINKERPOP-3136 Setup embedded test suite

Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 0852cad54c95f124161a33e2fdbaf54f45d96e5c
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Fri Apr 11 19:06:30 2025 -0400

    TINKERPOP-3136 Setup embedded test suite
    
    Moved all lambda testing to LambdaStepTest for the java-based testing.
    Deprecated the "limited" tests in favor of a newly added "embedded" test suite.
    Removed all lambda tests from gherkin
    For as long as we support lambdas in GLVs with Groovy those will need to be tested indepdenently per language.
    Removed test index from mergeV/E as it hasn't been maintained.
---
 CHANGELOG.asciidoc                                 |   2 +
 docs/src/dev/developer/for-committers.asciidoc     |   4 +-
 .../apache/tinkerpop/gremlin/structure/Graph.java  |  10 +
 gremlin-dotnet/build/generate.groovy               |   5 +-
 .../Gherkin/CommonSteps.cs                         |   6 -
 .../Gherkin/GherkinTestRunner.cs                   |   2 +-
 .../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs |  54 +-
 gremlin-go/build/generate.groovy                   |   5 +-
 gremlin-go/driver/cucumber/cucumberSteps_test.go   |   6 -
 gremlin-go/driver/cucumber/gremlin.go              |  54 +-
 .../groovy/jsr223/GroovyTranslatorProvider.java    | 124 +--
 .../ParameterizedGroovyTranslatorProvider.java     | 124 +--
 gremlin-javascript/build/generate.groovy           |   7 +-
 .../test/cucumber/feature-steps.js                 |  11 +-
 .../gremlin-javascript/test/cucumber/gremlin.js    |  56 +-
 gremlin-python/build/generate.groovy               |   5 +-
 .../src/main/python/radish/feature_steps.py        |   8 +-
 gremlin-python/src/main/python/radish/gremlin.py   |  54 +-
 .../driver/remote/AbstractRemoteGraphProvider.java | 124 +--
 .../tinkerpop/gremlin/features/StepDefinition.java |  28 +-
 .../gremlin/process/ProcessComputerSuite.java      |   5 +
 .../process/ProcessEmbeddedComputerSuite.java      |   4 +-
 .../process/ProcessEmbeddedStandardSuite.java      |   5 +-
 .../gremlin/process/ProcessStandardSuite.java      |   6 +
 .../process/traversal/step/LambdaStepTest.java     | 846 +++++++++++++++++++++
 .../process/traversal/step/branch/BranchTest.java  |  17 -
 .../process/traversal/step/branch/ChooseTest.java  |  17 -
 .../process/traversal/step/branch/RepeatTest.java  |  23 -
 .../process/traversal/step/filter/FilterTest.java  | 137 +---
 .../process/traversal/step/filter/HasTest.java     |  15 -
 .../process/traversal/step/map/MapTest.java        | 110 ---
 .../process/traversal/step/map/OrderTest.java      |  57 --
 .../process/traversal/step/map/UnfoldTest.java     |  39 -
 .../traversal/step/sideEffect/GroupTest.java       |  49 --
 .../traversal/step/sideEffect/InjectTest.java      |  28 -
 .../traversal/step/sideEffect/SideEffectTest.java  | 222 +-----
 .../gremlin/test/features/branch/Branch.feature    |  23 -
 .../gremlin/test/features/branch/Choose.feature    |  17 -
 .../gremlin/test/features/branch/Repeat.feature    |  12 -
 .../gremlin/test/features/filter/Filter.feature    |  45 +-
 .../gremlin/test/features/filter/Has.feature       |  12 -
 .../gremlin/test/features/map/FlatMap.feature      |  20 +
 .../gremlin/test/features/map/Map.feature          |  41 +-
 .../gremlin/test/features/map/MergeEdge.feature    | 109 ---
 .../gremlin/test/features/map/MergeVertex.feature  |  84 --
 .../gremlin/test/features/map/Order.feature        |  28 -
 .../gremlin/test/features/map/Unfold.feature       |   5 +-
 .../gremlin/test/features/sideEffect/Group.feature |   5 +-
 .../test/features/sideEffect/Inject.feature        |   3 +-
 .../gremlin/test/features/sideEffect/Sack.feature  |   8 -
 .../test/features/sideEffect/SideEffect.feature    |  93 +++
 .../test/features/sideEffect/SideEffectCap.feature |  18 +-
 ...tractTinkerGraphGraphSONTranslatorProvider.java | 147 +---
 .../io/gryo/TinkerGraphGryoTranslatorProvider.java | 125 +--
 54 files changed, 1231 insertions(+), 1833 deletions(-)

diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index 0ab3bfe73e..c42edb1fde 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -56,6 +56,8 @@ This release also includes changes from <<release-3-7-XXX, 3.7.XXX>>.
 * Fixed `BigInt` and `BigDecimal` parsing in `gremlin-go` cucumber test suite, fixed `UnscaledValue` type in `BigDecimal` struct and added `ParseBigDecimal` method.
 * Added validation to `groupCount()` to prevent an invalid usage of multiple `by()` modulators.
 * Deprecated `ProcessLimitedStandardSuite` and `ProcessLimitedComputerSuite` in favor of `ProcessEmbeddedStandardSuite` and `ProcessEmbeddedComputerSuite` respectively.
+* Removed lambda oriented Gremlin testing from Gherkin test suite.
+* Moved all lambda oriented Gremlin tests to `LambdaStepTest` in the Java test suite.
 
 == TinkerPop 3.7.0 (Gremfir Master of the Pan Flute)
 
diff --git a/docs/src/dev/developer/for-committers.asciidoc b/docs/src/dev/developer/for-committers.asciidoc
index f0bd52d692..f0e0cda24c 100644
--- a/docs/src/dev/developer/for-committers.asciidoc
+++ b/docs/src/dev/developer/for-committers.asciidoc
@@ -402,7 +402,6 @@ brackets, optionally suffixed with some additional notation depending on the pri
 * Edge - *e[_xxx_]* - The "xxx" should be replaced with a representation of an edge in the form of the
 `vertex_name-edgelabel->vertex_name`. This syntax may also include the `.id` suffix which would indicate getting the
 edge identifier or the `.sid` suffix which gets a string representation of the edge identifier.
-* Lambda - *c[_xxx_]* - The "xxx" should contain a lambda written in Groovy.
 * List - *l[_xxx_,_yyy_,_zzz_,...]* - A comma separated collection of values that make up the list should be added to
 between the square brackets. These values respect the type system thus allowing for creation of lists of vertices,
 edges, maps, and any other available type. Spaces are taken literally, therefore it is important to avoid spaces unless
@@ -581,8 +580,7 @@ the traversal does not mind the star graph limitation.
 * `@InsertionOrderingRequired` - The scenario is reliant on the graph system predictably returning results (vertices, edges, properties) in the same order in which they were inserted into the graph.
 * `@MetaProperties` - The scenario makes use of meta-properties.
 * `@MultiProperties` - The scenario makes use of multi-properties.
-* `@RemoteOnly` - The scenario uses some Gremlin syntax that cannot be supported outside of remote test executions. The
-best example of this sort of test would be one that uses the remote `Lambda` syntax.
+* `@RemoteOnly` - The scenario uses some Gremlin syntax that cannot be supported outside of remote test executions.
 * `@UserSuppliedVertexIds` - The scenario relies on the vertex IDs specified in the dataset used by the scenario.
 * `@UserSuppliedEdgeIds` - The scenario relies on the edge IDs specified in the dataset used by the scenario.
 * `@UserSuppliedVertexPropertyIds` - The scenario relies on the vertex property IDs specified in the dataset used by the scenario.
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Graph.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Graph.java
index c256c12cc5..6e30fdc4d2 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Graph.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Graph.java
@@ -1274,8 +1274,18 @@ public interface Graph extends AutoCloseable, Host {
         String SUITE_STRUCTURE_INTEGRATE = "org.apache.tinkerpop.gremlin.structure.StructureIntegrateSuite";
         String SUITE_PROCESS_COMPUTER = "org.apache.tinkerpop.gremlin.process.ProcessComputerSuite";
         String SUITE_PROCESS_STANDARD = "org.apache.tinkerpop.gremlin.process.ProcessStandardSuite";
+        /**
+         * @deprecated As of release 3.8.0, replaced by {@link #SUITE_PROCESS_EMBEDDED_STANDARD}.
+         */
+        @Deprecated
         String SUITE_PROCESS_LIMITED_COMPUTER = "org.apache.tinkerpop.gremlin.process.ProcessLimitedComputerSuite";
+        /**
+         * @deprecated As of release 3.8.0, replaced by {@link #SUITE_PROCESS_EMBEDDED_COMPUTER}
+         */
+        @Deprecated
         String SUITE_PROCESS_LIMITED_STANDARD = "org.apache.tinkerpop.gremlin.process.ProcessLimitedStandardSuite";
+        String SUITE_PROCESS_EMBEDDED_COMPUTER = "org.apache.tinkerpop.gremlin.process.ProcessEmbeddedComputerSuite";
+        String SUITE_PROCESS_EMBEDDED_STANDARD = "org.apache.tinkerpop.gremlin.process.ProcessEmbeddedStandardSuite";
 
         /**
          * The test suite class to opt in to.
diff --git a/gremlin-dotnet/build/generate.groovy b/gremlin-dotnet/build/generate.groovy
index 4d5b943e79..36eae53cac 100644
--- a/gremlin-dotnet/build/generate.groovy
+++ b/gremlin-dotnet/build/generate.groovy
@@ -98,10 +98,7 @@ radishGremlinFile.withWriter('UTF-8') { Writer writer ->
     // SAMPLE: g_injectXnull_nullX: "               {\"g_injectXnull_nullX\", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null,null)}}, ",1\"]).Values<object>(\"age\").Inject(null,null)}}, "
 
     gremlins.each { k,v ->
-        // skipping lambdas until we decide for sure that they are out in 4.x
-        if (v.any { it.contains('l1')} || v.any { it.contains('pred1')} || v.any { it.contains('Lambda')}) {
-            writer.writeLine("               {\"${k}\", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda")
-        } else if (staticTranslate.containsKey(k)) {
+        if (staticTranslate.containsKey(k)) {
             writer.writeLine(staticTranslate[k])
         } else {
             writer.write("               {\"")
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/CommonSteps.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/CommonSteps.cs
index f6540019f4..cbf5c49120 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/CommonSteps.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/CommonSteps.cs
@@ -73,7 +73,6 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                 {@"l\[(.*)\]", ToList},
                 {@"s\[(.*)\]", ToSet},
                 {@"m\[(.+)\]", ToMap},
-                {@"c\[(.+)\]", ToLambda},
                 {@"t\[(.+)\]", ToT},
                 {"null", (_, __) => null},
                 {"true", (_, __) => true},
@@ -368,11 +367,6 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
             return ParseMapValue(jsonMap, graphName)!;
         }
 
-        private static object ToLambda(string stringLambda, string graphName)
-        {
-            return Lambda.Groovy(stringLambda);
-        }
-
         private static object ToT(string enumName, string graphName)
         {
             return T.GetByValue(enumName);
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
index 5e3a85feb6..e12a89b64f 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
@@ -140,9 +140,9 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                         continue;
                     }
 
+                    // after backport of strategy construction improvements from master, there are now test failures (not currently running GLV tests on master)
                     if (scenario.Name.Contains("withStrategies") || scenario.Name.Contains("withoutStrategies"))
                     {
-                        // after backport of strategy construction improvements from master, there are now test failures (not currently running GLV tests on master)
                         failedSteps.Add(scenario.Steps.First(), new IgnoreException(IgnoreReason.NoReason));
                         continue;
                     }
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
index b65790752a..e1180b9479 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
@@ -63,13 +63,11 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
         private static readonly IDictionary<string, List<Func<GraphTraversalSource, IDictionary<string, object>,ITraversal>>> FixedTranslations = 
             new Dictionary<string, List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>>
             {
-               {"g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
                {"g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Branch<object>(__.Label().Is("person").Count()).Option(p["xx1"], __.Values<object>("age")).Option(p["xx2"], __.Values<object>("lang")).Option(p["xx2"], __.Values<object>("name"))}}, 
                {"g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX_optionXany__labelX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Branch<object>(__.Label().Is("person").Count()).Option(p["xx1"], __.Values<object>("age")).Option(p["xx2"], __.Values<object>("lang")).Option(p["xx2"], __.Values<object>("name")).Option(Pick.Any, __.Label())}}, 
                {"g_V_branchXageX_optionXltX30X__youngX_optionXgtX30X__oldX_optionXnone__on_the_edgeX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").Branch<object>(__.Values<object>("age")).Option(P.Lt(30), __.Constant<object>("young")).Option(P.Gt(30), __.Constant<object>("old")).Option(Pick.None, __.Constant<object>("on the edge"))}}, 
                {"g_V_branchXidentityX_optionXhasLabelXsoftwareX__inXcreatedX_name_order_foldX_optionXhasXname_vadasX__ageX_optionXneqX123X__bothE_countX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Branch<object>(__.Identity()).Option(__.HasLabel("software"), __.In("created").Values<object>("name").Order().Fold()).Option(__.Has("name", "vadas"), __.Values<object>("age")).Option(P.Neq(123), __.BothE().Count())}}, 
                {"g_V_chooseXout_countX_optionX2L_nameX_optionX3L_ageX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Choose<object>(__.Out().Count()).Option(p["xx1"], __.Values<object>("name")).Option(p["xx2"], __.Values<object>("age"))}}, 
-               {"g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
                {"g_V_chooseXhasLabelXpersonX_and_outXcreatedX__outXknowsX__identityX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Choose<object>(__.HasLabel("person").And().Out("created"), __.Out("knows"), __.Identity()).Values<object>("name")}}, 
                {"g_V_chooseXlabelX_optionXblah__outXknowsXX_optionXbleep__outXcreatedXX_optionXnone__identityX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Choose<object>(__.Label()).Option("blah", __.Out("knows")).Option("bleep", __.Out("created")).Option(Pick.None, __.Identity()).Values<object>("name")}}, 
                {"g_V_chooseXoutXknowsX_count_isXgtX0XX__outXknowsXX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Choose<object>(__.Out("knows").Count().Is(P.Gt(0)), __.Out("knows")).Values<object>("name")}}, 
@@ -106,7 +104,6 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_VX1X_repeatXgroupCountXmX_byXloopsX_outX_timesX3X_capXmX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Repeat(__.GroupCount("m").By(__.Loops()).Out()).Times(3).Cap<object>("m")}}, 
                {"g_V_repeatXbothX_timesX10X_asXaX_out_asXbX_selectXa_bX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Repeat(__.Both()).Times(10).As("a").Out().As("b").Select<object>("a", "b").Count()}}, 
                {"g_VX1X_repeatXoutX_untilXoutE_count_isX0XX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Repeat(__.Out()).Until(__.OutE().Count().Is(0)).Values<object>("name")}}, 
-               {"g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
                {"g_V_hasXname_markoX_repeatXoutE_inV_simplePathX_untilXhasXname_rippleXX_path_byXnameX_byXlabelX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("name", "marko").Repeat(__.OutE().InV().SimplePath()).Until(__.Has("name", "ripple")).Path().By("name").By(T.Label)}}, 
                {"g_V_hasXloop_name_loopX_repeatXinX_timesX5X_path_by_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("loops", "name", "loop").Repeat(__.In()).Times(5).Path().By("name")}}, 
                {"g_V_repeatXout_repeatXout_order_byXname_descXX_timesX1XX_timesX1X_limitX1X_path_byXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Repeat(__.Out().Repeat(__.Out().Order().By("name", Order.Desc)).Times(1)).Times(1).Limit<object>(1).Path().By("name")}}, 
@@ -208,16 +205,15 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_properties_drop", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV().Property("name", "bob").AddV().Property("name", "alice"), (g,p) =>g.V().Properties<object>().Drop(), (g,p) =>g.V(), (g,p) =>g.V().Properties<object>()}}, 
                {"g_E_propertiesXweightX_drop", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ripple").Property("lang", "j [...]
                {"g_V_properties_propertiesXstartTimeX_drop", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV().Property("name", "bob").Property(Cardinality.List, "location", "ny", "startTime", 2014, "endTime", 2016).Property(Cardinality.List, "location", "va", "startTime", 2016).AddV().Property("name", "alice").Property(Cardinality.List, "location", "va", "startTime", 2014, "endTime", 2016).Property(Cardinality.List, "location", "ny", "startT [...]
-               {"g_V_filterXfalseX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_V_filterXtrueX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_V_filterXlang_eq_javaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_VX1X_filterXage_gt_30X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_VX2X_filterXage_gt_30X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_VX1X_out_filterXage_gt_30X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_V_filterXname_startsWith_m_OR_name_startsWith_pX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_E_filterXfalseX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_E_filterXtrueX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
+               {"g_V_filterXisX0XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Filter(__.Is(0))}}, 
+               {"g_V_filterXconstantX0XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Filter(__.Constant<object>(0))}}, 
+               {"g_V_filterXhasXlang_javaXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Filter(__.Has("lang", "java"))}}, 
+               {"g_VX1X_filterXhasXage_gtX30XXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Filter(__.Has("age", P.Gt(30)))}}, 
+               {"g_VX2X_filterXhasXage_gtX30XXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid2"]).Filter(__.Has("age", P.Gt(30)))}}, 
+               {"g_VX1X_out_filterXhasXage_gtX30XXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Filter(__.Has("age", P.Gt(30)))}}, 
+               {"g_V_filterXhasXname_startingWithXm_or_pXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Filter(__.Has("name", TextP.StartingWith("m").Or(TextP.StartingWith("p"))))}}, 
+               {"g_E_filterXisX0XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E().Filter(__.Is(0))}}, 
+               {"g_E_filterXconstantX0XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E().Filter(__.Constant<object>(0))}}, 
                {"g_VX1X_hasXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Has("name")}}, 
                {"g_VX1X_hasXcircumferenceX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Has("circumference")}}, 
                {"g_VX1X_hasXname_markoX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Has("name", "marko")}}, 
@@ -436,8 +432,8 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_withoutStrategiesXIncidentToAdjacentStrategyX_V_outE_inV", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(IncidentToAdjacentStrategy)).V().OutE().InV()}}, 
                {"g_withStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new InlineFilterStrategy()).V().Filter(__.Has("name", "marko"))}}, 
                {"g_withoutStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(InlineFilterStrategy)).V().Filter(__.Has("name", "marko"))}}, 
-               {"g_withStrategiesXLambdaRestrictionStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_withoutStrategiesXLambdaRestrictionStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
+               {"g_withStrategiesXLambdaRestrictionStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new LambdaRestrictionStrategy()).V()}}, 
+               {"g_withoutStrategiesXLambdaRestrictionStrategyX_V", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(LambdaRestrictionStrategy)).V()}}, 
                {"g_withStrategiesXLazyBarrierStrategyX_V_out_bothE_count", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new LazyBarrierStrategy()).V().Out().BothE().Count()}}, 
                {"g_withoutStrategiesXLazyBarrierStrategyX_V_out_bothE_count", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithoutStrategies(typeof(LazyBarrierStrategy)).V().Out().BothE().Count()}}, 
                {"g_withStrategiesXMatchAlgorithmStrategyXmatchAlgorithm_CountMatchAlgorithmXX_V_matchXa_knows_b__a_created_cX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new MatchAlgorithmStrategy(matchAlgorithm: "org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchStep$CountMatchAlgorithm")).V().Match<object>(__.As("a").Out("knows").As("b"), __.As("a").Out("created").As("c"))}}, 
@@ -790,6 +786,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_EX11X_elementMap", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E(p["eid11"]).ElementMap<object>()}}, 
                {"g_V_elementMapXname_age_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ElementMap<object>("name", "age", null)}}, 
                {"g_V_asXaX_flatMapXselectXaXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("a").FlatMap<object>(__.Select<object>("a"))}}, 
+               {"g_V_valuesXnameX_flatMapXsplitXaX_unfoldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").FlatMap<object>(__.Split("a").Unfold<object>())}}, 
                {"g_V_fold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold()}}, 
                {"g_V_fold_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Unfold<object>()}}, 
                {"g_V_age_foldX0_plusX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Fold<object>(0, Operator.Sum)}}, 
@@ -848,12 +845,11 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_VX1X_repeatXboth_simplePathX_untilXhasXname_peterX_or_loops_isX2XX_hasXname_peterX_path_byXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Repeat(__.Both().SimplePath()).Until(__.Has("name", "peter").Or().Loops().Is(2)).Has("name", "peter").Path().By("name")}}, 
                {"g_VX1X_repeatXboth_simplePathX_untilXhasXname_peterX_and_loops_isX3XX_hasXname_peterX_path_byXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Repeat(__.Both().SimplePath()).Until(__.Has("name", "peter").And().Loops().Is(3)).Has("name", "peter").Path().By("name")}}, 
                {"g_V_emitXhasXname_markoX_or_loops_isX2XX_repeatXoutX_valuesXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Emit(__.Has("name", "marko").Or().Loops().Is(2)).Repeat(__.Out()).Values<object>("name")}}, 
-               {"g_VX1X_mapXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_VX1X_outE_label_mapXlengthX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_VX1X_out_mapXnameX_mapXlengthX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_VX1X_out_mapXlambdaXnameXX_mapXlambdaXlengthXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_withPath_V_asXaX_out_mapXa_nameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
-               {"g_withPath_V_asXaX_out_out_mapXa_name_it_nameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
+               {"g_VX1X_mapXvaluesXnameXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Map<object>(__.Values<object>("name"))}}, 
+               {"g_VX1X_outE_label_mapXlengthX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).OutE().Label().Map<object>(__.Length())}}, 
+               {"g_VX1X_out_mapXvaluesXnameXX_mapXlengthX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Map<object>(__.Values<object>("name")).Map<object>(__.Length())}}, 
+               {"g_withPath_V_asXaX_out_mapXselectXaX_valuesXnameXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithPath().V().As("a").Out().Map<object>(__.Select<object>("a").Values<object>("name"))}}, 
+               {"g_withPath_V_asXaX_out_out_asXbX_mapXselectXaX_valuesXnameX_concatXselectXbX_valuesXnameXXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithPath().V().As("a").Out().Out().As("b").Map<object>(__.Select<object>("a").Values<object>("name").Concat(__.Select<object>("b").Values<object>("name")))}}, 
                {"g_V_mapXselectXaXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("a").Map<object>(__.Select<object>("a"))}}, 
                {"g_V_mapXconstantXnullXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Map<object>(__.Constant<object>(null))}}, 
                {"g_V_valueMap_matchXa_selectXnameX_bX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>().Match<object>(__.As("a").Select<object>("name").As("b"))}}, 
@@ -1093,7 +1089,6 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_asXaX_outXcreatedX_asXbX_order_byXshuffleX_selectXa_bX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().As("a").Out("created").As("b").Order().By(Order.Shuffle).Select<object>("a", "b")}}, 
                {"g_V_both_hasLabelXpersonX_order_byXage_descX_limitX5X_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Both().HasLabel("person").Order().By("age", Order.Desc).Limit<object>(5).Values<object>("name")}}, 
                {"g_V_properties_order_byXkey_descX_key", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Properties<object>().Order().By(T.Key, Order.Desc).Key()}}, 
-               {"g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
                {"g_V_hasLabelXpersonX_group_byXnameX_byXoutE_weight_sumX_orderXlocalX_byXvaluesX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").Group<object, object>().By("name").By(__.OutE().Values<object>("weight").Sum<object>()).Order(Scope.Local).By(Column.Values)}}, 
                {"g_V_mapXbothE_weight_foldX_order_byXsumXlocalX_descX_byXcountXlocalX_descX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Map<object>(__.BothE().Values<object>("weight").Order().By(Order.Asc).Fold()).Order().By(__.Sum<object>(Scope.Local), Order.Desc).By(__.Count(Scope.Local), Order.Desc)}}, 
                {"g_V_group_byXlabelX_byXname_order_byXdescX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Group<object, object>().By(T.Label).By(__.Values<object>("name").Order().By(Order.Desc).Fold())}}, 
@@ -1108,7 +1103,6 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_fold_orderXlocalX_byXage_descX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fold().Order(Scope.Local).By("age", Order.Desc)}}, 
                {"g_V_orXhasLabelXpersonX_hasXsoftware_name_lopXX_order_byXageX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Or(__.HasLabel("person"), __.Has("software", "name", "lop")).Order().By("age")}}, 
                {"g_withStrategiesXProductiveByStrategyX_V_orXhasLabelXpersonX_hasXsoftware_name_lopXX_order_byXageX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithStrategies(new ProductiveByStrategy()).V().Or(__.HasLabel("person"), __.Has("software", "name", "lop")).Order().By("age")}}, 
-               {"g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
                {"g_V_hasXsong_name_OHBOYX_outXfollowedByX_outXfollowedByX_order_byXperformancesX_byXsongType_descX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("song", "name", "OH BOY").Out("followedBy").Out("followedBy").Order().By("performances").By("songType", Order.Desc).By("name")}}, 
                {"g_V_hasLabelXsongX_order_byXperformances_descX_byXnameX_rangeX110_120X_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("song").Order().By("performances", Order.Desc).By("name").Range<object>(110, 120).Values<object>("name")}}, 
                {"g_VX1X_elementMap_orderXlocalX_byXkeys_descXunfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).ElementMap<object>().Order(Scope.Local).By(Column.Keys, Order.Desc).Unfold<object>()}}, 
@@ -1346,7 +1340,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_valuesXnameX_trim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   ripple   ").Property( [...]
                {"g_V_valuesXnameX_order_fold_trimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   rip [...]
                {"g_V_localXoutE_foldX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Local<object>(__.OutE().Fold()).Unfold<object>()}}, 
-               {"g_V_valueMap_unfold_mapXkeyX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
+               {"g_V_valueMap_unfold_mapXselectXkeysXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>().Unfold<object>().Map<object>(__.Select<object>(Column.Keys))}}, 
                {"g_VX1X_repeatXboth_simplePathX_untilXhasIdX6XX_path_byXnameX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Repeat(__.Both().SimplePath()).Until(__.HasId(p["vid6"])).Path().By("name").Unfold<object>()}}, 
                {"g_V_valueMap", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>()}}, 
                {"g_V_valueMapXtrueX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>(true)}}, 
@@ -1578,7 +1572,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_hasXlangX_group_byXlangX_byXcountX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("lang").Group<object, object>().By("lang").By(__.Count())}}, 
                {"g_V_group_byXoutE_countX_byXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Order().By("name").Group<object, object>().By(__.OutE().Count()).By("name")}}, 
                {"g_V_repeatXbothXfollowedByXX_timesX2X_group_byXsongTypeX_byXcountX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Repeat(__.Both("followedBy")).Times(2).Group<object, object>().By("songType").By(__.Count())}}, 
-               {"g_V_group_byXname_substring_1X_byXconstantX1XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
+               {"g_V_group_byXvaluesXnameX_substringX1XX_byXconstantX1XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Group<object, object>().By(__.Values<object>("name").Substring(0, 1)).By(__.Constant<object>(1))}}, 
                {"g_V_out_group_byXlabelX_selectXpersonX_unfold_outXcreatedX_name_limitX2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Group<object, object>().By(T.Label).Select<object>("person").Unfold<object>().Out("created").Values<object>("name").Limit<object>(2)}}, 
                {"g_V_hasLabelXsongX_group_byXnameX_byXproperties_groupCount_byXlabelXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("song").Group<object, object>().By("name").By(__.Properties<object>().GroupCount<object>().By(T.Label))}}, 
                {"g_V_outXfollowedByX_group_byXsongTypeX_byXbothE_group_byXlabelX_byXweight_sumXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out("followedBy").Group<object, object>().By("songType").By(__.BothE().Group<object, object>().By(T.Label).By(__.Values<object>("weight").Sum<object>()))}}, 
@@ -1614,7 +1608,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_outXcreatedX_groupCount_byXnameX_byXageX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out("created").GroupCount<object>().By("name").By("age")}}, 
                {"g_V_outXcreatedX_groupCountXxX_byXnameX_byXageX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out("created").GroupCount("x").By("name").By("age")}}, 
                {"g_VX1X_out_injectXv2X_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Inject((Vertex) p["v2"]).Values<object>("name")}}, 
-               {"g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
+               {"g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Values<object>("name").Inject("daniel").As("a").Map<object>(__.Length()).Path()}}, 
                {"g_VX1X_injectXg_VX4XX_out_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Inject((Vertex) p["v2"]).Out().Values<object>("name")}}, 
                {"g_injectXnull_1_3_nullX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(null, 1, 3, null)}}, 
                {"g_injectX10_20_null_20_10_10X_groupCountXxX_dedup_asXyX_projectXa_bX_by_byXselectXxX_selectXselectXyXXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(10, 20, null, 20, 10, 10).GroupCount("x").Dedup().As("y").Project<object>("a", "b").By().By(__.Select<object>("x").Select<object>(__.Select<object>("y")))}}, 
@@ -1645,6 +1639,11 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_sackXassignX_byXageX_sack", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Sack(Operator.Assign).By("age").Sack<object>()}}, 
                {"g_withSackXBigInteger_TEN_powX1000X_assignX_V_localXoutXknowsX_barrierXnormSackXX_inXknowsX_barrier_sack", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithSack(p["xx1"], Operator.Assign).V().Local<object>(__.Out("knows").Barrier(Barrier.NormSack)).In("knows").Barrier().Sack<object>()}}, 
                {"g_withSackX2X_V_sackXdivX_byXconstantX4_0XX_sack", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithSack(2).V().Sack(Operator.Div).By(__.Constant<object>(p["xx1"])).Sack<object>()}}, 
+               {"g_V_sideEffectXidentityX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().SideEffect(__.Identity())}}, 
+               {"g_V_sideEffectXidentity_valuesXnameXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().SideEffect(__.Identity().Values<object>("name"))}}, 
+               {"g_V_sideEffectXpropertyXage_22X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("person").Property("age", 21), (g,p) =>g.V().SideEffect(__.Property("age", 22)), (g,p) =>g.V().Has("age", 21), (g,p) =>g.V().Has("age", 22)}}, 
+               {"g_V_group_byXvaluesXnameX_sideEffectXconstantXzyxXX_substringX1XX_byXconstantX1X_sideEffectXconstantXxyzXXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Group<object, object>().By(__.Values<object>("name").SideEffect(__.Constant<object>("zyx")).Substring(0, 1)).By(__.Constant<object>(1).SideEffect(__.Constant<object>("xyz")))}}, 
+               {"g_withSideEffectXx_setX_V_both_both_sideEffectXstoreXxX_byXnameXX_capXxX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.WithSideEffect("x", new HashSet<object> {  }).V().Both().Both().SideEffect(__.Store("x").By("name")).Cap<object>("x").Unfold<object>()}}, 
                {"g_V_hasXageX_groupCountXaX_byXnameX_out_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("age").GroupCount("a").By("name").Out().Cap<object>("a")}}, 
                {"g_V_groupXaX_byXageX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Group("a").By("age").Cap<object>("a")}}, 
                {"g_V_groupXaX_byXnameX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Group("a").By("name").Cap<object>("a")}}, 
@@ -1652,11 +1651,12 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_repeatXout_groupXaX_byXnameX_byXcountX_timesX2X_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Repeat(__.Out().Group("a").By("name").By(__.Count())).Times(2).Cap<object>("a")}}, 
                {"g_V_groupXaX_byXlabelX_byXoutE_weight_sumX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Group("a").By(T.Label).By(__.OutE().Values<object>("weight").Sum<object>()).Cap<object>("a")}}, 
                {"g_V_repeatXbothXfollowedByXX_timesX2X_groupXaX_byXsongTypeX_byXcountX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Repeat(__.Both("followedBy")).Times(2).Group("a").By("songType").By(__.Count()).Cap<object>("a")}}, 
-               {"g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>()},  // skipping as it contains a lambda
+               {"g_V_groupXaX_byXvaluesXnameX_substringX1XX_byXconstantX1XX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Group("a").By(__.Values<object>("name").Substring(0, 1)).By(__.Constant<object>(1)).Cap<object>("a")}}, 
                {"g_V_hasLabelXsongX_groupXaX_byXnameX_byXproperties_groupCount_byXlabelXX_out_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("song").Group("a").By("name").By(__.Properties<object>().GroupCount<object>().By(T.Label)).Out().Cap<object>("a")}}, 
                {"g_V_hasLabelXpersonX_asXpX_outXcreatedX_groupXaX_byXnameX_byXselectXpX_valuesXageX_sumX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").As("p").Out("created").Group("a").By("name").By(__.Select<object>("p").Values<object>("age").Sum<object>()).Cap<object>("a")}}, 
                {"g_V_groupXmX_byXnameX_byXinXknowsX_nameX_capXmX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Group("m").By("name").By(__.In("knows").Values<object>("name")).Cap<object>("m")}}, 
                {"g_V_groupXmX_byXlabelX_byXlabel_countX_capXmX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Group("m").By(__.Label()).By(__.Label().Count()).Cap<object>("m")}}, 
+               {"g_V_chooseXlabel_person__age_groupCountXaX__name_groupCountXbXX_capXa_bX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Choose<object>(__.Has(T.Label, "person"), __.Values<object>("age").GroupCount("a"), __.Values<object>("name").GroupCount("b")).Cap<object>("a", "b").Unfold<object>()}}, 
                {"g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_orderX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("person", "name", P.Within("vadas", "peter")).Group("a").By().By(__.Out().Order()).Cap<object>("a")}}, 
                {"g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_order_countX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("person", "name", P.Within("vadas", "peter")).Group("a").By().By(__.Out().Order().Count()).Cap<object>("a")}}, 
                {"g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_order_fold_countXlocalXX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("person", "name", P.Within("vadas", "peter")).Group("a").By().By(__.Out().Order().Fold().Count(Scope.Local)).Cap<object>("a")}}, 
diff --git a/gremlin-go/build/generate.groovy b/gremlin-go/build/generate.groovy
index 760c959839..3d1e95227c 100644
--- a/gremlin-go/build/generate.groovy
+++ b/gremlin-go/build/generate.groovy
@@ -81,10 +81,7 @@ radishGremlinFile.withWriter('UTF-8') { Writer writer ->
     ]
 
     gremlins.each { k,v ->
-        // skipping lambdas until we decide for sure that they are out in 4.x
-        if (v.any { it.contains('l1')} || v.any { it.contains('pred1')} || v.any { it.contains('Lambda')}) {
-            writer.writeLine("    \"${k}\": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda")
-        } else if (staticTranslate.containsKey(k)) {
+        if (staticTranslate.containsKey(k)) {
             writer.writeLine(staticTranslate[k])
         } else {
             writer.write("    ")
diff --git a/gremlin-go/driver/cucumber/cucumberSteps_test.go b/gremlin-go/driver/cucumber/cucumberSteps_test.go
index 1ad8f1ddd7..294bcfef54 100644
--- a/gremlin-go/driver/cucumber/cucumberSteps_test.go
+++ b/gremlin-go/driver/cucumber/cucumberSteps_test.go
@@ -65,7 +65,6 @@ func init() {
 		regexp.MustCompile(`^l\[(.*)]$`):            toList,
 		regexp.MustCompile(`^s\[(.*)]$`):            toSet,
 		regexp.MustCompile(`^m\[(.+)]$`):            toMap,
-		regexp.MustCompile(`^c\[(.+)]$`):            toLambda,
 		regexp.MustCompile(`^t\[(.+)]$`):            toT,
 		regexp.MustCompile(`^D\[(.+)]$`):            toDirection,
 		regexp.MustCompile(`^M\[(.+)]$`):            toMerge,
@@ -308,11 +307,6 @@ func parseMapValue(mapVal interface{}, graphName string) interface{} {
 	}
 }
 
-// Parse lambda.
-func toLambda(name, graphName string) interface{} {
-	return &gremlingo.Lambda{Script: name}
-}
-
 func toT(name, graphName string) interface{} {
 	// Return as is, since T values are just strings.
 	if name == "label" {
diff --git a/gremlin-go/driver/cucumber/gremlin.go b/gremlin-go/driver/cucumber/gremlin.go
index f09be8629e..6c17b89260 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -32,13 +32,11 @@ import (
 )
 
 var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal{
-    "g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
     "g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Branch(gremlingo.T__.Label().Is("person").Count()).Option(p["xx1"], gremlingo.T__.Values("age")).Option(p["xx2"], gremlingo.T__.Values("lang")).Option(p["xx2"], gremlingo.T__.Values("name"))}}, 
     "g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX_optionXany__labelX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Branch(gremlingo.T__.Label().Is("person").Count()).Option(p["xx1"], gremlingo.T__.Values("age")).Option(p["xx2"], gremlingo.T__.Values("lang")).Option(p["xx2"], gremlingo.T__.Values("name")).Option(gremlingo.Pick.Any, gremlingo.T__.Label())}}, 
     "g_V_branchXageX_optionXltX30X__youngX_optionXgtX30X__oldX_optionXnone__on_the_edgeX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Branch(gremlingo.T__.Values("age")).Option(gremlingo.P.Lt(30), gremlingo.T__.Constant("young")).Option(gremlingo.P.Gt(30), gremlingo.T__.Constant("old")).Option(gremlingo.Pick.None, gremlingo.T__.Constant("on the edge"))}}, 
     "g_V_branchXidentityX_optionXhasLabelXsoftwareX__inXcreatedX_name_order_foldX_optionXhasXname_vadasX__ageX_optionXneqX123X__bothE_countX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Branch(gremlingo.T__.Identity()).Option(gremlingo.T__.HasLabel("software"), gremlingo.T__.In("created").Values("name").Order().Fold()).Option(gremlingo.T__.Has("name", "vadas"), gremlingo.T__.Values("age")).Option(gremlingo.P.Neq(123), gremli [...]
     "g_V_chooseXout_countX_optionX2L_nameX_optionX3L_ageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Choose(gremlingo.T__.Out().Count()).Option(p["xx1"], gremlingo.T__.Values("name")).Option(p["xx2"], gremlingo.T__.Values("age"))}}, 
-    "g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
     "g_V_chooseXhasLabelXpersonX_and_outXcreatedX__outXknowsX__identityX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Choose(gremlingo.T__.HasLabel("person").And().Out("created"), gremlingo.T__.Out("knows"), gremlingo.T__.Identity()).Values("name")}}, 
     "g_V_chooseXlabelX_optionXblah__outXknowsXX_optionXbleep__outXcreatedXX_optionXnone__identityX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Choose(gremlingo.T__.Label()).Option("blah", gremlingo.T__.Out("knows")).Option("bleep", gremlingo.T__.Out("created")).Option(gremlingo.Pick.None, gremlingo.T__.Identity()).Values("name")}}, 
     "g_V_chooseXoutXknowsX_count_isXgtX0XX__outXknowsXX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Choose(gremlingo.T__.Out("knows").Count().Is(gremlingo.P.Gt(0)), gremlingo.T__.Out("knows")).Values("name")}}, 
@@ -75,7 +73,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_VX1X_repeatXgroupCountXmX_byXloopsX_outX_timesX3X_capXmX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Repeat(gremlingo.T__.GroupCount("m").By(gremlingo.T__.Loops()).Out()).Times(3).Cap("m")}}, 
     "g_V_repeatXbothX_timesX10X_asXaX_out_asXbX_selectXa_bX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Both()).Times(10).As("a").Out().As("b").Select("a", "b").Count()}}, 
     "g_VX1X_repeatXoutX_untilXoutE_count_isX0XX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Repeat(gremlingo.T__.Out()).Until(gremlingo.T__.OutE().Count().Is(0)).Values("name")}}, 
-    "g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
     "g_V_hasXname_markoX_repeatXoutE_inV_simplePathX_untilXhasXname_rippleXX_path_byXnameX_byXlabelX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("name", "marko").Repeat(gremlingo.T__.OutE().InV().SimplePath()).Until(gremlingo.T__.Has("name", "ripple")).Path().By("name").By(gremlingo.T.Label)}}, 
     "g_V_hasXloop_name_loopX_repeatXinX_timesX5X_path_by_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("loops", "name", "loop").Repeat(gremlingo.T__.In()).Times(5).Path().By("name")}}, 
     "g_V_repeatXout_repeatXout_order_byXname_descXX_timesX1XX_timesX1X_limitX1X_path_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Out().Repeat(gremlingo.T__.Out().Order().By("name", gremlingo.Order.Desc)).Times(1)).Times(1).Limit(1).Path().By("name")}}, 
@@ -177,16 +174,15 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_properties_drop": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property("name", "bob").AddV().Property("name", "alice")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties().Drop()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interfa [...]
     "g_E_propertiesXweightX_drop": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ripple").Property("lang",  [...]
     "g_V_properties_propertiesXstartTimeX_drop": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property("name", "bob").Property(gremlingo.Cardinality.List, "location", "ny", "startTime", 2014, "endTime", 2016).Property(gremlingo.Cardinality.List, "location", "va", "startTime", 2016).AddV().Property("name", "alice").Property(gremlingo.Cardinality.List, "location", "va", "startTime", 2014, "endTime", 2016).Property(gremlingo.C [...]
-    "g_V_filterXfalseX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_V_filterXtrueX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_V_filterXlang_eq_javaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_VX1X_filterXage_gt_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_VX2X_filterXage_gt_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_VX1X_out_filterXage_gt_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_V_filterXname_startsWith_m_OR_name_startsWith_pX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_E_filterXfalseX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_E_filterXtrueX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
+    "g_V_filterXisX0XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Filter(gremlingo.T__.Is(0))}}, 
+    "g_V_filterXconstantX0XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Filter(gremlingo.T__.Constant(0))}}, 
+    "g_V_filterXhasXlang_javaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Filter(gremlingo.T__.Has("lang", "java"))}}, 
+    "g_VX1X_filterXhasXage_gtX30XXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Filter(gremlingo.T__.Has("age", gremlingo.P.Gt(30)))}}, 
+    "g_VX2X_filterXhasXage_gtX30XXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid2"]).Filter(gremlingo.T__.Has("age", gremlingo.P.Gt(30)))}}, 
+    "g_VX1X_out_filterXhasXage_gtX30XXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Filter(gremlingo.T__.Has("age", gremlingo.P.Gt(30)))}}, 
+    "g_V_filterXhasXname_startingWithXm_or_pXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Filter(gremlingo.T__.Has("name", gremlingo.TextP.StartingWith("m").Or(gremlingo.TextP.StartingWith("p"))))}}, 
+    "g_E_filterXisX0XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().Filter(gremlingo.T__.Is(0))}}, 
+    "g_E_filterXconstantX0XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().Filter(gremlingo.T__.Constant(0))}}, 
     "g_VX1X_hasXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Has("name")}}, 
     "g_VX1X_hasXcircumferenceX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Has("circumference")}}, 
     "g_VX1X_hasXname_markoX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Has("name", "marko")}}, 
@@ -405,8 +401,8 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_withoutStrategiesXIncidentToAdjacentStrategyX_V_outE_inV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(gremlingo.IncidentToAdjacentStrategy()).V().OutE().InV()}}, 
     "g_withStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.InlineFilterStrategy()).V().Filter(gremlingo.T__.Has("name", "marko"))}}, 
     "g_withoutStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(gremlingo.InlineFilterStrategy()).V().Filter(gremlingo.T__.Has("name", "marko"))}}, 
-    "g_withStrategiesXLambdaRestrictionStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_withoutStrategiesXLambdaRestrictionStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
+    "g_withStrategiesXLambdaRestrictionStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.LambdaRestrictionStrategy()).V()}}, 
+    "g_withoutStrategiesXLambdaRestrictionStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(gremlingo.LambdaRestrictionStrategy()).V()}}, 
     "g_withStrategiesXLazyBarrierStrategyX_V_out_bothE_count": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.LazyBarrierStrategy()).V().Out().BothE().Count()}}, 
     "g_withoutStrategiesXLazyBarrierStrategyX_V_out_bothE_count": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(gremlingo.LazyBarrierStrategy()).V().Out().BothE().Count()}}, 
     "g_withStrategiesXMatchAlgorithmStrategyXmatchAlgorithm_CountMatchAlgorithmXX_V_matchXa_knows_b__a_created_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.MatchAlgorithmStrategy(gremlingo.MatchAlgorithmStrategyConfig{MatchAlgorithm: "org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchStep$CountMatchAlgorithm"})).V().Match(gremlingo.T__.As("a").Out("knows").As("b"), gremlingo.T__.As("a").Out [...]
@@ -759,6 +755,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_EX11X_elementMap": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"]).ElementMap()}}, 
     "g_V_elementMapXname_age_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ElementMap("name", "age", nil)}}, 
     "g_V_asXaX_flatMapXselectXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").FlatMap(gremlingo.T__.Select("a"))}}, 
+    "g_V_valuesXnameX_flatMapXsplitXaX_unfoldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").FlatMap(gremlingo.T__.Split("a").Unfold())}}, 
     "g_V_fold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold()}}, 
     "g_V_fold_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Unfold()}}, 
     "g_V_age_foldX0_plusX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Fold(0, gremlingo.Operator.Sum)}}, 
@@ -817,12 +814,11 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_VX1X_repeatXboth_simplePathX_untilXhasXname_peterX_or_loops_isX2XX_hasXname_peterX_path_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Repeat(gremlingo.T__.Both().SimplePath()).Until(gremlingo.T__.Has("name", "peter").Or().Loops().Is(2)).Has("name", "peter").Path().By("name")}}, 
     "g_VX1X_repeatXboth_simplePathX_untilXhasXname_peterX_and_loops_isX3XX_hasXname_peterX_path_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Repeat(gremlingo.T__.Both().SimplePath()).Until(gremlingo.T__.Has("name", "peter").And().Loops().Is(3)).Has("name", "peter").Path().By("name")}}, 
     "g_V_emitXhasXname_markoX_or_loops_isX2XX_repeatXoutX_valuesXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Emit(gremlingo.T__.Has("name", "marko").Or().Loops().Is(2)).Repeat(gremlingo.T__.Out()).Values("name")}}, 
-    "g_VX1X_mapXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_VX1X_outE_label_mapXlengthX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_VX1X_out_mapXnameX_mapXlengthX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_VX1X_out_mapXlambdaXnameXX_mapXlambdaXlengthXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_withPath_V_asXaX_out_mapXa_nameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
-    "g_withPath_V_asXaX_out_out_mapXa_name_it_nameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
+    "g_VX1X_mapXvaluesXnameXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Map(gremlingo.T__.Values("name"))}}, 
+    "g_VX1X_outE_label_mapXlengthX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE().Label().Map(gremlingo.T__.Length())}}, 
+    "g_VX1X_out_mapXvaluesXnameXX_mapXlengthX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Map(gremlingo.T__.Values("name")).Map(gremlingo.T__.Length())}}, 
+    "g_withPath_V_asXaX_out_mapXselectXaX_valuesXnameXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithPath().V().As("a").Out().Map(gremlingo.T__.Select("a").Values("name"))}}, 
+    "g_withPath_V_asXaX_out_out_asXbX_mapXselectXaX_valuesXnameX_concatXselectXbX_valuesXnameXXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithPath().V().As("a").Out().Out().As("b").Map(gremlingo.T__.Select("a").Values("name").Concat(gremlingo.T__.Select("b").Values("name")))}}, 
     "g_V_mapXselectXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Map(gremlingo.T__.Select("a"))}}, 
     "g_V_mapXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Map(gremlingo.T__.Constant(nil))}}, 
     "g_V_valueMap_matchXa_selectXnameX_bX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap().Match(gremlingo.T__.As("a").Select("name").As("b"))}}, 
@@ -1062,7 +1058,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_asXaX_outXcreatedX_asXbX_order_byXshuffleX_selectXa_bX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out("created").As("b").Order().By(gremlingo.Order.Shuffle).Select("a", "b")}}, 
     "g_V_both_hasLabelXpersonX_order_byXage_descX_limitX5X_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Both().HasLabel("person").Order().By("age", gremlingo.Order.Desc).Limit(5).Values("name")}}, 
     "g_V_properties_order_byXkey_descX_key": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties().Order().By(gremlingo.T.Key, gremlingo.Order.Desc).Key()}}, 
-    "g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
     "g_V_hasLabelXpersonX_group_byXnameX_byXoutE_weight_sumX_orderXlocalX_byXvaluesX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Group().By("name").By(gremlingo.T__.OutE().Values("weight").Sum()).Order(gremlingo.Scope.Local).By(gremlingo.Column.Values)}}, 
     "g_V_mapXbothE_weight_foldX_order_byXsumXlocalX_descX_byXcountXlocalX_descX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Map(gremlingo.T__.BothE().Values("weight").Order().By(gremlingo.Order.Asc).Fold()).Order().By(gremlingo.T__.Sum(gremlingo.Scope.Local), gremlingo.Order.Desc).By(gremlingo.T__.Count(gremlingo.Scope.Local), gremlingo.Order.Desc)}}, 
     "g_V_group_byXlabelX_byXname_order_byXdescX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group().By(gremlingo.T.Label).By(gremlingo.T__.Values("name").Order().By(gremlingo.Order.Desc).Fold())}}, 
@@ -1077,7 +1072,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_fold_orderXlocalX_byXage_descX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Order(gremlingo.Scope.Local).By("age", gremlingo.Order.Desc)}}, 
     "g_V_orXhasLabelXpersonX_hasXsoftware_name_lopXX_order_byXageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Or(gremlingo.T__.HasLabel("person"), gremlingo.T__.Has("software", "name", "lop")).Order().By("age")}}, 
     "g_withStrategiesXProductiveByStrategyX_V_orXhasLabelXpersonX_hasXsoftware_name_lopXX_order_byXageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.ProductiveByStrategy()).V().Or(gremlingo.T__.HasLabel("person"), gremlingo.T__.Has("software", "name", "lop")).Order().By("age")}}, 
-    "g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
     "g_V_hasXsong_name_OHBOYX_outXfollowedByX_outXfollowedByX_order_byXperformancesX_byXsongType_descX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("song", "name", "OH BOY").Out("followedBy").Out("followedBy").Order().By("performances").By("songType", gremlingo.Order.Desc).By("name")}}, 
     "g_V_hasLabelXsongX_order_byXperformances_descX_byXnameX_rangeX110_120X_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("song").Order().By("performances", gremlingo.Order.Desc).By("name").Range(110, 120).Values("name")}}, 
     "g_VX1X_elementMap_orderXlocalX_byXkeys_descXunfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).ElementMap().Order(gremlingo.Scope.Local).By(gremlingo.Column.Keys, gremlingo.Order.Desc).Unfold()}}, 
@@ -1315,7 +1309,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_valuesXnameX_trim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   ripple   ").Propert [...]
     "g_V_valuesXnameX_order_fold_trimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   r [...]
     "g_V_localXoutE_foldX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Local(gremlingo.T__.OutE().Fold()).Unfold()}}, 
-    "g_V_valueMap_unfold_mapXkeyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
+    "g_V_valueMap_unfold_mapXselectXkeysXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap().Unfold().Map(gremlingo.T__.Select(gremlingo.Column.Keys))}}, 
     "g_VX1X_repeatXboth_simplePathX_untilXhasIdX6XX_path_byXnameX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Repeat(gremlingo.T__.Both().SimplePath()).Until(gremlingo.T__.HasId(p["vid6"])).Path().By("name").Unfold()}}, 
     "g_V_valueMap": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap()}}, 
     "g_V_valueMapXtrueX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap(true)}}, 
@@ -1547,7 +1541,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_hasXlangX_group_byXlangX_byXcountX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("lang").Group().By("lang").By(gremlingo.T__.Count())}}, 
     "g_V_group_byXoutE_countX_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Order().By("name").Group().By(gremlingo.T__.OutE().Count()).By("name")}}, 
     "g_V_repeatXbothXfollowedByXX_timesX2X_group_byXsongTypeX_byXcountX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Both("followedBy")).Times(2).Group().By("songType").By(gremlingo.T__.Count())}}, 
-    "g_V_group_byXname_substring_1X_byXconstantX1XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
+    "g_V_group_byXvaluesXnameX_substringX1XX_byXconstantX1XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group().By(gremlingo.T__.Values("name").Substring(0, 1)).By(gremlingo.T__.Constant(1))}}, 
     "g_V_out_group_byXlabelX_selectXpersonX_unfold_outXcreatedX_name_limitX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Group().By(gremlingo.T.Label).Select("person").Unfold().Out("created").Values("name").Limit(2)}}, 
     "g_V_hasLabelXsongX_group_byXnameX_byXproperties_groupCount_byXlabelXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("song").Group().By("name").By(gremlingo.T__.Properties().GroupCount().By(gremlingo.T.Label))}}, 
     "g_V_outXfollowedByX_group_byXsongTypeX_byXbothE_group_byXlabelX_byXweight_sumXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out("followedBy").Group().By("songType").By(gremlingo.T__.BothE().Group().By(gremlingo.T.Label).By(gremlingo.T__.Values("weight").Sum()))}}, 
@@ -1583,7 +1577,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_outXcreatedX_groupCount_byXnameX_byXageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out("created").GroupCount().By("name").By("age")}}, 
     "g_V_outXcreatedX_groupCountXxX_byXnameX_byXageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out("created").GroupCount("x").By("name").By("age")}}, 
     "g_VX1X_out_injectXv2X_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Inject(p["v2"]).Values("name")}}, 
-    "g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
+    "g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Values("name").Inject("daniel").As("a").Map(gremlingo.T__.Length()).Path()}}, 
     "g_VX1X_injectXg_VX4XX_out_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Inject(p["v2"]).Out().Values("name")}}, 
     "g_injectXnull_1_3_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil, 1, 3, nil)}}, 
     "g_injectX10_20_null_20_10_10X_groupCountXxX_dedup_asXyX_projectXa_bX_by_byXselectXxX_selectXselectXyXXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(10, 20, nil, 20, 10, 10).GroupCount("x").Dedup().As("y").Project("a", "b").By().By(gremlingo.T__.Select("x").Select(gremlingo.T__.Select("y")))}}, 
@@ -1614,6 +1608,11 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_sackXassignX_byXageX_sack": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Sack(gremlingo.Operator.Assign).By("age").Sack()}}, 
     "g_withSackXBigInteger_TEN_powX1000X_assignX_V_localXoutXknowsX_barrierXnormSackXX_inXknowsX_barrier_sack": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSack(p["xx1"], gremlingo.Operator.Assign).V().Local(gremlingo.T__.Out("knows").Barrier(gremlingo.Barrier.NormSack)).In("knows").Barrier().Sack()}}, 
     "g_withSackX2X_V_sackXdivX_byXconstantX4_0XX_sack": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSack(2).V().Sack(gremlingo.Operator.Div).By(gremlingo.T__.Constant(p["xx1"])).Sack()}}, 
+    "g_V_sideEffectXidentityX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().SideEffect(gremlingo.T__.Identity())}}, 
+    "g_V_sideEffectXidentity_valuesXnameXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().SideEffect(gremlingo.T__.Identity().Values("name"))}}, 
+    "g_V_sideEffectXpropertyXage_22X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("age", 21)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().SideEffect(gremlingo.T__.Property("age", 22))}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("age", 21)}, func(g *gremlingo.GraphTraversalSour [...]
+    "g_V_group_byXvaluesXnameX_sideEffectXconstantXzyxXX_substringX1XX_byXconstantX1X_sideEffectXconstantXxyzXXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group().By(gremlingo.T__.Values("name").SideEffect(gremlingo.T__.Constant("zyx")).Substring(0, 1)).By(gremlingo.T__.Constant(1).SideEffect(gremlingo.T__.Constant("xyz")))}}, 
+    "g_withSideEffectXx_setX_V_both_both_sideEffectXstoreXxX_byXnameXX_capXxX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSideEffect("x", gremlingo.NewSimpleSet()).V().Both().Both().SideEffect(gremlingo.T__.Store("x").By("name")).Cap("x").Unfold()}}, 
     "g_V_hasXageX_groupCountXaX_byXnameX_out_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("age").GroupCount("a").By("name").Out().Cap("a")}}, 
     "g_V_groupXaX_byXageX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group("a").By("age").Cap("a")}}, 
     "g_V_groupXaX_byXnameX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group("a").By("name").Cap("a")}}, 
@@ -1621,11 +1620,12 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_repeatXout_groupXaX_byXnameX_byXcountX_timesX2X_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Out().Group("a").By("name").By(gremlingo.T__.Count())).Times(2).Cap("a")}}, 
     "g_V_groupXaX_byXlabelX_byXoutE_weight_sumX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group("a").By(gremlingo.T.Label).By(gremlingo.T__.OutE().Values("weight").Sum()).Cap("a")}}, 
     "g_V_repeatXbothXfollowedByXX_timesX2X_groupXaX_byXsongTypeX_byXcountX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Both("followedBy")).Times(2).Group("a").By("songType").By(gremlingo.T__.Count()).Cap("a")}}, 
-    "g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
+    "g_V_groupXaX_byXvaluesXnameX_substringX1XX_byXconstantX1XX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group("a").By(gremlingo.T__.Values("name").Substring(0, 1)).By(gremlingo.T__.Constant(1)).Cap("a")}}, 
     "g_V_hasLabelXsongX_groupXaX_byXnameX_byXproperties_groupCount_byXlabelXX_out_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("song").Group("a").By("name").By(gremlingo.T__.Properties().GroupCount().By(gremlingo.T.Label)).Out().Cap("a")}}, 
     "g_V_hasLabelXpersonX_asXpX_outXcreatedX_groupXaX_byXnameX_byXselectXpX_valuesXageX_sumX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").As("p").Out("created").Group("a").By("name").By(gremlingo.T__.Select("p").Values("age").Sum()).Cap("a")}}, 
     "g_V_groupXmX_byXnameX_byXinXknowsX_nameX_capXmX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group("m").By("name").By(gremlingo.T__.In("knows").Values("name")).Cap("m")}}, 
     "g_V_groupXmX_byXlabelX_byXlabel_countX_capXmX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group("m").By(gremlingo.T__.Label()).By(gremlingo.T__.Label().Count()).Cap("m")}}, 
+    "g_V_chooseXlabel_person__age_groupCountXaX__name_groupCountXbXX_capXa_bX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Choose(gremlingo.T__.Has(gremlingo.T.Label, "person"), gremlingo.T__.Values("age").GroupCount("a"), gremlingo.T__.Values("name").GroupCount("b")).Cap("a", "b").Unfold()}}, 
     "g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_orderX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", "name", gremlingo.P.Within("vadas", "peter")).Group("a").By().By(gremlingo.T__.Out().Order()).Cap("a")}}, 
     "g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_order_countX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", "name", gremlingo.P.Within("vadas", "peter")).Group("a").By().By(gremlingo.T__.Out().Order().Count()).Cap("a")}}, 
     "g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_order_fold_countXlocalXX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", "name", gremlingo.P.Within("vadas", "peter")).Group("a").By().By(gremlingo.T__.Out().Order().Fold().Count(gremlingo.Scope.Local)).Cap("a")}}, 
diff --git a/gremlin-groovy/src/test/java/org/apache/tinkerpop/gremlin/groovy/jsr223/GroovyTranslatorProvider.java b/gremlin-groovy/src/test/java/org/apache/tinkerpop/gremlin/groovy/jsr223/GroovyTranslatorProvider.java
index de9e1eea29..c0602169b7 100644
--- a/gremlin-groovy/src/test/java/org/apache/tinkerpop/gremlin/groovy/jsr223/GroovyTranslatorProvider.java
+++ b/gremlin-groovy/src/test/java/org/apache/tinkerpop/gremlin/groovy/jsr223/GroovyTranslatorProvider.java
@@ -32,93 +32,13 @@ import org.apache.tinkerpop.gremlin.util.TinkerGraphProvider;
         method = "*",
         reason = "Tests for profile() are not supported for remotes")
 @Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.BranchTest",
-        method = "g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.ChooseTest",
-        method = "g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name",
+        test = "org.apache.tinkerpop.gremlin.process.traversal.step.LambdaStepTest",
+        method = "*",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.DedupTest",
         method = "g_V_both_name_order_byXa_bX_dedup_value",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_E_filterXfalseX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_E_filterXtrueX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXfalseX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXlang_eq_javaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXname_startsWith_m_OR_name_startsWith_pX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXtrueX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX1X_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX1X_out_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX2X_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest",
-        method = "g_V_group_byXname_substring_1X_byXconstantX1XX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest",
-        method = "g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasTest",
-        method = "g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectTest",
-        method = "g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_mapXnameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_out_mapXnameX_mapXlengthX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_outE_label_mapXlengthX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_withPath_V_asXaX_out_mapXa_nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_withPath_V_asXaX_out_out_mapXa_name_it_nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
-        method = "g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
         method = "g_V_name_order_byXa1_b1X_byXb2_a2X",
@@ -127,46 +47,10 @@ import org.apache.tinkerpop.gremlin.util.TinkerGraphProvider;
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
         method = "g_V_order_byXname_a1_b1X_byXname_b2_a2X_name",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
-        method = "g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.RepeatTest",
-        method = "g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SackTest",
         method = "g_withSackXmap__map_cloneX_V_out_out_sackXmap_a_nameX_sack",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_out_sideEffectXincr_cX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_out_sideEffectXX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_sideEffectXstore_aX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest",
         method = "g_V_withSideEffectXsgX_outEXknowsX_subgraphXsgX_name_capXsgX",
@@ -179,10 +63,6 @@ import org.apache.tinkerpop.gremlin.util.TinkerGraphProvider;
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest",
         method = "g_withSideEffectXsgX_V_hasXname_danielXout_capXsgX",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.UnfoldTest",
-        method = "g_V_valueMap_unfold_mapXkeyX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.ProgramTest",
         method = "*",
diff --git a/gremlin-groovy/src/test/java/org/apache/tinkerpop/gremlin/groovy/jsr223/ParameterizedGroovyTranslatorProvider.java b/gremlin-groovy/src/test/java/org/apache/tinkerpop/gremlin/groovy/jsr223/ParameterizedGroovyTranslatorProvider.java
index fb4ef311b1..516dfba04c 100644
--- a/gremlin-groovy/src/test/java/org/apache/tinkerpop/gremlin/groovy/jsr223/ParameterizedGroovyTranslatorProvider.java
+++ b/gremlin-groovy/src/test/java/org/apache/tinkerpop/gremlin/groovy/jsr223/ParameterizedGroovyTranslatorProvider.java
@@ -32,93 +32,13 @@ import org.apache.tinkerpop.gremlin.util.TinkerGraphProvider;
         method = "*",
         reason = "Tests for profile() are not supported for remotes")
 @Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.BranchTest",
-        method = "g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.ChooseTest",
-        method = "g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name",
+        test = "org.apache.tinkerpop.gremlin.process.traversal.step.LambdaStepTest",
+        method = "*",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.DedupTest",
         method = "g_V_both_name_order_byXa_bX_dedup_value",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_E_filterXfalseX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_E_filterXtrueX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXfalseX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXlang_eq_javaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXname_startsWith_m_OR_name_startsWith_pX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXtrueX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX1X_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX1X_out_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX2X_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest",
-        method = "g_V_group_byXname_substring_1X_byXconstantX1XX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest",
-        method = "g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasTest",
-        method = "g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectTest",
-        method = "g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_mapXnameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_out_mapXnameX_mapXlengthX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_outE_label_mapXlengthX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_withPath_V_asXaX_out_mapXa_nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_withPath_V_asXaX_out_out_mapXa_name_it_nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
-        method = "g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
         method = "g_V_name_order_byXa1_b1X_byXb2_a2X",
@@ -127,46 +47,10 @@ import org.apache.tinkerpop.gremlin.util.TinkerGraphProvider;
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
         method = "g_V_order_byXname_a1_b1X_byXname_b2_a2X_name",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
-        method = "g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.RepeatTest",
-        method = "g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SackTest",
         method = "g_withSackXmap__map_cloneX_V_out_out_sackXmap_a_nameX_sack",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_out_sideEffectXincr_cX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_out_sideEffectXX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_sideEffectXstore_aX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest",
         method = "g_V_withSideEffectXsgX_outEXknowsX_subgraphXsgX_name_capXsgX",
@@ -179,10 +63,6 @@ import org.apache.tinkerpop.gremlin.util.TinkerGraphProvider;
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest",
         method = "g_withSideEffectXsgX_V_hasXname_danielXout_capXsgX",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.UnfoldTest",
-        method = "g_V_valueMap_unfold_mapXkeyX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.ProgramTest",
         method = "*",
diff --git a/gremlin-javascript/build/generate.groovy b/gremlin-javascript/build/generate.groovy
index 29c146dc98..359ced0b39 100644
--- a/gremlin-javascript/build/generate.groovy
+++ b/gremlin-javascript/build/generate.groovy
@@ -56,7 +56,7 @@ radishGremlinFile.withWriter('UTF-8') { Writer writer ->
     writer.writeLine(
                     'const graphTraversalModule = require(\'../../lib/process/graph-traversal\');\n' +
                     'const traversalModule = require(\'../../lib/process/traversal\');\n' +
-                    'const { TraversalStrategies, VertexProgramStrategy, OptionsStrategy, PartitionStrategy, ReadOnlyStrategy, SeedStrategy, SubgraphStrategy, ProductiveByStrategy } = require(\'../../lib/process/traversal-strategy\');\n' +
+                    'const { TraversalStrategies, VertexProgramStrategy, OptionsStrategy, PartitionStrategy, ReadOnlyStrategy, SeedStrategy, SubgraphStrategy, ProductiveByStrategy, LambdaRestrictionStrategy } = require(\'../../lib/process/traversal-strategy\');\n' +
                     'const __ = graphTraversalModule.statics;\n' +
                     'const Barrier = traversalModule.barrier\n' +
                     'const Cardinality = traversalModule.cardinality\n' +
@@ -89,10 +89,7 @@ radishGremlinFile.withWriter('UTF-8') { Writer writer ->
 
     writer.writeLine('const gremlins = {')
     gremlins.each { k,v ->
-        // skipping lambdas until we decide for sure that they are out in 4.x
-        if (v.any { it.contains('l1')} || v.any { it.contains('pred1')} || v.any { it.contains('Lambda')}) {
-            writer.writeLine("    '${k}': [],  // skipping as it contains a lambda")
-        } else if (staticTranslate.containsKey(k)) {
+        if (staticTranslate.containsKey(k)) {
             writer.writeLine(staticTranslate[k])
         } else {
             writer.write("    ")
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
index 71a7907789..42e3899e55 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
@@ -58,7 +58,6 @@ const parsers = [
   [ 'l\\[(.*)\\]', toArray ],
   [ 's\\[(.*)\\]', toSet ],
   [ 'm\\[(.+)\\]', toMap ],
-  [ 'c\\[(.+)\\]', toLambda ],
   [ 't\\[(.+)\\]', toT ],
   [ 'D\\[(.+)\\]', toDirection ],
   [ 'M\\[(.+)\\]', toMerge ]
@@ -154,12 +153,12 @@ const ignoredScenarios = {
   'g_withStrategiesXVertexProgramRestrictionStrategy_VertexProgramStrategyX_V': new IgnoreError(ignoreReason.needsFurtherInvestigation),
   'g_withoutStrategiesXVertexProgramRestrictionStrategyX_V': new IgnoreError(ignoreReason.needsFurtherInvestigation),
   'g_withoutStrategiesXVertexProgramStrategyX_V': new IgnoreError(ignoreReason.needsFurtherInvestigation),
+  'g_withoutStrategiesXLambdaRestrictionStrategyX_V': new IgnoreError(ignoreReason.needsFurtherInvestigation),
 };
 
 Given(/^the (.+) graph$/, function (graphName) {
-  // if the scenario is ignored or if the scenario has no gremlin (i.e. happens for skipped lambdas that can't
-  // translate) then skipp the test
-  if (ignoredScenarios[this.scenario] || gremlin[this.scenario].length === 0) {
+  // if the scenario is ignored then skip the test
+  if (ignoredScenarios[this.scenario]) {
     return 'skipped';
   }
   this.graphName = graphName;
@@ -495,10 +494,6 @@ function parseMapValue(value) {
   return map;
 }
 
-function toLambda(stringLambda) {
-  return () => [stringLambda, "gremlin-groovy"];
-}
-
 /**
  * Adapts the object to be compared, removing labels property of the Path.
  */
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
index 9a3ea1818a..a91b8b8908 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
@@ -26,7 +26,7 @@
 
 const graphTraversalModule = require('../../lib/process/graph-traversal');
 const traversalModule = require('../../lib/process/traversal');
-const { TraversalStrategies, VertexProgramStrategy, OptionsStrategy, PartitionStrategy, ReadOnlyStrategy, SeedStrategy, SubgraphStrategy, ProductiveByStrategy } = require('../../lib/process/traversal-strategy');
+const { TraversalStrategies, VertexProgramStrategy, OptionsStrategy, PartitionStrategy, ReadOnlyStrategy, SeedStrategy, SubgraphStrategy, ProductiveByStrategy, LambdaRestrictionStrategy } = require('../../lib/process/traversal-strategy');
 const __ = graphTraversalModule.statics;
 const Barrier = traversalModule.barrier
 const Cardinality = traversalModule.cardinality
@@ -53,13 +53,11 @@ const TextP = traversalModule.TextP
 const WithOptions = traversalModule.withOptions
 
 const gremlins = {
-    'g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX': [],  // skipping as it contains a lambda
     g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX: [function({g, xx1, xx2}) { return g.V().branch(__.label().is("person").count()).option(xx1, __.values("age")).option(xx2, __.values("lang")).option(xx2, __.values("name")) }], 
     g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX_optionXany__labelX: [function({g, xx1, xx2}) { return g.V().branch(__.label().is("person").count()).option(xx1, __.values("age")).option(xx2, __.values("lang")).option(xx2, __.values("name")).option(Pick.any, __.label()) }], 
     g_V_branchXageX_optionXltX30X__youngX_optionXgtX30X__oldX_optionXnone__on_the_edgeX: [function({g}) { return g.V().hasLabel("person").branch(__.values("age")).option(P.lt(30), __.constant("young")).option(P.gt(30), __.constant("old")).option(Pick.none, __.constant("on the edge")) }], 
     g_V_branchXidentityX_optionXhasLabelXsoftwareX__inXcreatedX_name_order_foldX_optionXhasXname_vadasX__ageX_optionXneqX123X__bothE_countX: [function({g}) { return g.V().branch(__.identity()).option(__.hasLabel("software"), __.in_("created").values("name").order().fold()).option(__.has("name", "vadas"), __.values("age")).option(P.neq(123), __.bothE().count()) }], 
     g_V_chooseXout_countX_optionX2L_nameX_optionX3L_ageX: [function({g, xx1, xx2}) { return g.V().choose(__.out().count()).option(xx1, __.values("name")).option(xx2, __.values("age")) }], 
-    'g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name': [],  // skipping as it contains a lambda
     g_V_chooseXhasLabelXpersonX_and_outXcreatedX__outXknowsX__identityX_name: [function({g}) { return g.V().choose(__.hasLabel("person").and().out("created"), __.out("knows"), __.identity()).values("name") }], 
     g_V_chooseXlabelX_optionXblah__outXknowsXX_optionXbleep__outXcreatedXX_optionXnone__identityX_name: [function({g}) { return g.V().choose(__.label()).option("blah", __.out("knows")).option("bleep", __.out("created")).option(Pick.none, __.identity()).values("name") }], 
     g_V_chooseXoutXknowsX_count_isXgtX0XX__outXknowsXX_name: [function({g}) { return g.V().choose(__.out("knows").count().is(P.gt(0)), __.out("knows")).values("name") }], 
@@ -96,7 +94,6 @@ const gremlins = {
     g_VX1X_repeatXgroupCountXmX_byXloopsX_outX_timesX3X_capXmX: [function({g, vid1}) { return g.V(vid1).repeat(__.groupCount("m").by(__.loops()).out()).times(3).cap("m") }], 
     g_V_repeatXbothX_timesX10X_asXaX_out_asXbX_selectXa_bX: [function({g}) { return g.V().repeat(__.both()).times(10).as("a").out().as("b").select("a", "b").count() }], 
     g_VX1X_repeatXoutX_untilXoutE_count_isX0XX_name: [function({g, vid1}) { return g.V(vid1).repeat(__.out()).until(__.outE().count().is(0)).values("name") }], 
-    'g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX': [],  // skipping as it contains a lambda
     g_V_hasXname_markoX_repeatXoutE_inV_simplePathX_untilXhasXname_rippleXX_path_byXnameX_byXlabelX: [function({g}) { return g.V().has("name", "marko").repeat(__.outE().inV().simplePath()).until(__.has("name", "ripple")).path().by("name").by(T.label) }], 
     g_V_hasXloop_name_loopX_repeatXinX_timesX5X_path_by_name: [function({g}) { return g.V().has("loops", "name", "loop").repeat(__.in_()).times(5).path().by("name") }], 
     g_V_repeatXout_repeatXout_order_byXname_descXX_timesX1XX_timesX1X_limitX1X_path_byXnameX: [function({g}) { return g.V().repeat(__.out().repeat(__.out().order().by("name", Order.desc)).times(1)).times(1).limit(1).path().by("name") }], 
@@ -198,16 +195,15 @@ const gremlins = {
     g_V_properties_drop: [function({g}) { return g.addV().property("name", "bob").addV().property("name", "alice") }, function({g}) { return g.V().properties().drop() }, function({g}) { return g.V() }, function({g}) { return g.V().properties() }], 
     g_E_propertiesXweightX_drop: [function({g}) { return g.addV("person").property("name", "marko").property("age", 29).as("marko").addV("person").property("name", "vadas").property("age", 27).as("vadas").addV("software").property("name", "lop").property("lang", "java").as("lop").addV("person").property("name", "josh").property("age", 32).as("josh").addV("software").property("name", "ripple").property("lang", "java").as("ripple").addV("person").property("name", "peter").property("age", 3 [...]
     g_V_properties_propertiesXstartTimeX_drop: [function({g}) { return g.addV().property("name", "bob").property(Cardinality.list, "location", "ny", "startTime", 2014, "endTime", 2016).property(Cardinality.list, "location", "va", "startTime", 2016).addV().property("name", "alice").property(Cardinality.list, "location", "va", "startTime", 2014, "endTime", 2016).property(Cardinality.list, "location", "ny", "startTime", 2016) }, function({g}) { return g.V().properties().properties("startTim [...]
-    'g_V_filterXfalseX': [],  // skipping as it contains a lambda
-    'g_V_filterXtrueX': [],  // skipping as it contains a lambda
-    'g_V_filterXlang_eq_javaX': [],  // skipping as it contains a lambda
-    'g_VX1X_filterXage_gt_30X': [],  // skipping as it contains a lambda
-    'g_VX2X_filterXage_gt_30X': [],  // skipping as it contains a lambda
-    'g_VX1X_out_filterXage_gt_30X': [],  // skipping as it contains a lambda
-    'g_V_filterXname_startsWith_m_OR_name_startsWith_pX': [],  // skipping as it contains a lambda
-    'g_E_filterXfalseX': [],  // skipping as it contains a lambda
-    'g_E_filterXtrueX': [],  // skipping as it contains a lambda
-    'g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name': [],  // skipping as it contains a lambda
+    g_V_filterXisX0XX: [function({g}) { return g.V().filter(__.is(0)) }], 
+    g_V_filterXconstantX0XX: [function({g}) { return g.V().filter(__.constant(0)) }], 
+    g_V_filterXhasXlang_javaXX: [function({g}) { return g.V().filter(__.has("lang", "java")) }], 
+    g_VX1X_filterXhasXage_gtX30XXX: [function({g, vid1}) { return g.V(vid1).filter(__.has("age", P.gt(30))) }], 
+    g_VX2X_filterXhasXage_gtX30XXX: [function({g, vid2}) { return g.V(vid2).filter(__.has("age", P.gt(30))) }], 
+    g_VX1X_out_filterXhasXage_gtX30XXX: [function({g, vid1}) { return g.V(vid1).out().filter(__.has("age", P.gt(30))) }], 
+    g_V_filterXhasXname_startingWithXm_or_pXX: [function({g}) { return g.V().filter(__.has("name", TextP.startingWith("m").or(TextP.startingWith("p")))) }], 
+    g_E_filterXisX0XX: [function({g}) { return g.E().filter(__.is(0)) }], 
+    g_E_filterXconstantX0XX: [function({g}) { return g.E().filter(__.constant(0)) }], 
     g_VX1X_hasXnameX: [function({g, vid1}) { return g.V(vid1).has("name") }], 
     g_VX1X_hasXcircumferenceX: [function({g, vid1}) { return g.V(vid1).has("circumference") }], 
     g_VX1X_hasXname_markoX: [function({g, vid1}) { return g.V(vid1).has("name", "marko") }], 
@@ -426,8 +422,8 @@ const gremlins = {
     g_withoutStrategiesXIncidentToAdjacentStrategyX_V_outE_inV: [function({g}) { return g.withoutStrategies(IncidentToAdjacentStrategy).V().outE().inV() }], 
     g_withStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX: [function({g}) { return g.withStrategies(new InlineFilterStrategy()).V().filter(__.has("name", "marko")) }], 
     g_withoutStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX: [function({g}) { return g.withoutStrategies(InlineFilterStrategy).V().filter(__.has("name", "marko")) }], 
-    'g_withStrategiesXLambdaRestrictionStrategyX_V': [],  // skipping as it contains a lambda
-    'g_withoutStrategiesXLambdaRestrictionStrategyX_V': [],  // skipping as it contains a lambda
+    g_withStrategiesXLambdaRestrictionStrategyX_V: [function({g}) { return g.withStrategies(new LambdaRestrictionStrategy()).V() }], 
+    g_withoutStrategiesXLambdaRestrictionStrategyX_V: [function({g}) { return g.withoutStrategies(LambdaRestrictionStrategy).V() }], 
     g_withStrategiesXLazyBarrierStrategyX_V_out_bothE_count: [function({g}) { return g.withStrategies(new LazyBarrierStrategy()).V().out().bothE().count() }], 
     g_withoutStrategiesXLazyBarrierStrategyX_V_out_bothE_count: [function({g}) { return g.withoutStrategies(LazyBarrierStrategy).V().out().bothE().count() }], 
     g_withStrategiesXMatchAlgorithmStrategyXmatchAlgorithm_CountMatchAlgorithmXX_V_matchXa_knows_b__a_created_cX: [function({g}) { return g.withStrategies(new MatchAlgorithmStrategy({matchAlgorithm: "org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchStep$CountMatchAlgorithm"})).V().match(__.as("a").out("knows").as("b"), __.as("a").out("created").as("c")) }], 
@@ -780,6 +776,7 @@ const gremlins = {
     g_EX11X_elementMap: [function({g, eid11}) { return g.E(eid11).elementMap() }], 
     g_V_elementMapXname_age_nullX: [function({g}) { return g.V().elementMap("name", "age", null) }], 
     g_V_asXaX_flatMapXselectXaXX: [function({g}) { return g.V().as("a").flatMap(__.select("a")) }], 
+    g_V_valuesXnameX_flatMapXsplitXaX_unfoldX: [function({g}) { return g.V().values("name").flatMap(__.split("a").unfold()) }], 
     g_V_fold: [function({g}) { return g.V().fold() }], 
     g_V_fold_unfold: [function({g}) { return g.V().fold().unfold() }], 
     g_V_age_foldX0_plusX: [function({g}) { return g.V().values("age").fold(0, Operator.sum) }], 
@@ -838,12 +835,11 @@ const gremlins = {
     g_VX1X_repeatXboth_simplePathX_untilXhasXname_peterX_or_loops_isX2XX_hasXname_peterX_path_byXnameX: [function({g, vid1}) { return g.V(vid1).repeat(__.both().simplePath()).until(__.has("name", "peter").or().loops().is(2)).has("name", "peter").path().by("name") }], 
     g_VX1X_repeatXboth_simplePathX_untilXhasXname_peterX_and_loops_isX3XX_hasXname_peterX_path_byXnameX: [function({g, vid1}) { return g.V(vid1).repeat(__.both().simplePath()).until(__.has("name", "peter").and().loops().is(3)).has("name", "peter").path().by("name") }], 
     g_V_emitXhasXname_markoX_or_loops_isX2XX_repeatXoutX_valuesXnameX: [function({g}) { return g.V().emit(__.has("name", "marko").or().loops().is(2)).repeat(__.out()).values("name") }], 
-    'g_VX1X_mapXnameX': [],  // skipping as it contains a lambda
-    'g_VX1X_outE_label_mapXlengthX': [],  // skipping as it contains a lambda
-    'g_VX1X_out_mapXnameX_mapXlengthX': [],  // skipping as it contains a lambda
-    'g_VX1X_out_mapXlambdaXnameXX_mapXlambdaXlengthXX': [],  // skipping as it contains a lambda
-    'g_withPath_V_asXaX_out_mapXa_nameX': [],  // skipping as it contains a lambda
-    'g_withPath_V_asXaX_out_out_mapXa_name_it_nameX': [],  // skipping as it contains a lambda
+    g_VX1X_mapXvaluesXnameXX: [function({g, vid1}) { return g.V(vid1).map(__.values("name")) }], 
+    g_VX1X_outE_label_mapXlengthX: [function({g, vid1}) { return g.V(vid1).outE().label().map(__.length()) }], 
+    g_VX1X_out_mapXvaluesXnameXX_mapXlengthX: [function({g, vid1}) { return g.V(vid1).out().map(__.values("name")).map(__.length()) }], 
+    g_withPath_V_asXaX_out_mapXselectXaX_valuesXnameXX: [function({g}) { return g.withPath().V().as("a").out().map(__.select("a").values("name")) }], 
+    g_withPath_V_asXaX_out_out_asXbX_mapXselectXaX_valuesXnameX_concatXselectXbX_valuesXnameXXX: [function({g}) { return g.withPath().V().as("a").out().out().as("b").map(__.select("a").values("name").concat(__.select("b").values("name"))) }], 
     g_V_mapXselectXaXX: [function({g}) { return g.V().as("a").map(__.select("a")) }], 
     g_V_mapXconstantXnullXX: [function({g}) { return g.V().map(__.constant(null)) }], 
     g_V_valueMap_matchXa_selectXnameX_bX: [function({g}) { return g.V().valueMap().match(__.as("a").select("name").as("b")) }], 
@@ -1083,7 +1079,6 @@ const gremlins = {
     g_V_asXaX_outXcreatedX_asXbX_order_byXshuffleX_selectXa_bX: [function({g}) { return g.V().as("a").out("created").as("b").order().by(Order.shuffle).select("a", "b") }], 
     g_V_both_hasLabelXpersonX_order_byXage_descX_limitX5X_name: [function({g}) { return g.V().both().hasLabel("person").order().by("age", Order.desc).limit(5).values("name") }], 
     g_V_properties_order_byXkey_descX_key: [function({g}) { return g.V().properties().order().by(T.key, Order.desc).key() }], 
-    'g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name': [],  // skipping as it contains a lambda
     g_V_hasLabelXpersonX_group_byXnameX_byXoutE_weight_sumX_orderXlocalX_byXvaluesX: [function({g}) { return g.V().hasLabel("person").group().by("name").by(__.outE().values("weight").sum()).order(Scope.local).by(Column.values) }], 
     g_V_mapXbothE_weight_foldX_order_byXsumXlocalX_descX_byXcountXlocalX_descX: [function({g}) { return g.V().map(__.bothE().values("weight").order().by(Order.asc).fold()).order().by(__.sum(Scope.local), Order.desc).by(__.count(Scope.local), Order.desc) }], 
     g_V_group_byXlabelX_byXname_order_byXdescX_foldX: [function({g}) { return g.V().group().by(T.label).by(__.values("name").order().by(Order.desc).fold()) }], 
@@ -1098,7 +1093,6 @@ const gremlins = {
     g_V_fold_orderXlocalX_byXage_descX: [function({g}) { return g.V().fold().order(Scope.local).by("age", Order.desc) }], 
     g_V_orXhasLabelXpersonX_hasXsoftware_name_lopXX_order_byXageX: [function({g}) { return g.V().or(__.hasLabel("person"), __.has("software", "name", "lop")).order().by("age") }], 
     g_withStrategiesXProductiveByStrategyX_V_orXhasLabelXpersonX_hasXsoftware_name_lopXX_order_byXageX: [function({g}) { return g.withStrategies(new ProductiveByStrategy()).V().or(__.hasLabel("person"), __.has("software", "name", "lop")).order().by("age") }], 
-    'g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX': [],  // skipping as it contains a lambda
     g_V_hasXsong_name_OHBOYX_outXfollowedByX_outXfollowedByX_order_byXperformancesX_byXsongType_descX: [function({g}) { return g.V().has("song", "name", "OH BOY").out("followedBy").out("followedBy").order().by("performances").by("songType", Order.desc).by("name") }], 
     g_V_hasLabelXsongX_order_byXperformances_descX_byXnameX_rangeX110_120X_name: [function({g}) { return g.V().hasLabel("song").order().by("performances", Order.desc).by("name").range(110, 120).values("name") }], 
     g_VX1X_elementMap_orderXlocalX_byXkeys_descXunfold: [function({g, vid1}) { return g.V(vid1).elementMap().order(Scope.local).by(Column.keys, Order.desc).unfold() }], 
@@ -1336,7 +1330,7 @@ const gremlins = {
     g_V_valuesXnameX_trim: [function({g}) { return g.addV("person").property("name", " marko ").property("age", 29).as("marko").addV("person").property("name", "  vadas  ").property("age", 27).as("vadas").addV("software").property("name", "  lop").property("lang", "java").as("lop").addV("person").property("name", "josh  ").property("age", 32).as("josh").addV("software").property("name", "   ripple   ").property("lang", "java").as("ripple").addV("person").property("name", "peter").propert [...]
     g_V_valuesXnameX_order_fold_trimXlocalX: [function({g}) { return g.addV("person").property("name", " marko ").property("age", 29).as("marko").addV("person").property("name", "  vadas  ").property("age", 27).as("vadas").addV("software").property("name", "  lop").property("lang", "java").as("lop").addV("person").property("name", "josh  ").property("age", 32).as("josh").addV("software").property("name", "   ripple   ").property("lang", "java").as("ripple").addV("person").property("name" [...]
     g_V_localXoutE_foldX_unfold: [function({g}) { return g.V().local(__.outE().fold()).unfold() }], 
-    'g_V_valueMap_unfold_mapXkeyX': [],  // skipping as it contains a lambda
+    g_V_valueMap_unfold_mapXselectXkeysXX: [function({g}) { return g.V().valueMap().unfold().map(__.select(Column.keys)) }], 
     g_VX1X_repeatXboth_simplePathX_untilXhasIdX6XX_path_byXnameX_unfold: [function({g, vid6, vid1}) { return g.V(vid1).repeat(__.both().simplePath()).until(__.hasId(vid6)).path().by("name").unfold() }], 
     g_V_valueMap: [function({g}) { return g.V().valueMap() }], 
     g_V_valueMapXtrueX: [function({g}) { return g.V().valueMap(true) }], 
@@ -1568,7 +1562,7 @@ const gremlins = {
     g_V_hasXlangX_group_byXlangX_byXcountX: [function({g}) { return g.V().has("lang").group().by("lang").by(__.count()) }], 
     g_V_group_byXoutE_countX_byXnameX: [function({g}) { return g.V().order().by("name").group().by(__.outE().count()).by("name") }], 
     g_V_repeatXbothXfollowedByXX_timesX2X_group_byXsongTypeX_byXcountX: [function({g}) { return g.V().repeat(__.both("followedBy")).times(2).group().by("songType").by(__.count()) }], 
-    'g_V_group_byXname_substring_1X_byXconstantX1XX': [],  // skipping as it contains a lambda
+    g_V_group_byXvaluesXnameX_substringX1XX_byXconstantX1XX: [function({g}) { return g.V().group().by(__.values("name").substring(0, 1)).by(__.constant(1)) }], 
     g_V_out_group_byXlabelX_selectXpersonX_unfold_outXcreatedX_name_limitX2X: [function({g}) { return g.V().out().group().by(T.label).select("person").unfold().out("created").values("name").limit(2) }], 
     g_V_hasLabelXsongX_group_byXnameX_byXproperties_groupCount_byXlabelXX: [function({g}) { return g.V().hasLabel("song").group().by("name").by(__.properties().groupCount().by(T.label)) }], 
     g_V_outXfollowedByX_group_byXsongTypeX_byXbothE_group_byXlabelX_byXweight_sumXX: [function({g}) { return g.V().out("followedBy").group().by("songType").by(__.bothE().group().by(T.label).by(__.values("weight").sum())) }], 
@@ -1604,7 +1598,7 @@ const gremlins = {
     g_V_outXcreatedX_groupCount_byXnameX_byXageX: [function({g}) { return g.V().out("created").groupCount().by("name").by("age") }], 
     g_V_outXcreatedX_groupCountXxX_byXnameX_byXageX: [function({g}) { return g.V().out("created").groupCount("x").by("name").by("age") }], 
     g_VX1X_out_injectXv2X_name: [function({g, vid1, v2}) { return g.V(vid1).out().inject(v2).values("name") }], 
-    'g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path': [],  // skipping as it contains a lambda
+    g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path: [function({g, vid1}) { return g.V(vid1).out().values("name").inject("daniel").as("a").map(__.length()).path() }], 
     g_VX1X_injectXg_VX4XX_out_name: [function({g, vid1, v2}) { return g.V(vid1).inject(v2).out().values("name") }], 
     g_injectXnull_1_3_nullX: [function({g}) { return g.inject(null, 1, 3, null) }], 
     g_injectX10_20_null_20_10_10X_groupCountXxX_dedup_asXyX_projectXa_bX_by_byXselectXxX_selectXselectXyXXX: [function({g}) { return g.inject(10, 20, null, 20, 10, 10).groupCount("x").dedup().as("y").project("a", "b").by().by(__.select("x").select(__.select("y"))) }], 
@@ -1635,6 +1629,11 @@ const gremlins = {
     g_V_sackXassignX_byXageX_sack: [function({g}) { return g.V().sack(Operator.assign).by("age").sack() }], 
     g_withSackXBigInteger_TEN_powX1000X_assignX_V_localXoutXknowsX_barrierXnormSackXX_inXknowsX_barrier_sack: [function({g, xx1}) { return g.withSack(xx1, Operator.assign).V().local(__.out("knows").barrier(Barrier.normSack)).in_("knows").barrier().sack() }], 
     g_withSackX2X_V_sackXdivX_byXconstantX4_0XX_sack: [function({g, xx1}) { return g.withSack(2).V().sack(Operator.div).by(__.constant(xx1)).sack() }], 
+    g_V_sideEffectXidentityX: [function({g}) { return g.V().sideEffect(__.identity()) }], 
+    g_V_sideEffectXidentity_valuesXnameXX: [function({g}) { return g.V().sideEffect(__.identity().values("name")) }], 
+    g_V_sideEffectXpropertyXage_22X: [function({g}) { return g.addV("person").property("age", 21) }, function({g}) { return g.V().sideEffect(__.property("age", 22)) }, function({g}) { return g.V().has("age", 21) }, function({g}) { return g.V().has("age", 22) }], 
+    g_V_group_byXvaluesXnameX_sideEffectXconstantXzyxXX_substringX1XX_byXconstantX1X_sideEffectXconstantXxyzXXX: [function({g}) { return g.V().group().by(__.values("name").sideEffect(__.constant("zyx")).substring(0, 1)).by(__.constant(1).sideEffect(__.constant("xyz"))) }], 
+    g_withSideEffectXx_setX_V_both_both_sideEffectXstoreXxX_byXnameXX_capXxX_unfold: [function({g}) { return g.withSideEffect("x", new Set([])).V().both().both().sideEffect(__.store("x").by("name")).cap("x").unfold() }], 
     g_V_hasXageX_groupCountXaX_byXnameX_out_capXaX: [function({g}) { return g.V().has("age").groupCount("a").by("name").out().cap("a") }], 
     g_V_groupXaX_byXageX_capXaX: [function({g}) { return g.V().group("a").by("age").cap("a") }], 
     g_V_groupXaX_byXnameX_capXaX: [function({g}) { return g.V().group("a").by("name").cap("a") }], 
@@ -1642,11 +1641,12 @@ const gremlins = {
     g_V_repeatXout_groupXaX_byXnameX_byXcountX_timesX2X_capXaX: [function({g}) { return g.V().repeat(__.out().group("a").by("name").by(__.count())).times(2).cap("a") }], 
     g_V_groupXaX_byXlabelX_byXoutE_weight_sumX_capXaX: [function({g}) { return g.V().group("a").by(T.label).by(__.outE().values("weight").sum()).cap("a") }], 
     g_V_repeatXbothXfollowedByXX_timesX2X_groupXaX_byXsongTypeX_byXcountX_capXaX: [function({g}) { return g.V().repeat(__.both("followedBy")).times(2).group("a").by("songType").by(__.count()).cap("a") }], 
-    'g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX': [],  // skipping as it contains a lambda
+    g_V_groupXaX_byXvaluesXnameX_substringX1XX_byXconstantX1XX_capXaX: [function({g}) { return g.V().group("a").by(__.values("name").substring(0, 1)).by(__.constant(1)).cap("a") }], 
     g_V_hasLabelXsongX_groupXaX_byXnameX_byXproperties_groupCount_byXlabelXX_out_capXaX: [function({g}) { return g.V().hasLabel("song").group("a").by("name").by(__.properties().groupCount().by(T.label)).out().cap("a") }], 
     g_V_hasLabelXpersonX_asXpX_outXcreatedX_groupXaX_byXnameX_byXselectXpX_valuesXageX_sumX_capXaX: [function({g}) { return g.V().hasLabel("person").as("p").out("created").group("a").by("name").by(__.select("p").values("age").sum()).cap("a") }], 
     g_V_groupXmX_byXnameX_byXinXknowsX_nameX_capXmX: [function({g}) { return g.V().group("m").by("name").by(__.in_("knows").values("name")).cap("m") }], 
     g_V_groupXmX_byXlabelX_byXlabel_countX_capXmX: [function({g}) { return g.V().group("m").by(__.label()).by(__.label().count()).cap("m") }], 
+    g_V_chooseXlabel_person__age_groupCountXaX__name_groupCountXbXX_capXa_bX_unfold: [function({g}) { return g.V().choose(__.has(T.label, "person"), __.values("age").groupCount("a"), __.values("name").groupCount("b")).cap("a", "b").unfold() }], 
     g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_orderX_capXaX: [function({g}) { return g.V().has("person", "name", P.within("vadas", "peter")).group("a").by().by(__.out().order()).cap("a") }], 
     g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_order_countX_capXaX: [function({g}) { return g.V().has("person", "name", P.within("vadas", "peter")).group("a").by().by(__.out().order().count()).cap("a") }], 
     g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_order_fold_countXlocalXX_capXaX: [function({g}) { return g.V().has("person", "name", P.within("vadas", "peter")).group("a").by().by(__.out().order().fold().count(Scope.local)).cap("a") }], 
diff --git a/gremlin-python/build/generate.groovy b/gremlin-python/build/generate.groovy
index 4ca45b3149..026319bb1e 100644
--- a/gremlin-python/build/generate.groovy
+++ b/gremlin-python/build/generate.groovy
@@ -70,10 +70,7 @@ radishGremlinFile.withWriter('UTF-8') { Writer writer ->
 
     writer.writeLine('world.gremlins = {')
     gremlins.each { k,v ->
-        // skipping lambdas until we decide for sure that they are out in 4.x
-        if (v.any { it.contains('l1')} || v.any { it.contains('pred1')} || v.any { it.contains('Lambda')}) {
-            writer.writeLine("    '${k}': [],  # skipping as it contains a lambda")
-        } else if (staticTranslate.containsKey(k)) {
+        if (staticTranslate.containsKey(k)) {
             writer.writeLine(staticTranslate[k])
         } else {
             writer.write("    '")
diff --git a/gremlin-python/src/main/python/radish/feature_steps.py b/gremlin-python/src/main/python/radish/feature_steps.py
index e87be53f41..6b1e0110c6 100644
--- a/gremlin-python/src/main/python/radish/feature_steps.py
+++ b/gremlin-python/src/main/python/radish/feature_steps.py
@@ -36,6 +36,8 @@ project = __.project
 tail = __.tail
 
 ignores = [
+    "g.V().choose(has(T.label, \"person\"),values(\"age\").groupCount(\"a\"), values(\"name\").groupCount(\"b\")).cap(\"a\", \"b\").unfold()", # uses embedded Map in assertion
+    "g.withSideEffect(\"x\",{}).V().both().both().sideEffect(__.store(\"x\").by(\"name\")).cap(\"x\").unfold()", # Objects must be both of Map or Collection: a=LinkedHashMap b=BulkSet???
     "g.withoutStrategies(CountStrategy).V().count()" # serialization issues with Class in GraphSON
     "g.withoutStrategies(LazyBarrierStrategy).V().as(\"label\").aggregate(local,\"x\").select(\"x\").select(\"label\")",
     "g.withSack(xx1, Operator.assign).V().local(__.out(\"knows\").barrier(Barrier.normSack)).in(\"knows\").barrier().sack()", # issues with BigInteger/BigDecimal - why do we carry BigDecimal? just use python Decimal module?
@@ -45,9 +47,7 @@ ignores = [
 
 @given("the {graph_name:w} graph")
 def choose_graph(step, graph_name):
-    # if we have no traversals then we are ignoring the test - should be temporary until we can settle out the
-    # issue of handling the removal of lambdas from Gremlin as a language
-    step.context.ignore = len(step.context.traversals) == 0
+    step.context.ignore = False
     tagset = [tag.name for tag in step.all_tags]
     if not step.context.ignore:
         step.context.ignore = "AllowNullPropertyValues" in tagset
@@ -272,8 +272,6 @@ def _convert(val, ctx):
     elif isinstance(val, str) and re.match(r"^p\[.*\]$", val):  # parse path
         path_objects = list(map((lambda x: _convert(x, ctx)), val[2:-1].split(",")))
         return Path([set([])], path_objects)
-    elif isinstance(val, str) and re.match(r"^c\[.*\]$", val):  # parse lambda/closure
-        return lambda: (val[2:-1], "gremlin-groovy")
     elif isinstance(val, str) and re.match(r"^t\[.*\]$", val):  # parse instance of T enum
         return T[val[2:-1]]
     elif isinstance(val, str) and re.match(r"^D\[.*\]$", val):  # parse instance of Direction enum
diff --git a/gremlin-python/src/main/python/radish/gremlin.py b/gremlin-python/src/main/python/radish/gremlin.py
index a5865cf775..cf73d3b836 100644
--- a/gremlin-python/src/main/python/radish/gremlin.py
+++ b/gremlin-python/src/main/python/radish/gremlin.py
@@ -35,13 +35,11 @@ from gremlin_python.structure.graph import Graph
 from gremlin_python.process.traversal import Barrier, Cardinality, CardinalityValue, P, TextP, Pop, Scope, Column, Order, Direction, DT, Merge, T, Pick, Operator, IO, WithOptions
 
 world.gremlins = {
-    'g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX': [],  # skipping as it contains a lambda
     'g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX': [(lambda g, xx1=None,xx2=None:g.V().branch(__.label().is_('person').count()).option(xx1, __.values('age')).option(xx2, __.values('lang')).option(xx2, __.values('name')))], 
     'g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX_optionXany__labelX': [(lambda g, xx1=None,xx2=None:g.V().branch(__.label().is_('person').count()).option(xx1, __.values('age')).option(xx2, __.values('lang')).option(xx2, __.values('name')).option(Pick.any_, __.label()))], 
     'g_V_branchXageX_optionXltX30X__youngX_optionXgtX30X__oldX_optionXnone__on_the_edgeX': [(lambda g:g.V().has_label('person').branch(__.values('age')).option(P.lt(30), __.constant('young')).option(P.gt(30), __.constant('old')).option(Pick.none, __.constant('on the edge')))], 
     'g_V_branchXidentityX_optionXhasLabelXsoftwareX__inXcreatedX_name_order_foldX_optionXhasXname_vadasX__ageX_optionXneqX123X__bothE_countX': [(lambda g:g.V().branch(__.identity()).option(__.has_label('software'), __.in_('created').values('name').order().fold()).option(__.has('name', 'vadas'), __.values('age')).option(P.neq(123), __.both_e().count()))], 
     'g_V_chooseXout_countX_optionX2L_nameX_optionX3L_ageX': [(lambda g, xx1=None,xx2=None:g.V().choose(__.out().count()).option(xx1, __.values('name')).option(xx2, __.values('age')))], 
-    'g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name': [],  # skipping as it contains a lambda
     'g_V_chooseXhasLabelXpersonX_and_outXcreatedX__outXknowsX__identityX_name': [(lambda g:g.V().choose(__.has_label('person').and_().out('created'), __.out('knows'), __.identity()).values('name'))], 
     'g_V_chooseXlabelX_optionXblah__outXknowsXX_optionXbleep__outXcreatedXX_optionXnone__identityX_name': [(lambda g:g.V().choose(__.label()).option('blah', __.out('knows')).option('bleep', __.out('created')).option(Pick.none, __.identity()).values('name'))], 
     'g_V_chooseXoutXknowsX_count_isXgtX0XX__outXknowsXX_name': [(lambda g:g.V().choose(__.out('knows').count().is_(P.gt(0)), __.out('knows')).values('name'))], 
@@ -78,7 +76,6 @@ world.gremlins = {
     'g_VX1X_repeatXgroupCountXmX_byXloopsX_outX_timesX3X_capXmX': [(lambda g, vid1=None:g.V(vid1).repeat(__.group_count('m').by(__.loops()).out()).times(3).cap('m'))], 
     'g_V_repeatXbothX_timesX10X_asXaX_out_asXbX_selectXa_bX': [(lambda g:g.V().repeat(__.both()).times(10).as_('a').out().as_('b').select('a', 'b').count())], 
     'g_VX1X_repeatXoutX_untilXoutE_count_isX0XX_name': [(lambda g, vid1=None:g.V(vid1).repeat(__.out()).until(__.out_e().count().is_(0)).values('name'))], 
-    'g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX': [],  # skipping as it contains a lambda
     'g_V_hasXname_markoX_repeatXoutE_inV_simplePathX_untilXhasXname_rippleXX_path_byXnameX_byXlabelX': [(lambda g:g.V().has('name', 'marko').repeat(__.out_e().in_v().simple_path()).until(__.has('name', 'ripple')).path().by('name').by(T.label))], 
     'g_V_hasXloop_name_loopX_repeatXinX_timesX5X_path_by_name': [(lambda g:g.V().has('loops', 'name', 'loop').repeat(__.in_()).times(5).path().by('name'))], 
     'g_V_repeatXout_repeatXout_order_byXname_descXX_timesX1XX_timesX1X_limitX1X_path_byXnameX': [(lambda g:g.V().repeat(__.out().repeat(__.out().order().by('name', Order.desc)).times(1)).times(1).limit(1).path().by('name'))], 
@@ -180,16 +177,15 @@ world.gremlins = {
     'g_V_properties_drop': [(lambda g:g.add_v().property('name', 'bob').add_v().property('name', 'alice')), (lambda g:g.V().properties().drop()), (lambda g:g.V()), (lambda g:g.V().properties())], 
     'g_E_propertiesXweightX_drop': [(lambda g:g.add_v('person').property('name', 'marko').property('age', 29).as_('marko').add_v('person').property('name', 'vadas').property('age', 27).as_('vadas').add_v('software').property('name', 'lop').property('lang', 'java').as_('lop').add_v('person').property('name', 'josh').property('age', 32).as_('josh').add_v('software').property('name', 'ripple').property('lang', 'java').as_('ripple').add_v('person').property('name', 'peter').property('age', 3 [...]
     'g_V_properties_propertiesXstartTimeX_drop': [(lambda g:g.add_v().property('name', 'bob').property(Cardinality.list_, 'location', 'ny', 'startTime', 2014, 'endTime', 2016).property(Cardinality.list_, 'location', 'va', 'startTime', 2016).add_v().property('name', 'alice').property(Cardinality.list_, 'location', 'va', 'startTime', 2014, 'endTime', 2016).property(Cardinality.list_, 'location', 'ny', 'startTime', 2016)), (lambda g:g.V().properties().properties('startTime').drop()), (lambd [...]
-    'g_V_filterXfalseX': [],  # skipping as it contains a lambda
-    'g_V_filterXtrueX': [],  # skipping as it contains a lambda
-    'g_V_filterXlang_eq_javaX': [],  # skipping as it contains a lambda
-    'g_VX1X_filterXage_gt_30X': [],  # skipping as it contains a lambda
-    'g_VX2X_filterXage_gt_30X': [],  # skipping as it contains a lambda
-    'g_VX1X_out_filterXage_gt_30X': [],  # skipping as it contains a lambda
-    'g_V_filterXname_startsWith_m_OR_name_startsWith_pX': [],  # skipping as it contains a lambda
-    'g_E_filterXfalseX': [],  # skipping as it contains a lambda
-    'g_E_filterXtrueX': [],  # skipping as it contains a lambda
-    'g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name': [],  # skipping as it contains a lambda
+    'g_V_filterXisX0XX': [(lambda g:g.V().filter_(__.is_(0)))], 
+    'g_V_filterXconstantX0XX': [(lambda g:g.V().filter_(__.constant(0)))], 
+    'g_V_filterXhasXlang_javaXX': [(lambda g:g.V().filter_(__.has('lang', 'java')))], 
+    'g_VX1X_filterXhasXage_gtX30XXX': [(lambda g, vid1=None:g.V(vid1).filter_(__.has('age', P.gt(30))))], 
+    'g_VX2X_filterXhasXage_gtX30XXX': [(lambda g, vid2=None:g.V(vid2).filter_(__.has('age', P.gt(30))))], 
+    'g_VX1X_out_filterXhasXage_gtX30XXX': [(lambda g, vid1=None:g.V(vid1).out().filter_(__.has('age', P.gt(30))))], 
+    'g_V_filterXhasXname_startingWithXm_or_pXX': [(lambda g:g.V().filter_(__.has('name', TextP.starting_with('m').or_(TextP.starting_with('p')))))], 
+    'g_E_filterXisX0XX': [(lambda g:g.E().filter_(__.is_(0)))], 
+    'g_E_filterXconstantX0XX': [(lambda g:g.E().filter_(__.constant(0)))], 
     'g_VX1X_hasXnameX': [(lambda g, vid1=None:g.V(vid1).has('name'))], 
     'g_VX1X_hasXcircumferenceX': [(lambda g, vid1=None:g.V(vid1).has('circumference'))], 
     'g_VX1X_hasXname_markoX': [(lambda g, vid1=None:g.V(vid1).has('name', 'marko'))], 
@@ -408,8 +404,8 @@ world.gremlins = {
     'g_withoutStrategiesXIncidentToAdjacentStrategyX_V_outE_inV': [(lambda g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IncidentToAdjacentStrategy')]).V().out_e().in_v())], 
     'g_withStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX': [(lambda g:g.with_strategies(InlineFilterStrategy()).V().filter_(__.has('name', 'marko')))], 
     'g_withoutStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX': [(lambda g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.InlineFilterStrategy')]).V().filter_(__.has('name', 'marko')))], 
-    'g_withStrategiesXLambdaRestrictionStrategyX_V': [],  # skipping as it contains a lambda
-    'g_withoutStrategiesXLambdaRestrictionStrategyX_V': [],  # skipping as it contains a lambda
+    'g_withStrategiesXLambdaRestrictionStrategyX_V': [(lambda g:g.with_strategies(LambdaRestrictionStrategy()).V())], 
+    'g_withoutStrategiesXLambdaRestrictionStrategyX_V': [(lambda g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.LambdaRestrictionStrategy')]).V())], 
     'g_withStrategiesXLazyBarrierStrategyX_V_out_bothE_count': [(lambda g:g.with_strategies(LazyBarrierStrategy()).V().out().both_e().count())], 
     'g_withoutStrategiesXLazyBarrierStrategyX_V_out_bothE_count': [(lambda g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.LazyBarrierStrategy')]).V().out().both_e().count())], 
     'g_withStrategiesXMatchAlgorithmStrategyXmatchAlgorithm_CountMatchAlgorithmXX_V_matchXa_knows_b__a_created_cX': [(lambda g:g.with_strategies(MatchAlgorithmStrategy(match_algorithm='org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchStep$CountMatchAlgorithm')).V().match(__.as_('a').out('knows').as_('b'), __.as_('a').out('created').as_('c')))], 
@@ -762,6 +758,7 @@ world.gremlins = {
     'g_EX11X_elementMap': [(lambda g, eid11=None:g.E(eid11).element_map())], 
     'g_V_elementMapXname_age_nullX': [(lambda g:g.V().element_map('name', 'age', None))], 
     'g_V_asXaX_flatMapXselectXaXX': [(lambda g:g.V().as_('a').flat_map(__.select('a')))], 
+    'g_V_valuesXnameX_flatMapXsplitXaX_unfoldX': [(lambda g:g.V().values('name').flat_map(__.split('a').unfold()))], 
     'g_V_fold': [(lambda g:g.V().fold())], 
     'g_V_fold_unfold': [(lambda g:g.V().fold().unfold())], 
     'g_V_age_foldX0_plusX': [(lambda g:g.V().values('age').fold(0, Operator.sum_))], 
@@ -820,12 +817,11 @@ world.gremlins = {
     'g_VX1X_repeatXboth_simplePathX_untilXhasXname_peterX_or_loops_isX2XX_hasXname_peterX_path_byXnameX': [(lambda g, vid1=None:g.V(vid1).repeat(__.both().simple_path()).until(__.has('name', 'peter').or_().loops().is_(2)).has('name', 'peter').path().by('name'))], 
     'g_VX1X_repeatXboth_simplePathX_untilXhasXname_peterX_and_loops_isX3XX_hasXname_peterX_path_byXnameX': [(lambda g, vid1=None:g.V(vid1).repeat(__.both().simple_path()).until(__.has('name', 'peter').and_().loops().is_(3)).has('name', 'peter').path().by('name'))], 
     'g_V_emitXhasXname_markoX_or_loops_isX2XX_repeatXoutX_valuesXnameX': [(lambda g:g.V().emit(__.has('name', 'marko').or_().loops().is_(2)).repeat(__.out()).values('name'))], 
-    'g_VX1X_mapXnameX': [],  # skipping as it contains a lambda
-    'g_VX1X_outE_label_mapXlengthX': [],  # skipping as it contains a lambda
-    'g_VX1X_out_mapXnameX_mapXlengthX': [],  # skipping as it contains a lambda
-    'g_VX1X_out_mapXlambdaXnameXX_mapXlambdaXlengthXX': [],  # skipping as it contains a lambda
-    'g_withPath_V_asXaX_out_mapXa_nameX': [],  # skipping as it contains a lambda
-    'g_withPath_V_asXaX_out_out_mapXa_name_it_nameX': [],  # skipping as it contains a lambda
+    'g_VX1X_mapXvaluesXnameXX': [(lambda g, vid1=None:g.V(vid1).map(__.values('name')))], 
+    'g_VX1X_outE_label_mapXlengthX': [(lambda g, vid1=None:g.V(vid1).out_e().label().map(__.length()))], 
+    'g_VX1X_out_mapXvaluesXnameXX_mapXlengthX': [(lambda g, vid1=None:g.V(vid1).out().map(__.values('name')).map(__.length()))], 
+    'g_withPath_V_asXaX_out_mapXselectXaX_valuesXnameXX': [(lambda g:g.with_path().V().as_('a').out().map(__.select('a').values('name')))], 
+    'g_withPath_V_asXaX_out_out_asXbX_mapXselectXaX_valuesXnameX_concatXselectXbX_valuesXnameXXX': [(lambda g:g.with_path().V().as_('a').out().out().as_('b').map(__.select('a').values('name').concat(__.select('b').values('name'))))], 
     'g_V_mapXselectXaXX': [(lambda g:g.V().as_('a').map(__.select('a')))], 
     'g_V_mapXconstantXnullXX': [(lambda g:g.V().map(__.constant(None)))], 
     'g_V_valueMap_matchXa_selectXnameX_bX': [(lambda g:g.V().value_map().match(__.as_('a').select('name').as_('b')))], 
@@ -1065,7 +1061,6 @@ world.gremlins = {
     'g_V_asXaX_outXcreatedX_asXbX_order_byXshuffleX_selectXa_bX': [(lambda g:g.V().as_('a').out('created').as_('b').order().by(Order.shuffle).select('a', 'b'))], 
     'g_V_both_hasLabelXpersonX_order_byXage_descX_limitX5X_name': [(lambda g:g.V().both().has_label('person').order().by('age', Order.desc).limit(5).values('name'))], 
     'g_V_properties_order_byXkey_descX_key': [(lambda g:g.V().properties().order().by(T.key, Order.desc).key())], 
-    'g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name': [],  # skipping as it contains a lambda
     'g_V_hasLabelXpersonX_group_byXnameX_byXoutE_weight_sumX_orderXlocalX_byXvaluesX': [(lambda g:g.V().has_label('person').group().by('name').by(__.out_e().values('weight').sum_()).order(Scope.local).by(Column.values))], 
     'g_V_mapXbothE_weight_foldX_order_byXsumXlocalX_descX_byXcountXlocalX_descX': [(lambda g:g.V().map(__.both_e().values('weight').order().by(Order.asc).fold()).order().by(__.sum_(Scope.local), Order.desc).by(__.count(Scope.local), Order.desc))], 
     'g_V_group_byXlabelX_byXname_order_byXdescX_foldX': [(lambda g:g.V().group().by(T.label).by(__.values('name').order().by(Order.desc).fold()))], 
@@ -1080,7 +1075,6 @@ world.gremlins = {
     'g_V_fold_orderXlocalX_byXage_descX': [(lambda g:g.V().fold().order(Scope.local).by('age', Order.desc))], 
     'g_V_orXhasLabelXpersonX_hasXsoftware_name_lopXX_order_byXageX': [(lambda g:g.V().or_(__.has_label('person'), __.has('software', 'name', 'lop')).order().by('age'))], 
     'g_withStrategiesXProductiveByStrategyX_V_orXhasLabelXpersonX_hasXsoftware_name_lopXX_order_byXageX': [(lambda g:g.with_strategies(ProductiveByStrategy()).V().or_(__.has_label('person'), __.has('software', 'name', 'lop')).order().by('age'))], 
-    'g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX': [],  # skipping as it contains a lambda
     'g_V_hasXsong_name_OHBOYX_outXfollowedByX_outXfollowedByX_order_byXperformancesX_byXsongType_descX': [(lambda g:g.V().has('song', 'name', 'OH BOY').out('followedBy').out('followedBy').order().by('performances').by('songType', Order.desc).by('name'))], 
     'g_V_hasLabelXsongX_order_byXperformances_descX_byXnameX_rangeX110_120X_name': [(lambda g:g.V().has_label('song').order().by('performances', Order.desc).by('name').range_(110, 120).values('name'))], 
     'g_VX1X_elementMap_orderXlocalX_byXkeys_descXunfold': [(lambda g, vid1=None:g.V(vid1).element_map().order(Scope.local).by(Column.keys, Order.desc).unfold())], 
@@ -1318,7 +1312,7 @@ world.gremlins = {
     'g_V_valuesXnameX_trim': [(lambda g:g.add_v('person').property('name', ' marko ').property('age', 29).as_('marko').add_v('person').property('name', '  vadas  ').property('age', 27).as_('vadas').add_v('software').property('name', '  lop').property('lang', 'java').as_('lop').add_v('person').property('name', 'josh  ').property('age', 32).as_('josh').add_v('software').property('name', '   ripple   ').property('lang', 'java').as_('ripple').add_v('person').property('name', 'peter').propert [...]
     'g_V_valuesXnameX_order_fold_trimXlocalX': [(lambda g:g.add_v('person').property('name', ' marko ').property('age', 29).as_('marko').add_v('person').property('name', '  vadas  ').property('age', 27).as_('vadas').add_v('software').property('name', '  lop').property('lang', 'java').as_('lop').add_v('person').property('name', 'josh  ').property('age', 32).as_('josh').add_v('software').property('name', '   ripple   ').property('lang', 'java').as_('ripple').add_v('person').property('name' [...]
     'g_V_localXoutE_foldX_unfold': [(lambda g:g.V().local(__.out_e().fold()).unfold())], 
-    'g_V_valueMap_unfold_mapXkeyX': [],  # skipping as it contains a lambda
+    'g_V_valueMap_unfold_mapXselectXkeysXX': [(lambda g:g.V().value_map().unfold().map(__.select(Column.keys)))], 
     'g_VX1X_repeatXboth_simplePathX_untilXhasIdX6XX_path_byXnameX_unfold': [(lambda g, vid6=None,vid1=None:g.V(vid1).repeat(__.both().simple_path()).until(__.has_id(vid6)).path().by('name').unfold())], 
     'g_V_valueMap': [(lambda g:g.V().value_map())], 
     'g_V_valueMapXtrueX': [(lambda g:g.V().value_map(True))], 
@@ -1550,7 +1544,7 @@ world.gremlins = {
     'g_V_hasXlangX_group_byXlangX_byXcountX': [(lambda g:g.V().has('lang').group().by('lang').by(__.count()))], 
     'g_V_group_byXoutE_countX_byXnameX': [(lambda g:g.V().order().by('name').group().by(__.out_e().count()).by('name'))], 
     'g_V_repeatXbothXfollowedByXX_timesX2X_group_byXsongTypeX_byXcountX': [(lambda g:g.V().repeat(__.both('followedBy')).times(2).group().by('songType').by(__.count()))], 
-    'g_V_group_byXname_substring_1X_byXconstantX1XX': [],  # skipping as it contains a lambda
+    'g_V_group_byXvaluesXnameX_substringX1XX_byXconstantX1XX': [(lambda g:g.V().group().by(__.values('name').substring(0, 1)).by(__.constant(1)))], 
     'g_V_out_group_byXlabelX_selectXpersonX_unfold_outXcreatedX_name_limitX2X': [(lambda g:g.V().out().group().by(T.label).select('person').unfold().out('created').values('name').limit(2))], 
     'g_V_hasLabelXsongX_group_byXnameX_byXproperties_groupCount_byXlabelXX': [(lambda g:g.V().has_label('song').group().by('name').by(__.properties().group_count().by(T.label)))], 
     'g_V_outXfollowedByX_group_byXsongTypeX_byXbothE_group_byXlabelX_byXweight_sumXX': [(lambda g:g.V().out('followedBy').group().by('songType').by(__.both_e().group().by(T.label).by(__.values('weight').sum_())))], 
@@ -1586,7 +1580,7 @@ world.gremlins = {
     'g_V_outXcreatedX_groupCount_byXnameX_byXageX': [(lambda g:g.V().out('created').group_count().by('name').by('age'))], 
     'g_V_outXcreatedX_groupCountXxX_byXnameX_byXageX': [(lambda g:g.V().out('created').group_count('x').by('name').by('age'))], 
     'g_VX1X_out_injectXv2X_name': [(lambda g, vid1=None,v2=None:g.V(vid1).out().inject(v2).values('name'))], 
-    'g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path': [],  # skipping as it contains a lambda
+    'g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path': [(lambda g, vid1=None:g.V(vid1).out().values('name').inject('daniel').as_('a').map(__.length()).path())], 
     'g_VX1X_injectXg_VX4XX_out_name': [(lambda g, vid1=None,v2=None:g.V(vid1).inject(v2).out().values('name'))], 
     'g_injectXnull_1_3_nullX': [(lambda g:g.inject(None, 1, 3, None))], 
     'g_injectX10_20_null_20_10_10X_groupCountXxX_dedup_asXyX_projectXa_bX_by_byXselectXxX_selectXselectXyXXX': [(lambda g:g.inject(10, 20, None, 20, 10, 10).group_count('x').dedup().as_('y').project('a', 'b').by().by(__.select('x').select(__.select('y'))))], 
@@ -1617,6 +1611,11 @@ world.gremlins = {
     'g_V_sackXassignX_byXageX_sack': [(lambda g:g.V().sack(Operator.assign).by('age').sack())], 
     'g_withSackXBigInteger_TEN_powX1000X_assignX_V_localXoutXknowsX_barrierXnormSackXX_inXknowsX_barrier_sack': [(lambda g, xx1=None:g.with_sack(xx1, Operator.assign).V().local(__.out('knows').barrier(Barrier.norm_sack)).in_('knows').barrier().sack())], 
     'g_withSackX2X_V_sackXdivX_byXconstantX4_0XX_sack': [(lambda g, xx1=None:g.with_sack(2).V().sack(Operator.div).by(__.constant(xx1)).sack())], 
+    'g_V_sideEffectXidentityX': [(lambda g:g.V().side_effect(__.identity()))], 
+    'g_V_sideEffectXidentity_valuesXnameXX': [(lambda g:g.V().side_effect(__.identity().values('name')))], 
+    'g_V_sideEffectXpropertyXage_22X': [(lambda g:g.add_v('person').property('age', 21)), (lambda g:g.V().side_effect(__.property('age', 22))), (lambda g:g.V().has('age', 21)), (lambda g:g.V().has('age', 22))], 
+    'g_V_group_byXvaluesXnameX_sideEffectXconstantXzyxXX_substringX1XX_byXconstantX1X_sideEffectXconstantXxyzXXX': [(lambda g:g.V().group().by(__.values('name').side_effect(__.constant('zyx')).substring(0, 1)).by(__.constant(1).side_effect(__.constant('xyz'))))], 
+    'g_withSideEffectXx_setX_V_both_both_sideEffectXstoreXxX_byXnameXX_capXxX_unfold': [(lambda g:g.with_side_effect('x', {}).V().both().both().side_effect(__.store('x').by('name')).cap('x').unfold())], 
     'g_V_hasXageX_groupCountXaX_byXnameX_out_capXaX': [(lambda g:g.V().has('age').group_count('a').by('name').out().cap('a'))], 
     'g_V_groupXaX_byXageX_capXaX': [(lambda g:g.V().group('a').by('age').cap('a'))], 
     'g_V_groupXaX_byXnameX_capXaX': [(lambda g:g.V().group('a').by('name').cap('a'))], 
@@ -1624,11 +1623,12 @@ world.gremlins = {
     'g_V_repeatXout_groupXaX_byXnameX_byXcountX_timesX2X_capXaX': [(lambda g:g.V().repeat(__.out().group('a').by('name').by(__.count())).times(2).cap('a'))], 
     'g_V_groupXaX_byXlabelX_byXoutE_weight_sumX_capXaX': [(lambda g:g.V().group('a').by(T.label).by(__.out_e().values('weight').sum_()).cap('a'))], 
     'g_V_repeatXbothXfollowedByXX_timesX2X_groupXaX_byXsongTypeX_byXcountX_capXaX': [(lambda g:g.V().repeat(__.both('followedBy')).times(2).group('a').by('songType').by(__.count()).cap('a'))], 
-    'g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX': [],  # skipping as it contains a lambda
+    'g_V_groupXaX_byXvaluesXnameX_substringX1XX_byXconstantX1XX_capXaX': [(lambda g:g.V().group('a').by(__.values('name').substring(0, 1)).by(__.constant(1)).cap('a'))], 
     'g_V_hasLabelXsongX_groupXaX_byXnameX_byXproperties_groupCount_byXlabelXX_out_capXaX': [(lambda g:g.V().has_label('song').group('a').by('name').by(__.properties().group_count().by(T.label)).out().cap('a'))], 
     'g_V_hasLabelXpersonX_asXpX_outXcreatedX_groupXaX_byXnameX_byXselectXpX_valuesXageX_sumX_capXaX': [(lambda g:g.V().has_label('person').as_('p').out('created').group('a').by('name').by(__.select('p').values('age').sum_()).cap('a'))], 
     'g_V_groupXmX_byXnameX_byXinXknowsX_nameX_capXmX': [(lambda g:g.V().group('m').by('name').by(__.in_('knows').values('name')).cap('m'))], 
     'g_V_groupXmX_byXlabelX_byXlabel_countX_capXmX': [(lambda g:g.V().group('m').by(__.label()).by(__.label().count()).cap('m'))], 
+    'g_V_chooseXlabel_person__age_groupCountXaX__name_groupCountXbXX_capXa_bX_unfold': [(lambda g:g.V().choose(__.has(T.label, 'person'), __.values('age').group_count('a'), __.values('name').group_count('b')).cap('a', 'b').unfold())], 
     'g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_orderX_capXaX': [(lambda g:g.V().has('person', 'name', P.within('vadas', 'peter')).group('a').by().by(__.out().order()).cap('a'))], 
     'g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_order_countX_capXaX': [(lambda g:g.V().has('person', 'name', P.within('vadas', 'peter')).group('a').by().by(__.out().order().count()).cap('a'))], 
     'g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_order_fold_countXlocalXX_capXaX': [(lambda g:g.V().has('person', 'name', P.within('vadas', 'peter')).group('a').by().by(__.out().order().fold().count(Scope.local)).cap('a'))], 
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/AbstractRemoteGraphProvider.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/AbstractRemoteGraphProvider.java
index 49c9134117..0f97f1338d 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/AbstractRemoteGraphProvider.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/AbstractRemoteGraphProvider.java
@@ -55,93 +55,13 @@ import static org.apache.tinkerpop.gremlin.process.remote.RemoteConnection.GREML
         method = "*",
         reason = "Tests for profile() are not supported for remotes")
 @Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.BranchTest",
-        method = "g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.ChooseTest",
-        method = "g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name",
+        test = "org.apache.tinkerpop.gremlin.process.traversal.step.LambdaStepTest",
+        method = "*",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.DedupTest",
         method = "g_V_both_name_order_byXa_bX_dedup_value",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_E_filterXfalseX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_E_filterXtrueX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXfalseX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXlang_eq_javaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXname_startsWith_m_OR_name_startsWith_pX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXtrueX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX1X_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX1X_out_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX2X_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest",
-        method = "g_V_group_byXname_substring_1X_byXconstantX1XX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest",
-        method = "g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasTest",
-        method = "g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectTest",
-        method = "g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_mapXnameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_out_mapXnameX_mapXlengthX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_outE_label_mapXlengthX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_withPath_V_asXaX_out_mapXa_nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_withPath_V_asXaX_out_out_mapXa_name_it_nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
-        method = "g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
         method = "g_V_name_order_byXa1_b1X_byXb2_a2X",
@@ -150,46 +70,10 @@ import static org.apache.tinkerpop.gremlin.process.remote.RemoteConnection.GREML
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
         method = "g_V_order_byXname_a1_b1X_byXname_b2_a2X_name",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
-        method = "g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.RepeatTest",
-        method = "g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SackTest",
         method = "g_withSackXmap__map_cloneX_V_out_out_sackXmap_a_nameX_sack",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_out_sideEffectXincr_cX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_out_sideEffectXX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_sideEffectXstore_aX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest",
         method = "g_V_withSideEffectXsgX_outEXknowsX_subgraphXsgX_name_capXsgX",
@@ -202,10 +86,6 @@ import static org.apache.tinkerpop.gremlin.process.remote.RemoteConnection.GREML
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest",
         method = "g_withSideEffectXsgX_V_hasXname_danielXout_capXsgX",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.UnfoldTest",
-        method = "g_V_valueMap_unfold_mapXkeyX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.OrderabilityTest",
         method = "g_inject_order_with_unknown_type",
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
index f14a1a5235..cefdc619dc 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
@@ -121,6 +121,12 @@ public final class StepDefinition {
             final String listItems = Stream.of(items).map(String::trim).map(x -> convertToString(x)).collect(Collectors.joining(","));
             return String.format("[%s]", listItems);
         }));
+        add(Pair.with(Pattern.compile("s\\[\\]"), s -> String.format("{}")));
+        add(Pair.with(Pattern.compile("s\\[(.*)\\]"), s -> {
+            final String[] items = s.split(",");
+            final String listItems = Stream.of(items).map(String::trim).map(x -> convertToString(x)).collect(Collectors.joining(","));
+            return String.format("{%s}", listItems);
+        }));
         add(Pair.with(Pattern.compile("d\\[(NaN)\\]"), s -> "NaN"));
         add(Pair.with(Pattern.compile("d\\[(Infinity)\\]"), s -> "Infinity"));
         add(Pair.with(Pattern.compile("d\\[(-Infinity)\\]"), s -> "-Infinity"));
@@ -147,28 +153,18 @@ public final class StepDefinition {
         add(Pair.with(Pattern.compile("t\\[(.*)\\]"), s -> String.format("T.%s", s)));
         add(Pair.with(Pattern.compile("D\\[(.*)\\]"), s -> String.format("Direction.%s", s)));
         add(Pair.with(Pattern.compile("M\\[(.*)\\]"), s -> String.format("Merge.%s", s)));
+        add(Pair.with(Pattern.compile("(null)"), s -> "null"));
+        add(Pair.with(Pattern.compile("(true)"), s -> "true"));
+        add(Pair.with(Pattern.compile("(false)"), s -> "false"));
 
         // the following force ignore conditions as they cannot be parsed by the grammar at this time. the grammar will
-        // need to be modified to handle them or perhaps these tests stay relegated to the JVM in some way for certain
-        // cases like the lambda item which likely won't make it to the grammar as it's raw groovy.
-        add(Pair.with(Pattern.compile("c\\[(.*)\\]"), s -> {
-            throw new AssumptionViolatedException("This test uses a lambda as a parameter which is not supported by gremlin-language");
-        }));
+        // need to be modified to handle them or perhaps these tests stay relegated to the JVM in some way
         add(Pair.with(Pattern.compile("e\\[(.+)\\]"), s -> {
             throw new AssumptionViolatedException("This test uses a Edge as a parameter which is not supported by gremlin-language");
         }));
         add(Pair.with(Pattern.compile("p\\[(.*)\\]"), s -> {
             throw new AssumptionViolatedException("This test uses a Path as a parameter which is not supported by gremlin-language");
         }));
-        add(Pair.with(Pattern.compile("s\\[\\]"), s -> {
-            throw new AssumptionViolatedException("This test uses a empty Set as a parameter which is not supported by gremlin-language");
-        }));
-        add(Pair.with(Pattern.compile("s\\[(.*)\\]"), s -> {
-            throw new AssumptionViolatedException("This test uses a Set as a parameter which is not supported by gremlin-language");
-        }));
-        add(Pair.with(Pattern.compile("(null)"), s -> "null"));
-        add(Pair.with(Pattern.compile("(true)"), s -> "true"));
-        add(Pair.with(Pattern.compile("(false)"), s -> "false"));
     }};
 
     private List<Pair<Pattern, Function<String,Object>>> objectMatcherConverters = new ArrayList<Pair<Pattern, Function<String,Object>>>() {{
@@ -238,10 +234,6 @@ public final class StepDefinition {
         add(Pair.with(Pattern.compile("D\\[(.*)\\]"), Direction::valueOf));
         add(Pair.with(Pattern.compile("M\\[(.*)\\]"), Merge::valueOf));
 
-        add(Pair.with(Pattern.compile("c\\[(.*)\\]"), s -> {
-            throw new AssumptionViolatedException("This test uses a lambda as a parameter which is not supported by gremlin-language");
-        }));
-
         add(Pair.with(Pattern.compile("(null)"), s -> null));
         add(Pair.with(Pattern.compile("(true)"), s -> true));
         add(Pair.with(Pattern.compile("(false)"), s -> false));
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java
index 8785e9005b..da76275f33 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java
@@ -27,6 +27,7 @@ import org.apache.tinkerpop.gremlin.process.computer.search.path.ShortestPathVer
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalInterruptionComputerTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.ComplexTest;
+import org.apache.tinkerpop.gremlin.process.traversal.step.LambdaStepTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.branch.BranchTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.branch.ChooseTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.branch.LocalTest;
@@ -121,6 +122,8 @@ public class ProcessComputerSuite extends AbstractGremlinSuite {
             // computer, vertex program, and map/reduce semantics
             GraphComputerTest.class,
 
+            LambdaStepTest.Traversals.class,
+
             // branch
             BranchTest.Traversals.class,
             ChooseTest.Traversals.class,
@@ -219,6 +222,8 @@ public class ProcessComputerSuite extends AbstractGremlinSuite {
      * A list of the minimum set of base tests that Gremlin flavors should implement to be compliant with Gremlin.
      */
     private static final Class<?>[] testsToEnforce = new Class<?>[]{
+            LambdaStepTest.class,
+
             // branch
             BranchTest.class,
             ChooseTest.class,
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
index 635b781bee..cd507f5099 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
@@ -26,6 +26,7 @@ import org.apache.tinkerpop.gremlin.process.computer.search.path.ShortestPathVer
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalInterruptionComputerTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.ComplexTest;
+import org.apache.tinkerpop.gremlin.process.traversal.step.LambdaStepTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProfileTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProgramTest;
@@ -61,9 +62,9 @@ public class ProcessEmbeddedComputerSuite extends AbstractGremlinSuite {
             ProgramTest.Traversals.class,
             WriteTest.Traversals.class,
             ExplainTest.Traversals.class,
-            SideEffectTest.Traversals.class,
             SubgraphTest.Traversals.class,
             TreeTest.Traversals.class,
+            LambdaStepTest.Traversals.class,
 
             // compliance
             ComplexTest.Traversals.class,
@@ -89,7 +90,6 @@ public class ProcessEmbeddedComputerSuite extends AbstractGremlinSuite {
             MatchTest.class,
             ProfileTest.class,
             ProgramTest.class,
-            SideEffectTest.class,
             SubgraphTest.class,
             TreeTest.class
     };
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
index 4e8c8b41d9..c14139401d 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
@@ -23,6 +23,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.CoreTraversalTest;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalInterruptionTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.ComplexTest;
+import org.apache.tinkerpop.gremlin.process.traversal.step.LambdaStepTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.TernaryBooleanLogicsTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProfileTest;
@@ -55,12 +56,12 @@ public class ProcessEmbeddedStandardSuite extends AbstractGremlinSuite {
      */
     private static final Class<?>[] allTests = new Class<?>[]{
 
+            LambdaStepTest.Traversals.class,
             MatchTest.CountMatchTraversals.class,
             MatchTest.GreedyMatchTraversals.class,
             ProfileTest.Traversals.class,
             WriteTest.Traversals.class,
             ExplainTest.Traversals.class,
-            SideEffectTest.Traversals.class,
             SubgraphTest.Traversals.class,
             TreeTest.Traversals.class,
 
@@ -75,7 +76,6 @@ public class ProcessEmbeddedStandardSuite extends AbstractGremlinSuite {
             // decorations
             ElementIdStrategyProcessTest.class,
             EventStrategyProcessTest.class,
-            PartitionStrategyProcessTest.class,
 
             // optimizations
             IncidentToAdjacentStrategyProcessTest.class,
@@ -90,7 +90,6 @@ public class ProcessEmbeddedStandardSuite extends AbstractGremlinSuite {
      */
     private static final Class<?>[] testsToEnforce = new Class<?>[]{
             ProfileTest.class,
-            SideEffectTest.class,
             SubgraphTest.class,
             TreeTest.class,
     };
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessStandardSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessStandardSuite.java
index 9ab1248709..127a2acc92 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessStandardSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessStandardSuite.java
@@ -23,6 +23,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.CoreTraversalTest;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalInterruptionTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.ComplexTest;
+import org.apache.tinkerpop.gremlin.process.traversal.step.LambdaStepTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.OrderabilityTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.TernaryBooleanLogicsTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.branch.BranchTest;
@@ -116,6 +117,9 @@ public class ProcessStandardSuite extends AbstractGremlinSuite {
      * This list of tests in the suite that will be executed as part of this suite.
      */
     private static final Class<?>[] allTests = new Class<?>[]{
+
+            LambdaStepTest.Traversals.class,
+
             // branch
             BranchTest.Traversals.class,
             ChooseTest.Traversals.class,
@@ -216,6 +220,8 @@ public class ProcessStandardSuite extends AbstractGremlinSuite {
      * A list of the minimum set of base tests that Gremlin flavors should implement to be compliant with Gremlin.
      */
     private static final Class<?>[] testsToEnforce = new Class<?>[]{
+            LambdaStepTest.class,
+
             // branch
             BranchTest.class,
             ChooseTest.class,
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/LambdaStepTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/LambdaStepTest.java
new file mode 100644
index 0000000000..0bd0bd9687
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/LambdaStepTest.java
@@ -0,0 +1,846 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.GremlinProcessRunner;
+import org.apache.tinkerpop.gremlin.process.IgnoreEngine;
+import org.apache.tinkerpop.gremlin.process.traversal.Operator;
+import org.apache.tinkerpop.gremlin.process.traversal.Order;
+import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
+import org.apache.tinkerpop.gremlin.process.traversal.Scope;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalSideEffects;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.structure.Column;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.T;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.util.function.ArrayListSupplier;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.apache.tinkerpop.gremlin.process.traversal.Order.desc;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.both;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.constant;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.in;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.out;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.select;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.valueMap;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.values;
+import static org.apache.tinkerpop.gremlin.structure.Column.keys;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Tests that cover lambda steps that are used in embedded cases.
+ */
+@RunWith(GremlinProcessRunner.class)
+public abstract class LambdaStepTest extends AbstractGremlinProcessTest {
+
+    /// branch
+
+    public abstract Traversal<Vertex, Object> get_g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX();
+
+    /// choose
+
+    public abstract Traversal<Vertex, String> get_g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name();
+
+    /// filter
+
+    public abstract Traversal<Vertex, Vertex> get_g_V_filterXfalseX();
+
+    public abstract Traversal<Vertex, Vertex> get_g_V_filterXtrueX();
+
+    public abstract Traversal<Vertex, Vertex> get_g_V_filterXlang_eq_javaX();
+
+    public abstract Traversal<Vertex, Vertex> get_g_VX1X_filterXage_gt_30X(final Object v1Id);
+
+    public abstract Traversal<Vertex, Vertex> get_g_VX1X_out_filterXage_gt_30X(final Object v1Id);
+
+    public abstract Traversal<Vertex, Vertex> get_g_V_filterXname_startsWith_m_OR_name_startsWith_pX();
+
+    public abstract Traversal<Edge, Edge> get_g_E_filterXfalseX();
+
+    public abstract Traversal<Edge, Edge> get_g_E_filterXtrueX();
+
+    /// flatMap
+
+    public abstract Traversal<Vertex, String> get_g_V_valuesXnameX_flatMapXsplitXaX();
+
+    ///  group
+
+    public abstract Traversal<Vertex, Map<String, Long>> get_g_V_group_byXname_substring_1X_byXconstantX1XX();
+
+    public abstract Traversal<Vertex, Map<String, Long>> get_g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX();
+
+    ///  has
+
+    public abstract Traversal<Vertex, String> get_g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name();
+
+    /// inject
+
+    public abstract Traversal<Vertex, Path> get_g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path(final Object v1Id);
+
+    /// map
+
+    public abstract Traversal<Vertex, String> get_g_VX1X_mapXnameX(final Object v1Id);
+
+    public abstract Traversal<Vertex, Integer> get_g_VX1X_outE_label_mapXlengthX(final Object v1Id);
+
+    public abstract Traversal<Vertex, Integer> get_g_VX1X_out_mapXnameX_mapXlengthX(final Object v1Id);
+
+    public abstract Traversal<Vertex, String> get_g_withPath_V_asXaX_out_mapXa_nameX();
+
+    public abstract Traversal<Vertex, String> get_g_withPath_V_asXaX_out_out_mapXa_name_it_nameX();
+
+    /// order
+
+    public abstract Traversal<Vertex, String> get_g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name();
+
+    public abstract Traversal<Vertex, Map<Integer, Integer>> get_g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX(final Object v1Id);
+
+    /// repeat
+
+    public abstract Traversal<Vertex, Map<String, Long>> get_g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX();
+
+    // sideEffect
+
+    public abstract Traversal<Vertex, String> get_g_VX1X_sideEffectXstore_aX_name(final Object v1Id);
+
+    public abstract Traversal<Vertex, String> get_g_VX1X_out_sideEffectXincr_cX_name(final Object v1Id);
+
+    public abstract Traversal<Vertex, String> get_g_VX1X_out_sideEffectXX_name(final Object v1Id);
+
+    public abstract Traversal<Vertex, Map<String, Long>> get_g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX();
+
+    public abstract Traversal<Vertex, Map<String, Long>> get_g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX();
+
+    public abstract Traversal<Vertex, Integer> get_g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX();
+
+    public abstract Traversal<Vertex, Integer> get_g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX();
+
+    public abstract Traversal<Vertex, String> get_g_withSideEffectXk_nameX_V_order_byXvalueMap_selectXkX_unfoldX_name();
+
+    ///  unfold
+
+    public abstract Traversal<Vertex, String> get_g_V_valueMap_unfold_mapXkeyX();
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX() {
+        final Traversal<Vertex, Object> traversal = get_g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX();
+        printTraversalForm(traversal);
+        checkResults(Arrays.asList("java", "java", "lop", "ripple", 29, 27, 32, 35), traversal);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name() {
+        final Traversal<Vertex, String> traversal = get_g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name();
+        printTraversalForm(traversal);
+        checkResults(Arrays.asList("josh", "vadas", "josh", "josh", "marko", "peter"), traversal);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX() {
+        final Traversal<Vertex, Map<String, Long>> traversal = get_g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX();
+        printTraversalForm(traversal);
+        final Map<String, Long> map = traversal.next();
+        assertFalse(traversal.hasNext());
+        assertEquals(5, map.size());
+        assertEquals(3L, map.get("ripple").longValue());
+        assertEquals(3L, map.get("vadas").longValue());
+        assertEquals(4L, map.get("josh").longValue());
+        assertEquals(10L, map.get("lop").longValue());
+        assertEquals(4L, map.get("marko").longValue());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_filterXfalseX() {
+        final Traversal<Vertex, Vertex> traversal = get_g_V_filterXfalseX();
+        printTraversalForm(traversal);
+        assertFalse(traversal.hasNext());
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_filterXtrueX() {
+        final Traversal<Vertex, Vertex> traversal = get_g_V_filterXtrueX();
+        printTraversalForm(traversal);
+        int counter = 0;
+        final Set<Vertex> vertices = new HashSet<>();
+        while (traversal.hasNext()) {
+            counter++;
+            vertices.add(traversal.next());
+        }
+        assertEquals(6, counter);
+        assertEquals(6, vertices.size());
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_filterXlang_eq_javaX() {
+        final Traversal<Vertex, Vertex> traversal = get_g_V_filterXlang_eq_javaX();
+        printTraversalForm(traversal);
+        int counter = 0;
+        final Set<Vertex> vertices = new HashSet<>();
+        while (traversal.hasNext()) {
+            counter++;
+            final Vertex vertex = traversal.next();
+            vertices.add(vertex);
+            assertTrue(vertex.value("name").equals("ripple") ||
+                    vertex.value("name").equals("lop"));
+        }
+        assertEquals(2, counter);
+        assertEquals(2, vertices.size());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_VX1X_filterXage_gt_30X() {
+        final Traversal<Vertex, Vertex> traversal = get_g_VX1X_filterXage_gt_30X(convertToVertexId("marko"));
+        printTraversalForm(traversal);
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_VX2X_filterXage_gt_30X() {
+        final  Traversal<Vertex, Vertex> traversal = get_g_VX1X_filterXage_gt_30X(convertToVertexId("josh"));
+        printTraversalForm(traversal);
+        assertTrue(traversal.hasNext());
+        assertEquals(Integer.valueOf(32), traversal.next().<Integer>value("age"));
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_VX1X_out_filterXage_gt_30X() {
+        final Traversal<Vertex, Vertex> traversal = get_g_VX1X_out_filterXage_gt_30X(convertToVertexId("marko"));
+        printTraversalForm(traversal);
+        assertEquals(Integer.valueOf(32), traversal.next().<Integer>value("age"));
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_filterXname_startsWith_m_OR_name_startsWith_pX() {
+        final Traversal<Vertex, Vertex> traversal = get_g_V_filterXname_startsWith_m_OR_name_startsWith_pX();
+        printTraversalForm(traversal);
+        int counter = 0;
+        final Set<Vertex> vertices = new HashSet<>();
+        while (traversal.hasNext()) {
+            counter++;
+            final Vertex vertex = traversal.next();
+            vertices.add(vertex);
+            assertTrue(vertex.value("name").equals("marko") ||
+                    vertex.value("name").equals("peter"));
+        }
+        assertEquals(counter, 2);
+        assertEquals(vertices.size(), 2);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_E_filterXfalseX() {
+        final Traversal<Edge, Edge> traversal = get_g_E_filterXfalseX();
+        printTraversalForm(traversal);
+        assertFalse(traversal.hasNext());
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_E_filterXtrueX() {
+        final Traversal<Edge, Edge> traversal = get_g_E_filterXtrueX();
+        printTraversalForm(traversal);
+        int counter = 0;
+        final Set<Edge> edges = new HashSet<>();
+        while (traversal.hasNext()) {
+            counter++;
+            edges.add(traversal.next());
+        }
+        assertEquals(6, counter);
+        assertEquals(6, edges.size());
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name() {
+        final Traversal<Vertex, String> traversal = get_g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name();
+        printTraversalForm(traversal);
+        checkResults(Arrays.asList("ripple"), traversal);
+    }
+
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_VX1X_mapXnameX() {
+        final Traversal<Vertex, String> traversal = get_g_VX1X_mapXnameX(convertToVertexId("marko"));
+        printTraversalForm(traversal);
+        assertEquals(traversal.next(), "marko");
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_VX1X_outE_label_mapXlengthX() {
+        final Traversal<Vertex, Integer> traversal = get_g_VX1X_outE_label_mapXlengthX(convertToVertexId("marko"));
+        printTraversalForm(traversal);
+        final List<Integer> lengths = traversal.toList();
+        assertTrue(lengths.contains("created".length()));
+        assertTrue(lengths.contains("knows".length()));
+        assertEquals(lengths.size(), 3);
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_VX1X_out_mapXnameX_mapXlengthX() {
+        final Traversal<Vertex, Integer> traversal = get_g_VX1X_out_mapXnameX_mapXlengthX(convertToVertexId("marko"));
+        printTraversalForm(traversal);
+        final List<Integer> lengths = traversal.toList();
+        assertTrue(lengths.contains("josh".length()));
+        assertTrue(lengths.contains("vadas".length()));
+        assertTrue(lengths.contains("lop".length()));
+        assertEquals(lengths.size(), 3);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+    public void g_withPath_V_asXaX_out_mapXa_nameX() {
+        int marko = 0;
+        int peter = 0;
+        int josh = 0;
+        int other = 0;
+
+        final Traversal<Vertex, String> traversal = get_g_withPath_V_asXaX_out_mapXa_nameX();
+        printTraversalForm(traversal);
+        while (traversal.hasNext()) {
+            final String name = traversal.next();
+            if (name.equals("marko")) marko++;
+            else if (name.equals("peter")) peter++;
+            else if (name.equals("josh")) josh++;
+            else other++;
+        }
+        assertEquals(marko, 3);
+        assertEquals(josh, 2);
+        assertEquals(peter, 1);
+        assertEquals(other, 0);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+    public void g_withPath_V_asXaX_out_out_mapXa_name_it_nameX() {
+        final Traversal<Vertex, String> traversal = get_g_withPath_V_asXaX_out_out_mapXa_name_it_nameX();
+        int counter = 0;
+        while (traversal.hasNext()) {
+            counter++;
+            final String doubleName = traversal.next();
+            assertTrue("markoripple".equals(doubleName) || "markolop".equals(doubleName));
+        }
+        assertEquals(2, counter);
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name() {
+        final Traversal<Vertex, String> traversal = get_g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name();
+        printTraversalForm(traversal);
+        checkOrderedResults(Arrays.asList("peter", "josh", "marko", "vadas"), traversal);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX() {
+        final Traversal<Vertex, Map<Integer, Integer>> traversal = get_g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX(convertToVertexId("marko"));
+        printTraversalForm(traversal);
+        final Map<Integer, Integer> map = traversal.next();
+        assertFalse(traversal.hasNext());
+        assertEquals(4, map.size());
+        final Iterator<Map.Entry<Integer, Integer>> iterator = map.entrySet().iterator();
+        Map.Entry<Integer, Integer> entry = iterator.next();
+        assertEquals(3, entry.getKey().intValue());
+        assertEquals(87, entry.getValue().intValue());
+        entry = iterator.next();
+        assertEquals(2, entry.getKey().intValue());
+        assertEquals(58, entry.getValue().intValue());
+        entry = iterator.next();
+        assertEquals(1, entry.getKey().intValue());
+        assertEquals(29, entry.getValue().intValue());
+        entry = iterator.next();
+        assertEquals(4, entry.getKey().intValue());
+        assertEquals(29, entry.getValue().intValue());
+        assertFalse(iterator.hasNext());
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_valueMap_unfold_mapXkeyX() {
+        final Traversal<Vertex, String> traversal = get_g_V_valueMap_unfold_mapXkeyX();
+        printTraversalForm(traversal);
+        int counter = 0;
+        int ageCounter = 0;
+        int nameCounter = 0;
+        int langCounter = 0;
+        while (traversal.hasNext()) {
+            counter++;
+            final String key = traversal.next();
+            if (key.equals("name"))
+                nameCounter++;
+            else if (key.equals("age"))
+                ageCounter++;
+            else if (key.equals("lang"))
+                langCounter++;
+            else
+                fail("The provided key is not known: " + key);
+        }
+        assertEquals(12, counter);
+        assertEquals(4, ageCounter);
+        assertEquals(2, langCounter);
+        assertEquals(6, nameCounter);
+        assertEquals(counter, ageCounter + langCounter + nameCounter);
+        assertFalse(traversal.hasNext());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_group_byXname_substring_1X_byXconstantX1XX() {
+        final Traversal<Vertex, Map<String, Long>> traversal = get_g_V_group_byXname_substring_1X_byXconstantX1XX();
+        printTraversalForm(traversal);
+        checkMap(new HashMap<String, Long>() {{
+            put("m", 1l);
+            put("v", 1l);
+            put("p", 1l);
+            put("l", 1l);
+            put("r", 1l);
+            put("j", 1l);
+        }}, traversal.next());
+        assertFalse(traversal.hasNext());
+        checkSideEffects(traversal.asAdmin().getSideEffects());
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX() {
+        final Traversal<Vertex, Map<String, Long>> traversal = get_g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX();
+        printTraversalForm(traversal);
+        checkMap(new HashMap<String, Long>() {{
+            put("m", 1l);
+            put("v", 1l);
+            put("p", 1l);
+            put("l", 1l);
+            put("r", 1l);
+            put("j", 1l);
+        }}, traversal.next());
+        assertFalse(traversal.hasNext());
+        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", HashMap.class);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path() {
+        final Traversal<Vertex, Path> traversal = get_g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path(convertToVertexId("marko"));
+        printTraversalForm(traversal);
+        int counter = 0;
+        while (traversal.hasNext()) {
+            counter++;
+            final Path path = traversal.next();
+            if (path.get("a").equals("daniel")) {
+                assertEquals(2, path.size());
+                assertEquals(6, (int) path.get(1));
+            } else {
+                assertEquals(4, path.size());
+                assertEquals(path.<String>get("a").length(), (int) path.get(3));
+            }
+        }
+        assertEquals(4, counter);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+    public void g_VX1X_sideEffectXstore_aX_name() {
+        final Traversal<Vertex, String> traversal = get_g_VX1X_sideEffectXstore_aX_name(convertToVertexId("marko"));
+        printTraversalForm(traversal);
+        assertEquals(traversal.next(), "marko");
+        assertFalse(traversal.hasNext());
+        assertEquals(convertToVertexId("marko"), traversal.asAdmin().getSideEffects().<List<Vertex>>get("a").get(0).id());
+        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", ArrayList.class);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+    public void g_VX1X_out_sideEffectXincr_cX_name() {
+        final Traversal<Vertex, String> traversal = get_g_VX1X_out_sideEffectXincr_cX_name(convertToVertexId("marko"));
+        printTraversalForm(traversal);
+        assert_g_v1_out_sideEffectXincr_cX_valueXnameX(traversal);
+        assertEquals(new Integer(3), traversal.asAdmin().getSideEffects().<List<Integer>>get("c").get(0));
+        checkSideEffects(traversal.asAdmin().getSideEffects(), "c", ArrayList.class);
+    }
+
+    private void assert_g_v1_out_sideEffectXincr_cX_valueXnameX(final Iterator<String> traversal) {
+        final List<String> names = new ArrayList<>();
+        while (traversal.hasNext()) {
+            names.add(traversal.next());
+        }
+        assertEquals(3, names.size());
+        assertTrue(names.contains("josh"));
+        assertTrue(names.contains("lop"));
+        assertTrue(names.contains("vadas"));
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_VX1X_out_sideEffectXX_name() {
+        final Traversal<Vertex, String> traversal = get_g_VX1X_out_sideEffectXX_name(convertToVertexId("marko"));
+        printTraversalForm(traversal);
+        assert_g_v1_out_sideEffectXincr_cX_valueXnameX(traversal);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX() {
+        final Traversal<Vertex, Map<String, Long>> traversal = get_g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX();
+        printTraversalForm(traversal);
+        Map<String, Long> map = traversal.next();
+        assertFalse(traversal.hasNext());
+        assertEquals(2, map.size());
+        assertEquals(4l, map.get("software").longValue());
+        assertEquals(2l, map.get("person").longValue());
+        final TraversalSideEffects sideEffects = traversal.asAdmin().getSideEffects();
+        map = sideEffects.get("a");
+        assertEquals(2, map.size());
+        assertEquals(4l, map.get("software").longValue());
+        assertEquals(2l, map.get("person").longValue());
+        ///
+        assertEquals(1, sideEffects.keys().size());
+        assertTrue(sideEffects.keys().contains("a"));
+        assertTrue(sideEffects.exists("a"));
+        assertTrue(sideEffects.get("a") instanceof LinkedHashMap);
+        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", LinkedHashMap.class);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX() {
+        final Traversal<Vertex, Map<String, Long>> traversal = get_g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX();
+        printTraversalForm(traversal);
+        Map<String, Long> map = traversal.next();
+        assertFalse(traversal.hasNext());
+        assertEquals(2, map.size());
+        assertEquals(2l, map.get("software").longValue());
+        assertEquals(4l, map.get("person").longValue());
+        final TraversalSideEffects sideEffects = traversal.asAdmin().getSideEffects();
+        map = sideEffects.get("a");
+        assertEquals(2, map.size());
+        assertEquals(2l, map.get("software").longValue());
+        assertEquals(4l, map.get("person").longValue());
+        ///
+        assertEquals(3, sideEffects.keys().size());
+        assertTrue(sideEffects.keys().contains("a"));
+        assertTrue(sideEffects.exists("a"));
+        assertTrue(sideEffects.get("a") instanceof LinkedHashMap);
+        //
+        assertTrue(sideEffects.keys().contains("b"));
+        assertTrue(sideEffects.exists("b"));
+        assertTrue(sideEffects.get("b") instanceof ArrayList);
+        assertEquals(18, sideEffects.<List<Integer>>get("b").size());
+        assertEquals(6l, sideEffects.<List<Integer>>get("b").stream().filter(t -> t == 1).count());
+        assertEquals(6l, sideEffects.<List<Integer>>get("b").stream().filter(t -> t == 2).count());
+        assertEquals(6l, sideEffects.<List<Integer>>get("b").stream().filter(t -> t == 3).count());
+        //
+        assertTrue(sideEffects.keys().contains("c"));
+        assertTrue(sideEffects.exists("c"));
+        assertTrue(sideEffects.get("c") instanceof ArrayList);
+        assertEquals(0, sideEffects.<List>get("c").size());
+        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", LinkedHashMap.class, "b", ArrayList.class, "c", ArrayList.class);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX() {
+        final Traversal<Vertex, Integer> traversal = get_g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX();
+        assertEquals(6, traversal.next().intValue());
+        assertFalse(traversal.hasNext());
+        assertEquals(6, traversal.asAdmin().getSideEffects().<Integer>get("a").intValue());
+        assertEquals(1, traversal.asAdmin().getSideEffects().keys().size());
+        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", Integer.class);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX() {
+        final Traversal<Vertex, Integer> traversal = get_g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX();
+        assertEquals(1, traversal.next().intValue());
+        assertFalse(traversal.hasNext());
+        assertEquals(1, traversal.asAdmin().getSideEffects().<Integer>get("a").intValue());
+        assertEquals(1, traversal.asAdmin().getSideEffects().keys().size());
+        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", Integer.class);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_withSideEffectXk_nameX_V_order_byXvalueMap_selectXkX_unfoldX_name() {
+        final Traversal<Vertex, String> traversal = get_g_withSideEffectXk_nameX_V_order_byXvalueMap_selectXkX_unfoldX_name();
+        checkOrderedResults(Arrays.asList(
+                "josh", "lop", "marko", "peter", "ripple", "vadas"), traversal);
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_valuesXnameX_flatMapXsplitXaX() {
+        final Traversal<Vertex, String> traversal = get_g_V_valuesXnameX_flatMapXsplitXaX();
+        checkResults(Arrays.asList(
+                "josh", "lop", "rko", "peter", "ripple", "v", "d", "s", "m"), traversal);
+    }
+
+    public static class Traversals extends LambdaStepTest {
+
+        @Override
+        public Traversal<Vertex, Object> get_g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX() {
+            return g.V().branch(v -> v.get().label().equals("person") ? "a" : "b")
+                    .option("a", values("age"))
+                    .option("b", values("lang"))
+                    .option("b", values("name"));
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name() {
+            return g.V().choose(v -> v.label().equals("person"), out("knows"), in("created")).values("name");
+        }
+
+        @Override
+        public Traversal<Vertex, Map<String, Long>> get_g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX() {
+            return g.V().repeat(both()).until(t -> t.get().value("name").equals("lop") || t.loops() > 1).<String>groupCount().by("name");
+        }
+
+        @Override
+        public Traversal<Vertex, Vertex> get_g_V_filterXfalseX() {
+            return g.V().filter(v -> false);
+        }
+
+        @Override
+        public Traversal<Vertex, Vertex> get_g_V_filterXtrueX() {
+            return g.V().filter(v -> true);
+        }
+
+        @Override
+        public Traversal<Vertex, Vertex> get_g_V_filterXlang_eq_javaX() {
+            return g.V().filter(v -> v.get().<String>property("lang").orElse("none").equals("java"));
+        }
+
+        @Override
+        public Traversal<Vertex, Vertex> get_g_VX1X_filterXage_gt_30X(final Object v1Id) {
+            return g.V(v1Id).filter(v -> v.get().<Integer>property("age").orElse(0) > 30);
+        }
+
+        @Override
+        public Traversal<Vertex, Vertex> get_g_VX1X_out_filterXage_gt_30X(final Object v1Id) {
+            return g.V(v1Id).out().filter(v -> v.get().<Integer>property("age").orElse(0) > 30);
+        }
+
+        @Override
+        public Traversal<Vertex, Vertex> get_g_V_filterXname_startsWith_m_OR_name_startsWith_pX() {
+            return g.V().filter(v -> {
+                final String name = v.get().value("name");
+                return name.startsWith("m") || name.startsWith("p");
+            });
+        }
+
+        @Override
+        public Traversal<Edge, Edge> get_g_E_filterXfalseX() {
+            return g.E().filter(e -> false);
+        }
+
+        @Override
+        public Traversal<Edge, Edge> get_g_E_filterXtrueX() {
+            return g.E().filter(e -> true);
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name() {
+            return g.V().out("created").has("name", __.<String, Integer>map(s -> s.get().length()).is(P.gt(3))).values("name");
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_VX1X_mapXnameX(final Object v1Id) {
+            return g.V(v1Id).<String>map(v -> v.get().value("name"));
+        }
+
+        @Override
+        public Traversal<Vertex, Integer> get_g_VX1X_outE_label_mapXlengthX(final Object v1Id) {
+            return g.V(v1Id).outE().label().map(l -> l.get().length());
+        }
+
+        @Override
+        public Traversal<Vertex, Integer> get_g_VX1X_out_mapXnameX_mapXlengthX(final Object v1Id) {
+            return g.V(v1Id).out().map(v -> v.get().value("name")).map(n -> n.get().toString().length());
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_withPath_V_asXaX_out_mapXa_nameX() {
+            return g.withPath().V().as("a").out().<String>map(v -> v.<Vertex>path("a").value("name"));
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_withPath_V_asXaX_out_out_mapXa_name_it_nameX() {
+            return g.withPath().V().as("a").out().out().map(v -> v.<Vertex>path("a").<String>value("name") + v.get().<String>value("name"));
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name() {
+            return g.V().hasLabel("person").order().<Vertex>by(v -> v.value("age"), desc).values("name");
+        }
+
+        @Override
+        public Traversal<Vertex, Map<Integer, Integer>> get_g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX(final Object v1Id) {
+            return g.V(v1Id).hasLabel("person").map(v -> {
+                final Map<Integer, Integer> map = new HashMap<>();
+                map.put(1, (int) v.get().value("age"));
+                map.put(2, (int) v.get().value("age") * 2);
+                map.put(3, (int) v.get().value("age") * 3);
+                map.put(4, (int) v.get().value("age"));
+                return map;
+            }).order(Scope.local).by(Column.values, desc).by(keys, Order.asc);
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_V_valueMap_unfold_mapXkeyX() {
+            return g.V().valueMap().<Map.Entry<String, List>>unfold().map(m -> m.get().getKey());
+        }
+
+        @Override
+        public Traversal<Vertex, Map<String, Long>> get_g_V_group_byXname_substring_1X_byXconstantX1XX() {
+            return g.V().<String, Long>group().<Vertex>by(v -> v.<String>value("name").substring(0, 1)).by(constant(1l));
+        }
+
+        @Override
+        public Traversal<Vertex, Map<String, Long>> get_g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX() {
+            return g.V().<String, Long>group("a").<Vertex>by(v -> v.<String>value("name").substring(0, 1)).by(constant(1l)).cap("a");
+        }
+
+        @Override
+        public Traversal<Vertex, Path> get_g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path(final Object v1Id) {
+            return g.V(v1Id).out().<String>values("name").inject("daniel").as("a").map(t -> t.get().length()).path();
+        }
+        @Override
+        public Traversal<Vertex, String> get_g_VX1X_sideEffectXstore_aX_name(final Object v1Id) {
+            return g.withSideEffect("a", ArrayList::new).V(v1Id).sideEffect(traverser -> {
+                traverser.<List>sideEffects("a").clear();
+                traverser.<List<Vertex>>sideEffects("a").add(traverser.get());
+            }).values("name");
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_VX1X_out_sideEffectXincr_cX_name(final Object v1Id) {
+            return g.withSideEffect("c", () -> {
+                final List<Integer> list = new ArrayList<>();
+                list.add(0);
+                return list;
+            }).V(v1Id).out().sideEffect(traverser -> {
+                Integer temp = traverser.<List<Integer>>sideEffects("c").get(0);
+                traverser.<List<Integer>>sideEffects("c").clear();
+                traverser.<List<Integer>>sideEffects("c").add(temp + 1);
+            }).values("name");
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_VX1X_out_sideEffectXX_name(final Object v1Id) {
+            return g.V(v1Id).out().sideEffect(traverser -> {
+            }).values("name");
+        }
+
+        @Override
+        public Traversal<Vertex, Map<String, Long>> get_g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX() {
+            return g.withSideEffect("a", new LinkedHashMapSupplier()).V().out().groupCount("a").by(T.label).out().out().cap("a");
+        }
+
+        @Override
+        public Traversal<Vertex, Map<String, Long>> get_g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX() {
+            return g.withSideEffect("a", new LinkedHashMapSupplier())
+                    .withSideEffect("b", ArrayListSupplier.instance(), Operator.addAll)
+                    .withSideEffect("c", ArrayListSupplier.instance(), Operator.addAll)
+                    .V().group("a").by(T.label).by(__.count())
+                    .sideEffect(t -> t.sideEffects("b", new LinkedList<>(Arrays.asList(1, 2, 3))))
+                    .out().out().out()
+                    .sideEffect(t -> t.sideEffects("c", new LinkedList<>(Arrays.asList("bob", "daniel"))))
+                    .cap("a");
+        }
+
+        @Override
+        public Traversal<Vertex, Integer> get_g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX() {
+            return g.withSideEffect("a", 0, Operator.sum).V().out().sideEffect(t -> t.sideEffects("a", (int) t.bulk())).cap("a");
+        }
+
+        @Override
+        public Traversal<Vertex, Integer> get_g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX() {
+            return g.withSideEffect("a", 0).V().out().sideEffect(t -> t.sideEffects("a", 1)).cap("a");
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_withSideEffectXk_nameX_V_order_byXvalueMap_selectXkX_unfoldX_name() {
+            return g.withSideEffect("key","name").V().order().by(valueMap().select(select("key")).unfold()).values("name");
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_V_valuesXnameX_flatMapXsplitXaX() {
+            return g.V().values("name").flatMap(s -> Stream.of(((String) s.get()).split("a")).iterator());
+        }
+    }
+
+    public static class LinkedHashMapSupplier implements Supplier<LinkedHashMap> {
+
+        @Override
+        public LinkedHashMap get() {
+            return new LinkedHashMap();
+        }
+
+    }
+}
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/BranchTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/BranchTest.java
index 642cda4a45..76462c4e54 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/BranchTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/BranchTest.java
@@ -49,7 +49,6 @@ import static org.apache.tinkerpop.gremlin.process.traversal.Pick.none;
 @RunWith(GremlinProcessRunner.class)
 public abstract class BranchTest extends AbstractGremlinProcessTest {
 
-    public abstract Traversal<Vertex, Object> get_g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX();
 
     public abstract Traversal<Vertex, Object> get_g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX();
 
@@ -59,14 +58,6 @@ public abstract class BranchTest extends AbstractGremlinProcessTest {
 
     public abstract Traversal<Vertex, Object> get_g_V_branchXidentityX_optionXhasLabelXsoftwareX__inXcreatedX_name_order_foldX_optionXhasXname_vadasX__ageX_optionXneqX123X__bothE_countX();
 
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX() {
-        final Traversal<Vertex, Object> traversal = get_g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX();
-        printTraversalForm(traversal);
-        checkResults(Arrays.asList("java", "java", "lop", "ripple", 29, 27, 32, 35), traversal);
-    }
-
     @Test
     @LoadGraphWith(MODERN)
     public void g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX() {
@@ -101,14 +92,6 @@ public abstract class BranchTest extends AbstractGremlinProcessTest {
 
     public static class Traversals extends BranchTest {
 
-        @Override
-        public Traversal<Vertex, Object> get_g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX() {
-            return g.V().branch(v -> v.get().label().equals("person") ? "a" : "b")
-                    .option("a", values("age"))
-                    .option("b", values("lang"))
-                    .option("b", values("name"));
-        }
-
         @Override
         public Traversal<Vertex, Object> get_g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX() {
             return g.V().branch(label().is("person").count())
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/ChooseTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/ChooseTest.java
index d1f4933287..8ea6be1628 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/ChooseTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/ChooseTest.java
@@ -39,11 +39,9 @@ import java.util.Map;
 import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.hasLabel;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.identity;
-import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.in;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.label;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.out;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.outE;
-import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.valueMap;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.values;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
@@ -60,8 +58,6 @@ public abstract class ChooseTest extends AbstractGremlinProcessTest {
 
     public abstract Traversal<Vertex, Object> get_g_V_chooseXout_countX_optionX2L_nameX_optionX3L_ageX();
 
-    public abstract Traversal<Vertex, String> get_g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name();
-
     public abstract Traversal<Vertex, String> get_g_V_chooseXhasLabelXpersonX_and_outXcreatedX__outXknowsX__identityX_name();
 
     public abstract Traversal<Vertex, String> get_g_V_chooseXlabelX_optionXblah__outXknowsXX_optionXbleep__outXcreatedXX_optionXnone__identityX_name();
@@ -94,14 +90,6 @@ public abstract class ChooseTest extends AbstractGremlinProcessTest {
         assertEquals(Long.valueOf(1), counts.get("josh"));
     }
 
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name() {
-        final Traversal<Vertex, String> traversal = get_g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name();
-        printTraversalForm(traversal);
-        checkResults(Arrays.asList("josh", "vadas", "josh", "josh", "marko", "peter"), traversal);
-    }
-
     @Test
     @LoadGraphWith(MODERN)
     public void g_V_chooseXhasLabelXpersonX_and_outXcreatedX__outXknowsX__identityX_name() {
@@ -180,11 +168,6 @@ public abstract class ChooseTest extends AbstractGremlinProcessTest {
                     .option(3L, values("age"));
         }
 
-        @Override
-        public Traversal<Vertex, String> get_g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name() {
-            return g.V().choose(v -> v.label().equals("person"), out("knows"), in("created")).values("name");
-        }
-
         @Override
         public Traversal<Vertex, String> get_g_V_chooseXhasLabelXpersonX_and_outXcreatedX__outXknowsX__identityX_name() {
             return g.V().choose(hasLabel("person").and().out("created"), out("knows"), identity()).values("name");
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/RepeatTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/RepeatTest.java
index 6368193086..9783a5e0be 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/RepeatTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/branch/RepeatTest.java
@@ -67,7 +67,6 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest {
 
     // DO/WHILE
 
-
     public abstract Traversal<Vertex, Path> get_g_V_repeatXoutX_timesX2X_emit_path();
 
     public abstract Traversal<Vertex, String> get_g_V_repeatXoutX_timesX2X_repeatXinX_timesX2X_name();
@@ -102,8 +101,6 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest {
 
     public abstract Traversal<Vertex, String> get_g_VX1X_repeatXoutX_untilXoutE_count_isX0XX_name(final Object v1Id);
 
-    public abstract Traversal<Vertex, Map<String, Long>> get_g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX();
-
     public abstract Traversal<Vertex, Path> get_g_V_hasXname_markoX_repeatXoutE_inV_simplePathX_untilXhasXname_rippleXX_path_byXnameX_byXlabelX();
 
     // NESTED LOOP
@@ -330,21 +327,6 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest {
         assertEquals(2L, map.get(2).longValue());
     }
 
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX() {
-        final Traversal<Vertex, Map<String, Long>> traversal = get_g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX();
-        printTraversalForm(traversal);
-        final Map<String, Long> map = traversal.next();
-        assertFalse(traversal.hasNext());
-        assertEquals(5, map.size());
-        assertEquals(3L, map.get("ripple").longValue());
-        assertEquals(3L, map.get("vadas").longValue());
-        assertEquals(4L, map.get("josh").longValue());
-        assertEquals(10L, map.get("lop").longValue());
-        assertEquals(4L, map.get("marko").longValue());
-    }
-
     @Test
     @LoadGraphWith(MODERN)
     public void g_V_hasXname_markoX_repeatXoutE_inV_simplePathX_untilXhasXname_rippleXX_path_byXnameX_byXlabelX() {
@@ -550,11 +532,6 @@ public abstract class RepeatTest extends AbstractGremlinProcessTest {
             return g.V(v1Id).repeat(groupCount("m").by(loops()).out()).times(3).cap("m");
         }
 
-        @Override
-        public Traversal<Vertex, Map<String, Long>> get_g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX() {
-            return g.V().repeat(both()).until(t -> t.get().value("name").equals("lop") || t.loops() > 1).<String>groupCount().by("name");
-        }
-
         @Override
         public Traversal<Vertex, Path> get_g_V_hasXname_markoX_repeatXoutE_inV_simplePathX_untilXhasXname_rippleXX_path_byXnameX_byXlabelX() {
             return g.V().has("name", "marko").repeat(outE().inV().simplePath()).until(has("name", "ripple")).path().by("name").by(T.label);
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/FilterTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/FilterTest.java
index ad908e5ca5..3e818148d0 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/FilterTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/FilterTest.java
@@ -30,9 +30,10 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.constant;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.is;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
 
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
@@ -41,26 +42,18 @@ import static org.junit.Assert.assertTrue;
 @RunWith(GremlinProcessRunner.class)
 public abstract class FilterTest extends AbstractGremlinProcessTest {
 
-    public abstract Traversal<Vertex, Vertex> get_g_V_filterXfalseX();
+    public abstract Traversal<Vertex, Vertex> get_g_V_filterXisX0XX();
 
-    public abstract Traversal<Vertex, Vertex> get_g_V_filterXtrueX();
+    public abstract Traversal<Vertex, Vertex> get_g_V_filterXconstantX0XX();
 
-    public abstract Traversal<Vertex, Vertex> get_g_V_filterXlang_eq_javaX();
+    public abstract Traversal<Edge, Edge> get_g_E_filterXisX0XX();
 
-    public abstract Traversal<Vertex, Vertex> get_g_VX1X_filterXage_gt_30X(final Object v1Id);
-
-    public abstract Traversal<Vertex, Vertex> get_g_VX1X_out_filterXage_gt_30X(final Object v1Id);
-
-    public abstract Traversal<Vertex, Vertex> get_g_V_filterXname_startsWith_m_OR_name_startsWith_pX();
-
-    public abstract Traversal<Edge, Edge> get_g_E_filterXfalseX();
-
-    public abstract Traversal<Edge, Edge> get_g_E_filterXtrueX();
+    public abstract Traversal<Edge, Edge> get_g_E_filterXconstantX0XX();
 
     @Test
     @LoadGraphWith(MODERN)
-    public void g_V_filterXfalseX() {
-        final Traversal<Vertex, Vertex> traversal = get_g_V_filterXfalseX();
+    public void g_V_filterXisX0XX() {
+        final Traversal<Vertex, Vertex> traversal = get_g_V_filterXisX0XX();
         printTraversalForm(traversal);
         assertFalse(traversal.hasNext());
         assertFalse(traversal.hasNext());
@@ -68,8 +61,8 @@ public abstract class FilterTest extends AbstractGremlinProcessTest {
 
     @Test
     @LoadGraphWith(MODERN)
-    public void g_V_filterXtrueX() {
-        final Traversal<Vertex, Vertex> traversal = get_g_V_filterXtrueX();
+    public void g_V_filterXconstantX0XX() {
+        final Traversal<Vertex, Vertex> traversal = get_g_V_filterXconstantX0XX();
         printTraversalForm(traversal);
         int counter = 0;
         final Set<Vertex> vertices = new HashSet<>();
@@ -84,71 +77,8 @@ public abstract class FilterTest extends AbstractGremlinProcessTest {
 
     @Test
     @LoadGraphWith(MODERN)
-    public void g_V_filterXlang_eq_javaX() {
-        final Traversal<Vertex, Vertex> traversal = get_g_V_filterXlang_eq_javaX();
-        printTraversalForm(traversal);
-        int counter = 0;
-        final Set<Vertex> vertices = new HashSet<>();
-        while (traversal.hasNext()) {
-            counter++;
-            final Vertex vertex = traversal.next();
-            vertices.add(vertex);
-            assertTrue(vertex.value("name").equals("ripple") ||
-                    vertex.value("name").equals("lop"));
-        }
-        assertEquals(2, counter);
-        assertEquals(2, vertices.size());
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_VX1X_filterXage_gt_30X() {
-        final Traversal<Vertex, Vertex> traversal = get_g_VX1X_filterXage_gt_30X(convertToVertexId("marko"));
-        printTraversalForm(traversal);
-        assertFalse(traversal.hasNext());
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_VX2X_filterXage_gt_30X() {
-        final  Traversal<Vertex, Vertex> traversal = get_g_VX1X_filterXage_gt_30X(convertToVertexId("josh"));
-        printTraversalForm(traversal);
-        assertTrue(traversal.hasNext());
-        assertEquals(Integer.valueOf(32), traversal.next().<Integer>value("age"));
-        assertFalse(traversal.hasNext());
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_VX1X_out_filterXage_gt_30X() {
-        final Traversal<Vertex, Vertex> traversal = get_g_VX1X_out_filterXage_gt_30X(convertToVertexId("marko"));
-        printTraversalForm(traversal);
-        assertEquals(Integer.valueOf(32), traversal.next().<Integer>value("age"));
-        assertFalse(traversal.hasNext());
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_V_filterXname_startsWith_m_OR_name_startsWith_pX() {
-        final Traversal<Vertex, Vertex> traversal = get_g_V_filterXname_startsWith_m_OR_name_startsWith_pX();
-        printTraversalForm(traversal);
-        int counter = 0;
-        final Set<Vertex> vertices = new HashSet<>();
-        while (traversal.hasNext()) {
-            counter++;
-            final Vertex vertex = traversal.next();
-            vertices.add(vertex);
-            assertTrue(vertex.value("name").equals("marko") ||
-                    vertex.value("name").equals("peter"));
-        }
-        assertEquals(counter, 2);
-        assertEquals(vertices.size(), 2);
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_E_filterXfalseX() {
-        final Traversal<Edge, Edge> traversal = get_g_E_filterXfalseX();
+    public void g_E_filterXisX0XX() {
+        final Traversal<Edge, Edge> traversal = get_g_E_filterXisX0XX();
         printTraversalForm(traversal);
         assertFalse(traversal.hasNext());
         assertFalse(traversal.hasNext());
@@ -156,8 +86,8 @@ public abstract class FilterTest extends AbstractGremlinProcessTest {
 
     @Test
     @LoadGraphWith(MODERN)
-    public void g_E_filterXtrueX() {
-        final Traversal<Edge, Edge> traversal = get_g_E_filterXtrueX();
+    public void g_E_filterXconstantX0XX() {
+        final Traversal<Edge, Edge> traversal = get_g_E_filterXconstantX0XX();
         printTraversalForm(traversal);
         int counter = 0;
         final Set<Edge> edges = new HashSet<>();
@@ -173,46 +103,23 @@ public abstract class FilterTest extends AbstractGremlinProcessTest {
     public static class Traversals extends FilterTest {
 
         @Override
-        public Traversal<Vertex, Vertex> get_g_V_filterXfalseX() {
-            return g.V().filter(v -> false);
-        }
-
-        @Override
-        public Traversal<Vertex, Vertex> get_g_V_filterXtrueX() {
-            return g.V().filter(v -> true);
-        }
-
-        @Override
-        public Traversal<Vertex, Vertex> get_g_V_filterXlang_eq_javaX() {
-            return g.V().filter(v -> v.get().<String>property("lang").orElse("none").equals("java"));
-        }
-
-        @Override
-        public Traversal<Vertex, Vertex> get_g_VX1X_filterXage_gt_30X(final Object v1Id) {
-            return g.V(v1Id).filter(v -> v.get().<Integer>property("age").orElse(0) > 30);
-        }
-
-        @Override
-        public Traversal<Vertex, Vertex> get_g_VX1X_out_filterXage_gt_30X(final Object v1Id) {
-            return g.V(v1Id).out().filter(v -> v.get().<Integer>property("age").orElse(0) > 30);
+        public Traversal<Vertex, Vertex> get_g_V_filterXisX0XX() {
+            return g.V().filter(is(0));
         }
 
         @Override
-        public Traversal<Vertex, Vertex> get_g_V_filterXname_startsWith_m_OR_name_startsWith_pX() {
-            return g.V().filter(v -> {
-                final String name = v.get().value("name");
-                return name.startsWith("m") || name.startsWith("p");
-            });
+        public Traversal<Vertex, Vertex> get_g_V_filterXconstantX0XX() {
+            return g.V().filter(constant(0));
         }
 
         @Override
-        public Traversal<Edge, Edge> get_g_E_filterXfalseX() {
-            return g.E().filter(e -> false);
+        public Traversal<Edge, Edge> get_g_E_filterXisX0XX() {
+            return g.E().filter(is(0));
         }
 
         @Override
-        public Traversal<Edge, Edge> get_g_E_filterXtrueX() {
-            return g.E().filter(e -> true);
+        public Traversal<Edge, Edge> get_g_E_filterXconstantX0XX() {
+            return g.E().filter(constant(0));
         }
     }
 }
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasTest.java
index 1c1cecec32..0c516d19d3 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/HasTest.java
@@ -56,8 +56,6 @@ import static org.junit.Assert.assertTrue;
 @RunWith(GremlinProcessRunner.class)
 public abstract class HasTest extends AbstractGremlinProcessTest {
 
-    public abstract Traversal<Vertex, String> get_g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name();
-
     public abstract Traversal<Vertex, Vertex> get_g_VX1X_hasXkeyX(final Object v1Id, final String key);
 
     public abstract Traversal<Vertex, Vertex> get_g_VX1X_hasXname_markoX(final Object v1Id);
@@ -200,14 +198,6 @@ public abstract class HasTest extends AbstractGremlinProcessTest {
 
     public abstract Traversal<Vertex, String> get_g_V_properties_hasValueXnull_joshX_value();
 
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name() {
-        final Traversal<Vertex, String> traversal = get_g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name();
-        printTraversalForm(traversal);
-        checkResults(Arrays.asList("ripple"), traversal);
-    }
-
     @Test
     @LoadGraphWith(MODERN)
     public void g_VX1X_hasXnameX() {
@@ -985,11 +975,6 @@ public abstract class HasTest extends AbstractGremlinProcessTest {
             return g.E(e11Id).outV().outE().has(T.id, e10Id);
         }
 
-        @Override
-        public Traversal<Vertex, String> get_g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name() {
-            return g.V().out("created").has("name", __.<String, Integer>map(s -> s.get().length()).is(P.gt(3))).values("name");
-        }
-
         @Override
         public Traversal<Vertex, Vertex> get_g_VX1X_hasXkeyX(final Object v1Id, final String key) {
             return g.V(v1Id).has(key);
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MapTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MapTest.java
index 35faa03818..478a973d33 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MapTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MapTest.java
@@ -21,113 +21,27 @@ package org.apache.tinkerpop.gremlin.process.traversal.step.map;
 import org.apache.tinkerpop.gremlin.LoadGraphWith;
 import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
 import org.apache.tinkerpop.gremlin.process.GremlinProcessRunner;
-import org.apache.tinkerpop.gremlin.process.IgnoreEngine;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-import java.util.List;
-
 import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.constant;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.select;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
 
 /**
  * @author Stephen Mallette (http://stephen.genoprime.com)
  */
 @RunWith(GremlinProcessRunner.class)
 public abstract class MapTest extends AbstractGremlinProcessTest {
-    public abstract Traversal<Vertex, String> get_g_VX1X_mapXnameX(final Object v1Id);
-
-    public abstract Traversal<Vertex, Integer> get_g_VX1X_outE_label_mapXlengthX(final Object v1Id);
-
-    public abstract Traversal<Vertex, Integer> get_g_VX1X_out_mapXnameX_mapXlengthX(final Object v1Id);
-
-    public abstract Traversal<Vertex, String> get_g_withPath_V_asXaX_out_mapXa_nameX();
-
-    public abstract Traversal<Vertex, String> get_g_withPath_V_asXaX_out_out_mapXa_name_it_nameX();
 
     public abstract Traversal<Vertex, Vertex> get_g_V_mapXselectXaXX();
 
     public abstract Traversal<Vertex, Vertex> get_g_V_mapXconstantXnullXX();
 
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_VX1X_mapXnameX() {
-        final Traversal<Vertex, String> traversal = get_g_VX1X_mapXnameX(convertToVertexId("marko"));
-        printTraversalForm(traversal);
-        assertEquals(traversal.next(), "marko");
-        assertFalse(traversal.hasNext());
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_VX1X_outE_label_mapXlengthX() {
-        final Traversal<Vertex, Integer> traversal = get_g_VX1X_outE_label_mapXlengthX(convertToVertexId("marko"));
-        printTraversalForm(traversal);
-        final List<Integer> lengths = traversal.toList();
-        assertTrue(lengths.contains("created".length()));
-        assertTrue(lengths.contains("knows".length()));
-        assertEquals(lengths.size(), 3);
-        assertFalse(traversal.hasNext());
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_VX1X_out_mapXnameX_mapXlengthX() {
-        final Traversal<Vertex, Integer> traversal = get_g_VX1X_out_mapXnameX_mapXlengthX(convertToVertexId("marko"));
-        printTraversalForm(traversal);
-        final List<Integer> lengths = traversal.toList();
-        assertTrue(lengths.contains("josh".length()));
-        assertTrue(lengths.contains("vadas".length()));
-        assertTrue(lengths.contains("lop".length()));
-        assertEquals(lengths.size(), 3);
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    @IgnoreEngine(TraversalEngine.Type.COMPUTER)
-    public void g_withPath_V_asXaX_out_mapXa_nameX() {
-        int marko = 0;
-        int peter = 0;
-        int josh = 0;
-        int other = 0;
-
-        final Traversal<Vertex, String> traversal = get_g_withPath_V_asXaX_out_mapXa_nameX();
-        printTraversalForm(traversal);
-        while (traversal.hasNext()) {
-            final String name = traversal.next();
-            if (name.equals("marko")) marko++;
-            else if (name.equals("peter")) peter++;
-            else if (name.equals("josh")) josh++;
-            else other++;
-        }
-        assertEquals(marko, 3);
-        assertEquals(josh, 2);
-        assertEquals(peter, 1);
-        assertEquals(other, 0);
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    @IgnoreEngine(TraversalEngine.Type.COMPUTER)
-    public void g_withPath_V_asXaX_out_out_mapXa_name_it_nameX() {
-        final Traversal<Vertex, String> traversal = get_g_withPath_V_asXaX_out_out_mapXa_name_it_nameX();
-        int counter = 0;
-        while (traversal.hasNext()) {
-            counter++;
-            final String doubleName = traversal.next();
-            assertTrue("markoripple".equals(doubleName) || "markolop".equals(doubleName));
-        }
-        assertEquals(2, counter);
-        assertFalse(traversal.hasNext());
-    }
 
     /** TINKERPOP-782 */
     @Test
@@ -157,30 +71,6 @@ public abstract class MapTest extends AbstractGremlinProcessTest {
     }
 
     public static class Traversals extends MapTest {
-        @Override
-        public Traversal<Vertex, String> get_g_VX1X_mapXnameX(final Object v1Id) {
-            return g.V(v1Id).<String>map(v -> v.get().value("name"));
-        }
-
-        @Override
-        public Traversal<Vertex, Integer> get_g_VX1X_outE_label_mapXlengthX(final Object v1Id) {
-            return g.V(v1Id).outE().label().map(l -> l.get().length());
-        }
-
-        @Override
-        public Traversal<Vertex, Integer> get_g_VX1X_out_mapXnameX_mapXlengthX(final Object v1Id) {
-            return g.V(v1Id).out().map(v -> v.get().value("name")).map(n -> n.get().toString().length());
-        }
-
-        @Override
-        public Traversal<Vertex, String> get_g_withPath_V_asXaX_out_mapXa_nameX() {
-            return g.withPath().V().as("a").out().<String>map(v -> v.<Vertex>path("a").value("name"));
-        }
-
-        @Override
-        public Traversal<Vertex, String> get_g_withPath_V_asXaX_out_out_mapXa_name_it_nameX() {
-            return g.withPath().V().as("a").out().out().map(v -> v.<Vertex>path("a").<String>value("name") + v.get().<String>value("name"));
-        }
 
         @Override
         public Traversal<Vertex, Vertex> get_g_V_mapXselectXaXX() {
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/OrderTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/OrderTest.java
index 1194958d13..b8eb4f07c7 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/OrderTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/OrderTest.java
@@ -29,14 +29,12 @@ import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
 import org.apache.tinkerpop.gremlin.structure.Column;
-import org.apache.tinkerpop.gremlin.structure.Property;
 import org.apache.tinkerpop.gremlin.structure.T;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -55,7 +53,6 @@ import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
  * @author Stephen Mallette (http://stephen.genoprime.com)
@@ -77,8 +74,6 @@ public abstract class OrderTest extends AbstractGremlinProcessTest {
 
     public abstract Traversal<Vertex, Map<String, Vertex>> get_g_V_asXaX_outXcreatedX_asXbX_order_byXshuffleX_selectXa_bX();
 
-    public abstract Traversal<Vertex, Map<Integer, Integer>> get_g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX(final Object v1Id);
-
     public abstract Traversal<Vertex, Vertex> get_g_V_order_byXoutE_count_descX_byXnameX();
 
     public abstract Traversal<Vertex, Map<String, List<Vertex>>> get_g_V_group_byXlabelX_byXname_order_byXdescX_foldX();
@@ -93,8 +88,6 @@ public abstract class OrderTest extends AbstractGremlinProcessTest {
 
     public abstract Traversal<Vertex, List<Vertex>> get_g_V_hasLabelXpersonX_fold_orderXlocalX_byXageX();
 
-    public abstract Traversal<Vertex, String> get_g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name();
-
     public abstract Traversal<Vertex, String> get_g_V_properties_order_byXkey_descX_key();
 
     public abstract Traversal<Vertex, Vertex> get_g_V_hasXsong_name_OHBOYX_outXfollowedByX_outXfollowedByX_order_byXperformancesX_byXsongType_descX();
@@ -198,31 +191,6 @@ public abstract class OrderTest extends AbstractGremlinProcessTest {
         assertEquals(4, counter);
     }
 
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX() {
-        final Traversal<Vertex, Map<Integer, Integer>> traversal = get_g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX(convertToVertexId("marko"));
-        printTraversalForm(traversal);
-        final Map<Integer, Integer> map = traversal.next();
-        assertFalse(traversal.hasNext());
-        assertEquals(4, map.size());
-        final Iterator<Map.Entry<Integer, Integer>> iterator = map.entrySet().iterator();
-        Map.Entry<Integer, Integer> entry = iterator.next();
-        assertEquals(3, entry.getKey().intValue());
-        assertEquals(87, entry.getValue().intValue());
-        entry = iterator.next();
-        assertEquals(2, entry.getKey().intValue());
-        assertEquals(58, entry.getValue().intValue());
-        entry = iterator.next();
-        assertEquals(1, entry.getKey().intValue());
-        assertEquals(29, entry.getValue().intValue());
-        entry = iterator.next();
-        assertEquals(4, entry.getKey().intValue());
-        assertEquals(29, entry.getValue().intValue());
-        assertFalse(iterator.hasNext());
-        assertFalse(traversal.hasNext());
-    }
-
     @Test
     @LoadGraphWith(MODERN)
     public void g_V_order_byXoutE_count_descX_byXnameX() {
@@ -328,14 +296,6 @@ public abstract class OrderTest extends AbstractGremlinProcessTest {
         assertEquals(convertToVertex(graph, "peter"), list.get(3));
     }
 
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name() {
-        final Traversal<Vertex, String> traversal = get_g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name();
-        printTraversalForm(traversal);
-        checkOrderedResults(Arrays.asList("peter", "josh", "marko", "vadas"), traversal);
-    }
-
     @Test
     @LoadGraphWith(MODERN)
     public void g_V_properties_order_byXkey_descX_key() {
@@ -554,18 +514,6 @@ public abstract class OrderTest extends AbstractGremlinProcessTest {
             return g.V().as("a").out("created").as("b").order().by(Order.shuffle).select("a", "b");
         }
 
-        @Override
-        public Traversal<Vertex, Map<Integer, Integer>> get_g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX(final Object v1Id) {
-            return g.V(v1Id).hasLabel("person").map(v -> {
-                final Map<Integer, Integer> map = new HashMap<>();
-                map.put(1, (int) v.get().value("age"));
-                map.put(2, (int) v.get().value("age") * 2);
-                map.put(3, (int) v.get().value("age") * 3);
-                map.put(4, (int) v.get().value("age"));
-                return map;
-            }).order(Scope.local).by(Column.values, desc).by(keys, Order.asc);
-        }
-
         @Override
         public Traversal<Vertex, Vertex> get_g_V_order_byXoutE_count_descX_byXnameX() {
             return g.V().order().by(outE().count(), desc).by("name");
@@ -601,11 +549,6 @@ public abstract class OrderTest extends AbstractGremlinProcessTest {
             return g.V().hasLabel("person").fold().order(Scope.local).by("age");
         }
 
-        @Override
-        public Traversal<Vertex, String> get_g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name() {
-            return g.V().hasLabel("person").order().<Vertex>by(v -> v.value("age"), desc).values("name");
-        }
-
         @Override
         public Traversal<Vertex, String> get_g_V_properties_order_byXkey_descX_key() {
             return g.V().properties().order().by(T.key, desc).key();
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/UnfoldTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/UnfoldTest.java
index 1926aa8212..3a32f96755 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/UnfoldTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/UnfoldTest.java
@@ -29,8 +29,6 @@ import org.junit.runner.RunWith;
 
 import java.util.Arrays;
 import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
 import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
@@ -39,7 +37,6 @@ import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.hasId;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.outE;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.fail;
 
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
@@ -49,8 +46,6 @@ public abstract class UnfoldTest extends AbstractGremlinProcessTest {
 
     public abstract Traversal<Vertex, Edge> get_g_V_localXoutE_foldX_unfold();
 
-    public abstract Traversal<Vertex, String> get_g_V_valueMap_unfold_mapXkeyX();
-
     public abstract Traversal<Vertex, String> get_g_VX1X_repeatXboth_simplePathX_untilXhasIdX6XX_path_byXnameX_unfold(final Object v1Id, final Object v6Id);
 
     @Test
@@ -69,35 +64,6 @@ public abstract class UnfoldTest extends AbstractGremlinProcessTest {
         assertFalse(traversal.hasNext());
     }
 
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_V_valueMap_unfold_mapXkeyX() {
-        final Traversal<Vertex, String> traversal = get_g_V_valueMap_unfold_mapXkeyX();
-        printTraversalForm(traversal);
-        int counter = 0;
-        int ageCounter = 0;
-        int nameCounter = 0;
-        int langCounter = 0;
-        while (traversal.hasNext()) {
-            counter++;
-            final String key = traversal.next();
-            if (key.equals("name"))
-                nameCounter++;
-            else if (key.equals("age"))
-                ageCounter++;
-            else if (key.equals("lang"))
-                langCounter++;
-            else
-                fail("The provided key is not known: " + key);
-        }
-        assertEquals(12, counter);
-        assertEquals(4, ageCounter);
-        assertEquals(2, langCounter);
-        assertEquals(6, nameCounter);
-        assertEquals(counter, ageCounter + langCounter + nameCounter);
-        assertFalse(traversal.hasNext());
-    }
-
     @Test
     @LoadGraphWith(MODERN)
     public void g_VX1X_repeatXboth_simplePathX_untilXhasIdX6XX_path_byXnameX_unfold() {
@@ -114,11 +80,6 @@ public abstract class UnfoldTest extends AbstractGremlinProcessTest {
             return g.V().local(outE().fold()).unfold();
         }
 
-        @Override
-        public Traversal<Vertex, String> get_g_V_valueMap_unfold_mapXkeyX() {
-            return g.V().valueMap().<Map.Entry<String, List>>unfold().map(m -> m.get().getKey());
-        }
-
         @Override
         public Traversal<Vertex, String> get_g_VX1X_repeatXboth_simplePathX_untilXhasIdX6XX_path_byXnameX_unfold(Object v1Id, Object v6Id) {
             return g.V(v1Id).repeat(both().simplePath()).until(hasId(v6Id)).path().by("name").unfold();
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/GroupTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/GroupTest.java
index 277267a07c..754f127ac4 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/GroupTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/GroupTest.java
@@ -41,7 +41,6 @@ import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.GRATEFUL;
 import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.both;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.bothE;
-import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.constant;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.count;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.out;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.outE;
@@ -79,10 +78,6 @@ public abstract class GroupTest extends AbstractGremlinProcessTest {
 
     public abstract Traversal<Vertex, Map<String, Long>> get_g_V_repeatXbothXfollowedByXX_timesX2X_groupXaX_byXsongTypeX_byXcountX_capXaX();
 
-    public abstract Traversal<Vertex, Map<String, Long>> get_g_V_group_byXname_substring_1X_byXconstantX1XX();
-
-    public abstract Traversal<Vertex, Map<String, Long>> get_g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX();
-
     public abstract Traversal<Vertex, String> get_g_V_out_group_byXlabelX_selectXpersonX_unfold_outXcreatedX_name_limitX2X();
 
     public abstract Traversal<Vertex, Map<String, Map<String, Long>>> get_g_V_hasLabelXsongX_group_byXnameX_byXproperties_groupCount_byXlabelXX();
@@ -277,40 +272,6 @@ public abstract class GroupTest extends AbstractGremlinProcessTest {
         checkSideEffects(traversal.asAdmin().getSideEffects(), "a", HashMap.class);
     }
 
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_V_group_byXname_substring_1X_byXconstantX1XX() {
-        final Traversal<Vertex, Map<String, Long>> traversal = get_g_V_group_byXname_substring_1X_byXconstantX1XX();
-        printTraversalForm(traversal);
-        checkMap(new HashMap<String, Long>() {{
-            put("m", 1l);
-            put("v", 1l);
-            put("p", 1l);
-            put("l", 1l);
-            put("r", 1l);
-            put("j", 1l);
-        }}, traversal.next());
-        assertFalse(traversal.hasNext());
-        checkSideEffects(traversal.asAdmin().getSideEffects());
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX() {
-        final Traversal<Vertex, Map<String, Long>> traversal = get_g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX();
-        printTraversalForm(traversal);
-        checkMap(new HashMap<String, Long>() {{
-            put("m", 1l);
-            put("v", 1l);
-            put("p", 1l);
-            put("l", 1l);
-            put("r", 1l);
-            put("j", 1l);
-        }}, traversal.next());
-        assertFalse(traversal.hasNext());
-        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", HashMap.class);
-    }
-
     @Test
     @LoadGraphWith(MODERN)
     public void g_V_out_group_byXlabelX_selectXpersonX_unfold_outXcreatedX_name_limitX2X() {
@@ -606,16 +567,6 @@ public abstract class GroupTest extends AbstractGremlinProcessTest {
             return g.V().repeat(both("followedBy")).times(2).<String, Long>group("a").by("songType").by(count()).cap("a");
         }
 
-        @Override
-        public Traversal<Vertex, Map<String, Long>> get_g_V_group_byXname_substring_1X_byXconstantX1XX() {
-            return g.V().<String, Long>group().<Vertex>by(v -> v.<String>value("name").substring(0, 1)).by(constant(1l));
-        }
-
-        @Override
-        public Traversal<Vertex, Map<String, Long>> get_g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX() {
-            return g.V().<String, Long>group("a").<Vertex>by(v -> v.<String>value("name").substring(0, 1)).by(constant(1l)).cap("a");
-        }
-
         @Override
         public Traversal<Vertex, String> get_g_V_out_group_byXlabelX_selectXpersonX_unfold_outXcreatedX_name_limitX2X() {
             return g.V().out().<String, Vertex>group().by(T.label).select("person").unfold().out("created").<String>values("name").limit(2);
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/InjectTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/InjectTest.java
index c256aa48a0..a5151bec76 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/InjectTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/InjectTest.java
@@ -21,7 +21,6 @@ package org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect;
 import org.apache.tinkerpop.gremlin.LoadGraphWith;
 import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
 import org.apache.tinkerpop.gremlin.process.GremlinProcessRunner;
-import org.apache.tinkerpop.gremlin.process.traversal.Path;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.MapHelper;
@@ -46,8 +45,6 @@ public abstract class InjectTest extends AbstractGremlinProcessTest {
 
     public abstract Traversal<Vertex, String> get_g_VX1X_out_injectXv2X_name(final Object v1Id, final Object v2Id);
 
-    public abstract Traversal<Vertex, Path> get_g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path(final Object v1Id);
-
     public abstract Traversal<Vertex, String> get_g_VX1X_injectXg_VX4XX_out_name(final Object v1Id, final Object v4Id);
 
     public abstract Traversal<Integer, Integer> get_g_injectXnull_1_3_nullX();
@@ -86,26 +83,6 @@ public abstract class InjectTest extends AbstractGremlinProcessTest {
         assertFalse(traversal.hasNext());
     }
 
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path() {
-        final Traversal<Vertex, Path> traversal = get_g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path(convertToVertexId("marko"));
-        printTraversalForm(traversal);
-        int counter = 0;
-        while (traversal.hasNext()) {
-            counter++;
-            final Path path = traversal.next();
-            if (path.get("a").equals("daniel")) {
-                assertEquals(2, path.size());
-                assertEquals(6, (int) path.get(1));
-            } else {
-                assertEquals(4, path.size());
-                assertEquals(path.<String>get("a").length(), (int) path.get(3));
-            }
-        }
-        assertEquals(4, counter);
-    }
-
     @Test
     public void g_injectXnull_1_3_nullX() {
         final Traversal<Integer, Integer> traversal = get_g_injectXnull_1_3_nullX();
@@ -197,11 +174,6 @@ public abstract class InjectTest extends AbstractGremlinProcessTest {
             return g.V(v1Id).out().inject(g.V(v2Id).next()).values("name");
         }
 
-        @Override
-        public Traversal<Vertex, Path> get_g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path(final Object v1Id) {
-            return g.V(v1Id).out().<String>values("name").inject("daniel").as("a").map(t -> t.get().length()).path();
-        }
-
         @Override
         public Traversal<Vertex, String> get_g_VX1X_injectXg_VX4XX_out_name(final Object v1Id, final Object v4Id) {
             return g.V(v1Id).inject(g.V(v4Id).next()).out().values("name");
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/SideEffectTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/SideEffectTest.java
index 8845683b69..236aa706a7 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/SideEffectTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/SideEffectTest.java
@@ -22,32 +22,17 @@ import org.apache.tinkerpop.gremlin.LoadGraphWith;
 import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
 import org.apache.tinkerpop.gremlin.process.GremlinProcessRunner;
 import org.apache.tinkerpop.gremlin.process.IgnoreEngine;
-import org.apache.tinkerpop.gremlin.process.traversal.Operator;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalSideEffects;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
-import org.apache.tinkerpop.gremlin.structure.T;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
-import org.apache.tinkerpop.gremlin.util.function.ArrayListSupplier;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Supplier;
+import java.util.HashSet;
 
 import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
-import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.select;
-import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.valueMap;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
 
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
@@ -56,220 +41,55 @@ import static org.junit.Assert.assertTrue;
 @RunWith(GremlinProcessRunner.class)
 public abstract class SideEffectTest extends AbstractGremlinProcessTest {
 
-    public abstract Traversal<Vertex, String> get_g_VX1X_sideEffectXstore_aX_name(final Object v1Id);
+    public abstract Traversal<Vertex, Object> get_g_V_valuesXnameX_sideEffectXidentityX();
 
-    public abstract Traversal<Vertex, String> get_g_VX1X_out_sideEffectXincr_cX_name(final Object v1Id);
+    public abstract Traversal<Vertex, Object> get_g_V_valuesXnameX_sideEffectXidentity_substringX1XX();
 
-    public abstract Traversal<Vertex, String> get_g_VX1X_out_sideEffectXX_name(final Object v1Id);
-
-    public abstract Traversal<Vertex, Map<String, Long>> get_g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX();
-
-    public abstract Traversal<Vertex, Map<String, Long>> get_g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX();
-
-    public abstract Traversal<Vertex, Integer> get_g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX();
-
-    public abstract Traversal<Vertex, Integer> get_g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX();
-
-    public abstract Traversal<Vertex, String> get_g_withSideEffectXk_nameX_V_order_byXvalueMap_selectXkX_unfoldX_name();
+    public abstract Traversal<Vertex, String> get_g_withSideEffectXx_setX_V_both_both_sideEffectXstoreXxX_byXnameXX_capXxX_unfold();
 
     @Test
     @LoadGraphWith(MODERN)
     @IgnoreEngine(TraversalEngine.Type.COMPUTER)
-    public void g_VX1X_sideEffectXstore_aX_name() {
-        final Traversal<Vertex, String> traversal = get_g_VX1X_sideEffectXstore_aX_name(convertToVertexId("marko"));
+    public void g_V_valuesXnameX_sideEffectXidentityX() {
+        final Traversal<Vertex, Object> traversal = get_g_V_valuesXnameX_sideEffectXidentityX();
         printTraversalForm(traversal);
-        assertEquals(traversal.next(), "marko");
-        assertFalse(traversal.hasNext());
-        assertEquals(convertToVertexId("marko"), traversal.asAdmin().getSideEffects().<List<Vertex>>get("a").get(0).id());
-        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", ArrayList.class);
+        checkResults(Arrays.asList("josh", "peter", "ripple", "marko", "vadas", "lop"), traversal);
     }
 
     @Test
     @LoadGraphWith(MODERN)
     @IgnoreEngine(TraversalEngine.Type.COMPUTER)
-    public void g_VX1X_out_sideEffectXincr_cX_name() {
-        final Traversal<Vertex, String> traversal = get_g_VX1X_out_sideEffectXincr_cX_name(convertToVertexId("marko"));
-        printTraversalForm(traversal);
-        assert_g_v1_out_sideEffectXincr_cX_valueXnameX(traversal);
-        assertEquals(new Integer(3), traversal.asAdmin().getSideEffects().<List<Integer>>get("c").get(0));
-        checkSideEffects(traversal.asAdmin().getSideEffects(), "c", ArrayList.class);
-    }
-
-    private void assert_g_v1_out_sideEffectXincr_cX_valueXnameX(final Iterator<String> traversal) {
-        final List<String> names = new ArrayList<>();
-        while (traversal.hasNext()) {
-            names.add(traversal.next());
-        }
-        assertEquals(3, names.size());
-        assertTrue(names.contains("josh"));
-        assertTrue(names.contains("lop"));
-        assertTrue(names.contains("vadas"));
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_VX1X_out_sideEffectXX_name() {
-        final Traversal<Vertex, String> traversal = get_g_VX1X_out_sideEffectXX_name(convertToVertexId("marko"));
+    public void g_V_valuesXnameX_sideEffectXidentity_substringX1XX() {
+        final Traversal<Vertex, Object> traversal = get_g_V_valuesXnameX_sideEffectXidentity_substringX1XX();
         printTraversalForm(traversal);
-        assert_g_v1_out_sideEffectXincr_cX_valueXnameX(traversal);
+        checkResults(Arrays.asList("josh", "peter", "ripple", "marko", "vadas", "lop"), traversal);
     }
 
     @Test
     @LoadGraphWith(MODERN)
-    public void g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX() {
-        final Traversal<Vertex, Map<String, Long>> traversal = get_g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX();
-        printTraversalForm(traversal);
-        Map<String, Long> map = traversal.next();
-        assertFalse(traversal.hasNext());
-        assertEquals(2, map.size());
-        assertEquals(4l, map.get("software").longValue());
-        assertEquals(2l, map.get("person").longValue());
-        final TraversalSideEffects sideEffects = traversal.asAdmin().getSideEffects();
-        map = sideEffects.get("a");
-        assertEquals(2, map.size());
-        assertEquals(4l, map.get("software").longValue());
-        assertEquals(2l, map.get("person").longValue());
-        ///
-        assertEquals(1, sideEffects.keys().size());
-        assertTrue(sideEffects.keys().contains("a"));
-        assertTrue(sideEffects.exists("a"));
-        assertTrue(sideEffects.get("a") instanceof LinkedHashMap);
-        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", LinkedHashMap.class);
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX() {
-        final Traversal<Vertex, Map<String, Long>> traversal = get_g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX();
+    @IgnoreEngine(TraversalEngine.Type.COMPUTER)
+    public void g_withSideEffectXx_setX_V_both_both_sideEffectXstoreXxX_byXnameXX_capXxX_unfold() {
+        final Traversal<Vertex, String> traversal = get_g_withSideEffectXx_setX_V_both_both_sideEffectXstoreXxX_byXnameXX_capXxX_unfold();
         printTraversalForm(traversal);
-        Map<String, Long> map = traversal.next();
-        assertFalse(traversal.hasNext());
-        assertEquals(2, map.size());
-        assertEquals(2l, map.get("software").longValue());
-        assertEquals(4l, map.get("person").longValue());
-        final TraversalSideEffects sideEffects = traversal.asAdmin().getSideEffects();
-        map = sideEffects.get("a");
-        assertEquals(2, map.size());
-        assertEquals(2l, map.get("software").longValue());
-        assertEquals(4l, map.get("person").longValue());
-        ///
-        assertEquals(3, sideEffects.keys().size());
-        assertTrue(sideEffects.keys().contains("a"));
-        assertTrue(sideEffects.exists("a"));
-        assertTrue(sideEffects.get("a") instanceof LinkedHashMap);
-        //
-        assertTrue(sideEffects.keys().contains("b"));
-        assertTrue(sideEffects.exists("b"));
-        assertTrue(sideEffects.get("b") instanceof ArrayList);
-        assertEquals(18, sideEffects.<List<Integer>>get("b").size());
-        assertEquals(6l, sideEffects.<List<Integer>>get("b").stream().filter(t -> t == 1).count());
-        assertEquals(6l, sideEffects.<List<Integer>>get("b").stream().filter(t -> t == 2).count());
-        assertEquals(6l, sideEffects.<List<Integer>>get("b").stream().filter(t -> t == 3).count());
-        //
-        assertTrue(sideEffects.keys().contains("c"));
-        assertTrue(sideEffects.exists("c"));
-        assertTrue(sideEffects.get("c") instanceof ArrayList);
-        assertEquals(0, sideEffects.<List>get("c").size());
-        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", LinkedHashMap.class, "b", ArrayList.class, "c", ArrayList.class);
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX() {
-        final Traversal<Vertex, Integer> traversal = get_g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX();
-        assertEquals(6, traversal.next().intValue());
-        assertFalse(traversal.hasNext());
-        assertEquals(6, traversal.asAdmin().getSideEffects().<Integer>get("a").intValue());
-        assertEquals(1, traversal.asAdmin().getSideEffects().keys().size());
-        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", Integer.class);
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX() {
-        final Traversal<Vertex, Integer> traversal = get_g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX();
-        assertEquals(1, traversal.next().intValue());
-        assertFalse(traversal.hasNext());
-        assertEquals(1, traversal.asAdmin().getSideEffects().<Integer>get("a").intValue());
-        assertEquals(1, traversal.asAdmin().getSideEffects().keys().size());
-        checkSideEffects(traversal.asAdmin().getSideEffects(), "a", Integer.class);
-    }
-
-    @Test
-    @LoadGraphWith(MODERN)
-    public void g_withSideEffectXk_nameX_V_order_byXvalueMap_selectXkX_unfoldX_name() {
-        final Traversal<Vertex, String> traversal = get_g_withSideEffectXk_nameX_V_order_byXvalueMap_selectXkX_unfoldX_name();
-        checkOrderedResults(Arrays.asList(
-                "josh", "lop", "marko", "peter", "ripple", "vadas"), traversal);
+        checkResults(Arrays.asList("josh", "peter", "ripple", "marko", "vadas", "lop"), traversal);
+        checkSideEffects(traversal.asAdmin().getSideEffects(), "x", HashSet.class);
     }
 
     public static class Traversals extends SideEffectTest {
 
         @Override
-        public Traversal<Vertex, String> get_g_VX1X_sideEffectXstore_aX_name(final Object v1Id) {
-            return g.withSideEffect("a", ArrayList::new).V(v1Id).sideEffect(traverser -> {
-                traverser.<List>sideEffects("a").clear();
-                traverser.<List<Vertex>>sideEffects("a").add(traverser.get());
-            }).values("name");
+        public Traversal<Vertex, Object> get_g_V_valuesXnameX_sideEffectXidentityX() {
+            return g.V().values("name").sideEffect(__.identity());
         }
 
         @Override
-        public Traversal<Vertex, String> get_g_VX1X_out_sideEffectXincr_cX_name(final Object v1Id) {
-            return g.withSideEffect("c", () -> {
-                final List<Integer> list = new ArrayList<>();
-                list.add(0);
-                return list;
-            }).V(v1Id).out().sideEffect(traverser -> {
-                Integer temp = traverser.<List<Integer>>sideEffects("c").get(0);
-                traverser.<List<Integer>>sideEffects("c").clear();
-                traverser.<List<Integer>>sideEffects("c").add(temp + 1);
-            }).values("name");
+        public Traversal<Vertex, Object> get_g_V_valuesXnameX_sideEffectXidentity_substringX1XX() {
+            return g.V().values("name").sideEffect(__.identity().substring(1));
         }
 
         @Override
-        public Traversal<Vertex, String> get_g_VX1X_out_sideEffectXX_name(final Object v1Id) {
-            return g.V(v1Id).out().sideEffect(traverser -> {
-            }).values("name");
-        }
-
-        @Override
-        public Traversal<Vertex, Map<String, Long>> get_g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX() {
-            return g.withSideEffect("a", new LinkedHashMapSupplier()).V().out().groupCount("a").by(T.label).out().out().cap("a");
-        }
-
-        @Override
-        public Traversal<Vertex, Map<String, Long>> get_g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX() {
-            return g.withSideEffect("a", new LinkedHashMapSupplier())
-                    .withSideEffect("b", ArrayListSupplier.instance(), Operator.addAll)
-                    .withSideEffect("c", ArrayListSupplier.instance(), Operator.addAll)
-                    .V().group("a").by(T.label).by(__.count())
-                    .sideEffect(t -> t.sideEffects("b", new LinkedList<>(Arrays.asList(1, 2, 3))))
-                    .out().out().out()
-                    .sideEffect(t -> t.sideEffects("c", new LinkedList<>(Arrays.asList("bob", "daniel"))))
-                    .cap("a");
-        }
-
-        @Override
-        public Traversal<Vertex, Integer> get_g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX() {
-            return g.withSideEffect("a", 0, Operator.sum).V().out().sideEffect(t -> t.sideEffects("a", (int) t.bulk())).cap("a");
-        }
-
-        @Override
-        public Traversal<Vertex, Integer> get_g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX() {
-            return g.withSideEffect("a", 0).V().out().sideEffect(t -> t.sideEffects("a", 1)).cap("a");
-        }
-
-        @Override
-        public Traversal<Vertex, String> get_g_withSideEffectXk_nameX_V_order_byXvalueMap_selectXkX_unfoldX_name() {
-            return g.withSideEffect("key","name").V().order().by(valueMap().select(select("key")).unfold()).values("name");
-        }
-    }
-
-    private static class LinkedHashMapSupplier implements Supplier<LinkedHashMap> {
-
-        @Override
-        public LinkedHashMap get() {
-            return new LinkedHashMap();
+        public Traversal<Vertex, String> get_g_withSideEffectXx_setX_V_both_both_sideEffectXstoreXxX_byXnameXX_capXxX_unfold() {
+            return g.withSideEffect("x",new HashSet<>()).V().both().both().sideEffect(__.store("x").by("name")).cap("x").unfold();
         }
 
     }
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Branch.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Branch.feature
index 90450290c0..d232f4f90d 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Branch.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Branch.feature
@@ -18,29 +18,6 @@
 @StepClassBranch @StepBranch
 Feature: Step - branch()
 
-  Scenario: g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX
-    Given the modern graph
-    And using the parameter l1 defined as "c[it.get().label() == 'person' ? 'a' : 'b']"
-    And the traversal of
-      """
-      g.V().
-        branch(l1).
-          option("a", __.values("age")).
-          option("b", __.values("lang")).
-          option("b", __.values("name"))
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | java |
-      | java |
-      | lop |
-      | ripple |
-      | d[29].i |
-      | d[27].i |
-      | d[32].i |
-      | d[35].i |
-
   Scenario: g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX
     Given the modern graph
     And using the parameter xx1 defined as "d[1].l"
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Choose.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Choose.feature
index 9696563308..9067922b23 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Choose.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Choose.feature
@@ -34,23 +34,6 @@ Feature: Step - choose()
       | d[29].i |
       | josh |
 
-  Scenario: g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name
-    Given the modern graph
-    And using the parameter pred1 defined as "c[it.label() == 'person']"
-    And the traversal of
-      """
-      g.V().choose(pred1, __.out("knows"), __.in("created")).values("name")
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | josh |
-      | vadas |
-      | josh |
-      | josh |
-      | marko |
-      | peter |
-
   Scenario: g_V_chooseXhasLabelXpersonX_and_outXcreatedX__outXknowsX__identityX_name
     Given the modern graph
     And the traversal of
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Repeat.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Repeat.feature
index 13a79acdce..47fd69f1ab 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Repeat.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/branch/Repeat.feature
@@ -212,18 +212,6 @@ Feature: Step - repeat()
       | ripple  |
       | lop  |
 
-  Scenario: g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX
-    Given the modern graph
-    And using the parameter pred1 defined as "c[t -> t.get().value('name').equals('lop') || t.loops() > 1]"
-    And the traversal of
-      """
-      g.V().repeat(__.both()).until(pred1).groupCount().by("name")
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | m[{"ripple":"d[3].l","vadas":"d[3].l","josh":"d[4].l","lop":"d[10].l","marko":"d[4].l"}] |
-
   @GraphComputerVerificationReferenceOnly
   Scenario: g_V_hasXname_markoX_repeatXoutE_inV_simplePathX_untilXhasXname_rippleXX_path_byXnameX_byXlabelX
     Given the modern graph
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Filter.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Filter.feature
index 6aa368ba23..9b9639f886 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Filter.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Filter.feature
@@ -18,22 +18,20 @@
 @StepClassFilter @StepFilter
 Feature: Step - filter()
 
-  Scenario: g_V_filterXfalseX
+  Scenario: g_V_filterXisX0XX
     Given the modern graph
-    And using the parameter pred1 defined as "c[false]"
     And the traversal of
       """
-      g.V().filter(pred1)
+      g.V().filter(__.is(0))
       """
     When iterated to list
     Then the result should be empty
 
-  Scenario: g_V_filterXtrueX
+  Scenario: g_V_filterXconstantX0XX
     Given the modern graph
-    And using the parameter pred1 defined as "c[true]"
     And the traversal of
       """
-      g.V().filter(pred1)
+      g.V().filter(__.constant(0))
       """
     When iterated to list
     Then the result should be unordered
@@ -45,12 +43,11 @@ Feature: Step - filter()
       | v[ripple] |
       | v[peter]  |
 
-  Scenario: g_V_filterXlang_eq_javaX
+  Scenario: g_V_filterXhasXlang_javaXX
     Given the modern graph
-    And using the parameter pred1 defined as "c[it.get().property('lang').orElse('none').equals('java')]"
     And the traversal of
       """
-      g.V().filter(pred1)
+      g.V().filter(__.has("lang","java"))
       """
     When iterated to list
     Then the result should be unordered
@@ -58,49 +55,45 @@ Feature: Step - filter()
       | v[ripple] |
       | v[lop]  |
 
-  Scenario: g_VX1X_filterXage_gt_30X
+  Scenario: g_VX1X_filterXhasXage_gtX30XXX
     Given the modern graph
     And using the parameter vid1 defined as "v[marko].id"
-    And using the parameter pred1 defined as "c[it.get().property('age').orElse(0) > 30]"
     And the traversal of
       """
-      g.V(vid1).filter(pred1)
+      g.V(vid1).filter(__.has("age",P.gt(30)))
       """
     When iterated to list
     Then the result should be empty
 
-  Scenario: g_VX2X_filterXage_gt_30X
+  Scenario: g_VX2X_filterXhasXage_gtX30XXX
     Given the modern graph
     And using the parameter vid2 defined as "v[josh].id"
-    And using the parameter pred1 defined as "c[it.get().property('age').orElse(0) > 30]"
     And the traversal of
       """
-      g.V(vid2).filter(pred1)
+      g.V(vid2).filter(__.has("age",P.gt(30)))
       """
     When iterated to list
     Then the result should be unordered
       | result |
       | v[josh] |
 
-  Scenario: g_VX1X_out_filterXage_gt_30X
+  Scenario: g_VX1X_out_filterXhasXage_gtX30XXX
     Given the modern graph
     And using the parameter vid1 defined as "v[marko].id"
-    And using the parameter pred1 defined as "c[it.get().property('age').orElse(0) > 30]"
     And the traversal of
       """
-      g.V(vid1).out().filter(pred1)
+      g.V(vid1).out().filter(__.has("age",P.gt(30)))
       """
     When iterated to list
     Then the result should be unordered
       | result |
       | v[josh] |
 
-  Scenario: g_V_filterXname_startsWith_m_OR_name_startsWith_pX
+  Scenario: g_V_filterXhasXname_startingWithXm_or_pXX
     Given the modern graph
-    And using the parameter pred1 defined as "c[{name = it.get().value('name'); name.startsWith('m') || name.startsWith('p')}]"
     And the traversal of
       """
-      g.V().filter(pred1)
+      g.V().filter(__.has("name", TextP.startingWith("m").or(TextP.startingWith("p"))))
       """
     When iterated to list
     Then the result should be unordered
@@ -108,22 +101,20 @@ Feature: Step - filter()
       | v[marko] |
       | v[peter]  |
 
-  Scenario: g_E_filterXfalseX
+  Scenario: g_E_filterXisX0XX
     Given the modern graph
-    And using the parameter pred1 defined as "c[false]"
     And the traversal of
       """
-      g.E().filter(pred1)
+      g.E().filter(__.is(0))
       """
     When iterated to list
     Then the result should be empty
 
-  Scenario: g_E_filterXtrueX
+  Scenario: g_E_filterXconstantX0XX
     Given the modern graph
-    And using the parameter pred1 defined as "c[true]"
     And the traversal of
       """
-      g.E().filter(pred1)
+      g.E().filter(__.constant(0))
       """
     When iterated to list
     Then the result should be unordered
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Has.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Has.feature
index c10757748d..dbba761111 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Has.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Has.feature
@@ -18,18 +18,6 @@
 @StepClassFilter @StepHas
 Feature: Step - has()
 
-  Scenario: g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name
-    Given the modern graph
-    And using the parameter l1 defined as "c[it.get().length()]"
-    And the traversal of
-      """
-      g.V().out("created").has("name", __.map(l1).is(P.gt(3))).values("name")
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | ripple |
-
   Scenario: g_VX1X_hasXnameX
     Given the modern graph
     And using the parameter vid1 defined as "v[marko].id"
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/FlatMap.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/FlatMap.feature
index 6924a100e7..356499f5fc 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/FlatMap.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/FlatMap.feature
@@ -34,3 +34,23 @@ Feature: Step - flatMap()
       | v[ripple] |
       | v[peter]  |
 
+  Scenario: g_V_valuesXnameX_flatMapXsplitXaX_unfoldX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().values("name").flatMap(split("a").unfold())
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | m |
+      | rko |
+      | v |
+      | d |
+      | s |
+      | lop |
+      | josh |
+      | ripple |
+      | peter |
+
+
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Map.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Map.feature
index cc2d8c7e3a..a0fae39616 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Map.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Map.feature
@@ -18,13 +18,12 @@
 @StepClassMap @StepMap
 Feature: Step - map()
 
-  Scenario: g_VX1X_mapXnameX
+  Scenario: g_VX1X_mapXvaluesXnameXX
     Given the modern graph
     And using the parameter vid1 defined as "v[marko].id"
-    And using the parameter l1 defined as "c[it.get().value('name')]"
     And the traversal of
       """
-      g.V(vid1).map(l1)
+      g.V(vid1).map(__.values("name"))
       """
     When iterated to list
     Then the result should be unordered
@@ -34,10 +33,9 @@ Feature: Step - map()
   Scenario: g_VX1X_outE_label_mapXlengthX
     Given the modern graph
     And using the parameter vid1 defined as "v[marko].id"
-    And using the parameter l1 defined as "c[it.get().length()]"
     And the traversal of
       """
-      g.V(vid1).outE().label().map(l1)
+      g.V(vid1).outE().label().map(__.length())
       """
     When iterated to list
     Then the result should be unordered
@@ -46,14 +44,12 @@ Feature: Step - map()
       | d[5].i |
       | d[5].i |
 
-  Scenario: g_VX1X_out_mapXnameX_mapXlengthX
+  Scenario: g_VX1X_out_mapXvaluesXnameXX_mapXlengthX
     Given the modern graph
     And using the parameter vid1 defined as "v[marko].id"
-    And using the parameter l1 defined as "c[it.get().value('name')]"
-    And using the parameter l2 defined as "c[it.get().toString().length()]"
     And the traversal of
       """
-      g.V(vid1).out().map(l1).map(l2)
+      g.V(vid1).out().map(__.values("name")).map(__.length())
       """
     When iterated to list
     Then the result should be unordered
@@ -62,27 +58,12 @@ Feature: Step - map()
       | d[5].i |
       | d[4].i |
 
-  @RemoteOnly
-  Scenario: g_VX1X_out_mapXlambdaXnameXX_mapXlambdaXlengthXX
+  @GraphComputerVerificationStarGraphExceeded
+  Scenario: g_withPath_V_asXaX_out_mapXselectXaX_valuesXnameXX
     Given the modern graph
-    And using the parameter vid1 defined as "v[marko].id"
-    And the traversal of
-      """
-      g.V(vid1).out().map(Lambda.function("it.get().value('name')")).map(Lambda.function("it.get().toString().length()"))
-      """
-    When iterated to list
-    Then the result should be unordered
-      | result |
-      | d[3].i |
-      | d[5].i |
-      | d[4].i |
-
-  Scenario: g_withPath_V_asXaX_out_mapXa_nameX
-    Given the modern graph
-    And using the parameter l1 defined as "c[it.path('a').value('name')]"
     And the traversal of
       """
-      g.withPath().V().as("a").out().map(l1)
+      g.withPath().V().as("a").out().map(__.select("a").values("name"))
       """
     When iterated to list
     Then the result should be unordered
@@ -94,12 +75,12 @@ Feature: Step - map()
       | josh  |
       | peter |
 
-  Scenario: g_withPath_V_asXaX_out_out_mapXa_name_it_nameX
+  @GraphComputerVerificationStarGraphExceeded
+  Scenario: g_withPath_V_asXaX_out_out_asXbX_mapXselectXaX_valuesXnameX_concatXselectXbX_valuesXnameXXX
     Given the modern graph
-    And using the parameter l1 defined as "c[it.path('a').value('name')  + it.get().value('name')]"
     And the traversal of
       """
-      g.withPath().V().as("a").out().out().map(l1)
+      g.withPath().V().as("a").out().out().as("b").map(__.select("a").values("name").concat(__.select("b").values("name")))
       """
     When iterated to list
     Then the result should be unordered
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeEdge.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeEdge.feature
index 608fc996e7..fcd625da0b 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeEdge.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeEdge.feature
@@ -18,115 +18,6 @@
 @StepClassMap @StepMergeE
 Feature: Step - mergeE()
 
-  # TEST INDEX
-  # Use of inject() is meant to exercise mergeV() in a mid-traversal form rather than start step.
-  # When the test name places a "1" following a "name" it just means that the test is using the id rather
-  # than vertex reference.
-  #
-  # g_mergeEXlabel_knows_out_marko_in_vadasX
-  # g_mergeEXlabel_knows_out_marko1_in_vadas1X
-  # g_mergeEXlabel_knows_out_marko_in_vadasX_aliased_direction
-  #   - mergeE(Map) specifying out/in for vertices in the match/create with no option()
-  #   - vertices already exist
-  #   - results in new edge
-  # g_withSideEffectXa_label_knows_out_marko_in_vadasX_mergeEXselectXaXX
-  #   - mergeE(Traversal) specifying out/in for vertices in the match/create with no option()
-  #   - vertices already exist
-  #   - results in new edge
-  # g_mergeEXlabel_knows_out_marko_in_vadas_weight_05X_exists
-  #   - mergeE(Map) specifying out/in for vertices in the match/create with no option()
-  #   - vertices already exist as does an edge between them but the search will not match because of a missing property
-  #   - results in new edge
-  # g_mergeEXlabel_knows_out_marko_in_vadas_weight_05X
-  #   - mergeE(Map) specifying out/in for vertices in the match/create with no option()
-  #   - no vertices/edges in graph
-  #   - results in error as vertices don't exist
-  # g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX
-  #   - mergeE(Map) specifying out/in for vertices in the match/create with option(Map)
-  #   - no vertices/edges in graph
-  #   - results in error as vertices don't exist
-  # g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists
-  #   - mergeE(Map) specifying out/in for vertices in the match/create with option(Map)
-  #   - vertices and edge already exist
-  #   - results in the existing edge getting a new property
-  # g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated
-  #   - mergeE(Map) specifying out/in for vertices in the match/create with option(Map)
-  #   - vertices and edge already exist
-  #   - results in the existing edge getting an existing property updated
-  # g_V_hasXperson_name_marko_X_mergeEXlabel_knowsX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated
-  #   - mergeE(Map) using the vertex of the current traverser as reference and no out/in for match/create with option(Map)
-  #   - vertices and two edges of the same label already exist with one edge having an existing property
-  #   - results in one edge getting an existing property updated and the other getting a new property added
-  # g_injectXlabel_knows_out_marko_in_vadasX_mergeE
-  #   - mergeE() using Map from current traverser in the match/create with no option()
-  #   - vertices already exist
-  #   - results in a new edge
-  # g_mergeEXlabel_knows_in_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated
-  #   - mergeE(Map) specifying in vertex in the match/create with option(Map)
-  #   - vertices exist and there are two edges such that only one will match on the out vertex
-  #   - results in updating the property on the one matched edge
-  # g_mergeEXout_vadasX_optionXonCreate_created_YX_optionXonMatch_created_NX_exists_updated
-  #   - mergeE(Map) specifying no label and in vertex in the match/create with option(Map)
-  #   - vertices exist and there are two edges such that only one will match on the out vertex
-  #   - results in updating the property on the one matched edge
-  # g_V_hasXperson_name_marko_X_mergeEXlabel_self_out_vadas1_in_vadas1X
-  #   - mergeE(Map) specifying label and in/out vertex in the match/create with option(Map)
-  #   - vertices exist with no edge and the match/create map overrides the marko vertex in the traverser
-  #   - results in a new edge
-  # g_withSideEffectXc_created_YX_withSideEffectXm_matchedX_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_selectXcXX_optionXonMatch_selectXmXX
-  #   - mergeE(Map) specifying out/in for vertices in the match/create with option(Map)
-  #   - vertices exist in the graph
-  #   - results in one new edge
-  # g_withSideEffectXc_created_YX_withSideEffectXm_matchedX_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_selectXcXX_optionXonMatch_selectXmXX_exists
-  #   - mergeE(Map) specifying out/in for vertices in the match/create with option(Map)
-  #   - vertices and edge already exist
-  #   - results in the existing edge getting a new property
-  # g_injectXlabel_knows_out_marko_in_vadas_label_self_out_vadas_in_vadasX
-  #   - mergeE() using the map of current traverser as reference
-  #   - vertices already exists
-  #   - results in two new edges
-  # g_mergeEXnullX
-  # g_V_mergeEXnullX
-  #   - mergeE(null) and no option
-  #   - vertices already exists
-  #   - Directions not specified - error
-  # g_mergeEXemptyX
-  #   - mergeE(empty) and no option
-  #   - vertex present and no edges
-  #   - results in error because empty map matches all edges and there are none so it creates but doesn't have a Vertex reference to use to create the edge
-  # g_V_mergeEXemptyX
-  #   - mergeE(empty) and no option
-  #   - two vertices exist
-  #   - results in one edge added to the first vertex and then the same edge being returned
-  # g_mergeEXemptyX
-  #   - mergeE(empty) and no option
-  #   - vertices already exists
-  #   - results in no matched edges and no new edge
-  # g_mergeEXemptyX_exists
-  #   - mergeE(empty) and no option
-  #   - vertex with self-edge already exists
-  #   - results in the matched self-edge
-  # g_V_mergeEXemptyX_two_exist
-  #   - mergeE(empty) and no option
-  #   - two vertices exist
-  #   - results in two new self edges, one for each vertex
-  # g_V_mergeEXemptyX_optionXonCreate_nullX
-  #   - mergeE(empty) with onCreate(null)
-  #   - one existing vertex
-  #   - results in no new edges because onCreate() was null
-  # g_V_mergeEXlabel_selfX_optionXonMatch_nullX
-  #   - mergeE(Map) with onMatch(null)
-  #   - one existing vertex and one edge
-  #   - results in one matched edge with no updates
-  # g_V_mergeEXlabel_selfX_optionXonMatch_emptyX
-  #   - mergeE(Map) with onMatch(null)
-  #   - one existing vertex and one edge
-  #   - results in one matched edge with no updates
-  # g_withSideEffectXc_created_YX_withSideEffectXm_matchedX_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_selectXcXX_optionXonMatch_sideEffectXpropertiesXweightX_dropX_selectXmXX_exists
-  #   - mergeE(Map) with onMatch(Map)
-  #   - matches an edge
-  #   - results in matched edge being updated with a side-effect that drops a property that is not updated in the Map
-
   Scenario: g_V_mergeEXlabel_selfX_optionXonMatch_emptyX
     Given the empty graph
     And the graph initializer of
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeVertex.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeVertex.feature
index 0b80e0a1e4..31028cd12f 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeVertex.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeVertex.feature
@@ -18,90 +18,6 @@
 @StepClassMap @StepMergeV
 Feature: Step - mergeV()
 
-  # TEST INDEX
-  # Use of inject() is meant to exercise mergeV() in a mid-traversal form rather than start step
-  #
-  # g_mergeVXlabel_person_name_stephenX
-  # g_injectX0X_mergeVXlabel_person_name_stephenX
-  #   - mergeV(Map) and no option()
-  #   - results in new vertex
-  # g_mergeVXlabel_person_name_markoX
-  # g_injectX0X_mergeVXlabel_person_name_markoX
-  #   - mergeV(Map) and no option()
-  #   - results in found vertex
-  # g_mergeVXlabel_person_name_stephenX_optionXonCreate_label_person_name_stephen_age_19X_option
-  # g_injectX0X_mergeVXlabel_person_name_stephenX_optionXonCreate_label_person_name_stephen_age_19X_option
-  #   - mergeV(Map) using onCreate(Map)
-  #   - results in new vertex
-  # g_mergeVXlabel_person_name_markoX_optionXonMatch_age_19X_option
-  # g_injectX0X_mergeVXlabel_person_name_markoX_optionXonMatch_age_19X_option
-  #   - mergeV(Map) using onMatch(Map)
-  #   - results in update vertex
-  # g_withSideEffectXc_label_person_name_stephenX_withSideEffectXm_label_person_name_stephen_age_19X_mergeVXselectXcXX_optionXonCreate_selectXmXX_option
-  # g_withSideEffectXc_label_person_name_stephenX_withSideEffectXm_label_person_name_stephen_age_19X_injectX0X_mergeVXselectXcXX_optionXonCreate_selectXmXX_option
-  #   - mergeV(Traversal) grabbing side-effect Map with onCreate(Traversal)
-  #   - results in new vertex
-  # g_withSideEffectXc_label_person_name_markoX_withSideEffectXm_age_19X_mergeVXselectXcXX_optionXonMatch_selectXmXX_option
-  # g_withSideEffectXc_label_person_name_markoX_withSideEffectXm_age_19X_injectX0X_mergeVXselectXcXX_optionXonMatch_selectXmXX_option
-  #   - mergeV(Traversal) grabbing side-effect Map with onMatch(Traversal)
-  #   - results in updated vertex
-  # g_mergeVXlabel_person_name_markoX_propertyXname_vadas_acl_publicX
-  # g_injectX0X_mergeVXlabel_person_name_markoX_propertyXname_vadas_acl_publicX
-  #   - mergeV(Map) with no option and call to AddPropertyStep
-  #   - results in updated vertex and added meta-property
-  # g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeVXidentityX
-  #   - mergeV(Traversal) grabbing current Map from traverser for the search criteria with no option()
-  #   - result in one found vertex and one new vertex
-  # g_injectXlabel_person_name_marko_label_person_name_stephenX_mergeV
-  #   - mergeV() which assumes incoming Map on the traverser for the search criteria with no option()
-  #   - results in one found vertex and one new vertex
-  # g_mergeVXlabel_person_name_stephenX_propertyXlist_name_steveX
-  #   - mergeV() which assumes finding vertex with list cardinality property and call AddPropertyStep
-  #   - results in updated vertex with additional list cardinality property
-  # g_mergeXlabel_person_name_vadasX_optionXonMatch_age_35X
-  #   - mergeV(Map) using onMatch(Map)
-  #   - results in updating two matched vertices
-  # g_V_mapXmergeXlabel_person_name_joshXX
-  #   - mergeV(Map) with no option() - testing child traversal usage
-  #   - results in one new vertex and one existing vertex that was just created
-  # g_mergeVXnullX
-  # g_V_mergeVXnullX
-  #   - mergeV(null) with no option()
-  #   - results in no new vertex and nothing returned
-  # g_mergeVXemptyX
-  # g_V_mergeVXemptyX
-  #   - mergeV(empty) with no option()
-  #   - results in matched vertex with no updates
-  # g_mergeVXemptyX_no_existing
-  # g_injectX0X_mergeVXemptyX_no_existing
-  #   - mergeV(empty) with no option()
-  #   - results in not matched updates and a creation of a vertex with default values
-  # g_mergeVXnullX_optionXonCreate_emptyX
-  # g_V_mergeVXnullX_optionXonCreate_emptyX
-  #   - mergeV(null) with onCreate(empty)
-  #   - results in no matches and creates a default vertex
-  # g_mergeVXlabel_person_name_stephenX_optionXonCreate_nullX
-  # g_V_mergeVXlabel_person_name_stephenX_optionXonCreate_nullX
-  #   - mergeV(Map) with onCreate(null)
-  #   - results in no match and no vertex creation
-  # g_mergeVXnullX_optionXonCreate_label_null_name_markoX
-  # g_V_mergeVXnullX_optionXonCreate_label_null_name_markoX
-  #   - mergeV(null) with onCreate(Map) where Map has a null label
-  #   - results in error
-  # g_mergeVXemptyX_optionXonMatch_nullX
-  # g_V_mergeVXemptyX_optionXonMatch_nullX
-  #   - mergeV(empty) with onMatch(null)
-  #   - results in a match and no vertex update
-  # g_V_mergeVXemptyX_two_exist
-  #  - mergeV(empty) with no option()
-  #  - results in matching two vertices
-  # g_withSideEffectXc_label_person_name_markoX_withSideEffectXm_age_19X_mergeVXselectXcXX_optionXonMatch_sideEffectXpropertiesXageX_dropX_selectXmXX_option
-  #  - mergeV() that has a match to a vertex with multiproperties
-  #  - results in all multiproperties removed to be replaced with one property
-  # g_withSideEffectXm_age_19X_V_hasXperson_name_markoX_mergeVXselectXcXX_optionXonMatch_sideEffectXpropertiesXageX_dropX_selectXmXX_option
-  #  - mergeV() that has a match to a vertex with multiproperties
-  #  - results in all multiproperties removed to be replaced with one property
-
   Scenario: g_mergeVXemptyX_optionXonMatch_nullX
     Given the empty graph
     And the graph initializer of
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Order.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Order.feature
index 52ccae79bd..32e2905944 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Order.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Order.feature
@@ -133,21 +133,6 @@ Feature: Step - order()
       | age    |
       | age    |
 
-  Scenario: g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name
-    Given the modern graph
-    And using the parameter l1 defined as "c[it.value('age')]"
-    And the traversal of
-      """
-      g.V().hasLabel("person").order().by(l1, Order.desc).values("name")
-      """
-    When iterated to list
-    Then the result should be ordered
-      | result |
-      | peter  |
-      | josh   |
-      | marko  |
-      | vadas  |
-
   Scenario: g_V_hasLabelXpersonX_group_byXnameX_byXoutE_weight_sumX_orderXlocalX_byXvaluesX
     Given the modern graph
     And the traversal of
@@ -349,19 +334,6 @@ Feature: Step - order()
       | v[josh]   |
       | v[peter] |
 
-  Scenario: g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX
-    Given the modern graph
-    And using the parameter v1 defined as "v[marko]"
-    And using the parameter l1 defined as "c[['1':it.get().value('age'),'2':it.get().value('age')*2,'3':it.get().value('age')*3,'4':it.get().value('age')]]"
-    And the traversal of
-      """
-      g.V(v1).hasLabel("person").map(l1).order(Scope.local).by(Column.values, Order.desc).by(Column.keys, Order.asc)
-      """
-    When iterated to list
-    Then the result should be ordered
-      | result |
-      | m[{"3":"d[87].i","2":"d[58].i","1":"d[29].i","4":"d[29].i"}] |
-
   Scenario: g_V_hasXsong_name_OHBOYX_outXfollowedByX_outXfollowedByX_order_byXperformancesX_byXsongType_descX
     Given the grateful graph
     And the traversal of
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Unfold.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Unfold.feature
index b687db9b8a..4922d776e0 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Unfold.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Unfold.feature
@@ -34,12 +34,11 @@ Feature: Step - unfold()
       | e[josh-created->lop] |
       | e[peter-created->lop] |
 
-  Scenario: g_V_valueMap_unfold_mapXkeyX
+  Scenario: g_V_valueMap_unfold_mapXselectXkeysXX
     Given the modern graph
-    And using the parameter l1 defined as "c[it.get().getKey()]"
     And the traversal of
       """
-      g.V().valueMap().unfold().map(l1)
+      g.V().valueMap().unfold().map(__.select(keys))
       """
     When iterated to list
     Then the result should be unordered
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Group.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Group.feature
index c5ceee16b9..f31fdd51fc 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Group.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Group.feature
@@ -115,12 +115,11 @@ Feature: Step - group()
       | result |
       | m[{"original":"d[771317].l", "":"d[160968].l", "cover":"d[368579].l"}] |
 
-  Scenario: g_V_group_byXname_substring_1X_byXconstantX1XX
+  Scenario: g_V_group_byXvaluesXnameX_substringX1XX_byXconstantX1XX
     Given the modern graph
-    And using the parameter l1 defined as "c[it.value('name').substring(0, 1)]"
     And the traversal of
       """
-      g.V().group().by(l1).by(__.constant(1))
+      g.V().group().by(__.values("name").substring(0,1)).by(__.constant(1))
       """
     When iterated to list
     Then the result should be unordered
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Inject.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Inject.feature
index 762f9cff5d..036b828743 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Inject.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Inject.feature
@@ -39,10 +39,9 @@ Feature: Step - inject()
   Scenario: g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path
     Given the modern graph
     And using the parameter vid1 defined as "v[marko].id"
-    And using the parameter l1 defined as "c[it.get().length()]"
     And the traversal of
       """
-      g.V(vid1).out().values("name").inject("daniel").as("a").map(l1).path()
+      g.V(vid1).out().values("name").inject("daniel").as("a").map(__.length()).path()
       """
     When iterated to list
     Then the result should be unordered
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Sack.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Sack.feature
index 4dbd8ea63c..315b8f9cca 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Sack.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Sack.feature
@@ -125,14 +125,6 @@ Feature: Step - sack()
       | d[0.5].m |
       | d[0.5].m |
 
-  Scenario: g_withSackXmap__map_cloneX_V_out_out_sackXmap_a_nameX_sack
-    Given an unsupported test
-    Then nothing should happen because
-      """
-      This test is bound pretty tightly to the JVM in that it requires a UnaryOperator cast to get the right
-      withSack() method called. Not sure how that would work with a GLV.
-      """
-
   Scenario: g_withSackX2X_V_sackXdivX_byXconstantX4_0XX_sack
     Given the modern graph
     And using the parameter xx1 defined as "d[4.0].d"
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/SideEffect.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/SideEffect.feature
new file mode 100644
index 0000000000..d68a4d35ca
--- /dev/null
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/SideEffect.feature
@@ -0,0 +1,93 @@
+# 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.
+
+@StepClassSideEffect @StepSideEffect
+Feature: Step - sideEffect()
+
+  Scenario: g_V_sideEffectXidentityX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().sideEffect(__.identity())
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | v[marko] |
+      | v[vadas] |
+      | v[lop] |
+      | v[josh] |
+      | v[ripple] |
+      | v[peter] |
+
+  Scenario: g_V_sideEffectXidentity_valuesXnameXX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().sideEffect(__.identity().values("name"))
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | v[marko] |
+      | v[vadas] |
+      | v[lop] |
+      | v[josh] |
+      | v[ripple] |
+      | v[peter] |
+
+  Scenario: g_V_sideEffectXpropertyXage_22X
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").property("age",21)
+      """
+    And the traversal of
+      """
+      g.V().sideEffect(__.property("age",22))
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 0 for count of "g.V().has(\"age\",21)"
+    And the graph should return 1 for count of "g.V().has(\"age\",22)"
+
+  Scenario: g_V_group_byXvaluesXnameX_sideEffectXconstantXzyxXX_substringX1XX_byXconstantX1X_sideEffectXconstantXxyzXXX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().group().by(__.values("name").sideEffect(__.constant("zyx")).substring(0,1)).by(__.constant(1).sideEffect(__.constant("xyz")))
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | m[{"p":"d[1].i", "r":"d[1].i", "v":"d[1].i", "j":"d[1].i", "l":"d[1].i", "m":"d[1].i"}] |
+
+  Scenario: g_withSideEffectXx_setX_V_both_both_sideEffectXstoreXxX_byXnameXX_capXxX_unfold
+    Given the modern graph
+    And the traversal of
+      """
+      g.withSideEffect("x",{}).V().both().both().sideEffect(__.store("x").by("name")).cap("x").unfold()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | marko |
+      | vadas |
+      | lop |
+      | josh |
+      | ripple |
+      | peter |
\ No newline at end of file
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/SideEffectCap.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/SideEffectCap.feature
index ab3858826c..99f5c37698 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/SideEffectCap.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/SideEffectCap.feature
@@ -97,12 +97,11 @@ Feature: Step - cap()
       | result |
       | m[{"original":"d[771317].l", "":"d[160968].l", "cover":"d[368579].l"}] |
 
-  Scenario: g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX
+  Scenario: g_V_groupXaX_byXvaluesXnameX_substringX1XX_byXconstantX1XX_capXaX
     Given the modern graph
-    And using the parameter l1 defined as "c[it.value('name').substring(0, 1)]"
     And the traversal of
       """
-      g.V().group("a").by(l1).by(__.constant(1)).cap("a")
+      g.V().group("a").by(__.values("name").substring(0,1)).by(__.constant(1)).cap("a")
       """
     When iterated to list
     Then the result should be unordered
@@ -153,12 +152,17 @@ Feature: Step - cap()
       | result |
       | m[{"software":"d[2].l", "person":"d[4].l"}] |
 
-  Scenario: g_V_chooseXlabel_person__age_groupCountXaX__name_groupCountXbXX_capXa_bX
-    Given an unsupported test
-    Then nothing should happen because
+  Scenario: g_V_chooseXlabel_person__age_groupCountXaX__name_groupCountXbXX_capXa_bX_unfold
+    Given the modern graph
+    And the traversal of
       """
-      The result is [a:[32:1,35:1,27:1,29:1],b:[ripple:1,lop:1]] which is not supported by this test suite
+      g.V().choose(has(T.label, "person"),values("age").groupCount("a"), values("name").groupCount("b")).cap("a", "b").unfold()
       """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | m[{"a":"m[{\"d[32].i\":\"d[1].l\",\"d[35].i\":\"d[1].l\",\"d[27].i\":\"d[1].l\",\"d[29].i\":\"d[1].l\"}]"}] |
+      | m[{"b":"m[{\"ripple\":\"d[1].l\",\"lop\":\"d[1].l\"}]"}] |
 
   # validates that a collecting barrier produces a filtering effect if it is unproductive.
   Scenario: g_V_hasXperson_name_withinXvadas_peterXX_groupXaX_by_byXout_orderX_capXaX
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/io/graphson/AbstractTinkerGraphGraphSONTranslatorProvider.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/io/graphson/AbstractTinkerGraphGraphSONTranslatorProvider.java
index bb9513b8a2..ab3041111e 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/io/graphson/AbstractTinkerGraphGraphSONTranslatorProvider.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/io/graphson/AbstractTinkerGraphGraphSONTranslatorProvider.java
@@ -16,7 +16,6 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-
 package org.apache.tinkerpop.gremlin.tinkergraph.structure.io.graphson;
 
 import org.apache.tinkerpop.gremlin.GraphProvider;
@@ -37,93 +36,13 @@ import org.apache.tinkerpop.gremlin.tinkergraph.process.computer.TinkerGraphComp
         method = "*",
         reason = "Tests for profile() are not supported for remotes")
 @Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.BranchTest",
-        method = "g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.ChooseTest",
-        method = "g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name",
+        test = "org.apache.tinkerpop.gremlin.process.traversal.step.LambdaStepTest",
+        method = "*",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.DedupTest",
         method = "g_V_both_name_order_byXa_bX_dedup_value",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_E_filterXfalseX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_E_filterXtrueX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXfalseX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXlang_eq_javaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXname_startsWith_m_OR_name_startsWith_pX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXtrueX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX1X_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX1X_out_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX2X_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest",
-        method = "g_V_group_byXname_substring_1X_byXconstantX1XX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest",
-        method = "g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasTest",
-        method = "g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectTest",
-        method = "g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_mapXnameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_out_mapXnameX_mapXlengthX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_outE_label_mapXlengthX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_withPath_V_asXaX_out_mapXa_nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_withPath_V_asXaX_out_out_mapXa_name_it_nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
-        method = "g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
         method = "g_V_name_order_byXa1_b1X_byXb2_a2X",
@@ -132,46 +51,10 @@ import org.apache.tinkerpop.gremlin.tinkergraph.process.computer.TinkerGraphComp
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
         method = "g_V_order_byXname_a1_b1X_byXname_b2_a2X_name",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
-        method = "g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.RepeatTest",
-        method = "g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SackTest",
         method = "g_withSackXmap__map_cloneX_V_out_out_sackXmap_a_nameX_sack",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_out_sideEffectXincr_cX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_out_sideEffectXX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_sideEffectXstore_aX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest",
         method = "g_V_withSideEffectXsgX_outEXknowsX_subgraphXsgX_name_capXsgX",
@@ -184,10 +67,6 @@ import org.apache.tinkerpop.gremlin.tinkergraph.process.computer.TinkerGraphComp
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest",
         method = "g_withSideEffectXsgX_V_hasXname_danielXout_capXsgX",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.UnfoldTest",
-        method = "g_V_valueMap_unfold_mapXkeyX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.ProgramTest",
         method = "*",
@@ -221,13 +100,9 @@ import org.apache.tinkerpop.gremlin.tinkergraph.process.computer.TinkerGraphComp
         method = "*",
         reason = "read and write tests don't translate locally well because of calling iterate() inside read()/write() add a none()")
 @Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.StoreTest",
-        method = "g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX",
-        reason = "This test returns BulkSet which isn't supported in GraphSON 3.0 until 3.4.0.")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.AggregateTest",
-        method = "g_withSideEffectXa_setX_V_both_name_aggregateXlocal_aX_capXaX",
-        reason = "This test returns BulkSet which isn't supported in GraphSON 3.0 until 3.4.0.")
+        test = "org.apache.tinkerpop.gremlin.process.traversal.step.OrderabilityTest",
+        method = "g_inject_order_with_unknown_type",
+        reason = "Remoting serializers only support known Gremlin types")
 public abstract class AbstractTinkerGraphGraphSONTranslatorProvider extends TinkerGraphProvider {
 
     private final GraphSONVersion version;
@@ -250,6 +125,18 @@ public abstract class AbstractTinkerGraphGraphSONTranslatorProvider extends Tink
             test = "org.apache.tinkerpop.gremlin.process.traversal.step.OrderabilityTest",
             method = "g_inject_order_with_unknown_type",
             reason = "Remoting serializers only support known Gremlin types")
+    @Graph.OptOut(
+            test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.StoreTest",
+            method = "g_withSideEffectXa_setX_V_both_name_storeXaX_capXaX",
+            reason = "GraphSONv2 does not properly round trip Maps and Sets")
+    @Graph.OptOut(
+            test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
+            method = "g_withSideEffectXx_setX_V_both_both_sideEffectXstoreXxX_byXnameXX_capXxX_unfold",
+            reason = "GraphSONv2 does not properly round trip Maps and Sets")
+    @Graph.OptOut(
+            test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.AggregateTest",
+            method = "g_withSideEffectXa_setX_V_both_name_aggregateXlocal_aX_capXaX",
+            reason = "GraphSONv2 does not properly round trip Maps and Sets")
     @Graph.OptOut(
             test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MergeEdgeTest",
             method = "*",
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/io/gryo/TinkerGraphGryoTranslatorProvider.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/io/gryo/TinkerGraphGryoTranslatorProvider.java
index 9b9b19a6b6..e1b4922aae 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/io/gryo/TinkerGraphGryoTranslatorProvider.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/io/gryo/TinkerGraphGryoTranslatorProvider.java
@@ -16,7 +16,6 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-
 package org.apache.tinkerpop.gremlin.tinkergraph.structure.io.gryo;
 
 import org.apache.tinkerpop.gremlin.jsr223.JavaTranslator;
@@ -33,93 +32,13 @@ import org.apache.tinkerpop.gremlin.tinkergraph.TinkerGraphProvider;
         method = "*",
         reason = "Tests for profile() are not supported for remotes")
 @Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.BranchTest",
-        method = "g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.ChooseTest",
-        method = "g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name",
+        test = "org.apache.tinkerpop.gremlin.process.traversal.step.LambdaStepTest",
+        method = "*",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.DedupTest",
         method = "g_V_both_name_order_byXa_bX_dedup_value",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_E_filterXfalseX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_E_filterXtrueX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXfalseX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXlang_eq_javaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXname_startsWith_m_OR_name_startsWith_pX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_V_filterXtrueX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX1X_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX1X_out_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest",
-        method = "g_VX2X_filterXage_gt_30X",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest",
-        method = "g_V_group_byXname_substring_1X_byXconstantX1XX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest",
-        method = "g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasTest",
-        method = "g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectTest",
-        method = "g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_mapXnameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_out_mapXnameX_mapXlengthX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_VX1X_outE_label_mapXlengthX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_withPath_V_asXaX_out_mapXa_nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest",
-        method = "g_withPath_V_asXaX_out_out_mapXa_name_it_nameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
-        method = "g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
         method = "g_V_name_order_byXa1_b1X_byXb2_a2X",
@@ -128,46 +47,10 @@ import org.apache.tinkerpop.gremlin.tinkergraph.TinkerGraphProvider;
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
         method = "g_V_order_byXname_a1_b1X_byXname_b2_a2X_name",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest",
-        method = "g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.branch.RepeatTest",
-        method = "g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SackTest",
         method = "g_withSackXmap__map_cloneX_V_out_out_sackXmap_a_nameX_sack",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_out_sideEffectXincr_cX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_out_sideEffectXX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_VX1X_sideEffectXstore_aX_name",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectsXa__linkedhashmapX_withSideEffectXb__arraylist__addAllX_withSideEffectXc__arrayList__addAllX_V_groupXaX_byXlabelX_byXcountX_sideEffectXb__1_2_3X_out_out_out_sideEffectXc__bob_danielX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa_0X_V_out_sideEffectXsideEffectsXa_1XX_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest",
-        method = "g_withSideEffectXa__linkedhashmapX_V_out_groupCountXaX_byXlabelX_out_out_capXaX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest",
         method = "g_V_withSideEffectXsgX_outEXknowsX_subgraphXsgX_name_capXsgX",
@@ -180,10 +63,6 @@ import org.apache.tinkerpop.gremlin.tinkergraph.TinkerGraphProvider;
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest",
         method = "g_withSideEffectXsgX_V_hasXname_danielXout_capXsgX",
         reason = "Tests that include lambdas are not supported by the test suite for remotes")
-@Graph.OptOut(
-        test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.UnfoldTest",
-        method = "g_V_valueMap_unfold_mapXkeyX",
-        reason = "Tests that include lambdas are not supported by the test suite for remotes")
 @Graph.OptOut(
         test = "org.apache.tinkerpop.gremlin.process.traversal.step.map.ProgramTest",
         method = "*",


(tinkerpop) 08/11: Added tree() tests to gherkin. Added prettyPrint() to Tree.

Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 86095666814ac2fa397e77f5653a85dddbae8469
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Thu Apr 17 15:27:52 2025 -0400

    Added tree() tests to gherkin. Added prettyPrint() to Tree.
---
 CHANGELOG.asciidoc                                 |   1 +
 docs/src/dev/developer/for-committers.asciidoc     |  56 +++++-
 .../gremlin/process/traversal/step/util/Tree.java  |  18 ++
 .../process/traversal/step/util/TreeTest.java      |  46 +++++
 .../Gherkin/CommonSteps.cs                         |  15 +-
 .../Gherkin/GherkinTestRunner.cs                   |  37 ++--
 .../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs |  11 ++
 .../Gherkin/IgnoreException.cs                     |   8 +-
 gremlin-go/driver/cucumber/cucumberSteps_test.go   |  42 ++---
 gremlin-go/driver/cucumber/gremlin.go              |  11 ++
 .../test/cucumber/feature-steps.js                 |  19 +-
 .../gremlin-javascript/test/cucumber/gremlin.js    |  11 ++
 .../gremlin/language/corpus/FeatureReader.java     |   2 +-
 .../src/main/python/radish/feature_steps.py        |   6 +-
 gremlin-python/src/main/python/radish/gremlin.py   |  11 ++
 .../tinkerpop/gremlin/features/StepDefinition.java | 175 +++++++++++++----
 .../process/ProcessEmbeddedComputerSuite.java      |   2 -
 .../process/ProcessEmbeddedStandardSuite.java      |   2 -
 .../test/features/sideEffect/Subgraph.feature      |  26 ++-
 .../gremlin/test/features/sideEffect/Tree.feature  | 208 +++++++++++++++++++++
 20 files changed, 596 insertions(+), 111 deletions(-)

diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index c42edb1fde..dbe618cb0b 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -39,6 +39,7 @@ This release also includes changes from <<release-3-7-XXX, 3.7.XXX>>.
 * Modified the Gremlin ANTLR grammar to more dynamically interact with any strategies registered globally to the `TraversalStrategies` cache sets.
 * Made `new` keyword optional in the Gremlin grammar.
 * Allowed keywords to be used as `Map` keys when defined using the shorthand without quotes.
+* Added `prettyPrint()` method to `Tree` to produce a formatted string representation of the tree structure.
 * Added integer overflow checks.
 * Added missing strategies to the `TraversalStrategies` global cache as well as `CoreImports` in `gremlin-groovy`.
 * Added missing strategies to `strategies.py` in `gremlin-python`.
diff --git a/docs/src/dev/developer/for-committers.asciidoc b/docs/src/dev/developer/for-committers.asciidoc
index 067b7ae98d..1a29db9f25 100644
--- a/docs/src/dev/developer/for-committers.asciidoc
+++ b/docs/src/dev/developer/for-committers.asciidoc
@@ -502,12 +502,14 @@ of traversal iteration where "_comparison_" may be one of "containing", "startin
 * "the result should be unordered" - the exact results but can appear any order
 * "the result should be of" - results can be any of the specified values and in any order (use when guarantees
 regarding the exact results cannot be pre-determined easily - see the `range()`-step tests for examples)
-* "the result should be a graph with _xxx_" - asserts a subgraph where the _xxx_ may be "vertices" or "edges" with a
-follow-on table containing vertex or edge definitions respectively that are expected to exist in the subgraph
+* "the result should be a graph with the following" - asserts a subgraph where the associated datatable is headed with
+"vertices" or "edges" with a set of expected vertex or edge definitions
+* "the result should be a tree with a structure of" - asserts a tree structure given as an asciiart representation of
+the expected tree.
 
-These final three types of assertions mentioned above should be followed by a Gherkin table that has one column, where
-each row value in that column represents a value to assert in the result. These values are type notation respected as
-shown in the following example:
+For "the result should be ordered/unordered/of" types of assertions mentioned above should be followed by a Gherkin
+table that has one column, where each row value in that column represents a value to assert in the result. These values
+are type notation respected as shown in the following example:
 
 [source,gherkin]
 ----
@@ -520,6 +522,50 @@ Then the result should be unordered
   | josh  |
 ----
 
+For "the result should be a graph with the following", the assertion looks like this:
+
+[source,gherkin]
+----
+When iterated next
+Then the result should be a subgraph with the following
+  | edges |
+  | e[marko-created->lop] |
+  | e[josh-created->lop] |
+  | e[josh-created->ripple] |
+  | e[peter-created->lop] |
+And the result should be a subgraph with the following
+  | vertices |
+  | v[marko] |
+  | v[lop] |
+  | v[josh] |
+  | v[peter] |
+  | v[ripple] |
+----
+
+Note the use of "When iterated next" to get the subgraph assigned directly as the result. To properly do the assertion
+of the graph, a line should be present for vertices and edges. While other objects can be parsed here, none
+particularly make sense, so it is important to just stick to the appropriate types in defining the assertions.
+
+For the result should be a tree with a structure of" the assertion looks like this:
+
+[source,gherkin]
+----
+When iterated next
+Then the result should be a tree with a structure of
+"""
+|--d[32].i
+|--d[35].i
+|--d[29].i
+   |--d[32].i
+   |--d[27].i
+"""
+----
+
+The indent spacing is critical in ensuring the tree is parsed by the test frameworks properly and should consist of 3
+spaces. Like the subgraph example, note the use of "When iterated next" to ensure the `Tree` itself is assigned to the
+result that is being asserted. Unlike the subgraph rules, any object can be used to designate a node. The example above
+used integers, but any of the allowed types should work.
+
 Another method of assertion is to test mutations in the original graph. Again, mutations should only occur on the
 "empty" graph, but they can be validated as follows:
 
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/Tree.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/Tree.java
index 7eb6673329..62dc3794a7 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/Tree.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/Tree.java
@@ -136,4 +136,22 @@ public class Tree<T> extends HashMap<T, Tree<T>> implements Serializable {
             return parents;
         }
     }
+
+    /**
+     * Produce a formatted string representation of the tree structure.
+     */
+    public String prettyPrint() {
+        final StringBuilder builder = new StringBuilder();
+        prettyPrint(builder, "");
+        final String pretty = builder.toString();
+        return pretty.isEmpty() ? pretty : pretty.substring(0, pretty.length() - 1);
+    }
+
+    private void prettyPrint(final StringBuilder builder, final String prefix) {
+        for (Map.Entry<T, Tree<T>> entry : this.entrySet()) {
+            builder.append(prefix).append("|--").append(entry.getKey());
+            builder.append(System.lineSeparator());
+            entry.getValue().prettyPrint(builder, prefix + "   ");
+        }
+    }
 }
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TreeTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TreeTest.java
index 03a2740251..180d0e3612 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TreeTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TreeTest.java
@@ -21,6 +21,7 @@ package org.apache.tinkerpop.gremlin.process.traversal.step.util;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
 import org.apache.tinkerpop.gremlin.process.traversal.step.StepTest;
+import org.hamcrest.Matchers;
 import org.junit.Test;
 
 import java.util.AbstractMap;
@@ -28,6 +29,7 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
@@ -97,6 +99,50 @@ public class TreeTest extends StepTest {
         assertTrue(mergeTree.getObjectsAtDepth(3).contains("1_2_2"));
     }
 
+    @Test
+    public void testPrettyPrintSingleNode() {
+        final Tree<String> tree = new Tree<>();
+        tree.put("root", new Tree<>());
+
+        final String expected = "|--root";
+        assertEquals(expected, tree.prettyPrint());
+    }
+
+    @Test
+    public void testPrettyPrintMultipleNodes() {
+        final Tree<String> tree = new Tree<>();
+        final Tree<String> child1 = new Tree<>();
+        final Tree<String> child2 = new Tree<>();
+        tree.put("root", new Tree<>());
+        tree.get("root").put("child1", child1);
+        tree.get("root").put("child2", child2);
+
+        // either can be expected since Tree doesn't maintain node order
+        final String expected1 = "|--root\n   |--child1\n   |--child2";
+        final String expected2 = "|--root\n   |--child2\n   |--child1";
+        assertThat(tree.prettyPrint(), Matchers.anyOf(Matchers.is(expected1), Matchers.is(expected2)));
+    }
+
+    @Test
+    public void testPrettyPrintNestedTree() {
+        final Tree<String> tree = new Tree<>();
+        final Tree<String> child1 = new Tree<>();
+        final Tree<String> grandchild = new Tree<>();
+        tree.put("root", new Tree<>());
+        tree.get("root").put("child1", child1);
+        tree.get("root").get("child1").put("grandchild", grandchild);
+
+        final String expected = "|--root\n   |--child1\n      |--grandchild";
+        assertEquals(expected, tree.prettyPrint());
+    }
+
+    @Test
+    public void testPrettyPrintEmptyTree() {
+        final Tree<String> tree = new Tree<>();
+        final String expected = "";
+        assertEquals(expected, tree.prettyPrint());
+    }
+
     private static <T> Map.Entry<T, Tree<T>> createTree(T key, Tree<T> tree) {
         return new AbstractMap.SimpleEntry<>(key, tree);
     }
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/CommonSteps.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/CommonSteps.cs
index cbf5c49120..0de6b3723f 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/CommonSteps.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/CommonSteps.cs
@@ -245,7 +245,20 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
             _error = null;
         }
 
-        [Then("the result should be (\\w+)")]
+
+        [Then("the result should be a tree with a structure of")]
+        public void AssertTreeStructure(string expectedTree)
+        {
+
+        }
+
+        [Then("the result should be a subgraph with the following")]
+        public void AssertSubgraphStructure(DataTable? table = null)
+        {
+
+        }
+
+        [Then("the result should be (\\w+)\\s*")]
         public void AssertResult(string characterizedAs, DataTable? table = null)
         {
             AssertThatNoErrorWasThrown();
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
index 20272e626b..2efac3e2a8 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
@@ -54,31 +54,6 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                 {"g_withStrategiesXProductiveByStrategyX_V_groupCount_byXageX", IgnoreReason.NullKeysInMapNotSupported},
                 {"g_withoutStrategiesXCountStrategyX_V_count", IgnoreReason.NoReason}, // needs investigation
                 {"g_withoutStrategiesXLazyBarrierStrategyX_V_asXlabelX_aggregateXlocal_xX_selectXxX_selectXlabelX", IgnoreReason.NoReason},
-                {"g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name", IgnoreReason.LambdasNotTranslated},
-                {"g_V_filterXfalseX", IgnoreReason.LambdasNotTranslated},
-                {"g_V_filterXtrueX", IgnoreReason.LambdasNotTranslated},
-                {"g_V_filterXlang_eq_javaX", IgnoreReason.LambdasNotTranslated},
-                {"g_VX1X_filterXage_gt_30X", IgnoreReason.LambdasNotTranslated},
-                {"g_VX2X_filterXage_gt_30X", IgnoreReason.LambdasNotTranslated},
-                {"g_VX1X_out_filterXage_gt_30X", IgnoreReason.LambdasNotTranslated},
-                {"g_V_filterXname_startsWith_m_OR_name_startsWith_pX", IgnoreReason.LambdasNotTranslated},
-                {"g_E_filterXfalseX", IgnoreReason.LambdasNotTranslated},
-                {"g_E_filterXtrueX", IgnoreReason.LambdasNotTranslated},
-                {"g_VX1X_mapXnameX", IgnoreReason.LambdasNotTranslated},
-                {"g_VX1X_outE_label_mapXlengthX", IgnoreReason.LambdasNotTranslated},
-                {"g_VX1X_out_mapXnameX_mapXlengthX", IgnoreReason.LambdasNotTranslated},
-                {"g_VX1X_out_mapXlambdaXnameXX_mapXlambdaXlengthXX", IgnoreReason.LambdasNotTranslated},
-                {"g_withPath_V_asXaX_out_mapXa_nameX", IgnoreReason.LambdasNotTranslated},
-                {"g_withPath_V_asXaX_out_out_mapXa_name_it_nameX", IgnoreReason.LambdasNotTranslated},
-                {"g_V_valueMap_unfold_mapXkeyX", IgnoreReason.LambdasNotTranslated},
-                {"g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name", IgnoreReason.LambdasNotTranslated},
-                {"g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX", IgnoreReason.LambdasNotTranslated},
-                {"g_V_group_byXname_substring_1X_byXconstantX1XX", IgnoreReason.LambdasNotTranslated},
-                {"g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path", IgnoreReason.LambdasNotTranslated},
-                {"g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX", IgnoreReason.LambdasNotTranslated},
-                {"g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX", IgnoreReason.LambdasNotTranslated},
-                {"g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name", IgnoreReason.LambdasNotTranslated},
-                {"g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX", IgnoreReason.LambdasNotTranslated},
             };
 
         private static class Keywords
@@ -142,6 +117,18 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                         continue;
                     }
 
+                    if (scenario.Tags.Any(t => t.Name == "@StepTree"))
+                    {
+                        failedSteps.Add(scenario.Steps.First(), new IgnoreException(IgnoreReason.TreeStepNotSupported));
+                        continue;
+                    }
+
+                    if (scenario.Tags.Any(t => t.Name == "@StepSubgraph"))
+                    {
+                        failedSteps.Add(scenario.Steps.First(), new IgnoreException(IgnoreReason.SubgraphStepNotSupported));
+                        continue;
+                    }
+
                     // after backport of strategy construction improvements from master, there are now test failures (not currently running GLV tests on master)
                     if (scenario.Name.Contains("withStrategies") || scenario.Name.Contains("withoutStrategies"))
                     {
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
index 0f7523940d..774cd7043c 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
@@ -1673,6 +1673,17 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Store("a").By(__.OutE("created").Count()).Out().Out().Store("a").By(__.InE("created").Values<object>("weight").Sum<object>()).Cap<object>("a")}}, 
                {"g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).OutE("knows").Subgraph("sg").Values<object>("name").Cap<object>("sg")}}, 
                {"g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Repeat(__.BothE("created").Subgraph("sg").OutV()).Times(5).Values<object>("name").Dedup().Cap<object>("sg")}}, 
+               {"g_V_outEXnoexistX_subgraphXsgXcapXsgX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().OutE("noexist").Subgraph("sg").Cap<object>("sg")}}, 
+               {"g_VX1X_out_out_tree_byXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Out().Tree<object>().By("name")}}, 
+               {"g_VX1X_out_out_tree", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Out().Tree<object>()}}, 
+               {"g_V_out_tree_byXageX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Tree<object>().By("age")}}, 
+               {"g_VX1X_out_out_treeXaX_byXnameX_both_both_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Out().Tree("a").By("name").Both().Both().Cap<object>("a")}}, 
+               {"g_VX1X_out_out_treeXaX_both_both_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Out().Tree("a").Both().Both().Cap<object>("a")}}, 
+               {"g_VX1X_out_out_tree_byXlabelX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Out().Tree<object>().By(T.Label)}}, 
+               {"g_VX1X_out_out_treeXaX_byXlabelX_both_both_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).Out().Out().Tree("a").By(T.Label).Both().Both().Cap<object>("a")}}, 
+               {"g_VX1X_out_out_out_tree", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Out().Tree<object>()}}, 
+               {"g_VX1X_outE_inV_bothE_otherV_tree", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).OutE().InV().BothE().OtherV().Tree<object>()}}, 
+               {"g_VX1X_outE_inV_bothE_otherV_tree_byXnameX_byXlabelX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"]).OutE().InV().BothE().OtherV().Tree<object>().By("name").By(T.Label)}}, 
             };
 
         public static ITraversal UseTraversal(string scenarioName, GraphTraversalSource g, IDictionary<string, object> parameters)
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs
index 480cf87d93..2ede64847e 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs
@@ -63,13 +63,13 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
         NullPropertyValuesNotSupportedOnTestGraph,
 
         /// <summary>
-        /// Tests with lambdas can't be translated. This should be removed once lambdas are completely dropped.
+        /// subgraph() is not supported yet
         /// </summary>
-        LambdasNotTranslated,
+        SubgraphStepNotSupported,
 
         /// <summary>
-        /// subgraph() is not supported yet
+        /// tree() is not supported yet
         /// </summary>
-        SubgraphStepNotSupported
+        TreeStepNotSupported
     }
 }
\ No newline at end of file
diff --git a/gremlin-go/driver/cucumber/cucumberSteps_test.go b/gremlin-go/driver/cucumber/cucumberSteps_test.go
index c543e038ab..1c90f81e7c 100644
--- a/gremlin-go/driver/cucumber/cucumberSteps_test.go
+++ b/gremlin-go/driver/cucumber/cucumberSteps_test.go
@@ -48,26 +48,26 @@ var parsers map[*regexp.Regexp]func(string, string) interface{}
 
 func init() {
 	parsers = map[*regexp.Regexp]func(string, string) interface{}{
-		regexp.MustCompile(`^str\[(.*)]$`): func(stringVal, graphName string) interface{} { return stringVal }, //returns the string value as is
-		regexp.MustCompile(`^dt\[(.*)]$`):           toDateTime,
-		regexp.MustCompile(`^d\[(.*)]\.[bslfd]$`):	 toNumeric,
-		regexp.MustCompile(`^d\[(.*)]\.[m]$`): 		 toBigDecimal,
-		regexp.MustCompile(`^d\[(.*)]\.[n]$`): 		 toBigInt,
-		regexp.MustCompile(`^d\[(.*)]\.[i]$`):       toInt32,
-		regexp.MustCompile(`^vp\[(.+)]$`):           toVertexProperty,
-		regexp.MustCompile(`^v\[(.+)]$`):            toVertex,
-		regexp.MustCompile(`^v\[(.+)]\.id$`):        toVertexId,
-		regexp.MustCompile(`^e\[(.+)]$`):            toEdge,
-		regexp.MustCompile(`^v\[(.+)]\.sid$`):       toVertexIdString,
-		regexp.MustCompile(`^e\[(.+)]\.id$`):        toEdgeId,
-		regexp.MustCompile(`^e\[(.+)]\.sid$`):       toEdgeIdString,
-		regexp.MustCompile(`^p\[(.+)]$`):            toPath,
-		regexp.MustCompile(`^l\[(.*)]$`):            toList,
-		regexp.MustCompile(`^s\[(.*)]$`):            toSet,
-		regexp.MustCompile(`^m\[(.+)]$`):            toMap,
-		regexp.MustCompile(`^t\[(.+)]$`):            toT,
-		regexp.MustCompile(`^D\[(.+)]$`):            toDirection,
-		regexp.MustCompile(`^M\[(.+)]$`):            toMerge,
+		regexp.MustCompile(`^str\[(.*)]$`):        func(stringVal, graphName string) interface{} { return stringVal }, //returns the string value as is
+		regexp.MustCompile(`^dt\[(.*)]$`):         toDateTime,
+		regexp.MustCompile(`^d\[(.*)]\.[bslfd]$`): toNumeric,
+		regexp.MustCompile(`^d\[(.*)]\.[m]$`):     toBigDecimal,
+		regexp.MustCompile(`^d\[(.*)]\.[n]$`):     toBigInt,
+		regexp.MustCompile(`^d\[(.*)]\.[i]$`):     toInt32,
+		regexp.MustCompile(`^vp\[(.+)]$`):         toVertexProperty,
+		regexp.MustCompile(`^v\[(.+)]$`):          toVertex,
+		regexp.MustCompile(`^v\[(.+)]\.id$`):      toVertexId,
+		regexp.MustCompile(`^e\[(.+)]$`):          toEdge,
+		regexp.MustCompile(`^v\[(.+)]\.sid$`):     toVertexIdString,
+		regexp.MustCompile(`^e\[(.+)]\.id$`):      toEdgeId,
+		regexp.MustCompile(`^e\[(.+)]\.sid$`):     toEdgeIdString,
+		regexp.MustCompile(`^p\[(.+)]$`):          toPath,
+		regexp.MustCompile(`^l\[(.*)]$`):          toList,
+		regexp.MustCompile(`^s\[(.*)]$`):          toSet,
+		regexp.MustCompile(`^m\[(.+)]$`):          toMap,
+		regexp.MustCompile(`^t\[(.+)]$`):          toT,
+		regexp.MustCompile(`^D\[(.+)]$`):          toDirection,
+		regexp.MustCompile(`^M\[(.+)]$`):          toMerge,
 	}
 }
 
@@ -956,7 +956,7 @@ func TestCucumberFeatures(t *testing.T) {
 		TestSuiteInitializer: InitializeTestSuite,
 		ScenarioInitializer:  InitializeScenario,
 		Options: &godog.Options{
-			Tags:     "~@GraphComputerOnly && ~@AllowNullPropertyValues && ~@StepSubgraph",
+			Tags:     "~@GraphComputerOnly && ~@AllowNullPropertyValues && ~@StepSubgraph && ~@StepTree",
 			Format:   "pretty",
 			Paths:    []string{getEnvOrDefaultString("CUCUMBER_FEATURE_FOLDER", "../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features")},
 			TestingT: t, // Testing instance that will run subtests.
diff --git a/gremlin-go/driver/cucumber/gremlin.go b/gremlin-go/driver/cucumber/gremlin.go
index 658a2ca905..b735220754 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -1642,6 +1642,17 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Store("a").By(gremlingo.T__.OutE("created").Count()).Out().Out().Store("a").By(gremlingo.T__.InE("created").Values("weight").Sum()).Cap("a")}}, 
     "g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows").Subgraph("sg").Values("name").Cap("sg")}}, 
     "g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.BothE("created").Subgraph("sg").OutV()).Times(5).Values("name").Dedup().Cap("sg")}}, 
+    "g_V_outEXnoexistX_subgraphXsgXcapXsgX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().OutE("noexist").Subgraph("sg").Cap("sg")}}, 
+    "g_VX1X_out_out_tree_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Out().Tree().By("name")}}, 
+    "g_VX1X_out_out_tree": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Out().Tree()}}, 
+    "g_V_out_tree_byXageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Tree().By("age")}}, 
+    "g_VX1X_out_out_treeXaX_byXnameX_both_both_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Out().Tree("a").By("name").Both().Both().Cap("a")}}, 
+    "g_VX1X_out_out_treeXaX_both_both_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Out().Tree("a").Both().Both().Cap("a")}}, 
+    "g_VX1X_out_out_tree_byXlabelX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Out().Tree().By(gremlingo.T.Label)}}, 
+    "g_VX1X_out_out_treeXaX_byXlabelX_both_both_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Out().Tree("a").By(gremlingo.T.Label).Both().Both().Cap("a")}}, 
+    "g_VX1X_out_out_out_tree": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Out().Tree()}}, 
+    "g_VX1X_outE_inV_bothE_otherV_tree": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE().InV().BothE().OtherV().Tree()}}, 
+    "g_VX1X_outE_inV_bothE_otherV_tree_byXnameX_byXlabelX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE().InV().BothE().OtherV().Tree().By("name").By(gremlingo.T.Label)}}, 
 }
 
    func GetTraversal(scenarioName string, g *gremlingo.GraphTraversalSource, parameters map[string]interface{}) (*gremlingo.GraphTraversal, error) {
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
index 75758c8294..2f88962177 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/feature-steps.js
@@ -74,6 +74,7 @@ const ignoreReason = {
   nullKeysInMapNotSupportedWell: "Javascript does not nicely support 'null' as a key in Map instances",
   floatingPointIssues: "Javascript floating point numbers not working in this case",
   subgraphStepNotSupported: "Javascript does not yet support subgraph()",
+  treeStepNotSupported: "Javascript does not yet support tree()",
   needsFurtherInvestigation: '',
 };
 
@@ -81,6 +82,18 @@ const ignoredScenarios = {
   // javascript doesn't have subgraph() step yet
   'g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX': new IgnoreError(ignoreReason.subgraphStepNotSupported),
   'g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX': new IgnoreError(ignoreReason.subgraphStepNotSupported),
+  'g_V_outEXnoexistX_subgraphXsgXcapXsgX': new IgnoreError(ignoreReason.subgraphStepNotSupported),
+  // javascript doesn't have tree() step yet
+  'g_VX1X_out_out_tree_byXnameX': new IgnoreError(ignoreReason.treeStepNotSupported),
+  'g_VX1X_out_out_tree': new IgnoreError(ignoreReason.treeStepNotSupported),
+  'g_V_out_tree_byXageX': new IgnoreError(ignoreReason.treeStepNotSupported),
+  'g_VX1X_out_out_treeXaX_byXnameX_both_both_capXaX': new IgnoreError(ignoreReason.treeStepNotSupported),
+  'g_VX1X_out_out_treeXaX_both_both_capXaX': new IgnoreError(ignoreReason.treeStepNotSupported),
+  'g_VX1X_out_out_tree_byXlabelX': new IgnoreError(ignoreReason.treeStepNotSupported),
+  'g_VX1X_out_out_treeXaX_byXlabelX_both_both_capXaX': new IgnoreError(ignoreReason.treeStepNotSupported),
+  'g_VX1X_out_out_out_tree': new IgnoreError(ignoreReason.treeStepNotSupported),
+  'g_VX1X_outE_inV_bothE_otherV_tree': new IgnoreError(ignoreReason.treeStepNotSupported),
+  'g_VX1X_outE_inV_bothE_otherV_tree_byXnameX_byXlabelX': new IgnoreError(ignoreReason.treeStepNotSupported),
   // An associative array containing the scenario name as key, for example:
   'g_withStrategiesXProductiveByStrategyX_V_groupCount_byXageX': new IgnoreError(ignoreReason.nullKeysInMapNotSupportedWell),
   'g_withoutStrategiesXCountStrategyX_V_count': new IgnoreError(ignoreReason.classNotSupported),
@@ -283,12 +296,12 @@ Then(/^the result should be (\w+)$/, function assertResult(characterizedAs, resu
   }
 });
 
-Then('the result should be a subgraph with edges', _ => {
+Then('the result should be a subgraph with the following', _ => {
   // subgraph is not supported yet in javascript
 });
 
-Then('the result should be a subgraph with vertices', _ => {
-  // subgraph is not supported yet in javascript
+Then('the result should be a tree with a structure of', _ => {
+  // tree is not supported yet in javascript
 });
 
 Then(/^the graph should return (\d+) for count of "(.+)"$/, function (stringCount, traversalText) {
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
index 993257eee6..cdd0e5023e 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
@@ -1663,6 +1663,17 @@ const gremlins = {
     g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX: [function({g}) { return g.V().store("a").by(__.outE("created").count()).out().out().store("a").by(__.inE("created").values("weight").sum()).cap("a") }], 
     g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX: [function({g, vid1}) { return g.V(vid1).outE("knows").subgraph("sg").values("name").cap("sg") }], 
     g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX: [function({g}) { return g.V().repeat(__.bothE("created").subgraph("sg").outV()).times(5).values("name").dedup().cap("sg") }], 
+    g_V_outEXnoexistX_subgraphXsgXcapXsgX: [function({g}) { return g.V().outE("noexist").subgraph("sg").cap("sg") }], 
+    g_VX1X_out_out_tree_byXnameX: [function({g, vid1}) { return g.V(vid1).out().out().tree().by("name") }], 
+    g_VX1X_out_out_tree: [function({g, vid1}) { return g.V(vid1).out().out().tree() }], 
+    g_V_out_tree_byXageX: [function({g}) { return g.V().out().tree().by("age") }], 
+    g_VX1X_out_out_treeXaX_byXnameX_both_both_capXaX: [function({g, vid1}) { return g.V(vid1).out().out().tree("a").by("name").both().both().cap("a") }], 
+    g_VX1X_out_out_treeXaX_both_both_capXaX: [function({g, vid1}) { return g.V(vid1).out().out().tree("a").both().both().cap("a") }], 
+    g_VX1X_out_out_tree_byXlabelX: [function({g, vid1}) { return g.V(vid1).out().out().tree().by(T.label) }], 
+    g_VX1X_out_out_treeXaX_byXlabelX_both_both_capXaX: [function({g, vid1}) { return g.V(vid1).out().out().tree("a").by(T.label).both().both().cap("a") }], 
+    g_VX1X_out_out_out_tree: [function({g}) { return g.V().out().out().out().tree() }], 
+    g_VX1X_outE_inV_bothE_otherV_tree: [function({g, vid1}) { return g.V(vid1).outE().inV().bothE().otherV().tree() }], 
+    g_VX1X_outE_inV_bothE_otherV_tree_byXnameX_byXlabelX: [function({g, vid1}) { return g.V(vid1).outE().inV().bothE().otherV().tree().by("name").by(T.label) }], 
 }
 
 exports.gremlin = gremlins
diff --git a/gremlin-language/src/main/java/org/apache/tinkerpop/gremlin/language/corpus/FeatureReader.java b/gremlin-language/src/main/java/org/apache/tinkerpop/gremlin/language/corpus/FeatureReader.java
index abd11e46d5..6161395255 100644
--- a/gremlin-language/src/main/java/org/apache/tinkerpop/gremlin/language/corpus/FeatureReader.java
+++ b/gremlin-language/src/main/java/org/apache/tinkerpop/gremlin/language/corpus/FeatureReader.java
@@ -113,7 +113,7 @@ public class FeatureReader {
                                 } else {
                                     throw new IllegalStateException(String.format("Could not read parameters at: %s", cleanLine));
                                 }
-                            } else if (cleanLine.startsWith("Then nothing should happen because")) {
+                            } else if (cleanLine.contains("nothing should happen because") || cleanLine.contains("the result should be a tree with a structure of")) {
                                 skipIgnored = true;
                             } else if (cleanLine.startsWith("And the graph should return")) {
                                 gremlins.computeIfAbsent(scenarioName, k -> new ArrayList<>()).add(applyParametersToGremlin(StringEscapeUtils.unescapeJava(cleanLine.substring(cleanLine.indexOf("\"") + 1, cleanLine.lastIndexOf("\""))), parameters));
diff --git a/gremlin-python/src/main/python/radish/feature_steps.py b/gremlin-python/src/main/python/radish/feature_steps.py
index 75659da2e7..55ed9137b1 100644
--- a/gremlin-python/src/main/python/radish/feature_steps.py
+++ b/gremlin-python/src/main/python/radish/feature_steps.py
@@ -36,8 +36,6 @@ project = __.project
 tail = __.tail
 
 ignores = [
-    "g.V(vid1).outE(\"knows\").subgraph(\"sg\").values(\"name\").cap(\"sg\")",
-    "g.V().repeat(__.bothE(\"created\").subgraph(\"sg\").outV()).times(5).values(\"name\").dedup().cap(\"sg\")",
     "g.V().choose(has(T.label, \"person\"),values(\"age\").groupCount(\"a\"), values(\"name\").groupCount(\"b\")).cap(\"a\", \"b\").unfold()", # uses embedded Map in assertion
     "g.withSideEffect(\"x\",{}).V().both().both().sideEffect(__.store(\"x\").by(\"name\")).cap(\"x\").unfold()", # Objects must be both of Map or Collection: a=LinkedHashMap b=BulkSet???
     "g.withoutStrategies(CountStrategy).V().count()" # serialization issues with Class in GraphSON
@@ -53,6 +51,10 @@ def choose_graph(step, graph_name):
     tagset = [tag.name for tag in step.all_tags]
     if not step.context.ignore:
         step.context.ignore = "AllowNullPropertyValues" in tagset
+    if not step.context.ignore:
+        step.context.ignore = "StepSubgraph" in tagset
+    if not step.context.ignore:
+        step.context.ignore = "StepTree" in tagset
 
     if (step.context.ignore):
         return
diff --git a/gremlin-python/src/main/python/radish/gremlin.py b/gremlin-python/src/main/python/radish/gremlin.py
index b9ba790cec..4985d650bc 100644
--- a/gremlin-python/src/main/python/radish/gremlin.py
+++ b/gremlin-python/src/main/python/radish/gremlin.py
@@ -1645,4 +1645,15 @@ world.gremlins = {
     'g_V_storeXaX_byXoutEXcreatedX_countX_out_out_storeXaX_byXinEXcreatedX_weight_sumX': [(lambda g:g.V().store('a').by(__.out_e('created').count()).out().out().store('a').by(__.in_e('created').values('weight').sum_()).cap('a'))], 
     'g_VX1X_outEXknowsX_subgraphXsgX_name_capXsgX': [(lambda g, vid1=None:g.V(vid1).out_e('knows').subgraph('sg').values('name').cap('sg'))], 
     'g_V_repeatXbothEXcreatedX_subgraphXsgX_outVX_timesX5X_name_dedup_capXsgX': [(lambda g:g.V().repeat(__.both_e('created').subgraph('sg').out_v()).times(5).values('name').dedup().cap('sg'))], 
+    'g_V_outEXnoexistX_subgraphXsgXcapXsgX': [(lambda g:g.V().out_e('noexist').subgraph('sg').cap('sg'))], 
+    'g_VX1X_out_out_tree_byXnameX': [(lambda g, vid1=None:g.V(vid1).out().out().tree().by('name'))], 
+    'g_VX1X_out_out_tree': [(lambda g, vid1=None:g.V(vid1).out().out().tree())], 
+    'g_V_out_tree_byXageX': [(lambda g:g.V().out().tree().by('age'))], 
+    'g_VX1X_out_out_treeXaX_byXnameX_both_both_capXaX': [(lambda g, vid1=None:g.V(vid1).out().out().tree('a').by('name').both().both().cap('a'))], 
+    'g_VX1X_out_out_treeXaX_both_both_capXaX': [(lambda g, vid1=None:g.V(vid1).out().out().tree('a').both().both().cap('a'))], 
+    'g_VX1X_out_out_tree_byXlabelX': [(lambda g, vid1=None:g.V(vid1).out().out().tree().by(T.label))], 
+    'g_VX1X_out_out_treeXaX_byXlabelX_both_both_capXaX': [(lambda g, vid1=None:g.V(vid1).out().out().tree('a').by(T.label).both().both().cap('a'))], 
+    'g_VX1X_out_out_out_tree': [(lambda g:g.V().out().out().out().tree())], 
+    'g_VX1X_outE_inV_bothE_otherV_tree': [(lambda g, vid1=None:g.V(vid1).out_e().in_v().both_e().other_v().tree())], 
+    'g_VX1X_outE_inV_bothE_otherV_tree_byXnameX_byXlabelX': [(lambda g, vid1=None:g.V(vid1).out_e().in_v().both_e().other_v().tree().by('name').by(T.label))], 
 }
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
index 9eeff82abc..3feb406efc 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
@@ -41,6 +41,7 @@ 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.util.ImmutablePath;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
 import org.apache.tinkerpop.gremlin.structure.Direction;
 import org.apache.tinkerpop.gremlin.structure.Edge;
 import org.apache.tinkerpop.gremlin.structure.Graph;
@@ -51,6 +52,7 @@ import org.apache.tinkerpop.gremlin.util.DatetimeHelper;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 import org.apache.tinkerpop.shaded.jackson.databind.JsonNode;
 import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
+import org.hamcrest.CoreMatchers;
 import org.hamcrest.collection.IsIterableContainingInAnyOrder;
 import org.hamcrest.collection.IsIterableContainingInOrder;
 import org.hamcrest.core.IsEqual;
@@ -76,6 +78,7 @@ import static org.junit.Assert.fail;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -85,6 +88,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.Stack;
 import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -379,7 +383,7 @@ public final class StepDefinition {
             fail(String.format("Missing an assert for this type", result.getClass()));
     }
 
-    @Then("the result should be a subgraph with edges")
+    @Then("the result should be a subgraph with the following")
     public void theResultShouldBeASubgraphWithEdges(final DataTable dataTable) {
         assertThatNoErrorWasThrown();
 
@@ -389,53 +393,78 @@ public final class StepDefinition {
         // pop a graph traversal source from what was returned so we can use it for assertions
         final GraphTraversalSource sg = ((Graph) result).traversal();
 
-        // grab the expected edges in the subgraph
-        final List<Edge> expectedEdges = dataTable.asList().stream().map(this::convertToObject).
-                map(e -> (Edge) e).collect(Collectors.toList());
-
-        // expected edges match the count in the graph
-        assertEquals(expectedEdges.size(), sg.E().count().next().intValue());
-
-        // assert the structure of the subgraph. there should be no references here as this is serialized as
-        // a full TinkerGraph. also, ids should be the same as they are in the source graph so we can use all
-        // of this to do a complete assertion. there is only support for the modern graph right now but it
-        // wouldn't be hard to add others.
-        for (Edge edge : expectedEdges) {
-            assertThat(sg.E(edge.id()).
-                          has(edge.label(), "weight", eq(edge.value("weight"))).
-                          filter(__.outV().hasId(edge.outVertex().id())).
-                          filter(__.inV().hasId(edge.inVertex().id())).hasNext(),
-                    equalTo(true));
+        // the first item in the datatable tells us what we are asserting
+        final boolean assertingVertices = dataTable.asList().get(0).equals("vertices") ? true : false;
+
+        if (assertingVertices) {
+            // grab the expected vertex in the subgraph
+            final List<Vertex> expectedVertices = dataTable.asList().stream().skip(1).
+                    map(this::convertToObject).
+                    map(v -> (Vertex) v).collect(Collectors.toList());
+
+            // expected vertices match the count in the graph
+            assertEquals(expectedVertices.size(), sg.V().count().next().intValue());
+
+            // assert the structure of the subgraph. there should be no references here as this is serialized as
+            // a full TinkerGraph. also, ids should be the same as they are in the source graph so we can use all
+            // of this to do a complete assertion. there is only support for the modern graph right now but it
+            // wouldn't be hard to add others.
+            for (Vertex vertex : expectedVertices) {
+                final String variableKey = vertex.label().equals("person") ? "age" : "lang";
+
+                assertThat(sg.V(vertex.id()).has(vertex.label(), "name", eq(vertex.value("name"))).
+                                has(variableKey, eq(vertex.value(variableKey))).hasNext(),
+                        equalTo(true));
+            }
+        } else {
+            // grab the expected edges in the subgraph
+            final List<Edge> expectedEdges = dataTable.asList().stream().skip(1).
+                    map(this::convertToObject).
+                    map(e -> (Edge) e).collect(Collectors.toList());
+
+            // expected edges match the count in the graph
+            assertEquals(expectedEdges.size(), sg.E().count().next().intValue());
+
+            // assert the structure of the subgraph. there should be no references here as this is serialized as
+            // a full TinkerGraph. also, ids should be the same as they are in the source graph so we can use all
+            // of this to do a complete assertion. there is only support for the modern graph right now but it
+            // wouldn't be hard to add others.
+            for (Edge edge : expectedEdges) {
+                assertThat(sg.E(edge.id()).
+                                has(edge.label(), "weight", eq(edge.value("weight"))).
+                                filter(__.outV().hasId(edge.outVertex().id())).
+                                filter(__.inV().hasId(edge.inVertex().id())).hasNext(),
+                        equalTo(true));
+            }
         }
     }
 
-    @Then("the result should be a subgraph with vertices")
-    public void theResultShouldBeASubgraphWithVertices(final DataTable dataTable) {
+    @Then("the result should be a tree with a structure of")
+    public void theGraphShouldBeATreeWithAStructureOf(final String asciiTree) {
         assertThatNoErrorWasThrown();
 
-        // result should be a graph
-        assertThat(result, instanceOf(Graph.class));
-
-        // pop a graph traversal source from what was returned so we can use it for assertions
-        final GraphTraversalSource sg = ((Graph) result).traversal();
-
-        // grab the expected vertex in the subgraph
-        final List<Vertex> expectedVertices = dataTable.asList().stream().map(this::convertToObject).
-                map(v -> (Vertex) v).collect(Collectors.toList());
+        // result should be a tree
+        assertThat(result, instanceOf(Tree.class));
+        final Tree tree = (Tree) result;
 
-        // expected vertices match the count in the graph
-        assertEquals(expectedVertices.size(), sg.E().count().next().intValue());
+        // empty list is an empty tree
+        final List<TreeNode> roots = parseTree(asciiTree);
 
-        // assert the structure of the subgraph. there should be no references here as this is serialized as
-        // a full TinkerGraph. also, ids should be the same as they are in the source graph so we can use all
-        // of this to do a complete assertion. there is only support for the modern graph right now but it
-        // wouldn't be hard to add others.
-        for (Vertex vertex : expectedVertices) {
-            final String variableKey = vertex.label().equals("person") ? "age" : "lang";
+        // Validate that the tree matches the data in roots
+        assertEquals(roots.size(), tree.keySet().size());
+        for (TreeNode root : roots) {
+            assertThat(String.format("Tree not matching at %s", root.getValue()),
+                    tree.containsKey(root.getValue()), CoreMatchers.is(true));
+            validateTreeStructure((Tree) tree.get(root.getValue()), root);
+        }
+    }
 
-            assertThat(sg.V(vertex.id()).has(vertex.label(), "name", eq(vertex.value("name"))).
-                            has(variableKey, eq(vertex.value(variableKey))).hasNext(),
-                    equalTo(true));
+    private void validateTreeStructure(final Tree<?> actualTree, final TreeNode expectedNode) {
+        assertEquals(expectedNode.getChildren().size(), actualTree.keySet().size());
+        for (TreeNode child : expectedNode.getChildren()) {
+            assertThat(String.format("Tree not matching at %s", child.getValue()),
+                    actualTree.containsKey(child.getValue()), CoreMatchers.is(true));
+            validateTreeStructure(actualTree.get(child.getValue()), child);
         }
     }
 
@@ -702,4 +731,70 @@ public final class StepDefinition {
         return matchers;
     }
 
+    /**
+     * Parse the tree structure as taken from the Gherkin feature file.
+     */
+    public List<TreeNode> parseTree(final String asciiTree) {
+        if (asciiTree.isEmpty()) return Collections.emptyList();
+
+        final List<String> lines = Arrays.asList(asciiTree.split("\n"));
+
+        final List<TreeNode> roots = new ArrayList<>();
+        final Map<Integer, TreeNode> levelMap = new HashMap<>();
+
+        for (String line : lines) {
+            final int level = countLeadingCharacters(line);
+            final String value = line.replace("|--", "").trim();
+
+            final TreeNode node = new TreeNode(convertToObject(value));
+            if (level == 0) {
+                roots.add(node);
+            } else {
+                levelMap.get(level - 1).addChild(node);
+            }
+            levelMap.put(level, node);
+        }
+
+        return roots;
+    }
+
+    private static int countLeadingCharacters(final String line) {
+        int count = 0;
+        for (char c : line.toCharArray()) {
+            if (c == ' ') count++;
+            else break;
+        }
+        return count / 3; // Assuming 4 spaces per level
+    }
+
+    /**
+     * An basic internal tree-structure to hold the expected tree defined in the gherkin feature files.
+     */
+    private static class TreeNode {
+        private final Object value;
+        private final List<TreeNode> children;
+
+        public TreeNode(final Object value) {
+            this.value = value;
+            this.children = new ArrayList<>();
+        }
+
+        public void addChild(final TreeNode child) {
+            this.children.add(child);
+        }
+
+        public Object getValue() {
+            return value;
+        }
+
+        public List<TreeNode> getChildren() {
+            return children;
+        }
+
+        @Override
+        public String toString() {
+            return value + (children.isEmpty() ? "" : " -> " + children);
+        }
+    }
+
 }
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
index 68b3bebbc0..f66752a26e 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
@@ -62,7 +62,6 @@ public class ProcessEmbeddedComputerSuite extends AbstractGremlinSuite {
             ProgramTest.Traversals.class,
             WriteTest.Traversals.class,
             ExplainTest.Traversals.class,
-            TreeTest.Traversals.class,
             LambdaStepTest.Traversals.class,
 
             // compliance
@@ -88,7 +87,6 @@ public class ProcessEmbeddedComputerSuite extends AbstractGremlinSuite {
             MatchTest.class,
             ProfileTest.class,
             ProgramTest.class,
-            TreeTest.class
     };
 
     /**
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
index 086fa1fcc6..48df852032 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
@@ -59,7 +59,6 @@ public class ProcessEmbeddedStandardSuite extends AbstractGremlinSuite {
             ProfileTest.Traversals.class,
             WriteTest.Traversals.class,
             ExplainTest.Traversals.class,
-            TreeTest.Traversals.class,
 
             // compliance
             CoreTraversalTest.class,
@@ -85,7 +84,6 @@ public class ProcessEmbeddedStandardSuite extends AbstractGremlinSuite {
      */
     private static final Class<?>[] testsToEnforce = new Class<?>[]{
             ProfileTest.class,
-            TreeTest.class,
     };
 
     /**
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Subgraph.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Subgraph.feature
index 1eb2edfc32..751481ba92 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Subgraph.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Subgraph.feature
@@ -26,10 +26,12 @@ Feature: Step - subgraph()
       g.V(vid1).outE("knows").subgraph("sg").values("name").cap("sg")
       """
     When iterated next
-    Then the result should be a subgraph with edges
+    Then the result should be a subgraph with the following
+      | edges |
       | e[marko-knows->josh] |
       | e[marko-knows->vadas] |
-    And the result should be a subgraph with vertices
+    And the result should be a subgraph with the following
+      | vertices |
       | v[marko] |
       | v[vadas] |
       | v[josh] |
@@ -41,14 +43,28 @@ Feature: Step - subgraph()
       g.V().repeat(__.bothE("created").subgraph("sg").outV()).times(5).values("name").dedup().cap("sg")
       """
     When iterated next
-    Then the result should be a subgraph with edges
+    Then the result should be a subgraph with the following
+      | edges |
       | e[marko-created->lop] |
       | e[josh-created->lop] |
       | e[josh-created->ripple] |
       | e[peter-created->lop] |
-    And the result should be a subgraph with vertices
+    And the result should be a subgraph with the following
+      | vertices |
       | v[marko] |
       | v[lop] |
       | v[josh] |
       | v[peter] |
-      | v[ripple] |
\ No newline at end of file
+      | v[ripple] |
+
+  Scenario: g_V_outEXnoexistX_subgraphXsgXcapXsgX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().outE("noexist").subgraph("sg").cap("sg")
+      """
+    When iterated next
+    Then the result should be a subgraph with the following
+      | edges |
+    And the result should be a subgraph with the following
+      | vertices |
\ No newline at end of file
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Tree.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Tree.feature
new file mode 100644
index 0000000000..93219940f6
--- /dev/null
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/Tree.feature
@@ -0,0 +1,208 @@
+# 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.
+
+@StepClassSideEffect @StepTree
+Feature: Step - tree()
+
+  @GraphComputerVerificationReferenceOnly
+  Scenario: g_VX1X_out_out_tree_byXnameX
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      g.V(vid1).out().out().tree().by("name")
+      """
+    When iterated next
+    Then the result should be a tree with a structure of
+      """
+      |--marko
+         |--josh
+            |--lop
+            |--ripple
+      """
+
+  Scenario: g_VX1X_out_out_tree
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      g.V(vid1).out().out().tree()
+      """
+    When iterated next
+    Then the result should be a tree with a structure of
+      """
+      |--v[marko]
+         |--v[josh]
+            |--v[lop]
+            |--v[ripple]
+      """
+
+  @GraphComputerVerificationReferenceOnly
+  Scenario: g_V_out_tree_byXageX
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().out().tree().by("age")
+      """
+    When iterated next
+    Then the result should be a tree with a structure of
+      """
+      |--d[32].i
+      |--d[35].i
+      |--d[29].i
+         |--d[32].i
+         |--d[27].i
+      """
+
+  @GraphComputerVerificationReferenceOnly
+  Scenario: g_VX1X_out_out_treeXaX_byXnameX_both_both_capXaX
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      g.V(vid1).out().out().tree("a").by("name").both().both().cap("a")
+      """
+    When iterated next
+    Then the result should be a tree with a structure of
+      """
+      |--marko
+         |--josh
+            |--lop
+            |--ripple
+      """
+
+  Scenario: g_VX1X_out_out_treeXaX_both_both_capXaX
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      g.V(vid1).out().out().tree("a").both().both().cap("a")
+      """
+    When iterated next
+    Then the result should be a tree with a structure of
+      """
+      |--v[marko]
+         |--v[josh]
+            |--v[lop]
+            |--v[ripple]
+      """
+
+  @GraphComputerVerificationReferenceOnly
+  Scenario: g_VX1X_out_out_tree_byXlabelX
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      g.V(vid1).out().out().tree().by(T.label)
+      """
+    When iterated next
+    Then the result should be a tree with a structure of
+      """
+      |--person
+         |--person
+            |--software
+      """
+
+  @GraphComputerVerificationReferenceOnly
+  Scenario: g_VX1X_out_out_treeXaX_byXlabelX_both_both_capXaX
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      g.V(vid1).out().out().tree("a").by(T.label).both().both().cap("a")
+      """
+    When iterated next
+    Then the result should be a tree with a structure of
+      """
+      |--person
+         |--person
+            |--software
+      """
+
+  Scenario: g_VX1X_out_out_out_tree
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().out().out().out().tree()
+      """
+    When iterated next
+    Then the result should be a tree with a structure of
+      """
+      """
+
+  Scenario: g_VX1X_outE_inV_bothE_otherV_tree
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      g.V(vid1).outE().inV().bothE().otherV().tree()
+      """
+    When iterated next
+    Then the result should be a tree with a structure of
+      """
+      |--v[marko]
+         |--e[marko-knows->vadas]
+            |--v[vadas]
+               |--e[marko-knows->vadas]
+                  |--v[marko]
+         |--e[marko-knows->josh]
+            |--v[josh]
+               |--e[josh-created->ripple]
+                  |--v[ripple]
+               |--e[josh-created->lop]
+                  |--v[lop]
+               |--e[marko-knows->josh]
+                  |--v[marko]
+         |--e[marko-created->lop]
+            |--v[lop]
+               |--e[marko-created->lop]
+                  |--v[marko]
+               |--e[josh-created->lop]
+                  |--v[josh]
+               |--e[peter-created->lop]
+                  |--v[peter]
+      """
+
+  @GraphComputerVerificationReferenceOnly
+  Scenario: g_VX1X_outE_inV_bothE_otherV_tree_byXnameX_byXlabelX
+    Given the modern graph
+    And using the parameter vid1 defined as "v[marko].id"
+    And the traversal of
+      """
+      g.V(vid1).outE().inV().bothE().otherV().tree().by("name").by(T.label)
+      """
+    When iterated next
+    Then the result should be a tree with a structure of
+      """
+      |--marko
+         |--knows
+            |--vadas
+               |--knows
+                  |--marko
+            |--josh
+               |--created
+                  |--ripple
+                  |--lop
+               |--knows
+                  |--marko
+         |--created
+            |--lop
+               |--created
+                  |--marko
+                  |--josh
+                  |--peter
+      """
\ No newline at end of file


(tinkerpop) 01/11: TINKERPOP-3136 Deprecated the "limited" test suites

Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 678b54d7b674bb890cb4415a7157fdea2d401ef5
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Fri Apr 11 07:25:37 2025 -0400

    TINKERPOP-3136 Deprecated the "limited" test suites
    
    Converted test suites to "embedded". Part of the move to push to full gherkin testing for Gremlin and reducing test duplication.
---
 CHANGELOG.asciidoc                                 |   1 +
 docs/src/dev/provider/index.asciidoc               |  59 ++++-----
 docs/src/upgrade/release-3.8.x.asciidoc            |  31 +++++
 ...uite.java => ProcessEmbeddedComputerSuite.java} |  66 ++++------
 ...uite.java => ProcessEmbeddedStandardSuite.java} |  23 +---
 .../process/ProcessLimitedComputerSuite.java       | 144 +--------------------
 .../process/ProcessLimitedStandardSuite.java       |  95 +-------------
 7 files changed, 105 insertions(+), 314 deletions(-)

diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index 00212e9637..0ab3bfe73e 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -55,6 +55,7 @@ This release also includes changes from <<release-3-7-XXX, 3.7.XXX>>.
 * Added missing strategies in `gremlin-go`, updated certain strategies to take varargs and updated `GoTranslatorVisitor` for corresponding translations.
 * Fixed `BigInt` and `BigDecimal` parsing in `gremlin-go` cucumber test suite, fixed `UnscaledValue` type in `BigDecimal` struct and added `ParseBigDecimal` method.
 * Added validation to `groupCount()` to prevent an invalid usage of multiple `by()` modulators.
+* Deprecated `ProcessLimitedStandardSuite` and `ProcessLimitedComputerSuite` in favor of `ProcessEmbeddedStandardSuite` and `ProcessEmbeddedComputerSuite` respectively.
 
 == TinkerPop 3.7.0 (Gremfir Master of the Pan Flute)
 
diff --git a/docs/src/dev/provider/index.asciidoc b/docs/src/dev/provider/index.asciidoc
index 995cf53350..1e49614a26 100644
--- a/docs/src/dev/provider/index.asciidoc
+++ b/docs/src/dev/provider/index.asciidoc
@@ -636,48 +636,44 @@ image:gremlin-edumacated.png[width=225]
 </dependency>
 ----
 
-Providers currently have two approaches to consider when validating their TinkerPop implementations. The first approach
-comes from the wholly JVM oriented original test suite which was developed in the early days of TinkerPop 3.x design
-and development. The second approach is available as of 3.6.0, is Gherkin-based and originates from the Gremlin
-Language Variant test suite which is language agnostic.
-
-The first approach is more complete and more opinionated as to how an implementation should behave and in many ways
-helpful in getting an implementation semantically correct from the ground up (i.e. first getting the `Graph` Structure
-API implemented well by getting the Structure Suite to pass which will almost inevitably ensure that the most of the
-Gremlin language oriented tests in the Process Suite pass early on). On the other hand, the fact that this test suite
-is rigorous also can make it harder to implement especially if your graph already exists and behaves in a certain
-fashion.
-
-The second approach only validates Gremlin semantics which is ultimately what users concern themselves with as that is
-the method by which they will interact with a provider's `Graph`. This test suite is less concerned with how a
-TinkerPop implementation does what it does, so long as it succeeds at processing Gremlin traversals. There is
-significant overlap between this test suite and the aforementioned Process Suite.
-
-At this time, it would be wise for providers to implement both approaches as the goal for TinkerPop is to move away
-from the rigors of the JVM Structure and Process Suites in favor of Gherkin. Over time, the Structure and Process
-Suites will be deprecated and removed.
+TinkerPop provides `gremlin-test`, a technology test kit, that helps validate provider implementations. There is a
+Gherkin-based test suite and a JVM-based test suite. The Gherkin suite is meant to test Gremlin operations and semantics
+while the JVM-based suite is meant for lower-level `Graph` implementation validation and for Gremlin use cases that
+apply to embedded operations (i.e. running Gremlin in the same JVM as the `Graph` implementation).
 
 ==== JVM Test Suite
 
-The operational semantics of any OLTP or OLAP implementation are validated by `gremlin-test`. To implement these tests,
-provide test case implementations as shown below, where `XXX` below denotes the name of the graph implementation (e.g.
-TinkerGraph, Neo4jGraph, HadoopGraph, etc.).
+The JVM test suite is useful to graph system implementers who want to validate that their `Graph` implementation is
+working properly and that Gremlin features specific to embedded use cases are behaving as expected. These tests do not
+validate that all the semantics of the Gremlin query language are properly operating. Providers should implement the
+<<gherkin-tests-suite>> for that type of validation.
+
+If you are a remote graph database only or don't implement the `Graph` API but simply expose access to the Gremlin
+language then it likely makes sense to skip implementing this suite and only implemented the Gherkin suite. On the other
+hand, if you do implement the `Graph` API or `GraphComputer` API, it likely makes sense to implement both these tests
+and the Gherkin suite.
+
+To implement the JVM tests, provide test case implementations as shown below, where `XXX` below denotes the name of the
+graph implementation (e.g. TinkerGraph, Neo4jGraph, HadoopGraph, etc.).
 
 [source,java]
 ----
-// Structure API tests
+// Structure API tests which validate the core functionality of the Graph implementation.
+// Start with this one because, generally speaking, if this suite passes then the others
+// will mostly follow suit. Moreover, the structure tests operate on lower-level aspects
+// of the Graph interfaces which are much easier to debug than Gremlin level tests.
 @RunWith(StructureStandardSuite.class)
 @GraphProviderClass(provider = XXXGraphProvider.class, graph = XXXGraph.class)
 public class XXXStructureStandardTest {}
 
-// Process API tests
-@RunWith(ProcessComputerSuite.class)
+// Process API tests cover embedded Gremlin uses cases
+@RunWith(ProcessEmbeddedStandardSuite.class)
 @GraphProviderClass(provider = XXXGraphProvider.class, graph = XXXGraph.class)
-public class XXXProcessComputerTest {}
+public class XXXProcessStandardTest {}
 
-@RunWith(ProcessStandardSuite.class)
+@RunWith(ProcessEmbeddedComputerSuite.class)
 @GraphProviderClass(provider = XXXGraphProvider.class, graph = XXXGraph.class)
-public class XXXProcessStandardTest {}
+public class XXXProcessComputerTest {}
 ----
 
 IMPORTANT: It is as important to look at "ignored" tests as it is to look at ones that fail.  The `gremlin-test`
@@ -770,7 +766,7 @@ there is a single test case that prevents an implementer from claiming support o
 choose to either not support the `Feature` or to support it but "opt-out" of the test with a "reason" as to why so
 that users understand the limitation.
 
-IMPORTANT: Before using `OptOut` be sure that the reason for using it is sound and it is more of a last resort.
+IMPORTANT: Before using `OptOut` be sure that the reason for using it is sound and that it is more of a last resort.
 It is possible that a test from the suite doesn't properly represent the expectations of a feature, is too broad or
 narrow for the semantics it is trying to enforce or simply contains a bug.  Please consider raising issues in the
 developer mailing list with such concerns before assuming `OptOut` is the only answer.
@@ -815,7 +811,8 @@ by way of a system property - simply set `-DtestIteratorLeaks=false".
 
 The Gherkin Test Suite is a language agnostic set of tests that verify Gremlin semantics. It provides a unified set of
 tests that validate many TinkerPop components internally. The tests themselves can be found in `gremlin-tests/features`
-(link:https://github.com/apache/tinkerpop/tree/x.y.z/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features[here]) with their syntax described in the
+(link:https://github.com/apache/tinkerpop/tree/x.y.z/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features[here])
+with their syntax described in the
 link:https://tinkerpop.apache.org/docs/x.y.z/dev/developer/#gremlin-language-test-cases[TinkerPop Developer Documentation].
 
 TinkerPop provides some infrastructure, for JVM based graphs, to help make it easier for providers to implement these
diff --git a/docs/src/upgrade/release-3.8.x.asciidoc b/docs/src/upgrade/release-3.8.x.asciidoc
index b241931d94..97e9359932 100644
--- a/docs/src/upgrade/release-3.8.x.asciidoc
+++ b/docs/src/upgrade/release-3.8.x.asciidoc
@@ -42,8 +42,10 @@ For Python, Go, JavaScript, and .NET GLVs, the existing date types are retained.
 For Java GLV, this change would impact users who are expecting the old `Date` object from a traversal in their application, in this case the recommendation is to update code to expect `OffsetDateTime` as part of the version upgrade.
 
 ==== Simplification to g creation
+
 The creation of "g" is the start point to writing Gremlin. There are a number of ways to create it, but TinkerPop has
 long recommended the use of the anonymous `traversal()` function for this creation.
+
 [source,groovy]
 ----
 // for embedded cases
@@ -52,7 +54,9 @@ g = traversal().withEmbedded(graph)
 // for remote cases
 g = traversal().withRemote(DriverRemoteConnection.using(...)))
 ----
+
 As of this release, those two methods have been deprecated in favor of just `with()` which means you could simply write:
+
 [source,groovy]
 ----
 // for embedded cases
@@ -61,18 +65,24 @@ g = traversal().with(graph)
 // for remote cases
 g = traversal().with(DriverRemoteConnection.using(...)))
 ----
+
 That's a bit less to type, but also removes need to programmatically decide which function to call which hopefully
 strengthens the abstraction further. To demonstrate this further consider this next example:
+
 [source,groovy]
 ----
 g = traversal().with("config.properties")
 ----
+
 The properties file in the above example can either point to a remote configuration or a embedded configuration allowing
 "g" to be switched as needed without code changes.
+
 See: link:https://issues.apache.org/jira/browse/TINKERPOP-3017[TINKERPOP-3017]
 
 ==== Splitting a string into characters using split()
+
 The `split()` step will now split a string into a list of its characters if the given separator is an empty string.
+
 [source,groovy]
 ----
 // previous implementation
@@ -82,7 +92,9 @@ g.inject("Hello").split("")
 g.inject("Hello").split("")
 ==>[H,e,l,l,o]
 ----
+
 See: link:https://issues.apache.org/jira/browse/TINKERPOP-3083[TINKERPOP-3083]
+
 ==== Changes to deserialization for gremlin-javascript
 
 Starting from this version, `gremlin-javascript` will deserialize `Set` data into a ECMAScript 2015 Set. Previously,
@@ -295,7 +307,25 @@ See: link:https://issues.apache.org/jira/browse/TINKERPOP-3121[TINKERPOP-3121]
 
 ==== Graph System Providers
 
+===== Test Suite Changes
+
+In 3.6.0, providers were encouraged to begin using the Gherkin test suite for testing Gremlin rather than the original
+Java based testing found in the `ProcessStandardSuite` and/or the `ProcessComputerSuite`. At that stage, the Gherkin
+suite was still being developed to match the features of the earlier framework. As of 3.8.0, the Gherkin based tests now
+represent the primary way that Gremlin tests are developed and the old system has fallen behind. The old suites have
+been deprecated in favor of the Gherkin test suite and providers should upgrade their implementations accordingly. Going
+forward, the expectation is that the old Java-based suite will continue to exist, but will be focused on covering test
+scenarios that cover either Java-specific syntax, lambdas or other cases that only fall into Gremlin embedded use cases.
+Graphs that need to support those cases would implement the `ProcessEmbeddedStandardSuite` and/or
+`ProcessEmbeddedComputerSuite`.
+
+Details on implementing the Gherkin tests can be found in the
+link:https://tinkerpop.apache.org/docs/3.8.0/dev/provider/#gherkin-tests-suite[Provider Documentation].
+
+See: link:https://issues.apache.org/jira/browse/TINKERPOP-3136[TINKERPOP-3136]
+
 ==== The Switch from Date to OffsetDateTime
+
 The default implementation for date type in Gremlin is now changed from the deprecated `java.util.Date` to the more encompassing `java.time.OffsetDateTime`. This means the reference implementation for all date manipulation steps, `asDate()`, `dateAdd()`, and `dateDiff()`, as well as helper methods `datetime()`, will return `OffsetDateTime`, whose string representation will be in ISO 8601 format.
 
 `Date` is still supported as incoming traverser results for these steps, as well as input into `dateDiff()` for compatibility purposes. All dates are assumed to be in `UTC` (given epoch time).
@@ -305,6 +335,7 @@ This may impact providers who use TinkerGraph or whose implementation store date
 ==== Graph Driver Providers
 
 ==== The Switch from Date to OffsetDateTime
+
 The default implementation for date type in Gremlin is now changed from the deprecated `java.util.Date` to the more encompassing `java.time.OffsetDateTime`. This means the reference implementation for all date manipulation steps, `asDate()`, `dateAdd()`, and `dateDiff()`, as well as helper methods `datetime()`, will return `OffsetDateTime`, whose string representation will be in ISO 8601 format.
 
 This means that drivers should use the extended `OffsetDateTime` type in the IO specs to serialize and deserialize native date objects.
\ No newline at end of file
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedStandardSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
similarity index 61%
copy from gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedStandardSuite.java
copy to gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
index fda7b04417..635b781bee 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedStandardSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedComputerSuite.java
@@ -19,54 +19,46 @@
 package org.apache.tinkerpop.gremlin.process;
 
 import org.apache.tinkerpop.gremlin.AbstractGremlinSuite;
-import org.apache.tinkerpop.gremlin.process.traversal.CoreTraversalTest;
+import org.apache.tinkerpop.gremlin.process.computer.GraphComputerTest;
+import org.apache.tinkerpop.gremlin.process.computer.clone.CloneVertexProgramTest;
+import org.apache.tinkerpop.gremlin.process.computer.ranking.pagerank.PageRankVertexProgramTest;
+import org.apache.tinkerpop.gremlin.process.computer.search.path.ShortestPathVertexProgramTest;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalInterruptionTest;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalInterruptionComputerTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.ComplexTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.OrderabilityTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.TernaryBooleanLogicsTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MergeEdgeTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MergeVertexTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProfileTest;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProgramTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.WriteTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.ExplainTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.TreeTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ElementIdStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.EventStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.PartitionStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SeedStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.TranslationStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.EarlyLimitStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IncidentToAdjacentStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReadOnlyStrategyProcessTest;
+import org.apache.tinkerpop.gremlin.structure.Graph;
 import org.junit.runners.model.InitializationError;
 import org.junit.runners.model.RunnerBuilder;
 
 /**
- * The {@code ProcessLimitedComputerSuite} is a set of tests that providers may implement in addition to the standard Gherkin
- * feature tests. The {@link ProcessStandardSuite} contains all the tests in Gherkin and is therefore duplicative of
- * that test set but also includes a number of tests that have not been (or cannot be) converted to Gherkin for various
- * reasons.
+ * The {@code ProcessLimitedComputerSuite} is a set of tests that providers may implement in addition to the standard
+ *  * Gherkin feature tests. These tests are only relevant for embedded use cases covering features like lambdas or other
+ *  * capabilities that can only work when running Gremlin in the same JVM as the {@link Graph} instance.
  *
  * @author Stephen Mallette (http://stephen.genoprime.com)
  */
-public class ProcessLimitedStandardSuite extends AbstractGremlinSuite {
+public class ProcessEmbeddedComputerSuite extends AbstractGremlinSuite {
 
     /**
      * This list of tests in the suite that will be executed as part of this suite.
      */
     private static final Class<?>[] allTests = new Class<?>[]{
-
-            MergeVertexTest.Traversals.class,
-            MergeEdgeTest.Traversals.class,
-
+            GraphComputerTest.class,
             MatchTest.CountMatchTraversals.class,
             MatchTest.GreedyMatchTraversals.class,
             ProfileTest.Traversals.class,
+            ProgramTest.Traversals.class,
             WriteTest.Traversals.class,
             ExplainTest.Traversals.class,
             SideEffectTest.Traversals.class,
@@ -75,48 +67,46 @@ public class ProcessLimitedStandardSuite extends AbstractGremlinSuite {
 
             // compliance
             ComplexTest.Traversals.class,
-            CoreTraversalTest.class,
-            TraversalInterruptionTest.class,
+            TraversalInterruptionComputerTest.class,
+
+            // algorithms
+            PageRankVertexProgramTest.class,
+            ShortestPathVertexProgramTest.class,
+            CloneVertexProgramTest.class,
 
             // creations
             TranslationStrategyProcessTest.class,
 
-            // decorations
-            ElementIdStrategyProcessTest.class,
-            EventStrategyProcessTest.class,
-            PartitionStrategyProcessTest.class,
-
             // optimizations
             IncidentToAdjacentStrategyProcessTest.class,
-            EarlyLimitStrategyProcessTest.class,
-
-            // semantics
-            TernaryBooleanLogicsTest.class,
+            EarlyLimitStrategyProcessTest.class
     };
 
     /**
      * A list of the minimum set of base tests that Gremlin flavors should implement to be compliant with Gremlin.
      */
     private static final Class<?>[] testsToEnforce = new Class<?>[]{
+            MatchTest.class,
             ProfileTest.class,
+            ProgramTest.class,
             SideEffectTest.class,
             SubgraphTest.class,
-            TreeTest.class,
+            TreeTest.class
     };
 
     /**
      * This constructor is used by JUnit and will run this suite with its concrete implementations of the
      * {@code testsToEnforce}.
      */
-    public ProcessLimitedStandardSuite(final Class<?> klass, final RunnerBuilder builder) throws InitializationError {
-        super(klass, builder, allTests, testsToEnforce, false, TraversalEngine.Type.STANDARD);
+    public ProcessEmbeddedComputerSuite(final Class<?> klass, final RunnerBuilder builder) throws InitializationError {
+        super(klass, builder, allTests, allTests, false, TraversalEngine.Type.COMPUTER);
     }
 
     /**
      * This constructor is used by Gremlin flavor implementers who supply their own implementations of the
      * {@code testsToEnforce}.
      */
-    public ProcessLimitedStandardSuite(final Class<?> klass, final RunnerBuilder builder, final Class<?>[] testsToExecute) throws InitializationError {
-        super(klass, builder, testsToExecute, testsToEnforce, true, TraversalEngine.Type.STANDARD);
+    public ProcessEmbeddedComputerSuite(final Class<?> klass, final RunnerBuilder builder, final Class<?>[] testsToExecute) throws InitializationError {
+        super(klass, builder, testsToExecute, testsToEnforce, true, TraversalEngine.Type.COMPUTER);
     }
-}
\ No newline at end of file
+}
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedStandardSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
similarity index 77%
copy from gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedStandardSuite.java
copy to gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
index fda7b04417..4e8c8b41d9 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedStandardSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessEmbeddedStandardSuite.java
@@ -23,11 +23,8 @@ import org.apache.tinkerpop.gremlin.process.traversal.CoreTraversalTest;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalInterruptionTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.ComplexTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.OrderabilityTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.TernaryBooleanLogicsTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MergeEdgeTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MergeVertexTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProfileTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.WriteTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.ExplainTest;
@@ -37,33 +34,27 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.TreeTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ElementIdStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.EventStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.PartitionStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SeedStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.TranslationStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.EarlyLimitStrategyProcessTest;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IncidentToAdjacentStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReadOnlyStrategyProcessTest;
+import org.apache.tinkerpop.gremlin.structure.Graph;
 import org.junit.runners.model.InitializationError;
 import org.junit.runners.model.RunnerBuilder;
 
 /**
- * The {@code ProcessLimitedComputerSuite} is a set of tests that providers may implement in addition to the standard Gherkin
- * feature tests. The {@link ProcessStandardSuite} contains all the tests in Gherkin and is therefore duplicative of
- * that test set but also includes a number of tests that have not been (or cannot be) converted to Gherkin for various
- * reasons.
+ * The {@code ProcessEmbeddedStandardSuite} is a set of tests that providers may implement in addition to the standard
+ * Gherkin feature tests. These tests are only relevant for embedded use cases covering features like lambdas or other
+ * capabilities that can only work when running Gremlin in the same JVM as the {@link Graph} instance.
  *
  * @author Stephen Mallette (http://stephen.genoprime.com)
  */
-public class ProcessLimitedStandardSuite extends AbstractGremlinSuite {
+public class ProcessEmbeddedStandardSuite extends AbstractGremlinSuite {
 
     /**
      * This list of tests in the suite that will be executed as part of this suite.
      */
     private static final Class<?>[] allTests = new Class<?>[]{
 
-            MergeVertexTest.Traversals.class,
-            MergeEdgeTest.Traversals.class,
-
             MatchTest.CountMatchTraversals.class,
             MatchTest.GreedyMatchTraversals.class,
             ProfileTest.Traversals.class,
@@ -108,7 +99,7 @@ public class ProcessLimitedStandardSuite extends AbstractGremlinSuite {
      * This constructor is used by JUnit and will run this suite with its concrete implementations of the
      * {@code testsToEnforce}.
      */
-    public ProcessLimitedStandardSuite(final Class<?> klass, final RunnerBuilder builder) throws InitializationError {
+    public ProcessEmbeddedStandardSuite(final Class<?> klass, final RunnerBuilder builder) throws InitializationError {
         super(klass, builder, allTests, testsToEnforce, false, TraversalEngine.Type.STANDARD);
     }
 
@@ -116,7 +107,7 @@ public class ProcessLimitedStandardSuite extends AbstractGremlinSuite {
      * This constructor is used by Gremlin flavor implementers who supply their own implementations of the
      * {@code testsToEnforce}.
      */
-    public ProcessLimitedStandardSuite(final Class<?> klass, final RunnerBuilder builder, final Class<?>[] testsToExecute) throws InitializationError {
+    public ProcessEmbeddedStandardSuite(final Class<?> klass, final RunnerBuilder builder, final Class<?>[] testsToExecute) throws InitializationError {
         super(klass, builder, testsToExecute, testsToEnforce, true, TraversalEngine.Type.STANDARD);
     }
 }
\ No newline at end of file
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedComputerSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedComputerSuite.java
index a9ceb268a2..5990973ab6 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedComputerSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedComputerSuite.java
@@ -18,155 +18,21 @@
  */
 package org.apache.tinkerpop.gremlin.process;
 
-import org.apache.tinkerpop.gremlin.AbstractGremlinSuite;
-import org.apache.tinkerpop.gremlin.process.computer.GraphComputer;
-import org.apache.tinkerpop.gremlin.process.computer.GraphComputerTest;
-import org.apache.tinkerpop.gremlin.process.computer.clone.CloneVertexProgramTest;
-import org.apache.tinkerpop.gremlin.process.computer.ranking.pagerank.PageRankVertexProgramTest;
-import org.apache.tinkerpop.gremlin.process.computer.search.path.ShortestPathVertexProgramTest;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalInterruptionComputerTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.ComplexTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.branch.BranchTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.branch.ChooseTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.branch.LocalTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.branch.OptionalTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.branch.RepeatTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.branch.UnionTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.AndTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.CoinTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.CyclicPathTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.DedupTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.IsTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.OrTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.RangeTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.SampleTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.SimplePathTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.TailTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.WhereTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddEdgeTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.CoalesceTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.ConnectedComponentTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.ConstantTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.CountTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.ElementMapTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.FlatMapTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.FoldTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.LoopsTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MapTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MathTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MaxTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MeanTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MinTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.PageRankTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.PathTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.PeerPressureTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProfileTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProgramTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProjectTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertiesTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.ReadTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.SelectTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.ShortestPathTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.SumTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.UnfoldTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.ValueMapTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.VertexTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.WriteTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.AggregateTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.ExplainTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupCountTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SackTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectCapTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.StoreTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.TreeTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SeedStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.TranslationStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.EarlyLimitStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IncidentToAdjacentStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReadOnlyStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.structure.Graph;
-import org.apache.tinkerpop.gremlin.structure.StructureStandardSuite;
 import org.junit.runners.model.InitializationError;
 import org.junit.runners.model.RunnerBuilder;
 
 /**
- * The {@code ProcessLimitedComputerSuite} is a set of tests that providers may implement in addition to the standard Gherkin
- * feature tests. The {@link ProcessComputerSuite} contains all the tests in Gherkin and is therefore duplicative of
- * that test set but also includes a number of tests that have not been (or cannot be) converted to Gherkin for various
- * reasons.
- *
  * @author Stephen Mallette (http://stephen.genoprime.com)
+ * @deprecated As of release 3.8.0, replaced by {@link ProcessEmbeddedComputerSuite}.
  */
-public class ProcessLimitedComputerSuite extends AbstractGremlinSuite {
-
-    /**
-     * This list of tests in the suite that will be executed as part of this suite.
-     */
-    private static final Class<?>[] allTests = new Class<?>[]{
-            GraphComputerTest.class,
-            MatchTest.CountMatchTraversals.class,
-            MatchTest.GreedyMatchTraversals.class,
-            ProfileTest.Traversals.class,
-            ProgramTest.Traversals.class,
-            WriteTest.Traversals.class,
-            ExplainTest.Traversals.class,
-            SideEffectTest.Traversals.class,
-            SubgraphTest.Traversals.class,
-            TreeTest.Traversals.class,
-
-            // compliance
-            ComplexTest.Traversals.class,
-            TraversalInterruptionComputerTest.class,
-
-            // algorithms
-            PageRankVertexProgramTest.class,
-            ShortestPathVertexProgramTest.class,
-            CloneVertexProgramTest.class,
-
-            // creations
-            TranslationStrategyProcessTest.class,
-
-            // optimizations
-            IncidentToAdjacentStrategyProcessTest.class,
-            EarlyLimitStrategyProcessTest.class
-    };
-
-    /**
-     * A list of the minimum set of base tests that Gremlin flavors should implement to be compliant with Gremlin.
-     */
-    private static final Class<?>[] testsToEnforce = new Class<?>[]{
-            MatchTest.class,
-            ProfileTest.class,
-            ProgramTest.class,
-            SideEffectTest.class,
-            SubgraphTest.class,
-            TreeTest.class
-    };
+@Deprecated
+public class ProcessLimitedComputerSuite extends ProcessEmbeddedComputerSuite {
 
-    /**
-     * This constructor is used by JUnit and will run this suite with its concrete implementations of the
-     * {@code testsToEnforce}.
-     */
     public ProcessLimitedComputerSuite(final Class<?> klass, final RunnerBuilder builder) throws InitializationError {
-        super(klass, builder, allTests, allTests, false, TraversalEngine.Type.COMPUTER);
+        super(klass, builder);
     }
 
-    /**
-     * This constructor is used by Gremlin flavor implementers who supply their own implementations of the
-     * {@code testsToEnforce}.
-     */
     public ProcessLimitedComputerSuite(final Class<?> klass, final RunnerBuilder builder, final Class<?>[] testsToExecute) throws InitializationError {
-        super(klass, builder, testsToExecute, testsToEnforce, true, TraversalEngine.Type.COMPUTER);
+        super(klass, builder, testsToExecute);
     }
 }
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedStandardSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedStandardSuite.java
index fda7b04417..e39933b7a1 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedStandardSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessLimitedStandardSuite.java
@@ -18,105 +18,20 @@
  */
 package org.apache.tinkerpop.gremlin.process;
 
-import org.apache.tinkerpop.gremlin.AbstractGremlinSuite;
-import org.apache.tinkerpop.gremlin.process.traversal.CoreTraversalTest;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalInterruptionTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.ComplexTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.OrderabilityTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.TernaryBooleanLogicsTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MergeEdgeTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.MergeVertexTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.ProfileTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.WriteTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.ExplainTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphTest;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.TreeTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ElementIdStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.EventStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.PartitionStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SeedStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.TranslationStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.EarlyLimitStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IncidentToAdjacentStrategyProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReadOnlyStrategyProcessTest;
 import org.junit.runners.model.InitializationError;
 import org.junit.runners.model.RunnerBuilder;
 
 /**
- * The {@code ProcessLimitedComputerSuite} is a set of tests that providers may implement in addition to the standard Gherkin
- * feature tests. The {@link ProcessStandardSuite} contains all the tests in Gherkin and is therefore duplicative of
- * that test set but also includes a number of tests that have not been (or cannot be) converted to Gherkin for various
- * reasons.
- *
  * @author Stephen Mallette (http://stephen.genoprime.com)
+ * @deprecated As of release 3.8.0, replaced by {@link ProcessEmbeddedStandardSuite}.
  */
-public class ProcessLimitedStandardSuite extends AbstractGremlinSuite {
-
-    /**
-     * This list of tests in the suite that will be executed as part of this suite.
-     */
-    private static final Class<?>[] allTests = new Class<?>[]{
-
-            MergeVertexTest.Traversals.class,
-            MergeEdgeTest.Traversals.class,
-
-            MatchTest.CountMatchTraversals.class,
-            MatchTest.GreedyMatchTraversals.class,
-            ProfileTest.Traversals.class,
-            WriteTest.Traversals.class,
-            ExplainTest.Traversals.class,
-            SideEffectTest.Traversals.class,
-            SubgraphTest.Traversals.class,
-            TreeTest.Traversals.class,
-
-            // compliance
-            ComplexTest.Traversals.class,
-            CoreTraversalTest.class,
-            TraversalInterruptionTest.class,
-
-            // creations
-            TranslationStrategyProcessTest.class,
-
-            // decorations
-            ElementIdStrategyProcessTest.class,
-            EventStrategyProcessTest.class,
-            PartitionStrategyProcessTest.class,
-
-            // optimizations
-            IncidentToAdjacentStrategyProcessTest.class,
-            EarlyLimitStrategyProcessTest.class,
-
-            // semantics
-            TernaryBooleanLogicsTest.class,
-    };
-
-    /**
-     * A list of the minimum set of base tests that Gremlin flavors should implement to be compliant with Gremlin.
-     */
-    private static final Class<?>[] testsToEnforce = new Class<?>[]{
-            ProfileTest.class,
-            SideEffectTest.class,
-            SubgraphTest.class,
-            TreeTest.class,
-    };
-
-    /**
-     * This constructor is used by JUnit and will run this suite with its concrete implementations of the
-     * {@code testsToEnforce}.
-     */
+@Deprecated
+public class ProcessLimitedStandardSuite extends ProcessEmbeddedStandardSuite {
     public ProcessLimitedStandardSuite(final Class<?> klass, final RunnerBuilder builder) throws InitializationError {
-        super(klass, builder, allTests, testsToEnforce, false, TraversalEngine.Type.STANDARD);
+        super(klass, builder);
     }
 
-    /**
-     * This constructor is used by Gremlin flavor implementers who supply their own implementations of the
-     * {@code testsToEnforce}.
-     */
     public ProcessLimitedStandardSuite(final Class<?> klass, final RunnerBuilder builder, final Class<?>[] testsToExecute) throws InitializationError {
-        super(klass, builder, testsToExecute, testsToEnforce, true, TraversalEngine.Type.STANDARD);
+        super(klass, builder, testsToExecute);
     }
 }
\ No newline at end of file


(tinkerpop) 09/11: Remvoed RemoteOnly tag from gherkin

Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 7620060b11ccd4292275f12dfb6d495124ec9146
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Thu Apr 17 16:17:45 2025 -0400

    Remvoed RemoteOnly tag from gherkin
---
 CHANGELOG.asciidoc                                        |  1 +
 docs/src/dev/developer/for-committers.asciidoc            |  1 -
 docs/src/dev/provider/index.asciidoc                      | 15 ++++++++-------
 .../driver/remote/GraphBinaryRemoteFeatureTest.java       |  2 +-
 .../gremlin/driver/remote/GraphSONRemoteFeatureTest.java  |  2 +-
 .../java/org/apache/tinkerpop/gremlin/features/World.java |  1 -
 .../gremlin/hadoop/HadoopGraphFeatureIntegrateTest.java   |  2 +-
 .../tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java    |  2 +-
 .../gremlin/tinkergraph/TinkerGraphFeatureTest.java       |  2 +-
 .../tinkergraph/TinkerShuffleGraphFeatureTest.java        |  2 +-
 .../tinkergraph/TinkerTransactionGraphFeatureTest.java    |  2 +-
 11 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index dbe618cb0b..11409cf38a 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -59,6 +59,7 @@ This release also includes changes from <<release-3-7-XXX, 3.7.XXX>>.
 * Deprecated `ProcessLimitedStandardSuite` and `ProcessLimitedComputerSuite` in favor of `ProcessEmbeddedStandardSuite` and `ProcessEmbeddedComputerSuite` respectively.
 * Removed lambda oriented Gremlin testing from Gherkin test suite.
 * Moved all lambda oriented Gremlin tests to `LambdaStepTest` in the Java test suite.
+* Removed the `@RemoteOnly` testing tag in Gherkin as lambda tests have all been moved to the Java test suite.
 
 == TinkerPop 3.7.0 (Gremfir Master of the Pan Flute)
 
diff --git a/docs/src/dev/developer/for-committers.asciidoc b/docs/src/dev/developer/for-committers.asciidoc
index 1a29db9f25..c890ede3af 100644
--- a/docs/src/dev/developer/for-committers.asciidoc
+++ b/docs/src/dev/developer/for-committers.asciidoc
@@ -630,7 +630,6 @@ the traversal does not mind the star graph limitation.
 * `@InsertionOrderingRequired` - The scenario is reliant on the graph system predictably returning results (vertices, edges, properties) in the same order in which they were inserted into the graph.
 * `@MetaProperties` - The scenario makes use of meta-properties.
 * `@MultiProperties` - The scenario makes use of multi-properties.
-* `@RemoteOnly` - The scenario uses some Gremlin syntax that cannot be supported outside of remote test executions.
 * `@UserSuppliedVertexIds` - The scenario relies on the vertex IDs specified in the dataset used by the scenario.
 * `@UserSuppliedEdgeIds` - The scenario relies on the edge IDs specified in the dataset used by the scenario.
 * `@UserSuppliedVertexPropertyIds` - The scenario relies on the vertex property IDs specified in the dataset used by the scenario.
diff --git a/docs/src/dev/provider/index.asciidoc b/docs/src/dev/provider/index.asciidoc
index ccf83a5b95..cb78aef55b 100644
--- a/docs/src/dev/provider/index.asciidoc
+++ b/docs/src/dev/provider/index.asciidoc
@@ -844,7 +844,7 @@ The following is just an example as taken from TinkerGraph:
 ----
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly",
+        tags = "not @GraphComputerOnly and not @AllowNullPropertyValues",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
         plugin = {"progress", "junit:target/cucumber.xml",
@@ -853,12 +853,13 @@ The following is just an example as taken from TinkerGraph:
 
 The `@CucumberOptions` that are used are mostly implementation specific, so it will be up to the provider to make some
 choices as to what is right for their environment. For TinkerGraph, it needed to ignore Gherkin tests with the
-`@RemoteOnly` tag (the full list of possible tags can be found link:https://tinkerpop.apache.org/docs/x.y.z/dev/developer/#gherkin-tags[here]),
-as will most providers. The "glue" will be the same for all test implementers as it refers to a package containing
-TinkerPop's test infrastructure in `gremlin-test` (unless of course, a provider needs to develop their own
-infrastructure for some reason). The "features" is the path to the actual Gherkin test files that should be made
-available locally. The files can be referenced on the classpath assuming `gremlin-test` is a dependency. The "plugin"
-defines a JUnit style output, which happens to be understood by Maven.
+`@GraphComputerOnly` and `@AllowNullPropertyValues` tags (the full list of possible tags can be found
+link:https://tinkerpop.apache.org/docs/x.y.z/dev/developer/#gherkin-tags[here]), since this configuration was for OLTP
+tests and the graph was configured without support for storing `null` in the graph. The "glue" will be the same for all
+test implementers as it refers to a package containing TinkerPop's test infrastructure in `gremlin-test` (unless of
+course, a provider needs to develop their own infrastructure for some reason). The "features" is the path to the actual
+Gherkin test files that should be made available locally. The files can be referenced on the classpath assuming
+`gremlin-test` is a dependency. The "plugin" defines a JUnit style output, which happens to be understood by Maven.
 
 The "objectFactory" is the last component. Cucumber relies on dependency injection to get a `World` implementation into
 the test infrastructure. Providers may choose from multiple available implementations, but TinkerPop chose to use
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteFeatureTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteFeatureTest.java
index 91c7fff3b7..e1f8439778 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteFeatureTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteFeatureTest.java
@@ -30,7 +30,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerOnly and not @AllowNullPropertyValues",
+        tags = "not @GraphComputerOnly and not @AllowNullPropertyValues",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = GraphBinaryRemoteFeatureTest.RemoteGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteFeatureTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteFeatureTest.java
index 6eeba5dc9a..cd97edc434 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteFeatureTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteFeatureTest.java
@@ -30,7 +30,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerOnly and not @AllowNullPropertyValues and not @StepSubgraph", // TINKERPOP-3154
+        tags = "not @GraphComputerOnly and not @AllowNullPropertyValues and not @StepSubgraph", // TINKERPOP-3154
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = GraphSONRemoteFeatureTest.RemoteGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/World.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/World.java
index ec0fb4f447..1f1d4a29cf 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/World.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/World.java
@@ -39,7 +39,6 @@ public interface World {
      * point to filtering away tests using the "tags" argument for {@link CucumberOptions}.
      */
     public static final String GRAPHCOMPUTER_TAG_FILTER =
-            "not @RemoteOnly and " +
             "not @StepDrop and not @StepV and not @StepE and not @StepIndex and not @StepInject and " +
             "not @StepSubgraph and not @GraphComputerVerificationMidENotSupported and " +
             "not @GraphComputerVerificationOneBulk and not @GraphComputerVerificationStrategyNotSupported and " +
diff --git a/hadoop-gremlin/src/test/java/org/apache/tinkerpop/gremlin/hadoop/HadoopGraphFeatureIntegrateTest.java b/hadoop-gremlin/src/test/java/org/apache/tinkerpop/gremlin/hadoop/HadoopGraphFeatureIntegrateTest.java
index b9fad5f7c8..32e76ab964 100644
--- a/hadoop-gremlin/src/test/java/org/apache/tinkerpop/gremlin/hadoop/HadoopGraphFeatureIntegrateTest.java
+++ b/hadoop-gremlin/src/test/java/org/apache/tinkerpop/gremlin/hadoop/HadoopGraphFeatureIntegrateTest.java
@@ -53,7 +53,7 @@ import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerOnly and not @TinkerServiceRegistry and not @InsertionOrderingRequired",
+        tags = "not @GraphComputerOnly and not @TinkerServiceRegistry and not @InsertionOrderingRequired",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = GuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java b/neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java
index 06cd60bfb3..a3485a4c83 100644
--- a/neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java
+++ b/neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java
@@ -50,7 +50,7 @@ import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @MultiProperties and not @MetaProperties and not @GraphComputerOnly and " +
+        tags = "not @MultiProperties and not @MetaProperties and not @GraphComputerOnly and " +
                "not @AllowNullPropertyValues and not @UserSuppliedVertexPropertyIds and not @UserSuppliedEdgeIds and " +
                "not @UserSuppliedVertexIds and not @TinkerServiceRegistry and not @InsertionOrderingRequired",
         glue = { "org.apache.tinkerpop.gremlin.features" },
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphFeatureTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphFeatureTest.java
index 8f03a7e991..26eff10056 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphFeatureTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphFeatureTest.java
@@ -30,7 +30,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerOnly and not @AllowNullPropertyValues",
+        tags = "not @GraphComputerOnly and not @AllowNullPropertyValues",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = TinkerGraphFeatureTest.TinkerGraphGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerShuffleGraphFeatureTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerShuffleGraphFeatureTest.java
index 13637e15da..804bc1b75f 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerShuffleGraphFeatureTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerShuffleGraphFeatureTest.java
@@ -30,7 +30,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerOnly and not @AllowNullPropertyValues and not @InsertionOrderingRequired",
+        tags = "not @GraphComputerOnly and not @AllowNullPropertyValues and not @InsertionOrderingRequired",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = TinkerShuffleGraphFeatureTest.TinkerShuffleGraphGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphFeatureTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphFeatureTest.java
index 937fdf14bb..102ec732df 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphFeatureTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphFeatureTest.java
@@ -30,7 +30,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerOnly and not @AllowNullPropertyValues and not @InsertionOrderingRequired",
+        tags = "not @GraphComputerOnly and not @AllowNullPropertyValues and not @InsertionOrderingRequired",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = TinkerTransactionGraphFeatureTest.TinkerGraphGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },


(tinkerpop) 05/11: Centralized graph computer test tag set

Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 04bb293ee88261607dbf85e77bcc70fd011a6d6f
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Wed Apr 16 07:55:41 2025 -0400

    Centralized graph computer test tag set
---
 .../GraphBinaryRemoteComputerFeatureTest.java      |  2 +-
 .../remote/GraphSONRemoteComputerFeatureTest.java  |  2 +-
 .../driver/remote/GraphSONRemoteFeatureTest.java   |  2 +-
 .../gremlin/driver/remote/RemoteWorld.java         | 37 ----------------------
 .../apache/tinkerpop/gremlin/features/World.java   | 15 +++++++++
 .../spark/SparkGraphFeatureIntegrateTest.java      |  9 ++----
 .../TinkerGraphComputerFeatureTest.java            |  2 +-
 .../TinkerTransactionGraphComputerFeatureTest.java |  2 +-
 .../tinkerpop/gremlin/tinkergraph/TinkerWorld.java | 28 ----------------
 9 files changed, 22 insertions(+), 77 deletions(-)

diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteComputerFeatureTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteComputerFeatureTest.java
index 0d04270b1f..3be1c8a509 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteComputerFeatureTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphBinaryRemoteComputerFeatureTest.java
@@ -30,7 +30,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly",
+        tags = World.GRAPHCOMPUTER_TAG_FILTER,
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = GraphBinaryRemoteComputerFeatureTest.RemoteGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteComputerFeatureTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteComputerFeatureTest.java
index 2f9b17742b..22fed68201 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteComputerFeatureTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteComputerFeatureTest.java
@@ -30,7 +30,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly",
+        tags = World.GRAPHCOMPUTER_TAG_FILTER + " and not @StepSubgraph", // TINKERPOP-3154
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = GraphSONRemoteComputerFeatureTest.RemoteGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteFeatureTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteFeatureTest.java
index 901ac413b1..6eeba5dc9a 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteFeatureTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/GraphSONRemoteFeatureTest.java
@@ -30,7 +30,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @GraphComputerOnly and not @AllowNullPropertyValues",
+        tags = "not @RemoteOnly and not @GraphComputerOnly and not @AllowNullPropertyValues and not @StepSubgraph", // TINKERPOP-3154
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = GraphSONRemoteFeatureTest.RemoteGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/RemoteWorld.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/RemoteWorld.java
index 966d50cf4a..5735a67f8f 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/RemoteWorld.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/driver/remote/RemoteWorld.java
@@ -111,23 +111,6 @@ public abstract class RemoteWorld implements World {
      * instances that include the VertexProgramStrategy.
      */
     public abstract static class RemoteComputerWorld extends RemoteWorld {
-        private static final List<String> TAGS_TO_IGNORE = Arrays.asList(
-                "@StepDrop",
-                "@StepInject",
-                "@StepMidV",
-                "@StepMidE",
-                "@StepSubgraph",
-                "@InsertionOrderingRequired",
-                "@StepIndex",
-                "@GraphComputerVerificationElementSupported",
-                "@GraphComputerVerificationOneBulk",
-                "@GraphComputerVerificationStrategyNotSupported",
-                "@GraphComputerVerificationMidENotSupported",
-                "@GraphComputerVerificationMidVNotSupported",
-                "@GraphComputerVerificationInjectionNotSupported",
-                "@GraphComputerVerificationStarGraphExceeded",
-                "@GraphComputerVerificationReferenceOnly",
-                "@TinkerServiceRegistry");
 
         private final int AVAILABLE_PROCESSORS = Runtime.getRuntime().availableProcessors();
 
@@ -135,15 +118,6 @@ public abstract class RemoteWorld implements World {
             super(cluster);
         }
 
-        @Override
-        public void beforeEachScenario(final Scenario scenario) {
-            final List<String> ignores = TAGS_TO_IGNORE.stream().filter(t -> scenario.getSourceTagNames().contains(t)).collect(Collectors.toList());
-            if (!ignores.isEmpty())
-                throw new AssumptionViolatedException(String.format("This scenario is not supported with GraphComputer: %s", ignores));
-
-            super.beforeEachScenario(scenario);
-        }
-
         @Override
         public GraphTraversalSource getGraphTraversalSource(final LoadGraphWith.GraphData graphData) {
             if (null == graphData) throw new AssumptionViolatedException("GraphComputer does not support mutation");
@@ -180,17 +154,6 @@ public abstract class RemoteWorld implements World {
 
     public static class GraphSONRemoteWorld extends RemoteWorld {
         public GraphSONRemoteWorld() { super(createTestCluster(Serializers.GRAPHSON_V3)); }
-
-        @Override
-        public void beforeEachScenario(final Scenario scenario) {
-            // not sure if it is expected or not that subgraph() does not work with GraphSON fully.
-            // getting serialization problems
-            final List<String> ignores = Arrays.asList("@StepSubgraph").stream().filter(t -> scenario.getSourceTagNames().contains(t)).collect(Collectors.toList());
-            if (!ignores.isEmpty())
-                throw new AssumptionViolatedException(String.format("This scenario is not supported with GraphComputer: %s", ignores));
-
-            super.beforeEachScenario(scenario);
-        }
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/World.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/World.java
index 52a977e614..ec0fb4f447 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/World.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/World.java
@@ -19,6 +19,7 @@
 package org.apache.tinkerpop.gremlin.features;
 
 import io.cucumber.java.Scenario;
+import io.cucumber.junit.CucumberOptions;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
 import org.apache.tinkerpop.gremlin.structure.Element;
 import org.apache.tinkerpop.gremlin.structure.T;
@@ -33,6 +34,20 @@ import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData;
  */
 public interface World {
 
+    /**
+     * Tag filter string for tests that will not run for tests using {@code withComputer()}. This is a helpful start
+     * point to filtering away tests using the "tags" argument for {@link CucumberOptions}.
+     */
+    public static final String GRAPHCOMPUTER_TAG_FILTER =
+            "not @RemoteOnly and " +
+            "not @StepDrop and not @StepV and not @StepE and not @StepIndex and not @StepInject and " +
+            "not @StepSubgraph and not @GraphComputerVerificationMidENotSupported and " +
+            "not @GraphComputerVerificationOneBulk and not @GraphComputerVerificationStrategyNotSupported and " +
+            "not @GraphComputerVerificationMidVNotSupported and not @GraphComputerVerificationElementSupported and " +
+            "not @GraphComputerVerificationInjectionNotSupported and " +
+            "not @GraphComputerVerificationStarGraphExceeded and not @GraphComputerVerificationReferenceOnly and " +
+            "not @TinkerServiceRegistry and not @InsertionOrderingRequired";
+
     /**
      * Gets a {@link GraphTraversalSource} that is backed by the specified {@link GraphData}. For {@code null}, the
      * returned source should be an empty graph with no data in it. Tests do not mutate the standard graphs. Only tests
diff --git a/spark-gremlin/src/test/java/org/apache/tinkerpop/gremlin/spark/SparkGraphFeatureIntegrateTest.java b/spark-gremlin/src/test/java/org/apache/tinkerpop/gremlin/spark/SparkGraphFeatureIntegrateTest.java
index 404bad3830..bcbeaa6d9f 100644
--- a/spark-gremlin/src/test/java/org/apache/tinkerpop/gremlin/spark/SparkGraphFeatureIntegrateTest.java
+++ b/spark-gremlin/src/test/java/org/apache/tinkerpop/gremlin/spark/SparkGraphFeatureIntegrateTest.java
@@ -54,16 +54,11 @@ import java.util.Map;
 import java.util.Optional;
 
 import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData;
+import static org.apache.tinkerpop.gremlin.features.World.GRAPHCOMPUTER_TAG_FILTER;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly and not @StepDrop and not @StepV and not @StepE and not @StepIndex and not @StepInject and " +
-               "not @StepSubgraph and not @GraphComputerVerificationMidENotSupported and " +
-               "not @GraphComputerVerificationOneBulk and not @GraphComputerVerificationStrategyNotSupported and " +
-               "not @GraphComputerVerificationMidVNotSupported and not @GraphComputerVerificationElementSupported and " +
-               "not @GraphComputerVerificationInjectionNotSupported and " +
-               "not @GraphComputerVerificationStarGraphExceeded and not @GraphComputerVerificationReferenceOnly and " +
-               "not @TinkerServiceRegistry and not @InsertionOrderingRequired and not @WithElementIdStrategy",
+        tags = GRAPHCOMPUTER_TAG_FILTER + " and not @WithElementIdStrategy",
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = GuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphComputerFeatureTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphComputerFeatureTest.java
index 51b39756e4..c3145bface 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphComputerFeatureTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerGraphComputerFeatureTest.java
@@ -31,7 +31,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly",
+        tags = World.GRAPHCOMPUTER_TAG_FILTER,
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = TinkerGraphComputerFeatureTest.TinkerGraphGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphComputerFeatureTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphComputerFeatureTest.java
index 748c6dd609..5b85e0d37f 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphComputerFeatureTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerTransactionGraphComputerFeatureTest.java
@@ -31,7 +31,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(
-        tags = "not @RemoteOnly",
+        tags = World.GRAPHCOMPUTER_TAG_FILTER,
         glue = { "org.apache.tinkerpop.gremlin.features" },
         objectFactory = TinkerTransactionGraphComputerFeatureTest.TinkerGraphGuiceFactory.class,
         features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerWorld.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerWorld.java
index ca94f2d7ea..0d69f0b0c7 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerWorld.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/TinkerWorld.java
@@ -280,25 +280,6 @@ public abstract class TinkerWorld implements World {
     public static class ComputerWorld implements World {
         private static final Random RANDOM = TestHelper.RANDOM;
 
-        /**
-         * Defining these here allows them to be globally ignored for all {@code withComputer()} test setups.
-         */
-        private static final List<String> TAGS_TO_IGNORE = Arrays.asList(
-                "@StepDrop",
-                "@StepInject",
-                "@StepSubgraph",
-                "@InsertionOrderingRequired",
-                "@StepIndex",
-                "@GraphComputerVerificationElementSupported",
-                "@GraphComputerVerificationOneBulk",
-                "@GraphComputerVerificationStrategyNotSupported",
-                "@GraphComputerVerificationMidENotSupported",
-                "@GraphComputerVerificationMidVNotSupported",
-                "@GraphComputerVerificationInjectionNotSupported",
-                "@GraphComputerVerificationStarGraphExceeded",
-                "@GraphComputerVerificationReferenceOnly",
-                "@TinkerServiceRegistry");
-
         private final World world;
 
         public ComputerWorld(final World world) { this.world = world; }
@@ -316,15 +297,6 @@ public abstract class TinkerWorld implements World {
             }})));
         }
 
-        @Override
-        public void beforeEachScenario(final Scenario scenario) {
-            final List<String> ignores = TAGS_TO_IGNORE.stream().filter(t -> scenario.getSourceTagNames().contains(t)).collect(Collectors.toList());
-            if (!ignores.isEmpty())
-                throw new AssumptionViolatedException(String.format("This scenario is not supported with GraphComputer: %s", ignores));
-
-            this.world.beforeEachScenario(scenario);
-        }
-
         @Override
         public void afterEachScenario() {
             this.world.afterEachScenario();


(tinkerpop) 11/11: address feedback

Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch TINKERPOP-3136
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 6b3ca5534692a88036d1e88863019d2d9010f9e8
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Tue Apr 22 07:30:47 2025 -0400

    address feedback
---
 docs/src/dev/developer/for-committers.asciidoc               |  2 +-
 .../gremlin/process/traversal/step/util/TreeTest.java        | 12 +++++++++---
 .../apache/tinkerpop/gremlin/features/StepDefinition.java    |  6 ++----
 neo4j-gremlin/pom.xml                                        |  1 +
 4 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/docs/src/dev/developer/for-committers.asciidoc b/docs/src/dev/developer/for-committers.asciidoc
index c890ede3af..390d73e2c6 100644
--- a/docs/src/dev/developer/for-committers.asciidoc
+++ b/docs/src/dev/developer/for-committers.asciidoc
@@ -503,7 +503,7 @@ of traversal iteration where "_comparison_" may be one of "containing", "startin
 * "the result should be of" - results can be any of the specified values and in any order (use when guarantees
 regarding the exact results cannot be pre-determined easily - see the `range()`-step tests for examples)
 * "the result should be a graph with the following" - asserts a subgraph where the associated datatable is headed with
-"vertices" or "edges" with a set of expected vertex or edge definitions
+"vertices" or "edges" with a set of expected vertex or edge definitions (can only be used with the "modern" graph data)
 * "the result should be a tree with a structure of" - asserts a tree structure given as an asciiart representation of
 the expected tree.
 
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TreeTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TreeTest.java
index 180d0e3612..af8441ac3d 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TreeTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TreeTest.java
@@ -118,8 +118,12 @@ public class TreeTest extends StepTest {
         tree.get("root").put("child2", child2);
 
         // either can be expected since Tree doesn't maintain node order
-        final String expected1 = "|--root\n   |--child1\n   |--child2";
-        final String expected2 = "|--root\n   |--child2\n   |--child1";
+        final String expected1 = "|--root" + System.lineSeparator() +
+                                 "   |--child1" + System.lineSeparator() +
+                                 "   |--child2";
+        final String expected2 = "|--root" + System.lineSeparator() +
+                                 "   |--child2" + System.lineSeparator() +
+                                 "   |--child1";
         assertThat(tree.prettyPrint(), Matchers.anyOf(Matchers.is(expected1), Matchers.is(expected2)));
     }
 
@@ -132,7 +136,9 @@ public class TreeTest extends StepTest {
         tree.get("root").put("child1", child1);
         tree.get("root").get("child1").put("grandchild", grandchild);
 
-        final String expected = "|--root\n   |--child1\n      |--grandchild";
+        final String expected = "|--root" + System.lineSeparator() +
+                                "   |--child1" + System.lineSeparator() +
+                                "      |--grandchild";
         assertEquals(expected, tree.prettyPrint());
     }
 
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
index 3feb406efc..39e6338cbe 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/features/StepDefinition.java
@@ -87,8 +87,6 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Optional;
-import java.util.Stack;
 import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -737,7 +735,7 @@ public final class StepDefinition {
     public List<TreeNode> parseTree(final String asciiTree) {
         if (asciiTree.isEmpty()) return Collections.emptyList();
 
-        final List<String> lines = Arrays.asList(asciiTree.split("\n"));
+        final List<String> lines = Arrays.asList(asciiTree.split(System.lineSeparator()));
 
         final List<TreeNode> roots = new ArrayList<>();
         final Map<Integer, TreeNode> levelMap = new HashMap<>();
@@ -764,7 +762,7 @@ public final class StepDefinition {
             if (c == ' ') count++;
             else break;
         }
-        return count / 3; // Assuming 4 spaces per level
+        return count / 3; // Assuming 3 spaces per level
     }
 
     /**
diff --git a/neo4j-gremlin/pom.xml b/neo4j-gremlin/pom.xml
index c0e7091dc6..ed4b6b2e72 100644
--- a/neo4j-gremlin/pom.xml
+++ b/neo4j-gremlin/pom.xml
@@ -54,6 +54,7 @@ limitations under the License.
             <groupId>org.apache.tinkerpop</groupId>
             <artifactId>tinkergraph-gremlin</artifactId>
             <version>${project.version}</version>
+            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>com.google.inject</groupId>