tinkerpop-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dkupp...@apache.org
Subject [21/50] tinkerpop git commit: Removed "performance" tests.
Date Fri, 04 Aug 2017 16:59:01 GMT
Removed "performance" tests.

These don't execute on tp32, but do on master as all performance testing is handled through
gremlin-benchmark now. These tests that were removed fail from time to time in certain environments
like travis. As these tests were only running in the performance test profile on tp32 they
weren't running in any continual way before so their use is minimal. If we want these kinds
of tests they should be re-developed under gremlin-benchmark. CTR


Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/726b4050
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/726b4050
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/726b4050

Branch: refs/heads/TINKERPOP-1682
Commit: 726b4050c875799b4b8754ec29533be670ccb492
Parents: 2116819
Author: Stephen Mallette <spmva@genoprime.com>
Authored: Fri Jul 21 08:18:43 2017 -0400
Committer: Stephen Mallette <spmva@genoprime.com>
Committed: Fri Jul 21 08:18:43 2017 -0400

----------------------------------------------------------------------
 .../TraversalStrategyPerformanceTest.java       | 120 ----------------
 .../IdentityRemovalStrategyTest.java            | 102 ++++----------
 .../optimization/RepeatUnrollStrategyTest.java  | 141 ++++++-------------
 pom.xml                                         |   1 -
 4 files changed, 70 insertions(+), 294 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/726b4050/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/TraversalStrategyPerformanceTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/TraversalStrategyPerformanceTest.java
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/TraversalStrategyPerformanceTest.java
deleted file mode 100644
index b89386c..0000000
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/TraversalStrategyPerformanceTest.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.tinkerpop.gremlin.process.traversal.strategy;
-
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
-import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
-import org.apache.tinkerpop.gremlin.util.TimeUtil;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.Iterator;
-import java.util.List;
-import java.util.Random;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-/**
- * @author Daniel Kuppitz (http://gremlin.guru)
- */
-public abstract class TraversalStrategyPerformanceTest {
-
-    private static final Logger LOGGER = LoggerFactory.getLogger(TraversalStrategyPerformanceTest.class);
-    private static final Random RANDOM = new Random();
-
-    protected int getClockRuns() {
-        return 1000;
-    }
-
-    /**
-     * Specifies for how many percent of all comparisons the optimized traversal must be
faster than the
-     * original traversal. Default is 100.
-     */
-    protected double getAssertionPercentile() {
-        return 75.0;
-    }
-
-    protected abstract Class<? extends TraversalStrategy> getStrategyUnderTest();
-
-    protected TraversalStrategy<?> getStrategyUnderTestInstance() throws Exception
{
-        return (TraversalStrategy) getStrategyUnderTest().getMethod("instance").invoke(null);
-    }
-
-    protected abstract Iterator<GraphTraversal> getTraversalIterator();
-
-    @Test
-    public void shouldBeFaster() throws Exception {
-
-        final TraversalStrategies withStrategyUnderTest = new DefaultTraversalStrategies();
-        withStrategyUnderTest.addStrategies(getStrategyUnderTestInstance());
-
-        final TraversalStrategies withoutStrategyUnderTest = new DefaultTraversalStrategies();
-        withoutStrategyUnderTest.removeStrategies(getStrategyUnderTest());
-
-        final int clockRuns = getClockRuns();
-        final Iterator<GraphTraversal> iterator = getTraversalIterator();
-        int faster = 0, numTraversals = 0;
-        while (iterator.hasNext()) {
-
-            final GraphTraversal traversal = iterator.next();
-            final GraphTraversal.Admin original = traversal.asAdmin();
-            final GraphTraversal.Admin optimized = original.clone();
-
-            original.setStrategies(withoutStrategyUnderTest);
-            optimized.setStrategies(withStrategyUnderTest);
-
-            final double originalTime, optimizedTime;
-
-            if (RANDOM.nextBoolean()) {
-                originalTime = TimeUtil.clock(clockRuns, () -> original.clone().iterate());
-                optimizedTime = TimeUtil.clock(clockRuns, () -> optimized.clone().iterate());
-            } else {
-                optimizedTime = TimeUtil.clock(clockRuns, () -> optimized.clone().iterate());
-                originalTime = TimeUtil.clock(clockRuns, () -> original.clone().iterate());
-            }
-
-            final List originalResult = original.toList();
-            final List optimizedResult = optimized.toList();
-
-            if (originalTime > optimizedTime) {
-                LOGGER.debug("Original traversal ({} ms): {}", originalTime, original);
-                LOGGER.debug("Optimized traversal ({} ms): {}", optimizedTime, optimized);
-            } else {
-                LOGGER.warn("Original traversal ({} ms): {}", originalTime, original);
-                LOGGER.warn("Optimized traversal ({} ms): {}", optimizedTime, optimized);
-            }
-
-            if (getAssertionPercentile() >= 100) assertTrue(originalTime > optimizedTime);
-            else {
-                if (originalTime > optimizedTime)
-                    faster++;
-                numTraversals++;
-            }
-
-            assertEquals(originalResult, optimizedResult);
-        }
-
-        if (getAssertionPercentile() < 100 && numTraversals > 0)
-            assertTrue(((faster * 100.0) / numTraversals) >= getAssertionPercentile());
-    }
-}

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/726b4050/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IdentityRemovalStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IdentityRemovalStrategyTest.java
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IdentityRemovalStrategyTest.java
index b14798e..eb791af 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IdentityRemovalStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/IdentityRemovalStrategyTest.java
@@ -20,102 +20,54 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
 
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.TraversalStrategyPerformanceTest;
 import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
 import org.junit.Test;
-import org.junit.experimental.runners.Enclosed;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 import java.util.Arrays;
-import java.util.Iterator;
-import java.util.stream.IntStream;
 
 import static org.junit.Assert.assertEquals;
 
-
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
  */
-@RunWith(Enclosed.class)
+@RunWith(Parameterized.class)
 public class IdentityRemovalStrategyTest {
 
-    @RunWith(Parameterized.class)
-    public static class ParameterizedTests {
-
-        @Parameterized.Parameter(value = 0)
-        public Traversal original;
-
-        @Parameterized.Parameter(value = 1)
-        public Traversal optimized;
-
+    @Parameterized.Parameter(value = 0)
+    public Traversal original;
 
-        private void applyIdentityRemovalStrategy(final Traversal traversal) {
-            final TraversalStrategies strategies = new DefaultTraversalStrategies();
-            strategies.addStrategies(IdentityRemovalStrategy.instance());
-            traversal.asAdmin().setStrategies(strategies);
-            traversal.asAdmin().applyStrategies();
+    @Parameterized.Parameter(value = 1)
+    public Traversal optimized;
 
-        }
 
-        @Test
-        public void doTest() {
-            applyIdentityRemovalStrategy(original);
-            assertEquals(optimized, original);
-        }
-
-        @Parameterized.Parameters(name = "{0}")
-        public static Iterable<Object[]> generateTestParameters() {
-
-            return Arrays.asList(new Traversal[][]{
-                    {__.identity(), __.identity()},
-                    {__.identity().out(), __.out()},
-                    {__.identity().out().identity(), __.out()},
-                    {__.identity().as("a").out().identity(), __.identity().as("a").out()},
-                    {__.identity().as("a").out().identity().as("b"), __.identity().as("a").out().as("b")},
-                    {__.identity().as("a").out().in().identity().identity().as("b").identity().out(),
__.identity().as("a").out().in().as("b").out()},
-                    {__.out().identity().as("a").out().in().identity().identity().as("b").identity().out(),
__.out().as("a").out().in().as("b").out()},
-            });
-        }
+    private void applyIdentityRemovalStrategy(final Traversal traversal) {
+        final TraversalStrategies strategies = new DefaultTraversalStrategies();
+        strategies.addStrategies(IdentityRemovalStrategy.instance());
+        traversal.asAdmin().setStrategies(strategies);
+        traversal.asAdmin().applyStrategies();
 
     }
 
-    public static class PerformanceTest extends TraversalStrategyPerformanceTest {
-
-        @Override
-        protected Class<? extends TraversalStrategy> getStrategyUnderTest() {
-            return IdentityRemovalStrategy.class;
-        }
-
-        @Override
-        protected Iterator<GraphTraversal> getTraversalIterator() {
-
-            return new Iterator<GraphTraversal>() {
-
-                final int minIdentities = 5;
-                final int maxIdentities = 10;
-                final Integer[] starts = IntStream.range(0, 1000).boxed().toArray(Integer[]::new);
-
-                private int numberOfIdentities = minIdentities;
-
-                @Override
-                public boolean hasNext() {
-                    return numberOfIdentities <= maxIdentities;
-                }
+    @Test
+    public void doTest() {
+        applyIdentityRemovalStrategy(original);
+        assertEquals(optimized, original);
+    }
 
-                @Override
-                public GraphTraversal next() {
-                    final GraphTraversal traversal = __.inject(starts);
-                    for (int j = 0; j < numberOfIdentities; j++) {
-                        traversal.identity();
-                    }
-                    numberOfIdentities++;
-                    return traversal;
-                }
-            };
-        }
+    @Parameterized.Parameters(name = "{0}")
+    public static Iterable<Object[]> generateTestParameters() {
+
+        return Arrays.asList(new Traversal[][]{
+                {__.identity(), __.identity()},
+                {__.identity().out(), __.out()},
+                {__.identity().out().identity(), __.out()},
+                {__.identity().as("a").out().identity(), __.identity().as("a").out()},
+                {__.identity().as("a").out().identity().as("b"), __.identity().as("a").out().as("b")},
+                {__.identity().as("a").out().in().identity().identity().as("b").identity().out(),
__.identity().as("a").out().in().as("b").out()},
+                {__.out().identity().as("a").out().in().identity().identity().as("b").identity().out(),
__.out().as("a").out().in().as("b").out()},
+        });
     }
 }

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/726b4050/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java
index 07c53cb..88eb5a6 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/RepeatUnrollStrategyTest.java
@@ -23,22 +23,17 @@ import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.TraversalStrategyPerformanceTest;
 import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.junit.Test;
-import org.junit.experimental.runners.Enclosed;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Iterator;
 import java.util.function.Predicate;
-import java.util.stream.IntStream;
 
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.out;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.path;
@@ -47,106 +42,56 @@ import static org.junit.Assert.assertEquals;
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
  */
-
-@RunWith(Enclosed.class)
+@RunWith(Parameterized.class)
 public class RepeatUnrollStrategyTest {
 
-    @RunWith(Parameterized.class)
-    public static class ParameterizedTests {
-
-        @Parameterized.Parameter(value = 0)
-        public Traversal original;
+    @Parameterized.Parameter(value = 0)
+    public Traversal original;
 
-        @Parameterized.Parameter(value = 1)
-        public Traversal optimized;
+    @Parameterized.Parameter(value = 1)
+    public Traversal optimized;
 
-        @Parameterized.Parameter(value = 2)
-        public Collection<TraversalStrategy> otherStrategies;
-
-        @Test
-        public void doTest() {
-            final TraversalStrategies strategies = new DefaultTraversalStrategies();
-            strategies.addStrategies(RepeatUnrollStrategy.instance());
-            for (final TraversalStrategy strategy : this.otherStrategies) {
-                strategies.addStrategies(strategy);
-            }
-            this.original.asAdmin().setStrategies(strategies);
-            this.original.asAdmin().applyStrategies();
-            assertEquals(this.optimized, this.original);
-        }
+    @Parameterized.Parameter(value = 2)
+    public Collection<TraversalStrategy> otherStrategies;
 
-        @Parameterized.Parameters(name = "{0}")
-        public static Iterable<Object[]> generateTestParameters() {
-            final int maxBarrierSize = RepeatUnrollStrategy.MAX_BARRIER_SIZE;
-            final Predicate<Traverser<Vertex>> predicate = t -> t.loops()
> 5;
-            return Arrays.asList(new Object[][]{
-                    {__.repeat(out()).times(0), __.repeat(out()).times(0), Collections.emptyList()},
-                    {__.<Vertex>times(0).repeat(out()), __.<Vertex>times(0).repeat(out()),
Collections.emptyList()},
-                    {__.identity(), __.identity(), Collections.emptyList()},
-                    {out().as("a").in().repeat(__.outE("created").bothV()).times(2).in(),
out().as("a").in().outE("created").bothV().barrier(maxBarrierSize).outE("created").bothV().barrier(maxBarrierSize).in(),
Collections.emptyList()},
-                    {out().repeat(__.outE("created").bothV()).times(1).in(), out().outE("created").bothV().barrier(maxBarrierSize).in(),
Collections.emptyList()},
-                    {__.repeat(__.outE("created").bothV()).times(1).in(), __.outE("created").bothV().barrier(maxBarrierSize).in(),
Collections.emptyList()},
-                    {__.repeat(out()).times(2).as("x").repeat(__.in().as("b")).times(3),
out().barrier(maxBarrierSize).out().barrier(maxBarrierSize).as("x").in().as("b").barrier(maxBarrierSize).in().as("b").barrier(maxBarrierSize).in().as("b").barrier(maxBarrierSize),
Collections.emptyList()},
-                    {__.repeat(__.outE("created").inV()).times(2), __.outE("created").inV().barrier(maxBarrierSize).outE("created").inV().barrier(maxBarrierSize),
Collections.emptyList()},
-                    {__.repeat(out()).times(3), out().barrier(maxBarrierSize).out().barrier(maxBarrierSize).out().barrier(maxBarrierSize),
Collections.emptyList()},
-                    {__.repeat(__.local(__.select("a").out("knows"))).times(2), __.local(__.select("a").out("knows")).barrier(maxBarrierSize).local(__.select("a").out("knows")).barrier(maxBarrierSize),
Collections.emptyList()},
-                    {__.<Vertex>times(2).repeat(out()), out().barrier(maxBarrierSize).out().barrier(maxBarrierSize),
Collections.emptyList()},
-                    {__.<Vertex>out().times(2).repeat(out().as("a")).as("x"), out().out().as("a").barrier(maxBarrierSize).out().as("a").barrier(maxBarrierSize).as("x"),
Collections.emptyList()},
-                    {__.repeat(out()).emit().times(2), __.repeat(out()).emit().times(2),
Collections.emptyList()},
-                    {__.repeat(out()).until(predicate), __.repeat(out()).until(predicate),
Collections.emptyList()},
-                    {__.repeat(out()).until(predicate).repeat(out()).times(2), __.repeat(out()).until(predicate).out().barrier(maxBarrierSize).out().barrier(maxBarrierSize),
Collections.emptyList()},
-                    {__.repeat(__.union(__.both(), __.identity())).times(2).out(), __.union(__.both(),
__.identity()).barrier(maxBarrierSize).union(__.both(), __.identity()).barrier(maxBarrierSize).out(),
Collections.emptyList()},
-                    {__.in().repeat(out("knows")).times(3).as("a").count().is(0), __.in().out("knows").barrier(maxBarrierSize).out("knows").barrier(maxBarrierSize).out("knows").as("a").count().is(0),
Collections.emptyList()},
-                    //
-                    {__.repeat(__.outE().inV()).times(2), __.outE().inV().barrier(maxBarrierSize).outE().inV().barrier(maxBarrierSize),
Collections.emptyList()},
-                    {__.repeat(__.outE().filter(path()).inV()).times(2), __.outE().filter(path()).inV().barrier(maxBarrierSize).outE().filter(path()).inV().barrier(maxBarrierSize),
Collections.singletonList(IncidentToAdjacentStrategy.instance())},
-                    {__.repeat(__.outE().inV()).times(2), __.out().barrier(maxBarrierSize).out().barrier(maxBarrierSize),
Collections.singletonList(IncidentToAdjacentStrategy.instance())},
-            });
+    @Test
+    public void doTest() {
+        final TraversalStrategies strategies = new DefaultTraversalStrategies();
+        strategies.addStrategies(RepeatUnrollStrategy.instance());
+        for (final TraversalStrategy strategy : this.otherStrategies) {
+            strategies.addStrategies(strategy);
         }
+        this.original.asAdmin().setStrategies(strategies);
+        this.original.asAdmin().applyStrategies();
+        assertEquals(this.optimized, this.original);
     }
 
-
-    public static class PerformanceTest extends TraversalStrategyPerformanceTest {
-
-        @Override
-        protected double getAssertionPercentile() {
-            return 95.0;
-        }
-
-        @Override
-        protected Class<? extends TraversalStrategy> getStrategyUnderTest() {
-            return RepeatUnrollStrategy.class;
-        }
-
-        @Override
-        protected Iterator<GraphTraversal> getTraversalIterator() {
-
-            return new Iterator<GraphTraversal>() {
-
-                final int minLoops = 2;
-                final int maxLoops = 5;
-                final int minModulo = 100;
-                final int maxModulo = 1000;
-
-                private int numberOfLoops = minLoops;
-                private int modulo = minModulo;
-
-                @Override
-                public boolean hasNext() {
-                    return modulo <= maxModulo;
-                }
-
-                @Override
-                public GraphTraversal next() {
-                    final Integer[] starts = IntStream.range(0, 1000).map(i -> i % modulo).boxed().toArray(Integer[]::new);
-                    final GraphTraversal traversal = __.inject(starts).repeat(__.identity()).times(numberOfLoops).sum();
-                    if (++numberOfLoops > maxLoops) {
-                        numberOfLoops = minLoops;
-                        modulo += 200;
-                    }
-                    return traversal;
-                }
-            };
-        }
+    @Parameterized.Parameters(name = "{0}")
+    public static Iterable<Object[]> generateTestParameters() {
+        final int maxBarrierSize = RepeatUnrollStrategy.MAX_BARRIER_SIZE;
+        final Predicate<Traverser<Vertex>> predicate = t -> t.loops() >
5;
+        return Arrays.asList(new Object[][]{
+                {__.repeat(out()).times(0), __.repeat(out()).times(0), Collections.emptyList()},
+                {__.<Vertex>times(0).repeat(out()), __.<Vertex>times(0).repeat(out()),
Collections.emptyList()},
+                {__.identity(), __.identity(), Collections.emptyList()},
+                {out().as("a").in().repeat(__.outE("created").bothV()).times(2).in(), out().as("a").in().outE("created").bothV().barrier(maxBarrierSize).outE("created").bothV().barrier(maxBarrierSize).in(),
Collections.emptyList()},
+                {out().repeat(__.outE("created").bothV()).times(1).in(), out().outE("created").bothV().barrier(maxBarrierSize).in(),
Collections.emptyList()},
+                {__.repeat(__.outE("created").bothV()).times(1).in(), __.outE("created").bothV().barrier(maxBarrierSize).in(),
Collections.emptyList()},
+                {__.repeat(out()).times(2).as("x").repeat(__.in().as("b")).times(3), out().barrier(maxBarrierSize).out().barrier(maxBarrierSize).as("x").in().as("b").barrier(maxBarrierSize).in().as("b").barrier(maxBarrierSize).in().as("b").barrier(maxBarrierSize),
Collections.emptyList()},
+                {__.repeat(__.outE("created").inV()).times(2), __.outE("created").inV().barrier(maxBarrierSize).outE("created").inV().barrier(maxBarrierSize),
Collections.emptyList()},
+                {__.repeat(out()).times(3), out().barrier(maxBarrierSize).out().barrier(maxBarrierSize).out().barrier(maxBarrierSize),
Collections.emptyList()},
+                {__.repeat(__.local(__.select("a").out("knows"))).times(2), __.local(__.select("a").out("knows")).barrier(maxBarrierSize).local(__.select("a").out("knows")).barrier(maxBarrierSize),
Collections.emptyList()},
+                {__.<Vertex>times(2).repeat(out()), out().barrier(maxBarrierSize).out().barrier(maxBarrierSize),
Collections.emptyList()},
+                {__.<Vertex>out().times(2).repeat(out().as("a")).as("x"), out().out().as("a").barrier(maxBarrierSize).out().as("a").barrier(maxBarrierSize).as("x"),
Collections.emptyList()},
+                {__.repeat(out()).emit().times(2), __.repeat(out()).emit().times(2), Collections.emptyList()},
+                {__.repeat(out()).until(predicate), __.repeat(out()).until(predicate), Collections.emptyList()},
+                {__.repeat(out()).until(predicate).repeat(out()).times(2), __.repeat(out()).until(predicate).out().barrier(maxBarrierSize).out().barrier(maxBarrierSize),
Collections.emptyList()},
+                {__.repeat(__.union(__.both(), __.identity())).times(2).out(), __.union(__.both(),
__.identity()).barrier(maxBarrierSize).union(__.both(), __.identity()).barrier(maxBarrierSize).out(),
Collections.emptyList()},
+                {__.in().repeat(out("knows")).times(3).as("a").count().is(0), __.in().out("knows").barrier(maxBarrierSize).out("knows").barrier(maxBarrierSize).out("knows").as("a").count().is(0),
Collections.emptyList()},
+                //
+                {__.repeat(__.outE().inV()).times(2), __.outE().inV().barrier(maxBarrierSize).outE().inV().barrier(maxBarrierSize),
Collections.emptyList()},
+                {__.repeat(__.outE().filter(path()).inV()).times(2), __.outE().filter(path()).inV().barrier(maxBarrierSize).outE().filter(path()).inV().barrier(maxBarrierSize),
Collections.singletonList(IncidentToAdjacentStrategy.instance())},
+                {__.repeat(__.outE().inV()).times(2), __.out().barrier(maxBarrierSize).out().barrier(maxBarrierSize),
Collections.singletonList(IncidentToAdjacentStrategy.instance())},
+        });
     }
 }

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/726b4050/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 8c81199..1600858 100644
--- a/pom.xml
+++ b/pom.xml
@@ -152,7 +152,6 @@ limitations under the License.
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <skipIntegrationTests>true</skipIntegrationTests>
-        <skipPerformanceTests>true</skipPerformanceTests>
 
         <!--
         This file will come from the root of each modules test/resources/ directories. log4j-silent.properties
will


Mime
View raw message