def test_decl_handler(tester):
tester.startTest("DTDHandler")
parser = CreateParser()
handler = DeclHandler()
parser.setProperty(property_declaration_handler, handler)
parser.parse(DefaultFactory.fromString(DTD_CONTENT, "file:source"))
elements = [
(u'doc', u'(#PCDATA|e)*'),
(u'e', u'EMPTY'),
]
attributes = [
(u'e', u'id', u'ID', u'#REQUIRED', None),
(u'e', u'a1', u'CDATA', u'#IMPLIED', None),
(u'e', u'enum', u'(v1|v2)', None, u'v1'),
]
entities = [
(u'e1', u'e1'),
(u'%e2', u'e2'),
(u'e3', None, u'file:entity.ent'),
]
tester.compare(elements, handler.elements, "element decls")
tester.compare(attributes, handler.attributes, "attribute decls")
tester.compare(entities, handler.entities, "entity decls")
tester.testDone()
def test_locator_sysid(tester):
tester.startTest("System ID")
parser = CreateParser()
parser.setContentHandler(LocatorTester(tester))
parser.parse(CONTENT_URI)
verify_finished_locator(tester, parser)
tester.testDone()
return
def test_locator_sax(tester):
tester.startTest("SAX InputSource")
parser = CreateParser()
parser.setContentHandler(LocatorTester(tester, CONTENT_PATH))
parser.parse(prepare_input_source(CONTENT_PATH))
verify_finished_locator(tester, parser)
tester.testDone()
return
def test_locator_ft(tester):
tester.startTest("4Suite InputSource")
parser = CreateParser()
parser.setContentHandler(LocatorTester(tester))
parser.parse(DefaultFactory.fromUri(CONTENT_URI))
verify_finished_locator(tester, parser)
tester.testDone()
return
def test_xmlreader_sax(tester):
tester.startTest("SAX InputSource")
parser = CreateParser()
builder = DomBuilder()
parser.setContentHandler(builder)
parser.parse(prepare_input_source(CONTENT_PATH))
tester.compare(XMLREADER_CONTENT, builder, func=compare_builder)
tester.testDone()
return
def test_xmlreader_sysid(tester):
tester.startTest("System ID")
parser = CreateParser()
builder = DomBuilder()
parser.setContentHandler(builder)
parser.parse(CONTENT_URI)
tester.compare(XMLREADER_CONTENT, builder, func=compare_builder)
tester.testDone()
return
def test_xmlreader_ft(tester):
tester.startTest("4Suite InputSource")
parser = CreateParser()
builder = DomBuilder()
parser.setContentHandler(builder)
parser.parse(DefaultFactory.fromUri(CONTENT_URI))
tester.compare(XMLREADER_CONTENT, builder, func=compare_builder)
tester.testDone()
return
def test_xmlreader_file(tester):
tester.startTest("file-like object")
parser = CreateParser()
builder = DomBuilder()
parser.setContentHandler(builder)
parser.parse(open(CONTENT_PATH))
tester.compare(XMLREADER_CONTENT, builder, func=compare_builder)
tester.testDone()
return
def test_errors_incomplete(tester):
tester.startTest("Incomplete Parsing")
parser = CreateParser()
content = "<foo>"
uri = "urn:test:source"
try:
parser.parse(DefaultFactory.fromString(content, uri))
except SAXParseException, e:
pass
def test_errors_location(tester):
tester.startTest("Location")
parser = CreateParser()
content = "<foo bar foorbar>"
uri = "urn:test:source"
try:
parser.parse(DefaultFactory.fromString(content, uri))
except SAXParseException, e:
tester.compare(uri, e.getSystemId())
def test_errors_location(tester):
tester.startTest("Location")
parser = CreateParser()
content = "<foo bar foorbar>"
uri = "urn:test:source"
try:
parser.parse(DefaultFactory.fromString(content, uri))
except SAXParseException, e:
tester.compare(uri, e.getSystemId())
def test_errors_incomplete(tester):
tester.startTest("Incomplete Parsing")
parser = CreateParser()
content = "<foo>"
uri = "urn:test:source"
try:
parser.parse(DefaultFactory.fromString(content, uri))
except SAXParseException, e:
pass
def build_static(self):
documents = []
for document in self.static:
# Building is as simple as creating a new Document instance to
# reflect the converted paths.
document = copy.copy(document)
document.source = util.convert_path(document.source)
documents.append(document)
# Validate the content
if self.validate:
from xml.sax.handler import feature_validation
from Ft.Xml.InputSource import DefaultFactory
from Ft.Xml.Sax import CreateParser
class ErrorHandler:
def __init__(self, displayhook):
self.displayhook = displayhook
def warning(self, exception):
self.displayhook(exception)
def error(self, exception):
self.displayhook(exception)
def fatalError(self, exception):
raise exception
parser = CreateParser()
parser.setFeature(feature_validation, True)
parser.setErrorHandler(ErrorHandler(self.warn))
for document in documents:
self.announce('validating %s' % document.source, 2)
parser.parse(DefaultFactory.fromUri(document.source))
return documents
def test_lexical_handler(tester):
tester.startTest("LexicalHandler")
parser = CreateParser()
handler = LexicalHandler()
parser.setProperty(property_lexical_handler, handler)
parser.parse(DefaultFactory.fromString(DTD_CONTENT, "file:source"))
events = [('startDTD', (u'doc', None, None)),
('endDTD', ()),
('startCDATA', ()),
('endCDATA', ()),
]
comments = [u'LexicalHandler']
tester.compare(events, handler.events, "events")
tester.compare(comments, handler.comments, "comments")
tester.testDone()
def test_dtd_handler(tester):
tester.startTest("DTDHandler")
parser = CreateParser()
dtdhandler = DTDHandler()
parser.setDTDHandler(dtdhandler)
parser.parse(DefaultFactory.fromString(DTD_CONTENT, "file:source"))
notations = [
(u'GIF',
u'-//CompuServe//NOTATION Graphics Interchange Format 89a//EN',
None),
]
entities = [
(u'img', None, u'file:expat.gif', u'GIF'),
]
tester.compare(notations, dtdhandler.notations, "notations")
tester.compare(entities, dtdhandler.entities, "unparsed entities")
tester.testDone()
def test_decl_handler(tester):
tester.startTest("DTDHandler")
parser = CreateParser()
handler = DeclHandler()
parser.setProperty(property_declaration_handler, handler)
parser.parse(DefaultFactory.fromString(DTD_CONTENT, "file:source"))
elements = [
(u'doc', u'(#PCDATA|e)*'),
(u'e', u'EMPTY'),
]
attributes = [
(u'e', u'id', u'ID', u'#REQUIRED', None),
(u'e', u'a1', u'CDATA', u'#IMPLIED', None),
(u'e', u'enum', u'(v1|v2)', None, u'v1'),
]
entities = [
(u'e1', u'e1'),
(u'%e2', u'e2'),
(u'e3', None, u'file:entity.ent'),
]
tester.compare(elements, handler.elements, "element decls")
tester.compare(attributes, handler.attributes, "attribute decls")
tester.compare(entities, handler.entities, "entity decls")
tester.testDone()
def test_attrs_empty(tester):
tester.startTest("Empty")
parser = CreateParser()
gatherer = AttributesGatherer()
parser.setContentHandler(gatherer)
content = "<doc/>"
parser.parse(DefaultFactory.fromString(content, "urn:test:source"))
attrs = gatherer._attrs
name = (TEST_NAMESPACE, "attr")
try:
attrs.getValue(name)
except KeyError:
pass
else:
tester.error("getValue")
try:
attrs[name]
except KeyError:
pass
else:
tester.error("__getitem__")
try:
attrs.getQNameByName(name)
except KeyError:
pass
else:
tester.error("getQNameByName")
tester.compare(0, len(attrs), "__len__")
tester.compare(False, name in attrs, "__contains__")
tester.compare(False, attrs.has_key(name), "has_key")
tester.compare(None, attrs.get(name), "get")
tester.compare(25, attrs.get(name, 25), "get")
tester.compare([], attrs.keys(), "keys")
tester.compare([], attrs.items(), "items")
tester.compare([], attrs.values(), "values")
tester.testDone()
return
def test_locator_ft(tester):
tester.startTest("4Suite InputSource")
parser = CreateParser()
parser.setContentHandler(LocatorTester(tester))
parser.parse(DefaultFactory.fromUri(CONTENT_URI))
verify_finished_locator(tester, parser)
tester.testDone()
return
def test_locator_sax(tester):
tester.startTest("SAX InputSource")
parser = CreateParser()
parser.setContentHandler(LocatorTester(tester, CONTENT_PATH))
parser.parse(prepare_input_source(CONTENT_PATH))
verify_finished_locator(tester, parser)
tester.testDone()
return
def test_locator_sysid(tester):
tester.startTest("System ID")
parser = CreateParser()
parser.setContentHandler(LocatorTester(tester))
parser.parse(CONTENT_URI)
verify_finished_locator(tester, parser)
tester.testDone()
return
def test_xmlreader_sax(tester):
tester.startTest("SAX InputSource")
parser = CreateParser()
builder = DomBuilder()
parser.setContentHandler(builder)
parser.parse(prepare_input_source(CONTENT_PATH))
tester.compare(XMLREADER_CONTENT, builder, func=compare_builder)
tester.testDone()
return
def test_xmlreader_sysid(tester):
tester.startTest("System ID")
parser = CreateParser()
builder = DomBuilder()
parser.setContentHandler(builder)
parser.parse(CONTENT_URI)
tester.compare(XMLREADER_CONTENT, builder, func=compare_builder)
tester.testDone()
return
def test_xmlreader_ft(tester):
tester.startTest("4Suite InputSource")
parser = CreateParser()
builder = DomBuilder()
parser.setContentHandler(builder)
parser.parse(DefaultFactory.fromUri(CONTENT_URI))
tester.compare(XMLREADER_CONTENT, builder, func=compare_builder)
tester.testDone()
return
def test_xmlreader_file(tester):
tester.startTest("file-like object")
parser = CreateParser()
builder = DomBuilder()
parser.setContentHandler(builder)
parser.parse(open(CONTENT_PATH))
tester.compare(XMLREADER_CONTENT, builder, func=compare_builder)
tester.testDone()
return
def test_attrs_specified(tester):
tester.startTest("Specified")
parser = CreateParser()
gatherer = AttributesGatherer()
parser.setContentHandler(gatherer)
content = "<doc xmlns:ns='%s' ns:attr='val'/>" % str(TEST_NAMESPACE)
parser.parse(DefaultFactory.fromString(content, "urn:test:source"))
attrs = gatherer._attrs
name = (TEST_NAMESPACE, "attr")
tester.compare(u"val", attrs.getValue(name), "getValue")
tester.compare(u"val", attrs[name], "__getitem__")
tester.compare(u"ns:attr", attrs.getQNameByName(name), "getQNameByName")
tester.compare(1, len(attrs), "__len__")
tester.compare(True, name in attrs, "__contains__")
tester.compare(True, attrs.has_key(name), "has_key")
tester.compare(u"val", attrs.get(name), "get")
tester.compare(u"val", attrs.get(name, 25), "get")
tester.compare([name], attrs.keys(), "keys")
tester.compare([(name, u"val")], attrs.items(), "items")
tester.compare([u"val"], attrs.values(), "values")
tester.testDone()
return
def test_make_parser(tester):
tester.startTest("Ft.Xml.Sax.CreateParser")
try:
parser = CreateParser()
except:
tester.error("parser not available")
tester.testDone()
tester.startTest("xml.sax.make_parser")
try:
parser = make_parser(['Ft.Xml.Sax'])
except:
tester.error("parser not available")
tester.compare("Ft.Xml.cDomlette", parser.__class__.__module__,
"wrong module")
tester.compare("Parser", parser.__class__.__name__, "wrong class")
tester.testDone()
return
def _parseXmlCat(self, data):
"""
Parse an XML Catalog, as specified in
http://www.oasis-open.org/committees/entity/spec-2001-08-06.html.
Partially implemented.
"""
self.prefer_public = [True]
self.base = [self.uri]
# Since we have the catalog data already, parse it.
source = xmlreader.InputSource(self.uri)
source.setByteStream(cStringIO.StringIO(data))
from Ft.Xml.Sax import CreateParser
p = CreateParser()
p.setFeature('http://xml.org/sax/features/external-parameter-entities',
False)
p.setContentHandler(self)
p.parse(source)
# are these explicit dels needed?
del self.prefer_public
del self.base
return
def test_lexical_handler(tester):
tester.startTest("LexicalHandler")
parser = CreateParser()
handler = LexicalHandler()
parser.setProperty(property_lexical_handler, handler)
parser.parse(DefaultFactory.fromString(DTD_CONTENT, "file:source"))
events = [
('startDTD', (u'doc', None, None)),
('endDTD', ()),
('startCDATA', ()),
('endCDATA', ()),
]
comments = [u'LexicalHandler']
tester.compare(events, handler.events, "events")
tester.compare(comments, handler.comments, "comments")
tester.testDone()
def test_dtd_handler(tester):
tester.startTest("DTDHandler")
parser = CreateParser()
dtdhandler = DTDHandler()
parser.setDTDHandler(dtdhandler)
parser.parse(DefaultFactory.fromString(DTD_CONTENT, "file:source"))
notations = [
(u'GIF',
u'-//CompuServe//NOTATION Graphics Interchange Format 89a//EN', None),
]
entities = [
(u'img', None, u'file:expat.gif', u'GIF'),
]
tester.compare(notations, dtdhandler.notations, "notations")
tester.compare(entities, dtdhandler.entities, "unparsed entities")
tester.testDone()
def _parseXmlCat(self, data):
"""
Parse an XML Catalog, as specified in
http://www.oasis-open.org/committees/entity/spec-2001-08-06.html.
Partially implemented.
"""
self.prefer_public = [True]
self.base = [self.uri]
# Since we have the catalog data already, parse it.
source = xmlreader.InputSource(self.uri)
source.setByteStream(cStringIO.StringIO(data))
from Ft.Xml.Sax import CreateParser
p = CreateParser()
p.setFeature(
'http://xml.org/sax/features/external-parameter-entities', False)
p.setContentHandler(self)
p.parse(source)
# are these explicit dels needed?
del self.prefer_public
del self.base
return
def test_attrs_empty(tester):
tester.startTest("Empty")
parser = CreateParser()
gatherer = AttributesGatherer()
parser.setContentHandler(gatherer)
content = "<doc/>"
parser.parse(DefaultFactory.fromString(content, "urn:test:source"))
attrs = gatherer._attrs
name = (TEST_NAMESPACE, "attr")
try:
attrs.getValue(name)
except KeyError:
pass
else:
tester.error("getValue")
try:
attrs[name]
except KeyError:
pass
else:
tester.error("__getitem__")
try:
attrs.getQNameByName(name)
except KeyError:
pass
else:
tester.error("getQNameByName")
tester.compare(0, len(attrs), "__len__")
tester.compare(False, name in attrs, "__contains__")
tester.compare(False, attrs.has_key(name), "has_key")
tester.compare(None, attrs.get(name), "get")
tester.compare(25, attrs.get(name, 25), "get")
tester.compare([], attrs.keys(), "keys")
tester.compare([], attrs.items(), "items")
tester.compare([], attrs.values(), "values")
tester.testDone()
return
def test_attrs_specified(tester):
tester.startTest("Specified")
parser = CreateParser()
gatherer = AttributesGatherer()
parser.setContentHandler(gatherer)
content = "<doc xmlns:ns='%s' ns:attr='val'/>" % str(TEST_NAMESPACE)
parser.parse(DefaultFactory.fromString(content, "urn:test:source"))
attrs = gatherer._attrs
name = (TEST_NAMESPACE, "attr")
tester.compare(u"val", attrs.getValue(name), "getValue")
tester.compare(u"val", attrs[name], "__getitem__")
tester.compare(u"ns:attr", attrs.getQNameByName(name), "getQNameByName")
tester.compare(1, len(attrs), "__len__")
tester.compare(True, name in attrs, "__contains__")
tester.compare(True, attrs.has_key(name), "has_key")
tester.compare(u"val", attrs.get(name), "get")
tester.compare(u"val", attrs.get(name, 25), "get")
tester.compare([name], attrs.keys(), "keys")
tester.compare([(name, u"val")], attrs.items(), "items")
tester.compare([u"val"], attrs.values(), "values")
tester.testDone()
return
def transform(self, node):
import FragmentFilter
from Ft.Xml.Sax import CreateParser, DomBuilder
rules = FragmentFilter.RulesLoader()
parser = CreateParser()
parser.setContentHandler(rules)
parser.setFeature(xml.sax.handler.property_dom_node, self.applyElt.dom)
parser.parse(None)
fragFilter = FragmentFilter.FragmentFilter(rules)
parser.setContentHandler(fragFilter)
parser.setFeature(xml.sax.handler.property_dom_node, node)
parser.setContentHandler(fragFilter)
builder = DomBuilder()
fragFilter.setContentHandler(builder)
try:
parser.parse(None)
except:
return None
#print "reg frag result: %s" % domg.getRootNode().childNodes[1]
return builder.getDocument().documentElement
