.

wcfs/internal/xbtree_test.py

@@ -114,6 +114,91 @@ def test_iterAllStructs():
                                  T([], B(1,3)))
                              ]
 
+    assert X([1,3], 1, 1) == [ T([], B(1,3)),
+                               # nsplit=0,0, depth=1
+                               T([],
+                                 T([], B(1,3))),
+                               # nsplit=0,1, depth=1
+                               T([],
+                                 T([0], B(), B(1,3))),
+                               T([],
+                                 T([1], B(), B(1,3))),
+                               T([],
+                                 T([2], B(1), B(3))),
+                               T([],
+                                 T([3], B(1), B(3))),
+                               T([],
+                                 T([4], B(1,3), B())),
+                               # nsplit=1, depth=0
+                               T([0], B(), B(1,3)),
+                               T([1], B(), B(1,3)),
+                               T([2], B(1), B(3)),
+                               T([3], B(1), B(3)),
+                               T([4], B(1,3), B()),
+                               # nsplit=1,0 depth=1
+                               T([0],
+                                 T([], B()),
+                                 T([], B(1,3))),
+                               T([1],
+                                 T([], B()),
+                                 T([], B(1,3))),
+                               T([2],
+                                 T([], B(1)),
+                                 T([], B(3))),
+                               T([3],
+                                 T([], B(1)),
+                                 T([], B(3))),
+                               T([4],
+                                 T([], B(1,3)),
+                                 T([], B())),
+                               # nsplit=1,1 depth=1
+                               T([0],                   # /0
+                                 T([], B()),
+                                 T([1], B(), B(1,3))),
+                               T([0],
+                                 T([], B()),
+                                 T([2], B(1), B(3))),
+                               T([0],
+                                 T([], B()),
+                                 T([3], B(1), B(3))),
+                               T([0],
+                                 T([], B()),
+                                 T([4], B(1,3), B())),
+                               T([1],                   # /1
+                                 T([0], B(), B()),
+                                 T([2], B(1), B(3))),
+                               T([1],
+                                 T([0], B(), B()),
+                                 T([3], B(1), B(3))),
+                               T([1],
+                                 T([0], B(), B()),
+                                 T([4], B(1,3), B())),
+                               T([2],                   # /2
+                                 T([0], B(), B(1)),
+                                 T([3], B(), B(3))),
+                               T([2],
+                                 T([0], B(), B(1)),
+                                 T([4], B(3), B())),
+                               T([2],
+                                 T([1], B(), B(1)),
+                                 T([3], B(), B(3))),
+                               T([2],
+                                 T([1], B(), B(1)),
+                                 T([4], B(3), B())),
+                               T([3],                   # /3
+                                 T([0], B(), B(1)),
+                                 T([4], B(3), B())),
+                               T([3],
+                                 T([1], B(), B(1)),
+                                 T([4], B(3), B())),
+                               T([3],
+                                 T([2], B(1), B()),
+                                 T([4], B(3), B())),
+
+                               # ... XXX continue
+                              ]
+
+
 
     assert X([1,3], 0, 2) == [ T([], B(1,3)),
                                # nsplit=1