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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
package eventstream
import (
"bufio"
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"path/filepath"
"testing"
)
type testCase struct {
Name string
Encoded []byte
Decoded decodedMessage
}
type testErrorCase struct {
Name string
Encoded []byte
Err string
}
type rawTestCase struct {
Name string
Encoded, Decoded []byte
}
func readRawTestCases(root, class string) (map[string]rawTestCase, error) {
encoded, err := readTests(filepath.Join(root, "encoded", class))
if err != nil {
return nil, err
}
decoded, err := readTests(filepath.Join(root, "decoded", class))
if err != nil {
return nil, err
}
if len(encoded) == 0 {
return nil, fmt.Errorf("expect encoded cases, found none")
}
if len(encoded) != len(decoded) {
return nil, fmt.Errorf("encoded and decoded sets different")
}
rawCases := map[string]rawTestCase{}
for name, encData := range encoded {
decData, ok := decoded[name]
if !ok {
return nil, fmt.Errorf("encoded %q case not found in decoded set", name)
}
rawCases[name] = rawTestCase{
Name: name,
Encoded: encData,
Decoded: decData,
}
}
return rawCases, nil
}
func readNegativeTests(root string) ([]testErrorCase, error) {
rawCases, err := readRawTestCases(root, "negative")
if err != nil {
return nil, err
}
cases := make([]testErrorCase, 0, len(rawCases))
for name, rawCase := range rawCases {
cases = append(cases, testErrorCase{
Name: name,
Encoded: rawCase.Encoded,
Err: string(rawCase.Decoded),
})
}
return cases, nil
}
func readPositiveTests(root string) ([]testCase, error) {
rawCases, err := readRawTestCases(root, "positive")
if err != nil {
return nil, err
}
cases := make([]testCase, 0, len(rawCases))
for name, rawCase := range rawCases {
var dec decodedMessage
if err := json.Unmarshal(rawCase.Decoded, &dec); err != nil {
return nil, fmt.Errorf("failed to decode %q, %v", name, err)
}
cases = append(cases, testCase{
Name: name,
Encoded: rawCase.Encoded,
Decoded: dec,
})
}
return cases, nil
}
func readTests(root string) (map[string][]byte, error) {
items, err := ioutil.ReadDir(root)
if err != nil {
return nil, fmt.Errorf("failed to read test suite %q dirs, %v", root, err)
}
cases := map[string][]byte{}
for _, item := range items {
if item.IsDir() {
continue
}
filename := filepath.Join(root, item.Name())
data, err := ioutil.ReadFile(filename)
if err != nil {
return nil, fmt.Errorf("failed to read test_data file %q, %v", filename, err)
}
cases[item.Name()] = data
}
return cases, nil
}
func compareLines(t *testing.T, a, b []byte) bool {
as := bufio.NewScanner(bytes.NewBuffer(a))
bs := bufio.NewScanner(bytes.NewBuffer(b))
var failed bool
for {
if ab, bb := as.Scan(), bs.Scan(); ab != bb {
t.Errorf("expect a & b to have same number of lines")
return false
} else if !ab {
break
}
if v1, v2 := as.Text(), bs.Text(); v1 != v2 {
t.Errorf("expect %q to be %q", v1, v2)
failed = true
}
}
return !failed
}
|
