recursive builder and filter iterator tests

tests/mptree.phpt

@@ -150,8 +150,6 @@ class Item
     );
 
 
-//new Filter($it, Seed::omitNull());
-//new Filter($it, Seed::omitRoot());
 
     Assert::same([
         '>' => '[0]',

tests/recursive.phpt

@@ -2,9 +2,12 @@
 
 declare(strict_types=1);
 
+use Dakujem\Oliva\Iterator\Filter;
+use Dakujem\Oliva\Iterator\PreOrderTraversal;
 use Dakujem\Oliva\Node;
 use Dakujem\Oliva\Recursive\TreeBuilder;
 use Dakujem\Oliva\Seed;
+use Dakujem\Oliva\TreeNodeContract;
 use Tester\Assert;
 use Tester\Environment;
 
@@ -21,15 +24,21 @@ class Item
 }
 
 (function () {
+    $toArray = function (TreeNodeContract $root, callable $mod = null) {
+        $it = new PreOrderTraversal($root, fn(
+            TreeNodeContract $node,
+            array $vector,
+            int $seq,
+            int $counter,
+        ): string => '>' . implode('.', $vector));
+        return array_map(function (Node $item): string {
+            $data = $item->data();
+            return null !== $data ? "[$data->id]" : 'root';
+        }, iterator_to_array($mod ? $mod($it) : $it));
+    };
+
     $data = [
-        new Item(1, 2),
-        new Item(2, 4),
-        new Item(3, 4),
-        new Item(4, null),
-        new Item(5, 4),
-        new Item(77, 42),
-        new Item(8, 7),
-        new Item(6, 5),
+        new Item(id: 0, parent: null),
     ];
 
     $builder = new TreeBuilder(
@@ -39,9 +48,77 @@ class Item
     );
 
     $tree = $builder->build(
-        input: Seed::nullFirst($data),
+        input: $data,
     );
 
+    Assert::same([
+        '>' => '[0]',
+    ], $toArray($tree));
+
+
+    $data = [
+        new Item(id: 1, parent: 2),
+        new Item(id: 2, parent: 4),
+        new Item(id: 4, parent: null),
+        new Item(id: 8, parent: 7),
+        new Item(id: 77, parent: 42),
+        new Item(id: 5, parent: 4),
+        new Item(id: 6, parent: 5),
+        new Item(id: 3, parent: 4),
+    ];
+
+    $builder = new TreeBuilder(
+        node: fn(?Item $item) => new Node($item),
+        self: fn(?Item $item) => $item?->id,
+        parent: fn(?Item $item) => $item?->parent,
+    );
+
+    $tree = $builder->build(
+        input: $data,
+    );
 
     Assert::type(Node::class, $tree);
+
+    Assert::same([
+        '>' => '[4]',
+        '>0' => '[2]',
+        '>0.0' => '[1]',
+        '>1' => '[5]',
+        '>1.0' => '[6]',
+        '>2' => '[3]',
+    ], $toArray($tree));
+
+
+    //new Filter($it, Seed::omitNull());
+    $withoutRoot = fn(iterable $iterator) => new Filter($iterator, Seed::omitRoot());
+
+    Assert::same([
+//        '>' => '[4]', is omitted by the Seed::omitRoot() call
+        '>0' => '[2]',
+        '>0.0' => '[1]',
+        '>1' => '[5]',
+        '>1.0' => '[6]',
+        '>2' => '[3]',
+    ], $toArray($tree, $withoutRoot));
+
+    $filter = new Filter($collection = [
+        new Node(null),
+        new Node('ok'),
+    ], Seed::omitNull());
+    $shouldContainOneElement = iterator_to_array($filter);
+    Assert::count(1, $shouldContainOneElement);
+    Assert::same(null, Seed::firstOf($collection)?->data());
+    Assert::same('ok', Seed::firstOf($filter)?->data());
+
+
+    Assert::throws(
+        fn() => $builder->build([]),
+        LogicException::class,
+        'No root node found.',
+    );
+    Assert::throws(
+        fn() => $builder->build([new Item(id: 7, parent: 42)]),
+        LogicException::class,
+        'No root node found.',
+    );
 })();