lxml.tests.test

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

70 -class ObjectifyTestCase(HelperTestCase):

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

75 - def XML(self, xml):

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

77

78 - def setUp(self):

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

91

92 - def tearDown(self):

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

105 106

107 - def test_element_nsmap_default(self):

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

110

111 - def test_element_nsmap_empty(self):

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

115

116 - def test_element_nsmap_custom_prefixes(self):

117 nsmap = {"mypy": PYTYPE_NAMESPACE, 118 "myxsi": XML_SCHEMA_INSTANCE_NS, 119 "myxsd": XML_SCHEMA_NS} 120 elt = objectify.Element("test", nsmap=nsmap) 121 self.assertEquals(elt.nsmap, nsmap)

122

123 - def test_element_nsmap_custom(self):

124 nsmap = {"my": "someNS", 125 "myother": "someOtherNS", 126 "myxsd": XML_SCHEMA_NS} 127 elt = objectify.Element("test", nsmap=nsmap) 128 self.assert_(PYTYPE_NAMESPACE in elt.nsmap.values()) 129 for prefix, ns in nsmap.items(): 130 self.assert_(prefix in elt.nsmap) 131 self.assertEquals(nsmap[prefix], elt.nsmap[prefix])

132

133 - def test_sub_element_nsmap_default(self):

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

137

138 - def test_sub_element_nsmap_empty(self):

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

143

144 - def test_sub_element_nsmap_custom_prefixes(self):

145 root = objectify.Element("root") 146 nsmap = {"mypy": PYTYPE_NAMESPACE, 147 "myxsi": XML_SCHEMA_INSTANCE_NS, 148 "myxsd": XML_SCHEMA_NS} 149 root.sub = objectify.Element("test", nsmap=nsmap) 150 self.assertEquals(root.sub.nsmap, DEFAULT_NSMAP)

151

152 - def test_sub_element_nsmap_custom(self):

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

162

163 - def test_data_element_nsmap_default(self):

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

166

167 - def test_data_element_nsmap_empty(self):

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

171

172 - def test_data_element_nsmap_custom_prefixes(self):

173 nsmap = {"mypy": PYTYPE_NAMESPACE, 174 "myxsi": XML_SCHEMA_INSTANCE_NS, 175 "myxsd": XML_SCHEMA_NS} 176 value = objectify.DataElement("test this", nsmap=nsmap) 177 self.assertEquals(value.nsmap, nsmap)

178

179 - def test_data_element_nsmap_custom(self):

180 nsmap = {"my": "someNS", 181 "myother": "someOtherNS", 182 "myxsd": XML_SCHEMA_NS,} 183 value = objectify.DataElement("test", nsmap=nsmap) 184 self.assert_(PYTYPE_NAMESPACE in value.nsmap.values()) 185 for prefix, ns in nsmap.items(): 186 self.assert_(prefix in value.nsmap) 187 self.assertEquals(nsmap[prefix], value.nsmap[prefix])

188

189 - def test_sub_data_element_nsmap_default(self):

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

193

194 - def test_sub_data_element_nsmap_empty(self):

195 root = objectify.Element("root") 196 nsmap = {} 197 root.value = objectify.DataElement("test this", nsmap=nsmap) 198 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)

199

200 - def test_sub_data_element_nsmap_custom_prefixes(self):

201 root = objectify.Element("root") 202 nsmap = {"mypy": PYTYPE_NAMESPACE, 203 "myxsi": XML_SCHEMA_INSTANCE_NS, 204 "myxsd": XML_SCHEMA_NS} 205 root.value = objectify.DataElement("test this", nsmap=nsmap) 206 self.assertEquals(root.value.nsmap, DEFAULT_NSMAP)

207

208 - def test_sub_data_element_nsmap_custom(self):

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

218

219 - def test_data_element_attrib_attributes_precedence(self):

220 # keyword arguments override attrib entries 221 value = objectify.DataElement(23, _pytype="str", _xsi="foobar", 222 attrib={"gnu": "muh", "cat": "meeow", 223 "dog": "wuff"}, 224 bird="tchilp", dog="grrr") 225 self.assertEquals(value.get("gnu"), "muh") 226 self.assertEquals(value.get("cat"), "meeow") 227 self.assertEquals(value.get("dog"), "grrr") 228 self.assertEquals(value.get("bird"), "tchilp")

229

230 - def test_data_element_data_element_arg(self):

231 # Check that DataElement preserves all attributes ObjectifiedDataElement 232 # arguments 233 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 234 attrib={"gnu": "muh", "cat": "meeow", 235 "dog": "wuff"}, 236 bird="tchilp", dog="grrr") 237 value = objectify.DataElement(arg) 238 self.assert_(isinstance(value, objectify.StringElement)) 239 for attr in arg.attrib: 240 self.assertEquals(value.get(attr), arg.get(attr))

241

242 - def test_data_element_data_element_arg_pytype_none(self):

243 # Check that _pytype arg overrides original py:pytype of 244 # ObjectifiedDataElement 245 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 246 attrib={"gnu": "muh", "cat": "meeow", 247 "dog": "wuff"}, 248 bird="tchilp", dog="grrr") 249 value = objectify.DataElement(arg, _pytype="NoneType") 250 self.assert_(isinstance(value, objectify.NoneElement)) 251 self.assertEquals(value.get(XML_SCHEMA_NIL_ATTR), "true") 252 self.assertEquals(value.text, None) 253 self.assertEquals(value.pyval, None) 254 for attr in arg.attrib: 255 #if not attr == objectify.PYTYPE_ATTRIBUTE: 256 self.assertEquals(value.get(attr), arg.get(attr))

257

258 - def test_data_element_data_element_arg_pytype(self):

259 # Check that _pytype arg overrides original py:pytype of 260 # ObjectifiedDataElement 261 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 262 attrib={"gnu": "muh", "cat": "meeow", 263 "dog": "wuff"}, 264 bird="tchilp", dog="grrr") 265 value = objectify.DataElement(arg, _pytype="int") 266 self.assert_(isinstance(value, objectify.IntElement)) 267 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 268 for attr in arg.attrib: 269 if not attr == objectify.PYTYPE_ATTRIBUTE: 270 self.assertEquals(value.get(attr), arg.get(attr))

271

272 - def test_data_element_data_element_arg_xsitype(self):

273 # Check that _xsi arg overrides original xsi:type of given 274 # ObjectifiedDataElement 275 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 276 attrib={"gnu": "muh", "cat": "meeow", 277 "dog": "wuff"}, 278 bird="tchilp", dog="grrr") 279 value = objectify.DataElement(arg, _xsi="xsd:int") 280 self.assert_(isinstance(value, objectify.IntElement)) 281 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 282 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 283 for attr in arg.attrib: 284 if not attr in [objectify.PYTYPE_ATTRIBUTE, 285 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 286 self.assertEquals(value.get(attr), arg.get(attr))

287

288 - def test_data_element_data_element_arg_pytype_xsitype(self):

289 # Check that _pytype and _xsi args override original py:pytype and 290 # xsi:type attributes of given ObjectifiedDataElement 291 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 292 attrib={"gnu": "muh", "cat": "meeow", 293 "dog": "wuff"}, 294 bird="tchilp", dog="grrr") 295 value = objectify.DataElement(arg, _pytype="int", _xsi="xsd:int") 296 self.assert_(isinstance(value, objectify.IntElement)) 297 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 298 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 299 for attr in arg.attrib: 300 if not attr in [objectify.PYTYPE_ATTRIBUTE, 301 XML_SCHEMA_INSTANCE_TYPE_ATTR]: 302 self.assertEquals(value.get(attr), arg.get(attr))

303

304 - def test_data_element_invalid_pytype(self):

305 self.assertRaises(ValueError, objectify.DataElement, 3.1415, 306 _pytype="int")

307

308 - def test_data_element_invalid_xsi(self):

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

311

312 - def test_data_element_data_element_arg_invalid_pytype(self):

313 arg = objectify.DataElement(3.1415) 314 self.assertRaises(ValueError, objectify.DataElement, arg, 315 _pytype="int")

316

317 - def test_data_element_data_element_arg_invalid_xsi(self):

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

321

322 - def test_root(self):

323 root = self.Element("test") 324 self.assert_(isinstance(root, objectify.ObjectifiedElement))

325

326 - def test_str(self):

327 root = self.Element("test") 328 self.assertEquals('', str(root))

329

330 - def test_child(self):

331 root = self.XML(xml_str) 332 self.assertEquals("0", root.c1.c2.text)

333

334 - def test_countchildren(self):

335 root = self.XML(xml_str) 336 self.assertEquals(1, root.countchildren()) 337 self.assertEquals(5, root.c1.countchildren())

338

339 - def test_child_getattr(self):

340 root = self.XML(xml_str) 341 self.assertEquals("0", getattr(root.c1, "{objectified}c2").text) 342 self.assertEquals("3", getattr(root.c1, "{otherNS}c2").text)

343

344 - def test_child_nonexistant(self):

345 root = self.XML(xml_str) 346 self.assertRaises(AttributeError, getattr, root.c1, "NOT_THERE") 347 self.assertRaises(AttributeError, getattr, root.c1, "{unknownNS}c2")

348

349 - def test_setattr(self):

350 for val in [ 351 2, 2**32, 1.2, "Won't get fooled again", 352 _str("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1'), True, 353 False, None]: 354 root = self.Element('root') 355 attrname = 'val' 356 setattr(root, attrname, val) 357 result = getattr(root, attrname) 358 self.assertEquals(val, result) 359 self.assertEquals(type(val), type(result.pyval))

360

361 - def test_setattr_nonunicode(self):

362 root = self.Element('root') 363 attrname = 'val' 364 val = _bytes("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1') 365 self.assertRaises(ValueError, setattr, root, attrname, val) 366 self.assertRaises(AttributeError, getattr, root, attrname)

367

368 - def test_addattr(self):

369 root = self.XML(xml_str) 370 self.assertEquals(1, len(root.c1)) 371 root.addattr("c1", "test") 372 self.assertEquals(2, len(root.c1)) 373 self.assertEquals("test", root.c1[1].text)

374

375 - def test_addattr_element(self):

376 root = self.XML(xml_str) 377 self.assertEquals(1, len(root.c1)) 378 379 new_el = self.Element("test", myattr="5") 380 root.addattr("c1", new_el) 381 self.assertEquals(2, len(root.c1)) 382 self.assertEquals(None, root.c1[0].get("myattr")) 383 self.assertEquals("5", root.c1[1].get("myattr"))

384

385 - def test_addattr_list(self):

386 root = self.XML(xml_str) 387 self.assertEquals(1, len(root.c1)) 388 389 new_el = self.Element("test") 390 self.etree.SubElement(new_el, "a", myattr="A") 391 self.etree.SubElement(new_el, "a", myattr="B") 392 393 root.addattr("c1", list(new_el.a)) 394 self.assertEquals(3, len(root.c1)) 395 self.assertEquals(None, root.c1[0].get("myattr")) 396 self.assertEquals("A", root.c1[1].get("myattr")) 397 self.assertEquals("B", root.c1[2].get("myattr"))

398

399 - def test_child_addattr(self):

400 root = self.XML(xml_str) 401 self.assertEquals(3, len(root.c1.c2)) 402 root.c1.addattr("c2", 3) 403 self.assertEquals(4, len(root.c1.c2)) 404 self.assertEquals("3", root.c1.c2[3].text)

405

406 - def test_child_index(self):

407 root = self.XML(xml_str) 408 self.assertEquals("0", root.c1.c2[0].text) 409 self.assertEquals("1", root.c1.c2[1].text) 410 self.assertEquals("2", root.c1.c2[2].text) 411 self.assertRaises(IndexError, operator.getitem, root.c1.c2, 3)

412

413 - def test_child_index_neg(self):

414 root = self.XML(xml_str) 415 self.assertEquals("0", root.c1.c2[0].text) 416 self.assertEquals("0", root.c1.c2[-3].text) 417 self.assertEquals("1", root.c1.c2[-2].text) 418 self.assertEquals("2", root.c1.c2[-1].text) 419 self.assertRaises(IndexError, operator.getitem, root.c1.c2, -4)

420

421 - def test_child_len(self):

422 root = self.XML(xml_str) 423 self.assertEquals(1, len(root)) 424 self.assertEquals(1, len(root.c1)) 425 self.assertEquals(3, len(root.c1.c2))

426

427 - def test_child_iter(self):

428 root = self.XML(xml_str) 429 self.assertEquals([root], 430 list(iter(root))) 431 self.assertEquals([root.c1], 432 list(iter(root.c1))) 433 self.assertEquals([root.c1.c2[0], root.c1.c2[1], root.c1.c2[2]], 434 list(iter((root.c1.c2))))

435

436 - def test_class_lookup(self):

437 root = self.XML(xml_str) 438 self.assert_(isinstance(root.c1.c2, objectify.ObjectifiedElement)) 439 self.assertFalse(isinstance(getattr(root.c1, "{otherNS}c2"), 440 objectify.ObjectifiedElement))

441

442 - def test_dir(self):

443 root = self.XML(xml_str) 444 dir_c1 = dir(objectify.ObjectifiedElement) + ['c1'] 445 dir_c1.sort() 446 dir_c2 = dir(objectify.ObjectifiedElement) + ['c2'] 447 dir_c2.sort() 448 449 self.assertEquals(dir_c1, dir(root)) 450 self.assertEquals(dir_c2, dir(root.c1))

451

452 - def test_vars(self):

453 root = self.XML(xml_str) 454 self.assertEquals({'c1' : root.c1}, vars(root)) 455 self.assertEquals({'c2' : root.c1.c2}, vars(root.c1))

456

457 - def test_child_set_ro(self):

458 root = self.XML(xml_str) 459 self.assertRaises(TypeError, setattr, root.c1.c2, 'text', "test") 460 self.assertRaises(TypeError, setattr, root.c1.c2, 'pyval', "test")

461 462 # slicing 463

464 - def test_getslice_complete(self):

465 root = self.XML("<root><c>c1</c><c>c2</c></root>") 466 self.assertEquals(["c1", "c2"], 467 [ c.text for c in root.c[:] ])

468

469 - def test_getslice_partial(self):

470 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 471 test_list = ["c1", "c2", "c3", "c4"] 472 473 self.assertEquals(test_list, 474 [ c.text for c in root.c[:] ]) 475 self.assertEquals(test_list[1:2], 476 [ c.text for c in root.c[1:2] ]) 477 self.assertEquals(test_list[-3:-1], 478 [ c.text for c in root.c[-3:-1] ]) 479 self.assertEquals(test_list[-3:3], 480 [ c.text for c in root.c[-3:3] ]) 481 self.assertEquals(test_list[-3000:3], 482 [ c.text for c in root.c[-3000:3] ]) 483 self.assertEquals(test_list[-3:3000], 484 [ c.text for c in root.c[-3:3000] ])

485

486 - def test_getslice_partial_neg(self):

487 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 488 test_list = ["c1", "c2", "c3", "c4"] 489 490 self.assertEquals(test_list, 491 [ c.text for c in root.c[:] ]) 492 self.assertEquals(test_list[2:1:-1], 493 [ c.text for c in root.c[2:1:-1] ]) 494 self.assertEquals(test_list[-1:-3:-1], 495 [ c.text for c in root.c[-1:-3:-1] ]) 496 self.assertEquals(test_list[2:-3:-1], 497 [ c.text for c in root.c[2:-3:-1] ]) 498 self.assertEquals(test_list[2:-3000:-1], 499 [ c.text for c in root.c[2:-3000:-1] ])

500 501 # slice assignment 502

503 - def test_setslice_complete(self):

504 Element = self.Element 505 root = Element("root") 506 root.c = ["c1", "c2"] 507 508 c1 = root.c[0] 509 c2 = root.c[1] 510 511 self.assertEquals([c1,c2], list(root.c)) 512 self.assertEquals(["c1", "c2"], 513 [ c.text for c in root.c ])

514

515 - def test_setslice_elements(self):

516 Element = self.Element 517 root = Element("root") 518 root.c = ["c1", "c2"] 519 520 c1 = root.c[0] 521 c2 = root.c[1] 522 523 self.assertEquals([c1,c2], list(root.c)) 524 self.assertEquals(["c1", "c2"], 525 [ c.text for c in root.c ]) 526 527 root2 = Element("root2") 528 root2.el = [ "test", "test" ] 529 self.assertEquals(["test", "test"], 530 [ el.text for el in root2.el ]) 531 532 root.c = [ root2.el, root2.el ] 533 self.assertEquals(["test", "test"], 534 [ c.text for c in root.c ]) 535 self.assertEquals(["test", "test"], 536 [ el.text for el in root2.el ]) 537 538 root.c[:] = [ c1, c2, c2, c1 ] 539 self.assertEquals(["c1", "c2", "c2", "c1"], 540 [ c.text for c in root.c ])

541

542 - def test_setslice_partial(self):

543 Element = self.Element 544 root = Element("root") 545 l = ["c1", "c2", "c3", "c4"] 546 root.c = l 547 548 self.assertEquals(["c1", "c2", "c3", "c4"], 549 [ c.text for c in root.c ]) 550 self.assertEquals(l, 551 [ c.text for c in root.c ]) 552 553 new_slice = ["cA", "cB"] 554 l[1:2] = new_slice 555 root.c[1:2] = new_slice 556 557 self.assertEquals(["c1", "cA", "cB", "c3", "c4"], l) 558 self.assertEquals(["c1", "cA", "cB", "c3", "c4"], 559 [ c.text for c in root.c ]) 560 self.assertEquals(l, 561 [ c.text for c in root.c ])

562

563 - def test_setslice_insert(self):

564 Element = self.Element 565 root = Element("root") 566 l = ["c1", "c2", "c3", "c4"] 567 root.c = l 568 569 self.assertEquals(["c1", "c2", "c3", "c4"], 570 [ c.text for c in root.c ]) 571 self.assertEquals(l, 572 [ c.text for c in root.c ]) 573 574 new_slice = ["cA", "cB"] 575 l[1:1] = new_slice 576 root.c[1:1] = new_slice 577 578 self.assertEquals(["c1", "cA", "cB", "c2", "c3", "c4"], l) 579 self.assertEquals(["c1", "cA", "cB", "c2", "c3", "c4"], 580 [ c.text for c in root.c ]) 581 self.assertEquals(l, 582 [ c.text for c in root.c ])

583

584 - def test_setslice_insert_neg(self):

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

604

605 - def test_setslice_empty(self):

606 Element = self.Element 607 root = Element("root") 608 609 root.c = [] 610 self.assertRaises( 611 AttributeError, getattr, root, 'c')

612

613 - def test_setslice_partial_wrong_length(self):

614 Element = self.Element 615 root = Element("root") 616 l = ["c1", "c2", "c3", "c4"] 617 root.c = l 618 619 self.assertEquals(["c1", "c2", "c3", "c4"], 620 [ c.text for c in root.c ]) 621 self.assertEquals(l, 622 [ c.text for c in root.c ]) 623 624 new_slice = ["cA", "cB", "cC"] 625 self.assertRaises( 626 ValueError, operator.setitem, 627 l, slice(1,2,-1), new_slice) 628 self.assertRaises( 629 ValueError, operator.setitem, 630 root.c, slice(1,2,-1), new_slice)

631

632 - def test_setslice_partial_neg(self):

633 Element = self.Element 634 root = Element("root") 635 l = ["c1", "c2", "c3", "c4"] 636 root.c = l 637 638 self.assertEquals(["c1", "c2", "c3", "c4"], 639 [ c.text for c in root.c ]) 640 self.assertEquals(l, 641 [ c.text for c in root.c ]) 642 643 new_slice = ["cA", "cB"] 644 l[-1:1:-1] = new_slice 645 root.c[-1:1:-1] = new_slice 646 647 self.assertEquals(["c1", "c2", "cB", "cA"], l) 648 self.assertEquals(["c1", "c2", "cB", "cA"], 649 [ c.text for c in root.c ]) 650 self.assertEquals(l, 651 [ c.text for c in root.c ])

652

653 - def test_setslice_partial_allneg(self):

654 Element = self.Element 655 root = Element("root") 656 l = ["c1", "c2", "c3", "c4"] 657 root.c = l 658 659 self.assertEquals(["c1", "c2", "c3", "c4"], 660 [ c.text for c in root.c ]) 661 self.assertEquals(l, 662 [ c.text for c in root.c ]) 663 664 new_slice = ["cA", "cB"] 665 l[-1:-4:-2] = new_slice 666 root.c[-1:-4:-2] = new_slice 667 668 self.assertEquals(["c1", "cB", "c3", "cA"], l) 669 self.assertEquals(["c1", "cB", "c3", "cA"], 670 [ c.text for c in root.c ]) 671 self.assertEquals(l, 672 [ c.text for c in root.c ])

673 674 # other stuff 675

676 - def test_set_string(self):

677 # make sure strings are not handled as sequences 678 Element = self.Element 679 root = Element("root") 680 root.c = "TEST" 681 self.assertEquals(["TEST"], 682 [ c.text for c in root.c ])

683

684 - def test_setitem_string(self):

685 # make sure strings are set as children 686 Element = self.Element 687 root = Element("root") 688 root["c"] = "TEST" 689 self.assertEquals(["TEST"], 690 [ c.text for c in root.c ])

691

692 - def test_setitem_string_special(self):

693 # make sure 'text' etc. are set as children 694 Element = self.Element 695 root = Element("root") 696 697 root["text"] = "TEST" 698 self.assertEquals(["TEST"], 699 [ c.text for c in root["text"] ]) 700 701 root["tail"] = "TEST" 702 self.assertEquals(["TEST"], 703 [ c.text for c in root["tail"] ]) 704 705 root["pyval"] = "TEST" 706 self.assertEquals(["TEST"], 707 [ c.text for c in root["pyval"] ]) 708 709 root["tag"] = "TEST" 710 self.assertEquals(["TEST"], 711 [ c.text for c in root["tag"] ])

712

713 - def test_findall(self):

714 XML = self.XML 715 root = XML('<a><c/><c></c></a>') 716 self.assertEquals(1, len(root.findall("c"))) 717 self.assertEquals(2, len(root.findall(".//c"))) 718 self.assertEquals(3, len(root.findall(".//b"))) 719 self.assert_(root.findall(".//b")[1] is root.getchildren()[1])

720

721 - def test_findall_ns(self):

722 XML = self.XML 723 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>') 724 self.assertEquals(2, len(root.findall(".//{X}b"))) 725 self.assertEquals(3, len(root.findall(".//b"))) 726 self.assertEquals(2, len(root.findall("b")))

727

728 - def test_build_tree(self):

729 root = self.Element('root') 730 root.a = 5 731 root.b = 6 732 self.assert_(isinstance(root, objectify.ObjectifiedElement)) 733 self.assert_(isinstance(root.a, objectify.IntElement)) 734 self.assert_(isinstance(root.b, objectify.IntElement))

735

736 - def test_type_NoneType(self):

737 Element = self.Element 738 SubElement = self.etree.SubElement 739 740 nil_attr = XML_SCHEMA_NIL_ATTR 741 root = Element("{objectified}root") 742 SubElement(root, "{objectified}none") 743 SubElement(root, "{objectified}none", {nil_attr : "true"}) 744 self.assertFalse(isinstance(root.none, objectify.NoneElement)) 745 self.assertFalse(isinstance(root.none[0], objectify.NoneElement)) 746 self.assert_(isinstance(root.none[1], objectify.NoneElement)) 747 self.assertEquals(root.none[1], None) 748 self.assertFalse(root.none[1])

749

750 - def test_data_element_NoneType(self):

751 value = objectify.DataElement(None) 752 self.assert_(isinstance(value, objectify.NoneElement)) 753 self.assertEquals(value, None) 754 self.assertEquals(value.get(XML_SCHEMA_NIL_ATTR), "true")

755

756 - def test_type_bool(self):

757 Element = self.Element 758 SubElement = self.etree.SubElement 759 root = Element("{objectified}root") 760 root.bool = True 761 self.assertEquals(root.bool, True) 762 self.assertEquals(root.bool + root.bool, True + True) 763 self.assertEquals(True + root.bool, True + root.bool) 764 self.assertEquals(root.bool * root.bool, True * True) 765 self.assertEquals(int(root.bool), int(True)) 766 self.assertEquals(complex(root.bool), complex(True)) 767 self.assert_(isinstance(root.bool, objectify.BoolElement)) 768 769 root.bool = False 770 self.assertEquals(root.bool, False) 771 self.assertEquals(root.bool + root.bool, False + False) 772 self.assertEquals(False + root.bool, False + root.bool) 773 self.assertEquals(root.bool * root.bool, False * False) 774 self.assertEquals(int(root.bool), int(False)) 775 self.assertEquals(complex(root.bool), complex(False)) 776 self.assert_(isinstance(root.bool, objectify.BoolElement))

777

778 - def test_data_element_bool(self):

779 value = objectify.DataElement(True) 780 self.assert_(isinstance(value, objectify.BoolElement)) 781 self.assertEquals(value, True) 782 783 value = objectify.DataElement(False) 784 self.assert_(isinstance(value, objectify.BoolElement)) 785 self.assertEquals(value, False)

786

787 - def test_type_str(self):

788 Element = self.Element 789 SubElement = self.etree.SubElement 790 root = Element("{objectified}root") 791 root.s = "test" 792 self.assert_(isinstance(root.s, objectify.StringElement))

793

794 - def test_type_str_intliteral(self):

795 Element = self.Element 796 SubElement = self.etree.SubElement 797 root = Element("{objectified}root") 798 root.s = "3" 799 self.assert_(isinstance(root.s, objectify.StringElement))

800

801 - def test_type_str_floatliteral(self):

802 Element = self.Element 803 SubElement = self.etree.SubElement 804 root = Element("{objectified}root") 805 root.s = "3.72" 806 self.assert_(isinstance(root.s, objectify.StringElement))

807

808 - def test_type_str_mul(self):

809 Element = self.Element 810 SubElement = self.etree.SubElement 811 root = Element("{objectified}root") 812 root.s = "test" 813 814 self.assertEquals("test" * 5, root.s * 5) 815 self.assertEquals(5 * "test", 5 * root.s) 816 817 self.assertRaises(TypeError, operator.mul, root.s, "honk") 818 self.assertRaises(TypeError, operator.mul, "honk", root.s)

819

820 - def test_type_str_add(self):

821 Element = self.Element 822 SubElement = self.etree.SubElement 823 root = Element("{objectified}root") 824 root.s = "test" 825 826 s = "toast" 827 self.assertEquals("test" + s, root.s + s) 828 self.assertEquals(s + "test", s + root.s)

829

830 - def test_type_str_mod(self):

831 s = "%d %f %s %r" 832 el = objectify.DataElement(s) 833 values = (1, 7.0, "abcd", None) 834 self.assertEquals(s % values, el % values) 835 836 s = "%d" 837 el = objectify.DataElement(s) 838 val = 5 839 self.assertEquals(s % val, el % val) 840 841 s = "%d %s" 842 el = objectify.DataElement(s) 843 val = 5 844 self.assertRaises(TypeError, el.__mod__, val) 845 846 s = "" 847 el = objectify.DataElement(s) 848 val = 5 849 self.assertRaises(TypeError, el.__mod__, val)

850

851 - def test_type_str_as_int(self):

852 v = "1" 853 el = objectify.DataElement(v) 854 self.assertEquals(int(el), 1)

855

856 - def test_type_str_as_float(self):

857 v = "1" 858 el = objectify.DataElement(v) 859 self.assertEquals(float(el), 1)

860

861 - def test_type_str_as_complex(self):

862 v = "1" 863 el = objectify.DataElement(v) 864 self.assertEquals(complex(el), 1)

865

866 - def test_type_str_mod_data_elements(self):

867 s = "%d %f %s %r" 868 el = objectify.DataElement(s) 869 values = (objectify.DataElement(1), 870 objectify.DataElement(7.0), 871 objectify.DataElement("abcd"), 872 objectify.DataElement(None)) 873 self.assertEquals(s % values, el % values)

874

875 - def test_data_element_str(self):

876 value = objectify.DataElement("test") 877 self.assert_(isinstance(value, objectify.StringElement)) 878 self.assertEquals(value, "test")

879

880 - def test_data_element_str_intliteral(self):

881 value = objectify.DataElement("3") 882 self.assert_(isinstance(value, objectify.StringElement)) 883 self.assertEquals(value, "3")

884

885 - def test_data_element_str_floatliteral(self):

886 value = objectify.DataElement("3.20") 887 self.assert_(isinstance(value, objectify.StringElement)) 888 self.assertEquals(value, "3.20")

889

890 - def test_type_ustr(self):

891 Element = self.Element 892 SubElement = self.etree.SubElement 893 root = Element("{objectified}root") 894 root.s = _str("test") 895 self.assert_(isinstance(root.s, objectify.StringElement))

896

897 - def test_type_ustr_intliteral(self):

898 Element = self.Element 899 SubElement = self.etree.SubElement 900 root = Element("{objectified}root") 901 root.s = _str("3") 902 self.assert_(isinstance(root.s, objectify.StringElement))

903

904 - def test_type_ustr_floatliteral(self):

905 Element = self.Element 906 SubElement = self.etree.SubElement 907 root = Element("{objectified}root") 908 root.s = _str("3.72") 909 self.assert_(isinstance(root.s, objectify.StringElement))

910

911 - def test_type_ustr_mul(self):

912 Element = self.Element 913 SubElement = self.etree.SubElement 914 root = Element("{objectified}root") 915 root.s = _str("test") 916 917 self.assertEquals(_str("test") * 5, root.s * 5) 918 self.assertEquals(5 * _str("test"), 5 * root.s) 919 920 self.assertRaises(TypeError, operator.mul, root.s, _str("honk")) 921 self.assertRaises(TypeError, operator.mul, _str("honk"), root.s)

922

923 - def test_type_ustr_add(self):

924 Element = self.Element 925 SubElement = self.etree.SubElement 926 root = Element("{objectified}root") 927 root.s = _str("test") 928 929 s = _str("toast") 930 self.assertEquals(_str("test") + s, root.s + s) 931 self.assertEquals(s + _str("test"), s + root.s)

932

933 - def test_data_element_ustr(self):

934 value = objectify.DataElement(_str("test")) 935 self.assert_(isinstance(value, objectify.StringElement)) 936 self.assertEquals(value, _str("test"))

937

938 - def test_data_element_ustr_intliteral(self):

939 value = objectify.DataElement("3") 940 self.assert_(isinstance(value, objectify.StringElement)) 941 self.assertEquals(value, _str("3"))

942

943 - def test_data_element_ustr_floatliteral(self):

944 value = objectify.DataElement(_str("3.20")) 945 self.assert_(isinstance(value, objectify.StringElement)) 946 self.assertEquals(value, _str("3.20"))

947

948 - def test_type_int(self):

949 Element = self.Element 950 SubElement = self.etree.SubElement 951 root = Element("{objectified}root") 952 root.none = 5 953 self.assert_(isinstance(root.none, objectify.IntElement))

954

955 - def test_data_element_int(self):

956 value = objectify.DataElement(5) 957 self.assert_(isinstance(value, objectify.IntElement)) 958 self.assertEquals(value, 5)

959

960 - def test_type_float(self):

961 Element = self.Element 962 SubElement = self.etree.SubElement 963 root = Element("{objectified}root") 964 root.none = 5.5 965 self.assert_(isinstance(root.none, objectify.FloatElement))

966

967 - def test_data_element_float(self):

968 value = objectify.DataElement(5.5) 969 self.assert_(isinstance(value, objectify.FloatElement)) 970 self.assertEquals(value, 5.5)

971

972 - def test_data_element_xsitypes(self):

973 for xsi, objclass in xsitype2objclass.items(): 974 # 1 is a valid value for all ObjectifiedDataElement classes 975 pyval = 1 976 value = objectify.DataElement(pyval, _xsi=xsi) 977 self.assert_(isinstance(value, objclass), 978 "DataElement(%s, _xsi='%s') returns %s, expected %s" 979 % (pyval, xsi, type(value), objclass))

980

981 - def test_data_element_xsitypes_xsdprefixed(self):

982 for xsi, objclass in xsitype2objclass.items(): 983 # 1 is a valid value for all ObjectifiedDataElement classes 984 pyval = 1 985 value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi) 986 self.assert_(isinstance(value, objclass), 987 "DataElement(%s, _xsi='%s') returns %s, expected %s" 988 % (pyval, xsi, type(value), objclass))

989

990 - def test_data_element_xsitypes_prefixed(self):

991 for xsi, objclass in xsitype2objclass.items(): 992 # 1 is a valid value for all ObjectifiedDataElement classes 993 self.assertRaises(ValueError, objectify.DataElement, 1, 994 _xsi="foo:%s" % xsi)

995

996 - def test_data_element_pytypes(self):

997 for pytype, objclass in pytype2objclass.items(): 998 # 1 is a valid value for all ObjectifiedDataElement classes 999 pyval = 1 1000 value = objectify.DataElement(pyval, _pytype=pytype) 1001 self.assert_(isinstance(value, objclass), 1002 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1003 % (pyval, pytype, type(value), objclass))

1004

1005 - def test_data_element_pytype_none(self):

1006 pyval = 1 1007 pytype = "NoneType" 1008 objclass = objectify.NoneElement 1009 value = objectify.DataElement(pyval, _pytype=pytype) 1010 self.assert_(isinstance(value, objclass), 1011 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1012 % (pyval, pytype, type(value), objclass)) 1013 self.assertEquals(value.text, None) 1014 self.assertEquals(value.pyval, None)

1015

1016 - def test_data_element_pytype_none_compat(self):

1017 # pre-2.0 lxml called NoneElement "none" 1018 pyval = 1 1019 pytype = "none" 1020 objclass = objectify.NoneElement 1021 value = objectify.DataElement(pyval, _pytype=pytype) 1022 self.assert_(isinstance(value, objclass), 1023 "DataElement(%s, _pytype='%s') returns %s, expected %s" 1024 % (pyval, pytype, type(value), objclass)) 1025 self.assertEquals(value.text, None) 1026 self.assertEquals(value.pyval, None)

1027

1028 - def test_type_unregistered(self):

1029 Element = self.Element 1030 SubElement = self.etree.SubElement 1031 class MyFloat(float): 1032 pass

1033 root = Element("{objectified}root") 1034 root.myfloat = MyFloat(5.5) 1035 self.assert_(isinstance(root.myfloat, objectify.FloatElement)) 1036 self.assertEquals(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None)

1037

1038 - def test_data_element_unregistered(self):

1039 class MyFloat(float): 1040 pass

1041 value = objectify.DataElement(MyFloat(5.5)) 1042 self.assert_(isinstance(value, objectify.FloatElement)) 1043 self.assertEquals(value, 5.5) 1044 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), None) 1045

1046 - def test_schema_types(self):

1047 XML = self.XML 1048 root = XML('''\ 1049 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1050 true 1051 false 1052 1 1053 0 1054 1055 <f xsi:type="float">5</f> 1056 <f xsi:type="double">5</f> 1057 1058 <s xsi:type="string">5</s> 1059 <s xsi:type="normalizedString">5</s> 1060 <s xsi:type="token">5</s> 1061 <s xsi:type="language">5</s> 1062 <s xsi:type="Name">5</s> 1063 <s xsi:type="NCName">5</s> 1064 <s xsi:type="ID">5</s> 1065 <s xsi:type="IDREF">5</s> 1066 <s xsi:type="ENTITY">5</s> 1067 <s xsi:type="NMTOKEN">5</s> 1068 1069 <l xsi:type="integer">5</l> 1070 <l xsi:type="nonPositiveInteger">5</l> 1071 <l xsi:type="negativeInteger">5</l> 1072 <l xsi:type="long">5</l> 1073 <l xsi:type="nonNegativeInteger">5</l> 1074 <l xsi:type="unsignedLong">5</l> 1075 <l xsi:type="unsignedInt">5</l> 1076 <l xsi:type="positiveInteger">5</l> 1077 1078 5 1079 5 1080 5 1081 5 1082 5 1083 1084 <n xsi:nil="true"/> 1085 </root> 1086 ''') 1087 1088 for b in root.b: 1089 self.assert_(isinstance(b, objectify.BoolElement)) 1090 self.assertEquals(True, root.b[0]) 1091 self.assertEquals(False, root.b[1]) 1092 self.assertEquals(True, root.b[2]) 1093 self.assertEquals(False, root.b[3]) 1094 1095 for f in root.f: 1096 self.assert_(isinstance(f, objectify.FloatElement)) 1097 self.assertEquals(5, f) 1098 1099 for s in root.s: 1100 self.assert_(isinstance(s, objectify.StringElement)) 1101 self.assertEquals("5", s) 1102 1103 for i in root.i: 1104 self.assert_(isinstance(i, objectify.IntElement)) 1105 self.assertEquals(5, i) 1106 1107 for l in root.l: 1108 self.assert_(isinstance(l, objectify.IntElement)) 1109 self.assertEquals(5, i) 1110 1111 self.assert_(isinstance(root.n, objectify.NoneElement)) 1112 self.assertEquals(None, root.n)

1113

1114 - def test_schema_types_prefixed(self):

1115 XML = self.XML 1116 root = XML('''\ 1117 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1118 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1119 true 1120 false 1121 1 1122 0 1123 1124 <f xsi:type="xsd:float">5</f> 1125 <f xsi:type="xsd:double">5</f> 1126 1127 <s xsi:type="xsd:string">5</s> 1128 <s xsi:type="xsd:normalizedString">5</s> 1129 <s xsi:type="xsd:token">5</s> 1130 <s xsi:type="xsd:language">5</s> 1131 <s xsi:type="xsd:Name">5</s> 1132 <s xsi:type="xsd:NCName">5</s> 1133 <s xsi:type="xsd:ID">5</s> 1134 <s xsi:type="xsd:IDREF">5</s> 1135 <s xsi:type="xsd:ENTITY">5</s> 1136 <s xsi:type="xsd:NMTOKEN">5</s> 1137 1138 <l xsi:type="xsd:integer">5</l> 1139 <l xsi:type="xsd:nonPositiveInteger">5</l> 1140 <l xsi:type="xsd:negativeInteger">5</l> 1141 <l xsi:type="xsd:long">5</l> 1142 <l xsi:type="xsd:nonNegativeInteger">5</l> 1143 <l xsi:type="xsd:unsignedLong">5</l> 1144 <l xsi:type="xsd:unsignedInt">5</l> 1145 <l xsi:type="xsd:positiveInteger">5</l> 1146 1147 5 1148 5 1149 5 1150 5 1151 5 1152 1153 <n xsi:nil="true"/> 1154 </root> 1155 ''') 1156 1157 for b in root.b: 1158 self.assert_(isinstance(b, objectify.BoolElement)) 1159 self.assertEquals(True, root.b[0]) 1160 self.assertEquals(False, root.b[1]) 1161 self.assertEquals(True, root.b[2]) 1162 self.assertEquals(False, root.b[3]) 1163 1164 for f in root.f: 1165 self.assert_(isinstance(f, objectify.FloatElement)) 1166 self.assertEquals(5, f) 1167 1168 for s in root.s: 1169 self.assert_(isinstance(s, objectify.StringElement)) 1170 self.assertEquals("5", s) 1171 1172 for i in root.i: 1173 self.assert_(isinstance(i, objectify.IntElement)) 1174 self.assertEquals(5, i) 1175 1176 for l in root.l: 1177 self.assert_(isinstance(l, objectify.IntElement)) 1178 self.assertEquals(5, l) 1179 1180 self.assert_(isinstance(root.n, objectify.NoneElement)) 1181 self.assertEquals(None, root.n)

1182

1183 - def test_type_str_sequence(self):

1184 XML = self.XML 1185 root = XML(_bytes('<root>whytry</root>')) 1186 strs = [ str(s) for s in root.b ] 1187 self.assertEquals(["why", "try"], 1188 strs)

1189

1190 - def test_type_str_cmp(self):

1191 XML = self.XML 1192 root = XML(_bytes('<root>testtaste</root>')) 1193 self.assertFalse(root.b[0] < root.b[1]) 1194 self.assertFalse(root.b[0] <= root.b[1]) 1195 self.assertFalse(root.b[0] == root.b[1]) 1196 1197 self.assert_(root.b[0] != root.b[1]) 1198 self.assert_(root.b[0] >= root.b[1]) 1199 self.assert_(root.b[0] > root.b[1]) 1200 1201 self.assertEquals(root.b[0], "test") 1202 self.assertEquals("test", root.b[0]) 1203 1204 self.assertEquals("", root.b[2]) 1205 self.assertEquals(root.b[2], "") 1206 self.assertEquals("", root.b[3]) 1207 self.assertEquals(root.b[3], "") 1208 self.assertEquals(root.b[2], root.b[3]) 1209 1210 root.b = "test" 1211 self.assert_(root.b) 1212 root.b = "" 1213 self.assertFalse(root.b) 1214 self.assertEquals(root.b, "") 1215 self.assertEquals("", root.b)

1216

1217 - def test_type_int_cmp(self):

1218 XML = self.XML 1219 root = XML(_bytes('<root>56</root>')) 1220 self.assert_(root.b[0] < root.b[1]) 1221 self.assert_(root.b[0] <= root.b[1]) 1222 self.assert_(root.b[0] != root.b[1]) 1223 1224 self.assertFalse(root.b[0] == root.b[1]) 1225 self.assertFalse(root.b[0] >= root.b[1]) 1226 self.assertFalse(root.b[0] > root.b[1]) 1227 1228 self.assertEquals(root.b[0], 5) 1229 self.assertEquals(5, root.b[0]) 1230 self.assertNotEquals(root.b[0], "5") 1231 1232 root.b = 5 1233 self.assert_(root.b) 1234 root.b = 0 1235 self.assertFalse(root.b)

1236 1237 # float + long share the NumberElement implementation with int 1238

1239 - def test_type_bool_cmp(self):

1240 XML = self.XML 1241 root = XML(_bytes('<root>falsetrue</root>')) 1242 self.assert_(root.b[0] < root.b[1]) 1243 self.assert_(root.b[0] <= root.b[1]) 1244 self.assert_(root.b[0] != root.b[1]) 1245 1246 self.assertFalse(root.b[0] == root.b[1]) 1247 self.assertFalse(root.b[0] >= root.b[1]) 1248 self.assertFalse(root.b[0] > root.b[1]) 1249 1250 self.assertFalse(root.b[0]) 1251 self.assert_(root.b[1]) 1252 1253 self.assertEquals(root.b[0], False) 1254 self.assertEquals(False, root.b[0]) 1255 self.assert_(root.b[0] < 5) 1256 self.assert_(5 > root.b[0]) 1257 1258 root.b = True 1259 self.assert_(root.b) 1260 root.b = False 1261 self.assertFalse(root.b)

1262

1263 - def test_type_none_cmp(self):

1264 XML = self.XML 1265 root = XML(_bytes(""" 1266 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1267  1268 </root>""")) 1269 self.assert_(root.b[0] == root.b[1]) 1270 self.assertFalse(root.b[0]) 1271 self.assertEquals(root.b[0], None) 1272 self.assertEquals(None, root.b[0])

1273 1274 # doesn't work in Py3: 1275 1276 #for comparison in ["abc", 5, 7.3, True, [], ()]: 1277 # none = root.b[1] 1278 # self.assert_(none < comparison, "%s (%s) should be < %s" % 1279 # (none, type(none), comparison) ) 1280 # self.assert_(comparison > none, "%s should be > %s (%s)" % 1281 # (comparison, none, type(none)) ) 1282

1283 - def test_dataelement_xsi(self):

1284 el = objectify.DataElement(1, _xsi="string") 1285 self.assertEquals( 1286 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1287 'xsd:string')

1288

1289 - def test_dataelement_xsi_nsmap(self):

1290 el = objectify.DataElement(1, _xsi="string", 1291 nsmap={'schema': XML_SCHEMA_NS}) 1292 self.assertEquals( 1293 el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 1294 'schema:string')

1295

1296 - def test_dataelement_xsi_prefix_error(self):

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

1299

1300 - def test_pytype_annotation(self):

1301 XML = self.XML 1302 root = XML(_bytes('''\ 1303 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1304 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1305 5 1306 test 1307 <c>1.1</c> 1308 <c>\uF8D2</c> 1309 <x>true</x> 1310 <n xsi:nil="true" /> 1311 <n></n> 1312 5 1313 5 1314 <s xsi:type="string">23</s> 1315 <s py:pytype="str">42</s> 1316 <f py:pytype="float">300</f> 1317 <l py:pytype="long">2</l> 1318 <t py:pytype="TREE"></t> 1319 </a> 1320 ''')) 1321 objectify.annotate(root) 1322 1323 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1324 for c in root.iterchildren() ] 1325 self.assertEquals("int", child_types[ 0]) 1326 self.assertEquals("str", child_types[ 1]) 1327 self.assertEquals("float", child_types[ 2]) 1328 self.assertEquals("str", child_types[ 3]) 1329 self.assertEquals("bool", child_types[ 4]) 1330 self.assertEquals("NoneType", child_types[ 5]) 1331 self.assertEquals(None, child_types[ 6]) 1332 self.assertEquals("float", child_types[ 7]) 1333 self.assertEquals("float", child_types[ 8]) 1334 self.assertEquals("str", child_types[ 9]) 1335 self.assertEquals("int", child_types[10]) 1336 self.assertEquals("int", child_types[11]) 1337 self.assertEquals("int", child_types[12]) 1338 self.assertEquals(None, child_types[13]) 1339 1340 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1341

1342 - def test_pytype_annotation_empty(self):

1343 XML = self.XML 1344 root = XML(_bytes('''\ 1345 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1346 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1347 <n></n> 1348 </a> 1349 ''')) 1350 objectify.annotate(root) 1351 1352 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1353 for c in root.iterchildren() ] 1354 self.assertEquals(None, child_types[0]) 1355 1356 objectify.annotate(root, empty_pytype="str") 1357 1358 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1359 for c in root.iterchildren() ] 1360 self.assertEquals("str", child_types[0])

1361

1362 - def test_pytype_annotation_use_old(self):

1363 XML = self.XML 1364 root = XML(_bytes('''\ 1365 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1366 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1367 5 1368 test 1369 <c>1.1</c> 1370 <c>\uF8D2</c> 1371 <x>true</x> 1372 <n xsi:nil="true" /> 1373 <n></n> 1374 5 1375 5 1376 <s xsi:type="string">23</s> 1377 <s py:pytype="str">42</s> 1378 <f py:pytype="float">300</f> 1379 <l py:pytype="long">2</l> 1380 <t py:pytype="TREE"></t> 1381 </a> 1382 ''')) 1383 objectify.annotate(root, ignore_old=False) 1384 1385 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1386 for c in root.iterchildren() ] 1387 self.assertEquals("int", child_types[ 0]) 1388 self.assertEquals("str", child_types[ 1]) 1389 self.assertEquals("float", child_types[ 2]) 1390 self.assertEquals("str", child_types[ 3]) 1391 self.assertEquals("bool", child_types[ 4]) 1392 self.assertEquals("NoneType", child_types[ 5]) 1393 self.assertEquals(None, child_types[ 6]) 1394 self.assertEquals("float", child_types[ 7]) 1395 self.assertEquals("float", child_types[ 8]) 1396 self.assertEquals("str", child_types[ 9]) 1397 self.assertEquals("str", child_types[10]) 1398 self.assertEquals("float", child_types[11]) 1399 self.assertEquals("int", child_types[12]) 1400 self.assertEquals(TREE_PYTYPE, child_types[13]) 1401 1402 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1403

1404 - def test_pytype_xsitype_annotation(self):

1405 XML = self.XML 1406 root = XML(_bytes('''\ 1407 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1408 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1409 5 1410 test 1411 <c>1.1</c> 1412 <c>\uF8D2</c> 1413 <x>true</x> 1414 <n xsi:nil="true" /> 1415 <n></n> 1416 5 1417 5 1418 <s xsi:type="string">23</s> 1419 <s py:pytype="str">42</s> 1420 <f py:pytype="float">300</f> 1421 <l py:pytype="long">2</l> 1422 <t py:pytype="TREE"></t> 1423 </a> 1424 ''')) 1425 objectify.annotate(root, ignore_old=False, ignore_xsi=False, 1426 annotate_xsi=1, annotate_pytype=1) 1427 1428 # check py annotations 1429 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1430 for c in root.iterchildren() ] 1431 self.assertEquals("int", child_types[ 0]) 1432 self.assertEquals("str", child_types[ 1]) 1433 self.assertEquals("float", child_types[ 2]) 1434 self.assertEquals("str", child_types[ 3]) 1435 self.assertEquals("bool", child_types[ 4]) 1436 self.assertEquals("NoneType", child_types[ 5]) 1437 self.assertEquals(None, child_types[ 6]) 1438 self.assertEquals("float", child_types[ 7]) 1439 self.assertEquals("float", child_types[ 8]) 1440 self.assertEquals("str", child_types[ 9]) 1441 self.assertEquals("str", child_types[10]) 1442 self.assertEquals("float", child_types[11]) 1443 self.assertEquals("int", child_types[12]) 1444 self.assertEquals(TREE_PYTYPE, child_types[13]) 1445 1446 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1447 1448 child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1449 for c in root.iterchildren() ] 1450 1451 # check xsi annotations 1452 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1453 for c in root.iterchildren() ] 1454 self.assertEquals("xsd:integer", child_types[ 0]) 1455 self.assertEquals("xsd:string", child_types[ 1]) 1456 self.assertEquals("xsd:double", child_types[ 2]) 1457 self.assertEquals("xsd:string", child_types[ 3]) 1458 self.assertEquals("xsd:boolean", child_types[ 4]) 1459 self.assertEquals(None, child_types[ 5]) 1460 self.assertEquals(None, child_types[ 6]) 1461 self.assertEquals("xsd:double", child_types[ 7]) 1462 self.assertEquals("xsd:float", child_types[ 8]) 1463 self.assertEquals("xsd:string", child_types[ 9]) 1464 self.assertEquals("xsd:string", child_types[10]) 1465 self.assertEquals("xsd:double", child_types[11]) 1466 self.assertEquals("xsd:integer", child_types[12]) 1467 self.assertEquals(None, child_types[13]) 1468 1469 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1470

1471 - def test_xsiannotate_use_old(self):

1472 XML = self.XML 1473 root = XML(_bytes('''\ 1474 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1475 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1476 5 1477 test 1478 <c>1.1</c> 1479 <c>\uF8D2</c> 1480 <x>true</x> 1481 <n xsi:nil="true" /> 1482 <n></n> 1483 5 1484 5 1485 <s xsi:type="string">23</s> 1486 <s py:pytype="str">42</s> 1487 <f py:pytype="float">300</f> 1488 <l py:pytype="long">2</l> 1489 <t py:pytype="TREE"></t> 1490 </a> 1491 ''')) 1492 objectify.xsiannotate(root, ignore_old=False) 1493 1494 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1495 for c in root.iterchildren() ] 1496 self.assertEquals("xsd:integer", child_types[ 0]) 1497 self.assertEquals("xsd:string", child_types[ 1]) 1498 self.assertEquals("xsd:double", child_types[ 2]) 1499 self.assertEquals("xsd:string", child_types[ 3]) 1500 self.assertEquals("xsd:boolean", child_types[ 4]) 1501 self.assertEquals(None, child_types[ 5]) 1502 self.assertEquals(None, child_types[ 6]) 1503 self.assertEquals("xsd:double", child_types[ 7]) 1504 self.assertEquals("xsd:float", child_types[ 8]) 1505 self.assertEquals("xsd:string", child_types[ 9]) 1506 self.assertEquals("xsd:string", child_types[10]) 1507 self.assertEquals("xsd:double", child_types[11]) 1508 self.assertEquals("xsd:integer", child_types[12]) 1509 self.assertEquals(None, child_types[13])

1510

1511 - def test_pyannotate_ignore_old(self):

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

1552

1553 - def test_pyannotate_empty(self):

1554 XML = self.XML 1555 root = XML('''\ 1556 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1557 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1558 <n></n> 1559 </a> 1560 ''') 1561 objectify.pyannotate(root) 1562 1563 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1564 for c in root.iterchildren() ] 1565 self.assertEquals(None, child_types[0]) 1566 1567 objectify.annotate(root, empty_pytype="str") 1568 1569 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1570 for c in root.iterchildren() ] 1571 self.assertEquals("str", child_types[0])

1572

1573 - def test_pyannotate_use_old(self):

1574 XML = self.XML 1575 root = XML('''\ 1576 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1577 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1578 5 1579 test 1580 <c>1.1</c> 1581 <c>\uF8D2</c> 1582 <x>true</x> 1583 <n xsi:nil="true" /> 1584 <n></n> 1585 5 1586 5 1587 <s xsi:type="string">23</s> 1588 <s py:pytype="str">42</s> 1589 <f py:pytype="float">300</f> 1590 <l py:pytype="long">2</l> 1591 <t py:pytype="TREE"></t> 1592 </a> 1593 ''') 1594 objectify.pyannotate(root) 1595 1596 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1597 for c in root.iterchildren() ] 1598 self.assertEquals("int", child_types[ 0]) 1599 self.assertEquals("str", child_types[ 1]) 1600 self.assertEquals("float", child_types[ 2]) 1601 self.assertEquals("str", child_types[ 3]) 1602 self.assertEquals("bool", child_types[ 4]) 1603 self.assertEquals("NoneType", child_types[ 5]) 1604 self.assertEquals(None, child_types[ 6]) 1605 self.assertEquals("float", child_types[ 7]) 1606 self.assertEquals("float", child_types[ 8]) 1607 self.assertEquals("str", child_types[ 9]) 1608 self.assertEquals("str", child_types[10]) 1609 self.assertEquals("float", child_types[11]) 1610 self.assertEquals("int", child_types[12]) 1611 self.assertEquals(TREE_PYTYPE, child_types[13]) 1612 1613 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1614

1615 - def test_xsiannotate_ignore_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=True) 1637 1638 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1639 for c in root.iterchildren() ] 1640 self.assertEquals("xsd:integer", child_types[ 0]) 1641 self.assertEquals("xsd:string", child_types[ 1]) 1642 self.assertEquals("xsd:double", child_types[ 2]) 1643 self.assertEquals("xsd:string", child_types[ 3]) 1644 self.assertEquals("xsd:boolean", child_types[ 4]) 1645 self.assertEquals(None, child_types[ 5]) 1646 self.assertEquals(None, child_types[ 6]) 1647 self.assertEquals("xsd:integer", child_types[ 7]) 1648 self.assertEquals("xsd:integer", child_types[ 8]) 1649 self.assertEquals("xsd:integer", child_types[ 9]) 1650 self.assertEquals("xsd:string", child_types[10]) 1651 self.assertEquals("xsd:double", child_types[11]) 1652 self.assertEquals("xsd:integer", child_types[12]) 1653 self.assertEquals(None, child_types[13]) 1654 1655 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1656

1657 - def test_deannotate(self):

1658 XML = self.XML 1659 root = XML(_bytes('''\ 1660 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1661 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1662 5 1663 test 1664 <c>1.1</c> 1665 <c>\uF8D2</c> 1666 <x>true</x> 1667 <n xsi:nil="true" /> 1668 <n></n> 1669 5 1670 5 1671 <s xsi:type="string">23</s> 1672 <s py:pytype="str">42</s> 1673 <f py:pytype="float">300</f> 1674 <l py:pytype="long">2</l> 1675 <t py:pytype="TREE"></t> 1676 </a> 1677 ''')) 1678 objectify.deannotate(root) 1679 1680 for c in root.getiterator(): 1681 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 1682 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1683 1684 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))

1685

1686 - def test_xsinil_deannotate(self):

1687 XML = self.XML 1688 root = XML(_bytes('''\ 1689 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1690 xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 1691 5 1692 test 1693 <c>1.1</c> 1694 <c>\uF8D2</c> 1695 <x>true</x> 1696 <n xsi:nil="true" /> 1697 <n></n> 1698 5 1699 5 1700 <s xsi:type="string">23</s> 1701 <s py:pytype="str">42</s> 1702 <f py:pytype="float">300</f> 1703 <l py:pytype="long">2</l> 1704 <t py:pytype="TREE"></t> 1705 </a> 1706 ''')) 1707 objectify.annotate( 1708 root, ignore_old=False, ignore_xsi=False, annotate_xsi=True, 1709 empty_pytype='str', empty_type='string') 1710 objectify.deannotate(root, pytype=False, xsi=False, xsi_nil=True) 1711 1712 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1713 for c in root.iterchildren() ] 1714 self.assertEquals("xsd:integer", child_types[ 0]) 1715 self.assertEquals("xsd:string", child_types[ 1]) 1716 self.assertEquals("xsd:double", child_types[ 2]) 1717 self.assertEquals("xsd:string", child_types[ 3]) 1718 self.assertEquals("xsd:boolean", child_types[ 4]) 1719 self.assertEquals(None, child_types[ 5]) 1720 self.assertEquals("xsd:string", child_types[ 6]) 1721 self.assertEquals("xsd:double", child_types[ 7]) 1722 self.assertEquals("xsd:float", child_types[ 8]) 1723 self.assertEquals("xsd:string", child_types[ 9]) 1724 self.assertEquals("xsd:string", child_types[10]) 1725 self.assertEquals("xsd:double", child_types[11]) 1726 self.assertEquals("xsd:integer", child_types[12]) 1727 self.assertEquals(None, child_types[13]) 1728 1729 self.assertEquals(None, root.n.get(XML_SCHEMA_NIL_ATTR)) 1730 1731 for c in root.iterchildren(): 1732 self.assertNotEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 1733 # these have no equivalent in xsi:type 1734 if (c.get(objectify.PYTYPE_ATTRIBUTE) not in [TREE_PYTYPE, 1735 "NoneType"]): 1736 self.assertNotEquals( 1737 None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))

1738

1739 - def test_xsitype_deannotate(self):

1740 XML = self.XML 1741 root = XML(_bytes('''\ 1742 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1743 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1744 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1745 5 1746 test 1747 <c>1.1</c> 1748 <c>\uF8D2</c> 1749 <x>true</x> 1750 <n xsi:nil="true" /> 1751 <n></n> 1752 5 1753 5 1754 <s xsi:type="xsd:string">23</s> 1755 <s py:pytype="str">42</s> 1756 <f py:pytype="float">300</f> 1757 <l py:pytype="long">2</l> 1758 <t py:pytype="TREE"></t> 1759 </a> 1760 ''')) 1761 objectify.annotate(root) 1762 objectify.deannotate(root, pytype=False) 1763 1764 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 1765 for c in root.iterchildren() ] 1766 self.assertEquals("int", child_types[ 0]) 1767 self.assertEquals("str", child_types[ 1]) 1768 self.assertEquals("float", child_types[ 2]) 1769 self.assertEquals("str", child_types[ 3]) 1770 self.assertEquals("bool", child_types[ 4]) 1771 self.assertEquals("NoneType", child_types[ 5]) 1772 self.assertEquals(None, child_types[ 6]) 1773 self.assertEquals("float", child_types[ 7]) 1774 self.assertEquals("float", child_types[ 8]) 1775 self.assertEquals("str", child_types[ 9]) 1776 self.assertEquals("int", child_types[10]) 1777 self.assertEquals("int", child_types[11]) 1778 self.assertEquals("int", child_types[12]) 1779 self.assertEquals(None, child_types[13]) 1780 1781 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1782 1783 for c in root.getiterator(): 1784 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))

1785

1786 - def test_pytype_deannotate(self):

1787 XML = self.XML 1788 root = XML(_bytes('''\ 1789 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 1790 xmlns:py="http://codespeak.net/lxml/objectify/pytype" 1791 xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 1792 5 1793 test 1794 <c xsi:type="xsd:float">1.1</c> 1795 <c xsi:type="xsd:string">\uF8D2</c> 1796 <x xsi:type="xsd:boolean">true</x> 1797 <n xsi:nil="true" /> 1798 <n></n> 1799 5 1800 5 1801 <s xsi:type="xsd:string">23</s> 1802 <s xsi:type="xsd:string">42</s> 1803 <f xsi:type="xsd:float">300</f> 1804 <l xsi:type="xsd:long">2</l> 1805 <t py:pytype="TREE"></t> 1806 </a> 1807 ''')) 1808 objectify.annotate(root) 1809 objectify.deannotate(root, xsi=False) 1810 1811 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 1812 for c in root.iterchildren() ] 1813 self.assertEquals("xsd:int", child_types[ 0]) 1814 self.assertEquals("xsd:string", child_types[ 1]) 1815 self.assertEquals("xsd:float", child_types[ 2]) 1816 self.assertEquals("xsd:string", child_types[ 3]) 1817 self.assertEquals("xsd:boolean", child_types[ 4]) 1818 self.assertEquals(None, child_types[ 5]) 1819 self.assertEquals(None, child_types[ 6]) 1820 self.assertEquals("xsd:double", child_types[ 7]) 1821 self.assertEquals("xsd:float", child_types[ 8]) 1822 self.assertEquals("xsd:string", child_types[ 9]) 1823 self.assertEquals("xsd:string", child_types[10]) 1824 self.assertEquals("xsd:float", child_types[11]) 1825 self.assertEquals("xsd:long", child_types[12]) 1826 self.assertEquals(None, child_types[13]) 1827 1828 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 1829 1830 for c in root.getiterator(): 1831 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))

1832

1833 - def test_change_pytype_attribute(self):

1834 XML = self.XML 1835 1836 xml = _bytes('''\ 1837 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 1838 5 1839 test 1840 <c>1.1</c> 1841 <c>\uF8D2</c> 1842 <x>true</x> 1843 <n xsi:nil="true" /> 1844 <n></n> 1845 5 1846 </a> 1847 ''') 1848 1849 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1850 objectify.set_pytype_attribute_tag("{TEST}test") 1851 1852 root = XML(xml) 1853 objectify.annotate(root) 1854 1855 attribs = root.xpath("//@py:%s" % pytype_name, 1856 namespaces={"py" : pytype_ns}) 1857 self.assertEquals(0, len(attribs)) 1858 attribs = root.xpath("//@py:test", 1859 namespaces={"py" : "TEST"}) 1860 self.assertEquals(7, len(attribs)) 1861 1862 objectify.set_pytype_attribute_tag() 1863 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 1864 1865 self.assertNotEqual("test", pytype_ns.lower()) 1866 self.assertNotEqual("test", pytype_name.lower()) 1867 1868 root = XML(xml) 1869 attribs = root.xpath("//@py:%s" % pytype_name, 1870 namespaces={"py" : pytype_ns}) 1871 self.assertEquals(0, len(attribs)) 1872 1873 objectify.annotate(root) 1874 attribs = root.xpath("//@py:%s" % pytype_name, 1875 namespaces={"py" : pytype_ns}) 1876 self.assertEquals(7, len(attribs))

1877

1878 - def test_registered_types(self):

1879 orig_types = objectify.getRegisteredTypes() 1880 orig_types[0].unregister() 1881 self.assertEquals(orig_types[1:], objectify.getRegisteredTypes()) 1882 1883 class NewType(objectify.ObjectifiedDataElement): 1884 pass

1885 1886 def checkMyType(s): 1887 return True 1888 1889 pytype = objectify.PyType("mytype", checkMyType, NewType) 1890 self.assert_(pytype not in objectify.getRegisteredTypes()) 1891 pytype.register() 1892 self.assert_(pytype in objectify.getRegisteredTypes()) 1893 pytype.unregister() 1894 self.assert_(pytype not in objectify.getRegisteredTypes()) 1895 1896 pytype.register(before = [objectify.getRegisteredTypes()[0].name]) 1897 self.assertEquals(pytype, objectify.getRegisteredTypes()[0]) 1898 pytype.unregister() 1899 1900 pytype.register(after = [objectify.getRegisteredTypes()[0].name]) 1901 self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0]) 1902 pytype.unregister() 1903 1904 self.assertRaises(ValueError, pytype.register, 1905 before = [objectify.getRegisteredTypes()[0].name], 1906 after = [objectify.getRegisteredTypes()[1].name]) 1907

1908 - def test_registered_type_stringify(self):

1909 from datetime import datetime 1910 def parse_date(value): 1911 if len(value) != 14: 1912 raise ValueError(value) 1913 Y = int(value[0:4]) 1914 M = int(value[4:6]) 1915 D = int(value[6:8]) 1916 h = int(value[8:10]) 1917 m = int(value[10:12]) 1918 s = int(value[12:14]) 1919 return datetime(Y, M, D, h, m, s)

1920 1921 def stringify_date(date): 1922 return date.strftime("%Y%m%d%H%M%S") 1923 1924 class DatetimeElement(objectify.ObjectifiedDataElement): 1925 def pyval(self): 1926 return parse_date(self.text) 1927 pyval = property(pyval) 1928 1929 datetime_type = objectify.PyType( 1930 "datetime", parse_date, DatetimeElement, stringify_date) 1931 datetime_type.xmlSchemaTypes = "dateTime" 1932 datetime_type.register() 1933 1934 NAMESPACE = "http://foo.net/xmlns" 1935 NAMESPACE_MAP = {'ns': NAMESPACE} 1936 1937 r = objectify.Element("{%s}root" % NAMESPACE, nsmap=NAMESPACE_MAP) 1938 time = datetime.now() 1939 r.date = time 1940 1941 self.assert_(isinstance(r.date, DatetimeElement)) 1942 self.assert_(isinstance(r.date.pyval, datetime)) 1943 1944 self.assertEquals(r.date.pyval, parse_date(stringify_date(time))) 1945 self.assertEquals(r.date.text, stringify_date(time)) 1946 1947 r.date = objectify.E.date(time) 1948 1949 self.assert_(isinstance(r.date, DatetimeElement)) 1950 self.assert_(isinstance(r.date.pyval, datetime)) 1951 1952 self.assertEquals(r.date.pyval, parse_date(stringify_date(time))) 1953 self.assertEquals(r.date.text, stringify_date(time)) 1954

1955 - def test_object_path(self):

1956 root = self.XML(xml_str) 1957 path = objectify.ObjectPath( "root.c1.c2" ) 1958 self.assertEquals(root.c1.c2.text, path.find(root).text) 1959 self.assertEquals(root.c1.c2.text, path(root).text)

1960

1961 - def test_object_path_list(self):

1962 root = self.XML(xml_str) 1963 path = objectify.ObjectPath( ['root', 'c1', 'c2'] ) 1964 self.assertEquals(root.c1.c2.text, path.find(root).text) 1965 self.assertEquals(root.c1.c2.text, path(root).text)

1966

1967 - def test_object_path_fail(self):

1968 root = self.XML(xml_str) 1969 path = objectify.ObjectPath( "root.c1.c99" ) 1970 self.assertRaises(AttributeError, path, root)

1971

1972 - def test_object_path_default_absolute(self):

1973 root = self.XML(xml_str) 1974 path = objectify.ObjectPath( "root.c1.c99" ) 1975 self.assertEquals(None, path(root, None)) 1976 path = objectify.ObjectPath( "root.c99.c2" ) 1977 self.assertEquals(None, path(root, None)) 1978 path = objectify.ObjectPath( "notroot.c99.c2" ) 1979 self.assertEquals(None, path(root, None))

1980

1981 - def test_object_path_default_relative(self):

1982 root = self.XML(xml_str) 1983 path = objectify.ObjectPath( ".c1.c99" ) 1984 self.assertEquals(None, path(root, None)) 1985 path = objectify.ObjectPath( ".c99.c2" ) 1986 self.assertEquals(None, path(root, None))

1987

1988 - def test_object_path_syntax(self):

1989 root = self.XML(xml_str) 1990 path = objectify.ObjectPath("root . {objectified}c1. c2") 1991 self.assertEquals(root.c1.c2.text, path(root).text) 1992 1993 path = objectify.ObjectPath(" root.{objectified} c1.c2 [ 0 ] ") 1994 self.assertEquals(root.c1.c2.text, path(root).text)

1995

1996 - def test_object_path_fail_parse_empty(self):

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

1998

1999 - def test_object_path_fail_parse_empty_list(self):

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

2001

2002 - def test_object_path_hasattr(self):

2003 root = self.XML(xml_str) 2004 path = objectify.ObjectPath( "root" ) 2005 self.assert_(path.hasattr(root)) 2006 path = objectify.ObjectPath( "root.c1" ) 2007 self.assert_(path.hasattr(root)) 2008 path = objectify.ObjectPath( "root.c1.c2" ) 2009 self.assert_(path.hasattr(root)) 2010 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 2011 self.assert_(path.hasattr(root)) 2012 path = objectify.ObjectPath( "root.c1.c2[1]" ) 2013 self.assert_(path.hasattr(root)) 2014 path = objectify.ObjectPath( "root.c1.c2[2]" ) 2015 self.assert_(path.hasattr(root)) 2016 path = objectify.ObjectPath( "root.c1.c2[3]" ) 2017 self.assertFalse(path.hasattr(root)) 2018 path = objectify.ObjectPath( "root.c1[1].c2" ) 2019 self.assertFalse(path.hasattr(root))

2020

2021 - def test_object_path_dot(self):

2022 root = self.XML(xml_str) 2023 path = objectify.ObjectPath( "." ) 2024 self.assertEquals(root.c1.c2.text, path(root).c1.c2.text)

2025

2026 - def test_object_path_dot_list(self):

2027 root = self.XML(xml_str) 2028 path = objectify.ObjectPath( [''] ) 2029 self.assertEquals(root.c1.c2.text, path(root).c1.c2.text)

2030

2031 - def test_object_path_dot_root(self):

2032 root = self.XML(xml_str) 2033 path = objectify.ObjectPath( ".c1.c2" ) 2034 self.assertEquals(root.c1.c2.text, path(root).text)

2035

2036 - def test_object_path_dot_root_list(self):

2037 root = self.XML(xml_str) 2038 path = objectify.ObjectPath( ['', 'c1', 'c2'] ) 2039 self.assertEquals(root.c1.c2.text, path(root).text)

2040

2041 - def test_object_path_index(self):

2042 root = self.XML(xml_str) 2043 path = objectify.ObjectPath( "root.c1[0].c2[0]" ) 2044 self.assertEquals(root.c1.c2.text, path(root).text) 2045 2046 path = objectify.ObjectPath( "root.c1[0].c2" ) 2047 self.assertEquals(root.c1.c2.text, path(root).text) 2048 2049 path = objectify.ObjectPath( "root.c1[0].c2[1]" ) 2050 self.assertEquals(root.c1.c2[1].text, path(root).text) 2051 2052 path = objectify.ObjectPath( "root.c1.c2[2]" ) 2053 self.assertEquals(root.c1.c2[2].text, path(root).text) 2054 2055 path = objectify.ObjectPath( "root.c1.c2[-1]" ) 2056 self.assertEquals(root.c1.c2[-1].text, path(root).text) 2057 2058 path = objectify.ObjectPath( "root.c1.c2[-3]" ) 2059 self.assertEquals(root.c1.c2[-3].text, path(root).text)

2060

2061 - def test_object_path_index_list(self):

2062 root = self.XML(xml_str) 2063 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] ) 2064 self.assertEquals(root.c1.c2.text, path(root).text) 2065 2066 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] ) 2067 self.assertEquals(root.c1.c2[2].text, path(root).text) 2068 2069 path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] ) 2070 self.assertEquals(root.c1.c2[2].text, path(root).text) 2071 2072 path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] ) 2073 self.assertEquals(root.c1.c2[-1].text, path(root).text) 2074 2075 path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] ) 2076 self.assertEquals(root.c1.c2[-3].text, path(root).text)

2077

2078 - def test_object_path_index_fail_parse(self):

2079 self.assertRaises(ValueError, objectify.ObjectPath, 2080 "root.c1[0].c2[-1-2]") 2081 self.assertRaises(ValueError, objectify.ObjectPath, 2082 ['root', 'c1[0]', 'c2[-1-2]']) 2083 2084 self.assertRaises(ValueError, objectify.ObjectPath, 2085 "root[2].c1.c2") 2086 self.assertRaises(ValueError, objectify.ObjectPath, 2087 ['root[2]', 'c1', 'c2']) 2088 2089 self.assertRaises(ValueError, objectify.ObjectPath, 2090 []) 2091 self.assertRaises(ValueError, objectify.ObjectPath, 2092 ['', '', ''])

2093

2094 - def test_object_path_index_fail_lookup(self):

2095 root = self.XML(xml_str) 2096 path = objectify.ObjectPath("root.c1[9999].c2") 2097 self.assertRaises(AttributeError, path, root) 2098 2099 path = objectify.ObjectPath("root.c1[0].c2[9999]") 2100 self.assertRaises(AttributeError, path, root) 2101 2102 path = objectify.ObjectPath(".c1[9999].c2[0]") 2103 self.assertRaises(AttributeError, path, root) 2104 2105 path = objectify.ObjectPath("root.c1[-2].c2") 2106 self.assertRaises(AttributeError, path, root) 2107 2108 path = objectify.ObjectPath("root.c1[0].c2[-4]") 2109 self.assertRaises(AttributeError, path, root)

2110

2111 - def test_object_path_ns(self):

2112 root = self.XML(xml_str) 2113 path = objectify.ObjectPath( "{objectified}root.c1.c2" ) 2114 self.assertEquals(root.c1.c2.text, path.find(root).text) 2115 path = objectify.ObjectPath( "{objectified}root.{objectified}c1.c2" ) 2116 self.assertEquals(root.c1.c2.text, path.find(root).text) 2117 path = objectify.ObjectPath( "root.{objectified}c1.{objectified}c2" ) 2118 self.assertEquals(root.c1.c2.text, path.find(root).text) 2119 path = objectify.ObjectPath( "root.c1.{objectified}c2" ) 2120 self.assertEquals(root.c1.c2.text, path.find(root).text) 2121 path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 2122 self.assertEquals(getattr(root.c1, '{otherNS}c2').text, 2123 path.find(root).text)

2124

2125 - def test_object_path_ns_list(self):

2126 root = self.XML(xml_str) 2127 path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] ) 2128 self.assertEquals(root.c1.c2.text, path.find(root).text) 2129 path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] ) 2130 self.assertEquals(root.c1.c2.text, path.find(root).text) 2131 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] ) 2132 self.assertEquals(root.c1.c2.text, path.find(root).text) 2133 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] ) 2134 self.assertEquals(root.c1.c2[2].text, path.find(root).text) 2135 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] ) 2136 self.assertEquals(root.c1.c2.text, path.find(root).text) 2137 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] ) 2138 self.assertEquals(root.c1.c2[2].text, path.find(root).text) 2139 path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] ) 2140 self.assertEquals(getattr(root.c1, '{otherNS}c2').text, 2141 path.find(root).text)

2142

2143 - def test_object_path_set(self):

2144 root = self.XML(xml_str) 2145 path = objectify.ObjectPath( "root.c1.c2" ) 2146 self.assertEquals(root.c1.c2.text, path.find(root).text) 2147 self.assertEquals("1", root.c1.c2[1].text) 2148 2149 new_value = "my new value" 2150 path.setattr(root, new_value) 2151 2152 self.assertEquals(new_value, root.c1.c2.text) 2153 self.assertEquals(new_value, path(root).text) 2154 self.assertEquals("1", root.c1.c2[1].text)

2155

2156 - def test_object_path_set_element(self):

2157 root = self.XML(xml_str) 2158 path = objectify.ObjectPath( "root.c1.c2" ) 2159 self.assertEquals(root.c1.c2.text, path.find(root).text) 2160 self.assertEquals("1", root.c1.c2[1].text) 2161 2162 new_el = self.Element("{objectified}test") 2163 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2164 path.setattr(root, new_el.sub) 2165 2166 self.assertEquals("ATTR", root.c1.c2.get("myattr")) 2167 self.assertEquals("TEST", root.c1.c2.a.text) 2168 self.assertEquals("TEST", path(root).a.text) 2169 self.assertEquals("1", root.c1.c2[1].text)

2170

2171 - def test_object_path_set_create(self):

2172 root = self.XML(xml_str) 2173 path = objectify.ObjectPath( "root.c1.c99" ) 2174 self.assertRaises(AttributeError, path.find, root) 2175 2176 new_value = "my new value" 2177 path.setattr(root, new_value) 2178 2179 self.assertEquals(1, len(root.c1.c99)) 2180 self.assertEquals(new_value, root.c1.c99.text) 2181 self.assertEquals(new_value, path(root).text)

2182

2183 - def test_object_path_set_create_element(self):

2184 root = self.XML(xml_str) 2185 path = objectify.ObjectPath( "root.c1.c99" ) 2186 self.assertRaises(AttributeError, path.find, root) 2187 2188 new_el = self.Element("{objectified}test") 2189 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2190 path.setattr(root, new_el.sub) 2191 2192 self.assertEquals(1, len(root.c1.c99)) 2193 self.assertEquals("ATTR", root.c1.c99.get("myattr")) 2194 self.assertEquals("TEST", root.c1.c99.a.text) 2195 self.assertEquals("TEST", path(root).a.text)

2196

2197 - def test_object_path_set_create_list(self):

2198 root = self.XML(xml_str) 2199 path = objectify.ObjectPath( "root.c1.c99" ) 2200 self.assertRaises(AttributeError, path.find, root) 2201 2202 new_el = self.Element("{objectified}test") 2203 new_el.a = ["TEST1", "TEST2"] 2204 new_el.a[0].set("myattr", "ATTR1") 2205 new_el.a[1].set("myattr", "ATTR2") 2206 2207 path.setattr(root, list(new_el.a)) 2208 2209 self.assertEquals(2, len(root.c1.c99)) 2210 self.assertEquals("ATTR1", root.c1.c99[0].get("myattr")) 2211 self.assertEquals("TEST1", root.c1.c99[0].text) 2212 self.assertEquals("ATTR2", root.c1.c99[1].get("myattr")) 2213 self.assertEquals("TEST2", root.c1.c99[1].text) 2214 self.assertEquals("TEST1", path(root).text)

2215

2216 - def test_object_path_addattr(self):

2217 root = self.XML(xml_str) 2218 path = objectify.ObjectPath( "root.c1.c2" ) 2219 self.assertEquals(3, len(root.c1.c2)) 2220 path.addattr(root, "test") 2221 self.assertEquals(4, len(root.c1.c2)) 2222 self.assertEquals(["0", "1", "2", "test"], 2223 [el.text for el in root.c1.c2])

2224

2225 - def test_object_path_addattr_element(self):

2226 root = self.XML(xml_str) 2227 path = objectify.ObjectPath( "root.c1.c2" ) 2228 self.assertEquals(3, len(root.c1.c2)) 2229 2230 new_el = self.Element("{objectified}test") 2231 etree.SubElement(new_el, "{objectified}sub").a = "TEST" 2232 2233 path.addattr(root, new_el.sub) 2234 self.assertEquals(4, len(root.c1.c2)) 2235 self.assertEquals("TEST", root.c1.c2[3].a.text) 2236 self.assertEquals(["0", "1", "2"], 2237 [el.text for el in root.c1.c2[:3]])

2238

2239 - def test_object_path_addattr_create(self):

2240 root = self.XML(xml_str) 2241 path = objectify.ObjectPath( "root.c1.c99" ) 2242 self.assertRaises(AttributeError, path.find, root) 2243 2244 new_value = "my new value" 2245 path.addattr(root, new_value) 2246 2247 self.assertEquals(1, len(root.c1.c99)) 2248 self.assertEquals(new_value, root.c1.c99.text) 2249 self.assertEquals(new_value, path(root).text)

2250

2251 - def test_object_path_addattr_create_element(self):

2252 root = self.XML(xml_str) 2253 path = objectify.ObjectPath( "root.c1.c99" ) 2254 self.assertRaises(AttributeError, path.find, root) 2255 2256 new_el = self.Element("{objectified}test") 2257 etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 2258 2259 path.addattr(root, new_el.sub) 2260 self.assertEquals(1, len(root.c1.c99)) 2261 self.assertEquals("TEST", root.c1.c99.a.text) 2262 self.assertEquals("TEST", path(root).a.text) 2263 self.assertEquals("ATTR", root.c1.c99.get("myattr"))

2264

2265 - def test_object_path_addattr_create_list(self):

2266 root = self.XML(xml_str) 2267 path = objectify.ObjectPath( "root.c1.c99" ) 2268 self.assertRaises(AttributeError, path.find, root) 2269 2270 new_el = self.Element("{objectified}test") 2271 new_el.a = ["TEST1", "TEST2"] 2272 2273 self.assertEquals(2, len(new_el.a)) 2274 2275 path.addattr(root, list(new_el.a)) 2276 self.assertEquals(2, len(root.c1.c99)) 2277 self.assertEquals("TEST1", root.c1.c99.text) 2278 self.assertEquals("TEST2", path(root)[1].text)

2279

2280 - def test_descendant_paths(self):

2281 root = self.XML(xml_str) 2282 self.assertEquals( 2283 ['{objectified}root', '{objectified}root.c1', 2284 '{objectified}root.c1.c2', 2285 '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]', 2286 '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'], 2287 root.descendantpaths())

2288

2289 - def test_descendant_paths_child(self):

2290 root = self.XML(xml_str) 2291 self.assertEquals( 2292 ['{objectified}c1', '{objectified}c1.c2', 2293 '{objectified}c1.c2[1]', '{objectified}c1.c2[2]', 2294 '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'], 2295 root.c1.descendantpaths())

2296

2297 - def test_descendant_paths_prefix(self):

2298 root = self.XML(xml_str) 2299 self.assertEquals( 2300 ['root.{objectified}c1', 'root.{objectified}c1.c2', 2301 'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]', 2302 'root.{objectified}c1.{otherNS}c2', 2303 'root.{objectified}c1.{}c2'], 2304 root.c1.descendantpaths('root'))

2305

2306 - def test_pickle(self):

2307 import pickle 2308 2309 root = self.XML(xml_str) 2310 out = BytesIO() 2311 pickle.dump(root, out) 2312 2313 new_root = pickle.loads(out.getvalue()) 2314 self.assertEquals( 2315 etree.tostring(new_root), 2316 etree.tostring(root))

2317

2318 - def test_pickle_elementtree(self):

2319 import pickle 2320 2321 tree = etree.ElementTree(self.XML(xml_str + "<?my pi?>")) 2322 out = BytesIO() 2323 pickle.dump(tree, out) 2324 2325 new_tree = pickle.loads(out.getvalue()) 2326 self.assert_(isinstance(new_tree, etree._ElementTree)) 2327 self.assertEquals( 2328 etree.tostring(new_tree), 2329 etree.tostring(tree))

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

2333 - def test_efactory_int(self):

2334 E = objectify.E 2335 root = E.root(E.val(23)) 2336 self.assert_(isinstance(root.val, objectify.IntElement))

2337

2338 - def test_efactory_float(self):

2339 E = objectify.E 2340 root = E.root(E.val(233.23)) 2341 self.assert_(isinstance(root.val, objectify.FloatElement))

2342

2343 - def test_efactory_str(self):

2344 E = objectify.E 2345 root = E.root(E.val("what?")) 2346 self.assert_(isinstance(root.val, objectify.StringElement))

2347

2348 - def test_efactory_unicode(self):

2349 E = objectify.E 2350 root = E.root(E.val(_str("blöödy häll", encoding="ISO-8859-1"))) 2351 self.assert_(isinstance(root.val, objectify.StringElement))

2352

2353 - def test_efactory_bool(self):

2354 E = objectify.E 2355 root = E.root(E.val(True)) 2356 self.assert_(isinstance(root.val, objectify.BoolElement))

2357

2358 - def test_efactory_none(self):

2359 E = objectify.E 2360 root = E.root(E.val(None)) 2361 self.assert_(isinstance(root.val, objectify.NoneElement))

2362

2363 - def test_efactory_value_concatenation(self):

2364 E = objectify.E 2365 root = E.root(E.val(1, "foo", 2.0, "bar ", True, None)) 2366 self.assert_(isinstance(root.val, objectify.StringElement))

2367

2368 - def test_efactory_attrib(self):

2369 E = objectify.E 2370 root = E.root(foo="bar") 2371 self.assertEquals(root.get("foo"), "bar")

2372

2373 - def test_efactory_nested(self):

2374 E = objectify.E 2375 DataElement = objectify.DataElement 2376 root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1), 2377 DataElement(2.0)) 2378 self.assert_(isinstance(root, objectify.ObjectifiedElement)) 2379 self.assertEquals(root.text, "text") 2380 self.assert_(isinstance(root.sub, objectify.ObjectifiedElement)) 2381 self.assertEquals(root.sub.tail, "tail") 2382 self.assert_(isinstance(root.sub.subsub, objectify.StringElement)) 2383 self.assertEquals(len(root.value), 2) 2384 self.assert_(isinstance(root.value[0], objectify.IntElement)) 2385 self.assert_(isinstance(root.value[1], objectify.FloatElement))

2386

2387 - def test_efactory_subtype(self):

2388 class Attribute(objectify.ObjectifiedDataElement): 2389 def __init__(self): 2390 objectify.ObjectifiedDataElement.__init__(self) 2391 self.set("datatype", "TYPE") 2392 self.set("range", "0.,1.")

2393 2394 attr = Attribute() 2395 self.assertEquals(attr.text, None) 2396 self.assertEquals(attr.get("datatype"), "TYPE") 2397 self.assertEquals(attr.get("range"), "0.,1.") 2398

2399 - def test_XML_base_url_docinfo(self):

2400 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2401 docinfo = root.getroottree().docinfo 2402 self.assertEquals(docinfo.URL, "http://no/such/url")

2403

2404 - def test_XML_set_base_url_docinfo(self):

2405 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2406 docinfo = root.getroottree().docinfo 2407 self.assertEquals(docinfo.URL, "http://no/such/url") 2408 docinfo.URL = "https://secret/url" 2409 self.assertEquals(docinfo.URL, "https://secret/url")

2410

2411 - def test_parse_stringio_base_url(self):

2412 tree = objectify.parse(BytesIO("<root/>"), base_url="http://no/such/url") 2413 docinfo = tree.docinfo 2414 self.assertEquals(docinfo.URL, "http://no/such/url")

2415

2416 - def test_parse_base_url_docinfo(self):

2417 tree = objectify.parse(fileInTestDir('include/test_xinclude.xml'), 2418 base_url="http://no/such/url") 2419 docinfo = tree.docinfo 2420 self.assertEquals(docinfo.URL, "http://no/such/url")

2421

2422 - def test_xml_base(self):

2423 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2424 self.assertEquals(root.base, "http://no/such/url") 2425 self.assertEquals( 2426 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2427 root.base = "https://secret/url" 2428 self.assertEquals(root.base, "https://secret/url") 2429 self.assertEquals( 2430 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2431 "https://secret/url")

2432

2433 - def test_xml_base_attribute(self):

2434 root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 2435 self.assertEquals(root.base, "http://no/such/url") 2436 self.assertEquals( 2437 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 2438 root.set('{http://www.w3.org/XML/1998/namespace}base', 2439 "https://secret/url") 2440 self.assertEquals(root.base, "https://secret/url") 2441 self.assertEquals( 2442 root.get('{http://www.w3.org/XML/1998/namespace}base'), 2443 "https://secret/url")

2444

2445 - def test_standard_lookup(self):

2446 XML = self.XML 2447 2448 xml = _bytes('''\ 2449 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 2450 5 2451 -5 2452 <l>4294967296</l> 2453 <l>-4294967296</l> 2454 <f>1.1</f> 2455 true 2456 false 2457 <s>Strange things happen, where strings collide</s> 2458 <s>True</s> 2459 <s>False</s> 2460 <s>t</s> 2461 <s>f</s> 2462 <s></s> 2463 <s>None</s> 2464 <n xsi:nil="true" /> 2465 </root> 2466 ''') 2467 root = XML(xml) 2468 2469 for i in root.i: 2470 self.assert_(isinstance(i, objectify.IntElement)) 2471 for l in root.l: 2472 self.assert_(isinstance(l, objectify.IntElement)) 2473 for f in root.f: 2474 self.assert_(isinstance(f, objectify.FloatElement)) 2475 for b in root.b: 2476 self.assert_(isinstance(b, objectify.BoolElement)) 2477 self.assertEquals(True, root.b[0]) 2478 self.assertEquals(False, root.b[1]) 2479 for s in root.s: 2480 self.assert_(isinstance(s, objectify.StringElement)) 2481 self.assert_(isinstance(root.n, objectify.NoneElement)) 2482 self.assertEquals(None, root.n)

2483

2484 -def test_suite():

2485 suite = unittest.TestSuite() 2486 suite.addTests([unittest.makeSuite(ObjectifyTestCase)]) 2487 suite.addTests(doctest.DocTestSuite(objectify)) 2488 if sys.version_info >= (2,4): 2489 suite.addTests( 2490 [make_doctest('../../../doc/objectify.txt')]) 2491 return suite

2492 2493 if __name__ == '__main__': 2494 print('to test use test.py %s' % __file__) 2495

Source Code for Module lxml.tests.test_objectify