1 package x2j
2
3 import (
4 "encoding/json"
5 "fmt"
6 "os"
7 "testing"
8 )
9
10 func TestX2j(t *testing.T) {
11 fmt.Println("\n================================ x2j_test.go ...")
12 fmt.Println("\n=================== TestX2j ...")
13 fi, fierr := os.Stat("x2j_test.xml")
14 if fierr != nil {
15 fmt.Println("fierr:",fierr.Error())
16 return
17 }
18 fh, fherr := os.Open("x2j_test.xml")
19 if fherr != nil {
20 fmt.Println("fherr:",fherr.Error())
21 return
22 }
23 defer fh.Close()
24 buf := make([]byte,fi.Size())
25 _, nerr := fh.Read(buf)
26 if nerr != nil {
27 fmt.Println("nerr:",nerr.Error())
28 return
29 }
30 doc := string(buf)
31 fmt.Println("\nXML doc:\n",doc)
32
33
34 mm, mmerr := DocToMap(doc,true)
35 if mmerr != nil {
36 println("mmerr:",mmerr.Error())
37 return
38 }
39 println("\nDocToMap(), recast==true:\n",WriteMap(mm))
40
41
42 s,serr := DocToJsonIndent(doc,true)
43 if serr != nil {
44 fmt.Println("serr:",serr.Error())
45 }
46 fmt.Println("\nDocToJsonIndent, recast==true:\n",s)
47 }
48
49 func TestGetValue(t *testing.T) {
50 fmt.Println("\n=================== TestGetValue ...")
51
52 doc := `<entry><vars><foo>bar</foo><foo2><hello>world</hello></foo2></vars></entry>`
53 fmt.Println("\nRead doc:",doc)
54 fmt.Println("Looking for value: entry.vars")
55 mm,mmerr := DocToMap(doc)
56 if mmerr != nil {
57 fmt.Println("merr:",mmerr.Error())
58 }
59 v,verr := MapValue(mm,"entry.vars",nil)
60 if verr != nil {
61 fmt.Println("verr:",verr.Error())
62 } else {
63 j, jerr := json.MarshalIndent(v,""," ")
64 if jerr != nil {
65 fmt.Println("jerr:",jerr.Error())
66 } else {
67 fmt.Println(string(j))
68 }
69 }
70 fmt.Println("Looking for value: entry.vars.foo2.hello")
71 v,verr = MapValue(mm,"entry.vars.foo2.hello",nil)
72 if verr != nil {
73 fmt.Println("verr:",verr.Error())
74 } else {
75 fmt.Println(v.(string))
76 }
77 fmt.Println("Looking with error in path: entry.var")
78 v,verr = MapValue(mm,"entry.var",nil)
79 fmt.Println("verr:",verr.Error())
80
81
82 fmt.Println("DocValue() for tag path entry.vars")
83 v,verr = DocValue(doc,"entry.vars")
84 if verr != nil {
85 fmt.Println("verr:",verr.Error())
86 }
87 j,_ := json.MarshalIndent(v,""," ")
88 fmt.Println(string(j))
89 }
90
91
92 func TestGetValueWithAttr(t *testing.T) {
93 fmt.Println("\n=================== TestGetValueWithAttr ...")
94 doc := `<entry><vars>
95 <foo item="1">bar</foo>
96 <foo item="2">
97 <hello item="3">world</hello>
98 <hello item="4">universe</hello>
99 </foo></vars></entry>`
100 fmt.Println("\nRead doc:",doc)
101 fmt.Println("Looking for value: entry.vars")
102 mm,mmerr := DocToMap(doc)
103 if mmerr != nil {
104 fmt.Println("merr:",mmerr.Error())
105 }
106 v,verr := MapValue(mm,"entry.vars",nil)
107 if verr != nil {
108 fmt.Println("verr:",verr.Error())
109 } else {
110 j, jerr := json.MarshalIndent(v,""," ")
111 if jerr != nil {
112 fmt.Println("jerr:",jerr.Error())
113 } else {
114 fmt.Println(string(j))
115 }
116 }
117
118 fmt.Println("\nMapValue(): Looking for value: entry.vars.foo item=2")
119 a,aerr := NewAttributeMap("item:2")
120 if aerr != nil {
121 fmt.Println("aerr:",aerr.Error())
122 }
123 v,verr = MapValue(mm,"entry.vars.foo",a)
124 if verr != nil {
125 fmt.Println("verr:",verr.Error())
126 } else {
127 j, jerr := json.MarshalIndent(v,""," ")
128 if jerr != nil {
129 fmt.Println("jerr:",jerr.Error())
130 } else {
131 fmt.Println(string(j))
132 }
133 }
134
135 fmt.Println("\nMapValue(): Looking for hello item:4")
136 a,_ = NewAttributeMap("item:4")
137 v,verr = MapValue(mm,"hello",a)
138 if verr != nil {
139 fmt.Println("verr:",verr.Error())
140 } else {
141 j, jerr := json.MarshalIndent(v,""," ")
142 if jerr != nil {
143 fmt.Println("jerr:",jerr.Error())
144 } else {
145 fmt.Println(string(j))
146 }
147 }
148
149 fmt.Println("\nDocValue(): Looking for entry.vars.foo.hello item:4")
150 v,verr = DocValue(doc,"entry.vars.foo.hello","item:4")
151 if verr != nil {
152 fmt.Println("verr:",verr.Error())
153 } else {
154 j, jerr := json.MarshalIndent(v,""," ")
155 if jerr != nil {
156 fmt.Println("jerr:",jerr.Error())
157 } else {
158 fmt.Println(string(j))
159 }
160 }
161
162 fmt.Println("\nDocValue(): Looking for empty nil")
163 v,verr = DocValue(doc,"")
164 if verr != nil {
165 fmt.Println("verr:",verr.Error())
166 } else {
167 j, jerr := json.MarshalIndent(v,""," ")
168 if jerr != nil {
169 fmt.Println("jerr:",jerr.Error())
170 } else {
171 fmt.Println(string(j))
172 }
173 }
174
175
176 fmt.Println("\ntesting recast switch...")
177 mm,mmerr = DocToMap(doc,true)
178 if mmerr != nil {
179 fmt.Println("merr:",mmerr.Error())
180 }
181 fmt.Println("MapValue(): Looking for value: entry.vars.foo item=2")
182 a,aerr = NewAttributeMap("item:2")
183 if aerr != nil {
184 fmt.Println("aerr:",aerr.Error())
185 }
186 v,verr = MapValue(mm,"entry.vars.foo",a,true)
187 if verr != nil {
188 fmt.Println("verr:",verr.Error())
189 } else {
190 j, jerr := json.MarshalIndent(v,""," ")
191 if jerr != nil {
192 fmt.Println("jerr:",jerr.Error())
193 } else {
194 fmt.Println(string(j))
195 }
196 }
197 }
198
199 func TestStuff_1(t *testing.T) {
200 fmt.Println("\n=================== TestStuff_1 ...")
201 doc := `<doc>
202 <tag item="1">val2</tag>
203 <tag item="2">val2</tag>
204 <tag item="2" instance="2">val3</tag>
205 </doc>`
206
207 fmt.Println(doc)
208 m,merr := DocToMap(doc)
209 if merr != nil {
210 fmt.Println("merr:",merr.Error())
211 } else {
212 fmt.Println(WriteMap(m))
213 }
214
215 fmt.Println("\nDocValue(): tag")
216 v,verr := DocValue(doc,"doc.tag")
217 if verr != nil {
218 fmt.Println("verr:",verr.Error())
219 } else {
220 j, jerr := json.MarshalIndent(v,""," ")
221 if jerr != nil {
222 fmt.Println("jerr:",jerr.Error())
223 } else {
224 fmt.Println(string(j))
225 }
226 }
227
228 fmt.Println("\nDocValue(): item:2 instance:2")
229 v,verr = DocValue(doc,"doc.tag","item:2","instance:2")
230 if verr != nil {
231 fmt.Println("verr:",verr.Error())
232 } else {
233 j, jerr := json.MarshalIndent(v,""," ")
234 if jerr != nil {
235 fmt.Println("jerr:",jerr.Error())
236 } else {
237 fmt.Println(string(j))
238 }
239 }
240 }
241
242 func TestStuff_2(t *testing.T) {
243 fmt.Println("\n=================== TestStuff_2 ...")
244 doc := `
245 <tag item="1">val2</tag>
246 <tag item="2">val2</tag>
247 <tag item="2" instance="2">val3</tag>`
248
249 fmt.Println(doc)
250 m,merr := DocToMap(doc)
251 if merr != nil {
252 fmt.Println("merr:",merr.Error())
253 } else {
254 fmt.Println(WriteMap(m))
255 }
256
257 fmt.Println("\nDocValue(): tag")
258 v,verr := DocValue(doc,"tag")
259 if verr != nil {
260 fmt.Println("verr:",verr.Error())
261 } else {
262 j, jerr := json.MarshalIndent(v,""," ")
263 if jerr != nil {
264 fmt.Println("jerr:",jerr.Error())
265 } else {
266 fmt.Println(string(j))
267 }
268 }
269
270 fmt.Println("\nDocValue(): item:2 instance:2")
271 v,verr = DocValue(doc,"tag","item:2","instance:2")
272 if verr != nil {
273 fmt.Println("verr:",verr.Error())
274 } else {
275 j, jerr := json.MarshalIndent(v,""," ")
276 if jerr != nil {
277 fmt.Println("jerr:",jerr.Error())
278 } else {
279 fmt.Println(string(j))
280 }
281 }
282 }
283
284 func procMap(m map[string]interface{}) bool {
285 fmt.Println("procMap:",WriteMap(m))
286 return true
287 }
288
289 func procMapToJson(m map[string]interface{}) bool {
290 b,_ := json.MarshalIndent(m,""," ")
291 fmt.Println("procMap:",string(b))
292 return true
293 }
294
295 func procErr(err error) bool {
296 fmt.Println("procError err:",err.Error())
297 return true
298 }
299
300 func TestBulk(t *testing.T) {
301 fmt.Println("\n=================== TestBulkBuffer ...")
302 fmt.Println("\nBulk Message Processing Tests")
303
304 if err := XmlMsgsFromFile("x2m_bulk.xml",procMapToJson,procErr); err != nil {
305 fmt.Println("XmlMsgsFromFile err:",err.Error())
306 }
307 }
308
309 func TestTagAndKey(t *testing.T) {
310 fmt.Println("\n=================== TestTagAndKey ...")
311 var doc string
312 doc = `<doc>
313 <sections>
314 <section>one</section>
315 <section>
316 <parts>
317 <part>two.one</part>
318 <part>two.two</part>
319 </parts>
320 </section>
321 </sections>
322 <partitions>
323 <parts>
324 <sections>
325 <section>one</section>
326 <section>two</section>
327 </sections>
328 </parts>
329 </partitions>
330 </doc>`
331
332 fmt.Println("\nTestTagAndKey()\n",doc)
333 v,verr := ValuesForTag(doc,"parts")
334 if verr != nil {
335 fmt.Println("verr:",verr.Error())
336 }
337 fmt.Println("tag: parts :: len:",len(v),"v:",v)
338 v, _ = ValuesForTag(doc,"not_a_tag")
339 if v == nil {
340 fmt.Println("no 'not_a_tag' tag")
341 } else {
342 fmt.Println("key: not_a_tag :: len:",len(v),"v:",v)
343 }
344
345 m,merr := DocToMap(doc)
346 if merr != nil {
347 fmt.Println("merr:",merr.Error())
348 }
349 v = ValuesForKey(m,"section")
350 fmt.Println("key: section :: len:",len(v),"v:",v)
351
352 v = ValuesForKey(m,"not_a_key")
353 if v == nil {
354 fmt.Println("no 'not_a_key' key")
355 } else {
356 fmt.Println("key: not_a-key :: len:",len(v),"v:",v)
357 }
358 }
359
360
361
391
View as plain text