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.assertEquals(root.bool + root.bool, True + True) 741 self.assertEquals(True + root.bool, True + root.bool) 742 self.assertEquals(root.bool * root.bool, True * True) 743 self.assertEquals(int(root.bool), int(True)) 744 self.assertEquals(complex(root.bool), complex(True)) 745 self.assert_(isinstance(root.bool, objectify.BoolElement)) 746 747 root.bool = False 748 self.assertEquals(root.bool, False) 749 self.assertEquals(root.bool + root.bool, False + False) 750 self.assertEquals(False + root.bool, False + root.bool) 751 self.assertEquals(root.bool * root.bool, False * False) 752 self.assertEquals(int(root.bool), int(False)) 753 self.assertEquals(complex(root.bool), complex(False)) 754 self.assert_(isinstance(root.bool, objectify.BoolElement))
755
756 - def test_data_element_bool(self):
757 value = objectify.DataElement(True) 758 self.assert_(isinstance(value, objectify.BoolElement)) 759 self.assertEquals(value, True) 760 761 value = objectify.DataElement(False) 762 self.assert_(isinstance(value, objectify.BoolElement)) 763 self.assertEquals(value, False)
764
765 - def test_type_str(self):
766 Element = self.Element 767 SubElement = self.etree.SubElement 768 root = Element("{objectified}root") 769 root.s = "test" 770 self.assert_(isinstance(root.s, objectify.StringElement))
771
772 - def test_type_str_intliteral(self):
773 Element = self.Element 774 SubElement = self.etree.SubElement 775 root = Element("{objectified}root") 776 root.s = "3" 777 self.assert_(isinstance(root.s, objectify.StringElement))
778
779 - def test_type_str_floatliteral(self):
780 Element = self.Element 781 SubElement = self.etree.SubElement 782 root = Element("{objectified}root") 783 root.s = "3.72" 784 self.assert_(isinstance(root.s, objectify.StringElement))
785
786 - def test_type_str_mul(self):
787 Element = self.Element 788 SubElement = self.etree.SubElement 789 root = Element("{objectified}root") 790 root.s = "test" 791 792 self.assertEquals("test" * 5, root.s * 5) 793 self.assertEquals(5 * "test", 5 * root.s) 794 795 self.assertRaises(TypeError, operator.mul, root.s, "honk") 796 self.assertRaises(TypeError, operator.mul, "honk", root.s)
797
798 - def test_type_str_add(self):
799 Element = self.Element 800 SubElement = self.etree.SubElement 801 root = Element("{objectified}root") 802 root.s = "test" 803 804 s = "toast" 805 self.assertEquals("test" + s, root.s + s) 806 self.assertEquals(s + "test", s + root.s)
807
808 - def test_type_str_mod(self):
809 s = "%d %f %s %r" 810 el = objectify.DataElement(s) 811 values = (1, 7.0, "abcd", None) 812 self.assertEquals(s % values, el % values) 813 814 s = "%d" 815 el = objectify.DataElement(s) 816 val = 5 817 self.assertEquals(s % val, el % val) 818 819 s = "%d %s" 820 el = objectify.DataElement(s) 821 val = 5 822 self.assertRaises(TypeError, el.__mod__, val) 823 824 s = "" 825 el = objectify.DataElement(s) 826 val = 5 827 self.assertRaises(TypeError, el.__mod__, val)
828
829 - def test_type_str_as_int(self):
830 v = "1" 831 el = objectify.DataElement(v) 832 self.assertEquals(int(el), 1)
833
834 - def test_type_str_as_long(self):
835 v = "1" 836 el = objectify.DataElement(v) 837 self.assertEquals(long(el), 1)
838
839 - def test_type_str_as_float(self):
840 v = "1" 841 el = objectify.DataElement(v) 842 self.assertEquals(float(el), 1)
843
844 - def test_type_str_as_complex(self):
845 v = "1" 846 el = objectify.DataElement(v) 847 self.assertEquals(complex(el), 1)
848
850 s = "%d %f %s %r" 851 el = objectify.DataElement(s) 852 values = (objectify.DataElement(1), 853 objectify.DataElement(7.0), 854 objectify.DataElement("abcd"), 855 objectify.DataElement(None)) 856 self.assertEquals(s % values, el % values)
857
858 - def test_data_element_str(self):
859 value = objectify.DataElement("test") 860 self.assert_(isinstance(value, objectify.StringElement)) 861 self.assertEquals(value, "test")
862
864 value = objectify.DataElement("3") 865 self.assert_(isinstance(value, objectify.StringElement)) 866 self.assertEquals(value, "3")
867
869 value = objectify.DataElement("3.20") 870 self.assert_(isinstance(value, objectify.StringElement)) 871 self.assertEquals(value, "3.20")
872
873 - def test_type_ustr(self):
874 Element = self.Element 875 SubElement = self.etree.SubElement 876 root = Element("{objectified}root") 877 root.s = u"test" 878 self.assert_(isinstance(root.s, objectify.StringElement))
879
880 - def test_type_ustr_intliteral(self):
881 Element = self.Element 882 SubElement = self.etree.SubElement 883 root = Element("{objectified}root") 884 root.s = u"3" 885 self.assert_(isinstance(root.s, objectify.StringElement))
886
888 Element = self.Element 889 SubElement = self.etree.SubElement 890 root = Element("{objectified}root") 891 root.s = u"3.72" 892 self.assert_(isinstance(root.s, objectify.StringElement))
893
894 - def test_type_ustr_mul(self):
895 Element = self.Element 896 SubElement = self.etree.SubElement 897 root = Element("{objectified}root") 898 root.s = u"test" 899 900 self.assertEquals(u"test" * 5, root.s * 5) 901 self.assertEquals(5 * u"test", 5 * root.s) 902 903 self.assertRaises(TypeError, operator.mul, root.s, u"honk") 904 self.assertRaises(TypeError, operator.mul, u"honk", root.s)
905
906 - def test_type_ustr_add(self):
907 Element = self.Element 908 SubElement = self.etree.SubElement 909 root = Element("{objectified}root") 910 root.s = u"test" 911 912 s = u"toast" 913 self.assertEquals(u"test" + s, root.s + s) 914 self.assertEquals(s + u"test", s + root.s)
915
916 - def test_data_element_ustr(self):
917 value = objectify.DataElement(u"test") 918 self.assert_(isinstance(value, objectify.StringElement)) 919 self.assertEquals(value, u"test")
920
922 value = objectify.DataElement("3") 923 self.assert_(isinstance(value, objectify.StringElement)) 924 self.assertEquals(value, u"3")
925
927 value = objectify.DataElement(u"3.20") 928 self.assert_(isinstance(value, objectify.StringElement)) 929 self.assertEquals(value, u"3.20")
930
931 - def test_type_int(self):
932 Element = self.Element 933 SubElement = self.etree.SubElement 934 root = Element("{objectified}root") 935 root.none = 5 936 self.assert_(isinstance(root.none, objectify.IntElement))
937
938 - def test_data_element_int(self):
939 value = objectify.DataElement(5) 940 self.assert_(isinstance(value, objectify.IntElement)) 941 self.assertEquals(value, 5)
942
943 - def test_type_float(self):
944 Element = self.Element 945 SubElement = self.etree.SubElement 946 root = Element("{objectified}root") 947 root.none = 5.5 948 self.assert_(isinstance(root.none, objectify.FloatElement))
949
950 - def test_data_element_float(self):
951 value = objectify.DataElement(5.5) 952 self.assert_(isinstance(value, objectify.FloatElement)) 953 self.assertEquals(value, 5.5)
954
955 - def test_data_element_xsitypes(self):
956 for xsi, objclass in xsitype2objclass.iteritems(): 957 # 1 is a valid value for all ObjectifiedDataElement classes 958 pyval = 1 959 value = objectify.DataElement(pyval, _xsi=xsi) 960 self.assert_(isinstance(value, objclass), 961 "DataElement(%s, _xsi='%s') returns %s, expected %s" 962 % (pyval, xsi, type(value), objclass))
963
965 for xsi, objclass in xsitype2objclass.iteritems(): 966 # 1 is a valid value for all ObjectifiedDataElement classes 967 pyval = 1 968 value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi) 969 self.assert_(isinstance(value, objclass), 970 "DataElement(%s, _xsi='%s') returns %s, expected %s" 971 % (pyval, xsi, type(value), objclass))
972
974 for xsi, objclass in xsitype2objclass.iteritems(): 975 # 1 is a valid value for all ObjectifiedDataElement classes 976 self.assertRaises(ValueError, objectify.DataElement, 1, 977 _xsi="foo:%s" % xsi)
978
979 - def test_data_element_pytypes(self):
980 for pytype, objclass in pytype2objclass.iteritems(): 981 # 1 is a valid value for all ObjectifiedDataElement classes 982 pyval = 1 983 value = objectify.DataElement(pyval, _pytype=pytype) 984 self.assert_(isinstance(value, objclass), 985 "DataElement(%s, _pytype='%s') returns %s, expected %s" 986 % (pyval, pytype, type(value), objclass))
987
989 pyval = 1 990 pytype = "NoneType" 991 objclass = objectify.NoneElement 992 value = objectify.DataElement(pyval, _pytype=pytype) 993 self.assert_(isinstance(value, objclass), 994 "DataElement(%s, _pytype='%s') returns %s, expected %s" 995 % (pyval, pytype, type(value), objclass)) 996 self.assertEquals(value.text, None) 997 self.assertEquals(value.pyval, None)
998
1000 # pre-2.0 lxml called NoneElement "none" 1001 pyval = 1 1002 pytype = "none" 1003 objclass = objectify.NoneElement 1004 value = objectify.DataElement(pyval, _pytype=pytype) 1005 self.assert_(isinstance(value, objclass), 1006 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1007 % (pyval, pytype, type(value), objclass)) 1008 self.assertEquals(value.text, None) 1009 self.assertEquals(value.pyval, None)
1010
1011 - def test_type_unregistered(self):
1012 Element = self.Element 1013 SubElement = self.etree.SubElement 1014 class MyFloat(float): 1015 pass
1016 root = Element("{objectified}root") 1017 root.myfloat = MyFloat(5.5) 1018 self.assert_(isinstance(root.myfloat, objectify.FloatElement)) 1019 self.assertEquals(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None)
1020
1021 - def test_data_element_unregistered(self):
1022 class MyFloat(float): 1023 pass
1024 value = objectify.DataElement(MyFloat(5.5)) 1025 self.assert_(isinstance(value, objectify.FloatElement)) 1026 self.assertEquals(value, 5.5) 1027 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), None) 1028
1029 - def test_schema_types(self):
1030 XML = self.XML 1031 root = XML('''\ 1032 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1033 <b xsi:type="boolean">true</b> 1034 <b xsi:type="boolean">false</b> 1035 <b xsi:type="boolean">1</b> 1036 <b xsi:type="boolean">0</b> 1037 1038 <f xsi:type="float">5</f> 1039 <f xsi:type="double">5</f> 1040 1041 <s xsi:type="string">5</s> 1042 <s xsi:type="normalizedString">5</s> 1043 <s xsi:type="token">5</s> 1044 <s xsi:type="language">5</s> 1045 <s xsi:type="Name">5</s> 1046 <s xsi:type="NCName">5</s> 1047 <s xsi:type="ID">5</s> 1048 <s xsi:type="IDREF">5</s> 1049 <s xsi:type="ENTITY">5</s> 1050 <s xsi:type="NMTOKEN">5</s> 1051 1052 <l xsi:type="integer">5</l> 1053 <l xsi:type="nonPositiveInteger">5</l> 1054 <l xsi:type="negativeInteger">5</l> 1055 <l xsi:type="long">5</l> 1056 <l xsi:type="nonNegativeInteger">5</l> 1057 <l xsi:type="unsignedLong">5</l> 1058 <l xsi:type="unsignedInt">5</l> 1059 <l xsi:type="positiveInteger">5</l> 1060 1061 <i xsi:type="int">5</i> 1062 <i xsi:type="short">5</i> 1063 <i xsi:type="byte">5</i> 1064 <i xsi:type="unsignedShort">5</i> 1065 <i xsi:type="unsignedByte">5</i> 1066 1067 <n xsi:nil="true"/> 1068 </root> 1069 ''') 1070 1071 for b in root.b: 1072 self.assert_(isinstance(b, objectify.BoolElement)) 1073 self.assertEquals(True, root.b[0]) 1074 self.assertEquals(False, root.b[1]) 1075 self.assertEquals(True, root.b[2]) 1076 self.assertEquals(False, root.b[3]) 1077 1078 for f in root.f: 1079 self.assert_(isinstance(f, objectify.FloatElement)) 1080 self.assertEquals(5, f) 1081 1082 for s in root.s: 1083 self.assert_(isinstance(s, objectify.StringElement)) 1084 self.assertEquals("5", s) 1085 1086 for l in root.l: 1087 self.assert_(isinstance(l, objectify.LongElement)) 1088 self.assertEquals(5L, l) 1089 1090 for i in root.i: 1091 self.assert_(isinstance(i, objectify.IntElement)) 1092 self.assertEquals(5, i) 1093 1094 self.assert_(isinstance(root.n, objectify.NoneElement)) 1095 self.assertEquals(None, root.n)
1096
1097 - def test_schema_types_prefixed(self):
1098 XML = self.XML 1099 root = XML('''\ 1100 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1101 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1102 <b xsi:type="xsd:boolean">true</b> 1103 <b xsi:type="xsd:boolean">false</b> 1104 <b xsi:type="xsd:boolean">1</b> 1105 <b xsi:type="xsd:boolean">0</b> 1106 1107 <f xsi:type="xsd:float">5</f> 1108 <f xsi:type="xsd:double">5</f> 1109 1110 <s xsi:type="xsd:string">5</s> 1111 <s xsi:type="xsd:normalizedString">5</s> 1112 <s xsi:type="xsd:token">5</s> 1113 <s xsi:type="xsd:language">5</s> 1114 <s xsi:type="xsd:Name">5</s> 1115 <s xsi:type="xsd:NCName">5</s> 1116 <s xsi:type="xsd:ID">5</s> 1117 <s xsi:type="xsd:IDREF">5</s> 1118 <s xsi:type="xsd:ENTITY">5</s> 1119 <s xsi:type="xsd:NMTOKEN">5</s> 1120 1121 <l xsi:type="xsd:integer">5</l> 1122 <l xsi:type="xsd:nonPositiveInteger">5</l> 1123 <l xsi:type="xsd:negativeInteger">5</l> 1124 <l xsi:type="xsd:long">5</l> 1125 <l xsi:type="xsd:nonNegativeInteger">5</l> 1126 <l xsi:type="xsd:unsignedLong">5</l> 1127 <l xsi:type="xsd:unsignedInt">5</l> 1128 <l xsi:type="xsd:positiveInteger">5</l> 1129 1130 <i xsi:type="xsd:int">5</i> 1131 <i xsi:type="xsd:short">5</i> 1132 <i xsi:type="xsd:byte">5</i> 1133 <i xsi:type="xsd:unsignedShort">5</i> 1134 <i xsi:type="xsd:unsignedByte">5</i> 1135 1136 <n xsi:nil="true"/> 1137 </root> 1138 ''') 1139 1140 for b in root.b: 1141 self.assert_(isinstance(b, objectify.BoolElement)) 1142 self.assertEquals(True, root.b[0]) 1143 self.assertEquals(False, root.b[1]) 1144 self.assertEquals(True, root.b[2]) 1145 self.assertEquals(False, root.b[3]) 1146 1147 for f in root.f: 1148 self.assert_(isinstance(f, objectify.FloatElement)) 1149 self.assertEquals(5, f) 1150 1151 for s in root.s: 1152 self.assert_(isinstance(s, objectify.StringElement)) 1153 self.assertEquals("5", s) 1154 1155 for l in root.l: 1156 self.assert_(isinstance(l, objectify.LongElement)) 1157 self.assertEquals(5L, l) 1158 1159 for i in root.i: 1160 self.assert_(isinstance(i, objectify.IntElement)) 1161 self.assertEquals(5, i) 1162 1163 self.assert_(isinstance(root.n, objectify.NoneElement)) 1164 self.assertEquals(None, root.n)
1165
1166 - def test_type_str_sequence(self):
1167 XML = self.XML 1168 root = XML(u'<root><b>why</b><b>try</b></root>') 1169 strs = [ str(s) for s in root.b ] 1170 self.assertEquals(["why", "try"], 1171 strs)
1172
1173 - def test_type_str_cmp(self):
1174 XML = self.XML 1175 root = XML(u'<root><b>test</b><b>taste</b><b></b><b/></root>') 1176 self.assertFalse(root.b[0] < root.b[1]) 1177 self.assertFalse(root.b[0] <= root.b[1]) 1178 self.assertFalse(root.b[0] == root.b[1]) 1179 1180 self.assert_(root.b[0] != root.b[1]) 1181 self.assert_(root.b[0] >= root.b[1]) 1182 self.assert_(root.b[0] > root.b[1]) 1183 1184 self.assertEquals(root.b[0], "test") 1185 self.assertEquals("test", root.b[0]) 1186 self.assert_(root.b[0] > 5) 1187 self.assert_(5 < root.b[0]) 1188 1189 self.assertEquals("", root.b[2]) 1190 self.assertEquals(root.b[2], "") 1191 self.assertEquals("", root.b[3]) 1192 self.assertEquals(root.b[3], "") 1193 self.assertEquals(root.b[2], root.b[3]) 1194 1195 root.b = "test" 1196 self.assert_(root.b) 1197 root.b = "" 1198 self.assertFalse(root.b) 1199 self.assertEquals(root.b, "") 1200 self.assertEquals("", root.b)
1201
1202 - def test_type_int_cmp(self):
1203 XML = self.XML 1204 root = XML(u'<root><b>5</b><b>6</b></root>') 1205 self.assert_(root.b[0] < root.b[1]) 1206 self.assert_(root.b[0] <= root.b[1]) 1207 self.assert_(root.b[0] != root.b[1]) 1208 1209 self.assertFalse(root.b[0] == root.b[1]) 1210 self.assertFalse(root.b[0] >= root.b[1]) 1211 self.assertFalse(root.b[0] > root.b[1]) 1212 1213 self.assertEquals(root.b[0], 5) 1214 self.assertEquals(5, root.b[0]) 1215 self.assert_(root.b[0] < "5") 1216 self.assert_("5" > root.b[0]) 1217 1218 root.b = 5 1219 self.assert_(root.b) 1220 root.b = 0 1221 self.assertFalse(root.b)
1222 1223 # float + long share the NumberElement implementation with int 1224
1225 - def test_type_bool_cmp(self):
1226 XML = self.XML 1227 root = XML(u'<root><b>false</b><b>true</b></root>') 1228 self.assert_(root.b[0] < root.b[1]) 1229 self.assert_(root.b[0] <= root.b[1]) 1230 self.assert_(root.b[0] != root.b[1]) 1231 1232 self.assertFalse(root.b[0] == root.b[1]) 1233 self.assertFalse(root.b[0] >= root.b[1]) 1234 self.assertFalse(root.b[0] > root.b[1]) 1235 1236 self.assertFalse(root.b[0]) 1237 self.assert_(root.b[1]) 1238 1239 self.assertEquals(root.b[0], False) 1240 self.assertEquals(False, root.b[0]) 1241 self.assert_(root.b[0] < 5) 1242 self.assert_(5 > root.b[0]) 1243 1244 root.b = True 1245 self.assert_(root.b) 1246 root.b = False 1247 self.assertFalse(root.b)
1248
1249 - def test_type_none_cmp(self):
1250 XML = self.XML 1251 root = XML(u""" 1252 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1253 <b xsi:nil="true"></b><b xsi:nil="true"/> 1254 </root>""") 1255 self.assert_(root.b[0] == root.b[1]) 1256 self.assertFalse(root.b[0]) 1257 self.assertEquals(root.b[0], None) 1258 self.assertEquals(None, root.b[0]) 1259 1260 for comparison in ["abc", 5, 7.3, True, [], ()]: 1261 none = root.b[1] 1262 self.assert_(none < comparison, "%s (%s) should be < %s" % 1263 (none, type(none), comparison) ) 1264 self.assert_(comparison > none, "%s should be > %s (%s)" % 1265 (comparison, none, type(none)) )
1266
1267 - def test_dataelement_xsi(self):
1268 el = objectify.DataElement(1, _xsi="string") 1269 self.assertEquals( 1270 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1271 'xsd:string')
1272
1273 - def test_dataelement_xsi_nsmap(self):
1274 el = objectify.DataElement(1, _xsi="string", 1275 nsmap={'schema': XML_SCHEMA_NS}) 1276 self.assertEquals( 1277 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1278 'schema:string')
1279
1280 - def test_dataelement_xsi_prefix_error(self):
1281 self.assertRaises(ValueError, objectify.DataElement, 1, 1282 _xsi="foo:string")
1283
1284 - def test_pytype_annotation(self):
1285 XML = self.XML 1286 root = XML(u'''\ 1287 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1288 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1289 <b>5</b> 1290 <b>test</b> 1291 <c>1.1</c> 1292 <c>\uF8D2</c> 1293 <x>true</x> 1294 <n xsi:nil="true" /> 1295 <n></n> 1296 <b xsi:type="double">5</b> 1297 <b xsi:type="float">5</b> 1298 <s xsi:type="string">23</s> 1299 <s py:pytype="str">42</s> 1300 <f py:pytype="float">300</f> 1301 <l py:pytype="long">2</l> 1302 <t py:pytype="TREE"></t> 1303 </a> 1304 ''') 1305 objectify.annotate(root) 1306 1307 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1308 for c in root.iterchildren() ] 1309 self.assertEquals("int", child_types[ 0]) 1310 self.assertEquals("str", child_types[ 1]) 1311 self.assertEquals("float", child_types[ 2]) 1312 self.assertEquals("str", child_types[ 3]) 1313 self.assertEquals("bool", child_types[ 4]) 1314 self.assertEquals("NoneType", child_types[ 5]) 1315 self.assertEquals(None, child_types[ 6]) 1316 self.assertEquals("float", child_types[ 7]) 1317 self.assertEquals("float", child_types[ 8]) 1318 self.assertEquals("str", child_types[ 9]) 1319 self.assertEquals("int", child_types[10]) 1320 self.assertEquals("int", child_types[11]) 1321 self.assertEquals("int", child_types[12]) 1322 self.assertEquals(None, child_types[13]) 1323 1324 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1325
1326 - def test_pytype_annotation_empty(self):
1327 XML = self.XML 1328 root = XML(u'''\ 1329 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1330 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1331 <n></n> 1332 </a> 1333 ''') 1334 objectify.annotate(root) 1335 1336 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1337 for c in root.iterchildren() ] 1338 self.assertEquals(None, child_types[0]) 1339 1340 objectify.annotate(root, empty_pytype="str") 1341 1342 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1343 for c in root.iterchildren() ] 1344 self.assertEquals("str", child_types[0])
1345
1346 - def test_pytype_annotation_use_old(self):
1347 XML = self.XML 1348 root = XML(u'''\ 1349 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1350 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1351 <b>5</b> 1352 <b>test</b> 1353 <c>1.1</c> 1354 <c>\uF8D2</c> 1355 <x>true</x> 1356 <n xsi:nil="true" /> 1357 <n></n> 1358 <b xsi:type="double">5</b> 1359 <b xsi:type="float">5</b> 1360 <s xsi:type="string">23</s> 1361 <s py:pytype="str">42</s> 1362 <f py:pytype="float">300</f> 1363 <l py:pytype="long">2</l> 1364 <t py:pytype="TREE"></t> 1365 </a> 1366 ''') 1367 objectify.annotate(root, ignore_old=False) 1368 1369 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1370 for c in root.iterchildren() ] 1371 self.assertEquals("int", child_types[ 0]) 1372 self.assertEquals("str", child_types[ 1]) 1373 self.assertEquals("float", child_types[ 2]) 1374 self.assertEquals("str", child_types[ 3]) 1375 self.assertEquals("bool", child_types[ 4]) 1376 self.assertEquals("NoneType", child_types[ 5]) 1377 self.assertEquals(None, child_types[ 6]) 1378 self.assertEquals("float", child_types[ 7]) 1379 self.assertEquals("float", child_types[ 8]) 1380 self.assertEquals("str", child_types[ 9]) 1381 self.assertEquals("str", child_types[10]) 1382 self.assertEquals("float", child_types[11]) 1383 self.assertEquals("long", child_types[12]) 1384 self.assertEquals(TREE_PYTYPE, child_types[13]) 1385 1386 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1387
1388 - def test_pytype_xsitype_annotation(self):
1389 XML = self.XML 1390 root = XML(u'''\ 1391 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1392 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1393 <b>5</b> 1394 <b>test</b> 1395 <c>1.1</c> 1396 <c>\uF8D2</c> 1397 <x>true</x> 1398 <n xsi:nil="true" /> 1399 <n></n> 1400 <b xsi:type="double">5</b> 1401 <b xsi:type="float">5</b> 1402 <s xsi:type="string">23</s> 1403 <s py:pytype="str">42</s> 1404 <f py:pytype="float">300</f> 1405 <l py:pytype="long">2</l> 1406 <t py:pytype="TREE"></t> 1407 </a> 1408 ''') 1409 objectify.annotate(root, ignore_old=False, ignore_xsi=False, 1410 annotate_xsi=1, annotate_pytype=1) 1411 1412 # check py annotations 1413 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1414 for c in root.iterchildren() ] 1415 self.assertEquals("int", child_types[ 0]) 1416 self.assertEquals("str", child_types[ 1]) 1417 self.assertEquals("float", child_types[ 2]) 1418 self.assertEquals("str", child_types[ 3]) 1419 self.assertEquals("bool", child_types[ 4]) 1420 self.assertEquals("NoneType", child_types[ 5]) 1421 self.assertEquals(None, child_types[ 6]) 1422 self.assertEquals("float", child_types[ 7]) 1423 self.assertEquals("float", child_types[ 8]) 1424 self.assertEquals("str", child_types[ 9]) 1425 self.assertEquals("str", child_types[10]) 1426 self.assertEquals("float", child_types[11]) 1427 self.assertEquals("long", child_types[12]) 1428 self.assertEquals(TREE_PYTYPE, child_types[13]) 1429 1430 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1431 1432 child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1433 for c in root.iterchildren() ] 1434 1435 # check xsi annotations 1436 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1437 for c in root.iterchildren() ] 1438 self.assertEquals("xsd:int", child_types[ 0]) 1439 self.assertEquals("xsd:string", child_types[ 1]) 1440 self.assertEquals("xsd:double", child_types[ 2]) 1441 self.assertEquals("xsd:string", child_types[ 3]) 1442 self.assertEquals("xsd:boolean", child_types[ 4]) 1443 self.assertEquals(None, child_types[ 5]) 1444 self.assertEquals(None, child_types[ 6]) 1445 self.assertEquals("xsd:double", child_types[ 7]) 1446 self.assertEquals("xsd:float", child_types[ 8]) 1447 self.assertEquals("xsd:string", child_types[ 9]) 1448 self.assertEquals("xsd:string", child_types[10]) 1449 self.assertEquals("xsd:double", child_types[11]) 1450 self.assertEquals("xsd:integer", child_types[12]) 1451 self.assertEquals(None, child_types[13]) 1452 1453 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1454
1455 - def test_xsiannotate_use_old(self):
1456 XML = self.XML 1457 root = XML(u'''\ 1458 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1459 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1460 <b>5</b> 1461 <b>test</b> 1462 <c>1.1</c> 1463 <c>\uF8D2</c> 1464 <x>true</x> 1465 <n xsi:nil="true" /> 1466 <n></n> 1467 <b xsi:type="double">5</b> 1468 <b xsi:type="float">5</b> 1469 <s xsi:type="string">23</s> 1470 <s py:pytype="str">42</s> 1471 <f py:pytype="float">300</f> 1472 <l py:pytype="long">2</l> 1473 <t py:pytype="TREE"></t> 1474 </a> 1475 ''') 1476 objectify.xsiannotate(root, ignore_old=False) 1477 1478 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1479 for c in root.iterchildren() ] 1480 self.assertEquals("xsd:int", child_types[ 0]) 1481 self.assertEquals("xsd:string", child_types[ 1]) 1482 self.assertEquals("xsd:double", child_types[ 2]) 1483 self.assertEquals("xsd:string", child_types[ 3]) 1484 self.assertEquals("xsd:boolean", child_types[ 4]) 1485 self.assertEquals(None, child_types[ 5]) 1486 self.assertEquals(None, child_types[ 6]) 1487 self.assertEquals("xsd:double", child_types[ 7]) 1488 self.assertEquals("xsd:float", child_types[ 8]) 1489 self.assertEquals("xsd:string", child_types[ 9]) 1490 self.assertEquals("xsd:string", child_types[10]) 1491 self.assertEquals("xsd:double", child_types[11]) 1492 self.assertEquals("xsd:integer", child_types[12]) 1493 self.assertEquals(None, child_types[13])
1494
1495 - def test_pyannotate_ignore_old(self):
1496 XML = self.XML 1497 root = XML(u'''\ 1498 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1499 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1500 <b>5</b> 1501 <b>test</b> 1502 <c>1.1</c> 1503 <c>\uF8D2</c> 1504 <x>true</x> 1505 <n xsi:nil="true" /> 1506 <n></n> 1507 <b xsi:type="double">5</b> 1508 <b xsi:type="float">5</b> 1509 <s xsi:type="string">23</s> 1510 <s py:pytype="str">42</s> 1511 <f py:pytype="float">300</f> 1512 <l py:pytype="long">2</l> 1513 <t py:pytype="TREE"></t> 1514 </a> 1515 ''') 1516 objectify.pyannotate(root, ignore_old=True) 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 - def test_pyannotate_empty(self):
1538 XML = self.XML 1539 root = XML(u'''\ 1540 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1541 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1542 <n></n> 1543 </a> 1544 ''') 1545 objectify.pyannotate(root) 1546 1547 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1548 for c in root.iterchildren() ] 1549 self.assertEquals(None, child_types[0]) 1550 1551 objectify.annotate(root, empty_pytype="str") 1552 1553 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1554 for c in root.iterchildren() ] 1555 self.assertEquals("str", child_types[0])
1556
1557 - def test_pyannotate_use_old(self):
1558 XML = self.XML 1559 root = XML(u'''\ 1560 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1561 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1562 <b>5</b> 1563 <b>test</b> 1564 <c>1.1</c> 1565 <c>\uF8D2</c> 1566 <x>true</x> 1567 <n xsi:nil="true" /> 1568 <n></n> 1569 <b xsi:type="double">5</b> 1570 <b xsi:type="float">5</b> 1571 <s xsi:type="string">23</s> 1572 <s py:pytype="str">42</s> 1573 <f py:pytype="float">300</f> 1574 <l py:pytype="long">2</l> 1575 <t py:pytype="TREE"></t> 1576 </a> 1577 ''') 1578 objectify.pyannotate(root) 1579 1580 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1581 for c in root.iterchildren() ] 1582 self.assertEquals("int", child_types[ 0]) 1583 self.assertEquals("str", child_types[ 1]) 1584 self.assertEquals("float", child_types[ 2]) 1585 self.assertEquals("str", child_types[ 3]) 1586 self.assertEquals("bool", child_types[ 4]) 1587 self.assertEquals("NoneType", child_types[ 5]) 1588 self.assertEquals(None, child_types[ 6]) 1589 self.assertEquals("float", child_types[ 7]) 1590 self.assertEquals("float", child_types[ 8]) 1591 self.assertEquals("str", child_types[ 9]) 1592 self.assertEquals("str", child_types[10]) 1593 self.assertEquals("float", child_types[11]) 1594 self.assertEquals("long", child_types[12]) 1595 self.assertEquals(TREE_PYTYPE, child_types[13]) 1596 1597 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1598
1599 - def test_xsiannotate_ignore_old(self):
1600 XML = self.XML 1601 root = XML(u'''\ 1602 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1603 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1604 <b>5</b> 1605 <b>test</b> 1606 <c>1.1</c> 1607 <c>\uF8D2</c> 1608 <x>true</x> 1609 <n xsi:nil="true" /> 1610 <n></n> 1611 <b xsi:type="double">5</b> 1612 <b xsi:type="float">5</b> 1613 <s xsi:type="string">23</s> 1614 <s py:pytype="str">42</s> 1615 <f py:pytype="float">300</f> 1616 <l py:pytype="long">2</l> 1617 <t py:pytype="TREE"></t> 1618 </a> 1619 ''') 1620 objectify.xsiannotate(root, ignore_old=True) 1621 1622 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1623 for c in root.iterchildren() ] 1624 self.assertEquals("xsd:int", child_types[ 0]) 1625 self.assertEquals("xsd:string", child_types[ 1]) 1626 self.assertEquals("xsd:double", child_types[ 2]) 1627 self.assertEquals("xsd:string", child_types[ 3]) 1628 self.assertEquals("xsd:boolean", child_types[ 4]) 1629 self.assertEquals(None, child_types[ 5]) 1630 self.assertEquals(None, child_types[ 6]) 1631 self.assertEquals("xsd:int", child_types[ 7]) 1632 self.assertEquals("xsd:int", child_types[ 8]) 1633 self.assertEquals("xsd:int", child_types[ 9]) 1634 self.assertEquals("xsd:string", child_types[10]) 1635 self.assertEquals("xsd:double", child_types[11]) 1636 self.assertEquals("xsd:integer", child_types[12]) 1637 self.assertEquals(None, child_types[13]) 1638 1639 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1640
1641 - def test_deannotate(self):
1642 XML = self.XML 1643 root = XML(u'''\ 1644 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1645 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1646 <b>5</b> 1647 <b>test</b> 1648 <c>1.1</c> 1649 <c>\uF8D2</c> 1650 <x>true</x> 1651 <n xsi:nil="true" /> 1652 <n></n> 1653 <b xsi:type="double">5</b> 1654 <b xsi:type="float">5</b> 1655 <s xsi:type="string">23</s> 1656 <s py:pytype="str">42</s> 1657 <f py:pytype="float">300</f> 1658 <l py:pytype="long">2</l> 1659 <t py:pytype="TREE"></t> 1660 </a> 1661 ''') 1662 objectify.deannotate(root) 1663 1664 for c in root.getiterator(): 1665 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 1666 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1667 1668 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1669
1670 - def test_pytype_deannotate(self):
1671 XML = self.XML 1672 root = XML(u'''\ 1673 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1674 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1675 <b>5</b> 1676 <b>test</b> 1677 <c>1.1</c> 1678 <c>\uF8D2</c> 1679 <x>true</x> 1680 <n xsi:nil="true" /> 1681 <n></n> 1682 <b xsi:type="double">5</b> 1683 <b xsi:type="float">5</b> 1684 <s xsi:type="string">23</s> 1685 <s py:pytype="str">42</s> 1686 <f py:pytype="float">300</f> 1687 <l py:pytype="long">2</l> 1688 <t py:pytype="TREE"></t> 1689 </a> 1690 ''') 1691 objectify.xsiannotate(root) 1692 objectify.deannotate(root, xsi=False) 1693 1694 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1695 for c in root.iterchildren() ] 1696 self.assertEquals("xsd:int", child_types[ 0]) 1697 self.assertEquals("xsd:string", child_types[ 1]) 1698 self.assertEquals("xsd:double", child_types[ 2]) 1699 self.assertEquals("xsd:string", child_types[ 3]) 1700 self.assertEquals("xsd:boolean", child_types[ 4]) 1701 self.assertEquals(None, child_types[ 5]) 1702 self.assertEquals(None, child_types[ 6]) 1703 self.assertEquals("xsd:int", child_types[ 7]) 1704 self.assertEquals("xsd:int", child_types[ 8]) 1705 self.assertEquals("xsd:int", child_types[ 9]) 1706 self.assertEquals("xsd:string", child_types[10]) 1707 self.assertEquals("xsd:double", child_types[11]) 1708 self.assertEquals("xsd:integer", child_types[12]) 1709 self.assertEquals(None, child_types[13]) 1710 1711 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1712 1713 for c in root.getiterator(): 1714 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1715
1716 - def test_xsitype_deannotate(self):
1717 XML = self.XML 1718 root = XML(u'''\ 1719 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1720 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1721 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1722 <b>5</b> 1723 <b>test</b> 1724 <c>1.1</c> 1725 <c>\uF8D2</c> 1726 <x>true</x> 1727 <n xsi:nil="true" /> 1728 <n></n> 1729 <b xsi:type="xsd:double">5</b> 1730 <b xsi:type="xsd:float">5</b> 1731 <s xsi:type="xsd:string">23</s> 1732 <s py:pytype="str">42</s> 1733 <f py:pytype="float">300</f> 1734 <l py:pytype="long">2</l> 1735 <t py:pytype="TREE"></t> 1736 </a> 1737 ''') 1738 objectify.annotate(root) 1739 objectify.deannotate(root, pytype=False) 1740 1741 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1742 for c in root.iterchildren() ] 1743 self.assertEquals("int", child_types[ 0]) 1744 self.assertEquals("str", child_types[ 1]) 1745 self.assertEquals("float", child_types[ 2]) 1746 self.assertEquals("str", child_types[ 3]) 1747 self.assertEquals("bool", child_types[ 4]) 1748 self.assertEquals("NoneType", child_types[ 5]) 1749 self.assertEquals(None, child_types[ 6]) 1750 self.assertEquals("float", child_types[ 7]) 1751 self.assertEquals("float", child_types[ 8]) 1752 self.assertEquals("str", child_types[ 9]) 1753 self.assertEquals("int", child_types[10]) 1754 self.assertEquals("int", child_types[11]) 1755 self.assertEquals("int", child_types[12]) 1756 self.assertEquals(None, child_types[13]) 1757 1758 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1759 1760 for c in root.getiterator(): 1761 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))
1762
1763 - def test_pytype_deannotate(self):
1764 XML = self.XML 1765 root = XML(u'''\ 1766 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1767 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1768 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1769 <b xsi:type="xsd:int">5</b> 1770 <b xsi:type="xsd:string">test</b> 1771 <c xsi:type="xsd:float">1.1</c> 1772 <c xsi:type="xsd:string">\uF8D2</c> 1773 <x xsi:type="xsd:boolean">true</x> 1774 <n xsi:nil="true" /> 1775 <n></n> 1776 <b xsi:type="xsd:double">5</b> 1777 <b xsi:type="xsd:float">5</b> 1778 <s xsi:type="xsd:string">23</s> 1779 <s xsi:type="xsd:string">42</s> 1780 <f xsi:type="xsd:float">300</f> 1781 <l xsi:type="xsd:long">2</l> 1782 <t py:pytype="TREE"></t> 1783 </a> 1784 ''') 1785 objectify.annotate(root) 1786 objectify.deannotate(root, xsi=False) 1787 1788 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1789 for c in root.iterchildren() ] 1790 self.assertEquals("xsd:int", child_types[ 0]) 1791 self.assertEquals("xsd:string", child_types[ 1]) 1792 self.assertEquals("xsd:float", child_types[ 2]) 1793 self.assertEquals("xsd:string", child_types[ 3]) 1794 self.assertEquals("xsd:boolean", child_types[ 4]) 1795 self.assertEquals(None, child_types[ 5]) 1796 self.assertEquals(None, child_types[ 6]) 1797 self.assertEquals("xsd:double", child_types[ 7]) 1798 self.assertEquals("xsd:float", child_types[ 8]) 1799 self.assertEquals("xsd:string", child_types[ 9]) 1800 self.assertEquals("xsd:string", child_types[10]) 1801 self.assertEquals("xsd:float", child_types[11]) 1802 self.assertEquals("xsd:long", child_types[12]) 1803 self.assertEquals(None, child_types[13]) 1804 1805 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1806 1807 for c in root.getiterator(): 1808 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1809
1810 - def test_change_pytype_attribute(self):
1811 XML = self.XML 1812 1813 xml = u'''\ 1814 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1815 <b>5</b> 1816 <b>test</b> 1817 <c>1.1</c> 1818 <c>\uF8D2</c> 1819 <x>true</x> 1820 <n xsi:nil="true" /> 1821 <n></n> 1822 <b xsi:type="double">5</b> 1823 </a> 1824 ''' 1825 1826 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1827 objectify.set_pytype_attribute_tag("{TEST}test") 1828 1829 root = XML(xml) 1830 objectify.annotate(root) 1831 1832 attribs = root.xpath("//@py:%s" % pytype_name, 1833 namespaces={"py" : pytype_ns}) 1834 self.assertEquals(0, len(attribs)) 1835 attribs = root.xpath("//@py:test", 1836 namespaces={"py" : "TEST"}) 1837 self.assertEquals(7, len(attribs)) 1838 1839 objectify.set_pytype_attribute_tag() 1840 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1841 1842 self.assertNotEqual("test", pytype_ns.lower()) 1843 self.assertNotEqual("test", pytype_name.lower()) 1844 1845 root = XML(xml) 1846 attribs = root.xpath("//@py:%s" % pytype_name, 1847 namespaces={"py" : pytype_ns}) 1848 self.assertEquals(0, len(attribs)) 1849 1850 objectify.annotate(root) 1851 attribs = root.xpath("//@py:%s" % pytype_name, 1852 namespaces={"py" : pytype_ns}) 1853 self.assertEquals(7, len(attribs))
1854
1855 - def test_registered_types(self):
1856 orig_types = objectify.getRegisteredTypes() 1857 orig_types[0].unregister() 1858 self.assertEquals(orig_types[1:], objectify.getRegisteredTypes()) 1859 1860 class NewType(objectify.ObjectifiedDataElement): 1861 pass
1862 1863 def checkMyType(s): 1864 return True 1865 1866 pytype = objectify.PyType("mytype", checkMyType, NewType) 1867 self.assert_(pytype not in objectify.getRegisteredTypes()) 1868 pytype.register() 1869 self.assert_(pytype in objectify.getRegisteredTypes()) 1870 pytype.unregister() 1871 self.assert_(pytype not in objectify.getRegisteredTypes()) 1872 1873 pytype.register(before = [objectify.getRegisteredTypes()[0].name]) 1874 self.assertEquals(pytype, objectify.getRegisteredTypes()[0]) 1875 pytype.unregister() 1876 1877 pytype.register(after = [objectify.getRegisteredTypes()[0].name]) 1878 self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0]) 1879 pytype.unregister() 1880 1881 self.assertRaises(ValueError, pytype.register, 1882 before = [objectify.getRegisteredTypes()[0].name], 1883 after = [objectify.getRegisteredTypes()[1].name]) 1884
1885 - def test_registered_type_stringify(self):
1886 from datetime import datetime 1887 def parse_date(value): 1888 if len(value) != 14: 1889 raise ValueError(value) 1890 Y = int(value[0:4]) 1891 M = int(value[4:6]) 1892 D = int(value[6:8]) 1893 h = int(value[8:10]) 1894 m = int(value[10:12]) 1895 s = int(value[12:14]) 1896 return datetime(Y, M, D, h, m, s)
1897 1898 def stringify_date(date): 1899 return date.strftime("%Y%m%d%H%M%S") 1900 1901 class DatetimeElement(objectify.ObjectifiedDataElement): 1902 def pyval(self): 1903 return parse_date(self.text) 1904 pyval = property(pyval) 1905 1906 datetime_type = objectify.PyType( 1907 "datetime", parse_date, DatetimeElement, stringify_date) 1908 datetime_type.xmlSchemaTypes = "dateTime" 1909 datetime_type.register() 1910 1911 NAMESPACE = "http://foo.net/xmlns" 1912 NAMESPACE_MAP = {'ns': NAMESPACE} 1913 1914 r = objectify.Element("{%s}root" % NAMESPACE, nsmap=NAMESPACE_MAP) 1915 time = datetime.now() 1916 r.date = time 1917 1918 self.assert_(isinstance(r.date, DatetimeElement)) 1919 self.assert_(isinstance(r.date.pyval, datetime)) 1920 1921 self.assertEquals(r.date.pyval, parse_date(stringify_date(time))) 1922 self.assertEquals(r.date.text, stringify_date(time)) 1923 1924 r.date = objectify.E.date(time) 1925 1926 self.assert_(isinstance(r.date, DatetimeElement)) 1927 self.assert_(isinstance(r.date.pyval, datetime)) 1928 1929 self.assertEquals(r.date.pyval, parse_date(stringify_date(time))) 1930 self.assertEquals(r.date.text, stringify_date(time)) 1931
1932 - def test_object_path(self):
1933 root = self.XML(xml_str) 1934 path = objectify.ObjectPath( "root.c1.c2" ) 1935 self.assertEquals(root.c1.c2.text, path.find(root).text) 1936 self.assertEquals(root.c1.c2.text, path(root).text)
1937
1938 - def test_object_path_list(self):
1939 root = self.XML(xml_str) 1940 path = objectify.ObjectPath( ['root', 'c1', 'c2'] ) 1941 self.assertEquals(root.c1.c2.text, path.find(root).text) 1942 self.assertEquals(root.c1.c2.text, path(root).text)
1943
1944 - def test_object_path_fail(self):
1945 root = self.XML(xml_str) 1946 path = objectify.ObjectPath( "root.c1.c99" ) 1947 self.assertRaises(AttributeError, path, root) 1948 self.assertEquals(None, path(root, None))
1949
1950 - def test_object_path_syntax(self):
1951 root = self.XML(xml_str) 1952 path = objectify.ObjectPath("root . {objectified}c1. c2") 1953 self.assertEquals(root.c1.c2.text, path(root).text) 1954 1955 path = objectify.ObjectPath(" root.{objectified} c1.c2 [ 0 ] ") 1956 self.assertEquals(root.c1.c2.text, path(root).text)
1957
1958 - def test_object_path_hasattr(self):
1959 root = self.XML(xml_str) 1960 path = objectify.ObjectPath( "root" ) 1961 self.assert_(path.hasattr(root)) 1962 path = objectify.ObjectPath( "root.c1" ) 1963 self.assert_(path.hasattr(root)) 1964 path = objectify.ObjectPath( "root.c1.c2" ) 1965 self.assert_(path.hasattr(root)) 1966 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 1967 self.assert_(path.hasattr(root)) 1968 path = objectify.ObjectPath( "root.c1.c2[1]" ) 1969 self.assert_(path.hasattr(root)) 1970 path = objectify.ObjectPath( "root.c1.c2[2]" ) 1971 self.assert_(path.hasattr(root)) 1972 path = objectify.ObjectPath( "root.c1.c2[3]" ) 1973 self.assertFalse(path.hasattr(root)) 1974 path = objectify.ObjectPath( "root.c1[1].c2" ) 1975 self.assertFalse(path.hasattr(root))
1976
1977 - def test_object_path_dot(self):
1978 root = self.XML(xml_str) 1979 path = objectify.ObjectPath( "." ) 1980 self.assertEquals(root.c1.c2.text, path(root).c1.c2.text)
1981
1982 - def test_object_path_dot_list(self):
1983 root = self.XML(xml_str) 1984 path = objectify.ObjectPath( [''] ) 1985 self.assertEquals(root.c1.c2.text, path(root).c1.c2.text)
1986
1987 - def test_object_path_dot_root(self):
1988 root = self.XML(xml_str) 1989 path = objectify.ObjectPath( ".c1.c2" ) 1990 self.assertEquals(root.c1.c2.text, path(root).text)
1991
1992 - def test_object_path_dot_root_list(self):
1993 root = self.XML(xml_str) 1994 path = objectify.ObjectPath( ['', 'c1', 'c2'] ) 1995 self.assertEquals(root.c1.c2.text, path(root).text)
1996
1997 - def test_object_path_index(self):
1998 root = self.XML(xml_str) 1999 path = objectify.ObjectPath( "root.c1[0].c2[0]" ) 2000 self.assertEquals(root.c1.c2.text, path(root).text) 2001 2002 path = objectify.ObjectPath( "root.c1[0].c2" ) 2003 self.assertEquals(root.c1.c2.text, path(root).text) 2004 2005 path = objectify.ObjectPath( "root.c1[0].c2[1]" ) 2006 self.assertEquals(root.c1.c2[1].text, path(root).text) 2007 2008 path = objectify.ObjectPath( "root.c1.c2[2]" ) 2009 self.assertEquals(root.c1.c2[2].text, path(root).text) 2010 2011 path = objectify.ObjectPath( "root.c1.c2[-1]" ) 2012 self.assertEquals(root.c1.c2[-1].text, path(root).text) 2013 2014 path = objectify.ObjectPath( "root.c1.c2[-3]" ) 2015 self.assertEquals(root.c1.c2[-3].text, path(root).text)
2016
2017 - def test_object_path_index_list(self):
2018 root = self.XML(xml_str) 2019 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] ) 2020 self.assertEquals(root.c1.c2.text, path(root).text) 2021 2022 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] ) 2023 self.assertEquals(root.c1.c2[2].text, path(root).text) 2024 2025 path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] ) 2026 self.assertEquals(root.c1.c2[2].text, path(root).text) 2027 2028 path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] ) 2029 self.assertEquals(root.c1.c2[-1].text, path(root).text) 2030 2031 path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] ) 2032 self.assertEquals(root.c1.c2[-3].text, path(root).text)
2033
2034 - def test_object_path_index_fail_parse(self):
2035 self.assertRaises(ValueError, objectify.ObjectPath, 2036 "root.c1[0].c2[-1-2]") 2037 self.assertRaises(ValueError, objectify.ObjectPath, 2038 ['root', 'c1[0]', 'c2[-1-2]']) 2039 2040 self.assertRaises(ValueError, objectify.ObjectPath, 2041 "root[2].c1.c2") 2042 self.assertRaises(ValueError, objectify.ObjectPath, 2043 ['root[2]', 'c1', 'c2']) 2044 2045 self.assertRaises(ValueError, objectify.ObjectPath, 2046 []) 2047 self.assertRaises(ValueError, objectify.ObjectPath, 2048 ['', '', ''])
2049
2050 - def test_object_path_index_fail_lookup(self):
2051 root = self.XML(xml_str) 2052 path = objectify.ObjectPath("root.c1[9999].c2") 2053 self.assertRaises(AttributeError, path, root) 2054 2055 path = objectify.ObjectPath("root.c1[0].c2[9999]") 2056 self.assertRaises(AttributeError, path, root) 2057 2058 path = objectify.ObjectPath(".c1[9999].c2[0]") 2059 self.assertRaises(AttributeError, path, root) 2060 2061 path = objectify.ObjectPath("root.c1[-2].c2") 2062 self.assertRaises(AttributeError, path, root) 2063 2064 path = objectify.ObjectPath("root.c1[0].c2[-4]") 2065 self.assertRaises(AttributeError, path, root)
2066
2067 - def test_object_path_ns(self):
2068 root = self.XML(xml_str) 2069 path = objectify.ObjectPath( "{objectified}root.c1.c2" ) 2070 self.assertEquals(root.c1.c2.text, path.find(root).text) 2071 path = objectify.ObjectPath( "{objectified}root.{objectified}c1.c2" ) 2072 self.assertEquals(root.c1.c2.text, path.find(root).text) 2073 path = objectify.ObjectPath( "root.{objectified}c1.{objectified}c2" ) 2074 self.assertEquals(root.c1.c2.text, path.find(root).text) 2075 path = objectify.ObjectPath( "root.c1.{objectified}c2" ) 2076 self.assertEquals(root.c1.c2.text, path.find(root).text) 2077 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 2078 self.assertEquals(getattr(root.c1, '{otherNS}c2').text, 2079 path.find(root).text)
2080
2081 - def test_object_path_ns_list(self):
2082 root = self.XML(xml_str) 2083 path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] ) 2084 self.assertEquals(root.c1.c2.text, path.find(root).text) 2085 path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] ) 2086 self.assertEquals(root.c1.c2.text, path.find(root).text) 2087 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] ) 2088 self.assertEquals(root.c1.c2.text, path.find(root).text) 2089 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] ) 2090 self.assertEquals(root.c1.c2[2].text, path.find(root).text) 2091 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] ) 2092 self.assertEquals(root.c1.c2.text, path.find(root).text) 2093 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] ) 2094 self.assertEquals(root.c1.c2[2].text, path.find(root).text) 2095 path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] ) 2096 self.assertEquals(getattr(root.c1, '{otherNS}c2').text, 2097 path.find(root).text)
2098
2099 - def test_object_path_set(self):
2100 root = self.XML(xml_str) 2101 path = objectify.ObjectPath( "root.c1.c2" ) 2102 self.assertEquals(root.c1.c2.text, path.find(root).text) 2103 self.assertEquals("1", root.c1.c2[1].text) 2104 2105 new_value = "my new value" 2106 path.setattr(root, new_value) 2107 2108 self.assertEquals(new_value, root.c1.c2.text) 2109 self.assertEquals(new_value, path(root).text) 2110 self.assertEquals("1", root.c1.c2[1].text)
2111
2112 - def test_object_path_set_element(self):
2113 root = self.XML(xml_str) 2114 path = objectify.ObjectPath( "root.c1.c2" ) 2115 self.assertEquals(root.c1.c2.text, path.find(root).text) 2116 self.assertEquals("1", root.c1.c2[1].text) 2117 2118 new_el = self.Element("{objectified}test") 2119 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2120 path.setattr(root, new_el.sub) 2121 2122 self.assertEquals("ATTR", root.c1.c2.get("myattr")) 2123 self.assertEquals("TEST", root.c1.c2.a.text) 2124 self.assertEquals("TEST", path(root).a.text) 2125 self.assertEquals("1", root.c1.c2[1].text)
2126
2127 - def test_object_path_set_create(self):
2128 root = self.XML(xml_str) 2129 path = objectify.ObjectPath( "root.c1.c99" ) 2130 self.assertRaises(AttributeError, path.find, root) 2131 2132 new_value = "my new value" 2133 path.setattr(root, new_value) 2134 2135 self.assertEquals(1, len(root.c1.c99)) 2136 self.assertEquals(new_value, root.c1.c99.text) 2137 self.assertEquals(new_value, path(root).text)
2138
2139 - def test_object_path_set_create_element(self):
2140 root = self.XML(xml_str) 2141 path = objectify.ObjectPath( "root.c1.c99" ) 2142 self.assertRaises(AttributeError, path.find, root) 2143 2144 new_el = self.Element("{objectified}test") 2145 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2146 path.setattr(root, new_el.sub) 2147 2148 self.assertEquals(1, len(root.c1.c99)) 2149 self.assertEquals("ATTR", root.c1.c99.get("myattr")) 2150 self.assertEquals("TEST", root.c1.c99.a.text) 2151 self.assertEquals("TEST", path(root).a.text)
2152
2153 - def test_object_path_set_create_list(self):
2154 root = self.XML(xml_str) 2155 path = objectify.ObjectPath( "root.c1.c99" ) 2156 self.assertRaises(AttributeError, path.find, root) 2157 2158 new_el = self.Element("{objectified}test") 2159 new_el.a = ["TEST1", "TEST2"] 2160 new_el.a[0].set("myattr", "ATTR1") 2161 new_el.a[1].set("myattr", "ATTR2") 2162 2163 path.setattr(root, list(new_el.a)) 2164 2165 self.assertEquals(2, len(root.c1.c99)) 2166 self.assertEquals("ATTR1", root.c1.c99[0].get("myattr")) 2167 self.assertEquals("TEST1", root.c1.c99[0].text) 2168 self.assertEquals("ATTR2", root.c1.c99[1].get("myattr")) 2169 self.assertEquals("TEST2", root.c1.c99[1].text) 2170 self.assertEquals("TEST1", path(root).text)
2171
2172 - def test_object_path_addattr(self):
2173 root = self.XML(xml_str) 2174 path = objectify.ObjectPath( "root.c1.c2" ) 2175 self.assertEquals(3, len(root.c1.c2)) 2176 path.addattr(root, "test") 2177 self.assertEquals(4, len(root.c1.c2)) 2178 self.assertEquals(["0", "1", "2", "test"], 2179 [el.text for el in root.c1.c2])
2180
2181 - def test_object_path_addattr_element(self):
2182 root = self.XML(xml_str) 2183 path = objectify.ObjectPath( "root.c1.c2" ) 2184 self.assertEquals(3, len(root.c1.c2)) 2185 2186 new_el = self.Element("{objectified}test") 2187 etree.SubElement(new_el, "{objectified}sub").a = "TEST" 2188 2189 path.addattr(root, new_el.sub) 2190 self.assertEquals(4, len(root.c1.c2)) 2191 self.assertEquals("TEST", root.c1.c2[3].a.text) 2192 self.assertEquals(["0", "1", "2"], 2193 [el.text for el in root.c1.c2[:3]])
2194
2195 - def test_object_path_addattr_create(self):
2196 root = self.XML(xml_str) 2197 path = objectify.ObjectPath( "root.c1.c99" ) 2198 self.assertRaises(AttributeError, path.find, root) 2199 2200 new_value = "my new value" 2201 path.addattr(root, new_value) 2202 2203 self.assertEquals(1, len(root.c1.c99)) 2204 self.assertEquals(new_value, root.c1.c99.text) 2205 self.assertEquals(new_value, path(root).text)
2206
2207 - def test_object_path_addattr_create_element(self):
2208 root = self.XML(xml_str) 2209 path = objectify.ObjectPath( "root.c1.c99" ) 2210 self.assertRaises(AttributeError, path.find, root) 2211 2212 new_el = self.Element("{objectified}test") 2213 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2214 2215 path.addattr(root, new_el.sub) 2216 self.assertEquals(1, len(root.c1.c99)) 2217 self.assertEquals("TEST", root.c1.c99.a.text) 2218 self.assertEquals("TEST", path(root).a.text) 2219 self.assertEquals("ATTR", root.c1.c99.get("myattr"))
2220
2221 - def test_object_path_addattr_create_list(self):
2222 root = self.XML(xml_str) 2223 path = objectify.ObjectPath( "root.c1.c99" ) 2224 self.assertRaises(AttributeError, path.find, root) 2225 2226 new_el = self.Element("{objectified}test") 2227 new_el.a = ["TEST1", "TEST2"] 2228 2229 self.assertEquals(2, len(new_el.a)) 2230 2231 path.addattr(root, list(new_el.a)) 2232 self.assertEquals(2, len(root.c1.c99)) 2233 self.assertEquals("TEST1", root.c1.c99.text) 2234 self.assertEquals("TEST2", path(root)[1].text)
2235
2236 - def test_descendant_paths(self):
2237 root = self.XML(xml_str) 2238 self.assertEquals( 2239 ['{objectified}root', '{objectified}root.c1', 2240 '{objectified}root.c1.c2', 2241 '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]', 2242 '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'], 2243 root.descendantpaths())
2244
2245 - def test_descendant_paths_child(self):
2246 root = self.XML(xml_str) 2247 self.assertEquals( 2248 ['{objectified}c1', '{objectified}c1.c2', 2249 '{objectified}c1.c2[1]', '{objectified}c1.c2[2]', 2250 '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'], 2251 root.c1.descendantpaths())
2252
2253 - def test_descendant_paths_prefix(self):
2254 root = self.XML(xml_str) 2255 self.assertEquals( 2256 ['root.{objectified}c1', 'root.{objectified}c1.c2', 2257 'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]', 2258 'root.{objectified}c1.{otherNS}c2', 2259 'root.{objectified}c1.{}c2'], 2260 root.c1.descendantpaths('root'))
2261
2262 - def test_pickle(self):
2263 import pickle 2264 2265 root = self.XML(xml_str) 2266 out = StringIO() 2267 pickle.dump(root, out) 2268 2269 new_root = pickle.loads(out.getvalue()) 2270 self.assertEquals( 2271 etree.tostring(new_root), 2272 etree.tostring(root))
2273 2274 # E-Factory tests, need to use sub-elements as root element is always 2275 # type-looked-up as ObjectifiedElement (no annotations)
2276 - def test_efactory_int(self):
2277 E = objectify.E 2278 root = E.root(E.val(23)) 2279 self.assert_(isinstance(root.val, objectify.IntElement))
2280
2281 - def test_efactory_long(self):
2282 E = objectify.E 2283 root = E.root(E.val(23L)) 2284 self.assert_(isinstance(root.val, objectify.LongElement))
2285
2286 - def test_efactory_float(self):
2287 E = objectify.E 2288 root = E.root(E.val(233.23)) 2289 self.assert_(isinstance(root.val, objectify.FloatElement))
2290
2291 - def test_efactory_str(self):
2292 E = objectify.E 2293 root = E.root(E.val("what?")) 2294 self.assert_(isinstance(root.val, objectify.StringElement))
2295
2296 - def test_efactory_unicode(self):
2297 E = objectify.E 2298 root = E.root(E.val(unicode("blöödy häll", encoding="ISO-8859-1"))) 2299 self.assert_(isinstance(root.val, objectify.StringElement))
2300
2301 - def test_efactory_bool(self):
2302 E = objectify.E 2303 root = E.root(E.val(True)) 2304 self.assert_(isinstance(root.val, objectify.BoolElement))
2305
2306 - def test_efactory_none(self):
2307 E = objectify.E 2308 root = E.root(E.val(None)) 2309 self.assert_(isinstance(root.val, objectify.NoneElement))
2310
2311 - def test_efactory_value_concatenation(self):
2312 E = objectify.E 2313 root = E.root(E.val(1, "foo", 2.0, "bar ", True, None)) 2314 self.assert_(isinstance(root.val, objectify.StringElement))
2315
2316 - def test_efactory_attrib(self):
2317 E = objectify.E 2318 root = E.root(foo="bar") 2319 self.assertEquals(root.get("foo"), "bar")
2320
2321 - def test_efactory_nested(self):
2322 E = objectify.E 2323 DataElement = objectify.DataElement 2324 root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1), 2325 DataElement(2.0)) 2326 self.assert_(isinstance(root, objectify.ObjectifiedElement)) 2327 self.assertEquals(root.text, "text") 2328 self.assert_(isinstance(root.sub, objectify.ObjectifiedElement)) 2329 self.assertEquals(root.sub.tail, "tail") 2330 self.assert_(isinstance(root.sub.subsub, objectify.StringElement)) 2331 self.assertEquals(len(root.value), 2) 2332 self.assert_(isinstance(root.value[0], objectify.IntElement)) 2333 self.assert_(isinstance(root.value[1], objectify.FloatElement))
2334
2335 -def test_suite():
2336 suite = unittest.TestSuite() 2337 suite.addTests([unittest.makeSuite(ObjectifyTestCase)]) 2338 if sys.version_info >= (2,4): 2339 suite.addTests( 2340 [doctest.DocFileSuite('../../../doc/objectify.txt')]) 2341 return suite
2342 2343 if __name__ == '__main__': 2344 print 'to test use test.py %s' % __file__ 2345