added ibbs_tree

common/ibbs_tree_test.go

@@ -0,0 +1,203 @@
+package common
+
+import (
+	"fmt"
+	"runtime"
+	"testing"
+)
+
+func init() {
+	// TODO: seed rand?
+}
+
+func (self *IBBSTree) lmd() *IBBSTree {
+	if self.height == 0 {
+		return self
+	}
+	return self.left.lmd()
+}
+
+func TestUnit(t *testing.T) {
+
+	// Convenience for a new node
+	N := func(l, r interface{}) *IBBSTree {
+		var left, right *IBBSTree
+		if _, ok := l.(*IBBSTree); ok {
+			left = l.(*IBBSTree)
+		} else {
+			left = NewIBBSTreeNode(uint64(l.(int)), nil)
+		}
+		if _, ok := r.(*IBBSTree); ok {
+			right = r.(*IBBSTree)
+		} else {
+			right = NewIBBSTreeNode(uint64(r.(int)), nil)
+		}
+
+		n := &IBBSTree{
+			key:   right.lmd().key,
+			left:  left,
+			right: right,
+		}
+		n.calcHeightAndSize()
+		return n
+	}
+
+	// Convenience for simple printing of keys & tree structure
+	var P func(*IBBSTree) string
+	P = func(n *IBBSTree) string {
+		if n.height == 0 {
+			return fmt.Sprintf("%v", n.key)
+		} else {
+			return fmt.Sprintf("(%v %v)", P(n.left), P(n.right))
+		}
+	}
+
+	expectSet := func(n *IBBSTree, i uint64, repr string) {
+		n2, updated := n.Set(i, nil)
+		// ensure node was added & structure is as expected.
+		if updated == true || P(n2) != repr {
+			t.Fatalf("Adding %v to %v:\nExpected         %v\nUnexpectedly got %v updated:%v",
+				i, P(n), repr, P(n2), updated)
+		}
+	}
+
+	expectRemove := func(n *IBBSTree, i uint64, repr string) {
+		n2, value, removed := n.Remove(i)
+		// ensure node was removed & structure is as expected.
+		if value != nil || P(n2) != repr || !removed {
+			t.Fatalf("Removing %v from %v:\nExpected         %v\nUnexpectedly got %v value:%v err:%v",
+				i, P(n), repr, P(n2), value, removed)
+		}
+	}
+
+	//////// Test Set cases:
+
+	// Case 1:
+	n1 := N(4, 20)
+
+	expectSet(n1, 8, "((4 8) 20)")
+	expectSet(n1, 25, "(4 (20 25))")
+
+	n2 := N(4, N(20, 25))
+
+	expectSet(n2, 8, "((4 8) (20 25))")
+	expectSet(n2, 30, "((4 20) (25 30))")
+
+	n3 := N(N(1, 2), 6)
+
+	expectSet(n3, 4, "((1 2) (4 6))")
+	expectSet(n3, 8, "((1 2) (6 8))")
+
+	n4 := N(N(1, 2), N(N(5, 6), N(7, 9)))
+
+	expectSet(n4, 8, "(((1 2) (5 6)) ((7 8) 9))")
+	expectSet(n4, 10, "(((1 2) (5 6)) (7 (9 10)))")
+
+	//////// Test Remove cases:
+
+	n10 := N(N(1, 2), 3)
+
+	expectRemove(n10, 2, "(1 3)")
+	expectRemove(n10, 3, "(1 2)")
+
+	n11 := N(N(N(1, 2), 3), N(4, 5))
+
+	expectRemove(n11, 4, "((1 2) (3 5))")
+	expectRemove(n11, 3, "((1 2) (4 5))")
+
+}
+
+func TestIntegration(t *testing.T) {
+
+	type record struct {
+		key   uint64
+		value string
+	}
+
+	records := make([]*record, 400)
+	var tree *IBBSTree = NewIBBSTree()
+	var val interface{}
+	var removed bool
+	var updated bool
+
+	randomRecord := func() *record {
+		return &record{RandUInt64(), RandStr(20)}
+	}
+
+	for i := range records {
+		r := randomRecord()
+		records[i] = r
+		//t.Log("New record", r)
+		//PrintIBBSTree(tree.root)
+		tree, updated = tree.Set(r.key, "")
+		if updated {
+			t.Error("should have not been updated")
+		}
+		tree, updated = tree.Set(r.key, r.value)
+		if !updated {
+			t.Error("should have been updated")
+		}
+		if tree.Size() != uint64(i+1) {
+			t.Error("size was wrong", tree.Size(), i+1)
+		}
+	}
+
+	for _, r := range records {
+		if has := tree.Has(r.key); !has {
+			t.Error("Missing key", r.key)
+		}
+		if val := tree.Get(r.key); val.(string) != r.value {
+			t.Error("wrong value")
+		}
+	}
+
+	for i, x := range records {
+		if tree, val, removed = tree.Remove(x.key); !removed {
+			t.Error("not removed")
+		} else if val.(string) != x.value {
+			t.Error("wrong value")
+		}
+		for _, r := range records[i+1:] {
+			if has := tree.Has(r.key); !has {
+				t.Error("Missing key", r.key)
+			}
+			val := tree.Get(r.key)
+			if val.(string) != r.value {
+				t.Error("wrong value")
+			}
+		}
+		if tree.Size() != uint64(len(records)-(i+1)) {
+			t.Error("size was wrong", tree.Size(), (len(records) - (i + 1)))
+		}
+	}
+}
+
+func BenchmarkIBBSTree(b *testing.B) {
+	b.StopTimer()
+
+	type record struct {
+		key   uint64
+		value interface{}
+	}
+
+	randomRecord := func() *record {
+		return &record{RandUInt64(), RandUInt64()}
+	}
+
+	t := NewIBBSTree()
+	for i := 0; i < 1000000; i++ {
+		r := randomRecord()
+		t, _ = t.Set(r.key, r.value)
+	}
+
+	fmt.Println("ok, starting")
+
+	runtime.GC()
+
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		r := randomRecord()
+		t, _ = t.Set(r.key, r.value)
+		t, _, _ = t.Remove(r.key)
+	}
+}