lxml.tests.test

1 # -*- coding: utf-8 -*- 2 3 """ 4 Tests specific to the lxml.objectify API 5 """ 6 7 from __future__ import absolute_import 8 9 import unittest, operator 10 11 from .common_imports import ( 12 etree, HelperTestCase, fileInTestDir, doctest, make_doctest, _bytes, _str, BytesIO 13 ) 14 15 from lxml import objectify 16 17 PYTYPE_NAMESPACE = "http://codespeak.net/lxml/objectify/pytype" 18 XML_SCHEMA_NS = "http://www.w3.org/2001/XMLSchema" 19 XML_SCHEMA_INSTANCE_NS = "http://www.w3.org/2001/XMLSchema-instance" 20 XML_SCHEMA_INSTANCE_TYPE_ATTR = "{%s}type" % XML_SCHEMA_INSTANCE_NS 21 XML_SCHEMA_NIL_ATTR = "{%s}nil" % XML_SCHEMA_INSTANCE_NS 22 TREE_PYTYPE = "TREE" 23 DEFAULT_NSMAP = { "py" : PYTYPE_NAMESPACE, 24 "xsi" : XML_SCHEMA_INSTANCE_NS, 25 "xsd" : XML_SCHEMA_NS} 26 27 objectclass2xsitype = { 28 # objectify built-in 29 objectify.IntElement: ("int", "short", "byte", "unsignedShort", 30 "unsignedByte", "integer", "nonPositiveInteger", 31 "negativeInteger", "long", "nonNegativeInteger", 32 "unsignedLong", "unsignedInt", "positiveInteger",), 33 objectify.FloatElement: ("float", "double"), 34 objectify.BoolElement: ("boolean",), 35 objectify.StringElement: ("string", "normalizedString", "token", "language", 36 "Name", "NCName", "ID", "IDREF", "ENTITY", 37 "NMTOKEN", ), 38 # None: xsi:nil="true" 39 } 40 41 xsitype2objclass = dict([ (v, k) for k in objectclass2xsitype 42 for v in objectclass2xsitype[k] ]) 43 44 objectclass2pytype = { 45 # objectify built-in 46 objectify.IntElement: "int", 47 objectify.FloatElement: "float", 48 objectify.BoolElement: "bool", 49 objectify.StringElement: "str", 50 # None: xsi:nil="true" 51 } 52 53 pytype2objclass = dict([ (objectclass2pytype[k], k) 54 for k in objectclass2pytype]) 55 56 xml_str = '''\ 57 <obj:root xmlns:obj="objectified" xmlns:other="otherNS"> 58 <obj:c1 a1="A1" a2="A2" other:a3="A3"> 59 <obj:c2>0</obj:c2> 60 <obj:c2>1</obj:c2> 61 <obj:c2>2</obj:c2> 62 <other:c2>3</other:c2> 63 <c2>4</c2> 64 </obj:c1> 65 </obj:root>''' 66

67 -class ObjectifyTestCase(HelperTestCase):

68 """Test cases for lxml.objectify 69 """ 70 etree = etree 71

72 - def XML(self, xml):

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

74

75 - def setUp(self):

76 super(ObjectifyTestCase, self).setUp() 77 self.parser = self.etree.XMLParser(remove_blank_text=True) 78 self.lookup = etree.ElementNamespaceClassLookup( 79 objectify.ObjectifyElementClassLookup() ) 80 self.parser.set_element_class_lookup(self.lookup) 81 82 self.Element = self.parser.makeelement 83 84 ns = self.lookup.get_namespace("otherNS") 85 ns[None] = self.etree.ElementBase 86 87 self._orig_types = objectify.getRegisteredTypes()

88

89 - def tearDown(self):

90 self.lookup.get_namespace("otherNS").clear() 91 objectify.set_pytype_attribute_tag() 92 del self.lookup 93 del self.parser 94 95 for pytype in objectify.getRegisteredTypes(): 96 pytype.unregister() 97 for pytype in self._orig_types: 98 pytype.register() 99 del self._orig_types 100 101 super(ObjectifyTestCase, self).tearDown()

102 103

104 - def test_element_nsmap_default(self):

105 elt = objectify.Element("test") 106 self.assertEqual(elt.nsmap, DEFAULT_NSMAP)

107

108 - def test_element_nsmap_empty(self):

109 nsmap = {} 110 elt = objectify.Element("test", nsmap=nsmap) 111 self.assertEqual(list(elt.nsmap.values()), [PYTYPE_NAMESPACE])

112

113 - def test_element_nsmap_custom_prefixes(self):

114 nsmap = {"mypy": PYTYPE_NAMESPACE, 115 "myxsi": XML_SCHEMA_INSTANCE_NS, 116 "myxsd": XML_SCHEMA_NS} 117 elt = objectify.Element("test", nsmap=nsmap) 118 self.assertEqual(elt.nsmap, nsmap)

119

120 - def test_element_nsmap_custom(self):

121 nsmap = {"my": "someNS", 122 "myother": "someOtherNS", 123 "myxsd": XML_SCHEMA_NS} 124 elt = objectify.Element("test", nsmap=nsmap) 125 self.assertTrue(PYTYPE_NAMESPACE in elt.nsmap.values()) 126 for prefix, ns in nsmap.items(): 127 self.assertTrue(prefix in elt.nsmap) 128 self.assertEqual(nsmap[prefix], elt.nsmap[prefix])

129

130 - def test_sub_element_nsmap_default(self):

131 root = objectify.Element("root") 132 root.sub = objectify.Element("test") 133 self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP)

134

135 - def test_sub_element_nsmap_empty(self):

136 root = objectify.Element("root") 137 nsmap = {} 138 root.sub = objectify.Element("test", nsmap=nsmap) 139 self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP)

140

141 - def test_sub_element_nsmap_custom_prefixes(self):

142 root = objectify.Element("root") 143 nsmap = {"mypy": PYTYPE_NAMESPACE, 144 "myxsi": XML_SCHEMA_INSTANCE_NS, 145 "myxsd": XML_SCHEMA_NS} 146 root.sub = objectify.Element("test", nsmap=nsmap) 147 self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP)

148

149 - def test_sub_element_nsmap_custom(self):

150 root = objectify.Element("root") 151 nsmap = {"my": "someNS", 152 "myother": "someOtherNS", 153 "myxsd": XML_SCHEMA_NS,} 154 root.sub = objectify.Element("test", nsmap=nsmap) 155 expected = nsmap.copy() 156 del expected["myxsd"] 157 expected.update(DEFAULT_NSMAP) 158 self.assertEqual(root.sub.nsmap, expected)

159

160 - def test_data_element_nsmap_default(self):

161 value = objectify.DataElement("test this") 162 self.assertEqual(value.nsmap, DEFAULT_NSMAP)

163

164 - def test_data_element_nsmap_empty(self):

165 nsmap = {} 166 value = objectify.DataElement("test this", nsmap=nsmap) 167 self.assertEqual(list(value.nsmap.values()), [PYTYPE_NAMESPACE])

168

169 - def test_data_element_nsmap_custom_prefixes(self):

170 nsmap = {"mypy": PYTYPE_NAMESPACE, 171 "myxsi": XML_SCHEMA_INSTANCE_NS, 172 "myxsd": XML_SCHEMA_NS} 173 value = objectify.DataElement("test this", nsmap=nsmap) 174 self.assertEqual(value.nsmap, nsmap)

175

176 - def test_data_element_nsmap_custom(self):

177 nsmap = {"my": "someNS", 178 "myother": "someOtherNS", 179 "myxsd": XML_SCHEMA_NS,} 180 value = objectify.DataElement("test", nsmap=nsmap) 181 self.assertTrue(PYTYPE_NAMESPACE in value.nsmap.values()) 182 for prefix, ns in nsmap.items(): 183 self.assertTrue(prefix in value.nsmap) 184 self.assertEqual(nsmap[prefix], value.nsmap[prefix])

185

186 - def test_sub_data_element_nsmap_default(self):

187 root = objectify.Element("root") 188 root.value = objectify.DataElement("test this") 189 self.assertEqual(root.value.nsmap, DEFAULT_NSMAP)

190

191 - def test_sub_data_element_nsmap_empty(self):

192 root = objectify.Element("root") 193 nsmap = {} 194 root.value = objectify.DataElement("test this", nsmap=nsmap) 195 self.assertEqual(root.value.nsmap, DEFAULT_NSMAP)

196

197 - def test_sub_data_element_nsmap_custom_prefixes(self):

198 root = objectify.Element("root") 199 nsmap = {"mypy": PYTYPE_NAMESPACE, 200 "myxsi": XML_SCHEMA_INSTANCE_NS, 201 "myxsd": XML_SCHEMA_NS} 202 root.value = objectify.DataElement("test this", nsmap=nsmap) 203 self.assertEqual(root.value.nsmap, DEFAULT_NSMAP)

204

205 - def test_sub_data_element_nsmap_custom(self):

206 root = objectify.Element("root") 207 nsmap = {"my": "someNS", 208 "myother": "someOtherNS", 209 "myxsd": XML_SCHEMA_NS} 210 root.value = objectify.DataElement("test", nsmap=nsmap) 211 expected = nsmap.copy() 212 del expected["myxsd"] 213 expected.update(DEFAULT_NSMAP) 214 self.assertEqual(root.value.nsmap, expected)

215

216 - def test_date_element_efactory_text(self):

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

220

221 - def test_date_element_efactory_tail(self):

222 # ObjectifiedDataElement can also be used as E-Factory 223 value = objectify.ObjectifiedElement(objectify.ObjectifiedDataElement(), 'test', 'toast') 224 self.assertEqual(value.ObjectifiedDataElement.tail, 'testtoast')

225

226 - def test_data_element_attrib_attributes_precedence(self):

227 # keyword arguments override attrib entries 228 value = objectify.DataElement(23, _pytype="str", _xsi="foobar", 229 attrib={"gnu": "muh", "cat": "meeow", 230 "dog": "wuff"}, 231 bird="tchilp", dog="grrr") 232 self.assertEqual(value.get("gnu"), "muh") 233 self.assertEqual(value.get("cat"), "meeow") 234 self.assertEqual(value.get("dog"), "grrr") 235 self.assertEqual(value.get("bird"), "tchilp")

236

237 - def test_data_element_data_element_arg(self):

238 # Check that DataElement preserves all attributes ObjectifiedDataElement 239 # arguments 240 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 241 attrib={"gnu": "muh", "cat": "meeow", 242 "dog": "wuff"}, 243 bird="tchilp", dog="grrr") 244 value = objectify.DataElement(arg) 245 self.assertTrue(isinstance(value, objectify.StringElement)) 246 for attr in arg.attrib: 247 self.assertEqual(value.get(attr), arg.get(attr))

248

249 - def test_data_element_data_element_arg_pytype_none(self):

250 # Check that _pytype arg overrides original py:pytype of 251 # ObjectifiedDataElement 252 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 253 attrib={"gnu": "muh", "cat": "meeow", 254 "dog": "wuff"}, 255 bird="tchilp", dog="grrr") 256 value = objectify.DataElement(arg, _pytype="NoneType") 257 self.assertTrue(isinstance(value, objectify.NoneElement)) 258 self.assertEqual(value.get(XML_SCHEMA_NIL_ATTR), "true") 259 self.assertEqual(value.text, None) 260 self.assertEqual(value.pyval, None) 261 for attr in arg.attrib: 262 #if not attr == objectify.PYTYPE_ATTRIBUTE: 263 self.assertEqual(value.get(attr), arg.get(attr))

264

265 - def test_data_element_data_element_arg_pytype(self):

266 # Check that _pytype arg overrides original py:pytype of 267 # ObjectifiedDataElement 268 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 269 attrib={"gnu": "muh", "cat": "meeow", 270 "dog": "wuff"}, 271 bird="tchilp", dog="grrr") 272 value = objectify.DataElement(arg, _pytype="int") 273 self.assertTrue(isinstance(value, objectify.IntElement)) 274 self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 275 for attr in arg.attrib: 276 if not attr == objectify.PYTYPE_ATTRIBUTE: 277 self.assertEqual(value.get(attr), arg.get(attr))

278

279 - def test_data_element_data_element_arg_xsitype(self):

280 # Check that _xsi arg overrides original xsi:type of given 281 # ObjectifiedDataElement 282 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 283 attrib={"gnu": "muh", "cat": "meeow", 284 "dog": "wuff"}, 285 bird="tchilp", dog="grrr") 286 value = objectify.DataElement(arg, _xsi="xsd:int") 287 self.assertTrue(isinstance(value, objectify.IntElement)) 288 self.assertEqual(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 289 self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 290 for attr in arg.attrib: 291 if not attr in [objectify.PYTYPE_ATTRIBUTE, 292 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 293 self.assertEqual(value.get(attr), arg.get(attr))

294

295 - def test_data_element_data_element_arg_pytype_xsitype(self):

296 # Check that _pytype and _xsi args override original py:pytype and 297 # xsi:type attributes of given ObjectifiedDataElement 298 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 299 attrib={"gnu": "muh", "cat": "meeow", 300 "dog": "wuff"}, 301 bird="tchilp", dog="grrr") 302 value = objectify.DataElement(arg, _pytype="int", _xsi="xsd:int") 303 self.assertTrue(isinstance(value, objectify.IntElement)) 304 self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 305 self.assertEqual(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 306 for attr in arg.attrib: 307 if not attr in [objectify.PYTYPE_ATTRIBUTE, 308 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 309 self.assertEqual(value.get(attr), arg.get(attr))

310

311 - def test_data_element_invalid_pytype(self):

312 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 313 _pytype="int")

314

315 - def test_data_element_invalid_xsi(self):

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

318

319 - def test_data_element_data_element_arg_invalid_pytype(self):

320 arg = objectify.DataElement(3.1415) 321 self.assertRaises(ValueError, objectify.DataElement, arg, 322 _pytype="int")

323

324 - def test_data_element_data_element_arg_invalid_xsi(self):

325 arg = objectify.DataElement(3.1415) 326 self.assertRaises(ValueError, objectify.DataElement, arg, 327 _xsi="xsd:int")

328

329 - def test_data_element_element_arg(self):

330 arg = objectify.Element('arg') 331 value = objectify.DataElement(arg) 332 self.assertTrue(isinstance(value, objectify.ObjectifiedElement)) 333 for attr in arg.attrib: 334 self.assertEqual(value.get(attr), arg.get(attr))

335

336 - def test_root(self):

337 root = self.Element("test") 338 self.assertTrue(isinstance(root, objectify.ObjectifiedElement))

339

340 - def test_str(self):

341 root = self.Element("test") 342 self.assertEqual('', str(root))

343

344 - def test_child(self):

345 root = self.XML(xml_str) 346 self.assertEqual("0", root.c1.c2.text)

347

348 - def test_child_ns_nons(self):

349 root = self.XML(""" 350 <root> 351 <foo:x xmlns:foo="/foo/bar">1</foo:x> 352 <x>2</x> 353 </root> 354 """) 355 self.assertEqual(2, root.x)

356

357 - def test_countchildren(self):

358 root = self.XML(xml_str) 359 self.assertEqual(1, root.countchildren()) 360 self.assertEqual(5, root.c1.countchildren())

361

362 - def test_child_getattr(self):

363 root = self.XML(xml_str) 364 self.assertEqual("0", getattr(root.c1, "{objectified}c2").text) 365 self.assertEqual("3", getattr(root.c1, "{otherNS}c2").text)

366

367 - def test_child_nonexistant(self):

368 root = self.XML(xml_str) 369 self.assertRaises(AttributeError, getattr, root.c1, "NOT_THERE") 370 self.assertRaises(AttributeError, getattr, root.c1, "{unknownNS}c2")

371

372 - def test_child_getattr_empty_ns(self):

373 root = self.XML(xml_str) 374 self.assertEqual("4", getattr(root.c1, "{}c2").text) 375 self.assertEqual("0", getattr(root.c1, "c2").text)

376

377 - def test_setattr(self):

378 for val in [ 379 2, 2**32, 1.2, "Won't get fooled again", 380 _str("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1'), True, 381 False, None]: 382 root = self.Element('root') 383 attrname = 'val' 384 setattr(root, attrname, val) 385 result = getattr(root, attrname) 386 self.assertEqual(val, result) 387 self.assertEqual(type(val), type(result.pyval))

388

389 - def test_setattr_nonunicode(self):

390 root = self.Element('root') 391 attrname = 'val' 392 val = _bytes("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1') 393 self.assertRaises(ValueError, setattr, root, attrname, val) 394 self.assertRaises(AttributeError, getattr, root, attrname)

395

396 - def test_addattr(self):

397 root = self.XML(xml_str) 398 self.assertEqual(1, len(root.c1)) 399 root.addattr("c1", "test") 400 self.assertEqual(2, len(root.c1)) 401 self.assertEqual("test", root.c1[1].text)

402

403 - def test_addattr_element(self):

404 root = self.XML(xml_str) 405 self.assertEqual(1, len(root.c1)) 406 407 new_el = self.Element("test", myattr="5") 408 root.addattr("c1", new_el) 409 self.assertEqual(2, len(root.c1)) 410 self.assertEqual(None, root.c1[0].get("myattr")) 411 self.assertEqual("5", root.c1[1].get("myattr"))

412

413 - def test_addattr_list(self):

414 root = self.XML(xml_str) 415 self.assertEqual(1, len(root.c1)) 416 417 new_el = self.Element("test") 418 self.etree.SubElement(new_el, "a", myattr="A") 419 self.etree.SubElement(new_el, "a", myattr="B") 420 421 root.addattr("c1", list(new_el.a)) 422 self.assertEqual(3, len(root.c1)) 423 self.assertEqual(None, root.c1[0].get("myattr")) 424 self.assertEqual("A", root.c1[1].get("myattr")) 425 self.assertEqual("B", root.c1[2].get("myattr"))

426

427 - def test_child_addattr(self):

428 root = self.XML(xml_str) 429 self.assertEqual(3, len(root.c1.c2)) 430 root.c1.addattr("c2", 3) 431 self.assertEqual(4, len(root.c1.c2)) 432 self.assertEqual("3", root.c1.c2[3].text)

433

434 - def test_child_index(self):

435 root = self.XML(xml_str) 436 self.assertEqual("0", root.c1.c2[0].text) 437 self.assertEqual("1", root.c1.c2[1].text) 438 self.assertEqual("2", root.c1.c2[2].text) 439 self.assertRaises(IndexError, operator.getitem, root.c1.c2, 3) 440 self.assertEqual(root, root[0]) 441 self.assertRaises(IndexError, operator.getitem, root, 1) 442 443 c1 = root.c1 444 del root.c1 # unlink from parent 445 self.assertEqual(c1, c1[0]) 446 self.assertRaises(IndexError, operator.getitem, c1, 1)

447

448 - def test_child_index_neg(self):

449 root = self.XML(xml_str) 450 self.assertEqual("0", root.c1.c2[0].text) 451 self.assertEqual("0", root.c1.c2[-3].text) 452 self.assertEqual("1", root.c1.c2[-2].text) 453 self.assertEqual("2", root.c1.c2[-1].text) 454 self.assertRaises(IndexError, operator.getitem, root.c1.c2, -4) 455 self.assertEqual(root, root[-1]) 456 self.assertRaises(IndexError, operator.getitem, root, -2) 457 458 c1 = root.c1 459 del root.c1 # unlink from parent 460 self.assertEqual(c1, c1[-1]) 461 self.assertRaises(IndexError, operator.getitem, c1, -2)

462

463 - def test_child_len(self):

464 root = self.XML(xml_str) 465 self.assertEqual(1, len(root)) 466 self.assertEqual(1, len(root.c1)) 467 self.assertEqual(3, len(root.c1.c2))

468

469 - def test_child_iter(self):

470 root = self.XML(xml_str) 471 self.assertEqual([root], 472 list(iter(root))) 473 self.assertEqual([root.c1], 474 list(iter(root.c1))) 475 self.assertEqual([root.c1.c2[0], root.c1.c2[1], root.c1.c2[2]], 476 list(iter(root.c1.c2)))

477

478 - def test_class_lookup(self):

479 root = self.XML(xml_str) 480 self.assertTrue(isinstance(root.c1.c2, objectify.ObjectifiedElement)) 481 self.assertFalse(isinstance(getattr(root.c1, "{otherNS}c2"), 482 objectify.ObjectifiedElement))

483

484 - def test_dir(self):

485 root = self.XML(xml_str) 486 dir_c1 = dir(objectify.ObjectifiedElement) + ['c1'] 487 dir_c1.sort() 488 dir_c2 = dir(objectify.ObjectifiedElement) + ['c2'] 489 dir_c2.sort() 490 491 self.assertEqual(dir_c1, dir(root)) 492 self.assertEqual(dir_c2, dir(root.c1))

493

494 - def test_vars(self):

495 root = self.XML(xml_str) 496 self.assertEqual({'c1' : root.c1}, vars(root)) 497 self.assertEqual({'c2' : root.c1.c2}, vars(root.c1))

498

499 - def test_child_set_ro(self):

500 root = self.XML(xml_str) 501 self.assertRaises(TypeError, setattr, root.c1.c2, 'text', "test") 502 self.assertRaises(TypeError, setattr, root.c1.c2, 'pyval', "test")

503 504 # slicing 505

506 - def test_getslice_complete(self):

507 root = self.XML("<root><c>c1</c><c>c2</c></root>") 508 self.assertEqual(["c1", "c2"], 509 [ c.text for c in root.c[:] ])

510

511 - def test_getslice_partial(self):

512 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 513 test_list = ["c1", "c2", "c3", "c4"] 514 515 self.assertEqual(test_list, 516 [ c.text for c in root.c[:] ]) 517 self.assertEqual(test_list[1:2], 518 [ c.text for c in root.c[1:2] ]) 519 self.assertEqual(test_list[-3:-1], 520 [ c.text for c in root.c[-3:-1] ]) 521 self.assertEqual(test_list[-3:3], 522 [ c.text for c in root.c[-3:3] ]) 523 self.assertEqual(test_list[-3000:3], 524 [ c.text for c in root.c[-3000:3] ]) 525 self.assertEqual(test_list[-3:3000], 526 [ c.text for c in root.c[-3:3000] ])

527

528 - def test_getslice_partial_neg(self):

529 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 530 test_list = ["c1", "c2", "c3", "c4"] 531 532 self.assertEqual(test_list, 533 [ c.text for c in root.c[:] ]) 534 self.assertEqual(test_list[2:1:-1], 535 [ c.text for c in root.c[2:1:-1] ]) 536 self.assertEqual(test_list[-1:-3:-1], 537 [ c.text for c in root.c[-1:-3:-1] ]) 538 self.assertEqual(test_list[2:-3:-1], 539 [ c.text for c in root.c[2:-3:-1] ]) 540 self.assertEqual(test_list[2:-3000:-1], 541 [ c.text for c in root.c[2:-3000:-1] ])

542 543 # slice assignment 544

545 - def test_setslice_complete(self):

546 Element = self.Element 547 root = Element("root") 548 root.c = ["c1", "c2"] 549 550 c1 = root.c[0] 551 c2 = root.c[1] 552 553 self.assertEqual([c1,c2], list(root.c)) 554 self.assertEqual(["c1", "c2"], 555 [ c.text for c in root.c ])

556

557 - def test_setslice_elements(self):

558 Element = self.Element 559 root = Element("root") 560 root.c = ["c1", "c2"] 561 562 c1 = root.c[0] 563 c2 = root.c[1] 564 565 self.assertEqual([c1,c2], list(root.c)) 566 self.assertEqual(["c1", "c2"], 567 [ c.text for c in root.c ]) 568 569 root2 = Element("root2") 570 root2.el = [ "test", "test" ] 571 self.assertEqual(["test", "test"], 572 [ el.text for el in root2.el ]) 573 574 root.c = [ root2.el, root2.el ] 575 self.assertEqual(["test", "test"], 576 [ c.text for c in root.c ]) 577 self.assertEqual(["test", "test"], 578 [ el.text for el in root2.el ]) 579 580 root.c[:] = [ c1, c2, c2, c1 ] 581 self.assertEqual(["c1", "c2", "c2", "c1"], 582 [ c.text for c in root.c ])

583

584 - def test_setslice_partial(self):

585 Element = self.Element 586 root = Element("root") 587 l = ["c1", "c2", "c3", "c4"] 588 root.c = l 589 590 self.assertEqual(["c1", "c2", "c3", "c4"], 591 [ c.text for c in root.c ]) 592 self.assertEqual(l, 593 [ c.text for c in root.c ]) 594 595 new_slice = ["cA", "cB"] 596 l[1:2] = new_slice 597 root.c[1:2] = new_slice 598 599 self.assertEqual(["c1", "cA", "cB", "c3", "c4"], l) 600 self.assertEqual(["c1", "cA", "cB", "c3", "c4"], 601 [ c.text for c in root.c ]) 602 self.assertEqual(l, 603 [ c.text for c in root.c ])

604

605 - def test_setslice_insert(self):

606 Element = self.Element 607 root = Element("root") 608 l = ["c1", "c2", "c3", "c4"] 609 root.c = l 610 611 self.assertEqual(["c1", "c2", "c3", "c4"], 612 [ c.text for c in root.c ]) 613 self.assertEqual(l, 614 [ c.text for c in root.c ]) 615 616 new_slice = ["cA", "cB"] 617 l[1:1] = new_slice 618 root.c[1:1] = new_slice 619 620 self.assertEqual(["c1", "cA", "cB", "c2", "c3", "c4"], l) 621 self.assertEqual(["c1", "cA", "cB", "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 - def test_setslice_insert_neg(self):

627 Element = self.Element 628 root = Element("root") 629 l = ["c1", "c2", "c3", "c4"] 630 root.c = l 631 632 self.assertEqual(["c1", "c2", "c3", "c4"], 633 [ c.text for c in root.c ]) 634 self.assertEqual(l, 635 [ c.text for c in root.c ]) 636 637 new_slice = ["cA", "cB"] 638 l[-2:-2] = new_slice 639 root.c[-2:-2] = new_slice 640 641 self.assertEqual(["c1", "c2", "cA", "cB", "c3", "c4"], l) 642 self.assertEqual(["c1", "c2", "cA", "cB", "c3", "c4"], 643 [ c.text for c in root.c ]) 644 self.assertEqual(l, 645 [ c.text for c in root.c ])

646

647 - def test_setslice_empty(self):

648 Element = self.Element 649 root = Element("root") 650 651 root.c = [] 652 self.assertRaises( 653 AttributeError, getattr, root, 'c')

654

655 - def test_setslice_partial_wrong_length(self):

656 Element = self.Element 657 root = Element("root") 658 l = ["c1", "c2", "c3", "c4"] 659 root.c = l 660 661 self.assertEqual(["c1", "c2", "c3", "c4"], 662 [ c.text for c in root.c ]) 663 self.assertEqual(l, 664 [ c.text for c in root.c ]) 665 666 new_slice = ["cA", "cB", "cC"] 667 self.assertRaises( 668 ValueError, operator.setitem, 669 l, slice(1,2,-1), new_slice) 670 self.assertRaises( 671 ValueError, operator.setitem, 672 root.c, slice(1,2,-1), new_slice)

673

674 - def test_setslice_partial_neg(self):

675 Element = self.Element 676 root = Element("root") 677 l = ["c1", "c2", "c3", "c4"] 678 root.c = l 679 680 self.assertEqual(["c1", "c2", "c3", "c4"], 681 [ c.text for c in root.c ]) 682 self.assertEqual(l, 683 [ c.text for c in root.c ]) 684 685 new_slice = ["cA", "cB"] 686 l[-1:1:-1] = new_slice 687 root.c[-1:1:-1] = new_slice 688 689 self.assertEqual(["c1", "c2", "cB", "cA"], l) 690 self.assertEqual(["c1", "c2", "cB", "cA"], 691 [ c.text for c in root.c ]) 692 self.assertEqual(l, 693 [ c.text for c in root.c ])

694

695 - def test_setslice_partial_allneg(self):

696 Element = self.Element 697 root = Element("root") 698 l = ["c1", "c2", "c3", "c4"] 699 root.c = l 700 701 self.assertEqual(["c1", "c2", "c3", "c4"], 702 [ c.text for c in root.c ]) 703 self.assertEqual(l, 704 [ c.text for c in root.c ]) 705 706 new_slice = ["cA", "cB"] 707 l[-1:-4:-2] = new_slice 708 root.c[-1:-4:-2] = new_slice 709 710 self.assertEqual(["c1", "cB", "c3", "cA"], l) 711 self.assertEqual(["c1", "cB", "c3", "cA"], 712 [ c.text for c in root.c ]) 713 self.assertEqual(l, 714 [ c.text for c in root.c ])

715 716 # other stuff 717

718 - def test_setitem_index(self):

719 Element = self.Element 720 root = Element("root") 721 root['child'] = ['CHILD1', 'CHILD2'] 722 self.assertEqual(["CHILD1", "CHILD2"], 723 [ c.text for c in root.child ]) 724 725 self.assertRaises(IndexError, operator.setitem, root.child, -3, 'oob') 726 self.assertRaises(IndexError, operator.setitem, root.child, -300, 'oob') 727 self.assertRaises(IndexError, operator.setitem, root.child, 2, 'oob') 728 self.assertRaises(IndexError, operator.setitem, root.child, 200, 'oob') 729 730 root.child[0] = "child0" 731 root.child[-1] = "child-1" 732 self.assertEqual(["child0", "child-1"], 733 [ c.text for c in root.child ]) 734 735 root.child[1] = "child1" 736 root.child[-2] = "child-2" 737 self.assertEqual(["child-2", "child1"], 738 [ c.text for c in root.child ])

739

740 - def test_delitem_index(self):

741 # make sure strings are set as children 742 Element = self.Element 743 root = Element("root") 744 root['child'] = ['CHILD1', 'CHILD2', 'CHILD3', 'CHILD4'] 745 self.assertEqual(["CHILD1", "CHILD2", "CHILD3", "CHILD4"], 746 [ c.text for c in root.child ]) 747 748 del root.child[-1] 749 self.assertEqual(["CHILD1", "CHILD2", "CHILD3"], 750 [ c.text for c in root.child ]) 751 del root.child[-2] 752 self.assertEqual(["CHILD1", "CHILD3"], 753 [ c.text for c in root.child ]) 754 del root.child[0] 755 self.assertEqual(["CHILD3"], 756 [ c.text for c in root.child ]) 757 del root.child[-1] 758 self.assertRaises(AttributeError, getattr, root, 'child')

759

760 - def test_set_string(self):

761 # make sure strings are not handled as sequences 762 Element = self.Element 763 root = Element("root") 764 root.c = "TEST" 765 self.assertEqual(["TEST"], 766 [ c.text for c in root.c ])

767

768 - def test_setitem_string(self):

769 # make sure strings are set as children 770 Element = self.Element 771 root = Element("root") 772 root["c"] = "TEST" 773 self.assertEqual(["TEST"], 774 [ c.text for c in root.c ])

775

776 - def test_setitem_string_special(self):

777 # make sure 'text' etc. are set as children 778 Element = self.Element 779 root = Element("root") 780 781 root["text"] = "TEST" 782 self.assertEqual(["TEST"], 783 [ c.text for c in root["text"] ]) 784 785 root["tail"] = "TEST" 786 self.assertEqual(["TEST"], 787 [ c.text for c in root["tail"] ]) 788 789 root["pyval"] = "TEST" 790 self.assertEqual(["TEST"], 791 [ c.text for c in root["pyval"] ]) 792 793 root["tag"] = "TEST" 794 self.assertEqual(["TEST"], 795 [ c.text for c in root["tag"] ])

796

797 - def test_findall(self):

798 XML = self.XML 799 root = XML('<a><c/><c></c></a>') 800 self.assertEqual(1, len(root.findall("c"))) 801 self.assertEqual(2, len(root.findall(".//c"))) 802 self.assertEqual(3, len(root.findall(".//b"))) 803 self.assertTrue(root.findall(".//b")[1] is root.getchildren()[1])

804

805 - def test_findall_ns(self):

806 XML = self.XML 807 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>') 808 self.assertEqual(2, len(root.findall(".//{X}b"))) 809 self.assertEqual(3, len(root.findall(".//b"))) 810 self.assertEqual(2, len(root.findall("b")))

811

812 - def test_build_tree(self):

813 root = self.Element('root') 814 root.a = 5 815 root.b = 6 816 self.assertTrue(isinstance(root, objectify.ObjectifiedElement)) 817 self.assertTrue(isinstance(root.a, objectify.IntElement)) 818 self.assertTrue(isinstance(root.b, objectify.IntElement))

819

820 - def test_type_NoneType(self):

821 Element = self.Element 822 SubElement = self.etree.SubElement 823 824 nil_attr = XML_SCHEMA_NIL_ATTR 825 root = Element("{objectified}root") 826 SubElement(root, "{objectified}none") 827 SubElement(root, "{objectified}none", {nil_attr : "true"}) 828 self.assertFalse(isinstance(root.none, objectify.NoneElement)) 829 self.assertFalse(isinstance(root.none[0], objectify.NoneElement)) 830 self.assertTrue(isinstance(root.none[1], objectify.NoneElement)) 831 self.assertEqual(hash(root.none[1]), hash(None)) 832 self.assertEqual(root.none[1], None) 833 self.assertFalse(root.none[1])

834

835 - def test_data_element_NoneType(self):

836 value = objectify.DataElement(None) 837 self.assertTrue(isinstance(value, objectify.NoneElement)) 838 self.assertEqual(value, None) 839 self.assertEqual(value.get(XML_SCHEMA_NIL_ATTR), "true")

840

841 - def test_type_bool(self):

842 Element = self.Element 843 SubElement = self.etree.SubElement 844 root = Element("{objectified}root") 845 root.bool = True 846 self.assertEqual(root.bool, True) 847 self.assertEqual(root.bool + root.bool, True + True) 848 self.assertEqual(True + root.bool, True + root.bool) 849 self.assertEqual(root.bool * root.bool, True * True) 850 self.assertEqual(int(root.bool), int(True)) 851 self.assertEqual(hash(root.bool), hash(True)) 852 self.assertEqual(complex(root.bool), complex(True)) 853 self.assertTrue(isinstance(root.bool, objectify.BoolElement)) 854 855 root.bool = False 856 self.assertEqual(root.bool, False) 857 self.assertEqual(root.bool + root.bool, False + False) 858 self.assertEqual(False + root.bool, False + root.bool) 859 self.assertEqual(root.bool * root.bool, False * False) 860 self.assertEqual(int(root.bool), int(False)) 861 self.assertEqual(hash(root.bool), hash(False)) 862 self.assertEqual(complex(root.bool), complex(False)) 863 self.assertTrue(isinstance(root.bool, objectify.BoolElement))

864

865 - def test_data_element_bool(self):

866 value = objectify.DataElement(True) 867 self.assertTrue(isinstance(value, objectify.BoolElement)) 868 self.assertEqual(value, True) 869 870 value = objectify.DataElement(False) 871 self.assertTrue(isinstance(value, objectify.BoolElement)) 872 self.assertEqual(value, False)

873

874 - def test_type_str(self):

875 Element = self.Element 876 SubElement = self.etree.SubElement 877 root = Element("{objectified}root") 878 root.s = "test" 879 self.assertTrue(isinstance(root.s, objectify.StringElement))

880

881 - def test_type_str_intliteral(self):

882 Element = self.Element 883 SubElement = self.etree.SubElement 884 root = Element("{objectified}root") 885 root.s = "3" 886 self.assertTrue(isinstance(root.s, objectify.StringElement))

887

888 - def test_type_str_floatliteral(self):

889 Element = self.Element 890 SubElement = self.etree.SubElement 891 root = Element("{objectified}root") 892 root.s = "3.72" 893 self.assertTrue(isinstance(root.s, objectify.StringElement))

894

895 - def test_type_str_mul(self):

896 Element = self.Element 897 SubElement = self.etree.SubElement 898 root = Element("{objectified}root") 899 root.s = "test" 900 901 self.assertEqual("test" * 5, root.s * 5) 902 self.assertEqual(5 * "test", 5 * root.s) 903 904 self.assertRaises(TypeError, operator.mul, root.s, "honk") 905 self.assertRaises(TypeError, operator.mul, "honk", root.s)

906

907 - def test_type_str_add(self):

908 Element = self.Element 909 SubElement = self.etree.SubElement 910 root = Element("{objectified}root") 911 root.s = "test" 912 913 s = "toast" 914 self.assertEqual("test" + s, root.s + s) 915 self.assertEqual(s + "test", s + root.s)

916

917 - def test_type_str_mod(self):

918 s = "%d %f %s %r" 919 el = objectify.DataElement(s) 920 values = (1, 7.0, "abcd", None) 921 self.assertEqual(s % values, el % values) 922 923 s = "%d" 924 el = objectify.DataElement(s) 925 val = 5 926 self.assertEqual(s % val, el % val) 927 928 s = "%d %s" 929 el = objectify.DataElement(s) 930 val = 5 931 self.assertRaises(TypeError, el.__mod__, val) 932 933 s = "" 934 el = objectify.DataElement(s) 935 val = 5 936 self.assertRaises(TypeError, el.__mod__, val)

937

938 - def test_type_str_hash(self):

939 v = "1" 940 el = objectify.DataElement(v) 941 self.assertEqual(hash(el), hash("1"))

942

943 - def test_type_str_as_int(self):

944 v = "1" 945 el = objectify.DataElement(v) 946 self.assertEqual(int(el), 1)

947

948 - def test_type_str_as_float(self):

949 v = "1" 950 el = objectify.DataElement(v) 951 self.assertEqual(float(el), 1)

952

953 - def test_type_str_as_complex(self):

954 v = "1" 955 el = objectify.DataElement(v) 956 self.assertEqual(complex(el), 1)

957

958 - def test_type_str_mod_data_elements(self):

959 s = "%d %f %s %r" 960 el = objectify.DataElement(s) 961 values = (objectify.DataElement(1), 962 objectify.DataElement(7.0), 963 objectify.DataElement("abcd"), 964 objectify.DataElement(None)) 965 self.assertEqual(s % values, el % values)

966

967 - def test_data_element_str(self):

968 value = objectify.DataElement("test") 969 self.assertTrue(isinstance(value, objectify.StringElement)) 970 self.assertEqual(value, "test")

971

972 - def test_data_element_str_intliteral(self):

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

976

977 - def test_data_element_str_floatliteral(self):

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

981

982 - def test_type_ustr(self):

983 Element = self.Element 984 SubElement = self.etree.SubElement 985 root = Element("{objectified}root") 986 root.s = _str("test") 987 self.assertTrue(isinstance(root.s, objectify.StringElement))

988

989 - def test_type_ustr_intliteral(self):

990 Element = self.Element 991 SubElement = self.etree.SubElement 992 root = Element("{objectified}root") 993 root.s = _str("3") 994 self.assertTrue(isinstance(root.s, objectify.StringElement))

995

996 - def test_type_ustr_floatliteral(self):

997 Element = self.Element 998 SubElement = self.etree.SubElement 999 root = Element("{objectified}root") 1000 root.s = _str("3.72") 1001 self.assertTrue(isinstance(root.s, objectify.StringElement))

1002

1003 - def test_type_ustr_mul(self):

1004 Element = self.Element 1005 SubElement = self.etree.SubElement 1006 root = Element("{objectified}root") 1007 root.s = _str("test") 1008 1009 self.assertEqual(_str("test") * 5, root.s * 5) 1010 self.assertEqual(5 * _str("test"), 5 * root.s) 1011 1012 self.assertRaises(TypeError, operator.mul, root.s, _str("honk")) 1013 self.assertRaises(TypeError, operator.mul, _str("honk"), root.s)

1014

1015 - def test_type_ustr_add(self):

1016 Element = self.Element 1017 SubElement = self.etree.SubElement 1018 root = Element("{objectified}root") 1019 root.s = _str("test") 1020 1021 s = _str("toast") 1022 self.assertEqual(_str("test") + s, root.s + s) 1023 self.assertEqual(s + _str("test"), s + root.s)

1024

1025 - def test_data_element_ustr(self):

1026 value = objectify.DataElement(_str("test")) 1027 self.assertTrue(isinstance(value, objectify.StringElement)) 1028 self.assertEqual(value, _str("test"))

1029

1030 - def test_data_element_ustr_intliteral(self):

1031 value = objectify.DataElement("3") 1032 self.assertTrue(isinstance(value, objectify.StringElement)) 1033 self.assertEqual(value, _str("3"))

1034

1035 - def test_data_element_ustr_floatliteral(self):

1036 value = objectify.DataElement(_str("3.20")) 1037 self.assertTrue(isinstance(value, objectify.StringElement)) 1038 self.assertEqual(value, _str("3.20"))

1039

1040 - def test_type_int(self):

1041 Element = self.Element 1042 root = Element("{objectified}root") 1043 root.none = 5 1044 self.assertTrue(isinstance(root.none, objectify.IntElement)) 1045 self.assertEqual(5, root.none.__index__())

1046

1047 - def test_data_element_int(self):

1048 value = objectify.DataElement(5) 1049 self.assertTrue(isinstance(value, objectify.IntElement)) 1050 self.assertEqual(value, 5)

1051

1052 - def test_data_element_int_hash(self):

1053 value = objectify.DataElement(123) 1054 self.assertEqual(hash(value), hash(123))

1055

1056 - def test_type_float(self):

1057 Element = self.Element 1058 SubElement = self.etree.SubElement 1059 root = Element("{objectified}root") 1060 root.none = 5.5 1061 self.assertTrue(isinstance(root.none, objectify.FloatElement))

1062

1063 - def test_data_element_float(self):

1064 value = objectify.DataElement(5.5) 1065 self.assertTrue(isinstance(value, objectify.FloatElement)) 1066 self.assertEqual(value, 5.5)

1067

1068 - def test_data_element_float_hash(self):

1069 value = objectify.DataElement(5.5) 1070 self.assertEqual(hash(value), hash(5.5))

1071

1072 - def test_type_float_precision(self):

1073 # test not losing precision by shortened float str() value 1074 # repr(2.305064300557): '2.305064300557' 1075 # str(2.305064300557): '2.30506430056' 1076 # "%57.54f" % 2.305064300557: 1077 # ' 2.305064300556999956626214043353684246540069580078125000' 1078 Element = self.Element 1079 root = Element("{objectified}root") 1080 s = "2.305064300557" 1081 root.f = float(s) 1082 self.assertTrue(isinstance(root.f, objectify.FloatElement)) 1083 self.assertEqual(root.f.text, s) 1084 self.assertEqual(root.f.pyval, float(s))

1085

1086 - def test_type_float_instantiation_precision(self):

1087 # test precision preservation for FloatElement instantiation 1088 s = "2.305064300557" 1089 self.assertEqual(objectify.FloatElement(s), float(s))

1090

1091 - def test_type_float_precision_consistency(self):

1092 # test consistent FloatElement values for the different instantiation 1093 # possibilities 1094 Element = self.Element 1095 root = Element("{objectified}root") 1096 s = "2.305064300557" 1097 f = float(s) 1098 float_elem = objectify.FloatElement(s) 1099 float_data_elem = objectify.DataElement(f) 1100 root.float_child = float(f) 1101 self.assertTrue(f == float_elem == float_data_elem == root.float_child)

1102

1103 - def test_data_element_float_precision(self):

1104 # test not losing precision by shortened float str() value 1105 f = 2305064300557.0 1106 value = objectify.DataElement(f) 1107 self.assertTrue(isinstance(value, objectify.FloatElement)) 1108 self.assertEqual(value, f)

1109

1110 - def test_data_element_float_hash_repr(self):

1111 # test not losing precision by shortened float str() value 1112 f = 2305064300557.0 1113 value = objectify.DataElement(f) 1114 self.assertEqual(hash(value), hash(f))

1115

1116 - def test_data_element_xsitypes(self):

1117 for xsi, objclass in xsitype2objclass.items(): 1118 # 1 is a valid value for all ObjectifiedDataElement classes 1119 pyval = 1 1120 value = objectify.DataElement(pyval, _xsi=xsi) 1121 self.assertTrue(isinstance(value, objclass), 1122 "DataElement(%s, _xsi='%s') returns %s, expected %s" 1123 % (pyval, xsi, type(value), objclass))

1124

1125 - def test_data_element_xsitypes_xsdprefixed(self):

1126 for xsi, objclass in xsitype2objclass.items(): 1127 # 1 is a valid value for all ObjectifiedDataElement classes 1128 pyval = 1 1129 value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi) 1130 self.assertTrue(isinstance(value, objclass), 1131 "DataElement(%s, _xsi='%s') returns %s, expected %s" 1132 % (pyval, xsi, type(value), objclass))

1133

1134 - def test_data_element_xsitypes_prefixed(self):

1135 for xsi, objclass in xsitype2objclass.items(): 1136 # 1 is a valid value for all ObjectifiedDataElement classes 1137 self.assertRaises(ValueError, objectify.DataElement, 1, 1138 _xsi="foo:%s" % xsi)

1139

1140 - def test_data_element_pytypes(self):

1141 for pytype, objclass in pytype2objclass.items(): 1142 # 1 is a valid value for all ObjectifiedDataElement classes 1143 pyval = 1 1144 value = objectify.DataElement(pyval, _pytype=pytype) 1145 self.assertTrue(isinstance(value, objclass), 1146 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1147 % (pyval, pytype, type(value), objclass))

1148

1149 - def test_data_element_pytype_none(self):

1150 pyval = 1 1151 pytype = "NoneType" 1152 objclass = objectify.NoneElement 1153 value = objectify.DataElement(pyval, _pytype=pytype) 1154 self.assertTrue(isinstance(value, objclass), 1155 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1156 % (pyval, pytype, type(value), objclass)) 1157 self.assertEqual(value.text, None) 1158 self.assertEqual(value.pyval, None)

1159

1160 - def test_data_element_pytype_none_compat(self):

1161 # pre-2.0 lxml called NoneElement "none" 1162 pyval = 1 1163 pytype = "none" 1164 objclass = objectify.NoneElement 1165 value = objectify.DataElement(pyval, _pytype=pytype) 1166 self.assertTrue(isinstance(value, objclass), 1167 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1168 % (pyval, pytype, type(value), objclass)) 1169 self.assertEqual(value.text, None) 1170 self.assertEqual(value.pyval, None)

1171

1172 - def test_type_unregistered(self):

1173 Element = self.Element 1174 SubElement = self.etree.SubElement 1175 class MyFloat(float): 1176 pass

1177 root = Element("{objectified}root") 1178 root.myfloat = MyFloat(5.5) 1179 self.assertTrue(isinstance(root.myfloat, objectify.FloatElement)) 1180 self.assertEqual(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None)

1181

1182 - def test_data_element_unregistered(self):

1183 class MyFloat(float): 1184 pass

1185 value = objectify.DataElement(MyFloat(5.5)) 1186 self.assertTrue(isinstance(value, objectify.FloatElement)) 1187 self.assertEqual(value, 5.5) 1188 self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), None) 1189

1190 - def test_schema_types(self):

1191 XML = self.XML 1192 root = XML('''\ 1193 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1194 true 1195 false 1196 1 1197 0 1198 1199 <f xsi:type="float">5</f> 1200 <f xsi:type="double">5</f> 1201 1202 <s xsi:type="string">5</s> 1203 <s xsi:type="normalizedString">5</s> 1204 <s xsi:type="token">5</s> 1205 <s xsi:type="language">5</s> 1206 <s xsi:type="Name">5</s> 1207 <s xsi:type="NCName">5</s> 1208 <s xsi:type="ID">5</s> 1209 <s xsi:type="IDREF">5</s> 1210 <s xsi:type="ENTITY">5</s> 1211 <s xsi:type="NMTOKEN">5</s> 1212 1213 <l xsi:type="integer">5</l> 1214 <l xsi:type="nonPositiveInteger">5</l> 1215 <l xsi:type="negativeInteger">5</l> 1216 <l xsi:type="long">5</l> 1217 <l xsi:type="nonNegativeInteger">5</l> 1218 <l xsi:type="unsignedLong">5</l> 1219 <l xsi:type="unsignedInt">5</l> 1220 <l xsi:type="positiveInteger">5</l> 1221 1222 5 1223 5 1224 5 1225 5 1226 5 1227 1228 <n xsi:nil="true"/> 1229 </root> 1230 ''') 1231 1232 for b in root.b: 1233 self.assertTrue(isinstance(b, objectify.BoolElement)) 1234 self.assertEqual(True, root.b[0]) 1235 self.assertEqual(False, root.b[1]) 1236 self.assertEqual(True, root.b[2]) 1237 self.assertEqual(False, root.b[3]) 1238 1239 for f in root.f: 1240 self.assertTrue(isinstance(f, objectify.FloatElement)) 1241 self.assertEqual(5, f) 1242 1243 for s in root.s: 1244 self.assertTrue(isinstance(s, objectify.StringElement)) 1245 self.assertEqual("5", s) 1246 1247 for i in root.i: 1248 self.assertTrue(isinstance(i, objectify.IntElement)) 1249 self.assertEqual(5, i) 1250 1251 for l in root.l: 1252 self.assertTrue(isinstance(l, objectify.IntElement)) 1253 self.assertEqual(5, i) 1254 1255 self.assertTrue(isinstance(root.n, objectify.NoneElement)) 1256 self.assertEqual(None, root.n)

1257

1258 - def test_schema_types_prefixed(self):

1259 XML = self.XML 1260 root = XML('''\ 1261 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1262 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1263 true 1264 false 1265 1 1266 0 1267 1268 <f xsi:type="xsd:float">5</f> 1269 <f xsi:type="xsd:double">5</f> 1270 1271 <s xsi:type="xsd:string">5</s> 1272 <s xsi:type="xsd:normalizedString">5</s> 1273 <s xsi:type="xsd:token">5</s> 1274 <s xsi:type="xsd:language">5</s> 1275 <s xsi:type="xsd:Name">5</s> 1276 <s xsi:type="xsd:NCName">5</s> 1277 <s xsi:type="xsd:ID">5</s> 1278 <s xsi:type="xsd:IDREF">5</s> 1279 <s xsi:type="xsd:ENTITY">5</s> 1280 <s xsi:type="xsd:NMTOKEN">5</s> 1281 1282 <l xsi:type="xsd:integer">5</l> 1283 <l xsi:type="xsd:nonPositiveInteger">5</l> 1284 <l xsi:type="xsd:negativeInteger">5</l> 1285 <l xsi:type="xsd:long">5</l> 1286 <l xsi:type="xsd:nonNegativeInteger">5</l> 1287 <l xsi:type="xsd:unsignedLong">5</l> 1288 <l xsi:type="xsd:unsignedInt">5</l> 1289 <l xsi:type="xsd:positiveInteger">5</l> 1290 1291 5 1292 5 1293 5 1294 5 1295 5 1296 1297 <n xsi:nil="true"/> 1298 </root> 1299 ''') 1300 1301 for b in root.b: 1302 self.assertTrue(isinstance(b, objectify.BoolElement)) 1303 self.assertEqual(True, root.b[0]) 1304 self.assertEqual(False, root.b[1]) 1305 self.assertEqual(True, root.b[2]) 1306 self.assertEqual(False, root.b[3]) 1307 1308 for f in root.f: 1309 self.assertTrue(isinstance(f, objectify.FloatElement)) 1310 self.assertEqual(5, f) 1311 1312 for s in root.s: 1313 self.assertTrue(isinstance(s, objectify.StringElement)) 1314 self.assertEqual("5", s) 1315 1316 for i in root.i: 1317 self.assertTrue(isinstance(i, objectify.IntElement)) 1318 self.assertEqual(5, i) 1319 1320 for l in root.l: 1321 self.assertTrue(isinstance(l, objectify.IntElement)) 1322 self.assertEqual(5, l) 1323 1324 self.assertTrue(isinstance(root.n, objectify.NoneElement)) 1325 self.assertEqual(None, root.n)

1326

1327 - def test_type_str_sequence(self):

1328 XML = self.XML 1329 root = XML(_bytes('<root>whytry</root>')) 1330 strs = [ str(s) for s in root.b ] 1331 self.assertEqual(["why", "try"], 1332 strs)

1333

1334 - def test_type_str_cmp(self):

1335 XML = self.XML 1336 root = XML(_bytes('<root>testtaste</root>')) 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.assertTrue(root.b[0] != root.b[1]) 1342 self.assertTrue(root.b[0] >= root.b[1]) 1343 self.assertTrue(root.b[0] > root.b[1]) 1344 1345 self.assertEqual(root.b[0], "test") 1346 self.assertEqual("test", root.b[0]) 1347 1348 self.assertEqual("", root.b[2]) 1349 self.assertEqual(root.b[2], "") 1350 self.assertEqual("", root.b[3]) 1351 self.assertEqual(root.b[3], "") 1352 self.assertEqual(root.b[2], root.b[3]) 1353 1354 root.b = "test" 1355 self.assertTrue(root.b) 1356 root.b = "" 1357 self.assertFalse(root.b) 1358 self.assertEqual(root.b, "") 1359 self.assertEqual("", root.b)

1360

1361 - def test_type_int_cmp(self):

1362 XML = self.XML 1363 root = XML(_bytes('<root>56</root>')) 1364 self.assertTrue(root.b[0] < root.b[1]) 1365 self.assertTrue(root.b[0] <= root.b[1]) 1366 self.assertTrue(root.b[0] != root.b[1]) 1367 1368 self.assertFalse(root.b[0] == root.b[1]) 1369 self.assertFalse(root.b[0] >= root.b[1]) 1370 self.assertFalse(root.b[0] > root.b[1]) 1371 1372 self.assertEqual(root.b[0], 5) 1373 self.assertEqual(5, root.b[0]) 1374 self.assertNotEqual(root.b[0], "5") 1375 1376 root.b = 5 1377 self.assertTrue(root.b) 1378 root.b = 0 1379 self.assertFalse(root.b)

1380 1381 # float + long share the NumberElement implementation with int 1382

1383 - def test_type_bool_cmp(self):

1384 XML = self.XML 1385 root = XML(_bytes('<root>falsetrue</root>')) 1386 self.assertTrue(root.b[0] < root.b[1]) 1387 self.assertTrue(root.b[0] <= root.b[1]) 1388 self.assertTrue(root.b[0] != root.b[1]) 1389 1390 self.assertFalse(root.b[0] == root.b[1]) 1391 self.assertFalse(root.b[0] >= root.b[1]) 1392 self.assertFalse(root.b[0] > root.b[1]) 1393 1394 self.assertFalse(root.b[0]) 1395 self.assertTrue(root.b[1]) 1396 1397 self.assertEqual(root.b[0], False) 1398 self.assertEqual(False, root.b[0]) 1399 self.assertTrue(root.b[0] < 5) 1400 self.assertTrue(5 > root.b[0]) 1401 1402 root.b = True 1403 self.assertTrue(root.b) 1404 root.b = False 1405 self.assertFalse(root.b)

1406

1407 - def test_type_none_cmp(self):

1408 XML = self.XML 1409 root = XML(_bytes(""" 1410 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1411  1412 </root>""")) 1413 self.assertTrue(root.b[0] == root.b[1]) 1414 self.assertFalse(root.b[0]) 1415 self.assertEqual(root.b[0], None) 1416 self.assertEqual(None, root.b[0])

1417 1418 # doesn't work in Py3: 1419 1420 #for comparison in ["abc", 5, 7.3, True, [], ()]: 1421 # none = root.b[1] 1422 # self.assertTrue(none < comparison, "%s (%s) should be < %s" % 1423 # (none, type(none), comparison) ) 1424 # self.assertTrue(comparison > none, "%s should be > %s (%s)" % 1425 # (comparison, none, type(none)) ) 1426

1427 - def test_dataelement_xsi(self):

1428 el = objectify.DataElement(1, _xsi="string") 1429 self.assertEqual( 1430 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1431 'xsd:string')

1432

1433 - def test_dataelement_xsi_nsmap(self):

1434 el = objectify.DataElement(1, _xsi="string", 1435 nsmap={'schema': XML_SCHEMA_NS}) 1436 self.assertEqual( 1437 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1438 'schema:string')

1439

1440 - def test_dataelement_xsi_prefix_error(self):

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

1443

1444 - def test_pytype_annotation(self):

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

1485

1486 - def test_pytype_annotation_empty(self):

1487 XML = self.XML 1488 root = XML(_bytes('''\ 1489 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1490 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1491 <n></n> 1492 </a> 1493 ''')) 1494 objectify.annotate(root) 1495 1496 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1497 for c in root.iterchildren() ] 1498 self.assertEqual(None, child_types[0]) 1499 1500 objectify.annotate(root, empty_pytype="str") 1501 1502 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1503 for c in root.iterchildren() ] 1504 self.assertEqual("str", child_types[0])

1505

1506 - def test_pytype_annotation_use_old(self):

1507 XML = self.XML 1508 root = XML(_bytes('''\ 1509 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1510 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1511 5 1512 test 1513 <c>1.1</c> 1514 <c>\uF8D2</c> 1515 <x>true</x> 1516 <n xsi:nil="true" /> 1517 <n></n> 1518 5 1519 5 1520 <s xsi:type="string">23</s> 1521 <s py:pytype="str">42</s> 1522 <f py:pytype="float">300</f> 1523 <l py:pytype="long">2</l> 1524 <t py:pytype="TREE"></t> 1525 </a> 1526 ''')) 1527 objectify.annotate(root, ignore_old=False) 1528 1529 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1530 for c in root.iterchildren() ] 1531 self.assertEqual("int", child_types[ 0]) 1532 self.assertEqual("str", child_types[ 1]) 1533 self.assertEqual("float", child_types[ 2]) 1534 self.assertEqual("str", child_types[ 3]) 1535 self.assertEqual("bool", child_types[ 4]) 1536 self.assertEqual("NoneType", child_types[ 5]) 1537 self.assertEqual(None, child_types[ 6]) 1538 self.assertEqual("float", child_types[ 7]) 1539 self.assertEqual("float", child_types[ 8]) 1540 self.assertEqual("str", child_types[ 9]) 1541 self.assertEqual("str", child_types[10]) 1542 self.assertEqual("float", child_types[11]) 1543 self.assertEqual("int", child_types[12]) 1544 self.assertEqual(TREE_PYTYPE, child_types[13]) 1545 1546 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1547

1548 - def test_pytype_xsitype_annotation(self):

1549 XML = self.XML 1550 root = XML(_bytes('''\ 1551 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1552 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1553 5 1554 test 1555 <c>1.1</c> 1556 <c>\uF8D2</c> 1557 <x>true</x> 1558 <n xsi:nil="true" /> 1559 <n></n> 1560 5 1561 5 1562 <s xsi:type="string">23</s> 1563 <s py:pytype="str">42</s> 1564 <f py:pytype="float">300</f> 1565 <l py:pytype="long">2</l> 1566 <t py:pytype="TREE"></t> 1567 </a> 1568 ''')) 1569 objectify.annotate(root, ignore_old=False, ignore_xsi=False, 1570 annotate_xsi=1, annotate_pytype=1) 1571 1572 # check py annotations 1573 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1574 for c in root.iterchildren() ] 1575 self.assertEqual("int", child_types[ 0]) 1576 self.assertEqual("str", child_types[ 1]) 1577 self.assertEqual("float", child_types[ 2]) 1578 self.assertEqual("str", child_types[ 3]) 1579 self.assertEqual("bool", child_types[ 4]) 1580 self.assertEqual("NoneType", child_types[ 5]) 1581 self.assertEqual(None, child_types[ 6]) 1582 self.assertEqual("float", child_types[ 7]) 1583 self.assertEqual("float", child_types[ 8]) 1584 self.assertEqual("str", child_types[ 9]) 1585 self.assertEqual("str", child_types[10]) 1586 self.assertEqual("float", child_types[11]) 1587 self.assertEqual("int", child_types[12]) 1588 self.assertEqual(TREE_PYTYPE, child_types[13]) 1589 1590 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1591 1592 child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1593 for c in root.iterchildren() ] 1594 1595 # check xsi annotations 1596 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1597 for c in root.iterchildren() ] 1598 self.assertEqual("xsd:integer", child_types[ 0]) 1599 self.assertEqual("xsd:string", child_types[ 1]) 1600 self.assertEqual("xsd:double", child_types[ 2]) 1601 self.assertEqual("xsd:string", child_types[ 3]) 1602 self.assertEqual("xsd:boolean", child_types[ 4]) 1603 self.assertEqual(None, child_types[ 5]) 1604 self.assertEqual(None, child_types[ 6]) 1605 self.assertEqual("xsd:double", child_types[ 7]) 1606 self.assertEqual("xsd:float", child_types[ 8]) 1607 self.assertEqual("xsd:string", child_types[ 9]) 1608 self.assertEqual("xsd:string", child_types[10]) 1609 self.assertEqual("xsd:double", child_types[11]) 1610 self.assertEqual("xsd:integer", child_types[12]) 1611 self.assertEqual(None, child_types[13]) 1612 1613 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1614

1615 - def test_xsiannotate_use_old(self):

1616 XML = self.XML 1617 root = XML(_bytes('''\ 1618 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1619 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1620 5 1621 test 1622 <c>1.1</c> 1623 <c>\uF8D2</c> 1624 <x>true</x> 1625 <n xsi:nil="true" /> 1626 <n></n> 1627 5 1628 5 1629 <s xsi:type="string">23</s> 1630 <s py:pytype="str">42</s> 1631 <f py:pytype="float">300</f> 1632 <l py:pytype="long">2</l> 1633 <t py:pytype="TREE"></t> 1634 </a> 1635 ''')) 1636 objectify.xsiannotate(root, ignore_old=False) 1637 1638 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1639 for c in root.iterchildren() ] 1640 self.assertEqual("xsd:integer", child_types[ 0]) 1641 self.assertEqual("xsd:string", child_types[ 1]) 1642 self.assertEqual("xsd:double", child_types[ 2]) 1643 self.assertEqual("xsd:string", child_types[ 3]) 1644 self.assertEqual("xsd:boolean", child_types[ 4]) 1645 self.assertEqual(None, child_types[ 5]) 1646 self.assertEqual(None, child_types[ 6]) 1647 self.assertEqual("xsd:double", child_types[ 7]) 1648 self.assertEqual("xsd:float", child_types[ 8]) 1649 self.assertEqual("xsd:string", child_types[ 9]) 1650 self.assertEqual("xsd:string", child_types[10]) 1651 self.assertEqual("xsd:double", child_types[11]) 1652 self.assertEqual("xsd:integer", child_types[12]) 1653 self.assertEqual(None, child_types[13])

1654

1655 - def test_pyannotate_ignore_old(self):

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

1696

1697 - def test_pyannotate_empty(self):

1698 XML = self.XML 1699 root = XML('''\ 1700 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1701 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1702 <n></n> 1703 </a> 1704 ''') 1705 objectify.pyannotate(root) 1706 1707 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1708 for c in root.iterchildren() ] 1709 self.assertEqual(None, child_types[0]) 1710 1711 objectify.annotate(root, empty_pytype="str") 1712 1713 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1714 for c in root.iterchildren() ] 1715 self.assertEqual("str", child_types[0])

1716

1717 - def test_pyannotate_use_old(self):

1718 XML = self.XML 1719 root = XML('''\ 1720 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1721 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1722 5 1723 test 1724 <c>1.1</c> 1725 <c>\uF8D2</c> 1726 <x>true</x> 1727 <n xsi:nil="true" /> 1728 <n></n> 1729 5 1730 5 1731 <s xsi:type="string">23</s> 1732 <s py:pytype="str">42</s> 1733 <f py:pytype="float">300</f> 1734 <l py:pytype="long">2</l> 1735 <t py:pytype="TREE"></t> 1736 </a> 1737 ''') 1738 objectify.pyannotate(root) 1739 1740 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1741 for c in root.iterchildren() ] 1742 self.assertEqual("int", child_types[ 0]) 1743 self.assertEqual("str", child_types[ 1]) 1744 self.assertEqual("float", child_types[ 2]) 1745 self.assertEqual("str", child_types[ 3]) 1746 self.assertEqual("bool", child_types[ 4]) 1747 self.assertEqual("NoneType", child_types[ 5]) 1748 self.assertEqual(None, child_types[ 6]) 1749 self.assertEqual("float", child_types[ 7]) 1750 self.assertEqual("float", child_types[ 8]) 1751 self.assertEqual("str", child_types[ 9]) 1752 self.assertEqual("str", child_types[10]) 1753 self.assertEqual("float", child_types[11]) 1754 self.assertEqual("int", child_types[12]) 1755 self.assertEqual(TREE_PYTYPE, child_types[13]) 1756 1757 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1758

1759 - def test_xsiannotate_ignore_old(self):

1760 XML = self.XML 1761 root = XML(_bytes('''\ 1762 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1763 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1764 5 1765 test 1766 <c>1.1</c> 1767 <c>\uF8D2</c> 1768 <x>true</x> 1769 <n xsi:nil="true" /> 1770 <n></n> 1771 5 1772 5 1773 <s xsi:type="string">23</s> 1774 <s py:pytype="str">42</s> 1775 <f py:pytype="float">300</f> 1776 <l py:pytype="long">2</l> 1777 <t py:pytype="TREE"></t> 1778 </a> 1779 ''')) 1780 objectify.xsiannotate(root, ignore_old=True) 1781 1782 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1783 for c in root.iterchildren() ] 1784 self.assertEqual("xsd:integer", child_types[ 0]) 1785 self.assertEqual("xsd:string", child_types[ 1]) 1786 self.assertEqual("xsd:double", child_types[ 2]) 1787 self.assertEqual("xsd:string", child_types[ 3]) 1788 self.assertEqual("xsd:boolean", child_types[ 4]) 1789 self.assertEqual(None, child_types[ 5]) 1790 self.assertEqual(None, child_types[ 6]) 1791 self.assertEqual("xsd:integer", child_types[ 7]) 1792 self.assertEqual("xsd:integer", child_types[ 8]) 1793 self.assertEqual("xsd:integer", child_types[ 9]) 1794 self.assertEqual("xsd:string", child_types[10]) 1795 self.assertEqual("xsd:double", child_types[11]) 1796 self.assertEqual("xsd:integer", child_types[12]) 1797 self.assertEqual(None, child_types[13]) 1798 1799 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1800

1801 - def test_deannotate(self):

1802 XML = self.XML 1803 root = XML(_bytes('''\ 1804 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1805 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1806 5 1807 test 1808 <c>1.1</c> 1809 <c>\uF8D2</c> 1810 <x>true</x> 1811 <n xsi:nil="true" /> 1812 <n></n> 1813 5 1814 5 1815 <s xsi:type="string">23</s> 1816 <s py:pytype="str">42</s> 1817 <f py:pytype="float">300</f> 1818 <l py:pytype="long">2</l> 1819 <t py:pytype="TREE"></t> 1820 </a> 1821 ''')) 1822 objectify.deannotate(root) 1823 1824 for c in root.getiterator(): 1825 self.assertEqual(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 1826 self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1827 1828 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1829

1830 - def test_xsinil_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 5 1836 test 1837 <c>1.1</c> 1838 <c>\uF8D2</c> 1839 <x>true</x> 1840 <n xsi:nil="true" /> 1841 <n></n> 1842 5 1843 5 1844 <s xsi:type="string">23</s> 1845 <s py:pytype="str">42</s> 1846 <f py:pytype="float">300</f> 1847 <l py:pytype="long">2</l> 1848 <t py:pytype="TREE"></t> 1849 </a> 1850 ''')) 1851 objectify.annotate( 1852 root, ignore_old=False, ignore_xsi=False, annotate_xsi=True, 1853 empty_pytype='str', empty_type='string') 1854 objectify.deannotate(root, pytype=False, xsi=False, xsi_nil=True) 1855 1856 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1857 for c in root.iterchildren() ] 1858 self.assertEqual("xsd:integer", child_types[ 0]) 1859 self.assertEqual("xsd:string", child_types[ 1]) 1860 self.assertEqual("xsd:double", child_types[ 2]) 1861 self.assertEqual("xsd:string", child_types[ 3]) 1862 self.assertEqual("xsd:boolean", child_types[ 4]) 1863 self.assertEqual(None, child_types[ 5]) 1864 self.assertEqual("xsd:string", child_types[ 6]) 1865 self.assertEqual("xsd:double", child_types[ 7]) 1866 self.assertEqual("xsd:float", child_types[ 8]) 1867 self.assertEqual("xsd:string", child_types[ 9]) 1868 self.assertEqual("xsd:string", child_types[10]) 1869 self.assertEqual("xsd:double", child_types[11]) 1870 self.assertEqual("xsd:integer", child_types[12]) 1871 self.assertEqual(None, child_types[13]) 1872 1873 self.assertEqual(None, root.n.get(XML_SCHEMA_NIL_ATTR)) 1874 1875 for c in root.iterchildren(): 1876 self.assertNotEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1877 # these have no equivalent in xsi:type 1878 if (c.get(objectify.PYTYPE_ATTRIBUTE) not in [TREE_PYTYPE, 1879 "NoneType"]): 1880 self.assertNotEqual( 1881 None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))

1882

1883 - def test_xsitype_deannotate(self):

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

1929

1930 - def test_pytype_deannotate(self):

1931 XML = self.XML 1932 root = XML(_bytes('''\ 1933 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1934 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1935 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1936 5 1937 test 1938 <c xsi:type="xsd:float">1.1</c> 1939 <c xsi:type="xsd:string">\uF8D2</c> 1940 <x xsi:type="xsd:boolean">true</x> 1941 <n xsi:nil="true" /> 1942 <n></n> 1943 5 1944 5 1945 <s xsi:type="xsd:string">23</s> 1946 <s xsi:type="xsd:string">42</s> 1947 <f xsi:type="xsd:float">300</f> 1948 <l xsi:type="xsd:long">2</l> 1949 <t py:pytype="TREE"></t> 1950 </a> 1951 ''')) 1952 objectify.annotate(root) 1953 objectify.deannotate(root, xsi=False) 1954 1955 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1956 for c in root.iterchildren() ] 1957 self.assertEqual("xsd:int", child_types[ 0]) 1958 self.assertEqual("xsd:string", child_types[ 1]) 1959 self.assertEqual("xsd:float", child_types[ 2]) 1960 self.assertEqual("xsd:string", child_types[ 3]) 1961 self.assertEqual("xsd:boolean", child_types[ 4]) 1962 self.assertEqual(None, child_types[ 5]) 1963 self.assertEqual(None, child_types[ 6]) 1964 self.assertEqual("xsd:double", child_types[ 7]) 1965 self.assertEqual("xsd:float", child_types[ 8]) 1966 self.assertEqual("xsd:string", child_types[ 9]) 1967 self.assertEqual("xsd:string", child_types[10]) 1968 self.assertEqual("xsd:float", child_types[11]) 1969 self.assertEqual("xsd:long", child_types[12]) 1970 self.assertEqual(None, child_types[13]) 1971 1972 self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1973 1974 for c in root.getiterator(): 1975 self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE))

1976

1977 - def test_change_pytype_attribute(self):

1978 XML = self.XML 1979 1980 xml = _bytes('''\ 1981 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1982 5 1983 test 1984 <c>1.1</c> 1985 <c>\uF8D2</c> 1986 <x>true</x> 1987 <n xsi:nil="true" /> 1988 <n></n> 1989 5 1990 </a> 1991 ''') 1992 1993 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1994 objectify.set_pytype_attribute_tag("{TEST}test") 1995 1996 root = XML(xml) 1997 objectify.annotate(root) 1998 1999 attribs = root.xpath("//@py:%s" % pytype_name, 2000 namespaces={"py" : pytype_ns}) 2001 self.assertEqual(0, len(attribs)) 2002 attribs = root.xpath("//@py:test", 2003 namespaces={"py" : "TEST"}) 2004 self.assertEqual(7, len(attribs)) 2005 2006 objectify.set_pytype_attribute_tag() 2007 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 2008 2009 self.assertNotEqual("test", pytype_ns.lower()) 2010 self.assertNotEqual("test", pytype_name.lower()) 2011 2012 root = XML(xml) 2013 attribs = root.xpath("//@py:%s" % pytype_name, 2014 namespaces={"py" : pytype_ns}) 2015 self.assertEqual(0, len(attribs)) 2016 2017 objectify.annotate(root) 2018 attribs = root.xpath("//@py:%s" % pytype_name, 2019 namespaces={"py" : pytype_ns}) 2020 self.assertEqual(7, len(attribs))

2021

2022 - def test_registered_types(self):

2023 orig_types = objectify.getRegisteredTypes() 2024 orig_types[0].unregister() 2025 self.assertEqual(orig_types[1:], objectify.getRegisteredTypes()) 2026 2027 class NewType(objectify.ObjectifiedDataElement): 2028 pass

2029 2030 def checkMyType(s): 2031 return True 2032 2033 pytype = objectify.PyType("mytype", checkMyType, NewType) 2034 self.assertTrue(pytype not in objectify.getRegisteredTypes()) 2035 pytype.register() 2036 self.assertTrue(pytype in objectify.getRegisteredTypes()) 2037 pytype.unregister() 2038 self.assertTrue(pytype not in objectify.getRegisteredTypes()) 2039 2040 pytype.register(before = [objectify.getRegisteredTypes()[0].name]) 2041 self.assertEqual(pytype, objectify.getRegisteredTypes()[0]) 2042 pytype.unregister() 2043 2044 pytype.register(after = [objectify.getRegisteredTypes()[0].name]) 2045 self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0]) 2046 pytype.unregister() 2047 2048 self.assertRaises(ValueError, pytype.register, 2049 before = [objectify.getRegisteredTypes()[0].name], 2050 after = [objectify.getRegisteredTypes()[1].name]) 2051

2052 - def test_registered_type_stringify(self):

2053 from datetime import datetime 2054 def parse_date(value): 2055 if len(value) != 14: 2056 raise ValueError(value) 2057 Y = int(value[0:4]) 2058 M = int(value[4:6]) 2059 D = int(value[6:8]) 2060 h = int(value[8:10]) 2061 m = int(value[10:12]) 2062 s = int(value[12:14]) 2063 return datetime(Y, M, D, h, m, s)

2064 2065 def stringify_date(date): 2066 return date.strftime("%Y%m%d%H%M%S") 2067 2068 class DatetimeElement(objectify.ObjectifiedDataElement): 2069 def pyval(self): 2070 return parse_date(self.text) 2071 pyval = property(pyval) 2072 2073 datetime_type = objectify.PyType( 2074 "datetime", parse_date, DatetimeElement, stringify_date) 2075 datetime_type.xmlSchemaTypes = "dateTime" 2076 datetime_type.register() 2077 2078 NAMESPACE = "http://foo.net/xmlns" 2079 NAMESPACE_MAP = {'ns': NAMESPACE} 2080 2081 r = objectify.Element("{%s}root" % NAMESPACE, nsmap=NAMESPACE_MAP) 2082 time = datetime.now() 2083 r.date = time 2084 2085 self.assertTrue(isinstance(r.date, DatetimeElement)) 2086 self.assertTrue(isinstance(r.date.pyval, datetime)) 2087 2088 self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 2089 self.assertEqual(r.date.text, stringify_date(time)) 2090 2091 r.date = objectify.E.date(time) 2092 2093 self.assertTrue(isinstance(r.date, DatetimeElement)) 2094 self.assertTrue(isinstance(r.date.pyval, datetime)) 2095 2096 self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 2097 self.assertEqual(r.date.text, stringify_date(time)) 2098 2099 date = objectify.DataElement(time) 2100 2101 self.assertTrue(isinstance(date, DatetimeElement)) 2102 self.assertTrue(isinstance(date.pyval, datetime)) 2103 2104 self.assertEqual(date.pyval, parse_date(stringify_date(time))) 2105 self.assertEqual(date.text, stringify_date(time)) 2106

2107 - def test_object_path(self):

2108 root = self.XML(xml_str) 2109 path = objectify.ObjectPath( "root.c1.c2" ) 2110 self.assertEqual(root.c1.c2.text, path.find(root).text) 2111 self.assertEqual(root.c1.c2.text, path(root).text)

2112

2113 - def test_object_path_list(self):

2114 root = self.XML(xml_str) 2115 path = objectify.ObjectPath( ['root', 'c1', 'c2'] ) 2116 self.assertEqual(root.c1.c2.text, path.find(root).text) 2117 self.assertEqual(root.c1.c2.text, path(root).text)

2118

2119 - def test_object_path_fail(self):

2120 root = self.XML(xml_str) 2121 path = objectify.ObjectPath( "root.c1.c99" ) 2122 self.assertRaises(AttributeError, path, root)

2123

2124 - def test_object_path_default_absolute(self):

2125 root = self.XML(xml_str) 2126 path = objectify.ObjectPath( "root.c1.c99" ) 2127 self.assertEqual(None, path(root, None)) 2128 path = objectify.ObjectPath( "root.c99.c2" ) 2129 self.assertEqual(None, path(root, None)) 2130 path = objectify.ObjectPath( "notroot.c99.c2" ) 2131 self.assertEqual(None, path(root, None))

2132

2133 - def test_object_path_default_relative(self):

2134 root = self.XML(xml_str) 2135 path = objectify.ObjectPath( ".c1.c99" ) 2136 self.assertEqual(None, path(root, None)) 2137 path = objectify.ObjectPath( ".c99.c2" ) 2138 self.assertEqual(None, path(root, None))

2139

2140 - def test_object_path_syntax(self):

2141 root = self.XML(xml_str) 2142 path = objectify.ObjectPath("root . {objectified}c1. c2") 2143 self.assertEqual(root.c1.c2.text, path(root).text) 2144 2145 path = objectify.ObjectPath(" root.{objectified} c1.c2 [ 0 ] ") 2146 self.assertEqual(root.c1.c2.text, path(root).text)

2147

2148 - def test_object_path_fail_parse_empty(self):

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

2150

2151 - def test_object_path_fail_parse_empty_list(self):

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

2153

2154 - def test_object_path_hasattr(self):

2155 root = self.XML(xml_str) 2156 path = objectify.ObjectPath( "root" ) 2157 self.assertTrue(path.hasattr(root)) 2158 path = objectify.ObjectPath( "root.c1" ) 2159 self.assertTrue(path.hasattr(root)) 2160 path = objectify.ObjectPath( "root.c1.c2" ) 2161 self.assertTrue(path.hasattr(root)) 2162 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 2163 self.assertTrue(path.hasattr(root)) 2164 path = objectify.ObjectPath( "root.c1.c2[1]" ) 2165 self.assertTrue(path.hasattr(root)) 2166 path = objectify.ObjectPath( "root.c1.c2[2]" ) 2167 self.assertTrue(path.hasattr(root)) 2168 path = objectify.ObjectPath( "root.c1.c2[3]" ) 2169 self.assertFalse(path.hasattr(root)) 2170 path = objectify.ObjectPath( "root.c1[1].c2" ) 2171 self.assertFalse(path.hasattr(root))

2172

2173 - def test_object_path_dot(self):

2174 root = self.XML(xml_str) 2175 path = objectify.ObjectPath( "." ) 2176 self.assertEqual(root.c1.c2.text, path(root).c1.c2.text)

2177

2178 - def test_object_path_dot_list(self):

2179 root = self.XML(xml_str) 2180 path = objectify.ObjectPath( [''] ) 2181 self.assertEqual(root.c1.c2.text, path(root).c1.c2.text)

2182

2183 - def test_object_path_dot_root(self):

2184 root = self.XML(xml_str) 2185 path = objectify.ObjectPath( ".c1.c2" ) 2186 self.assertEqual(root.c1.c2.text, path(root).text)

2187

2188 - def test_object_path_dot_root_list(self):

2189 root = self.XML(xml_str) 2190 path = objectify.ObjectPath( ['', 'c1', 'c2'] ) 2191 self.assertEqual(root.c1.c2.text, path(root).text)

2192

2193 - def test_object_path_index(self):

2194 root = self.XML(xml_str) 2195 path = objectify.ObjectPath( "root.c1[0].c2[0]" ) 2196 self.assertEqual(root.c1.c2.text, path(root).text) 2197 2198 path = objectify.ObjectPath( "root.c1[0].c2" ) 2199 self.assertEqual(root.c1.c2.text, path(root).text) 2200 2201 path = objectify.ObjectPath( "root.c1[0].c2[1]" ) 2202 self.assertEqual(root.c1.c2[1].text, path(root).text) 2203 2204 path = objectify.ObjectPath( "root.c1.c2[2]" ) 2205 self.assertEqual(root.c1.c2[2].text, path(root).text) 2206 2207 path = objectify.ObjectPath( "root.c1.c2[-1]" ) 2208 self.assertEqual(root.c1.c2[-1].text, path(root).text) 2209 2210 path = objectify.ObjectPath( "root.c1.c2[-3]" ) 2211 self.assertEqual(root.c1.c2[-3].text, path(root).text)

2212

2213 - def test_object_path_index_list(self):

2214 root = self.XML(xml_str) 2215 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] ) 2216 self.assertEqual(root.c1.c2.text, path(root).text) 2217 2218 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] ) 2219 self.assertEqual(root.c1.c2[2].text, path(root).text) 2220 2221 path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] ) 2222 self.assertEqual(root.c1.c2[2].text, path(root).text) 2223 2224 path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] ) 2225 self.assertEqual(root.c1.c2[-1].text, path(root).text) 2226 2227 path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] ) 2228 self.assertEqual(root.c1.c2[-3].text, path(root).text)

2229

2230 - def test_object_path_index_fail_parse(self):

2231 self.assertRaises(ValueError, objectify.ObjectPath, 2232 "root.c1[0].c2[-1-2]") 2233 self.assertRaises(ValueError, objectify.ObjectPath, 2234 ['root', 'c1[0]', 'c2[-1-2]']) 2235 2236 self.assertRaises(ValueError, objectify.ObjectPath, 2237 "root[2].c1.c2") 2238 self.assertRaises(ValueError, objectify.ObjectPath, 2239 ['root[2]', 'c1', 'c2']) 2240 2241 self.assertRaises(ValueError, objectify.ObjectPath, 2242 []) 2243 self.assertRaises(ValueError, objectify.ObjectPath, 2244 ['', '', ''])

2245

2246 - def test_object_path_index_fail_lookup(self):

2247 root = self.XML(xml_str) 2248 path = objectify.ObjectPath("root.c1[9999].c2") 2249 self.assertRaises(AttributeError, path, root) 2250 2251 path = objectify.ObjectPath("root.c1[0].c2[9999]") 2252 self.assertRaises(AttributeError, path, root) 2253 2254 path = objectify.ObjectPath(".c1[9999].c2[0]") 2255 self.assertRaises(AttributeError, path, root) 2256 2257 path = objectify.ObjectPath("root.c1[-2].c2") 2258 self.assertRaises(AttributeError, path, root) 2259 2260 path = objectify.ObjectPath("root.c1[0].c2[-4]") 2261 self.assertRaises(AttributeError, path, root)

2262

2263 - def test_object_path_ns(self):

2264 root = self.XML(xml_str) 2265 path = objectify.ObjectPath( "{objectified}root.c1.c2" ) 2266 self.assertEqual(root.c1.c2.text, path.find(root).text) 2267 path = objectify.ObjectPath( "{objectified}root.{objectified}c1.c2" ) 2268 self.assertEqual(root.c1.c2.text, path.find(root).text) 2269 path = objectify.ObjectPath( "root.{objectified}c1.{objectified}c2" ) 2270 self.assertEqual(root.c1.c2.text, path.find(root).text) 2271 path = objectify.ObjectPath( "root.c1.{objectified}c2" ) 2272 self.assertEqual(root.c1.c2.text, path.find(root).text) 2273 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 2274 self.assertEqual(getattr(root.c1, '{otherNS}c2').text, 2275 path.find(root).text)

2276

2277 - def test_object_path_ns_list(self):

2278 root = self.XML(xml_str) 2279 path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] ) 2280 self.assertEqual(root.c1.c2.text, path.find(root).text) 2281 path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] ) 2282 self.assertEqual(root.c1.c2.text, path.find(root).text) 2283 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] ) 2284 self.assertEqual(root.c1.c2.text, path.find(root).text) 2285 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] ) 2286 self.assertEqual(root.c1.c2[2].text, path.find(root).text) 2287 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] ) 2288 self.assertEqual(root.c1.c2.text, path.find(root).text) 2289 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] ) 2290 self.assertEqual(root.c1.c2[2].text, path.find(root).text) 2291 path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] ) 2292 self.assertEqual(getattr(root.c1, '{otherNS}c2').text, 2293 path.find(root).text)

2294

2295 - def test_object_path_set(self):

2296 root = self.XML(xml_str) 2297 path = objectify.ObjectPath( "root.c1.c2" ) 2298 self.assertEqual(root.c1.c2.text, path.find(root).text) 2299 self.assertEqual("1", root.c1.c2[1].text) 2300 2301 new_value = "my new value" 2302 path.setattr(root, new_value) 2303 2304 self.assertEqual(new_value, root.c1.c2.text) 2305 self.assertEqual(new_value, path(root).text) 2306 self.assertEqual("1", root.c1.c2[1].text)

2307

2308 - def test_object_path_set_element(self):

2309 root = self.XML(xml_str) 2310 path = objectify.ObjectPath( "root.c1.c2" ) 2311 self.assertEqual(root.c1.c2.text, path.find(root).text) 2312 self.assertEqual("1", root.c1.c2[1].text) 2313 2314 new_el = self.Element("{objectified}test") 2315 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2316 path.setattr(root, new_el.sub) 2317 2318 self.assertEqual("ATTR", root.c1.c2.get("myattr")) 2319 self.assertEqual("TEST", root.c1.c2.a.text) 2320 self.assertEqual("TEST", path(root).a.text) 2321 self.assertEqual("1", root.c1.c2[1].text)

2322

2323 - def test_object_path_set_create(self):

2324 root = self.XML(xml_str) 2325 path = objectify.ObjectPath( "root.c1.c99" ) 2326 self.assertRaises(AttributeError, path.find, root) 2327 2328 new_value = "my new value" 2329 path.setattr(root, new_value) 2330 2331 self.assertEqual(1, len(root.c1.c99)) 2332 self.assertEqual(new_value, root.c1.c99.text) 2333 self.assertEqual(new_value, path(root).text)

2334

2335 - def test_object_path_set_create_element(self):

2336 root = self.XML(xml_str) 2337 path = objectify.ObjectPath( "root.c1.c99" ) 2338 self.assertRaises(AttributeError, path.find, root) 2339 2340 new_el = self.Element("{objectified}test") 2341 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2342 path.setattr(root, new_el.sub) 2343 2344 self.assertEqual(1, len(root.c1.c99)) 2345 self.assertEqual("ATTR", root.c1.c99.get("myattr")) 2346 self.assertEqual("TEST", root.c1.c99.a.text) 2347 self.assertEqual("TEST", path(root).a.text)

2348

2349 - def test_object_path_set_create_list(self):

2350 root = self.XML(xml_str) 2351 path = objectify.ObjectPath( "root.c1.c99" ) 2352 self.assertRaises(AttributeError, path.find, root) 2353 2354 new_el = self.Element("{objectified}test") 2355 new_el.a = ["TEST1", "TEST2"] 2356 new_el.a[0].set("myattr", "ATTR1") 2357 new_el.a[1].set("myattr", "ATTR2") 2358 2359 path.setattr(root, list(new_el.a)) 2360 2361 self.assertEqual(2, len(root.c1.c99)) 2362 self.assertEqual("ATTR1", root.c1.c99[0].get("myattr")) 2363 self.assertEqual("TEST1", root.c1.c99[0].text) 2364 self.assertEqual("ATTR2", root.c1.c99[1].get("myattr")) 2365 self.assertEqual("TEST2", root.c1.c99[1].text) 2366 self.assertEqual("TEST1", path(root).text)

2367

2368 - def test_object_path_addattr(self):

2369 root = self.XML(xml_str) 2370 path = objectify.ObjectPath( "root.c1.c2" ) 2371 self.assertEqual(3, len(root.c1.c2)) 2372 path.addattr(root, "test") 2373 self.assertEqual(4, len(root.c1.c2)) 2374 self.assertEqual(["0", "1", "2", "test"], 2375 [el.text for el in root.c1.c2])

2376

2377 - def test_object_path_addattr_element(self):

2378 root = self.XML(xml_str) 2379 path = objectify.ObjectPath( "root.c1.c2" ) 2380 self.assertEqual(3, len(root.c1.c2)) 2381 2382 new_el = self.Element("{objectified}test") 2383 etree.SubElement(new_el, "{objectified}sub").a = "TEST" 2384 2385 path.addattr(root, new_el.sub) 2386 self.assertEqual(4, len(root.c1.c2)) 2387 self.assertEqual("TEST", root.c1.c2[3].a.text) 2388 self.assertEqual(["0", "1", "2"], 2389 [el.text for el in root.c1.c2[:3]])

2390

2391 - def test_object_path_addattr_create(self):

2392 root = self.XML(xml_str) 2393 path = objectify.ObjectPath( "root.c1.c99" ) 2394 self.assertRaises(AttributeError, path.find, root) 2395 2396 new_value = "my new value" 2397 path.addattr(root, new_value) 2398 2399 self.assertEqual(1, len(root.c1.c99)) 2400 self.assertEqual(new_value, root.c1.c99.text) 2401 self.assertEqual(new_value, path(root).text)

2402

2403 - def test_object_path_addattr_create_element(self):

2404 root = self.XML(xml_str) 2405 path = objectify.ObjectPath( "root.c1.c99" ) 2406 self.assertRaises(AttributeError, path.find, root) 2407 2408 new_el = self.Element("{objectified}test") 2409 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2410 2411 path.addattr(root, new_el.sub) 2412 self.assertEqual(1, len(root.c1.c99)) 2413 self.assertEqual("TEST", root.c1.c99.a.text) 2414 self.assertEqual("TEST", path(root).a.text) 2415 self.assertEqual("ATTR", root.c1.c99.get("myattr"))

2416

2417 - def test_object_path_addattr_create_list(self):

2418 root = self.XML(xml_str) 2419 path = objectify.ObjectPath( "root.c1.c99" ) 2420 self.assertRaises(AttributeError, path.find, root) 2421 2422 new_el = self.Element("{objectified}test") 2423 new_el.a = ["TEST1", "TEST2"] 2424 2425 self.assertEqual(2, len(new_el.a)) 2426 2427 path.addattr(root, list(new_el.a)) 2428 self.assertEqual(2, len(root.c1.c99)) 2429 self.assertEqual("TEST1", root.c1.c99.text) 2430 self.assertEqual("TEST2", path(root)[1].text)

2431

2432 - def test_descendant_paths(self):

2433 root = self.XML(xml_str) 2434 self.assertEqual( 2435 ['{objectified}root', '{objectified}root.c1', 2436 '{objectified}root.c1.c2', 2437 '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]', 2438 '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'], 2439 root.descendantpaths())

2440

2441 - def test_descendant_paths_child(self):

2442 root = self.XML(xml_str) 2443 self.assertEqual( 2444 ['{objectified}c1', '{objectified}c1.c2', 2445 '{objectified}c1.c2[1]', '{objectified}c1.c2[2]', 2446 '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'], 2447 root.c1.descendantpaths())

2448

2449 - def test_descendant_paths_prefix(self):

2450 root = self.XML(xml_str) 2451 self.assertEqual( 2452 ['root.{objectified}c1', 'root.{objectified}c1.c2', 2453 'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]', 2454 'root.{objectified}c1.{otherNS}c2', 2455 'root.{objectified}c1.{}c2'], 2456 root.c1.descendantpaths('root'))

2457

2458 - def test_pickle(self):

2459 import pickle 2460 2461 root = self.XML(xml_str) 2462 out = BytesIO() 2463 pickle.dump(root, out) 2464 2465 new_root = pickle.loads(out.getvalue()) 2466 self.assertEqual( 2467 etree.tostring(new_root), 2468 etree.tostring(root))

2469

2470 - def test_pickle_elementtree(self):

2471 import pickle 2472 2473 tree = etree.ElementTree(self.XML(xml_str + "<?my pi?>")) 2474 out = BytesIO() 2475 pickle.dump(tree, out) 2476 2477 new_tree = pickle.loads(out.getvalue()) 2478 self.assertTrue(isinstance(new_tree, etree._ElementTree)) 2479 self.assertEqual( 2480 etree.tostring(new_tree), 2481 etree.tostring(tree))

2482

2483 - def test_pickle_intelement(self):

2484 self._test_pickle('<x>42</x>') 2485 self._test_pickle(objectify.DataElement(42))

2486

2487 - def test_pickle_floattelement(self):

2488 self._test_pickle('<x>42.0</x>') 2489 self._test_pickle(objectify.DataElement(42.0))

2490

2491 - def test_pickle_strelement(self):

2492 self._test_pickle('<x>Pickle me!</x>') 2493 self._test_pickle(objectify.DataElement('Pickle me!'))

2494

2495 - def test_pickle_boolelement(self):

2496 self._test_pickle('<x>true</x>') 2497 self._test_pickle('<x>false</x>') 2498 self._test_pickle(objectify.DataElement(True)) 2499 self._test_pickle(objectify.DataElement(False))

2500

2501 - def test_pickle_noneelement(self):

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

2505

2506 - def _test_pickle(self, stringOrElt):

2507 import pickle 2508 if isinstance(stringOrElt, (etree._Element, etree._ElementTree)): 2509 elt = stringOrElt 2510 else: 2511 elt = self.XML(stringOrElt) 2512 out = BytesIO() 2513 pickle.dump(elt, out) 2514 2515 new_elt = pickle.loads(out.getvalue()) 2516 self.assertEqual( 2517 etree.tostring(new_elt), 2518 etree.tostring(elt))

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

2522 - def test_efactory_int(self):

2523 E = objectify.E 2524 root = E.root(E.val(23)) 2525 self.assertTrue(isinstance(root.val, objectify.IntElement))

2526

2527 - def test_efactory_float(self):

2528 E = objectify.E 2529 root = E.root(E.val(233.23)) 2530 self.assertTrue(isinstance(root.val, objectify.FloatElement))

2531

2532 - def test_efactory_str(self):

2533 E = objectify.E 2534 root = E.root(E.val("what?")) 2535 self.assertTrue(isinstance(root.val, objectify.StringElement))

2536

2537 - def test_efactory_unicode(self):

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

2541

2542 - def test_efactory_bool(self):

2543 E = objectify.E 2544 root = E.root(E.val(True)) 2545 self.assertTrue(isinstance(root.val, objectify.BoolElement))

2546

2547 - def test_efactory_none(self):

2548 E = objectify.E 2549 root = E.root(E.val(None)) 2550 self.assertTrue(isinstance(root.val, objectify.NoneElement))

2551

2552 - def test_efactory_value_concatenation(self):

2553 E = objectify.E 2554 root = E.root(E.val(1, "foo", 2.0, "bar ", True, None)) 2555 self.assertTrue(isinstance(root.val, objectify.StringElement))

2556

2557 - def test_efactory_attrib(self):

2558 E = objectify.E 2559 root = E.root(foo="bar") 2560 self.assertEqual(root.get("foo"), "bar")

2561

2562 - def test_efactory_nested(self):

2563 E = objectify.E 2564 DataElement = objectify.DataElement 2565 root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1), 2566 DataElement(2.0)) 2567 self.assertTrue(isinstance(root, objectify.ObjectifiedElement)) 2568 self.assertEqual(root.text, "text") 2569 self.assertTrue(isinstance(root.sub, objectify.ObjectifiedElement)) 2570 self.assertEqual(root.sub.tail, "tail") 2571 self.assertTrue(isinstance(root.sub.subsub, objectify.StringElement)) 2572 self.assertEqual(len(root.value), 2) 2573 self.assertTrue(isinstance(root.value[0], objectify.IntElement)) 2574 self.assertTrue(isinstance(root.value[1], objectify.FloatElement))

2575

2576 - def test_efactory_subtype(self):

2577 class Attribute(objectify.ObjectifiedDataElement): 2578 def __init__(self): 2579 objectify.ObjectifiedDataElement.__init__(self) 2580 self.set("datatype", "TYPE") 2581 self.set("range", "0.,1.")

2582 2583 attr = Attribute() 2584 self.assertEqual(attr.text, None) 2585 self.assertEqual(attr.get("datatype"), "TYPE") 2586 self.assertEqual(attr.get("range"), "0.,1.") 2587

2588 - def test_XML_base_url_docinfo(self):

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

2592

2593 - def test_XML_set_base_url_docinfo(self):

2594 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2595 docinfo = root.getroottree().docinfo 2596 self.assertEqual(docinfo.URL, "http://no/such/url") 2597 docinfo.URL = "https://secret/url" 2598 self.assertEqual(docinfo.URL, "https://secret/url")

2599

2600 - def test_parse_stringio_base_url(self):

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

2604

2605 - def test_parse_base_url_docinfo(self):

2606 tree = objectify.parse(fileInTestDir('include/test_xinclude.xml'), 2607 base_url="http://no/such/url") 2608 docinfo = tree.docinfo 2609 self.assertEqual(docinfo.URL, "http://no/such/url")

2610

2611 - def test_xml_base(self):

2612 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2613 self.assertEqual(root.base, "http://no/such/url") 2614 self.assertEqual( 2615 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2616 root.base = "https://secret/url" 2617 self.assertEqual(root.base, "https://secret/url") 2618 self.assertEqual( 2619 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2620 "https://secret/url")

2621

2622 - def test_xml_base_attribute(self):

2623 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2624 self.assertEqual(root.base, "http://no/such/url") 2625 self.assertEqual( 2626 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2627 root.set('{http://www.w3.org/XML/1998/namespace}base', 2628 "https://secret/url") 2629 self.assertEqual(root.base, "https://secret/url") 2630 self.assertEqual( 2631 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2632 "https://secret/url")

2633

2634 - def test_standard_lookup(self):

2635 XML = self.XML 2636 2637 xml = _bytes('''\ 2638 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 2639 5 2640 -5 2641 <l>4294967296</l> 2642 <l>-4294967296</l> 2643 <f>1.1</f> 2644 true 2645 false 2646 <s>Strange things happen, where strings collide</s> 2647 <s>True</s> 2648 <s>False</s> 2649 <s>t</s> 2650 <s>f</s> 2651 <s></s> 2652 <s>None</s> 2653 <n xsi:nil="true" /> 2654 </root> 2655 ''') 2656 root = XML(xml) 2657 2658 for i in root.i: 2659 self.assertTrue(isinstance(i, objectify.IntElement)) 2660 for l in root.l: 2661 self.assertTrue(isinstance(l, objectify.IntElement)) 2662 for f in root.f: 2663 self.assertTrue(isinstance(f, objectify.FloatElement)) 2664 for b in root.b: 2665 self.assertTrue(isinstance(b, objectify.BoolElement)) 2666 self.assertEqual(True, root.b[0]) 2667 self.assertEqual(False, root.b[1]) 2668 for s in root.s: 2669 self.assertTrue(isinstance(s, objectify.StringElement)) 2670 self.assertTrue(isinstance(root.n, objectify.NoneElement)) 2671 self.assertEqual(None, root.n)

2672

2673 -def test_suite():

2674 suite = unittest.TestSuite() 2675 suite.addTests([unittest.makeSuite(ObjectifyTestCase)]) 2676 suite.addTests(doctest.DocTestSuite(objectify)) 2677 suite.addTests([make_doctest('../../../doc/objectify.txt')]) 2678 return suite

2679 2680 if __name__ == '__main__': 2681 print('to test use test.py %s' % __file__) 2682

Source Code for Module lxml.tests.test_objectify