MergePoolTest.java

/*
 * Grapht, an open source dependency injector.
 * Copyright 2014-2015 various contributors (see CONTRIBUTORS.txt)
 * Copyright 2010-2014 Regents of the University of Minnesota
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
package org.grouplens.grapht.graph;

import com.google.common.collect.Lists;
import org.hamcrest.Matcher;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

import static org.hamcrest.Matchers.*;
import static org.junit.Assert.assertThat;

public class MergePoolTest {
    MergePool<String,String> pool;

    @Before
    public void createPool() {
        pool = MergePool.create();
    }

    @Test
    public void testSingletonNode() {
        DAGNode<String,String> node = DAGNode.singleton("foo");
        DAGNode<String,String> merged = pool.merge(node);
        // merging a singleton node should just return the node
        assertThat(merged, sameInstance(node));
    }

    @Test
    public void testReuseSingleton() {
        DAGNode<String,String> node = DAGNode.singleton("foo");
        DAGNode<String,String> node2 = DAGNode.singleton("foo");
        // simplify first so it's in the pool
        pool.merge(node);
        // and merge the second
        DAGNode<String,String> merged = pool.merge(node2);
        // the first node should have been reused
        assertThat(merged, sameInstance(node));
    }

    @Test
    public void testMergeDescendants() {
        DAGNode<String,String> node = DAGNode.singleton("foo");
        DAGNode<String,String> node2 = DAGNode.singleton("foo");
        DAGNode<String,String> root =
                DAGNode.<String,String>newBuilder("root")
                       .addEdge(node, "hello")
                       .addEdge(node2, "goodbye")
                       .build();

        DAGNode<String,String> merged = pool.merge(root);

        // now, node and node2 should be merged
        // new graph (since they're merged)
        assertThat(merged, not(sameInstance(root)));
        // only 2 nodes (root has 2 edges to same node)
        assertThat(merged.getReachableNodes(), hasSize(2));
        // two edges have same target
        List<DAGEdge<String,String>> nbrs =
                Lists.newArrayList(merged.getOutgoingEdges());
        // both edges have the same instance
        assertThat(nbrs.get(1).getTail(),
                   sameInstance(nbrs.get(0).getTail()));
        // it's one of the nodes we gave it
        assertThat(nbrs.get(0).getTail(),
                   anyOf(sameInstance(node),
                         sameInstance(node2)));

        // and a new singleton should be merged
        assertThat(pool.merge(DAGNode.<String, String>singleton("foo")),
                   anyOf(sameInstance(node),
                         sameInstance(node2)));

        // re-merging our old root should give us the same node
        assertThat(pool.merge(root), sameInstance(merged));
    }

    @Test
    public void testMergeWithChildren() {
        DAGNode<String,String> node = DAGNode.singleton("foo");
        DAGNode<String,String> p1 =
                DAGNode.<String,String>newBuilder("child")
                       .addEdge(node, "k1")
                       .build();
        DAGNode<String,String> node2 = DAGNode.singleton("foo");
        // second parent node. it will have different label to test that labels are ignored
        DAGNode<String,String> p2 =
                DAGNode.<String,String>newBuilder("child")
                       .addEdge(node, "k2")
                       .build();
        DAGNode<String,String> root =
                DAGNode.<String,String>newBuilder("root")
                       .addEdge(p1, "hello")
                       .addEdge(p2, "fish")
                       .build();

        DAGNode<String,String> merged = pool.merge(root);

        // now, p1 and p2 should be merged
        // new graph (since they're merged)
        assertThat(merged, not(sameInstance(root)));
        // only 3 nodes (root has 2 edges to now-merged nodes)
        assertThat(merged.getReachableNodes(), hasSize(3));
        // it has one of the leaves
        assertThat(merged.getReachableNodes(),
                   (Matcher) anyOf(hasItem(sameInstance(node)),
                                   hasItem(sameInstance(node2))));
        // two edges have same target
        List<DAGEdge<String,String>> nbrs =
                Lists.newArrayList(merged.getOutgoingEdges());
        // both edges have the same instance
        assertThat(nbrs.get(1).getTail(),
                   sameInstance(nbrs.get(0).getTail()));

        // and a new singleton should be merged
        assertThat(pool.merge(DAGNode.<String, String>singleton("foo")),
                   anyOf(sameInstance(node),
                         sameInstance(node2)));

        // re-merging a child should give us a previously-merged node
        assertThat(pool.merge(p2), isIn(merged.getReachableNodes()));
        assertThat(pool.merge(p1), isIn(merged.getReachableNodes()));
    }
}