Package lxml :: Package tests :: Module test_objectify
[frames] | no frames]

Source Code for Module lxml.tests.test_objectify

   1  # -*- coding: utf-8 -*- 
   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      # objectify built-in 
  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      # None: xsi:nil="true" 
  38      } 
  39   
  40  xsitype2objclass = dict([ (v, k) for k in objectclass2xsitype 
  41                            for v in objectclass2xsitype[k] ]) 
  42   
  43  objectclass2pytype = { 
  44      # objectify built-in 
  45      objectify.IntElement: "int", 
  46      objectify.LongElement: "long", 
  47      objectify.FloatElement: "float", 
  48      objectify.BoolElement: "bool", 
  49      objectify.StringElement: "str", 
  50      # None: xsi:nil="true" 
  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   
67 -class ObjectifyTestCase(HelperTestCase):
68 """Test cases for lxml.objectify 69 """ 70 etree = etree 71
72 - def XML(self, xml):
73 return self.etree.XML(xml, self.parser)
74
75 - def setUp(self):
76 super(ObjectifyTestCase, self).setUp() 77 self.parser = self.etree.XMLParser(remove_blank_text=True) 78 self.lookup = etree.ElementNamespaceClassLookup( 79 objectify.ObjectifyElementClassLookup() ) 80 self.parser.set_element_class_lookup(self.lookup) 81 82 self.Element = self.parser.makeelement 83 84 ns = self.lookup.get_namespace("otherNS") 85 ns[None] = self.etree.ElementBase 86 87 self._orig_types = objectify.getRegisteredTypes()
88
89 - def tearDown(self):
90 self.lookup.get_namespace("otherNS").clear() 91 objectify.set_pytype_attribute_tag() 92 del self.lookup 93 del self.parser 94 95 for pytype in objectify.getRegisteredTypes(): 96 pytype.unregister() 97 for pytype in self._orig_types: 98 pytype.register() 99 del self._orig_types 100 101 super(ObjectifyTestCase, self).tearDown()
102 103
104 - def test_element_nsmap_default(self):
105 elt = objectify.Element("test") 106 self.assertEquals(elt.nsmap, DEFAULT_NSMAP)
107
108 - def test_element_nsmap_empty(self):
109 nsmap = {} 110 elt = objectify.Element("test", nsmap=nsmap) 111 self.assertEquals(elt.nsmap.values(), [PYTYPE_NAMESPACE])
112
114 nsmap = {"mypy": PYTYPE_NAMESPACE, 115 "myxsi": XML_SCHEMA_INSTANCE_NS, 116 "myxsd": XML_SCHEMA_NS} 117 elt = objectify.Element("test", nsmap=nsmap) 118 self.assertEquals(elt.nsmap, nsmap)
119
120 - def test_element_nsmap_custom(self):
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
131 root = objectify.Element("root") 132 root.sub = objectify.Element("test") 133 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)
134
136 root = objectify.Element("root") 137 nsmap = {} 138 root.sub = objectify.Element("test", nsmap=nsmap) 139 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)
140
142 root = objectify.Element("root") 143 nsmap = {"mypy": PYTYPE_NAMESPACE, 144 "myxsi": XML_SCHEMA_INSTANCE_NS, 145 "myxsd": XML_SCHEMA_NS} 146 root.sub = objectify.Element("test", nsmap=nsmap) 147 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)
148
150 root = objectify.Element("root") 151 nsmap = {"my": "someNS", 152 "myother": "someOtherNS", 153 "myxsd": XML_SCHEMA_NS,} 154 root.sub = objectify.Element("test", nsmap=nsmap) 155 expected = nsmap.copy() 156 del expected["myxsd"] 157 expected.update(DEFAULT_NSMAP) 158 self.assertEquals(root.sub.nsmap, expected)
159
161 value = objectify.DataElement("test this") 162 self.assertEquals(value.nsmap, DEFAULT_NSMAP)
163
165 nsmap = {} 166 value = objectify.DataElement("test this", nsmap=nsmap) 167 self.assertEquals(value.nsmap.values(), [PYTYPE_NAMESPACE])
168
170 nsmap = {"mypy": PYTYPE_NAMESPACE, 171 "myxsi": XML_SCHEMA_INSTANCE_NS, 172 "myxsd": XML_SCHEMA_NS} 173 value = objectify.DataElement("test this", nsmap=nsmap) 174 self.assertEquals(value.nsmap, nsmap)
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
187 root = objectify.Element("root") 188 root.value = objectify.DataElement("test this") 189 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)
190
192 root = objectify.Element("root") 193 nsmap = {} 194 root.value = objectify.DataElement("test this", nsmap=nsmap) 195 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)
196
198 root = objectify.Element("root") 199 nsmap = {"mypy": PYTYPE_NAMESPACE, 200 "myxsi": XML_SCHEMA_INSTANCE_NS, 201 "myxsd": XML_SCHEMA_NS} 202 root.value = objectify.DataElement("test this", nsmap=nsmap) 203 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)
204
206 root = objectify.Element("root") 207 nsmap = {"my": "someNS", 208 "myother": "someOtherNS", 209 "myxsd": XML_SCHEMA_NS} 210 root.value = objectify.DataElement("test", nsmap=nsmap) 211 expected = nsmap.copy() 212 del expected["myxsd"] 213 expected.update(DEFAULT_NSMAP) 214 self.assertEquals(root.value.nsmap, expected)
215
217 # keyword arguments override attrib entries 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
228 # Check that DataElement preserves all attributes ObjectifiedDataElement 229 # arguments 230 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 231 attrib={"gnu": "muh", "cat": "meeow", 232 "dog": "wuff"}, 233 bird="tchilp", dog="grrr") 234 value = objectify.DataElement(arg) 235 self.assert_(isinstance(value, objectify.StringElement)) 236 for attr in arg.attrib: 237 self.assertEquals(value.get(attr), arg.get(attr))
238
240 # Check that _pytype arg overrides original py:pytype of 241 # ObjectifiedDataElement 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 #if not attr == objectify.PYTYPE_ATTRIBUTE: 253 self.assertEquals(value.get(attr), arg.get(attr))
254
256 # Check that _pytype arg overrides original py:pytype of 257 # ObjectifiedDataElement 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 # Check that _xsi arg overrides original xsi:type of given 271 # ObjectifiedDataElement 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 # Check that _pytype and _xsi args override original py:pytype and 287 # xsi:type attributes of given ObjectifiedDataElement 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
302 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 303 _pytype="int")
304
306 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 307 _xsi="xsd:int")
308
310 arg = objectify.DataElement(3.1415) 311 self.assertRaises(ValueError, objectify.DataElement, arg, 312 _pytype="int")
313
315 arg = objectify.DataElement(3.1415) 316 self.assertRaises(ValueError, objectify.DataElement, arg, 317 _xsi="xsd:int")
318
319 - def test_root(self):
320 root = self.Element("test") 321 self.assert_(isinstance(root, objectify.ObjectifiedElement))
322
323 - def test_str(self):
324 root = self.Element("test") 325 self.assertEquals('', str(root))
326
327 - def test_child(self):
328 root = self.XML(xml_str) 329 self.assertEquals("0", root.c1.c2.text)
330
331 - def test_countchildren(self):
332 root = self.XML(xml_str) 333 self.assertEquals(1, root.countchildren()) 334 self.assertEquals(5, root.c1.countchildren())
335
336 - def test_child_getattr(self):
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
341 - def test_child_nonexistant(self):
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
346 - def test_addattr(self):
347 root = self.XML(xml_str) 348 self.assertEquals(1, len(root.c1)) 349 root.addattr("c1", "test") 350 self.assertEquals(2, len(root.c1)) 351 self.assertEquals("test", root.c1[1].text)
352
353 - def test_addattr_element(self):
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
363 - def test_addattr_list(self):
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
377 - def test_child_addattr(self):
378 root = self.XML(xml_str) 379 self.assertEquals(3, len(root.c1.c2)) 380 root.c1.addattr("c2", 3) 381 self.assertEquals(4, len(root.c1.c2)) 382 self.assertEquals("3", root.c1.c2[3].text)
383
384 - def test_child_index(self):
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
391 - def test_child_index_neg(self):
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
399 - def test_child_len(self):
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
405 - def test_child_iter(self):
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
414 - def test_class_lookup(self):
415 root = self.XML(xml_str) 416 self.assert_(isinstance(root.c1.c2, objectify.ObjectifiedElement)) 417 self.assertFalse(isinstance(getattr(root.c1, "{otherNS}c2"), 418 objectify.ObjectifiedElement))
419
420 - def test_dir(self):
421 root = self.XML(xml_str) 422 dir_c1 = dir(objectify.ObjectifiedElement) + ['c1'] 423 dir_c1.sort() 424 dir_c2 = dir(objectify.ObjectifiedElement) + ['c2'] 425 dir_c2.sort() 426 427 self.assertEquals(dir_c1, dir(root)) 428 self.assertEquals(dir_c2, dir(root.c1))
429
430 - def test_vars(self):
431 root = self.XML(xml_str) 432 self.assertEquals({'c1' : root.c1}, vars(root)) 433 self.assertEquals({'c2' : root.c1.c2}, vars(root.c1))
434
435 - def test_child_set_ro(self):
436 root = self.XML(xml_str) 437 self.assertRaises(TypeError, setattr, root.c1.c2, 'text', "test") 438 self.assertRaises(TypeError, setattr, root.c1.c2, 'pyval', "test")
439 440 # slicing 441
442 - def test_getslice_complete(self):
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
447 - def test_getslice_partial(self):
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
464 - def test_getslice_partial_neg(self):
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 # slice assignment 480
481 - def test_setslice_complete(self):
482 Element = self.Element 483 root = Element("root") 484 root.c = ["c1", "c2"] 485 486 c1 = root.c[0] 487 c2 = root.c[1] 488 489 self.assertEquals([c1,c2], list(root.c)) 490 self.assertEquals(["c1", "c2"], 491 [ c.text for c in root.c ])
492
493 - def test_setslice_elements(self):
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
520 - def test_setslice_partial(self):
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
541 - def test_setslice_insert(self):
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
562 - def test_setslice_insert_neg(self):
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
583 - def test_setslice_empty(self):
584 Element = self.Element 585 root = Element("root") 586 587 root.c = [] 588 self.assertRaises( 589 AttributeError, getattr, root, 'c')
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
610 - def test_setslice_partial_neg(self):
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 # other stuff 653
654 - def test_set_string(self):
655 # make sure strings are not handled as sequences 656 Element = self.Element 657 root = Element("root") 658 root.c = "TEST" 659 self.assertEquals(["TEST"], 660 [ c.text for c in root.c ])
661
662 - def test_setitem_string(self):
663 # make sure strings are set as children 664 Element = self.Element 665 root = Element("root") 666 root["c"] = "TEST" 667 self.assertEquals(["TEST"], 668 [ c.text for c in root.c ])
669
671 # make sure 'text' etc. are set as children 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
691 - def test_findall(self):
692 XML = self.XML 693 root = XML('<a><b><c/></b><b/><c><b/></c></a>') 694 self.assertEquals(1, len(root.findall("c"))) 695 self.assertEquals(2, len(root.findall(".//c"))) 696 self.assertEquals(3, len(root.findall(".//b"))) 697 self.assert_(root.findall(".//b")[1] is root.getchildren()[1])
698
699 - def test_findall_ns(self):
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
706 - def test_build_tree(self):
707 root = self.Element('root') 708 root.a = 5 709 root.b = 6 710 self.assert_(isinstance(root, objectify.ObjectifiedElement)) 711 self.assert_(isinstance(root.a, objectify.IntElement)) 712 self.assert_(isinstance(root.b, objectify.IntElement))
713
714 - def test_type_NoneType(self):
715 Element = self.Element 716 SubElement = self.etree.SubElement 717 718 nil_attr = XML_SCHEMA_NIL_ATTR 719 root = Element("{objectified}root") 720 SubElement(root, "{objectified}none") 721 SubElement(root, "{objectified}none", {nil_attr : "true"}) 722 self.assertFalse(isinstance(root.none, objectify.NoneElement)) 723 self.assertFalse(isinstance(root.none[0], objectify.NoneElement)) 724 self.assert_(isinstance(root.none[1], objectify.NoneElement)) 725 self.assertEquals(root.none[1], None) 726 self.assertFalse(root.none[1])
727
728 - def test_data_element_NoneType(self):
729 value = objectify.DataElement(None) 730 self.assert_(isinstance(value, objectify.NoneElement)) 731 self.assertEquals(value, None) 732 self.assertEquals(value.get(XML_SCHEMA_NIL_ATTR), "true")
733
734 - def test_type_bool(self):
735 Element = self.Element 736 SubElement = self.etree.SubElement 737 root = Element("{objectified}root") 738 root.bool = True 739 self.assertEquals(root.bool, True) 740 self.assert_(isinstance(root.bool, objectify.BoolElement)) 741 742 root.bool = False 743 self.assertEquals(root.bool, False) 744 self.assert_(isinstance(root.bool, objectify.BoolElement))
745
746 - def test_data_element_bool(self):
747 value = objectify.DataElement(True) 748 self.assert_(isinstance(value, objectify.BoolElement)) 749 self.assertEquals(value, True) 750 751 value = objectify.DataElement(False) 752 self.assert_(isinstance(value, objectify.BoolElement)) 753 self.assertEquals(value, False)
754
755 - def test_type_str(self):
756 Element = self.Element 757 SubElement = self.etree.SubElement 758 root = Element("{objectified}root") 759 root.s = "test" 760 self.assert_(isinstance(root.s, objectify.StringElement))
761
762 - def test_type_str_intliteral(self):
763 Element = self.Element 764 SubElement = self.etree.SubElement 765 root = Element("{objectified}root") 766 root.s = "3" 767 self.assert_(isinstance(root.s, objectify.StringElement))
768
769 - def test_type_str_floatliteral(self):
770 Element = self.Element 771 SubElement = self.etree.SubElement 772 root = Element("{objectified}root") 773 root.s = "3.72" 774 self.assert_(isinstance(root.s, objectify.StringElement))
775
776 - def test_type_str_mul(self):
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
788 - def test_type_str_add(self):
789 Element = self.Element 790 SubElement = self.etree.SubElement 791 root = Element("{objectified}root") 792 root.s = "test" 793 794 s = "toast" 795 self.assertEquals("test" + s, root.s + s) 796 self.assertEquals(s + "test", s + root.s)
797
798 - def test_type_str_mod(self):
799 s = "%d %f %s %r" 800 el = objectify.DataElement(s) 801 values = (1, 7.0, "abcd", None) 802 self.assertEquals(s % values, el % values) 803 804 s = "%d" 805 el = objectify.DataElement(s) 806 val = 5 807 self.assertEquals(s % val, el % val) 808 809 s = "%d %s" 810 el = objectify.DataElement(s) 811 val = 5 812 self.assertRaises(TypeError, el.__mod__, val) 813 814 s = "" 815 el = objectify.DataElement(s) 816 val = 5 817 self.assertRaises(TypeError, el.__mod__, val)
818
820 s = "%d %f %s %r" 821 el = objectify.DataElement(s) 822 values = (objectify.DataElement(1), 823 objectify.DataElement(7.0), 824 objectify.DataElement("abcd"), 825 objectify.DataElement(None)) 826 self.assertEquals(s % values, el % values)
827
828 - def test_data_element_str(self):
829 value = objectify.DataElement("test") 830 self.assert_(isinstance(value, objectify.StringElement)) 831 self.assertEquals(value, "test")
832
834 value = objectify.DataElement("3") 835 self.assert_(isinstance(value, objectify.StringElement)) 836 self.assertEquals(value, "3")
837
839 value = objectify.DataElement("3.20") 840 self.assert_(isinstance(value, objectify.StringElement)) 841 self.assertEquals(value, "3.20")
842
843 - def test_type_ustr(self):
844 Element = self.Element 845 SubElement = self.etree.SubElement 846 root = Element("{objectified}root") 847 root.s = u"test" 848 self.assert_(isinstance(root.s, objectify.StringElement))
849
850 - def test_type_ustr_intliteral(self):
851 Element = self.Element 852 SubElement = self.etree.SubElement 853 root = Element("{objectified}root") 854 root.s = u"3" 855 self.assert_(isinstance(root.s, objectify.StringElement))
856
858 Element = self.Element 859 SubElement = self.etree.SubElement 860 root = Element("{objectified}root") 861 root.s = u"3.72" 862 self.assert_(isinstance(root.s, objectify.StringElement))
863
864 - def test_type_ustr_mul(self):
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
876 - def test_type_ustr_add(self):
877 Element = self.Element 878 SubElement = self.etree.SubElement 879 root = Element("{objectified}root") 880 root.s = u"test" 881 882 s = u"toast" 883 self.assertEquals(u"test" + s, root.s + s) 884 self.assertEquals(s + u"test", s + root.s)
885
886 - def test_data_element_ustr(self):
887 value = objectify.DataElement(u"test") 888 self.assert_(isinstance(value, objectify.StringElement)) 889 self.assertEquals(value, u"test")
890
892 value = objectify.DataElement("3") 893 self.assert_(isinstance(value, objectify.StringElement)) 894 self.assertEquals(value, u"3")
895
897 value = objectify.DataElement(u"3.20") 898 self.assert_(isinstance(value, objectify.StringElement)) 899 self.assertEquals(value, u"3.20")
900
901 - def test_type_int(self):
902 Element = self.Element 903 SubElement = self.etree.SubElement 904 root = Element("{objectified}root") 905 root.none = 5 906 self.assert_(isinstance(root.none, objectify.IntElement))
907
908 - def test_data_element_int(self):
909 value = objectify.DataElement(5) 910 self.assert_(isinstance(value, objectify.IntElement)) 911 self.assertEquals(value, 5)
912
913 - def test_type_float(self):
914 Element = self.Element 915 SubElement = self.etree.SubElement 916 root = Element("{objectified}root") 917 root.none = 5.5 918 self.assert_(isinstance(root.none, objectify.FloatElement))
919
920 - def test_data_element_float(self):
921 value = objectify.DataElement(5.5) 922 self.assert_(isinstance(value, objectify.FloatElement)) 923 self.assertEquals(value, 5.5)
924
925 - def test_data_element_xsitypes(self):
926 for xsi, objclass in xsitype2objclass.iteritems(): 927 # 1 is a valid value for all ObjectifiedDataElement classes 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 # 1 is a valid value for all ObjectifiedDataElement classes 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
944 for xsi, objclass in xsitype2objclass.iteritems(): 945 # 1 is a valid value for all ObjectifiedDataElement classes 946 self.assertRaises(ValueError, objectify.DataElement, 1, 947 _xsi="foo:%s" % xsi)
948
949 - def test_data_element_pytypes(self):
950 for pytype, objclass in pytype2objclass.iteritems(): 951 # 1 is a valid value for all ObjectifiedDataElement classes 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 # pre-2.0 lxml called NoneElement "none" 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
981 - def test_type_unregistered(self):
982 Element = self.Element 983 SubElement = self.etree.SubElement 984 class MyFloat(float): 985 pass
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
991 - def test_data_element_unregistered(self):
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
999 - def test_schema_types(self):
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
1067 - def test_schema_types_prefixed(self):
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
1136 - def test_type_str_sequence(self):
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
1143 - def test_type_str_cmp(self):
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
1172 - def test_type_int_cmp(self):
1173 XML = self.XML 1174 root = XML(u'<root><b>5</b><b>6</b></root>') 1175 self.assert_(root.b[0] < root.b[1]) 1176 self.assert_(root.b[0] <= root.b[1]) 1177 self.assert_(root.b[0] != root.b[1]) 1178 1179 self.assertFalse(root.b[0] == root.b[1]) 1180 self.assertFalse(root.b[0] >= root.b[1]) 1181 self.assertFalse(root.b[0] > root.b[1]) 1182 1183 self.assertEquals(root.b[0], 5) 1184 self.assertEquals(5, root.b[0]) 1185 self.assert_(root.b[0] < "5") 1186 self.assert_("5" > root.b[0]) 1187 1188 root.b = 5 1189 self.assert_(root.b) 1190 root.b = 0 1191 self.assertFalse(root.b)
1192 1193 # float + long share the NumberElement implementation with int 1194
1195 - def test_type_bool_cmp(self):
1196 XML = self.XML 1197 root = XML(u'<root><b>false</b><b>true</b></root>') 1198 self.assert_(root.b[0] < root.b[1]) 1199 self.assert_(root.b[0] <= root.b[1]) 1200 self.assert_(root.b[0] != root.b[1]) 1201 1202 self.assertFalse(root.b[0] == root.b[1]) 1203 self.assertFalse(root.b[0] >= root.b[1]) 1204 self.assertFalse(root.b[0] > root.b[1]) 1205 1206 self.assertFalse(root.b[0]) 1207 self.assert_(root.b[1]) 1208 1209 self.assertEquals(root.b[0], False) 1210 self.assertEquals(False, root.b[0]) 1211 self.assert_(root.b[0] < 5) 1212 self.assert_(5 > root.b[0]) 1213 1214 root.b = True 1215 self.assert_(root.b) 1216 root.b = False 1217 self.assertFalse(root.b)
1218
1219 - def test_type_none_cmp(self):
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
1237 - def test_dataelement_xsi(self):
1238 el = objectify.DataElement(1, _xsi="string") 1239 self.assertEquals( 1240 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1241 'xsd:string')
1242
1243 - def test_dataelement_xsi_nsmap(self):
1244 el = objectify.DataElement(1, _xsi="string", 1245 nsmap={'schema': XML_SCHEMA_NS}) 1246 self.assertEquals( 1247 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1248 'schema:string')
1249
1250 - def test_dataelement_xsi_prefix_error(self):
1251 self.assertRaises(ValueError, objectify.DataElement, 1, 1252 _xsi="foo:string")
1253
1254 - def test_pytype_annotation(self):
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
1296 - def test_pytype_annotation_empty(self):
1297 XML = self.XML 1298 root = XML(u'''\ 1299 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1300 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1301 <n></n> 1302 </a> 1303 ''') 1304 objectify.annotate(root) 1305 1306 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1307 for c in root.iterchildren() ] 1308 self.assertEquals(None, child_types[0]) 1309 1310 objectify.annotate(root, empty_pytype="str") 1311 1312 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1313 for c in root.iterchildren() ] 1314 self.assertEquals("str", child_types[0])
1315
1316 - def test_pytype_annotation_use_old(self):
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
1358 - def test_pytype_xsitype_annotation(self):
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 # check py annotations 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 # check xsi annotations 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
1425 - def test_xsiannotate_use_old(self):
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
1465 - def test_pyannotate_ignore_old(self):
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
1507 - def test_pyannotate_empty(self):
1508 XML = self.XML 1509 root = XML(u'''\ 1510 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1511 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1512 <n></n> 1513 </a> 1514 ''') 1515 objectify.pyannotate(root) 1516 1517 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1518 for c in root.iterchildren() ] 1519 self.assertEquals(None, child_types[0]) 1520 1521 objectify.annotate(root, empty_pytype="str") 1522 1523 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1524 for c in root.iterchildren() ] 1525 self.assertEquals("str", child_types[0])
1526
1527 - def test_pyannotate_use_old(self):
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
1569 - def test_xsiannotate_ignore_old(self):
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
1611 - def test_deannotate(self):
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
1640 - def test_pytype_deannotate(self):
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
1686 - def test_xsitype_deannotate(self):
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
1733 - def test_pytype_deannotate(self):
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
1780 - def test_change_pytype_attribute(self):
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
1825 - def test_registered_types(self):
1826 orig_types = objectify.getRegisteredTypes() 1827 orig_types[0].unregister() 1828 self.assertEquals(orig_types[1:], objectify.getRegisteredTypes()) 1829 1830 class NewType(objectify.ObjectifiedDataElement): 1831 pass
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
1855 - def test_registered_type_stringify(self):
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
1902 - def test_object_path(self):
1903 root = self.XML(xml_str) 1904 path = objectify.ObjectPath( "root.c1.c2" ) 1905 self.assertEquals(root.c1.c2.text, path.find(root).text) 1906 self.assertEquals(root.c1.c2.text, path(root).text)
1907
1908 - def test_object_path_list(self):
1909 root = self.XML(xml_str) 1910 path = objectify.ObjectPath( ['root', 'c1', 'c2'] ) 1911 self.assertEquals(root.c1.c2.text, path.find(root).text) 1912 self.assertEquals(root.c1.c2.text, path(root).text)
1913
1914 - def test_object_path_fail(self):
1915 root = self.XML(xml_str) 1916 path = objectify.ObjectPath( "root.c1.c99" ) 1917 self.assertRaises(AttributeError, path, root) 1918 self.assertEquals(None, path(root, None))
1919
1920 - def test_object_path_syntax(self):
1921 root = self.XML(xml_str) 1922 path = objectify.ObjectPath("root . {objectified}c1. c2") 1923 self.assertEquals(root.c1.c2.text, path(root).text) 1924 1925 path = objectify.ObjectPath(" root.{objectified} c1.c2 [ 0 ] ") 1926 self.assertEquals(root.c1.c2.text, path(root).text)
1927
1928 - def test_object_path_hasattr(self):
1929 root = self.XML(xml_str) 1930 path = objectify.ObjectPath( "root" ) 1931 self.assert_(path.hasattr(root)) 1932 path = objectify.ObjectPath( "root.c1" ) 1933 self.assert_(path.hasattr(root)) 1934 path = objectify.ObjectPath( "root.c1.c2" ) 1935 self.assert_(path.hasattr(root)) 1936 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 1937 self.assert_(path.hasattr(root)) 1938 path = objectify.ObjectPath( "root.c1.c2[1]" ) 1939 self.assert_(path.hasattr(root)) 1940 path = objectify.ObjectPath( "root.c1.c2[2]" ) 1941 self.assert_(path.hasattr(root)) 1942 path = objectify.ObjectPath( "root.c1.c2[3]" ) 1943 self.assertFalse(path.hasattr(root)) 1944 path = objectify.ObjectPath( "root.c1[1].c2" ) 1945 self.assertFalse(path.hasattr(root))
1946
1947 - def test_object_path_dot(self):
1948 root = self.XML(xml_str) 1949 path = objectify.ObjectPath( "." ) 1950 self.assertEquals(root.c1.c2.text, path(root).c1.c2.text)
1951
1952 - def test_object_path_dot_list(self):
1953 root = self.XML(xml_str) 1954 path = objectify.ObjectPath( [''] ) 1955 self.assertEquals(root.c1.c2.text, path(root).c1.c2.text)
1956
1957 - def test_object_path_dot_root(self):
1958 root = self.XML(xml_str) 1959 path = objectify.ObjectPath( ".c1.c2" ) 1960 self.assertEquals(root.c1.c2.text, path(root).text)
1961
1962 - def test_object_path_dot_root_list(self):
1963 root = self.XML(xml_str) 1964 path = objectify.ObjectPath( ['', 'c1', 'c2'] ) 1965 self.assertEquals(root.c1.c2.text, path(root).text)
1966
1967 - def test_object_path_index(self):
1968 root = self.XML(xml_str) 1969 path = objectify.ObjectPath( "root.c1[0].c2[0]" ) 1970 self.assertEquals(root.c1.c2.text, path(root).text) 1971 1972 path = objectify.ObjectPath( "root.c1[0].c2" ) 1973 self.assertEquals(root.c1.c2.text, path(root).text) 1974 1975 path = objectify.ObjectPath( "root.c1[0].c2[1]" ) 1976 self.assertEquals(root.c1.c2[1].text, path(root).text) 1977 1978 path = objectify.ObjectPath( "root.c1.c2[2]" ) 1979 self.assertEquals(root.c1.c2[2].text, path(root).text) 1980 1981 path = objectify.ObjectPath( "root.c1.c2[-1]" ) 1982 self.assertEquals(root.c1.c2[-1].text, path(root).text) 1983 1984 path = objectify.ObjectPath( "root.c1.c2[-3]" ) 1985 self.assertEquals(root.c1.c2[-3].text, path(root).text)
1986
1987 - def test_object_path_index_list(self):
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
2004 - def test_object_path_index_fail_parse(self):
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
2020 - def test_object_path_index_fail_lookup(self):
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
2037 - def test_object_path_ns(self):
2038 root = self.XML(xml_str) 2039 path = objectify.ObjectPath( "{objectified}root.c1.c2" ) 2040 self.assertEquals(root.c1.c2.text, path.find(root).text) 2041 path = objectify.ObjectPath( "{objectified}root.{objectified}c1.c2" ) 2042 self.assertEquals(root.c1.c2.text, path.find(root).text) 2043 path = objectify.ObjectPath( "root.{objectified}c1.{objectified}c2" ) 2044 self.assertEquals(root.c1.c2.text, path.find(root).text) 2045 path = objectify.ObjectPath( "root.c1.{objectified}c2" ) 2046 self.assertEquals(root.c1.c2.text, path.find(root).text) 2047 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 2048 self.assertEquals(getattr(root.c1, '{otherNS}c2').text, 2049 path.find(root).text)
2050
2051 - def test_object_path_ns_list(self):
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
2069 - def test_object_path_set(self):
2070 root = self.XML(xml_str) 2071 path = objectify.ObjectPath( "root.c1.c2" ) 2072 self.assertEquals(root.c1.c2.text, path.find(root).text) 2073 self.assertEquals("1", root.c1.c2[1].text) 2074 2075 new_value = "my new value" 2076 path.setattr(root, new_value) 2077 2078 self.assertEquals(new_value, root.c1.c2.text) 2079 self.assertEquals(new_value, path(root).text) 2080 self.assertEquals("1", root.c1.c2[1].text)
2081
2082 - def test_object_path_set_element(self):
2083 root = self.XML(xml_str) 2084 path = objectify.ObjectPath( "root.c1.c2" ) 2085 self.assertEquals(root.c1.c2.text, path.find(root).text) 2086 self.assertEquals("1", root.c1.c2[1].text) 2087 2088 new_el = self.Element("{objectified}test") 2089 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2090 path.setattr(root, new_el.sub) 2091 2092 self.assertEquals("ATTR", root.c1.c2.get("myattr")) 2093 self.assertEquals("TEST", root.c1.c2.a.text) 2094 self.assertEquals("TEST", path(root).a.text) 2095 self.assertEquals("1", root.c1.c2[1].text)
2096
2097 - def test_object_path_set_create(self):
2098 root = self.XML(xml_str) 2099 path = objectify.ObjectPath( "root.c1.c99" ) 2100 self.assertRaises(AttributeError, path.find, root) 2101 2102 new_value = "my new value" 2103 path.setattr(root, new_value) 2104 2105 self.assertEquals(1, len(root.c1.c99)) 2106 self.assertEquals(new_value, root.c1.c99.text) 2107 self.assertEquals(new_value, path(root).text)
2108
2109 - def test_object_path_set_create_element(self):
2110 root = self.XML(xml_str) 2111 path = objectify.ObjectPath( "root.c1.c99" ) 2112 self.assertRaises(AttributeError, path.find, root) 2113 2114 new_el = self.Element("{objectified}test") 2115 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2116 path.setattr(root, new_el.sub) 2117 2118 self.assertEquals(1, len(root.c1.c99)) 2119 self.assertEquals("ATTR", root.c1.c99.get("myattr")) 2120 self.assertEquals("TEST", root.c1.c99.a.text) 2121 self.assertEquals("TEST", path(root).a.text)
2122
2123 - def test_object_path_set_create_list(self):
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
2142 - def test_object_path_addattr(self):
2143 root = self.XML(xml_str) 2144 path = objectify.ObjectPath( "root.c1.c2" ) 2145 self.assertEquals(3, len(root.c1.c2)) 2146 path.addattr(root, "test") 2147 self.assertEquals(4, len(root.c1.c2)) 2148 self.assertEquals(["0", "1", "2", "test"], 2149 [el.text for el in root.c1.c2])
2150
2151 - def test_object_path_addattr_element(self):
2152 root = self.XML(xml_str) 2153 path = objectify.ObjectPath( "root.c1.c2" ) 2154 self.assertEquals(3, len(root.c1.c2)) 2155 2156 new_el = self.Element("{objectified}test") 2157 etree.SubElement(new_el, "{objectified}sub").a = "TEST" 2158 2159 path.addattr(root, new_el.sub) 2160 self.assertEquals(4, len(root.c1.c2)) 2161 self.assertEquals("TEST", root.c1.c2[3].a.text) 2162 self.assertEquals(["0", "1", "2"], 2163 [el.text for el in root.c1.c2[:3]])
2164
2165 - def test_object_path_addattr_create(self):
2166 root = self.XML(xml_str) 2167 path = objectify.ObjectPath( "root.c1.c99" ) 2168 self.assertRaises(AttributeError, path.find, root) 2169 2170 new_value = "my new value" 2171 path.addattr(root, new_value) 2172 2173 self.assertEquals(1, len(root.c1.c99)) 2174 self.assertEquals(new_value, root.c1.c99.text) 2175 self.assertEquals(new_value, path(root).text)
2176
2177 - def test_object_path_addattr_create_element(self):
2178 root = self.XML(xml_str) 2179 path = objectify.ObjectPath( "root.c1.c99" ) 2180 self.assertRaises(AttributeError, path.find, root) 2181 2182 new_el = self.Element("{objectified}test") 2183 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2184 2185 path.addattr(root, new_el.sub) 2186 self.assertEquals(1, len(root.c1.c99)) 2187 self.assertEquals("TEST", root.c1.c99.a.text) 2188 self.assertEquals("TEST", path(root).a.text) 2189 self.assertEquals("ATTR", root.c1.c99.get("myattr"))
2190
2191 - def test_object_path_addattr_create_list(self):
2192 root = self.XML(xml_str) 2193 path = objectify.ObjectPath( "root.c1.c99" ) 2194 self.assertRaises(AttributeError, path.find, root) 2195 2196 new_el = self.Element("{objectified}test") 2197 new_el.a = ["TEST1", "TEST2"] 2198 2199 self.assertEquals(2, len(new_el.a)) 2200 2201 path.addattr(root, list(new_el.a)) 2202 self.assertEquals(2, len(root.c1.c99)) 2203 self.assertEquals("TEST1", root.c1.c99.text) 2204 self.assertEquals("TEST2", path(root)[1].text)
2205
2206 - def test_descendant_paths(self):
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
2215 - def test_descendant_paths_child(self):
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
2223 - def test_descendant_paths_prefix(self):
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
2232 - def test_pickle(self):
2233 import pickle 2234 2235 root = self.XML(xml_str) 2236 out = StringIO() 2237 pickle.dump(root, out) 2238 2239 new_root = pickle.loads(out.getvalue()) 2240 self.assertEquals( 2241 etree.tostring(new_root), 2242 etree.tostring(root))
2243 2244 # E-Factory tests, need to use sub-elements as root element is always 2245 # type-looked-up as ObjectifiedElement (no annotations)
2246 - def test_efactory_int(self):
2247 E = objectify.E 2248 root = E.root(E.val(23)) 2249 self.assert_(isinstance(root.val, objectify.IntElement))
2250
2251 - def test_efactory_long(self):
2252 E = objectify.E 2253 root = E.root(E.val(23L)) 2254 self.assert_(isinstance(root.val, objectify.LongElement))
2255
2256 - def test_efactory_float(self):
2257 E = objectify.E 2258 root = E.root(E.val(233.23)) 2259 self.assert_(isinstance(root.val, objectify.FloatElement))
2260
2261 - def test_efactory_str(self):
2262 E = objectify.E 2263 root = E.root(E.val("what?")) 2264 self.assert_(isinstance(root.val, objectify.StringElement))
2265
2266 - def test_efactory_unicode(self):
2267 E = objectify.E 2268 root = E.root(E.val(unicode("blöödy häll", encoding="ISO-8859-1"))) 2269 self.assert_(isinstance(root.val, objectify.StringElement))
2270
2271 - def test_efactory_bool(self):
2272 E = objectify.E 2273 root = E.root(E.val(True)) 2274 self.assert_(isinstance(root.val, objectify.BoolElement))
2275
2276 - def test_efactory_none(self):
2277 E = objectify.E 2278 root = E.root(E.val(None)) 2279 self.assert_(isinstance(root.val, objectify.NoneElement))
2280
2281 - def test_efactory_value_concatenation(self):
2282 E = objectify.E 2283 root = E.root(E.val(1, "foo", 2.0, "bar ", True, None)) 2284 self.assert_(isinstance(root.val, objectify.StringElement))
2285
2286 - def test_efactory_attrib(self):
2287 E = objectify.E 2288 root = E.root(foo="bar") 2289 self.assertEquals(root.get("foo"), "bar")
2290
2291 - def test_efactory_nested(self):
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
2305 -def test_suite():
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