1
2
3 """
4 Tests specific to the lxml.objectify API
5 """
6
7
8 import unittest, operator, sys
9
10 from common_imports import etree, StringIO, HelperTestCase, fileInTestDir
11 from common_imports import SillyFileLike, canonicalize, doctest
12
13 from lxml import objectify
14
15 PYTYPE_NAMESPACE = "http://codespeak.net/lxml/objectify/pytype"
16 XML_SCHEMA_NS = "http://www.w3.org/2001/XMLSchema"
17 XML_SCHEMA_INSTANCE_NS = "http://www.w3.org/2001/XMLSchema-instance"
18 XML_SCHEMA_INSTANCE_TYPE_ATTR = "{%s}type" % XML_SCHEMA_INSTANCE_NS
19 XML_SCHEMA_NIL_ATTR = "{%s}nil" % XML_SCHEMA_INSTANCE_NS
20 TREE_PYTYPE = "TREE"
21 DEFAULT_NSMAP = { "py" : PYTYPE_NAMESPACE,
22 "xsi" : XML_SCHEMA_INSTANCE_NS,
23 "xsd" : XML_SCHEMA_NS}
24
25 objectclass2xsitype = {
26
27 objectify.IntElement: ("int", "short", "byte", "unsignedShort",
28 "unsignedByte",),
29 objectify.LongElement: ("integer", "nonPositiveInteger", "negativeInteger",
30 "long", "nonNegativeInteger", "unsignedLong",
31 "unsignedInt", "positiveInteger",),
32 objectify.FloatElement: ("float", "double"),
33 objectify.BoolElement: ("boolean",),
34 objectify.StringElement: ("string", "normalizedString", "token", "language",
35 "Name", "NCName", "ID", "IDREF", "ENTITY",
36 "NMTOKEN", ),
37
38 }
39
40 xsitype2objclass = dict([ (v, k) for k in objectclass2xsitype
41 for v in objectclass2xsitype[k] ])
42
43 objectclass2pytype = {
44
45 objectify.IntElement: "int",
46 objectify.LongElement: "long",
47 objectify.FloatElement: "float",
48 objectify.BoolElement: "bool",
49 objectify.StringElement: "str",
50
51 }
52
53 pytype2objclass = dict([ (objectclass2pytype[k], k)
54 for k in objectclass2pytype])
55
56 xml_str = '''\
57 <obj:root xmlns:obj="objectified" xmlns:other="otherNS">
58 <obj:c1 a1="A1" a2="A2" other:a3="A3">
59 <obj:c2>0</obj:c2>
60 <obj:c2>1</obj:c2>
61 <obj:c2>2</obj:c2>
62 <other:c2>3</other:c2>
63 <c2>3</c2>
64 </obj:c1>
65 </obj:root>'''
66
68 """Test cases for lxml.objectify
69 """
70 etree = etree
71
74
88
102
103
107
112
119
121 nsmap = {"my": "someNS",
122 "myother": "someOtherNS",
123 "myxsd": XML_SCHEMA_NS}
124 elt = objectify.Element("test", nsmap=nsmap)
125 self.assert_(PYTYPE_NAMESPACE in elt.nsmap.values())
126 for prefix, ns in nsmap.items():
127 self.assert_(prefix in elt.nsmap)
128 self.assertEquals(nsmap[prefix], elt.nsmap[prefix])
129
134
140
148
159
163
168
175
177 nsmap = {"my": "someNS",
178 "myother": "someOtherNS",
179 "myxsd": XML_SCHEMA_NS,}
180 value = objectify.DataElement("test", nsmap=nsmap)
181 self.assert_(PYTYPE_NAMESPACE in value.nsmap.values())
182 for prefix, ns in nsmap.items():
183 self.assert_(prefix in value.nsmap)
184 self.assertEquals(nsmap[prefix], value.nsmap[prefix])
185
190
196
204
215
217
218 value = objectify.DataElement(23, _pytype="str", _xsi="foobar",
219 attrib={"gnu": "muh", "cat": "meeow",
220 "dog": "wuff"},
221 bird="tchilp", dog="grrr")
222 self.assertEquals(value.get("gnu"), "muh")
223 self.assertEquals(value.get("cat"), "meeow")
224 self.assertEquals(value.get("dog"), "grrr")
225 self.assertEquals(value.get("bird"), "tchilp")
226
238
240
241
242 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
243 attrib={"gnu": "muh", "cat": "meeow",
244 "dog": "wuff"},
245 bird="tchilp", dog="grrr")
246 value = objectify.DataElement(arg, _pytype="NoneType")
247 self.assert_(isinstance(value, objectify.NoneElement))
248 self.assertEquals(value.get(XML_SCHEMA_NIL_ATTR), "true")
249 self.assertEquals(value.text, None)
250 self.assertEquals(value.pyval, None)
251 for attr in arg.attrib:
252
253 self.assertEquals(value.get(attr), arg.get(attr))
254
256
257
258 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
259 attrib={"gnu": "muh", "cat": "meeow",
260 "dog": "wuff"},
261 bird="tchilp", dog="grrr")
262 value = objectify.DataElement(arg, _pytype="int")
263 self.assert_(isinstance(value, objectify.IntElement))
264 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int")
265 for attr in arg.attrib:
266 if not attr == objectify.PYTYPE_ATTRIBUTE:
267 self.assertEquals(value.get(attr), arg.get(attr))
268
270
271
272 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
273 attrib={"gnu": "muh", "cat": "meeow",
274 "dog": "wuff"},
275 bird="tchilp", dog="grrr")
276 value = objectify.DataElement(arg, _xsi="xsd:int")
277 self.assert_(isinstance(value, objectify.IntElement))
278 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int")
279 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int")
280 for attr in arg.attrib:
281 if not attr in [objectify.PYTYPE_ATTRIBUTE,
282 XML_SCHEMA_INSTANCE_TYPE_ATTR]:
283 self.assertEquals(value.get(attr), arg.get(attr))
284
286
287
288 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
289 attrib={"gnu": "muh", "cat": "meeow",
290 "dog": "wuff"},
291 bird="tchilp", dog="grrr")
292 value = objectify.DataElement(arg, _pytype="int", _xsi="xsd:int")
293 self.assert_(isinstance(value, objectify.IntElement))
294 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int")
295 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int")
296 for attr in arg.attrib:
297 if not attr in [objectify.PYTYPE_ATTRIBUTE,
298 XML_SCHEMA_INSTANCE_TYPE_ATTR]:
299 self.assertEquals(value.get(attr), arg.get(attr))
300
304
308
313
318
322
326
330
335
337 root = self.XML(xml_str)
338 self.assertEquals("0", getattr(root.c1, "{objectified}c2").text)
339 self.assertEquals("3", getattr(root.c1, "{otherNS}c2").text)
340
342 root = self.XML(xml_str)
343 self.assertRaises(AttributeError, getattr, root.c1, "NOT_THERE")
344 self.assertRaises(AttributeError, getattr, root.c1, "{unknownNS}c2")
345
352
354 root = self.XML(xml_str)
355 self.assertEquals(1, len(root.c1))
356
357 new_el = self.Element("test", myattr="5")
358 root.addattr("c1", new_el)
359 self.assertEquals(2, len(root.c1))
360 self.assertEquals(None, root.c1[0].get("myattr"))
361 self.assertEquals("5", root.c1[1].get("myattr"))
362
364 root = self.XML(xml_str)
365 self.assertEquals(1, len(root.c1))
366
367 new_el = self.Element("test")
368 self.etree.SubElement(new_el, "a", myattr="A")
369 self.etree.SubElement(new_el, "a", myattr="B")
370
371 root.addattr("c1", list(new_el.a))
372 self.assertEquals(3, len(root.c1))
373 self.assertEquals(None, root.c1[0].get("myattr"))
374 self.assertEquals("A", root.c1[1].get("myattr"))
375 self.assertEquals("B", root.c1[2].get("myattr"))
376
383
385 root = self.XML(xml_str)
386 self.assertEquals("0", root.c1.c2[0].text)
387 self.assertEquals("1", root.c1.c2[1].text)
388 self.assertEquals("2", root.c1.c2[2].text)
389 self.assertRaises(IndexError, operator.getitem, root.c1.c2, 3)
390
392 root = self.XML(xml_str)
393 self.assertEquals("0", root.c1.c2[0].text)
394 self.assertEquals("0", root.c1.c2[-3].text)
395 self.assertEquals("1", root.c1.c2[-2].text)
396 self.assertEquals("2", root.c1.c2[-1].text)
397 self.assertRaises(IndexError, operator.getitem, root.c1.c2, -4)
398
400 root = self.XML(xml_str)
401 self.assertEquals(1, len(root))
402 self.assertEquals(1, len(root.c1))
403 self.assertEquals(3, len(root.c1.c2))
404
406 root = self.XML(xml_str)
407 self.assertEquals([root],
408 list(iter(root)))
409 self.assertEquals([root.c1],
410 list(iter(root.c1)))
411 self.assertEquals([root.c1.c2[0], root.c1.c2[1], root.c1.c2[2]],
412 list(iter((root.c1.c2))))
413
419
429
434
439
440
441
443 root = self.XML("<root><c>c1</c><c>c2</c></root>")
444 self.assertEquals(["c1", "c2"],
445 [ c.text for c in root.c[:] ])
446
448 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>")
449 test_list = ["c1", "c2", "c3", "c4"]
450
451 self.assertEquals(test_list,
452 [ c.text for c in root.c[:] ])
453 self.assertEquals(test_list[1:2],
454 [ c.text for c in root.c[1:2] ])
455 self.assertEquals(test_list[-3:-1],
456 [ c.text for c in root.c[-3:-1] ])
457 self.assertEquals(test_list[-3:3],
458 [ c.text for c in root.c[-3:3] ])
459 self.assertEquals(test_list[-3000:3],
460 [ c.text for c in root.c[-3000:3] ])
461 self.assertEquals(test_list[-3:3000],
462 [ c.text for c in root.c[-3:3000] ])
463
465 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>")
466 test_list = ["c1", "c2", "c3", "c4"]
467
468 self.assertEquals(test_list,
469 [ c.text for c in root.c[:] ])
470 self.assertEquals(test_list[2:1:-1],
471 [ c.text for c in root.c[2:1:-1] ])
472 self.assertEquals(test_list[-1:-3:-1],
473 [ c.text for c in root.c[-1:-3:-1] ])
474 self.assertEquals(test_list[2:-3:-1],
475 [ c.text for c in root.c[2:-3:-1] ])
476 self.assertEquals(test_list[2:-3000:-1],
477 [ c.text for c in root.c[2:-3000:-1] ])
478
479
480
492
494 Element = self.Element
495 root = Element("root")
496 root.c = ["c1", "c2"]
497
498 c1 = root.c[0]
499 c2 = root.c[1]
500
501 self.assertEquals([c1,c2], list(root.c))
502 self.assertEquals(["c1", "c2"],
503 [ c.text for c in root.c ])
504
505 root2 = Element("root2")
506 root2.el = [ "test", "test" ]
507 self.assertEquals(["test", "test"],
508 [ el.text for el in root2.el ])
509
510 root.c = [ root2.el, root2.el ]
511 self.assertEquals(["test", "test"],
512 [ c.text for c in root.c ])
513 self.assertEquals(["test", "test"],
514 [ el.text for el in root2.el ])
515
516 root.c[:] = [ c1, c2, c2, c1 ]
517 self.assertEquals(["c1", "c2", "c2", "c1"],
518 [ c.text for c in root.c ])
519
521 Element = self.Element
522 root = Element("root")
523 l = ["c1", "c2", "c3", "c4"]
524 root.c = l
525
526 self.assertEquals(["c1", "c2", "c3", "c4"],
527 [ c.text for c in root.c ])
528 self.assertEquals(l,
529 [ c.text for c in root.c ])
530
531 new_slice = ["cA", "cB"]
532 l[1:2] = new_slice
533 root.c[1:2] = new_slice
534
535 self.assertEquals(["c1", "cA", "cB", "c3", "c4"], l)
536 self.assertEquals(["c1", "cA", "cB", "c3", "c4"],
537 [ c.text for c in root.c ])
538 self.assertEquals(l,
539 [ c.text for c in root.c ])
540
542 Element = self.Element
543 root = Element("root")
544 l = ["c1", "c2", "c3", "c4"]
545 root.c = l
546
547 self.assertEquals(["c1", "c2", "c3", "c4"],
548 [ c.text for c in root.c ])
549 self.assertEquals(l,
550 [ c.text for c in root.c ])
551
552 new_slice = ["cA", "cB"]
553 l[1:1] = new_slice
554 root.c[1:1] = new_slice
555
556 self.assertEquals(["c1", "cA", "cB", "c2", "c3", "c4"], l)
557 self.assertEquals(["c1", "cA", "cB", "c2", "c3", "c4"],
558 [ c.text for c in root.c ])
559 self.assertEquals(l,
560 [ c.text for c in root.c ])
561
563 Element = self.Element
564 root = Element("root")
565 l = ["c1", "c2", "c3", "c4"]
566 root.c = l
567
568 self.assertEquals(["c1", "c2", "c3", "c4"],
569 [ c.text for c in root.c ])
570 self.assertEquals(l,
571 [ c.text for c in root.c ])
572
573 new_slice = ["cA", "cB"]
574 l[-2:-2] = new_slice
575 root.c[-2:-2] = new_slice
576
577 self.assertEquals(["c1", "c2", "cA", "cB", "c3", "c4"], l)
578 self.assertEquals(["c1", "c2", "cA", "cB", "c3", "c4"],
579 [ c.text for c in root.c ])
580 self.assertEquals(l,
581 [ c.text for c in root.c ])
582
590
592 Element = self.Element
593 root = Element("root")
594 l = ["c1", "c2", "c3", "c4"]
595 root.c = l
596
597 self.assertEquals(["c1", "c2", "c3", "c4"],
598 [ c.text for c in root.c ])
599 self.assertEquals(l,
600 [ c.text for c in root.c ])
601
602 new_slice = ["cA", "cB", "cC"]
603 self.assertRaises(
604 ValueError, operator.setitem,
605 l, slice(1,2,-1), new_slice)
606 self.assertRaises(
607 ValueError, operator.setitem,
608 root.c, slice(1,2,-1), new_slice)
609
611 Element = self.Element
612 root = Element("root")
613 l = ["c1", "c2", "c3", "c4"]
614 root.c = l
615
616 self.assertEquals(["c1", "c2", "c3", "c4"],
617 [ c.text for c in root.c ])
618 self.assertEquals(l,
619 [ c.text for c in root.c ])
620
621 new_slice = ["cA", "cB"]
622 l[-1:1:-1] = new_slice
623 root.c[-1:1:-1] = new_slice
624
625 self.assertEquals(["c1", "c2", "cB", "cA"], l)
626 self.assertEquals(["c1", "c2", "cB", "cA"],
627 [ c.text for c in root.c ])
628 self.assertEquals(l,
629 [ c.text for c in root.c ])
630
632 Element = self.Element
633 root = Element("root")
634 l = ["c1", "c2", "c3", "c4"]
635 root.c = l
636
637 self.assertEquals(["c1", "c2", "c3", "c4"],
638 [ c.text for c in root.c ])
639 self.assertEquals(l,
640 [ c.text for c in root.c ])
641
642 new_slice = ["cA", "cB"]
643 l[-1:-4:-2] = new_slice
644 root.c[-1:-4:-2] = new_slice
645
646 self.assertEquals(["c1", "cB", "c3", "cA"], l)
647 self.assertEquals(["c1", "cB", "c3", "cA"],
648 [ c.text for c in root.c ])
649 self.assertEquals(l,
650 [ c.text for c in root.c ])
651
652
653
661
669
671
672 Element = self.Element
673 root = Element("root")
674
675 root["text"] = "TEST"
676 self.assertEquals(["TEST"],
677 [ c.text for c in root["text"] ])
678
679 root["tail"] = "TEST"
680 self.assertEquals(["TEST"],
681 [ c.text for c in root["tail"] ])
682
683 root["pyval"] = "TEST"
684 self.assertEquals(["TEST"],
685 [ c.text for c in root["pyval"] ])
686
687 root["tag"] = "TEST"
688 self.assertEquals(["TEST"],
689 [ c.text for c in root["tag"] ])
690
698
700 XML = self.XML
701 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')
702 self.assertEquals(2, len(root.findall(".//{X}b")))
703 self.assertEquals(3, len(root.findall(".//b")))
704 self.assertEquals(2, len(root.findall("b")))
705
713
727
733
745
754
761
768
775
777 Element = self.Element
778 SubElement = self.etree.SubElement
779 root = Element("{objectified}root")
780 root.s = "test"
781
782 self.assertEquals("test" * 5, root.s * 5)
783 self.assertEquals(5 * "test", 5 * root.s)
784
785 self.assertRaises(TypeError, operator.mul, root.s, "honk")
786 self.assertRaises(TypeError, operator.mul, "honk", root.s)
787
797
818
827
832
837
842
849
856
863
865 Element = self.Element
866 SubElement = self.etree.SubElement
867 root = Element("{objectified}root")
868 root.s = u"test"
869
870 self.assertEquals(u"test" * 5, root.s * 5)
871 self.assertEquals(5 * u"test", 5 * root.s)
872
873 self.assertRaises(TypeError, operator.mul, root.s, u"honk")
874 self.assertRaises(TypeError, operator.mul, u"honk", root.s)
875
885
890
895
900
907
912
919
924
926 for xsi, objclass in xsitype2objclass.iteritems():
927
928 pyval = 1
929 value = objectify.DataElement(pyval, _xsi=xsi)
930 self.assert_(isinstance(value, objclass),
931 "DataElement(%s, _xsi='%s') returns %s, expected %s"
932 % (pyval, xsi, type(value), objclass))
933
935 for xsi, objclass in xsitype2objclass.iteritems():
936
937 pyval = 1
938 value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi)
939 self.assert_(isinstance(value, objclass),
940 "DataElement(%s, _xsi='%s') returns %s, expected %s"
941 % (pyval, xsi, type(value), objclass))
942
948
950 for pytype, objclass in pytype2objclass.iteritems():
951
952 pyval = 1
953 value = objectify.DataElement(pyval, _pytype=pytype)
954 self.assert_(isinstance(value, objclass),
955 "DataElement(%s, _pytype='%s') returns %s, expected %s"
956 % (pyval, pytype, type(value), objclass))
957
959 pyval = 1
960 pytype = "NoneType"
961 objclass = objectify.NoneElement
962 value = objectify.DataElement(pyval, _pytype=pytype)
963 self.assert_(isinstance(value, objclass),
964 "DataElement(%s, _pytype='%s') returns %s, expected %s"
965 % (pyval, pytype, type(value), objclass))
966 self.assertEquals(value.text, None)
967 self.assertEquals(value.pyval, None)
968
970
971 pyval = 1
972 pytype = "none"
973 objclass = objectify.NoneElement
974 value = objectify.DataElement(pyval, _pytype=pytype)
975 self.assert_(isinstance(value, objclass),
976 "DataElement(%s, _pytype='%s') returns %s, expected %s"
977 % (pyval, pytype, type(value), objclass))
978 self.assertEquals(value.text, None)
979 self.assertEquals(value.pyval, None)
980
986 root = Element("{objectified}root")
987 root.myfloat = MyFloat(5.5)
988 self.assert_(isinstance(root.myfloat, objectify.FloatElement))
989 self.assertEquals(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None)
990
992 class MyFloat(float):
993 pass
994 value = objectify.DataElement(MyFloat(5.5))
995 self.assert_(isinstance(value, objectify.FloatElement))
996 self.assertEquals(value, 5.5)
997 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), None)
998
1000 XML = self.XML
1001 root = XML('''\
1002 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
1003 <b xsi:type="boolean">true</b>
1004 <b xsi:type="boolean">false</b>
1005 <b xsi:type="boolean">1</b>
1006 <b xsi:type="boolean">0</b>
1007
1008 <f xsi:type="float">5</f>
1009 <f xsi:type="double">5</f>
1010
1011 <s xsi:type="string">5</s>
1012 <s xsi:type="normalizedString">5</s>
1013 <s xsi:type="token">5</s>
1014 <s xsi:type="language">5</s>
1015 <s xsi:type="Name">5</s>
1016 <s xsi:type="NCName">5</s>
1017 <s xsi:type="ID">5</s>
1018 <s xsi:type="IDREF">5</s>
1019 <s xsi:type="ENTITY">5</s>
1020 <s xsi:type="NMTOKEN">5</s>
1021
1022 <l xsi:type="integer">5</l>
1023 <l xsi:type="nonPositiveInteger">5</l>
1024 <l xsi:type="negativeInteger">5</l>
1025 <l xsi:type="long">5</l>
1026 <l xsi:type="nonNegativeInteger">5</l>
1027 <l xsi:type="unsignedLong">5</l>
1028 <l xsi:type="unsignedInt">5</l>
1029 <l xsi:type="positiveInteger">5</l>
1030
1031 <i xsi:type="int">5</i>
1032 <i xsi:type="short">5</i>
1033 <i xsi:type="byte">5</i>
1034 <i xsi:type="unsignedShort">5</i>
1035 <i xsi:type="unsignedByte">5</i>
1036
1037 <n xsi:nil="true"/>
1038 </root>
1039 ''')
1040
1041 for b in root.b:
1042 self.assert_(isinstance(b, objectify.BoolElement))
1043 self.assertEquals(True, root.b[0])
1044 self.assertEquals(False, root.b[1])
1045 self.assertEquals(True, root.b[2])
1046 self.assertEquals(False, root.b[3])
1047
1048 for f in root.f:
1049 self.assert_(isinstance(f, objectify.FloatElement))
1050 self.assertEquals(5, f)
1051
1052 for s in root.s:
1053 self.assert_(isinstance(s, objectify.StringElement))
1054 self.assertEquals("5", s)
1055
1056 for l in root.l:
1057 self.assert_(isinstance(l, objectify.LongElement))
1058 self.assertEquals(5L, l)
1059
1060 for i in root.i:
1061 self.assert_(isinstance(i, objectify.IntElement))
1062 self.assertEquals(5, i)
1063
1064 self.assert_(isinstance(root.n, objectify.NoneElement))
1065 self.assertEquals(None, root.n)
1066
1068 XML = self.XML
1069 root = XML('''\
1070 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1071 xmlns:xsd="http://www.w3.org/2001/XMLSchema">
1072 <b xsi:type="xsd:boolean">true</b>
1073 <b xsi:type="xsd:boolean">false</b>
1074 <b xsi:type="xsd:boolean">1</b>
1075 <b xsi:type="xsd:boolean">0</b>
1076
1077 <f xsi:type="xsd:float">5</f>
1078 <f xsi:type="xsd:double">5</f>
1079
1080 <s xsi:type="xsd:string">5</s>
1081 <s xsi:type="xsd:normalizedString">5</s>
1082 <s xsi:type="xsd:token">5</s>
1083 <s xsi:type="xsd:language">5</s>
1084 <s xsi:type="xsd:Name">5</s>
1085 <s xsi:type="xsd:NCName">5</s>
1086 <s xsi:type="xsd:ID">5</s>
1087 <s xsi:type="xsd:IDREF">5</s>
1088 <s xsi:type="xsd:ENTITY">5</s>
1089 <s xsi:type="xsd:NMTOKEN">5</s>
1090
1091 <l xsi:type="xsd:integer">5</l>
1092 <l xsi:type="xsd:nonPositiveInteger">5</l>
1093 <l xsi:type="xsd:negativeInteger">5</l>
1094 <l xsi:type="xsd:long">5</l>
1095 <l xsi:type="xsd:nonNegativeInteger">5</l>
1096 <l xsi:type="xsd:unsignedLong">5</l>
1097 <l xsi:type="xsd:unsignedInt">5</l>
1098 <l xsi:type="xsd:positiveInteger">5</l>
1099
1100 <i xsi:type="xsd:int">5</i>
1101 <i xsi:type="xsd:short">5</i>
1102 <i xsi:type="xsd:byte">5</i>
1103 <i xsi:type="xsd:unsignedShort">5</i>
1104 <i xsi:type="xsd:unsignedByte">5</i>
1105
1106 <n xsi:nil="true"/>
1107 </root>
1108 ''')
1109
1110 for b in root.b:
1111 self.assert_(isinstance(b, objectify.BoolElement))
1112 self.assertEquals(True, root.b[0])
1113 self.assertEquals(False, root.b[1])
1114 self.assertEquals(True, root.b[2])
1115 self.assertEquals(False, root.b[3])
1116
1117 for f in root.f:
1118 self.assert_(isinstance(f, objectify.FloatElement))
1119 self.assertEquals(5, f)
1120
1121 for s in root.s:
1122 self.assert_(isinstance(s, objectify.StringElement))
1123 self.assertEquals("5", s)
1124
1125 for l in root.l:
1126 self.assert_(isinstance(l, objectify.LongElement))
1127 self.assertEquals(5L, l)
1128
1129 for i in root.i:
1130 self.assert_(isinstance(i, objectify.IntElement))
1131 self.assertEquals(5, i)
1132
1133 self.assert_(isinstance(root.n, objectify.NoneElement))
1134 self.assertEquals(None, root.n)
1135
1137 XML = self.XML
1138 root = XML(u'<root><b>why</b><b>try</b></root>')
1139 strs = [ str(s) for s in root.b ]
1140 self.assertEquals(["why", "try"],
1141 strs)
1142
1144 XML = self.XML
1145 root = XML(u'<root><b>test</b><b>taste</b><b></b><b/></root>')
1146 self.assertFalse(root.b[0] < root.b[1])
1147 self.assertFalse(root.b[0] <= root.b[1])
1148 self.assertFalse(root.b[0] == root.b[1])
1149
1150 self.assert_(root.b[0] != root.b[1])
1151 self.assert_(root.b[0] >= root.b[1])
1152 self.assert_(root.b[0] > root.b[1])
1153
1154 self.assertEquals(root.b[0], "test")
1155 self.assertEquals("test", root.b[0])
1156 self.assert_(root.b[0] > 5)
1157 self.assert_(5 < root.b[0])
1158
1159 self.assertEquals("", root.b[2])
1160 self.assertEquals(root.b[2], "")
1161 self.assertEquals("", root.b[3])
1162 self.assertEquals(root.b[3], "")
1163 self.assertEquals(root.b[2], root.b[3])
1164
1165 root.b = "test"
1166 self.assert_(root.b)
1167 root.b = ""
1168 self.assertFalse(root.b)
1169 self.assertEquals(root.b, "")
1170 self.assertEquals("", root.b)
1171
1192
1193
1194
1218
1220 XML = self.XML
1221 root = XML(u"""
1222 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
1223 <b xsi:nil="true"></b><b xsi:nil="true"/>
1224 </root>""")
1225 self.assert_(root.b[0] == root.b[1])
1226 self.assertFalse(root.b[0])
1227 self.assertEquals(root.b[0], None)
1228 self.assertEquals(None, root.b[0])
1229
1230 for comparison in ["abc", 5, 7.3, True, [], ()]:
1231 none = root.b[1]
1232 self.assert_(none < comparison, "%s (%s) should be < %s" %
1233 (none, type(none), comparison) )
1234 self.assert_(comparison > none, "%s should be > %s (%s)" %
1235 (comparison, none, type(none)) )
1236
1242
1249
1253
1255 XML = self.XML
1256 root = XML(u'''\
1257 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1258 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1259 <b>5</b>
1260 <b>test</b>
1261 <c>1.1</c>
1262 <c>\uF8D2</c>
1263 <x>true</x>
1264 <n xsi:nil="true" />
1265 <n></n>
1266 <b xsi:type="double">5</b>
1267 <b xsi:type="float">5</b>
1268 <s xsi:type="string">23</s>
1269 <s py:pytype="str">42</s>
1270 <f py:pytype="float">300</f>
1271 <l py:pytype="long">2</l>
1272 <t py:pytype="TREE"></t>
1273 </a>
1274 ''')
1275 objectify.annotate(root)
1276
1277 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1278 for c in root.iterchildren() ]
1279 self.assertEquals("int", child_types[ 0])
1280 self.assertEquals("str", child_types[ 1])
1281 self.assertEquals("float", child_types[ 2])
1282 self.assertEquals("str", child_types[ 3])
1283 self.assertEquals("bool", child_types[ 4])
1284 self.assertEquals("NoneType", child_types[ 5])
1285 self.assertEquals(None, child_types[ 6])
1286 self.assertEquals("float", child_types[ 7])
1287 self.assertEquals("float", child_types[ 8])
1288 self.assertEquals("str", child_types[ 9])
1289 self.assertEquals("int", child_types[10])
1290 self.assertEquals("int", child_types[11])
1291 self.assertEquals("int", child_types[12])
1292 self.assertEquals(None, child_types[13])
1293
1294 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1295
1315
1317 XML = self.XML
1318 root = XML(u'''\
1319 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1320 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1321 <b>5</b>
1322 <b>test</b>
1323 <c>1.1</c>
1324 <c>\uF8D2</c>
1325 <x>true</x>
1326 <n xsi:nil="true" />
1327 <n></n>
1328 <b xsi:type="double">5</b>
1329 <b xsi:type="float">5</b>
1330 <s xsi:type="string">23</s>
1331 <s py:pytype="str">42</s>
1332 <f py:pytype="float">300</f>
1333 <l py:pytype="long">2</l>
1334 <t py:pytype="TREE"></t>
1335 </a>
1336 ''')
1337 objectify.annotate(root, ignore_old=False)
1338
1339 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1340 for c in root.iterchildren() ]
1341 self.assertEquals("int", child_types[ 0])
1342 self.assertEquals("str", child_types[ 1])
1343 self.assertEquals("float", child_types[ 2])
1344 self.assertEquals("str", child_types[ 3])
1345 self.assertEquals("bool", child_types[ 4])
1346 self.assertEquals("NoneType", child_types[ 5])
1347 self.assertEquals(None, child_types[ 6])
1348 self.assertEquals("float", child_types[ 7])
1349 self.assertEquals("float", child_types[ 8])
1350 self.assertEquals("str", child_types[ 9])
1351 self.assertEquals("str", child_types[10])
1352 self.assertEquals("float", child_types[11])
1353 self.assertEquals("long", child_types[12])
1354 self.assertEquals(TREE_PYTYPE, child_types[13])
1355
1356 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1357
1359 XML = self.XML
1360 root = XML(u'''\
1361 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1362 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1363 <b>5</b>
1364 <b>test</b>
1365 <c>1.1</c>
1366 <c>\uF8D2</c>
1367 <x>true</x>
1368 <n xsi:nil="true" />
1369 <n></n>
1370 <b xsi:type="double">5</b>
1371 <b xsi:type="float">5</b>
1372 <s xsi:type="string">23</s>
1373 <s py:pytype="str">42</s>
1374 <f py:pytype="float">300</f>
1375 <l py:pytype="long">2</l>
1376 <t py:pytype="TREE"></t>
1377 </a>
1378 ''')
1379 objectify.annotate(root, ignore_old=False, ignore_xsi=False,
1380 annotate_xsi=1, annotate_pytype=1)
1381
1382
1383 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1384 for c in root.iterchildren() ]
1385 self.assertEquals("int", child_types[ 0])
1386 self.assertEquals("str", child_types[ 1])
1387 self.assertEquals("float", child_types[ 2])
1388 self.assertEquals("str", child_types[ 3])
1389 self.assertEquals("bool", child_types[ 4])
1390 self.assertEquals("NoneType", child_types[ 5])
1391 self.assertEquals(None, child_types[ 6])
1392 self.assertEquals("float", child_types[ 7])
1393 self.assertEquals("float", child_types[ 8])
1394 self.assertEquals("str", child_types[ 9])
1395 self.assertEquals("str", child_types[10])
1396 self.assertEquals("float", child_types[11])
1397 self.assertEquals("long", child_types[12])
1398 self.assertEquals(TREE_PYTYPE, child_types[13])
1399
1400 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1401
1402 child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1403 for c in root.iterchildren() ]
1404
1405
1406 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1407 for c in root.iterchildren() ]
1408 self.assertEquals("xsd:int", child_types[ 0])
1409 self.assertEquals("xsd:string", child_types[ 1])
1410 self.assertEquals("xsd:double", child_types[ 2])
1411 self.assertEquals("xsd:string", child_types[ 3])
1412 self.assertEquals("xsd:boolean", child_types[ 4])
1413 self.assertEquals(None, child_types[ 5])
1414 self.assertEquals(None, child_types[ 6])
1415 self.assertEquals("xsd:double", child_types[ 7])
1416 self.assertEquals("xsd:float", child_types[ 8])
1417 self.assertEquals("xsd:string", child_types[ 9])
1418 self.assertEquals("xsd:string", child_types[10])
1419 self.assertEquals("xsd:double", child_types[11])
1420 self.assertEquals("xsd:integer", child_types[12])
1421 self.assertEquals(None, child_types[13])
1422
1423 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1424
1426 XML = self.XML
1427 root = XML(u'''\
1428 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1429 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1430 <b>5</b>
1431 <b>test</b>
1432 <c>1.1</c>
1433 <c>\uF8D2</c>
1434 <x>true</x>
1435 <n xsi:nil="true" />
1436 <n></n>
1437 <b xsi:type="double">5</b>
1438 <b xsi:type="float">5</b>
1439 <s xsi:type="string">23</s>
1440 <s py:pytype="str">42</s>
1441 <f py:pytype="float">300</f>
1442 <l py:pytype="long">2</l>
1443 <t py:pytype="TREE"></t>
1444 </a>
1445 ''')
1446 objectify.xsiannotate(root, ignore_old=False)
1447
1448 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1449 for c in root.iterchildren() ]
1450 self.assertEquals("xsd:int", child_types[ 0])
1451 self.assertEquals("xsd:string", child_types[ 1])
1452 self.assertEquals("xsd:double", child_types[ 2])
1453 self.assertEquals("xsd:string", child_types[ 3])
1454 self.assertEquals("xsd:boolean", child_types[ 4])
1455 self.assertEquals(None, child_types[ 5])
1456 self.assertEquals(None, child_types[ 6])
1457 self.assertEquals("xsd:double", child_types[ 7])
1458 self.assertEquals("xsd:float", child_types[ 8])
1459 self.assertEquals("xsd:string", child_types[ 9])
1460 self.assertEquals("xsd:string", child_types[10])
1461 self.assertEquals("xsd:double", child_types[11])
1462 self.assertEquals("xsd:integer", child_types[12])
1463 self.assertEquals(None, child_types[13])
1464
1466 XML = self.XML
1467 root = XML(u'''\
1468 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1469 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1470 <b>5</b>
1471 <b>test</b>
1472 <c>1.1</c>
1473 <c>\uF8D2</c>
1474 <x>true</x>
1475 <n xsi:nil="true" />
1476 <n></n>
1477 <b xsi:type="double">5</b>
1478 <b xsi:type="float">5</b>
1479 <s xsi:type="string">23</s>
1480 <s py:pytype="str">42</s>
1481 <f py:pytype="float">300</f>
1482 <l py:pytype="long">2</l>
1483 <t py:pytype="TREE"></t>
1484 </a>
1485 ''')
1486 objectify.pyannotate(root, ignore_old=True)
1487
1488 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1489 for c in root.iterchildren() ]
1490 self.assertEquals("int", child_types[ 0])
1491 self.assertEquals("str", child_types[ 1])
1492 self.assertEquals("float", child_types[ 2])
1493 self.assertEquals("str", child_types[ 3])
1494 self.assertEquals("bool", child_types[ 4])
1495 self.assertEquals("NoneType", child_types[ 5])
1496 self.assertEquals(None, child_types[ 6])
1497 self.assertEquals("float", child_types[ 7])
1498 self.assertEquals("float", child_types[ 8])
1499 self.assertEquals("str", child_types[ 9])
1500 self.assertEquals("int", child_types[10])
1501 self.assertEquals("int", child_types[11])
1502 self.assertEquals("int", child_types[12])
1503 self.assertEquals(None, child_types[13])
1504
1505 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1506
1526
1528 XML = self.XML
1529 root = XML(u'''\
1530 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1531 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1532 <b>5</b>
1533 <b>test</b>
1534 <c>1.1</c>
1535 <c>\uF8D2</c>
1536 <x>true</x>
1537 <n xsi:nil="true" />
1538 <n></n>
1539 <b xsi:type="double">5</b>
1540 <b xsi:type="float">5</b>
1541 <s xsi:type="string">23</s>
1542 <s py:pytype="str">42</s>
1543 <f py:pytype="float">300</f>
1544 <l py:pytype="long">2</l>
1545 <t py:pytype="TREE"></t>
1546 </a>
1547 ''')
1548 objectify.pyannotate(root)
1549
1550 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1551 for c in root.iterchildren() ]
1552 self.assertEquals("int", child_types[ 0])
1553 self.assertEquals("str", child_types[ 1])
1554 self.assertEquals("float", child_types[ 2])
1555 self.assertEquals("str", child_types[ 3])
1556 self.assertEquals("bool", child_types[ 4])
1557 self.assertEquals("NoneType", child_types[ 5])
1558 self.assertEquals(None, child_types[ 6])
1559 self.assertEquals("float", child_types[ 7])
1560 self.assertEquals("float", child_types[ 8])
1561 self.assertEquals("str", child_types[ 9])
1562 self.assertEquals("str", child_types[10])
1563 self.assertEquals("float", child_types[11])
1564 self.assertEquals("long", child_types[12])
1565 self.assertEquals(TREE_PYTYPE, child_types[13])
1566
1567 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1568
1570 XML = self.XML
1571 root = XML(u'''\
1572 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1573 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1574 <b>5</b>
1575 <b>test</b>
1576 <c>1.1</c>
1577 <c>\uF8D2</c>
1578 <x>true</x>
1579 <n xsi:nil="true" />
1580 <n></n>
1581 <b xsi:type="double">5</b>
1582 <b xsi:type="float">5</b>
1583 <s xsi:type="string">23</s>
1584 <s py:pytype="str">42</s>
1585 <f py:pytype="float">300</f>
1586 <l py:pytype="long">2</l>
1587 <t py:pytype="TREE"></t>
1588 </a>
1589 ''')
1590 objectify.xsiannotate(root, ignore_old=True)
1591
1592 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1593 for c in root.iterchildren() ]
1594 self.assertEquals("xsd:int", child_types[ 0])
1595 self.assertEquals("xsd:string", child_types[ 1])
1596 self.assertEquals("xsd:double", child_types[ 2])
1597 self.assertEquals("xsd:string", child_types[ 3])
1598 self.assertEquals("xsd:boolean", child_types[ 4])
1599 self.assertEquals(None, child_types[ 5])
1600 self.assertEquals(None, child_types[ 6])
1601 self.assertEquals("xsd:int", child_types[ 7])
1602 self.assertEquals("xsd:int", child_types[ 8])
1603 self.assertEquals("xsd:int", child_types[ 9])
1604 self.assertEquals("xsd:string", child_types[10])
1605 self.assertEquals("xsd:double", child_types[11])
1606 self.assertEquals("xsd:integer", child_types[12])
1607 self.assertEquals(None, child_types[13])
1608
1609 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1610
1612 XML = self.XML
1613 root = XML(u'''\
1614 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1615 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1616 <b>5</b>
1617 <b>test</b>
1618 <c>1.1</c>
1619 <c>\uF8D2</c>
1620 <x>true</x>
1621 <n xsi:nil="true" />
1622 <n></n>
1623 <b xsi:type="double">5</b>
1624 <b xsi:type="float">5</b>
1625 <s xsi:type="string">23</s>
1626 <s py:pytype="str">42</s>
1627 <f py:pytype="float">300</f>
1628 <l py:pytype="long">2</l>
1629 <t py:pytype="TREE"></t>
1630 </a>
1631 ''')
1632 objectify.deannotate(root)
1633
1634 for c in root.getiterator():
1635 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))
1636 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1637
1638 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1639
1641 XML = self.XML
1642 root = XML(u'''\
1643 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1644 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1645 <b>5</b>
1646 <b>test</b>
1647 <c>1.1</c>
1648 <c>\uF8D2</c>
1649 <x>true</x>
1650 <n xsi:nil="true" />
1651 <n></n>
1652 <b xsi:type="double">5</b>
1653 <b xsi:type="float">5</b>
1654 <s xsi:type="string">23</s>
1655 <s py:pytype="str">42</s>
1656 <f py:pytype="float">300</f>
1657 <l py:pytype="long">2</l>
1658 <t py:pytype="TREE"></t>
1659 </a>
1660 ''')
1661 objectify.xsiannotate(root)
1662 objectify.deannotate(root, xsi=False)
1663
1664 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1665 for c in root.iterchildren() ]
1666 self.assertEquals("xsd:int", child_types[ 0])
1667 self.assertEquals("xsd:string", child_types[ 1])
1668 self.assertEquals("xsd:double", child_types[ 2])
1669 self.assertEquals("xsd:string", child_types[ 3])
1670 self.assertEquals("xsd:boolean", child_types[ 4])
1671 self.assertEquals(None, child_types[ 5])
1672 self.assertEquals(None, child_types[ 6])
1673 self.assertEquals("xsd:int", child_types[ 7])
1674 self.assertEquals("xsd:int", child_types[ 8])
1675 self.assertEquals("xsd:int", child_types[ 9])
1676 self.assertEquals("xsd:string", child_types[10])
1677 self.assertEquals("xsd:double", child_types[11])
1678 self.assertEquals("xsd:integer", child_types[12])
1679 self.assertEquals(None, child_types[13])
1680
1681 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1682
1683 for c in root.getiterator():
1684 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1685
1687 XML = self.XML
1688 root = XML(u'''\
1689 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1690 xmlns:py="http://codespeak.net/lxml/objectify/pytype"
1691 xmlns:xsd="http://www.w3.org/2001/XMLSchema">
1692 <b>5</b>
1693 <b>test</b>
1694 <c>1.1</c>
1695 <c>\uF8D2</c>
1696 <x>true</x>
1697 <n xsi:nil="true" />
1698 <n></n>
1699 <b xsi:type="xsd:double">5</b>
1700 <b xsi:type="xsd:float">5</b>
1701 <s xsi:type="xsd:string">23</s>
1702 <s py:pytype="str">42</s>
1703 <f py:pytype="float">300</f>
1704 <l py:pytype="long">2</l>
1705 <t py:pytype="TREE"></t>
1706 </a>
1707 ''')
1708 objectify.annotate(root)
1709 objectify.deannotate(root, pytype=False)
1710
1711 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1712 for c in root.iterchildren() ]
1713 self.assertEquals("int", child_types[ 0])
1714 self.assertEquals("str", child_types[ 1])
1715 self.assertEquals("float", child_types[ 2])
1716 self.assertEquals("str", child_types[ 3])
1717 self.assertEquals("bool", child_types[ 4])
1718 self.assertEquals("NoneType", child_types[ 5])
1719 self.assertEquals(None, child_types[ 6])
1720 self.assertEquals("float", child_types[ 7])
1721 self.assertEquals("float", child_types[ 8])
1722 self.assertEquals("str", child_types[ 9])
1723 self.assertEquals("int", child_types[10])
1724 self.assertEquals("int", child_types[11])
1725 self.assertEquals("int", child_types[12])
1726 self.assertEquals(None, child_types[13])
1727
1728 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1729
1730 for c in root.getiterator():
1731 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))
1732
1734 XML = self.XML
1735 root = XML(u'''\
1736 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1737 xmlns:py="http://codespeak.net/lxml/objectify/pytype"
1738 xmlns:xsd="http://www.w3.org/2001/XMLSchema">
1739 <b xsi:type="xsd:int">5</b>
1740 <b xsi:type="xsd:string">test</b>
1741 <c xsi:type="xsd:float">1.1</c>
1742 <c xsi:type="xsd:string">\uF8D2</c>
1743 <x xsi:type="xsd:boolean">true</x>
1744 <n xsi:nil="true" />
1745 <n></n>
1746 <b xsi:type="xsd:double">5</b>
1747 <b xsi:type="xsd:float">5</b>
1748 <s xsi:type="xsd:string">23</s>
1749 <s xsi:type="xsd:string">42</s>
1750 <f xsi:type="xsd:float">300</f>
1751 <l xsi:type="xsd:long">2</l>
1752 <t py:pytype="TREE"></t>
1753 </a>
1754 ''')
1755 objectify.annotate(root)
1756 objectify.deannotate(root, xsi=False)
1757
1758 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1759 for c in root.iterchildren() ]
1760 self.assertEquals("xsd:int", child_types[ 0])
1761 self.assertEquals("xsd:string", child_types[ 1])
1762 self.assertEquals("xsd:float", child_types[ 2])
1763 self.assertEquals("xsd:string", child_types[ 3])
1764 self.assertEquals("xsd:boolean", child_types[ 4])
1765 self.assertEquals(None, child_types[ 5])
1766 self.assertEquals(None, child_types[ 6])
1767 self.assertEquals("xsd:double", child_types[ 7])
1768 self.assertEquals("xsd:float", child_types[ 8])
1769 self.assertEquals("xsd:string", child_types[ 9])
1770 self.assertEquals("xsd:string", child_types[10])
1771 self.assertEquals("xsd:float", child_types[11])
1772 self.assertEquals("xsd:long", child_types[12])
1773 self.assertEquals(None, child_types[13])
1774
1775 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1776
1777 for c in root.getiterator():
1778 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1779
1781 XML = self.XML
1782
1783 xml = u'''\
1784 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
1785 <b>5</b>
1786 <b>test</b>
1787 <c>1.1</c>
1788 <c>\uF8D2</c>
1789 <x>true</x>
1790 <n xsi:nil="true" />
1791 <n></n>
1792 <b xsi:type="double">5</b>
1793 </a>
1794 '''
1795
1796 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}')
1797 objectify.set_pytype_attribute_tag("{TEST}test")
1798
1799 root = XML(xml)
1800 objectify.annotate(root)
1801
1802 attribs = root.xpath("//@py:%s" % pytype_name,
1803 namespaces={"py" : pytype_ns})
1804 self.assertEquals(0, len(attribs))
1805 attribs = root.xpath("//@py:test",
1806 namespaces={"py" : "TEST"})
1807 self.assertEquals(7, len(attribs))
1808
1809 objectify.set_pytype_attribute_tag()
1810 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}')
1811
1812 self.assertNotEqual("test", pytype_ns.lower())
1813 self.assertNotEqual("test", pytype_name.lower())
1814
1815 root = XML(xml)
1816 attribs = root.xpath("//@py:%s" % pytype_name,
1817 namespaces={"py" : pytype_ns})
1818 self.assertEquals(0, len(attribs))
1819
1820 objectify.annotate(root)
1821 attribs = root.xpath("//@py:%s" % pytype_name,
1822 namespaces={"py" : pytype_ns})
1823 self.assertEquals(7, len(attribs))
1824
1832
1833 def checkMyType(s):
1834 return True
1835
1836 pytype = objectify.PyType("mytype", checkMyType, NewType)
1837 self.assert_(pytype not in objectify.getRegisteredTypes())
1838 pytype.register()
1839 self.assert_(pytype in objectify.getRegisteredTypes())
1840 pytype.unregister()
1841 self.assert_(pytype not in objectify.getRegisteredTypes())
1842
1843 pytype.register(before = [objectify.getRegisteredTypes()[0].name])
1844 self.assertEquals(pytype, objectify.getRegisteredTypes()[0])
1845 pytype.unregister()
1846
1847 pytype.register(after = [objectify.getRegisteredTypes()[0].name])
1848 self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0])
1849 pytype.unregister()
1850
1851 self.assertRaises(ValueError, pytype.register,
1852 before = [objectify.getRegisteredTypes()[0].name],
1853 after = [objectify.getRegisteredTypes()[1].name])
1854
1856 from datetime import datetime
1857 def parse_date(value):
1858 if len(value) != 14:
1859 raise ValueError(value)
1860 Y = int(value[0:4])
1861 M = int(value[4:6])
1862 D = int(value[6:8])
1863 h = int(value[8:10])
1864 m = int(value[10:12])
1865 s = int(value[12:14])
1866 return datetime(Y, M, D, h, m, s)
1867
1868 def stringify_date(date):
1869 return date.strftime("%Y%m%d%H%M%S")
1870
1871 class DatetimeElement(objectify.ObjectifiedDataElement):
1872 def pyval(self):
1873 return parse_date(self.text)
1874 pyval = property(pyval)
1875
1876 datetime_type = objectify.PyType(
1877 "datetime", parse_date, DatetimeElement, stringify_date)
1878 datetime_type.xmlSchemaTypes = "dateTime"
1879 datetime_type.register()
1880
1881 NAMESPACE = "http://foo.net/xmlns"
1882 NAMESPACE_MAP = {'ns': NAMESPACE}
1883
1884 r = objectify.Element("{%s}root" % NAMESPACE, nsmap=NAMESPACE_MAP)
1885 time = datetime.now()
1886 r.date = time
1887
1888 self.assert_(isinstance(r.date, DatetimeElement))
1889 self.assert_(isinstance(r.date.pyval, datetime))
1890
1891 self.assertEquals(r.date.pyval, parse_date(stringify_date(time)))
1892 self.assertEquals(r.date.text, stringify_date(time))
1893
1894 r.date = objectify.E.date(time)
1895
1896 self.assert_(isinstance(r.date, DatetimeElement))
1897 self.assert_(isinstance(r.date.pyval, datetime))
1898
1899 self.assertEquals(r.date.pyval, parse_date(stringify_date(time)))
1900 self.assertEquals(r.date.text, stringify_date(time))
1901
1907
1913
1919
1927
1946
1951
1956
1961
1966
1986
1988 root = self.XML(xml_str)
1989 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] )
1990 self.assertEquals(root.c1.c2.text, path(root).text)
1991
1992 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] )
1993 self.assertEquals(root.c1.c2[2].text, path(root).text)
1994
1995 path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] )
1996 self.assertEquals(root.c1.c2[2].text, path(root).text)
1997
1998 path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] )
1999 self.assertEquals(root.c1.c2[-1].text, path(root).text)
2000
2001 path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] )
2002 self.assertEquals(root.c1.c2[-3].text, path(root).text)
2003
2005 self.assertRaises(ValueError, objectify.ObjectPath,
2006 "root.c1[0].c2[-1-2]")
2007 self.assertRaises(ValueError, objectify.ObjectPath,
2008 ['root', 'c1[0]', 'c2[-1-2]'])
2009
2010 self.assertRaises(ValueError, objectify.ObjectPath,
2011 "root[2].c1.c2")
2012 self.assertRaises(ValueError, objectify.ObjectPath,
2013 ['root[2]', 'c1', 'c2'])
2014
2015 self.assertRaises(ValueError, objectify.ObjectPath,
2016 [])
2017 self.assertRaises(ValueError, objectify.ObjectPath,
2018 ['', '', ''])
2019
2021 root = self.XML(xml_str)
2022 path = objectify.ObjectPath("root.c1[9999].c2")
2023 self.assertRaises(AttributeError, path, root)
2024
2025 path = objectify.ObjectPath("root.c1[0].c2[9999]")
2026 self.assertRaises(AttributeError, path, root)
2027
2028 path = objectify.ObjectPath(".c1[9999].c2[0]")
2029 self.assertRaises(AttributeError, path, root)
2030
2031 path = objectify.ObjectPath("root.c1[-2].c2")
2032 self.assertRaises(AttributeError, path, root)
2033
2034 path = objectify.ObjectPath("root.c1[0].c2[-4]")
2035 self.assertRaises(AttributeError, path, root)
2036
2050
2052 root = self.XML(xml_str)
2053 path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] )
2054 self.assertEquals(root.c1.c2.text, path.find(root).text)
2055 path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] )
2056 self.assertEquals(root.c1.c2.text, path.find(root).text)
2057 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] )
2058 self.assertEquals(root.c1.c2.text, path.find(root).text)
2059 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] )
2060 self.assertEquals(root.c1.c2[2].text, path.find(root).text)
2061 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] )
2062 self.assertEquals(root.c1.c2.text, path.find(root).text)
2063 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] )
2064 self.assertEquals(root.c1.c2[2].text, path.find(root).text)
2065 path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] )
2066 self.assertEquals(getattr(root.c1, '{otherNS}c2').text,
2067 path.find(root).text)
2068
2081
2096
2108
2122
2124 root = self.XML(xml_str)
2125 path = objectify.ObjectPath( "root.c1.c99" )
2126 self.assertRaises(AttributeError, path.find, root)
2127
2128 new_el = self.Element("{objectified}test")
2129 new_el.a = ["TEST1", "TEST2"]
2130 new_el.a[0].set("myattr", "ATTR1")
2131 new_el.a[1].set("myattr", "ATTR2")
2132
2133 path.setattr(root, list(new_el.a))
2134
2135 self.assertEquals(2, len(root.c1.c99))
2136 self.assertEquals("ATTR1", root.c1.c99[0].get("myattr"))
2137 self.assertEquals("TEST1", root.c1.c99[0].text)
2138 self.assertEquals("ATTR2", root.c1.c99[1].get("myattr"))
2139 self.assertEquals("TEST2", root.c1.c99[1].text)
2140 self.assertEquals("TEST1", path(root).text)
2141
2150
2164
2176
2190
2205
2207 root = self.XML(xml_str)
2208 self.assertEquals(
2209 ['{objectified}root', '{objectified}root.c1',
2210 '{objectified}root.c1.c2',
2211 '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]',
2212 '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'],
2213 root.descendantpaths())
2214
2216 root = self.XML(xml_str)
2217 self.assertEquals(
2218 ['{objectified}c1', '{objectified}c1.c2',
2219 '{objectified}c1.c2[1]', '{objectified}c1.c2[2]',
2220 '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'],
2221 root.c1.descendantpaths())
2222
2224 root = self.XML(xml_str)
2225 self.assertEquals(
2226 ['root.{objectified}c1', 'root.{objectified}c1.c2',
2227 'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]',
2228 'root.{objectified}c1.{otherNS}c2',
2229 'root.{objectified}c1.{}c2'],
2230 root.c1.descendantpaths('root'))
2231
2243
2244
2245
2250
2255
2260
2265
2270
2275
2280
2285
2290
2292 E = objectify.E
2293 DataElement = objectify.DataElement
2294 root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1),
2295 DataElement(2.0))
2296 self.assert_(isinstance(root, objectify.ObjectifiedElement))
2297 self.assertEquals(root.text, "text")
2298 self.assert_(isinstance(root.sub, objectify.ObjectifiedElement))
2299 self.assertEquals(root.sub.tail, "tail")
2300 self.assert_(isinstance(root.sub.subsub, objectify.StringElement))
2301 self.assertEquals(len(root.value), 2)
2302 self.assert_(isinstance(root.value[0], objectify.IntElement))
2303 self.assert_(isinstance(root.value[1], objectify.FloatElement))
2304
2306 suite = unittest.TestSuite()
2307 suite.addTests([unittest.makeSuite(ObjectifyTestCase)])
2308 if sys.version_info >= (2,4):
2309 suite.addTests(
2310 [doctest.DocFileSuite('../../../doc/objectify.txt')])
2311 return suite
2312
2313 if __name__ == '__main__':
2314 print 'to test use test.py %s' % __file__
2315