@Override public MutableCTree<Integer> createTree() { return TreeBuilder.builder().build(); }
MutableCTree<Integer> tree = treeBuilder.build();
@Test public void equivalent_edgeAddOrdersDiffer() { TreeBuilder<Object> builder = TreeBuilder.builder(); MutableGraph<Integer> t1 = builder.build(); MutableGraph<Integer> t2 = builder.build(); // for t1, add 1->2 first, then 1->3 t1.putEdge(N1, N2); t1.putEdge(N1, N3); // for t2, add 1->3 first, then 1->2 t2.putEdge(N1, N3); t2.putEdge(N1, N2); assertThat(t1).isEqualTo(t2); } }
private static <N> CTree<N> subTree(CTree<N> tree, N subTreeRoot) { MutableCTree<N> result = TreeBuilder.builder().build(); for (N node : Iterables.skip( Traverser.forTree(tree).breadthFirst(subTreeRoot), 1)) { // skip the subtree's root node, for it has no predecessor // connect every non-root node to its predecessor result.putEdge(tree.predecessor(node).get(), node); } return result; } }
@Test public void nodeOrder_none() { MutableCTree<Integer> tree = TreeBuilder.builder().nodeOrder(unordered()).build(); assertThat(tree.nodeOrder()).isEqualTo(unordered()); }
@Test public void equivalent_propertiesDiffer() { MutableCTree<Integer> t1 = TreeBuilder.builder().nodeOrder(ElementOrder.insertion()).build(); t1.putEdge(N1, N2); MutableCTree<Integer> t2 = TreeBuilder.from(t1).nodeOrder(ElementOrder.unordered()).build(); t2.putEdge(N1, N2); assertThat(t1).isEqualTo(t2); }
@Test public void nodeOrder_default() { MutableCTree<Integer> tree = TreeBuilder.builder().build(); addNodes(tree); assertThat(tree.nodeOrder()).isEqualTo(insertion()); assertThat(tree.nodes()).containsExactly(3, 1, 4).inOrder(); }
@Test public void nodeOrder_natural() { MutableCTree<Integer> tree = TreeBuilder.builder().nodeOrder(ElementOrder.<Integer>natural()).build(); addNodes(tree); assertThat(tree.nodeOrder()).isEqualTo(ElementOrder.sorted(Ordering.<Integer>natural())); assertThat(tree.nodes()).containsExactly(1, 3, 4).inOrder(); }
@Test public void nodeOrder_insertion() { MutableCTree<Integer> tree = TreeBuilder.builder().nodeOrder(insertion()).build(); addNodes(tree); assertThat(tree.nodeOrder()).isEqualTo(insertion()); assertThat(tree.nodes()).containsExactly(3, 1, 4).inOrder(); }
@Test public void nodeOrder_sorted() { MutableCTree<Integer> tree = TreeBuilder.builder() .nodeOrder(ElementOrder.sorted(Ordering.<Integer>natural().reverse())) .build(); addNodes(tree); assertThat(tree.nodeOrder()) .isEqualTo(ElementOrder.sorted(Ordering.<Integer>natural().reverse())); assertThat(tree.nodes()).containsExactly(4, 3, 1).inOrder(); }
@Test public void customComparator() { Comparator<NonComparableSuperClass> comparator = comparing(left -> left.value); MutableCTree<NonComparableSuperClass> tree = TreeBuilder.builder().nodeOrder(ElementOrder.sorted(comparator)).build(); NonComparableSuperClass node1 = new NonComparableSuperClass(1); NonComparableSuperClass node3 = new NonComparableSuperClass(3); NonComparableSuperClass node5 = new NonComparableSuperClass(5); NonComparableSuperClass node7 = new NonComparableSuperClass(7); tree.putEdge(node1, node7); tree.putEdge(node1, node5); tree.putEdge(node5, node3); assertThat(tree.nodeOrder().comparator()).isEqualTo(comparator); assertThat(tree.nodes()).containsExactly(node1, node3, node5, node7).inOrder(); }
@Test public void customComparable() { MutableCTree<ComparableSubClass> tree = TreeBuilder.builder().nodeOrder(ElementOrder.<ComparableSubClass>natural()).build(); ComparableSubClass node2 = new ComparableSubClass(2); ComparableSubClass node4 = new ComparableSubClass(4); ComparableSubClass node6 = new ComparableSubClass(6); ComparableSubClass node8 = new ComparableSubClass(8); tree.putEdge(node2, node8); tree.putEdge(node2, node6); tree.putEdge(node6, node4); assertThat(tree.nodeOrder().comparator()).isEqualTo(Ordering.natural()); assertThat(tree.nodes()).containsExactly(node2, node4, node6, node8).inOrder(); }