Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.tinkerpop.gremlin.structure.strategy.SequenceStrategyTest Maven / Gradle / Ivy
package com.tinkerpop.gremlin.structure.strategy;
import com.tinkerpop.gremlin.AbstractGremlinTest;
import com.tinkerpop.gremlin.FeatureRequirement;
import com.tinkerpop.gremlin.FeatureRequirementSet;
import com.tinkerpop.gremlin.process.graph.GraphTraversal;
import com.tinkerpop.gremlin.structure.Direction;
import com.tinkerpop.gremlin.structure.Edge;
import com.tinkerpop.gremlin.structure.Graph;
import com.tinkerpop.gremlin.structure.Property;
import com.tinkerpop.gremlin.structure.Vertex;
import com.tinkerpop.gremlin.structure.VertexProperty;
import com.tinkerpop.gremlin.util.function.TriFunction;
import org.junit.Test;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;
import static org.junit.Assert.*;
/**
* @author Stephen Mallette (http://stephen.genoprime.com)
*/
public class SequenceStrategyTest extends AbstractGremlinTest {
@Test
@FeatureRequirementSet(FeatureRequirementSet.Package.VERTICES_ONLY)
@FeatureRequirement(featureClass = Graph.Features.VertexFeatures.class, feature = Graph.Features.VertexFeatures.FEATURE_MULTI_PROPERTIES)
public void shouldAppendMultiPropertyValuesToVertex() {
final StrategyGraph swg = g.strategy(SequenceStrategy.build().sequence(
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working1"));
return f.apply(o.toArray());
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working2"));
o.addAll(Arrays.asList("try", "anything"));
return f.apply(o.toArray());
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return UnaryOperator.identity();
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working3"));
return f.apply(o.toArray());
};
}
}
).create());
final Vertex v = swg.addVertex("any", "thing");
assertNotNull(v);
assertEquals("thing", v.property("any").value());
assertEquals(3, v.values("anonymous").toList().size());
assertTrue(v.values("anonymous").toList().contains("working1"));
assertTrue(v.values("anonymous").toList().contains("working2"));
assertTrue(v.values("anonymous").toList().contains("working3"));
assertEquals("anything", v.property("try").value());
}
@Test
@FeatureRequirementSet(FeatureRequirementSet.Package.VERTICES_ONLY)
public void shouldOverwritePropertyValuesToVertex() {
final StrategyGraph swg = g.strategy(SequenceStrategy.build().sequence(
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working1"));
return f.apply(o.toArray());
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.remove("anonymous");
o.remove("working1");
o.addAll(Arrays.asList("anonymous", "working2"));
o.addAll(Arrays.asList("try", "anything"));
return f.apply(o.toArray());
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return UnaryOperator.identity();
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.remove("anonymous");
o.remove("working2");
o.addAll(Arrays.asList("anonymous", "working3"));
return f.apply(o.toArray());
};
}
}
).create());
final Vertex v = swg.addVertex("any", "thing");
assertNotNull(v);
assertEquals("thing", v.property("any").value());
assertEquals(1, v.values("anonymous").toList().size());
assertTrue(v.values("anonymous").toList().contains("working3"));
assertEquals("anything", v.property("try").value());
}
@Test
@FeatureRequirementSet(FeatureRequirementSet.Package.VERTICES_ONLY)
public void shouldAllowForALocalGraphStrategyCallInSequence() {
final StrategyGraph swg = g.strategy(SequenceStrategy.build().sequence(
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working"));
return f.apply(o.toArray());
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("ts", "timestamped"));
return f.apply(o.toArray());
};
}
@Override
public UnaryOperator>> getVertexPropertyStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (k, v) -> {
ctx.getCurrent().getBaseVertex().property("timestamp", "timestamped");
// dynamically construct a strategy to force this call to addVertex to stay localized
// to this GraphStrategy (i.e. the first GraphStrategy in the sequence is ignored)
// note that this will not call GraphStrategy implementations after this one in the
// sequence either
final StrategyContext innerCtx = new StrategyContext<>(ctx.getStrategyGraph(), ctx.getStrategyGraph());
this.getAddVertexStrategy(innerCtx, composingStrategy)
.apply(ctx.getStrategyGraph().getBaseGraph()::addVertex)
.apply(Arrays.asList("strategy", "bypassed").toArray());
return f.apply(k, v);
};
}
}
).create());
final Vertex v = swg.addVertex("any", "thing");
v.property("set", "prop");
assertNotNull(v);
assertEquals("thing", v.property("any").value());
assertEquals(1, v.values("anonymous").toList().size());
assertTrue(v.values("ts").toList().contains("timestamped"));
assertTrue(v.values("set").toList().contains("prop"));
final Vertex vStrat = (Vertex) g.V().has("strategy", "bypassed").next();
assertEquals(0, vStrat.values("anonymous").toList().size());
assertTrue(v.values("ts").toList().contains("timestamped"));
assertTrue(v.values("timestamp").toList().contains("timestamped"));
}
@Test
@FeatureRequirementSet(FeatureRequirementSet.Package.VERTICES_ONLY)
public void shouldAllowForANeighborhoodGraphStrategyCallInSequence() {
final SequenceStrategy innerSequenceStrategy = SequenceStrategy.build().sequence(new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("ts1", "timestamped"));
return f.apply(o.toArray());
};
}
@Override
public UnaryOperator>> getVertexPropertyStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (k, v) -> {
ctx.getCurrent().getBaseVertex().property("timestamp", "timestamped");
// dynamically construct a strategy to force this call to addVertex to stay localized
// to the innerSequenceGraphStrategy. note that this will only call GraphStrategy implementations
// in this sequence
final StrategyContext innerCtx = new StrategyContext<>(ctx.getStrategyGraph(), ctx.getStrategyGraph());
composingStrategy.getAddVertexStrategy(innerCtx, composingStrategy)
.apply(ctx.getStrategyGraph().getBaseGraph()::addVertex)
.apply(Arrays.asList("strategy", "bypassed").toArray());
return f.apply(k, v);
};
}
}, new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("ts2", "timestamped"));
return f.apply(o.toArray());
};
}
}).create();
final StrategyGraph swg = g.strategy(SequenceStrategy.build().sequence(
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working"));
return f.apply(o.toArray());
};
}
},
innerSequenceStrategy
).create());
final Vertex v = swg.addVertex("any", "thing");
v.property("set", "prop");
assertNotNull(v);
assertEquals("thing", v.property("any").value());
assertEquals(1, v.values("anonymous").toList().size());
assertTrue(v.values("ts1").toList().contains("timestamped"));
assertTrue(v.values("ts2").toList().contains("timestamped"));
assertTrue(v.values("set").toList().contains("prop"));
final Vertex vStrat = (Vertex) g.V().has("strategy", "bypassed").next();
assertEquals(0, vStrat.values("anonymous").toList().size());
assertTrue(v.values("ts1").toList().contains("timestamped"));
assertTrue(v.values("ts2").toList().contains("timestamped"));
assertTrue(v.values("timestamp").toList().contains("timestamped"));
}
@Test
@FeatureRequirementSet(FeatureRequirementSet.Package.VERTICES_ONLY)
public void shouldAlterArgumentsToAddVertexInOrderOfSequence() {
final StrategyGraph swg = g.strategy(SequenceStrategy.build().sequence(
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working1"));
return f.apply(o.toArray());
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.replaceAll(it -> it.equals("working1") ? "working2" : it);
o.addAll(Arrays.asList("try", "anything"));
return f.apply(o.toArray());
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return UnaryOperator.identity();
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.replaceAll(it -> it.equals("working2") ? "working3" : it);
return f.apply(o.toArray());
};
}
}
).create());
final Vertex v = swg.addVertex("any", "thing");
assertNotNull(v);
assertEquals("thing", v.property("any").value());
assertEquals("working3", v.property("anonymous").value());
assertEquals("anything", v.property("try").value());
}
@Test(expected = RuntimeException.class)
@FeatureRequirementSet(FeatureRequirementSet.Package.VERTICES_ONLY)
public void shouldShortCircuitStrategyWithException() {
final StrategyGraph swg = g.strategy(SequenceStrategy.build().sequence(
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working1"));
return f.apply(o.toArray());
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
throw new RuntimeException("test");
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working3"));
return f.apply(o.toArray());
};
}
}
).create());
swg.addVertex("any", "thing");
}
@Test
@FeatureRequirementSet(FeatureRequirementSet.Package.VERTICES_ONLY)
public void shouldShortCircuitStrategyWithNoOp() {
final StrategyGraph swg = g.strategy(SequenceStrategy.build().sequence(
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working1"));
return f.apply(o.toArray());
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
// if "f" is not applied then the next step and following steps won't process
return (f) -> (args) -> null;
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working3"));
return f.apply(o.toArray());
};
}
}
).create());
assertNull(swg.addVertex("any", "thing"));
}
@Test
@FeatureRequirementSet(FeatureRequirementSet.Package.VERTICES_ONLY)
public void shouldDoSomethingBeforeAndAfter() {
final StrategyGraph swg = g.strategy(SequenceStrategy.build().sequence(
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final Vertex v = f.apply(args);
// this means that the next strategy and those below it executed including
// the implementation
assertEquals("working2", v.property("anonymous").value());
// now do something with that vertex after the fact
v.properties("anonymous").remove();
v.property("anonymous", "working1");
return v;
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final Vertex v = f.apply(args);
// this means that the next strategy and those below it executed including
// the implementation
assertEquals("working3", v.property("anonymous").value());
// now do something with that vertex after the fact
v.properties("anonymous").remove();
v.property("anonymous", "working2");
return v;
};
}
},
new GraphStrategy() {
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return (f) -> (args) -> {
final List o = new ArrayList<>(Arrays.asList(args));
o.addAll(Arrays.asList("anonymous", "working3"));
return f.apply(o.toArray());
};
}
}
).create());
final Vertex v = swg.addVertex("any", "thing");
assertNotNull(v);
assertEquals("thing", v.property("any").value());
assertEquals("working1", v.property("anonymous").value());
}
@Test
public void shouldHaveAllMethodsImplemented() throws Exception {
final Method[] methods = GraphStrategy.class.getDeclaredMethods();
final SpyGraphStrategy spy = new SpyGraphStrategy();
final SequenceStrategy strategy = SequenceStrategy.build().sequence(spy).create();
// invoke all the strategy methods
Stream.of(methods).forEach(method -> {
try {
method.invoke(strategy, new StrategyContext(new StrategyGraph(g), new StrategyWrapped() {
}), strategy);
} catch (Exception ex) {
ex.printStackTrace();
fail("Should be able to invoke function");
throw new RuntimeException("fail");
}
});
// check the spy to see that all methods were executed
assertEquals(methods.length, spy.getCount());
}
public class SpyGraphStrategy implements GraphStrategy {
private int count = 0;
public int getCount() {
return count;
}
private UnaryOperator spy() {
count++;
return UnaryOperator.identity();
}
@Override
public UnaryOperator>> getGraphIteratorsVertexIteratorStrategy(final StrategyContext ctx, GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getGraphIteratorsEdgeIteratorStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getAddVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getAddEdgeStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getRemoveEdgeStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getRemoveVertexStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getRemovePropertyStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVertexGetPropertyStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getEdgeGetPropertyStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVertexPropertyStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getEdgePropertyStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVertexIdStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVertexGraphStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getEdgeIdStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getEdgeGraphStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVertexLabelStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getEdgeLabelStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVertexKeysStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getEdgeKeysStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVertexValueStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getEdgeValueStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVariableKeysStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVariableGetStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVariableSetStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVariableRemoveStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVariableAsMapStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getGraphCloseStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>>> getVertexIteratorsPropertyIteratorStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>>> getEdgeIteratorsPropertyIteratorStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVertexIteratorsValueIteratorStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getEdgeIteratorsValueIteratorStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVertexIteratorsVertexIteratorStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVertexIteratorsEdgeIteratorStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getRemoveVertexPropertyStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getEdgeIteratorsVertexIteratorStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVertexPropertyIdStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVertexPropertyLabelStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVertexPropertyGraphStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVertexPropertyKeysStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVertexPropertyGetElementStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVertexPropertyPropertyStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>>> getVertexPropertyIteratorsPropertyIteratorStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getVertexPropertyIteratorsValueIteratorStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getGraphVStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator>> getGraphEStrategy(final StrategyContext ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVertexPropertyValueStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getPropertyValueStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getVertexPropertyKeyStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
@Override
public UnaryOperator> getPropertyKeyStrategy(final StrategyContext> ctx, final GraphStrategy composingStrategy) {
return spy();
}
}
}
