blob: ddf99842596df6c37818d6cdd54e5e768edafef9 [file] [log] [blame]
# 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.
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 v1Id defined as "v[marko].id"
And the traversal of
"""
g.V(v1Id).has("name")
"""
When iterated to list
Then the result should be unordered
| result |
| v[marko] |
Scenario: g_VX1X_hasXcircumferenceX
Given the modern graph
And using the parameter v1Id defined as "v[marko].id"
And the traversal of
"""
g.V(v1Id).has("circumference")
"""
When iterated to list
Then the result should be empty
Scenario: g_VX1X_hasXname_markoX
Given the modern graph
And using the parameter v1Id defined as "v[marko].id"
And the traversal of
"""
g.V(v1Id).has("name", "marko")
"""
When iterated to list
Then the result should be unordered
| result |
| v[marko] |
Scenario: g_VX2X_hasXname_markoX
Given the modern graph
And using the parameter v1Id defined as "v[vadas].id"
And the traversal of
"""
g.V(v1Id).has("name", "marko")
"""
When iterated to list
Then the result should be empty
Scenario: g_V_hasXname_markoX
Given the modern graph
And the traversal of
"""
g.V().has("name", "marko")
"""
When iterated to list
Then the result should be unordered
| result |
| v[marko] |
Scenario: g_V_hasXname_blahX
Given the modern graph
And the traversal of
"""
g.V().has("name", "blah")
"""
When iterated to list
Then the result should be empty
Scenario: g_V_hasXage_gt_30X
Given the modern graph
And the traversal of
"""
g.V().has("age", P.gt(30))
"""
When iterated to list
Then the result should be unordered
| result |
| v[josh] |
| v[peter] |
Scenario: g_V_hasXage_isXgt_30XX
Given the modern graph
And the traversal of
"""
g.V().has("age", __.is(P.gt(30)))
"""
When iterated to list
Then the result should be unordered
| result |
| v[josh] |
| v[peter] |
Scenario: g_VX1X_hasXage_gt_30X
Given the modern graph
And using the parameter v1Id defined as "v[marko].id"
And the traversal of
"""
g.V(v1Id).has("age", P.gt(30))
"""
When iterated to list
Then the result should be empty
Scenario: g_VX4X_hasXage_gt_30X
Given the modern graph
And using the parameter v4Id defined as "v[josh].id"
And the traversal of
"""
g.V(v4Id).has("age", P.gt(30))
"""
When iterated to list
Then the result should be unordered
| result |
| v[josh] |
Scenario: g_VXv1X_hasXage_gt_30X
Given the modern graph
And using the parameter v1 defined as "v[marko]"
And the traversal of
"""
g.V(v1).has("age", P.gt(30))
"""
When iterated to list
Then the result should be empty
Scenario: g_VXv4X_hasXage_gt_30X
Given the modern graph
And using the parameter v4 defined as "v[josh]"
And using the parameter d30 defined as "d[30].i"
And the traversal of
"""
g.V(v4).has("age", P.gt(d30))
"""
When iterated to list
Then the result should be unordered
| result |
| v[josh] |
Scenario: g_VX1X_out_hasXid_lt_3X
Given the modern graph
And using the parameter v1Id defined as "v[marko].id"
And using the parameter v3Id defined as "v[lop].id"
And the traversal of
"""
g.V(v1Id).out().has(T.id, P.lt(v3Id))
"""
When iterated to list
Then the result should be unordered
| result |
| v[vadas] |
Scenario: g_VX1AsStringX_out_hasXid_2AsStringX
Given the modern graph
And using the parameter v1Id defined as "v[marko].sid"
And using the parameter v2Id defined as "v[vadas].sid"
And the traversal of
"""
g.V(v1Id).out().hasId(v2Id)
"""
When iterated to list
Then the result should be unordered
| result |
| v[vadas] |
Scenario: g_VX1X_out_hasXid_2X
Given the modern graph
And using the parameter v2 defined as "v[josh]"
And the traversal of
"""
g.V(v2).has("age", P.gt(30))
"""
When iterated to list
Then the result should be unordered
| result |
| v[josh] |
Scenario: g_VX1X_out_hasIdX2X
Given the modern graph
And using the parameter v1Id defined as "v[marko].id"
And using the parameter v2Id defined as "v[vadas].id"
And the traversal of
"""
g.V(v1Id).out().hasId(v2Id)
"""
When iterated to list
Then the result should be unordered
| result |
| v[vadas] |
Scenario: g_VX1X_out_hasXid_2_3X
Given the modern graph
And using the parameter v1Id defined as "v[marko].id"
And using the parameter v2Id defined as "v[vadas].id"
And using the parameter v3Id defined as "v[lop].id"
And the traversal of
"""
g.V(v1Id).out().hasId(v2Id, v3Id)
"""
When iterated to list
Then the result should be unordered
| result |
| v[vadas] |
| v[lop] |
Scenario: g_VX1X_out_hasXid_2AsString_3AsStringX
Given the modern graph
And using the parameter v1Id defined as "v[marko].sid"
And using the parameter v2Id defined as "v[vadas].sid"
And using the parameter v3Id defined as "v[lop].sid"
And the traversal of
"""
g.V(v1Id).out().hasId(v2Id, v3Id)
"""
When iterated to list
Then the result should be unordered
| result |
| v[vadas] |
| v[lop] |
Scenario: g_V_hasXblahX
Given the modern graph
And the traversal of
"""
g.V().has("blah")
"""
When iterated to list
Then the result should be empty
Scenario: g_EX7X_hasXlabelXknowsX
Given the modern graph
And using the parameter e7Id defined as "e[marko-knows->vadas].id"
And the traversal of
"""
g.E(e7Id).hasLabel("knows")
"""
When iterated to list
Then the result should be unordered
| result |
| e[marko-knows->vadas] |
Scenario: g_E_hasXlabelXknowsX
Given the modern graph
And the traversal of
"""
g.E().hasLabel("knows")
"""
When iterated to list
Then the result should be unordered
| result |
| e[marko-knows->vadas] |
| e[marko-knows->josh] |
Scenario: g_E_hasLabelXuses_traversesX
Given the crew graph
And the traversal of
"""
g.E().hasLabel("uses", "traverses")
"""
When iterated to list
Then the result should be unordered
| result |
| e[marko-uses->gremlin] |
| e[marko-uses->tinkergraph] |
| e[stephen-uses->gremlin] |
| e[stephen-uses->tinkergraph] |
| e[daniel-uses->gremlin] |
| e[daniel-uses->tinkergraph] |
| e[matthias-uses->gremlin] |
| e[matthias-uses->tinkergraph] |
| e[gremlin-traverses->tinkergraph] |
Scenario: g_V_hasLabelXperson_software_blahX
Given the modern graph
And the traversal of
"""
g.V().hasLabel("person","software", "blah")
"""
When iterated to list
Then the result should be unordered
| result |
| v[marko] |
| v[vadas] |
| v[josh] |
| v[peter] |
| v[lop] |
| v[ripple] |
Scenario: g_V_hasXperson_name_markoX_age
Given the modern graph
And the traversal of
"""
g.V().has("person", "name", "marko").values("age")
"""
When iterated to list
Then the result should be unordered
| result |
| d[29].i |
Scenario: g_VX1X_outE_hasXweight_inside_0_06X_inV
Given the modern graph
And using the parameter v1Id defined as "v[marko].id"
And using the parameter lower defined as "d[0.0].d"
And using the parameter upper defined as "d[0.6].d"
And the traversal of
"""
g.V(v1Id).outE().has("weight", P.inside(lower, upper)).inV()
"""
When iterated to list
Then the result should be unordered
| result |
| v[vadas] |
| v[lop] |
Scenario: g_EX11X_outV_outE_hasXid_10X
Given the modern graph
And using the parameter e11Id defined as "e[josh-created->lop].id"
And using the parameter e10Id defined as "e[josh-created->ripple].id"
And the traversal of
"""
g.E(e11Id).outV().outE().has(T.id, e10Id)
"""
When iterated to list
Then the result should be unordered
| result |
| e[josh-created->ripple] |
Scenario: g_EX11X_outV_outE_hasXid_10AsStringX
Given the modern graph
And using the parameter e11Id defined as "e[josh-created->lop].sid"
And using the parameter e10Id defined as "e[josh-created->ripple].sid"
And the traversal of
"""
g.E(e11Id).outV().outE().has(T.id, e10Id)
"""
When iterated to list
Then the result should be unordered
| result |
| e[josh-created->ripple] |
Scenario: g_V_hasXlocationX
Given the crew graph
And the traversal of
"""
g.V().has("location")
"""
When iterated to list
Then the result should be unordered
| result |
| v[marko] |
| v[matthias] |
| v[stephen] |
| v[daniel] |
Scenario: g_V_hasLabelXpersonX_hasXage_notXlteX10X_andXnotXbetweenX11_20XXXX_andXltX29X_orXeqX35XXXX_name
Given the modern graph
And using the parameter d10 defined as "d[10].i"
And using the parameter d11 defined as "d[11].i"
And using the parameter d20 defined as "d[20].i"
And using the parameter d29 defined as "d[29].i"
And using the parameter d35 defined as "d[35].i"
And the traversal of
"""
g.V().hasLabel("person").has("age", P.not(P.lte(d10).and(P.not(P.between(d11, d20)))).and(P.lt(d29).or(P.eq(d35)))).values("name")
"""
When iterated to list
Then the result should be unordered
| result |
| vadas |
| peter |
Scenario: g_V_in_hasIdXneqX1XX
Given the modern graph
And using the parameter v1Id defined as "v[marko].id"
And the traversal of
"""
g.V().in().hasId(P.neq(v1Id))
"""
When iterated to list
Then the result should be unordered
| result |
| v[josh] |
| v[josh] |
| v[peter] |
Scenario: g_V_both_dedup_properties_hasKeyXageX_value
Given the modern graph
And the traversal of
"""
g.V().both().properties().dedup().hasKey("age").value()
"""
When iterated to list
Then the result should be unordered
| result |
| d[29].i |
| d[27].i |
| d[32].i |
| d[35].i |
Scenario: g_V_hasXage_withinX27X_count
Given the modern graph
And the traversal of
"""
g.V().has("age", P.within(27)).count()
"""
When iterated to list
Then the result should be ordered
| result |
| d[1].l |
Scenario: g_V_hasXage_withinX27_29X_count
Given the modern graph
And the traversal of
"""
g.V().has("age", P.within(27,29)).count()
"""
When iterated to list
Then the result should be ordered
| result |
| d[2].l |
Scenario: g_V_hasXage_withoutX27X_count
Given the modern graph
And the traversal of
"""
g.V().has("age", P.without(27)).count()
"""
When iterated to list
Then the result should be ordered
| result |
| d[3].l |
Scenario: g_V_hasXage_withoutX27_29X_count
Given the modern graph
And the traversal of
"""
g.V().has("age", P.without(27,29)).count()
"""
When iterated to list
Then the result should be ordered
| result |
| d[2].l |
Scenario: g_V_both_dedup_properties_hasKeyXageX_hasValueXgtX30XX_value
Given the modern graph
And using the parameter d30 defined as "d[30].i"
And the traversal of
"""
g.V().both().properties().dedup().hasKey("age").hasValue(P.gt(d30)).value()
"""
When iterated to list
Then the result should be unordered
| result |
| d[32].i |
| d[35].i |
Scenario: g_V_hasNotXageX_name
Given the modern graph
And the traversal of
"""
g.V().hasNot("age").values("name")
"""
When iterated to list
Then the result should be unordered
| result |
| lop |
| ripple |
Scenario: g_V_hasIdX1X_hasIdX2X
Given the modern graph
And using the parameter v1Id defined as "v[marko].id"
And using the parameter v2Id defined as "v[vadas].id"
And the traversal of
"""
g.V().hasId(v1Id).hasId(v2Id)
"""
When iterated to list
Then the result should be empty
Scenario: g_V_hasLabelXpersonX_hasLabelXsoftwareX
Given the modern graph
And the traversal of
"""
g.V().hasLabel("person").hasLabel("software")
"""
When iterated to list
Then the result should be empty
Scenario: g_V_hasIdXemptyX_count
Given the modern graph
And using the parameter l defined as "l[]"
And the traversal of
"""
g.V().hasId(l).count()
"""
When iterated to list
Then the result should be unordered
| result |
| d[0].l |
Scenario: g_V_hasIdXwithinXemptyXX_count
Given the modern graph
And using the parameter l defined as "l[]"
And the traversal of
"""
g.V().hasId(P.within(l)).count()
"""
When iterated to list
Then the result should be unordered
| result |
| d[0].l |
Scenario: g_V_hasIdXwithoutXemptyXX_count
Given the modern graph
And using the parameter l defined as "l[]"
And the traversal of
"""
g.V().hasId(P.without(l)).count()
"""
When iterated to list
Then the result should be unordered
| result |
| d[6].l |
Scenario: g_V_notXhasIdXwithinXemptyXXX_count
Given the modern graph
And using the parameter l defined as "l[]"
And the traversal of
"""
g.V().not(__.hasId(P.within(l))).count()
"""
When iterated to list
Then the result should be unordered
| result |
| d[6].l |