gedcom - types_test.go
1 package gedcom
2
3 import (
4 "errors"
5 "reflect"
6 "strings"
7 "testing"
8 )
9
10 type typeI interface {
11 parse(l *Line, o options) error
12 }
13
14 type typeTests[T any] struct {
15 Line Line
16 Options []Option
17 Result T
18 Error error
19 }
20
21 type pointerOf[T any] interface {
22 typeI
23 *T
24 }
25
26 func testType[T any, U pointerOf[T]](t *testing.T, tests []typeTests[T]) {
27 t.Helper()
28
29 for n, test := range tests {
30 var s U
31
32 s = reflect.New(reflect.TypeOf(s).Elem()).Interface().(U)
33
34 var opts options
35
36 for _, opt := range test.Options {
37 opt(&opts)
38 }
39
40 if err := s.parse(&test.Line, opts); !errors.Is(err, test.Error) {
41 t.Errorf("test %d: expecting error %v, got %v", n+1, test.Error, err)
42 } else if !reflect.DeepEqual(s, &test.Result) {
43 t.Errorf("test %d: expecting value %v, got %v", n+1, test.Result, *s)
44 }
45 }
46 }
47
48 func testSimpleType[T ~string, U pointerOf[T]](t *testing.T, min, max uint) {
49 name := reflect.TypeOf(new(T)).Elem().Name()
50
51 testType[T, U](t, []typeTests[T]{
52 { // 1
53 Line: l(""),
54 Error: ErrInvalidLength{name, "", min, max},
55 Result: "",
56 },
57 { // 2
58 Line: l(""),
59 Options: []Option{AllowWrongLength},
60 Result: "",
61 },
62 { // 3
63 Line: l(strings.Repeat("a", int(min)-1)),
64 Options: []Option{AllowWrongLength},
65 Result: T(strings.Repeat("a", int(min)-1)),
66 },
67 { // 4
68 Line: l(strings.Repeat("a", int(min))),
69 Result: T(strings.Repeat("a", int(min))),
70 },
71 { // 5
72 Line: l(strings.Repeat("a", int(max))),
73 Result: T(strings.Repeat("a", int(max))),
74 },
75 { // 6
76 Line: l(strings.Repeat("a", int(max)+1)),
77 Error: ErrInvalidLength{name, strings.Repeat("a", int(max)+1), min, max},
78 Result: "",
79 },
80 { // 7
81 Line: l(strings.Repeat("a", int(max)+1)),
82 Options: []Option{AllowWrongLength},
83 Result: T(strings.Repeat("a", int(max)+1)),
84 },
85 })
86 }
87
88 func l(v string, subs ...Line) Line {
89 return Line{
90 line: line{
91 value: v,
92 },
93 Sub: subs,
94 }
95 }
96
97 func lt(v, t string, subs ...Line) Line {
98 return Line{
99 line: line{
100 tag: t,
101 value: v,
102 },
103 Sub: subs,
104 }
105 }
106
107 func TestAddressCity(t *testing.T) {
108 testSimpleType[AddressCity](t, 1, 60)
109 }
110
111 func TestAddressCountry(t *testing.T) {
112 testSimpleType[AddressCountry](t, 1, 60)
113 }
114
115 func TestAddressLine(t *testing.T) {
116 testType(t, []typeTests[AddressLine]{
117 { // 1
118 Line: l(""),
119 Error: ErrInvalidLength{"AddressLine", "", 1, 60},
120 Result: AddressLine(""),
121 },
122 { // 2
123 Line: l(strings.Repeat("a", 61)),
124 Error: ErrInvalidLength{"AddressLine", strings.Repeat("a", 61), 1, 60},
125 Result: AddressLine(""),
126 },
127 { // 3
128 Line: l("a"),
129 Result: AddressLine("a"),
130 },
131 { // 4
132 Line: l("a", lt("", cCONT)),
133 Error: ErrContext{"AddressLine", cCONT, ErrInvalidLength{"AddressLine", "", 1, 60}},
134 Result: AddressLine("a\n"),
135 },
136 { // 5
137 Line: l("a", lt(strings.Repeat("b", 60), cCONT)),
138 Result: AddressLine("a\n" + strings.Repeat("b", 60)),
139 },
140 { // 6
141 Line: l("a", lt(strings.Repeat("b", 61), cCONT)),
142 Error: ErrContext{"AddressLine", cCONT, ErrInvalidLength{"AddressLine", strings.Repeat("b", 61), 1, 60}},
143 Result: AddressLine("a\n"),
144 },
145 { // 7
146 Line: l("a", lt(strings.Repeat("b", 61), cCONT)),
147 Options: []Option{AllowWrongLength},
148 Result: AddressLine("a\n" + strings.Repeat("b", 61)),
149 },
150 { // 8
151 Line: l("a", lt("b", cCONT)),
152 Result: AddressLine("a\nb"),
153 },
154 { // 9
155 Line: l("a", lt("b", cCONT), lt("c", cCONT)),
156 Result: AddressLine("a\nb\nc"),
157 },
158 { // 10
159 Line: l("a", lt("", cCONC)),
160 Error: ErrContext{"AddressLine", cCONC, ErrInvalidLength{"AddressLine", "", 1, 60}},
161 Result: AddressLine("a"),
162 },
163 { // 11
164 Line: l("a", lt(strings.Repeat("b", 61), cCONC)),
165 Error: ErrContext{"AddressLine", cCONC, ErrInvalidLength{"AddressLine", strings.Repeat("b", 61), 1, 60}},
166 Result: AddressLine("a"),
167 },
168 { // 12
169 Line: l("a", lt("b", cCONC)),
170 Result: AddressLine("ab"),
171 },
172 })
173 }
174
175 func TestAddressLine1(t *testing.T) {
176 testSimpleType[AddressLine1](t, 1, 60)
177 }
178
179 func TestAddressLine2(t *testing.T) {
180 testSimpleType[AddressLine2](t, 1, 60)
181 }
182
183 func TestAddressPostalCode(t *testing.T) {
184 testSimpleType[AddressPostalCode](t, 1, 10)
185 }
186
187 func TestAddressState(t *testing.T) {
188 testSimpleType[AddressState](t, 1, 60)
189 }
190
191 func TestAdoptedBy(t *testing.T) {
192 testType(t, []typeTests[AdoptedBy]{
193 { // 1
194 Line: l(""),
195 Error: ErrInvalidValue{"AdoptedBy", ""},
196 Result: "",
197 },
198 { // 2
199 Line: l(""),
200 Options: []Option{IgnoreInvalidValue},
201 Result: "",
202 },
203 { // 3
204 Line: l("a"),
205 Error: ErrInvalidValue{"AdoptedBy", "a"},
206 Result: "",
207 },
208 { // 4
209 Line: l("a"),
210 Options: []Option{IgnoreInvalidValue},
211 Result: "",
212 },
213 { // 5
214 Line: l("HUSB"),
215 Result: cHUSB,
216 },
217 { // 6
218 Line: l("Wife"),
219 Result: cWIFE,
220 },
221 { // 7
222 Line: l("both"),
223 Result: cBOTH,
224 },
225 })
226 }
227
228 func TestAgeAtEvent(t *testing.T) {
229 testSimpleType[AgeAtEvent](t, 1, 12)
230 }
231
232 func TestAncestralFileNumber(t *testing.T) {
233 testSimpleType[AncestralFileNumber](t, 1, 12)
234 }
235
236 func TestApprovedSystemID(t *testing.T) {
237 testSimpleType[ApprovedSystemID](t, 1, 20)
238 }
239
240 func TestAttributeType(t *testing.T) {
241 testType(t, []typeTests[AttributeType]{
242 { // 1
243 Line: l(""),
244 Error: ErrInvalidValue{"AttributeType", ""},
245 Result: "",
246 },
247 { // 2
248 Line: l(""),
249 Options: []Option{IgnoreInvalidValue},
250 Result: "",
251 },
252 { // 3
253 Line: l("a"),
254 Error: ErrInvalidValue{"AttributeType", "a"},
255 Result: "",
256 },
257 { // 4
258 Line: l("a"),
259 Options: []Option{IgnoreInvalidValue},
260 Result: "",
261 },
262 { // 5
263 Line: l("CAST"),
264 Result: cCAST,
265 },
266 { // 6
267 Line: l("educ"),
268 Result: cEDUC,
269 },
270 { // 7
271 Line: l("NatI"),
272 Result: cNATI,
273 },
274 { // 8
275 Line: l("oCcU"),
276 Result: cOCCU,
277 },
278 { // 9
279 Line: l("PrOp"),
280 Result: cPROP,
281 },
282 { // 10
283 Line: l("reLI"),
284 Result: cRELI,
285 },
286 { // 11
287 Line: l("REsi"),
288 Result: cRESI,
289 },
290 { // 12
291 Line: l("titl"),
292 Result: cTITL,
293 },
294 })
295 }
296
297 func TestAutomatedRecordID(t *testing.T) {
298 testSimpleType[AutomatedRecordID](t, 1, 12)
299 }
300
301 func TestCasteName(t *testing.T) {
302 testSimpleType[CasteName](t, 1, 90)
303 }
304
305 func TestCauseOfEvent(t *testing.T) {
306 testSimpleType[CauseOfEvent](t, 1, 90)
307 }
308
309 func TestCertaintyAssessment(t *testing.T) {
310 testType(t, []typeTests[CertaintyAssessment]{
311 { // 1
312 Line: l(""),
313 Error: ErrInvalidValue{"CertaintyAssessment", ""},
314 Result: 0,
315 },
316 { // 2
317 Line: l("CertaintyAssessment"),
318 Options: []Option{IgnoreInvalidValue},
319 Result: 0,
320 },
321 { // 3
322 Line: l("a"),
323 Error: ErrInvalidValue{"CertaintyAssessment", "a"},
324 Result: 0,
325 },
326 { // 4
327 Line: l("a"),
328 Options: []Option{IgnoreInvalidValue},
329 Result: 0,
330 },
331 { // 5
332 Line: l("0"),
333 Result: 0,
334 },
335 { // 6
336 Line: l("1"),
337 Result: 1,
338 },
339 { // 7
340 Line: l("2"),
341 Result: 2,
342 },
343 { // 8
344 Line: l("3"),
345 Result: 3,
346 },
347 { // 9
348 Line: l("4"),
349 Error: ErrInvalidValue{"CertaintyAssessment", "4"},
350 Result: 0,
351 },
352 })
353 }
354
355 func TestChangeDate(t *testing.T) {
356 testSimpleType[ChangeDate](t, 10, 11)
357 }
358
359 func TestCharacterSet(t *testing.T) {
360 testType(t, []typeTests[CharacterSet]{
361 { // 1
362 Line: l(""),
363 Error: ErrInvalidValue{"CharacterSet", ""},
364 Result: "",
365 },
366 { // 2
367 Line: l(""),
368 Options: []Option{IgnoreInvalidValue},
369 Result: "",
370 },
371 { // 3
372 Line: l("a"),
373 Error: ErrInvalidValue{"CharacterSet", "a"},
374 Result: "",
375 },
376 { // 4
377 Line: l("a"),
378 Options: []Option{IgnoreInvalidValue},
379 Result: "",
380 },
381 { // 5
382 Line: l("ANSEL"),
383 Result: cANSEL,
384 },
385 { // 6
386 Line: l("Unicode"),
387 Result: cUNICODE,
388 },
389 { // 7
390 Line: l("ascii"),
391 Result: cASCII,
392 },
393 })
394 }
395