lxml.tests.test

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

70 -class ObjectifyTestCase(HelperTestCase):

71 """Test cases for lxml.objectify 72 """ 73 etree = etree 74

75 - def XML(self, xml):

76 return self.etree.XML(xml, self.parser)

77

78 - def setUp(self):

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

92 - def tearDown(self):

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

107 - def test_element_nsmap_default(self):

108 elt = objectify.Element("test") 109 self.assertEqual(elt.nsmap, DEFAULT_NSMAP)

110

111 - def test_element_nsmap_empty(self):

112 nsmap = {} 113 elt = objectify.Element("test", nsmap=nsmap) 114 self.assertEqual(list(elt.nsmap.values()), [PYTYPE_NAMESPACE])

115

116 - def test_element_nsmap_custom_prefixes(self):

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

123 - def test_element_nsmap_custom(self):

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

133 - def test_sub_element_nsmap_default(self):

134 root = objectify.Element("root") 135 root.sub = objectify.Element("test") 136 self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP)

137

138 - def test_sub_element_nsmap_empty(self):

139 root = objectify.Element("root") 140 nsmap = {} 141 root.sub = objectify.Element("test", nsmap=nsmap) 142 self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP)

143

144 - def test_sub_element_nsmap_custom_prefixes(self):

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

152 - def test_sub_element_nsmap_custom(self):

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

163 - def test_data_element_nsmap_default(self):

164 value = objectify.DataElement("test this") 165 self.assertEqual(value.nsmap, DEFAULT_NSMAP)

166

167 - def test_data_element_nsmap_empty(self):

168 nsmap = {} 169 value = objectify.DataElement("test this", nsmap=nsmap) 170 self.assertEqual(list(value.nsmap.values()), [PYTYPE_NAMESPACE])

171

172 - def test_data_element_nsmap_custom_prefixes(self):

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

179 - def test_data_element_nsmap_custom(self):

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

189 - def test_sub_data_element_nsmap_default(self):

190 root = objectify.Element("root") 191 root.value = objectify.DataElement("test this") 192 self.assertEqual(root.value.nsmap, DEFAULT_NSMAP)

193

194 - def test_sub_data_element_nsmap_empty(self):

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

200 - def test_sub_data_element_nsmap_custom_prefixes(self):

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

208 - def test_sub_data_element_nsmap_custom(self):

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

219 - def test_date_element_efactory_text(self):

220 # ObjectifiedDataElement can also be used as E-Factory 221 value = objectify.ObjectifiedDataElement('test', 'toast') 222 self.assertEqual(value.text, 'testtoast')

223

224 - def test_date_element_efactory_tail(self):

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

229 - def test_data_element_attrib_attributes_precedence(self):

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

240 - def test_data_element_data_element_arg(self):

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

252 - def test_data_element_data_element_arg_pytype_none(self):

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

268 - def test_data_element_data_element_arg_pytype(self):

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

282 - def test_data_element_data_element_arg_xsitype(self):

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

298 - def test_data_element_data_element_arg_pytype_xsitype(self):

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

314 - def test_data_element_invalid_pytype(self):

315 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 316 _pytype="int")

317

318 - def test_data_element_invalid_xsi(self):

319 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 320 _xsi="xsd:int")

321

322 - def test_data_element_data_element_arg_invalid_pytype(self):

323 arg = objectify.DataElement(3.1415) 324 self.assertRaises(ValueError, objectify.DataElement, arg, 325 _pytype="int")

326

327 - def test_data_element_data_element_arg_invalid_xsi(self):

328 arg = objectify.DataElement(3.1415) 329 self.assertRaises(ValueError, objectify.DataElement, arg, 330 _xsi="xsd:int")

331

332 - def test_data_element_element_arg(self):

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

339 - def test_root(self):

340 root = self.Element("test") 341 self.assertTrue(isinstance(root, objectify.ObjectifiedElement))

342

343 - def test_str(self):

344 root = self.Element("test") 345 self.assertEqual('', str(root))

346

347 - def test_child(self):

348 root = self.XML(xml_str) 349 self.assertEqual("0", root.c1.c2.text)

350

351 - def test_child_ns_nons(self):

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

360 - def test_countchildren(self):

361 root = self.XML(xml_str) 362 self.assertEqual(1, root.countchildren()) 363 self.assertEqual(5, root.c1.countchildren())

364

365 - def test_child_getattr(self):

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

370 - def test_child_nonexistant(self):

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

375 - def test_child_getattr_empty_ns(self):

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

380 - def test_setattr(self):

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

392 - def test_setattr_nonunicode(self):

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

399 - def test_addattr(self):

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

406 - def test_addattr_element(self):

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

416 - def test_addattr_list(self):

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

430 - def test_child_addattr(self):

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

437 - def test_child_index(self):

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

444 - def test_child_index_neg(self):

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

452 - def test_child_len(self):

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

458 - def test_child_iter(self):

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

467 - def test_class_lookup(self):

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

473 - def test_dir(self):

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

483 - def test_vars(self):

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

488 - def test_child_set_ro(self):

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

495 - def test_getslice_complete(self):

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

500 - def test_getslice_partial(self):

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

517 - def test_getslice_partial_neg(self):

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

534 - def test_setslice_complete(self):

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

546 - def test_setslice_elements(self):

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

573 - def test_setslice_partial(self):

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

594 - def test_setslice_insert(self):

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

615 - def test_setslice_insert_neg(self):

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

636 - def test_setslice_empty(self):

637 Element = self.Element 638 root = Element("root") 639 640 root.c = [] 641 self.assertRaises( 642 AttributeError, getattr, root, 'c')

643

644 - def test_setslice_partial_wrong_length(self):

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

663 - def test_setslice_partial_neg(self):

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

684 - def test_setslice_partial_allneg(self):

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

707 - def test_set_string(self):

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

715 - def test_setitem_string(self):

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

723 - def test_setitem_string_special(self):

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

744 - def test_findall(self):

745 XML = self.XML 746 root = XML('<a><c/><c></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

752 - def test_findall_ns(self):

753 XML = self.XML 754 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></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

759 - def test_build_tree(self):

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

767 - def test_type_NoneType(self):

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

782 - def test_data_element_NoneType(self):

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

788 - def test_type_bool(self):

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

812 - def test_data_element_bool(self):

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

821 - def test_type_str(self):

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

828 - def test_type_str_intliteral(self):

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

835 - def test_type_str_floatliteral(self):

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

842 - def test_type_str_mul(self):

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

854 - def test_type_str_add(self):

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

864 - def test_type_str_mod(self):

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

885 - def test_type_str_hash(self):

886 v = "1" 887 el = objectify.DataElement(v) 888 self.assertEqual(hash(el), hash("1"))

889

890 - def test_type_str_as_int(self):

891 v = "1" 892 el = objectify.DataElement(v) 893 self.assertEqual(int(el), 1)

894

895 - def test_type_str_as_float(self):

896 v = "1" 897 el = objectify.DataElement(v) 898 self.assertEqual(float(el), 1)

899

900 - def test_type_str_as_complex(self):

901 v = "1" 902 el = objectify.DataElement(v) 903 self.assertEqual(complex(el), 1)

904

905 - def test_type_str_mod_data_elements(self):

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

914 - def test_data_element_str(self):

915 value = objectify.DataElement("test") 916 self.assertTrue(isinstance(value, objectify.StringElement)) 917 self.assertEqual(value, "test")

918

919 - def test_data_element_str_intliteral(self):

920 value = objectify.DataElement("3") 921 self.assertTrue(isinstance(value, objectify.StringElement)) 922 self.assertEqual(value, "3")

923

924 - def test_data_element_str_floatliteral(self):

925 value = objectify.DataElement("3.20") 926 self.assertTrue(isinstance(value, objectify.StringElement)) 927 self.assertEqual(value, "3.20")

928

929 - def test_type_ustr(self):

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

936 - def test_type_ustr_intliteral(self):

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

943 - def test_type_ustr_floatliteral(self):

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

950 - def test_type_ustr_mul(self):

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

962 - def test_type_ustr_add(self):

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

972 - def test_data_element_ustr(self):

973 value = objectify.DataElement(_str("test")) 974 self.assertTrue(isinstance(value, objectify.StringElement)) 975 self.assertEqual(value, _str("test"))

976

977 - def test_data_element_ustr_intliteral(self):

978 value = objectify.DataElement("3") 979 self.assertTrue(isinstance(value, objectify.StringElement)) 980 self.assertEqual(value, _str("3"))

981

982 - def test_data_element_ustr_floatliteral(self):

983 value = objectify.DataElement(_str("3.20")) 984 self.assertTrue(isinstance(value, objectify.StringElement)) 985 self.assertEqual(value, _str("3.20"))

986

987 - def test_type_int(self):

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

994 - def test_data_element_int(self):

995 value = objectify.DataElement(5) 996 self.assertTrue(isinstance(value, objectify.IntElement)) 997 self.assertEqual(value, 5)

998

999 - def test_data_element_int_hash(self):

1000 value = objectify.DataElement(123) 1001 self.assertEqual(hash(value), hash(123))

1002

1003 - def test_type_float(self):

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

1010 - def test_data_element_float(self):

1011 value = objectify.DataElement(5.5) 1012 self.assertTrue(isinstance(value, objectify.FloatElement)) 1013 self.assertEqual(value, 5.5)

1014

1015 - def test_data_element_float_hash(self):

1016 value = objectify.DataElement(5.5) 1017 self.assertEqual(hash(value), hash(5.5))

1018

1019 - def test_type_float_precision(self):

1020 # test not losing precision by shortened float str() value 1021 # repr(2.305064300557): '2.305064300557' 1022 # str(2.305064300557): '2.30506430056' 1023 # "%57.54f" % 2.305064300557: 1024 # ' 2.305064300556999956626214043353684246540069580078125000' 1025 Element = self.Element 1026 root = Element("{objectified}root") 1027 s = "2.305064300557" 1028 root.f = float(s) 1029 self.assertTrue(isinstance(root.f, objectify.FloatElement)) 1030 self.assertEqual(root.f.text, s) 1031 self.assertEqual(root.f.pyval, float(s))

1032

1033 - def test_type_float_instantiation_precision(self):

1034 # test precision preservation for FloatElement instantiation 1035 s = "2.305064300557" 1036 self.assertEqual(objectify.FloatElement(s), float(s))

1037

1038 - def test_type_float_precision_consistency(self):

1039 # test consistent FloatElement values for the different instantiation 1040 # possibilities 1041 Element = self.Element 1042 root = Element("{objectified}root") 1043 s = "2.305064300557" 1044 f = float(s) 1045 float_elem = objectify.FloatElement(s) 1046 float_data_elem = objectify.DataElement(f) 1047 root.float_child = float(f) 1048 self.assertTrue(f == float_elem == float_data_elem == root.float_child)

1049

1050 - def test_data_element_float_precision(self):

1051 # test not losing precision by shortened float str() value 1052 f = 2305064300557.0 1053 value = objectify.DataElement(f) 1054 self.assertTrue(isinstance(value, objectify.FloatElement)) 1055 self.assertEqual(value, f)

1056

1057 - def test_data_element_float_hash_repr(self):

1058 # test not losing precision by shortened float str() value 1059 f = 2305064300557.0 1060 value = objectify.DataElement(f) 1061 self.assertEqual(hash(value), hash(f))

1062

1063 - def test_data_element_xsitypes(self):

1064 for xsi, objclass in xsitype2objclass.items(): 1065 # 1 is a valid value for all ObjectifiedDataElement classes 1066 pyval = 1 1067 value = objectify.DataElement(pyval, _xsi=xsi) 1068 self.assertTrue(isinstance(value, objclass), 1069 "DataElement(%s, _xsi='%s') returns %s, expected %s" 1070 % (pyval, xsi, type(value), objclass))

1071

1072 - def test_data_element_xsitypes_xsdprefixed(self):

1073 for xsi, objclass in xsitype2objclass.items(): 1074 # 1 is a valid value for all ObjectifiedDataElement classes 1075 pyval = 1 1076 value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi) 1077 self.assertTrue(isinstance(value, objclass), 1078 "DataElement(%s, _xsi='%s') returns %s, expected %s" 1079 % (pyval, xsi, type(value), objclass))

1080

1081 - def test_data_element_xsitypes_prefixed(self):

1082 for xsi, objclass in xsitype2objclass.items(): 1083 # 1 is a valid value for all ObjectifiedDataElement classes 1084 self.assertRaises(ValueError, objectify.DataElement, 1, 1085 _xsi="foo:%s" % xsi)

1086

1087 - def test_data_element_pytypes(self):

1088 for pytype, objclass in pytype2objclass.items(): 1089 # 1 is a valid value for all ObjectifiedDataElement classes 1090 pyval = 1 1091 value = objectify.DataElement(pyval, _pytype=pytype) 1092 self.assertTrue(isinstance(value, objclass), 1093 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1094 % (pyval, pytype, type(value), objclass))

1095

1096 - def test_data_element_pytype_none(self):

1097 pyval = 1 1098 pytype = "NoneType" 1099 objclass = objectify.NoneElement 1100 value = objectify.DataElement(pyval, _pytype=pytype) 1101 self.assertTrue(isinstance(value, objclass), 1102 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1103 % (pyval, pytype, type(value), objclass)) 1104 self.assertEqual(value.text, None) 1105 self.assertEqual(value.pyval, None)

1106

1107 - def test_data_element_pytype_none_compat(self):

1108 # pre-2.0 lxml called NoneElement "none" 1109 pyval = 1 1110 pytype = "none" 1111 objclass = objectify.NoneElement 1112 value = objectify.DataElement(pyval, _pytype=pytype) 1113 self.assertTrue(isinstance(value, objclass), 1114 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1115 % (pyval, pytype, type(value), objclass)) 1116 self.assertEqual(value.text, None) 1117 self.assertEqual(value.pyval, None)

1118

1119 - def test_type_unregistered(self):

1120 Element = self.Element 1121 SubElement = self.etree.SubElement 1122 class MyFloat(float): 1123 pass

1124 root = Element("{objectified}root") 1125 root.myfloat = MyFloat(5.5) 1126 self.assertTrue(isinstance(root.myfloat, objectify.FloatElement)) 1127 self.assertEqual(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None)

1128

1129 - def test_data_element_unregistered(self):

1130 class MyFloat(float): 1131 pass

1132 value = objectify.DataElement(MyFloat(5.5)) 1133 self.assertTrue(isinstance(value, objectify.FloatElement)) 1134 self.assertEqual(value, 5.5) 1135 self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), None) 1136

1137 - def test_schema_types(self):

1138 XML = self.XML 1139 root = XML('''\ 1140 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1141 true 1142 false 1143 1 1144 0 1145 1146 <f xsi:type="float">5</f> 1147 <f xsi:type="double">5</f> 1148 1149 <s xsi:type="string">5</s> 1150 <s xsi:type="normalizedString">5</s> 1151 <s xsi:type="token">5</s> 1152 <s xsi:type="language">5</s> 1153 <s xsi:type="Name">5</s> 1154 <s xsi:type="NCName">5</s> 1155 <s xsi:type="ID">5</s> 1156 <s xsi:type="IDREF">5</s> 1157 <s xsi:type="ENTITY">5</s> 1158 <s xsi:type="NMTOKEN">5</s> 1159 1160 <l xsi:type="integer">5</l> 1161 <l xsi:type="nonPositiveInteger">5</l> 1162 <l xsi:type="negativeInteger">5</l> 1163 <l xsi:type="long">5</l> 1164 <l xsi:type="nonNegativeInteger">5</l> 1165 <l xsi:type="unsignedLong">5</l> 1166 <l xsi:type="unsignedInt">5</l> 1167 <l xsi:type="positiveInteger">5</l> 1168 1169 5 1170 5 1171 5 1172 5 1173 5 1174 1175 <n xsi:nil="true"/> 1176 </root> 1177 ''') 1178 1179 for b in root.b: 1180 self.assertTrue(isinstance(b, objectify.BoolElement)) 1181 self.assertEqual(True, root.b[0]) 1182 self.assertEqual(False, root.b[1]) 1183 self.assertEqual(True, root.b[2]) 1184 self.assertEqual(False, root.b[3]) 1185 1186 for f in root.f: 1187 self.assertTrue(isinstance(f, objectify.FloatElement)) 1188 self.assertEqual(5, f) 1189 1190 for s in root.s: 1191 self.assertTrue(isinstance(s, objectify.StringElement)) 1192 self.assertEqual("5", s) 1193 1194 for i in root.i: 1195 self.assertTrue(isinstance(i, objectify.IntElement)) 1196 self.assertEqual(5, i) 1197 1198 for l in root.l: 1199 self.assertTrue(isinstance(l, objectify.IntElement)) 1200 self.assertEqual(5, i) 1201 1202 self.assertTrue(isinstance(root.n, objectify.NoneElement)) 1203 self.assertEqual(None, root.n)

1204

1205 - def test_schema_types_prefixed(self):

1206 XML = self.XML 1207 root = XML('''\ 1208 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1209 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1210 true 1211 false 1212 1 1213 0 1214 1215 <f xsi:type="xsd:float">5</f> 1216 <f xsi:type="xsd:double">5</f> 1217 1218 <s xsi:type="xsd:string">5</s> 1219 <s xsi:type="xsd:normalizedString">5</s> 1220 <s xsi:type="xsd:token">5</s> 1221 <s xsi:type="xsd:language">5</s> 1222 <s xsi:type="xsd:Name">5</s> 1223 <s xsi:type="xsd:NCName">5</s> 1224 <s xsi:type="xsd:ID">5</s> 1225 <s xsi:type="xsd:IDREF">5</s> 1226 <s xsi:type="xsd:ENTITY">5</s> 1227 <s xsi:type="xsd:NMTOKEN">5</s> 1228 1229 <l xsi:type="xsd:integer">5</l> 1230 <l xsi:type="xsd:nonPositiveInteger">5</l> 1231 <l xsi:type="xsd:negativeInteger">5</l> 1232 <l xsi:type="xsd:long">5</l> 1233 <l xsi:type="xsd:nonNegativeInteger">5</l> 1234 <l xsi:type="xsd:unsignedLong">5</l> 1235 <l xsi:type="xsd:unsignedInt">5</l> 1236 <l xsi:type="xsd:positiveInteger">5</l> 1237 1238 5 1239 5 1240 5 1241 5 1242 5 1243 1244 <n xsi:nil="true"/> 1245 </root> 1246 ''') 1247 1248 for b in root.b: 1249 self.assertTrue(isinstance(b, objectify.BoolElement)) 1250 self.assertEqual(True, root.b[0]) 1251 self.assertEqual(False, root.b[1]) 1252 self.assertEqual(True, root.b[2]) 1253 self.assertEqual(False, root.b[3]) 1254 1255 for f in root.f: 1256 self.assertTrue(isinstance(f, objectify.FloatElement)) 1257 self.assertEqual(5, f) 1258 1259 for s in root.s: 1260 self.assertTrue(isinstance(s, objectify.StringElement)) 1261 self.assertEqual("5", s) 1262 1263 for i in root.i: 1264 self.assertTrue(isinstance(i, objectify.IntElement)) 1265 self.assertEqual(5, i) 1266 1267 for l in root.l: 1268 self.assertTrue(isinstance(l, objectify.IntElement)) 1269 self.assertEqual(5, l) 1270 1271 self.assertTrue(isinstance(root.n, objectify.NoneElement)) 1272 self.assertEqual(None, root.n)

1273

1274 - def test_type_str_sequence(self):

1275 XML = self.XML 1276 root = XML(_bytes('<root>whytry</root>')) 1277 strs = [ str(s) for s in root.b ] 1278 self.assertEqual(["why", "try"], 1279 strs)

1280

1281 - def test_type_str_cmp(self):

1282 XML = self.XML 1283 root = XML(_bytes('<root>testtaste</root>')) 1284 self.assertFalse(root.b[0] < root.b[1]) 1285 self.assertFalse(root.b[0] <= root.b[1]) 1286 self.assertFalse(root.b[0] == root.b[1]) 1287 1288 self.assertTrue(root.b[0] != root.b[1]) 1289 self.assertTrue(root.b[0] >= root.b[1]) 1290 self.assertTrue(root.b[0] > root.b[1]) 1291 1292 self.assertEqual(root.b[0], "test") 1293 self.assertEqual("test", root.b[0]) 1294 1295 self.assertEqual("", root.b[2]) 1296 self.assertEqual(root.b[2], "") 1297 self.assertEqual("", root.b[3]) 1298 self.assertEqual(root.b[3], "") 1299 self.assertEqual(root.b[2], root.b[3]) 1300 1301 root.b = "test" 1302 self.assertTrue(root.b) 1303 root.b = "" 1304 self.assertFalse(root.b) 1305 self.assertEqual(root.b, "") 1306 self.assertEqual("", root.b)

1307

1308 - def test_type_int_cmp(self):

1309 XML = self.XML 1310 root = XML(_bytes('<root>56</root>')) 1311 self.assertTrue(root.b[0] < root.b[1]) 1312 self.assertTrue(root.b[0] <= root.b[1]) 1313 self.assertTrue(root.b[0] != root.b[1]) 1314 1315 self.assertFalse(root.b[0] == root.b[1]) 1316 self.assertFalse(root.b[0] >= root.b[1]) 1317 self.assertFalse(root.b[0] > root.b[1]) 1318 1319 self.assertEqual(root.b[0], 5) 1320 self.assertEqual(5, root.b[0]) 1321 self.assertNotEqual(root.b[0], "5") 1322 1323 root.b = 5 1324 self.assertTrue(root.b) 1325 root.b = 0 1326 self.assertFalse(root.b)

1327 1328 # float + long share the NumberElement implementation with int 1329

1330 - def test_type_bool_cmp(self):

1331 XML = self.XML 1332 root = XML(_bytes('<root>falsetrue</root>')) 1333 self.assertTrue(root.b[0] < root.b[1]) 1334 self.assertTrue(root.b[0] <= root.b[1]) 1335 self.assertTrue(root.b[0] != root.b[1]) 1336 1337 self.assertFalse(root.b[0] == root.b[1]) 1338 self.assertFalse(root.b[0] >= root.b[1]) 1339 self.assertFalse(root.b[0] > root.b[1]) 1340 1341 self.assertFalse(root.b[0]) 1342 self.assertTrue(root.b[1]) 1343 1344 self.assertEqual(root.b[0], False) 1345 self.assertEqual(False, root.b[0]) 1346 self.assertTrue(root.b[0] < 5) 1347 self.assertTrue(5 > root.b[0]) 1348 1349 root.b = True 1350 self.assertTrue(root.b) 1351 root.b = False 1352 self.assertFalse(root.b)

1353

1354 - def test_type_none_cmp(self):

1355 XML = self.XML 1356 root = XML(_bytes(""" 1357 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1358  1359 </root>""")) 1360 self.assertTrue(root.b[0] == root.b[1]) 1361 self.assertFalse(root.b[0]) 1362 self.assertEqual(root.b[0], None) 1363 self.assertEqual(None, root.b[0])

1364 1365 # doesn't work in Py3: 1366 1367 #for comparison in ["abc", 5, 7.3, True, [], ()]: 1368 # none = root.b[1] 1369 # self.assertTrue(none < comparison, "%s (%s) should be < %s" % 1370 # (none, type(none), comparison) ) 1371 # self.assertTrue(comparison > none, "%s should be > %s (%s)" % 1372 # (comparison, none, type(none)) ) 1373

1374 - def test_dataelement_xsi(self):

1375 el = objectify.DataElement(1, _xsi="string") 1376 self.assertEqual( 1377 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1378 'xsd:string')

1379

1380 - def test_dataelement_xsi_nsmap(self):

1381 el = objectify.DataElement(1, _xsi="string", 1382 nsmap={'schema': XML_SCHEMA_NS}) 1383 self.assertEqual( 1384 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1385 'schema:string')

1386

1387 - def test_dataelement_xsi_prefix_error(self):

1388 self.assertRaises(ValueError, objectify.DataElement, 1, 1389 _xsi="foo:string")

1390

1391 - def test_pytype_annotation(self):

1392 XML = self.XML 1393 root = XML(_bytes('''\ 1394 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1395 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1396 5 1397 test 1398 <c>1.1</c> 1399 <c>\uF8D2</c> 1400 <x>true</x> 1401 <n xsi:nil="true" /> 1402 <n></n> 1403 5 1404 5 1405 <s xsi:type="string">23</s> 1406 <s py:pytype="str">42</s> 1407 <f py:pytype="float">300</f> 1408 <l py:pytype="long">2</l> 1409 <t py:pytype="TREE"></t> 1410 </a> 1411 ''')) 1412 objectify.annotate(root) 1413 1414 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1415 for c in root.iterchildren() ] 1416 self.assertEqual("int", child_types[ 0]) 1417 self.assertEqual("str", child_types[ 1]) 1418 self.assertEqual("float", child_types[ 2]) 1419 self.assertEqual("str", child_types[ 3]) 1420 self.assertEqual("bool", child_types[ 4]) 1421 self.assertEqual("NoneType", child_types[ 5]) 1422 self.assertEqual(None, child_types[ 6]) 1423 self.assertEqual("float", child_types[ 7]) 1424 self.assertEqual("float", child_types[ 8]) 1425 self.assertEqual("str", child_types[ 9]) 1426 self.assertEqual("int", child_types[10]) 1427 self.assertEqual("int", child_types[11]) 1428 self.assertEqual("int", child_types[12]) 1429 self.assertEqual(None, child_types[13]) 1430 1431 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1432

1433 - def test_pytype_annotation_empty(self):

1434 XML = self.XML 1435 root = XML(_bytes('''\ 1436 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1437 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1438 <n></n> 1439 </a> 1440 ''')) 1441 objectify.annotate(root) 1442 1443 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1444 for c in root.iterchildren() ] 1445 self.assertEqual(None, child_types[0]) 1446 1447 objectify.annotate(root, empty_pytype="str") 1448 1449 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1450 for c in root.iterchildren() ] 1451 self.assertEqual("str", child_types[0])

1452

1453 - def test_pytype_annotation_use_old(self):

1454 XML = self.XML 1455 root = XML(_bytes('''\ 1456 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1457 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1458 5 1459 test 1460 <c>1.1</c> 1461 <c>\uF8D2</c> 1462 <x>true</x> 1463 <n xsi:nil="true" /> 1464 <n></n> 1465 5 1466 5 1467 <s xsi:type="string">23</s> 1468 <s py:pytype="str">42</s> 1469 <f py:pytype="float">300</f> 1470 <l py:pytype="long">2</l> 1471 <t py:pytype="TREE"></t> 1472 </a> 1473 ''')) 1474 objectify.annotate(root, ignore_old=False) 1475 1476 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1477 for c in root.iterchildren() ] 1478 self.assertEqual("int", child_types[ 0]) 1479 self.assertEqual("str", child_types[ 1]) 1480 self.assertEqual("float", child_types[ 2]) 1481 self.assertEqual("str", child_types[ 3]) 1482 self.assertEqual("bool", child_types[ 4]) 1483 self.assertEqual("NoneType", child_types[ 5]) 1484 self.assertEqual(None, child_types[ 6]) 1485 self.assertEqual("float", child_types[ 7]) 1486 self.assertEqual("float", child_types[ 8]) 1487 self.assertEqual("str", child_types[ 9]) 1488 self.assertEqual("str", child_types[10]) 1489 self.assertEqual("float", child_types[11]) 1490 self.assertEqual("int", child_types[12]) 1491 self.assertEqual(TREE_PYTYPE, child_types[13]) 1492 1493 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1494

1495 - def test_pytype_xsitype_annotation(self):

1496 XML = self.XML 1497 root = XML(_bytes('''\ 1498 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1499 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1500 5 1501 test 1502 <c>1.1</c> 1503 <c>\uF8D2</c> 1504 <x>true</x> 1505 <n xsi:nil="true" /> 1506 <n></n> 1507 5 1508 5 1509 <s xsi:type="string">23</s> 1510 <s py:pytype="str">42</s> 1511 <f py:pytype="float">300</f> 1512 <l py:pytype="long">2</l> 1513 <t py:pytype="TREE"></t> 1514 </a> 1515 ''')) 1516 objectify.annotate(root, ignore_old=False, ignore_xsi=False, 1517 annotate_xsi=1, annotate_pytype=1) 1518 1519 # check py annotations 1520 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1521 for c in root.iterchildren() ] 1522 self.assertEqual("int", child_types[ 0]) 1523 self.assertEqual("str", child_types[ 1]) 1524 self.assertEqual("float", child_types[ 2]) 1525 self.assertEqual("str", child_types[ 3]) 1526 self.assertEqual("bool", child_types[ 4]) 1527 self.assertEqual("NoneType", child_types[ 5]) 1528 self.assertEqual(None, child_types[ 6]) 1529 self.assertEqual("float", child_types[ 7]) 1530 self.assertEqual("float", child_types[ 8]) 1531 self.assertEqual("str", child_types[ 9]) 1532 self.assertEqual("str", child_types[10]) 1533 self.assertEqual("float", child_types[11]) 1534 self.assertEqual("int", child_types[12]) 1535 self.assertEqual(TREE_PYTYPE, child_types[13]) 1536 1537 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1538 1539 child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1540 for c in root.iterchildren() ] 1541 1542 # check xsi annotations 1543 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1544 for c in root.iterchildren() ] 1545 self.assertEqual("xsd:integer", child_types[ 0]) 1546 self.assertEqual("xsd:string", child_types[ 1]) 1547 self.assertEqual("xsd:double", child_types[ 2]) 1548 self.assertEqual("xsd:string", child_types[ 3]) 1549 self.assertEqual("xsd:boolean", child_types[ 4]) 1550 self.assertEqual(None, child_types[ 5]) 1551 self.assertEqual(None, child_types[ 6]) 1552 self.assertEqual("xsd:double", child_types[ 7]) 1553 self.assertEqual("xsd:float", child_types[ 8]) 1554 self.assertEqual("xsd:string", child_types[ 9]) 1555 self.assertEqual("xsd:string", child_types[10]) 1556 self.assertEqual("xsd:double", child_types[11]) 1557 self.assertEqual("xsd:integer", child_types[12]) 1558 self.assertEqual(None, child_types[13]) 1559 1560 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1561

1562 - def test_xsiannotate_use_old(self):

1563 XML = self.XML 1564 root = XML(_bytes('''\ 1565 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1566 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1567 5 1568 test 1569 <c>1.1</c> 1570 <c>\uF8D2</c> 1571 <x>true</x> 1572 <n xsi:nil="true" /> 1573 <n></n> 1574 5 1575 5 1576 <s xsi:type="string">23</s> 1577 <s py:pytype="str">42</s> 1578 <f py:pytype="float">300</f> 1579 <l py:pytype="long">2</l> 1580 <t py:pytype="TREE"></t> 1581 </a> 1582 ''')) 1583 objectify.xsiannotate(root, ignore_old=False) 1584 1585 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1586 for c in root.iterchildren() ] 1587 self.assertEqual("xsd:integer", child_types[ 0]) 1588 self.assertEqual("xsd:string", child_types[ 1]) 1589 self.assertEqual("xsd:double", child_types[ 2]) 1590 self.assertEqual("xsd:string", child_types[ 3]) 1591 self.assertEqual("xsd:boolean", child_types[ 4]) 1592 self.assertEqual(None, child_types[ 5]) 1593 self.assertEqual(None, child_types[ 6]) 1594 self.assertEqual("xsd:double", child_types[ 7]) 1595 self.assertEqual("xsd:float", child_types[ 8]) 1596 self.assertEqual("xsd:string", child_types[ 9]) 1597 self.assertEqual("xsd:string", child_types[10]) 1598 self.assertEqual("xsd:double", child_types[11]) 1599 self.assertEqual("xsd:integer", child_types[12]) 1600 self.assertEqual(None, child_types[13])

1601

1602 - def test_pyannotate_ignore_old(self):

1603 XML = self.XML 1604 root = XML(_bytes('''\ 1605 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1606 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1607 5 1608 test 1609 <c>1.1</c> 1610 <c>\uF8D2</c> 1611 <x>true</x> 1612 <n xsi:nil="true" /> 1613 <n></n> 1614 5 1615 5 1616 <s xsi:type="string">23</s> 1617 <s py:pytype="str">42</s> 1618 <f py:pytype="float">300</f> 1619 <l py:pytype="long">2</l> 1620 <t py:pytype="TREE"></t> 1621 </a> 1622 ''')) 1623 objectify.pyannotate(root, ignore_old=True) 1624 1625 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1626 for c in root.iterchildren() ] 1627 self.assertEqual("int", child_types[ 0]) 1628 self.assertEqual("str", child_types[ 1]) 1629 self.assertEqual("float", child_types[ 2]) 1630 self.assertEqual("str", child_types[ 3]) 1631 self.assertEqual("bool", child_types[ 4]) 1632 self.assertEqual("NoneType", child_types[ 5]) 1633 self.assertEqual(None, child_types[ 6]) 1634 self.assertEqual("float", child_types[ 7]) 1635 self.assertEqual("float", child_types[ 8]) 1636 self.assertEqual("str", child_types[ 9]) 1637 self.assertEqual("int", child_types[10]) 1638 self.assertEqual("int", child_types[11]) 1639 self.assertEqual("int", child_types[12]) 1640 self.assertEqual(None, child_types[13]) 1641 1642 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1643

1644 - def test_pyannotate_empty(self):

1645 XML = self.XML 1646 root = XML('''\ 1647 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1648 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1649 <n></n> 1650 </a> 1651 ''') 1652 objectify.pyannotate(root) 1653 1654 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1655 for c in root.iterchildren() ] 1656 self.assertEqual(None, child_types[0]) 1657 1658 objectify.annotate(root, empty_pytype="str") 1659 1660 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1661 for c in root.iterchildren() ] 1662 self.assertEqual("str", child_types[0])

1663

1664 - def test_pyannotate_use_old(self):

1665 XML = self.XML 1666 root = XML('''\ 1667 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1668 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1669 5 1670 test 1671 <c>1.1</c> 1672 <c>\uF8D2</c> 1673 <x>true</x> 1674 <n xsi:nil="true" /> 1675 <n></n> 1676 5 1677 5 1678 <s xsi:type="string">23</s> 1679 <s py:pytype="str">42</s> 1680 <f py:pytype="float">300</f> 1681 <l py:pytype="long">2</l> 1682 <t py:pytype="TREE"></t> 1683 </a> 1684 ''') 1685 objectify.pyannotate(root) 1686 1687 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1688 for c in root.iterchildren() ] 1689 self.assertEqual("int", child_types[ 0]) 1690 self.assertEqual("str", child_types[ 1]) 1691 self.assertEqual("float", child_types[ 2]) 1692 self.assertEqual("str", child_types[ 3]) 1693 self.assertEqual("bool", child_types[ 4]) 1694 self.assertEqual("NoneType", child_types[ 5]) 1695 self.assertEqual(None, child_types[ 6]) 1696 self.assertEqual("float", child_types[ 7]) 1697 self.assertEqual("float", child_types[ 8]) 1698 self.assertEqual("str", child_types[ 9]) 1699 self.assertEqual("str", child_types[10]) 1700 self.assertEqual("float", child_types[11]) 1701 self.assertEqual("int", child_types[12]) 1702 self.assertEqual(TREE_PYTYPE, child_types[13]) 1703 1704 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1705

1706 - def test_xsiannotate_ignore_old(self):

1707 XML = self.XML 1708 root = XML(_bytes('''\ 1709 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1710 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1711 5 1712 test 1713 <c>1.1</c> 1714 <c>\uF8D2</c> 1715 <x>true</x> 1716 <n xsi:nil="true" /> 1717 <n></n> 1718 5 1719 5 1720 <s xsi:type="string">23</s> 1721 <s py:pytype="str">42</s> 1722 <f py:pytype="float">300</f> 1723 <l py:pytype="long">2</l> 1724 <t py:pytype="TREE"></t> 1725 </a> 1726 ''')) 1727 objectify.xsiannotate(root, ignore_old=True) 1728 1729 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1730 for c in root.iterchildren() ] 1731 self.assertEqual("xsd:integer", child_types[ 0]) 1732 self.assertEqual("xsd:string", child_types[ 1]) 1733 self.assertEqual("xsd:double", child_types[ 2]) 1734 self.assertEqual("xsd:string", child_types[ 3]) 1735 self.assertEqual("xsd:boolean", child_types[ 4]) 1736 self.assertEqual(None, child_types[ 5]) 1737 self.assertEqual(None, child_types[ 6]) 1738 self.assertEqual("xsd:integer", child_types[ 7]) 1739 self.assertEqual("xsd:integer", child_types[ 8]) 1740 self.assertEqual("xsd:integer", child_types[ 9]) 1741 self.assertEqual("xsd:string", child_types[10]) 1742 self.assertEqual("xsd:double", child_types[11]) 1743 self.assertEqual("xsd:integer", child_types[12]) 1744 self.assertEqual(None, child_types[13]) 1745 1746 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1747

1748 - def test_deannotate(self):

1749 XML = self.XML 1750 root = XML(_bytes('''\ 1751 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1752 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1753 5 1754 test 1755 <c>1.1</c> 1756 <c>\uF8D2</c> 1757 <x>true</x> 1758 <n xsi:nil="true" /> 1759 <n></n> 1760 5 1761 5 1762 <s xsi:type="string">23</s> 1763 <s py:pytype="str">42</s> 1764 <f py:pytype="float">300</f> 1765 <l py:pytype="long">2</l> 1766 <t py:pytype="TREE"></t> 1767 </a> 1768 ''')) 1769 objectify.deannotate(root) 1770 1771 for c in root.getiterator(): 1772 self.assertEqual(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 1773 self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1774 1775 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1776

1777 - def test_xsinil_deannotate(self):

1778 XML = self.XML 1779 root = XML(_bytes('''\ 1780 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1781 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1782 5 1783 test 1784 <c>1.1</c> 1785 <c>\uF8D2</c> 1786 <x>true</x> 1787 <n xsi:nil="true" /> 1788 <n></n> 1789 5 1790 5 1791 <s xsi:type="string">23</s> 1792 <s py:pytype="str">42</s> 1793 <f py:pytype="float">300</f> 1794 <l py:pytype="long">2</l> 1795 <t py:pytype="TREE"></t> 1796 </a> 1797 ''')) 1798 objectify.annotate( 1799 root, ignore_old=False, ignore_xsi=False, annotate_xsi=True, 1800 empty_pytype='str', empty_type='string') 1801 objectify.deannotate(root, pytype=False, xsi=False, xsi_nil=True) 1802 1803 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1804 for c in root.iterchildren() ] 1805 self.assertEqual("xsd:integer", child_types[ 0]) 1806 self.assertEqual("xsd:string", child_types[ 1]) 1807 self.assertEqual("xsd:double", child_types[ 2]) 1808 self.assertEqual("xsd:string", child_types[ 3]) 1809 self.assertEqual("xsd:boolean", child_types[ 4]) 1810 self.assertEqual(None, child_types[ 5]) 1811 self.assertEqual("xsd:string", child_types[ 6]) 1812 self.assertEqual("xsd:double", child_types[ 7]) 1813 self.assertEqual("xsd:float", child_types[ 8]) 1814 self.assertEqual("xsd:string", child_types[ 9]) 1815 self.assertEqual("xsd:string", child_types[10]) 1816 self.assertEqual("xsd:double", child_types[11]) 1817 self.assertEqual("xsd:integer", child_types[12]) 1818 self.assertEqual(None, child_types[13]) 1819 1820 self.assertEqual(None, root.n.get(XML_SCHEMA_NIL_ATTR)) 1821 1822 for c in root.iterchildren(): 1823 self.assertNotEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1824 # these have no equivalent in xsi:type 1825 if (c.get(objectify.PYTYPE_ATTRIBUTE) not in [TREE_PYTYPE, 1826 "NoneType"]): 1827 self.assertNotEqual( 1828 None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))

1829

1830 - def test_xsitype_deannotate(self):

1831 XML = self.XML 1832 root = XML(_bytes('''\ 1833 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1834 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1835 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1836 5 1837 test 1838 <c>1.1</c> 1839 <c>\uF8D2</c> 1840 <x>true</x> 1841 <n xsi:nil="true" /> 1842 <n></n> 1843 5 1844 5 1845 <s xsi:type="xsd:string">23</s> 1846 <s py:pytype="str">42</s> 1847 <f py:pytype="float">300</f> 1848 <l py:pytype="long">2</l> 1849 <t py:pytype="TREE"></t> 1850 </a> 1851 ''')) 1852 objectify.annotate(root) 1853 objectify.deannotate(root, pytype=False) 1854 1855 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1856 for c in root.iterchildren() ] 1857 self.assertEqual("int", child_types[ 0]) 1858 self.assertEqual("str", child_types[ 1]) 1859 self.assertEqual("float", child_types[ 2]) 1860 self.assertEqual("str", child_types[ 3]) 1861 self.assertEqual("bool", child_types[ 4]) 1862 self.assertEqual("NoneType", child_types[ 5]) 1863 self.assertEqual(None, child_types[ 6]) 1864 self.assertEqual("float", child_types[ 7]) 1865 self.assertEqual("float", child_types[ 8]) 1866 self.assertEqual("str", child_types[ 9]) 1867 self.assertEqual("int", child_types[10]) 1868 self.assertEqual("int", child_types[11]) 1869 self.assertEqual("int", child_types[12]) 1870 self.assertEqual(None, child_types[13]) 1871 1872 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1873 1874 for c in root.getiterator(): 1875 self.assertEqual(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))

1876

1877 - def test_pytype_deannotate(self):

1878 XML = self.XML 1879 root = XML(_bytes('''\ 1880 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1881 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1882 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1883 5 1884 test 1885 <c xsi:type="xsd:float">1.1</c> 1886 <c xsi:type="xsd:string">\uF8D2</c> 1887 <x xsi:type="xsd:boolean">true</x> 1888 <n xsi:nil="true" /> 1889 <n></n> 1890 5 1891 5 1892 <s xsi:type="xsd:string">23</s> 1893 <s xsi:type="xsd:string">42</s> 1894 <f xsi:type="xsd:float">300</f> 1895 <l xsi:type="xsd:long">2</l> 1896 <t py:pytype="TREE"></t> 1897 </a> 1898 ''')) 1899 objectify.annotate(root) 1900 objectify.deannotate(root, xsi=False) 1901 1902 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1903 for c in root.iterchildren() ] 1904 self.assertEqual("xsd:int", child_types[ 0]) 1905 self.assertEqual("xsd:string", child_types[ 1]) 1906 self.assertEqual("xsd:float", child_types[ 2]) 1907 self.assertEqual("xsd:string", child_types[ 3]) 1908 self.assertEqual("xsd:boolean", child_types[ 4]) 1909 self.assertEqual(None, child_types[ 5]) 1910 self.assertEqual(None, child_types[ 6]) 1911 self.assertEqual("xsd:double", child_types[ 7]) 1912 self.assertEqual("xsd:float", child_types[ 8]) 1913 self.assertEqual("xsd:string", child_types[ 9]) 1914 self.assertEqual("xsd:string", child_types[10]) 1915 self.assertEqual("xsd:float", child_types[11]) 1916 self.assertEqual("xsd:long", child_types[12]) 1917 self.assertEqual(None, child_types[13]) 1918 1919 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1920 1921 for c in root.getiterator(): 1922 self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE))

1923

1924 - def test_change_pytype_attribute(self):

1925 XML = self.XML 1926 1927 xml = _bytes('''\ 1928 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1929 5 1930 test 1931 <c>1.1</c> 1932 <c>\uF8D2</c> 1933 <x>true</x> 1934 <n xsi:nil="true" /> 1935 <n></n> 1936 5 1937 </a> 1938 ''') 1939 1940 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1941 objectify.set_pytype_attribute_tag("{TEST}test") 1942 1943 root = XML(xml) 1944 objectify.annotate(root) 1945 1946 attribs = root.xpath("//@py:%s" % pytype_name, 1947 namespaces={"py" : pytype_ns}) 1948 self.assertEqual(0, len(attribs)) 1949 attribs = root.xpath("//@py:test", 1950 namespaces={"py" : "TEST"}) 1951 self.assertEqual(7, len(attribs)) 1952 1953 objectify.set_pytype_attribute_tag() 1954 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1955 1956 self.assertNotEqual("test", pytype_ns.lower()) 1957 self.assertNotEqual("test", pytype_name.lower()) 1958 1959 root = XML(xml) 1960 attribs = root.xpath("//@py:%s" % pytype_name, 1961 namespaces={"py" : pytype_ns}) 1962 self.assertEqual(0, len(attribs)) 1963 1964 objectify.annotate(root) 1965 attribs = root.xpath("//@py:%s" % pytype_name, 1966 namespaces={"py" : pytype_ns}) 1967 self.assertEqual(7, len(attribs))

1968

1969 - def test_registered_types(self):

1970 orig_types = objectify.getRegisteredTypes() 1971 orig_types[0].unregister() 1972 self.assertEqual(orig_types[1:], objectify.getRegisteredTypes()) 1973 1974 class NewType(objectify.ObjectifiedDataElement): 1975 pass

1976 1977 def checkMyType(s): 1978 return True 1979 1980 pytype = objectify.PyType("mytype", checkMyType, NewType) 1981 self.assertTrue(pytype not in objectify.getRegisteredTypes()) 1982 pytype.register() 1983 self.assertTrue(pytype in objectify.getRegisteredTypes()) 1984 pytype.unregister() 1985 self.assertTrue(pytype not in objectify.getRegisteredTypes()) 1986 1987 pytype.register(before = [objectify.getRegisteredTypes()[0].name]) 1988 self.assertEqual(pytype, objectify.getRegisteredTypes()[0]) 1989 pytype.unregister() 1990 1991 pytype.register(after = [objectify.getRegisteredTypes()[0].name]) 1992 self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0]) 1993 pytype.unregister() 1994 1995 self.assertRaises(ValueError, pytype.register, 1996 before = [objectify.getRegisteredTypes()[0].name], 1997 after = [objectify.getRegisteredTypes()[1].name]) 1998

1999 - def test_registered_type_stringify(self):

2000 from datetime import datetime 2001 def parse_date(value): 2002 if len(value) != 14: 2003 raise ValueError(value) 2004 Y = int(value[0:4]) 2005 M = int(value[4:6]) 2006 D = int(value[6:8]) 2007 h = int(value[8:10]) 2008 m = int(value[10:12]) 2009 s = int(value[12:14]) 2010 return datetime(Y, M, D, h, m, s)

2011 2012 def stringify_date(date): 2013 return date.strftime("%Y%m%d%H%M%S") 2014 2015 class DatetimeElement(objectify.ObjectifiedDataElement): 2016 def pyval(self): 2017 return parse_date(self.text) 2018 pyval = property(pyval) 2019 2020 datetime_type = objectify.PyType( 2021 "datetime", parse_date, DatetimeElement, stringify_date) 2022 datetime_type.xmlSchemaTypes = "dateTime" 2023 datetime_type.register() 2024 2025 NAMESPACE = "http://foo.net/xmlns" 2026 NAMESPACE_MAP = {'ns': NAMESPACE} 2027 2028 r = objectify.Element("{%s}root" % NAMESPACE, nsmap=NAMESPACE_MAP) 2029 time = datetime.now() 2030 r.date = time 2031 2032 self.assertTrue(isinstance(r.date, DatetimeElement)) 2033 self.assertTrue(isinstance(r.date.pyval, datetime)) 2034 2035 self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 2036 self.assertEqual(r.date.text, stringify_date(time)) 2037 2038 r.date = objectify.E.date(time) 2039 2040 self.assertTrue(isinstance(r.date, DatetimeElement)) 2041 self.assertTrue(isinstance(r.date.pyval, datetime)) 2042 2043 self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 2044 self.assertEqual(r.date.text, stringify_date(time)) 2045 2046 date = objectify.DataElement(time) 2047 2048 self.assertTrue(isinstance(date, DatetimeElement)) 2049 self.assertTrue(isinstance(date.pyval, datetime)) 2050 2051 self.assertEqual(date.pyval, parse_date(stringify_date(time))) 2052 self.assertEqual(date.text, stringify_date(time)) 2053

2054 - def test_object_path(self):

2055 root = self.XML(xml_str) 2056 path = objectify.ObjectPath( "root.c1.c2" ) 2057 self.assertEqual(root.c1.c2.text, path.find(root).text) 2058 self.assertEqual(root.c1.c2.text, path(root).text)

2059

2060 - def test_object_path_list(self):

2061 root = self.XML(xml_str) 2062 path = objectify.ObjectPath( ['root', 'c1', 'c2'] ) 2063 self.assertEqual(root.c1.c2.text, path.find(root).text) 2064 self.assertEqual(root.c1.c2.text, path(root).text)

2065

2066 - def test_object_path_fail(self):

2067 root = self.XML(xml_str) 2068 path = objectify.ObjectPath( "root.c1.c99" ) 2069 self.assertRaises(AttributeError, path, root)

2070

2071 - def test_object_path_default_absolute(self):

2072 root = self.XML(xml_str) 2073 path = objectify.ObjectPath( "root.c1.c99" ) 2074 self.assertEqual(None, path(root, None)) 2075 path = objectify.ObjectPath( "root.c99.c2" ) 2076 self.assertEqual(None, path(root, None)) 2077 path = objectify.ObjectPath( "notroot.c99.c2" ) 2078 self.assertEqual(None, path(root, None))

2079

2080 - def test_object_path_default_relative(self):

2081 root = self.XML(xml_str) 2082 path = objectify.ObjectPath( ".c1.c99" ) 2083 self.assertEqual(None, path(root, None)) 2084 path = objectify.ObjectPath( ".c99.c2" ) 2085 self.assertEqual(None, path(root, None))

2086

2087 - def test_object_path_syntax(self):

2088 root = self.XML(xml_str) 2089 path = objectify.ObjectPath("root . {objectified}c1. c2") 2090 self.assertEqual(root.c1.c2.text, path(root).text) 2091 2092 path = objectify.ObjectPath(" root.{objectified} c1.c2 [ 0 ] ") 2093 self.assertEqual(root.c1.c2.text, path(root).text)

2094

2095 - def test_object_path_fail_parse_empty(self):

2096 self.assertRaises(ValueError, objectify.ObjectPath, "")

2097

2098 - def test_object_path_fail_parse_empty_list(self):

2099 self.assertRaises(ValueError, objectify.ObjectPath, [])

2100

2101 - def test_object_path_hasattr(self):

2102 root = self.XML(xml_str) 2103 path = objectify.ObjectPath( "root" ) 2104 self.assertTrue(path.hasattr(root)) 2105 path = objectify.ObjectPath( "root.c1" ) 2106 self.assertTrue(path.hasattr(root)) 2107 path = objectify.ObjectPath( "root.c1.c2" ) 2108 self.assertTrue(path.hasattr(root)) 2109 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 2110 self.assertTrue(path.hasattr(root)) 2111 path = objectify.ObjectPath( "root.c1.c2[1]" ) 2112 self.assertTrue(path.hasattr(root)) 2113 path = objectify.ObjectPath( "root.c1.c2[2]" ) 2114 self.assertTrue(path.hasattr(root)) 2115 path = objectify.ObjectPath( "root.c1.c2[3]" ) 2116 self.assertFalse(path.hasattr(root)) 2117 path = objectify.ObjectPath( "root.c1[1].c2" ) 2118 self.assertFalse(path.hasattr(root))

2119

2120 - def test_object_path_dot(self):

2121 root = self.XML(xml_str) 2122 path = objectify.ObjectPath( "." ) 2123 self.assertEqual(root.c1.c2.text, path(root).c1.c2.text)

2124

2125 - def test_object_path_dot_list(self):

2126 root = self.XML(xml_str) 2127 path = objectify.ObjectPath( [''] ) 2128 self.assertEqual(root.c1.c2.text, path(root).c1.c2.text)

2129

2130 - def test_object_path_dot_root(self):

2131 root = self.XML(xml_str) 2132 path = objectify.ObjectPath( ".c1.c2" ) 2133 self.assertEqual(root.c1.c2.text, path(root).text)

2134

2135 - def test_object_path_dot_root_list(self):

2136 root = self.XML(xml_str) 2137 path = objectify.ObjectPath( ['', 'c1', 'c2'] ) 2138 self.assertEqual(root.c1.c2.text, path(root).text)

2139

2140 - def test_object_path_index(self):

2141 root = self.XML(xml_str) 2142 path = objectify.ObjectPath( "root.c1[0].c2[0]" ) 2143 self.assertEqual(root.c1.c2.text, path(root).text) 2144 2145 path = objectify.ObjectPath( "root.c1[0].c2" ) 2146 self.assertEqual(root.c1.c2.text, path(root).text) 2147 2148 path = objectify.ObjectPath( "root.c1[0].c2[1]" ) 2149 self.assertEqual(root.c1.c2[1].text, path(root).text) 2150 2151 path = objectify.ObjectPath( "root.c1.c2[2]" ) 2152 self.assertEqual(root.c1.c2[2].text, path(root).text) 2153 2154 path = objectify.ObjectPath( "root.c1.c2[-1]" ) 2155 self.assertEqual(root.c1.c2[-1].text, path(root).text) 2156 2157 path = objectify.ObjectPath( "root.c1.c2[-3]" ) 2158 self.assertEqual(root.c1.c2[-3].text, path(root).text)

2159

2160 - def test_object_path_index_list(self):

2161 root = self.XML(xml_str) 2162 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] ) 2163 self.assertEqual(root.c1.c2.text, path(root).text) 2164 2165 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] ) 2166 self.assertEqual(root.c1.c2[2].text, path(root).text) 2167 2168 path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] ) 2169 self.assertEqual(root.c1.c2[2].text, path(root).text) 2170 2171 path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] ) 2172 self.assertEqual(root.c1.c2[-1].text, path(root).text) 2173 2174 path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] ) 2175 self.assertEqual(root.c1.c2[-3].text, path(root).text)

2176

2177 - def test_object_path_index_fail_parse(self):

2178 self.assertRaises(ValueError, objectify.ObjectPath, 2179 "root.c1[0].c2[-1-2]") 2180 self.assertRaises(ValueError, objectify.ObjectPath, 2181 ['root', 'c1[0]', 'c2[-1-2]']) 2182 2183 self.assertRaises(ValueError, objectify.ObjectPath, 2184 "root[2].c1.c2") 2185 self.assertRaises(ValueError, objectify.ObjectPath, 2186 ['root[2]', 'c1', 'c2']) 2187 2188 self.assertRaises(ValueError, objectify.ObjectPath, 2189 []) 2190 self.assertRaises(ValueError, objectify.ObjectPath, 2191 ['', '', ''])

2192

2193 - def test_object_path_index_fail_lookup(self):

2194 root = self.XML(xml_str) 2195 path = objectify.ObjectPath("root.c1[9999].c2") 2196 self.assertRaises(AttributeError, path, root) 2197 2198 path = objectify.ObjectPath("root.c1[0].c2[9999]") 2199 self.assertRaises(AttributeError, path, root) 2200 2201 path = objectify.ObjectPath(".c1[9999].c2[0]") 2202 self.assertRaises(AttributeError, path, root) 2203 2204 path = objectify.ObjectPath("root.c1[-2].c2") 2205 self.assertRaises(AttributeError, path, root) 2206 2207 path = objectify.ObjectPath("root.c1[0].c2[-4]") 2208 self.assertRaises(AttributeError, path, root)

2209

2210 - def test_object_path_ns(self):

2211 root = self.XML(xml_str) 2212 path = objectify.ObjectPath( "{objectified}root.c1.c2" ) 2213 self.assertEqual(root.c1.c2.text, path.find(root).text) 2214 path = objectify.ObjectPath( "{objectified}root.{objectified}c1.c2" ) 2215 self.assertEqual(root.c1.c2.text, path.find(root).text) 2216 path = objectify.ObjectPath( "root.{objectified}c1.{objectified}c2" ) 2217 self.assertEqual(root.c1.c2.text, path.find(root).text) 2218 path = objectify.ObjectPath( "root.c1.{objectified}c2" ) 2219 self.assertEqual(root.c1.c2.text, path.find(root).text) 2220 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 2221 self.assertEqual(getattr(root.c1, '{otherNS}c2').text, 2222 path.find(root).text)

2223

2224 - def test_object_path_ns_list(self):

2225 root = self.XML(xml_str) 2226 path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] ) 2227 self.assertEqual(root.c1.c2.text, path.find(root).text) 2228 path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] ) 2229 self.assertEqual(root.c1.c2.text, path.find(root).text) 2230 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] ) 2231 self.assertEqual(root.c1.c2.text, path.find(root).text) 2232 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] ) 2233 self.assertEqual(root.c1.c2[2].text, path.find(root).text) 2234 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] ) 2235 self.assertEqual(root.c1.c2.text, path.find(root).text) 2236 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] ) 2237 self.assertEqual(root.c1.c2[2].text, path.find(root).text) 2238 path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] ) 2239 self.assertEqual(getattr(root.c1, '{otherNS}c2').text, 2240 path.find(root).text)

2241

2242 - def test_object_path_set(self):

2243 root = self.XML(xml_str) 2244 path = objectify.ObjectPath( "root.c1.c2" ) 2245 self.assertEqual(root.c1.c2.text, path.find(root).text) 2246 self.assertEqual("1", root.c1.c2[1].text) 2247 2248 new_value = "my new value" 2249 path.setattr(root, new_value) 2250 2251 self.assertEqual(new_value, root.c1.c2.text) 2252 self.assertEqual(new_value, path(root).text) 2253 self.assertEqual("1", root.c1.c2[1].text)

2254

2255 - def test_object_path_set_element(self):

2256 root = self.XML(xml_str) 2257 path = objectify.ObjectPath( "root.c1.c2" ) 2258 self.assertEqual(root.c1.c2.text, path.find(root).text) 2259 self.assertEqual("1", root.c1.c2[1].text) 2260 2261 new_el = self.Element("{objectified}test") 2262 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2263 path.setattr(root, new_el.sub) 2264 2265 self.assertEqual("ATTR", root.c1.c2.get("myattr")) 2266 self.assertEqual("TEST", root.c1.c2.a.text) 2267 self.assertEqual("TEST", path(root).a.text) 2268 self.assertEqual("1", root.c1.c2[1].text)

2269

2270 - def test_object_path_set_create(self):

2271 root = self.XML(xml_str) 2272 path = objectify.ObjectPath( "root.c1.c99" ) 2273 self.assertRaises(AttributeError, path.find, root) 2274 2275 new_value = "my new value" 2276 path.setattr(root, new_value) 2277 2278 self.assertEqual(1, len(root.c1.c99)) 2279 self.assertEqual(new_value, root.c1.c99.text) 2280 self.assertEqual(new_value, path(root).text)

2281

2282 - def test_object_path_set_create_element(self):

2283 root = self.XML(xml_str) 2284 path = objectify.ObjectPath( "root.c1.c99" ) 2285 self.assertRaises(AttributeError, path.find, root) 2286 2287 new_el = self.Element("{objectified}test") 2288 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2289 path.setattr(root, new_el.sub) 2290 2291 self.assertEqual(1, len(root.c1.c99)) 2292 self.assertEqual("ATTR", root.c1.c99.get("myattr")) 2293 self.assertEqual("TEST", root.c1.c99.a.text) 2294 self.assertEqual("TEST", path(root).a.text)

2295

2296 - def test_object_path_set_create_list(self):

2297 root = self.XML(xml_str) 2298 path = objectify.ObjectPath( "root.c1.c99" ) 2299 self.assertRaises(AttributeError, path.find, root) 2300 2301 new_el = self.Element("{objectified}test") 2302 new_el.a = ["TEST1", "TEST2"] 2303 new_el.a[0].set("myattr", "ATTR1") 2304 new_el.a[1].set("myattr", "ATTR2") 2305 2306 path.setattr(root, list(new_el.a)) 2307 2308 self.assertEqual(2, len(root.c1.c99)) 2309 self.assertEqual("ATTR1", root.c1.c99[0].get("myattr")) 2310 self.assertEqual("TEST1", root.c1.c99[0].text) 2311 self.assertEqual("ATTR2", root.c1.c99[1].get("myattr")) 2312 self.assertEqual("TEST2", root.c1.c99[1].text) 2313 self.assertEqual("TEST1", path(root).text)

2314

2315 - def test_object_path_addattr(self):

2316 root = self.XML(xml_str) 2317 path = objectify.ObjectPath( "root.c1.c2" ) 2318 self.assertEqual(3, len(root.c1.c2)) 2319 path.addattr(root, "test") 2320 self.assertEqual(4, len(root.c1.c2)) 2321 self.assertEqual(["0", "1", "2", "test"], 2322 [el.text for el in root.c1.c2])

2323

2324 - def test_object_path_addattr_element(self):

2325 root = self.XML(xml_str) 2326 path = objectify.ObjectPath( "root.c1.c2" ) 2327 self.assertEqual(3, len(root.c1.c2)) 2328 2329 new_el = self.Element("{objectified}test") 2330 etree.SubElement(new_el, "{objectified}sub").a = "TEST" 2331 2332 path.addattr(root, new_el.sub) 2333 self.assertEqual(4, len(root.c1.c2)) 2334 self.assertEqual("TEST", root.c1.c2[3].a.text) 2335 self.assertEqual(["0", "1", "2"], 2336 [el.text for el in root.c1.c2[:3]])

2337

2338 - def test_object_path_addattr_create(self):

2339 root = self.XML(xml_str) 2340 path = objectify.ObjectPath( "root.c1.c99" ) 2341 self.assertRaises(AttributeError, path.find, root) 2342 2343 new_value = "my new value" 2344 path.addattr(root, new_value) 2345 2346 self.assertEqual(1, len(root.c1.c99)) 2347 self.assertEqual(new_value, root.c1.c99.text) 2348 self.assertEqual(new_value, path(root).text)

2349

2350 - def test_object_path_addattr_create_element(self):

2351 root = self.XML(xml_str) 2352 path = objectify.ObjectPath( "root.c1.c99" ) 2353 self.assertRaises(AttributeError, path.find, root) 2354 2355 new_el = self.Element("{objectified}test") 2356 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2357 2358 path.addattr(root, new_el.sub) 2359 self.assertEqual(1, len(root.c1.c99)) 2360 self.assertEqual("TEST", root.c1.c99.a.text) 2361 self.assertEqual("TEST", path(root).a.text) 2362 self.assertEqual("ATTR", root.c1.c99.get("myattr"))

2363

2364 - def test_object_path_addattr_create_list(self):

2365 root = self.XML(xml_str) 2366 path = objectify.ObjectPath( "root.c1.c99" ) 2367 self.assertRaises(AttributeError, path.find, root) 2368 2369 new_el = self.Element("{objectified}test") 2370 new_el.a = ["TEST1", "TEST2"] 2371 2372 self.assertEqual(2, len(new_el.a)) 2373 2374 path.addattr(root, list(new_el.a)) 2375 self.assertEqual(2, len(root.c1.c99)) 2376 self.assertEqual("TEST1", root.c1.c99.text) 2377 self.assertEqual("TEST2", path(root)[1].text)

2378

2379 - def test_descendant_paths(self):

2380 root = self.XML(xml_str) 2381 self.assertEqual( 2382 ['{objectified}root', '{objectified}root.c1', 2383 '{objectified}root.c1.c2', 2384 '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]', 2385 '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'], 2386 root.descendantpaths())

2387

2388 - def test_descendant_paths_child(self):

2389 root = self.XML(xml_str) 2390 self.assertEqual( 2391 ['{objectified}c1', '{objectified}c1.c2', 2392 '{objectified}c1.c2[1]', '{objectified}c1.c2[2]', 2393 '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'], 2394 root.c1.descendantpaths())

2395

2396 - def test_descendant_paths_prefix(self):

2397 root = self.XML(xml_str) 2398 self.assertEqual( 2399 ['root.{objectified}c1', 'root.{objectified}c1.c2', 2400 'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]', 2401 'root.{objectified}c1.{otherNS}c2', 2402 'root.{objectified}c1.{}c2'], 2403 root.c1.descendantpaths('root'))

2404

2405 - def test_pickle(self):

2406 import pickle 2407 2408 root = self.XML(xml_str) 2409 out = BytesIO() 2410 pickle.dump(root, out) 2411 2412 new_root = pickle.loads(out.getvalue()) 2413 self.assertEqual( 2414 etree.tostring(new_root), 2415 etree.tostring(root))

2416

2417 - def test_pickle_elementtree(self):

2418 import pickle 2419 2420 tree = etree.ElementTree(self.XML(xml_str + "<?my pi?>")) 2421 out = BytesIO() 2422 pickle.dump(tree, out) 2423 2424 new_tree = pickle.loads(out.getvalue()) 2425 self.assertTrue(isinstance(new_tree, etree._ElementTree)) 2426 self.assertEqual( 2427 etree.tostring(new_tree), 2428 etree.tostring(tree))

2429

2430 - def test_pickle_intelement(self):

2431 self._test_pickle('<x>42</x>') 2432 self._test_pickle(objectify.DataElement(42))

2433

2434 - def test_pickle_floattelement(self):

2435 self._test_pickle('<x>42.0</x>') 2436 self._test_pickle(objectify.DataElement(42.0))

2437

2438 - def test_pickle_strelement(self):

2439 self._test_pickle('<x>Pickle me!</x>') 2440 self._test_pickle(objectify.DataElement('Pickle me!'))

2441

2442 - def test_pickle_boolelement(self):

2443 self._test_pickle('<x>true</x>') 2444 self._test_pickle('<x>false</x>') 2445 self._test_pickle(objectify.DataElement(True)) 2446 self._test_pickle(objectify.DataElement(False))

2447

2448 - def test_pickle_noneelement(self):

2449 self._test_pickle(''' 2450 <x xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>''') 2451 self._test_pickle(objectify.DataElement(None))

2452

2453 - def _test_pickle(self, stringOrElt):

2454 import pickle 2455 if isinstance(stringOrElt, (etree._Element, etree._ElementTree)): 2456 elt = stringOrElt 2457 else: 2458 elt = self.XML(stringOrElt) 2459 out = BytesIO() 2460 pickle.dump(elt, out) 2461 2462 new_elt = pickle.loads(out.getvalue()) 2463 self.assertEqual( 2464 etree.tostring(new_elt), 2465 etree.tostring(elt))

2466 2467 # E-Factory tests, need to use sub-elements as root element is always 2468 # type-looked-up as ObjectifiedElement (no annotations)

2469 - def test_efactory_int(self):

2470 E = objectify.E 2471 root = E.root(E.val(23)) 2472 self.assertTrue(isinstance(root.val, objectify.IntElement))

2473

2474 - def test_efactory_float(self):

2475 E = objectify.E 2476 root = E.root(E.val(233.23)) 2477 self.assertTrue(isinstance(root.val, objectify.FloatElement))

2478

2479 - def test_efactory_str(self):

2480 E = objectify.E 2481 root = E.root(E.val("what?")) 2482 self.assertTrue(isinstance(root.val, objectify.StringElement))

2483

2484 - def test_efactory_unicode(self):

2485 E = objectify.E 2486 root = E.root(E.val(_str("blöödy häll", encoding="ISO-8859-1"))) 2487 self.assertTrue(isinstance(root.val, objectify.StringElement))

2488

2489 - def test_efactory_bool(self):

2490 E = objectify.E 2491 root = E.root(E.val(True)) 2492 self.assertTrue(isinstance(root.val, objectify.BoolElement))

2493

2494 - def test_efactory_none(self):

2495 E = objectify.E 2496 root = E.root(E.val(None)) 2497 self.assertTrue(isinstance(root.val, objectify.NoneElement))

2498

2499 - def test_efactory_value_concatenation(self):

2500 E = objectify.E 2501 root = E.root(E.val(1, "foo", 2.0, "bar ", True, None)) 2502 self.assertTrue(isinstance(root.val, objectify.StringElement))

2503

2504 - def test_efactory_attrib(self):

2505 E = objectify.E 2506 root = E.root(foo="bar") 2507 self.assertEqual(root.get("foo"), "bar")

2508

2509 - def test_efactory_nested(self):

2510 E = objectify.E 2511 DataElement = objectify.DataElement 2512 root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1), 2513 DataElement(2.0)) 2514 self.assertTrue(isinstance(root, objectify.ObjectifiedElement)) 2515 self.assertEqual(root.text, "text") 2516 self.assertTrue(isinstance(root.sub, objectify.ObjectifiedElement)) 2517 self.assertEqual(root.sub.tail, "tail") 2518 self.assertTrue(isinstance(root.sub.subsub, objectify.StringElement)) 2519 self.assertEqual(len(root.value), 2) 2520 self.assertTrue(isinstance(root.value[0], objectify.IntElement)) 2521 self.assertTrue(isinstance(root.value[1], objectify.FloatElement))

2522

2523 - def test_efactory_subtype(self):

2524 class Attribute(objectify.ObjectifiedDataElement): 2525 def __init__(self): 2526 objectify.ObjectifiedDataElement.__init__(self) 2527 self.set("datatype", "TYPE") 2528 self.set("range", "0.,1.")

2529 2530 attr = Attribute() 2531 self.assertEqual(attr.text, None) 2532 self.assertEqual(attr.get("datatype"), "TYPE") 2533 self.assertEqual(attr.get("range"), "0.,1.") 2534

2535 - def test_XML_base_url_docinfo(self):

2536 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2537 docinfo = root.getroottree().docinfo 2538 self.assertEqual(docinfo.URL, "http://no/such/url")

2539

2540 - def test_XML_set_base_url_docinfo(self):

2541 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2542 docinfo = root.getroottree().docinfo 2543 self.assertEqual(docinfo.URL, "http://no/such/url") 2544 docinfo.URL = "https://secret/url" 2545 self.assertEqual(docinfo.URL, "https://secret/url")

2546

2547 - def test_parse_stringio_base_url(self):

2548 tree = objectify.parse(BytesIO("<root/>"), base_url="http://no/such/url") 2549 docinfo = tree.docinfo 2550 self.assertEqual(docinfo.URL, "http://no/such/url")

2551

2552 - def test_parse_base_url_docinfo(self):

2553 tree = objectify.parse(fileInTestDir('include/test_xinclude.xml'), 2554 base_url="http://no/such/url") 2555 docinfo = tree.docinfo 2556 self.assertEqual(docinfo.URL, "http://no/such/url")

2557

2558 - def test_xml_base(self):

2559 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2560 self.assertEqual(root.base, "http://no/such/url") 2561 self.assertEqual( 2562 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2563 root.base = "https://secret/url" 2564 self.assertEqual(root.base, "https://secret/url") 2565 self.assertEqual( 2566 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2567 "https://secret/url")

2568

2569 - def test_xml_base_attribute(self):

2570 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2571 self.assertEqual(root.base, "http://no/such/url") 2572 self.assertEqual( 2573 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2574 root.set('{http://www.w3.org/XML/1998/namespace}base', 2575 "https://secret/url") 2576 self.assertEqual(root.base, "https://secret/url") 2577 self.assertEqual( 2578 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2579 "https://secret/url")

2580

2581 - def test_standard_lookup(self):

2582 XML = self.XML 2583 2584 xml = _bytes('''\ 2585 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 2586 5 2587 -5 2588 <l>4294967296</l> 2589 <l>-4294967296</l> 2590 <f>1.1</f> 2591 true 2592 false 2593 <s>Strange things happen, where strings collide</s> 2594 <s>True</s> 2595 <s>False</s> 2596 <s>t</s> 2597 <s>f</s> 2598 <s></s> 2599 <s>None</s> 2600 <n xsi:nil="true" /> 2601 </root> 2602 ''') 2603 root = XML(xml) 2604 2605 for i in root.i: 2606 self.assertTrue(isinstance(i, objectify.IntElement)) 2607 for l in root.l: 2608 self.assertTrue(isinstance(l, objectify.IntElement)) 2609 for f in root.f: 2610 self.assertTrue(isinstance(f, objectify.FloatElement)) 2611 for b in root.b: 2612 self.assertTrue(isinstance(b, objectify.BoolElement)) 2613 self.assertEqual(True, root.b[0]) 2614 self.assertEqual(False, root.b[1]) 2615 for s in root.s: 2616 self.assertTrue(isinstance(s, objectify.StringElement)) 2617 self.assertTrue(isinstance(root.n, objectify.NoneElement)) 2618 self.assertEqual(None, root.n)

2619

2620 -def test_suite():

2621 suite = unittest.TestSuite() 2622 suite.addTests([unittest.makeSuite(ObjectifyTestCase)]) 2623 suite.addTests(doctest.DocTestSuite(objectify)) 2624 if sys.version_info >= (2,4): 2625 suite.addTests( 2626 [make_doctest('../../../doc/objectify.txt')]) 2627 return suite

2628 2629 if __name__ == '__main__': 2630 print('to test use test.py %s' % __file__) 2631

Source Code for Module lxml.tests.test_objectify