Return to indexes.py CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2 / python / tests

Annotation of embedaddon/libxml2/python/tests/indexes.py, revision 1.1.1.2

1.1       misho       1: #!/usr/bin/python -u
                      2: # -*- coding: ISO-8859-1 -*-
                      3: import sys
                      4: import libxml2
                      5: 
                      6: # Memory debug specific
                      7: libxml2.debugMemory(1)
                      8: 
                      9: ctxt = None
                     10: 
                     11: class callback:
                     12:     def __init__(self, startd, starte, ende, delta, endd):
                     13:         self.startd = startd
                     14:         self.starte = starte
                     15:         self.ende = ende
                     16:         self.endd = endd
                     17:         self.delta = delta
                     18:         self.count = 0
                     19: 
                     20:     def startDocument(self):
                     21:         global ctxt
                     22:         if ctxt.byteConsumed() != self.startd:
1.1.1.2 ! misho      23:             print("document start at wrong index: %d expecting %d\n" % (
        !            24:                   ctxt.byteConsumed(), self.startd))
1.1       misho      25:             sys.exit(1)
                     26: 
                     27:     def endDocument(self):
                     28:         global ctxt
                     29:         expect = self.ende + self.delta * (self.count - 1) + self.endd
                     30:         if ctxt.byteConsumed() != expect:
1.1.1.2 ! misho      31:             print("document end at wrong index: %d expecting %d\n" % (
        !            32:                   ctxt.byteConsumed(), expect))
1.1       misho      33:             sys.exit(1)
                     34: 
                     35:     def startElement(self, tag, attrs):
                     36:         global ctxt
                     37:         if tag == "bar1":
                     38:             expect = self.starte + self.delta * self.count
                     39:             if ctxt.byteConsumed() != expect:
1.1.1.2 ! misho      40:                 print("element start at wrong index: %d expecting %d\n" % (
        !            41:                    ctxt.byteConsumed(), expect))
1.1       misho      42:                 sys.exit(1)
                     43:             
                     44: 
                     45:     def endElement(self, tag):
                     46:         global ctxt
                     47:         if tag == "bar1":
                     48:             expect = self.ende + self.delta * self.count
                     49:             if ctxt.byteConsumed() != expect:
1.1.1.2 ! misho      50:                 print("element end at wrong index: %d expecting %d\n" % (
        !            51:                       ctxt.byteConsumed(), expect))
1.1       misho      52:                 sys.exit(1)
                     53:             self.count = self.count + 1
                     54: 
                     55:     def characters(self, data):
                     56:         pass
                     57: 
                     58: #
                     59: # First run a pure UTF-8 test
                     60: #
                     61: handler = callback(0, 13, 27, 198, 183)
                     62: ctxt = libxml2.createPushParser(handler, "<foo>\n", 6, "test.xml")
                     63: chunk = """  <bar1>chars1</bar1>
                     64:   <bar2>chars2</bar2>
                     65:   <bar3>chars3</bar3>
                     66:   <bar4>chars4</bar4>
                     67:   <bar5>chars5</bar5>
                     68:   <bar6>&lt;s6</bar6>
                     69:   <bar7>chars7</bar7>
                     70:   <bar8>&#38;8</bar8>
                     71:   <bar9>chars9</bar9>
                     72: """
                     73: i = 0
                     74: while i < 10000:
                     75:     ctxt.parseChunk(chunk, len(chunk), 0)
                     76:     i = i + 1
                     77: chunk = "</foo>"
                     78: ctxt.parseChunk(chunk, len(chunk), 1)
                     79: ctxt=None
                     80: 
                     81: #
                     82: # Then run a test relying on ISO-Latin-1
                     83: #
                     84: handler = callback(43, 57, 71, 198, 183)
                     85: chunk="""<?xml version="1.0" encoding="ISO-8859-1"?>
                     86: <foo>
                     87: """
                     88: ctxt = libxml2.createPushParser(handler, chunk, len(chunk), "test.xml")
                     89: chunk = """  <bar1>chars1</bar1>
                     90:   <bar2>chars2</bar2>
                     91:   <bar3>chars3</bar3>
                     92:   <bar4>chàrs4</bar4>
                     93:   <bar5>chars5</bar5>
                     94:   <bar6>&lt;s6</bar6>
                     95:   <bar7>chars7</bar7>
                     96:   <bar8>&#38;8</bar8>
                     97:   <bar9>très 9</bar9>
                     98: """
                     99: i = 0
                    100: while i < 10000:
                    101:     ctxt.parseChunk(chunk, len(chunk), 0)
                    102:     i = i + 1
                    103: chunk = "</foo>"
                    104: ctxt.parseChunk(chunk, len(chunk), 1)
                    105: ctxt=None
                    106: 
                    107: # Memory debug specific
                    108: libxml2.cleanupParser()
                    109: if libxml2.debugMemory(1) == 0:
1.1.1.2 ! misho     110:     print("OK")
1.1       misho     111: else:
1.1.1.2 ! misho     112:     print("Memory leak %d bytes" % (libxml2.debugMemory(1)))
1.1       misho     113:     libxml2.dumpMemory()