1
2
3 package mxj
4
5 import (
6
7 "fmt"
8
9 "testing"
10 )
11
12 func TestKVHeader(t *testing.T) {
13 fmt.Println("\n---------------- keyvalues_test.go ...")
14 }
15
16 var doc1 = []byte(`
17 <doc>
18 <books>
19 <book seq="1">
20 <author>William T. Gaddis</author>
21 <title>The Recognitions</title>
22 <review>One of the great seminal American novels of the 20th century.</review>
23 </book>
24 <book seq="2">
25 <author>Austin Tappan Wright</author>
26 <title>Islandia</title>
27 <review>An example of earlier 20th century American utopian fiction.</review>
28 </book>
29 <book seq="3">
30 <author>John Hawkes</author>
31 <title>The Beetle Leg</title>
32 <review>A lyrical novel about the construction of Ft. Peck Dam in Montana.</review>
33 </book>
34 <book seq="4">
35 <author>
36 <first_name>T.E.</first_name>
37 <last_name>Porter</last_name>
38 </author>
39 <title>King's Day</title>
40 <review>A magical novella.</review>
41 </book>
42 </books>
43 </doc>
44 `)
45
46 var doc2 = []byte(`
47 <doc>
48 <books>
49 <book seq="1">
50 <author>William T. Gaddis</author>
51 <title>The Recognitions</title>
52 <review>One of the great seminal American novels of the 20th century.</review>
53 </book>
54 </books>
55 <book>Something else.</book>
56 </doc>
57 `)
58
59
60 func TestPathsForKey(t *testing.T) {
61 fmt.Println("PathsForKey, doc1 ...")
62 m, merr := NewMapXml(doc1)
63 if merr != nil {
64 t.Fatal("merr:", merr.Error())
65 }
66 fmt.Println("PathsForKey, doc1#author")
67 ss := m.PathsForKey("author")
68 fmt.Println("... ss:", ss)
69
70 fmt.Println("PathsForKey, doc1#books")
71 ss = m.PathsForKey("books")
72 fmt.Println("... ss:", ss)
73
74 fmt.Println("PathsForKey, doc2 ...")
75 m, merr = NewMapXml(doc2)
76 if merr != nil {
77 t.Fatal("merr:", merr.Error())
78 }
79 fmt.Println("PathForKey, doc2#book")
80 ss = m.PathsForKey("book")
81 fmt.Println("... ss:", ss)
82
83 fmt.Println("PathForKeyShortest, doc2#book")
84 s := m.PathForKeyShortest("book")
85 fmt.Println("... s :", s)
86 }
87
88 func TestValuesForKey(t *testing.T) {
89 fmt.Println("ValuesForKey ...")
90 m, merr := NewMapXml(doc1)
91 if merr != nil {
92 t.Fatal("merr:", merr.Error())
93 }
94 fmt.Println("ValuesForKey, doc1#author")
95 ss, sserr := m.ValuesForKey("author")
96 if sserr != nil {
97 t.Fatal("sserr:", sserr.Error())
98 }
99 for _, v := range ss {
100 fmt.Println("... ss.v:", v)
101 }
102
103 fmt.Println("ValuesForKey, doc1#book")
104 ss, sserr = m.ValuesForKey("book")
105 if sserr != nil {
106 t.Fatal("sserr:", sserr.Error())
107 }
108 for _, v := range ss {
109 fmt.Println("... ss.v:", v)
110 }
111
112 fmt.Println("ValuesForKey, doc1#book,-seq:3")
113 ss, sserr = m.ValuesForKey("book", "-seq:3")
114 if sserr != nil {
115 t.Fatal("sserr:", sserr.Error())
116 }
117 for _, v := range ss {
118 fmt.Println("... ss.v:", v)
119 }
120
121 fmt.Println("ValuesForKey, doc1#book, author:William T. Gaddis")
122 ss, sserr = m.ValuesForKey("book", "author:William T. Gaddis")
123 if sserr != nil {
124 t.Fatal("sserr:", sserr.Error())
125 }
126 for _, v := range ss {
127 fmt.Println("... ss.v:", v)
128 }
129
130 fmt.Println("ValuesForKey, doc1#author, -seq:1")
131 ss, sserr = m.ValuesForKey("author", "-seq:1")
132 if sserr != nil {
133 t.Fatal("sserr:", sserr.Error())
134 }
135 for _, v := range ss {
136 fmt.Println("... ss.v:", v)
137 }
138 }
139
140 func TestValuesForPath(t *testing.T) {
141 fmt.Println("ValuesForPath ...")
142 m, merr := NewMapXml(doc1)
143 if merr != nil {
144 t.Fatal("merr:", merr.Error())
145 }
146 fmt.Println("ValuesForPath, doc.books.book.author")
147 ss, sserr := m.ValuesForPath("doc.books.book.author")
148 if sserr != nil {
149 t.Fatal("sserr:", sserr.Error())
150 }
151 for _, v := range ss {
152 fmt.Println("... ss.v:", v)
153 }
154
155 fmt.Println("ValuesForPath, doc.books.book")
156 ss, sserr = m.ValuesForPath("doc.books.book")
157 if sserr != nil {
158 t.Fatal("sserr:", sserr.Error())
159 }
160 for _, v := range ss {
161 fmt.Println("... ss.v:", v)
162 }
163
164 fmt.Println("ValuesForPath, doc.books.book -seq=3")
165 ss, sserr = m.ValuesForPath("doc.books.book", "-seq:3")
166 if sserr != nil {
167 t.Fatal("sserr:", sserr.Error())
168 }
169 for _, v := range ss {
170 fmt.Println("... ss.v:", v)
171 }
172
173 fmt.Println("ValuesForPath, doc.books.* -seq=3")
174 ss, sserr = m.ValuesForPath("doc.books.*", "-seq:3")
175 if sserr != nil {
176 t.Fatal("sserr:", sserr.Error())
177 }
178 for _, v := range ss {
179 fmt.Println("... ss.v:", v)
180 }
181
182 fmt.Println("ValuesForPath, doc.*.* -seq=3")
183 ss, sserr = m.ValuesForPath("doc.*.*", "-seq:3")
184 if sserr != nil {
185 t.Fatal("sserr:", sserr.Error())
186 }
187 for _, v := range ss {
188 fmt.Println("... ss.v:", v)
189 }
190 }
191
192 func TestValuesForNotKey(t *testing.T) {
193 fmt.Println("ValuesForNotKey ...")
194 m, merr := NewMapXml(doc1)
195 if merr != nil {
196 t.Fatal("merr:", merr.Error())
197 }
198 fmt.Println("ValuesForPath, doc.books.book !author:William T. Gaddis")
199 ss, sserr := m.ValuesForPath("doc.books.book", "!author:William T. Gaddis")
200 if sserr != nil {
201 t.Fatal("sserr:", sserr.Error())
202 }
203 for _, v := range ss {
204 fmt.Println("... ss.v:", v)
205 }
206
207 fmt.Println("ValuesForPath, doc.books.book !author:*")
208 ss, sserr = m.ValuesForPath("doc.books.book", "!author:*")
209 if sserr != nil {
210 t.Fatal("sserr:", sserr.Error())
211 }
212 for _, v := range ss {
213 fmt.Println("... ss.v:", v)
214 }
215
216 fmt.Println("ValuesForPath, doc.books.book !unknown:*")
217 ss, sserr = m.ValuesForPath("doc.books.book", "!unknown:*")
218 if sserr != nil {
219 t.Fatal("sserr:", sserr.Error())
220 }
221 for _, v := range ss {
222 fmt.Println("... ss.v:", v)
223 }
224 }
225
226 func TestIAHeader(t *testing.T) {
227 fmt.Println("\n---------------- indexedarray_test.go ...")
228 }
229
230 var ak_data = []byte(`{ "section1":{"data" : [{"F1" : "F1 data","F2" : "F2 data"},{"F1" : "demo 123","F2" : "abc xyz"}]}}`)
231 var j_data = []byte(`{ "stuff":[ { "data":[ { "F":1 }, { "F":2 }, { "F":3 } ] }, { "data":[ 4, 5, 6 ] } ] }`)
232 var x_data = []byte(`
233 <doc>
234 <stuff>
235 <data seq="1.1">
236 <F>1</F>
237 </data>
238 <data seq="1.2">
239 <F>2</F>
240 </data>
241 <data seq="1.3">
242 <F>3</F>
243 </data>
244 </stuff>
245 <stuff>
246 <data seq="2.1">
247 <F>4</F>
248 </data>
249 <data seq="2.2">
250 <F>5</F>
251 </data>
252 <data seq="2.3">
253 <F>6</F>
254 </data>
255 </stuff>
256 </doc>`)
257
258 func TestValuesForIndexedArray(t *testing.T) {
259 j_main(t)
260 x_main(t)
261 ak_main(t)
262 }
263
264 func ak_main(t *testing.T) {
265 fmt.Println("\nak_data:", string(ak_data))
266 m, merr := NewMapJson(ak_data)
267 if merr != nil {
268 t.Fatal("merr:", merr.Error())
269 return
270 }
271 fmt.Println("m:", m)
272
273 v, verr := m.ValuesForPath("section1.data[0].F1")
274 if verr != nil {
275 t.Fatal("verr:", verr.Error())
276 }
277 fmt.Println("section1.data[0].F1:", v)
278 }
279
280 func j_main(t *testing.T) {
281 fmt.Println("j_data:", string(j_data))
282 m, merr := NewMapJson(j_data)
283 if merr != nil {
284 t.Fatal("merr:", merr.Error())
285 return
286 }
287 fmt.Println("m:", m)
288
289 v, verr := m.ValuesForPath("stuff[0]")
290 if verr != nil {
291 t.Fatal("verr:", verr.Error())
292 }
293 fmt.Println("stuff[0]:", v)
294
295 v, verr = m.ValuesForPath("stuff.data")
296 if verr != nil {
297 t.Fatal("verr:", verr.Error())
298 }
299 fmt.Println("stuff.data:", v)
300
301 v, verr = m.ValuesForPath("stuff[0].data")
302 if verr != nil {
303 t.Fatal("verr:", verr.Error())
304 }
305 fmt.Println("stuff[0].data:", v)
306
307 v, verr = m.ValuesForPath("stuff.data[0]")
308 if verr != nil {
309 t.Fatal("verr:", verr.Error())
310 }
311 fmt.Println("stuff.data[0]:", v)
312
313 v, verr = m.ValuesForPath("stuff.*[2]")
314 if verr != nil {
315 t.Fatal("verr:", verr.Error())
316 }
317 fmt.Println("stuff.*[2]:", v)
318
319 v, verr = m.ValuesForPath("stuff.data.F")
320 if verr != nil {
321 t.Fatal("verr:", verr.Error())
322 }
323 fmt.Println("stuff.data.F:", v)
324
325 v, verr = m.ValuesForPath("*.*.F")
326 if verr != nil {
327 t.Fatal("verr:", verr.Error())
328 }
329 fmt.Println("*.*.F:", v)
330
331 v, verr = m.ValuesForPath("stuff.data[0].F")
332 if verr != nil {
333 t.Fatal("verr:", verr.Error())
334 }
335 fmt.Println("stuff.data[0].F:", v)
336
337 v, verr = m.ValuesForPath("stuff.data[1].F")
338 if verr != nil {
339 t.Fatal("verr:", verr.Error())
340 }
341 fmt.Println("stuff.data[1].F:", v)
342
343 v, verr = m.ValuesForPath("stuff[0].data[2]")
344 if verr != nil {
345 t.Fatal("verr:", verr.Error())
346 }
347 fmt.Println("stuff[0].data[2]:", v)
348
349 v, verr = m.ValuesForPath("stuff[1].data[1]")
350 if verr != nil {
351 t.Fatal("verr:", verr.Error())
352 }
353 fmt.Println("stuff[1].data[1]:", v)
354
355 v, verr = m.ValuesForPath("stuff[1].data[1].F")
356 if verr != nil {
357 t.Fatal("verr:", verr.Error())
358 }
359 fmt.Println("stuff[1].data[1].F", v)
360
361 v, verr = m.ValuesForPath("stuff[1].data.F")
362 if verr != nil {
363 t.Fatal("verr:", verr.Error())
364 }
365 fmt.Println("stuff[1].data.F:", v)
366 }
367
368 func x_main(t *testing.T) {
369 fmt.Println("\nx_data:", string(x_data))
370 m, merr := NewMapXml(x_data)
371 if merr != nil {
372 t.Fatal("merr:", merr.Error())
373 return
374 }
375 fmt.Println("m:", m)
376
377 v, verr := m.ValuesForPath("doc.stuff[0]")
378 if verr != nil {
379 t.Fatal("verr:", verr.Error())
380 }
381 fmt.Println("doc.stuff[0]:", v)
382
383 v, verr = m.ValuesForPath("doc.stuff.data[0]")
384 if verr != nil {
385 t.Fatal("verr:", verr.Error())
386 }
387 fmt.Println("doc.stuff.data[0]:", v)
388
389 v, verr = m.ValuesForPath("doc.stuff.data[0]", "-seq:2.1")
390 if verr != nil {
391 t.Fatal("verr:", verr.Error())
392 }
393 fmt.Println("doc.stuff.data[0] -seq:2.1:", v)
394
395 v, verr = m.ValuesForPath("doc.stuff.data[0].F")
396 if verr != nil {
397 t.Fatal("verr:", verr.Error())
398 }
399 fmt.Println("doc.stuff.data[0].F:", v)
400
401 v, verr = m.ValuesForPath("doc.stuff[0].data[2]")
402 if verr != nil {
403 t.Fatal("verr:", verr.Error())
404 }
405 fmt.Println("doc.stuff[0].data[2]:", v)
406
407 v, verr = m.ValuesForPath("doc.stuff[1].data[1].F")
408 if verr != nil {
409 t.Fatal("verr:", verr.Error())
410 }
411 fmt.Println("doc.stuff[1].data[1].F:", v)
412 }
413
414 func TestValueForPath(t *testing.T) {
415 m := map[string]interface{}{
416 "Div": map[string]interface{}{
417 "Colour": "blue",
418 },
419 }
420 mv := Map(m)
421
422 v, err := mv.ValueForPath("Div.Colour")
423 if err != nil {
424 t.Fatal(err)
425 }
426 if str, ok := v.(string); !ok || str != "blue" {
427 t.Fatal("wrong value")
428 }
429 }
430
431 func TestValueForPathString(t *testing.T) {
432 m := map[string]interface{}{
433 "Div": map[string]interface{}{
434 "Colour": "blue",
435 },
436 }
437 mv := Map(m)
438
439 str, err := mv.ValueForPathString("Div.Colour")
440 if err != nil {
441 t.Fatal(err)
442 }
443 if str != "blue" {
444 t.Fatal("wrong value")
445 }
446 }
447
448 func TestValueForPathError(t *testing.T) {
449 m := map[string]interface{}{
450 "Div": map[string]interface{}{
451 "Colour": "blue",
452 },
453 }
454 mv := Map(m)
455
456 _, err := mv.ValueForPath("Color")
457 if err != PathNotExistError {
458 t.Fatal("no PathNotExistError returned")
459 }
460 }
461
462 func TestValueForKey(t *testing.T) {
463 m := map[string]interface{}{
464 "Div": map[string]interface{}{
465 "Colour": "blue",
466 },
467 }
468 mv := Map(m)
469
470 v, err := mv.ValueForKey("Colour")
471 if err != nil {
472 t.Fatal(err)
473 }
474 if str, ok := v.(string); !ok || str != "blue" {
475 t.Fatal("wrong value")
476 }
477 }
478
479 func TestValueForKeyError(t *testing.T) {
480 m := map[string]interface{}{
481 "Div": map[string]interface{}{
482 "Colour": "blue",
483 },
484 }
485 mv := Map(m)
486
487 _, err := mv.ValueForKey("Color")
488 if err != KeyNotExistError {
489 t.Fatal("no KeyNotExistError returned")
490 }
491 }
492
493
View as plain text