com.tinkerpop.gremlin.process.graph.step.sideEffect.CountTest Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gremlin-test Show documentation
The newest version!
package com.tinkerpop.gremlin.process.graph.step.sideEffect;

import com.tinkerpop.gremlin.LoadGraphWith;
import com.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
import com.tinkerpop.gremlin.process.Traversal;
import com.tinkerpop.gremlin.structure.Vertex;
import org.junit.Test;

import static com.tinkerpop.gremlin.LoadGraphWith.GraphData.GRATEFUL;
import static com.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
import static com.tinkerpop.gremlin.process.graph.AnonymousGraphTraversal.Tokens.__;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;

/**
 * @author Marko A. Rodriguez (http://markorodriguez.com)
 */
public abstract class CountTest extends AbstractGremlinProcessTest {

    public abstract Traversal get_g_V_count();

    public abstract Traversal get_g_V_out_count();

    public abstract Traversal get_g_V_both_both_count();

    public abstract Traversal get_g_V_repeatXoutX_timesX3X_count();

    public abstract Traversal get_g_V_repeatXoutX_timesX8X_count();

    public abstract Traversal get_g_V_filterXfalseX_count();

    @Test
    @LoadGraphWith(MODERN)
    public void g_V_count() {
        final Traversal traversal = get_g_V_count();
        printTraversalForm(traversal);
        assertEquals(new Long(6), traversal.next());
        assertFalse(traversal.hasNext());
    }

    @Test
    @LoadGraphWith(MODERN)
    public void g_V_out_count() {
        final Traversal traversal = get_g_V_out_count();
        printTraversalForm(traversal);
        assertEquals(new Long(6), traversal.next());
        assertFalse(traversal.hasNext());
    }

    @Test
    @LoadGraphWith(GRATEFUL)
    public void g_V_both_both_count() {
        final Traversal traversal = get_g_V_both_both_count();
        printTraversalForm(traversal);
        assertEquals(new Long(1406914), traversal.next());
        assertFalse(traversal.hasNext());
    }

    @Test
    @LoadGraphWith(GRATEFUL)
    public void g_V_repeatXoutX_timesX3X_count() {
        final Traversal traversal = get_g_V_repeatXoutX_timesX3X_count();
        printTraversalForm(traversal);
        assertEquals(new Long(14465066L), traversal.next());
        assertFalse(traversal.hasNext());
    }

    @Test
    @LoadGraphWith(GRATEFUL)
    public void g_V_repeatXoutX_timesX8X_count() {
        final Traversal traversal = get_g_V_repeatXoutX_timesX8X_count();
        printTraversalForm(traversal);
        assertEquals(new Long(2505037961767380L), traversal.next());
        assertFalse(traversal.hasNext());
    }

    @Test
    @LoadGraphWith(MODERN)
    public void g_V_filterXfalseX_count() {
        final Traversal traversal = get_g_V_filterXfalseX_count();
        printTraversalForm(traversal);
        assertEquals(new Long(0), traversal.next());
        assertFalse(traversal.hasNext());
    }

    public static class StandardTest extends CountTest {

        @Override
        public Traversal get_g_V_count() {
            return g.V().count();
        }

        @Override
        public Traversal get_g_V_out_count() {
            return g.V().out().count();
        }

        @Override
        public Traversal get_g_V_both_both_count() {
            return g.V().both().both().count();
        }

        @Override
        public Traversal get_g_V_repeatXoutX_timesX3X_count() {
            return g.V().repeat(__.out()).times(3).count();
        }

        @Override
        public Traversal get_g_V_repeatXoutX_timesX8X_count() {
            return g.V().repeat(__.out()).times(8).count();
        }

        @Override
        public Traversal get_g_V_filterXfalseX_count() {
            return g.V().filter(v -> false).count();
        }
    }

    public static class ComputerTest extends CountTest {

        public ComputerTest() {
            requiresGraphComputer = true;
        }

        @Override
        public Traversal get_g_V_count() {
            return g.V().count().submit(g.compute());
        }

        @Override
        public Traversal get_g_V_out_count() {
            return g.V().out().count().submit(g.compute());
        }

        @Override
        public Traversal get_g_V_both_both_count() {
            return g.V().both().both().count().submit(g.compute());
        }

        @Override
        public Traversal get_g_V_repeatXoutX_timesX3X_count() {
            return g.V().repeat(__.out()).times(3).count().submit(g.compute());
        }

        @Override
        public Traversal get_g_V_repeatXoutX_timesX8X_count() {
            return g.V().repeat(__.out()).times(8).count().submit(g.compute());
        }

        @Override
        public Traversal get_g_V_filterXfalseX_count() {
            return g.V().filter(v -> false).count().submit(g.compute());
        }
    }
}