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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
package types
import (
"bytes"
"fmt"
"io"
"reflect"
"testing"
)
func TestInclusionProofToASCII(t *testing.T) {
desc := "valid"
buf := bytes.NewBuffer(nil)
if err := validInclusionProof(t).ToASCII(buf); err != nil {
t.Fatalf("got error true but wanted false in test %q: %v", desc, err)
}
if got, want := string(buf.Bytes()), validInclusionProofASCII(t); got != want {
t.Errorf("got inclusion proof\n\t%v\nbut wanted\n\t%v\nin test %q\n", got, want, desc)
}
}
func TestInclusionProofFromASCII(t *testing.T) {
for _, table := range []struct {
desc string
serialized io.Reader
wantErr bool
want *InclusionProof
}{
{
desc: "invalid: not an inclusion proof (unexpected key-value pair)",
serialized: bytes.NewBuffer(append([]byte(validInclusionProofASCII(t)), []byte("tree_size=4")...)),
wantErr: true,
want: validInclusionProof(t), // to populate input to FromASCII
},
{
desc: "valid",
serialized: bytes.NewBuffer([]byte(validInclusionProofASCII(t))),
want: validInclusionProof(t),
},
} {
var proof InclusionProof
err := proof.FromASCII(table.serialized, table.want.TreeSize)
if got, want := err != nil, table.wantErr; got != want {
t.Errorf("got error %v but wanted %v in test %q: %v", got, want, table.desc, err)
}
if err != nil {
continue
}
if got, want := &proof, table.want; !reflect.DeepEqual(got, want) {
t.Errorf("got inclusion proof\n\t%v\nbut wanted\n\t%v\nin test %q\n", got, want, table.desc)
}
}
}
func TestConsistencyProofToASCII(t *testing.T) {
desc := "valid"
buf := bytes.NewBuffer(nil)
if err := validConsistencyProof(t).ToASCII(buf); err != nil {
t.Fatalf("got error true but wanted false in test %q: %v", desc, err)
}
if got, want := string(buf.Bytes()), validConsistencyProofASCII(t); got != want {
t.Errorf("got consistency proof\n\t%v\nbut wanted\n\t%v\nin test %q\n", got, want, desc)
}
}
func TestConsistencyProofFromASCII(t *testing.T) {
for _, table := range []struct {
desc string
serialized io.Reader
wantErr bool
want *ConsistencyProof
}{
{
desc: "invalid: not a consistency proof (unexpected key-value pair)",
serialized: bytes.NewBuffer(append([]byte(validConsistencyProofASCII(t)), []byte("start_size=1")...)),
wantErr: true,
want: validConsistencyProof(t), // to populate input to FromASCII
},
{
desc: "valid",
serialized: bytes.NewBuffer([]byte(validConsistencyProofASCII(t))),
want: validConsistencyProof(t),
},
} {
var proof ConsistencyProof
err := proof.FromASCII(table.serialized, table.want.OldSize, table.want.NewSize)
if got, want := err != nil, table.wantErr; got != want {
t.Errorf("got error %v but wanted %v in test %q: %v", got, want, table.desc, err)
}
if err != nil {
continue
}
if got, want := &proof, table.want; !reflect.DeepEqual(got, want) {
t.Errorf("got consistency proof\n\t%v\nbut wanted\n\t%v\nin test %q\n", got, want, table.desc)
}
}
}
func validInclusionProof(t *testing.T) *InclusionProof {
t.Helper()
return &InclusionProof{
LeafIndex: 1,
TreeSize: 4,
Path: []Hash{
Hash{},
*newHashBufferInc(t),
},
}
}
func validInclusionProofASCII(t *testing.T) string {
t.Helper()
return fmt.Sprintf("%s=%d\n%s=%x\n%s=%x\n",
"leaf_index", 1,
"inclusion_path", Hash{},
"inclusion_path", newHashBufferInc(t)[:],
)
}
func validConsistencyProof(t *testing.T) *ConsistencyProof {
t.Helper()
return &ConsistencyProof{
NewSize: 1,
OldSize: 4,
Path: []Hash{
Hash{},
*newHashBufferInc(t),
},
}
}
func validConsistencyProofASCII(t *testing.T) string {
t.Helper()
return fmt.Sprintf("%s=%x\n%s=%x\n",
"consistency_path", Hash{},
"consistency_path", newHashBufferInc(t)[:],
)
}
|
