Skip to content

Z
Zope
Commit 6928e297 authored by Andreas Jung's avatar Andreas Jung
Browse files
Options

Major rework and removal of redundant code. 

Warning: this test is incomplete like the former
version because the real regression tests are not working
because the reference HTML files were generated
for the old ST - and not STXNG.
parent d8bd1b9c
Show whitespace changes
Inline Side-by-side
Showing with 173 additions and 496 deletions
lib/python/StructuredText/tests/framework.py 0 → 100644
View file @ 6928e297
##############################################################################
#
# Zope Public License (ZPL) Version 1.0
# -------------------------------------
#
# Copyright (c) Digital Creations. All rights reserved.
#
# This license has been certified as Open Source(tm).
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# 1. Redistributions in source code must retain the above copyright
# notice, this list of conditions, and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions, and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
#
# 3. Digital Creations requests that attribution be given to Zope
# in any manner possible. Zope includes a "Powered by Zope"
# button that is installed by default. While it is not a license
# violation to remove this button, it is requested that the
# attribution remain. A significant investment has been put
# into Zope, and this effort will continue if the Zope community
# continues to grow. This is one way to assure that growth.
#
# 4. All advertising materials and documentation mentioning
# features derived from or use of this software must display
# the following acknowledgement:
#
# "This product includes software developed by Digital Creations
# for use in the Z Object Publishing Environment
# (http://www.zope.org/)."
#
# In the event that the product being advertised includes an
# intact Zope distribution (with copyright and license included)
# then this clause is waived.
#
# 5. Names associated with Zope or Digital Creations must not be used to
# endorse or promote products derived from this software without
# prior written permission from Digital Creations.
#
# 6. Modified redistributions of any form whatsoever must retain
# the following acknowledgment:
#
# "This product includes software developed by Digital Creations
# for use in the Z Object Publishing Environment
# (http://www.zope.org/)."
#
# Intact (re-)distributions of any official Zope release do not
# require an external acknowledgement.
#
# 7. Modifications are encouraged but must be packaged separately as
# patches to official Zope releases. Distributions that do not
# clearly separate the patches from the original work must be clearly
# labeled as unofficial distributions. Modifications which do not
# carry the name Zope may be packaged in any form, as long as they
# conform to all of the clauses above.
#
#
# Disclaimer
#
# THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS ``AS IS'' AND ANY
# EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DIGITAL CREATIONS OR ITS
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
# SUCH DAMAGE.
#
#
# This software consists of contributions made by Digital Creations and
# many individuals on behalf of Digital Creations. Specific
# attributions are listed in the accompanying credits file.
#
##############################################################################
######################################################################
# Set up unit testing framework
#
# The following code should be at the top of every test module:
#
# import os, sys
# execfile(os.path.join(sys.path[0], 'framework.py'))
#
# ...and the following at the bottom:
#
# framework()
# Find the Testing package
if not sys.modules.has_key('Testing'):
p0 = sys.path[0]
if p0 and __name__ == '__main__':
os.chdir(p0)
p0 = ''
p = d = os.path.abspath(os.curdir)
while d:
if os.path.isdir(os.path.join(p, 'Testing')):
sys.path[:1] = [p0, os.pardir, p]
break
p, d = os.path.split(p)
else:
print 'Unable to locate Testing package.'
sys.exit(1)
import Testing, unittest
execfile(os.path.join(os.path.split(Testing.__file__)[0], 'common.py'))
lib/python/StructuredText/tests/testStructuredText.py
View file @ 6928e297
...@@ -3,8 +3,8 @@ from StructuredText import DocumentClass ...@@ -3,8 +3,8 @@ from StructuredText import DocumentClass
from StructuredText import ClassicDocumentClass from StructuredText import ClassicDocumentClass
from StructuredText import StructuredText from StructuredText import StructuredText
from StructuredText import HTMLClass from StructuredText import HTMLClass
from string import join
import sys, os, unittest import sys, os, unittest
execfile(os.path.join(sys.path[0],'framework.py'))
""" """
This tester first ensures that all regression files This tester first ensures that all regression files
...@@ -14,519 +14,78 @@ StructuredText and ClassicDocumentClass->HTMLClass ...@@ -14,519 +14,78 @@ StructuredText and ClassicDocumentClass->HTMLClass
to help ensure backwards compatability. to help ensure backwards compatability.
""" """
package_dir=os.path.split(ST.__file__)[0] package_dir = os.path.split(ST.__file__)[0]
regressions=os.path.join(package_dir, 'regressions') regressions=os.path.join(package_dir, 'regressions')
files = ['index.stx','Acquisition.stx','ExtensionClass.stx',
'MultiMapping.stx','examples.stx']
class StructuredTextIndexTestCase(unittest.TestCase):
def setUp(self):
myfile = open(os.path.join(regressions, 'index.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = lines
def runTest(self):
assert StructuredText.StructuredText(self.raw_text), \
'StructuredText failed on index'
class StructuredTextAcquisitionTestCase(unittest.TestCase):
def setUp(self):
myfile = open(os.path.join(regressions, 'Acquisition.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = lines
def runTest(self):
assert StructuredText.StructuredText(self.raw_text), \
'StructuredText failed on Acquisition'
class StructuredTextExtensionClassTestCase(unittest.TestCase):
def setUp(self):
myfile = open(os.path.join(regressions, 'index.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = lines
def runTest(self):
assert StructuredText.StructuredText(self.raw_text), \
'StructuredText failed on ExtensionClass'
class StructuredTextMultiMappingTestCase(unittest.TestCase):
def setUp(self):
myfile = open(os.path.join(regressions, 'MultiMapping.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = lines
def runTest(self):
assert StructuredText.StructuredText(self.raw_text), \
'StructuredText failed on MultiMapping'
class StructuredTextExamplesTestCase(unittest.TestCase):
def setUp(self):
myfile = open(os.path.join(regressions, 'examples.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = lines
def runTest(self):
assert StructuredText.StructuredText(self.raw_text), \
'StructuredText failed on examples'
class STNGIndexTestCase(unittest.TestCase):
def setUp(self):
myfile = open(os.path.join(regressions, 'index.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = lines
def runTest(self):
assert ST.StructuredText(self.raw_text), \
'StructuredTextNG failed on index'
class STNGAcquisitionTestCase(unittest.TestCase):
def setUp(self):
myfile = open(os.path.join(regressions, 'Acquisition.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = lines
def runTest(self):
assert ST.StructuredText(self.raw_text), \
'StructuredTextNG failed on Acquisition'
class STNGExtensionClassTestCase(unittest.TestCase):
def setUp(self):
myfile = open(os.path.join(regressions, 'ExtensionClass.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = lines
def runTest(self):
assert ST.StructuredText(self.raw_text), \
'StructuredTextNG failed on ExtensionClass'
class STNGMultiMappingTestCase(unittest.TestCase):
def setUp(self):
myfile = open(os.path.join(regressions, 'MultiMapping.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = lines
def runTest(self):
assert ST.StructuredText(self.raw_text), \
'StructuredTextNG failed on MultiMapping'
class STNGExamplesTestCase(unittest.TestCase):
def setUp(self):
myfile = open(os.path.join(regressions, 'examples.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = lines
def runTest(self):
assert ST.StructuredText(self.raw_text), \
'StructuredTextNG failed on examples'
class DocumentClassIndexTestCase(unittest.TestCase):
def setUp(self):
self.Doc = DocumentClass.DocumentClass()
myfile = open(os.path.join(regressions, 'index.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = ST.StructuredText(lines)
def runTest(self):
assert self.Doc(self.text), \
'DocumentClass failed on index'
class DocumentClassAcquisitionTestCase(unittest.TestCase):
def setUp(self):
self.Doc = DocumentClass.DocumentClass()
myfile = open(os.path.join(regressions, 'Acquisition.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = ST.StructuredText(lines)
def runTest(self):
assert self.Doc(self.text), \
'DocumentClass failed on Acquisition'
class DocumentClassExtensionClassTestCase(unittest.TestCase):
def setUp(self):
self.Doc = DocumentClass.DocumentClass()
myfile = open(os.path.join(regressions, 'ExtensionClass.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = ST.StructuredText(lines)
def runTest(self):
assert self.Doc(self.text), \
'DocumentClass failed on ExtensionClass'
class DocumentClassMultiMappingTestCase(unittest.TestCase):
def setUp(self):
self.Doc = DocumentClass.DocumentClass()
myfile = open(os.path.join(regressions, 'MultiMapping.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = ST.StructuredText(lines)
def runTest(self):
assert self.Doc(self.text), \
'DocumentClass failed on MultiMapping'
class DocumentClassExamplesTestCase(unittest.TestCase):
def setUp(self):
self.Doc = DocumentClass.DocumentClass()
myfile = open(os.path.join(regressions, 'examples.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = ST.StructuredText(lines)
def runTest(self):
assert self.Doc(self.text), \
'DocumentClass failed on examples'
class ClassicDocumentClassIndexTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
myfile = open(os.path.join(regressions, 'index.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = ST.StructuredText(lines)
def runTest(self):
assert self.Doc(self.text), \
'DocumentClass failed on index'
class ClassicDocumentClassAcquisitionTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
myfile = open(os.path.join(regressions, 'Acquisition.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = ST.StructuredText(lines)
def runTest(self):
assert self.Doc(self.text), \
'DocumentClass failed on Acquisition'
class ClassicDocumentClassExtensionClassTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
myfile = open(os.path.join(regressions, 'ExtensionClass.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = ST.StructuredText(lines)
def runTest(self):
assert self.Doc(self.text), \
'DocumentClass failed on ExtensionClass'
class ClassicDocumentClassMultiMappingTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
myfile = open(os.path.join(regressions, 'MultiMapping.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = ST.StructuredText(lines)
def runTest(self):
assert self.Doc(self.text), \
'DocumentClass failed on MultiMapping'
class ClassicDocumentClassExamplesTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
myfile = open(os.path.join(regressions, 'examples.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = ST.StructuredText(lines)
def runTest(self):
assert self.Doc(self.text), \
'DocumentClass failed on examples'
class ClassicHtmlIndexTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
myfile = open(os.path.join(regressions, 'index.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = self.Doc(ST.StructuredText(lines))
def runTest(self):
assert self.HTML(self.text),\
'HTML failed on classic index'
class ClassicHtmlAcquisitionTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
myfile = open(os.path.join(regressions, 'Acquisition.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = self.Doc(ST.StructuredText(lines))
def runTest(self):
assert self.HTML(self.text),\
'HTML failed on classic Acquisition '
class ClassicHtmlExtensionClassTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
myfile = open(os.path.join(regressions, 'ExtensionClass.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = self.Doc(ST.StructuredText(lines))
def runTest(self):
assert self.HTML(self.text),\
'HTML failed on classic ExtensionClass'
class ClassicHtmlMultiMappingTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
myfile = open(os.path.join(regressions, 'MultiMapping.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = self.Doc(ST.StructuredText(lines))
def runTest(self):
assert self.HTML(self.text),\
'MultiMapping'
class ClassicHtmlExamplesTestCase(unittest.TestCase): def readFile(dirname,fname):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
myfile = open(os.path.join(regressions, 'examples.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = self.Doc(ST.StructuredText(lines))
def runTest(self):
assert self.HTML(self.text),\
'HTML failed on classic examples'
class HtmlIndexTestCase(unittest.TestCase):
def setUp(self):
self.Doc = DocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
myfile = open(os.path.join(regressions, 'index.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = self.Doc(ST.StructuredText(lines))
def runTest(self):
assert self.HTML(self.text),\
'HTML failed on classic index'
class HtmlAcquisitionTestCase(unittest.TestCase):
def setUp(self):
self.Doc = DocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
myfile = open(os.path.join(regressions, 'Acquisition.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = self.Doc(ST.StructuredText(lines))
def runTest(self):
assert self.HTML(self.text),\
'HTML failed on classic Acquisition '
class HtmlExtensionClassTestCase(unittest.TestCase):
def setUp(self):
self.Doc = DocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
myfile = open(os.path.join(regressions, 'ExtensionClass.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = self.Doc(ST.StructuredText(lines))
def runTest(self):
assert self.HTML(self.text),\
'HTML failed on classic ExtensionClass'
class HtmlMultiMappingTestCase(unittest.TestCase):
def setUp(self):
self.Doc = DocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
myfile = open(os.path.join(regressions, 'MultiMapping.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = self.Doc(ST.StructuredText(lines))
def runTest(self):
assert self.HTML(self.text),\
'MultiMapping'
class HtmlExamplesTestCase(unittest.TestCase):
def setUp(self):
self.Doc = DocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
myfile = open(os.path.join(regressions, 'examples.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.text = self.Doc(ST.StructuredText(lines))
def runTest(self):
assert self.HTML(self.text),\
'HTML failed on classic examples'
class IndexRegressionTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
self.ST = StructuredText.StructuredText
myfile = open(os.path.join(regressions, 'index.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = self.Doc(lines)
def runTest(self):
assert self.HTML(self.Doc(self.ST(self.raw_text))) == self.StructuredText(raw_text), \
'StructuredText and ClassicDocumentClass do not match on index.stx'
class AcquisitionRegressionTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
self.ST = StructuredText.StructuredText
myfile = open(os.path.join(regressions, 'Acquisition.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = self.Doc(lines)
def runTest(self):
assert self.HTML(self.Doc(self.ST(self.raw_text))) == self.StructuredText(raw_text), \
'StructuredText and ClassicDocumentClass do not match on Acquisition.stx'
class ExtensionClassRegressionTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
self.ST = StructuredText.StructuredText
myfile = open(os.path.join(regressions, 'ExtensionClass.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = self.Doc(lines)
def runTest(self):
assert self.HTML(self.Doc(self.ST(self.raw_text))) == self.StructuredText(raw_text), \
'StructuredText and ClassicDocumentClass do not match on ExtensionClass.stx'
class MultiMappingRegressionTestCase(unittest.TestCase):
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
self.HTML = HTMLClass.HTMLClass()
self.ST = StructuredText.StructuredText
myfile = open(os.path.join(regressions, 'MultiMapping.stx'),"r")
lines = myfile.readlines()
myfile.close()
lines = join(lines)
self.raw_text = self.Doc(lines)
def runTest(self):
assert self.HTML(self.Doc(self.ST(self.raw_text))) == self.StructuredText(raw_text), \
'StructuredText and ClassicDocumentClass do not match on MultiMapping.stx'
class ExamplesRegressionTestCase(unittest.TestCase): myfile = open(os.path.join(dirname, fname),"r")
def setUp(self):
self.Doc = ClassicDocumentClass.DocumentClass()
self.ST = ST.StructuredText
self.HTML = HTMLClass.HTMLClass()
self.ST = StructuredText.StructuredText
myfile = open(os.path.join(regressions, 'examples.stx'),"r")
lines = myfile.readlines() lines = myfile.readlines()
myfile.close() myfile.close()
lines = join(lines) return ''.join(lines)
self.raw_text = self.Doc(lines)
def runTest(self):
assert self.HTML(self.Doc(self.ST(self.raw_text))) == self.StructuredText(raw_text), \
'StructuredText and ClassicDocumentClass do not match on examples.stx'
ClassicHTMLTestSuite = unittest.TestSuite() class StructuredTextTests(unittest.TestCase):
HTMLTestSuite = unittest.TestSuite()
ClassicDocumentClassTestSuite = unittest.TestSuite()
DocumentClassTestSuite = unittest.TestSuite()
STNGTestSuite = unittest.TestSuite()
StructuredTextTestSuite = unittest.TestSuite()
RegressionTestSuite = unittest.TestSuite()
ClassicHTMLTestSuite.addTest(ClassicHtmlIndexTestCase("runTest")) def testStructuredText(self):
ClassicHTMLTestSuite.addTest(ClassicHtmlAcquisitionTestCase("runTest")) """ testing StructuredText """
ClassicHTMLTestSuite.addTest(ClassicHtmlExtensionClassTestCase("runTest"))
ClassicHTMLTestSuite.addTest(ClassicHtmlMultiMappingTestCase("runTest"))
ClassicHTMLTestSuite.addTest(ClassicHtmlExamplesTestCase("runTest"))
HTMLTestSuite.addTest(HtmlIndexTestCase("runTest")) for f in files:
HTMLTestSuite.addTest(HtmlAcquisitionTestCase("runTest")) raw_text = readFile(regressions,f)
HTMLTestSuite.addTest(HtmlExtensionClassTestCase("runTest")) assert StructuredText.StructuredText(raw_text),\
HTMLTestSuite.addTest(HtmlMultiMappingTestCase("runTest")) 'StructuredText failed on %s' % f
HTMLTestSuite.addTest(HtmlExamplesTestCase("runTest"))
ClassicDocumentClassTestSuite.addTest(ClassicDocumentClassIndexTestCase("runTest")) def testStructuredTextNG(self):
ClassicDocumentClassTestSuite.addTest(ClassicDocumentClassAcquisitionTestCase("runTest")) """ testing StructuredTextNG """
ClassicDocumentClassTestSuite.addTest(ClassicDocumentClassExtensionClassTestCase("runTest"))
ClassicDocumentClassTestSuite.addTest(ClassicDocumentClassMultiMappingTestCase("runTest"))
ClassicDocumentClassTestSuite.addTest(ClassicDocumentClassExamplesTestCase("runTest"))
DocumentClassTestSuite.addTest(DocumentClassIndexTestCase("runTest")) for f in files:
DocumentClassTestSuite.addTest(DocumentClassAcquisitionTestCase("runTest")) raw_text = readFile(regressions,f)
DocumentClassTestSuite.addTest(DocumentClassExtensionClassTestCase("runTest")) assert ST.StructuredText(raw_text),\
DocumentClassTestSuite.addTest(DocumentClassMultiMappingTestCase("runTest")) 'StructuredText failed on %s' % f
DocumentClassTestSuite.addTest(DocumentClassExamplesTestCase("runTest"))
STNGTestSuite.addTest(STNGIndexTestCase("runTest"))
STNGTestSuite.addTest(STNGAcquisitionTestCase("runTest"))
STNGTestSuite.addTest(STNGExtensionClassTestCase("runTest"))
STNGTestSuite.addTest(STNGMultiMappingTestCase("runTest"))
STNGTestSuite.addTest(STNGExamplesTestCase("runTest"))
StructuredTextTestSuite.addTest(StructuredTextIndexTestCase("runTest")) def testDocumentClass(self):
StructuredTextTestSuite.addTest(StructuredTextAcquisitionTestCase("runTest")) """ testing DocumentClass"""
StructuredTextTestSuite.addTest(StructuredTextExtensionClassTestCase("runTest"))
StructuredTextTestSuite.addTest(StructuredTextMultiMappingTestCase("runTest"))
StructuredTextTestSuite.addTest(StructuredTextExamplesTestCase("runTest"))
RegressionTestSuite.addTest(IndexRegressionTestCase("runTest")) for f in files:
RegressionTestSuite.addTest(AcquisitionRegressionTestCase("runTest")) Doc = DocumentClass.DocumentClass()
RegressionTestSuite.addTest(ExtensionClassRegressionTestCase("runTest")) raw_text = readFile(regressions,f)
RegressionTestSuite.addTest(MultiMappingRegressionTestCase("runTest")) text = ST.StructuredText(raw_text)
RegressionTestSuite.addTest(ExamplesRegressionTestCase("runTest")) assert Doc(text),\
'DocumentClass failed on %s' % f
runner = unittest.TextTestRunner() def testClassicDocumentClass(self):
""" testing ClassicDocumentClass"""
runner.run(ClassicHTMLTestSuite) for f in files:
runner.run(HTMLTestSuite) Doc = ClassicDocumentClass.DocumentClass()
raw_text = readFile(regressions,f)
text = ST.StructuredText(raw_text)
assert Doc(text),\
'ClassicDocumentClass failed on %s' % f
runner.run(ClassicDocumentClassTestSuite) def testClassicHTMLDocumentClass(self):
runner.run(DocumentClassTestSuite) """ testing HTML ClassicDocumentClass"""
runner.run(STNGTestSuite)
runner.run(StructuredTextTestSuite)
#runner.run(RegressionTestSuite)
for f in files:
Doc = ClassicDocumentClass.DocumentClass()
HTML = HTMLClass.HTMLClass()
raw_text = readFile(regressions,f)
text = Doc(ST.StructuredText(raw_text))
assert HTML(text),\
'HTML ClassicDocumentClass failed on %s' % f
def test_suite():
suite=unittest.TestSuite((
ClassicHTMLTestSuite,
HTMLTestSuite,
ClassicDocumentClassTestSuite,
DocumentClassTestSuite,
STNGTestSuite,
StructuredTextTestSuite,
# RegressionTestSuite,
))
return suite
# def testRegressionsTests(self)
# """ there should be a regression tests that compares
# generated HTML against the reference HTML files.
# This test is commented in the 2.4 branch because
# of the change from ST to STXNG and the changed
# HTML generation (HTML references files are no longer
# valid for STXNG)
if __name__=='__main__': framework()
# Run tests if run as a standalone script
unittest.TextTestRunner().run(test_suite())
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7