import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void g_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);
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void shouldFilterVertexCriterionAndKeepLabels() throws Exception {
    // this will exclude "peter"
    final Traversal<Vertex, ?> vertexCriterion = __.has("name", P.within("ripple", "josh", "marko"));

    final SubgraphStrategy strategy = SubgraphStrategy.build().vertexCriterion(vertexCriterion).create();
    final GraphTraversalSource sg = create(strategy);

    assertEquals(9, g.V().as("a").out().in().as("b").dedup("a", "b").count().next().intValue());
    assertEquals(2, sg.V().as("a").out().in().as("b").dedup("a", "b").count().next().intValue());

    final List<Object> list = sg.V().as("a").out().in().as("b").dedup("a", "b").values("name").toList();
    assertThat(list, hasItems("marko", "josh"));
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@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);
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void g_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());
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith
@FeatureRequirement(featureClass = Graph.Features.VertexFeatures.class, feature = Graph.Features.VertexFeatures.FEATURE_REMOVE_VERTICES)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void g_VX1_2_3_4X_name() {
    final Traversal<Vertex, String> traversal = get_g_VX1_2_3_4X_name(convertToVertexId("marko"), convertToVertexId("vadas"), convertToVertexId("lop"), convertToVertexId("josh"));
    printTraversalForm(traversal);
    checkResults(Arrays.asList("marko", "vadas", "josh"), traversal);
    assertFalse(traversal.hasNext());
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@IgnoreEngine(TraversalEngine.Type.STANDARD) // validating the internal sort/limit works in GraphComputer
@LoadGraphWith(MODERN)
public void g_V_both_hasLabelXpersonX_order_byXage_decrX_name() {
    final Traversal<Vertex, String> traversal = get_g_V_both_hasLabelXpersonX_order_byXage_decrX_name();
    traversal.asAdmin().applyStrategies();
    if (!TraversalHelper.getFirstStepOfAssignableClass(OrderGlobalStep.class, traversal.asAdmin()).isPresent())
        return; // total hack to avoid providers that don't compile to OrderGlobalStep
    TraversalHelper.getFirstStepOfAssignableClass(OrderGlobalStep.class, traversal.asAdmin()).get().setLimit(1);
    printTraversalForm(traversal);
    final List<String> results = traversal.toList();
    assertTrue(results.size() < 8);
    assertFalse(traversal.hasNext());
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profile() {
    final Traversal<Vertex, TraversalMetrics> traversal = get_g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profile();
    printTraversalForm(traversal);
    TraversalMetrics traversalMetrics = traversal.next();
    assertEquals("There should be 8 steps in this traversal (counting injected profile steps).", 8, traversal.asAdmin().getSteps().size());
    validate_g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profile(traversalMetrics);
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profileXmetricsX() {
    final Traversal<Vertex, Vertex> traversal = get_g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profileXmetricsX();
    printTraversalForm(traversal);
    traversal.iterate();
    assertEquals("There should be 7 steps in this traversal (counting injected profile steps).", 7, traversal.asAdmin().getSteps().size());
    TraversalMetrics traversalMetrics = traversal.asAdmin().getSideEffects().<TraversalMetrics>get(METRICS_KEY);
    validate_g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profile(traversalMetrics);
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.STANDARD)
public void g_V_hasLabelXpersonX_pageRank_byXrankX_byXbothEX_rank_profile() {
    final Traversal<Vertex, TraversalMetrics> traversal = get_g_V_hasLabelXpersonX_pageRank_byXrankX_byXbothEX_rank_profile();
    //printTraversalForm(traversal);
    try {
        traversal.iterate();
        fail("Should have tossed an exception because multi-OLAP is unsolvable");
    } catch (Exception ex) {
        assertTrue(ex instanceof VerificationException || ExceptionUtils.getRootCause(ex) instanceof VerificationException);
    }
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@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);
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@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);
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void g_V_outE_identity_inV_explain() {
    final TraversalExplanation explanation = get_g_V_outE_identity_inV_explain();
    if (explanation.getStrategyTraversals().stream().map(Pair::getValue0).filter(s -> s instanceof IdentityRemovalStrategy || s instanceof IncidentToAdjacentStrategy).count() == 2) {
        printTraversalForm(explanation.getOriginalTraversal());
        boolean beforeIncident = true;
        boolean beforeIdentity = true;
        for (final Pair<TraversalStrategy, Traversal.Admin<?, ?>> pair : explanation.getStrategyTraversals()) {
            if (pair.getValue0().getClass().equals(IncidentToAdjacentStrategy.class))
                beforeIncident = false;
            if (pair.getValue0().getClass().equals(IdentityRemovalStrategy.class))
                beforeIdentity = false;

            if (beforeIdentity)
                assertEquals(1, TraversalHelper.getStepsOfClass(IdentityStep.class, pair.getValue1()).size());

            if (beforeIncident)
                assertEquals(1, TraversalHelper.getStepsOfClass(EdgeVertexStep.class, pair.getValue1()).size());

            if (!beforeIdentity)
                assertEquals(0, TraversalHelper.getStepsOfClass(IdentityStep.class, pair.getValue1()).size());

            if (!beforeIncident)
                assertEquals(0, TraversalHelper.getStepsOfClass(EdgeVertexStep.class, pair.getValue1()).size());
        }
        assertFalse(beforeIncident);
    }
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER) // only validate for OLTP
public void g_V_hasId_compilationEquality() {
    final Traversal<Vertex, Vertex> traversala1 = get_g_VX1X(convertToVertexId("marko"));
    final Traversal<Vertex, Vertex> traversala2 = get_g_V_hasIdX1X(convertToVertexId("marko"));
    final Traversal<Vertex, Vertex> traversalb1 = get_g_VX1_2X(convertToVertexId("marko"), convertToVertexId("vadas"));
    final Traversal<Vertex, Vertex> traversalb2 = get_g_V_hasIdX1_2X(convertToVertexId("marko"), convertToVertexId("vadas"));
    printTraversalForm(traversala1);
    printTraversalForm(traversala2);
    printTraversalForm(traversalb1);
    printTraversalForm(traversalb2);
    checkResults(Collections.singletonList(convertToVertex(graph, "marko")), traversala1);
    checkResults(Collections.singletonList(convertToVertex(graph, "marko")), traversala2);
    checkResults(Arrays.asList(convertToVertex(graph, "marko"), convertToVertex(graph, "vadas")), traversalb1);
    checkResults(Arrays.asList(convertToVertex(graph, "marko"), convertToVertex(graph, "vadas")), traversalb2);
    // if providers don't have their own custom GraphStep, then ignore validating compilation equality
    if ((traversala1.asAdmin().getStartStep() instanceof GraphStep) &&
            !traversala1.asAdmin().getStartStep().getClass().equals(GraphStep.class)) {
        assertEquals(traversala1, traversala2);
        assertEquals(traversalb1, traversalb2);
        assertNotEquals(traversala1, traversalb1);
        assertNotEquals(traversala1, traversalb2);
        assertNotEquals(traversala2, traversalb1);
        assertNotEquals(traversala2, traversalb2);
    }
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER) // we can't modify the graph in computer mode
public void shouldProperlyHandleMetaProperties() throws Exception {
    graph.traversal().V().has("name", "marko").properties("name").property("alias", "okram").iterate();
    final BulkLoaderVertexProgram blvp = BulkLoaderVertexProgram.build()
            .userSuppliedIds(true)
            .writeGraph(getWriteGraphConfiguration()).create(graph);
    graphProvider.getGraphComputer(graph).workers(1).program(blvp).submit().get();
    assertGraphEquality(graph, getWriteGraph());
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@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());
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith
@FeatureRequirement(featureClass = Graph.Features.VertexFeatures.class, feature = Graph.Features.VertexFeatures.FEATURE_REMOVE_VERTICES)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void g_VX1_2_3_4X_name() {
    final Object vLop = convertToVertexId("lop");
    g.V(vLop).drop().iterate();
    final Traversal<Vertex, String> traversal = get_g_VX1_2_3_4X_name(convertToVertexId("marko"), convertToVertexId("vadas"), vLop, convertToVertexId("josh"));
    printTraversalForm(traversal);
    checkResults(Arrays.asList("marko", "vadas", "josh"), traversal);
    assertFalse(traversal.hasNext());
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profile() {
    final Traversal<Vertex, TraversalMetrics> traversal = get_g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profile();
    printTraversalForm(traversal);

    // This assertion is really only meant for tinkergraph
    if (graph.getClass().getSimpleName().equals("TinkerGraph"))
        assertEquals("There should be 8 steps in this traversal (counting injected profile steps).", 8, traversal.asAdmin().getSteps().size());

    final TraversalMetrics traversalMetrics = traversal.next();
    validate_g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profile(traversalMetrics);
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profileXmetricsX() {
    final Traversal<Vertex, Vertex> traversal = get_g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profileXmetricsX();
    printTraversalForm(traversal);
    traversal.iterate();

    // This assertion is really only meant for tinkergraph
    if (graph.getClass().getSimpleName().equals("TinkerGraph"))
        assertEquals("There should be 7 steps in this traversal (counting injected profile steps).", 7, traversal.asAdmin().getSteps().size());

    final TraversalMetrics traversalMetrics = traversal.asAdmin().getSideEffects().get(METRICS_KEY);
    validate_g_V_sideEffectXThread_sleepX10XX_sideEffectXThread_sleepX5XX_profile(traversalMetrics);
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER) // no mid-traversal V() in computer mode + star-graph limitations
public void coworkerSummaryOLTP() {
    final Traversal<Vertex, Map<String, Map<String, Map<String, Object>>>> traversal = getCoworkerSummaryOLTP();
    printTraversalForm(traversal);
    assertTrue(traversal.hasNext());
    checkCoworkerSummary(traversal.next());
    assertFalse(traversal.hasNext());
}
 

import org.apache.tinkerpop.gremlin.process.IgnoreEngine; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void shouldFilterMixedCriteria() throws Exception {
    final Traversal<Vertex,?> vertexCriterion = __.has("name", P.within("josh", "lop", "ripple"));

    // 9 isn't present because marko is not in the vertex list
    final Traversal<Edge, ?> edgeCriterion = __.or(
            __.has("weight", 0.4d).hasLabel("created"), // 11
            __.has("weight", 1.0d).hasLabel("created") // 10
    );

    final SubgraphStrategy strategy = SubgraphStrategy.build().edgeCriterion(edgeCriterion).vertexCriterion(vertexCriterion).create();
    final GraphTraversalSource sg = create(strategy);

    // three vertices are included in the subgraph
    assertEquals(6, g.V().count().next().longValue());
    assertEquals(3, sg.V().count().next().longValue());

    // three edges are explicitly included, but one is missing its out-vertex due to the vertex criterion
    assertEquals(6, g.E().count().next().longValue());
    assertEquals(2, sg.E().count().next().longValue());

    // from vertex

    assertEquals(2, g.V(convertToVertexId("josh")).outE().count().next().longValue());
    assertEquals(2, sg.V(convertToVertexId("josh")).outE().count().next().longValue());
    assertEquals(2, g.V(convertToVertexId("josh")).out().count().next().longValue());
    assertEquals(2, sg.V(convertToVertexId("josh")).out().count().next().longValue());

    assertEquals(1, g.V(convertToVertexId("josh")).inE().count().next().longValue());
    assertEquals(0, sg.V(convertToVertexId("josh")).inE().count().next().longValue());
    assertEquals(1, g.V(convertToVertexId("josh")).in().count().next().longValue());
    assertEquals(0, sg.V(convertToVertexId("josh")).in().count().next().longValue());

    assertEquals(3, g.V(convertToVertexId("josh")).bothE().count().next().longValue());
    assertEquals(2, sg.V(convertToVertexId("josh")).bothE().count().next().longValue());
    assertEquals(3, g.V(convertToVertexId("josh")).both().count().next().longValue());
    assertEquals(2, sg.V(convertToVertexId("josh")).both().count().next().longValue());

    // with label

    assertEquals(2, g.V(convertToVertexId("josh")).outE("created").count().next().longValue());
    assertEquals(2, sg.V(convertToVertexId("josh")).outE("created").count().next().longValue());
    assertEquals(2, g.V(convertToVertexId("josh")).out("created").count().next().longValue());
    assertEquals(2, sg.V(convertToVertexId("josh")).out("created").count().next().longValue());
    assertEquals(2, g.V(convertToVertexId("josh")).bothE("created").count().next().longValue());
    assertEquals(2, sg.V(convertToVertexId("josh")).bothE("created").count().next().longValue());
    assertEquals(2, g.V(convertToVertexId("josh")).both("created").count().next().longValue());
    assertEquals(2, sg.V(convertToVertexId("josh")).both("created").count().next().longValue());

    assertEquals(1, g.V(convertToVertexId("josh")).inE("knows").count().next().longValue());
    assertEquals(0, sg.V(convertToVertexId("josh")).inE("knows").count().next().longValue());
    assertEquals(1, g.V(convertToVertexId("josh")).in("knows").count().next().longValue());
    assertEquals(0, sg.V(convertToVertexId("josh")).in("knows").count().next().longValue());
    assertEquals(1, g.V(convertToVertexId("josh")).bothE("knows").count().next().longValue());
    assertEquals(0, sg.V(convertToVertexId("josh")).bothE("knows").count().next().longValue());
    assertEquals(1, g.V(convertToVertexId("josh")).both("knows").count().next().longValue());
    assertEquals(0, sg.V(convertToVertexId("josh")).both("knows").count().next().longValue());

    // with branch factor

    assertEquals(1, g.V(convertToVertexId("josh")).local(bothE().limit(1)).count().next().longValue());
    assertEquals(1, sg.V(convertToVertexId("josh")).local(bothE().limit(1)).count().next().longValue());
    assertEquals(1, g.V(convertToVertexId("josh")).local(bothE().limit(1)).inV().count().next().longValue());
    assertEquals(1, sg.V(convertToVertexId("josh")).local(bothE().limit(1)).inV().count().next().longValue());
    assertEquals(1, g.V(convertToVertexId("josh")).local(bothE("knows", "created").limit(1)).count().next().longValue());
    assertEquals(1, sg.V(convertToVertexId("josh")).local(bothE("knows", "created").limit(1)).count().next().longValue());
    assertEquals(1, g.V(convertToVertexId("josh")).local(bothE("knows", "created").limit(1)).inV().count().next().longValue());
    assertEquals(1, sg.V(convertToVertexId("josh")).local(bothE("knows", "created").limit(1)).inV().count().next().longValue());

    // from edge

    assertEquals(2, g.E(convertToEdgeId("marko", "created", "lop")).bothV().count().next().longValue());
    try {
        sg.E(convertToEdgeId("marko", "created", "lop")).next();
        fail("Edge 9 should not be in the graph because marko is not a vertex");
    } catch (Exception ex) {
        assertTrue(ex instanceof NoSuchElementException);
    }
}