.

wcfs/internal/xbtree/xbtreetest/rtree.go

@@ -70,7 +70,7 @@ func (rbs RBucketSet) Get(k Key) *RBucket {
 	}
 
 	rb := rbs[i]
-	if !(rb.Keycov.Lo <= k && k <= rb.Keycov.Hi_) {
+	if !rb.Keycov.Has(k) {
 		panicf("BUG: get(%v) -> %s;  coverage: %s", k, rb.Keycov, rbs.coverage())
 	}
 

wcfs/internal/xbtree/xbtreetest/treeenv.go

@@ -42,7 +42,7 @@ type T struct {
 	work    string   // working directory
 	treeSrv *TreeSrv
 	zstor   zodb.IStorage
-	db      *zodb.DB
+	DB      *zodb.DB
 
 	// all committed trees
 	commitv []*Commit
@@ -50,13 +50,13 @@ type T struct {
 
 // Commit represent test commit changing a tree.
 type Commit struct {
-	tree       string              // the tree in topology-encoding
-	prev       *Commit             // previous commit
-	at         zodb.Tid            // commit revision
-	δZ         *zodb.EventCommit   // raw ZODB changes; δZ.tid == at
-	xkv        RBucketSet          // full tree state as of @at
-	δxkv       map[Key]Δstring     // full tree-diff against parent
-	blkDataTab map[zodb.Oid]string // full snapshot of all ZBlk data @at  XXX -> zblkDataTab
+	Tree        string              // the tree in topology-encoding
+	Prev        *Commit             // previous commit
+	At          zodb.Tid            // commit revision
+	ΔZ          *zodb.EventCommit   // raw ZODB changes; δZ.tid == at
+	Xkv         RBucketSet          // full tree state as of @at
+	Δxkv        map[Key]Δstring     // full tree-diff against parent
+	zblkDataTab map[zodb.Oid]string // full snapshot of all ZBlk data @at
 //	δzblkData  map[zodb.Oid]Δstring // full diff for zblkData against parent XXX ?
 }
 
@@ -81,25 +81,25 @@ func NewT(t *testing.T) *T {
 		err := tt.zstor.Close(); X(err)
 	})
 
-	tt.db = zodb.NewDB(tt.zstor, &zodb.DBOptions{
+	tt.DB = zodb.NewDB(tt.zstor, &zodb.DBOptions{
 		// We need objects to be cached, because otherwise it is too
 		// slow to run the test for many testcases, especially
 		// xverifyΔBTail_rebuild.
 		CacheControl: &tZODBCacheEverything{},
 	})
 	t.Cleanup(func() {
-		err := tt.db.Close(); X(err)
+		err := tt.DB.Close(); X(err)
 	})
 
 	head := tt.treeSrv.head
 	t1 := &Commit{
-		tree:       "T/B:",	// treegen.py creates the tree as initially empty
-		prev:       nil,
-		at:         head,
-		xkv:        xGetTree(tt.db, head, tt.Root()),
-		blkDataTab: xGetBlkDataTab(tt.db, head),
-		δZ:         nil,
-		δxkv:       nil,
+		Tree:        "T/B:",	// treegen.py creates the tree as initially empty
+		Prev:        nil,
+		At:          head,
+		Xkv:         xGetTree(tt.DB, head, tt.Root()),
+		zblkDataTab: xGetBlkDataTab(tt.DB, head),
+		ΔZ:          nil,
+		Δxkv:        nil,
 	}
 	tt.commitv = []*Commit{t1}
 
@@ -152,7 +152,7 @@ func (t *T) CommitTree(tree string) *Commit {
 	// if the tree does not exist yet - report its structure as empty
 	var xkv RBucketSet
 	if tree != DEL {
-		xkv = xGetTree(t.db, δZ.Tid, t.Root())
+		xkv = xGetTree(t.DB, δZ.Tid, t.Root())
 	} else {
 		// empty tree with real treeRoot as oid even though the tree is
 		// deleted.  Having real oid in the root tests that after deletion,
@@ -178,16 +178,16 @@ func (t *T) CommitTree(tree string) *Commit {
 	}
 
 	ttree := &Commit{
-		tree:       tree,
-		at:         δZ.Tid,
-		δZ:         δZ,
-		xkv:        xkv,
-		blkDataTab: xGetBlkDataTab(t.db, δZ.Tid),
+		Tree:        tree,
+		At:          δZ.Tid,
+		ΔZ:          δZ,
+		Xkv:         xkv,
+		zblkDataTab: xGetBlkDataTab(t.DB, δZ.Tid),
 	}
 
 	tprev := t.Head()
-	ttree.prev = tprev
-	ttree.δxkv = kvdiff(tprev.xkv.Flatten(), ttree.xkv.Flatten())
+	ttree.Prev = tprev
+	ttree.Δxkv = kvdiff(tprev.Xkv.Flatten(), ttree.Xkv.Flatten())
 
 	t.commitv = append(t.commitv, ttree)
 
@@ -242,16 +242,16 @@ func xGetBlkDataTab(db *zodb.DB, at zodb.Tid) map[zodb.Oid]string {
 	return blkDataTab
 }
 
-// xgetBlkData loads blk data for ZBlk<oid> @t.at
+// XGetBlkData loads blk data for ZBlk<oid> @t.at
 //
 // For speed the load is done via preloaded t.blkDataTab instead of access to the DB.
-func (t *Commit) xgetBlkData(oid zodb.Oid) string {
+func (t *Commit) XGetBlkData(oid zodb.Oid) string {
 	if oid == VDEL {
 		return DEL
 	}
-	data, ok := t.blkDataTab[oid]
+	data, ok := t.zblkDataTab[oid]
 	if !ok {
-		exc.Raisef("getBlkData ZBlk<%s> @%s: no such ZBlk", oid, t.at)
+		exc.Raisef("getBlkData ZBlk<%s> @%s: no such ZBlk", oid, t.At)
 	}
 	return data
 }

wcfs/internal/xbtree/δbtail_test.go

@@ -144,8 +144,8 @@ func XGetδKV(t1, t2 *xbtreetest.Commit, δkvOid map[Key]ΔValue) map[Key]Δstri
 	δkv := make(map[Key]Δstring, len(δkvOid))
 	for k, δvOid := range δkvOid {
 		δkv[k] = Δstring{
-			Old: t1.xgetBlkData(δvOid.Old),
-			New: t2.xgetBlkData(δvOid.New),
+			Old: t1.XGetBlkData(δvOid.Old),
+			New: t2.XGetBlkData(δvOid.New),
 		}
 	}
 	return δkv
@@ -225,7 +225,7 @@ func KAdj(t1, t2 *xbtreetest.Commit, keysv ...setKey) (kadj KAdjMatrix) {
 	kadj21 := _KAdj(t2,t1, keysv...)
 	if !reflect.DeepEqual(kadj12, kadj21) {
 		panicf("KAdj not symmetric:\nt1: %s\nt2: %s\nkadj12: %v\nkadj21: %v",
-			t1.tree, t2.tree, kadj12, kadj21)
+			t1.Tree, t2.Tree, kadj12, kadj21)
 	}
 	return kadj12
 }
@@ -249,8 +249,8 @@ func _KAdj(t1, t2 *xbtreetest.Commit, keysv ...setKey) (kadj KAdjMatrix) {
 	}
 
 	debugfKAdj("\n\n_KAdj\n")
-	debugfKAdj("t1:   %s\n", t1.tree)
-	debugfKAdj("t2:   %s\n", t2.tree)
+	debugfKAdj("t1:   %s\n", t1.Tree)
+	debugfKAdj("t2:   %s\n", t2.Tree)
 	debugfKAdj("keys: %s\n", keys)
 	defer func() {
 		debugfKAdj("kadj -> %v\n", kadj)
@@ -273,59 +273,57 @@ func _KAdj(t1, t2 *xbtreetest.Commit, keysv ...setKey) (kadj KAdjMatrix) {
 			debugfKAdj("q1:   %s\tdone1:  %s\n", q1, done1)
 			debugfKAdj("q2:   %s\tdone2:  %s\n", q2, done2)
 			for _, r1 := range q1.AllRanges() {
-				lo1 := r1.lo
+				lo1 := r1.Lo
 				for {
-					b1 := t1.xkv.Get(lo1)
+					b1 := t1.Xkv.Get(lo1)
 					debugfKAdj("  b1: %s\n", b1)
 					for k_ := range keys {
-						if b1.lo <= k_ && k_ <= b1.hi_ {
+						if b1.Keycov.Has(k_) {
 							adj1.Add(k_)
 							debugfKAdj("    adj1 += %s\t-> %s\n", kstr(k_), adj1)
 						}
 					}
-					b1r := blib.KeyRange{b1.lo, b1.hi_}
-					done1.AddRange(b1r)
+					done1.AddRange(b1.Keycov)
 					// q2 |= (b1.keyrange \ done2)
 					δq2 := &blib.RangedKeySet{}
-					δq2.AddRange(b1r)
+					δq2.AddRange(b1.Keycov)
 					δq2.DifferenceInplace(done2)
 					q2.UnionInplace(δq2)
 					debugfKAdj("q2 += %s\t-> %s\n", δq2, q2)
 
 					// continue with next right bucket until r1 coverage is complete
-					if r1.hi_ <= b1.hi_ {
+					if r1.Hi_ <= b1.Keycov.Hi_ {
 						break
 					}
-					lo1 = b1.hi_ + 1
+					lo1 = b1.Keycov.Hi_ + 1
 				}
 			}
 			q1.Clear()
 
 			for _, r2 := range q2.AllRanges() {
-				lo2 := r2.lo
+				lo2 := r2.Lo
 				for {
-					b2 := t2.xkv.Get(lo2)
+					b2 := t2.Xkv.Get(lo2)
 					debugfKAdj("  b2: %s\n", b2)
 					for k_ := range keys {
-						if b2.lo <= k_ && k_ <= b2.hi_ {
+						if b2.Keycov.Has(k_) {
 							adj2.Add(k_)
 							debugfKAdj("    adj2 += %s\t-> %s\n", kstr(k_), adj2)
 						}
 					}
-					b2r := blib.KeyRange{b2.lo, b2.hi_}
-					done2.AddRange(b2r)
+					done2.AddRange(b2.Keycov)
 					// q1 |= (b2.keyrange \ done1)
 					δq1 := &blib.RangedKeySet{}
-					δq1.AddRange(b2r)
+					δq1.AddRange(b2.Keycov)
 					δq1.DifferenceInplace(done1)
 					q1.UnionInplace(δq1)
 					debugfKAdj("q1 += %s\t-> %s\n", δq1, q1)
 
 					// continue with next right bucket until r2 coverage is complete
-					if r2.hi_ <= b2.hi_ {
+					if r2.Hi_ <= b2.Keycov.Hi_ {
 						break
 					}
-					lo2 = b2.hi_ + 1
+					lo2 = b2.Keycov.Hi_ + 1
 				}
 			}
 			q2.Clear()
@@ -348,7 +346,7 @@ func _KAdj(t1, t2 *xbtreetest.Commit, keysv ...setKey) (kadj KAdjMatrix) {
 func xverifyΔBTail_Update(t *testing.T, subj string, db *zodb.DB, treeRoot zodb.Oid, t1, t2 *xbtreetest.Commit) {
 	// verify transition at1->at2 for all initial states of tracked {keys} from kv1 + kv2 + ∞
 
-	t.Run(fmt.Sprintf("Update/%s→%s", t1.tree, t2.tree), func(t *testing.T) {
+	t.Run(fmt.Sprintf("Update/%s→%s", t1.Tree, t2.Tree), func(t *testing.T) {
 		allKeys := allTestKeys(t1, t2)
 		allKeyv := allKeys.SortedElements()
 
@@ -376,8 +374,8 @@ func xverifyΔBTail_Update1(t *testing.T, subj string, db *zodb.DB, treeRoot zod
 	X := exc.Raiseif
 	//t.Logf("\n>>> Track=%s\n", initialTrackedKeys)
 
-	δZ  := t2.δZ
-	d12 := t2.δxkv
+	δZ  := t2.ΔZ
+	d12 := t2.Δxkv
 
 	var TrackedδZ setKey = nil
 	var kadjTrackedδZ setKey = nil
@@ -409,23 +407,23 @@ func xverifyΔBTail_Update1(t *testing.T, subj string, db *zodb.DB, treeRoot zod
 
 
 	// δbtail @at1 with initial tracked set
-	δbtail := NewΔBtail(t1.at, db)
+	δbtail := NewΔBtail(t1.At, db)
 	xtrackKeys(δbtail, t1, initialTrackedKeys)
 
 	// TrackedδZ = Tracked ^ δZ  (i.e. a tracked node has changed, or its coverage was changed)
 	TrackedδZ = setKey{}
 	for k := range initialTrackedKeys {
-		leaf1 := t1.xkv.Get(k)
-		oid1 := leaf1.oid
+		leaf1 := t1.Xkv.Get(k)
+		oid1 := leaf1.Oid
 		if oid1 == zodb.InvalidOid { // embedded bucket
-			oid1 = leaf1.parent.oid
+			oid1 = leaf1.Parent.Oid
 		}
-		leaf2 := t2.xkv.Get(k)
-		oid2 := leaf2.oid
+		leaf2 := t2.Xkv.Get(k)
+		oid2 := leaf2.Oid
 		if oid2 == zodb.InvalidOid { // embedded bucket
-			oid2 = leaf2.parent.oid
+			oid2 = leaf2.Parent.Oid
 		}
-		if δZset.Has(oid1) || δZset.Has(oid2) || (blib.KeyRange{leaf1.lo,leaf1.hi_} != blib.KeyRange{leaf2.lo,leaf2.hi_}) {
+		if δZset.Has(oid1) || δZset.Has(oid2) || (leaf1.Keycov != leaf2.Keycov) {
 			TrackedδZ.Add(k)
 		}
 	}
@@ -458,8 +456,8 @@ func xverifyΔBTail_Update1(t *testing.T, subj string, db *zodb.DB, treeRoot zod
 
 	// trackSet1 = xkv1[tracked1]
 	// trackSet2 = xkv2[tracked2]  ( = xkv2[kadj[tracked1]]
-	trackSet1, tkeyCov1 := trackSetWithCov(t1.xkv, initialTrackedKeys)
-	trackSet2, tkeyCov2 := trackSetWithCov(t2.xkv, initialTrackedKeys.Union(kadjTrackedδZ))
+	trackSet1, tkeyCov1 := trackSetWithCov(t1.Xkv, initialTrackedKeys)
+	trackSet2, tkeyCov2 := trackSetWithCov(t2.Xkv, initialTrackedKeys.Union(kadjTrackedδZ))
 
 	// verify δbtail.trackSet against @at1
 	δbtail.assertTrack(t, "1", ø, trackSet1)
@@ -608,20 +606,20 @@ func (δBtail *ΔBtail) assertTrack(t *testing.T, subj string, trackSetOK blib.P
 //
 // It also exercises rebuild phase of ΔBtail.Update.
 func xverifyΔBTail_rebuild(t *testing.T, db *zodb.DB, treeRoot zodb.Oid, t0, t1, t2 *xbtreetest.Commit) {
-	t.Run(fmt.Sprintf("rebuild/%s→%s", t0.tree, t1.tree), func(t *testing.T) {
+	t.Run(fmt.Sprintf("rebuild/%s→%s", t0.Tree, t1.Tree), func(t *testing.T) {
 		tAllKeys := allTestKeys(t0, t1, t2)
 		tAllKeyv := tAllKeys.SortedElements()
 
 		// tid -> "at_i"
 		xat := map[zodb.Tid]string{
-			t0.at: "at0",
-			t1.at: "at1",
-			t2.at: "at2",
+			t0.At: "at0",
+			t1.At: "at1",
+			t2.At: "at2",
 		}
 
-		//fmt.Printf("@%s:  %v\n", xat[t0.at], t0.xkv.Flatten())
-		//fmt.Printf("@%s:  %v\n", xat[t1.at], t1.xkv.Flatten())
-		//fmt.Printf("@%s:  %v\n", xat[t2.at], t2.xkv.Flatten())
+		//fmt.Printf("@%s:  %v\n", xat[t0.At], t0.Xkv.Flatten())
+		//fmt.Printf("@%s:  %v\n", xat[t1.At], t1.Xkv.Flatten())
+		//fmt.Printf("@%s:  %v\n", xat[t2.At], t2.Xkv.Flatten())
 
 		kadj10 := KAdj(t1,t0, allTestKeys(t0,t1,t2))
 		kadj21 := KAdj(t2,t1, allTestKeys(t0,t1,t2))
@@ -644,17 +642,17 @@ func xverifyΔBTail_rebuild(t *testing.T, db *zodb.DB, treeRoot zodb.Oid, t0, t1
 			keys1_0 := kadj10.Map(keys1)
 			δkv1_1 := map[Key]Δstring{}
 			for k := range keys1_0 {
-				δv, ok := t1.δxkv[k]
+				δv, ok := t1.Δxkv[k]
 				if ok {
 					δkv1_1[k] = δv
 				}
 			}
 
-			Tkeys1   := t1.xkv.trackSet(keys1)
-			Tkeys1_0 := t1.xkv.trackSet(keys1_0)
+			Tkeys1   := trackSet(t1.Xkv, keys1)
+			Tkeys1_0 := trackSet(t1.Xkv, keys1_0)
 
 			t.Run(fmt.Sprintf(" T%s;R", keys1), func(t *testing.T) {
-				δbtail := NewΔBtail(t0.at, db)
+				δbtail := NewΔBtail(t0.At, db)
 
 				// assert trackSet=ø, trackNew=ø, vδB=[]
 				δbtail.assertTrack(t, "@at0", ø, ø)
@@ -674,7 +672,7 @@ func xverifyΔBTail_rebuild(t *testing.T, db *zodb.DB, treeRoot zodb.Oid, t0, t1
 					/*trackSet=*/ Tkeys1_0,
 					/*vδT=*/ δkv1_1)
 
-				t.Run((" →" + t2.tree), func(t *testing.T) {
+				t.Run((" →" + t2.Tree), func(t *testing.T) {
 					// keys1R2 is full set of keys that should become tracked after
 					// Update()  (which includes rebuild)
 					keys1R2 := kadj12.Map(keys1)
@@ -690,17 +688,17 @@ func xverifyΔBTail_rebuild(t *testing.T, db *zodb.DB, treeRoot zodb.Oid, t0, t1
 					δkv1_k1R2 := map[Key]Δstring{}
 					δkv2_k1R2 := map[Key]Δstring{}
 					for k := range keys1R2 {
-						δv1, ok := t1.δxkv[k]
+						δv1, ok := t1.Δxkv[k]
 						if ok {
 							δkv1_k1R2[k] = δv1
 						}
-						δv2, ok := t2.δxkv[k]
+						δv2, ok := t2.Δxkv[k]
 						if ok {
 							δkv2_k1R2[k] = δv2
 						}
 					}
 
-					Tkeys1R2  := t2.xkv.trackSet(keys1R2)
+					Tkeys1R2  := trackSet(t2.Xkv, keys1R2)
 
 					xverifyΔBTail_rebuild_U(t, δbtail, treeRoot, t1, t2, xat,
 						/*trackSet=*/ Tkeys1R2,
@@ -735,16 +733,16 @@ func xverifyΔBTail_rebuild(t *testing.T, db *zodb.DB, treeRoot zodb.Oid, t0, t1
 							keys12R2 = keys12R2_
 						}
 
-						Tkeys2    := t2.xkv.trackSet(keys2)
-						Tkeys12R2 := t2.xkv.trackSet(keys12R2)
+						Tkeys2    := trackSet(t2.Xkv, keys2)
+						Tkeys12R2 := trackSet(t2.Xkv, keys12R2)
 /*
 						fmt.Printf("\n\n\nKKK\nkeys1=%s  keys2=%s\n", keys1, keys2)
 						fmt.Printf("keys1R2:  %s\n", keys1R2)
 						fmt.Printf("keys12R2: %s\n", keys12R2)
 
-						fmt.Printf("t0.xkv: %v\n", t0.xkv)
-						fmt.Printf("t1.xkv: %v\n", t1.xkv)
-						fmt.Printf("t2.xkv: %v\n", t2.xkv)
+						fmt.Printf("t0.Xkv: %v\n", t0.Xkv)
+						fmt.Printf("t1.Xkv: %v\n", t1.Xkv)
+						fmt.Printf("t2.Xkv: %v\n", t2.Xkv)
 						fmt.Printf("kadj21: %v\n", kadj21)
 						fmt.Printf("kadj12: %v\n", kadj12)
 						fmt.Printf("Tkeys2   -> %s\n", Tkeys2)
@@ -755,14 +753,14 @@ func xverifyΔBTail_rebuild(t *testing.T, db *zodb.DB, treeRoot zodb.Oid, t0, t1
 
 
 						// δkvX_k12R2 = tX.δxkv / keys12R2
-						δkv1_k12R2 := make(map[Key]Δstring, len(t1.δxkv))
-						δkv2_k12R2 := make(map[Key]Δstring, len(t2.δxkv))
+						δkv1_k12R2 := make(map[Key]Δstring, len(t1.Δxkv))
+						δkv2_k12R2 := make(map[Key]Δstring, len(t2.Δxkv))
 						for k := range keys12R2 {
-							δv1, ok := t1.δxkv[k]
+							δv1, ok := t1.Δxkv[k]
 							if ok {
 								δkv1_k12R2[k] = δv1
 							}
-							δv2, ok := t2.δxkv[k]
+							δv2, ok := t2.Δxkv[k]
 							if ok {
 								δkv2_k12R2[k] = δv2
 							}
@@ -797,10 +795,10 @@ func xverifyΔBTail_rebuild_U(t *testing.T, δbtail *ΔBtail, treeRoot zodb.Oid,
 	X := exc.Raiseif
 	ø := blib.PPTreeSubSet{}
 
-	subj := fmt.Sprintf("after Update(@%s→@%s)", xat[ti.at], xat[tj.at])
+	subj := fmt.Sprintf("after Update(@%s→@%s)", xat[ti.At], xat[tj.At])
 
 	// Update ati -> atj
-	δB, err := δbtail.Update(tj.δZ);  X(err)
+	δB, err := δbtail.Update(tj.ΔZ);  X(err)
 	δbtail.assertTrack(t, subj, trackSet, ø)
 	assertΔTtail(t, subj, δbtail, tj, treeRoot, xat, vδTok...)
 
@@ -825,8 +823,8 @@ func xverifyΔBTail_rebuild_U(t *testing.T, δbtail *ΔBtail, treeRoot zodb.Oid,
 	if ok {
 		δT = XGetδKV(ti, tj, δToid)
 	}
-	if δB.Rev != tj.at {
-		t.Errorf("%s: δB.Rev: have %s  ; want %s", subj, δB.Rev, tj.at)
+	if δB.Rev != tj.At {
+		t.Errorf("%s: δB.Rev: have %s  ; want %s", subj, δB.Rev, tj.At)
 	}
 	if len(δB.ΔByRoot) != δrootsOK {
 		t.Errorf("%s: len(δB.ΔByRoot) != %d  ; δroots=%v", subj, δrootsOK, δroots)
@@ -844,7 +842,7 @@ func xverifyΔBTail_rebuild_TR(t *testing.T, δbtail *ΔBtail, tj *xbtreetest.Co
 	// Track(keys)
 	xtrackKeys(δbtail, tj, keys)
 
-	subj := fmt.Sprintf("@%s: after Track%v", xat[tj.at], keys)
+	subj := fmt.Sprintf("@%s: after Track%v", xat[tj.At], keys)
 	δbtail.assertTrack(t, subj, trackSet, trackNew)
 
 	δbtail.rebuildAll()
@@ -867,16 +865,16 @@ func assertΔTtail(t *testing.T, subj string, δbtail *ΔBtail, tj *xbtreetest.C
 	l := len(vδTok)
 	var vatOK  []zodb.Tid
 	var vδTok_ []map[Key]Δstring
-	at2t := map[zodb.Tid]*xbtreetest.Commit{tj.at: tj}
+	at2t := map[zodb.Tid]*xbtreetest.Commit{tj.At: tj}
 	t0 := tj
 	for i := 0; i<l; i++ {
 		// empty vδTok entries means they should be absent in vδT
 		if δTok := vδTok[l-i-1]; len(δTok) != 0 {
-			vatOK  = append([]zodb.Tid{t0.at}, vatOK...)
+			vatOK  = append([]zodb.Tid{t0.At}, vatOK...)
 			vδTok_ = append([]map[Key]Δstring{δTok}, vδTok_...)
 		}
-		t0 = t0.prev
-		at2t[t0.at] = t0
+		t0 = t0.Prev
+		at2t[t0.At] = t0
 	}
 	vδTok = vδTok_
 	δTtail, ok := δbtail.vδTbyRoot[treeRoot]
@@ -888,7 +886,7 @@ func assertΔTtail(t *testing.T, subj string, δbtail *ΔBtail, tj *xbtreetest.C
 	l = len(vδToid)
 	var vat []zodb.Tid
 	var vδT []map[Key]Δstring
-	atPrev := t0.at
+	atPrev := t0.At
 	for _, δToid := range vδToid {
 		vat = append(vat, δToid.Rev)
 		δT := XGetδKV(at2t[atPrev], at2t[δToid.Rev], δToid.ΔKV) // {} k -> δ(ZBlk(oid).data)
@@ -938,8 +936,8 @@ func assertΔTtail(t *testing.T, subj string, δbtail *ΔBtail, tj *xbtreetest.C
 func xtrackKeys(δbtail *ΔBtail, t *xbtreetest.Commit, keys setKey) {
 	X := exc.Raiseif
 	head := δbtail.Head()
-	if head != t.at {
-		panicf("BUG: δbtail.head: %s  ; t.at: %s", head, t.at)
+	if head != t.At {
+		panicf("BUG: δbtail.head: %s  ; t.at: %s", head, t.At)
 	}
 
 	for k := range keys {
@@ -953,7 +951,7 @@ func xtrackKeys(δbtail *ΔBtail, t *xbtreetest.Commit, keys setKey) {
 		// continues to be tracked and all keys migrate to holes in the
 		// tracking set. By aligning initial state to the same as after
 		// T1->ø, we test what will happen on ø->T2.
-		b := t.xkv.Get(k)
+		b := t.Xkv.Get(k)
 		err := δbtail.track(k, b.Path()); X(err)
 	}
 }
@@ -963,18 +961,18 @@ func xtrackKeys(δbtail *ΔBtail, t *xbtreetest.Commit, keys setKey) {
 // XXX kill
 /*
 func ___xverifyΔBTail_GetAt(t *testing.T, db *zodb.DB, treeRoot zodb.Oid, vt ...*xbtreetest.Commit) {
-	subj := vt[0].tree
+	subj := vt[0].Tree
 	for _, t := range vt[1:] {
-		subj += "→" + t.tree
+		subj += "→" + t.Tree
 	}
 
 	t.Run(fmt.Sprintf("Get/%s", subj), func(t *testing.T) {
 		// tid -> "at_i"
 		xat := map[zodb.Tid]string{}
 		for i := range vt {
-			xat[vt[i].at] = fmt.Sprintf("at%d", i)
+			xat[vt[i].At] = fmt.Sprintf("at%d", i)
 
-			fmt.Printf("@%s:  %v\n", xat[vt[i].at], vt[i].xkv.Flatten())
+			fmt.Printf("@%s:  %v\n", xat[vt[i].At], vt[i].Xkv.Flatten())
 		}
 
 		tkeys := allTestKeys(vt...)
@@ -999,15 +997,15 @@ func xverifyΔBTail_GetAt1(t *testing.T, db *zodb.DB, treeRoot zodb.Oid, vt []*x
 	X := exc.Raiseif
 
 	// t1->t2-> ... -> tn
-	δbtail := NewΔBtail(vt[0].at, db)
+	δbtail := NewΔBtail(vt[0].At, db)
 	for i := 1; i < len(vt); i++ {
-		_, err := δbtail.Update(vt[i].δZ);  X(err)
+		_, err := δbtail.Update(vt[i].ΔZ);  X(err)
 	}
 
 	// Track(keys)
 	txn, ctx := transaction.New(context.Background())
 	defer txn.Abort()
-	zconn, err := db.Open(ctx, &zodb.ConnOptions{At: vt[len(vt)-1].at});  X(err)
+	zconn, err := db.Open(ctx, &zodb.ConnOptions{At: vt[len(vt)-1].At});  X(err)
 	xtree, err := zconn.Get(ctx, treeRoot);	 X(err)
 	ztree := xtree.(*Tree)
 
@@ -1018,21 +1016,21 @@ func xverifyΔBTail_GetAt1(t *testing.T, db *zodb.DB, treeRoot zodb.Oid, vt []*x
 
 	// verify GetAt(k, @at) for all keys and @at
 	for i := 1; i < len(vt); i++ {
-		at := vt[i].at
+		at := vt[i].At
 		for _, k := range keys.SortedElements() {
 			vOid, ok, rev, revExact, err := δbtail.GetAt(ctx, ztree, k, at);  X(err)
 			v := xzgetBlkDataAt(db, vOid, rev)
 
-			v_, ok_ := vt[i].xkv.Get(k).kv[k]
-			rev_, revExact_ := vt[i].at, false
+			v_, ok_ := vt[i].Xkv.Get(k).kv[k]
+			rev_, revExact_ := vt[i].At, false
 			for j := i-1; j >= 0; j-- {
-				v__ := vt[j].xkv.Get(k).kv[k]
+				v__ := vt[j].Xkv.Get(k).kv[k]
 				if v__ != v_ {
-					rev_ = vt[j+1].at
+					rev_ = vt[j+1].At
 					revExact_ = true
 					break
 				}
-				rev_ = vt[j].at
+				rev_ = vt[j].At
 			}
 
 			if v == "" { v = DEL }
@@ -1090,12 +1088,12 @@ func testΔBTail(t_ *testing.T, testq chan ΔBTestEntry) {
 		t1 := t.Head()
 		t2 := t.CommitTree(test.tree)
 
-		subj := fmt.Sprintf("%s -> %s", t1.tree, t2.tree)
+		subj := fmt.Sprintf("%s -> %s", t1.Tree, t2.Tree)
 		//t.Logf("\n\n\n**** %s ****\n\n", subj)
 
 		// KAdj
 		if kadjOK := test.kadjOK; kadjOK != nil {
-			t.Run(fmt.Sprintf("KAdj/%s→%s", t1.tree, t2.tree), func(t *testing.T) {
+			t.Run(fmt.Sprintf("KAdj/%s→%s", t1.Tree, t2.Tree), func(t *testing.T) {
 				kadj := KAdj(t1, t2)
 				if !reflect.DeepEqual(kadj, kadjOK) {
 					t.Fatalf("BUG: computed kadj is wrong:\nkadjOK: %v\nkadj  : %v\n\n", kadjOK, kadj)
@@ -1105,12 +1103,12 @@ func testΔBTail(t_ *testing.T, testq chan ΔBTestEntry) {
 
 		// ΔBTail.Update
 		if test.flags & ΔBTest_SkipUpdate == 0 {
-			xverifyΔBTail_Update(t.T, subj, t.db, t.Root(), t1,t2)
+			xverifyΔBTail_Update(t.T, subj, t.DB, t.Root(), t1,t2)
 		}
 
 		// ΔBTail.rebuild
 		if t0 != nil && (test.flags & ΔBTest_SkipRebuild == 0) {
-			xverifyΔBTail_rebuild(t.T, t.db, t.Root(), t0,t1,t2)
+			xverifyΔBTail_rebuild(t.T, t.DB, t.Root(), t0,t1,t2)
 		}
 
 		t0, t1 = t1, t2
@@ -1280,7 +1278,7 @@ func TestΔBTail(t *testing.T) {
 		// * `ø -> Tree ...`		(tree is created anew),
 		// * `... Tree -> ø`		(tree is deleted), and
 		// * `Tree -> ø -> Tree`	(tree is deleted and then recreated)
-		DEL,
+		xbtreetest.DEL,
 
 		// tree rotation
 		"T3/B2:b-B3:c,4:d",
@@ -1573,29 +1571,29 @@ func TestΔBtailForget(t_ *testing.T) {
 	t2 := t.CommitTree("T2/B1:a-B2:b")
 	t3 := t.CommitTree("T/B2:b")
 
-	δbtail := NewΔBtail(t0.at, t.db)
-	_, err := δbtail.Update(t1.δZ);  X(err)
-	_, err  = δbtail.Update(t2.δZ);  X(err)
+	δbtail := NewΔBtail(t0.At, t.DB)
+	_, err := δbtail.Update(t1.ΔZ);  X(err)
+	_, err  = δbtail.Update(t2.ΔZ);  X(err)
 
 	// start tracking. everything becomes tracked because t1's T/B1:a has [-∞,∞) coverage
 	// By starting tracking after t2 we verify vδBroots update in both Update and rebuild
 	_0 := setKey{}; _0.Add(0)
 	xtrackKeys(δbtail, t2, _0)
 
-	_, err  = δbtail.Update(t3.δZ);  X(err)
+	_, err  = δbtail.Update(t3.ΔZ);  X(err)
 
 	xat := map[zodb.Tid]string{
-		t0.at: "at0",
-		t1.at: "at1",
-		t2.at: "at2",
-		t3.at: "at3",
-	}
-	assertΔTtail(t.T, "init",         δbtail, t3, t.Root(), xat, t1.δxkv, t2.δxkv, t3.δxkv)
-	δbtail.ForgetPast(t0.at)
-	assertΔTtail(t.T, "forget ≤ at0", δbtail, t3, t.Root(), xat, t1.δxkv, t2.δxkv, t3.δxkv)
-	δbtail.ForgetPast(t1.at)
-	assertΔTtail(t.T, "forget ≤ at1", δbtail, t3, t.Root(), xat,          t2.δxkv, t3.δxkv)
-	δbtail.ForgetPast(t3.at)
+		t0.At: "at0",
+		t1.At: "at1",
+		t2.At: "at2",
+		t3.At: "at3",
+	}
+	assertΔTtail(t.T, "init",         δbtail, t3, t.Root(), xat, t1.Δxkv, t2.Δxkv, t3.Δxkv)
+	δbtail.ForgetPast(t0.At)
+	assertΔTtail(t.T, "forget ≤ at0", δbtail, t3, t.Root(), xat, t1.Δxkv, t2.Δxkv, t3.Δxkv)
+	δbtail.ForgetPast(t1.At)
+	assertΔTtail(t.T, "forget ≤ at1", δbtail, t3, t.Root(), xat,          t2.Δxkv, t3.Δxkv)
+	δbtail.ForgetPast(t3.At)
 	assertΔTtail(t.T, "forget ≤ at3", δbtail, t3, t.Root(), xat,                          )
 }
 
@@ -1609,15 +1607,15 @@ func TestΔBtailClone(t_ *testing.T) {
 
 	t0 := t.CommitTree("T2/B1:a-B2:b")
 	t1 := t.CommitTree("T2/B1:c-B2:d")
-	δbtail := NewΔBtail(t0.at, t.db)
-	_, err := δbtail.Update(t1.δZ); X(err)
+	δbtail := NewΔBtail(t0.At, t.DB)
+	_, err := δbtail.Update(t1.ΔZ); X(err)
 	_2 := setKey{}; _2.Add(2)
 	xtrackKeys(δbtail, t1, _2)
 	err = δbtail.rebuildAll(); X(err)
 
 	xat := map[zodb.Tid]string{
-		t0.at: "at0",
-		t1.at: "at1",
+		t0.At: "at0",
+		t1.At: "at1",
 	}
 
 	δkv1_1 := map[Key]Δstring{2:{"b","d"}}
@@ -1626,8 +1624,8 @@ func TestΔBtailClone(t_ *testing.T) {
 	assertΔTtail(t.T, "klon @at1", δbklon, t1, t.Root(), xat, δkv1_1)
 
 	t2 := t.CommitTree("T/B1:b,2:a")
-	_, err = δbtail.Update(t2.δZ); X(err)
-	xat[t2.at] = "at2"
+	_, err = δbtail.Update(t2.ΔZ); X(err)
+	xat[t2.At] = "at2"
 
 	δkv1_2 := map[Key]Δstring{1:{"a","c"}, 2:{"b","d"}}
 	δkv2_2 := map[Key]Δstring{1:{"c","b"}, 2:{"d","a"}}
@@ -1683,8 +1681,8 @@ func TestIntSets(t *testing.T) {
 func allTestKeys(vt ...*xbtreetest.Commit) setKey {
 	allKeys := setKey{}; allKeys.Add(KeyMax) // ∞ simulating ZBigFile.Size() query
 	for _, t := range vt {
-		for _, b := range t.xkv {
-			for k := range b.kv {
+		for _, b := range t.Xkv {
+			for k := range b.KV {
 				allKeys.Add(k)
 			}
 		}