Java tutorial
/* * 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; import org.apache.commons.configuration.BaseConfiguration; import org.apache.commons.configuration.Configuration; import org.apache.tinkerpop.gremlin.process.computer.ComputerResult; import org.apache.tinkerpop.gremlin.process.computer.GraphComputer; import org.apache.tinkerpop.gremlin.process.computer.MapReduce; import org.apache.tinkerpop.gremlin.process.computer.VertexProgram; 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.strategy.AbstractTraversalStrategy; import org.apache.tinkerpop.gremlin.structure.Edge; import org.apache.tinkerpop.gremlin.structure.Graph; import org.apache.tinkerpop.gremlin.structure.Transaction; import org.apache.tinkerpop.gremlin.structure.Vertex; import org.junit.Test; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Future; import java.util.stream.Collectors; import java.util.stream.Stream; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; /** * @author Matthias Broecheler (me@matthiasb.com) * @author Marko A. Rodriguez (marko@markorodriguez.com) */ public class TraversalStrategiesTest { @Test public void shouldAllowUserManipulationOfGlobalCache() throws Exception { /////////// // GRAPH // /////////// TestGraph graph = new TestGraph(); TraversalStrategies strategies = graph.traversal().getStrategies(); assertFalse(TraversalStrategies.GlobalCache.getStrategies(Graph.class).toList().isEmpty()); for (final TraversalStrategy strategy : TraversalStrategies.GlobalCache.getStrategies(Graph.class) .toList()) { assertTrue(strategies.getStrategy(strategy.getClass()).isPresent()); } for (final TraversalStrategy strategy : TraversalStrategies.GlobalCache .getStrategies(TestGraphComputer.class).toList()) { assertFalse(strategies.getStrategy(strategy.getClass()).isPresent()); } assertTrue(strategies.getStrategy(StrategyA.class).isPresent()); assertTrue(strategies.getStrategy(StrategyB.class).isPresent()); assertFalse(strategies.getStrategy(StrategyC.class).isPresent()); assertFalse(strategies.getStrategy(StrategyD.class).isPresent()); strategies.addStrategies(new StrategyD()); strategies.removeStrategies(StrategyA.class); assertFalse(strategies.getStrategy(StrategyA.class).isPresent()); assertTrue(strategies.getStrategy(StrategyD.class).isPresent()); /// graph = new TestGraph(); strategies = graph.traversal().getStrategies(); for (final TraversalStrategy strategy : TraversalStrategies.GlobalCache.getStrategies(Graph.class) .toList()) { assertTrue(strategies.getStrategy(strategy.getClass()).isPresent()); } for (final TraversalStrategy strategy : TraversalStrategies.GlobalCache .getStrategies(TestGraphComputer.class).toList()) { assertFalse(strategies.getStrategy(strategy.getClass()).isPresent()); } assertFalse(strategies.getStrategy(StrategyA.class).isPresent()); assertTrue(strategies.getStrategy(StrategyB.class).isPresent()); assertFalse(strategies.getStrategy(StrategyC.class).isPresent()); assertTrue(strategies.getStrategy(StrategyD.class).isPresent()); ////////////////////// /// GRAPH COMPUTER /// ////////////////////// strategies = TraversalStrategies.GlobalCache.getStrategies(TestGraphComputer.class); assertFalse(TraversalStrategies.GlobalCache.getStrategies(GraphComputer.class).toList().isEmpty()); for (final TraversalStrategy strategy : TraversalStrategies.GlobalCache.getStrategies(GraphComputer.class) .toList()) { assertTrue(strategies.getStrategy(strategy.getClass()).isPresent()); } for (final TraversalStrategy strategy : TraversalStrategies.GlobalCache.getStrategies(TestGraph.class) .toList()) { assertFalse(strategies.getStrategy(strategy.getClass()).isPresent()); } assertFalse(strategies.getStrategy(StrategyA.class).isPresent()); assertFalse(strategies.getStrategy(StrategyB.class).isPresent()); assertTrue(strategies.getStrategy(StrategyC.class).isPresent()); strategies.addStrategies(new StrategyE()); strategies.removeStrategies(StrategyC.class); // strategies = TraversalStrategies.GlobalCache.getStrategies(TestGraphComputer.class); assertFalse(TraversalStrategies.GlobalCache.getStrategies(GraphComputer.class).toList().isEmpty()); for (final TraversalStrategy strategy : TraversalStrategies.GlobalCache.getStrategies(GraphComputer.class) .toList()) { assertTrue(strategies.getStrategy(strategy.getClass()).isPresent()); } for (final TraversalStrategy strategy : TraversalStrategies.GlobalCache.getStrategies(TestGraph.class) .toList()) { assertFalse(strategies.getStrategy(strategy.getClass()).isPresent()); } assertFalse(strategies.getStrategy(StrategyA.class).isPresent()); assertFalse(strategies.getStrategy(StrategyB.class).isPresent()); assertFalse(strategies.getStrategy(StrategyC.class).isPresent()); assertFalse(strategies.getStrategy(StrategyD.class).isPresent()); assertTrue(strategies.getStrategy(StrategyE.class).isPresent()); } public static class TestGraphComputer implements GraphComputer { static { TraversalStrategies.GlobalCache.registerStrategies(TestGraphComputer.class, TraversalStrategies.GlobalCache.getStrategies(GraphComputer.class).clone() .addStrategies(new StrategyC())); } @Override public GraphComputer result(ResultGraph resultGraph) { return this; } @Override public GraphComputer persist(Persist persist) { return this; } @Override public GraphComputer program(VertexProgram vertexProgram) { return this; } @Override public GraphComputer mapReduce(MapReduce mapReduce) { return this; } @Override public GraphComputer workers(int workers) { return this; } @Override public GraphComputer vertices(Traversal<Vertex, Vertex> vertexFilter) throws IllegalArgumentException { return this; } @Override public GraphComputer edges(Traversal<Vertex, Edge> edgeFilter) throws IllegalArgumentException { return this; } @Override public Future<ComputerResult> submit() { return new CompletableFuture<>(); } } public static class TestGraph implements Graph { static { TraversalStrategies.GlobalCache.registerStrategies(TestGraph.class, TraversalStrategies.GlobalCache .getStrategies(Graph.class).clone().addStrategies(new StrategyA(), new StrategyB())); } @Override public Vertex addVertex(Object... keyValues) { return null; } @Override public <C extends GraphComputer> C compute(Class<C> graphComputerClass) throws IllegalArgumentException { return (C) new TestGraphComputer(); } @Override public GraphComputer compute() throws IllegalArgumentException { return new TestGraphComputer(); } @Override public Iterator<Vertex> vertices(Object... vertexIds) { return Collections.emptyIterator(); } @Override public Iterator<Edge> edges(Object... edgeIds) { return Collections.emptyIterator(); } @Override public Transaction tx() { return null; } @Override public void close() throws Exception { } @Override public Variables variables() { return null; } @Override public Configuration configuration() { return new BaseConfiguration(); } } /** * Tests that {@link org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies#sortStrategies(java.util.List)} * works as advertised. This class defines a bunch of dummy strategies which define an order. It is verified * that the right order is being returned. */ @Test public void testTraversalStrategySorting() { TraversalStrategy a = new StrategyA(), b = new StrategyB(), c = new StrategyC(), d = new StrategyD(), e = new StrategyE(), k = new StrategyK(), l = new StrategyL(), m = new StrategyM(), n = new StrategyN(), o = new StrategyO(); List<TraversalStrategy<?>> s; //Dependency well defined s = Arrays.asList(b, a); s = TraversalStrategies.sortStrategies(s); assertEquals(2, s.size()); assertEquals(a, s.get(0)); assertEquals(b, s.get(1)); //No dependency s = Arrays.asList(c, a); s = TraversalStrategies.sortStrategies(s); assertEquals(2, s.size()); //Dependency well defined s = Arrays.asList(c, a, b); s = TraversalStrategies.sortStrategies(s); assertEquals(3, s.size()); assertEquals(a, s.get(0)); assertEquals(b, s.get(1)); assertEquals(c, s.get(2)); //Circular dependency => throws exception s = Arrays.asList(c, k, a, b); try { TraversalStrategies.sortStrategies(s); fail(); } catch (IllegalStateException ex) { assertTrue(ex.getMessage().toLowerCase().contains("cyclic")); } //Dependency well defined s = Arrays.asList(d, c, a, e, b); s = TraversalStrategies.sortStrategies(s); assertEquals(5, s.size()); assertEquals(a, s.get(0)); assertEquals(b, s.get(1)); assertEquals(d, s.get(2)); assertEquals(c, s.get(3)); assertEquals(e, s.get(4)); //Circular dependency => throws exception s = Arrays.asList(d, c, k, a, e, b); try { TraversalStrategies.sortStrategies(s); fail(); } catch (IllegalStateException ex) { assertTrue(ex.getMessage().toLowerCase().contains("cyclic")); } //Lots of strategies s = Arrays.asList(b, l, m, n, o, a); s = TraversalStrategies.sortStrategies(s); assertTrue(s.indexOf(a) < s.indexOf(b)); // sort and then add more s = new ArrayList<>((List) Arrays.asList(b, a, c)); s = TraversalStrategies.sortStrategies(s); assertEquals(3, s.size()); assertEquals(a, s.get(0)); assertEquals(b, s.get(1)); assertEquals(c, s.get(2)); s.add(d); s = TraversalStrategies.sortStrategies(s); assertEquals(4, s.size()); assertEquals(a, s.get(0)); assertEquals(b, s.get(1)); assertEquals(d, s.get(2)); assertEquals(c, s.get(3)); s.add(e); s = TraversalStrategies.sortStrategies(s); assertEquals(5, s.size()); assertEquals(a, s.get(0)); assertEquals(b, s.get(1)); assertEquals(d, s.get(2)); assertEquals(c, s.get(3)); assertEquals(e, s.get(4)); } public static class StrategyA extends DummyStrategy { @Override public Set<Class<? extends TraversalStrategy>> applyPost() { return Stream.of(StrategyB.class).collect(Collectors.toSet()); } } public static class StrategyB extends DummyStrategy { @Override public Set<Class<? extends TraversalStrategy>> applyPrior() { return Stream.of(StrategyA.class).collect(Collectors.toSet()); } @Override public Set<Class<? extends TraversalStrategy>> applyPost() { return Stream.of(StrategyC.class).collect(Collectors.toSet()); } } public static class StrategyC extends DummyStrategy { } public static class StrategyD extends DummyStrategy { @Override public Set<Class<? extends TraversalStrategy>> applyPrior() { return Stream.of(StrategyB.class).collect(Collectors.toSet()); } @Override public Set<Class<? extends TraversalStrategy>> applyPost() { return Stream.of(StrategyC.class).collect(Collectors.toSet()); } } public static class StrategyE extends DummyStrategy { @Override public Set<Class<? extends TraversalStrategy>> applyPrior() { return Stream.of(StrategyC.class).collect(Collectors.toSet()); } } public static class StrategyK extends DummyStrategy { @Override public Set<Class<? extends TraversalStrategy>> applyPrior() { return Stream.of(StrategyC.class).collect(Collectors.toSet()); } @Override public Set<Class<? extends TraversalStrategy>> applyPost() { return Stream.of(StrategyA.class).collect(Collectors.toSet()); } } public static class StrategyL extends DummyStrategy { } public static class StrategyM extends DummyStrategy { } public static class StrategyN extends DummyStrategy { } public static class StrategyO extends DummyStrategy { } private static class DummyStrategy<S extends TraversalStrategy> extends AbstractTraversalStrategy<S> { @Override public void apply(Traversal.Admin<?, ?> traversal) { //Do nothing } } //////////////////////////////////////////// //////////////////////////////////////////// //////////////////////////////////////////// @Test public void testTraversalStrategySortingWithCategories() { TraversalStrategy a = new StrategyADecoration(), b = new StrategyBDecoration(), c = new StrategyCOptimization(), d = new StrategyDOptimization(), e = new StrategyEFinalization(), k = new StrategyKVerification(); List<TraversalStrategy<?>> s; //in category sorting s = Arrays.asList(b, a); s = TraversalStrategies.sortStrategies(s); assertEquals(2, s.size()); assertEquals(a, s.get(0)); assertEquals(b, s.get(1)); //mixed category sorting s = Arrays.asList(a, e, b, d); s = TraversalStrategies.sortStrategies(s); assertEquals(4, s.size()); assertEquals(a, s.get(0)); assertEquals(b, s.get(1)); assertEquals(d, s.get(2)); assertEquals(e, s.get(3)); //full reverse sorting s = Arrays.asList(k, e, d, c, b, a); s = TraversalStrategies.sortStrategies(s); assertEquals(6, s.size()); assertEquals(a, s.get(0)); assertEquals(b, s.get(1)); assertEquals(c, s.get(2)); assertEquals(d, s.get(3)); assertEquals(e, s.get(4)); assertEquals(k, s.get(5)); } public static class StrategyADecoration extends DummyStrategy<TraversalStrategy.DecorationStrategy> implements TraversalStrategy.DecorationStrategy { @Override public Set<Class<? extends DecorationStrategy>> applyPost() { return Stream.of(StrategyBDecoration.class).collect(Collectors.toSet()); } } public static class StrategyBDecoration extends DummyStrategy<TraversalStrategy.DecorationStrategy> implements TraversalStrategy.DecorationStrategy { } public static class StrategyCOptimization extends DummyStrategy<TraversalStrategy.OptimizationStrategy> implements TraversalStrategy.OptimizationStrategy { @Override public Set<Class<? extends OptimizationStrategy>> applyPost() { return Stream.of(StrategyDOptimization.class).collect(Collectors.toSet()); } } public static class StrategyDOptimization extends DummyStrategy<TraversalStrategy.OptimizationStrategy> implements TraversalStrategy.OptimizationStrategy { @Override public Set<Class<? extends OptimizationStrategy>> applyPrior() { return Stream.of(StrategyCOptimization.class).collect(Collectors.toSet()); } } public static class StrategyEFinalization extends DummyStrategy<TraversalStrategy.FinalizationStrategy> implements TraversalStrategy.FinalizationStrategy { } public static class StrategyKVerification extends DummyStrategy<TraversalStrategy.VerificationStrategy> implements TraversalStrategy.VerificationStrategy { } }