@Test

    public void testOpenBitSet() {

        OpenBitSet b1 = bitSet("00000111");

        OpenBitSet b2 = bitSet("00000111");

        OpenBitSet b3 = bitSet("00000110");

        OpenBitSet b4 = bitSet("00001110");

        assertEquals(0, OpenBitSet.andNotCount(b1, b2)); // b1 and b3 are equal

        assertEquals( 1,  OpenBitSet.andNotCount( b2, b3 ) ); // b2 is not a subset of b3

        assertEquals(0, OpenBitSet.andNotCount(b3, b2)); // b3 is a subset of b2

        assertEquals(1, OpenBitSet.andNotCount(b2, b4)); // b2 is not a subset of b4

        assertEquals(1, OpenBitSet.andNotCount(b4, b2)); // b4 is not a subset of b3

    }

    @Test

    public void testMoralize1() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        connectParentToChildren(x2, x1);

        connectParentToChildren(x3, x1);

        connectParentToChildren(x4, x1);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        assertLinkedNode(jtBuilder, new int[]{1, 2, 3, 4});

        assertLinkedNode(jtBuilder, new int[]{2, 1});

        assertLinkedNode(jtBuilder, new int[]{3, 1});

        assertLinkedNode(jtBuilder, new int[]{4, 1});

        jtBuilder.moralize();

        assertLinkedNode(jtBuilder, new int[]{1, 2, 3, 4});

        assertLinkedNode(jtBuilder, new int[]{2, 1, 3, 4});

        assertLinkedNode(jtBuilder, new int[]{3, 1, 2, 4});

        assertLinkedNode(jtBuilder, new int[]{4, 1, 2, 3});

    }

    @Test

    public void testMoralize2() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        connectParentToChildren(x1, x2, x3);

        connectParentToChildren(x2, x4);

        connectParentToChildren(x4, x5);

        connectParentToChildren(x3, x5);

        connectParentToChildren(x6, x5);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        jtBuilder.moralize();

        assertLinkedNode(jtBuilder, new int[]{x1.getId(), 2, 3});

        assertLinkedNode(jtBuilder, new int[]{x2.getId(), 1, 4});

        assertLinkedNode(jtBuilder, new int[]{x3.getId(), 1, 4, 5, 6});

        assertLinkedNode(jtBuilder, new int[]{x4.getId(), 2, 3, 5, 6});

        assertLinkedNode(jtBuilder, new int[]{x5.getId(), 3, 4, 6});

        assertLinkedNode(jtBuilder, new int[]{x6.getId(), 3, 4, 5});

    }

    @Test

    public void testEliminationCandidate1() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        connectParentToChildren(x1, x2, x3, x4);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        jtBuilder.moralize();

        EliminationCandidate vt1 = new EliminationCandidate(graph, jtBuilder.getAdjacencyMatrix(), x1 );

        assertEquals(3, vt1.getNewEdgesRequired() );

        assertEquals( bitSet("11110"), vt1.getCliqueBitSit());

    }

    @Test

    public void testEliminationCandidate2() {

        Graph graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        connectParentToChildren(x1, x2, x3, x4);

        connectParentToChildren(x3, x4);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        jtBuilder.moralize();

        EliminationCandidate vt1 = new EliminationCandidate(graph, jtBuilder.getAdjacencyMatrix(), x1 );

        assertEquals(2, vt1.getNewEdgesRequired());

        assertEquals(bitSet("11110"), vt1.getCliqueBitSit());

    }

    @Test

    public void testCreateClique() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode dX0 = addNode(graph);

        GraphNode dX1 = addNode(graph);

        GraphNode dX2 = addNode(graph);

        GraphNode dX3 = addNode(graph);

        GraphNode dX4 = addNode(graph);

        GraphNode dX5 = addNode(graph);

        connectParentToChildren(dX1, dX2, dX3, dX4);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        // do not moralize, as we want to test just the clique creation through elimination of the provided vertices

        Set<Integer> vertices = new HashSet<Integer>();

        boolean[] adjList = new boolean[] { false, false, true, true, true, false };

        boolean[][] clonedAdjMatrix = JunctionTreeBuilder.cloneAdjacencyMarix(jtBuilder.getAdjacencyMatrix());

        jtBuilder.createClique(dX1.getId(), clonedAdjMatrix, vertices, adjList );

        assertEquals( 3, vertices.size() );

        assertTrue( vertices.containsAll(Arrays.asList(new Integer[]{2, 3, 4})) );

        assertLinkedNode(jtBuilder, 1, 2, 3, 4);

        assertLinkedNode(jtBuilder, 2, 1, 3, 4);

        assertLinkedNode(jtBuilder, 3, 1, 2, 4);

        assertLinkedNode(jtBuilder, 4, 1, 2, 3);

    }

    @Test

    public void testCliqueSuperSet() {

        Graph<BayesVariable> graph = new BayesNetwork();

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        List<OpenBitSet> cliques = new ArrayList<OpenBitSet>();

        OpenBitSet OpenBitSet1 = bitSet("00011110");

        jtBuilder.updateCliques(cliques, OpenBitSet1);

        assertEquals( 1, cliques.size() );

        // ignore subset

        OpenBitSet OpenBitSet2 = bitSet("00000110");

        jtBuilder.updateCliques(cliques, OpenBitSet2);

        assertEquals( 1, cliques.size() );

        assertEquals( OpenBitSet1, cliques.get(0) );

        // add overlapping, as not a pure subset

        OpenBitSet OpenBitSet3 = bitSet("01000110");

        jtBuilder.updateCliques(cliques, OpenBitSet3);

        assertEquals( 2, cliques.size() );

        assertEquals( OpenBitSet1, cliques.get(0) );

        assertEquals( OpenBitSet3, cliques.get(1) );

    }

    @Test

    public void testPriorityQueueWithMinimalNewEdges() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        GraphNode x7 = addNode(graph);

        GraphNode x8 = addNode(graph);

        GraphNode x9 = addNode(graph);

        GraphNode x10 = addNode(graph);

        GraphNode x11 = addNode(graph);

        GraphNode x12 = addNode(graph);

        // 3 new edges

        connectParentToChildren(x2, x1);

        connectParentToChildren(x3, x1);

        connectParentToChildren(x4, x1);

        // 1 new edge

        // we give this a high weight, to show required new edges is compared first

        connectParentToChildren(x6, x5);

        connectParentToChildren(x7, x5);

        x5.setContent(new BayesVariable<String>("x5", x0.getId(), new String[]{"a", "b", "c"}, new double[][]{{0.1, 0.1, 0.1}}));

        x6.setContent(new BayesVariable<String>("x6", x0.getId(), new String[]{"a", "b", "c"}, new double[][]{{0.1, 0.1, 0.1}}));

        x7.setContent(new BayesVariable<String>("x7", x0.getId(), new String[]{"a", "b", "c"}, new double[][]{{0.1, 0.1, 0.1}}));

        // 6 new edges

        connectParentToChildren(x9, x8);

        connectParentToChildren(x10, x8);

        connectParentToChildren(x11, x8);

        connectParentToChildren(x12, x8);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        //jtBuilder.moralize(); // don't moralize, as we want to force a simpler construction for required edges, for the purposes of testing

        PriorityQueue<EliminationCandidate> p = new PriorityQueue<EliminationCandidate>(graph.size());

        EliminationCandidate elmCandVert = new EliminationCandidate(graph, jtBuilder.getAdjacencyMatrix(), x1);

        p.add( elmCandVert );

        elmCandVert = new EliminationCandidate(graph, jtBuilder.getAdjacencyMatrix(), x5);

        p.add( elmCandVert );

        elmCandVert = new EliminationCandidate(graph, jtBuilder.getAdjacencyMatrix(), x8);

        p.add( elmCandVert );

        EliminationCandidate v = p.remove();

        int id = v.getV().getId();

        assertEquals( 5, id );

        assertEquals( 1, v.getNewEdgesRequired() );

        v = p.remove();

        id = v.getV().getId();

        assertEquals( 1, id );

        assertEquals( 3, v.getNewEdgesRequired() );

        v = p.remove();

        id = v.getV().getId();

        assertEquals( 8, id );

        assertEquals( 6, v.getNewEdgesRequired() );

        assertEquals( 0, p.size() );

    }

    @Test

    public void testPriorityQueueWithMaximalCliqueWeight() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        GraphNode x7 = addNode(graph);

        GraphNode x8 = addNode(graph);

        GraphNode x9 = addNode(graph);

        GraphNode x10 = addNode(graph);

        GraphNode x11 = addNode(graph);

        GraphNode x12 = addNode(graph);

        connectParentToChildren(x2, x1);

        connectParentToChildren(x3, x1);

        connectParentToChildren(x4, x1);

        x1.setContent(new BayesVariable<String>("x1", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        x2.setContent(new BayesVariable<String>("x2", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        x3.setContent(new BayesVariable<String>("x3", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        x4.setContent(new BayesVariable<String>("x4", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        connectParentToChildren(x6, x5);

        connectParentToChildren(x7, x5);

        connectParentToChildren(x8, x5);

        x5.setContent(new BayesVariable<String>("x5", x0.getId(), new String[]{"a", "b", "c"}, new double[][]{{0.1, 0.1, 0.1}}));

        x6.setContent(new BayesVariable<String>("x6", x0.getId(), new String[]{"a", "b", "c"}, new double[][]{{0.1, 0.1, 0.1}}));

        x7.setContent(new BayesVariable<String>("x7", x0.getId(), new String[]{"a", "b", "c"}, new double[][]{{0.1, 0.1, 0.1}}));

        x8.setContent(new BayesVariable<String>("x8", x0.getId(), new String[]{"a", "b", "c"}, new double[][]{{0.1, 0.1, 0.1}}));

        connectParentToChildren(x10, x9);

        connectParentToChildren(x11, x9);

        connectParentToChildren(x12, x9);

        x9.setContent(new BayesVariable<String>("x9", x0.getId(), new String[]{"a"}, new double[][]{{0.1}}));

        x10.setContent(new BayesVariable<String>("x10", x0.getId(), new String[]{"a"}, new double[][]{{0.1}}));

        x11.setContent(new BayesVariable<String>("x11", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        x12.setContent(new BayesVariable<String>("x12", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        //jtBuilder.moralize(); // don't moralize, as we want to force a simpler construction for required edges, for the purposes of testing

        PriorityQueue<EliminationCandidate> p = new PriorityQueue<EliminationCandidate>(graph.size());

        EliminationCandidate elmCandVert = new EliminationCandidate(graph, jtBuilder.getAdjacencyMatrix(), x1);

        p.add( elmCandVert );

        elmCandVert = new EliminationCandidate(graph, jtBuilder.getAdjacencyMatrix(), x5);

        p.add( elmCandVert );

        elmCandVert = new EliminationCandidate(graph, jtBuilder.getAdjacencyMatrix(), x9);

        p.add( elmCandVert );

        EliminationCandidate v = p.remove();

        int id = v.getV().getId();

        assertEquals( 9, id );

        assertEquals( 4, v.getWeightRequired() );

        v = p.remove();

        id = v.getV().getId();

        assertEquals( 1, id );

        assertEquals( 16, v.getWeightRequired() );

        v = p.remove();

        id = v.getV().getId();

        assertEquals( 5, id );

        assertEquals( 81, v.getWeightRequired() );

        assertEquals( 0, p.size() );

    }

    @Test

    public void testIterativeEliminationUsingEdgeAndWeight() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        //          *

        //        / | \

        //       *  | *

        //       |  | |

        //       *  | *

        //        \  /

        //         *

        connectParentToChildren(x1, x2);

        connectParentToChildren(x1, x3);

        connectParentToChildren(x1, x6);

        connectParentToChildren(x2, x4);

        connectParentToChildren(x3, x5);

        connectParentToChildren(x4, x6);

        connectParentToChildren(x5, x6);

        // need to ensure x5 followed by x4 are removed first

        x1.setContent(new BayesVariable<String>("x1", x0.getId(), new String[]{"a", "b", "c", "d", "e", "f"}, new double[][]{{0.1, 0.1, 0.1, 0.1, 0.1, 0.1}}));

        x2.setContent(new BayesVariable<String>("x2", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        x3.setContent(new BayesVariable<String>("x3", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        x4.setContent(new BayesVariable<String>("x4", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        x5.setContent(new BayesVariable<String>("x5", x0.getId(), new String[]{"a"}, new double[][]{{0.1 }}));

        x6.setContent(new BayesVariable<String>("x6", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        //jtBuilder.moralize(); // don't moralize, as we want to force a simpler construction for vertex elimination order and updates

        boolean[][] clonedAdjMatrix = jtBuilder.cloneAdjacencyMarix(jtBuilder.getAdjacencyMatrix());

        PriorityQueue<EliminationCandidate> p = new PriorityQueue<EliminationCandidate>(graph.size());

        Map<Integer, EliminationCandidate> elmVertMap = new HashMap<Integer, EliminationCandidate>();

        for ( GraphNode<BayesVariable> v : graph ) {

            if   ( v.getId() == 0 ) {

                continue;

            }

            EliminationCandidate elmCandVert = new EliminationCandidate(graph, clonedAdjMatrix, v);

            p.add( elmCandVert );

            elmVertMap.put( v.getId(), elmCandVert );

        }

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 1, 2, 3, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 2, 1, 4 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 3, 1, 5 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 4, 2, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 5, 3, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 6, 1, 4, 5 });

        assertEquals( 3, elmVertMap.get( 1 ).getNewEdgesRequired() );

        assertEquals( 1, elmVertMap.get( 2 ).getNewEdgesRequired() );

        assertEquals( 1, elmVertMap.get( 3 ).getNewEdgesRequired() );

        assertEquals( 1, elmVertMap.get( 4 ).getNewEdgesRequired() );

        assertEquals( 1, elmVertMap.get( 5 ).getNewEdgesRequired() );

        assertEquals( 3, elmVertMap.get( 6 ).getNewEdgesRequired() );

        // 5 has the lowest new edges and weight

        EliminationCandidate v = p.remove();

        int id = v.getV().getId();

        assertEquals( 5, id );

        Set<Integer> verticesToUpdate = new HashSet<Integer>();

        boolean[] adjList = clonedAdjMatrix[ id  ];

        jtBuilder.createClique(5, clonedAdjMatrix, verticesToUpdate, adjList);

        assertEquals(4, verticesToUpdate.size());

        assertTrue(verticesToUpdate.containsAll(Arrays.asList(new Integer[]{1, 3,  6})));

        jtBuilder.eliminateVertex(p, elmVertMap, clonedAdjMatrix, adjList, verticesToUpdate, v );

        // assert all new edges

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 1, 2, 3, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 2, 1, 4 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 3, 1, 5, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 4, 2, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 5, 3, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 6, 1, 3, 4, 5 });

        // assert new edges were correctly recalculated

        assertEquals( 2, elmVertMap.get( 1 ).getNewEdgesRequired() );

        assertEquals( 1, elmVertMap.get( 2 ).getNewEdgesRequired() );

        assertEquals( 0, elmVertMap.get( 3 ).getNewEdgesRequired() );

        assertEquals( 2, elmVertMap.get( 6 ).getNewEdgesRequired() );

        assertEquals( 1, elmVertMap.get( 4 ).getNewEdgesRequired() );

        // 3 next as it has no new edges now, after recalculation

        v = p.remove();

        id = v.getV().getId();

        assertEquals( 3, id );

        verticesToUpdate = new HashSet<Integer>();

        jtBuilder.createClique(3, clonedAdjMatrix, verticesToUpdate, adjList);

        jtBuilder.eliminateVertex(p, elmVertMap, clonedAdjMatrix, adjList, verticesToUpdate, v );

        // 4 is next

        v = p.remove();

        id = v.getV().getId();

        assertEquals( 4, id );

        verticesToUpdate = new HashSet<Integer>();

        adjList = clonedAdjMatrix[ id  ];

        jtBuilder.createClique(4, clonedAdjMatrix, verticesToUpdate, adjList);

        assertEquals(3, verticesToUpdate.size());

        assertTrue(verticesToUpdate.containsAll(Arrays.asList(new Integer[]{1, 2, 6}))); // don't forget 3 and 5 were already eliminated

        jtBuilder.eliminateVertex(p, elmVertMap, clonedAdjMatrix, adjList, verticesToUpdate, v );

        // assert all new edges

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 1, 2, 3, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 2, 1, 4, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 3, 1, 5, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 4, 2, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 5, 3, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 6, 1, 2, 3, 4, 5 });

        // assert new edges were correctly recalculated

        assertEquals( 0, elmVertMap.get( 1 ).getNewEdgesRequired() );

        assertEquals( 0, elmVertMap.get( 2 ).getNewEdgesRequired() );

        assertEquals( 0, elmVertMap.get( 6 ).getNewEdgesRequired() );

        // 1, 2 and 6 all have no new edges, and same cluster, so it uses id to ensure arbitrary is deterministic

        v = p.remove();

        id = v.getV().getId();

        assertEquals( 1, id );

        verticesToUpdate = new HashSet<Integer>();

        jtBuilder.createClique(1, clonedAdjMatrix, verticesToUpdate, adjList);

        jtBuilder.eliminateVertex(p, elmVertMap, clonedAdjMatrix, adjList, verticesToUpdate, v );

        v = p.remove();

        id = v.getV().getId();

        assertEquals( 2, id );

        verticesToUpdate = new HashSet<Integer>();

        jtBuilder.createClique(2, clonedAdjMatrix, verticesToUpdate, adjList);

        jtBuilder.eliminateVertex(p, elmVertMap, clonedAdjMatrix, adjList, verticesToUpdate, v);

        v = p.remove();

        id = v.getV().getId();

        assertEquals( 6, id );

        verticesToUpdate = new HashSet<Integer>();

        jtBuilder.createClique(6, clonedAdjMatrix, verticesToUpdate, adjList);

        jtBuilder.eliminateVertex(p, elmVertMap, clonedAdjMatrix, adjList, verticesToUpdate, v );

        assertEquals( 0, p.size() );

    }

    @Test

    public void testTriangulate1() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        //          *

        //        / | \

        //       *  | *

        //       |  | |

        //       *  | *

        //        \  /

        //         *

        connectParentToChildren(x1, x2);

        connectParentToChildren(x1, x3);

        connectParentToChildren(x1, x6);

        connectParentToChildren(x2, x4);

        connectParentToChildren(x3, x5);

        connectParentToChildren(x4, x6);

        connectParentToChildren(x5, x6);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        jtBuilder.moralize();

        jtBuilder.triangulate();

        // assert all new edges

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 1, 2, 3, 4, 5, 6 });

        assertLinkedVertex(jtBuilder.getAdjacencyMatrix(), new int[]{2, 1, 4});

        assertLinkedVertex(jtBuilder.getAdjacencyMatrix(), new int[]{3, 1, 5});

        assertLinkedVertex(jtBuilder.getAdjacencyMatrix(), new int[]{4, 1, 2, 5, 6});

        assertLinkedVertex(jtBuilder.getAdjacencyMatrix(), new int[]{5, 1, 3, 4, 6});

        assertLinkedVertex(jtBuilder.getAdjacencyMatrix(), new int[]{6, 1, 4, 5});

    }

    @Test

    public void testTriangulate2() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        //            *

        //           /

        //          *

        //        /  \

        //       *   *

        //       |   |

        //       *   |

        //        \  /

        //         *

        connectParentToChildren(x1, x2);

        connectParentToChildren(x1, x3);

        connectParentToChildren(x2, x4);

        connectParentToChildren(x2, x6);

        connectParentToChildren(x3, x5);

        connectParentToChildren(x5, x6);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        jtBuilder.moralize();

        List<OpenBitSet> cliques =  jtBuilder.triangulate();

        // assert all new edges

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 1, 2, 3 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 2, 1, 3, 4, 5, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 3, 1, 2, 5 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 4, 2 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 5, 2, 3, 6 });

        assertLinkedVertex( jtBuilder.getAdjacencyMatrix(), new int[] { 6, 2, 5 });

        assertEquals( 5, cliques.size() ); // 5th is 0, which is just a dummy V to get numbers aligned

        assertTrue( cliques.contains( bitSet("1110" ) ) ); // x1, x2, x3 //a, b, c

        assertTrue( cliques.contains( bitSet("10100" ) ) ); // x2, x4

        assertTrue( cliques.contains( bitSet("1100100" ) ) ); // x2, x5, x6

        assertTrue( cliques.contains( bitSet("101100" ) ) ); // x2, x3, x5

    }

    @Test

    public void testSepSetCompareWithDifferentMass() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        OpenBitSet OpenBitSet1_1 = bitSet("00001110");

        OpenBitSet OpenBitSet1_2 = bitSet("01101100");

        SeparatorSet s1 = new SeparatorSet( OpenBitSet1_1, 0, OpenBitSet1_2, 0, graph);

        OpenBitSet OpenBitSet2_1 = bitSet("00001110");

        OpenBitSet OpenBitSet2_2 = bitSet("00100100");

        SeparatorSet s2 = new SeparatorSet( OpenBitSet2_1, 0, OpenBitSet2_2, 0, graph);

        List<SeparatorSet> list = new ArrayList<SeparatorSet>();

        list.add( s1 );

        list.add( s2 );

        Collections.sort(list);

        assertEquals(s1, list.get( 0 ) );

    }

    @Test

    public void testSepSetCompareWithDifferentCost() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        x1.setContent(new BayesVariable<String>("x1", x0.getId(), new String[]{"a"}, new double[][]{{0.1 }}));

        x2.setContent(new BayesVariable<String>("x2", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        x3.setContent(new BayesVariable<String>("x3", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        OpenBitSet OpenBitSet1_1 = bitSet("00001110");

        OpenBitSet OpenBitSet1_2 = bitSet("01101100");

        SeparatorSet s1 = new SeparatorSet( OpenBitSet1_1, 0, OpenBitSet1_2, 0, graph);

        OpenBitSet OpenBitSet2_1 = bitSet("00001110");

        OpenBitSet OpenBitSet2_2 = bitSet("00100110");

        SeparatorSet s2 = new SeparatorSet( OpenBitSet2_1, 0, OpenBitSet2_2, 0, graph);

        List<SeparatorSet> list = new ArrayList<SeparatorSet>();

        list.add( s1 );

        list.add( s2 );

        Collections.sort( list );

        assertEquals(s1, list.get( 0 ) );

        // repeat, reversing the costs, to be sure no other factor is in play.

        x1.setContent(new BayesVariable<String>("x3", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        x2.setContent(new BayesVariable<String>("x2", x0.getId(), new String[]{"a", "b"}, new double[][]{{0.1, 0.1}}));

        x3.setContent(new BayesVariable<String>("x1", x0.getId(), new String[]{"a"}, new double[][]{{0.1 }}));

        s1 = new SeparatorSet( OpenBitSet1_1, 0, OpenBitSet1_2, 0, graph);

        s2 = new SeparatorSet( OpenBitSet2_1, 0, OpenBitSet2_2, 0, graph);

        list = new ArrayList<SeparatorSet>();

        list.add( s1 );

        list.add( s2 );

        Collections.sort( list );

        assertEquals(s2, list.get( 0 ) ); // was s1 before

    }

    @Test

    public void testSepSetCompareWithSameIntersect() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        OpenBitSet OpenBitSet1_1 = bitSet("00001110");

        OpenBitSet OpenBitSet1_2 = bitSet("01000010");

        SeparatorSet s1 = new SeparatorSet( OpenBitSet1_1, 0, OpenBitSet1_2, 0, graph);

        OpenBitSet OpenBitSet2_1 = bitSet("00001110");

        OpenBitSet OpenBitSet2_2 = bitSet("01000100");

        SeparatorSet s2 = new SeparatorSet( OpenBitSet2_1, 0, OpenBitSet2_2, 0, graph);

        List<SeparatorSet> list = new ArrayList<SeparatorSet>();

        list.add( s1 );

        list.add( s2 );

        Collections.sort( list );

        assertEquals(s1, list.get( 0 ) );

        // reverse the bits, to show the arbitrary is deterministic

        OpenBitSet1_2 = bitSet("01000100");

        s1 = new SeparatorSet( OpenBitSet1_1, 0, OpenBitSet1_2, 0, graph);

        OpenBitSet2_2 = bitSet("01000010");

        s2 = new SeparatorSet( OpenBitSet2_1, 0, OpenBitSet2_2, 0, graph);

        list = new ArrayList<SeparatorSet>();

        list.add( s1 );

        list.add( s2 );

        Collections.sort( list );

        assertEquals(s2, list.get( 0 ) ); // was s1 before

    }

    @Test

    public void testJunctionTree() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        OpenBitSet OpenBitSet1 = bitSet("00001110");

        OpenBitSet OpenBitSet2 = bitSet("00011100");

        OpenBitSet OpenBitSet3 = bitSet("00110000");

        OpenBitSet OpenBitSet4 = bitSet("01110000");

        List<OpenBitSet> cliques = new ArrayList<OpenBitSet>();

        cliques.add ( OpenBitSet1 );

        cliques.add ( OpenBitSet2 );

        cliques.add ( OpenBitSet3 );

        cliques.add ( OpenBitSet4 );

        List<SeparatorSet> separatorSets = new ArrayList<SeparatorSet>();

        for ( int i = 0; i < cliques.size(); i++ ) {

            OpenBitSet ci = cliques.get(i);

            for ( int j = i+1; j < cliques.size(); j++ ) {

                OpenBitSet cj = cliques.get(j);

                if ( ci.intersects( cj ) ) {

                    SeparatorSet separatorSet = new SeparatorSet( ci, 0, cj, 0, graph );

                }

            }

        }

        Collections.sort(separatorSets);

    }

    @Test

    public void testJunctionTreeNoPruning() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        GraphNode x7 = addNode(graph);

        List<OpenBitSet> list = new ArrayList<OpenBitSet>();

        OpenBitSet OpenBitSet1 = bitSet("00001111");

        OpenBitSet OpenBitSet2 = bitSet("00111100");

        OpenBitSet OpenBitSet3 = bitSet("11100000"); // linear

        OpenBitSet intersect1And2 = ((OpenBitSet)OpenBitSet2.clone());

        intersect1And2.and(OpenBitSet1);

        OpenBitSet intersect2And3 = ((OpenBitSet)OpenBitSet2.clone());

        intersect2And3.and(OpenBitSet3);

        list.add(OpenBitSet1);

        list.add(OpenBitSet2);

        list.add(OpenBitSet3);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        JunctionTreeClique jtNode = jtBuilder.junctionTree(list, false).getRoot();

        assertEquals( OpenBitSet1, jtNode.getBitSet() );

        assertEquals( 1,  jtNode.getChildren().size() );

        JunctionTreeSeparator sep =  jtNode.getChildren().get(0);

        assertEquals( OpenBitSet1, sep.getParent().getBitSet() );

        assertEquals( OpenBitSet2, sep.getChild().getBitSet() );

        assertEquals( intersect1And2, sep.getBitSet() );

        jtNode = sep.getChild();

        assertEquals( OpenBitSet2, jtNode.getBitSet() );

        assertEquals( 1,  jtNode.getChildren().size() );

        sep =   jtNode.getChildren().get(0);

        assertEquals( OpenBitSet2, sep.getParent().getBitSet() );

        assertEquals( OpenBitSet3, sep.getChild().getBitSet() );

        assertEquals( intersect2And3, sep.getBitSet() );

    }

    @Test

    public void testJunctionWithPruning1() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        GraphNode x7 = addNode(graph);

        List<OpenBitSet> list = new ArrayList<OpenBitSet>();

        OpenBitSet OpenBitSet1 = bitSet("00001111");

        OpenBitSet OpenBitSet2 = bitSet("00111100");

        OpenBitSet OpenBitSet3 = bitSet("11100001"); // links to 2 and 1, but should still result in a single path. As the 3 -> 1 link, gets pruned

        OpenBitSet intersect1And2 = ((OpenBitSet)OpenBitSet2.clone());

        intersect1And2.and(OpenBitSet1);

        OpenBitSet intersect2And3 = ((OpenBitSet)OpenBitSet2.clone());

        intersect2And3.and(OpenBitSet3);

        list.add(OpenBitSet1);

        list.add(OpenBitSet2);

        list.add(OpenBitSet3);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        JunctionTreeClique jtNode = jtBuilder.junctionTree(list, false).getRoot();

        assertEquals( OpenBitSet1, jtNode.getBitSet() );

        assertEquals( 2,  jtNode.getChildren().size() );

        JunctionTreeSeparator sep =  jtNode.getChildren().get(0);

        assertEquals( OpenBitSet1, sep.getParent().getBitSet() );

        assertEquals( OpenBitSet2, sep.getChild().getBitSet() );

        assertEquals(0, sep.getChild().getChildren().size());

        sep =  jtNode.getChildren().get(1);

        assertEquals( OpenBitSet1, sep.getParent().getBitSet() );

        assertEquals( OpenBitSet3, sep.getChild().getBitSet() );

        assertEquals( 0, sep.getChild().getChildren().size() );

    }

    @Test

    public void testJunctionWithPruning2() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        GraphNode x7 = addNode(graph);

        List<OpenBitSet> list = new ArrayList<OpenBitSet>();

        OpenBitSet OpenBitSet1 = bitSet("00001111");

        OpenBitSet OpenBitSet2 = bitSet("00111100");

        OpenBitSet OpenBitSet3 = bitSet("11100000");

        OpenBitSet OpenBitSet4 = bitSet("00100001");

        OpenBitSet intersect1And2 = ((OpenBitSet)OpenBitSet2.clone());

        intersect1And2.and(OpenBitSet1);

        OpenBitSet intersect2And3 = ((OpenBitSet)OpenBitSet2.clone());

        intersect2And3.and(OpenBitSet3);

        OpenBitSet intersect1And4 = ((OpenBitSet)OpenBitSet1.clone());

        intersect1And4.and(OpenBitSet4);

        list.add(OpenBitSet1);

        list.add(OpenBitSet2);

        list.add(OpenBitSet3);

        list.add(OpenBitSet4);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        JunctionTreeClique jtNode = jtBuilder.junctionTree(list, false).getRoot();

        JunctionTreeClique root = jtNode;

        assertEquals( OpenBitSet1, root.getBitSet() );

        assertEquals( 2,  root.getChildren().size() );

        JunctionTreeSeparator sep =  root.getChildren().get(0);

        assertEquals( OpenBitSet1, sep.getParent().getBitSet() );

        assertEquals( OpenBitSet2, sep.getChild().getBitSet() );

        assertEquals(1, sep.getChild().getChildren().size());

        jtNode = sep.getChild();

        assertEquals( OpenBitSet2, jtNode.getBitSet() );

        assertEquals( 1,  jtNode.getChildren().size() );

        sep =   jtNode.getChildren().get(0);

        assertEquals( OpenBitSet2, sep.getParent().getBitSet() );

        assertEquals( OpenBitSet3, sep.getChild().getBitSet() );

        assertEquals( intersect2And3, sep.getBitSet() );

        assertEquals( 0, sep.getChild().getChildren().size());

        sep =  root.getChildren().get(1);

        assertEquals( OpenBitSet1, sep.getParent().getBitSet() );

        assertEquals( OpenBitSet4, sep.getChild().getBitSet() );

        assertEquals( intersect1And4, sep.getBitSet() );

        assertEquals( 0, sep.getChild().getChildren().size() );

    }

    @Test

    public void testJunctionWithPruning3() {

        Graph<BayesVariable> graph = new BayesNetwork();

        GraphNode x0 = addNode(graph);

        GraphNode x1 = addNode(graph);

        GraphNode x2 = addNode(graph);

        GraphNode x3 = addNode(graph);

        GraphNode x4 = addNode(graph);

        GraphNode x5 = addNode(graph);

        GraphNode x6 = addNode(graph);

        GraphNode x7 = addNode(graph);

        List<OpenBitSet> list = new ArrayList<OpenBitSet>();

        OpenBitSet OpenBitSet1 = bitSet("00001111");

        OpenBitSet OpenBitSet2 = bitSet("00011110");

        OpenBitSet OpenBitSet3 = bitSet("11100000");

        OpenBitSet OpenBitSet4 = bitSet("01100001");

        OpenBitSet intersect1And2 = ((OpenBitSet)OpenBitSet2.clone());

        intersect1And2.and(OpenBitSet1);

        OpenBitSet intersect2And3 = ((OpenBitSet)OpenBitSet2.clone());

        intersect2And3.and(OpenBitSet3);

        OpenBitSet intersect1And4 = ((OpenBitSet)OpenBitSet1.clone());

        intersect1And4.and(OpenBitSet4);

        OpenBitSet intersect3And4 = ((OpenBitSet)OpenBitSet3.clone());

        intersect3And4.and(OpenBitSet4);

        list.add(OpenBitSet1);

        list.add(OpenBitSet2);

        list.add(OpenBitSet3);

        list.add(OpenBitSet4);

        JunctionTreeBuilder jtBuilder = new JunctionTreeBuilder( graph );

        JunctionTreeClique jtNode = jtBuilder.junctionTree(list, false).getRoot();;

        JunctionTreeClique root = jtNode;

        assertEquals( OpenBitSet1, root.getBitSet() );

        assertEquals( 2,  root.getChildren().size() );

        JunctionTreeSeparator sep =  root.getChildren().get(0);

        assertEquals( OpenBitSet1, sep.getParent().getBitSet() );

        assertEquals( OpenBitSet2, sep.getChild().getBitSet() );

        assertEquals(0, sep.getChild().getChildren().size());

        sep =  root.getChildren().get(1);

        assertEquals( OpenBitSet1, sep.getParent().getBitSet() );

        assertEquals( OpenBitSet4, sep.getChild().getBitSet() );

        assertEquals( intersect1And4, sep.getBitSet() );

        assertEquals( 1, sep.getChild().getChildren().size() );

        jtNode = sep.getChild();

        assertEquals( OpenBitSet4, jtNode.getBitSet() );

        assertEquals( 1,  jtNode.getChildren().size() );

        sep =   jtNode.getChildren().get(0);

        assertEquals( OpenBitSet4, sep.getParent().getBitSet() );

        assertEquals( OpenBitSet3, sep.getChild().getBitSet() );