| 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          for xsi, objclass in xsitype2objclass.items(): 
1021              # 1 is a valid value for all ObjectifiedDataElement classes 
1022              pyval = 1 
1023              value = objectify.DataElement(pyval, _xsi=xsi) 
1024              self.assertTrue(isinstance(value, objclass), 
1025                           "DataElement(%s, _xsi='%s') returns %s, expected %s" 
1026                           % (pyval, xsi, type(value), objclass)) 
1027           
1029          for xsi, objclass in xsitype2objclass.items(): 
1030              # 1 is a valid value for all ObjectifiedDataElement classes 
1031              pyval = 1 
1032              value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi) 
1033              self.assertTrue(isinstance(value, objclass), 
1034                           "DataElement(%s, _xsi='%s') returns %s, expected %s" 
1035                           % (pyval, xsi, type(value), objclass)) 
1036           
1038          for xsi, objclass in xsitype2objclass.items(): 
1039              # 1 is a valid value for all ObjectifiedDataElement classes 
1040              self.assertRaises(ValueError, objectify.DataElement, 1, 
1041                                _xsi="foo:%s" % xsi) 
1042   
1044          for pytype, objclass in pytype2objclass.items(): 
1045              # 1 is a valid value for all ObjectifiedDataElement classes 
1046              pyval = 1 
1047              value = objectify.DataElement(pyval, _pytype=pytype) 
1048              self.assertTrue(isinstance(value, objclass), 
1049                           "DataElement(%s, _pytype='%s') returns %s, expected %s" 
1050                           % (pyval, pytype, type(value), objclass)) 
1051   
1053          pyval = 1 
1054          pytype = "NoneType" 
1055          objclass = objectify.NoneElement 
1056          value = objectify.DataElement(pyval, _pytype=pytype) 
1057          self.assertTrue(isinstance(value, objclass), 
1058                       "DataElement(%s, _pytype='%s') returns %s, expected %s" 
1059                       % (pyval, pytype, type(value), objclass)) 
1060          self.assertEqual(value.text, None) 
1061          self.assertEqual(value.pyval, None) 
1062               
1064          # pre-2.0 lxml called NoneElement "none" 
1065          pyval = 1 
1066          pytype = "none" 
1067          objclass = objectify.NoneElement 
1068          value = objectify.DataElement(pyval, _pytype=pytype) 
1069          self.assertTrue(isinstance(value, objclass), 
1070                       "DataElement(%s, _pytype='%s') returns %s, expected %s" 
1071                       % (pyval, pytype, type(value), objclass)) 
1072          self.assertEqual(value.text, None) 
1073          self.assertEqual(value.pyval, None) 
1074   
1076          Element = self.Element 
1077          SubElement = self.etree.SubElement 
1078          class MyFloat(float): 
1079              pass 
1080          root = Element("{objectified}root") 
1081          root.myfloat = MyFloat(5.5) 
1082          self.assertTrue(isinstance(root.myfloat, objectify.FloatElement)) 
1083          self.assertEqual(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None) 
1084   
1088          value = objectify.DataElement(MyFloat(5.5)) 
1089          self.assertTrue(isinstance(value, objectify.FloatElement)) 
1090          self.assertEqual(value, 5.5) 
1091          self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), None) 
1092   
1094          XML = self.XML 
1095          root = XML('''\ 
1096          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
1097            <b xsi:type="boolean">true</b> 
1098            <b xsi:type="boolean">false</b> 
1099            <b xsi:type="boolean">1</b> 
1100            <b xsi:type="boolean">0</b> 
1101   
1102            <f xsi:type="float">5</f> 
1103            <f xsi:type="double">5</f> 
1104           
1105            <s xsi:type="string">5</s> 
1106            <s xsi:type="normalizedString">5</s> 
1107            <s xsi:type="token">5</s> 
1108            <s xsi:type="language">5</s> 
1109            <s xsi:type="Name">5</s> 
1110            <s xsi:type="NCName">5</s> 
1111            <s xsi:type="ID">5</s> 
1112            <s xsi:type="IDREF">5</s> 
1113            <s xsi:type="ENTITY">5</s> 
1114            <s xsi:type="NMTOKEN">5</s> 
1115   
1116            <l xsi:type="integer">5</l> 
1117            <l xsi:type="nonPositiveInteger">5</l> 
1118            <l xsi:type="negativeInteger">5</l> 
1119            <l xsi:type="long">5</l> 
1120            <l xsi:type="nonNegativeInteger">5</l> 
1121            <l xsi:type="unsignedLong">5</l> 
1122            <l xsi:type="unsignedInt">5</l> 
1123            <l xsi:type="positiveInteger">5</l> 
1124             
1125            <i xsi:type="int">5</i> 
1126            <i xsi:type="short">5</i> 
1127            <i xsi:type="byte">5</i> 
1128            <i xsi:type="unsignedShort">5</i> 
1129            <i xsi:type="unsignedByte">5</i> 
1130   
1131            <n xsi:nil="true"/> 
1132          </root> 
1133          ''') 
1134   
1135          for b in root.b: 
1136              self.assertTrue(isinstance(b, objectify.BoolElement)) 
1137          self.assertEqual(True,  root.b[0]) 
1138          self.assertEqual(False, root.b[1]) 
1139          self.assertEqual(True,  root.b[2]) 
1140          self.assertEqual(False, root.b[3]) 
1141   
1142          for f in root.f: 
1143              self.assertTrue(isinstance(f, objectify.FloatElement)) 
1144              self.assertEqual(5, f) 
1145               
1146          for s in root.s: 
1147              self.assertTrue(isinstance(s, objectify.StringElement)) 
1148              self.assertEqual("5", s) 
1149   
1150          for i in root.i: 
1151              self.assertTrue(isinstance(i, objectify.IntElement)) 
1152              self.assertEqual(5, i) 
1153   
1154          for l in root.l: 
1155              self.assertTrue(isinstance(l, objectify.IntElement)) 
1156              self.assertEqual(5, i) 
1157               
1158          self.assertTrue(isinstance(root.n, objectify.NoneElement)) 
1159          self.assertEqual(None, root.n) 
1160   
1162          XML = self.XML 
1163          root = XML('''\ 
1164          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1165          xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
1166            <b xsi:type="xsd:boolean">true</b> 
1167            <b xsi:type="xsd:boolean">false</b> 
1168            <b xsi:type="xsd:boolean">1</b> 
1169            <b xsi:type="xsd:boolean">0</b> 
1170   
1171            <f xsi:type="xsd:float">5</f> 
1172            <f xsi:type="xsd:double">5</f> 
1173           
1174            <s xsi:type="xsd:string">5</s> 
1175            <s xsi:type="xsd:normalizedString">5</s> 
1176            <s xsi:type="xsd:token">5</s> 
1177            <s xsi:type="xsd:language">5</s> 
1178            <s xsi:type="xsd:Name">5</s> 
1179            <s xsi:type="xsd:NCName">5</s> 
1180            <s xsi:type="xsd:ID">5</s> 
1181            <s xsi:type="xsd:IDREF">5</s> 
1182            <s xsi:type="xsd:ENTITY">5</s> 
1183            <s xsi:type="xsd:NMTOKEN">5</s> 
1184   
1185            <l xsi:type="xsd:integer">5</l> 
1186            <l xsi:type="xsd:nonPositiveInteger">5</l> 
1187            <l xsi:type="xsd:negativeInteger">5</l> 
1188            <l xsi:type="xsd:long">5</l> 
1189            <l xsi:type="xsd:nonNegativeInteger">5</l> 
1190            <l xsi:type="xsd:unsignedLong">5</l> 
1191            <l xsi:type="xsd:unsignedInt">5</l> 
1192            <l xsi:type="xsd:positiveInteger">5</l> 
1193             
1194            <i xsi:type="xsd:int">5</i> 
1195            <i xsi:type="xsd:short">5</i> 
1196            <i xsi:type="xsd:byte">5</i> 
1197            <i xsi:type="xsd:unsignedShort">5</i> 
1198            <i xsi:type="xsd:unsignedByte">5</i> 
1199   
1200            <n xsi:nil="true"/> 
1201          </root> 
1202          ''') 
1203   
1204          for b in root.b: 
1205              self.assertTrue(isinstance(b, objectify.BoolElement)) 
1206          self.assertEqual(True,  root.b[0]) 
1207          self.assertEqual(False, root.b[1]) 
1208          self.assertEqual(True,  root.b[2]) 
1209          self.assertEqual(False, root.b[3]) 
1210   
1211          for f in root.f: 
1212              self.assertTrue(isinstance(f, objectify.FloatElement)) 
1213              self.assertEqual(5, f) 
1214               
1215          for s in root.s: 
1216              self.assertTrue(isinstance(s, objectify.StringElement)) 
1217              self.assertEqual("5", s) 
1218   
1219          for i in root.i: 
1220              self.assertTrue(isinstance(i, objectify.IntElement)) 
1221              self.assertEqual(5, i) 
1222   
1223          for l in root.l: 
1224              self.assertTrue(isinstance(l, objectify.IntElement)) 
1225              self.assertEqual(5, l) 
1226               
1227          self.assertTrue(isinstance(root.n, objectify.NoneElement)) 
1228          self.assertEqual(None, root.n) 
1229           
1231          XML = self.XML 
1232          root = XML(_bytes('<root><b>why</b><b>try</b></root>')) 
1233          strs = [ str(s) for s in root.b ] 
1234          self.assertEqual(["why", "try"], 
1235                            strs) 
1236   
1238          XML = self.XML 
1239          root = XML(_bytes('<root><b>test</b><b>taste</b><b></b><b/></root>')) 
1240          self.assertFalse(root.b[0] <  root.b[1]) 
1241          self.assertFalse(root.b[0] <= root.b[1]) 
1242          self.assertFalse(root.b[0] == root.b[1]) 
1243   
1244          self.assertTrue(root.b[0] != root.b[1]) 
1245          self.assertTrue(root.b[0] >= root.b[1]) 
1246          self.assertTrue(root.b[0] >  root.b[1]) 
1247   
1248          self.assertEqual(root.b[0], "test") 
1249          self.assertEqual("test", root.b[0]) 
1250   
1251          self.assertEqual("", root.b[2]) 
1252          self.assertEqual(root.b[2], "") 
1253          self.assertEqual("", root.b[3]) 
1254          self.assertEqual(root.b[3], "") 
1255          self.assertEqual(root.b[2], root.b[3]) 
1256           
1257          root.b = "test" 
1258          self.assertTrue(root.b) 
1259          root.b = "" 
1260          self.assertFalse(root.b) 
1261          self.assertEqual(root.b, "") 
1262          self.assertEqual("", root.b) 
1263   
1265          XML = self.XML 
1266          root = XML(_bytes('<root><b>5</b><b>6</b></root>')) 
1267          self.assertTrue(root.b[0] <  root.b[1]) 
1268          self.assertTrue(root.b[0] <= root.b[1]) 
1269          self.assertTrue(root.b[0] != root.b[1]) 
1270   
1271          self.assertFalse(root.b[0] == root.b[1]) 
1272          self.assertFalse(root.b[0] >= root.b[1]) 
1273          self.assertFalse(root.b[0] >  root.b[1]) 
1274   
1275          self.assertEqual(root.b[0], 5) 
1276          self.assertEqual(5, root.b[0]) 
1277          self.assertNotEqual(root.b[0], "5") 
1278   
1279          root.b = 5 
1280          self.assertTrue(root.b) 
1281          root.b = 0 
1282          self.assertFalse(root.b) 
1283           
1284      # float + long share the NumberElement implementation with int 
1285   
1287          XML = self.XML 
1288          root = XML(_bytes('<root><b>false</b><b>true</b></root>')) 
1289          self.assertTrue(root.b[0] <  root.b[1]) 
1290          self.assertTrue(root.b[0] <= root.b[1]) 
1291          self.assertTrue(root.b[0] != root.b[1]) 
1292   
1293          self.assertFalse(root.b[0] == root.b[1]) 
1294          self.assertFalse(root.b[0] >= root.b[1]) 
1295          self.assertFalse(root.b[0] >  root.b[1]) 
1296   
1297          self.assertFalse(root.b[0]) 
1298          self.assertTrue(root.b[1]) 
1299   
1300          self.assertEqual(root.b[0], False) 
1301          self.assertEqual(False, root.b[0]) 
1302          self.assertTrue(root.b[0] <  5) 
1303          self.assertTrue(5 > root.b[0]) 
1304   
1305          root.b = True 
1306          self.assertTrue(root.b) 
1307          root.b = False 
1308          self.assertFalse(root.b) 
1309   
1311          XML = self.XML 
1312          root = XML(_bytes(""" 
1313          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
1314            <b xsi:nil="true"></b><b xsi:nil="true"/> 
1315          </root>""")) 
1316          self.assertTrue(root.b[0] == root.b[1]) 
1317          self.assertFalse(root.b[0]) 
1318          self.assertEqual(root.b[0], None) 
1319          self.assertEqual(None, root.b[0]) 
1320   
1321          # doesn't work in Py3: 
1322   
1323          #for comparison in ["abc", 5, 7.3, True, [], ()]: 
1324          #    none = root.b[1] 
1325          #    self.assertTrue(none < comparison, "%s (%s) should be < %s" % 
1326          #                 (none, type(none), comparison) ) 
1327          #    self.assertTrue(comparison > none, "%s should be > %s (%s)" % 
1328          #                 (comparison, none, type(none)) ) 
1329   
1331          el = objectify.DataElement(1, _xsi="string") 
1332          self.assertEqual( 
1333              el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 
1334              'xsd:string') 
1335   
1337          el = objectify.DataElement(1, _xsi="string",  
1338                                     nsmap={'schema': XML_SCHEMA_NS}) 
1339          self.assertEqual( 
1340              el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 
1341              'schema:string') 
1342   
1346   
1348          XML = self.XML 
1349          root = XML(_bytes('''\ 
1350          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1351          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1352            <b>5</b> 
1353            <b>test</b> 
1354            <c>1.1</c> 
1355            <c>\uF8D2</c> 
1356            <x>true</x> 
1357            <n xsi:nil="true" /> 
1358            <n></n> 
1359            <b xsi:type="double">5</b> 
1360            <b xsi:type="float">5</b> 
1361            <s xsi:type="string">23</s> 
1362            <s py:pytype="str">42</s> 
1363            <f py:pytype="float">300</f> 
1364            <l py:pytype="long">2</l> 
1365            <t py:pytype="TREE"></t> 
1366          </a> 
1367          ''')) 
1368          objectify.annotate(root) 
1369   
1370          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1371                          for c in root.iterchildren() ] 
1372          self.assertEqual("int",   child_types[ 0]) 
1373          self.assertEqual("str",   child_types[ 1]) 
1374          self.assertEqual("float", child_types[ 2]) 
1375          self.assertEqual("str",   child_types[ 3]) 
1376          self.assertEqual("bool",  child_types[ 4]) 
1377          self.assertEqual("NoneType",  child_types[ 5]) 
1378          self.assertEqual(None,    child_types[ 6]) 
1379          self.assertEqual("float", child_types[ 7]) 
1380          self.assertEqual("float", child_types[ 8]) 
1381          self.assertEqual("str",   child_types[ 9]) 
1382          self.assertEqual("int",   child_types[10]) 
1383          self.assertEqual("int",   child_types[11]) 
1384          self.assertEqual("int",   child_types[12]) 
1385          self.assertEqual(None,    child_types[13]) 
1386           
1387          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1388   
1390          XML = self.XML 
1391          root = XML(_bytes('''\ 
1392          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1393          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1394            <n></n> 
1395          </a> 
1396          ''')) 
1397          objectify.annotate(root) 
1398   
1399          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1400                          for c in root.iterchildren() ] 
1401          self.assertEqual(None,    child_types[0]) 
1402   
1403          objectify.annotate(root, empty_pytype="str") 
1404   
1405          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1406                          for c in root.iterchildren() ] 
1407          self.assertEqual("str",    child_types[0]) 
1408   
1410          XML = self.XML 
1411          root = XML(_bytes('''\ 
1412          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1413          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1414            <b>5</b> 
1415            <b>test</b> 
1416            <c>1.1</c> 
1417            <c>\uF8D2</c> 
1418            <x>true</x> 
1419            <n xsi:nil="true" /> 
1420            <n></n> 
1421            <b xsi:type="double">5</b> 
1422            <b xsi:type="float">5</b> 
1423            <s xsi:type="string">23</s> 
1424            <s py:pytype="str">42</s> 
1425            <f py:pytype="float">300</f> 
1426            <l py:pytype="long">2</l> 
1427            <t py:pytype="TREE"></t> 
1428          </a> 
1429          ''')) 
1430          objectify.annotate(root, ignore_old=False) 
1431   
1432          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1433                          for c in root.iterchildren() ] 
1434          self.assertEqual("int",   child_types[ 0]) 
1435          self.assertEqual("str",   child_types[ 1]) 
1436          self.assertEqual("float", child_types[ 2]) 
1437          self.assertEqual("str",   child_types[ 3]) 
1438          self.assertEqual("bool",  child_types[ 4]) 
1439          self.assertEqual("NoneType",  child_types[ 5]) 
1440          self.assertEqual(None,    child_types[ 6]) 
1441          self.assertEqual("float", child_types[ 7]) 
1442          self.assertEqual("float", child_types[ 8]) 
1443          self.assertEqual("str",   child_types[ 9]) 
1444          self.assertEqual("str",   child_types[10]) 
1445          self.assertEqual("float", child_types[11]) 
1446          self.assertEqual("int",   child_types[12]) 
1447          self.assertEqual(TREE_PYTYPE,  child_types[13]) 
1448           
1449          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1450   
1452          XML = self.XML 
1453          root = XML(_bytes('''\ 
1454          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1455          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1456            <b>5</b> 
1457            <b>test</b> 
1458            <c>1.1</c> 
1459            <c>\uF8D2</c> 
1460            <x>true</x> 
1461            <n xsi:nil="true" /> 
1462            <n></n> 
1463            <b xsi:type="double">5</b> 
1464            <b xsi:type="float">5</b> 
1465            <s xsi:type="string">23</s> 
1466            <s py:pytype="str">42</s> 
1467            <f py:pytype="float">300</f> 
1468            <l py:pytype="long">2</l> 
1469            <t py:pytype="TREE"></t> 
1470          </a> 
1471          ''')) 
1472          objectify.annotate(root, ignore_old=False, ignore_xsi=False, 
1473                             annotate_xsi=1, annotate_pytype=1) 
1474           
1475          # check py annotations 
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   
1495          child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1496                          for c in root.iterchildren() ] 
1497   
1498          # check xsi annotations 
1499          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1500                          for c in root.iterchildren() ] 
1501          self.assertEqual("xsd:integer", child_types[ 0]) 
1502          self.assertEqual("xsd:string",  child_types[ 1]) 
1503          self.assertEqual("xsd:double",  child_types[ 2]) 
1504          self.assertEqual("xsd:string",  child_types[ 3]) 
1505          self.assertEqual("xsd:boolean", child_types[ 4]) 
1506          self.assertEqual(None,          child_types[ 5]) 
1507          self.assertEqual(None,          child_types[ 6]) 
1508          self.assertEqual("xsd:double",  child_types[ 7]) 
1509          self.assertEqual("xsd:float",   child_types[ 8]) 
1510          self.assertEqual("xsd:string",  child_types[ 9]) 
1511          self.assertEqual("xsd:string",  child_types[10]) 
1512          self.assertEqual("xsd:double",  child_types[11]) 
1513          self.assertEqual("xsd:integer", child_types[12]) 
1514          self.assertEqual(None,  child_types[13]) 
1515   
1516          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1517   
1519          XML = self.XML 
1520          root = XML(_bytes('''\ 
1521          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1522          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1523            <b>5</b> 
1524            <b>test</b> 
1525            <c>1.1</c> 
1526            <c>\uF8D2</c> 
1527            <x>true</x> 
1528            <n xsi:nil="true" /> 
1529            <n></n> 
1530            <b xsi:type="double">5</b> 
1531            <b xsi:type="float">5</b> 
1532            <s xsi:type="string">23</s> 
1533            <s py:pytype="str">42</s> 
1534            <f py:pytype="float">300</f> 
1535            <l py:pytype="long">2</l> 
1536            <t py:pytype="TREE"></t> 
1537          </a> 
1538          ''')) 
1539          objectify.xsiannotate(root, ignore_old=False) 
1540   
1541          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1542                          for c in root.iterchildren() ] 
1543          self.assertEqual("xsd:integer", child_types[ 0]) 
1544          self.assertEqual("xsd:string",  child_types[ 1]) 
1545          self.assertEqual("xsd:double",  child_types[ 2]) 
1546          self.assertEqual("xsd:string",  child_types[ 3]) 
1547          self.assertEqual("xsd:boolean", child_types[ 4]) 
1548          self.assertEqual(None,          child_types[ 5]) 
1549          self.assertEqual(None,          child_types[ 6]) 
1550          self.assertEqual("xsd:double",  child_types[ 7]) 
1551          self.assertEqual("xsd:float",   child_types[ 8]) 
1552          self.assertEqual("xsd:string",  child_types[ 9]) 
1553          self.assertEqual("xsd:string",  child_types[10]) 
1554          self.assertEqual("xsd:double",  child_types[11]) 
1555          self.assertEqual("xsd:integer", child_types[12]) 
1556          self.assertEqual(None,          child_types[13]) 
1557   
1559          XML = self.XML 
1560          root = XML(_bytes('''\ 
1561          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1562          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1563            <b>5</b> 
1564            <b>test</b> 
1565            <c>1.1</c> 
1566            <c>\uF8D2</c> 
1567            <x>true</x> 
1568            <n xsi:nil="true" /> 
1569            <n></n> 
1570            <b xsi:type="double">5</b> 
1571            <b xsi:type="float">5</b> 
1572            <s xsi:type="string">23</s> 
1573            <s py:pytype="str">42</s> 
1574            <f py:pytype="float">300</f> 
1575            <l py:pytype="long">2</l> 
1576            <t py:pytype="TREE"></t> 
1577          </a> 
1578          ''')) 
1579          objectify.pyannotate(root, ignore_old=True) 
1580   
1581          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1582                          for c in root.iterchildren() ] 
1583          self.assertEqual("int",   child_types[ 0]) 
1584          self.assertEqual("str",   child_types[ 1]) 
1585          self.assertEqual("float", child_types[ 2]) 
1586          self.assertEqual("str",   child_types[ 3]) 
1587          self.assertEqual("bool",  child_types[ 4]) 
1588          self.assertEqual("NoneType",  child_types[ 5]) 
1589          self.assertEqual(None,    child_types[ 6]) 
1590          self.assertEqual("float", child_types[ 7]) 
1591          self.assertEqual("float", child_types[ 8]) 
1592          self.assertEqual("str",   child_types[ 9]) 
1593          self.assertEqual("int",   child_types[10]) 
1594          self.assertEqual("int",   child_types[11]) 
1595          self.assertEqual("int",   child_types[12]) 
1596          self.assertEqual(None,    child_types[13]) 
1597           
1598          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1599   
1601          XML = self.XML 
1602          root = XML('''\ 
1603          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1604          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1605            <n></n> 
1606          </a> 
1607          ''') 
1608          objectify.pyannotate(root) 
1609   
1610          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1611                          for c in root.iterchildren() ] 
1612          self.assertEqual(None,    child_types[0]) 
1613   
1614          objectify.annotate(root, empty_pytype="str") 
1615   
1616          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1617                          for c in root.iterchildren() ] 
1618          self.assertEqual("str",    child_types[0]) 
1619   
1621          XML = self.XML 
1622          root = XML('''\ 
1623          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1624          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1625            <b>5</b> 
1626            <b>test</b> 
1627            <c>1.1</c> 
1628            <c>\uF8D2</c> 
1629            <x>true</x> 
1630            <n xsi:nil="true" /> 
1631            <n></n> 
1632            <b xsi:type="double">5</b> 
1633            <b xsi:type="float">5</b> 
1634            <s xsi:type="string">23</s> 
1635            <s py:pytype="str">42</s> 
1636            <f py:pytype="float">300</f> 
1637            <l py:pytype="long">2</l> 
1638            <t py:pytype="TREE"></t> 
1639          </a> 
1640          ''') 
1641          objectify.pyannotate(root) 
1642   
1643          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1644                          for c in root.iterchildren() ] 
1645          self.assertEqual("int",   child_types[ 0]) 
1646          self.assertEqual("str",   child_types[ 1]) 
1647          self.assertEqual("float", child_types[ 2]) 
1648          self.assertEqual("str",   child_types[ 3]) 
1649          self.assertEqual("bool",  child_types[ 4]) 
1650          self.assertEqual("NoneType",  child_types[ 5]) 
1651          self.assertEqual(None,    child_types[ 6]) 
1652          self.assertEqual("float", child_types[ 7]) 
1653          self.assertEqual("float", child_types[ 8]) 
1654          self.assertEqual("str",   child_types[ 9]) 
1655          self.assertEqual("str",   child_types[10]) 
1656          self.assertEqual("float", child_types[11]) 
1657          self.assertEqual("int",   child_types[12]) 
1658          self.assertEqual(TREE_PYTYPE, child_types[13]) 
1659           
1660          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1661           
1663          XML = self.XML 
1664          root = XML(_bytes('''\ 
1665          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1666          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1667            <b>5</b> 
1668            <b>test</b> 
1669            <c>1.1</c> 
1670            <c>\uF8D2</c> 
1671            <x>true</x> 
1672            <n xsi:nil="true" /> 
1673            <n></n> 
1674            <b xsi:type="double">5</b> 
1675            <b xsi:type="float">5</b> 
1676            <s xsi:type="string">23</s> 
1677            <s py:pytype="str">42</s> 
1678            <f py:pytype="float">300</f> 
1679            <l py:pytype="long">2</l> 
1680            <t py:pytype="TREE"></t> 
1681          </a> 
1682          ''')) 
1683          objectify.xsiannotate(root, ignore_old=True) 
1684   
1685          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1686                          for c in root.iterchildren() ] 
1687          self.assertEqual("xsd:integer", child_types[ 0]) 
1688          self.assertEqual("xsd:string",  child_types[ 1]) 
1689          self.assertEqual("xsd:double",  child_types[ 2]) 
1690          self.assertEqual("xsd:string",  child_types[ 3]) 
1691          self.assertEqual("xsd:boolean", child_types[ 4]) 
1692          self.assertEqual(None,          child_types[ 5]) 
1693          self.assertEqual(None,          child_types[ 6]) 
1694          self.assertEqual("xsd:integer", child_types[ 7]) 
1695          self.assertEqual("xsd:integer", child_types[ 8]) 
1696          self.assertEqual("xsd:integer", child_types[ 9]) 
1697          self.assertEqual("xsd:string",  child_types[10]) 
1698          self.assertEqual("xsd:double",  child_types[11]) 
1699          self.assertEqual("xsd:integer", child_types[12]) 
1700          self.assertEqual(None,          child_types[13]) 
1701   
1702          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1703   
1705          XML = self.XML 
1706          root = XML(_bytes('''\ 
1707          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1708          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1709            <b>5</b> 
1710            <b>test</b> 
1711            <c>1.1</c> 
1712            <c>\uF8D2</c> 
1713            <x>true</x> 
1714            <n xsi:nil="true" /> 
1715            <n></n> 
1716            <b xsi:type="double">5</b> 
1717            <b xsi:type="float">5</b> 
1718            <s xsi:type="string">23</s> 
1719            <s py:pytype="str">42</s> 
1720            <f py:pytype="float">300</f> 
1721            <l py:pytype="long">2</l> 
1722            <t py:pytype="TREE"></t> 
1723          </a> 
1724          ''')) 
1725          objectify.deannotate(root) 
1726   
1727          for c in root.getiterator(): 
1728              self.assertEqual(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 
1729              self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 
1730   
1731          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1732   
1734          XML = self.XML 
1735          root = XML(_bytes('''\ 
1736          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1737          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
1738            <b>5</b> 
1739            <b>test</b> 
1740            <c>1.1</c> 
1741            <c>\uF8D2</c> 
1742            <x>true</x> 
1743            <n xsi:nil="true" /> 
1744            <n></n> 
1745            <b xsi:type="double">5</b> 
1746            <b xsi:type="float">5</b> 
1747            <s xsi:type="string">23</s> 
1748            <s py:pytype="str">42</s> 
1749            <f py:pytype="float">300</f> 
1750            <l py:pytype="long">2</l> 
1751            <t py:pytype="TREE"></t> 
1752          </a> 
1753          ''')) 
1754          objectify.annotate( 
1755              root, ignore_old=False, ignore_xsi=False, annotate_xsi=True, 
1756              empty_pytype='str', empty_type='string') 
1757          objectify.deannotate(root, pytype=False, xsi=False, xsi_nil=True) 
1758   
1759          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1760                          for c in root.iterchildren() ] 
1761          self.assertEqual("xsd:integer",  child_types[ 0]) 
1762          self.assertEqual("xsd:string",   child_types[ 1]) 
1763          self.assertEqual("xsd:double",   child_types[ 2]) 
1764          self.assertEqual("xsd:string",   child_types[ 3]) 
1765          self.assertEqual("xsd:boolean",  child_types[ 4]) 
1766          self.assertEqual(None,           child_types[ 5]) 
1767          self.assertEqual("xsd:string",   child_types[ 6]) 
1768          self.assertEqual("xsd:double",   child_types[ 7]) 
1769          self.assertEqual("xsd:float",    child_types[ 8]) 
1770          self.assertEqual("xsd:string",   child_types[ 9]) 
1771          self.assertEqual("xsd:string",   child_types[10]) 
1772          self.assertEqual("xsd:double",    child_types[11]) 
1773          self.assertEqual("xsd:integer",  child_types[12]) 
1774          self.assertEqual(None,           child_types[13]) 
1775   
1776          self.assertEqual(None, root.n.get(XML_SCHEMA_NIL_ATTR)) 
1777   
1778          for c in root.iterchildren(): 
1779              self.assertNotEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 
1780              # these have no equivalent in xsi:type 
1781              if (c.get(objectify.PYTYPE_ATTRIBUTE) not in [TREE_PYTYPE,  
1782                  "NoneType"]): 
1783                  self.assertNotEqual( 
1784                      None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 
1785   
1787          XML = self.XML 
1788          root = XML(_bytes('''\ 
1789          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1790          xmlns:py="http://codespeak.net/lxml/objectify/pytype" 
1791          xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
1792            <b>5</b> 
1793            <b>test</b> 
1794            <c>1.1</c> 
1795            <c>\uF8D2</c> 
1796            <x>true</x> 
1797            <n xsi:nil="true" /> 
1798            <n></n> 
1799            <b xsi:type="xsd:double">5</b> 
1800            <b xsi:type="xsd:float">5</b> 
1801            <s xsi:type="xsd:string">23</s> 
1802            <s py:pytype="str">42</s> 
1803            <f py:pytype="float">300</f> 
1804            <l py:pytype="long">2</l> 
1805            <t py:pytype="TREE"></t> 
1806          </a> 
1807          ''')) 
1808          objectify.annotate(root) 
1809          objectify.deannotate(root, pytype=False) 
1810   
1811          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
1812                          for c in root.iterchildren() ] 
1813          self.assertEqual("int",   child_types[ 0]) 
1814          self.assertEqual("str",   child_types[ 1]) 
1815          self.assertEqual("float", child_types[ 2]) 
1816          self.assertEqual("str",   child_types[ 3]) 
1817          self.assertEqual("bool",  child_types[ 4]) 
1818          self.assertEqual("NoneType",  child_types[ 5]) 
1819          self.assertEqual(None,    child_types[ 6]) 
1820          self.assertEqual("float", child_types[ 7]) 
1821          self.assertEqual("float", child_types[ 8]) 
1822          self.assertEqual("str",   child_types[ 9]) 
1823          self.assertEqual("int",   child_types[10]) 
1824          self.assertEqual("int",   child_types[11]) 
1825          self.assertEqual("int",   child_types[12]) 
1826          self.assertEqual(None,    child_types[13]) 
1827           
1828          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1829   
1830          for c in root.getiterator(): 
1831              self.assertEqual(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 
1832   
1834          XML = self.XML 
1835          root = XML(_bytes('''\ 
1836          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
1837          xmlns:py="http://codespeak.net/lxml/objectify/pytype" 
1838          xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
1839            <b xsi:type="xsd:int">5</b> 
1840            <b xsi:type="xsd:string">test</b> 
1841            <c xsi:type="xsd:float">1.1</c> 
1842            <c xsi:type="xsd:string">\uF8D2</c> 
1843            <x xsi:type="xsd:boolean">true</x> 
1844            <n xsi:nil="true" /> 
1845            <n></n> 
1846            <b xsi:type="xsd:double">5</b> 
1847            <b xsi:type="xsd:float">5</b> 
1848            <s xsi:type="xsd:string">23</s> 
1849            <s xsi:type="xsd:string">42</s> 
1850            <f xsi:type="xsd:float">300</f> 
1851            <l xsi:type="xsd:long">2</l> 
1852            <t py:pytype="TREE"></t> 
1853          </a> 
1854          ''')) 
1855          objectify.annotate(root) 
1856          objectify.deannotate(root, xsi=False) 
1857   
1858          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
1859                          for c in root.iterchildren() ] 
1860          self.assertEqual("xsd:int",      child_types[ 0]) 
1861          self.assertEqual("xsd:string",   child_types[ 1]) 
1862          self.assertEqual("xsd:float",    child_types[ 2]) 
1863          self.assertEqual("xsd:string",   child_types[ 3]) 
1864          self.assertEqual("xsd:boolean",  child_types[ 4]) 
1865          self.assertEqual(None,           child_types[ 5]) 
1866          self.assertEqual(None,           child_types[ 6]) 
1867          self.assertEqual("xsd:double",   child_types[ 7]) 
1868          self.assertEqual("xsd:float",    child_types[ 8]) 
1869          self.assertEqual("xsd:string",   child_types[ 9]) 
1870          self.assertEqual("xsd:string",   child_types[10]) 
1871          self.assertEqual("xsd:float",    child_types[11]) 
1872          self.assertEqual("xsd:long",     child_types[12]) 
1873          self.assertEqual(None,           child_types[13]) 
1874   
1875          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
1876   
1877          for c in root.getiterator(): 
1878              self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 
1879   
1881          XML = self.XML 
1882   
1883          xml = _bytes('''\ 
1884          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
1885            <b>5</b> 
1886            <b>test</b> 
1887            <c>1.1</c> 
1888            <c>\uF8D2</c> 
1889            <x>true</x> 
1890            <n xsi:nil="true" /> 
1891            <n></n> 
1892            <b xsi:type="double">5</b> 
1893          </a> 
1894          ''') 
1895   
1896          pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 
1897          objectify.set_pytype_attribute_tag("{TEST}test") 
1898   
1899          root = XML(xml) 
1900          objectify.annotate(root) 
1901   
1902          attribs = root.xpath("//@py:%s" % pytype_name, 
1903                               namespaces={"py" : pytype_ns}) 
1904          self.assertEqual(0, len(attribs)) 
1905          attribs = root.xpath("//@py:test", 
1906                               namespaces={"py" : "TEST"}) 
1907          self.assertEqual(7, len(attribs)) 
1908   
1909          objectify.set_pytype_attribute_tag() 
1910          pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 
1911   
1912          self.assertNotEqual("test", pytype_ns.lower()) 
1913          self.assertNotEqual("test", pytype_name.lower()) 
1914   
1915          root = XML(xml) 
1916          attribs = root.xpath("//@py:%s" % pytype_name, 
1917                               namespaces={"py" : pytype_ns}) 
1918          self.assertEqual(0, len(attribs)) 
1919   
1920          objectify.annotate(root) 
1921          attribs = root.xpath("//@py:%s" % pytype_name, 
1922                               namespaces={"py" : pytype_ns}) 
1923          self.assertEqual(7, len(attribs)) 
1924   
1926          orig_types = objectify.getRegisteredTypes() 
1927          orig_types[0].unregister() 
1928          self.assertEqual(orig_types[1:], objectify.getRegisteredTypes()) 
1929   
1930          class NewType(objectify.ObjectifiedDataElement): 
1931              pass 
1932   
1933          def checkMyType(s): 
1934              return True 
1935   
1936          pytype = objectify.PyType("mytype", checkMyType, NewType) 
1937          self.assertTrue(pytype not in objectify.getRegisteredTypes()) 
1938          pytype.register() 
1939          self.assertTrue(pytype in objectify.getRegisteredTypes()) 
1940          pytype.unregister() 
1941          self.assertTrue(pytype not in objectify.getRegisteredTypes()) 
1942   
1943          pytype.register(before = [objectify.getRegisteredTypes()[0].name]) 
1944          self.assertEqual(pytype, objectify.getRegisteredTypes()[0]) 
1945          pytype.unregister() 
1946   
1947          pytype.register(after = [objectify.getRegisteredTypes()[0].name]) 
1948          self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0]) 
1949          pytype.unregister() 
1950   
1951          self.assertRaises(ValueError, pytype.register, 
1952                            before = [objectify.getRegisteredTypes()[0].name], 
1953                            after  = [objectify.getRegisteredTypes()[1].name]) 
1954   
1956          from datetime import datetime 
1957          def parse_date(value): 
1958              if len(value) != 14: 
1959                  raise ValueError(value) 
1960              Y = int(value[0:4]) 
1961              M = int(value[4:6]) 
1962              D = int(value[6:8]) 
1963              h = int(value[8:10]) 
1964              m = int(value[10:12]) 
1965              s = int(value[12:14]) 
1966              return datetime(Y, M, D, h, m, s) 
1967   
1968          def stringify_date(date): 
1969              return date.strftime("%Y%m%d%H%M%S") 
1970   
1971          class DatetimeElement(objectify.ObjectifiedDataElement): 
1972              def pyval(self): 
1973                  return parse_date(self.text) 
1974              pyval = property(pyval) 
1975   
1976          datetime_type = objectify.PyType( 
1977              "datetime", parse_date, DatetimeElement, stringify_date) 
1978          datetime_type.xmlSchemaTypes = "dateTime" 
1979          datetime_type.register() 
1980   
1981          NAMESPACE = "http://foo.net/xmlns" 
1982          NAMESPACE_MAP = {'ns': NAMESPACE} 
1983   
1984          r = objectify.Element("{%s}root" % NAMESPACE, nsmap=NAMESPACE_MAP) 
1985          time = datetime.now() 
1986          r.date = time 
1987   
1988          self.assertTrue(isinstance(r.date, DatetimeElement)) 
1989          self.assertTrue(isinstance(r.date.pyval, datetime)) 
1990   
1991          self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 
1992          self.assertEqual(r.date.text, stringify_date(time)) 
1993   
1994          r.date = objectify.E.date(time) 
1995   
1996          self.assertTrue(isinstance(r.date, DatetimeElement)) 
1997          self.assertTrue(isinstance(r.date.pyval, datetime)) 
1998   
1999          self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 
2000          self.assertEqual(r.date.text, stringify_date(time)) 
2001   
2002          date = objectify.DataElement(time) 
2003   
2004          self.assertTrue(isinstance(date, DatetimeElement)) 
2005          self.assertTrue(isinstance(date.pyval, datetime)) 
2006   
2007          self.assertEqual(date.pyval, parse_date(stringify_date(time))) 
2008          self.assertEqual(date.text, stringify_date(time)) 
2009   
2011          root = self.XML(xml_str) 
2012          path = objectify.ObjectPath( "root.c1.c2" ) 
2013          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2014          self.assertEqual(root.c1.c2.text, path(root).text) 
2015   
2017          root = self.XML(xml_str) 
2018          path = objectify.ObjectPath( ['root', 'c1', 'c2'] ) 
2019          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2020          self.assertEqual(root.c1.c2.text, path(root).text) 
2021   
2023          root = self.XML(xml_str) 
2024          path = objectify.ObjectPath( "root.c1.c99" ) 
2025          self.assertRaises(AttributeError, path, root) 
2026   
2028          root = self.XML(xml_str) 
2029          path = objectify.ObjectPath( "root.c1.c99" ) 
2030          self.assertEqual(None, path(root, None)) 
2031          path = objectify.ObjectPath( "root.c99.c2" ) 
2032          self.assertEqual(None, path(root, None)) 
2033          path = objectify.ObjectPath( "notroot.c99.c2" ) 
2034          self.assertEqual(None, path(root, None)) 
2035   
2037          root = self.XML(xml_str) 
2038          path = objectify.ObjectPath( ".c1.c99" ) 
2039          self.assertEqual(None, path(root, None)) 
2040          path = objectify.ObjectPath( ".c99.c2" ) 
2041          self.assertEqual(None, path(root, None)) 
2042   
2044          root = self.XML(xml_str) 
2045          path = objectify.ObjectPath("root .    {objectified}c1.   c2") 
2046          self.assertEqual(root.c1.c2.text, path(root).text) 
2047   
2048          path = objectify.ObjectPath("   root.{objectified}  c1.c2  [ 0 ]   ") 
2049          self.assertEqual(root.c1.c2.text, path(root).text) 
2050   
2053   
2056   
2058          root = self.XML(xml_str) 
2059          path = objectify.ObjectPath( "root" ) 
2060          self.assertTrue(path.hasattr(root)) 
2061          path = objectify.ObjectPath( "root.c1" ) 
2062          self.assertTrue(path.hasattr(root)) 
2063          path = objectify.ObjectPath( "root.c1.c2" ) 
2064          self.assertTrue(path.hasattr(root)) 
2065          path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 
2066          self.assertTrue(path.hasattr(root)) 
2067          path = objectify.ObjectPath( "root.c1.c2[1]" ) 
2068          self.assertTrue(path.hasattr(root)) 
2069          path = objectify.ObjectPath( "root.c1.c2[2]" ) 
2070          self.assertTrue(path.hasattr(root)) 
2071          path = objectify.ObjectPath( "root.c1.c2[3]" ) 
2072          self.assertFalse(path.hasattr(root)) 
2073          path = objectify.ObjectPath( "root.c1[1].c2" ) 
2074          self.assertFalse(path.hasattr(root)) 
2075   
2077          root = self.XML(xml_str) 
2078          path = objectify.ObjectPath( "." ) 
2079          self.assertEqual(root.c1.c2.text, path(root).c1.c2.text) 
2080   
2082          root = self.XML(xml_str) 
2083          path = objectify.ObjectPath( [''] ) 
2084          self.assertEqual(root.c1.c2.text, path(root).c1.c2.text) 
2085   
2087          root = self.XML(xml_str) 
2088          path = objectify.ObjectPath( ".c1.c2" ) 
2089          self.assertEqual(root.c1.c2.text, path(root).text) 
2090   
2092          root = self.XML(xml_str) 
2093          path = objectify.ObjectPath( ['', 'c1', 'c2'] ) 
2094          self.assertEqual(root.c1.c2.text, path(root).text) 
2095   
2097          root = self.XML(xml_str) 
2098          path = objectify.ObjectPath( "root.c1[0].c2[0]" ) 
2099          self.assertEqual(root.c1.c2.text, path(root).text) 
2100   
2101          path = objectify.ObjectPath( "root.c1[0].c2" ) 
2102          self.assertEqual(root.c1.c2.text, path(root).text) 
2103   
2104          path = objectify.ObjectPath( "root.c1[0].c2[1]" ) 
2105          self.assertEqual(root.c1.c2[1].text, path(root).text) 
2106   
2107          path = objectify.ObjectPath( "root.c1.c2[2]" ) 
2108          self.assertEqual(root.c1.c2[2].text, path(root).text) 
2109   
2110          path = objectify.ObjectPath( "root.c1.c2[-1]" ) 
2111          self.assertEqual(root.c1.c2[-1].text, path(root).text) 
2112   
2113          path = objectify.ObjectPath( "root.c1.c2[-3]" ) 
2114          self.assertEqual(root.c1.c2[-3].text, path(root).text) 
2115   
2117          root = self.XML(xml_str) 
2118          path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] ) 
2119          self.assertEqual(root.c1.c2.text, path(root).text) 
2120   
2121          path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] ) 
2122          self.assertEqual(root.c1.c2[2].text, path(root).text) 
2123   
2124          path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] ) 
2125          self.assertEqual(root.c1.c2[2].text, path(root).text) 
2126   
2127          path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] ) 
2128          self.assertEqual(root.c1.c2[-1].text, path(root).text) 
2129   
2130          path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] ) 
2131          self.assertEqual(root.c1.c2[-3].text, path(root).text) 
2132   
2134          self.assertRaises(ValueError, objectify.ObjectPath, 
2135                            "root.c1[0].c2[-1-2]") 
2136          self.assertRaises(ValueError, objectify.ObjectPath, 
2137                            ['root', 'c1[0]', 'c2[-1-2]']) 
2138   
2139          self.assertRaises(ValueError, objectify.ObjectPath, 
2140                            "root[2].c1.c2") 
2141          self.assertRaises(ValueError, objectify.ObjectPath, 
2142                            ['root[2]', 'c1', 'c2']) 
2143   
2144          self.assertRaises(ValueError, objectify.ObjectPath, 
2145                            []) 
2146          self.assertRaises(ValueError, objectify.ObjectPath, 
2147                            ['', '', '']) 
2148   
2150          root = self.XML(xml_str) 
2151          path = objectify.ObjectPath("root.c1[9999].c2") 
2152          self.assertRaises(AttributeError, path, root) 
2153   
2154          path = objectify.ObjectPath("root.c1[0].c2[9999]") 
2155          self.assertRaises(AttributeError, path, root) 
2156   
2157          path = objectify.ObjectPath(".c1[9999].c2[0]") 
2158          self.assertRaises(AttributeError, path, root) 
2159   
2160          path = objectify.ObjectPath("root.c1[-2].c2") 
2161          self.assertRaises(AttributeError, path, root) 
2162   
2163          path = objectify.ObjectPath("root.c1[0].c2[-4]") 
2164          self.assertRaises(AttributeError, path, root) 
2165   
2167          root = self.XML(xml_str) 
2168          path = objectify.ObjectPath( "{objectified}root.c1.c2" ) 
2169          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2170          path = objectify.ObjectPath( "{objectified}root.{objectified}c1.c2" ) 
2171          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2172          path = objectify.ObjectPath( "root.{objectified}c1.{objectified}c2" ) 
2173          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2174          path = objectify.ObjectPath( "root.c1.{objectified}c2" ) 
2175          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2176          path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 
2177          self.assertEqual(getattr(root.c1, '{otherNS}c2').text, 
2178                            path.find(root).text) 
2179   
2181          root = self.XML(xml_str) 
2182          path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] ) 
2183          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2184          path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] ) 
2185          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2186          path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] ) 
2187          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2188          path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] ) 
2189          self.assertEqual(root.c1.c2[2].text, path.find(root).text) 
2190          path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] ) 
2191          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2192          path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] ) 
2193          self.assertEqual(root.c1.c2[2].text, path.find(root).text) 
2194          path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] ) 
2195          self.assertEqual(getattr(root.c1, '{otherNS}c2').text, 
2196                            path.find(root).text) 
2197   
2199          root = self.XML(xml_str) 
2200          path = objectify.ObjectPath( "root.c1.c2" ) 
2201          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2202          self.assertEqual("1", root.c1.c2[1].text) 
2203   
2204          new_value = "my new value" 
2205          path.setattr(root, new_value) 
2206   
2207          self.assertEqual(new_value, root.c1.c2.text) 
2208          self.assertEqual(new_value, path(root).text) 
2209          self.assertEqual("1", root.c1.c2[1].text) 
2210   
2212          root = self.XML(xml_str) 
2213          path = objectify.ObjectPath( "root.c1.c2" ) 
2214          self.assertEqual(root.c1.c2.text, path.find(root).text) 
2215          self.assertEqual("1", root.c1.c2[1].text) 
2216   
2217          new_el = self.Element("{objectified}test") 
2218          etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 
2219          path.setattr(root, new_el.sub) 
2220   
2221          self.assertEqual("ATTR", root.c1.c2.get("myattr")) 
2222          self.assertEqual("TEST", root.c1.c2.a.text) 
2223          self.assertEqual("TEST", path(root).a.text) 
2224          self.assertEqual("1", root.c1.c2[1].text) 
2225   
2227          root = self.XML(xml_str) 
2228          path = objectify.ObjectPath( "root.c1.c99" ) 
2229          self.assertRaises(AttributeError, path.find, root) 
2230   
2231          new_value = "my new value" 
2232          path.setattr(root, new_value) 
2233   
2234          self.assertEqual(1, len(root.c1.c99)) 
2235          self.assertEqual(new_value, root.c1.c99.text) 
2236          self.assertEqual(new_value, path(root).text) 
2237   
2239          root = self.XML(xml_str) 
2240          path = objectify.ObjectPath( "root.c1.c99" ) 
2241          self.assertRaises(AttributeError, path.find, root) 
2242   
2243          new_el = self.Element("{objectified}test") 
2244          etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 
2245          path.setattr(root, new_el.sub) 
2246   
2247          self.assertEqual(1, len(root.c1.c99)) 
2248          self.assertEqual("ATTR", root.c1.c99.get("myattr")) 
2249          self.assertEqual("TEST", root.c1.c99.a.text) 
2250          self.assertEqual("TEST", path(root).a.text) 
2251   
2253          root = self.XML(xml_str) 
2254          path = objectify.ObjectPath( "root.c1.c99" ) 
2255          self.assertRaises(AttributeError, path.find, root) 
2256   
2257          new_el = self.Element("{objectified}test") 
2258          new_el.a = ["TEST1", "TEST2"] 
2259          new_el.a[0].set("myattr", "ATTR1") 
2260          new_el.a[1].set("myattr", "ATTR2") 
2261   
2262          path.setattr(root, list(new_el.a)) 
2263   
2264          self.assertEqual(2, len(root.c1.c99)) 
2265          self.assertEqual("ATTR1", root.c1.c99[0].get("myattr")) 
2266          self.assertEqual("TEST1", root.c1.c99[0].text) 
2267          self.assertEqual("ATTR2", root.c1.c99[1].get("myattr")) 
2268          self.assertEqual("TEST2", root.c1.c99[1].text) 
2269          self.assertEqual("TEST1", path(root).text) 
2270   
2272          root = self.XML(xml_str) 
2273          path = objectify.ObjectPath( "root.c1.c2" ) 
2274          self.assertEqual(3, len(root.c1.c2)) 
2275          path.addattr(root, "test") 
2276          self.assertEqual(4, len(root.c1.c2)) 
2277          self.assertEqual(["0", "1", "2", "test"], 
2278                            [el.text for el in root.c1.c2]) 
2279   
2281          root = self.XML(xml_str) 
2282          path = objectify.ObjectPath( "root.c1.c2" ) 
2283          self.assertEqual(3, len(root.c1.c2)) 
2284   
2285          new_el = self.Element("{objectified}test") 
2286          etree.SubElement(new_el, "{objectified}sub").a = "TEST" 
2287   
2288          path.addattr(root, new_el.sub) 
2289          self.assertEqual(4, len(root.c1.c2)) 
2290          self.assertEqual("TEST", root.c1.c2[3].a.text) 
2291          self.assertEqual(["0", "1", "2"], 
2292                            [el.text for el in root.c1.c2[:3]]) 
2293   
2295          root = self.XML(xml_str) 
2296          path = objectify.ObjectPath( "root.c1.c99" ) 
2297          self.assertRaises(AttributeError, path.find, root) 
2298   
2299          new_value = "my new value" 
2300          path.addattr(root, new_value) 
2301   
2302          self.assertEqual(1, len(root.c1.c99)) 
2303          self.assertEqual(new_value, root.c1.c99.text) 
2304          self.assertEqual(new_value, path(root).text) 
2305   
2307          root = self.XML(xml_str) 
2308          path = objectify.ObjectPath( "root.c1.c99" ) 
2309          self.assertRaises(AttributeError, path.find, root) 
2310   
2311          new_el = self.Element("{objectified}test") 
2312          etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 
2313   
2314          path.addattr(root, new_el.sub) 
2315          self.assertEqual(1, len(root.c1.c99)) 
2316          self.assertEqual("TEST", root.c1.c99.a.text) 
2317          self.assertEqual("TEST", path(root).a.text) 
2318          self.assertEqual("ATTR", root.c1.c99.get("myattr")) 
2319   
2321          root = self.XML(xml_str) 
2322          path = objectify.ObjectPath( "root.c1.c99" ) 
2323          self.assertRaises(AttributeError, path.find, root) 
2324   
2325          new_el = self.Element("{objectified}test") 
2326          new_el.a = ["TEST1", "TEST2"] 
2327   
2328          self.assertEqual(2, len(new_el.a)) 
2329   
2330          path.addattr(root, list(new_el.a)) 
2331          self.assertEqual(2, len(root.c1.c99)) 
2332          self.assertEqual("TEST1", root.c1.c99.text) 
2333          self.assertEqual("TEST2", path(root)[1].text) 
2334   
2336          root = self.XML(xml_str) 
2337          self.assertEqual( 
2338              ['{objectified}root', '{objectified}root.c1', 
2339               '{objectified}root.c1.c2', 
2340               '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]', 
2341               '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'], 
2342              root.descendantpaths()) 
2343   
2345          root = self.XML(xml_str) 
2346          self.assertEqual( 
2347              ['{objectified}c1', '{objectified}c1.c2', 
2348               '{objectified}c1.c2[1]', '{objectified}c1.c2[2]', 
2349               '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'], 
2350              root.c1.descendantpaths()) 
2351   
2353          root = self.XML(xml_str) 
2354          self.assertEqual( 
2355              ['root.{objectified}c1', 'root.{objectified}c1.c2', 
2356               'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]', 
2357               'root.{objectified}c1.{otherNS}c2', 
2358               'root.{objectified}c1.{}c2'], 
2359              root.c1.descendantpaths('root')) 
2360   
2362          import pickle 
2363   
2364          root = self.XML(xml_str) 
2365          out = BytesIO() 
2366          pickle.dump(root, out) 
2367   
2368          new_root = pickle.loads(out.getvalue()) 
2369          self.assertEqual( 
2370              etree.tostring(new_root), 
2371              etree.tostring(root)) 
2372   
2374          import pickle 
2375   
2376          tree = etree.ElementTree(self.XML(xml_str + "<?my pi?>")) 
2377          out = BytesIO() 
2378          pickle.dump(tree, out) 
2379   
2380          new_tree = pickle.loads(out.getvalue()) 
2381          self.assertTrue(isinstance(new_tree, etree._ElementTree)) 
2382          self.assertEqual( 
2383              etree.tostring(new_tree), 
2384              etree.tostring(tree)) 
2385   
2389   
2393   
2395          self._test_pickle('<x>Pickle me!</x>') 
2396          self._test_pickle(objectify.DataElement('Pickle me!')) 
2397   
2399          self._test_pickle('<x>true</x>') 
2400          self._test_pickle('<x>false</x>') 
2401          self._test_pickle(objectify.DataElement(True)) 
2402          self._test_pickle(objectify.DataElement(False)) 
2403   
2405          self._test_pickle(''' 
2406  <x xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>''') 
2407          self._test_pickle(objectify.DataElement(None)) 
2408   
2410          import pickle 
2411          if isinstance(stringOrElt, (etree._Element, etree._ElementTree)): 
2412              elt = stringOrElt 
2413          else: 
2414              elt = self.XML(stringOrElt) 
2415          out = BytesIO() 
2416          pickle.dump(elt, out) 
2417   
2418          new_elt = pickle.loads(out.getvalue()) 
2419          self.assertEqual( 
2420              etree.tostring(new_elt), 
2421              etree.tostring(elt)) 
2422   
2423      # E-Factory tests, need to use sub-elements as root element is always 
2424      # type-looked-up as ObjectifiedElement (no annotations) 
2426          E = objectify.E 
2427          root = E.root(E.val(23)) 
2428          self.assertTrue(isinstance(root.val, objectify.IntElement)) 
2429   
2431          E = objectify.E 
2432          root = E.root(E.val(233.23)) 
2433          self.assertTrue(isinstance(root.val, objectify.FloatElement)) 
2434   
2436          E = objectify.E 
2437          root = E.root(E.val("what?")) 
2438          self.assertTrue(isinstance(root.val, objectify.StringElement)) 
2439   
2441          E = objectify.E 
2442          root = E.root(E.val(_str("blöödy häll", encoding="ISO-8859-1"))) 
2443          self.assertTrue(isinstance(root.val, objectify.StringElement)) 
2444   
2446          E = objectify.E 
2447          root = E.root(E.val(True)) 
2448          self.assertTrue(isinstance(root.val, objectify.BoolElement)) 
2449   
2451          E = objectify.E 
2452          root = E.root(E.val(None)) 
2453          self.assertTrue(isinstance(root.val, objectify.NoneElement)) 
2454   
2456          E = objectify.E 
2457          root = E.root(E.val(1, "foo", 2.0, "bar ", True, None)) 
2458          self.assertTrue(isinstance(root.val, objectify.StringElement)) 
2459   
2464   
2466          E = objectify.E 
2467          DataElement = objectify.DataElement 
2468          root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1), 
2469                        DataElement(2.0)) 
2470          self.assertTrue(isinstance(root, objectify.ObjectifiedElement)) 
2471          self.assertEqual(root.text, "text") 
2472          self.assertTrue(isinstance(root.sub, objectify.ObjectifiedElement)) 
2473          self.assertEqual(root.sub.tail, "tail") 
2474          self.assertTrue(isinstance(root.sub.subsub, objectify.StringElement)) 
2475          self.assertEqual(len(root.value), 2) 
2476          self.assertTrue(isinstance(root.value[0], objectify.IntElement)) 
2477          self.assertTrue(isinstance(root.value[1], objectify.FloatElement)) 
2478   
2480          class Attribute(objectify.ObjectifiedDataElement): 
2481              def __init__(self): 
2482                  objectify.ObjectifiedDataElement.__init__(self) 
2483                  self.set("datatype", "TYPE") 
2484                  self.set("range", "0.,1.") 
2485   
2486          attr = Attribute() 
2487          self.assertEqual(attr.text, None) 
2488          self.assertEqual(attr.get("datatype"), "TYPE") 
2489          self.assertEqual(attr.get("range"), "0.,1.") 
2490   
2492          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
2493          docinfo = root.getroottree().docinfo 
2494          self.assertEqual(docinfo.URL, "http://no/such/url") 
2495    
2497          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
2498          docinfo = root.getroottree().docinfo 
2499          self.assertEqual(docinfo.URL, "http://no/such/url") 
2500          docinfo.URL = "https://secret/url" 
2501          self.assertEqual(docinfo.URL, "https://secret/url") 
2502    
2504          tree = objectify.parse(BytesIO("<root/>"), base_url="http://no/such/url") 
2505          docinfo = tree.docinfo 
2506          self.assertEqual(docinfo.URL, "http://no/such/url") 
2507    
2509          tree = objectify.parse(fileInTestDir('include/test_xinclude.xml'), 
2510                                 base_url="http://no/such/url") 
2511          docinfo = tree.docinfo 
2512          self.assertEqual(docinfo.URL, "http://no/such/url") 
2513   
2515          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
2516          self.assertEqual(root.base, "http://no/such/url") 
2517          self.assertEqual( 
2518              root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 
2519          root.base = "https://secret/url" 
2520          self.assertEqual(root.base, "https://secret/url") 
2521          self.assertEqual( 
2522              root.get('{http://www.w3.org/XML/1998/namespace}base'), 
2523              "https://secret/url") 
2524    
2526          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
2527          self.assertEqual(root.base, "http://no/such/url") 
2528          self.assertEqual( 
2529              root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 
2530          root.set('{http://www.w3.org/XML/1998/namespace}base', 
2531                   "https://secret/url") 
2532          self.assertEqual(root.base, "https://secret/url") 
2533          self.assertEqual( 
2534              root.get('{http://www.w3.org/XML/1998/namespace}base'), 
2535              "https://secret/url") 
2536   
2538          XML = self.XML 
2539   
2540          xml = _bytes('''\ 
2541          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
2542            <i>5</i> 
2543            <i>-5</i> 
2544            <l>4294967296</l> 
2545            <l>-4294967296</l> 
2546            <f>1.1</f> 
2547            <b>true</b> 
2548            <b>false</b> 
2549            <s>Strange things happen, where strings collide</s> 
2550            <s>True</s> 
2551            <s>False</s> 
2552            <s>t</s> 
2553            <s>f</s> 
2554            <s></s> 
2555            <s>None</s> 
2556            <n xsi:nil="true" /> 
2557          </root> 
2558          ''') 
2559          root = XML(xml) 
2560   
2561          for i in root.i: 
2562              self.assertTrue(isinstance(i, objectify.IntElement)) 
2563          for l in root.l: 
2564              self.assertTrue(isinstance(l, objectify.IntElement)) 
2565          for f in root.f: 
2566              self.assertTrue(isinstance(f, objectify.FloatElement))   
2567          for b in root.b: 
2568              self.assertTrue(isinstance(b, objectify.BoolElement)) 
2569          self.assertEqual(True,  root.b[0]) 
2570          self.assertEqual(False, root.b[1]) 
2571          for s in root.s: 
2572              self.assertTrue(isinstance(s, objectify.StringElement)) 
2573          self.assertTrue(isinstance(root.n, objectify.NoneElement)) 
2574          self.assertEqual(None, root.n) 
2575   
2577      suite = unittest.TestSuite() 
2578      suite.addTests([unittest.makeSuite(ObjectifyTestCase)]) 
2579      suite.addTests(doctest.DocTestSuite(objectify)) 
2580      if sys.version_info >= (2,4): 
2581          suite.addTests( 
2582              [make_doctest('../../../doc/objectify.txt')]) 
2583      return suite 
2584   
2585  if __name__ == '__main__': 
2586      print('to test use test.py %s' % __file__) 
2587   
| Home | Trees | Indices | Help | 
 | 
|---|
| Generated by Epydoc 3.0.1 on Thu Mar 17 15:04:28 2016 | http://epydoc.sourceforge.net |