ics - tokeniser_test.go
1 package ics
2
3 import (
4 "reflect"
5 "strings"
6 "testing"
7
8 "vimagination.zapto.org/parser"
9 )
10
11 func TestTokeniser(t *testing.T) {
12 tests := []struct {
13 Input string
14 Output parser.Phrase
15 Error error
16 }{
17 {
18 Input: "Name:Value\r\n",
19 Output: parser.Phrase{
20 Type: phraseContentLine,
21 Data: []parser.Token{
22 {
23 Type: tokenName,
24 Data: "Name",
25 },
26 {
27 Type: tokenValue,
28 Data: "Value",
29 },
30 },
31 },
32 },
33 {
34 Input: ":Value\r\n",
35 Error: ErrInvalidContentLine,
36 },
37 {
38 Input: "Name+:Value\r\n",
39 Error: ErrInvalidContentLineName,
40 },
41 {
42 Input: "Name:!Value HERE09 zø\r\n",
43 Output: parser.Phrase{
44 Type: phraseContentLine,
45 Data: []parser.Token{
46 {
47 Type: tokenName,
48 Data: "Name",
49 },
50 {
51 Type: tokenValue,
52 Data: "!Value HERE09 zø",
53 },
54 },
55 },
56 },
57 {
58 Input: "Name:\nValue\r\n",
59 Error: ErrInvalidContentLineValue,
60 },
61 {
62 Input: "Name:Va\x00lue\r\n",
63 Error: ErrInvalidContentLineValue,
64 },
65 {
66 Input: "Name:Value\x7f\r\n",
67 Error: ErrInvalidContentLineValue,
68 },
69 {
70 Input: "Name;param=paramValue:Value\r\n",
71 Output: parser.Phrase{
72 Type: phraseContentLine,
73 Data: []parser.Token{
74 {
75 Type: tokenName,
76 Data: "Name",
77 },
78 {
79 Type: tokenParamName,
80 Data: "param",
81 },
82 {
83 Type: tokenParamValue,
84 Data: "paramValue",
85 },
86 {
87 Type: tokenValue,
88 Data: "Value",
89 },
90 },
91 },
92 },
93 {
94 Input: "Name;param=\"paramValue\":Value\r\n",
95 Output: parser.Phrase{
96 Type: phraseContentLine,
97 Data: []parser.Token{
98 {
99 Type: tokenName,
100 Data: "Name",
101 },
102 {
103 Type: tokenParamName,
104 Data: "param",
105 },
106 {
107 Type: tokenParamQuotedValue,
108 Data: "paramValue",
109 },
110 {
111 Type: tokenValue,
112 Data: "Value",
113 },
114 },
115 },
116 },
117 {
118 Input: "Name;param=\":;,\":Value\r\n",
119 Output: parser.Phrase{
120 Type: phraseContentLine,
121 Data: []parser.Token{
122 {
123 Type: tokenName,
124 Data: "Name",
125 },
126 {
127 Type: tokenParamName,
128 Data: "param",
129 },
130 {
131 Type: tokenParamQuotedValue,
132 Data: ":;,",
133 },
134 {
135 Type: tokenValue,
136 Data: "Value",
137 },
138 },
139 },
140 },
141 {
142 Input: "Name;param=paramValue1,\"paramValue2\":Value\r\n",
143 Output: parser.Phrase{
144 Type: phraseContentLine,
145 Data: []parser.Token{
146 {
147 Type: tokenName,
148 Data: "Name",
149 },
150 {
151 Type: tokenParamName,
152 Data: "param",
153 },
154 {
155 Type: tokenParamValue,
156 Data: "paramValue1",
157 },
158 {
159 Type: tokenParamQuotedValue,
160 Data: "paramValue2",
161 },
162 {
163 Type: tokenValue,
164 Data: "Value",
165 },
166 },
167 },
168 },
169 {
170 Input: "Name;param1=\"ABC\";param2=DEF:Value\r\n",
171 Output: parser.Phrase{
172 Type: phraseContentLine,
173 Data: []parser.Token{
174 {
175 Type: tokenName,
176 Data: "Name",
177 },
178 {
179 Type: tokenParamName,
180 Data: "param1",
181 },
182 {
183 Type: tokenParamQuotedValue,
184 Data: "ABC",
185 },
186 {
187 Type: tokenParamName,
188 Data: "param2",
189 },
190 {
191 Type: tokenParamValue,
192 Data: "DEF",
193 },
194 {
195 Type: tokenValue,
196 Data: "Value",
197 },
198 },
199 },
200 },
201 }
202 for n, test := range tests {
203 p, err := newTokeniser(strings.NewReader(test.Input)).GetPhrase()
204 if !reflect.DeepEqual(err, test.Error) {
205 t.Errorf("test %d: expecting error %q, got %q", n+1, test.Error, err)
206 } else if test.Error == nil && !reflect.DeepEqual(p, test.Output) {
207 t.Errorf("test %d: expecting %v, got %v", n+1, test.Output, p)
208 }
209 }
210 }