| Home | Trees | Indices | Help | 
 | 
|---|
|  | 
   1  # -*- coding: utf-8 -*- 
   2   
   3  """ 
   4  Tests specific to the lxml.objectify API 
   5  """ 
   6   
   7   
   8  import unittest, operator, sys, os.path 
   9   
  10  this_dir = os.path.dirname(__file__) 
  11  if this_dir not in sys.path: 
  12      sys.path.insert(0, this_dir) # needed for Py3 
  13   
  14  from common_imports import etree, HelperTestCase, fileInTestDir 
  15  from common_imports import SillyFileLike, canonicalize, doctest, make_doctest 
  16  from common_imports import _bytes, _str, StringIO, BytesIO 
  17   
  18  from lxml import objectify 
  19   
  20  PYTYPE_NAMESPACE = "http://codespeak.net/lxml/objectify/pytype" 
  21  XML_SCHEMA_NS = "http://www.w3.org/2001/XMLSchema" 
  22  XML_SCHEMA_INSTANCE_NS = "http://www.w3.org/2001/XMLSchema-instance" 
  23  XML_SCHEMA_INSTANCE_TYPE_ATTR = "{%s}type" % XML_SCHEMA_INSTANCE_NS 
  24  XML_SCHEMA_NIL_ATTR = "{%s}nil" % XML_SCHEMA_INSTANCE_NS 
  25  TREE_PYTYPE = "TREE" 
  26  DEFAULT_NSMAP = { "py"  : PYTYPE_NAMESPACE, 
  27                    "xsi" : XML_SCHEMA_INSTANCE_NS, 
  28                    "xsd" : XML_SCHEMA_NS} 
  29   
  30  objectclass2xsitype = { 
  31      # objectify built-in 
  32      objectify.IntElement: ("int", "short", "byte", "unsignedShort", 
  33                             "unsignedByte", "integer", "nonPositiveInteger", 
  34                             "negativeInteger", "long", "nonNegativeInteger", 
  35                             "unsignedLong", "unsignedInt", "positiveInteger",), 
  36      objectify.FloatElement: ("float", "double"), 
  37      objectify.BoolElement: ("boolean",), 
  38      objectify.StringElement: ("string", "normalizedString", "token", "language", 
  39                                "Name", "NCName", "ID", "IDREF", "ENTITY", 
  40                                "NMTOKEN", ), 
  41      # None: xsi:nil="true" 
  42      } 
  43   
  44  xsitype2objclass = dict([ (v, k) for k in objectclass2xsitype 
  45                            for v in objectclass2xsitype[k] ]) 
  46   
  47  objectclass2pytype = { 
  48      # objectify built-in 
  49      objectify.IntElement: "int", 
  50      objectify.FloatElement: "float", 
  51      objectify.BoolElement: "bool", 
  52      objectify.StringElement: "str", 
  53      # None: xsi:nil="true" 
  54      } 
  55   
  56  pytype2objclass = dict([ (objectclass2pytype[k], k) 
  57                           for k in objectclass2pytype]) 
  58   
  59  xml_str = '''\ 
  60  <obj:root xmlns:obj="objectified" xmlns:other="otherNS"> 
  61    <obj:c1 a1="A1" a2="A2" other:a3="A3"> 
  62      <obj:c2>0</obj:c2> 
  63      <obj:c2>1</obj:c2> 
  64      <obj:c2>2</obj:c2> 
  65      <other:c2>3</other:c2> 
  66      <c2>4</c2> 
  67    </obj:c1> 
  68  </obj:root>''' 
  69   
  71      """Test cases for lxml.objectify 
  72      """ 
  73      etree = etree 
  74       
  77   
  79          super(ObjectifyTestCase, self).setUp() 
  80          self.parser = self.etree.XMLParser(remove_blank_text=True) 
  81          self.lookup = etree.ElementNamespaceClassLookup( 
  82              objectify.ObjectifyElementClassLookup() ) 
  83          self.parser.set_element_class_lookup(self.lookup) 
  84   
  85          self.Element = self.parser.makeelement 
  86   
  87          ns = self.lookup.get_namespace("otherNS") 
  88          ns[None] = self.etree.ElementBase 
  89   
  90          self._orig_types = objectify.getRegisteredTypes() 
  91   
  93          self.lookup.get_namespace("otherNS").clear() 
  94          objectify.set_pytype_attribute_tag() 
  95          del self.lookup 
  96          del self.parser 
  97   
  98          for pytype in objectify.getRegisteredTypes(): 
  99              pytype.unregister() 
 100          for pytype in self._orig_types: 
 101              pytype.register() 
 102          del self._orig_types 
 103   
 104          super(ObjectifyTestCase, self).tearDown() 
 105   
 106   
 110   
 112          nsmap = {} 
 113          elt = objectify.Element("test", nsmap=nsmap) 
 114          self.assertEqual(list(elt.nsmap.values()), [PYTYPE_NAMESPACE]) 
 115   
 117          nsmap = {"mypy": PYTYPE_NAMESPACE, 
 118                   "myxsi": XML_SCHEMA_INSTANCE_NS, 
 119                   "myxsd": XML_SCHEMA_NS} 
 120          elt = objectify.Element("test", nsmap=nsmap) 
 121          self.assertEqual(elt.nsmap, nsmap) 
 122           
 124          nsmap = {"my": "someNS", 
 125                   "myother": "someOtherNS", 
 126                   "myxsd": XML_SCHEMA_NS} 
 127          elt = objectify.Element("test", nsmap=nsmap) 
 128          self.assertTrue(PYTYPE_NAMESPACE in elt.nsmap.values()) 
 129          for prefix, ns in nsmap.items(): 
 130              self.assertTrue(prefix in elt.nsmap) 
 131              self.assertEqual(nsmap[prefix], elt.nsmap[prefix])  
 132           
 134          root = objectify.Element("root") 
 135          root.sub = objectify.Element("test") 
 136          self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP) 
 137   
 139          root = objectify.Element("root") 
 140          nsmap = {} 
 141          root.sub = objectify.Element("test", nsmap=nsmap) 
 142          self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP) 
 143   
 145          root = objectify.Element("root") 
 146          nsmap = {"mypy": PYTYPE_NAMESPACE, 
 147                   "myxsi": XML_SCHEMA_INSTANCE_NS, 
 148                   "myxsd": XML_SCHEMA_NS} 
 149          root.sub = objectify.Element("test", nsmap=nsmap) 
 150          self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP) 
 151           
 153          root = objectify.Element("root") 
 154          nsmap = {"my": "someNS", 
 155                   "myother": "someOtherNS", 
 156                   "myxsd": XML_SCHEMA_NS,} 
 157          root.sub = objectify.Element("test", nsmap=nsmap) 
 158          expected = nsmap.copy() 
 159          del expected["myxsd"] 
 160          expected.update(DEFAULT_NSMAP) 
 161          self.assertEqual(root.sub.nsmap, expected)  
 162           
 166   
 168          nsmap = {} 
 169          value = objectify.DataElement("test this", nsmap=nsmap) 
 170          self.assertEqual(list(value.nsmap.values()), [PYTYPE_NAMESPACE]) 
 171   
 173          nsmap = {"mypy": PYTYPE_NAMESPACE, 
 174                   "myxsi": XML_SCHEMA_INSTANCE_NS, 
 175                   "myxsd": XML_SCHEMA_NS} 
 176          value = objectify.DataElement("test this", nsmap=nsmap) 
 177          self.assertEqual(value.nsmap, nsmap) 
 178           
 180          nsmap = {"my": "someNS", 
 181                   "myother": "someOtherNS", 
 182                   "myxsd": XML_SCHEMA_NS,} 
 183          value = objectify.DataElement("test", nsmap=nsmap) 
 184          self.assertTrue(PYTYPE_NAMESPACE in value.nsmap.values()) 
 185          for prefix, ns in nsmap.items(): 
 186              self.assertTrue(prefix in value.nsmap) 
 187              self.assertEqual(nsmap[prefix], value.nsmap[prefix])  
 188           
 190          root = objectify.Element("root") 
 191          root.value = objectify.DataElement("test this") 
 192          self.assertEqual(root.value.nsmap, DEFAULT_NSMAP) 
 193   
 195          root = objectify.Element("root") 
 196          nsmap = {} 
 197          root.value = objectify.DataElement("test this", nsmap=nsmap) 
 198          self.assertEqual(root.value.nsmap, DEFAULT_NSMAP) 
 199   
 201          root = objectify.Element("root") 
 202          nsmap = {"mypy": PYTYPE_NAMESPACE, 
 203                   "myxsi": XML_SCHEMA_INSTANCE_NS, 
 204                   "myxsd": XML_SCHEMA_NS} 
 205          root.value = objectify.DataElement("test this", nsmap=nsmap) 
 206          self.assertEqual(root.value.nsmap, DEFAULT_NSMAP) 
 207           
 209          root = objectify.Element("root") 
 210          nsmap = {"my": "someNS", 
 211                   "myother": "someOtherNS", 
 212                   "myxsd": XML_SCHEMA_NS} 
 213          root.value = objectify.DataElement("test", nsmap=nsmap) 
 214          expected = nsmap.copy() 
 215          del expected["myxsd"] 
 216          expected.update(DEFAULT_NSMAP) 
 217          self.assertEqual(root.value.nsmap, expected) 
 218   
 220          # ObjectifiedDataElement can also be used as E-Factory 
 221          value = objectify.ObjectifiedDataElement('test', 'toast') 
 222          self.assertEqual(value.text, 'testtoast') 
 223   
 225          # ObjectifiedDataElement can also be used as E-Factory 
 226          value = objectify.ObjectifiedElement(objectify.ObjectifiedDataElement(), 'test', 'toast') 
 227          self.assertEqual(value.ObjectifiedDataElement.tail, 'testtoast') 
 228   
 230          # keyword arguments override attrib entries 
 231          value = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
 232                                        attrib={"gnu": "muh", "cat": "meeow", 
 233                                                "dog": "wuff"}, 
 234                                        bird="tchilp", dog="grrr") 
 235          self.assertEqual(value.get("gnu"), "muh") 
 236          self.assertEqual(value.get("cat"), "meeow") 
 237          self.assertEqual(value.get("dog"), "grrr") 
 238          self.assertEqual(value.get("bird"), "tchilp") 
 239           
 241          # Check that DataElement preserves all attributes ObjectifiedDataElement 
 242          # arguments 
 243          arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
 244                                      attrib={"gnu": "muh", "cat": "meeow", 
 245                                              "dog": "wuff"}, 
 246                                      bird="tchilp", dog="grrr") 
 247          value = objectify.DataElement(arg) 
 248          self.assertTrue(isinstance(value, objectify.StringElement)) 
 249          for attr in arg.attrib: 
 250              self.assertEqual(value.get(attr), arg.get(attr)) 
 251   
 253          # Check that _pytype arg overrides original py:pytype of 
 254          # ObjectifiedDataElement 
 255          arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
 256                                      attrib={"gnu": "muh", "cat": "meeow", 
 257                                              "dog": "wuff"}, 
 258                                      bird="tchilp", dog="grrr") 
 259          value = objectify.DataElement(arg, _pytype="NoneType") 
 260          self.assertTrue(isinstance(value, objectify.NoneElement)) 
 261          self.assertEqual(value.get(XML_SCHEMA_NIL_ATTR), "true") 
 262          self.assertEqual(value.text, None) 
 263          self.assertEqual(value.pyval, None) 
 264          for attr in arg.attrib: 
 265              #if not attr == objectify.PYTYPE_ATTRIBUTE: 
 266              self.assertEqual(value.get(attr), arg.get(attr)) 
 267   
 269          # Check that _pytype arg overrides original py:pytype of 
 270          # ObjectifiedDataElement 
 271          arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
 272                                      attrib={"gnu": "muh", "cat": "meeow", 
 273                                              "dog": "wuff"}, 
 274                                      bird="tchilp", dog="grrr") 
 275          value = objectify.DataElement(arg, _pytype="int") 
 276          self.assertTrue(isinstance(value, objectify.IntElement)) 
 277          self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 
 278          for attr in arg.attrib: 
 279              if not attr == objectify.PYTYPE_ATTRIBUTE: 
 280                  self.assertEqual(value.get(attr), arg.get(attr)) 
 281   
 283          # Check that _xsi arg overrides original xsi:type of given 
 284          # ObjectifiedDataElement 
 285          arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
 286                                      attrib={"gnu": "muh", "cat": "meeow", 
 287                                              "dog": "wuff"}, 
 288                                      bird="tchilp", dog="grrr") 
 289          value = objectify.DataElement(arg, _xsi="xsd:int") 
 290          self.assertTrue(isinstance(value, objectify.IntElement)) 
 291          self.assertEqual(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 
 292          self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 
 293          for attr in arg.attrib: 
 294              if not attr in [objectify.PYTYPE_ATTRIBUTE, 
 295                              XML_SCHEMA_INSTANCE_TYPE_ATTR]: 
 296                  self.assertEqual(value.get(attr), arg.get(attr)) 
 297   
 299          # Check that _pytype and _xsi args override original py:pytype and 
 300          # xsi:type attributes of given ObjectifiedDataElement 
 301          arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
 302                                      attrib={"gnu": "muh", "cat": "meeow", 
 303                                              "dog": "wuff"}, 
 304                                      bird="tchilp", dog="grrr") 
 305          value = objectify.DataElement(arg, _pytype="int", _xsi="xsd:int") 
 306          self.assertTrue(isinstance(value, objectify.IntElement)) 
 307          self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 
 308          self.assertEqual(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 
 309          for attr in arg.attrib: 
 310              if not attr in [objectify.PYTYPE_ATTRIBUTE, 
 311                              XML_SCHEMA_INSTANCE_TYPE_ATTR]: 
 312                  self.assertEqual(value.get(attr), arg.get(attr)) 
 313   
 317   
 321           
 323          arg = objectify.DataElement(3.1415) 
 324          self.assertRaises(ValueError, objectify.DataElement, arg, 
 325                            _pytype="int") 
 326   
 328          arg = objectify.DataElement(3.1415) 
 329          self.assertRaises(ValueError, objectify.DataElement, arg, 
 330                            _xsi="xsd:int") 
 331   
 333          arg = objectify.Element('arg') 
 334          value = objectify.DataElement(arg) 
 335          self.assertTrue(isinstance(value, objectify.ObjectifiedElement)) 
 336          for attr in arg.attrib: 
 337              self.assertEqual(value.get(attr), arg.get(attr)) 
 338           
 342   
 346   
 350   
 352          root = self.XML(""" 
 353              <root> 
 354                  <foo:x xmlns:foo="/foo/bar">1</foo:x> 
 355                  <x>2</x> 
 356              </root> 
 357          """) 
 358          self.assertEqual(2, root.x) 
 359   
 361          root = self.XML(xml_str) 
 362          self.assertEqual(1, root.countchildren()) 
 363          self.assertEqual(5, root.c1.countchildren()) 
 364   
 366          root = self.XML(xml_str) 
 367          self.assertEqual("0", getattr(root.c1, "{objectified}c2").text) 
 368          self.assertEqual("3", getattr(root.c1, "{otherNS}c2").text) 
 369   
 371          root = self.XML(xml_str) 
 372          self.assertRaises(AttributeError, getattr, root.c1, "NOT_THERE") 
 373          self.assertRaises(AttributeError, getattr, root.c1, "{unknownNS}c2") 
 374   
 376          root = self.XML(xml_str) 
 377          self.assertEqual("4", getattr(root.c1, "{}c2").text) 
 378          self.assertEqual("0", getattr(root.c1, "c2").text) 
 379   
 381          for val in [ 
 382              2, 2**32, 1.2, "Won't get fooled again",  
 383              _str("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1'), True, 
 384              False, None]:  
 385              root = self.Element('root') 
 386              attrname = 'val' 
 387              setattr(root, attrname, val) 
 388              result = getattr(root, attrname) 
 389              self.assertEqual(val, result) 
 390              self.assertEqual(type(val), type(result.pyval)) 
 391    
 393          root = self.Element('root') 
 394          attrname = 'val' 
 395          val = _bytes("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1') 
 396          self.assertRaises(ValueError, setattr, root, attrname, val) 
 397          self.assertRaises(AttributeError, getattr, root, attrname)  
 398    
 400          root = self.XML(xml_str) 
 401          self.assertEqual(1, len(root.c1)) 
 402          root.addattr("c1", "test") 
 403          self.assertEqual(2, len(root.c1)) 
 404          self.assertEqual("test", root.c1[1].text) 
 405   
 407          root = self.XML(xml_str) 
 408          self.assertEqual(1, len(root.c1)) 
 409   
 410          new_el = self.Element("test", myattr="5") 
 411          root.addattr("c1", new_el) 
 412          self.assertEqual(2, len(root.c1)) 
 413          self.assertEqual(None, root.c1[0].get("myattr")) 
 414          self.assertEqual("5",  root.c1[1].get("myattr")) 
 415   
 417          root = self.XML(xml_str) 
 418          self.assertEqual(1, len(root.c1)) 
 419   
 420          new_el = self.Element("test") 
 421          self.etree.SubElement(new_el, "a", myattr="A") 
 422          self.etree.SubElement(new_el, "a", myattr="B") 
 423   
 424          root.addattr("c1", list(new_el.a)) 
 425          self.assertEqual(3, len(root.c1)) 
 426          self.assertEqual(None, root.c1[0].get("myattr")) 
 427          self.assertEqual("A",  root.c1[1].get("myattr")) 
 428          self.assertEqual("B",  root.c1[2].get("myattr")) 
 429   
 431          root = self.XML(xml_str) 
 432          self.assertEqual(3, len(root.c1.c2)) 
 433          root.c1.addattr("c2", 3) 
 434          self.assertEqual(4, len(root.c1.c2)) 
 435          self.assertEqual("3", root.c1.c2[3].text) 
 436   
 438          root = self.XML(xml_str) 
 439          self.assertEqual("0", root.c1.c2[0].text) 
 440          self.assertEqual("1", root.c1.c2[1].text) 
 441          self.assertEqual("2", root.c1.c2[2].text) 
 442          self.assertRaises(IndexError, operator.getitem, root.c1.c2, 3) 
 443   
 445          root = self.XML(xml_str) 
 446          self.assertEqual("0", root.c1.c2[0].text) 
 447          self.assertEqual("0", root.c1.c2[-3].text) 
 448          self.assertEqual("1", root.c1.c2[-2].text) 
 449          self.assertEqual("2", root.c1.c2[-1].text) 
 450          self.assertRaises(IndexError, operator.getitem, root.c1.c2, -4) 
 451   
 453          root = self.XML(xml_str) 
 454          self.assertEqual(1, len(root)) 
 455          self.assertEqual(1, len(root.c1)) 
 456          self.assertEqual(3, len(root.c1.c2)) 
 457   
 459          root = self.XML(xml_str) 
 460          self.assertEqual([root], 
 461                            list(iter(root))) 
 462          self.assertEqual([root.c1], 
 463                            list(iter(root.c1))) 
 464          self.assertEqual([root.c1.c2[0], root.c1.c2[1], root.c1.c2[2]], 
 465                            list(iter((root.c1.c2)))) 
 466   
 468          root = self.XML(xml_str) 
 469          self.assertTrue(isinstance(root.c1.c2, objectify.ObjectifiedElement)) 
 470          self.assertFalse(isinstance(getattr(root.c1, "{otherNS}c2"), 
 471                                      objectify.ObjectifiedElement)) 
 472   
 474          root = self.XML(xml_str) 
 475          dir_c1 = dir(objectify.ObjectifiedElement) + ['c1'] 
 476          dir_c1.sort() 
 477          dir_c2 = dir(objectify.ObjectifiedElement) + ['c2'] 
 478          dir_c2.sort() 
 479   
 480          self.assertEqual(dir_c1, dir(root)) 
 481          self.assertEqual(dir_c2, dir(root.c1)) 
 482   
 484          root = self.XML(xml_str) 
 485          self.assertEqual({'c1' : root.c1},    vars(root)) 
 486          self.assertEqual({'c2' : root.c1.c2}, vars(root.c1)) 
 487   
 489          root = self.XML(xml_str) 
 490          self.assertRaises(TypeError, setattr, root.c1.c2, 'text',  "test") 
 491          self.assertRaises(TypeError, setattr, root.c1.c2, 'pyval', "test") 
 492   
 493      # slicing 
 494   
 496          root = self.XML("<root><c>c1</c><c>c2</c></root>") 
 497          self.assertEqual(["c1", "c2"], 
 498                            [ c.text for c in root.c[:] ]) 
 499   
 501          root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 
 502          test_list = ["c1", "c2", "c3", "c4"] 
 503   
 504          self.assertEqual(test_list, 
 505                            [ c.text for c in root.c[:] ]) 
 506          self.assertEqual(test_list[1:2], 
 507                            [ c.text for c in root.c[1:2] ]) 
 508          self.assertEqual(test_list[-3:-1], 
 509                            [ c.text for c in root.c[-3:-1] ]) 
 510          self.assertEqual(test_list[-3:3], 
 511                            [ c.text for c in root.c[-3:3] ]) 
 512          self.assertEqual(test_list[-3000:3], 
 513                            [ c.text for c in root.c[-3000:3] ]) 
 514          self.assertEqual(test_list[-3:3000], 
 515                            [ c.text for c in root.c[-3:3000] ]) 
 516   
 518          root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 
 519          test_list = ["c1", "c2", "c3", "c4"] 
 520   
 521          self.assertEqual(test_list, 
 522                            [ c.text for c in root.c[:] ]) 
 523          self.assertEqual(test_list[2:1:-1], 
 524                            [ c.text for c in root.c[2:1:-1] ]) 
 525          self.assertEqual(test_list[-1:-3:-1], 
 526                            [ c.text for c in root.c[-1:-3:-1] ]) 
 527          self.assertEqual(test_list[2:-3:-1], 
 528                            [ c.text for c in root.c[2:-3:-1] ]) 
 529          self.assertEqual(test_list[2:-3000:-1], 
 530                            [ c.text for c in root.c[2:-3000:-1] ]) 
 531   
 532      # slice assignment 
 533   
 535          Element = self.Element 
 536          root = Element("root") 
 537          root.c = ["c1", "c2"] 
 538   
 539          c1 = root.c[0] 
 540          c2 = root.c[1] 
 541   
 542          self.assertEqual([c1,c2], list(root.c)) 
 543          self.assertEqual(["c1", "c2"], 
 544                            [ c.text for c in root.c ]) 
 545   
 547          Element = self.Element 
 548          root = Element("root") 
 549          root.c = ["c1", "c2"] 
 550   
 551          c1 = root.c[0] 
 552          c2 = root.c[1] 
 553   
 554          self.assertEqual([c1,c2], list(root.c)) 
 555          self.assertEqual(["c1", "c2"], 
 556                            [ c.text for c in root.c ]) 
 557   
 558          root2 = Element("root2") 
 559          root2.el = [ "test", "test" ] 
 560          self.assertEqual(["test", "test"], 
 561                            [ el.text for el in root2.el ]) 
 562   
 563          root.c = [ root2.el, root2.el ] 
 564          self.assertEqual(["test", "test"], 
 565                            [ c.text for c in root.c ]) 
 566          self.assertEqual(["test", "test"], 
 567                            [ el.text for el in root2.el ]) 
 568   
 569          root.c[:] = [ c1, c2, c2, c1 ] 
 570          self.assertEqual(["c1", "c2", "c2", "c1"], 
 571                            [ c.text for c in root.c ]) 
 572   
 574          Element = self.Element 
 575          root = Element("root") 
 576          l = ["c1", "c2", "c3", "c4"] 
 577          root.c = l 
 578   
 579          self.assertEqual(["c1", "c2", "c3", "c4"], 
 580                            [ c.text for c in root.c ]) 
 581          self.assertEqual(l, 
 582                            [ c.text for c in root.c ]) 
 583   
 584          new_slice = ["cA", "cB"] 
 585          l[1:2] = new_slice 
 586          root.c[1:2] = new_slice 
 587   
 588          self.assertEqual(["c1", "cA", "cB", "c3", "c4"], l) 
 589          self.assertEqual(["c1", "cA", "cB", "c3", "c4"], 
 590                            [ c.text for c in root.c ]) 
 591          self.assertEqual(l, 
 592                            [ c.text for c in root.c ]) 
 593   
 595          Element = self.Element 
 596          root = Element("root") 
 597          l = ["c1", "c2", "c3", "c4"] 
 598          root.c = l 
 599   
 600          self.assertEqual(["c1", "c2", "c3", "c4"], 
 601                            [ c.text for c in root.c ]) 
 602          self.assertEqual(l, 
 603                            [ c.text for c in root.c ]) 
 604   
 605          new_slice = ["cA", "cB"] 
 606          l[1:1] = new_slice 
 607          root.c[1:1] = new_slice 
 608   
 609          self.assertEqual(["c1", "cA", "cB", "c2", "c3", "c4"], l) 
 610          self.assertEqual(["c1", "cA", "cB", "c2", "c3", "c4"], 
 611                            [ c.text for c in root.c ]) 
 612          self.assertEqual(l, 
 613                            [ c.text for c in root.c ]) 
 614   
 616          Element = self.Element 
 617          root = Element("root") 
 618          l = ["c1", "c2", "c3", "c4"] 
 619          root.c = l 
 620   
 621          self.assertEqual(["c1", "c2", "c3", "c4"], 
 622                            [ c.text for c in root.c ]) 
 623          self.assertEqual(l, 
 624                            [ c.text for c in root.c ]) 
 625   
 626          new_slice = ["cA", "cB"] 
 627          l[-2:-2] = new_slice 
 628          root.c[-2:-2] = new_slice 
 629   
 630          self.assertEqual(["c1", "c2", "cA", "cB", "c3", "c4"], l) 
 631          self.assertEqual(["c1", "c2", "cA", "cB", "c3", "c4"], 
 632                            [ c.text for c in root.c ]) 
 633          self.assertEqual(l, 
 634                            [ c.text for c in root.c ]) 
 635   
 637          Element = self.Element 
 638          root = Element("root") 
 639   
 640          root.c = [] 
 641          self.assertRaises( 
 642              AttributeError, getattr, root, 'c') 
 643   
 645          Element = self.Element 
 646          root = Element("root") 
 647          l = ["c1", "c2", "c3", "c4"] 
 648          root.c = l 
 649   
 650          self.assertEqual(["c1", "c2", "c3", "c4"], 
 651                            [ c.text for c in root.c ]) 
 652          self.assertEqual(l, 
 653                            [ c.text for c in root.c ]) 
 654   
 655          new_slice = ["cA", "cB", "cC"] 
 656          self.assertRaises( 
 657              ValueError, operator.setitem, 
 658              l, slice(1,2,-1), new_slice) 
 659          self.assertRaises( 
 660              ValueError, operator.setitem, 
 661              root.c, slice(1,2,-1), new_slice) 
 662   
 664          Element = self.Element 
 665          root = Element("root") 
 666          l = ["c1", "c2", "c3", "c4"] 
 667          root.c = l 
 668   
 669          self.assertEqual(["c1", "c2", "c3", "c4"], 
 670                            [ c.text for c in root.c ]) 
 671          self.assertEqual(l, 
 672                            [ c.text for c in root.c ]) 
 673   
 674          new_slice = ["cA", "cB"] 
 675          l[-1:1:-1] = new_slice 
 676          root.c[-1:1:-1] = new_slice 
 677   
 678          self.assertEqual(["c1", "c2", "cB", "cA"], l) 
 679          self.assertEqual(["c1", "c2", "cB", "cA"], 
 680                            [ c.text for c in root.c ]) 
 681          self.assertEqual(l, 
 682                            [ c.text for c in root.c ]) 
 683   
 685          Element = self.Element 
 686          root = Element("root") 
 687          l = ["c1", "c2", "c3", "c4"] 
 688          root.c = l 
 689   
 690          self.assertEqual(["c1", "c2", "c3", "c4"], 
 691                            [ c.text for c in root.c ]) 
 692          self.assertEqual(l, 
 693                            [ c.text for c in root.c ]) 
 694   
 695          new_slice = ["cA", "cB"] 
 696          l[-1:-4:-2] = new_slice 
 697          root.c[-1:-4:-2] = new_slice 
 698   
 699          self.assertEqual(["c1", "cB", "c3", "cA"], l) 
 700          self.assertEqual(["c1", "cB", "c3", "cA"], 
 701                            [ c.text for c in root.c ]) 
 702          self.assertEqual(l, 
 703                            [ c.text for c in root.c ]) 
 704   
 705      # other stuff 
 706   
 708          # make sure strings are not handled as sequences 
 709          Element = self.Element 
 710          root = Element("root") 
 711          root.c = "TEST" 
 712          self.assertEqual(["TEST"], 
 713                            [ c.text for c in root.c ]) 
 714   
 716          # make sure strings are set as children 
 717          Element = self.Element 
 718          root = Element("root") 
 719          root["c"] = "TEST" 
 720          self.assertEqual(["TEST"], 
 721                            [ c.text for c in root.c ]) 
 722   
 724          # make sure 'text' etc. are set as children 
 725          Element = self.Element 
 726          root = Element("root") 
 727   
 728          root["text"] = "TEST" 
 729          self.assertEqual(["TEST"], 
 730                            [ c.text for c in root["text"] ]) 
 731   
 732          root["tail"] = "TEST" 
 733          self.assertEqual(["TEST"], 
 734                            [ c.text for c in root["tail"] ]) 
 735   
 736          root["pyval"] = "TEST" 
 737          self.assertEqual(["TEST"], 
 738                            [ c.text for c in root["pyval"] ]) 
 739   
 740          root["tag"] = "TEST" 
 741          self.assertEqual(["TEST"], 
 742                            [ c.text for c in root["tag"] ]) 
 743   
 745          XML = self.XML 
 746          root = XML('<a><b><c/></b><b/><c><b/></c></a>') 
 747          self.assertEqual(1, len(root.findall("c"))) 
 748          self.assertEqual(2, len(root.findall(".//c"))) 
 749          self.assertEqual(3, len(root.findall(".//b"))) 
 750          self.assertTrue(root.findall(".//b")[1] is root.getchildren()[1]) 
 751   
 753          XML = self.XML 
 754          root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>') 
 755          self.assertEqual(2, len(root.findall(".//{X}b"))) 
 756          self.assertEqual(3, len(root.findall(".//b"))) 
 757          self.assertEqual(2, len(root.findall("b"))) 
 758   
 760          root = self.Element('root') 
 761          root.a = 5 
 762          root.b = 6 
 763          self.assertTrue(isinstance(root, objectify.ObjectifiedElement)) 
 764          self.assertTrue(isinstance(root.a, objectify.IntElement)) 
 765          self.assertTrue(isinstance(root.b, objectify.IntElement)) 
 766   
 768          Element = self.Element 
 769          SubElement = self.etree.SubElement 
 770   
 771          nil_attr = XML_SCHEMA_NIL_ATTR 
 772          root = Element("{objectified}root") 
 773          SubElement(root, "{objectified}none") 
 774          SubElement(root, "{objectified}none", {nil_attr : "true"}) 
 775          self.assertFalse(isinstance(root.none, objectify.NoneElement)) 
 776          self.assertFalse(isinstance(root.none[0], objectify.NoneElement)) 
 777          self.assertTrue(isinstance(root.none[1], objectify.NoneElement)) 
 778          self.assertEqual(hash(root.none[1]), hash(None)) 
 779          self.assertEqual(root.none[1], None) 
 780          self.assertFalse(root.none[1]) 
 781   
 783          value = objectify.DataElement(None) 
 784          self.assertTrue(isinstance(value, objectify.NoneElement)) 
 785          self.assertEqual(value, None) 
 786          self.assertEqual(value.get(XML_SCHEMA_NIL_ATTR), "true") 
 787   
 789          Element = self.Element 
 790          SubElement = self.etree.SubElement 
 791          root = Element("{objectified}root") 
 792          root.bool = True 
 793          self.assertEqual(root.bool, True) 
 794          self.assertEqual(root.bool + root.bool, True + True) 
 795          self.assertEqual(True + root.bool, True + root.bool) 
 796          self.assertEqual(root.bool * root.bool, True * True) 
 797          self.assertEqual(int(root.bool), int(True)) 
 798          self.assertEqual(hash(root.bool), hash(True)) 
 799          self.assertEqual(complex(root.bool), complex(True)) 
 800          self.assertTrue(isinstance(root.bool, objectify.BoolElement)) 
 801   
 802          root.bool = False 
 803          self.assertEqual(root.bool, False) 
 804          self.assertEqual(root.bool + root.bool, False + False) 
 805          self.assertEqual(False + root.bool, False + root.bool) 
 806          self.assertEqual(root.bool * root.bool, False * False) 
 807          self.assertEqual(int(root.bool), int(False)) 
 808          self.assertEqual(hash(root.bool), hash(False)) 
 809          self.assertEqual(complex(root.bool), complex(False)) 
 810          self.assertTrue(isinstance(root.bool, objectify.BoolElement)) 
 811   
 813          value = objectify.DataElement(True) 
 814          self.assertTrue(isinstance(value, objectify.BoolElement)) 
 815          self.assertEqual(value, True) 
 816   
 817          value = objectify.DataElement(False) 
 818          self.assertTrue(isinstance(value, objectify.BoolElement)) 
 819          self.assertEqual(value, False) 
 820   
 822          Element = self.Element 
 823          SubElement = self.etree.SubElement 
 824          root = Element("{objectified}root") 
 825          root.s = "test" 
 826          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
 827   
 829          Element = self.Element 
 830          SubElement = self.etree.SubElement 
 831          root = Element("{objectified}root") 
 832          root.s = "3" 
 833          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
 834   
 836          Element = self.Element 
 837          SubElement = self.etree.SubElement 
 838          root = Element("{objectified}root") 
 839          root.s = "3.72" 
 840          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
 841   
 843          Element = self.Element 
 844          SubElement = self.etree.SubElement 
 845          root = Element("{objectified}root") 
 846          root.s = "test" 
 847   
 848          self.assertEqual("test" * 5, root.s * 5) 
 849          self.assertEqual(5 * "test", 5 * root.s) 
 850   
 851          self.assertRaises(TypeError, operator.mul, root.s, "honk") 
 852          self.assertRaises(TypeError, operator.mul, "honk", root.s) 
 853   
 855          Element = self.Element 
 856          SubElement = self.etree.SubElement 
 857          root = Element("{objectified}root") 
 858          root.s = "test" 
 859   
 860          s = "toast" 
 861          self.assertEqual("test" + s, root.s + s) 
 862          self.assertEqual(s + "test", s + root.s) 
 863               
 865          s = "%d %f %s %r" 
 866          el = objectify.DataElement(s) 
 867          values = (1, 7.0, "abcd", None) 
 868          self.assertEqual(s % values, el % values) 
 869   
 870          s = "%d" 
 871          el = objectify.DataElement(s) 
 872          val = 5 
 873          self.assertEqual(s % val, el % val) 
 874   
 875          s = "%d %s" 
 876          el = objectify.DataElement(s) 
 877          val = 5 
 878          self.assertRaises(TypeError, el.__mod__, val) 
 879   
 880          s = "" 
 881          el = objectify.DataElement(s) 
 882          val = 5 
 883          self.assertRaises(TypeError, el.__mod__, val) 
 884   
 889   
 894               
 899   
 904               
 906          s = "%d %f %s %r" 
 907          el = objectify.DataElement(s) 
 908          values = (objectify.DataElement(1), 
 909                    objectify.DataElement(7.0), 
 910                    objectify.DataElement("abcd"), 
 911                    objectify.DataElement(None)) 
 912          self.assertEqual(s % values, el % values) 
 913   
 915          value = objectify.DataElement("test") 
 916          self.assertTrue(isinstance(value, objectify.StringElement)) 
 917          self.assertEqual(value, "test") 
 918   
 920          value = objectify.DataElement("3") 
 921          self.assertTrue(isinstance(value, objectify.StringElement)) 
 922          self.assertEqual(value, "3") 
 923   
 925          value = objectify.DataElement("3.20") 
 926          self.assertTrue(isinstance(value, objectify.StringElement)) 
 927          self.assertEqual(value, "3.20") 
 928   
 930          Element = self.Element 
 931          SubElement = self.etree.SubElement 
 932          root = Element("{objectified}root") 
 933          root.s = _str("test") 
 934          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
 935   
 937          Element = self.Element 
 938          SubElement = self.etree.SubElement 
 939          root = Element("{objectified}root") 
 940          root.s = _str("3") 
 941          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
 942   
 944          Element = self.Element 
 945          SubElement = self.etree.SubElement 
 946          root = Element("{objectified}root") 
 947          root.s = _str("3.72") 
 948          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
 949   
 951          Element = self.Element 
 952          SubElement = self.etree.SubElement 
 953          root = Element("{objectified}root") 
 954          root.s = _str("test") 
 955   
 956          self.assertEqual(_str("test") * 5, root.s * 5) 
 957          self.assertEqual(5 * _str("test"), 5 * root.s) 
 958   
 959          self.assertRaises(TypeError, operator.mul, root.s, _str("honk")) 
 960          self.assertRaises(TypeError, operator.mul, _str("honk"), root.s) 
 961   
 963          Element = self.Element 
 964          SubElement = self.etree.SubElement 
 965          root = Element("{objectified}root") 
 966          root.s = _str("test") 
 967   
 968          s = _str("toast") 
 969          self.assertEqual(_str("test") + s, root.s + s) 
 970          self.assertEqual(s + _str("test"), s + root.s) 
 971   
 973          value = objectify.DataElement(_str("test")) 
 974          self.assertTrue(isinstance(value, objectify.StringElement)) 
 975          self.assertEqual(value, _str("test")) 
 976   
 978          value = objectify.DataElement("3") 
 979          self.assertTrue(isinstance(value, objectify.StringElement)) 
 980          self.assertEqual(value, _str("3")) 
 981   
 983          value = objectify.DataElement(_str("3.20")) 
 984          self.assertTrue(isinstance(value, objectify.StringElement)) 
 985          self.assertEqual(value, _str("3.20")) 
 986   
 988          Element = self.Element 
 989          SubElement = self.etree.SubElement 
 990          root = Element("{objectified}root") 
 991          root.none = 5 
 992          self.assertTrue(isinstance(root.none, objectify.IntElement)) 
 993   
 995          value = objectify.DataElement(5) 
 996          self.assertTrue(isinstance(value, objectify.IntElement)) 
 997          self.assertEqual(value, 5) 
 998   
1002   
1004          Element = self.Element 
1005          SubElement = self.etree.SubElement 
1006          root = Element("{objectified}root") 
1007          root.none = 5.5 
1008          self.assertTrue(isinstance(root.none, objectify.FloatElement)) 
1009   
1011          value = objectify.DataElement(5.5) 
1012          self.assertTrue(isinstance(value, objectify.FloatElement)) 
1013          self.assertEqual(value, 5.5) 
1014   
1018   
1020          # test not losing precision by shortened float str() value 
1021          # repr(2.305064300557): '2.305064300557' 
1022          # str(2.305064300557): '2.30506430056' 
1023          # "%57.54f" % 2.305064300557: 
1024          #     ' 2.305064300556999956626214043353684246540069580078125000' 
1025          Element = self.Element 
1026          root = Element("{objectified}root") 
1027          s = "2.305064300557" 
1028          root.f = float(s) 
1029          self.assertTrue(isinstance(root.f, objectify.FloatElement)) 
1030          self.assertEqual(root.f.text, s) 
1031          self.assertEqual(root.f.pyval, float(s)) 
1032   
1034          # test precision preservation for FloatElement instantiation 
1035          s = "2.305064300557" 
1036          self.assertEqual(objectify.FloatElement(s), float(s)) 
1037     
1039          # test consistent FloatElement values for the different instantiation 
1040          # possibilities 
1041          Element = self.Element 
1042          root = Element("{objectified}root") 
1043          s = "2.305064300557" 
1044          f = float(s) 
1045          float_elem = objectify.FloatElement(s) 
1046          float_data_elem = objectify.DataElement(f) 
1047          root.float_child = float(f) 
1048          self.assertTrue(f == float_elem == float_data_elem == root.float_child) 
1049   
1051          # test not losing precision by shortened float str() value 
1052          f = 2305064300557.0 
1053          value = objectify.DataElement(f) 
1054          self.assertTrue(isinstance(value, objectify.FloatElement)) 
1055          self.assertEqual(value, f) 
1056   
1058          # test not losing precision by shortened float str() value 
1059          f = 2305064300557.0 
1060          value = objectify.DataElement(f) 
1061          self.assertEqual(hash(value), hash(f)) 
1062   
1064          for xsi, objclass in xsitype2objclass.items(): 
1065              # 1 is a valid value for all ObjectifiedDataElement classes 
1066              pyval = 1 
1067              value = objectify.DataElement(pyval, _xsi=xsi) 
1068              self.assertTrue(isinstance(value, objclass), 
1069                           "DataElement(%s, _xsi='%s') returns %s, expected %s" 
1070                           % (pyval, xsi, type(value), objclass)) 
1071           
1073          for xsi, objclass in xsitype2objclass.items(): 
1074              # 1 is a valid value for all ObjectifiedDataElement classes 
1075              pyval = 1 
1076              value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi) 
1077              self.assertTrue(isinstance(value, objclass), 
1078                           "DataElement(%s, _xsi='%s') returns %s, expected %s" 
1079                           % (pyval, xsi, type(value), objclass)) 
1080           
1082          for xsi, objclass in xsitype2objclass.items(): 
1083              # 1 is a valid value for all ObjectifiedDataElement classes 
1084              self.assertRaises(ValueError, objectify.DataElement, 1, 
1085                                _xsi="foo:%s" % xsi) 
1086   
1088          for pytype, objclass in pytype2objclass.items(): 
1089              # 1 is a valid value for all ObjectifiedDataElement classes 
1090              pyval = 1 
1091              value = objectify.DataElement(pyval, _pytype=pytype) 
1092              self.assertTrue(isinstance(value, objclass), 
1093                           "DataElement(%s, _pytype='%s') returns %s, expected %s" 
1094                           % (pyval, pytype, type(value), objclass)) 
1095   
1097          pyval = 1 
1098          pytype = "NoneType" 
1099          objclass = objectify.NoneElement 
1100          value = objectify.DataElement(pyval, _pytype=pytype) 
1101          self.assertTrue(isinstance(value, objclass), 
1102                       "DataElement(%s, _pytype='%s') returns %s, expected %s" 
1103                       % (pyval, pytype, type(value), objclass)) 
1104          self.assertEqual(value.text, None) 
1105          self.assertEqual(value.pyval, None) 
1106               
1108          # pre-2.0 lxml called NoneElement "none" 
1109          pyval = 1 
1110          pytype = "none" 
1111          objclass = objectify.NoneElement 
1112          value = objectify.DataElement(pyval, _pytype=pytype) 
1113          self.assertTrue(isinstance(value, objclass), 
1114                       "DataElement(%s, _pytype='%s') returns %s, expected %s" 
1115                       % (pyval, pytype, type(value), objclass)) 
1116          self.assertEqual(value.text, None) 
1117          self.assertEqual(value.pyval, None) 
1118   
1120          Element = self.Element 
1121          SubElement = self.etree.SubElement 
1122          class MyFloat(float): 
1123              pass 
1124          root = Element("{objectified}root") 
1125          root.myfloat = MyFloat(5.5) 
1126          self.assertTrue(isinstance(root.myfloat, objectify.FloatElement)) 
1127          self.assertEqual(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None) 
1128   
1132          value = objectify.DataElement(MyFloat(5.5)) 
1133          self.assertTrue(isinstance(value, objectify.FloatElement)) 
1134          self.assertEqual(value, 5.5) 
1135          self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), None) 
1136   
1138          XML = self.XML 
1139          root = XML('''\ 
1140          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
1141            <b xsi:type="boolean">true</b> 
1142            <b xsi:type="boolean">false</b> 
1143            <b xsi:type="boolean">1</b> 
1144            <b xsi:type="boolean">0</b> 
1145   
1146            <f xsi:type="float">5</f> 
1147            <f xsi:type="double">5</f> 
1148           
1149            <s xsi:type="string">5</s> 
1150            <s xsi:type="normalizedString">5</s> 
1151            <s xsi:type="token">5</s> 
1152            <s xsi:type="language">5</s> 
1153            <s xsi:type="Name">5</s> 
1154            <s xsi:type="NCName">5</s> 
1155            <s xsi:type="ID">5</s> 
1156            <s xsi:type="IDREF">5</s> 
1157            <s xsi:type="ENTITY">5</s> 
1158            <s xsi:type="NMTOKEN">5</s> 
1159   
1160            <l xsi:type="integer">5</l> 
1161            <l xsi:type="nonPositiveInteger">5</l> 
1162            <l xsi:type="negativeInteger">5</l> 
1163            <l xsi:type="long">5</l> 
1164            <l xsi:type="nonNegativeInteger">5</l> 
1165            <l xsi:type="unsignedLong">5</l> 
1166            <l xsi:type="unsignedInt">5</l> 
1167            <l xsi:type="positiveInteger">5</l> 
1168             
1169            <i xsi:type="int">5</i> 
1170            <i xsi:type="short">5</i> 
1171            <i xsi:type="byte">5</i> 
1172            <i xsi:type="unsignedShort">5</i> 
1173            <i xsi:type="unsignedByte">5</i> 
1174   
1175            <n xsi:nil="true"/> 
1176          </root> 
1177          ''') 
1178   
1179          for b in root.b: 
1180              self.assertTrue(isinstance(b, objectify.BoolElement)) 
1181          self.assertEqual(True,  root.b[0]) 
1182          self.assertEqual(False, root.b[1]) 
1183          self.assertEqual(True,  root.b[2]) 
1184          self.assertEqual(False, root.b[3]) 
1185   
1186          for f in root.f: 
1187              self.assertTrue(isinstance(f, objectify.FloatElement)) 
1188              self.assertEqual(5, f) 
1189               
1190          for s in root.s: 
1191              self.assertTrue(isinstance(s, objectify.StringElement)) 
1192              self.assertEqual("5", s) 
1193   
1194          for i in root.i: 
1195              self.assertTrue(isinstance(i, objectify.IntElement)) 
1196              self.assertEqual(5, i) 
1197   
1198          for l in root.l: 
1199              self.assertTrue(isinstance(l, objectify.IntElement)) 
1200              self.assertEqual(5, i) 
1201               
1202          self.assertTrue(isinstance(root.n, objectify.NoneElement)) 
1203          self.assertEqual(None, root.n) 
1204   
1206          XML = self.XML 
1207          root = XML('''\ 
1208          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1209          xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
1210            <b xsi:type="xsd:boolean">true</b> 
1211            <b xsi:type="xsd:boolean">false</b> 
1212            <b xsi:type="xsd:boolean">1</b> 
1213            <b xsi:type="xsd:boolean">0</b> 
1214   
1215            <f xsi:type="xsd:float">5</f> 
1216            <f xsi:type="xsd:double">5</f> 
1217           
1218            <s xsi:type="xsd:string">5</s> 
1219            <s xsi:type="xsd:normalizedString">5</s> 
1220            <s xsi:type="xsd:token">5</s> 
1221            <s xsi:type="xsd:language">5</s> 
1222            <s xsi:type="xsd:Name">5</s> 
1223            <s xsi:type="xsd:NCName">5</s> 
1224            <s xsi:type="xsd:ID">5</s> 
1225            <s xsi:type="xsd:IDREF">5</s> 
1226            <s xsi:type="xsd:ENTITY">5</s> 
1227            <s xsi:type="xsd:NMTOKEN">5</s> 
1228   
1229            <l xsi:type="xsd:integer">5</l> 
1230            <l xsi:type="xsd:nonPositiveInteger">5</l> 
1231            <l xsi:type="xsd:negativeInteger">5</l> 
1232            <l xsi:type="xsd:long">5</l> 
1233            <l xsi:type="xsd:nonNegativeInteger">5</l> 
1234            <l xsi:type="xsd:unsignedLong">5</l> 
1235            <l xsi:type="xsd:unsignedInt">5</l> 
1236            <l xsi:type="xsd:positiveInteger">5</l> 
1237             
1238            <i xsi:type="xsd:int">5</i> 
1239            <i xsi:type="xsd:short">5</i> 
1240            <i xsi:type="xsd:byte">5</i> 
1241            <i xsi:type="xsd:unsignedShort">5</i> 
1242            <i xsi:type="xsd:unsignedByte">5</i> 
1243   
1244            <n xsi:nil="true"/> 
1245          </root> 
1246          ''') 
1247   
1248          for b in root.b: 
1249              self.assertTrue(isinstance(b, objectify.BoolElement)) 
1250          self.assertEqual(True,  root.b[0]) 
1251          self.assertEqual(False, root.b[1]) 
1252          self.assertEqual(True,  root.b[2]) 
1253          self.assertEqual(False, root.b[3]) 
1254   
1255          for f in root.f: 
1256              self.assertTrue(isinstance(f, objectify.FloatElement)) 
1257              self.assertEqual(5, f) 
1258               
1259          for s in root.s: 
1260              self.assertTrue(isinstance(s, objectify.StringElement)) 
1261              self.assertEqual("5", s) 
1262   
1263          for i in root.i: 
1264              self.assertTrue(isinstance(i, objectify.IntElement)) 
1265              self.assertEqual(5, i) 
1266   
1267          for l in root.l: 
1268              self.assertTrue(isinstance(l, objectify.IntElement)) 
1269              self.assertEqual(5, l) 
1270               
1271          self.assertTrue(isinstance(root.n, objectify.NoneElement)) 
1272          self.assertEqual(None, root.n) 
1273           
1275          XML = self.XML 
1276          root = XML(_bytes('<root><b>why</b><b>try</b></root>')) 
1277          strs = [ str(s) for s in root.b ] 
1278          self.assertEqual(["why", "try"], 
1279                            strs) 
1280   
1282          XML = self.XML 
1283          root = XML(_bytes('<root><b>test</b><b>taste</b><b></b><b/></root>')) 
1284          self.assertFalse(root.b[0] <  root.b[1]) 
1285          self.assertFalse(root.b[0] <= root.b[1]) 
1286          self.assertFalse(root.b[0] == root.b[1]) 
1287   
1288          self.assertTrue(root.b[0] != root.b[1]) 
1289          self.assertTrue(root.b[0] >= root.b[1]) 
1290          self.assertTrue(root.b[0] >  root.b[1]) 
1291   
1292          self.assertEqual(root.b[0], "test") 
1293          self.assertEqual("test", root.b[0]) 
1294   
1295          self.assertEqual("", root.b[2]) 
1296          self.assertEqual(root.b[2], "") 
1297          self.assertEqual("", root.b[3]) 
1298          self.assertEqual(root.b[3], "") 
1299          self.assertEqual(root.b[2], root.b[3]) 
1300           
1301          root.b = "test" 
1302          self.assertTrue(root.b) 
1303          root.b = "" 
1304          self.assertFalse(root.b) 
1305          self.assertEqual(root.b, "") 
1306          self.assertEqual("", root.b) 
1307   
1309          XML = self.XML 
1310          root = XML(_bytes('<root><b>5</b><b>6</b></root>')) 
1311          self.assertTrue(root.b[0] <  root.b[1]) 
1312          self.assertTrue(root.b[0] <= root.b[1]) 
1313          self.assertTrue(root.b[0] != root.b[1]) 
1314   
1315          self.assertFalse(root.b[0] == root.b[1]) 
1316          self.assertFalse(root.b[0] >= root.b[1]) 
1317          self.assertFalse(root.b[0] >  root.b[1]) 
1318   
1319          self.assertEqual(root.b[0], 5) 
1320          self.assertEqual(5, root.b[0]) 
1321          self.assertNotEqual(root.b[0], "5") 
1322   
1323          root.b = 5 
1324          self.assertTrue(root.b) 
1325          root.b = 0 
1326          self.assertFalse(root.b) 
1327           
1328      # float + long share the NumberElement implementation with int 
1329   
1331          XML = self.XML 
1332          root = XML(_bytes('<root><b>false</b><b>true</b></root>')) 
1333          self.assertTrue(root.b[0] <  root.b[1]) 
1334          self.assertTrue(root.b[0] <= root.b[1]) 
1335          self.assertTrue(root.b[0] != root.b[1]) 
1336   
1337          self.assertFalse(root.b[0] == root.b[1]) 
1338          self.assertFalse(root.b[0] >= root.b[1]) 
1339          self.assertFalse(root.b[0] >  root.b[1]) 
1340   
1341          self.assertFalse(root.b[0]) 
1342          self.assertTrue(root.b[1]) 
1343   
1344          self.assertEqual(root.b[0], False) 
1345          self.assertEqual(False, root.b[0]) 
1346          self.assertTrue(root.b[0] <  5) 
1347          self.assertTrue(5 > root.b[0]) 
1348   
1349          root.b = True 
1350          self.assertTrue(root.b) 
1351          root.b = False 
1352          self.assertFalse(root.b) 
1353   
1355          XML = self.XML 
1356          root = XML(_bytes(""" 
1357          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
1358            <b xsi:nil="true"></b><b xsi:nil="true"/> 
1359          </root>""")) 
1360          self.assertTrue(root.b[0] == root.b[1]) 
1361          self.assertFalse(root.b[0]) 
1362          self.assertEqual(root.b[0], None) 
1363          self.assertEqual(None, root.b[0]) 
1364   
1365          # doesn't work in Py3: 
1366   
1367          #for comparison in ["abc", 5, 7.3, True, [], ()]: 
1368          #    none = root.b[1] 
1369          #    self.assertTrue(none < comparison, "%s (%s) should be < %s" % 
1370          #                 (none, type(none), comparison) ) 
1371          #    self.assertTrue(comparison > none, "%s should be > %s (%s)" % 
1372          #                 (comparison, none, type(none)) ) 
1373   
1375          el = objectify.DataElement(1, _xsi="string") 
1376          self.assertEqual( 
1377              el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 
1378              'xsd:string') 
1379   
1381          el = objectify.DataElement(1, _xsi="string",  
1382                                     nsmap={'schema': XML_SCHEMA_NS}) 
1383          self.assertEqual( 
1384              el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 
1385              'schema:string') 
1386   
1390   
1392          XML = self.XML 
1393          root = XML(_bytes('''\ 
1394          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1395          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1396            <b>5</b> 
1397            <b>test</b> 
1398            <c>1.1</c> 
1399            <c>\uF8D2</c> 
1400            <x>true</x> 
1401            <n xsi:nil="true" /> 
1402            <n></n> 
1403            <b xsi:type="double">5</b> 
1404            <b xsi:type="float">5</b> 
1405            <s xsi:type="string">23</s> 
1406            <s py:pytype="str">42</s> 
1407            <f py:pytype="float">300</f> 
1408            <l py:pytype="long">2</l> 
1409            <t py:pytype="TREE"></t> 
1410          </a> 
1411          ''')) 
1412          objectify.annotate(root) 
1413   
1414          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1415                          for c in root.iterchildren() ] 
1416          self.assertEqual("int",   child_types[ 0]) 
1417          self.assertEqual("str",   child_types[ 1]) 
1418          self.assertEqual("float", child_types[ 2]) 
1419          self.assertEqual("str",   child_types[ 3]) 
1420          self.assertEqual("bool",  child_types[ 4]) 
1421          self.assertEqual("NoneType",  child_types[ 5]) 
1422          self.assertEqual(None,    child_types[ 6]) 
1423          self.assertEqual("float", child_types[ 7]) 
1424          self.assertEqual("float", child_types[ 8]) 
1425          self.assertEqual("str",   child_types[ 9]) 
1426          self.assertEqual("int",   child_types[10]) 
1427          self.assertEqual("int",   child_types[11]) 
1428          self.assertEqual("int",   child_types[12]) 
1429          self.assertEqual(None,    child_types[13]) 
1430           
1431          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1432   
1434          XML = self.XML 
1435          root = XML(_bytes('''\ 
1436          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1437          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1438            <n></n> 
1439          </a> 
1440          ''')) 
1441          objectify.annotate(root) 
1442   
1443          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1444                          for c in root.iterchildren() ] 
1445          self.assertEqual(None,    child_types[0]) 
1446   
1447          objectify.annotate(root, empty_pytype="str") 
1448   
1449          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1450                          for c in root.iterchildren() ] 
1451          self.assertEqual("str",    child_types[0]) 
1452   
1454          XML = self.XML 
1455          root = XML(_bytes('''\ 
1456          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1457          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1458            <b>5</b> 
1459            <b>test</b> 
1460            <c>1.1</c> 
1461            <c>\uF8D2</c> 
1462            <x>true</x> 
1463            <n xsi:nil="true" /> 
1464            <n></n> 
1465            <b xsi:type="double">5</b> 
1466            <b xsi:type="float">5</b> 
1467            <s xsi:type="string">23</s> 
1468            <s py:pytype="str">42</s> 
1469            <f py:pytype="float">300</f> 
1470            <l py:pytype="long">2</l> 
1471            <t py:pytype="TREE"></t> 
1472          </a> 
1473          ''')) 
1474          objectify.annotate(root, ignore_old=False) 
1475   
1476          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1477                          for c in root.iterchildren() ] 
1478          self.assertEqual("int",   child_types[ 0]) 
1479          self.assertEqual("str",   child_types[ 1]) 
1480          self.assertEqual("float", child_types[ 2]) 
1481          self.assertEqual("str",   child_types[ 3]) 
1482          self.assertEqual("bool",  child_types[ 4]) 
1483          self.assertEqual("NoneType",  child_types[ 5]) 
1484          self.assertEqual(None,    child_types[ 6]) 
1485          self.assertEqual("float", child_types[ 7]) 
1486          self.assertEqual("float", child_types[ 8]) 
1487          self.assertEqual("str",   child_types[ 9]) 
1488          self.assertEqual("str",   child_types[10]) 
1489          self.assertEqual("float", child_types[11]) 
1490          self.assertEqual("int",   child_types[12]) 
1491          self.assertEqual(TREE_PYTYPE,  child_types[13]) 
1492           
1493          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1494   
1496          XML = self.XML 
1497          root = XML(_bytes('''\ 
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.annotate(root, ignore_old=False, ignore_xsi=False, 
1517                             annotate_xsi=1, annotate_pytype=1) 
1518           
1519          # check py annotations 
1520          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1521                          for c in root.iterchildren() ] 
1522          self.assertEqual("int",   child_types[ 0]) 
1523          self.assertEqual("str",   child_types[ 1]) 
1524          self.assertEqual("float", child_types[ 2]) 
1525          self.assertEqual("str",   child_types[ 3]) 
1526          self.assertEqual("bool",  child_types[ 4]) 
1527          self.assertEqual("NoneType",  child_types[ 5]) 
1528          self.assertEqual(None,    child_types[ 6]) 
1529          self.assertEqual("float", child_types[ 7]) 
1530          self.assertEqual("float", child_types[ 8]) 
1531          self.assertEqual("str",   child_types[ 9]) 
1532          self.assertEqual("str",   child_types[10]) 
1533          self.assertEqual("float",   child_types[11]) 
1534          self.assertEqual("int",     child_types[12]) 
1535          self.assertEqual(TREE_PYTYPE,  child_types[13]) 
1536           
1537          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1538   
1539          child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1540                          for c in root.iterchildren() ] 
1541   
1542          # check xsi annotations 
1543          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1544                          for c in root.iterchildren() ] 
1545          self.assertEqual("xsd:integer", child_types[ 0]) 
1546          self.assertEqual("xsd:string",  child_types[ 1]) 
1547          self.assertEqual("xsd:double",  child_types[ 2]) 
1548          self.assertEqual("xsd:string",  child_types[ 3]) 
1549          self.assertEqual("xsd:boolean", child_types[ 4]) 
1550          self.assertEqual(None,          child_types[ 5]) 
1551          self.assertEqual(None,          child_types[ 6]) 
1552          self.assertEqual("xsd:double",  child_types[ 7]) 
1553          self.assertEqual("xsd:float",   child_types[ 8]) 
1554          self.assertEqual("xsd:string",  child_types[ 9]) 
1555          self.assertEqual("xsd:string",  child_types[10]) 
1556          self.assertEqual("xsd:double",  child_types[11]) 
1557          self.assertEqual("xsd:integer", child_types[12]) 
1558          self.assertEqual(None,  child_types[13]) 
1559   
1560          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1561   
1563          XML = self.XML 
1564          root = XML(_bytes('''\ 
1565          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1566          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1567            <b>5</b> 
1568            <b>test</b> 
1569            <c>1.1</c> 
1570            <c>\uF8D2</c> 
1571            <x>true</x> 
1572            <n xsi:nil="true" /> 
1573            <n></n> 
1574            <b xsi:type="double">5</b> 
1575            <b xsi:type="float">5</b> 
1576            <s xsi:type="string">23</s> 
1577            <s py:pytype="str">42</s> 
1578            <f py:pytype="float">300</f> 
1579            <l py:pytype="long">2</l> 
1580            <t py:pytype="TREE"></t> 
1581          </a> 
1582          ''')) 
1583          objectify.xsiannotate(root, ignore_old=False) 
1584   
1585          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1586                          for c in root.iterchildren() ] 
1587          self.assertEqual("xsd:integer", child_types[ 0]) 
1588          self.assertEqual("xsd:string",  child_types[ 1]) 
1589          self.assertEqual("xsd:double",  child_types[ 2]) 
1590          self.assertEqual("xsd:string",  child_types[ 3]) 
1591          self.assertEqual("xsd:boolean", child_types[ 4]) 
1592          self.assertEqual(None,          child_types[ 5]) 
1593          self.assertEqual(None,          child_types[ 6]) 
1594          self.assertEqual("xsd:double",  child_types[ 7]) 
1595          self.assertEqual("xsd:float",   child_types[ 8]) 
1596          self.assertEqual("xsd:string",  child_types[ 9]) 
1597          self.assertEqual("xsd:string",  child_types[10]) 
1598          self.assertEqual("xsd:double",  child_types[11]) 
1599          self.assertEqual("xsd:integer", child_types[12]) 
1600          self.assertEqual(None,          child_types[13]) 
1601   
1603          XML = self.XML 
1604          root = XML(_bytes('''\ 
1605          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1606          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1607            <b>5</b> 
1608            <b>test</b> 
1609            <c>1.1</c> 
1610            <c>\uF8D2</c> 
1611            <x>true</x> 
1612            <n xsi:nil="true" /> 
1613            <n></n> 
1614            <b xsi:type="double">5</b> 
1615            <b xsi:type="float">5</b> 
1616            <s xsi:type="string">23</s> 
1617            <s py:pytype="str">42</s> 
1618            <f py:pytype="float">300</f> 
1619            <l py:pytype="long">2</l> 
1620            <t py:pytype="TREE"></t> 
1621          </a> 
1622          ''')) 
1623          objectify.pyannotate(root, ignore_old=True) 
1624   
1625          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1626                          for c in root.iterchildren() ] 
1627          self.assertEqual("int",   child_types[ 0]) 
1628          self.assertEqual("str",   child_types[ 1]) 
1629          self.assertEqual("float", child_types[ 2]) 
1630          self.assertEqual("str",   child_types[ 3]) 
1631          self.assertEqual("bool",  child_types[ 4]) 
1632          self.assertEqual("NoneType",  child_types[ 5]) 
1633          self.assertEqual(None,    child_types[ 6]) 
1634          self.assertEqual("float", child_types[ 7]) 
1635          self.assertEqual("float", child_types[ 8]) 
1636          self.assertEqual("str",   child_types[ 9]) 
1637          self.assertEqual("int",   child_types[10]) 
1638          self.assertEqual("int",   child_types[11]) 
1639          self.assertEqual("int",   child_types[12]) 
1640          self.assertEqual(None,    child_types[13]) 
1641           
1642          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1643   
1645          XML = self.XML 
1646          root = XML('''\ 
1647          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1648          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1649            <n></n> 
1650          </a> 
1651          ''') 
1652          objectify.pyannotate(root) 
1653   
1654          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1655                          for c in root.iterchildren() ] 
1656          self.assertEqual(None,    child_types[0]) 
1657   
1658          objectify.annotate(root, empty_pytype="str") 
1659   
1660          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1661                          for c in root.iterchildren() ] 
1662          self.assertEqual("str",    child_types[0]) 
1663   
1665          XML = self.XML 
1666          root = XML('''\ 
1667          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1668          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1669            <b>5</b> 
1670            <b>test</b> 
1671            <c>1.1</c> 
1672            <c>\uF8D2</c> 
1673            <x>true</x> 
1674            <n xsi:nil="true" /> 
1675            <n></n> 
1676            <b xsi:type="double">5</b> 
1677            <b xsi:type="float">5</b> 
1678            <s xsi:type="string">23</s> 
1679            <s py:pytype="str">42</s> 
1680            <f py:pytype="float">300</f> 
1681            <l py:pytype="long">2</l> 
1682            <t py:pytype="TREE"></t> 
1683          </a> 
1684          ''') 
1685          objectify.pyannotate(root) 
1686   
1687          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1688                          for c in root.iterchildren() ] 
1689          self.assertEqual("int",   child_types[ 0]) 
1690          self.assertEqual("str",   child_types[ 1]) 
1691          self.assertEqual("float", child_types[ 2]) 
1692          self.assertEqual("str",   child_types[ 3]) 
1693          self.assertEqual("bool",  child_types[ 4]) 
1694          self.assertEqual("NoneType",  child_types[ 5]) 
1695          self.assertEqual(None,    child_types[ 6]) 
1696          self.assertEqual("float", child_types[ 7]) 
1697          self.assertEqual("float", child_types[ 8]) 
1698          self.assertEqual("str",   child_types[ 9]) 
1699          self.assertEqual("str",   child_types[10]) 
1700          self.assertEqual("float", child_types[11]) 
1701          self.assertEqual("int",   child_types[12]) 
1702          self.assertEqual(TREE_PYTYPE, child_types[13]) 
1703           
1704          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1705           
1707          XML = self.XML 
1708          root = XML(_bytes('''\ 
1709          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1710          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1711            <b>5</b> 
1712            <b>test</b> 
1713            <c>1.1</c> 
1714            <c>\uF8D2</c> 
1715            <x>true</x> 
1716            <n xsi:nil="true" /> 
1717            <n></n> 
1718            <b xsi:type="double">5</b> 
1719            <b xsi:type="float">5</b> 
1720            <s xsi:type="string">23</s> 
1721            <s py:pytype="str">42</s> 
1722            <f py:pytype="float">300</f> 
1723            <l py:pytype="long">2</l> 
1724            <t py:pytype="TREE"></t> 
1725          </a> 
1726          ''')) 
1727          objectify.xsiannotate(root, ignore_old=True) 
1728   
1729          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1730                          for c in root.iterchildren() ] 
1731          self.assertEqual("xsd:integer", child_types[ 0]) 
1732          self.assertEqual("xsd:string",  child_types[ 1]) 
1733          self.assertEqual("xsd:double",  child_types[ 2]) 
1734          self.assertEqual("xsd:string",  child_types[ 3]) 
1735          self.assertEqual("xsd:boolean", child_types[ 4]) 
1736          self.assertEqual(None,          child_types[ 5]) 
1737          self.assertEqual(None,          child_types[ 6]) 
1738          self.assertEqual("xsd:integer", child_types[ 7]) 
1739          self.assertEqual("xsd:integer", child_types[ 8]) 
1740          self.assertEqual("xsd:integer", child_types[ 9]) 
1741          self.assertEqual("xsd:string",  child_types[10]) 
1742          self.assertEqual("xsd:double",  child_types[11]) 
1743          self.assertEqual("xsd:integer", child_types[12]) 
1744          self.assertEqual(None,          child_types[13]) 
1745   
1746          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1747   
1749          XML = self.XML 
1750          root = XML(_bytes('''\ 
1751          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1752          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1753            <b>5</b> 
1754            <b>test</b> 
1755            <c>1.1</c> 
1756            <c>\uF8D2</c> 
1757            <x>true</x> 
1758            <n xsi:nil="true" /> 
1759            <n></n> 
1760            <b xsi:type="double">5</b> 
1761            <b xsi:type="float">5</b> 
1762            <s xsi:type="string">23</s> 
1763            <s py:pytype="str">42</s> 
1764            <f py:pytype="float">300</f> 
1765            <l py:pytype="long">2</l> 
1766            <t py:pytype="TREE"></t> 
1767          </a> 
1768          ''')) 
1769          objectify.deannotate(root) 
1770   
1771          for c in root.getiterator(): 
1772              self.assertEqual(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 
1773              self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 
1774   
1775          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1776   
1778          XML = self.XML 
1779          root = XML(_bytes('''\ 
1780          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1781          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1782            <b>5</b> 
1783            <b>test</b> 
1784            <c>1.1</c> 
1785            <c>\uF8D2</c> 
1786            <x>true</x> 
1787            <n xsi:nil="true" /> 
1788            <n></n> 
1789            <b xsi:type="double">5</b> 
1790            <b xsi:type="float">5</b> 
1791            <s xsi:type="string">23</s> 
1792            <s py:pytype="str">42</s> 
1793            <f py:pytype="float">300</f> 
1794            <l py:pytype="long">2</l> 
1795            <t py:pytype="TREE"></t> 
1796          </a> 
1797          ''')) 
1798          objectify.annotate( 
1799              root, ignore_old=False, ignore_xsi=False, annotate_xsi=True, 
1800              empty_pytype='str', empty_type='string') 
1801          objectify.deannotate(root, pytype=False, xsi=False, xsi_nil=True) 
1802   
1803          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1804                          for c in root.iterchildren() ] 
1805          self.assertEqual("xsd:integer",  child_types[ 0]) 
1806          self.assertEqual("xsd:string",   child_types[ 1]) 
1807          self.assertEqual("xsd:double",   child_types[ 2]) 
1808          self.assertEqual("xsd:string",   child_types[ 3]) 
1809          self.assertEqual("xsd:boolean",  child_types[ 4]) 
1810          self.assertEqual(None,           child_types[ 5]) 
1811          self.assertEqual("xsd:string",   child_types[ 6]) 
1812          self.assertEqual("xsd:double",   child_types[ 7]) 
1813          self.assertEqual("xsd:float",    child_types[ 8]) 
1814          self.assertEqual("xsd:string",   child_types[ 9]) 
1815          self.assertEqual("xsd:string",   child_types[10]) 
1816          self.assertEqual("xsd:double",    child_types[11]) 
1817          self.assertEqual("xsd:integer",  child_types[12]) 
1818          self.assertEqual(None,           child_types[13]) 
1819   
1820          self.assertEqual(None, root.n.get(XML_SCHEMA_NIL_ATTR)) 
1821   
1822          for c in root.iterchildren(): 
1823              self.assertNotEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 
1824              # these have no equivalent in xsi:type 
1825              if (c.get(objectify.PYTYPE_ATTRIBUTE) not in [TREE_PYTYPE,  
1826                  "NoneType"]): 
1827                  self.assertNotEqual( 
1828                      None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 
1829   
1831          XML = self.XML 
1832          root = XML(_bytes('''\ 
1833          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1834          xmlns:py="http://codespeak.net/lxml/objectify/pytype" 
1835          xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
1836            <b>5</b> 
1837            <b>test</b> 
1838            <c>1.1</c> 
1839            <c>\uF8D2</c> 
1840            <x>true</x> 
1841            <n xsi:nil="true" /> 
1842            <n></n> 
1843            <b xsi:type="xsd:double">5</b> 
1844            <b xsi:type="xsd:float">5</b> 
1845            <s xsi:type="xsd:string">23</s> 
1846            <s py:pytype="str">42</s> 
1847            <f py:pytype="float">300</f> 
1848            <l py:pytype="long">2</l> 
1849            <t py:pytype="TREE"></t> 
1850          </a> 
1851          ''')) 
1852          objectify.annotate(root) 
1853          objectify.deannotate(root, pytype=False) 
1854   
1855          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1856                          for c in root.iterchildren() ] 
1857          self.assertEqual("int",   child_types[ 0]) 
1858          self.assertEqual("str",   child_types[ 1]) 
1859          self.assertEqual("float", child_types[ 2]) 
1860          self.assertEqual("str",   child_types[ 3]) 
1861          self.assertEqual("bool",  child_types[ 4]) 
1862          self.assertEqual("NoneType",  child_types[ 5]) 
1863          self.assertEqual(None,    child_types[ 6]) 
1864          self.assertEqual("float", child_types[ 7]) 
1865          self.assertEqual("float", child_types[ 8]) 
1866          self.assertEqual("str",   child_types[ 9]) 
1867          self.assertEqual("int",   child_types[10]) 
1868          self.assertEqual("int",   child_types[11]) 
1869          self.assertEqual("int",   child_types[12]) 
1870          self.assertEqual(None,    child_types[13]) 
1871           
1872          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1873   
1874          for c in root.getiterator(): 
1875              self.assertEqual(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 
1876   
1878          XML = self.XML 
1879          root = XML(_bytes('''\ 
1880          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1881          xmlns:py="http://codespeak.net/lxml/objectify/pytype" 
1882          xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
1883            <b xsi:type="xsd:int">5</b> 
1884            <b xsi:type="xsd:string">test</b> 
1885            <c xsi:type="xsd:float">1.1</c> 
1886            <c xsi:type="xsd:string">\uF8D2</c> 
1887            <x xsi:type="xsd:boolean">true</x> 
1888            <n xsi:nil="true" /> 
1889            <n></n> 
1890            <b xsi:type="xsd:double">5</b> 
1891            <b xsi:type="xsd:float">5</b> 
1892            <s xsi:type="xsd:string">23</s> 
1893            <s xsi:type="xsd:string">42</s> 
1894            <f xsi:type="xsd:float">300</f> 
1895            <l xsi:type="xsd:long">2</l> 
1896            <t py:pytype="TREE"></t> 
1897          </a> 
1898          ''')) 
1899          objectify.annotate(root) 
1900          objectify.deannotate(root, xsi=False) 
1901   
1902          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1903                          for c in root.iterchildren() ] 
1904          self.assertEqual("xsd:int",      child_types[ 0]) 
1905          self.assertEqual("xsd:string",   child_types[ 1]) 
1906          self.assertEqual("xsd:float",    child_types[ 2]) 
1907          self.assertEqual("xsd:string",   child_types[ 3]) 
1908          self.assertEqual("xsd:boolean",  child_types[ 4]) 
1909          self.assertEqual(None,           child_types[ 5]) 
1910          self.assertEqual(None,           child_types[ 6]) 
1911          self.assertEqual("xsd:double",   child_types[ 7]) 
1912          self.assertEqual("xsd:float",    child_types[ 8]) 
1913          self.assertEqual("xsd:string",   child_types[ 9]) 
1914          self.assertEqual("xsd:string",   child_types[10]) 
1915          self.assertEqual("xsd:float",    child_types[11]) 
1916          self.assertEqual("xsd:long",     child_types[12]) 
1917          self.assertEqual(None,           child_types[13]) 
1918   
1919          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1920   
1921          for c in root.getiterator(): 
1922              self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 
1923   
1925          XML = self.XML 
1926   
1927          xml = _bytes('''\ 
1928          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
1929            <b>5</b> 
1930            <b>test</b> 
1931            <c>1.1</c> 
1932            <c>\uF8D2</c> 
1933            <x>true</x> 
1934            <n xsi:nil="true" /> 
1935            <n></n> 
1936            <b xsi:type="double">5</b> 
1937          </a> 
1938          ''') 
1939   
1940          pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 
1941          objectify.set_pytype_attribute_tag("{TEST}test") 
1942   
1943          root = XML(xml) 
1944          objectify.annotate(root) 
1945   
1946          attribs = root.xpath("//@py:%s" % pytype_name, 
1947                               namespaces={"py" : pytype_ns}) 
1948          self.assertEqual(0, len(attribs)) 
1949          attribs = root.xpath("//@py:test", 
1950                               namespaces={"py" : "TEST"}) 
1951          self.assertEqual(7, len(attribs)) 
1952   
1953          objectify.set_pytype_attribute_tag() 
1954          pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 
1955   
1956          self.assertNotEqual("test", pytype_ns.lower()) 
1957          self.assertNotEqual("test", pytype_name.lower()) 
1958   
1959          root = XML(xml) 
1960          attribs = root.xpath("//@py:%s" % pytype_name, 
1961                               namespaces={"py" : pytype_ns}) 
1962          self.assertEqual(0, len(attribs)) 
1963   
1964          objectify.annotate(root) 
1965          attribs = root.xpath("//@py:%s" % pytype_name, 
1966                               namespaces={"py" : pytype_ns}) 
1967          self.assertEqual(7, len(attribs)) 
1968   
1970          orig_types = objectify.getRegisteredTypes() 
1971          orig_types[0].unregister() 
1972          self.assertEqual(orig_types[1:], objectify.getRegisteredTypes()) 
1973   
1974          class NewType(objectify.ObjectifiedDataElement): 
1975              pass 
1976   
1977          def checkMyType(s): 
1978              return True 
1979   
1980          pytype = objectify.PyType("mytype", checkMyType, NewType) 
1981          self.assertTrue(pytype not in objectify.getRegisteredTypes()) 
1982          pytype.register() 
1983          self.assertTrue(pytype in objectify.getRegisteredTypes()) 
1984          pytype.unregister() 
1985          self.assertTrue(pytype not in objectify.getRegisteredTypes()) 
1986   
1987          pytype.register(before = [objectify.getRegisteredTypes()[0].name]) 
1988          self.assertEqual(pytype, objectify.getRegisteredTypes()[0]) 
1989          pytype.unregister() 
1990   
1991          pytype.register(after = [objectify.getRegisteredTypes()[0].name]) 
1992          self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0]) 
1993          pytype.unregister() 
1994   
1995          self.assertRaises(ValueError, pytype.register, 
1996                            before = [objectify.getRegisteredTypes()[0].name], 
1997                            after  = [objectify.getRegisteredTypes()[1].name]) 
1998   
2000          from datetime import datetime 
2001          def parse_date(value): 
2002              if len(value) != 14: 
2003                  raise ValueError(value) 
2004              Y = int(value[0:4]) 
2005              M = int(value[4:6]) 
2006              D = int(value[6:8]) 
2007              h = int(value[8:10]) 
2008              m = int(value[10:12]) 
2009              s = int(value[12:14]) 
2010              return datetime(Y, M, D, h, m, s) 
2011   
2012          def stringify_date(date): 
2013              return date.strftime("%Y%m%d%H%M%S") 
2014   
2015          class DatetimeElement(objectify.ObjectifiedDataElement): 
2016              def pyval(self): 
2017                  return parse_date(self.text) 
2018              pyval = property(pyval) 
2019   
2020          datetime_type = objectify.PyType( 
2021              "datetime", parse_date, DatetimeElement, stringify_date) 
2022          datetime_type.xmlSchemaTypes = "dateTime" 
2023          datetime_type.register() 
2024   
2025          NAMESPACE = "http://foo.net/xmlns" 
2026          NAMESPACE_MAP = {'ns': NAMESPACE} 
2027   
2028          r = objectify.Element("{%s}root" % NAMESPACE, nsmap=NAMESPACE_MAP) 
2029          time = datetime.now() 
2030          r.date = time 
2031   
2032          self.assertTrue(isinstance(r.date, DatetimeElement)) 
2033          self.assertTrue(isinstance(r.date.pyval, datetime)) 
2034   
2035          self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 
2036          self.assertEqual(r.date.text, stringify_date(time)) 
2037   
2038          r.date = objectify.E.date(time) 
2039   
2040          self.assertTrue(isinstance(r.date, DatetimeElement)) 
2041          self.assertTrue(isinstance(r.date.pyval, datetime)) 
2042   
2043          self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 
2044          self.assertEqual(r.date.text, stringify_date(time)) 
2045   
2046          date = objectify.DataElement(time) 
2047   
2048          self.assertTrue(isinstance(date, DatetimeElement)) 
2049          self.assertTrue(isinstance(date.pyval, datetime)) 
2050   
2051          self.assertEqual(date.pyval, parse_date(stringify_date(time))) 
2052          self.assertEqual(date.text, stringify_date(time)) 
2053   
2055          root = self.XML(xml_str) 
2056          path = objectify.ObjectPath( "root.c1.c2" ) 
2057          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2058          self.assertEqual(root.c1.c2.text, path(root).text) 
2059   
2061          root = self.XML(xml_str) 
2062          path = objectify.ObjectPath( ['root', 'c1', 'c2'] ) 
2063          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2064          self.assertEqual(root.c1.c2.text, path(root).text) 
2065   
2067          root = self.XML(xml_str) 
2068          path = objectify.ObjectPath( "root.c1.c99" ) 
2069          self.assertRaises(AttributeError, path, root) 
2070   
2072          root = self.XML(xml_str) 
2073          path = objectify.ObjectPath( "root.c1.c99" ) 
2074          self.assertEqual(None, path(root, None)) 
2075          path = objectify.ObjectPath( "root.c99.c2" ) 
2076          self.assertEqual(None, path(root, None)) 
2077          path = objectify.ObjectPath( "notroot.c99.c2" ) 
2078          self.assertEqual(None, path(root, None)) 
2079   
2081          root = self.XML(xml_str) 
2082          path = objectify.ObjectPath( ".c1.c99" ) 
2083          self.assertEqual(None, path(root, None)) 
2084          path = objectify.ObjectPath( ".c99.c2" ) 
2085          self.assertEqual(None, path(root, None)) 
2086   
2088          root = self.XML(xml_str) 
2089          path = objectify.ObjectPath("root .    {objectified}c1.   c2") 
2090          self.assertEqual(root.c1.c2.text, path(root).text) 
2091   
2092          path = objectify.ObjectPath("   root.{objectified}  c1.c2  [ 0 ]   ") 
2093          self.assertEqual(root.c1.c2.text, path(root).text) 
2094   
2097   
2100   
2102          root = self.XML(xml_str) 
2103          path = objectify.ObjectPath( "root" ) 
2104          self.assertTrue(path.hasattr(root)) 
2105          path = objectify.ObjectPath( "root.c1" ) 
2106          self.assertTrue(path.hasattr(root)) 
2107          path = objectify.ObjectPath( "root.c1.c2" ) 
2108          self.assertTrue(path.hasattr(root)) 
2109          path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 
2110          self.assertTrue(path.hasattr(root)) 
2111          path = objectify.ObjectPath( "root.c1.c2[1]" ) 
2112          self.assertTrue(path.hasattr(root)) 
2113          path = objectify.ObjectPath( "root.c1.c2[2]" ) 
2114          self.assertTrue(path.hasattr(root)) 
2115          path = objectify.ObjectPath( "root.c1.c2[3]" ) 
2116          self.assertFalse(path.hasattr(root)) 
2117          path = objectify.ObjectPath( "root.c1[1].c2" ) 
2118          self.assertFalse(path.hasattr(root)) 
2119   
2121          root = self.XML(xml_str) 
2122          path = objectify.ObjectPath( "." ) 
2123          self.assertEqual(root.c1.c2.text, path(root).c1.c2.text) 
2124   
2126          root = self.XML(xml_str) 
2127          path = objectify.ObjectPath( [''] ) 
2128          self.assertEqual(root.c1.c2.text, path(root).c1.c2.text) 
2129   
2131          root = self.XML(xml_str) 
2132          path = objectify.ObjectPath( ".c1.c2" ) 
2133          self.assertEqual(root.c1.c2.text, path(root).text) 
2134   
2136          root = self.XML(xml_str) 
2137          path = objectify.ObjectPath( ['', 'c1', 'c2'] ) 
2138          self.assertEqual(root.c1.c2.text, path(root).text) 
2139   
2141          root = self.XML(xml_str) 
2142          path = objectify.ObjectPath( "root.c1[0].c2[0]" ) 
2143          self.assertEqual(root.c1.c2.text, path(root).text) 
2144   
2145          path = objectify.ObjectPath( "root.c1[0].c2" ) 
2146          self.assertEqual(root.c1.c2.text, path(root).text) 
2147   
2148          path = objectify.ObjectPath( "root.c1[0].c2[1]" ) 
2149          self.assertEqual(root.c1.c2[1].text, path(root).text) 
2150   
2151          path = objectify.ObjectPath( "root.c1.c2[2]" ) 
2152          self.assertEqual(root.c1.c2[2].text, path(root).text) 
2153   
2154          path = objectify.ObjectPath( "root.c1.c2[-1]" ) 
2155          self.assertEqual(root.c1.c2[-1].text, path(root).text) 
2156   
2157          path = objectify.ObjectPath( "root.c1.c2[-3]" ) 
2158          self.assertEqual(root.c1.c2[-3].text, path(root).text) 
2159   
2161          root = self.XML(xml_str) 
2162          path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] ) 
2163          self.assertEqual(root.c1.c2.text, path(root).text) 
2164   
2165          path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] ) 
2166          self.assertEqual(root.c1.c2[2].text, path(root).text) 
2167   
2168          path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] ) 
2169          self.assertEqual(root.c1.c2[2].text, path(root).text) 
2170   
2171          path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] ) 
2172          self.assertEqual(root.c1.c2[-1].text, path(root).text) 
2173   
2174          path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] ) 
2175          self.assertEqual(root.c1.c2[-3].text, path(root).text) 
2176   
2178          self.assertRaises(ValueError, objectify.ObjectPath, 
2179                            "root.c1[0].c2[-1-2]") 
2180          self.assertRaises(ValueError, objectify.ObjectPath, 
2181                            ['root', 'c1[0]', 'c2[-1-2]']) 
2182   
2183          self.assertRaises(ValueError, objectify.ObjectPath, 
2184                            "root[2].c1.c2") 
2185          self.assertRaises(ValueError, objectify.ObjectPath, 
2186                            ['root[2]', 'c1', 'c2']) 
2187   
2188          self.assertRaises(ValueError, objectify.ObjectPath, 
2189                            []) 
2190          self.assertRaises(ValueError, objectify.ObjectPath, 
2191                            ['', '', '']) 
2192   
2194          root = self.XML(xml_str) 
2195          path = objectify.ObjectPath("root.c1[9999].c2") 
2196          self.assertRaises(AttributeError, path, root) 
2197   
2198          path = objectify.ObjectPath("root.c1[0].c2[9999]") 
2199          self.assertRaises(AttributeError, path, root) 
2200   
2201          path = objectify.ObjectPath(".c1[9999].c2[0]") 
2202          self.assertRaises(AttributeError, path, root) 
2203   
2204          path = objectify.ObjectPath("root.c1[-2].c2") 
2205          self.assertRaises(AttributeError, path, root) 
2206   
2207          path = objectify.ObjectPath("root.c1[0].c2[-4]") 
2208          self.assertRaises(AttributeError, path, root) 
2209   
2211          root = self.XML(xml_str) 
2212          path = objectify.ObjectPath( "{objectified}root.c1.c2" ) 
2213          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2214          path = objectify.ObjectPath( "{objectified}root.{objectified}c1.c2" ) 
2215          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2216          path = objectify.ObjectPath( "root.{objectified}c1.{objectified}c2" ) 
2217          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2218          path = objectify.ObjectPath( "root.c1.{objectified}c2" ) 
2219          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2220          path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 
2221          self.assertEqual(getattr(root.c1, '{otherNS}c2').text, 
2222                            path.find(root).text) 
2223   
2225          root = self.XML(xml_str) 
2226          path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] ) 
2227          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2228          path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] ) 
2229          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2230          path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] ) 
2231          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2232          path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] ) 
2233          self.assertEqual(root.c1.c2[2].text, path.find(root).text) 
2234          path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] ) 
2235          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2236          path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] ) 
2237          self.assertEqual(root.c1.c2[2].text, path.find(root).text) 
2238          path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] ) 
2239          self.assertEqual(getattr(root.c1, '{otherNS}c2').text, 
2240                            path.find(root).text) 
2241   
2243          root = self.XML(xml_str) 
2244          path = objectify.ObjectPath( "root.c1.c2" ) 
2245          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2246          self.assertEqual("1", root.c1.c2[1].text) 
2247   
2248          new_value = "my new value" 
2249          path.setattr(root, new_value) 
2250   
2251          self.assertEqual(new_value, root.c1.c2.text) 
2252          self.assertEqual(new_value, path(root).text) 
2253          self.assertEqual("1", root.c1.c2[1].text) 
2254   
2256          root = self.XML(xml_str) 
2257          path = objectify.ObjectPath( "root.c1.c2" ) 
2258          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2259          self.assertEqual("1", root.c1.c2[1].text) 
2260   
2261          new_el = self.Element("{objectified}test") 
2262          etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 
2263          path.setattr(root, new_el.sub) 
2264   
2265          self.assertEqual("ATTR", root.c1.c2.get("myattr")) 
2266          self.assertEqual("TEST", root.c1.c2.a.text) 
2267          self.assertEqual("TEST", path(root).a.text) 
2268          self.assertEqual("1", root.c1.c2[1].text) 
2269   
2271          root = self.XML(xml_str) 
2272          path = objectify.ObjectPath( "root.c1.c99" ) 
2273          self.assertRaises(AttributeError, path.find, root) 
2274   
2275          new_value = "my new value" 
2276          path.setattr(root, new_value) 
2277   
2278          self.assertEqual(1, len(root.c1.c99)) 
2279          self.assertEqual(new_value, root.c1.c99.text) 
2280          self.assertEqual(new_value, path(root).text) 
2281   
2283          root = self.XML(xml_str) 
2284          path = objectify.ObjectPath( "root.c1.c99" ) 
2285          self.assertRaises(AttributeError, path.find, root) 
2286   
2287          new_el = self.Element("{objectified}test") 
2288          etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 
2289          path.setattr(root, new_el.sub) 
2290   
2291          self.assertEqual(1, len(root.c1.c99)) 
2292          self.assertEqual("ATTR", root.c1.c99.get("myattr")) 
2293          self.assertEqual("TEST", root.c1.c99.a.text) 
2294          self.assertEqual("TEST", path(root).a.text) 
2295   
2297          root = self.XML(xml_str) 
2298          path = objectify.ObjectPath( "root.c1.c99" ) 
2299          self.assertRaises(AttributeError, path.find, root) 
2300   
2301          new_el = self.Element("{objectified}test") 
2302          new_el.a = ["TEST1", "TEST2"] 
2303          new_el.a[0].set("myattr", "ATTR1") 
2304          new_el.a[1].set("myattr", "ATTR2") 
2305   
2306          path.setattr(root, list(new_el.a)) 
2307   
2308          self.assertEqual(2, len(root.c1.c99)) 
2309          self.assertEqual("ATTR1", root.c1.c99[0].get("myattr")) 
2310          self.assertEqual("TEST1", root.c1.c99[0].text) 
2311          self.assertEqual("ATTR2", root.c1.c99[1].get("myattr")) 
2312          self.assertEqual("TEST2", root.c1.c99[1].text) 
2313          self.assertEqual("TEST1", path(root).text) 
2314   
2316          root = self.XML(xml_str) 
2317          path = objectify.ObjectPath( "root.c1.c2" ) 
2318          self.assertEqual(3, len(root.c1.c2)) 
2319          path.addattr(root, "test") 
2320          self.assertEqual(4, len(root.c1.c2)) 
2321          self.assertEqual(["0", "1", "2", "test"], 
2322                            [el.text for el in root.c1.c2]) 
2323   
2325          root = self.XML(xml_str) 
2326          path = objectify.ObjectPath( "root.c1.c2" ) 
2327          self.assertEqual(3, len(root.c1.c2)) 
2328   
2329          new_el = self.Element("{objectified}test") 
2330          etree.SubElement(new_el, "{objectified}sub").a = "TEST" 
2331   
2332          path.addattr(root, new_el.sub) 
2333          self.assertEqual(4, len(root.c1.c2)) 
2334          self.assertEqual("TEST", root.c1.c2[3].a.text) 
2335          self.assertEqual(["0", "1", "2"], 
2336                            [el.text for el in root.c1.c2[:3]]) 
2337   
2339          root = self.XML(xml_str) 
2340          path = objectify.ObjectPath( "root.c1.c99" ) 
2341          self.assertRaises(AttributeError, path.find, root) 
2342   
2343          new_value = "my new value" 
2344          path.addattr(root, new_value) 
2345   
2346          self.assertEqual(1, len(root.c1.c99)) 
2347          self.assertEqual(new_value, root.c1.c99.text) 
2348          self.assertEqual(new_value, path(root).text) 
2349   
2351          root = self.XML(xml_str) 
2352          path = objectify.ObjectPath( "root.c1.c99" ) 
2353          self.assertRaises(AttributeError, path.find, root) 
2354   
2355          new_el = self.Element("{objectified}test") 
2356          etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 
2357   
2358          path.addattr(root, new_el.sub) 
2359          self.assertEqual(1, len(root.c1.c99)) 
2360          self.assertEqual("TEST", root.c1.c99.a.text) 
2361          self.assertEqual("TEST", path(root).a.text) 
2362          self.assertEqual("ATTR", root.c1.c99.get("myattr")) 
2363   
2365          root = self.XML(xml_str) 
2366          path = objectify.ObjectPath( "root.c1.c99" ) 
2367          self.assertRaises(AttributeError, path.find, root) 
2368   
2369          new_el = self.Element("{objectified}test") 
2370          new_el.a = ["TEST1", "TEST2"] 
2371   
2372          self.assertEqual(2, len(new_el.a)) 
2373   
2374          path.addattr(root, list(new_el.a)) 
2375          self.assertEqual(2, len(root.c1.c99)) 
2376          self.assertEqual("TEST1", root.c1.c99.text) 
2377          self.assertEqual("TEST2", path(root)[1].text) 
2378   
2380          root = self.XML(xml_str) 
2381          self.assertEqual( 
2382              ['{objectified}root', '{objectified}root.c1', 
2383               '{objectified}root.c1.c2', 
2384               '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]', 
2385               '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'], 
2386              root.descendantpaths()) 
2387   
2389          root = self.XML(xml_str) 
2390          self.assertEqual( 
2391              ['{objectified}c1', '{objectified}c1.c2', 
2392               '{objectified}c1.c2[1]', '{objectified}c1.c2[2]', 
2393               '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'], 
2394              root.c1.descendantpaths()) 
2395   
2397          root = self.XML(xml_str) 
2398          self.assertEqual( 
2399              ['root.{objectified}c1', 'root.{objectified}c1.c2', 
2400               'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]', 
2401               'root.{objectified}c1.{otherNS}c2', 
2402               'root.{objectified}c1.{}c2'], 
2403              root.c1.descendantpaths('root')) 
2404   
2406          import pickle 
2407   
2408          root = self.XML(xml_str) 
2409          out = BytesIO() 
2410          pickle.dump(root, out) 
2411   
2412          new_root = pickle.loads(out.getvalue()) 
2413          self.assertEqual( 
2414              etree.tostring(new_root), 
2415              etree.tostring(root)) 
2416   
2418          import pickle 
2419   
2420          tree = etree.ElementTree(self.XML(xml_str + "<?my pi?>")) 
2421          out = BytesIO() 
2422          pickle.dump(tree, out) 
2423   
2424          new_tree = pickle.loads(out.getvalue()) 
2425          self.assertTrue(isinstance(new_tree, etree._ElementTree)) 
2426          self.assertEqual( 
2427              etree.tostring(new_tree), 
2428              etree.tostring(tree)) 
2429   
2433   
2437   
2439          self._test_pickle('<x>Pickle me!</x>') 
2440          self._test_pickle(objectify.DataElement('Pickle me!')) 
2441   
2443          self._test_pickle('<x>true</x>') 
2444          self._test_pickle('<x>false</x>') 
2445          self._test_pickle(objectify.DataElement(True)) 
2446          self._test_pickle(objectify.DataElement(False)) 
2447   
2449          self._test_pickle(''' 
2450  <x xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>''') 
2451          self._test_pickle(objectify.DataElement(None)) 
2452   
2454          import pickle 
2455          if isinstance(stringOrElt, (etree._Element, etree._ElementTree)): 
2456              elt = stringOrElt 
2457          else: 
2458              elt = self.XML(stringOrElt) 
2459          out = BytesIO() 
2460          pickle.dump(elt, out) 
2461   
2462          new_elt = pickle.loads(out.getvalue()) 
2463          self.assertEqual( 
2464              etree.tostring(new_elt), 
2465              etree.tostring(elt)) 
2466   
2467      # E-Factory tests, need to use sub-elements as root element is always 
2468      # type-looked-up as ObjectifiedElement (no annotations) 
2470          E = objectify.E 
2471          root = E.root(E.val(23)) 
2472          self.assertTrue(isinstance(root.val, objectify.IntElement)) 
2473   
2475          E = objectify.E 
2476          root = E.root(E.val(233.23)) 
2477          self.assertTrue(isinstance(root.val, objectify.FloatElement)) 
2478   
2480          E = objectify.E 
2481          root = E.root(E.val("what?")) 
2482          self.assertTrue(isinstance(root.val, objectify.StringElement)) 
2483   
2485          E = objectify.E 
2486          root = E.root(E.val(_str("blöödy häll", encoding="ISO-8859-1"))) 
2487          self.assertTrue(isinstance(root.val, objectify.StringElement)) 
2488   
2490          E = objectify.E 
2491          root = E.root(E.val(True)) 
2492          self.assertTrue(isinstance(root.val, objectify.BoolElement)) 
2493   
2495          E = objectify.E 
2496          root = E.root(E.val(None)) 
2497          self.assertTrue(isinstance(root.val, objectify.NoneElement)) 
2498   
2500          E = objectify.E 
2501          root = E.root(E.val(1, "foo", 2.0, "bar ", True, None)) 
2502          self.assertTrue(isinstance(root.val, objectify.StringElement)) 
2503   
2508   
2510          E = objectify.E 
2511          DataElement = objectify.DataElement 
2512          root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1), 
2513                        DataElement(2.0)) 
2514          self.assertTrue(isinstance(root, objectify.ObjectifiedElement)) 
2515          self.assertEqual(root.text, "text") 
2516          self.assertTrue(isinstance(root.sub, objectify.ObjectifiedElement)) 
2517          self.assertEqual(root.sub.tail, "tail") 
2518          self.assertTrue(isinstance(root.sub.subsub, objectify.StringElement)) 
2519          self.assertEqual(len(root.value), 2) 
2520          self.assertTrue(isinstance(root.value[0], objectify.IntElement)) 
2521          self.assertTrue(isinstance(root.value[1], objectify.FloatElement)) 
2522   
2524          class Attribute(objectify.ObjectifiedDataElement): 
2525              def __init__(self): 
2526                  objectify.ObjectifiedDataElement.__init__(self) 
2527                  self.set("datatype", "TYPE") 
2528                  self.set("range", "0.,1.") 
2529   
2530          attr = Attribute() 
2531          self.assertEqual(attr.text, None) 
2532          self.assertEqual(attr.get("datatype"), "TYPE") 
2533          self.assertEqual(attr.get("range"), "0.,1.") 
2534   
2536          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
2537          docinfo = root.getroottree().docinfo 
2538          self.assertEqual(docinfo.URL, "http://no/such/url") 
2539    
2541          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
2542          docinfo = root.getroottree().docinfo 
2543          self.assertEqual(docinfo.URL, "http://no/such/url") 
2544          docinfo.URL = "https://secret/url" 
2545          self.assertEqual(docinfo.URL, "https://secret/url") 
2546    
2548          tree = objectify.parse(BytesIO("<root/>"), base_url="http://no/such/url") 
2549          docinfo = tree.docinfo 
2550          self.assertEqual(docinfo.URL, "http://no/such/url") 
2551    
2553          tree = objectify.parse(fileInTestDir('include/test_xinclude.xml'), 
2554                                 base_url="http://no/such/url") 
2555          docinfo = tree.docinfo 
2556          self.assertEqual(docinfo.URL, "http://no/such/url") 
2557   
2559          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
2560          self.assertEqual(root.base, "http://no/such/url") 
2561          self.assertEqual( 
2562              root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 
2563          root.base = "https://secret/url" 
2564          self.assertEqual(root.base, "https://secret/url") 
2565          self.assertEqual( 
2566              root.get('{http://www.w3.org/XML/1998/namespace}base'), 
2567              "https://secret/url") 
2568    
2570          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
2571          self.assertEqual(root.base, "http://no/such/url") 
2572          self.assertEqual( 
2573              root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 
2574          root.set('{http://www.w3.org/XML/1998/namespace}base', 
2575                   "https://secret/url") 
2576          self.assertEqual(root.base, "https://secret/url") 
2577          self.assertEqual( 
2578              root.get('{http://www.w3.org/XML/1998/namespace}base'), 
2579              "https://secret/url") 
2580   
2582          XML = self.XML 
2583   
2584          xml = _bytes('''\ 
2585          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
2586            <i>5</i> 
2587            <i>-5</i> 
2588            <l>4294967296</l> 
2589            <l>-4294967296</l> 
2590            <f>1.1</f> 
2591            <b>true</b> 
2592            <b>false</b> 
2593            <s>Strange things happen, where strings collide</s> 
2594            <s>True</s> 
2595            <s>False</s> 
2596            <s>t</s> 
2597            <s>f</s> 
2598            <s></s> 
2599            <s>None</s> 
2600            <n xsi:nil="true" /> 
2601          </root> 
2602          ''') 
2603          root = XML(xml) 
2604   
2605          for i in root.i: 
2606              self.assertTrue(isinstance(i, objectify.IntElement)) 
2607          for l in root.l: 
2608              self.assertTrue(isinstance(l, objectify.IntElement)) 
2609          for f in root.f: 
2610              self.assertTrue(isinstance(f, objectify.FloatElement))   
2611          for b in root.b: 
2612              self.assertTrue(isinstance(b, objectify.BoolElement)) 
2613          self.assertEqual(True,  root.b[0]) 
2614          self.assertEqual(False, root.b[1]) 
2615          for s in root.s: 
2616              self.assertTrue(isinstance(s, objectify.StringElement)) 
2617          self.assertTrue(isinstance(root.n, objectify.NoneElement)) 
2618          self.assertEqual(None, root.n) 
2619   
2621      suite = unittest.TestSuite() 
2622      suite.addTests([unittest.makeSuite(ObjectifyTestCase)]) 
2623      suite.addTests(doctest.DocTestSuite(objectify)) 
2624      if sys.version_info >= (2,4): 
2625          suite.addTests( 
2626              [make_doctest('../../../doc/objectify.txt')]) 
2627      return suite 
2628   
2629  if __name__ == '__main__': 
2630      print('to test use test.py %s' % __file__) 
2631   
| Home | Trees | Indices | Help | 
 | 
|---|
| Generated by Epydoc 3.0.1 on Fri Nov 24 17:07:09 2017 | http://epydoc.sourceforge.net |