pacer 2.0.10.pre-java → 2.0.12-java

data/ext/src/main/java/com/xnlogic/pacer/pipes/LabelCollectionFilterPipe.java

@@ -0,0 +1,32 @@
+package com.xnlogic.pacer.pipes;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import com.tinkerpop.blueprints.Edge;
+import com.tinkerpop.pipes.AbstractPipe;
+
+public class LabelCollectionFilterPipe extends AbstractPipe<Edge, Edge> {
+    private Set<String> labels;
+
+    public LabelCollectionFilterPipe(final Collection<String> labels) {
+        if (labels instanceof Set) {
+            this.labels = (Set<String>)labels;
+        } else {
+        	this.labels = new HashSet<String>();
+        	if(labels != null){
+        		this.labels.addAll(labels);
+        	}
+        }
+    }
+
+    protected Edge processNextStart() {
+        while (true) {
+            Edge edge = this.starts.next();
+            if (edge != null && this.labels.contains(edge.getLabel())) {
+                return edge;
+            }
+        }
+    }
+}

data/ext/src/main/java/com/xnlogic/pacer/pipes/LabelPrefixPipe.java

@@ -0,0 +1,23 @@
+package com.xnlogic.pacer.pipes;
+
+import com.tinkerpop.blueprints.Edge;
+import com.tinkerpop.pipes.AbstractPipe;
+import java.util.regex.Pattern;
+
+public class LabelPrefixPipe extends AbstractPipe<Edge, Edge> {
+    private Pattern pattern;
+  
+    public LabelPrefixPipe(final String pattern) {
+        super();
+        this.pattern = Pattern.compile("^" + pattern);
+    }
+
+    protected Edge processNextStart() {
+        while (true) {
+            Edge e = this.starts.next();
+            if (this.pattern.matcher(e.getLabel()).matches()) {
+                return e;
+            }
+        }
+    }
+}

data/ext/src/main/java/com/xnlogic/pacer/pipes/NeverPipe.java

@@ -0,0 +1,10 @@
+package com.xnlogic.pacer.pipes;
+
+import com.tinkerpop.pipes.AbstractPipe;
+import com.tinkerpop.pipes.util.FastNoSuchElementException;
+
+public class NeverPipe extends AbstractPipe<Object, Object> {
+    protected Object processNextStart() {
+        throw FastNoSuchElementException.instance();
+    }
+}

data/ext/src/main/java/com/xnlogic/pacer/pipes/VerticesPipe.java

@@ -0,0 +1,26 @@
+package com.xnlogic.pacer.pipes;
+
+import java.util.Iterator;
+
+import com.tinkerpop.blueprints.Graph;
+import com.tinkerpop.blueprints.Vertex;
+import com.tinkerpop.pipes.AbstractPipe;
+
+public class VerticesPipe extends AbstractPipe<Graph, Vertex> {
+    private Iterator<Vertex> iter;
+    private Graph starts;
+      
+    public void setStarts(Iterator<Graph> starts) {
+        // TODO: Error checking?
+        this.starts = (Graph)starts.next();
+        this.iter = this.starts.getVertices().iterator();
+    }
+
+    protected Vertex processNextStart() {
+        return this.iter.next();
+    }
+
+    public void reset() {
+        this.iter = this.starts.getVertices().iterator();
+    }
+}

data/ext/src/test/java/com/xnlogic/pacer/pipes/BlackboxPipelineTest.java

@@ -0,0 +1,33 @@
+package com.xnlogic.pacer.pipes;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import com.tinkerpop.pipes.Pipe;
+import com.tinkerpop.pipes.IdentityPipe;
+import java.util.Arrays;
+import java.util.List;
+import com.xnlogic.pacer.pipes.BlackboxPipeline;
+
+public class BlackboxPipelineTest {
+    @Test
+    public void resetTest() {
+        List<String> data = Arrays.asList("Pacer", "Pipes", "Test");
+        Pipe<String, String> pipe1 = new IdentityPipe<String>();
+        Pipe<String, String> pipe2 = new IdentityPipe<String>();
+        BlackboxPipeline<String, String> blackboxPipeline = new BlackboxPipeline<String, String>(pipe1, pipe2);
+
+        blackboxPipeline.setStarts(data);
+        pipe2.setStarts(data);
+        
+        int count = 0;
+        
+        while (blackboxPipeline.hasNext()) {
+            assertEquals(blackboxPipeline.next(), data.get(count));
+            blackboxPipeline.reset();
+            count++;
+        }
+
+        assertEquals(count, data.size());
+        assertFalse(blackboxPipeline.hasNext());
+    }
+}

data/ext/src/test/java/com/xnlogic/pacer/pipes/CollectionFilterPipeTest.java

@@ -0,0 +1,50 @@
+package com.xnlogic.pacer.pipes;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import com.tinkerpop.blueprints.Contains;
+import java.util.Collection;
+import java.util.Arrays;
+import java.util.ArrayList;
+import com.xnlogic.pacer.pipes.CollectionFilterPipe;
+
+public class CollectionFilterPipeTest {
+    @Test
+    public void filterInTest() {
+        Collection<String> collection = Arrays.asList("Pacer", "Pipes", "XNLogic");
+        Collection<String> starts = Arrays.asList("Pacer", "XNLogic");
+        Collection<String> result = new ArrayList<String>();
+        CollectionFilterPipe<String> collectionFilterPipe = new CollectionFilterPipe<String>(collection, Contains.IN);
+
+        collectionFilterPipe.setStarts(starts);
+
+        while (collectionFilterPipe.hasNext()) {
+            result.add(collectionFilterPipe.next());
+        }
+
+        assertEquals(2, result.size());
+        assertTrue(result.contains("Pacer"));
+        assertTrue(result.contains("XNLogic"));
+        assertFalse(result.contains("Pipes"));
+    }
+
+    @Test
+    public void filterNotInTest() {
+        Collection<String> collection = Arrays.asList("Pacer", "Pipes", "XNLogic");
+        Collection<String> starts = Arrays.asList("Pacer", "Java");
+        Collection<String> result = new ArrayList<String>();
+        CollectionFilterPipe<String> collectionFilterPipe = new CollectionFilterPipe<String>(collection, Contains.NOT_IN);
+
+        collectionFilterPipe.setStarts(starts);
+
+        while (collectionFilterPipe.hasNext()) {
+            result.add(collectionFilterPipe.next());
+        }
+
+        assertEquals(1, result.size());
+        assertFalse(result.contains("Pacer"));
+        assertTrue(result.contains("Java"));
+    }
+
+    // TODO: Test other constructor version.
+}

data/ext/src/test/java/com/xnlogic/pacer/pipes/EdgesPipeTest.java

@@ -0,0 +1,103 @@
+package com.xnlogic.pacer.pipes;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import org.junit.Before;
+import org.junit.After;
+import com.tinkerpop.blueprints.impls.tg.TinkerGraph;
+import com.tinkerpop.blueprints.Graph;
+import com.tinkerpop.blueprints.Vertex;
+import com.tinkerpop.blueprints.Edge;
+import java.util.Collection;
+import java.util.Arrays;
+import java.util.ArrayList;
+import com.xnlogic.pacer.pipes.EdgesPipe;
+
+public class EdgesPipeTest {
+    private TinkerGraph graph = null;
+    private Collection<Graph> graphs;
+    private Collection<Edge> edgesThatCount;
+
+    @Before
+    public void setup() throws Exception {
+        this.graph = new TinkerGraph();
+        this.graphs = Arrays.asList((Graph)this.graph);
+    }
+
+    private void createEdges() {
+        Vertex v1 = this.graph.addVertex(1);
+        Vertex v2 = this.graph.addVertex(2);
+        Vertex v3 = this.graph.addVertex(3);
+        
+        Edge e1 = this.graph.addEdge("E1", v1, v2, "edge_label");
+        Edge e2 = this.graph.addEdge("E2", v2, v1, "edge_label2");
+        Edge e3 = this.graph.addEdge("E3", v1, v2, "edge_label3");
+        this.graph.addEdge("E4", v2, v3, "edge_label4");
+
+        this.edgesThatCount = Arrays.asList(e1, e2, e3);
+    }
+  
+    @After
+    public void teardown() throws Exception {
+        this.graph.shutdown();
+        this.graph = null;
+    }
+
+    @Test
+    public void getEdgesFromGraphTest() {
+        this.createEdges();
+
+        EdgesPipe edgesPipe = new EdgesPipe();
+        edgesPipe.setStarts(this.graphs);
+        
+        Collection<Edge> edges = new ArrayList<Edge>();
+
+        while (edgesPipe.hasNext()) {
+            edges.add(edgesPipe.next());
+        }
+
+        assertEquals(4, edges.size());
+        assertTrue(edges.containsAll(this.edgesThatCount));
+    }
+
+    @Test
+    public void getEdgesFromGraphAfterResetTest() {
+        this.createEdges();
+        
+        EdgesPipe edgesPipe = new EdgesPipe();
+        edgesPipe.setStarts(this.graphs);
+        
+        Collection<Edge> edges = new ArrayList<Edge>();
+
+        while (edgesPipe.hasNext()) {
+            edges.add(edgesPipe.next());
+        }
+
+        assertEquals(4, edges.size());
+        assertTrue(edges.containsAll(this.edgesThatCount));
+        
+        edgesPipe.reset();
+        edges.clear();
+        
+        while (edgesPipe.hasNext()) {
+            edges.add(edgesPipe.next());
+        }
+
+        assertEquals(4, edges.size());
+        assertTrue(edges.containsAll(this.edgesThatCount));
+    }
+    
+    @Test
+    public void getNoEdgesFromGraphTest() {
+        EdgesPipe edgesPipe = new EdgesPipe();
+        edgesPipe.setStarts(this.graphs);
+        
+        Collection<Edge> edges = new ArrayList<Edge>();
+
+        while (edgesPipe.hasNext()) {
+            edges.add(edgesPipe.next());
+        }
+
+        assertEquals(0, edges.size());
+    }
+}

data/ext/src/test/java/com/xnlogic/pacer/pipes/ExpandablePipeTest.java

@@ -0,0 +1,66 @@
+package com.xnlogic.pacer.pipes;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import java.util.Arrays;
+import java.util.ArrayList;
+import com.tinkerpop.pipes.Pipe;
+import com.tinkerpop.pipes.IdentityPipe;
+import com.tinkerpop.pipes.AbstractPipe;
+import java.util.Iterator;
+import com.xnlogic.pacer.pipes.ExpandablePipe;
+
+public class ExpandablePipeTest {
+
+    @Test
+    public void queueWithElementsTest() {
+        ExpandablePipe expandablePipe = new ExpandablePipe();
+
+        ArrayList input = new ArrayList();
+        input.add("X");
+
+        expandablePipe.setStarts(input.iterator());
+
+        expandablePipe.add("a", 1, new ArrayList());
+        expandablePipe.add("b", 2, new ArrayList());
+        expandablePipe.add("c", 3, new ArrayList());
+      
+        Object result = expandablePipe.next();
+        assertTrue(result.equals("a"));
+        assertTrue(expandablePipe.getMetadata().equals(1));
+
+        result = expandablePipe.next();
+        assertTrue(result.equals("b"));
+        assertTrue(expandablePipe.getMetadata().equals(2));
+        
+        result = expandablePipe.next();
+        assertTrue(result.equals("c"));
+        assertTrue(expandablePipe.getMetadata().equals(3));
+        
+        result = expandablePipe.next();
+        assertTrue(result.equals("X"));
+        assertNull(expandablePipe.getMetadata());
+    }
+
+    @Test
+    public void emptyQueueTest() {
+        // TODO: fix this test
+
+        //ExpandablePipe expandablePipe = new ExpandablePipe();
+
+        //IdentityPipe<Pipe> pipe1 = new IdentityPipe<Pipe>();
+        //DeadPipe pipe2 = new DeadPipe();
+       
+        //pipe1.enablePath(true);
+
+        //pipe1.setStarts(pipe2);
+        //expandablePipe.setStarts(pipe1);
+        //
+        //Pipe p = expandablePipe.next();
+        //assertTrue(pipe2.equals(p));
+        //assertNull(expandablePipe.getMetadata());
+    }
+
+    // TODO: Test getPathToHere()
+      
+}

data/ext/src/test/java/com/xnlogic/pacer/pipes/IdCollectionFilterPipeTest.java

@@ -0,0 +1,85 @@
+package com.xnlogic.pacer.pipes;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import org.junit.Before;
+import org.junit.After;
+import com.tinkerpop.blueprints.Contains;
+import com.tinkerpop.blueprints.Vertex;
+import com.tinkerpop.blueprints.impls.tg.TinkerGraph;
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+import com.xnlogic.pacer.pipes.IdCollectionFilterPipe;
+
+public class IdCollectionFilterPipeTest {
+    private TinkerGraph graph = null;
+
+    @Before
+    public void setup() throws Exception {
+        this.graph = new TinkerGraph();
+    }
+
+    @After
+    public void teardown() throws Exception {
+        this.graph.shutdown();
+        this.graph = null;
+    }
+    
+    @Test
+    public void containsInTest() {
+        IdCollectionFilterPipe<Vertex> idCollectionFilterPipe =
+          new IdCollectionFilterPipe<Vertex>(Arrays.asList("1", "2", "3", "4"), Contains.IN);
+
+        Vertex v1 = this.graph.addVertex("1");
+        Vertex v2 = this.graph.addVertex("2");
+        Vertex v3 = this.graph.addVertex("5");
+
+        idCollectionFilterPipe.setStarts(Arrays.asList(v1, v2, v3));
+
+        Vertex v = idCollectionFilterPipe.next();
+        assertTrue(v.getId().equals("1"));
+        
+        v = idCollectionFilterPipe.next();
+        assertTrue(v.getId().equals("2"));
+
+        boolean hasEx = false;
+        
+        try {
+            v = idCollectionFilterPipe.next();
+        } catch (NoSuchElementException nsee) {
+            hasEx = true;
+        }
+
+        assertTrue(hasEx);
+    }
+
+    @Test
+    public void containsNotInTest() {
+        IdCollectionFilterPipe<Vertex> idCollectionFilterPipe =
+          new IdCollectionFilterPipe<Vertex>(Arrays.asList("1", "2", "3", "4"), Contains.NOT_IN);
+
+        Vertex v1 = this.graph.addVertex("7");
+        Vertex v2 = this.graph.addVertex("8");
+        Vertex v3 = this.graph.addVertex("1");
+
+        idCollectionFilterPipe.setStarts(Arrays.asList(v1, v2, v3));
+
+        Vertex v = idCollectionFilterPipe.next();
+        assertTrue(v.getId().equals("7"));
+        
+        v = idCollectionFilterPipe.next();
+        assertTrue(v.getId().equals("8"));
+
+        boolean hasEx = false;
+
+        try {
+            v = idCollectionFilterPipe.next();
+        } catch (NoSuchElementException nsee) {
+            hasEx = true;
+        }
+        
+        assertTrue(hasEx);
+    }
+
+    // TODO: Lookup "Contains" and see if there are more than just the two values in the enum.
+}

data/ext/src/test/java/com/xnlogic/pacer/pipes/IsUniquePipeTest.java

@@ -0,0 +1,62 @@
+package com.xnlogic.pacer.pipes;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import java.util.Collection;
+import java.util.Arrays;
+import com.xnlogic.pacer.pipes.IsUniquePipe;
+
+public class IsUniquePipeTest {
+
+    @Test
+    public void allUniqueTest() {
+        Collection<String> collection = Arrays.asList("These", "are", "all", "unique");
+        IsUniquePipe<String> isUniquePipe = new IsUniquePipe<String>();
+
+        isUniquePipe.setStarts(collection);
+
+        String s = isUniquePipe.next();
+        assertTrue(s.equals("These"));
+        assertTrue(isUniquePipe.isUnique());
+        
+        s = isUniquePipe.next();
+        assertTrue(s.equals("are"));
+        assertTrue(isUniquePipe.isUnique());
+        
+        s = isUniquePipe.next();
+        assertTrue(s.equals("all"));
+        assertTrue(isUniquePipe.isUnique());
+        
+        s = isUniquePipe.next();
+        assertTrue(s.equals("unique"));
+        assertTrue(isUniquePipe.isUnique());
+    }
+    
+    @Test
+    public void notAllUniqueTest() {
+        Collection<String> collection = Arrays.asList("Not", "all", "all", "all", "unique");
+        IsUniquePipe<String> isUniquePipe = new IsUniquePipe<String>();
+
+        isUniquePipe.setStarts(collection);
+
+        String s = isUniquePipe.next();
+        assertTrue(s.equals("Not"));
+        assertTrue(isUniquePipe.isUnique());
+        
+        s = isUniquePipe.next();
+        assertTrue(s.equals("all"));
+        assertTrue(isUniquePipe.isUnique());
+        
+        s = isUniquePipe.next();
+        assertTrue(s.equals("all"));
+        assertFalse(isUniquePipe.isUnique());
+        
+        s = isUniquePipe.next();
+        assertTrue(s.equals("all"));
+        assertFalse(isUniquePipe.isUnique());
+        
+        s = isUniquePipe.next();
+        assertTrue(s.equals("unique"));
+        assertFalse(isUniquePipe.isUnique());
+    }
+}

data/ext/src/test/java/com/xnlogic/pacer/pipes/LabelCollectionFilterPipeTest.java

@@ -0,0 +1,97 @@
+package com.xnlogic.pacer.pipes;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import org.junit.Before;
+import org.junit.After;
+import com.tinkerpop.blueprints.impls.tg.TinkerGraph;
+import com.tinkerpop.blueprints.Vertex;
+import com.tinkerpop.blueprints.Edge;
+import java.util.Collection;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.NoSuchElementException;
+import com.xnlogic.pacer.pipes.LabelCollectionFilterPipe;
+
+public class LabelCollectionFilterPipeTest {
+    private TinkerGraph graph;
+    private Collection<Edge> edges;
+  
+    @Before
+    public void setup() throws Exception {
+        this.graph = new TinkerGraph();
+    }
+
+    @After
+    public void teardown() throws Exception {
+        this.graph.shutdown();
+        this.graph = null;
+    }
+
+    private void createEdges() {
+        Vertex v1 = this.graph.addVertex(1);
+        Vertex v2 = this.graph.addVertex(2);
+        Vertex v3 = this.graph.addVertex(3);
+        Vertex v4 = this.graph.addVertex(4);
+
+        Edge e1 = this.graph.addEdge("E1", v1, v2, "edge1");
+        Edge e2 = this.graph.addEdge("E2", v2, v1, "edge2");
+        Edge e3 = this.graph.addEdge("E3", v2, v3, "edge3");
+        Edge e4 = this.graph.addEdge("E4", v3, v4, "edge4");
+
+        this.edges = Arrays.asList(e1, e2, e3, e4);
+    }
+    
+    @Test(expected=NoSuchElementException.class)
+    public void hasSomeMatchingEdgesTest() {
+        this.createEdges();
+        Collection<String> edgeLabels = Arrays.asList("edge2", "edge3");
+        LabelCollectionFilterPipe labelCollectionFilterPipe = new LabelCollectionFilterPipe(edgeLabels);
+        
+        labelCollectionFilterPipe.setStarts(this.edges);
+        Edge e = labelCollectionFilterPipe.next();
+        assertEquals("E2", e.getId());
+        
+        e = labelCollectionFilterPipe.next();
+        assertEquals("E3", e.getId());
+
+        labelCollectionFilterPipe.next();
+    }
+    
+    
+    @Test(expected=NoSuchElementException.class)
+    public void hasSomeMatchingEdgesWithSetTest() {
+        this.createEdges();
+        HashSet<String> edgeLabels = new HashSet<String>(Arrays.asList("edge2", "edge3"));
+        LabelCollectionFilterPipe labelCollectionFilterPipe = new LabelCollectionFilterPipe(edgeLabels);
+        
+        labelCollectionFilterPipe.setStarts(this.edges);
+        Edge e = labelCollectionFilterPipe.next();
+        assertEquals("E2", e.getId());
+        
+        e = labelCollectionFilterPipe.next();
+        assertEquals("E3", e.getId());
+
+        labelCollectionFilterPipe.next();
+    }
+
+    @Test(expected=NoSuchElementException.class)
+    public void hasNoMatchingEdgesTest() {
+        this.createEdges();
+        Collection<String> edgeLabels = Arrays.asList("edge5", "edge6");
+        LabelCollectionFilterPipe labelCollectionFilterPipe = new LabelCollectionFilterPipe(edgeLabels);
+        
+        labelCollectionFilterPipe.setStarts(this.edges);
+        labelCollectionFilterPipe.next();
+    }
+    
+    
+    @Test(expected=NoSuchElementException.class)
+    public void noEdgesToMatchTest() {
+        this.createEdges();
+        LabelCollectionFilterPipe labelCollectionFilterPipe = new LabelCollectionFilterPipe(null);
+        
+        labelCollectionFilterPipe.setStarts(this.edges);
+        labelCollectionFilterPipe.next();
+    }
+}

data/ext/src/test/java/com/xnlogic/pacer/pipes/LabelPrefixPipeTest.java

@@ -0,0 +1,69 @@
+package com.xnlogic.pacer.pipes;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.NoSuchElementException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.tinkerpop.blueprints.Edge;
+import com.tinkerpop.blueprints.Vertex;
+import com.tinkerpop.blueprints.impls.tg.TinkerGraph;
+
+public class LabelPrefixPipeTest {
+    private TinkerGraph graph;
+    private Collection<Edge> edges;
+  
+    @Before
+    public void setup() throws Exception {
+        this.graph = new TinkerGraph();
+    }
+
+    @After
+    public void teardown() throws Exception {
+        this.graph.shutdown();
+        this.graph = null;
+    }
+
+    private void createEdges() {
+        Vertex v1 = this.graph.addVertex(1);
+        Vertex v2 = this.graph.addVertex(2);
+        Vertex v3 = this.graph.addVertex(3);
+        Vertex v4 = this.graph.addVertex(4);
+
+        Edge e1 = this.graph.addEdge("E1", v1, v2, "edge1");
+        Edge e2 = this.graph.addEdge("E2", v2, v1, "edge2");
+        Edge e3 = this.graph.addEdge("E3", v2, v3, "edge3");
+        Edge e4 = this.graph.addEdge("E4", v3, v4, "edge4");
+
+        this.edges = Arrays.asList(e1, e2, e3, e4);
+    }
+    
+    @Test
+    public void hasLabelPrefixesTest() {
+        this.createEdges();
+        LabelPrefixPipe labelPrefixPipe = new LabelPrefixPipe("edge[2-3]");
+        
+        labelPrefixPipe.setStarts(this.edges);
+        Edge e = labelPrefixPipe.next();
+        assertEquals("E2", e.getId());
+        
+        e = labelPrefixPipe.next();
+        assertEquals("E3", e.getId());
+
+        boolean hasEx = false;
+
+        try {
+            e = labelPrefixPipe.next();
+        } catch (NoSuchElementException nsee) {
+            hasEx = true;
+        }
+        
+        assertTrue(hasEx);
+    }
+}

data/ext/src/test/java/com/xnlogic/pacer/pipes/NeverPipeTest.java

@@ -0,0 +1,17 @@
+package com.xnlogic.pacer.pipes;
+
+import java.util.ArrayList;
+import java.util.NoSuchElementException;
+
+import org.junit.Test;
+
+public class NeverPipeTest {
+    @Test(expected=NoSuchElementException.class)
+    public void ensureExceptionTest() {
+        NeverPipe neverPipe = new NeverPipe();
+        ArrayList<Object> starts = new ArrayList<Object>();
+        starts.add(new Object());
+        neverPipe.setStarts(starts.iterator());
+        neverPipe.next();
+    }
+}