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
86
93
97
102
109
119
124
130
138
149
153
158
165
175
180
186
194
205
207
208 value = objectify.DataElement(23, _pytype="str", _xsi="foobar",
209 attrib={"gnu": "muh", "cat": "meeow",
210 "dog": "wuff"},
211 bird="tchilp", dog="grrr")
212 self.assertEquals(value.get("gnu"), "muh")
213 self.assertEquals(value.get("cat"), "meeow")
214 self.assertEquals(value.get("dog"), "grrr")
215 self.assertEquals(value.get("bird"), "tchilp")
216
228
230
231
232 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
233 attrib={"gnu": "muh", "cat": "meeow",
234 "dog": "wuff"},
235 bird="tchilp", dog="grrr")
236 value = objectify.DataElement(arg, _pytype="NoneType")
237 self.assert_(isinstance(value, objectify.NoneElement))
238 self.assertEquals(value.get(XML_SCHEMA_NIL_ATTR), "true")
239 self.assertEquals(value.text, None)
240 self.assertEquals(value.pyval, None)
241 for attr in arg.attrib:
242
243 self.assertEquals(value.get(attr), arg.get(attr))
244
246
247
248 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
249 attrib={"gnu": "muh", "cat": "meeow",
250 "dog": "wuff"},
251 bird="tchilp", dog="grrr")
252 value = objectify.DataElement(arg, _pytype="int")
253 self.assert_(isinstance(value, objectify.IntElement))
254 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int")
255 for attr in arg.attrib:
256 if not attr == objectify.PYTYPE_ATTRIBUTE:
257 self.assertEquals(value.get(attr), arg.get(attr))
258
260
261
262 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
263 attrib={"gnu": "muh", "cat": "meeow",
264 "dog": "wuff"},
265 bird="tchilp", dog="grrr")
266 value = objectify.DataElement(arg, _xsi="xsd:int")
267 self.assert_(isinstance(value, objectify.IntElement))
268 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int")
269 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int")
270 for attr in arg.attrib:
271 if not attr in [objectify.PYTYPE_ATTRIBUTE,
272 XML_SCHEMA_INSTANCE_TYPE_ATTR]:
273 self.assertEquals(value.get(attr), arg.get(attr))
274
276
277
278 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
279 attrib={"gnu": "muh", "cat": "meeow",
280 "dog": "wuff"},
281 bird="tchilp", dog="grrr")
282 value = objectify.DataElement(arg, _pytype="int", _xsi="xsd:int")
283 self.assert_(isinstance(value, objectify.IntElement))
284 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int")
285 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int")
286 for attr in arg.attrib:
287 if not attr in [objectify.PYTYPE_ATTRIBUTE,
288 XML_SCHEMA_INSTANCE_TYPE_ATTR]:
289 self.assertEquals(value.get(attr), arg.get(attr))
290
294
298
303
308
312
316
320
325
327 root = self.XML(xml_str)
328 self.assertEquals("0", getattr(root.c1, "{objectified}c2").text)
329 self.assertEquals("3", getattr(root.c1, "{otherNS}c2").text)
330
332 root = self.XML(xml_str)
333 self.assertRaises(AttributeError, getattr, root.c1, "NOT_THERE")
334 self.assertRaises(AttributeError, getattr, root.c1, "{unknownNS}c2")
335
342
344 root = self.XML(xml_str)
345 self.assertEquals(1, len(root.c1))
346
347 new_el = self.Element("test", myattr="5")
348 root.addattr("c1", new_el)
349 self.assertEquals(2, len(root.c1))
350 self.assertEquals(None, root.c1[0].get("myattr"))
351 self.assertEquals("5", root.c1[1].get("myattr"))
352
354 root = self.XML(xml_str)
355 self.assertEquals(1, len(root.c1))
356
357 new_el = self.Element("test")
358 self.etree.SubElement(new_el, "a", myattr="A")
359 self.etree.SubElement(new_el, "a", myattr="B")
360
361 root.addattr("c1", list(new_el.a))
362 self.assertEquals(3, len(root.c1))
363 self.assertEquals(None, root.c1[0].get("myattr"))
364 self.assertEquals("A", root.c1[1].get("myattr"))
365 self.assertEquals("B", root.c1[2].get("myattr"))
366
373
375 root = self.XML(xml_str)
376 self.assertEquals("0", root.c1.c2[0].text)
377 self.assertEquals("1", root.c1.c2[1].text)
378 self.assertEquals("2", root.c1.c2[2].text)
379 self.assertRaises(IndexError, operator.getitem, root.c1.c2, 3)
380
382 root = self.XML(xml_str)
383 self.assertEquals("0", root.c1.c2[0].text)
384 self.assertEquals("0", root.c1.c2[-3].text)
385 self.assertEquals("1", root.c1.c2[-2].text)
386 self.assertEquals("2", root.c1.c2[-1].text)
387 self.assertRaises(IndexError, operator.getitem, root.c1.c2, -4)
388
390 root = self.XML(xml_str)
391 self.assertEquals(1, len(root))
392 self.assertEquals(1, len(root.c1))
393 self.assertEquals(3, len(root.c1.c2))
394
403
409
419
424
429
431 Element = self.Element
432 SubElement = self.etree.SubElement
433 root = Element("root")
434 root.c = ["c1", "c2"]
435
436 c1 = root.c[0]
437 c2 = root.c[1]
438
439 self.assertEquals([c1,c2], list(root.c))
440 self.assertEquals(["c1", "c2"],
441 [ c.text for c in root.c ])
442
443 root2 = Element("root2")
444 root2.el = [ "test", "test" ]
445 self.assertEquals(["test", "test"],
446 [ el.text for el in root2.el ])
447
448 root.c = [ root2.el, root2.el ]
449 self.assertEquals(["test", "test"],
450 [ c.text for c in root.c ])
451 self.assertEquals(["test", "test"],
452 [ el.text for el in root2.el ])
453
454 root.c[:] = [ c1, c2, c2, c1 ]
455 self.assertEquals(["c1", "c2", "c2", "c1"],
456 [ c.text for c in root.c ])
457
466
475
477
478 Element = self.Element
479 SubElement = self.etree.SubElement
480 root = Element("root")
481
482 root["text"] = "TEST"
483 self.assertEquals(["TEST"],
484 [ c.text for c in root["text"] ])
485
486 root["tail"] = "TEST"
487 self.assertEquals(["TEST"],
488 [ c.text for c in root["tail"] ])
489
490 root["pyval"] = "TEST"
491 self.assertEquals(["TEST"],
492 [ c.text for c in root["pyval"] ])
493
494 root["tag"] = "TEST"
495 self.assertEquals(["TEST"],
496 [ c.text for c in root["tag"] ])
497
505
507 XML = self.XML
508 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')
509 self.assertEquals(2, len(root.findall(".//{X}b")))
510 self.assertEquals(3, len(root.findall(".//b")))
511 self.assertEquals(2, len(root.findall("b")))
512
520
534
540
552
561
568
575
582
584 Element = self.Element
585 SubElement = self.etree.SubElement
586 root = Element("{objectified}root")
587 root.s = "test"
588
589 self.assertEquals("test" * 5, root.s * 5)
590 self.assertEquals(5 * "test", 5 * root.s)
591
592 self.assertRaises(TypeError, operator.mul, root.s, "honk")
593 self.assertRaises(TypeError, operator.mul, "honk", root.s)
594
604
625
634
639
644
649
656
663
670
672 Element = self.Element
673 SubElement = self.etree.SubElement
674 root = Element("{objectified}root")
675 root.s = u"test"
676
677 self.assertEquals(u"test" * 5, root.s * 5)
678 self.assertEquals(5 * u"test", 5 * root.s)
679
680 self.assertRaises(TypeError, operator.mul, root.s, u"honk")
681 self.assertRaises(TypeError, operator.mul, u"honk", root.s)
682
692
697
702
707
714
719
726
731
740
749
755
764
766 pyval = 1
767 pytype = "NoneType"
768 objclass = objectify.NoneElement
769 value = objectify.DataElement(pyval, _pytype=pytype)
770 self.assert_(isinstance(value, objclass),
771 "DataElement(%s, _pytype='%s') returns %s, expected %s"
772 % (pyval, pytype, type(value), objclass))
773 self.assertEquals(value.text, None)
774 self.assertEquals(value.pyval, None)
775
777
778 pyval = 1
779 pytype = "none"
780 objclass = objectify.NoneElement
781 value = objectify.DataElement(pyval, _pytype=pytype)
782 self.assert_(isinstance(value, objclass),
783 "DataElement(%s, _pytype='%s') returns %s, expected %s"
784 % (pyval, pytype, type(value), objclass))
785 self.assertEquals(value.text, None)
786 self.assertEquals(value.pyval, None)
787
793 root = Element("{objectified}root")
794 root.myfloat = MyFloat(5.5)
795 self.assert_(isinstance(root.myfloat, objectify.FloatElement))
796 self.assertEquals(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None)
797
799 class MyFloat(float):
800 pass
801 value = objectify.DataElement(MyFloat(5.5))
802 self.assert_(isinstance(value, objectify.FloatElement))
803 self.assertEquals(value, 5.5)
804 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), None)
805
807 XML = self.XML
808 root = XML('''\
809 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
810 <b xsi:type="boolean">true</b>
811 <b xsi:type="boolean">false</b>
812 <b xsi:type="boolean">1</b>
813 <b xsi:type="boolean">0</b>
814
815 <f xsi:type="float">5</f>
816 <f xsi:type="double">5</f>
817
818 <s xsi:type="string">5</s>
819 <s xsi:type="normalizedString">5</s>
820 <s xsi:type="token">5</s>
821 <s xsi:type="language">5</s>
822 <s xsi:type="Name">5</s>
823 <s xsi:type="NCName">5</s>
824 <s xsi:type="ID">5</s>
825 <s xsi:type="IDREF">5</s>
826 <s xsi:type="ENTITY">5</s>
827 <s xsi:type="NMTOKEN">5</s>
828
829 <l xsi:type="integer">5</l>
830 <l xsi:type="nonPositiveInteger">5</l>
831 <l xsi:type="negativeInteger">5</l>
832 <l xsi:type="long">5</l>
833 <l xsi:type="nonNegativeInteger">5</l>
834 <l xsi:type="unsignedLong">5</l>
835 <l xsi:type="unsignedInt">5</l>
836 <l xsi:type="positiveInteger">5</l>
837
838 <i xsi:type="int">5</i>
839 <i xsi:type="short">5</i>
840 <i xsi:type="byte">5</i>
841 <i xsi:type="unsignedShort">5</i>
842 <i xsi:type="unsignedByte">5</i>
843
844 <n xsi:nil="true"/>
845 </root>
846 ''')
847
848 for b in root.b:
849 self.assert_(isinstance(b, objectify.BoolElement))
850 self.assertEquals(True, root.b[0])
851 self.assertEquals(False, root.b[1])
852 self.assertEquals(True, root.b[2])
853 self.assertEquals(False, root.b[3])
854
855 for f in root.f:
856 self.assert_(isinstance(f, objectify.FloatElement))
857 self.assertEquals(5, f)
858
859 for s in root.s:
860 self.assert_(isinstance(s, objectify.StringElement))
861 self.assertEquals("5", s)
862
863 for l in root.l:
864 self.assert_(isinstance(l, objectify.LongElement))
865 self.assertEquals(5L, l)
866
867 for i in root.i:
868 self.assert_(isinstance(i, objectify.IntElement))
869 self.assertEquals(5, i)
870
871 self.assert_(isinstance(root.n, objectify.NoneElement))
872 self.assertEquals(None, root.n)
873
875 XML = self.XML
876 root = XML('''\
877 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
878 xmlns:xsd="http://www.w3.org/2001/XMLSchema">
879 <b xsi:type="xsd:boolean">true</b>
880 <b xsi:type="xsd:boolean">false</b>
881 <b xsi:type="xsd:boolean">1</b>
882 <b xsi:type="xsd:boolean">0</b>
883
884 <f xsi:type="xsd:float">5</f>
885 <f xsi:type="xsd:double">5</f>
886
887 <s xsi:type="xsd:string">5</s>
888 <s xsi:type="xsd:normalizedString">5</s>
889 <s xsi:type="xsd:token">5</s>
890 <s xsi:type="xsd:language">5</s>
891 <s xsi:type="xsd:Name">5</s>
892 <s xsi:type="xsd:NCName">5</s>
893 <s xsi:type="xsd:ID">5</s>
894 <s xsi:type="xsd:IDREF">5</s>
895 <s xsi:type="xsd:ENTITY">5</s>
896 <s xsi:type="xsd:NMTOKEN">5</s>
897
898 <l xsi:type="xsd:integer">5</l>
899 <l xsi:type="xsd:nonPositiveInteger">5</l>
900 <l xsi:type="xsd:negativeInteger">5</l>
901 <l xsi:type="xsd:long">5</l>
902 <l xsi:type="xsd:nonNegativeInteger">5</l>
903 <l xsi:type="xsd:unsignedLong">5</l>
904 <l xsi:type="xsd:unsignedInt">5</l>
905 <l xsi:type="xsd:positiveInteger">5</l>
906
907 <i xsi:type="xsd:int">5</i>
908 <i xsi:type="xsd:short">5</i>
909 <i xsi:type="xsd:byte">5</i>
910 <i xsi:type="xsd:unsignedShort">5</i>
911 <i xsi:type="xsd:unsignedByte">5</i>
912
913 <n xsi:nil="true"/>
914 </root>
915 ''')
916
917 for b in root.b:
918 self.assert_(isinstance(b, objectify.BoolElement))
919 self.assertEquals(True, root.b[0])
920 self.assertEquals(False, root.b[1])
921 self.assertEquals(True, root.b[2])
922 self.assertEquals(False, root.b[3])
923
924 for f in root.f:
925 self.assert_(isinstance(f, objectify.FloatElement))
926 self.assertEquals(5, f)
927
928 for s in root.s:
929 self.assert_(isinstance(s, objectify.StringElement))
930 self.assertEquals("5", s)
931
932 for l in root.l:
933 self.assert_(isinstance(l, objectify.LongElement))
934 self.assertEquals(5L, l)
935
936 for i in root.i:
937 self.assert_(isinstance(i, objectify.IntElement))
938 self.assertEquals(5, i)
939
940 self.assert_(isinstance(root.n, objectify.NoneElement))
941 self.assertEquals(None, root.n)
942
944 XML = self.XML
945 root = XML(u'<root><b>why</b><b>try</b></root>')
946 strs = [ str(s) for s in root.b ]
947 self.assertEquals(["why", "try"],
948 strs)
949
978
999
1000
1001
1025
1027 XML = self.XML
1028 root = XML(u"""
1029 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
1030 <b xsi:nil="true"></b><b xsi:nil="true"/>
1031 </root>""")
1032 self.assert_(root.b[0] == root.b[1])
1033 self.assertFalse(root.b[0])
1034 self.assertEquals(root.b[0], None)
1035 self.assertEquals(None, root.b[0])
1036
1037 for comparison in ["abc", 5, 7.3, True, [], ()]:
1038 none = root.b[1]
1039 self.assert_(none < comparison, "%s (%s) should be < %s" %
1040 (none, type(none), comparison) )
1041 self.assert_(comparison > none, "%s should be > %s (%s)" %
1042 (comparison, none, type(none)) )
1043
1049
1056
1060
1062 XML = self.XML
1063 root = XML(u'''\
1064 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1065 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1066 <b>5</b>
1067 <b>test</b>
1068 <c>1.1</c>
1069 <c>\uF8D2</c>
1070 <x>true</x>
1071 <n xsi:nil="true" />
1072 <n></n>
1073 <b xsi:type="double">5</b>
1074 <b xsi:type="float">5</b>
1075 <s xsi:type="string">23</s>
1076 <s py:pytype="str">42</s>
1077 <f py:pytype="float">300</f>
1078 <l py:pytype="long">2</l>
1079 <t py:pytype="TREE"></t>
1080 </a>
1081 ''')
1082 objectify.annotate(root)
1083
1084 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1085 for c in root.iterchildren() ]
1086 self.assertEquals("int", child_types[ 0])
1087 self.assertEquals("str", child_types[ 1])
1088 self.assertEquals("float", child_types[ 2])
1089 self.assertEquals("str", child_types[ 3])
1090 self.assertEquals("bool", child_types[ 4])
1091 self.assertEquals("NoneType", child_types[ 5])
1092 self.assertEquals(None, child_types[ 6])
1093 self.assertEquals("float", child_types[ 7])
1094 self.assertEquals("float", child_types[ 8])
1095 self.assertEquals("str", child_types[ 9])
1096 self.assertEquals("int", child_types[10])
1097 self.assertEquals("int", child_types[11])
1098 self.assertEquals("int", child_types[12])
1099 self.assertEquals(None, child_types[13])
1100
1101 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1102
1122
1124 XML = self.XML
1125 root = XML(u'''\
1126 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1127 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1128 <b>5</b>
1129 <b>test</b>
1130 <c>1.1</c>
1131 <c>\uF8D2</c>
1132 <x>true</x>
1133 <n xsi:nil="true" />
1134 <n></n>
1135 <b xsi:type="double">5</b>
1136 <b xsi:type="float">5</b>
1137 <s xsi:type="string">23</s>
1138 <s py:pytype="str">42</s>
1139 <f py:pytype="float">300</f>
1140 <l py:pytype="long">2</l>
1141 <t py:pytype="TREE"></t>
1142 </a>
1143 ''')
1144 objectify.annotate(root, ignore_old=False)
1145
1146 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1147 for c in root.iterchildren() ]
1148 self.assertEquals("int", child_types[ 0])
1149 self.assertEquals("str", child_types[ 1])
1150 self.assertEquals("float", child_types[ 2])
1151 self.assertEquals("str", child_types[ 3])
1152 self.assertEquals("bool", child_types[ 4])
1153 self.assertEquals("NoneType", child_types[ 5])
1154 self.assertEquals(None, child_types[ 6])
1155 self.assertEquals("float", child_types[ 7])
1156 self.assertEquals("float", child_types[ 8])
1157 self.assertEquals("str", child_types[ 9])
1158 self.assertEquals("str", child_types[10])
1159 self.assertEquals("float", child_types[11])
1160 self.assertEquals("long", child_types[12])
1161 self.assertEquals(TREE_PYTYPE, child_types[13])
1162
1163 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1164
1166 XML = self.XML
1167 root = XML(u'''\
1168 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1169 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1170 <b>5</b>
1171 <b>test</b>
1172 <c>1.1</c>
1173 <c>\uF8D2</c>
1174 <x>true</x>
1175 <n xsi:nil="true" />
1176 <n></n>
1177 <b xsi:type="double">5</b>
1178 <b xsi:type="float">5</b>
1179 <s xsi:type="string">23</s>
1180 <s py:pytype="str">42</s>
1181 <f py:pytype="float">300</f>
1182 <l py:pytype="long">2</l>
1183 <t py:pytype="TREE"></t>
1184 </a>
1185 ''')
1186 objectify.annotate(root, ignore_old=False, ignore_xsi=False,
1187 annotate_xsi=1, annotate_pytype=1)
1188
1189
1190 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1191 for c in root.iterchildren() ]
1192 self.assertEquals("int", child_types[ 0])
1193 self.assertEquals("str", child_types[ 1])
1194 self.assertEquals("float", child_types[ 2])
1195 self.assertEquals("str", child_types[ 3])
1196 self.assertEquals("bool", child_types[ 4])
1197 self.assertEquals("NoneType", child_types[ 5])
1198 self.assertEquals(None, child_types[ 6])
1199 self.assertEquals("float", child_types[ 7])
1200 self.assertEquals("float", child_types[ 8])
1201 self.assertEquals("str", child_types[ 9])
1202 self.assertEquals("str", child_types[10])
1203 self.assertEquals("float", child_types[11])
1204 self.assertEquals("long", child_types[12])
1205 self.assertEquals(TREE_PYTYPE, child_types[13])
1206
1207 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1208
1209 child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1210 for c in root.iterchildren() ]
1211
1212
1213 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1214 for c in root.iterchildren() ]
1215 self.assertEquals("xsd:int", child_types[ 0])
1216 self.assertEquals("xsd:string", child_types[ 1])
1217 self.assertEquals("xsd:double", child_types[ 2])
1218 self.assertEquals("xsd:string", child_types[ 3])
1219 self.assertEquals("xsd:boolean", child_types[ 4])
1220 self.assertEquals(None, child_types[ 5])
1221 self.assertEquals(None, child_types[ 6])
1222 self.assertEquals("xsd:double", child_types[ 7])
1223 self.assertEquals("xsd:float", child_types[ 8])
1224 self.assertEquals("xsd:string", child_types[ 9])
1225 self.assertEquals("xsd:string", child_types[10])
1226 self.assertEquals("xsd:double", child_types[11])
1227 self.assertEquals("xsd:integer", child_types[12])
1228 self.assertEquals(None, child_types[13])
1229
1230 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1231
1233 XML = self.XML
1234 root = XML(u'''\
1235 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1236 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1237 <b>5</b>
1238 <b>test</b>
1239 <c>1.1</c>
1240 <c>\uF8D2</c>
1241 <x>true</x>
1242 <n xsi:nil="true" />
1243 <n></n>
1244 <b xsi:type="double">5</b>
1245 <b xsi:type="float">5</b>
1246 <s xsi:type="string">23</s>
1247 <s py:pytype="str">42</s>
1248 <f py:pytype="float">300</f>
1249 <l py:pytype="long">2</l>
1250 <t py:pytype="TREE"></t>
1251 </a>
1252 ''')
1253 objectify.xsiannotate(root, ignore_old=False)
1254
1255 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1256 for c in root.iterchildren() ]
1257 self.assertEquals("xsd:int", child_types[ 0])
1258 self.assertEquals("xsd:string", child_types[ 1])
1259 self.assertEquals("xsd:double", child_types[ 2])
1260 self.assertEquals("xsd:string", child_types[ 3])
1261 self.assertEquals("xsd:boolean", child_types[ 4])
1262 self.assertEquals(None, child_types[ 5])
1263 self.assertEquals(None, child_types[ 6])
1264 self.assertEquals("xsd:double", child_types[ 7])
1265 self.assertEquals("xsd:float", child_types[ 8])
1266 self.assertEquals("xsd:string", child_types[ 9])
1267 self.assertEquals("xsd:string", child_types[10])
1268 self.assertEquals("xsd:double", child_types[11])
1269 self.assertEquals("xsd:integer", child_types[12])
1270 self.assertEquals(None, child_types[13])
1271
1273 XML = self.XML
1274 root = XML(u'''\
1275 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1276 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1277 <b>5</b>
1278 <b>test</b>
1279 <c>1.1</c>
1280 <c>\uF8D2</c>
1281 <x>true</x>
1282 <n xsi:nil="true" />
1283 <n></n>
1284 <b xsi:type="double">5</b>
1285 <b xsi:type="float">5</b>
1286 <s xsi:type="string">23</s>
1287 <s py:pytype="str">42</s>
1288 <f py:pytype="float">300</f>
1289 <l py:pytype="long">2</l>
1290 <t py:pytype="TREE"></t>
1291 </a>
1292 ''')
1293 objectify.pyannotate(root, ignore_old=True)
1294
1295 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1296 for c in root.iterchildren() ]
1297 self.assertEquals("int", child_types[ 0])
1298 self.assertEquals("str", child_types[ 1])
1299 self.assertEquals("float", child_types[ 2])
1300 self.assertEquals("str", child_types[ 3])
1301 self.assertEquals("bool", child_types[ 4])
1302 self.assertEquals("NoneType", child_types[ 5])
1303 self.assertEquals(None, child_types[ 6])
1304 self.assertEquals("float", child_types[ 7])
1305 self.assertEquals("float", child_types[ 8])
1306 self.assertEquals("str", child_types[ 9])
1307 self.assertEquals("int", child_types[10])
1308 self.assertEquals("int", child_types[11])
1309 self.assertEquals("int", child_types[12])
1310 self.assertEquals(None, child_types[13])
1311
1312 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1313
1333
1335 XML = self.XML
1336 root = XML(u'''\
1337 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1338 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1339 <b>5</b>
1340 <b>test</b>
1341 <c>1.1</c>
1342 <c>\uF8D2</c>
1343 <x>true</x>
1344 <n xsi:nil="true" />
1345 <n></n>
1346 <b xsi:type="double">5</b>
1347 <b xsi:type="float">5</b>
1348 <s xsi:type="string">23</s>
1349 <s py:pytype="str">42</s>
1350 <f py:pytype="float">300</f>
1351 <l py:pytype="long">2</l>
1352 <t py:pytype="TREE"></t>
1353 </a>
1354 ''')
1355 objectify.pyannotate(root)
1356
1357 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1358 for c in root.iterchildren() ]
1359 self.assertEquals("int", child_types[ 0])
1360 self.assertEquals("str", child_types[ 1])
1361 self.assertEquals("float", child_types[ 2])
1362 self.assertEquals("str", child_types[ 3])
1363 self.assertEquals("bool", child_types[ 4])
1364 self.assertEquals("NoneType", child_types[ 5])
1365 self.assertEquals(None, child_types[ 6])
1366 self.assertEquals("float", child_types[ 7])
1367 self.assertEquals("float", child_types[ 8])
1368 self.assertEquals("str", child_types[ 9])
1369 self.assertEquals("str", child_types[10])
1370 self.assertEquals("float", child_types[11])
1371 self.assertEquals("long", child_types[12])
1372 self.assertEquals(TREE_PYTYPE, child_types[13])
1373
1374 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1375
1377 XML = self.XML
1378 root = XML(u'''\
1379 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1380 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1381 <b>5</b>
1382 <b>test</b>
1383 <c>1.1</c>
1384 <c>\uF8D2</c>
1385 <x>true</x>
1386 <n xsi:nil="true" />
1387 <n></n>
1388 <b xsi:type="double">5</b>
1389 <b xsi:type="float">5</b>
1390 <s xsi:type="string">23</s>
1391 <s py:pytype="str">42</s>
1392 <f py:pytype="float">300</f>
1393 <l py:pytype="long">2</l>
1394 <t py:pytype="TREE"></t>
1395 </a>
1396 ''')
1397 objectify.xsiannotate(root, ignore_old=True)
1398
1399 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1400 for c in root.iterchildren() ]
1401 self.assertEquals("xsd:int", child_types[ 0])
1402 self.assertEquals("xsd:string", child_types[ 1])
1403 self.assertEquals("xsd:double", child_types[ 2])
1404 self.assertEquals("xsd:string", child_types[ 3])
1405 self.assertEquals("xsd:boolean", child_types[ 4])
1406 self.assertEquals(None, child_types[ 5])
1407 self.assertEquals(None, child_types[ 6])
1408 self.assertEquals("xsd:int", child_types[ 7])
1409 self.assertEquals("xsd:int", child_types[ 8])
1410 self.assertEquals("xsd:int", child_types[ 9])
1411 self.assertEquals("xsd:string", child_types[10])
1412 self.assertEquals("xsd:double", child_types[11])
1413 self.assertEquals("xsd:integer", child_types[12])
1414 self.assertEquals(None, child_types[13])
1415
1416 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1417
1419 XML = self.XML
1420 root = XML(u'''\
1421 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1422 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1423 <b>5</b>
1424 <b>test</b>
1425 <c>1.1</c>
1426 <c>\uF8D2</c>
1427 <x>true</x>
1428 <n xsi:nil="true" />
1429 <n></n>
1430 <b xsi:type="double">5</b>
1431 <b xsi:type="float">5</b>
1432 <s xsi:type="string">23</s>
1433 <s py:pytype="str">42</s>
1434 <f py:pytype="float">300</f>
1435 <l py:pytype="long">2</l>
1436 <t py:pytype="TREE"></t>
1437 </a>
1438 ''')
1439 objectify.deannotate(root)
1440
1441 for c in root.getiterator():
1442 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))
1443 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1444
1445 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1446
1448 XML = self.XML
1449 root = XML(u'''\
1450 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1451 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1452 <b>5</b>
1453 <b>test</b>
1454 <c>1.1</c>
1455 <c>\uF8D2</c>
1456 <x>true</x>
1457 <n xsi:nil="true" />
1458 <n></n>
1459 <b xsi:type="double">5</b>
1460 <b xsi:type="float">5</b>
1461 <s xsi:type="string">23</s>
1462 <s py:pytype="str">42</s>
1463 <f py:pytype="float">300</f>
1464 <l py:pytype="long">2</l>
1465 <t py:pytype="TREE"></t>
1466 </a>
1467 ''')
1468 objectify.xsiannotate(root)
1469 objectify.deannotate(root, xsi=False)
1470
1471 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1472 for c in root.iterchildren() ]
1473 self.assertEquals("xsd:int", child_types[ 0])
1474 self.assertEquals("xsd:string", child_types[ 1])
1475 self.assertEquals("xsd:double", child_types[ 2])
1476 self.assertEquals("xsd:string", child_types[ 3])
1477 self.assertEquals("xsd:boolean", child_types[ 4])
1478 self.assertEquals(None, child_types[ 5])
1479 self.assertEquals(None, child_types[ 6])
1480 self.assertEquals("xsd:int", child_types[ 7])
1481 self.assertEquals("xsd:int", child_types[ 8])
1482 self.assertEquals("xsd:int", child_types[ 9])
1483 self.assertEquals("xsd:string", child_types[10])
1484 self.assertEquals("xsd:double", child_types[11])
1485 self.assertEquals("xsd:integer", child_types[12])
1486 self.assertEquals(None, child_types[13])
1487
1488 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1489
1490 for c in root.getiterator():
1491 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1492
1494 XML = self.XML
1495 root = XML(u'''\
1496 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1497 xmlns:py="http://codespeak.net/lxml/objectify/pytype"
1498 xmlns:xsd="http://www.w3.org/2001/XMLSchema">
1499 <b>5</b>
1500 <b>test</b>
1501 <c>1.1</c>
1502 <c>\uF8D2</c>
1503 <x>true</x>
1504 <n xsi:nil="true" />
1505 <n></n>
1506 <b xsi:type="xsd:double">5</b>
1507 <b xsi:type="xsd:float">5</b>
1508 <s xsi:type="xsd:string">23</s>
1509 <s py:pytype="str">42</s>
1510 <f py:pytype="float">300</f>
1511 <l py:pytype="long">2</l>
1512 <t py:pytype="TREE"></t>
1513 </a>
1514 ''')
1515 objectify.annotate(root)
1516 objectify.deannotate(root, pytype=False)
1517
1518 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1519 for c in root.iterchildren() ]
1520 self.assertEquals("int", child_types[ 0])
1521 self.assertEquals("str", child_types[ 1])
1522 self.assertEquals("float", child_types[ 2])
1523 self.assertEquals("str", child_types[ 3])
1524 self.assertEquals("bool", child_types[ 4])
1525 self.assertEquals("NoneType", child_types[ 5])
1526 self.assertEquals(None, child_types[ 6])
1527 self.assertEquals("float", child_types[ 7])
1528 self.assertEquals("float", child_types[ 8])
1529 self.assertEquals("str", child_types[ 9])
1530 self.assertEquals("int", child_types[10])
1531 self.assertEquals("int", child_types[11])
1532 self.assertEquals("int", child_types[12])
1533 self.assertEquals(None, child_types[13])
1534
1535 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1536
1537 for c in root.getiterator():
1538 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))
1539
1541 XML = self.XML
1542 root = XML(u'''\
1543 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1544 xmlns:py="http://codespeak.net/lxml/objectify/pytype"
1545 xmlns:xsd="http://www.w3.org/2001/XMLSchema">
1546 <b xsi:type="xsd:int">5</b>
1547 <b xsi:type="xsd:string">test</b>
1548 <c xsi:type="xsd:float">1.1</c>
1549 <c xsi:type="xsd:string">\uF8D2</c>
1550 <x xsi:type="xsd:boolean">true</x>
1551 <n xsi:nil="true" />
1552 <n></n>
1553 <b xsi:type="xsd:double">5</b>
1554 <b xsi:type="xsd:float">5</b>
1555 <s xsi:type="xsd:string">23</s>
1556 <s xsi:type="xsd:string">42</s>
1557 <f xsi:type="xsd:float">300</f>
1558 <l xsi:type="xsd:long">2</l>
1559 <t py:pytype="TREE"></t>
1560 </a>
1561 ''')
1562 objectify.annotate(root)
1563 objectify.deannotate(root, xsi=False)
1564
1565 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1566 for c in root.iterchildren() ]
1567 self.assertEquals("xsd:int", child_types[ 0])
1568 self.assertEquals("xsd:string", child_types[ 1])
1569 self.assertEquals("xsd:float", child_types[ 2])
1570 self.assertEquals("xsd:string", child_types[ 3])
1571 self.assertEquals("xsd:boolean", child_types[ 4])
1572 self.assertEquals(None, child_types[ 5])
1573 self.assertEquals(None, child_types[ 6])
1574 self.assertEquals("xsd:double", child_types[ 7])
1575 self.assertEquals("xsd:float", child_types[ 8])
1576 self.assertEquals("xsd:string", child_types[ 9])
1577 self.assertEquals("xsd:string", child_types[10])
1578 self.assertEquals("xsd:float", child_types[11])
1579 self.assertEquals("xsd:long", child_types[12])
1580 self.assertEquals(None, child_types[13])
1581
1582 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1583
1584 for c in root.getiterator():
1585 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1586
1588 XML = self.XML
1589
1590 xml = u'''\
1591 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
1592 <b>5</b>
1593 <b>test</b>
1594 <c>1.1</c>
1595 <c>\uF8D2</c>
1596 <x>true</x>
1597 <n xsi:nil="true" />
1598 <n></n>
1599 <b xsi:type="double">5</b>
1600 </a>
1601 '''
1602
1603 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}')
1604 objectify.setPytypeAttributeTag("{TEST}test")
1605
1606 root = XML(xml)
1607 objectify.annotate(root)
1608
1609 attribs = root.xpath("//@py:%s" % pytype_name,
1610 namespaces={"py" : pytype_ns})
1611 self.assertEquals(0, len(attribs))
1612 attribs = root.xpath("//@py:test",
1613 namespaces={"py" : "TEST"})
1614 self.assertEquals(7, len(attribs))
1615
1616 objectify.setPytypeAttributeTag()
1617 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}')
1618
1619 self.assertNotEqual("test", pytype_ns.lower())
1620 self.assertNotEqual("test", pytype_name.lower())
1621
1622 root = XML(xml)
1623 attribs = root.xpath("//@py:%s" % pytype_name,
1624 namespaces={"py" : pytype_ns})
1625 self.assertEquals(0, len(attribs))
1626
1627 objectify.annotate(root)
1628 attribs = root.xpath("//@py:%s" % pytype_name,
1629 namespaces={"py" : pytype_ns})
1630 self.assertEquals(7, len(attribs))
1631
1641
1642 def checkMyType(s):
1643 return True
1644
1645 pytype = objectify.PyType("mytype", checkMyType, NewType)
1646 pytype.register()
1647 self.assert_(pytype in objectify.getRegisteredTypes())
1648 pytype.unregister()
1649
1650 pytype.register(before = [objectify.getRegisteredTypes()[0].name])
1651 self.assertEquals(pytype, objectify.getRegisteredTypes()[0])
1652 pytype.unregister()
1653
1654 pytype.register(after = [objectify.getRegisteredTypes()[0].name])
1655 self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0])
1656 pytype.unregister()
1657
1658 self.assertRaises(ValueError, pytype.register,
1659 before = [objectify.getRegisteredTypes()[0].name],
1660 after = [objectify.getRegisteredTypes()[1].name])
1661
1662 finally:
1663 for pytype in objectify.getRegisteredTypes():
1664 pytype.unregister()
1665 for pytype in orig_types:
1666 pytype.register()
1667
1673
1679
1685
1693
1712
1717
1722
1727
1732
1752
1754 root = self.XML(xml_str)
1755 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] )
1756 self.assertEquals(root.c1.c2.text, path(root).text)
1757
1758 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] )
1759 self.assertEquals(root.c1.c2[2].text, path(root).text)
1760
1761 path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] )
1762 self.assertEquals(root.c1.c2[2].text, path(root).text)
1763
1764 path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] )
1765 self.assertEquals(root.c1.c2[-1].text, path(root).text)
1766
1767 path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] )
1768 self.assertEquals(root.c1.c2[-3].text, path(root).text)
1769
1771 self.assertRaises(ValueError, objectify.ObjectPath,
1772 "root.c1[0].c2[-1-2]")
1773 self.assertRaises(ValueError, objectify.ObjectPath,
1774 ['root', 'c1[0]', 'c2[-1-2]'])
1775
1776 self.assertRaises(ValueError, objectify.ObjectPath,
1777 "root[2].c1.c2")
1778 self.assertRaises(ValueError, objectify.ObjectPath,
1779 ['root[2]', 'c1', 'c2'])
1780
1781 self.assertRaises(ValueError, objectify.ObjectPath,
1782 [])
1783 self.assertRaises(ValueError, objectify.ObjectPath,
1784 ['', '', ''])
1785
1787 root = self.XML(xml_str)
1788 path = objectify.ObjectPath("root.c1[9999].c2")
1789 self.assertRaises(AttributeError, path, root)
1790
1791 path = objectify.ObjectPath("root.c1[0].c2[9999]")
1792 self.assertRaises(AttributeError, path, root)
1793
1794 path = objectify.ObjectPath(".c1[9999].c2[0]")
1795 self.assertRaises(AttributeError, path, root)
1796
1797 path = objectify.ObjectPath("root.c1[-2].c2")
1798 self.assertRaises(AttributeError, path, root)
1799
1800 path = objectify.ObjectPath("root.c1[0].c2[-4]")
1801 self.assertRaises(AttributeError, path, root)
1802
1816
1818 root = self.XML(xml_str)
1819 path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] )
1820 self.assertEquals(root.c1.c2.text, path.find(root).text)
1821 path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] )
1822 self.assertEquals(root.c1.c2.text, path.find(root).text)
1823 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] )
1824 self.assertEquals(root.c1.c2.text, path.find(root).text)
1825 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] )
1826 self.assertEquals(root.c1.c2[2].text, path.find(root).text)
1827 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] )
1828 self.assertEquals(root.c1.c2.text, path.find(root).text)
1829 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] )
1830 self.assertEquals(root.c1.c2[2].text, path.find(root).text)
1831 path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] )
1832 self.assertEquals(getattr(root.c1, '{otherNS}c2').text,
1833 path.find(root).text)
1834
1847
1862
1874
1888
1890 root = self.XML(xml_str)
1891 path = objectify.ObjectPath( "root.c1.c99" )
1892 self.assertRaises(AttributeError, path.find, root)
1893
1894 new_el = self.Element("{objectified}test")
1895 new_el.a = ["TEST1", "TEST2"]
1896 new_el.a[0].set("myattr", "ATTR1")
1897 new_el.a[1].set("myattr", "ATTR2")
1898
1899 path.setattr(root, list(new_el.a))
1900
1901 self.assertEquals(2, len(root.c1.c99))
1902 self.assertEquals("ATTR1", root.c1.c99[0].get("myattr"))
1903 self.assertEquals("TEST1", root.c1.c99[0].text)
1904 self.assertEquals("ATTR2", root.c1.c99[1].get("myattr"))
1905 self.assertEquals("TEST2", root.c1.c99[1].text)
1906 self.assertEquals("TEST1", path(root).text)
1907
1916
1930
1942
1956
1971
1973 root = self.XML(xml_str)
1974 self.assertEquals(
1975 ['{objectified}root', '{objectified}root.c1',
1976 '{objectified}root.c1.c2',
1977 '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]',
1978 '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'],
1979 root.descendantpaths())
1980
1982 root = self.XML(xml_str)
1983 self.assertEquals(
1984 ['{objectified}c1', '{objectified}c1.c2',
1985 '{objectified}c1.c2[1]', '{objectified}c1.c2[2]',
1986 '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'],
1987 root.c1.descendantpaths())
1988
1990 root = self.XML(xml_str)
1991 self.assertEquals(
1992 ['root.{objectified}c1', 'root.{objectified}c1.c2',
1993 'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]',
1994 'root.{objectified}c1.{otherNS}c2',
1995 'root.{objectified}c1.{}c2'],
1996 root.c1.descendantpaths('root'))
1997
2009
2010
2011
2016
2021
2026
2031
2036
2041
2046
2051
2056
2058 E = objectify.E
2059 DataElement = objectify.DataElement
2060 root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1),
2061 DataElement(2.0))
2062 self.assert_(isinstance(root, objectify.ObjectifiedElement))
2063 self.assertEquals(root.text, "text")
2064 self.assert_(isinstance(root.sub, objectify.ObjectifiedElement))
2065 self.assertEquals(root.sub.tail, "tail")
2066 self.assert_(isinstance(root.sub.subsub, objectify.StringElement))
2067 self.assertEquals(len(root.value), 2)
2068 self.assert_(isinstance(root.value[0], objectify.IntElement))
2069 self.assert_(isinstance(root.value[1], objectify.FloatElement))
2070
2072 suite = unittest.TestSuite()
2073 suite.addTests([unittest.makeSuite(ObjectifyTestCase)])
2074 if sys.version_info >= (2,4):
2075 suite.addTests(
2076 [doctest.DocFileSuite('../../../doc/objectify.txt')])
2077 return suite
2078
2079 if __name__ == '__main__':
2080 print 'to test use test.py %s' % __file__
2081