seaweedfs/weed/util/bptree/bptree_test.go

package bptree

import (
	"encoding/hex"
	"runtime/debug"
	"sort"
	"sync"
	"testing"

	crand "crypto/rand"
	"encoding/binary"
	mrand "math/rand"

)

var rand *mrand.Rand

func init() {
	seed := make([]byte, 8)
	if _, err := crand.Read(seed); err == nil {
		rand = ThreadSafeRand(int64(binary.BigEndian.Uint64(seed)))
	} else {
		panic(err)
	}
}

func randslice(length int) []byte {
	return RandSlice(length)
}

func randstr(length int) String {
	return String(RandStr(length))
}

type Strings []String

func (self Strings) Len() int {
	return len(self)
}

func (self Strings) Less(i, j int) bool {
	return self[i].Less(self[j])
}

func (self Strings) Swap(i, j int) {
	self[i], self[j] = self[j], self[i]
}

type record struct {
	key   String
	value String
}

type records []*record

func (self records) Len() int {
	return len(self)
}

func (self records) Less(i, j int) bool {
	return self[i].key.Less(self[j].key)
}

func (self records) Swap(i, j int) {
	self[i], self[j] = self[j], self[i]
}

func BenchmarkBpTree(b *testing.B) {
	b.StopTimer()

	recs := make(records, 100)
	ranrec := func() *record {
		return &record{randstr(20), randstr(20)}
	}

	for i := range recs {
		recs[i] = ranrec()
	}

	b.StartTimer()
	for i := 0; i < b.N; i++ {
		t := NewBpTree(23)
		for _, r := range recs {
			t.Add(r.key, r.value)
		}
		for _, r := range recs {
			t.RemoveWhere(r.key, func(value interface{}) bool { return true })
		}
	}
}

func TestAddHasCountFindIterateRemove(t *testing.T) {

	ranrec := func() *record {
		return &record{
			randstr(12),
			randstr(12),
		}
	}

	test := func(bpt *BpTree) {
		var err error
		recs := make(records, 128)
		new_recs := make(records, 128)
		for i := range recs {
			r := ranrec()
			recs[i] = r
			new_recs[i] = &record{r.key, randstr(12)}
			err = bpt.Add(r.key, r.value)
			if err != nil {
				t.Error(err)
			}
		}

		for i, r := range recs {
			if has := bpt.Has(r.key); !has {
				t.Error(bpt, "Missing key")
			}
			if has := bpt.Has(randstr(10)); has {
				t.Error("Table has extra key")
			}
			for k, v, next := bpt.Find(r.key)(); next != nil; k, v, next = next() {
				if !k.Equals(r.key) {
					t.Error(bpt, "Find Failed Key Error")
				}
				if !v.(String).Equals(r.value) {
					t.Error(bpt, "Find Failed Value Error")
				}
			}
			err = bpt.Replace(r.key, func(value interface{}) bool { return true }, new_recs[i].value)
			if err != nil {
				t.Error(err)
			}
		}
		sort.Sort(recs)
		sort.Sort(new_recs)
		i := 0
		for k, v, next := bpt.Iterate()(); next != nil; k, v, next = next() {
			if !recs[i].key.Equals(k) {
				t.Error("iterate error wrong key")
			}
			if !new_recs[i].value.Equals(v.(String)) {
				t.Error("iterate error wrong value")
			}
			i++
		}
		i = len(recs) - 1
		for k, v, next := bpt.Backward()(); next != nil; k, v, next = next() {
			if !recs[i].key.Equals(k) {
				t.Error("iterate error wrong key")
			}
			if !new_recs[i].value.Equals(v.(String)) {
				t.Error("iterate error wrong value")
			}
			i--
		}
		i = 0
		for k, next := bpt.Keys()(); next != nil; k, next = next() {
			if !recs[i].key.Equals(k) {
				t.Error("iterate error wrong key")
			}
			i++
		}
		i = 7
		for k, v, next := bpt.Range(recs[i].key, recs[i+(len(recs)/2)].key)(); next != nil; k, v, next = next() {
			if !recs[i].key.Equals(k) {
				t.Error("iterate error wrong key")
			}
			if !new_recs[i].value.Equals(v.(String)) {
				t.Error("iterate error wrong value")
			}
			i++
		}
		for k, v, next := bpt.Range(recs[i].key, recs[7].key)(); next != nil; k, v, next = next() {
			if !recs[i].key.Equals(k) {
				t.Error("iterate error wrong key")
			}
			if !new_recs[i].value.Equals(v.(String)) {
				t.Error("iterate error wrong value", k, v, recs[i].value, new_recs[i].value)
			}
			i--
		}
		for i, r := range recs {
			if has := bpt.Has(r.key); !has {
				t.Error(bpt, "Missing key")
			}
			if err := bpt.RemoveWhere(r.key, func(value interface{}) bool { return true }); err != nil {
				t.Fatal(bpt, err)
			}
			if has := bpt.Has(r.key); has {
				t.Error("Table has extra key")
			}
			for _, x := range recs[i+1:] {
				if has := bpt.Has(x.key); !has {
					t.Error(bpt, "Missing key", x.key)
				}
			}
		}
	}
	for i := 2; i < 64; i++ {
		test(NewBpTree(i))
	}
}

func TestBpMap(t *testing.T) {

	ranrec := func() *record {
		return &record{
			randstr(12),
			randstr(12),
		}
	}

	test := func(table MapOperable) {
		recs := make(records, 400)
		for i := range recs {
			r := ranrec()
			recs[i] = r
			err := table.Put(r.key, String(""))
			if err != nil {
				t.Error(err)
			}
			err = table.Put(r.key, r.value)
			if err != nil {
				t.Error(err)
			}
		}

		for _, r := range recs {
			if has := table.Has(r.key); !has {
				t.Error(table, "Missing key")
			}
			if has := table.Has(randstr(12)); has {
				t.Error("Table has extra key")
			}
			if val, err := table.Get(r.key); err != nil {
				t.Error(err)
			} else if !(val.(String)).Equals(r.value) {
				t.Error("wrong value")
			}
		}

		for i, x := range recs {
			if val, err := table.Remove(x.key); err != nil {
				t.Error(err)
			} else if !(val.(String)).Equals(x.value) {
				t.Error("wrong value")
			}
			for _, r := range recs[i+1:] {
				if has := table.Has(r.key); !has {
					t.Error("Missing key")
				}
				if has := table.Has(randstr(12)); has {
					t.Error("Table has extra key")
				}
				if val, err := table.Get(r.key); err != nil {
					t.Error(err)
				} else if !(val.(String)).Equals(r.value) {
					t.Error("wrong value")
				}
			}
		}
	}

	test(NewBpMap(23))
}

func Test_get_start(t *testing.T) {
	root := NewLeaf(2)
	root, err := root.put(Int(1), 1)
	if err != nil {
		t.Error(err)
	}
	root, err = root.put(Int(5), 3)
	if err != nil {
		t.Error(err)
	}
	root, err = root.put(Int(3), 2)
	if err != nil {
		t.Error(err)
	}
	t.Log(root)
	t.Log(root.pointers[0])
	t.Log(root.pointers[1])
	i, n := root.get_start(Int(1))
	if n != root.pointers[0] {
		t.Error("wrong node from get_start")
	}
	if i != 0 {
		t.Error("wrong index from get_start")
	}
	i, n = root.get_start(Int(3))
	if n != root.pointers[0] {
		t.Error("wrong node from get_start")
	}
	if i != 1 {
		t.Error("wrong index from get_start")
	}
	i, n = root.get_start(Int(5))
	if n != root.pointers[1] {
		t.Error("wrong node from get_start")
	}
	if i != 0 {
		t.Error("wrong index from get_start")
	}
	i, n = root.get_start(Int(2))
	if n != root.pointers[0] {
		t.Error("wrong node from get_start")
	}
	if i != 1 {
		t.Error("wrong index from get_start")
	}
	i, n = root.get_start(Int(4))
	t.Log(n)
	if n != root.pointers[1] {
		t.Error("wrong node from get_start")
	}
	if i != 0 {
		t.Error("wrong index from get_start")
	}
	i, n = root.get_start(Int(0))
	if n != root.pointers[0] {
		t.Error("wrong node from get_start")
	}
	if i != 0 {
		t.Error("wrong index from get_start")
	}
	i, n = root.get_start(Int(5))
	if n != root.pointers[1] {
		t.Error("wrong node from get_start")
	}
	if i != 0 {
		t.Error("wrong index from get_start")
	}
}

func Test_get_end(t *testing.T) {
	root := NewLeaf(3)
	root, err := root.put(Int(1), -1)
	if err != nil {
		t.Fatal(err)
	}
	root, err = root.put(Int(4), -1)
	if err != nil {
		t.Fatal(err)
	}
	root, err = root.put(Int(3), 1)
	if err != nil {
		t.Fatal(err)
	}
	root, err = root.put(Int(3), 2)
	if err != nil {
		t.Fatal(err)
	}
	root, err = root.put(Int(3), 3)
	if err != nil {
		t.Fatal(err)
	}
	root, err = root.put(Int(3), 4)
	if err != nil {
		t.Fatal(err)
	}
	root, err = root.put(Int(3), 5)
	if err != nil {
		t.Fatal(err)
	}
	t.Log(root)
	t.Log(root.pointers[0])
	t.Log(root.pointers[1])
	t.Log(root.pointers[2])
	i, n := root.get_start(Int(3))
	t.Log(n)
	if n != root.pointers[1] {
		t.Error("wrong node from get_start")
	}
	if i != 0 {
		t.Error("wrong index from get_start")
	}
	i, n = root.get_end(Int(3))
	t.Log(n)
	if n != root.pointers[1].getNext() {
		t.Error("wrong node from get_end")
	}
	if i != 1 {
		t.Error("wrong index from get_end")
	}
	i, n = root.get_end(Int(1))
	t.Log(n)
	if n != root.pointers[0] {
		t.Error("wrong node from get_end")
	}
	if i != 0 {
		t.Error("wrong index from get_end")
	}
	i, n = root.get_end(Int(4))
	t.Log(n)
	if n != root.pointers[2] {
		t.Error("wrong node from get_end")
	}
	if i != 0 {
		t.Error("wrong index from get_end")
	}
	i, n = root.get_end(Int(0))
	t.Log(n)
	if n != root.pointers[0] {
		t.Error("wrong node from get_end")
	}
	if i != 0 {
		t.Error("wrong index from get_end")
	}
	i, n = root.get_end(Int(5))
	t.Log(n)
	if n != root.pointers[2] {
		t.Error("wrong node from get_end")
	}
	if i != 0 {
		t.Error("wrong index from get_end")
	}
	i, n = root.get_end(Int(2))
	t.Log(n)
	if n != root.pointers[1] {
		t.Error("wrong node from get_end")
	}
	if i != 0 {
		t.Error("wrong index from get_end")
	}
}

func Test_put_no_root_split(t *testing.T) {
	a := NewLeaf(2)
	if err := a.put_kv(Int(1), 1); err != nil {
		t.Error(err)
	}
	p, err := a.put(Int(1), 2)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if !p.has(Int(1)) {
			t.Error("p didn't have the right keys", p)
		}
	}
	p, err = a.put(Int(1), 3)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if !p.has(Int(1)) {
			t.Error("p didn't have the right keys", p)
		}
		if p.getNext() == nil {
			t.Error("p.next should not be nil")
		}
		t.Log(p)
		t.Log(p.getNext())
	}
}

func Test_put_root_split(t *testing.T) {
	a := NewLeaf(2)
	p, err := a.put(Int(1), 1)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if !p.has(Int(1)) {
			t.Error("p didn't have the right keys", p)
		}
	}
	p, err = a.put(Int(3), 3)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if !p.has(Int(1)) || !p.has(Int(3)) {
			t.Error("p didn't have the right keys", p)
		}
	}
	p, err = a.put(Int(2), 2)
	if err != nil {
		t.Error(err)
	} else {
		if p == a {
			t.Errorf("p == a")
		}
		if !p.has(Int(1)) || !p.has(Int(3)) {
			t.Error("p didn't have the right keys", p)
		}
		if len(p.pointers) != 2 {
			t.Error("p didn't have right number of pointers", p)
		}
		if !p.pointers[0].has(Int(1)) || !p.pointers[0].has(Int(2)) {
			t.Error("p.pointers[0] didn't have the right keys", p.pointers[0])
		}
		if !p.pointers[1].has(Int(3)) {
			t.Error("p.pointers[1] didn't have the right keys", p.pointers[1])
		}
		t.Log(p)
		t.Log(p.pointers[0])
		t.Log(p.pointers[1])
	}
}

func Test_internal_insert_no_split(t *testing.T) {
	a := NewInternal(3)
	leaf := NewLeaf(1)
	if err := leaf.put_kv(Int(1), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(1), leaf); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(5), nil); err != nil {
		t.Error(err)
	}
	p, q, err := a.internal_insert(Int(2), nil)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if q != nil {
			t.Errorf("q != nil")
		}
		if !p.has(Int(1)) || !p.has(Int(2)) || !p.has(Int(5)) {
			t.Error("p didn't have the right keys", p)
		}
	}
}

func Test_internal_insert_split_less(t *testing.T) {
	a := NewInternal(3)
	leaf := NewLeaf(1)
	if err := leaf.put_kv(Int(1), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(1), leaf); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(3), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(5), nil); err != nil {
		t.Error(err)
	}
	p, q, err := a.internal_insert(Int(2), nil)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if q == nil {
			t.Errorf("q == nil")
		}
		if !p.has(Int(1)) || !p.has(Int(2)) {
			t.Error("p didn't have the right keys", p)
		}
		if !q.has(Int(3)) || !q.has(Int(5)) {
			t.Error("q didn't have the right keys", q)
		}
	}
}

func Test_internal_split_less(t *testing.T) {
	a := NewInternal(3)
	if err := a.put_kp(Int(1), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(3), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(5), nil); err != nil {
		t.Error(err)
	}
	p, q, err := a.internal_split(Int(2), nil)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if q == nil {
			t.Errorf("q == nil")
		}
		if !p.has(Int(1)) || !p.has(Int(2)) {
			t.Error("p didn't have the right keys", p)
		}
		if !q.has(Int(3)) || !q.has(Int(5)) {
			t.Error("q didn't have the right keys", q)
		}
	}
}

func Test_internal_split_equal(t *testing.T) {
	a := NewInternal(3)
	if err := a.put_kp(Int(1), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(3), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(5), nil); err != nil {
		t.Error(err)
	}
	p, q, err := a.internal_split(Int(3), nil)
	if err == nil {
		t.Error("split succeeded should have failed", p, q)
	}
}

func Test_internal_split_greater(t *testing.T) {
	a := NewInternal(3)
	if err := a.put_kp(Int(1), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(3), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(5), nil); err != nil {
		t.Error(err)
	}
	p, q, err := a.internal_split(Int(4), nil)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if q == nil {
			t.Errorf("q == nil")
		}
		if !p.has(Int(1)) {
			t.Error("p didn't have the right keys", p)
		}
		if !q.has(Int(3)) || !q.has(Int(4)) || !q.has(Int(5)) {
			t.Error("q didn't have the right keys", q)
		}
	}
}

func Test_leaf_insert_no_split(t *testing.T) {
	a := NewLeaf(3)
	insert_linked_list_node(a, nil, nil)
	if err := a.put_kv(Int(1), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(3), 3); err != nil {
		t.Error(err)
	}
	p, q, err := a.leaf_insert(Int(2), 2)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if q != nil {
			t.Errorf("q != nil")
		}
		if !p.has(Int(1)) || !p.has(Int(2)) || !p.has(Int(3)) {
			t.Error("p didn't have the right keys", p)
		}
	}
}

// tests the defer to split logic
func Test_leaf_insert_split_less(t *testing.T) {
	a := NewLeaf(3)
	insert_linked_list_node(a, nil, nil)
	if err := a.put_kv(Int(1), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(3), 3); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(5), 5); err != nil {
		t.Error(err)
	}
	p, q, err := a.leaf_insert(Int(2), 2)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if q == nil {
			t.Errorf("q == nil")
		}
		if !p.has(Int(1)) || !p.has(Int(2)) {
			t.Error("p didn't have the right keys", p)
		}
		if !q.has(Int(3)) || !q.has(Int(5)) {
			t.Error("q didn't have the right keys", q)
		}
	}
}

func Test_leaf_split_less(t *testing.T) {
	a := NewLeaf(3)
	insert_linked_list_node(a, nil, nil)
	if err := a.put_kv(Int(1), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(3), 3); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(5), 5); err != nil {
		t.Error(err)
	}
	p, q, err := a.leaf_split(Int(2), 2)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if q == nil {
			t.Errorf("q == nil")
		}
		if !p.has(Int(1)) || !p.has(Int(2)) {
			t.Error("p didn't have the right keys", p)
		}
		if !q.has(Int(3)) || !q.has(Int(5)) {
			t.Error("q didn't have the right keys", q)
		}
	}
}

func Test_leaf_split_equal(t *testing.T) {
	a := NewLeaf(3)
	insert_linked_list_node(a, nil, nil)
	if err := a.put_kv(Int(1), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(3), 3); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(5), 5); err != nil {
		t.Error(err)
	}
	p, q, err := a.leaf_split(Int(3), 2)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if q == nil {
			t.Errorf("q == nil")
		}
		if !p.has(Int(1)) {
			t.Error("p didn't have the right keys", p)
		}
		if !q.has(Int(3)) || q.count(Int(3)) != 2 || !q.has(Int(5)) {
			t.Error("q didn't have the right keys", q, q.count(Int(3)))
		}
	}
}

func Test_leaf_split_greater(t *testing.T) {
	a := NewLeaf(3)
	insert_linked_list_node(a, nil, nil)
	if err := a.put_kv(Int(1), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(3), 3); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(5), 5); err != nil {
		t.Error(err)
	}
	p, q, err := a.leaf_split(Int(4), 2)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if q == nil {
			t.Errorf("q == nil")
		}
		if !p.has(Int(1)) {
			t.Error("p didn't have the right keys", p)
		}
		if !q.has(Int(3)) || !q.has(Int(4)) || !q.has(Int(5)) {
			t.Error("q didn't have the right keys", q)
		}
	}
}

// tests the defer logic
func Test_pure_leaf_insert_split_less(t *testing.T) {
	a := NewLeaf(2)
	insert_linked_list_node(a, nil, nil)
	b := NewLeaf(2)
	insert_linked_list_node(b, a, nil)
	c := NewLeaf(2)
	insert_linked_list_node(c, b, nil)
	d := NewLeaf(2)
	insert_linked_list_node(d, c, nil)
	if err := a.put_kv(Int(3), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(3), 2); err != nil {
		t.Error(err)
	}
	if err := b.put_kv(Int(3), 3); err != nil {
		t.Error(err)
	}
	if err := b.put_kv(Int(3), 4); err != nil {
		t.Error(err)
	}
	if err := c.put_kv(Int(3), 5); err != nil {
		t.Error(err)
	}
	if err := c.put_kv(Int(3), 6); err != nil {
		t.Error(err)
	}
	if err := d.put_kv(Int(4), 6); err != nil {
		t.Error(err)
	}
	p, q, err := a.leaf_insert(Int(2), 1)
	if err != nil {
		t.Error(err)
	} else {
		if q != a {
			t.Errorf("q != a")
		}
		if p == nil || len(p.keys) != 1 || !p.keys[0].Equals(Int(2)) {
			t.Errorf("p did not contain the right key")
		}
		if p.getPrev() != nil {
			t.Errorf("expected p.prev == nil")
		}
		if p.getNext() != a {
			t.Errorf("expected p.next == a")
		}
		if a.getPrev() != p {
			t.Errorf("expected a.prev == p")
		}
		if a.getNext() != b {
			t.Errorf("expected a.next == b")
		}
		if b.getPrev() != a {
			t.Errorf("expected b.prev == a")
		}
		if b.getNext() != c {
			t.Errorf("expected b.next == c")
		}
		if c.getPrev() != b {
			t.Errorf("expected c.prev == b")
		}
		if c.getNext() != d {
			t.Errorf("expected c.next == d")
		}
		if d.getPrev() != c {
			t.Errorf("expected d.prev == c")
		}
		if d.getNext() != nil {
			t.Errorf("expected d.next == nil")
		}
	}
}

func Test_pure_leaf_split_less(t *testing.T) {
	a := NewLeaf(2)
	insert_linked_list_node(a, nil, nil)
	b := NewLeaf(2)
	insert_linked_list_node(b, a, nil)
	c := NewLeaf(2)
	insert_linked_list_node(c, b, nil)
	d := NewLeaf(2)
	insert_linked_list_node(d, c, nil)
	if err := a.put_kv(Int(3), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(3), 2); err != nil {
		t.Error(err)
	}
	if err := b.put_kv(Int(3), 3); err != nil {
		t.Error(err)
	}
	if err := b.put_kv(Int(3), 4); err != nil {
		t.Error(err)
	}
	if err := c.put_kv(Int(3), 5); err != nil {
		t.Error(err)
	}
	if err := c.put_kv(Int(3), 6); err != nil {
		t.Error(err)
	}
	if err := d.put_kv(Int(4), 6); err != nil {
		t.Error(err)
	}
	p, q, err := a.pure_leaf_split(Int(2), 1)
	if err != nil {
		t.Error(err)
	} else {
		if q != a {
			t.Errorf("q != a")
		}
		if p == nil || len(p.keys) != 1 || !p.keys[0].Equals(Int(2)) {
			t.Errorf("p did not contain the right key")
		}
		if p.getPrev() != nil {
			t.Errorf("expected p.prev == nil")
		}
		if p.getNext() != a {
			t.Errorf("expected p.next == a")
		}
		if a.getPrev() != p {
			t.Errorf("expected a.prev == p")
		}
		if a.getNext() != b {
			t.Errorf("expected a.next == b")
		}
		if b.getPrev() != a {
			t.Errorf("expected b.prev == a")
		}
		if b.getNext() != c {
			t.Errorf("expected b.next == c")
		}
		if c.getPrev() != b {
			t.Errorf("expected c.prev == b")
		}
		if c.getNext() != d {
			t.Errorf("expected c.next == d")
		}
		if d.getPrev() != c {
			t.Errorf("expected d.prev == c")
		}
		if d.getNext() != nil {
			t.Errorf("expected d.next == nil")
		}
	}
}

func Test_pure_leaf_split_equal(t *testing.T) {
	a := NewLeaf(2)
	insert_linked_list_node(a, nil, nil)
	b := NewLeaf(2)
	insert_linked_list_node(b, a, nil)
	c := NewLeaf(2)
	insert_linked_list_node(c, b, nil)
	d := NewLeaf(2)
	insert_linked_list_node(d, c, nil)
	if err := a.put_kv(Int(3), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(3), 2); err != nil {
		t.Error(err)
	}
	if err := b.put_kv(Int(3), 3); err != nil {
		t.Error(err)
	}
	if err := b.put_kv(Int(3), 4); err != nil {
		t.Error(err)
	}
	if err := c.put_kv(Int(3), 5); err != nil {
		t.Error(err)
	}
	if err := d.put_kv(Int(4), 6); err != nil {
		t.Error(err)
	}
	p, q, err := a.pure_leaf_split(Int(3), 1)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if q != nil {
			t.Errorf("q != nil")
		}
		if a.getPrev() != nil {
			t.Errorf("expected a.prev == nil")
		}
		if a.getNext() != b {
			t.Errorf("expected a.next == b")
		}
		if b.getPrev() != a {
			t.Errorf("expected b.prev == a")
		}
		if b.getNext() != c {
			t.Errorf("expected b.next == c")
		}
		if c.getPrev() != b {
			t.Errorf("expected c.prev == b")
		}
		if c.getNext() != d {
			t.Errorf("expected c.next == d")
		}
		if d.getPrev() != c {
			t.Errorf("expected d.prev == c")
		}
		if d.getNext() != nil {
			t.Errorf("expected d.next == nil")
		}
	}
}

func Test_pure_leaf_split_greater(t *testing.T) {
	a := NewLeaf(2)
	insert_linked_list_node(a, nil, nil)
	b := NewLeaf(2)
	insert_linked_list_node(b, a, nil)
	c := NewLeaf(2)
	insert_linked_list_node(c, b, nil)
	d := NewLeaf(2)
	insert_linked_list_node(d, c, nil)
	if err := a.put_kv(Int(3), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(3), 2); err != nil {
		t.Error(err)
	}
	if err := b.put_kv(Int(3), 3); err != nil {
		t.Error(err)
	}
	if err := b.put_kv(Int(3), 4); err != nil {
		t.Error(err)
	}
	if err := c.put_kv(Int(3), 5); err != nil {
		t.Error(err)
	}
	if err := d.put_kv(Int(5), 6); err != nil {
		t.Error(err)
	}
	p, q, err := a.pure_leaf_split(Int(4), 1)
	if err != nil {
		t.Error(err)
	} else {
		if p != a {
			t.Errorf("p != a")
		}
		if q == nil || len(q.keys) != 1 || !q.keys[0].Equals(Int(4)) {
			t.Errorf("q != nil")
		}
		if a.getPrev() != nil {
			t.Errorf("expected a.prev == nil")
		}
		if a.getNext() != b {
			t.Errorf("expected a.next == b")
		}
		if b.getPrev() != a {
			t.Errorf("expected b.prev == a")
		}
		if b.getNext() != c {
			t.Errorf("expected b.next == c")
		}
		if c.getPrev() != b {
			t.Errorf("expected c.prev == b")
		}
		if c.getNext() != q {
			t.Errorf("expected c.next == q")
		}
		if q.getPrev() != c {
			t.Errorf("expected q.prev == c")
		}
		if q.getNext() != d {
			t.Errorf("expected q.next == d")
		}
		if d.getPrev() != q {
			t.Errorf("expected d.prev == q")
		}
		if d.getNext() != nil {
			t.Errorf("expected d.next == nil")
		}
	}
}

func Test_find_end_of_pure_run(t *testing.T) {
	a := NewLeaf(2)
	insert_linked_list_node(a, nil, nil)
	b := NewLeaf(2)
	insert_linked_list_node(b, a, nil)
	c := NewLeaf(2)
	insert_linked_list_node(c, b, nil)
	d := NewLeaf(2)
	insert_linked_list_node(d, c, nil)
	if err := a.put_kv(Int(3), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(3), 2); err != nil {
		t.Error(err)
	}
	if err := b.put_kv(Int(3), 3); err != nil {
		t.Error(err)
	}
	if err := b.put_kv(Int(3), 4); err != nil {
		t.Error(err)
	}
	if err := c.put_kv(Int(3), 5); err != nil {
		t.Error(err)
	}
	if err := c.put_kv(Int(3), 6); err != nil {
		t.Error(err)
	}
	if err := d.put_kv(Int(4), 6); err != nil {
		t.Error(err)
	}
	e := a.find_end_of_pure_run()
	if e != c {
		t.Errorf("end of run should have been block c %v %v", e, c)
	}
}

func Test_insert_linked_list_node(t *testing.T) {
	a := NewLeaf(1)
	insert_linked_list_node(a, nil, nil)
	b := NewLeaf(2)
	insert_linked_list_node(b, a, nil)
	c := NewLeaf(3)
	insert_linked_list_node(c, b, nil)
	d := NewLeaf(4)
	insert_linked_list_node(d, a, b)
	if a.getPrev() != nil {
		t.Errorf("expected a.prev == nil")
	}
	if a.getNext() != d {
		t.Errorf("expected a.next == d")
	}
	if d.getPrev() != a {
		t.Errorf("expected d.prev == a")
	}
	if d.getNext() != b {
		t.Errorf("expected d.next == b")
	}
	if b.getPrev() != d {
		t.Errorf("expected b.prev == d")
	}
	if b.getNext() != c {
		t.Errorf("expected b.next == c")
	}
	if c.getPrev() != b {
		t.Errorf("expected c.prev == b")
	}
	if c.getNext() != nil {
		t.Errorf("expected c.next == nil")
	}
}

func Test_remove_linked_list_node(t *testing.T) {
	a := NewLeaf(1)
	insert_linked_list_node(a, nil, nil)
	b := NewLeaf(2)
	insert_linked_list_node(b, a, nil)
	c := NewLeaf(3)
	insert_linked_list_node(c, b, nil)
	d := NewLeaf(4)
	insert_linked_list_node(d, a, b)
	if a.getPrev() != nil {
		t.Errorf("expected a.prev == nil")
	}
	if a.getNext() != d {
		t.Errorf("expected a.next == d")
	}
	if d.getPrev() != a {
		t.Errorf("expected d.prev == a")
	}
	if d.getNext() != b {
		t.Errorf("expected d.next == b")
	}
	if b.getPrev() != d {
		t.Errorf("expected b.prev == d")
	}
	if b.getNext() != c {
		t.Errorf("expected b.next == c")
	}
	if c.getPrev() != b {
		t.Errorf("expected c.prev == b")
	}
	if c.getNext() != nil {
		t.Errorf("expected c.next == nil")
	}
	remove_linked_list_node(d)
	if a.getPrev() != nil {
		t.Errorf("expected a.prev == nil")
	}
	if a.getNext() != b {
		t.Errorf("expected a.next == b")
	}
	if b.getPrev() != a {
		t.Errorf("expected b.prev == a")
	}
	if b.getNext() != c {
		t.Errorf("expected b.next == c")
	}
	if c.getPrev() != b {
		t.Errorf("expected c.prev == b")
	}
	if c.getNext() != nil {
		t.Errorf("expected c.next == nil")
	}
	remove_linked_list_node(a)
	if b.getPrev() != nil {
		t.Errorf("expected b.prev == nil")
	}
	if b.getNext() != c {
		t.Errorf("expected b.next == c")
	}
	if c.getPrev() != b {
		t.Errorf("expected c.prev == b")
	}
	if c.getNext() != nil {
		t.Errorf("expected c.next == nil")
	}
	remove_linked_list_node(c)
	if b.getPrev() != nil {
		t.Errorf("expected b.prev == nil")
	}
	if b.getNext() != nil {
		t.Errorf("expected b.next == nil")
	}
	remove_linked_list_node(b)
}

func Test_balance_leaf_nodes_with_dup(t *testing.T) {
	a := NewLeaf(3)
	b := NewLeaf(3)
	if err := a.put_kv(Int(1), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(1), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(2), 1); err != nil {
		t.Error(err)
	}
	balance_nodes(a, b)
	if !a.has(Int(1)) || a.count(Int(1)) != 2 || a.has(Int(2)) {
		t.Error("a had wrong items", a)
	}
	if !b.has(Int(2)) || b.count(Int(2)) != 1 || b.has(Int(1)) {
		t.Error("a had wrong items", b)
	}
}

func Test_balance_leaf_nodes(t *testing.T) {
	a := NewLeaf(7)
	b := NewLeaf(7)
	if err := a.put_kv(Int(1), 1); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(2), 2); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(3), 3); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(4), 4); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(5), 5); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(6), 6); err != nil {
		t.Error(err)
	}
	if err := a.put_kv(Int(7), 7); err != nil {
		t.Error(err)
	}
	balance_nodes(a, b)
	for i, k := range a.keys {
		if int(k.(Int)) != i+1 {
			t.Errorf("k != %d", i+1)
		}
	}
	for i, k := range b.keys {
		if int(k.(Int)) != 3+i+1 {
			t.Errorf("k != %d", 3+i+1)
		}
	}
	for i, v := range a.values {
		if v.(int) != i+1 {
			t.Errorf("k != %d", i+1)
		}
	}
	for i, v := range b.values {
		if v.(int) != 3+i+1 {
			t.Errorf("v != %d", 3+i+1)
		}
	}
	t.Log(a)
	t.Log(b)
}

func Test_balance_internal_nodes(t *testing.T) {
	a := NewInternal(6)
	b := NewInternal(6)
	if err := a.put_kp(Int(1), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(2), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(3), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(4), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(5), nil); err != nil {
		t.Error(err)
	}
	if err := a.put_kp(Int(6), nil); err != nil {
		t.Error(err)
	}
	balance_nodes(a, b)
	for i, k := range a.keys {
		if int(k.(Int)) != i+1 {
			t.Errorf("k != %d", i+1)
		}
	}
	for i, k := range b.keys {
		if int(k.(Int)) != 3+i+1 {
			t.Errorf("k != %d", 3+i+1)
		}
	}
	t.Log(a)
	t.Log(b)
}


// copied from

// ThreadSafeRand provides a thread safe version of math/rand.Rand using
// the same technique used in the math/rand package to make the top level
// functions thread safe.
func ThreadSafeRand(seed int64) *mrand.Rand {
	return mrand.New(&lockedSource{src: mrand.NewSource(seed).(mrand.Source64)})
}

// from: https://golang.org/src/math/rand/rand.go?s=8161:8175#L317
type lockedSource struct {
	lk  sync.Mutex
	src mrand.Source64
}

func (r *lockedSource) Int63() (n int64) {
	r.lk.Lock()
	n = r.src.Int63()
	r.lk.Unlock()
	return
}

func (r *lockedSource) Uint64() (n uint64) {
	r.lk.Lock()
	n = r.src.Uint64()
	r.lk.Unlock()
	return
}

func (r *lockedSource) Seed(seed int64) {
	r.lk.Lock()
	r.src.Seed(seed)
	r.lk.Unlock()
}

// seedPos implements Seed for a lockedSource without a race condiiton.
func (r *lockedSource) seedPos(seed int64, readPos *int8) {
	r.lk.Lock()
	r.src.Seed(seed)
	*readPos = 0
	r.lk.Unlock()
}

// read implements Read for a lockedSource without a race condition.
func (r *lockedSource) read(p []byte, readVal *int64, readPos *int8) (n int, err error) {
	r.lk.Lock()
	n, err = read(p, r.src.Int63, readVal, readPos)
	r.lk.Unlock()
	return
}

func read(p []byte, int63 func() int64, readVal *int64, readPos *int8) (n int, err error) {
	pos := *readPos
	val := *readVal
	for n = 0; n < len(p); n++ {
		if pos == 0 {
			val = int63()
			pos = 7
		}
		p[n] = byte(val)
		val >>= 8
		pos--
	}
	*readPos = pos
	*readVal = val
	return
}

// copied from https://sourcegraph.com/github.com/timtadh/data-structures@master/-/blob/test/support.go

type T testing.T

func (t *T) Assert(ok bool, msg string, vars ...interface{}) {
	if !ok {
		t.Log("\n" + string(debug.Stack()))
		t.Fatalf(msg, vars...)
	}
}

func (t *T) AssertNil(errors ...error) {
	any := false
	for _, err := range errors {
		if err != nil {
			any = true
			t.Log("\n" + string(debug.Stack()))
			t.Error(err)
		}
	}
	if any {
		t.Fatal("assert failed")
	}
}

func RandSlice(length int) []byte {
	slice := make([]byte, length)
	if _, err := crand.Read(slice); err != nil {
		panic(err)
	}
	return slice
}

func RandHex(length int) string {
	return hex.EncodeToString(RandSlice(length / 2))
}

func RandStr(length int) string {
	return string(RandSlice(length))
}