/
ptree_test.go
116 lines (108 loc) · 3.29 KB
/
ptree_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
/*
symflux - Symetric Distributed Database Synchronization Library - A minor fork of conflux
Copyright (c) 2014 Pruthvirajsinh Rajendrasinh Chauhan
symflux is a slightly modified version of conflux(https://github.com/cmars/conflux) by Casey Marshall, copyright 2013(GNU GPL v3).
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
package recon
import (
"github.com/bmizerany/assert"
. "github.com/pruthvirajsinh/symflux"
"strings"
"testing"
)
func TestInsertNodesNoSplit(t *testing.T) {
tree := new(MemPrefixTree)
tree.Init()
tree.Insert(Zi(P_SKS, 100))
tree.Insert(Zi(P_SKS, 300))
tree.Insert(Zi(P_SKS, 500))
root, err := tree.Root()
assert.Equal(t, nil, err)
assert.Equal(t, 3, len(root.Elements()))
assert.T(t, root.IsLeaf())
tree.Remove(Zi(P_SKS, 100))
tree.Remove(Zi(P_SKS, 300))
tree.Remove(Zi(P_SKS, 500))
assert.Equal(t, 0, len(root.Elements()))
for _, sv := range root.SValues() {
assert.Equal(t, 0, sv.Cmp(Zi(P_SKS, 1)))
}
}
func TestJustOneKey(t *testing.T) {
tree := new(MemPrefixTree)
tree.Init()
tree.Insert(Zs(P_SKS, "224045810486609649306292620830306652473"))
expect := NewZSet()
for _, sv := range []string{
"306467079064992673198834899522272784866",
"306467079064992673198834899522272784865",
"306467079064992673198834899522272784867",
"306467079064992673198834899522272784864",
"306467079064992673198834899522272784868",
"306467079064992673198834899522272784863"} {
expect.Add(Zs(P_SKS, sv))
}
root, err := tree.Root()
assert.Equal(t, err, nil)
for _, sv := range root.SValues() {
assert.T(t, expect.Has(sv))
expect.Remove(sv)
}
assert.Equal(t, 0, len(expect.Items()))
}
func TestInsertNodeSplit(t *testing.T) {
tree := new(MemPrefixTree)
tree.Init()
// Add a bunch of nodes, enough to cause splits
for i := 0; i < tree.SplitThreshold()*4; i++ {
tree.Insert(Zi(P_SKS, i+65536))
}
// Remove a bunch of nodes, enough to cause joins
for i := 0; i < tree.SplitThreshold()*4; i++ {
tree.Remove(Zi(P_SKS, i+65536))
}
root, err := tree.Root()
assert.Equal(t, err, nil)
// Insert/Remove reversible after splitting & joining?
for _, sv := range root.SValues() {
assert.Equal(t, 0, sv.Cmp(Zi(P_SKS, 1)))
}
assert.Equal(t, 0, len(tree.root.children))
assert.Equal(t, 0, len(tree.root.elements))
}
// Test key consistency
func TestKeyMatch(t *testing.T) {
tree1 := new(MemPrefixTree)
tree1.Init()
for i := 1; i < 100; i++ {
tree1.Insert(Zi(P_SKS, 65537*i+i))
}
// Some extra samples
for i := 1; i < 50; i++ {
tree1.Insert(Zi(P_SKS, 68111*i))
}
tree2 := new(MemPrefixTree)
tree2.Init()
for i := 1; i < 100; i++ {
tree2.Insert(Zi(P_SKS, 65537*i))
}
// One extra sample
for i := 1; i < 20; i++ {
tree2.Insert(Zi(P_SKS, 70001*i))
}
for i := 1; i < 100; i++ {
zi := Zi(P_SKS, 65537*i)
bs := NewZpBitstring(zi)
node1, err := Find(tree1, zi)
assert.Equal(t, err, nil)
node2, err := Find(tree2, zi)
assert.Equal(t, err, nil)
t.Logf("node1=%v, node2=%v (%b) full=%v", node1.Key(), node2.Key(), zi.Int64(), bs)
// If keys are different, one must prefix the other.
assert.T(t, strings.HasPrefix(node1.Key().String(), node2.Key().String()) ||
strings.HasPrefix(node2.Key().String(), node1.Key().String()))
}
}