Consolidate patches #1690164, 1683397, and 1690169, all of which refactor XML-related test suites. The patches are applied together because they use a common output/xmltests file.

Thanks to Jerry Seutter for all three patches.

1 files changed, 595 insertions, 687 deletions

diff --git a/Lib/test/test_sax.py b/Lib/test/test_sax.py
index bb5e54920a..5298155f4b 100644
--- a/Lib/test/test_sax.py
+++ b/Lib/test/test_sax.py
@@ -13,26 +13,66 @@ from xml.sax.saxutils import XMLGenerator, escape, unescape, quoteattr, \
 from xml.sax.expatreader import create_parser
 from xml.sax.xmlreader import InputSource, AttributesImpl, AttributesNSImpl
 from cStringIO import StringIO
-from test.test_support import verify, verbose, TestFailed, findfile
+from test.test_support import findfile, run_unittest
+import unittest
 import os
 
-# ===== Utilities
-
-tests = 0
-failures = []
-
-def confirm(outcome, name):
-    global tests
-
-    tests = tests + 1
-    if outcome:
-        if verbose:
-            print "Passed", name
-    else:
-        failures.append(name)
+ns_uri = "http://www.python.org/xml-ns/saxtest/"
 
-def test_make_parser2():
-    try:
+class XmlTestBase(unittest.TestCase):
+    def verify_empty_attrs(self, attrs):
+        self.assertRaises(KeyError, attrs.getValue, "attr")
+        self.assertRaises(KeyError, attrs.getValueByQName, "attr")
+        self.assertRaises(KeyError, attrs.getNameByQName, "attr")
+        self.assertRaises(KeyError, attrs.getQNameByName, "attr")
+        self.assertRaises(KeyError, attrs.__getitem__, "attr")
+        self.assertEquals(attrs.getLength(), 0)
+        self.assertEquals(attrs.getNames(), [])
+        self.assertEquals(attrs.getQNames(), [])
+        self.assertEquals(len(attrs), 0)
+        self.assertFalse(attrs.has_key("attr"))
+        self.assertEquals(attrs.keys(), [])
+        self.assertEquals(attrs.get("attrs"), None)
+        self.assertEquals(attrs.get("attrs", 25), 25)
+        self.assertEquals(attrs.items(), [])
+        self.assertEquals(attrs.values(), [])
+    
+    def verify_empty_nsattrs(self, attrs):
+        self.assertRaises(KeyError, attrs.getValue, (ns_uri, "attr"))
+        self.assertRaises(KeyError, attrs.getValueByQName, "ns:attr")
+        self.assertRaises(KeyError, attrs.getNameByQName, "ns:attr")
+        self.assertRaises(KeyError, attrs.getQNameByName, (ns_uri, "attr"))
+        self.assertRaises(KeyError, attrs.__getitem__, (ns_uri, "attr"))
+        self.assertEquals(attrs.getLength(), 0)
+        self.assertEquals(attrs.getNames(), [])
+        self.assertEquals(attrs.getQNames(), [])
+        self.assertEquals(len(attrs), 0)
+        self.assertFalse(attrs.has_key((ns_uri, "attr")))
+        self.assertEquals(attrs.keys(), [])
+        self.assertEquals(attrs.get((ns_uri, "attr")), None)
+        self.assertEquals(attrs.get((ns_uri, "attr"), 25), 25)
+        self.assertEquals(attrs.items(), [])
+        self.assertEquals(attrs.values(), [])
+
+    def verify_attrs_wattr(self, attrs):
+        self.assertEquals(attrs.getLength(), 1)
+        self.assertEquals(attrs.getNames(), ["attr"])
+        self.assertEquals(attrs.getQNames(), ["attr"])
+        self.assertEquals(len(attrs), 1)
+        self.assertTrue(attrs.has_key("attr"))
+        self.assertEquals(attrs.keys(), ["attr"])
+        self.assertEquals(attrs.get("attr"), "val")
+        self.assertEquals(attrs.get("attr", 25), "val")
+        self.assertEquals(attrs.items(), [("attr", "val")])
+        self.assertEquals(attrs.values(), ["val"])
+        self.assertEquals(attrs.getValue("attr"), "val")
+        self.assertEquals(attrs.getValueByQName("attr"), "val")
+        self.assertEquals(attrs.getNameByQName("attr"), "attr")
+        self.assertEquals(attrs["attr"], "val")
+        self.assertEquals(attrs.getQNameByName("attr"), "attr")
+    
+class MakeParserTest(unittest.TestCase):
+    def test_make_parser2(self):
         # Creating parsers several times in a row should succeed.
         # Testing this because there have been failures of this kind
         # before.
@@ -48,10 +88,6 @@ def test_make_parser2():
         p = make_parser()
         from xml.sax import make_parser
         p = make_parser()
-    except:
-        return 0
-    else:
-        return p
 
 
 # ===========================================================================
@@ -60,215 +96,214 @@ def test_make_parser2():
 #
 # ===========================================================================
 
-# ===== escape
-
-def test_escape_basic():
-    return escape("Donald Duck & Co") == "Donald Duck & Co"
-
-def test_escape_all():
-    return escape("<Donald Duck & Co>") == "&lt;Donald Duck &amp; Co&gt;"
-
-def test_escape_extra():
-    return escape("Hei på deg", {"å" : "&aring;"}) == "Hei p&aring; deg"
-
-# ===== unescape
-
-def test_unescape_basic():
-    return unescape("Donald Duck &amp; Co") == "Donald Duck & Co"
-
-def test_unescape_all():
-    return unescape("&lt;Donald Duck &amp; Co&gt;") == "<Donald Duck & Co>"
-
-def test_unescape_extra():
-    return unescape("Hei på deg", {"å" : "&aring;"}) == "Hei p&aring; deg"
-
-def test_unescape_amp_extra():
-    return unescape("&amp;foo;", {"&foo;": "splat"}) == "&foo;"
-
-# ===== quoteattr
-
-def test_quoteattr_basic():
-    return quoteattr("Donald Duck & Co") == '"Donald Duck &amp; Co"'
-
-def test_single_quoteattr():
-    return (quoteattr('Includes "double" quotes')
-            == '\'Includes "double" quotes\'')
-
-def test_double_quoteattr():
-    return (quoteattr("Includes 'single' quotes")
-            == "\"Includes 'single' quotes\"")
-
-def test_single_double_quoteattr():
-    return (quoteattr("Includes 'single' and \"double\" quotes")
-            == "\"Includes 'single' and &quot;double&quot; quotes\"")
-
-# ===== make_parser
-
-def test_make_parser():
-    try:
+class SaxutilsTest(unittest.TestCase):
+    # ===== escape
+    def test_escape_basic(self):
+        self.assertEquals(escape("Donald Duck & Co"), "Donald Duck &amp; Co")
+    
+    def test_escape_all(self):
+        self.assertEquals(escape("<Donald Duck & Co>"),
+                          "&lt;Donald Duck &amp; Co&gt;")
+    
+    def test_escape_extra(self):
+        self.assertEquals(escape("Hei på deg", {"å" : "&aring;"}),
+                          "Hei p&aring; deg")
+
+    # ===== unescape
+    def test_unescape_basic(self):
+        self.assertEquals(unescape("Donald Duck &amp; Co"), "Donald Duck & Co")
+    
+    def test_unescape_all(self):
+        self.assertEquals(unescape("&lt;Donald Duck &amp; Co&gt;"), 
+                          "<Donald Duck & Co>")
+    
+    def test_unescape_extra(self):
+        self.assertEquals(unescape("Hei på deg", {"å" : "&aring;"}), 
+                          "Hei p&aring; deg")
+    
+    def test_unescape_amp_extra(self):
+        self.assertEquals(unescape("&amp;foo;", {"&foo;": "splat"}), "&foo;")
+
+    # ===== quoteattr
+    def test_quoteattr_basic(self):
+        self.assertEquals(quoteattr("Donald Duck & Co"), 
+                          '"Donald Duck &amp; Co"')
+    
+    def test_single_quoteattr(self):
+        self.assertEquals(quoteattr('Includes "double" quotes'),
+                          '\'Includes "double" quotes\'')
+    
+    def test_double_quoteattr(self):
+        self.assertEquals(quoteattr("Includes 'single' quotes"),
+                          "\"Includes 'single' quotes\"")
+    
+    def test_single_double_quoteattr(self):
+        self.assertEquals(quoteattr("Includes 'single' and \"double\" quotes"),
+                    "\"Includes 'single' and &quot;double&quot; quotes\"")
+    
+    # ===== make_parser
+    def test_make_parser(self):
         # Creating a parser should succeed - it should fall back
         # to the expatreader
         p = make_parser(['xml.parsers.no_such_parser'])
-    except:
-        return 0
-    else:
-        return p
 
 
 # ===== XMLGenerator
 
 start = '<?xml version="1.0" encoding="iso-8859-1"?>\n'
 
-def test_xmlgen_basic():
-    result = StringIO()
-    gen = XMLGenerator(result)
-    gen.startDocument()
-    gen.startElement("doc", {})
-    gen.endElement("doc")
-    gen.endDocument()
-
-    return result.getvalue() == start + "<doc></doc>"
-
-def test_xmlgen_content():
-    result = StringIO()
-    gen = XMLGenerator(result)
-
-    gen.startDocument()
-    gen.startElement("doc", {})
-    gen.characters("huhei")
-    gen.endElement("doc")
-    gen.endDocument()
-
-    return result.getvalue() == start + "<doc>huhei</doc>"
-
-def test_xmlgen_pi():
-    result = StringIO()
-    gen = XMLGenerator(result)
-
-    gen.startDocument()
-    gen.processingInstruction("test", "data")
-    gen.startElement("doc", {})
-    gen.endElement("doc")
-    gen.endDocument()
-
-    return result.getvalue() == start + "<?test data?><doc></doc>"
-
-def test_xmlgen_content_escape():
-    result = StringIO()
-    gen = XMLGenerator(result)
-
-    gen.startDocument()
-    gen.startElement("doc", {})
-    gen.characters("<huhei&")
-    gen.endElement("doc")
-    gen.endDocument()
-
-    return result.getvalue() == start + "<doc>&lt;huhei&amp;</doc>"
-
-def test_xmlgen_attr_escape():
-    result = StringIO()
-    gen = XMLGenerator(result)
-
-    gen.startDocument()
-    gen.startElement("doc", {"a": '"'})
-    gen.startElement("e", {"a": "'"})
-    gen.endElement("e")
-    gen.startElement("e", {"a": "'\""})
-    gen.endElement("e")
-    gen.startElement("e", {"a": "\n\r\t"})
-    gen.endElement("e")
-    gen.endElement("doc")
-    gen.endDocument()
-
-    return result.getvalue() == start + ("<doc a='\"'><e a=\"'\"></e>"
-                                         "<e a=\"'&quot;\"></e>"
-                                         "<e a=\"&#10;&#13;&#9;\"></e></doc>")
-
-def test_xmlgen_ignorable():
-    result = StringIO()
-    gen = XMLGenerator(result)
-
-    gen.startDocument()
-    gen.startElement("doc", {})
-    gen.ignorableWhitespace(" ")
-    gen.endElement("doc")
-    gen.endDocument()
-
-    return result.getvalue() == start + "<doc> </doc>"
-
-ns_uri = "http://www.python.org/xml-ns/saxtest/"
-
-def test_xmlgen_ns():
-    result = StringIO()
-    gen = XMLGenerator(result)
-
-    gen.startDocument()
-    gen.startPrefixMapping("ns1", ns_uri)
-    gen.startElementNS((ns_uri, "doc"), "ns1:doc", {})
-    # add an unqualified name
-    gen.startElementNS((None, "udoc"), None, {})
-    gen.endElementNS((None, "udoc"), None)
-    gen.endElementNS((ns_uri, "doc"), "ns1:doc")
-    gen.endPrefixMapping("ns1")
-    gen.endDocument()
-
-    return result.getvalue() == start + \
+class XmlgenTest(unittest.TestCase):
+    def test_xmlgen_basic(self):
+        result = StringIO()
+        gen = XMLGenerator(result)
+        gen.startDocument()
+        gen.startElement("doc", {})
+        gen.endElement("doc")
+        gen.endDocument()
+    
+        self.assertEquals(result.getvalue(), start + "<doc></doc>")
+    
+    def test_xmlgen_content(self):
+        result = StringIO()
+        gen = XMLGenerator(result)
+    
+        gen.startDocument()
+        gen.startElement("doc", {})
+        gen.characters("huhei")
+        gen.endElement("doc")
+        gen.endDocument()
+    
+        self.assertEquals(result.getvalue(), start + "<doc>huhei</doc>")
+
+    def test_xmlgen_pi(self):
+        result = StringIO()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.processingInstruction("test", "data")
+        gen.startElement("doc", {})
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEquals(result.getvalue(), start + "<?test data?><doc></doc>")
+
+    def test_xmlgen_content_escape(self):
+        result = StringIO()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startElement("doc", {})
+        gen.characters("<huhei&")
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEquals(result.getvalue(), 
+            start + "<doc>&lt;huhei&amp;</doc>")
+
+    def test_xmlgen_attr_escape(self):
+        result = StringIO()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startElement("doc", {"a": '"'})
+        gen.startElement("e", {"a": "'"})
+        gen.endElement("e")
+        gen.startElement("e", {"a": "'\""})
+        gen.endElement("e")
+        gen.startElement("e", {"a": "\n\r\t"})
+        gen.endElement("e")
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEquals(result.getvalue(), start + 
+            ("<doc a='\"'><e a=\"'\"></e>"
+             "<e a=\"'&quot;\"></e>"
+             "<e a=\"&#10;&#13;&#9;\"></e></doc>"))
+
+    def test_xmlgen_ignorable(self):
+        result = StringIO()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startElement("doc", {})
+        gen.ignorableWhitespace(" ")
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEquals(result.getvalue(), start + "<doc> </doc>")
+
+    def test_xmlgen_ns(self):
+        result = StringIO()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startPrefixMapping("ns1", ns_uri)
+        gen.startElementNS((ns_uri, "doc"), "ns1:doc", {})
+        # add an unqualified name
+        gen.startElementNS((None, "udoc"), None, {})
+        gen.endElementNS((None, "udoc"), None)
+        gen.endElementNS((ns_uri, "doc"), "ns1:doc")
+        gen.endPrefixMapping("ns1")
+        gen.endDocument()
+
+        self.assertEquals(result.getvalue(), start + \
            ('<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' %
-                                         ns_uri)
+                                         ns_uri))
 
-def test_1463026_1():
-    result = StringIO()
-    gen = XMLGenerator(result)
+    def test_1463026_1(self):
+        result = StringIO()
+        gen = XMLGenerator(result)
 
-    gen.startDocument()
-    gen.startElementNS((None, 'a'), 'a', {(None, 'b'):'c'})
-    gen.endElementNS((None, 'a'), 'a')
-    gen.endDocument()
+        gen.startDocument()
+        gen.startElementNS((None, 'a'), 'a', {(None, 'b'):'c'})
+        gen.endElementNS((None, 'a'), 'a')
+        gen.endDocument()
 
-    return result.getvalue() == start+'<a b="c"></a>'
+        self.assertEquals(result.getvalue(), start+'<a b="c"></a>')
 
-def test_1463026_2():
-    result = StringIO()
-    gen = XMLGenerator(result)
+    def test_1463026_2(self):
+        result = StringIO()
+        gen = XMLGenerator(result)
 
-    gen.startDocument()
-    gen.startPrefixMapping(None, 'qux')
-    gen.startElementNS(('qux', 'a'), 'a', {})
-    gen.endElementNS(('qux', 'a'), 'a')
-    gen.endPrefixMapping(None)
-    gen.endDocument()
+        gen.startDocument()
+        gen.startPrefixMapping(None, 'qux')
+        gen.startElementNS(('qux', 'a'), 'a', {})
+        gen.endElementNS(('qux', 'a'), 'a')
+        gen.endPrefixMapping(None)
+        gen.endDocument()
 
-    return result.getvalue() == start+'<a xmlns="qux"></a>'
+        self.assertEquals(result.getvalue(), start+'<a xmlns="qux"></a>')
 
-def test_1463026_3():
-    result = StringIO()
-    gen = XMLGenerator(result)
+    def test_1463026_3(self):
+        result = StringIO()
+        gen = XMLGenerator(result)
 
-    gen.startDocument()
-    gen.startPrefixMapping('my', 'qux')
-    gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'):'c'})
-    gen.endElementNS(('qux', 'a'), 'a')
-    gen.endPrefixMapping('my')
-    gen.endDocument()
+        gen.startDocument()
+        gen.startPrefixMapping('my', 'qux')
+        gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'):'c'})
+        gen.endElementNS(('qux', 'a'), 'a')
+        gen.endPrefixMapping('my')
+        gen.endDocument()
 
-    return result.getvalue() == start+'<my:a xmlns:my="qux" b="c"></my:a>'
+        self.assertEquals(result.getvalue(), 
+            start+'<my:a xmlns:my="qux" b="c"></my:a>')
 
-# ===== Xmlfilterbase
 
-def test_filter_basic():
-    result = StringIO()
-    gen = XMLGenerator(result)
-    filter = XMLFilterBase()
-    filter.setContentHandler(gen)
+class XMLFilterBaseTest(unittest.TestCase):
+    def test_filter_basic(self):
+        result = StringIO()
+        gen = XMLGenerator(result)
+        filter = XMLFilterBase()
+        filter.setContentHandler(gen)
 
-    filter.startDocument()
-    filter.startElement("doc", {})
-    filter.characters("content")
-    filter.ignorableWhitespace(" ")
-    filter.endElement("doc")
-    filter.endDocument()
+        filter.startDocument()
+        filter.startElement("doc", {})
+        filter.characters("content")
+        filter.ignorableWhitespace(" ")
+        filter.endElement("doc")
+        filter.endDocument()
 
-    return result.getvalue() == start + "<doc>content </doc>"
+        self.assertEquals(result.getvalue(), start + "<doc>content </doc>")
 
 # ===========================================================================
 #
@@ -276,294 +311,294 @@ def test_filter_basic():
 #
 # ===========================================================================
 
-# ===== XMLReader support
-
-def test_expat_file():
-    parser = create_parser()
-    result = StringIO()
-    xmlgen = XMLGenerator(result)
-
-    parser.setContentHandler(xmlgen)
-    parser.parse(open(findfile("test"+os.extsep+"xml")))
-
-    return result.getvalue() == xml_test_out
-
-# ===== DTDHandler support
-
-class TestDTDHandler:
-
-    def __init__(self):
-        self._notations = []
-        self._entities  = []
-
-    def notationDecl(self, name, publicId, systemId):
-        self._notations.append((name, publicId, systemId))
-
-    def unparsedEntityDecl(self, name, publicId, systemId, ndata):
-        self._entities.append((name, publicId, systemId, ndata))
-
-def test_expat_dtdhandler():
-    parser = create_parser()
-    handler = TestDTDHandler()
-    parser.setDTDHandler(handler)
-
-    parser.feed('<!DOCTYPE doc [\n')
-    parser.feed('  <!ENTITY img SYSTEM "expat.gif" NDATA GIF>\n')
-    parser.feed('  <!NOTATION GIF PUBLIC "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN">\n')
-    parser.feed(']>\n')
-    parser.feed('<doc></doc>')
-    parser.close()
-
-    return handler._notations == [("GIF", "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN", None)] and \
-           handler._entities == [("img", None, "expat.gif", "GIF")]
-
-# ===== EntityResolver support
-
-class TestEntityResolver:
-
-    def resolveEntity(self, publicId, systemId):
-        inpsrc = InputSource()
-        inpsrc.setByteStream(StringIO("<entity/>"))
-        return inpsrc
-
-def test_expat_entityresolver():
-    parser = create_parser()
-    parser.setEntityResolver(TestEntityResolver())
-    result = StringIO()
-    parser.setContentHandler(XMLGenerator(result))
-
-    parser.feed('<!DOCTYPE doc [\n')
-    parser.feed('  <!ENTITY test SYSTEM "whatever">\n')
-    parser.feed(']>\n')
-    parser.feed('<doc>&test;</doc>')
-    parser.close()
-
-    return result.getvalue() == start + "<doc><entity></entity></doc>"
-
-# ===== Attributes support
-
-class AttrGatherer(ContentHandler):
-
-    def startElement(self, name, attrs):
-        self._attrs = attrs
-
-    def startElementNS(self, name, qname, attrs):
-        self._attrs = attrs
-
-def test_expat_attrs_empty():
-    parser = create_parser()
-    gather = AttrGatherer()
-    parser.setContentHandler(gather)
-
-    parser.feed("<doc/>")
-    parser.close()
-
-    return verify_empty_attrs(gather._attrs)
-
-def test_expat_attrs_wattr():
-    parser = create_parser()
-    gather = AttrGatherer()
-    parser.setContentHandler(gather)
-
-    parser.feed("<doc attr='val'/>")
-    parser.close()
-
-    return verify_attrs_wattr(gather._attrs)
-
-def test_expat_nsattrs_empty():
-    parser = create_parser(1)
-    gather = AttrGatherer()
-    parser.setContentHandler(gather)
-
-    parser.feed("<doc/>")
-    parser.close()
-
-    return verify_empty_nsattrs(gather._attrs)
-
-def test_expat_nsattrs_wattr():
-    parser = create_parser(1)
-    gather = AttrGatherer()
-    parser.setContentHandler(gather)
-
-    parser.feed("<doc xmlns:ns='%s' ns:attr='val'/>" % ns_uri)
-    parser.close()
-
-    attrs = gather._attrs
-
-    return attrs.getLength() == 1 and \
-           attrs.getNames() == [(ns_uri, "attr")] and \
-           (attrs.getQNames() == [] or attrs.getQNames() == ["ns:attr"]) and \
-           len(attrs) == 1 and \
-           attrs.has_key((ns_uri, "attr")) and \
-           attrs.keys() == [(ns_uri, "attr")] and \
-           attrs.get((ns_uri, "attr")) == "val" and \
-           attrs.get((ns_uri, "attr"), 25) == "val" and \
-           attrs.items() == [((ns_uri, "attr"), "val")] and \
-           attrs.values() == ["val"] and \
-           attrs.getValue((ns_uri, "attr")) == "val" and \
-           attrs[(ns_uri, "attr")] == "val"
-
-# ===== InputSource support
-
 xml_test_out = open(findfile("test"+os.extsep+"xml"+os.extsep+"out")).read()
 
-def test_expat_inpsource_filename():
-    parser = create_parser()
-    result = StringIO()
-    xmlgen = XMLGenerator(result)
-
-    parser.setContentHandler(xmlgen)
-    parser.parse(findfile("test"+os.extsep+"xml"))
-
-    return result.getvalue() == xml_test_out
-
-def test_expat_inpsource_sysid():
-    parser = create_parser()
-    result = StringIO()
-    xmlgen = XMLGenerator(result)
-
-    parser.setContentHandler(xmlgen)
-    parser.parse(InputSource(findfile("test"+os.extsep+"xml")))
-
-    return result.getvalue() == xml_test_out
-
-def test_expat_inpsource_stream():
-    parser = create_parser()
-    result = StringIO()
-    xmlgen = XMLGenerator(result)
-
-    parser.setContentHandler(xmlgen)
-    inpsrc = InputSource()
-    inpsrc.setByteStream(open(findfile("test"+os.extsep+"xml")))
-    parser.parse(inpsrc)
-
-    return result.getvalue() == xml_test_out
-
-# ===== IncrementalParser support
+class ExpatReaderTest(XmlTestBase):
+    
+    # ===== XMLReader support
 
-def test_expat_incremental():
-    result = StringIO()
-    xmlgen = XMLGenerator(result)
-    parser = create_parser()
-    parser.setContentHandler(xmlgen)
+    def test_expat_file(self):
+        parser = create_parser()
+        result = StringIO()
+        xmlgen = XMLGenerator(result)
 
-    parser.feed("<doc>")
-    parser.feed("</doc>")
-    parser.close()
+        parser.setContentHandler(xmlgen)
+        parser.parse(open(findfile("test"+os.extsep+"xml")))
 
-    return result.getvalue() == start + "<doc></doc>"
+        self.assertEquals(result.getvalue(), xml_test_out)
 
-def test_expat_incremental_reset():
-    result = StringIO()
-    xmlgen = XMLGenerator(result)
-    parser = create_parser()
-    parser.setContentHandler(xmlgen)
+    # ===== DTDHandler support
 
-    parser.feed("<doc>")
-    parser.feed("text")
+    class TestDTDHandler:
 
-    result = StringIO()
-    xmlgen = XMLGenerator(result)
-    parser.setContentHandler(xmlgen)
-    parser.reset()
+        def __init__(self):
+            self._notations = []
+            self._entities  = []
 
-    parser.feed("<doc>")
-    parser.feed("text")
-    parser.feed("</doc>")
-    parser.close()
+        def notationDecl(self, name, publicId, systemId):
+            self._notations.append((name, publicId, systemId))
 
-    return result.getvalue() == start + "<doc>text</doc>"
+        def unparsedEntityDecl(self, name, publicId, systemId, ndata):
+            self._entities.append((name, publicId, systemId, ndata))
 
-# ===== Locator support
+    def test_expat_dtdhandler(self):
+        parser = create_parser()
+        handler = self.TestDTDHandler()
+        parser.setDTDHandler(handler)
 
-def test_expat_locator_noinfo():
-    result = StringIO()
-    xmlgen = XMLGenerator(result)
-    parser = create_parser()
-    parser.setContentHandler(xmlgen)
+        parser.feed('<!DOCTYPE doc [\n')
+        parser.feed('  <!ENTITY img SYSTEM "expat.gif" NDATA GIF>\n')
+        parser.feed('  <!NOTATION GIF PUBLIC "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN">\n')
+        parser.feed(']>\n')
+        parser.feed('<doc></doc>')
+        parser.close()
 
-    parser.feed("<doc>")
-    parser.feed("</doc>")
-    parser.close()
+        self.assertEquals(handler._notations, 
+            [("GIF", "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN", None)])
+        self.assertEquals(handler._entities, [("img", None, "expat.gif", "GIF")])
 
-    return parser.getSystemId() is None and \
-           parser.getPublicId() is None and \
-           parser.getLineNumber() == 1
+    # ===== EntityResolver support
 
-def test_expat_locator_withinfo():
-    result = StringIO()
-    xmlgen = XMLGenerator(result)
-    parser = create_parser()
-    parser.setContentHandler(xmlgen)
-    parser.parse(findfile("test.xml"))
-
-    return parser.getSystemId() == findfile("test.xml") and \
-           parser.getPublicId() is None
+    class TestEntityResolver:
 
+        def resolveEntity(self, publicId, systemId):
+            inpsrc = InputSource()
+            inpsrc.setByteStream(StringIO("<entity/>"))
+            return inpsrc
 
+    def test_expat_entityresolver(self):
+        parser = create_parser()
+        parser.setEntityResolver(self.TestEntityResolver())
+        result = StringIO()
+        parser.setContentHandler(XMLGenerator(result))
+
+        parser.feed('<!DOCTYPE doc [\n')
+        parser.feed('  <!ENTITY test SYSTEM "whatever">\n')
+        parser.feed(']>\n')
+        parser.feed('<doc>&test;</doc>')
+        parser.close()
+
+        self.assertEquals(result.getvalue(), start + 
+                          "<doc><entity></entity></doc>")
+
+    # ===== Attributes support
+
+    class AttrGatherer(ContentHandler):
+
+        def startElement(self, name, attrs):
+            self._attrs = attrs
+
+        def startElementNS(self, name, qname, attrs):
+            self._attrs = attrs
+
+    def test_expat_attrs_empty(self):
+        parser = create_parser()
+        gather = self.AttrGatherer()
+        parser.setContentHandler(gather)
+
+        parser.feed("<doc/>")
+        parser.close()
+
+        self.verify_empty_attrs(gather._attrs)
+
+    def test_expat_attrs_wattr(self):
+        parser = create_parser()
+        gather = self.AttrGatherer()
+        parser.setContentHandler(gather)
+
+        parser.feed("<doc attr='val'/>")
+        parser.close()
+
+        self.verify_attrs_wattr(gather._attrs)
+
+    def test_expat_nsattrs_empty(self):
+        parser = create_parser(1)
+        gather = self.AttrGatherer()
+        parser.setContentHandler(gather)
+
+        parser.feed("<doc/>")
+        parser.close()
+
+        self.verify_empty_nsattrs(gather._attrs)
+
+    def test_expat_nsattrs_wattr(self):
+        parser = create_parser(1)
+        gather = self.AttrGatherer()
+        parser.setContentHandler(gather)
+
+        parser.feed("<doc xmlns:ns='%s' ns:attr='val'/>" % ns_uri)
+        parser.close()
+
+        attrs = gather._attrs
+
+        self.assertEquals(attrs.getLength(), 1)
+        self.assertEquals(attrs.getNames(), [(ns_uri, "attr")])
+        self.assertTrue((attrs.getQNames() == [] or 
+                         attrs.getQNames() == ["ns:attr"]))
+        self.assertEquals(len(attrs), 1)
+        self.assertTrue(attrs.has_key((ns_uri, "attr")))
+        self.assertEquals(attrs.get((ns_uri, "attr")), "val")
+        self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
+        self.assertEquals(attrs.items(), [((ns_uri, "attr"), "val")])
+        self.assertEquals(attrs.values(), ["val"])
+        self.assertEquals(attrs.getValue((ns_uri, "attr")), "val")
+        self.assertEquals(attrs[(ns_uri, "attr")], "val")
+
+    # ===== InputSource support
+    
+    def test_expat_inpsource_filename(self):
+        parser = create_parser()
+        result = StringIO()
+        xmlgen = XMLGenerator(result)
+    
+        parser.setContentHandler(xmlgen)
+        parser.parse(findfile("test"+os.extsep+"xml"))
+
+        self.assertEquals(result.getvalue(), xml_test_out)
+    
+    def test_expat_inpsource_sysid(self):
+        parser = create_parser()
+        result = StringIO()
+        xmlgen = XMLGenerator(result)
+    
+        parser.setContentHandler(xmlgen)
+        parser.parse(InputSource(findfile("test"+os.extsep+"xml")))
+
+        self.assertEquals(result.getvalue(), xml_test_out)
+    
+    def test_expat_inpsource_stream(self):
+        parser = create_parser()
+        result = StringIO()
+        xmlgen = XMLGenerator(result)
+    
+        parser.setContentHandler(xmlgen)
+        inpsrc = InputSource()
+        inpsrc.setByteStream(open(findfile("test"+os.extsep+"xml")))
+        parser.parse(inpsrc)
+    
+        self.assertEquals(result.getvalue(), xml_test_out)
+    
+    # ===== IncrementalParser support
+    
+    def test_expat_incremental(self):
+        result = StringIO()
+        xmlgen = XMLGenerator(result)
+        parser = create_parser()
+        parser.setContentHandler(xmlgen)
+    
+        parser.feed("<doc>")
+        parser.feed("</doc>")
+        parser.close()
+    
+        self.assertEquals(result.getvalue(), start + "<doc></doc>")
+    
+    def test_expat_incremental_reset(self):
+        result = StringIO()
+        xmlgen = XMLGenerator(result)
+        parser = create_parser()
+        parser.setContentHandler(xmlgen)
+    
+        parser.feed("<doc>")
+        parser.feed("text")
+    
+        result = StringIO()
+        xmlgen = XMLGenerator(result)
+        parser.setContentHandler(xmlgen)
+        parser.reset()
+    
+        parser.feed("<doc>")
+        parser.feed("text")
+        parser.feed("</doc>")
+        parser.close()
+
+        self.assertEquals(result.getvalue(), start + "<doc>text</doc>")
+    
+    # ===== Locator support
+    
+    def test_expat_locator_noinfo(self):
+        result = StringIO()
+        xmlgen = XMLGenerator(result)
+        parser = create_parser()
+        parser.setContentHandler(xmlgen)
+    
+        parser.feed("<doc>")
+        parser.feed("</doc>")
+        parser.close()
+    
+        self.assertEquals(parser.getSystemId(), None)
+        self.assertEquals(parser.getPublicId(), None)
+        self.assertEquals(parser.getLineNumber(), 1)
+    
+    def test_expat_locator_withinfo(self):
+        result = StringIO()
+        xmlgen = XMLGenerator(result)
+        parser = create_parser()
+        parser.setContentHandler(xmlgen)
+        parser.parse(findfile("test.xml"))
+    
+        self.assertEquals(parser.getSystemId(), findfile("test.xml"))
+        self.assertEquals(parser.getPublicId(), None)
+    
+    
 # ===========================================================================
 #
 #   error reporting
 #
 # ===========================================================================
 
-def test_expat_inpsource_location():
-    parser = create_parser()
-    parser.setContentHandler(ContentHandler()) # do nothing
-    source = InputSource()
-    source.setByteStream(StringIO("<foo bar foobar>"))   #ill-formed
-    name = "a file name"
-    source.setSystemId(name)
-    try:
-        parser.parse(source)
-    except SAXException, e:
-        return e.getSystemId() == name
-
-def test_expat_incomplete():
-    parser = create_parser()
-    parser.setContentHandler(ContentHandler()) # do nothing
-    try:
-        parser.parse(StringIO("<foo>"))
-    except SAXParseException:
-        return 1 # ok, error found
-    else:
-        return 0
-
-def test_sax_parse_exception_str():
-    # pass various values from a locator to the SAXParseException to
-    # make sure that the __str__() doesn't fall apart when None is
-    # passed instead of an integer line and column number
-    #
-    # use "normal" values for the locator:
-    str(SAXParseException("message", None,
-                          DummyLocator(1, 1)))
-    # use None for the line number:
-    str(SAXParseException("message", None,
-                          DummyLocator(None, 1)))
-    # use None for the column number:
-    str(SAXParseException("message", None,
-                          DummyLocator(1, None)))
-    # use None for both:
-    str(SAXParseException("message", None,
-                          DummyLocator(None, None)))
-    return 1
-
-class DummyLocator:
-    def __init__(self, lineno, colno):
-        self._lineno = lineno
-        self._colno = colno
-
-    def getPublicId(self):
-        return "pubid"
-
-    def getSystemId(self):
-        return "sysid"
-
-    def getLineNumber(self):
-        return self._lineno
-
-    def getColumnNumber(self):
-        return self._colno
+class ErrorReportingTest(unittest.TestCase):
+    def test_expat_inpsource_location(self):
+        parser = create_parser()
+        parser.setContentHandler(ContentHandler()) # do nothing
+        source = InputSource()
+        source.setByteStream(StringIO("<foo bar foobar>"))   #ill-formed
+        name = "a file name"
+        source.setSystemId(name)
+        try:
+            parser.parse(source)
+            self.fail()
+        except SAXException, e:
+            self.assertEquals(e.getSystemId(), name)
+    
+    def test_expat_incomplete(self):
+        parser = create_parser()
+        parser.setContentHandler(ContentHandler()) # do nothing
+        self.assertRaises(SAXParseException, parser.parse, StringIO("<foo>"))
+    
+    def test_sax_parse_exception_str(self):
+        # pass various values from a locator to the SAXParseException to
+        # make sure that the __str__() doesn't fall apart when None is
+        # passed instead of an integer line and column number
+        #
+        # use "normal" values for the locator:
+        str(SAXParseException("message", None,
+                              self.DummyLocator(1, 1)))
+        # use None for the line number:
+        str(SAXParseException("message", None,
+                              self.DummyLocator(None, 1)))
+        # use None for the column number:
+        str(SAXParseException("message", None,
+                              self.DummyLocator(1, None)))
+        # use None for both:
+        str(SAXParseException("message", None,
+                              self.DummyLocator(None, None)))
+    
+    class DummyLocator:
+        def __init__(self, lineno, colno):
+            self._lineno = lineno
+            self._colno = colno
+    
+        def getPublicId(self):
+            return "pubid"
+    
+        def getSystemId(self):
+            return "sysid"
+    
+        def getLineNumber(self):
+            return self._lineno
+    
+        def getColumnNumber(self):
+            return self._colno
 
 # ===========================================================================
 #
@@ -571,218 +606,91 @@ class DummyLocator:
 #
 # ===========================================================================
 
-# ===== AttributesImpl
-
-def verify_empty_attrs(attrs):
-    try:
-        attrs.getValue("attr")
-        gvk = 0
-    except KeyError:
-        gvk = 1
-
-    try:
-        attrs.getValueByQName("attr")
-        gvqk = 0
-    except KeyError:
-        gvqk = 1
-
-    try:
-        attrs.getNameByQName("attr")
-        gnqk = 0
-    except KeyError:
-        gnqk = 1
-
-    try:
-        attrs.getQNameByName("attr")
-        gqnk = 0
-    except KeyError:
-        gqnk = 1
-
-    try:
-        attrs["attr"]
-        gik = 0
-    except KeyError:
-        gik = 1
-
-    return attrs.getLength() == 0 and \
-           attrs.getNames() == [] and \
-           attrs.getQNames() == [] and \
-           len(attrs) == 0 and \
-           not attrs.has_key("attr") and \
-           attrs.keys() == [] and \
-           attrs.get("attrs") is None and \
-           attrs.get("attrs", 25) == 25 and \
-           attrs.items() == [] and \
-           attrs.values() == [] and \
-           gvk and gvqk and gnqk and gik and gqnk
-
-def verify_attrs_wattr(attrs):
-    return attrs.getLength() == 1 and \
-           attrs.getNames() == ["attr"] and \
-           attrs.getQNames() == ["attr"] and \
-           len(attrs) == 1 and \
-           attrs.has_key("attr") and \
-           attrs.keys() == ["attr"] and \
-           attrs.get("attr") == "val" and \
-           attrs.get("attr", 25) == "val" and \
-           attrs.items() == [("attr", "val")] and \
-           attrs.values() == ["val"] and \
-           attrs.getValue("attr") == "val" and \
-           attrs.getValueByQName("attr") == "val" and \
-           attrs.getNameByQName("attr") == "attr" and \
-           attrs["attr"] == "val" and \
-           attrs.getQNameByName("attr") == "attr"
-
-def test_attrs_empty():
-    return verify_empty_attrs(AttributesImpl({}))
-
-def test_attrs_wattr():
-    return verify_attrs_wattr(AttributesImpl({"attr" : "val"}))
-
-# ===== AttributesImpl
-
-def verify_empty_nsattrs(attrs):
-    try:
-        attrs.getValue((ns_uri, "attr"))
-        gvk = 0
-    except KeyError:
-        gvk = 1
-
-    try:
-        attrs.getValueByQName("ns:attr")
-        gvqk = 0
-    except KeyError:
-        gvqk = 1
-
-    try:
-        attrs.getNameByQName("ns:attr")
-        gnqk = 0
-    except KeyError:
-        gnqk = 1
-
-    try:
-        attrs.getQNameByName((ns_uri, "attr"))
-        gqnk = 0
-    except KeyError:
-        gqnk = 1
-
-    try:
-        attrs[(ns_uri, "attr")]
-        gik = 0
-    except KeyError:
-        gik = 1
-
-    return attrs.getLength() == 0 and \
-           attrs.getNames() == [] and \
-           attrs.getQNames() == [] and \
-           len(attrs) == 0 and \
-           not attrs.has_key((ns_uri, "attr")) and \
-           attrs.keys() == [] and \
-           attrs.get((ns_uri, "attr")) is None and \
-           attrs.get((ns_uri, "attr"), 25) == 25 and \
-           attrs.items() == [] and \
-           attrs.values() == [] and \
-           gvk and gvqk and gnqk and gik and gqnk
-
-def test_nsattrs_empty():
-    return verify_empty_nsattrs(AttributesNSImpl({}, {}))
-
-def test_nsattrs_wattr():
-    attrs = AttributesNSImpl({(ns_uri, "attr") : "val"},
-                             {(ns_uri, "attr") : "ns:attr"})
-
-    return attrs.getLength() == 1 and \
-           attrs.getNames() == [(ns_uri, "attr")] and \
-           attrs.getQNames() == ["ns:attr"] and \
-           len(attrs) == 1 and \
-           attrs.has_key((ns_uri, "attr")) and \
-           attrs.keys() == [(ns_uri, "attr")] and \
-           attrs.get((ns_uri, "attr")) == "val" and \
-           attrs.get((ns_uri, "attr"), 25) == "val" and \
-           attrs.items() == [((ns_uri, "attr"), "val")] and \
-           attrs.values() == ["val"] and \
-           attrs.getValue((ns_uri, "attr")) == "val" and \
-           attrs.getValueByQName("ns:attr") == "val" and \
-           attrs.getNameByQName("ns:attr") == (ns_uri, "attr") and \
-           attrs[(ns_uri, "attr")] == "val" and \
-           attrs.getQNameByName((ns_uri, "attr")) == "ns:attr"
-
-
-# During the development of Python 2.5, an attempt to move the "xml"
-# package implementation to a new package ("xmlcore") proved painful.
-# The goal of this change was to allow applications to be able to
-# obtain and rely on behavior in the standard library implementation
-# of the XML support without needing to be concerned about the
-# availability of the PyXML implementation.
-#
-# While the existing import hackery in Lib/xml/__init__.py can cause
-# PyXML's _xmlpus package to supplant the "xml" package, that only
-# works because either implementation uses the "xml" package name for
-# imports.
-#
-# The move resulted in a number of problems related to the fact that
-# the import machinery's "package context" is based on the name that's
-# being imported rather than the __name__ of the actual package
-# containment; it wasn't possible for the "xml" package to be replaced
-# by a simple module that indirected imports to the "xmlcore" package.
-#
-# The following two tests exercised bugs that were introduced in that
-# attempt.  Keeping these tests around will help detect problems with
-# other attempts to provide reliable access to the standard library's
-# implementation of the XML support.
-
-def test_sf_1511497():
-    # Bug report: http://www.python.org/sf/1511497
-    import sys
-    old_modules = sys.modules.copy()
-    for modname in sys.modules.keys():
-        if modname.startswith("xml."):
-            del sys.modules[modname]
-    try:
-        import xml.sax.expatreader
-        module = xml.sax.expatreader
-        return module.__name__ == "xml.sax.expatreader"
-    finally:
-        sys.modules.update(old_modules)
-
-def test_sf_1513611():
-    # Bug report: http://www.python.org/sf/1513611
-    sio = StringIO("invalid")
-    parser = make_parser()
-    from xml.sax import SAXParseException
-    try:
-        parser.parse(sio)
-    except SAXParseException:
-        return True
-    else:
-        return False
-
-# ===== Main program
-
-def make_test_output():
-    parser = create_parser()
-    result = StringIO()
-    xmlgen = XMLGenerator(result)
-
-    parser.setContentHandler(xmlgen)
-    parser.parse(findfile("test"+os.extsep+"xml"))
-
-    outf = open(findfile("test"+os.extsep+"xml"+os.extsep+"out"), "w")
-    outf.write(result.getvalue())
-    outf.close()
-
-items = locals().items()
-items.sort()
-for (name, value) in items:
-    if name[ : 5] == "test_":
-        confirm(value(), name)
-# We delete the items variable so that the assignment to items above
-# doesn't pick up the old value of items (which messes with attempts
-# to find reference leaks).
-del items
-
-if verbose:
-    print "%d tests, %d failures" % (tests, len(failures))
-if failures:
-    raise TestFailed("%d of %d tests failed: %s"
-                     % (len(failures), tests, ", ".join(failures)))
+class XmlReaderTest(XmlTestBase):
+        
+    # ===== AttributesImpl
+    def test_attrs_empty(self):
+        self.verify_empty_attrs(AttributesImpl({}))
+    
+    def test_attrs_wattr(self):
+        self.verify_attrs_wattr(AttributesImpl({"attr" : "val"}))
+    
+    def test_nsattrs_empty(self):
+        self.verify_empty_nsattrs(AttributesNSImpl({}, {}))
+    
+    def test_nsattrs_wattr(self):
+        attrs = AttributesNSImpl({(ns_uri, "attr") : "val"},
+                                 {(ns_uri, "attr") : "ns:attr"})
+    
+        self.assertEquals(attrs.getLength(), 1)
+        self.assertEquals(attrs.getNames(), [(ns_uri, "attr")])
+        self.assertEquals(attrs.getQNames(), ["ns:attr"])
+        self.assertEquals(len(attrs), 1)
+        self.assertTrue(attrs.has_key((ns_uri, "attr")))
+        self.assertEquals(attrs.keys(), [(ns_uri, "attr")])
+        self.assertEquals(attrs.get((ns_uri, "attr")), "val")
+        self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
+        self.assertEquals(attrs.items(), [((ns_uri, "attr"), "val")])
+        self.assertEquals(attrs.values(), ["val"])
+        self.assertEquals(attrs.getValue((ns_uri, "attr")), "val")
+        self.assertEquals(attrs.getValueByQName("ns:attr"), "val")
+        self.assertEquals(attrs.getNameByQName("ns:attr"), (ns_uri, "attr"))
+        self.assertEquals(attrs[(ns_uri, "attr")], "val")
+        self.assertEquals(attrs.getQNameByName((ns_uri, "attr")), "ns:attr")
+
+
+    # During the development of Python 2.5, an attempt to move the "xml"
+    # package implementation to a new package ("xmlcore") proved painful.
+    # The goal of this change was to allow applications to be able to
+    # obtain and rely on behavior in the standard library implementation
+    # of the XML support without needing to be concerned about the
+    # availability of the PyXML implementation.
+    #
+    # While the existing import hackery in Lib/xml/__init__.py can cause
+    # PyXML's _xmlpus package to supplant the "xml" package, that only
+    # works because either implementation uses the "xml" package name for
+    # imports.
+    #
+    # The move resulted in a number of problems related to the fact that
+    # the import machinery's "package context" is based on the name that's
+    # being imported rather than the __name__ of the actual package
+    # containment; it wasn't possible for the "xml" package to be replaced
+    # by a simple module that indirected imports to the "xmlcore" package.
+    #
+    # The following two tests exercised bugs that were introduced in that
+    # attempt.  Keeping these tests around will help detect problems with
+    # other attempts to provide reliable access to the standard library's
+    # implementation of the XML support.
+    
+    def test_sf_1511497(self):
+        # Bug report: http://www.python.org/sf/1511497
+        import sys
+        old_modules = sys.modules.copy()
+        for modname in sys.modules.keys():
+            if modname.startswith("xml."):
+                del sys.modules[modname]
+        try:
+            import xml.sax.expatreader
+            module = xml.sax.expatreader
+            self.assertEquals(module.__name__, "xml.sax.expatreader")
+        finally:
+            sys.modules.update(old_modules)
+    
+    def test_sf_1513611(self):
+        # Bug report: http://www.python.org/sf/1513611
+        sio = StringIO("invalid")
+        parser = make_parser()
+        from xml.sax import SAXParseException
+        self.assertRaises(SAXParseException, parser.parse, sio)
+
+
+def unittest_main():
+    run_unittest(MakeParserTest,
+                 SaxutilsTest,
+                 XmlgenTest,
+                 ExpatReaderTest,
+                 ErrorReportingTest,
+                 XmlReaderTest)
+
+if __name__ == "__main__":
+     unittest_main()