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

andreac pushed a commit to branch 3.8-dev
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git


The following commit(s) were added to refs/heads/3.8-dev by this push:
     new 980e2c3cbd Added by('name') modulator to order() for better 
predictability of output of feature tests. (#3260)
980e2c3cbd is described below

commit 980e2c3cbd4ca95dcb3fda3d586db672b3a29ef9
Author: andreachild <[email protected]>
AuthorDate: Thu Oct 30 16:07:59 2025 -0700

    Added by('name') modulator to order() for better predictability of output 
of feature tests. (#3260)
---
 .../test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs      |  8 ++++----
 gremlin-go/driver/cucumber/gremlin.go                        |  8 ++++----
 .../javascript/gremlin-javascript/test/cucumber/gremlin.js   |  8 ++++----
 gremlin-python/src/main/python/radish/gremlin.py             |  8 ++++----
 .../test/features/integrated/EarlyLimitStrategy.feature      | 12 ++++++------
 .../test/features/integrated/RepeatUnrollStrategy.feature    |  8 ++++----
 6 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs 
b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
index c415067399..84bc0d5250 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
@@ -696,8 +696,8 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                
{"g_withoutStrategiesXConnectiveStrategyX_V_hasXname_markoX_or_whereXinXknowsX_hasXname_markoXX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithoutStrategies(typeof(ConnectiveStrategy)).V().Has("name", 
"marko").Or().Where(__.In("knows").Has("name", "marko"))}}, 
                {"g_withStrategiesXCountStrategyX_V_whereXoutE_count_isX0XX", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new 
CountStrategy()).V().Where(__.OutE().Count().Is(0))}}, 
                
{"g_withoutStrategiesXCountStrategyX_V_whereXoutE_count_isX0XX", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithoutStrategies(typeof(CountStrategy)).V().Where(__.OutE().Count().Is(0))}},
 
-               
{"g_withStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new 
EarlyLimitStrategy()).V().Out().Order().ValueMap<object, 
object>().Limit<object>(3).Select<object>("name")}}, 
-               
{"g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithoutStrategies(typeof(EarlyLimitStrategy)).V().Out().Order().ValueMap<object,
 object>().Limit<object>(3).Select<object>("name")}}, 
+               
{"g_withStrategiesXEarlyLimitStrategyX_V_out_order_byXnameX_valueMap_limitX3X_selectXnameX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new 
EarlyLimitStrategy()).V().Out().Order().By("name").ValueMap<object, 
object>().Limit<object>(3).Select<object>("name")}}, 
+               
{"g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_byXnameX_valueMap_limitX3X_selectXnameX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithoutStrategies(typeof(EarlyLimitStrategy)).V().Out().Order().By("name").ValueMap<object,
 object>().Limit<object>(3).Select<object>("name")}}, 
                
{"g_withStrategiesXEdgeLabelVerificationStrategyXthrowException_true_logWarning_falseXX_V",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new EdgeLabelVerificationStrategy(throwException: 
true, logWarning: false)).V().Out()}}, 
                
{"g_withStrategiesXEdgeLabelVerificationStrategyXthrowException_false_logWarning_falseXX_V",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new EdgeLabelVerificationStrategy(throwException: 
false, logWarning: false)).V().Out()}}, 
                {"g_withoutStrategiesXEdgeLabelVerificationStrategyX_V", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithoutStrategies(typeof(EdgeLabelVerificationStrategy)).V().Out()}}, 
@@ -793,8 +793,8 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                
{"g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXbothE_otherV_hasXage_ltX30XXX_timesX2X",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithoutStrategies(typeof(RepeatUnrollStrategy)).V().Repeat(__.BothE().OtherV().Has("age",
 P.Lt(30))).Times(2)}}, 
                
{"g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_limitX1XX_timesX2X", new 
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new 
RepeatUnrollStrategy()).V().Repeat(__.Both().Limit<object>(1)).Times(2)}}, 
                
{"g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_limitX1XX_timesX2X", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithoutStrategies(typeof(RepeatUnrollStrategy)).V().Repeat(__.Both().Limit<object>(1)).Times(2)}},
 
-               
{"g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_aggregateXxXX_timesX2X_limitX10X",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new 
RepeatUnrollStrategy()).V().Order().Repeat(__.Both().Order().Aggregate("x")).Times(2).Limit<object>(10)}},
 
-               
{"g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_aggregateXxXX_timesX2X_limitX10X",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithoutStrategies(typeof(RepeatUnrollStrategy)).V().Order().Repeat(__.Both().Order().Aggregate("x")).Times(2).Limit<object>(10)}},
 
+               
{"g_withStrategiesXRepeatUnrollStrategyX_V_order_byXnameX_repeatXboth_aggregateXxXX_timesX2X_limitX10X",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new 
RepeatUnrollStrategy()).V().Order().By("name").Repeat(__.Both().Order().Aggregate("x")).Times(2).Limit<object>(10)}},
 
+               
{"g_withoutStrategiesXRepeatUnrollStrategyX_V_order_byXnameX_repeatXboth_aggregateXxXX_timesX2X_limitX10X",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithoutStrategies(typeof(RepeatUnrollStrategy)).V().Order().By("name").Repeat(__.Both().Order().Aggregate("x")).Times(2).Limit<object>(10)}},
 
                
{"g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_sampleX1XX_timesX2X", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new 
RepeatUnrollStrategy()).V().Repeat(__.Both().Sample(1)).Times(2)}}, 
                
{"g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_sampleX1XX_timesX2X", 
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) 
=>g.WithoutStrategies(typeof(RepeatUnrollStrategy)).V().Repeat(__.Both().Sample(1)).Times(2)}},
 
                
{"g_withStrategiesXReservedKeysVerificationStrategyXthrowException_trueXX_addVXpersonX_propertyXid_123X_propertyXname_markoX",
 new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> 
{(g,p) =>g.WithStrategies(new ReservedKeysVerificationStrategy(throwException: 
true)).AddV("person").Property("id", 123).Property("name", "marko")}}, 
diff --git a/gremlin-go/driver/cucumber/gremlin.go 
b/gremlin-go/driver/cucumber/gremlin.go
index 9f2b8a2e0c..d28e76f6b5 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -666,8 +666,8 @@ var translationMap = map[string][]func(g 
*gremlingo.GraphTraversalSource, p map[
     
"g_withoutStrategiesXConnectiveStrategyX_V_hasXname_markoX_or_whereXinXknowsX_hasXname_markoXX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.ConnectiveStrategy()).V().Has("name", 
"marko").Or().Where(gremlingo.T__.In("knows").Has("name", "marko"))}}, 
     "g_withStrategiesXCountStrategyX_V_whereXoutE_count_isX0XX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.CountStrategy()).V().Where(gremlingo.T__.OutE().Count().Is(0))}},
 
     "g_withoutStrategiesXCountStrategyX_V_whereXoutE_count_isX0XX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.CountStrategy()).V().Where(gremlingo.T__.OutE().Count().Is(0))}},
 
-    
"g_withStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.EarlyLimitStrategy()).V().Out().Order().ValueMap().Limit(3).Select("name")}},
 
-    
"g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.EarlyLimitStrategy()).V().Out().Order().ValueMap().Limit(3).Select("name")}},
 
+    
"g_withStrategiesXEarlyLimitStrategyX_V_out_order_byXnameX_valueMap_limitX3X_selectXnameX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.EarlyLimitStrategy()).V().Out().Order().By("name").ValueMap().Limit(3).Select("name")}},
 
+    
"g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_byXnameX_valueMap_limitX3X_selectXnameX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.EarlyLimitStrategy()).V().Out().Order().By("name").ValueMap().Limit(3).Select("name")}},
 
     
"g_withStrategiesXEdgeLabelVerificationStrategyXthrowException_true_logWarning_falseXX_V":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.EdgeLabelVerificationStrategy(gremlingo.EdgeLabelVerificationStrategyConfig{ThrowException:
 true, LogWarning: false})).V().Out()}}, 
     
"g_withStrategiesXEdgeLabelVerificationStrategyXthrowException_false_logWarning_falseXX_V":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.EdgeLabelVerificationStrategy(gremlingo.EdgeLabelVerificationStrategyConfig{ThrowException:
 false, LogWarning: false})).V().Out()}}, 
     "g_withoutStrategiesXEdgeLabelVerificationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.EdgeLabelVerificationStrategy()).V().Out()}}, 
@@ -763,8 +763,8 @@ var translationMap = map[string][]func(g 
*gremlingo.GraphTraversalSource, p map[
     
"g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXbothE_otherV_hasXage_ltX30XXX_timesX2X":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.RepeatUnrollStrategy()).V().Repeat(gremlingo.T__.BothE().OtherV().Has("age",
 gremlingo.P.Lt(30))).Times(2)}}, 
     "g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_limitX1XX_timesX2X": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.RepeatUnrollStrategy()).V().Repeat(gremlingo.T__.Both().Limit(1)).Times(2)}},
 
     
"g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_limitX1XX_timesX2X": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.RepeatUnrollStrategy()).V().Repeat(gremlingo.T__.Both().Limit(1)).Times(2)}},
 
-    
"g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_aggregateXxXX_timesX2X_limitX10X":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.RepeatUnrollStrategy()).V().Order().Repeat(gremlingo.T__.Both().Order().Aggregate("x")).Times(2).Limit(10)}},
 
-    
"g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_aggregateXxXX_timesX2X_limitX10X":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.RepeatUnrollStrategy()).V().Order().Repeat(gremlingo.T__.Both().Order().Aggregate("x")).Times(2).Limit(10)}},
 
+    
"g_withStrategiesXRepeatUnrollStrategyX_V_order_byXnameX_repeatXboth_aggregateXxXX_timesX2X_limitX10X":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.RepeatUnrollStrategy()).V().Order().By("name").Repeat(gremlingo.T__.Both().Order().Aggregate("x")).Times(2).Limit(10)}},
 
+    
"g_withoutStrategiesXRepeatUnrollStrategyX_V_order_byXnameX_repeatXboth_aggregateXxXX_timesX2X_limitX10X":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.RepeatUnrollStrategy()).V().Order().By("name").Repeat(gremlingo.T__.Both().Order().Aggregate("x")).Times(2).Limit(10)}},
 
     
"g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_sampleX1XX_timesX2X": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.RepeatUnrollStrategy()).V().Repeat(gremlingo.T__.Both().Sample(1)).Times(2)}},
 
     
"g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_sampleX1XX_timesX2X": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.RepeatUnrollStrategy()).V().Repeat(gremlingo.T__.Both().Sample(1)).Times(2)}},
 
     
"g_withStrategiesXReservedKeysVerificationStrategyXthrowException_trueXX_addVXpersonX_propertyXid_123X_propertyXname_markoX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ReservedKeysVerificationStrategy(gremlingo.ReservedKeysVerificationStrategyConfig{ThrowException:
 true})).AddV("person").Property("id", 123).Property("name", "marko")}}, 
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 cc9556916f..b6d1d754da 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
@@ -697,8 +697,8 @@ const gremlins = {
     
g_withoutStrategiesXConnectiveStrategyX_V_hasXname_markoX_or_whereXinXknowsX_hasXname_markoXX:
 [function({g}) { return 
g.withoutStrategies(ConnectiveStrategy).V().has("name", 
"marko").or().where(__.in_("knows").has("name", "marko")) }], 
     g_withStrategiesXCountStrategyX_V_whereXoutE_count_isX0XX: [function({g}) 
{ return g.withStrategies(new 
CountStrategy()).V().where(__.outE().count().is(0)) }], 
     g_withoutStrategiesXCountStrategyX_V_whereXoutE_count_isX0XX: 
[function({g}) { return 
g.withoutStrategies(CountStrategy).V().where(__.outE().count().is(0)) }], 
-    
g_withStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX:
 [function({g}) { return g.withStrategies(new 
EarlyLimitStrategy()).V().out().order().valueMap().limit(3).select("name") }], 
-    
g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX:
 [function({g}) { return 
g.withoutStrategies(EarlyLimitStrategy).V().out().order().valueMap().limit(3).select("name")
 }], 
+    
g_withStrategiesXEarlyLimitStrategyX_V_out_order_byXnameX_valueMap_limitX3X_selectXnameX:
 [function({g}) { return g.withStrategies(new 
EarlyLimitStrategy()).V().out().order().by("name").valueMap().limit(3).select("name")
 }], 
+    
g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_byXnameX_valueMap_limitX3X_selectXnameX:
 [function({g}) { return 
g.withoutStrategies(EarlyLimitStrategy).V().out().order().by("name").valueMap().limit(3).select("name")
 }], 
     
g_withStrategiesXEdgeLabelVerificationStrategyXthrowException_true_logWarning_falseXX_V:
 [function({g}) { return g.withStrategies(new 
EdgeLabelVerificationStrategy({throwException: true, logWarning: 
false})).V().out() }], 
     
g_withStrategiesXEdgeLabelVerificationStrategyXthrowException_false_logWarning_falseXX_V:
 [function({g}) { return g.withStrategies(new 
EdgeLabelVerificationStrategy({throwException: false, logWarning: 
false})).V().out() }], 
     g_withoutStrategiesXEdgeLabelVerificationStrategyX_V: [function({g}) { 
return g.withoutStrategies(EdgeLabelVerificationStrategy).V().out() }], 
@@ -794,8 +794,8 @@ const gremlins = {
     
g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXbothE_otherV_hasXage_ltX30XXX_timesX2X:
 [function({g}) { return 
g.withoutStrategies(RepeatUnrollStrategy).V().repeat(__.bothE().otherV().has("age",
 P.lt(30))).times(2) }], 
     g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_limitX1XX_timesX2X: 
[function({g}) { return g.withStrategies(new 
RepeatUnrollStrategy()).V().repeat(__.both().limit(1)).times(2) }], 
     
g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_limitX1XX_timesX2X: 
[function({g}) { return 
g.withoutStrategies(RepeatUnrollStrategy).V().repeat(__.both().limit(1)).times(2)
 }], 
-    
g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_aggregateXxXX_timesX2X_limitX10X:
 [function({g}) { return g.withStrategies(new 
RepeatUnrollStrategy()).V().order().repeat(__.both().order().aggregate("x")).times(2).limit(10)
 }], 
-    
g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_aggregateXxXX_timesX2X_limitX10X:
 [function({g}) { return 
g.withoutStrategies(RepeatUnrollStrategy).V().order().repeat(__.both().order().aggregate("x")).times(2).limit(10)
 }], 
+    
g_withStrategiesXRepeatUnrollStrategyX_V_order_byXnameX_repeatXboth_aggregateXxXX_timesX2X_limitX10X:
 [function({g}) { return g.withStrategies(new 
RepeatUnrollStrategy()).V().order().by("name").repeat(__.both().order().aggregate("x")).times(2).limit(10)
 }], 
+    
g_withoutStrategiesXRepeatUnrollStrategyX_V_order_byXnameX_repeatXboth_aggregateXxXX_timesX2X_limitX10X:
 [function({g}) { return 
g.withoutStrategies(RepeatUnrollStrategy).V().order().by("name").repeat(__.both().order().aggregate("x")).times(2).limit(10)
 }], 
     g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_sampleX1XX_timesX2X: 
[function({g}) { return g.withStrategies(new 
RepeatUnrollStrategy()).V().repeat(__.both().sample(1)).times(2) }], 
     
g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_sampleX1XX_timesX2X: 
[function({g}) { return 
g.withoutStrategies(RepeatUnrollStrategy).V().repeat(__.both().sample(1)).times(2)
 }], 
     
g_withStrategiesXReservedKeysVerificationStrategyXthrowException_trueXX_addVXpersonX_propertyXid_123X_propertyXname_markoX:
 [function({g}) { return g.withStrategies(new 
ReservedKeysVerificationStrategy({throwException: 
true})).addV("person").property("id", 123).property("name", "marko") }], 
diff --git a/gremlin-python/src/main/python/radish/gremlin.py 
b/gremlin-python/src/main/python/radish/gremlin.py
index 95651581ee..2e06dd0462 100644
--- a/gremlin-python/src/main/python/radish/gremlin.py
+++ b/gremlin-python/src/main/python/radish/gremlin.py
@@ -669,8 +669,8 @@ world.gremlins = {
     
'g_withoutStrategiesXConnectiveStrategyX_V_hasXname_markoX_or_whereXinXknowsX_hasXname_markoXX':
 [(lambda 
g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ConnectiveStrategy')]).V().has('name',
 'marko').or_().where(__.in_('knows').has('name', 'marko')))], 
     'g_withStrategiesXCountStrategyX_V_whereXoutE_count_isX0XX': [(lambda 
g:g.with_strategies(CountStrategy()).V().where(__.out_e().count().is_(0)))], 
     'g_withoutStrategiesXCountStrategyX_V_whereXoutE_count_isX0XX': [(lambda 
g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.CountStrategy')]).V().where(__.out_e().count().is_(0)))],
 
-    
'g_withStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX':
 [(lambda 
g:g.with_strategies(EarlyLimitStrategy()).V().out().order().value_map().limit(3).select('name'))],
 
-    
'g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX':
 [(lambda 
g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.EarlyLimitStrategy')]).V().out().order().value_map().limit(3).select('name'))],
 
+    
'g_withStrategiesXEarlyLimitStrategyX_V_out_order_byXnameX_valueMap_limitX3X_selectXnameX':
 [(lambda 
g:g.with_strategies(EarlyLimitStrategy()).V().out().order().by('name').value_map().limit(3).select('name'))],
 
+    
'g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_byXnameX_valueMap_limitX3X_selectXnameX':
 [(lambda 
g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.EarlyLimitStrategy')]).V().out().order().by('name').value_map().limit(3).select('name'))],
 
     
'g_withStrategiesXEdgeLabelVerificationStrategyXthrowException_true_logWarning_falseXX_V':
 [(lambda 
g:g.with_strategies(EdgeLabelVerificationStrategy(throw_exception=True, 
log_warning=False)).V().out())], 
     
'g_withStrategiesXEdgeLabelVerificationStrategyXthrowException_false_logWarning_falseXX_V':
 [(lambda 
g:g.with_strategies(EdgeLabelVerificationStrategy(throw_exception=False, 
log_warning=False)).V().out())], 
     'g_withoutStrategiesXEdgeLabelVerificationStrategyX_V': [(lambda 
g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy')]).V().out())],
 
@@ -766,8 +766,8 @@ world.gremlins = {
     
'g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXbothE_otherV_hasXage_ltX30XXX_timesX2X':
 [(lambda 
g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.RepeatUnrollStrategy')]).V().repeat(__.both_e().other_v().has('age',
 P.lt(30))).times(2))], 
     'g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_limitX1XX_timesX2X': 
[(lambda 
g:g.with_strategies(RepeatUnrollStrategy()).V().repeat(__.both().limit(1)).times(2))],
 
     
'g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_limitX1XX_timesX2X': 
[(lambda 
g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.RepeatUnrollStrategy')]).V().repeat(__.both().limit(1)).times(2))],
 
-    
'g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_aggregateXxXX_timesX2X_limitX10X':
 [(lambda 
g:g.with_strategies(RepeatUnrollStrategy()).V().order().repeat(__.both().order().aggregate('x')).times(2).limit(10))],
 
-    
'g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_aggregateXxXX_timesX2X_limitX10X':
 [(lambda 
g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.RepeatUnrollStrategy')]).V().order().repeat(__.both().order().aggregate('x')).times(2).limit(10))],
 
+    
'g_withStrategiesXRepeatUnrollStrategyX_V_order_byXnameX_repeatXboth_aggregateXxXX_timesX2X_limitX10X':
 [(lambda 
g:g.with_strategies(RepeatUnrollStrategy()).V().order().by('name').repeat(__.both().order().aggregate('x')).times(2).limit(10))],
 
+    
'g_withoutStrategiesXRepeatUnrollStrategyX_V_order_byXnameX_repeatXboth_aggregateXxXX_timesX2X_limitX10X':
 [(lambda 
g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.RepeatUnrollStrategy')]).V().order().by('name').repeat(__.both().order().aggregate('x')).times(2).limit(10))],
 
     
'g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_sampleX1XX_timesX2X': 
[(lambda 
g:g.with_strategies(RepeatUnrollStrategy()).V().repeat(__.both().sample(1)).times(2))],
 
     
'g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_sampleX1XX_timesX2X': 
[(lambda 
g:g.without_strategies(*[GremlinType('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.RepeatUnrollStrategy')]).V().repeat(__.both().sample(1)).times(2))],
 
     
'g_withStrategiesXReservedKeysVerificationStrategyXthrowException_trueXX_addVXpersonX_propertyXid_123X_propertyXname_markoX':
 [(lambda 
g:g.with_strategies(ReservedKeysVerificationStrategy(throw_exception=True)).add_v('person').property('id',
 123).property('name', 'marko'))], 
diff --git 
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/EarlyLimitStrategy.feature
 
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/EarlyLimitStrategy.feature
index dcbe50be5e..ee0f8aab43 100644
--- 
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/EarlyLimitStrategy.feature
+++ 
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/EarlyLimitStrategy.feature
@@ -19,28 +19,28 @@
 Feature: Step - EarlyLimitStrategy
 
   @WithEarlyLimitStrategy
-  Scenario: 
g_withStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX
+  Scenario: 
g_withStrategiesXEarlyLimitStrategyX_V_out_order_byXnameX_valueMap_limitX3X_selectXnameX
     Given the modern graph
     And the traversal of
       """
-      
g.withStrategies(EarlyLimitStrategy).V().out().order().valueMap().limit(3).select("name")
+      
g.withStrategies(EarlyLimitStrategy).V().out().order().by('name').valueMap().limit(3).select("name")
       """
     When iterated to list
     Then the result should be unordered
       | result |
-      | l[vadas] |
+      | l[josh] |
       | l[lop] |
       | l[lop] |
 
-  Scenario: 
g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX
+  Scenario: 
g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_byXnameX_valueMap_limitX3X_selectXnameX
     Given the modern graph
     And the traversal of
       """
-      
g.withoutStrategies(EarlyLimitStrategy).V().out().order().valueMap().limit(3).select("name")
+      
g.withoutStrategies(EarlyLimitStrategy).V().out().order().by('name').valueMap().limit(3).select("name")
       """
     When iterated to list
     Then the result should be unordered
       | result |
-      | l[vadas] |
+      | l[josh] |
       | l[lop] |
       | l[lop] |
diff --git 
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/RepeatUnrollStrategy.feature
 
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/RepeatUnrollStrategy.feature
index 41f9c0a896..edae534459 100644
--- 
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/RepeatUnrollStrategy.feature
+++ 
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/integrated/RepeatUnrollStrategy.feature
@@ -211,11 +211,11 @@ Feature: Step - RepeatUnrollStrategy
   # this traversal is not expected to be unrolled by the strategy but should 
have consistent semantics compared to traversal without the strategy applied
   @WithRepeatUnrollStrategy
   @GraphComputerVerificationStrategyNotSupported
-  Scenario: 
g_withStrategiesXRepeatUnrollStrategyX_V_repeatXboth_aggregateXxXX_timesX2X_limitX10X
+  Scenario: 
g_withStrategiesXRepeatUnrollStrategyX_V_order_byXnameX_repeatXboth_aggregateXxXX_timesX2X_limitX10X
     Given the modern graph
     And the traversal of
       """
-      
g.withStrategies(RepeatUnrollStrategy).V().order().repeat(both().order().aggregate('x')).times(2).limit(10)
+      
g.withStrategies(RepeatUnrollStrategy).V().order().by('name').repeat(both().order().aggregate('x')).times(2).limit(10)
       """
     When iterated to list
     Then the result should be unordered
@@ -232,11 +232,11 @@ Feature: Step - RepeatUnrollStrategy
       | v[vadas] |
 
   @GraphComputerVerificationStrategyNotSupported
-  Scenario: 
g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXboth_aggregateXxXX_timesX2X_limitX10X
+  Scenario: 
g_withoutStrategiesXRepeatUnrollStrategyX_V_order_byXnameX_repeatXboth_aggregateXxXX_timesX2X_limitX10X
     Given the modern graph
     And the traversal of
       """
-      
g.withoutStrategies(RepeatUnrollStrategy).V().order().repeat(both().order().aggregate('x')).times(2).limit(10)
+      
g.withoutStrategies(RepeatUnrollStrategy).V().order().by('name').repeat(both().order().aggregate('x')).times(2).limit(10)
       """
     When iterated to list
     Then the result should be unordered

Reply via email to