TreeGraphTest.java

package org.neo4j.kernel.impl.traversal;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Stack;

import org.junit.BeforeClass;
import org.junit.Test;
import org.neo4j.graphdb.Node;
import org.neo4j.graphdb.Path;
import org.neo4j.graphdb.Relationship;
import org.neo4j.graphdb.traversal.Traverser;
import org.neo4j.kernel.Traversal;

public class TreeGraphTest extends AbstractTestBase
{
    /*
     *                     (1)
     *               ------ | ------
     *             /        |        \
     *           (2)       (3)       (4)
     *          / | \     / | \     / | \
     *        (5)(6)(7) (8)(9)(A) (B)(C)(D)
     */
    private static final String[] THE_WORLD_AS_WE_KNOWS_IT = new String[] {
            "1 TO 2", "1 TO 3", "1 TO 4", "2 TO 5", "2 TO 6", "2 TO 7",
            "3 TO 8", "3 TO 9", "3 TO A", "4 TO B", "4 TO C", "4 TO D", };

    @BeforeClass
    public static void setupGraph()
    {
        createGraph( THE_WORLD_AS_WE_KNOWS_IT );
    }

    @Test
    public void nodesIteratorReturnAllNodes() throws Exception
    {
        Traverser traverser = new TraversalDescriptionImpl().traverse( referenceNode() );
        int count = 0;
        for ( Node node : traverser.nodes() )
        {
            assertNotNull( "returned nodes should not be null. node #"
                           + count, node );
            count++;
        }
        assertEquals( 13, count );
    }

    @Test
    public void relationshipsIteratorReturnAllNodes() throws Exception
    {
        Traverser traverser = new TraversalDescriptionImpl().traverse( referenceNode() );
        int count = 0;
        for ( Relationship relationship : traverser.relationships() )
        {
            assertNotNull(
                    "returned relationships should not be. relationship #"
                            + count, relationship );
            count++;
        }
        assertEquals( 12, count );
    }

    @Test
    public void pathsIteratorReturnAllNodes() throws Exception
    {
        Traverser traverser = new TraversalDescriptionImpl().traverse( referenceNode() );
        int count = 0;
        for ( Path path : traverser )
        {
            assertNotNull( "returned paths should not be null. path #"
                           + count, path );
            count++;
        }
        assertEquals( 13, count );
    }

    @Test
    public void testBreadthFirst() throws Exception
    {
        Traverser traverser = new TraversalDescriptionImpl().breadthFirst().traverse(
                referenceNode() );
        Stack<Set<String>> levels = new Stack<Set<String>>();
        levels.push( new HashSet<String>( Arrays.asList( "5", "6", "7", "8",
                "9", "A", "B", "C", "D" ) ) );
        levels.push( new HashSet<String>( Arrays.asList( "2", "3", "4" ) ) );
        levels.push( new HashSet<String>( Arrays.asList( "1" ) ) );
        assertLevels( traverser, levels );
    }

    @Test
    public void testDepthFirstTraversalReturnsNodesOnCorrectDepths()
            throws Exception
    {
        Traverser traverser = new TraversalDescriptionImpl().depthFirst().traverse(
                referenceNode() );
        int i = 0;
        for ( Path pos : traverser )
        {
            assertEquals( expectedDepth( i++ ), pos.length() );
        }
        assertEquals( 13, i );
    }

    @Test
    public void testPostorderDepthFirstReturnsDeeperNodesFirst()
    {
        Traverser traverser = new TraversalDescriptionImpl().order(
                Traversal.postorderDepthFirst() ).traverse(
                        referenceNode() );
        int i = 0;
        List<String> encounteredNodes = new ArrayList<String>();
        for ( Path pos : traverser )
        {
            encounteredNodes.add( (String) pos.endNode().getProperty( "name" ) );
            assertEquals( expectedDepth( ( 12 - i++ ) ), pos.length() );
        }
        assertEquals( 13, i );

        assertTrue( encounteredNodes.indexOf( "5" ) < encounteredNodes.indexOf( "2" ) );
        assertTrue( encounteredNodes.indexOf( "6" ) < encounteredNodes.indexOf( "2" ) );
        assertTrue( encounteredNodes.indexOf( "7" ) < encounteredNodes.indexOf( "2" ) );
        assertTrue( encounteredNodes.indexOf( "8" ) < encounteredNodes.indexOf( "3" ) );
        assertTrue( encounteredNodes.indexOf( "9" ) < encounteredNodes.indexOf( "3" ) );
        assertTrue( encounteredNodes.indexOf( "A" ) < encounteredNodes.indexOf( "3" ) );
        assertTrue( encounteredNodes.indexOf( "B" ) < encounteredNodes.indexOf( "4" ) );
        assertTrue( encounteredNodes.indexOf( "C" ) < encounteredNodes.indexOf( "4" ) );
        assertTrue( encounteredNodes.indexOf( "D" ) < encounteredNodes.indexOf( "4" ) );
        assertTrue( encounteredNodes.indexOf( "2" ) < encounteredNodes.indexOf( "1" ) );
        assertTrue( encounteredNodes.indexOf( "3" ) < encounteredNodes.indexOf( "1" ) );
        assertTrue( encounteredNodes.indexOf( "4" ) < encounteredNodes.indexOf( "1" ) );
    }

    @Test
    public void testPostorderBreadthFirstReturnsDeeperNodesFirst()
    {
        Traverser traverser = new TraversalDescriptionImpl().order(
                Traversal.postorderBreadthFirst() ).traverse(
                        referenceNode() );
        Stack<Set<String>> levels = new Stack<Set<String>>();
        levels.push( new HashSet<String>( Arrays.asList( "1" ) ) );
        levels.push( new HashSet<String>( Arrays.asList( "2", "3", "4" ) ) );
        levels.push( new HashSet<String>( Arrays.asList( "5", "6", "7", "8",
                "9", "A", "B", "C", "D" ) ) );
        assertLevels( traverser, levels );
    }

    private int expectedDepth( int i )
    {
        assertTrue( i < 13 );
        if ( i == 0 )
        {
            return 0;
        }
        else if ( ( i - 1 ) % 4 == 0 )
        {
            return 1;
        }
        else
        {
            return 2;
        }
    }
}