1494 1493 - def test_addnext_cycle(self): + 1494 Element = self.Element('root') 1497 a = SubElement(root, 'a') -1498 b = SubElement(root, 'b') -1499 a.addprevious(a) -1500 self.assertEqual('a', root[0].1498 b = SubElement(a, 'b') +1499 # appending parent as sibling is forbidden +1500 self.assertRaises(ValueError, b.addnext, a) +1501 self.assertEqual(['a'], [c.tag) -1501 self.assertEqual('b', root[1].tag for c in root]) +1502 self.assertEqual(['b'], [c.tag) -1502 b.addprevious(b) -1503 self.assertEqual('a', root[0].tag for c in a]) + 1503 +1504 - def test_addprevious_cycle(self): + 1505 Element = self.etree.Element +1506 SubElement = self.etree.SubElement +1507 root = Element('root') +1508 a = SubElement(root, 'a') +1509 b = SubElement(a, 'b') +1510 # appending parent as sibling is forbidden +1511 self.assertRaises(ValueError, b.addprevious, a) +1512 self.assertEqual(['a'], [c.tag for c in root]) +1513 self.assertEqual(['b'], [c.tag for c in a]) + 1514 +1515 - def test_addnext_cycle_long(self): + 1516 Element = self.etree.Element +1517 SubElement = self.etree.SubElement +1518 root = Element('root') +1519 a = SubElement(root, 'a') +1520 b = SubElement(a, 'b') +1521 c = SubElement(b, 'c') +1522 # appending parent as sibling is forbidden +1523 self.assertRaises(ValueError, c.addnext, a) + 1524 +1525 - def test_addprevious_cycle_long(self): + 1526 Element = self.etree.Element +1527 SubElement = self.etree.SubElement +1528 root = Element('root') +1529 a = SubElement(root, 'a') +1530 b = SubElement(a, 'b') +1531 c = SubElement(b, 'c') +1532 # appending parent as sibling is forbidden +1533 self.assertRaises(ValueError, c.addprevious, a) + 1534 +1535 - def test_addprevious_noops(self): + 1536 Element = self.etree.Element +1537 SubElement = self.etree.SubElement +1538 root = Element('root') +1539 a = SubElement(root, 'a') +1540 b = SubElement(root, 'b') +1541 a.addprevious(a) +1542 self.assertEqual('a', root[0].tag) -1504 self.assertEqual('b', root[1].tag) +1543 self.assertEqual('b', root[1].tag) -1505 b.addprevious(a) -1506 self.assertEqual('a', root[0].tag) +1544 b.addprevious(b) +1545 self.assertEqual('a', root[0].tag) -1507 self.assertEqual('b', root[1].tag) +1546 self.assertEqual('b', root[1].tag) - 1508 -1509 - def test_addnext_noops(self): - 1510 tag) +1547 b.addprevious(a) +1548 self.assertEqual('a', root[0].tag) +1549 self.assertEqual('b', root[1].tag) + 1550 +1551 - def test_addnext_noops(self): + 1552 Element = self.Element = self.etree.etree.Element -1511 SubElement = self.Element +1553 SubElement = self.etree.SubElement -1512 root = etree.SubElement +1554 root = Element('root') -1513 a = SubElement(root, 'a') -1514 b = SubElement(root, 'b') -1515 a.addnext(a) -1516 self.assertEqual('a', root[0].Element('root') +1555 a = SubElement(root, 'a') +1556 b = SubElement(root, 'b') +1557 a.addnext(a) +1558 self.assertEqual('a', root[0].tag) -1517 self.assertEqual('b', root[1].tag) +1559 self.assertEqual('b', root[1].tag) -1518 b.addnext(b) -1519 self.assertEqual('a', root[0].tag) +1560 b.addnext(b) +1561 self.assertEqual('a', root[0].tag) -1520 self.assertEqual('b', root[1].tag) +1562 self.assertEqual('b', root[1].tag) -1521 a.addnext(b) -1522 self.assertEqual('a', root[0].tag) +1563 a.addnext(b) +1564 self.assertEqual('a', root[0].tag) -1523 self.assertEqual('b', root[1].tag) +1565 self.assertEqual('b', root[1].tag) - 1524 -1525 - def test_addnext_root(self): - 1526 tag) + 1566 +1567 - def test_addnext_root(self): + 1568 Element = self.Element = self.etree.etree.Element -1527 a = Element +1569 a = Element('a') -1528 b = Element('a') +1570 b = Element('b') -1529 self.assertRaises(TypeError, a.addnext, b) - 1530 -1531 - def test_addprevious_pi(self): - 1532 Element('b') +1571 self.assertRaises(TypeError, a.addnext, b) + 1572 +1573 - def test_addprevious_pi(self): + 1574 Element = self.Element = self.etree.etree.Element -1533 SubElement = self.Element +1575 SubElement = self.etree.SubElement -1534 PI = self.etree.SubElement +1576 PI = self.etree.PI -1535 root = etree.PI +1577 root = Element('root') -1536 SubElement(root, 'a') -1537 pi = PI('TARGET', 'TEXT') -1538 pi.tail = "TAIL" -1539 -1540 self.assertEqual(_bytes('<root><a></a></root>'), -1541 self._writeElement(root)) -1542 root[0].addprevious(pi) -1543 self.assertEqual(_bytes('<root><?TARGET TEXT?>TAIL<a></a></root>'), -1544 self._writeElement(root)) - 1545 -1546 - def test_addprevious_root_pi(self): - 1547 Element('root') +1578 SubElement(root, 'a') +1579 pi = PI('TARGET', 'TEXT') +1580 pi.tail = "TAIL" +1581 +1582 self.assertEqual(_bytes('<root><a></a></root>'), +1583 self._writeElement(root)) +1584 root[0].addprevious(pi) +1585 self.assertEqual(_bytes('<root><?TARGET TEXT?>TAIL<a></a></root>'), +1586 self._writeElement(root)) + 1587 +1588 - def test_addprevious_root_pi(self): + 1589 Element = self.Element = self.etree.etree.Element -1548 PI = self.Element +1590 PI = self.etree.PI -1549 root = etree.PI +1591 root = Element('root') -1550 pi = PI('TARGET', 'TEXT') -1551 pi.tail = "TAIL" -1552 -1553 self.assertEqual(_bytes('<root></root>'), -1554 self._writeElement(root)) -1555 root.addprevious(pi) -1556 self.assertEqual(_bytes('<?TARGET TEXT?>\n<root></root>'), -1557 self._writeElement(root)) - 1558 -1559 - def test_addnext_pi(self): - 1560 Element('root') +1592 pi = PI('TARGET', 'TEXT') +1593 pi.tail = "TAIL" +1594 +1595 self.assertEqual(_bytes('<root></root>'), +1596 self._writeElement(root)) +1597 root.addprevious(pi) +1598 self.assertEqual(_bytes('<?TARGET TEXT?>\n<root></root>'), +1599 self._writeElement(root)) + 1600 +1601 - def test_addnext_pi(self): + 1602 Element = self.Element = self.etree.etree.Element -1561 SubElement = self.Element +1603 SubElement = self.etree.SubElement -1562 PI = self.etree.SubElement +1604 PI = self.etree.PI -1563 root = etree.PI +1605 root = Element('root') -1564 SubElement(root, 'a') -1565 pi = PI('TARGET', 'TEXT') -1566 pi.tail = "TAIL" -1567 -1568 self.assertEqual(_bytes('<root><a></a></root>'), -1569 self._writeElement(root)) -1570 root[0].addnext(pi) -1571 self.assertEqual(_bytes('<root><a></a><?TARGET TEXT?>TAIL</root>'), -1572 self._writeElement(root)) - 1573 -1574 - def test_addnext_root_pi(self): - 1575 Element('root') +1606 SubElement(root, 'a') +1607 pi = PI('TARGET', 'TEXT') +1608 pi.tail = "TAIL" +1609 +1610 self.assertEqual(_bytes('<root><a></a></root>'), +1611 self._writeElement(root)) +1612 root[0].addnext(pi) +1613 self.assertEqual(_bytes('<root><a></a><?TARGET TEXT?>TAIL</root>'), +1614 self._writeElement(root)) + 1615 +1616 - def test_addnext_root_pi(self): + 1617 Element = self.Element = self.etree.etree.Element -1576 PI = self.Element +1618 PI = self.etree.PI -1577 root = etree.PI +1619 root = Element('root') -1578 pi = PI('TARGET', 'TEXT') -1579 pi.tail = "TAIL" -1580 -1581 self.assertEqual(_bytes('<root></root>'), -1582 self._writeElement(root)) -1583 root.addnext(pi) -1584 self.assertEqual(_bytes('<root></root>\n<?TARGET TEXT?>'), -1585 self._writeElement(root)) - 1586 -1587 - def test_addnext_comment(self): - 1588 Element('root') +1620 pi = PI('TARGET', 'TEXT') +1621 pi.tail = "TAIL" +1622 +1623 self.assertEqual(_bytes('<root></root>'), +1624 self._writeElement(root)) +1625 root.addnext(pi) +1626 self.assertEqual(_bytes('<root></root>\n<?TARGET TEXT?>'), +1627 self._writeElement(root)) + 1628 +1629 - def test_addnext_comment(self): + 1630 Element = self.Element = self.etree.etree.Element -1589 SubElement = self.Element +1631 SubElement = self.etree.SubElement -1590 Comment = self.etree.SubElement +1632 Comment = self.etree.Comment -1591 root = etree.Comment +1633 root = Element('root') -1592 SubElement(root, 'a') -1593 comment = Comment('TEXT ') -1594 comment.tail = "TAIL" -1595 -1596 self.assertEqual(_bytes('<root><a></a></root>'), -1597 self._writeElement(root)) -1598 root[0].addnext(comment) -1599 self.assertEqual(_bytes('<root><a></a>TAIL</root>'), -1600 self._writeElement(root)) - 1601 -1602 - def test_addnext_root_comment(self): - 1603 Element('root') +1634 SubElement(root, 'a') +1635 comment = Comment('TEXT ') +1636 comment.tail = "TAIL" +1637 +1638 self.assertEqual(_bytes('<root><a></a></root>'), +1639 self._writeElement(root)) +1640 root[0].addnext(comment) +1641 self.assertEqual(_bytes('<root><a></a>TAIL</root>'), +1642 self._writeElement(root)) + 1643 +1644 - def test_addnext_root_comment(self): + 1645 Element = self.Element = self.etree.etree.Element -1604 Comment = self.Element +1646 Comment = self.etree.Comment -1605 root = etree.Comment +1647 root = Element('root') -1606 comment = Comment('TEXT ') -1607 comment.tail = "TAIL" -1608 -1609 self.assertEqual(_bytes('<root></root>'), -1610 self._writeElement(root)) -1611 root.addnext(comment) -1612 self.assertEqual(_bytes('<root></root>\n'), -1613 self._writeElement(root)) - 1614 -1615 - def test_addprevious_comment(self): - 1616 Element('root') +1648 comment = Comment('TEXT ') +1649 comment.tail = "TAIL" +1650 +1651 self.assertEqual(_bytes('<root></root>'), +1652 self._writeElement(root)) +1653 root.addnext(comment) +1654 self.assertEqual(_bytes('<root></root>\n'), +1655 self._writeElement(root)) + 1656 +1657 - def test_addprevious_comment(self): + 1658 Element = self.Element = self.etree.etree.Element -1617 SubElement = self.Element +1659 SubElement = self.etree.SubElement -1618 Comment = self.etree.SubElement +1660 Comment = self.etree.Comment -1619 root = etree.Comment +1661 root = Element('root') -1620 SubElement(root, 'a') -1621 comment = Comment('TEXT ') -1622 comment.tail = "TAIL" -1623 -1624 self.assertEqual(_bytes('<root><a></a></root>'), -1625 self._writeElement(root)) -1626 root[0].addprevious(comment) -1627 self.assertEqual(_bytes('<root>TAIL<a></a></root>'), -1628 self._writeElement(root)) - 1629 -1630 - def test_addprevious_root_comment(self): - 1631 Element('root') +1662 SubElement(root, 'a') +1663 comment = Comment('TEXT ') +1664 comment.tail = "TAIL" +1665 +1666 self.assertEqual(_bytes('<root><a></a></root>'), +1667 self._writeElement(root)) +1668 root[0].addprevious(comment) +1669 self.assertEqual(_bytes('<root>TAIL<a></a></root>'), +1670 self._writeElement(root)) + 1671 +1672 - def test_addprevious_root_comment(self): + 1673 Element = self.Element = self.etree.etree.Element -1632 Comment = self.Element +1674 Comment = self.etree.Comment -1633 root = etree.Comment +1675 root = Element('root') -1634 comment = Comment('TEXT ') -1635 comment.tail = "TAIL" -1636 -1637 self.assertEqual(_bytes('<root></root>'), -1638 self._writeElement(root)) -1639 root.addprevious(comment) -1640 self.assertEqual(_bytes('\n<root></root>'), -1641 self._writeElement(root)) - 1642 -1643 # ET's Elements have items() and key(), but not values() -1644 - def test_attribute_values(self): - 1645 Element('root') +1676 comment = Comment('TEXT ') +1677 comment.tail = "TAIL" +1678 +1679 self.assertEqual(_bytes('<root></root>'), +1680 self._writeElement(root)) +1681 root.addprevious(comment) +1682 self.assertEqual(_bytes('\n<root></root>'), +1683 self._writeElement(root)) + 1684 +1685 # ET's Elements have items() and key(), but not values() +1686 - def test_attribute_values(self): + 1687 XML = self.XML = self.etree.etree.XML -1646 -1647 root = XML +1688 +1689 root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) -1648 XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) +1690 values = root.values = root.values() -1649 values() +1691 values.sort() -1650 self.assertEqual(['Alpha', 'Beta', 'Gamma'], values.sort() +1692 self.assertEqual(['Alpha', 'Beta', 'Gamma'], values) - 1651 -1652 # gives error in ElementTree -1653 - def test_comment_empty(self): - 1654 values) + 1693 +1694 # gives error in ElementTree +1695 - def test_comment_empty(self): + 1696 Element = self.Element = self.etree.etree.Element -1655 Comment = self.Element +1697 Comment = self.etree.Comment -1656 -1657 a = etree.Comment +1698 +1699 a = Element('a') -1658 a.append(Comment()) -1659 self.assertEqual( -1660 _bytes('<a></a>'), -1661 self._writeElement(a)) - 1662 -1663 # ElementTree ignores comments -1664 - def test_comment_parse_empty(self): - 1665 Element('a') +1700 a.append(Comment()) +1701 self.assertEqual( +1702 _bytes('<a></a>'), +1703 self._writeElement(a)) + 1704 +1705 # ElementTree ignores comments +1706 - def test_comment_parse_empty(self): + 1707 ElementTree = self.ElementTree = self.etree.etree.ElementTree -1666 tostring = self.ElementTree +1708 tostring = self.etree.tostring -1667 -1668 xml = _bytes('<a><c/></a>') -1669 f = BytesIO(xml) -1670 doc = etree.tostring +1709 +1710 xml = _bytes('<a><c/></a>') +1711 f = BytesIO(xml) +1712 doc = ElementTree(file=f) -1671 a = doc.getroot() -1672 self.assertEqual( -1673 '', -1674 a[1].ElementTree(file=f) +1713 a = doc.getroot() +1714 self.assertEqual( +1715 '', +1716 a[1].text) -1675 self.assertEqual( -1676 xml, -1677 tostring(a)) - 1678 -1679 # ElementTree ignores comments -1680 - def test_comment_no_proxy_yet(self): - 1681 text) +1717 self.assertEqual( +1718 xml, +1719 tostring(a)) + 1720 +1721 # ElementTree ignores comments +1722 - def test_comment_no_proxy_yet(self): + 1723 ElementTree = self.ElementTree = self.etree.etree.ElementTree -1682 -1683 f = BytesIO('<a><c></c></a>') -1684 doc = ElementTree +1724 +1725 f = BytesIO('<a><c></c></a>') +1726 doc = ElementTree(file=f) -1685 a = doc.getroot() -1686 self.assertEqual( -1687 ' hoi ', -1688 a[1].ElementTree(file=f) +1727 a = doc.getroot() +1728 self.assertEqual( +1729 ' hoi ', +1730 a[1].text) - 1689 -1690 # does not raise an exception in ElementTree -1691 - def test_comment_immutable(self): - 1692 text) + 1731 +1732 # does not raise an exception in ElementTree +1733 - def test_comment_immutable(self): + 1734 Element = self.Element = self.etree.etree.Element -1693 Comment = self.Element +1735 Comment = self.etree.Comment -1694 -1695 c = Comment() -1696 el = etree.Comment +1736 +1737 c = Comment() +1738 el = Element('myel') -1697 -1698 self.assertRaises(TypeError, c.append, el) -1699 self.assertRaises(TypeError, c.insert, 0, el) -1700 self.assertRaises(TypeError, c.set, "myattr", "test") - 1701 -1702 - def test_comment_immutable_attrib(self): - 1703 c = self.Element('myel') +1739 +1740 self.assertRaises(TypeError, c.append, el) +1741 self.assertRaises(TypeError, c.insert, 0, el) +1742 self.assertRaises(TypeError, c.set, "myattr", "test") + 1743 +1744 - def test_comment_immutable_attrib(self): + 1745 c = self.etree.Comment() -1704 self.assertEqual(0, len(c.etree.Comment() +1746 self.assertEqual(0, len(c.attrib)) -1705 -1706 self.assertFalse(c.attrib)) +1747 +1748 self.assertFalse(c.attrib.attrib.__contains__('nope')) -1707 self.assertFalse('nope' in c.__contains__('nope')) +1749 self.assertFalse('nope' in c.attrib) -1708 self.assertFalse('nope' in c.attrib) +1750 self.assertFalse('nope' in c.attrib.attrib.keys()) -1709 self.assertFalse('nope' in c.keys()) +1751 self.assertFalse('nope' in c.attrib.attrib.values()) -1710 self.assertFalse(('nope', 'huhu') in c.values()) +1752 self.assertFalse(('nope', 'huhu') in c.attrib.attrib.items()) -1711 -1712 self.assertEqual([], list(c.items()) +1753 +1754 self.assertEqual([], list(c.attrib)) -1713 self.assertEqual([], list(c.attrib)) +1755 self.assertEqual([], list(c.attrib.attrib.keys())) -1714 self.assertEqual([], list(c.keys())) +1756 self.assertEqual([], list(c.attrib.attrib.items())) -1715 self.assertEqual([], list(c.items())) +1757 self.assertEqual([], list(c.attrib.attrib.values())) -1716 self.assertEqual([], list(c.values())) +1758 self.assertEqual([], list(c.attrib.iterkeys())) -1717 self.assertEqual([], list(c.attrib.iterkeys())) +1759 self.assertEqual([], list(c.attrib.iteritems())) -1718 self.assertEqual([], list(c.attrib.iteritems())) +1760 self.assertEqual([], list(c.attrib.itervalues())) -1719 -1720 self.assertEqual('HUHU', c.attrib.itervalues())) +1761 +1762 self.assertEqual('HUHU', c.attrib.pop('nope', 'HUHU')) -1721 self.assertRaises(KeyError, c.attrib.pop('nope', 'HUHU')) +1763 self.assertRaises(KeyError, c.attrib.pop, 'nope') -1722 -1723 self.assertRaises(KeyError, c.attrib.pop, 'nope') +1764 +1765 self.assertRaises(KeyError, c.attrib.attrib.__getitem__, 'only') -1724 self.assertRaises(KeyError, c.__getitem__, 'only') +1766 self.assertRaises(KeyError, c.attrib.attrib.__getitem__, 'names') -1725 self.assertRaises(KeyError, c.__getitem__, 'names') +1767 self.assertRaises(KeyError, c.attrib.attrib.__getitem__, 'nope') -1726 self.assertRaises(KeyError, c.__getitem__, 'nope') +1768 self.assertRaises(KeyError, c.attrib.attrib.__setitem__, 'nope', 'yep') -1727 self.assertRaises(KeyError, c.__setitem__, 'nope', 'yep') +1769 self.assertRaises(KeyError, c.attrib.attrib.__delitem__, 'nope') - 1728 -1729 # test passing 'None' to dump() -1730 - def test_dump_none(self): - 1731 self.assertRaises(TypeError, self.__delitem__, 'nope') + 1770 +1771 # test passing 'None' to dump() +1772 - def test_dump_none(self): + 1773 self.assertRaises(TypeError, self.etree.dump, None) - 1732 -1733 - def test_prefix(self): - 1734 etree.dump, None) + 1774 +1775 - def test_prefix(self): + 1776 ElementTree = self.ElementTree = self.etree.etree.ElementTree -1735 -1736 f = BytesIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>') -1737 doc = ElementTree +1777 +1778 f = BytesIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>') +1779 doc = ElementTree(file=f) -1738 a = doc.getroot() -1739 self.assertEqual( -1740 None, -1741 a.prefix) -1742 self.assertEqual( -1743 'foo', -1744 a[0].prefix) - 1745 -1746 - def test_prefix_default_ns(self): - 1747 ElementTree(file=f) +1780 a = doc.getroot() +1781 self.assertEqual( +1782 None, +1783 a.prefix) +1784 self.assertEqual( +1785 'foo', +1786 a[0].prefix) + 1787 +1788 - def test_prefix_default_ns(self): + 1789 ElementTree = self.ElementTree = self.etree.etree.ElementTree -1748 -1749 f = BytesIO('<a xmlns="http://www.infrae.com/ns/1"></a>') -1750 doc = ElementTree +1790 +1791 f = BytesIO('<a xmlns="http://www.infrae.com/ns/1"></a>') +1792 doc = ElementTree(file=f) -1751 a = doc.getroot() -1752 self.assertEqual( -1753 None, -1754 a.prefix) -1755 self.assertEqual( -1756 None, -1757 a[0].prefix) - 1758 -1759 - def test_getparent(self): - 1760 ElementTree(file=f) +1793 a = doc.getroot() +1794 self.assertEqual( +1795 None, +1796 a.prefix) +1797 self.assertEqual( +1798 None, +1799 a[0].prefix) + 1800 +1801 - def test_getparent(self): + 1802 Element = self.Element = self.etree.etree.Element -1761 SubElement = self.Element +1803 SubElement = self.etree.SubElement -1762 -1763 a = etree.SubElement +1804 +1805 a = Element('a') -1764 b = SubElement(a, 'b') -1765 c = SubElement(a, 'c') -1766 d = SubElement(b, 'd') -1767 self.assertEqual( -1768 None, -1769 a.Element('a') +1806 b = SubElement(a, 'b') +1807 c = SubElement(a, 'c') +1808 d = SubElement(b, 'd') +1809 self.assertEqual( +1810 None, +1811 a.getparent()) -1770 self.assertEqual( -1771 a, -1772 b.getparent()) +1812 self.assertEqual( +1813 a, +1814 b.getparent()) -1773 self.assertEqual( -1774 b.getparent()) +1815 self.assertEqual( +1816 b.getparent(), -1775 c.getparent(), +1817 c.getparent()) -1776 self.assertEqual( -1777 b, -1778 d.getparent()) +1818 self.assertEqual( +1819 b, +1820 d.getparent()) - 1779 -1780 - def test_iterchildren(self): - 1781 getparent()) + 1821 +1822 - def test_iterchildren(self): + 1823 XML = self.XML = self.etree.etree.XML -1782 -1783 root = XML +1824 +1825 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) -1784 result = [] -1785 for el in root.iterchildren(): -1786 result.append(el.XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) +1826 result = [] +1827 for el in root.iterchildren(): +1828 result.append(el.tag) -1787 self.assertEqual(['one', 'two', 'three'], result) - 1788 -1789 - def test_iterchildren_reversed(self): - 1790 tag) +1829 self.assertEqual(['one', 'two', 'three'], result) + 1830 +1831 - def test_iterchildren_reversed(self): + 1832 XML = self.XML = self.etree.etree.XML -1791 -1792 root = XML +1833 +1834 root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) -1793 result = [] -1794 for el in root.iterchildren(reversed=True): -1795 result.append(el.XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) +1835 result = [] +1836 for el in root.iterchildren(reversed=True): +1837 result.append(el.tag) -1796 self.assertEqual(['three', 'two', 'one'], result) - 1797 -1798 - def test_iterchildren_tag(self): - 1799 tag) +1838 self.assertEqual(['three', 'two', 'one'], result) + 1839 +1840 - def test_iterchildren_tag(self): + 1841 XML = self.XML = self.etree.etree.XML -1800 -1801 root = XML +1842 +1843 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) -1802 result = [] -1803 for el in root.iterchildren(XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) +1844 result = [] +1845 for el in root.iterchildren(tag='two'): -1804 result.append(el.tag='two'): +1846 result.append(el.text) -1805 self.assertEqual(['Two', 'Bla'], result) - 1806 -1807 - def test_iterchildren_tag_posarg(self): - 1808 text) +1847 self.assertEqual(['Two', 'Bla'], result) + 1848 +1849 - def test_iterchildren_tag_posarg(self): + 1850 XML = self.XML = self.etree.etree.XML -1809 -1810 root = XML +1851 +1852 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) -1811 result = [] -1812 for el in root.iterchildren('two'): -1813 result.append(el.XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) +1853 result = [] +1854 for el in root.iterchildren('two'): +1855 result.append(el.text) -1814 self.assertEqual(['Two', 'Bla'], result) - 1815 -1816 - def test_iterchildren_tag_reversed(self): - 1817 text) +1856 self.assertEqual(['Two', 'Bla'], result) + 1857 +1858 - def test_iterchildren_tag_reversed(self): + 1859 XML = self.XML = self.etree.etree.XML -1818 -1819 root = XML +1860 +1861 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) -1820 result = [] -1821 for el in root.iterchildren(reversed=True, XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) +1862 result = [] +1863 for el in root.iterchildren(reversed=True, tag='two'): -1822 result.append(el.tag='two'): +1864 result.append(el.text) -1823 self.assertEqual(['Bla', 'Two'], result) - 1824 -1825 - def test_iterchildren_tag_multiple(self): - 1826 text) +1865 self.assertEqual(['Bla', 'Two'], result) + 1866 +1867 - def test_iterchildren_tag_multiple(self): + 1868 XML = self.XML = self.etree.etree.XML -1827 -1828 root = XML +1869 +1870 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two><three/></doc>')) -1829 result = [] -1830 for el in root.iterchildren(XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two><three/></doc>')) +1871 result = [] +1872 for el in root.iterchildren(tag=['two', 'three']): -1831 result.append(el.tag=['two', 'three']): +1873 result.append(el.text) -1832 self.assertEqual(['Two', 'Bla', None], result) - 1833 -1834 - def test_iterchildren_tag_multiple_posarg(self): - 1835 text) +1874 self.assertEqual(['Two', 'Bla', None], result) + 1875 +1876 - def test_iterchildren_tag_multiple_posarg(self): + 1877 XML = self.XML = self.etree.etree.XML -1836 -1837 root = XML +1878 +1879 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two><three/></doc>')) -1838 result = [] -1839 for el in root.iterchildren('two', 'three'): -1840 result.append(el.XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two><three/></doc>')) +1880 result = [] +1881 for el in root.iterchildren('two', 'three'): +1882 result.append(el.text) -1841 self.assertEqual(['Two', 'Bla', None], result) - 1842 -1843 - def test_iterchildren_tag_multiple_reversed(self): - 1844 text) +1883 self.assertEqual(['Two', 'Bla', None], result) + 1884 +1885 - def test_iterchildren_tag_multiple_reversed(self): + 1886 XML = self.XML = self.etree.etree.XML -1845 -1846 root = XML +1887 +1888 root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two><three/></doc>')) -1847 result = [] -1848 for el in root.iterchildren(reversed=True, XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two><three/></doc>')) +1889 result = [] +1890 for el in root.iterchildren(reversed=True, tag=['two', 'three']): -1849 result.append(el.tag=['two', 'three']): +1891 result.append(el.text) -1850 self.assertEqual([None, 'Bla', 'Two'], result) - 1851 -1852 - def test_iterancestors(self): - 1853 text) +1892 self.assertEqual([None, 'Bla', 'Two'], result) + 1893 +1894 - def test_iterancestors(self): + 1895 Element = self.Element = self.etree.etree.Element -1854 SubElement = self.Element +1896 SubElement = self.etree.SubElement -1855 -1856 a = etree.SubElement +1897 +1898 a = Element('a') -1857 b = SubElement(a, 'b') -1858 c = SubElement(a, 'c') -1859 d = SubElement(b, 'd') -1860 self.assertEqual( -1861 [], -1862 list(a.iterancestors())) -1863 self.assertEqual( -1864 [a], -1865 list(b.iterancestors())) -1866 self.assertEqual( -1867 [a], -1868 list(c.iterancestors())) -1869 self.assertEqual( -1870 [b, a], -1871 list(d.iterancestors())) - 1872 -1873 - def test_iterancestors_tag(self): - 1874 Element('a') +1899 b = SubElement(a, 'b') +1900 c = SubElement(a, 'c') +1901 d = SubElement(b, 'd') +1902 self.assertEqual( +1903 [], +1904 list(a.iterancestors())) +1905 self.assertEqual( +1906 [a], +1907 list(b.iterancestors())) +1908 self.assertEqual( +1909 [a], +1910 list(c.iterancestors())) +1911 self.assertEqual( +1912 [b, a], +1913 list(d.iterancestors())) + 1914 +1915 - def test_iterancestors_tag(self): + 1916 Element = self.Element = self.etree.etree.Element -1875 SubElement = self.Element +1917 SubElement = self.etree.SubElement -1876 -1877 a = etree.SubElement +1918 +1919 a = Element('a') -1878 b = SubElement(a, 'b') -1879 c = SubElement(a, 'c') -1880 d = SubElement(b, 'd') -1881 self.assertEqual( -1882 [a], -1883 list(d.iterancestors('a'))) -1884 self.assertEqual( -1885 [a], -1886 list(d.iterancestors(Element('a') +1920 b = SubElement(a, 'b') +1921 c = SubElement(a, 'c') +1922 d = SubElement(b, 'd') +1923 self.assertEqual( +1924 [a], +1925 list(d.iterancestors('a'))) +1926 self.assertEqual( +1927 [a], +1928 list(d.iterancestors(tag='a'))) -1887 -1888 self.assertEqual( -1889 [b, a], -1890 list(d.iterancestors('*'))) -1891 self.assertEqual( -1892 [b, a], -1893 list(d.iterancestors(tag='a'))) +1929 +1930 self.assertEqual( +1931 [b, a], +1932 list(d.iterancestors('*'))) +1933 self.assertEqual( +1934 [b, a], +1935 list(d.iterancestors(tag='*'))) - 1894 -1895 - def test_iterancestors_tag_multiple(self): - 1896 tag='*'))) + 1936 +1937 - def test_iterancestors_tag_multiple(self): + 1938 Element = self.Element = self.etree.etree.Element -1897 SubElement = self.Element +1939 SubElement = self.etree.SubElement -1898 -1899 a = etree.SubElement +1940 +1941 a = Element('a') -1900 b = SubElement(a, 'b') -1901 c = SubElement(a, 'c') -1902 d = SubElement(b, 'd') -1903 self.assertEqual( -1904 [b, a], -1905 list(d.iterancestors(Element('a') +1942 b = SubElement(a, 'b') +1943 c = SubElement(a, 'c') +1944 d = SubElement(b, 'd') +1945 self.assertEqual( +1946 [b, a], +1947 list(d.iterancestors(tag=('a', 'b')))) -1906 self.assertEqual( -1907 [b, a], -1908 list(d.iterancestors('a', 'b'))) -1909 -1910 self.assertEqual( -1911 [], -1912 list(d.iterancestors(tag=('a', 'b')))) +1948 self.assertEqual( +1949 [b, a], +1950 list(d.iterancestors('a', 'b'))) +1951 +1952 self.assertEqual( +1953 [], +1954 list(d.iterancestors(tag=('w', 'x', 'y', 'z')))) -1913 self.assertEqual( -1914 [], -1915 list(d.iterancestors('w', 'x', 'y', 'z'))) -1916 -1917 self.assertEqual( -1918 [], -1919 list(d.iterancestors(tag=('w', 'x', 'y', 'z')))) +1955 self.assertEqual( +1956 [], +1957 list(d.iterancestors('w', 'x', 'y', 'z'))) +1958 +1959 self.assertEqual( +1960 [], +1961 list(d.iterancestors(tag=('d', 'x')))) -1920 self.assertEqual( -1921 [], -1922 list(d.iterancestors('d', 'x'))) -1923 -1924 self.assertEqual( -1925 [b, a], -1926 list(d.iterancestors(tag=('d', 'x')))) +1962 self.assertEqual( +1963 [], +1964 list(d.iterancestors('d', 'x'))) +1965 +1966 self.assertEqual( +1967 [b, a], +1968 list(d.iterancestors(tag=('b', '*')))) -1927 self.assertEqual( -1928 [b, a], -1929 list(d.iterancestors('b', '*'))) -1930 -1931 self.assertEqual( -1932 [b], -1933 list(d.iterancestors(tag=('b', '*')))) +1969 self.assertEqual( +1970 [b, a], +1971 list(d.iterancestors('b', '*'))) +1972 +1973 self.assertEqual( +1974 [b], +1975 list(d.iterancestors(tag=('b', 'c')))) -1934 self.assertEqual( -1935 [b], -1936 list(d.iterancestors('b', 'c'))) - 1937 -1938 - def test_iterdescendants(self): - 1939 tag=('b', 'c')))) +1976 self.assertEqual( +1977 [b], +1978 list(d.iterancestors('b', 'c'))) + 1979 +1980 - def test_iterdescendants(self): + 1981 Element = self.Element = self.etree.etree.Element -1940 SubElement = self.Element +1982 SubElement = self.etree.SubElement -1941 -1942 a = etree.SubElement +1983 +1984 a = Element('a') -1943 b = SubElement(a, 'b') -1944 c = SubElement(a, 'c') -1945 d = SubElement(b, 'd') -1946 e = SubElement(c, 'e') -1947 -1948 self.assertEqual( -1949 [b, d, c, e], -1950 list(a.iterdescendants())) -1951 self.assertEqual( -1952 [], -1953 list(d.iterdescendants())) - 1954 -1955 - def test_iterdescendants_tag(self): - 1956 Element('a') +1985 b = SubElement(a, 'b') +1986 c = SubElement(a, 'c') +1987 d = SubElement(b, 'd') +1988 e = SubElement(c, 'e') +1989 +1990 self.assertEqual( +1991 [b, d, c, e], +1992 list(a.iterdescendants())) +1993 self.assertEqual( +1994 [], +1995 list(d.iterdescendants())) + 1996 +1997 - def test_iterdescendants_tag(self): + 1998 Element = self.Element = self.etree.etree.Element -1957 SubElement = self.Element +1999 SubElement = self.etree.SubElement -1958 -1959 a = Element('a') -1960 b = SubElement(a, 'b') -1961 c = SubElement(a, 'c') -1962 d = SubElement(b, 'd') -1963 e = SubElement(c, 'e') -1964 -1965 self.assertEqual( -1966 [], -1967 list(a.iterdescendants('a'))) -1968 self.assertEqual( -1969 [], -1970 list(a.iterdescendants(etree.SubElement +2000 +2001 a = Element('a') +2002 b = SubElement(a, 'b') +2003 c = SubElement(a, 'c') +2004 d = SubElement(b, 'd') +2005 e = SubElement(c, 'e') +2006 +2007 self.assertEqual( +2008 [], +2009 list(a.iterdescendants('a'))) +2010 self.assertEqual( +2011 [], +2012 list(a.iterdescendants(tag='a'))) -1971 -1972 a2 = SubElement(e, 'a') -1973 self.assertEqual( -1974 [a2], -1975 list(a.iterdescendants('a'))) -1976 -1977 self.assertEqual( -1978 [a2], -1979 list(c.iterdescendants('a'))) -1980 self.assertEqual( -1981 [a2], -1982 list(c.iterdescendants(tag='a'))) +2013 +2014 a2 = SubElement(e, 'a') +2015 self.assertEqual( +2016 [a2], +2017 list(a.iterdescendants('a'))) +2018 +2019 self.assertEqual( +2020 [a2], +2021 list(c.iterdescendants('a'))) +2022 self.assertEqual( +2023 [a2], +2024 list(c.iterdescendants(tag='a'))) - 1983 -1984 - def test_iterdescendants_tag_multiple(self): - 1985 tag='a'))) + 2025 +2026 - def test_iterdescendants_tag_multiple(self): + 2027 Element = self.Element = self.etree.etree.Element -1986 SubElement = self.Element +2028 SubElement = self.etree.SubElement -1987 -1988 a = etree.SubElement +2029 +2030 a = Element('a') -1989 b = SubElement(a, 'b') -1990 c = SubElement(a, 'c') -1991 d = SubElement(b, 'd') -1992 e = SubElement(c, 'e') -1993 -1994 self.assertEqual( -1995 [b, e], -1996 list(a.iterdescendants(Element('a') +2031 b = SubElement(a, 'b') +2032 c = SubElement(a, 'c') +2033 d = SubElement(b, 'd') +2034 e = SubElement(c, 'e') +2035 +2036 self.assertEqual( +2037 [b, e], +2038 list(a.iterdescendants(tag=('a', 'b', 'e')))) -1997 self.assertEqual( -1998 [b, e], -1999 list(a.iterdescendants('a', 'b', 'e'))) -2000 -2001 a2 = SubElement(e, 'a') -2002 self.assertEqual( -2003 [b, a2], -2004 list(a.iterdescendants(tag=('a', 'b', 'e')))) +2039 self.assertEqual( +2040 [b, e], +2041 list(a.iterdescendants('a', 'b', 'e'))) +2042 +2043 a2 = SubElement(e, 'a') +2044 self.assertEqual( +2045 [b, a2], +2046 list(a.iterdescendants(tag=('a', 'b')))) -2005 self.assertEqual( -2006 [b, a2], -2007 list(a.iterdescendants('a', 'b'))) -2008 -2009 self.assertEqual( -2010 [], -2011 list(c.iterdescendants(tag=('a', 'b')))) +2047 self.assertEqual( +2048 [b, a2], +2049 list(a.iterdescendants('a', 'b'))) +2050 +2051 self.assertEqual( +2052 [], +2053 list(c.iterdescendants(tag=('x', 'y', 'z')))) -2012 self.assertEqual( -2013 [], -2014 list(c.iterdescendants('x', 'y', 'z'))) -2015 -2016 self.assertEqual( -2017 [b, d, c, e, a2], -2018 list(a.iterdescendants(tag=('x', 'y', 'z')))) +2054 self.assertEqual( +2055 [], +2056 list(c.iterdescendants('x', 'y', 'z'))) +2057 +2058 self.assertEqual( +2059 [b, d, c, e, a2], +2060 list(a.iterdescendants(tag=('x', 'y', 'z', '*')))) -2019 self.assertEqual( -2020 [b, d, c, e, a2], -2021 list(a.iterdescendants('x', 'y', 'z', '*'))) - 2022 -2023 - def test_getroottree(self): - 2024 tag=('x', 'y', 'z', '*')))) +2061 self.assertEqual( +2062 [b, d, c, e, a2], +2063 list(a.iterdescendants('x', 'y', 'z', '*'))) + 2064 +2065 - def test_getroottree(self): + 2066 Element = self.Element = self.etree.etree.Element -2025 SubElement = self.Element +2067 SubElement = self.etree.SubElement -2026 -2027 a = etree.SubElement +2068 +2069 a = Element('a') -2028 b = SubElement(a, 'b') -2029 c = SubElement(a, 'c') -2030 d = SubElement(b, 'd') -2031 self.assertEqual( -2032 a, -2033 a.getroottree().getroot()) -2034 self.assertEqual( -2035 a, -2036 b.getroottree().getroot()) -2037 self.assertEqual( -2038 a, -2039 d.getroottree().getroot()) - 2040 -2041 - def test_getnext(self): - 2042 Element('a') +2070 b = SubElement(a, 'b') +2071 c = SubElement(a, 'c') +2072 d = SubElement(b, 'd') +2073 self.assertEqual( +2074 a, +2075 a.getroottree().getroot()) +2076 self.assertEqual( +2077 a, +2078 b.getroottree().getroot()) +2079 self.assertEqual( +2080 a, +2081 d.getroottree().getroot()) + 2082 +2083 - def test_getnext(self): + 2084 Element = self.Element = self.etree.etree.Element -2043 SubElement = self.Element +2085 SubElement = self.etree.SubElement -2044 -2045 a = etree.SubElement +2086 +2087 a = Element('a') -2046 b = SubElement(a, 'b') -2047 c = SubElement(a, 'c') -2048 self.assertEqual( -2049 None, -2050 a.getnext()) -2051 self.assertEqual( -2052 c, -2053 b.getnext()) -2054 self.assertEqual( -2055 None, -2056 c.getnext()) - 2057 -2058 - def test_getprevious(self): - 2059 Element('a') +2088 b = SubElement(a, 'b') +2089 c = SubElement(a, 'c') +2090 self.assertEqual( +2091 None, +2092 a.getnext()) +2093 self.assertEqual( +2094 c, +2095 b.getnext()) +2096 self.assertEqual( +2097 None, +2098 c.getnext()) + 2099 +2100 - def test_getprevious(self): + 2101 Element = self.Element = self.etree.etree.Element -2060 SubElement = self.Element +2102 SubElement = self.etree.SubElement -2061 -2062 a = etree.SubElement +2103 +2104 a = Element('a') -2063 b = SubElement(a, 'b') -2064 c = SubElement(a, 'c') -2065 d = SubElement(b, 'd') -2066 self.assertEqual( -2067 None, -2068 a.getprevious()) -2069 self.assertEqual( -2070 b, -2071 c.getprevious()) -2072 self.assertEqual( -2073 None, -2074 b.getprevious()) - 2075 -2076 - def test_itersiblings(self): - 2077 Element('a') +2105 b = SubElement(a, 'b') +2106 c = SubElement(a, 'c') +2107 d = SubElement(b, 'd') +2108 self.assertEqual( +2109 None, +2110 a.getprevious()) +2111 self.assertEqual( +2112 b, +2113 c.getprevious()) +2114 self.assertEqual( +2115 None, +2116 b.getprevious()) + 2117 +2118 - def test_itersiblings(self): + 2119 Element = self.Element = self.etree.etree.Element -2078 SubElement = self.Element +2120 SubElement = self.etree.SubElement -2079 -2080 a = etree.SubElement +2121 +2122 a = Element('a') -2081 b = SubElement(a, 'b') -2082 c = SubElement(a, 'c') -2083 d = SubElement(b, 'd') -2084 self.assertEqual( -2085 [], -2086 list(a.itersiblings())) -2087 self.assertEqual( -2088 [c], -2089 list(b.itersiblings())) -2090 self.assertEqual( -2091 [], -2092 list(c.itersiblings())) -2093 self.assertEqual( -2094 [b], -2095 list(c.itersiblings(preceding=True))) -2096 self.assertEqual( -2097 [], -2098 list(b.itersiblings(preceding=True))) - 2099 -2100 - def test_itersiblings_tag(self): - 2101 Element('a') +2123 b = SubElement(a, 'b') +2124 c = SubElement(a, 'c') +2125 d = SubElement(b, 'd') +2126 self.assertEqual( +2127 [], +2128 list(a.itersiblings())) +2129 self.assertEqual( +2130 [c], +2131 list(b.itersiblings())) +2132 self.assertEqual( +2133 [], +2134 list(c.itersiblings())) +2135 self.assertEqual( +2136 [b], +2137 list(c.itersiblings(preceding=True))) +2138 self.assertEqual( +2139 [], +2140 list(b.itersiblings(preceding=True))) + 2141 +2142 - def test_itersiblings_tag(self): + 2143 Element = self.Element = self.etree.etree.Element -2102 SubElement = self.Element +2144 SubElement = self.etree.SubElement -2103 -2104 a = etree.SubElement +2145 +2146 a = Element('a') -2105 b = SubElement(a, 'b') -2106 c = SubElement(a, 'c') -2107 d = SubElement(b, 'd') -2108 self.assertEqual( -2109 [], -2110 list(a.itersiblings(Element('a') +2147 b = SubElement(a, 'b') +2148 c = SubElement(a, 'c') +2149 d = SubElement(b, 'd') +2150 self.assertEqual( +2151 [], +2152 list(a.itersiblings(tag='XXX'))) -2111 self.assertEqual( -2112 [c], -2113 list(b.itersiblings(tag='XXX'))) +2153 self.assertEqual( +2154 [c], +2155 list(b.itersiblings(tag='c'))) -2114 self.assertEqual( -2115 [c], -2116 list(b.itersiblings(tag='c'))) +2156 self.assertEqual( +2157 [c], +2158 list(b.itersiblings(tag='*'))) -2117 self.assertEqual( -2118 [b], -2119 list(c.itersiblings(preceding=True, tag='*'))) +2159 self.assertEqual( +2160 [b], +2161 list(c.itersiblings(preceding=True, tag='b'))) -2120 self.assertEqual( -2121 [], -2122 list(c.itersiblings(preceding=True, tag='b'))) +2162 self.assertEqual( +2163 [], +2164 list(c.itersiblings(preceding=True, tag='c'))) - 2123 -2124 - def test_itersiblings_tag_multiple(self): - 2125 tag='c'))) + 2165 +2166 - def test_itersiblings_tag_multiple(self): + 2167 Element = self.Element = self.etree.etree.Element -2126 SubElement = self.Element +2168 SubElement = self.etree.SubElement -2127 -2128 a = etree.SubElement +2169 +2170 a = Element('a') -2129 b = SubElement(a, 'b') -2130 c = SubElement(a, 'c') -2131 d = SubElement(b, 'd') -2132 e = SubElement(a, 'e') -2133 self.assertEqual( -2134 [], -2135 list(a.itersiblings(Element('a') +2171 b = SubElement(a, 'b') +2172 c = SubElement(a, 'c') +2173 d = SubElement(b, 'd') +2174 e = SubElement(a, 'e') +2175 self.assertEqual( +2176 [], +2177 list(a.itersiblings(tag=('XXX', 'YYY')))) -2136 self.assertEqual( -2137 [c, e], -2138 list(b.itersiblings(tag=('XXX', 'YYY')))) +2178 self.assertEqual( +2179 [c, e], +2180 list(b.itersiblings(tag=('c', 'd', 'e')))) -2139 self.assertEqual( -2140 [b], -2141 list(c.itersiblings(preceding=True, tag=('c', 'd', 'e')))) +2181 self.assertEqual( +2182 [b], +2183 list(c.itersiblings(preceding=True, tag=('b', 'b', 'c', 'd')))) -2142 self.assertEqual( -2143 [c, b], -2144 list(e.itersiblings(preceding=True, tag=('b', 'b', 'c', 'd')))) +2184 self.assertEqual( +2185 [c, b], +2186 list(e.itersiblings(preceding=True, tag=('c', '*')))) - 2145 -2146 - def test_parseid(self): - 2147 parseid = self.tag=('c', '*')))) + 2187 +2188 - def test_parseid(self): + 2189 parseid = self.etree.parseid -2148 etree.parseid +2190 XML = self.XML = self.etree.etree.XML -2149 xml_text = _bytes(''' -2150 <!DOCTYPE document [ -2151 <!ELEMENT document (h1,p)*> -2152 <!ELEMENT h1 (#PCDATA)> -2153 <!ATTLIST h1 myid ID #REQUIRED> -2154 <!ELEMENT p (#PCDATA)> -2155 <!ATTLIST p someid ID #REQUIRED> -2156 ]> -2157 <document> -2158 <h1 myid="chapter1">...</h1> -2159 ... -2160 Regular paragraph. -2161 XML:ID paragraph. -2162 ... -2163 </document> -2164 ''') -2165 -2166 tree, dic = parseid(BytesIO(xml_text)) -2167 root = tree.getroot() -2168 root2 = XML +2191 xml_text = _bytes(''' +2192 <!DOCTYPE document [ +2193 <!ELEMENT document (h1,p)*> +2194 <!ELEMENT h1 (#PCDATA)> +2195 <!ATTLIST h1 myid ID #REQUIRED> +2196 <!ELEMENT p (#PCDATA)> +2197 <!ATTLIST p someid ID #REQUIRED> +2198 ]> +2199 <document> +2200 <h1 myid="chapter1">...</h1> +2201 ... +2202 Regular paragraph. +2203 XML:ID paragraph. +2204 ... +2205 </document> +2206 ''') +2207 +2208 tree, dic = parseid(BytesIO(xml_text)) +2209 root = tree.getroot() +2210 root2 = XML(xml_text) -2169 self.assertEqual(self._writeElement(root), -2170 self._writeElement(root2)) -2171 expected = { -2172 "chapter1" : root[0], -2173 "xmlid" : root[3], -2174 "warn1" : root[4] -2175 } -2176 self.assertTrue("chapter1" in dic) -2177 self.assertTrue("warn1" in dic) -2178 self.assertTrue("xmlid" in dic) -2179 self._checkIDDict(dic, expected) - 2180 -2181 - def test_XMLDTDID(self): - 2182 XMLDTDID = self.XML(xml_text) +2211 self.assertEqual(self._writeElement(root), +2212 self._writeElement(root2)) +2213 expected = { +2214 "chapter1" : root[0], +2215 "xmlid" : root[3], +2216 "warn1" : root[4] +2217 } +2218 self.assertTrue("chapter1" in dic) +2219 self.assertTrue("warn1" in dic) +2220 self.assertTrue("xmlid" in dic) +2221 self._checkIDDict(dic, expected) + 2222 +2223 - def test_XMLDTDID(self): + 2224 XMLDTDID = self.etree.XMLDTDID -2183 etree.XMLDTDID +2225 XML = self.XML = self.etree.etree.XML -2184 xml_text = _bytes(''' -2185 <!DOCTYPE document [ -2186 <!ELEMENT document (h1,p)*> -2187 <!ELEMENT h1 (#PCDATA)> -2188 <!ATTLIST h1 myid ID #REQUIRED> -2189 <!ELEMENT p (#PCDATA)> -2190 <!ATTLIST p someid ID #REQUIRED> -2191 ]> -2192 <document> -2193 <h1 myid="chapter1">...</h1> -2194 ... -2195 Regular paragraph. -2196 XML:ID paragraph. -2197 ... -2198 </document> -2199 ''') -2200 -2201 root, dic = XMLDTDID(xml_text) -2202 root2 = XML +2226 xml_text = _bytes(''' +2227 <!DOCTYPE document [ +2228 <!ELEMENT document (h1,p)*> +2229 <!ELEMENT h1 (#PCDATA)> +2230 <!ATTLIST h1 myid ID #REQUIRED> +2231 <!ELEMENT p (#PCDATA)> +2232 <!ATTLIST p someid ID #REQUIRED> +2233 ]> +2234 <document> +2235 <h1 myid="chapter1">...</h1> +2236 ... +2237 Regular paragraph. +2238 XML:ID paragraph. +2239 ... +2240 </document> +2241 ''') +2242 +2243 root, dic = XMLDTDID(xml_text) +2244 root2 = XML(xml_text) -2203 self.assertEqual(self._writeElement(root), -2204 self._writeElement(root2)) -2205 expected = { -2206 "chapter1" : root[0], -2207 "xmlid" : root[3], -2208 "warn1" : root[4] -2209 } -2210 self.assertTrue("chapter1" in dic) -2211 self.assertTrue("warn1" in dic) -2212 self.assertTrue("xmlid" in dic) -2213 self._checkIDDict(dic, expected) - 2214 -2215 - def test_XMLDTDID_empty(self): - 2216 XMLDTDID = self.etree.XMLDTDID -2217 XML = self.etree.XML -2218 xml_text = _bytes(''' -2219 <document> -2220 <h1 myid="chapter1">...</h1> -2221 ... -2222 Regular paragraph. -2223 ... -2224 </document> -2225 ''') -2226 -2227 root, dic = XMLDTDID(xml_text) -2228 root2 = XML(xml_text) +2245 self.assertEqual(self._writeElement(root), +2246 self._writeElement(root2)) +2247 expected = { +2248 "chapter1" : root[0], +2249 "xmlid" : root[3], +2250 "warn1" : root[4] +2251 } +2252 self.assertTrue("chapter1" in dic) +2253 self.assertTrue("warn1" in dic) +2254 self.assertTrue("xmlid" in dic) +2255 self._checkIDDict(dic, expected) + 2256 +2257 - def test_XMLDTDID_empty(self): + 2258 XMLDTDID = self.etree.XMLDTDID +2259 XML = self.etree.XML +2260 xml_text = _bytes(''' +2261 <document> +2262 <h1 myid="chapter1">...</h1> +2263 ... +2264 Regular paragraph. +2265 ... +2266 </document> +2267 ''') +2268 +2269 root, dic = XMLDTDID(xml_text) +2270 root2 = XML(xml_text) -2229 self.assertEqual(self._writeElement(root), -2230 self._writeElement(root2)) -2231 expected = {} -2232 self._checkIDDict(dic, expected) - 2233 -2234 - def _checkIDDict(self, dic, expected): - 2235 self.assertEqual(len(dic), -2236 len(expected)) -2237 self.assertEqual(sorted(dic.XML(xml_text) +2271 self.assertEqual(self._writeElement(root), +2272 self._writeElement(root2)) +2273 expected = {} +2274 self._checkIDDict(dic, expected) + 2275 +2276 - def _checkIDDict(self, dic, expected): + 2277 self.assertEqual(len(dic), +2278 len(expected)) +2279 self.assertEqual(sorted(dic.items()), -2238 sorted(expected.items()), +2280 sorted(expected.items())) -2239 if sys.version_info < (3,): -2240 self.assertEqual(sorted(dic.iteritems()), -2241 sorted(expected.iteritems())) -2242 self.assertEqual(sorted(dic.items())) +2281 if sys.version_info < (3,): +2282 self.assertEqual(sorted(dic.iteritems()), +2283 sorted(expected.iteritems())) +2284 self.assertEqual(sorted(dic.keys()), -2243 sorted(expected.keys()), +2285 sorted(expected.keys())) -2244 if sys.version_info < (3,): -2245 self.assertEqual(sorted(dic.iterkeys()), -2246 sorted(expected.iterkeys())) -2247 if sys.version_info < (3,): -2248 self.assertEqual(sorted(dic.keys())) +2286 if sys.version_info < (3,): +2287 self.assertEqual(sorted(dic.iterkeys()), +2288 sorted(expected.iterkeys())) +2289 if sys.version_info < (3,): +2290 self.assertEqual(sorted(dic.values()), -2249 sorted(expected.values()), +2291 sorted(expected.values())) -2250 self.assertEqual(sorted(dic.itervalues()), -2251 sorted(expected.itervalues())) - 2252 -2253 - def test_namespaces(self): - 2254 values())) +2292 self.assertEqual(sorted(dic.itervalues()), +2293 sorted(expected.itervalues())) + 2294 +2295 - def test_namespaces(self): + 2296 etree = self.etree = self.etree -2255 -2256 r = {'foo': 'http://ns.infrae.com/foo'} -2257 e = etree +2297 +2298 r = {'foo': 'http://ns.infrae.com/foo'} +2299 e = etree.etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) -2258 self.assertEqual( -2259 'foo', -2260 e.prefix) -2261 self.assertEqual( -2262 _bytes('<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>'), -2263 self._writeElement(e)) - 2264 -2265 - def test_namespaces_default(self): - 2266 Element('{http://ns.infrae.com/foo}bar', nsmap=r) +2300 self.assertEqual( +2301 'foo', +2302 e.prefix) +2303 self.assertEqual( +2304 _bytes('<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>'), +2305 self._writeElement(e)) + 2306 +2307 - def test_namespaces_default(self): + 2308 etree = self.etree = self.etree -2267 -2268 r = {None: 'http://ns.infrae.com/foo'} -2269 e = etree +2309 +2310 r = {None: 'http://ns.infrae.com/foo'} +2311 e = etree.etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) -2270 self.assertEqual( -2271 None, -2272 e.prefix) -2273 self.assertEqual( -2274 '{http://ns.infrae.com/foo}bar', -2275 e.Element('{http://ns.infrae.com/foo}bar', nsmap=r) +2312 self.assertEqual( +2313 None, +2314 e.prefix) +2315 self.assertEqual( +2316 '{http://ns.infrae.com/foo}bar', +2317 e.tag) -2276 self.assertEqual( -2277 _bytes('<bar xmlns="http://ns.infrae.com/foo"></bar>'), -2278 self._writeElement(e)) - 2279 -2280 - def test_namespaces_default_and_attr(self): - 2281 tag) +2318 self.assertEqual( +2319 _bytes('<bar xmlns="http://ns.infrae.com/foo"></bar>'), +2320 self._writeElement(e)) + 2321 +2322 - def test_namespaces_default_and_attr(self): + 2323 etree = self.etree = self.etree -2282 -2283 r = {None: 'http://ns.infrae.com/foo', -2284 'hoi': 'http://ns.infrae.com/hoi'} -2285 e = etree +2324 +2325 r = {None: 'http://ns.infrae.com/foo', +2326 'hoi': 'http://ns.infrae.com/hoi'} +2327 e = etree.etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) -2286 e.set('{http://ns.infrae.com/hoi}test', 'value') -2287 self.assertEqual( -2288 _bytes('<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>'), -2289 self._writeElement(e)) - 2290 -2291 - def test_attribute_keeps_namespace_prefix_on_merge(self): - 2292 Element('{http://ns.infrae.com/foo}bar', nsmap=r) +2328 e.set('{http://ns.infrae.com/hoi}test', 'value') +2329 self.assertEqual( +2330 _bytes('<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>'), +2331 self._writeElement(e)) + 2332 +2333 - def test_attribute_keeps_namespace_prefix_on_merge(self): + 2334 etree = self.etree = self.etree -2293 -2294 root = etree +2335 +2336 root = etree.etree.Element('{http://test/ns}root', -2295 nsmap={None: 'http://test/ns'}) -2296 sub = Element('{http://test/ns}root', +2337 nsmap={None: 'http://test/ns'}) +2338 sub = etree.etree.Element('{http://test/ns}sub', -2297 nsmap={'test': 'http://test/ns'}) -2298 -2299 sub.Element('{http://test/ns}sub', +2339 nsmap={'test': 'http://test/ns'}) +2340 +2341 sub.attrib['{http://test/ns}attr'] = 'value' -2300 self.assertEqual(sub.attrib['{http://test/ns}attr'] = 'value' +2342 self.assertEqual(sub.attrib['{http://test/ns}attr'], 'value') -2301 self.assertEqual( -2302 _bytes('<test:sub xmlns:test="http://test/ns" test:attr="value"/>'), -2303 attrib['{http://test/ns}attr'], 'value') +2343 self.assertEqual( +2344 _bytes('<test:sub xmlns:test="http://test/ns" test:attr="value"/>'), +2345 etree.tostring(sub)) -2304 -2305 root.append(sub) -2306 self.assertEqual( -2307 _bytes('<root xmlns="http://test/ns">' -2308 '' -2309 '</root>'), -2310 etree.tostring(sub)) +2346 +2347 root.append(sub) +2348 self.assertEqual( +2349 _bytes('<root xmlns="http://test/ns">' +2350 '' +2351 '</root>'), +2352 etree.tostring(root)) - 2311 -2312 - def test_attribute_keeps_namespace_prefix_on_merge_with_nons(self): - 2313 etree.tostring(root)) + 2353 +2354 - def test_attribute_keeps_namespace_prefix_on_merge_with_nons(self): + 2355 etree = self.etree = self.etree -2314 -2315 root = etree +2356 +2357 root = etree.etree.Element('root') -2316 sub = Element('root') +2358 sub = etree.etree.Element('{http://test/ns}sub', -2317 nsmap={'test': 'http://test/ns'}) -2318 -2319 sub.Element('{http://test/ns}sub', +2359 nsmap={'test': 'http://test/ns'}) +2360 +2361 sub.attrib['{http://test/ns}attr'] = 'value' -2320 self.assertEqual(sub.attrib['{http://test/ns}attr'] = 'value' +2362 self.assertEqual(sub.attrib['{http://test/ns}attr'], 'value') -2321 self.assertEqual( -2322 _bytes('<test:sub xmlns:test="http://test/ns" test:attr="value"/>'), -2323 attrib['{http://test/ns}attr'], 'value') +2363 self.assertEqual( +2364 _bytes('<test:sub xmlns:test="http://test/ns" test:attr="value"/>'), +2365 etree.tostring(sub)) -2324 -2325 root.append(sub) -2326 self.assertEqual( -2327 _bytes('<root>' -2328 '<test:sub xmlns:test="http://test/ns" test:attr="value"/>' -2329 '</root>'), -2330 etree.tostring(sub)) +2366 +2367 root.append(sub) +2368 self.assertEqual( +2369 _bytes('<root>' +2370 '<test:sub xmlns:test="http://test/ns" test:attr="value"/>' +2371 '</root>'), +2372 etree.tostring(root)) - 2331 -2332 - def test_attribute_gets_namespace_prefix_on_merge_with_nons(self): - 2333 etree.tostring(root)) + 2373 +2374 - def test_attribute_gets_namespace_prefix_on_merge_with_nons(self): + 2375 etree = self.etree = self.etree -2334 -2335 root = etree +2376 +2377 root = etree.etree.Element('root') -2336 sub = Element('root') +2378 sub = etree.etree.Element('{http://test/ns}sub', -2337 nsmap={None: 'http://test/ns'}) -2338 -2339 sub.Element('{http://test/ns}sub', +2379 nsmap={None: 'http://test/ns'}) +2380 +2381 sub.attrib['{http://test/ns}attr'] = 'value' -2340 self.assertEqual(sub.attrib['{http://test/ns}attr'] = 'value' +2382 self.assertEqual(sub.attrib['{http://test/ns}attr'], 'value') -2341 self.assertEqual( -2342 _bytes(''), -2344 attrib['{http://test/ns}attr'], 'value') +2383 self.assertEqual( +2384 _bytes(''), +2386 etree.tostring(sub)) -2345 -2346 root.append(sub) -2347 self.assertEqual( -2348 _bytes('<root>' -2349 '' -2351 '</root>'), -2352 etree.tostring(sub)) +2387 +2388 root.append(sub) +2389 self.assertEqual( +2390 _bytes('<root>' +2391 '' +2393 '</root>'), +2394 etree.tostring(root)) - 2353 -2354 - def test_attribute_gets_namespace_prefix_on_merge(self): - 2355 etree.tostring(root)) + 2395 +2396 - def test_attribute_gets_namespace_prefix_on_merge(self): + 2397 etree = self.etree = self.etree -2356 -2357 root = etree +2398 +2399 root = etree.etree.Element('{http://test/ns}root', -2358 nsmap={'test': 'http://test/ns', -2359 None: 'http://test/ns'}) -2360 sub = Element('{http://test/ns}root', +2400 nsmap={'test': 'http://test/ns', +2401 None: 'http://test/ns'}) +2402 sub = etree.etree.Element('{http://test/ns}sub', -2361 nsmap={None: 'http://test/ns'}) -2362 -2363 sub.Element('{http://test/ns}sub', +2403 nsmap={None: 'http://test/ns'}) +2404 +2405 sub.attrib['{http://test/ns}attr'] = 'value' -2364 self.assertEqual(sub.attrib['{http://test/ns}attr'] = 'value' +2406 self.assertEqual(sub.attrib['{http://test/ns}attr'], 'value') -2365 self.assertEqual( -2366 _bytes(''), -2368 attrib['{http://test/ns}attr'], 'value') +2407 self.assertEqual( +2408 _bytes(''), +2410 etree.tostring(sub)) -2369 -2370 root.append(sub) -2371 self.assertEqual( -2372 _bytes('<test:root xmlns:test="http://test/ns" xmlns="http://test/ns">' -2373 '<test:sub test:attr="value"/>' -2374 '</test:root>'), -2375 etree.tostring(sub)) +2411 +2412 root.append(sub) +2413 self.assertEqual( +2414 _bytes('<test:root xmlns:test="http://test/ns" xmlns="http://test/ns">' +2415 '<test:sub test:attr="value"/>' +2416 '</test:root>'), +2417 etree.tostring(root)) - 2376 -2377 - def test_namespaces_elementtree(self): - 2378 etree.tostring(root)) + 2418 +2419 - def test_namespaces_elementtree(self): + 2420 etree = self.etree = self.etree -2379 r = {None: 'http://ns.infrae.com/foo', -2380 'hoi': 'http://ns.infrae.com/hoi'} -2381 e = etree +2421 r = {None: 'http://ns.infrae.com/foo', +2422 'hoi': 'http://ns.infrae.com/hoi'} +2423 e = etree.etree.Element('{http://ns.infrae.com/foo}z', nsmap=r) -2382 tree = Element('{http://ns.infrae.com/foo}z', nsmap=r) +2424 tree = etree.etree.ElementTree(element=e) -2383 ElementTree(element=e) +2425 etree.SubElement(e, '{http://ns.infrae.com/hoi}x') -2384 self.assertEqual( -2385 _bytes('<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>'), -2386 self._writeElement(e)) - 2387 -2388 - def test_namespaces_default_copy_element(self): - 2389 etree.SubElement(e, '{http://ns.infrae.com/hoi}x') +2426 self.assertEqual( +2427 _bytes('<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>'), +2428 self._writeElement(e)) + 2429 +2430 - def test_namespaces_default_copy_element(self): + 2431 etree = self.etree = self.etree -2390 -2391 r = {None: 'http://ns.infrae.com/foo'} -2392 e1 = etree +2432 +2433 r = {None: 'http://ns.infrae.com/foo'} +2434 e1 = etree.etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) -2393 e2 = Element('{http://ns.infrae.com/foo}bar', nsmap=r) +2435 e2 = etree.etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) -2394 -2395 e1.append(e2) -2396 -2397 self.assertEqual( -2398 None, -2399 e1.prefix) -2400 self.assertEqual( -2401 None, -2402 e1[0].prefix) -2403 self.assertEqual( -2404 '{http://ns.infrae.com/foo}bar', -2405 e1.Element('{http://ns.infrae.com/foo}bar', nsmap=r) +2436 +2437 e1.append(e2) +2438 +2439 self.assertEqual( +2440 None, +2441 e1.prefix) +2442 self.assertEqual( +2443 None, +2444 e1[0].prefix) +2445 self.assertEqual( +2446 '{http://ns.infrae.com/foo}bar', +2447 e1.tag) -2406 self.assertEqual( -2407 '{http://ns.infrae.com/foo}bar', -2408 e1[0].tag) +2448 self.assertEqual( +2449 '{http://ns.infrae.com/foo}bar', +2450 e1[0].tag) - 2409 -2410 - def test_namespaces_copy_element(self): - 2411 tag) + 2451 +2452 - def test_namespaces_copy_element(self): + 2453 etree = self.etree = self.etree -2412 -2413 r = {None: 'http://ns.infrae.com/BAR'} -2414 e1 = etree +2454 +2455 r = {None: 'http://ns.infrae.com/BAR'} +2456 e1 = etree.etree.Element('{http://ns.infrae.com/BAR}bar', nsmap=r) -2415 e2 = Element('{http://ns.infrae.com/BAR}bar', nsmap=r) +2457 e2 = etree.etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) -2416 -2417 e1.append(e2) -2418 -2419 self.assertEqual( -2420 None, -2421 e1.prefix) -2422 self.assertNotEqual( -2423 None, -2424 e2.prefix) -2425 self.assertEqual( -2426 '{http://ns.infrae.com/BAR}bar', -2427 e1.Element('{http://ns.infrae.com/foo}bar', nsmap=r) +2458 +2459 e1.append(e2) +2460 +2461 self.assertEqual( +2462 None, +2463 e1.prefix) +2464 self.assertNotEqual( +2465 None, +2466 e2.prefix) +2467 self.assertEqual( +2468 '{http://ns.infrae.com/BAR}bar', +2469 e1.tag) -2428 self.assertEqual( -2429 '{http://ns.infrae.com/foo}bar', -2430 e2.tag) +2470 self.assertEqual( +2471 '{http://ns.infrae.com/foo}bar', +2472 e2.tag) - 2431 -2432 - def test_namespaces_reuse_after_move(self): - 2433 ns_href = "http://a.b.c" -2434 one = self.tag) + 2473 +2474 - def test_namespaces_reuse_after_move(self): + 2475 ns_href = "http://a.b.c" +2476 one = self.etree.etree.fromstring( -2435 _bytes('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) -2436 baz = one[0][0] -2437 -2438 two = self.fromstring( +2477 _bytes('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) +2478 baz = one[0][0] +2479 +2480 two = self.etree.etree.fromstring( -2439 _bytes('<root xmlns:ns="%s"/>' % ns_href)) -2440 two.append(baz) -2441 del one # make sure the source document is deallocated -2442 -2443 self.assertEqual('{%s}baz' % ns_href, baz.fromstring( +2481 _bytes('<root xmlns:ns="%s"/>' % ns_href)) +2482 two.append(baz) +2483 del one # make sure the source document is deallocated +2484 +2485 self.assertEqual('{%s}baz' % ns_href, baz.tag) -2444 self.assertEqual( -2445 _bytes('<root xmlns:ns="%s"><ns:baz/></root>' % ns_href), -2446 self.tag) +2486 self.assertEqual( +2487 _bytes('<root xmlns:ns="%s"><ns:baz/></root>' % ns_href), +2488 self.etree.tostring(two)) - 2447 -2448 - def test_namespace_cleanup(self): - 2449 xml = _bytes('<foo xmlns="F" xmlns:x="x"><bar xmlns:ns="NS" xmlns:b="b" xmlns="B"><ns:baz/></bar></foo>') -2450 root = self.etree.tostring(two)) + 2489 +2490 - def test_namespace_cleanup(self): + 2491 xml = _bytes('<foo xmlns="F" xmlns:x="x"><bar xmlns:ns="NS" xmlns:b="b" xmlns="B"><ns:baz/></bar></foo>') +2492 root = self.etree.etree.fromstring(xml) -2451 self.assertEqual(xml, -2452 self.fromstring(xml) +2493 self.assertEqual(xml, +2494 self.etree.tostring(root)) -2453 self.etree.tostring(root)) +2495 self.etree.cleanup_namespaces(root) -2454 self.assertEqual( -2455 _bytes('<foo xmlns="F"><bar xmlns:ns="NS" xmlns="B"><ns:baz/></bar></foo>'), -2456 self.etree.cleanup_namespaces(root) +2496 self.assertEqual( +2497 _bytes('<foo xmlns="F"><bar xmlns:ns="NS" xmlns="B"><ns:baz/></bar></foo>'), +2498 self.etree.tostring(root)) - 2457 -2458 - def test_element_nsmap(self): - 2459 etree.tostring(root)) + 2499 +2500 - def test_element_nsmap(self): + 2501 etree = self.etree = self.etree -2460 -2461 r = {None: 'http://ns.infrae.com/foo', -2462 'hoi': 'http://ns.infrae.com/hoi'} -2463 e = etree +2502 +2503 r = {None: 'http://ns.infrae.com/foo', +2504 'hoi': 'http://ns.infrae.com/hoi'} +2505 e = etree.etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) -2464 self.assertEqual( -2465 r, -2466 e.nsmap) - 2467 -2468 - def test_subelement_nsmap(self): - 2469 Element('{http://ns.infrae.com/foo}bar', nsmap=r) +2506 self.assertEqual( +2507 r, +2508 e.nsmap) + 2509 +2510 - def test_subelement_nsmap(self): + 2511 etree = self.etree = self.etree -2470 -2471 re = {None: 'http://ns.infrae.com/foo', -2472 'hoi': 'http://ns.infrae.com/hoi'} -2473 e = etree +2512 +2513 re = {None: 'http://ns.infrae.com/foo', +2514 'hoi': 'http://ns.infrae.com/hoi'} +2515 e = etree.etree.Element('{http://ns.infrae.com/foo}bar', nsmap=re) -2474 -2475 rs = {None: 'http://ns.infrae.com/honk', -2476 'top': 'http://ns.infrae.com/top'} -2477 s = Element('{http://ns.infrae.com/foo}bar', nsmap=re) +2516 +2517 rs = {None: 'http://ns.infrae.com/honk', +2518 'top': 'http://ns.infrae.com/top'} +2519 s = etree.SubElement(e, '{http://ns.infrae.com/honk}bar', nsmap=rs) -2478 -2479 r = re.etree.SubElement(e, '{http://ns.infrae.com/honk}bar', nsmap=rs) +2520 +2521 r = re.copy() -2480 r.update(rs) -2481 self.assertEqual(re, e.nsmap) -2482 self.assertEqual(r, s.nsmap) - 2483 -2484 - def test_html_prefix_nsmap(self): - 2485 copy() +2522 r.update(rs) +2523 self.assertEqual(re, e.nsmap) +2524 self.assertEqual(r, s.nsmap) + 2525 +2526 - def test_html_prefix_nsmap(self): + 2527 etree = self.etree = self.etree -2486 el = etree +2528 el = etree.etree.HTML('<hha:page-description>aa</hha:page-description>').HTML('<hha:page-description>aa</hha:page-description>').find('.//page-description') -2487 self.assertEqual({'hha': None}, el.nsmap) - 2488 -2489 - def test_getiterator_filter_multiple(self): - 2490 find('.//page-description') +2529 self.assertEqual({'hha': None}, el.nsmap) + 2530 +2531 - def test_getiterator_filter_multiple(self): + 2532 Element = self.Element = self.etree.etree.Element -2491 SubElement = self.Element +2533 SubElement = self.etree.SubElement -2492 -2493 a = etree.SubElement +2534 +2535 a = Element('a') -2494 b = SubElement(a, 'b') -2495 c = SubElement(a, 'c') -2496 d = SubElement(b, 'd') -2497 e = SubElement(c, 'e') -2498 f = SubElement(c, 'f') -2499 -2500 self.assertEqual( -2501 [a, b], -2502 list(a.getiterator('a', 'b'))) -2503 self.assertEqual( -2504 [], -2505 list(a.getiterator('x', 'y'))) -2506 self.assertEqual( -2507 [a, f], -2508 list(a.getiterator('f', 'a'))) -2509 self.assertEqual( -2510 [c, e, f], -2511 list(c.getiterator('c', '*', 'a'))) -2512 self.assertEqual( -2513 [], -2514 list(a.getiterator( (), () ))) - 2515 -2516 - def test_getiterator_filter_multiple_tuple(self): - 2517 Element = self.etree.Element -2518 SubElement = self.etree.SubElement -2519 -2520 a = Element('a') -2521 b = SubElement(a, 'b') -2522 c = SubElement(a, 'c') -2523 d = SubElement(b, 'd') -2524 e = SubElement(c, 'e') -2525 f = SubElement(c, 'f') -2526 -2527 self.assertEqual( -2528 [a, b], -2529 list(a.getiterator( ('a', 'b') ))) -2530 self.assertEqual( -2531 [], -2532 list(a.getiterator( ('x', 'y') ))) -2533 self.assertEqual( -2534 [a, f], -2535 list(a.getiterator( ('f', 'a') ))) -2536 self.assertEqual( -2537 [c, e, f], -2538 list(c.getiterator( ('c', '*', 'a') ))) -2539 self.assertEqual( -2540 [], -2541 list(a.getiterator( () ))) - 2542 -2543 - def test_getiterator_filter_namespace(self): - 2544 Element = self.etree.Element -2545 SubElement = self.etree.SubElement -2546 -2547 a = Element('{a}a') -2548 b = SubElement(a, '{a}b') -2549 c = SubElement(a, '{a}c') -2550 d = SubElement(b, '{b}d') -2551 e = SubElement(c, '{a}e') -2552 f = SubElement(c, '{b}f') -2553 g = SubElement(c, 'g') -2554 -2555 self.assertEqual( -2556 [a], -2557 list(a.getiterator('{a}a'))) -2558 self.assertEqual( -2559 [], -2560 list(a.getiterator('{b}a'))) -2561 self.assertEqual( -2562 [], -2563 list(a.getiterator('a'))) -2564 self.assertEqual( -2565 [a,b,d,c,e,f,g], -2566 list(a.getiterator('*'))) -2567 self.assertEqual( -2568 [f], -2569 list(c.getiterator('{b}*'))) -2570 self.assertEqual( -2571 [d, f], -2572 list(a.getiterator('{b}*'))) -2573 self.assertEqual( -2574 [g], -2575 list(a.getiterator('g'))) -2576 self.assertEqual( -2577 [g], -2578 list(a.getiterator('{}g'))) -2579 self.assertEqual( -2580 [g], -2581 list(a.getiterator('{}*'))) - 2582 -2583 - def test_getiterator_filter_local_name(self): - 2584 Element('a') +2536 b = SubElement(a, 'b') +2537 c = SubElement(a, 'c') +2538 d = SubElement(b, 'd') +2539 e = SubElement(c, 'e') +2540 f = SubElement(c, 'f') +2541 +2542 self.assertEqual( +2543 [a, b], +2544 list(a.getiterator('a', 'b'))) +2545 self.assertEqual( +2546 [], +2547 list(a.getiterator('x', 'y'))) +2548 self.assertEqual( +2549 [a, f], +2550 list(a.getiterator('f', 'a'))) +2551 self.assertEqual( +2552 [c, e, f], +2553 list(c.getiterator('c', '*', 'a'))) +2554 self.assertEqual( +2555 [], +2556 list(a.getiterator( (), () ))) + 2557 +2558 - def test_getiterator_filter_multiple_tuple(self): + 2559 Element = self.etree.Element +2560 SubElement = self.etree.SubElement +2561 +2562 a = Element('a') +2563 b = SubElement(a, 'b') +2564 c = SubElement(a, 'c') +2565 d = SubElement(b, 'd') +2566 e = SubElement(c, 'e') +2567 f = SubElement(c, 'f') +2568 +2569 self.assertEqual( +2570 [a, b], +2571 list(a.getiterator( ('a', 'b') ))) +2572 self.assertEqual( +2573 [], +2574 list(a.getiterator( ('x', 'y') ))) +2575 self.assertEqual( +2576 [a, f], +2577 list(a.getiterator( ('f', 'a') ))) +2578 self.assertEqual( +2579 [c, e, f], +2580 list(c.getiterator( ('c', '*', 'a') ))) +2581 self.assertEqual( +2582 [], +2583 list(a.getiterator( () ))) + 2584 +2585 - def test_getiterator_filter_namespace(self): + 2586 Element = self.etree.Element +2587 SubElement = self.etree.SubElement +2588 +2589 a = Element('{a}a') +2590 b = SubElement(a, '{a}b') +2591 c = SubElement(a, '{a}c') +2592 d = SubElement(b, '{b}d') +2593 e = SubElement(c, '{a}e') +2594 f = SubElement(c, '{b}f') +2595 g = SubElement(c, 'g') +2596 +2597 self.assertEqual( +2598 [a], +2599 list(a.getiterator('{a}a'))) +2600 self.assertEqual( +2601 [], +2602 list(a.getiterator('{b}a'))) +2603 self.assertEqual( +2604 [], +2605 list(a.getiterator('a'))) +2606 self.assertEqual( +2607 [a,b,d,c,e,f,g], +2608 list(a.getiterator('*'))) +2609 self.assertEqual( +2610 [f], +2611 list(c.getiterator('{b}*'))) +2612 self.assertEqual( +2613 [d, f], +2614 list(a.getiterator('{b}*'))) +2615 self.assertEqual( +2616 [g], +2617 list(a.getiterator('g'))) +2618 self.assertEqual( +2619 [g], +2620 list(a.getiterator('{}g'))) +2621 self.assertEqual( +2622 [g], +2623 list(a.getiterator('{}*'))) + 2624 +2625 - def test_getiterator_filter_local_name(self): + 2626 Element = self.Element = self.etree.etree.Element -2585 SubElement = self.Element +2627 SubElement = self.etree.SubElement -2586 -2587 a = etree.SubElement +2628 +2629 a = Element('{a}a') -2588 b = SubElement(a, '{nsA}b') -2589 c = SubElement(b, '{nsB}b') -2590 d = SubElement(a, 'b') -2591 e = SubElement(a, '{nsA}e') -2592 f = SubElement(e, '{nsB}e') -2593 g = SubElement(e, 'e') -2594 -2595 self.assertEqual( -2596 [b, c, d], -2597 list(a.getiterator('{*}b'))) -2598 self.assertEqual( -2599 [e, f, g], -2600 list(a.getiterator('{*}e'))) -2601 self.assertEqual( -2602 [a, b, c, d, e, f, g], -2603 list(a.getiterator('{*}*'))) - 2604 -2605 - def test_getiterator_filter_entities(self): - 2606 Element('{a}a') +2630 b = SubElement(a, '{nsA}b') +2631 c = SubElement(b, '{nsB}b') +2632 d = SubElement(a, 'b') +2633 e = SubElement(a, '{nsA}e') +2634 f = SubElement(e, '{nsB}e') +2635 g = SubElement(e, 'e') +2636 +2637 self.assertEqual( +2638 [b, c, d], +2639 list(a.getiterator('{*}b'))) +2640 self.assertEqual( +2641 [e, f, g], +2642 list(a.getiterator('{*}e'))) +2643 self.assertEqual( +2644 [a, b, c, d, e, f, g], +2645 list(a.getiterator('{*}*'))) + 2646 +2647 - def test_getiterator_filter_entities(self): + 2648 Element = self.Element = self.etree.etree.Element -2607 Entity = self.Element +2649 Entity = self.etree.Entity -2608 SubElement = self.etree.Entity +2650 SubElement = self.etree.SubElement -2609 -2610 a = etree.SubElement +2651 +2652 a = Element('a') -2611 b = SubElement(a, 'b') -2612 entity_b = Entity("TEST-b") -2613 b.append(entity_b) -2614 -2615 self.assertEqual( -2616 [entity_b], -2617 list(a.getiterator(Entity))) -2618 -2619 entity_a = Entity("TEST-a") -2620 a.append(entity_a) -2621 -2622 self.assertEqual( -2623 [entity_b, entity_a], -2624 list(a.getiterator(Entity))) -2625 -2626 self.assertEqual( -2627 [entity_b], -2628 list(b.getiterator(Entity))) - 2629 -2630 - def test_getiterator_filter_element(self): - 2631 Element('a') +2653 b = SubElement(a, 'b') +2654 entity_b = Entity("TEST-b") +2655 b.append(entity_b) +2656 +2657 self.assertEqual( +2658 [entity_b], +2659 list(a.getiterator(Entity))) +2660 +2661 entity_a = Entity("TEST-a") +2662 a.append(entity_a) +2663 +2664 self.assertEqual( +2665 [entity_b, entity_a], +2666 list(a.getiterator(Entity))) +2667 +2668 self.assertEqual( +2669 [entity_b], +2670 list(b.getiterator(Entity))) + 2671 +2672 - def test_getiterator_filter_element(self): + 2673 Element = self.Element = self.etree.etree.Element -2632 Comment = self.Element +2674 Comment = self.etree.Comment -2633 PI = self.etree.Comment +2675 PI = self.etree.PI -2634 SubElement = self.etree.PI +2676 SubElement = self.etree.SubElement -2635 -2636 a = etree.SubElement +2677 +2678 a = Element('a') -2637 b = SubElement(a, 'b') -2638 a.append(Comment("test")) -2639 a.append(PI("pi", "content")) -2640 c = SubElement(a, 'c') -2641 -2642 self.assertEqual( -2643 [a, b, c], -2644 list(a.getiterator(Element('a') +2679 b = SubElement(a, 'b') +2680 a.append(Comment("test")) +2681 a.append(PI("pi", "content")) +2682 c = SubElement(a, 'c') +2683 +2684 self.assertEqual( +2685 [a, b, c], +2686 list(a.getiterator(Element))) - 2645 -2646 - def test_getiterator_filter_all_comment_pi(self): - 2647 # ElementTree iterates over everything here -2648 Element))) + 2687 +2688 - def test_getiterator_filter_all_comment_pi(self): + 2689 # ElementTree iterates over everything here +2690 Element = self.Element = self.etree.etree.Element -2649 Comment = self.Element +2691 Comment = self.etree.Comment -2650 PI = self.etree.Comment +2692 PI = self.etree.PI -2651 SubElement = self.etree.PI +2693 SubElement = self.etree.SubElement -2652 -2653 a = etree.SubElement +2694 +2695 a = Element('a') -2654 b = SubElement(a, 'b') -2655 a.append(Comment("test")) -2656 a.append(PI("pi", "content")) -2657 c = SubElement(a, 'c') -2658 -2659 self.assertEqual( -2660 [a, b, c], -2661 list(a.getiterator('*'))) - 2662 -2663 - def test_elementtree_find_qname(self): - 2664 Element('a') +2696 b = SubElement(a, 'b') +2697 a.append(Comment("test")) +2698 a.append(PI("pi", "content")) +2699 c = SubElement(a, 'c') +2700 +2701 self.assertEqual( +2702 [a, b, c], +2703 list(a.getiterator('*'))) + 2704 +2705 - def test_elementtree_find_qname(self): + 2706 XML = self.XML = self.etree.etree.XML -2665 XML +2707 ElementTree = self.ElementTree = self.etree.etree.ElementTree -2666 QName = self.ElementTree +2708 QName = self.etree.QName -2667 tree = etree.QName +2709 tree = ElementTree(ElementTree(XML(_bytes('<a><c/><c></c></a>'))) -2668 self.assertEqual(tree.XML(_bytes('<a><c/><c></c></a>'))) +2710 self.assertEqual(tree.find(QName("c")), tree.getroot()[2]) - 2669 -2670 - def test_elementtree_findall_qname(self): - 2671 find(QName("c")), tree.getroot()[2]) + 2711 +2712 - def test_elementtree_findall_qname(self): + 2713 XML = self.XML = self.etree.etree.XML -2672 XML +2714 ElementTree = self.ElementTree = self.etree.etree.ElementTree -2673 QName = self.ElementTree +2715 QName = self.etree.QName -2674 tree = etree.QName +2716 tree = ElementTree(ElementTree(XML(_bytes('<a><c/><c></c></a>'))) -2675 self.assertEqual(len(list(tree.findall(QName("c")))), 1) - 2676 -2677 - def test_elementtree_findall_ns_qname(self): - 2678 XML(_bytes('<a><c/><c></c></a>'))) +2717 self.assertEqual(len(list(tree.findall(QName("c")))), 1) + 2718 +2719 - def test_elementtree_findall_ns_qname(self): + 2720 XML = self.XML = self.etree.etree.XML -2679 XML +2721 ElementTree = self.ElementTree = self.etree.etree.ElementTree -2680 QName = self.ElementTree +2722 QName = self.etree.QName -2681 tree = etree.QName +2723 tree = ElementTree(ElementTree(XML( -2682 _bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>'))) -2683 self.assertEqual(len(list(tree.findall(QName("b")))), 2) -2684 self.assertEqual(len(list(tree.findall(QName("X", "b")))), 1) - 2685 -2686 - def test_findall_ns(self): - 2687 XML( +2724 _bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>'))) +2725 self.assertEqual(len(list(tree.findall(QName("b")))), 2) +2726 self.assertEqual(len(list(tree.findall(QName("X", "b")))), 1) + 2727 +2728 - def test_findall_ns(self): + 2729 XML = self.XML = self.etree.etree.XML -2688 root = XML +2730 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>')) -2689 self.assertEqual(len(root.findall(".//{X}b")), 2) -2690 self.assertEqual(len(root.findall(".//{X}*")), 2) -2691 self.assertEqual(len(root.findall(".//b")), 3) - 2692 -2693 - def test_findall_different_nsmaps(self): - 2694 XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c></a>')) +2731 self.assertEqual(len(root.findall(".//{X}b")), 2) +2732 self.assertEqual(len(root.findall(".//{X}*")), 2) +2733 self.assertEqual(len(root.findall(".//b")), 3) + 2734 +2735 - def test_findall_different_nsmaps(self): + 2736 XML = self.XML = self.etree.etree.XML -2695 root = XML +2737 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c><y:b/></a>')) -2696 nsmap = {'xx': 'X'} -2697 self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 2) -2698 self.assertEqual(len(root.findall(".//xx:*", namespaces=nsmap)), 2) -2699 self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2) -2700 nsmap = {'xx': 'Y'} -2701 self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 1) -2702 self.assertEqual(len(root.findall(".//xx:*", namespaces=nsmap)), 1) -2703 self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2) - 2704 -2705 - def test_findall_different_nsmaps(self): - 2706 XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c><y:b/></a>')) +2738 nsmap = {'xx': 'X'} +2739 self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 2) +2740 self.assertEqual(len(root.findall(".//xx:*", namespaces=nsmap)), 2) +2741 self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2) +2742 nsmap = {'xx': 'Y'} +2743 self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 1) +2744 self.assertEqual(len(root.findall(".//xx:*", namespaces=nsmap)), 1) +2745 self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2) + 2746 +2747 - def test_findall_different_nsmaps(self): + 2748 XML = self.XML = self.etree.etree.XML -2707 root = XML +2749 root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c><y:b/></a>')) -2708 nsmap = {'xx': 'X'} -2709 self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 2) -2710 self.assertEqual(len(root.findall(".//xx:*", namespaces=nsmap)), 2) -2711 self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2) -2712 nsmap = {'xx': 'Y'} -2713 self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 1) -2714 self.assertEqual(len(root.findall(".//xx:*", namespaces=nsmap)), 1) -2715 self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2) - 2716 -2717 - def test_findall_syntax_error(self): - 2718 XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><c><x:b/></c><y:b/></a>')) +2750 nsmap = {'xx': 'X'} +2751 self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 2) +2752 self.assertEqual(len(root.findall(".//xx:*", namespaces=nsmap)), 2) +2753 self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2) +2754 nsmap = {'xx': 'Y'} +2755 self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 1) +2756 self.assertEqual(len(root.findall(".//xx:*", namespaces=nsmap)), 1) +2757 self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2) + 2758 +2759 - def test_findall_syntax_error(self): + 2760 XML = self.XML = self.etree.etree.XML -2719 root = XML +2761 root = XML(_bytes('<a><c/><c></c></a>')) -2720 self.assertRaises(SyntaxError, root.findall, '') -2721 self.assertRaises(SyntaxError, root.findall, '//') # absolute path on Element -2722 self.assertRaises(SyntaxError, root.findall, './//') - 2723 -2724 - def test_index(self): - 2725 XML(_bytes('<a><c/><c></c></a>')) +2762 self.assertRaises(SyntaxError, root.findall, '') +2763 self.assertRaises(SyntaxError, root.findall, '//') # absolute path on Element +2764 self.assertRaises(SyntaxError, root.findall, './//') + 2765 +2766 - def test_index(self): + 2767 etree = self.etree = self.etree -2726 e = etree +2768 e = etree.etree.Element('foo') -2727 for i in range(10): -2728 Element('foo') +2769 for i in range(10): +2770 etree.SubElement(e, 'a%s' % i) -2729 for i in range(10): -2730 self.assertEqual( -2731 i, -2732 e.index(e[i])) -2733 self.assertEqual( -2734 3, e.index(e[3], 3)) -2735 self.assertRaises( -2736 ValueError, e.index, e[3], 4) -2737 self.assertRaises( -2738 ValueError, e.index, e[3], 0, 2) -2739 self.assertRaises( -2740 ValueError, e.index, e[8], 0, -3) -2741 self.assertRaises( -2742 ValueError, e.index, e[8], -5, -3) -2743 self.assertEqual( -2744 8, e.index(e[8], 0, -1)) -2745 self.assertEqual( -2746 8, e.index(e[8], -12, -1)) -2747 self.assertEqual( -2748 0, e.index(e[0], -12, -1)) - 2749 -2750 - def test_replace(self): - 2751 etree.SubElement(e, 'a%s' % i) +2771 for i in range(10): +2772 self.assertEqual( +2773 i, +2774 e.index(e[i])) +2775 self.assertEqual( +2776 3, e.index(e[3], 3)) +2777 self.assertRaises( +2778 ValueError, e.index, e[3], 4) +2779 self.assertRaises( +2780 ValueError, e.index, e[3], 0, 2) +2781 self.assertRaises( +2782 ValueError, e.index, e[8], 0, -3) +2783 self.assertRaises( +2784 ValueError, e.index, e[8], -5, -3) +2785 self.assertEqual( +2786 8, e.index(e[8], 0, -1)) +2787 self.assertEqual( +2788 8, e.index(e[8], -12, -1)) +2789 self.assertEqual( +2790 0, e.index(e[0], -12, -1)) + 2791 +2792 - def test_replace(self): + 2793 etree = self.etree = self.etree -2752 e = etree +2794 e = etree.etree.Element('foo') -2753 for i in range(10): -2754 el = Element('foo') +2795 for i in range(10): +2796 el = etree.SubElement(e, 'a%s' % i) -2755 el.etree.SubElement(e, 'a%s' % i) +2797 el.text = "text%d" % i -2756 el.tail = "tail%d" % i -2757 -2758 child0 = e[0] -2759 child1 = e[1] -2760 child2 = e[2] -2761 -2762 e.replace(e[0], e[1]) -2763 self.assertEqual( -2764 9, len(e)) -2765 self.assertEqual( -2766 child1, e[0]) -2767 self.assertEqual( -2768 child1.text = "text%d" % i +2798 el.tail = "tail%d" % i +2799 +2800 child0 = e[0] +2801 child1 = e[1] +2802 child2 = e[2] +2803 +2804 e.replace(e[0], e[1]) +2805 self.assertEqual( +2806 9, len(e)) +2807 self.assertEqual( +2808 child1, e[0]) +2809 self.assertEqual( +2810 child1.text, "text1") -2769 self.assertEqual( -2770 child1.tail, "tail1") -2771 self.assertEqual( -2772 child0.tail, "tail0") -2773 self.assertEqual( -2774 child2, e[1]) -2775 -2776 e.replace(e[-1], e[0]) -2777 self.assertEqual( -2778 child1, e[-1]) -2779 self.assertEqual( -2780 child1.text, "text1") +2811 self.assertEqual( +2812 child1.tail, "tail1") +2813 self.assertEqual( +2814 child0.tail, "tail0") +2815 self.assertEqual( +2816 child2, e[1]) +2817 +2818 e.replace(e[-1], e[0]) +2819 self.assertEqual( +2820 child1, e[-1]) +2821 self.assertEqual( +2822 child1.text, "text1") -2781 self.assertEqual( -2782 child1.tail, "tail1") -2783 self.assertEqual( -2784 child2, e[0]) - 2785 -2786 - def test_replace_new(self): - 2787 text, "text1") +2823 self.assertEqual( +2824 child1.tail, "tail1") +2825 self.assertEqual( +2826 child2, e[0]) + 2827 +2828 - def test_replace_new(self): + 2829 etree = self.etree = self.etree -2788 e = etree +2830 e = etree.etree.Element('foo') -2789 for i in range(10): -2790 Element('foo') +2831 for i in range(10): +2832 etree.SubElement(e, 'a%s' % i) -2791 -2792 new_element = etree.SubElement(e, 'a%s' % i) +2833 +2834 new_element = etree.etree.Element("test") -2793 new_element.Element("test") +2835 new_element.text = "TESTTEXT" -2794 new_element.tail = "TESTTAIL" -2795 child1 = e[1] -2796 e.replace(e[0], new_element) -2797 self.assertEqual( -2798 new_element, e[0]) -2799 self.assertEqual( -2800 "TESTTEXT", -2801 e[0].text = "TESTTEXT" +2836 new_element.tail = "TESTTAIL" +2837 child1 = e[1] +2838 e.replace(e[0], new_element) +2839 self.assertEqual( +2840 new_element, e[0]) +2841 self.assertEqual( +2842 "TESTTEXT", +2843 e[0].text) -2802 self.assertEqual( -2803 "TESTTAIL", -2804 e[0].tail) -2805 self.assertEqual( -2806 child1, e[1]) - 2807 -2808 - def test_setslice_all_empty_reversed(self): - 2809 text) +2844 self.assertEqual( +2845 "TESTTAIL", +2846 e[0].tail) +2847 self.assertEqual( +2848 child1, e[1]) + 2849 +2850 - def test_setslice_all_empty_reversed(self): + 2851 Element = self.Element = self.etree.etree.Element -2810 SubElement = self.Element +2852 SubElement = self.etree.SubElement -2811 -2812 a = etree.SubElement +2853 +2854 a = Element('a') -2813 -2814 e = Element('a') +2855 +2856 e = Element('e') -2815 f = Element('e') +2857 f = Element('f') -2816 g = Element('f') +2858 g = Element('g') -2817 -2818 s = [e, f, g] -2819 a[::-1] = s -2820 self.assertEqual( -2821 [g, f, e], -2822 list(a)) - 2823 -2824 - def test_setslice_step(self): - 2825 Element('g') +2859 +2860 s = [e, f, g] +2861 a[::-1] = s +2862 self.assertEqual( +2863 [g, f, e], +2864 list(a)) + 2865 +2866 - def test_setslice_step(self): + 2867 Element = self.Element = self.etree.etree.Element -2826 SubElement = self.Element +2868 SubElement = self.etree.SubElement -2827 -2828 a = etree.SubElement +2869 +2870 a = Element('a') -2829 b = SubElement(a, 'b') -2830 c = SubElement(a, 'c') -2831 d = SubElement(a, 'd') -2832 e = SubElement(a, 'e') -2833 -2834 x = Element('a') +2871 b = SubElement(a, 'b') +2872 c = SubElement(a, 'c') +2873 d = SubElement(a, 'd') +2874 e = SubElement(a, 'e') +2875 +2876 x = Element('x') -2835 y = Element('x') +2877 y = Element('y') -2836 -2837 a[1::2] = [x, y] -2838 self.assertEqual( -2839 [b, x, d, y], -2840 list(a)) - 2841 -2842 - def test_setslice_step_negative(self): - 2843 Element('y') +2878 +2879 a[1::2] = [x, y] +2880 self.assertEqual( +2881 [b, x, d, y], +2882 list(a)) + 2883 +2884 - def test_setslice_step_negative(self): + 2885 Element = self.Element = self.etree.etree.Element -2844 SubElement = self.Element +2886 SubElement = self.etree.SubElement -2845 -2846 a = etree.SubElement +2887 +2888 a = Element('a') -2847 b = SubElement(a, 'b') -2848 c = SubElement(a, 'c') -2849 d = SubElement(a, 'd') -2850 e = SubElement(a, 'e') -2851 -2852 x = Element('a') +2889 b = SubElement(a, 'b') +2890 c = SubElement(a, 'c') +2891 d = SubElement(a, 'd') +2892 e = SubElement(a, 'e') +2893 +2894 x = Element('x') -2853 y = Element('x') +2895 y = Element('y') -2854 -2855 a[1::-1] = [x, y] -2856 self.assertEqual( -2857 [y, x, d, e], -2858 list(a)) - 2859 -2860 - def test_setslice_step_negative2(self): - 2861 Element('y') +2896 +2897 a[1::-1] = [x, y] +2898 self.assertEqual( +2899 [y, x, d, e], +2900 list(a)) + 2901 +2902 - def test_setslice_step_negative2(self): + 2903 Element = self.Element = self.etree.etree.Element -2862 SubElement = self.Element +2904 SubElement = self.etree.SubElement -2863 -2864 a = etree.SubElement +2905 +2906 a = Element('a') -2865 b = SubElement(a, 'b') -2866 c = SubElement(a, 'c') -2867 d = SubElement(a, 'd') -2868 e = SubElement(a, 'e') -2869 -2870 x = Element('a') +2907 b = SubElement(a, 'b') +2908 c = SubElement(a, 'c') +2909 d = SubElement(a, 'd') +2910 e = SubElement(a, 'e') +2911 +2912 x = Element('x') -2871 y = Element('x') +2913 y = Element('y') -2872 -2873 a[::-2] = [x, y] -2874 self.assertEqual( -2875 [b, y, d, x], -2876 list(a)) - 2877 -2878 - def test_setslice_step_overrun(self): - 2879 Element('y') +2914 +2915 a[::-2] = [x, y] +2916 self.assertEqual( +2917 [b, y, d, x], +2918 list(a)) + 2919 +2920 - def test_setslice_step_overrun(self): + 2921 Element = self.Element = self.etree.etree.Element -2880 SubElement = self.Element +2922 SubElement = self.etree.SubElement -2881 try: -2882 slice -2883 except NameError: -2884 print("slice() not found") -2885 return -2886 -2887 a = etree.SubElement +2923 try: +2924 slice +2925 except NameError: +2926 print("slice() not found") +2927 return +2928 +2929 a = Element('a') -2888 b = SubElement(a, 'b') -2889 c = SubElement(a, 'c') -2890 d = SubElement(a, 'd') -2891 e = SubElement(a, 'e') -2892 -2893 x = Element('a') +2930 b = SubElement(a, 'b') +2931 c = SubElement(a, 'c') +2932 d = SubElement(a, 'd') +2933 e = SubElement(a, 'e') +2934 +2935 x = Element('x') -2894 y = Element('x') +2936 y = Element('y') -2895 z = Element('y') +2937 z = Element('z') -2896 -2897 self.assertRaises( -2898 ValueError, -2899 operator.setitem, a, slice(1,None,2), [x, y, z]) -2900 -2901 self.assertEqual( -2902 [b, c, d, e], -2903 list(a)) - 2904 -2905 - def test_sourceline_XML(self): - 2906 Element('z') +2938 +2939 self.assertRaises( +2940 ValueError, +2941 operator.setitem, a, slice(1,None,2), [x, y, z]) +2942 +2943 self.assertEqual( +2944 [b, c, d, e], +2945 list(a)) + 2946 +2947 - def test_sourceline_XML(self): + 2948 XML = self.XML = self.etree.etree.XML -2907 root = XML +2949 root = XML(_bytes('''<?xml version="1.0"?> -2908 <root><test> -2909 -2910 <bla/></test> -2911 </root> -2912 ''')) -2913 -2914 self.assertEqual( -2915 [2, 2, 4], -2916 [ el.sourceline for el in root.getiterator() ]) - 2917 -2918 - def test_large_sourceline_XML(self): - 2919 XML(_bytes('''<?xml version="1.0"?> +2950 <root><test> +2951 +2952 <bla/></test> +2953 </root> +2954 ''')) +2955 +2956 self.assertEqual( +2957 [2, 2, 4], +2958 [ el.sourceline for el in root.getiterator() ]) + 2959 +2960 - def test_large_sourceline_XML(self): + 2961 XML = self.XML = self.etree.etree.XML -2920 root = XML +2962 root = XML(_bytes( -2921 '<?xml version="1.0"?>\n' -2922 '<root>' + '\n' * 65536 + -2923 '' + '\n' * 65536 + '\n' + -2924 ' \n' -2925 '</root>')) -2926 -2927 if self.XML(_bytes( +2963 '<?xml version="1.0"?>\n' +2964 '<root>' + '\n' * 65536 + +2965 '' + '\n' * 65536 + '\n' + +2966 ' \n' +2967 '</root>')) +2968 +2969 if self.etree.LIBXML_VERSION >= (2, 9): -2928 expected = [2, 131074, 131076] -2929 else: -2930 expected = [2, 65535, 65535] -2931 -2932 self.assertEqual(expected, [el.sourceline for el in root.iter()]) - 2933 -2934 - def test_sourceline_parse(self): - 2935 etree.LIBXML_VERSION >= (2, 9): +2970 expected = [2, 131074, 131076] +2971 else: +2972 expected = [2, 65535, 65535] +2973 +2974 self.assertEqual(expected, [el.sourceline for el in root.iter()]) + 2975 +2976 - def test_sourceline_parse(self): + 2977 parse = self.parse = self.etree.etree.parse -2936 tree = parse +2978 tree = parse(fileInTestDir('include/test_xinclude.xml')) -2937 -2938 self.assertEqual( -2939 [1, 2, 3], -2940 [ el.sourceline for el in tree.getiterator() ]) - 2941 -2942 - def test_sourceline_iterparse_end(self): - 2943 iterparse = self.parse(fileInTestDir('include/test_xinclude.xml')) +2979 +2980 self.assertEqual( +2981 [1, 2, 3], +2982 [ el.sourceline for el in tree.getiterator() ]) + 2983 +2984 - def test_sourceline_iterparse_end(self): + 2985 iterparse = self.etree.iterparse -2944 lines = [ el.sourceline for (event, el) in -2945 iterparse(fileInTestDir('include/test_xinclude.xml')) ] -2946 -2947 self.assertEqual( -2948 [2, 3, 1], -2949 lines) - 2950 -2951 - def test_sourceline_iterparse_start(self): - 2952 iterparse = self.etree.iterparse +2986 lines = [ el.sourceline for (event, el) in +2987 iterparse(fileInTestDir('include/test_xinclude.xml')) ] +2988 +2989 self.assertEqual( +2990 [2, 3, 1], +2991 lines) + 2992 +2993 - def test_sourceline_iterparse_start(self): + 2994 iterparse = self.etree.iterparse -2953 lines = [ el.sourceline for (event, el) in -2954 iterparse(fileInTestDir('include/test_xinclude.xml'), -2955 events=("start",)) ] -2956 -2957 self.assertEqual( -2958 [1, 2, 3], -2959 lines) - 2960 -2961 - def test_sourceline_element(self): - 2962 etree.iterparse +2995 lines = [ el.sourceline for (event, el) in +2996 iterparse(fileInTestDir('include/test_xinclude.xml'), +2997 events=("start",)) ] +2998 +2999 self.assertEqual( +3000 [1, 2, 3], +3001 lines) + 3002 +3003 - def test_sourceline_element(self): + 3004 Element = self.Element = self.etree.etree.Element -2963 SubElement = self.Element +3005 SubElement = self.etree.SubElement -2964 el = etree.SubElement +3006 el = Element("test") -2965 self.assertEqual(None, el.sourceline) -2966 -2967 child = SubElement(el, "test") -2968 self.assertEqual(None, el.sourceline) -2969 self.assertEqual(None, child.sourceline) - 2970 -2971 - def test_XML_base_url_docinfo(self): - 2972 Element("test") +3007 self.assertEqual(None, el.sourceline) +3008 +3009 child = SubElement(el, "test") +3010 self.assertEqual(None, el.sourceline) +3011 self.assertEqual(None, child.sourceline) + 3012 +3013 - def test_XML_base_url_docinfo(self): + 3014 etree = self.etree = self.etree -2973 root = etree +3015 root = etree.etree.XML(_bytes("<root/>"), base_url="http://no/such/url") -2974 docinfo = root.getroottree().docinfo -2975 self.assertEqual(docinfo.URL, "http://no/such/url") - 2976 -2977 - def test_XML_set_base_url_docinfo(self): - 2978 XML(_bytes("<root/>"), base_url="http://no/such/url") +3016 docinfo = root.getroottree().docinfo +3017 self.assertEqual(docinfo.URL, "http://no/such/url") + 3018 +3019 - def test_XML_set_base_url_docinfo(self): + 3020 etree = self.etree = self.etree -2979 root = etree +3021 root = etree.etree.XML(_bytes("<root/>"), base_url="http://no/such/url") -2980 docinfo = root.getroottree().docinfo -2981 self.assertEqual(docinfo.URL, "http://no/such/url") -2982 docinfo.URL = "https://secret/url" -2983 self.assertEqual(docinfo.URL, "https://secret/url") - 2984 -2985 - def test_parse_stringio_base_url(self): - 2986 XML(_bytes("<root/>"), base_url="http://no/such/url") +3022 docinfo = root.getroottree().docinfo +3023 self.assertEqual(docinfo.URL, "http://no/such/url") +3024 docinfo.URL = "https://secret/url" +3025 self.assertEqual(docinfo.URL, "https://secret/url") + 3026 +3027 - def test_parse_stringio_base_url(self): + 3028 etree = self.etree = self.etree -2987 tree = etree +3029 tree = etree.etree.parse(BytesIO("<root/>"), base_url="http://no/such/url") -2988 docinfo = tree.docinfo -2989 self.assertEqual(docinfo.URL, "http://no/such/url") - 2990 -2991 - def test_parse_base_url_docinfo(self): - 2992 parse(BytesIO("<root/>"), base_url="http://no/such/url") +3030 docinfo = tree.docinfo +3031 self.assertEqual(docinfo.URL, "http://no/such/url") + 3032 +3033 - def test_parse_base_url_docinfo(self): + 3034 etree = self.etree = self.etree -2993 tree = etree +3035 tree = etree.etree.parse(fileInTestDir('include/test_xinclude.xml'), -2994 base_url="http://no/such/url") -2995 docinfo = tree.docinfo -2996 self.assertEqual(docinfo.URL, "http://no/such/url") - 2997 -2998 - def test_HTML_base_url_docinfo(self): - 2999 parse(fileInTestDir('include/test_xinclude.xml'), +3036 base_url="http://no/such/url") +3037 docinfo = tree.docinfo +3038 self.assertEqual(docinfo.URL, "http://no/such/url") + 3039 +3040 - def test_HTML_base_url_docinfo(self): + 3041 etree = self.etree = self.etree -3000 root = etree +3042 root = etree.etree.HTML(_bytes("<html/>"), base_url="http://no/such/url") -3001 docinfo = root.getroottree().docinfo -3002 self.assertEqual(docinfo.URL, "http://no/such/url") - 3003 -3004 - def test_docinfo_public(self): - 3005 HTML(_bytes("<html/>"), base_url="http://no/such/url") +3043 docinfo = root.getroottree().docinfo +3044 self.assertEqual(docinfo.URL, "http://no/such/url") + 3045 +3046 - def test_docinfo_public(self): + 3047 etree = self.etree = self.etree -3006 xml_header = '<?xml version="1.0" encoding="ascii"?>' -3007 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" -3008 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" -3009 doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id) -3010 -3011 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>') -3012 -3013 tree = etree +3048 xml_header = '<?xml version="1.0" encoding="ascii"?>' +3049 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" +3050 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" +3051 doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id) +3052 +3053 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>') +3054 +3055 tree = etree.etree.parse(BytesIO(xml)) -3014 docinfo = tree.docinfo -3015 self.assertEqual(docinfo.encoding, "ascii") -3016 self.assertEqual(docinfo.xml_version, "1.0") -3017 self.assertEqual(docinfo.public_id, pub_id) -3018 self.assertEqual(docinfo.system_url, sys_id) -3019 self.assertEqual(docinfo.root_name, 'html') -3020 self.assertEqual(docinfo.doctype, doctype_string) - 3021 -3022 - def test_docinfo_system(self): - 3023 parse(BytesIO(xml)) +3056 docinfo = tree.docinfo +3057 self.assertEqual(docinfo.encoding, "ascii") +3058 self.assertEqual(docinfo.xml_version, "1.0") +3059 self.assertEqual(docinfo.public_id, pub_id) +3060 self.assertEqual(docinfo.system_url, sys_id) +3061 self.assertEqual(docinfo.root_name, 'html') +3062 self.assertEqual(docinfo.doctype, doctype_string) + 3063 +3064 - def test_docinfo_system(self): + 3065 etree = self.etree = self.etree -3024 xml_header = '<?xml version="1.0" encoding="UTF-8"?>' -3025 sys_id = "some.dtd" -3026 doctype_string = '<!DOCTYPE html SYSTEM "%s">' % sys_id -3027 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>') -3028 -3029 tree = etree +3066 xml_header = '<?xml version="1.0" encoding="UTF-8"?>' +3067 sys_id = "some.dtd" +3068 doctype_string = '<!DOCTYPE html SYSTEM "%s">' % sys_id +3069 xml = _bytes(xml_header + doctype_string + '<html><body></body></html>') +3070 +3071 tree = etree.etree.parse(BytesIO(xml)) -3030 docinfo = tree.docinfo -3031 self.assertEqual(docinfo.encoding, "UTF-8") -3032 self.assertEqual(docinfo.xml_version, "1.0") -3033 self.assertEqual(docinfo.public_id, None) -3034 self.assertEqual(docinfo.system_url, sys_id) -3035 self.assertEqual(docinfo.root_name, 'html') -3036 self.assertEqual(docinfo.doctype, doctype_string) - 3037 -3038 - def test_docinfo_empty(self): - 3039 parse(BytesIO(xml)) +3072 docinfo = tree.docinfo +3073 self.assertEqual(docinfo.encoding, "UTF-8") +3074 self.assertEqual(docinfo.xml_version, "1.0") +3075 self.assertEqual(docinfo.public_id, None) +3076 self.assertEqual(docinfo.system_url, sys_id) +3077 self.assertEqual(docinfo.root_name, 'html') +3078 self.assertEqual(docinfo.doctype, doctype_string) + 3079 +3080 - def test_docinfo_empty(self): + 3081 etree = self.etree = self.etree -3040 xml = _bytes('<html><body></body></html>') -3041 tree = etree +3082 xml = _bytes('<html><body></body></html>') +3083 tree = etree.etree.parse(BytesIO(xml)) -3042 docinfo = tree.docinfo -3043 self.assertEqual(docinfo.encoding, "UTF-8") -3044 self.assertEqual(docinfo.xml_version, "1.0") -3045 self.assertEqual(docinfo.public_id, None) -3046 self.assertEqual(docinfo.system_url, None) -3047 self.assertEqual(docinfo.root_name, 'html') -3048 self.assertEqual(docinfo.doctype, '') - 3049 -3050 - def test_docinfo_name_only(self): - 3051 parse(BytesIO(xml)) +3084 docinfo = tree.docinfo +3085 self.assertEqual(docinfo.encoding, "UTF-8") +3086 self.assertEqual(docinfo.xml_version, "1.0") +3087 self.assertEqual(docinfo.public_id, None) +3088 self.assertEqual(docinfo.system_url, None) +3089 self.assertEqual(docinfo.root_name, 'html') +3090 self.assertEqual(docinfo.doctype, '') + 3091 +3092 - def test_docinfo_name_only(self): + 3093 etree = self.etree = self.etree -3052 xml = _bytes('<!DOCTYPE root><root></root>') -3053 tree = etree +3094 xml = _bytes('<!DOCTYPE root><root></root>') +3095 tree = etree.etree.parse(BytesIO(xml)) -3054 docinfo = tree.docinfo -3055 self.assertEqual(docinfo.encoding, "UTF-8") -3056 self.assertEqual(docinfo.xml_version, "1.0") -3057 self.assertEqual(docinfo.public_id, None) -3058 self.assertEqual(docinfo.system_url, None) -3059 self.assertEqual(docinfo.root_name, 'root') -3060 self.assertEqual(docinfo.doctype, '<!DOCTYPE root>') - 3061 -3062 - def test_doctype_name_only_roundtrip(self): - 3063 parse(BytesIO(xml)) +3096 docinfo = tree.docinfo +3097 self.assertEqual(docinfo.encoding, "UTF-8") +3098 self.assertEqual(docinfo.xml_version, "1.0") +3099 self.assertEqual(docinfo.public_id, None) +3100 self.assertEqual(docinfo.system_url, None) +3101 self.assertEqual(docinfo.root_name, 'root') +3102 self.assertEqual(docinfo.doctype, '<!DOCTYPE root>') + 3103 +3104 - def test_doctype_name_only_roundtrip(self): + 3105 etree = self.etree = self.etree -3064 xml = _bytes('<!DOCTYPE root>\n<root/>') -3065 tree = etree +3106 xml = _bytes('<!DOCTYPE root>\n<root/>') +3107 tree = etree.etree.parse(BytesIO(xml)) -3066 self.assertEqual(xml, parse(BytesIO(xml)) +3108 self.assertEqual(xml, etree.tostring(tree)) - 3067 -3068 - def test_doctype_output_override(self): - 3069 etree.tostring(tree)) + 3109 +3110 - def test_doctype_output_override(self): + 3111 etree = self.etree = self.etree -3070 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" -3071 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" -3072 doctype_string = _bytes('<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id)) -3073 -3074 xml = _bytes('<!DOCTYPE root>\n<root/>') -3075 tree = etree +3112 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" +3113 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" +3114 doctype_string = _bytes('<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id)) +3115 +3116 xml = _bytes('<!DOCTYPE root>\n<root/>') +3117 tree = etree.etree.parse(BytesIO(xml)) -3076 self.assertEqual(xml.replace(_bytes('<!DOCTYPE root>'), doctype_string), -3077 parse(BytesIO(xml)) +3118 self.assertEqual(xml.replace(_bytes('<!DOCTYPE root>'), doctype_string), +3119 etree.tostring(tree, doctype=doctype_string)) - 3078 -3079 - def test_xml_base(self): - 3080 etree.tostring(tree, doctype=doctype_string)) + 3120 +3121 - def test_xml_base(self): + 3122 etree = self.etree = self.etree -3081 root = etree +3123 root = etree.etree.XML(_bytes("<root/>"), base_url="http://no/such/url") -3082 self.assertEqual(root.base, "http://no/such/url") -3083 self.assertEqual( -3084 root.XML(_bytes("<root/>"), base_url="http://no/such/url") +3124 self.assertEqual(root.base, "http://no/such/url") +3125 self.assertEqual( +3126 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) -3085 root.base = "https://secret/url" -3086 self.assertEqual(root.base, "https://secret/url") -3087 self.assertEqual( -3088 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) +3127 root.base = "https://secret/url" +3128 self.assertEqual(root.base, "https://secret/url") +3129 self.assertEqual( +3130 root.get('{http://www.w3.org/XML/1998/namespace}base'), -3089 "https://secret/url") - 3090 -3091 - def test_xml_base_attribute(self): - 3092 get('{http://www.w3.org/XML/1998/namespace}base'), +3131 "https://secret/url") + 3132 +3133 - def test_xml_base_attribute(self): + 3134 etree = self.etree = self.etree -3093 root = etree +3135 root = etree.etree.XML(_bytes("<root/>"), base_url="http://no/such/url") -3094 self.assertEqual(root.base, "http://no/such/url") -3095 self.assertEqual( -3096 root.XML(_bytes("<root/>"), base_url="http://no/such/url") +3136 self.assertEqual(root.base, "http://no/such/url") +3137 self.assertEqual( +3138 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) -3097 root.set('{http://www.w3.org/XML/1998/namespace}base', -3098 "https://secret/url") -3099 self.assertEqual(root.base, "https://secret/url") -3100 self.assertEqual( -3101 root.get('{http://www.w3.org/XML/1998/namespace}base'), None) +3139 root.set('{http://www.w3.org/XML/1998/namespace}base', +3140 "https://secret/url") +3141 self.assertEqual(root.base, "https://secret/url") +3142 self.assertEqual( +3143 root.get('{http://www.w3.org/XML/1998/namespace}base'), -3102 "https://secret/url") - 3103 -3104 - def test_html_base(self): - 3105 get('{http://www.w3.org/XML/1998/namespace}base'), +3144 "https://secret/url") + 3145 +3146 - def test_html_base(self): + 3147 etree = self.etree = self.etree -3106 root = etree +3148 root = etree.etree.HTML(_bytes("<html><body></body></html>"), -3107 base_url="http://no/such/url") -3108 self.assertEqual(root.base, "http://no/such/url") - 3109 -3110 - def test_html_base_tag(self): - 3111 HTML(_bytes("<html><body></body></html>"), +3149 base_url="http://no/such/url") +3150 self.assertEqual(root.base, "http://no/such/url") + 3151 +3152 - def test_html_base_tag(self): + 3153 etree = self.etree = self.etree -3112 root = etree +3154 root = etree.etree.HTML(_bytes('<html><head><base href="http://no/such/url"></head></html>')) -3113 self.assertEqual(root.base, "http://no/such/url") - 3114 -3115 - def test_parse_fileobject_unicode(self): - 3116 # parse from a file object that returns unicode strings -3117 f = LargeFileLikeUnicode() -3118 tree = self.HTML(_bytes('<html><head><base href="http://no/such/url"></head></html>')) +3155 self.assertEqual(root.base, "http://no/such/url") + 3156 +3157 - def test_parse_fileobject_unicode(self): + 3158 # parse from a file object that returns unicode strings +3159 f = LargeFileLikeUnicode() +3160 tree = self.etree.etree.parse(f) -3119 root = tree.getroot() -3120 self.assertTrue(root.parse(f) +3161 root = tree.getroot() +3162 self.assertTrue(root.tag.endswith('root')) - 3121 -3122 - def test_dtd_io(self): - 3123 # check that DTDs that go in also go back out -3124 xml = _bytes('''\ -3125 <!DOCTYPE test SYSTEM "test.dtd" [ -3126 <!ENTITY entity "tasty"> -3127 <!ELEMENT test (a)> -3128 <!ELEMENT a (#PCDATA)> -3129 ]> -3130 <test><a>test-test</a></test>\ -3131 ''') -3132 tree = self.tag.endswith('root')) + 3163 +3164 - def test_dtd_io(self): + 3165 # check that DTDs that go in also go back out +3166 xml = _bytes('''\ +3167 <!DOCTYPE test SYSTEM "test.dtd" [ +3168 <!ENTITY entity "tasty"> +3169 <!ELEMENT test (a)> +3170 <!ELEMENT a (#PCDATA)> +3171 ]> +3172 <test><a>test-test</a></test>\ +3173 ''') +3174 tree = self.etree.etree.parse(BytesIO(xml)) -3133 self.assertEqual(self.parse(BytesIO(xml)) +3175 self.assertEqual(self.etree.tostring(tree).replace(_bytes(" "), _bytes("")), -3134 xml.replace(_bytes(" "), _bytes(""))) - 3135 -3136 - def test_byte_zero(self): - 3137 etree.tostring(tree).replace(_bytes(" "), _bytes("")), +3176 xml.replace(_bytes(" "), _bytes(""))) + 3177 +3178 - def test_byte_zero(self): + 3179 Element = self.Element = self.etree.etree.Element -3138 -3139 a = Element +3180 +3181 a = Element('a') -3140 self.assertRaises(ValueError, setattr, a, "text", 'ha\0ho') -3141 self.assertRaises(ValueError, setattr, a, "tail", 'ha\0ho') -3142 -3143 self.assertRaises(ValueError, Element('a') +3182 self.assertRaises(ValueError, setattr, a, "text", 'ha\0ho') +3183 self.assertRaises(ValueError, setattr, a, "tail", 'ha\0ho') +3184 +3185 self.assertRaises(ValueError, Element, 'ha\0ho') - 3144 -3145 - def test_unicode_byte_zero(self): - 3146 Element, 'ha\0ho') + 3186 +3187 - def test_unicode_byte_zero(self): + 3188 Element = self.Element = self.etree.etree.Element -3147 -3148 a = Element +3189 +3190 a = Element('a') -3149 self.assertRaises(ValueError, setattr, a, "text", -3150 _str('ha\0ho')) -3151 self.assertRaises(ValueError, setattr, a, "tail", -3152 _str('ha\0ho')) -3153 -3154 self.assertRaises(ValueError, Element('a') +3191 self.assertRaises(ValueError, setattr, a, "text", +3192 _str('ha\0ho')) +3193 self.assertRaises(ValueError, setattr, a, "tail", +3194 _str('ha\0ho')) +3195 +3196 self.assertRaises(ValueError, Element, -3155 _str('ha\0ho')) - 3156 -3157 - def test_byte_invalid(self): - 3158 Element, +3197 _str('ha\0ho')) + 3198 +3199 - def test_byte_invalid(self): + 3200 Element = self.Element = self.etree.etree.Element -3159 -3160 a = Element +3201 +3202 a = Element('a') -3161 self.assertRaises(ValueError, setattr, a, "text", 'ha\x07ho') -3162 self.assertRaises(ValueError, setattr, a, "text", 'ha\x02ho') -3163 -3164 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x07ho') -3165 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x02ho') -3166 -3167 self.assertRaises(ValueError, Element('a') +3203 self.assertRaises(ValueError, setattr, a, "text", 'ha\x07ho') +3204 self.assertRaises(ValueError, setattr, a, "text", 'ha\x02ho') +3205 +3206 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x07ho') +3207 self.assertRaises(ValueError, setattr, a, "tail", 'ha\x02ho') +3208 +3209 self.assertRaises(ValueError, Element, 'ha\x07ho') -3168 self.assertRaises(ValueError, Element, 'ha\x07ho') +3210 self.assertRaises(ValueError, Element, 'ha\x02ho') - 3169 -3170 - def test_unicode_byte_invalid(self): - 3171 Element, 'ha\x02ho') + 3211 +3212 - def test_unicode_byte_invalid(self): + 3213 Element = self.Element = self.etree.etree.Element -3172 -3173 a = Element +3214 +3215 a = Element('a') -3174 self.assertRaises(ValueError, setattr, a, "text", -3175 _str('ha\x07ho')) -3176 self.assertRaises(ValueError, setattr, a, "text", -3177 _str('ha\x02ho')) -3178 -3179 self.assertRaises(ValueError, setattr, a, "tail", -3180 _str('ha\x07ho')) -3181 self.assertRaises(ValueError, setattr, a, "tail", -3182 _str('ha\x02ho')) -3183 -3184 self.assertRaises(ValueError, Element('a') +3216 self.assertRaises(ValueError, setattr, a, "text", +3217 _str('ha\x07ho')) +3218 self.assertRaises(ValueError, setattr, a, "text", +3219 _str('ha\x02ho')) +3220 +3221 self.assertRaises(ValueError, setattr, a, "tail", +3222 _str('ha\x07ho')) +3223 self.assertRaises(ValueError, setattr, a, "tail", +3224 _str('ha\x02ho')) +3225 +3226 self.assertRaises(ValueError, Element, -3185 _str('ha\x07ho')) -3186 self.assertRaises(ValueError, Element, +3227 _str('ha\x07ho')) +3228 self.assertRaises(ValueError, Element, -3187 _str('ha\x02ho')) - 3188 -3189 - def test_unicode_byte_invalid_sequence(self): - 3190 Element, +3229 _str('ha\x02ho')) + 3230 +3231 - def test_unicode_byte_invalid_sequence(self): + 3232 Element = self.Element = self.etree.etree.Element -3191 -3192 a = Element +3233 +3234 a = Element('a') -3193 self.assertRaises(ValueError, setattr, a, "text", -3194 _str('ha\u1234\x07ho')) -3195 self.assertRaises(ValueError, setattr, a, "text", -3196 _str('ha\u1234\x02ho')) -3197 -3198 self.assertRaises(ValueError, setattr, a, "tail", -3199 _str('ha\u1234\x07ho')) -3200 self.assertRaises(ValueError, setattr, a, "tail", -3201 _str('ha\u1234\x02ho')) -3202 -3203 self.assertRaises(ValueError, Element('a') +3235 self.assertRaises(ValueError, setattr, a, "text", +3236 _str('ha\u1234\x07ho')) +3237 self.assertRaises(ValueError, setattr, a, "text", +3238 _str('ha\u1234\x02ho')) +3239 +3240 self.assertRaises(ValueError, setattr, a, "tail", +3241 _str('ha\u1234\x07ho')) +3242 self.assertRaises(ValueError, setattr, a, "tail", +3243 _str('ha\u1234\x02ho')) +3244 +3245 self.assertRaises(ValueError, Element, -3204 _str('ha\u1234\x07ho')) -3205 self.assertRaises(ValueError, Element, +3246 _str('ha\u1234\x07ho')) +3247 self.assertRaises(ValueError, Element, -3206 _str('ha\u1234\x02ho')) - 3207 -3208 - def test_encoding_tostring_utf16(self): - 3209 # ElementTree fails to serialize this -3210 tostring = self.Element, +3248 _str('ha\u1234\x02ho')) + 3249 +3250 - def test_encoding_tostring_utf16(self): + 3251 # ElementTree fails to serialize this +3252 tostring = self.etree.tostring -3211 etree.tostring +3253 Element = self.Element = self.etree.etree.Element -3212 SubElement = self.Element +3254 SubElement = self.etree.SubElement -3213 -3214 a = etree.SubElement +3255 +3256 a = Element('a') -3215 b = SubElement(a, 'b') -3216 c = SubElement(a, 'c') -3217 -3218 result = tostring(a, encoding='UTF-16') -3219 self.assertEqual(_bytes('<a><c></c></a>'), -3220 canonicalize(result)) - 3221 -3222 - def test_tostring_none(self): - 3223 # ElementTree raises an AssertionError here -3224 tostring = self.Element('a') +3257 b = SubElement(a, 'b') +3258 c = SubElement(a, 'c') +3259 +3260 result = tostring(a, encoding='UTF-16') +3261 self.assertEqual(_bytes('<a><c></c></a>'), +3262 canonicalize(result)) + 3263 +3264 - def test_tostring_none(self): + 3265 # ElementTree raises an AssertionError here +3266 tostring = self.etree.tostring -3225 self.assertRaises(TypeError, self.etree.tostring +3267 self.assertRaises(TypeError, self.etree.tostring, None) - 3226 -3227 - def test_tostring_pretty(self): - 3228 tostring = self.etree.tostring, None) + 3268 +3269 - def test_tostring_pretty(self): + 3270 tostring = self.etree.tostring -3229 etree.tostring +3271 Element = self.Element = self.etree.etree.Element -3230 SubElement = self.Element +3272 SubElement = self.etree.SubElement -3231 -3232 a = etree.SubElement +3273 +3274 a = Element('a') -3233 b = SubElement(a, 'b') -3234 c = SubElement(a, 'c') -3235 -3236 result = tostring(a) -3237 self.assertEqual(result, _bytes("<a><c/></a>")) -3238 -3239 result = tostring(a, pretty_print=False) -3240 self.assertEqual(result, _bytes("<a><c/></a>")) -3241 -3242 result = tostring(a, pretty_print=True) -3243 self.assertEqual(result, _bytes("<a>\n \n <c/>\n</a>\n")) - 3244 -3245 - def test_tostring_with_tail(self): - 3246 tostring = self.Element('a') +3275 b = SubElement(a, 'b') +3276 c = SubElement(a, 'c') +3277 +3278 result = tostring(a) +3279 self.assertEqual(result, _bytes("<a><c/></a>")) +3280 +3281 result = tostring(a, pretty_print=False) +3282 self.assertEqual(result, _bytes("<a><c/></a>")) +3283 +3284 result = tostring(a, pretty_print=True) +3285 self.assertEqual(result, _bytes("<a>\n \n <c/>\n</a>\n")) + 3286 +3287 - def test_tostring_with_tail(self): + 3288 tostring = self.etree.tostring -3247 etree.tostring +3289 Element = self.Element = self.etree.etree.Element -3248 SubElement = self.Element +3290 SubElement = self.etree.SubElement -3249 -3250 a = etree.SubElement +3291 +3292 a = Element('a') -3251 a.tail = "aTAIL" -3252 b = SubElement(a, 'b') -3253 b.tail = "bTAIL" -3254 c = SubElement(a, 'c') -3255 -3256 result = tostring(a) -3257 self.assertEqual(result, _bytes("<a>bTAIL<c/></a>aTAIL")) -3258 -3259 result = tostring(a, with_tail=False) -3260 self.assertEqual(result, _bytes("<a>bTAIL<c/></a>")) -3261 -3262 result = tostring(a, with_tail=True) -3263 self.assertEqual(result, _bytes("<a>bTAIL<c/></a>aTAIL")) - 3264 -3265 - def test_tostring_method_html_with_tail(self): - 3266 tostring = self.Element('a') +3293 a.tail = "aTAIL" +3294 b = SubElement(a, 'b') +3295 b.tail = "bTAIL" +3296 c = SubElement(a, 'c') +3297 +3298 result = tostring(a) +3299 self.assertEqual(result, _bytes("<a>bTAIL<c/></a>aTAIL")) +3300 +3301 result = tostring(a, with_tail=False) +3302 self.assertEqual(result, _bytes("<a>bTAIL<c/></a>")) +3303 +3304 result = tostring(a, with_tail=True) +3305 self.assertEqual(result, _bytes("<a>bTAIL<c/></a>aTAIL")) + 3306 +3307 - def test_tostring_method_html_with_tail(self): + 3308 tostring = self.etree.tostring -3267 etree.tostring +3309 html = self.html = self.etree.etree.fromstring( -3268 '<html><body>' -3269 '<div>Some text\r\n</div>\r\n' -3270 '</body></html>', -3271 parser=self.fromstring( +3310 '<html><body>' +3311 '<div>Some text\r\n</div>\r\n' +3312 '</body></html>', +3313 parser=self.etree.etree.HTMLParser()) -3272 self.assertEqual(HTMLParser()) +3314 self.assertEqual(html.html.tag, 'html') -3273 div = tag, 'html') +3315 div = html.html.find('.//div') -3274 self.assertEqual(div.tail, '\r\n') -3275 result = tostring(div, method='html') -3276 self.assertEqual( -3277 result, -3278 _bytes("<div>Some text\r\n</div>\r\n")) -3279 result = tostring(div, method='html', with_tail=True) -3280 self.assertEqual( -3281 result, -3282 _bytes("<div>Some text\r\n</div>\r\n")) -3283 result = tostring(div, method='html', with_tail=False) -3284 self.assertEqual( -3285 result, -3286 _bytes("<div>Some text\r\n</div>")) - 3287 -3288 - def test_standalone(self): - 3289 tostring = self.find('.//div') +3316 self.assertEqual(div.tail, '\r\n') +3317 result = tostring(div, method='html') +3318 self.assertEqual( +3319 result, +3320 _bytes("<div>Some text\r\n</div>\r\n")) +3321 result = tostring(div, method='html', with_tail=True) +3322 self.assertEqual( +3323 result, +3324 _bytes("<div>Some text\r\n</div>\r\n")) +3325 result = tostring(div, method='html', with_tail=False) +3326 self.assertEqual( +3327 result, +3328 _bytes("<div>Some text\r\n</div>")) + 3329 +3330 - def test_standalone(self): + 3331 tostring = self.etree.tostring -3290 etree.tostring +3332 XML = self.XML = self.etree.etree.XML -3291 XML +3333 ElementTree = self.ElementTree = self.etree.etree.ElementTree -3292 ElementTree +3334 Element = self.Element = self.etree.etree.Element -3293 -3294 tree = Element +3335 +3336 tree = Element("root").getroottree() -3295 self.assertEqual(None, tree.docinfo.standalone) -3296 -3297 tree = Element("root").getroottree() +3337 self.assertEqual(None, tree.docinfo.standalone) +3338 +3339 tree = XML(_bytes("<root/>")).getroottree() -3298 self.assertEqual(None, tree.docinfo.standalone) -3299 -3300 tree = XML(_bytes("<root/>")).getroottree() +3340 self.assertEqual(None, tree.docinfo.standalone) +3341 +3342 tree = XML(_bytes( -3301 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>" -3302 )).getroottree() -3303 self.assertEqual(True, tree.docinfo.standalone) -3304 -3305 tree = XML(_bytes( +3343 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>" +3344 )).getroottree() +3345 self.assertEqual(True, tree.docinfo.standalone) +3346 +3347 tree = XML(_bytes( -3306 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>" -3307 )).getroottree() -3308 self.assertEqual(False, tree.docinfo.standalone) - 3309 -3310 - def test_tostring_standalone(self): - 3311 tostring = self.XML(_bytes( +3348 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>" +3349 )).getroottree() +3350 self.assertEqual(False, tree.docinfo.standalone) + 3351 +3352 - def test_tostring_standalone(self): + 3353 tostring = self.etree.tostring -3312 etree.tostring +3354 XML = self.XML = self.etree.etree.XML -3313 XML +3355 ElementTree = self.ElementTree = self.etree.etree.ElementTree -3314 -3315 root = ElementTree +3356 +3357 root = XML(_bytes("<root/>")) -3316 -3317 tree = XML(_bytes("<root/>")) +3358 +3359 tree = ElementTree(root) -3318 self.assertEqual(None, tree.docinfo.standalone) -3319 -3320 result = tostring(root, xml_declaration=True, encoding="ASCII") -3321 self.assertEqual(result, _bytes( -3322 "<?xml version='1.0' encoding='ASCII'?>\n<root/>")) -3323 -3324 result = tostring(root, xml_declaration=True, encoding="ASCII", -3325 standalone=True) -3326 self.assertEqual(result, _bytes( -3327 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>")) -3328 -3329 tree = ElementTree(root) +3360 self.assertEqual(None, tree.docinfo.standalone) +3361 +3362 result = tostring(root, xml_declaration=True, encoding="ASCII") +3363 self.assertEqual(result, _bytes( +3364 "<?xml version='1.0' encoding='ASCII'?>\n<root/>")) +3365 +3366 result = tostring(root, xml_declaration=True, encoding="ASCII", +3367 standalone=True) +3368 self.assertEqual(result, _bytes( +3369 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>")) +3370 +3371 tree = ElementTree(XML(result)) -3330 self.assertEqual(True, tree.docinfo.standalone) -3331 -3332 result = tostring(root, xml_declaration=True, encoding="ASCII", -3333 standalone=False) -3334 self.assertEqual(result, _bytes( -3335 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>")) -3336 -3337 tree = ElementTree(XML(result)) +3372 self.assertEqual(True, tree.docinfo.standalone) +3373 +3374 result = tostring(root, xml_declaration=True, encoding="ASCII", +3375 standalone=False) +3376 self.assertEqual(result, _bytes( +3377 "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>")) +3378 +3379 tree = ElementTree(ElementTree(XML(result)) -3338 self.assertEqual(False, tree.docinfo.standalone) - 3339 -3340 - def test_tostring_standalone_in_out(self): - 3341 tostring = self.XML(result)) +3380 self.assertEqual(False, tree.docinfo.standalone) + 3381 +3382 - def test_tostring_standalone_in_out(self): + 3383 tostring = self.etree.tostring -3342 etree.tostring +3384 XML = self.XML = self.etree.etree.XML -3343 XML +3385 ElementTree = self.ElementTree = self.etree.etree.ElementTree -3344 -3345 root = ElementTree +3386 +3387 root = XML(_bytes( -3346 "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n<root/>")) -3347 -3348 tree = XML(_bytes( +3388 "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n<root/>")) +3389 +3390 tree = ElementTree(root) -3349 self.assertEqual(True, tree.docinfo.standalone) -3350 -3351 result = tostring(root, xml_declaration=True, encoding="ASCII") -3352 self.assertEqual(result, _bytes( -3353 "<?xml version='1.0' encoding='ASCII'?>\n<root/>")) -3354 -3355 result = tostring(root, xml_declaration=True, encoding="ASCII", -3356 standalone=True) -3357 self.assertEqual(result, _bytes( -3358 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>")) - 3359 -3360 - def test_tostring_method_text_encoding(self): - 3361 tostring = self.ElementTree(root) +3391 self.assertEqual(True, tree.docinfo.standalone) +3392 +3393 result = tostring(root, xml_declaration=True, encoding="ASCII") +3394 self.assertEqual(result, _bytes( +3395 "<?xml version='1.0' encoding='ASCII'?>\n<root/>")) +3396 +3397 result = tostring(root, xml_declaration=True, encoding="ASCII", +3398 standalone=True) +3399 self.assertEqual(result, _bytes( +3400 "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>")) + 3401 +3402 - def test_tostring_method_text_encoding(self): + 3403 tostring = self.etree.tostring -3362 etree.tostring +3404 Element = self.Element = self.etree.etree.Element -3363 SubElement = self.Element +3405 SubElement = self.etree.SubElement -3364 -3365 a = etree.SubElement +3406 +3407 a = Element('a') -3366 a.Element('a') +3408 a.text = "A" -3367 a.tail = "tail" -3368 b = SubElement(a, 'b') -3369 b.text = "A" +3409 a.tail = "tail" +3410 b = SubElement(a, 'b') +3411 b.text = "B" -3370 b.tail = _str("Søk på nettet") -3371 c = SubElement(a, 'c') -3372 c.text = "B" +3412 b.tail = _str("Søk på nettet") +3413 c = SubElement(a, 'c') +3414 c.text = "C" -3373 -3374 result = tostring(a, method="text", encoding="UTF-16") -3375 -3376 self.assertEqual(_str('ABSøk på nettetCtail').encode("UTF-16"), -3377 result) - 3378 -3379 - def test_tostring_method_text_unicode(self): - 3380 tostring = self.text = "C" +3415 +3416 result = tostring(a, method="text", encoding="UTF-16") +3417 +3418 self.assertEqual(_str('ABSøk på nettetCtail').encode("UTF-16"), +3419 result) + 3420 +3421 - def test_tostring_method_text_unicode(self): + 3422 tostring = self.etree.tostring -3381 etree.tostring +3423 Element = self.Element = self.etree.etree.Element -3382 SubElement = self.Element +3424 SubElement = self.etree.SubElement -3383 -3384 a = etree.SubElement +3425 +3426 a = Element('a') -3385 a.Element('a') +3427 a.text = _str('Søk på nettetA') -3386 a.tail = "tail" -3387 b = SubElement(a, 'b') -3388 b.text = _str('Søk på nettetA') +3428 a.tail = "tail" +3429 b = SubElement(a, 'b') +3430 b.text = "B" -3389 b.tail = _str('Søk på nettetB') -3390 c = SubElement(a, 'c') -3391 c.text = "B" +3431 b.tail = _str('Søk på nettetB') +3432 c = SubElement(a, 'c') +3433 c.text = "C" -3392 -3393 self.assertRaises(UnicodeEncodeError, -3394 tostring, a, method="text") -3395 -3396 self.assertEqual( -3397 _str('Søk på nettetABSøk på nettetBCtail').encode('utf-8'), -3398 tostring(a, encoding="UTF-8", method="text")) - 3399 -3400 - def test_tounicode(self): - 3401 tounicode = self.text = "C" +3434 +3435 self.assertRaises(UnicodeEncodeError, +3436 tostring, a, method="text") +3437 +3438 self.assertEqual( +3439 _str('Søk på nettetABSøk på nettetBCtail').encode('utf-8'), +3440 tostring(a, encoding="UTF-8", method="text")) + 3441 +3442 - def test_tounicode(self): + 3443 tounicode = self.etree.tounicode -3402 etree.tounicode +3444 Element = self.Element = self.etree.etree.Element -3403 SubElement = self.Element +3445 SubElement = self.etree.SubElement -3404 -3405 a = etree.SubElement +3446 +3447 a = Element('a') -3406 b = SubElement(a, 'b') -3407 c = SubElement(a, 'c') -3408 -3409 self.assertTrue(isinstance(tounicode(a), _unicode)) -3410 self.assertEqual(_bytes('<a><c></c></a>'), -3411 canonicalize(tounicode(a))) - 3412 -3413 - def test_tounicode_element(self): - 3414 tounicode = self.Element('a') +3448 b = SubElement(a, 'b') +3449 c = SubElement(a, 'c') +3450 +3451 self.assertTrue(isinstance(tounicode(a), _unicode)) +3452 self.assertEqual(_bytes('<a><c></c></a>'), +3453 canonicalize(tounicode(a))) + 3454 +3455 - def test_tounicode_element(self): + 3456 tounicode = self.etree.tounicode -3415 etree.tounicode +3457 Element = self.Element = self.etree.etree.Element -3416 SubElement = self.Element +3458 SubElement = self.etree.SubElement -3417 -3418 a = etree.SubElement +3459 +3460 a = Element('a') -3419 b = SubElement(a, 'b') -3420 c = SubElement(a, 'c') -3421 d = SubElement(c, 'd') -3422 self.assertTrue(isinstance(tounicode(b), _unicode)) -3423 self.assertTrue(isinstance(tounicode(c), _unicode)) -3424 self.assertEqual(_bytes(''), -3425 canonicalize(tounicode(b))) -3426 self.assertEqual(_bytes('<c><d></d></c>'), -3427 canonicalize(tounicode(c))) - 3428 -3429 - def test_tounicode_none(self): - 3430 tounicode = self.Element('a') +3461 b = SubElement(a, 'b') +3462 c = SubElement(a, 'c') +3463 d = SubElement(c, 'd') +3464 self.assertTrue(isinstance(tounicode(b), _unicode)) +3465 self.assertTrue(isinstance(tounicode(c), _unicode)) +3466 self.assertEqual(_bytes(''), +3467 canonicalize(tounicode(b))) +3468 self.assertEqual(_bytes('<c><d></d></c>'), +3469 canonicalize(tounicode(c))) + 3470 +3471 - def test_tounicode_none(self): + 3472 tounicode = self.etree.tounicode -3431 self.assertRaises(TypeError, self.etree.tounicode +3473 self.assertRaises(TypeError, self.etree.tounicode, None) - 3432 -3433 - def test_tounicode_element_tail(self): - 3434 tounicode = self.etree.tounicode, None) + 3474 +3475 - def test_tounicode_element_tail(self): + 3476 tounicode = self.etree.tounicode -3435 etree.tounicode +3477 Element = self.Element = self.etree.etree.Element -3436 SubElement = self.Element +3478 SubElement = self.etree.SubElement -3437 -3438 a = etree.SubElement +3479 +3480 a = Element('a') -3439 b = SubElement(a, 'b') -3440 c = SubElement(a, 'c') -3441 d = SubElement(c, 'd') -3442 b.tail = 'Foo' -3443 -3444 self.assertTrue(isinstance(tounicode(b), _unicode)) -3445 self.assertTrue(tounicode(b) == 'Foo' or -3446 tounicode(b) == 'Foo') - 3447 -3448 - def test_tounicode_pretty(self): - 3449 tounicode = self.Element('a') +3481 b = SubElement(a, 'b') +3482 c = SubElement(a, 'c') +3483 d = SubElement(c, 'd') +3484 b.tail = 'Foo' +3485 +3486 self.assertTrue(isinstance(tounicode(b), _unicode)) +3487 self.assertTrue(tounicode(b) == 'Foo' or +3488 tounicode(b) == 'Foo') + 3489 +3490 - def test_tounicode_pretty(self): + 3491 tounicode = self.etree.tounicode -3450 etree.tounicode +3492 Element = self.Element = self.etree.etree.Element -3451 SubElement = self.Element +3493 SubElement = self.etree.SubElement -3452 -3453 a = etree.SubElement +3494 +3495 a = Element('a') -3454 b = SubElement(a, 'b') -3455 c = SubElement(a, 'c') -3456 -3457 result = tounicode(a) -3458 self.assertEqual(result, "<a><c/></a>") -3459 -3460 result = tounicode(a, pretty_print=False) -3461 self.assertEqual(result, "<a><c/></a>") -3462 -3463 result = tounicode(a, pretty_print=True) -3464 self.assertEqual(result, "<a>\n \n <c/>\n</a>\n") - 3465 -3466 - def test_tostring_unicode(self): - 3467 tostring = self.Element('a') +3496 b = SubElement(a, 'b') +3497 c = SubElement(a, 'c') +3498 +3499 result = tounicode(a) +3500 self.assertEqual(result, "<a><c/></a>") +3501 +3502 result = tounicode(a, pretty_print=False) +3503 self.assertEqual(result, "<a><c/></a>") +3504 +3505 result = tounicode(a, pretty_print=True) +3506 self.assertEqual(result, "<a>\n \n <c/>\n</a>\n") + 3507 +3508 - def test_tostring_unicode(self): + 3509 tostring = self.etree.tostring -3468 etree.tostring +3510 Element = self.Element = self.etree.etree.Element -3469 SubElement = self.Element +3511 SubElement = self.etree.SubElement -3470 -3471 a = etree.SubElement +3512 +3513 a = Element('a') -3472 b = SubElement(a, 'b') -3473 c = SubElement(a, 'c') -3474 -3475 self.assertTrue(isinstance(tostring(a, encoding=_unicode), _unicode)) -3476 self.assertEqual(_bytes('<a><c></c></a>'), -3477 canonicalize(tostring(a, encoding=_unicode))) - 3478 -3479 - def test_tostring_unicode_element(self): - 3480 tostring = self.Element('a') +3514 b = SubElement(a, 'b') +3515 c = SubElement(a, 'c') +3516 +3517 self.assertTrue(isinstance(tostring(a, encoding=_unicode), _unicode)) +3518 self.assertEqual(_bytes('<a><c></c></a>'), +3519 canonicalize(tostring(a, encoding=_unicode))) + 3520 +3521 - def test_tostring_unicode_element(self): + 3522 tostring = self.etree.tostring -3481 etree.tostring +3523 Element = self.Element = self.etree.etree.Element -3482 SubElement = self.Element +3524 SubElement = self.etree.SubElement -3483 -3484 a = etree.SubElement +3525 +3526 a = Element('a') -3485 b = SubElement(a, 'b') -3486 c = SubElement(a, 'c') -3487 d = SubElement(c, 'd') -3488 self.assertTrue(isinstance(tostring(b, encoding=_unicode), _unicode)) -3489 self.assertTrue(isinstance(tostring(c, encoding=_unicode), _unicode)) -3490 self.assertEqual(_bytes(''), -3491 canonicalize(tostring(b, encoding=_unicode))) -3492 self.assertEqual(_bytes('<c><d></d></c>'), -3493 canonicalize(tostring(c, encoding=_unicode))) - 3494 -3495 - def test_tostring_unicode_none(self): - 3496 tostring = self.Element('a') +3527 b = SubElement(a, 'b') +3528 c = SubElement(a, 'c') +3529 d = SubElement(c, 'd') +3530 self.assertTrue(isinstance(tostring(b, encoding=_unicode), _unicode)) +3531 self.assertTrue(isinstance(tostring(c, encoding=_unicode), _unicode)) +3532 self.assertEqual(_bytes(''), +3533 canonicalize(tostring(b, encoding=_unicode))) +3534 self.assertEqual(_bytes('<c><d></d></c>'), +3535 canonicalize(tostring(c, encoding=_unicode))) + 3536 +3537 - def test_tostring_unicode_none(self): + 3538 tostring = self.etree.tostring -3497 self.assertRaises(TypeError, self.etree.tostring +3539 self.assertRaises(TypeError, self.etree.tostring, -3498 None, encoding=_unicode) - 3499 -3500 - def test_tostring_unicode_element_tail(self): - 3501 tostring = self.etree.tostring, +3540 None, encoding=_unicode) + 3541 +3542 - def test_tostring_unicode_element_tail(self): + 3543 tostring = self.etree.tostring -3502 etree.tostring +3544 Element = self.Element = self.etree.etree.Element -3503 SubElement = self.Element +3545 SubElement = self.etree.SubElement -3504 -3505 a = etree.SubElement +3546 +3547 a = Element('a') -3506 b = SubElement(a, 'b') -3507 c = SubElement(a, 'c') -3508 d = SubElement(c, 'd') -3509 b.tail = 'Foo' -3510 -3511 self.assertTrue(isinstance(tostring(b, encoding=_unicode), _unicode)) -3512 self.assertTrue(tostring(b, encoding=_unicode) == 'Foo' or -3513 tostring(b, encoding=_unicode) == 'Foo') - 3514 -3515 - def test_tostring_unicode_pretty(self): - 3516 tostring = self.Element('a') +3548 b = SubElement(a, 'b') +3549 c = SubElement(a, 'c') +3550 d = SubElement(c, 'd') +3551 b.tail = 'Foo' +3552 +3553 self.assertTrue(isinstance(tostring(b, encoding=_unicode), _unicode)) +3554 self.assertTrue(tostring(b, encoding=_unicode) == 'Foo' or +3555 tostring(b, encoding=_unicode) == 'Foo') + 3556 +3557 - def test_tostring_unicode_pretty(self): + 3558 tostring = self.etree.tostring -3517 etree.tostring +3559 Element = self.Element = self.etree.etree.Element -3518 SubElement = self.Element +3560 SubElement = self.etree.SubElement -3519 -3520 a = etree.SubElement +3561 +3562 a = Element('a') -3521 b = SubElement(a, 'b') -3522 c = SubElement(a, 'c') -3523 -3524 result = tostring(a, encoding=_unicode) -3525 self.assertEqual(result, "<a><c/></a>") -3526 -3527 result = tostring(a, encoding=_unicode, pretty_print=False) -3528 self.assertEqual(result, "<a><c/></a>") -3529 -3530 result = tostring(a, encoding=_unicode, pretty_print=True) -3531 self.assertEqual(result, "<a>\n \n <c/>\n</a>\n") - 3532 -3533 - def test_pypy_proxy_collect(self): - 3534 root = Element('a') +3563 b = SubElement(a, 'b') +3564 c = SubElement(a, 'c') +3565 +3566 result = tostring(a, encoding=_unicode) +3567 self.assertEqual(result, "<a><c/></a>") +3568 +3569 result = tostring(a, encoding=_unicode, pretty_print=False) +3570 self.assertEqual(result, "<a><c/></a>") +3571 +3572 result = tostring(a, encoding=_unicode, pretty_print=True) +3573 self.assertEqual(result, "<a>\n \n <c/>\n</a>\n") + 3574 +3575 - def test_pypy_proxy_collect(self): + 3576 root = etree.etree.Element('parent') -3535 Element('parent') +3577 etree.SubElement(root, 'child') -3536 -3537 self.assertEqual(len(root), 1) -3538 self.assertEqual(root[0].etree.SubElement(root, 'child') +3578 +3579 self.assertEqual(len(root), 1) +3580 self.assertEqual(root[0].tag, 'child') -3539 -3540 # in PyPy, GC used to kill the Python proxy instance without cleanup -3541 gc.collect() -3542 self.assertEqual(len(root), 1) -3543 self.assertEqual(root[0].tag, 'child') +3581 +3582 # in PyPy, GC used to kill the Python proxy instance without cleanup +3583 gc.collect() +3584 self.assertEqual(len(root), 1) +3585 self.assertEqual(root[0].tag, 'child') - 3544 -3545 - def test_element_refcycle(self): - 3546 class SubEl(etree.ElementBase): -3547 pass - 3548 -3549 el1 = SubEl() -3550 el2 = SubEl() -3551 self.assertEqual('SubEl', el1.tag, 'child') +

3769 tree = self.parse(_bytes('<a></a>')) -3697 f = BytesIO() -3698 tree.write_c14n(f) -3699 s = f.getvalue() -3700 self.assertEqual(_bytes('\n<a></a>\n'), -3701 s) -3702 f = BytesIO() -3703 tree.write_c14n(f, with_comments=True) -3704 s = f.getvalue() -3705 self.assertEqual(_bytes('\n<a></a>\n'), -3706 s) -3707 f = BytesIO() -3708 tree.write_c14n(f, with_comments=False) -3709 s = f.getvalue() -3710 self.assertEqual(_bytes('<a></a>'), -3711 s) -

3714 tree = self.parse(_bytes('<a></a>')) +3770 f = BytesIO() +3771 tree.write_c14n(f) +3772 s = f.getvalue() +3773 self.assertEqual(_bytes('\n<a></a>\n'), +3774 s) +3775 f = BytesIO() +3776 tree.write_c14n(f, with_comments=True) +3777 s = f.getvalue() +3778 self.assertEqual(_bytes('\n<a></a>\n'), +3779 s) +3780 f = BytesIO() +3781 tree.write_c14n(f, with_comments=False) +3782 s = f.getvalue() +3783 self.assertEqual(_bytes('<a></a>'), +3784 s) +

3787 tree = self.parse(_bytes('<a></a>')) -3715 s = parse(_bytes('<a></a>')) +3788 s = etree.tostring(tree, method='c14n') -3716 self.assertEqual(_bytes('\n<a></a>\n'), -3717 s) -3718 s = etree.tostring(tree, method='c14n') +3789 self.assertEqual(_bytes('\n<a></a>\n'), +3790 s) +3791 s = etree.tostring(tree, method='c14n', with_comments=True) -3719 self.assertEqual(_bytes('\n<a></a>\n'), -3720 s) -3721 s = etree.tostring(tree, method='c14n', with_comments=True) +3792 self.assertEqual(_bytes('\n<a></a>\n'), +3793 s) +3794 s = etree.tostring(tree, method='c14n', with_comments=False) -3722 self.assertEqual(_bytes('<a></a>'), -3723 s) -

3799 tree = self.parse(_bytes('<a></a>')) -3727 s = parse(_bytes('<a></a>')) +3800 s = etree.tostring(tree.getroot(), method='c14n') -3728 self.assertEqual(_bytes('<a></a>'), -3729 s) -3730 s = etree.tostring(tree.getroot(), method='c14n') +3801 self.assertEqual(_bytes('<a></a>'), +3802 s) +3803 s = etree.tostring(tree.getroot(), method='c14n', with_comments=True) -3731 self.assertEqual(_bytes('<a></a>'), -3732 s) -3733 s = etree.tostring(tree.getroot(), method='c14n', with_comments=True) +3804 self.assertEqual(_bytes('<a></a>'), +3805 s) +3806 s = etree.tostring(tree.getroot(), method='c14n', with_comments=False) -3734 self.assertEqual(_bytes('<a></a>'), -3735 s) -

lxml FAQ - Frequently Asked Questions

lxml FAQ - Frequently Asked Questions

APIs specific to lxml.etree

APIs specific to lxml.etree

_abc_negative_cache

html_annotate(doclist, - markup=<function default_markup at 0x381a398>) + markup=<function default_markup at 0x2b7afe0fa050>)