.

wcfs/wcfs_test.py

@@ -1538,17 +1538,17 @@ def test_wcfs_watch_setup():
     defer(t.close)
 
     f = t.open(zf)
-    at1 = t.commit(zf, {2:'c1'})                # XXX + hole -> zblk
+    at1 = t.commit(zf, {2:'c1'})
     at2 = t.commit(zf, {2:'c2', 3:'d2', 4:'e2', 5:'f2'})
-    at3 = t.commit(zf, {2:'c3', 5:'f3'})
+    at3 = t.commit(zf, {0:'a3', 2:'c3', 5:'f3'})
 
-    f.assertData(['','','c3','d2','x','f3'])     # access everything except e as of @at3
+    f.assertData(['a3','','c3','d2','x','f3'])  # access everything except e as of @at3
     f.assertCache([1,1,1,1,0,1])
 
     # change again, but don't access e and f
     at4 = t.commit(zf, {2:'c4', 4:'e4', 5:'f4'})
     at5 = t.commit(zf, {3:'d5', 5:'f5'})
-    f.assertData(['','','c4','d5','x','x'])
+    f.assertData(['a3','','c4','d5','x','x'])
     f.assertCache([1,1,1,1,0,0])
 
     # some watch setup/update requests with explicit pinok (also partly
@@ -1559,27 +1559,27 @@ def test_wcfs_watch_setup():
         wl = t.openwatch()
         wl.watch(zf, at, pinok)
         wl.close()
-    assertNewWatch(at1, {2:at1,  3:at0,  5:at0})
-    assertNewWatch(at2, {2:at2,  3:at2,  5:at2})
-    assertNewWatch(at3, {2:at3,  3:at2,  5:at3})    # f(5) is pinned, even though it was not
-    assertNewWatch(at4, {        3:at2,  5:at4})    # accessed after at3
-    assertNewWatch(at5, {                     })
+    assertNewWatch(at1, {0:at0,  2:at1,  3:at0,  5:at0})
+    assertNewWatch(at2, {0:at0,  2:at2,  3:at2,  5:at2})
+    assertNewWatch(at3, {        2:at3,  3:at2,  5:at3})    # f(5) is pinned, even though it was not
+    assertNewWatch(at4, {                3:at2,  5:at4})    # accessed after at3
+    assertNewWatch(at5, {                             })
 
     # new watch + update at_i -> at_j
     wl = t.openwatch()
     # XXX check @at0 ?
-    wl.watch(zf, at1, {2:at1,  3:at0,  5:at0})  #     -> at1 (new watch)    XXX at0 -> ø?
-    wl.watch(zf, at2, {2:at2,  3:at2,  5:at2})  # at1 -> at2
-    wl.watch(zf, at3, {2:at3,          5:at3})  # at2 -> at3
-    wl.watch(zf, at4, {2:None,         5:at4})  # at3 -> at4 f(5) pinned even it was not accessed >=4
-    wl.watch(zf, at5, {        3:None, 5:None}) # at4 -> at5 (current head)
+    wl.watch(zf, at1, {0:at0,  2:at1,  3:at0,  5:at0})  #     -> at1 (new watch)    XXX at0 -> ø?
+    wl.watch(zf, at2, {        2:at2,  3:at2,  5:at2})  # at1 -> at2
+    wl.watch(zf, at3, {0:None, 2:at3,          5:at3})  # at2 -> at3
+    wl.watch(zf, at4, {        2:None,         5:at4})  # at3 -> at4 f(5) pinned even it was not accessed >=4
+    wl.watch(zf, at5, {                3:None, 5:None}) # at4 -> at5 (current head)
     wl.close()
 
     # all valid watch setup/update requests going at_i -> at_j -> ... with automatic pinok
     for zf in t.zfiles():
         for revv in t.iter_revv():
             print('\n--------')
-            print(' -> '.join(['%s' % _ for _ in revv]))    # XXX join joins bytes as raw
+            print(' -> '.join(['%s' % _ for _ in revv]))
             wl = t.openwatch()
             wl.watch(zf, revv[0])
             wl.watch(zf, revv[0])    # verify at_i -> at_i
@@ -1595,11 +1595,11 @@ def test_wcfs_watch_vs_access():
     defer(t.close)
 
     f = t.open(zf)
-    at1 = t.commit(zf, {2:'c1'})                # XXX + hole -> zblk
+    at1 = t.commit(zf, {2:'c1'})
     at2 = t.commit(zf, {2:'c2', 3:'d2', 5:'f2'})
-    at3 = t.commit(zf, {2:'c3', 5:'f3'})
+    at3 = t.commit(zf, {0:'a3', 2:'c3', 5:'f3'})
 
-    f.assertData(['','','c3','d2','x','x'])
+    f.assertData(['a3','','c3','d2','x','x'])
     f.assertCache([1,1,1,1,0,0])
 
     # watched + commit -> read -> receive pin messages.
@@ -1617,7 +1617,7 @@ def test_wcfs_watch_vs_access():
 
     wl2  = t.openwatch();  w2 = wl2.watch(zf, at2)
     assert w2.at     == at2
-    assert w2.pinned == {2: at2}
+    assert w2.pinned == {0:at0, 2:at2}
 
     # w_assertPin asserts on state of .pinned for {w3,w3_,w2}
     def w_assertPin(pinw3, pinw3_, pinw2):
@@ -1629,27 +1629,27 @@ def test_wcfs_watch_vs_access():
     at4 = t.commit(zf, {         2:'c4', 5:'f4', 6:'g4'})  # FIXME + b4 after δbtree works + update vvv
     f.assertCache([1,1,0,1,0,0,0])
 
-    f.assertBlk(0, '',   {wl3: {},              wl3_: {},              wl2: {}})
-    w_assertPin(               {},                    {},                   {2:at2})
+    f.assertBlk(0, 'a3', {wl3: {},              wl3_: {},              wl2: {}})
+    w_assertPin(               {},                    {},                   {0:at0, 2:at2})
 
     f.assertBlk(1, '',   {wl3: {},              wl3_: {},              wl2: {}})
-    w_assertPin(               {},                    {},                   {2:at2})
+    w_assertPin(               {},                    {},                   {0:at0, 2:at2})
 
     f.assertBlk(2, 'c4', {wl3: {2:at3},         wl3_: {2:at3},         wl2: {}})
-    w_assertPin(               {2:at3},               {2:at3},              {2:at2})
+    w_assertPin(               {2:at3},               {2:at3},              {0:at0, 2:at2})
 
     f.assertBlk(3, 'd2', {wl3: {},              wl3_: {},              wl2: {}})
-    w_assertPin(               {2:at3},               {2:at3},              {2:at2})
+    w_assertPin(               {2:at3},               {2:at3},              {0:at0, 2:at2})
 
     # blk4 is hole @head - the same as at earlier db view - not pinned
     f.assertBlk(4, '',   {wl3: {},              wl3_: {},              wl2: {}})
-    w_assertPin(               {2:at3},               {2:at3},              {2:at2})
+    w_assertPin(               {2:at3},               {2:at3},              {0:at0, 2:at2})
 
     # f(5) is kept unaccessed (see ^^^)
     assert f.cached()[5] == 0
 
     f.assertBlk(6, 'g4', {wl3: {6:at0},         wl3_: {6:at0},         wl2: {6:at0}}) # XXX at0->ø?
-    w_assertPin(               {2:at3, 6:at0},        {2:at3, 6:at0},       {2:at2, 6:at0})
+    w_assertPin(               {2:at3, 6:at0},        {2:at3, 6:at0},       {0:at0, 2:at2, 6:at0})
 
     # commit again:
     # - c(2) is already pinned  -> wl3 not notified
@@ -1667,7 +1667,7 @@ def test_wcfs_watch_vs_access():
         assert w3_.pinned  == {}; assert w3_.at == z64  # wl3_ unsubscribed from zf
         assert w2.pinned   == {}; assert w2.at  == z64  # wl2 closed
 
-    f.assertBlk(0, '',   {wl3: {},                      wl3_: {}})  # no change
+    f.assertBlk(0, 'a3', {wl3: {},                      wl3_: {}})  # no change
     w_assertPin(               {2:at3, 6:at0})
 
     f.assertBlk(1, '',   {wl3: {},                      wl3_: {}})
@@ -1812,8 +1812,8 @@ def test_wcfs_watch_2files():
 
 
 
-# XXX new watch request while previous watch request is in progress (over the same /head/watch handle)
-# XXX @revX/ is automatically removed after some time
+# TODO new watch request while previous watch request is in progress (over the same /head/watch handle)
+# TODO @revX/ is automatically removed after some time
 
 
 # ---- misc ---