+++ /dev/null
-"""
-Basic TestCases for BTree and hash DBs, with and without a DBEnv, with
-various DB flags, etc.
-"""
-
-import unittest
-
-from rpm import mpw
-
-from test_all import verbose
-
-DASH = '-'
-
-Methods = ( '__add__', '__sub__', '__mul__', '__div__', '__mod__', '__lshift__', '__rshift__', '__and__', '__xor__', '__or__')
-
-class Factory(object):
- def __init__(self, false_self, method_name):
- self.false_self = false_self
- self.method_name = method_name
-
- def __call__(self, val):
- xself = long(self.false_self)
- yself = int(self.false_self)
- xm = long.__getattribute__(xself, self.method_name)
- ym = mpw.__getattribute__(yself, self.method_name)
- xa = xm(long(val))
- ya = ym(int(val))
- print " Comparing", xa, ya
- assert xa == ya
- return xa
-
-class Long(long):
- def __getattribute__(self, name):
- print "__getattribute__ ~%s~" % name
- if name not in ('__add__', '__sub__'):
- return long.getattr(self, name)
- return Factory(self, name)
-
-#a1 = Bar(1)
-#a2 = Bar(2)
-#print a1.__add__(a2)
-#print "Done"
-#print a1 + a2
-
-#----------------------------------------------------------------------
-
-class BasicTestCase(unittest.TestCase):
- a = 0x0000000987654321L
- b = 0x0000000000000010L
- c = 0x0fedcba000000000L
- lo = 2
- hi = 200
- t = 10
-
- def setUp(self):
- mpw().Debug(0)
- pass
-
- def tearDown(self):
- mpw().Debug(0)
- pass
-
- #----------------------------------------
-
- def test01_SimpleMethods(self):
- if verbose:
- print '\n', '-=' * 30
- print "Running %s.test01_SimpleMethods..." % \
- self.__class__.__name__
- print "\ta:\t%s\t%s\t0x%x" % (type(self.a), self.a, self.a)
- print "\tb:\t%s\t%s\t0x%x" % (type(self.b), self.b, self.b)
- print "\tc:\t%s\t%s\t0x%x" % (type(self.c), self.c, self.c)
-
- wa = mpw(self.a)
- wb = mpw(self.b)
- wc = mpw(self.c)
-# xa - Long(self.a)
-# xb = Long(self.b)
-# xc = Long(self.c)
- za = long(self.a)
- zb = long(self.b)
- zc = long(self.c)
-
- print "__int__:\t", int(wb), "\t", int(zb)
- assert int(wb) == int(zb)
- print "__long__:\t", long(wa), "\t", long(za)
- assert long(wb) == long(zb)
- print "__float__:\t", float(wa), "\t", float(za)
- assert float(wb) == float(zb)
-
- zs = hex(za)
- print "__hex__:\t", hex(wa), "\t", zs
- assert hex(wa) == zs
- zs = oct(za)
- print "__oct__:\t", oct(wa), "\t", zs
- assert oct(wa) == zs
-
- print "__neg__:\t", (-wa), "\t", long(-za)
- print "__pos__:\t", (+wa), "\t", long(+za)
- print "__abs__:\t", abs(wa), "\t", long(abs(za))
- print "__invert__:\t", (~wa), "\t", long(~za)
-
- print "__add__:\t", (wa + wb), "\t", long(za + zb)
- print "__sub__:\t", (wa - wb), "\t", long(za - zb)
- print "__mul__:\t", (wa * wb), "\t", long(za * zb)
- print "__div__:\t", (wa / wb), "\t", long(za / zb)
- print "__mod__:\t", (wa % wb), "\t", long(za % zb)
-
- wq, wr = divmod(wa, wb)
- zq, zr = divmod(za, zb)
- print "__divmod__ q:\t", wq, "\t", long(zq)
- print "__divmod__ r:\t", wr, "\t", long(zr)
-
- print "__pow__:\t", (wb ** wb), "\t", long(zb ** zb)
-
- print "__lshift__:\t", (wa << wb), "\t", long(za << zb)
- print "__rshift__:\t", (wa >> wb), "\t", long(za >> zb)
- print "__and__:\t", (wa & wc), "\t", long(za & zc)
- print "__xor__:\t", (wa ^ wa), "\t", long(za ^ za)
- print "__or__:\t", (wa | wc), "\t", long(za | zc)
-
-# print mpw.__complex__(b)
-# print mpw.__coerce__(b, i)
-
- del wa
- del wb
- del wc
- del za
- del zb
- del zc
- pass
-
- #----------------------------------------
- def test02_CarryBorrow(self):
- if verbose:
- print '\n', '-=' * 30
- print "Running %s.test02_CarryBorrow..." % \
- self.__class__.__name__
- a = 0x7fffffff
- wa = -mpw(a); wa = wa+wa
- za = -long(a); za = za+za
- wb = -mpw(1)
- zb = -long(1)
- wc = mpw(1)
- zc = long(1)
- wd = mpw(a); wd = wd+wd
- zd = long(a); zd = zd+zd
- print "add --:\t", (wa+wa), "\t", (za+za)
- print "add -+:\t", (wb+wd), "\t", (zb+zd)
- print "add +-:\t", (wc+wa), "\t", (zc+za)
- print "add ++:\t", (wd+wd), "\t", (zd+zd)
- print "sub --:\t", (wb-wa), "\t", (zb-za)
-# print "sub -+:\t", (wb-wd), "\t", (zb-zd)
-# print "sub +-:\t", (wc-wa), "\t", (zc-za)
- print "sub ++:\t", (wc-wd), "\t", (zc-zd)
- pass
-
- #----------------------------------------
- def test03_Signs(self):
- if verbose:
- print '\n', '-=' * 30
- print "Running %s.test03_Signs..." % \
- self.__class__.__name__
- wpa = mpw(13)
- wma = -wpa
- wpb = wpa - 3
- wmb = -wpb
- zpa = long(13)
- zma = -zpa
- zpb = zpa - 3
- zmb = -zpb
- print "add --:\t", (wma+wmb), "\t", (zma+zmb)
- print "add -+:\t", (wma+wpb), "\t", (zma+zpb)
- print "add +-:\t", (wpa+wmb), "\t", (zpa+zmb)
- print "add ++:\t", (wpa+wpb), "\t", (zpa+zpb)
-
- print "sub --:\t", (wma-wmb), "\t", (zma-zmb)
- print "sub -+:\t", (wma-wpb), "\t", (zma-zpb)
- print "sub +-:\t", (wpa-wmb), "\t", (zpa-zmb)
- print "sub ++:\t", (wpa-wpb), "\t", (zpa-zpb)
- print "sub --:\t", (wmb-wma), "\t", (zmb-zma)
- print "sub -+:\t", (wmb-wpa), "\t", (zmb-zpa)
- print "sub +-:\t", (wpb-wma), "\t", (zpb-zma)
- print "sub ++:\t", (wpb-wpa), "\t", (zpb-zpa)
-
- print "mul --:\t", (wma*wmb), "\t", (zma*zmb)
- print "mul -+:\t", (wma*wpb), "\t", (zma*zpb)
- print "mul +-:\t", (wpa*wmb), "\t", (zpa*zmb)
- print "mul ++:\t", (wpa*wpb), "\t", (zpa*zpb)
-
- print "div --:\t", (wma/wmb), "\t", (zma/zmb)
- print "div -+:\t", (wma/wpb), "\t", (zma/zpb)
- print "div +-:\t", (wpa/wmb), "\t", (zpa/zmb)
- print "div ++:\t", (wpa/wpb), "\t", (zpa/zpb)
- print "div --:\t", (wmb/wma), "\t", (zmb/zma)
- print "div -+:\t", (wmb/wpa), "\t", (zmb/zpa)
- print "div +-:\t", (wpb/wma), "\t", (zpb/zma)
- print "div ++:\t", (wpb/wpa), "\t", (zpb/zpa)
-
- print "pow --:\t", (wma**wmb), "\t", (zma**zmb)
- print "pow -+:\t", (wma**wpb), "\t", (zma**zpb)
- print "pow +-:\t", (wpa**wmb), "\t", (zpa**zmb)
- print "pow ++:\t", (wpa**wpb), "\t", (zpa**zpb)
- print "pow --:\t", (wmb**wma), "\t", (zmb**zma)
- print "pow -+:\t", (wmb**wpa), "\t", (zmb**zpa)
- print "pow +-:\t", (wpb**wma), "\t", (zpb**zma)
- print "pow ++:\t", (wpb**wpa), "\t", (zpb**zpa)
-
-# wpa = mpw(13)
-# wma = -wpa
-# wpb = wpa - 3
-# wmb = -wpb
-# zpa = long(13)
-# zma = -zpa
-# zpb = zpa - 3
-# zmb = -zpb
- print "mod --:\t", (wma%wmb), "\t", (zma%zmb)
- print "mod -+:\t", (wma%wpb), "\t", (zma%zpb)
- print "mod +-:\t", (wpa%wmb), "\t", (zpa%zmb)
- print "mod ++:\t", (wpa%wpb), "\t", (zpa%zpb)
- print "mod --:\t", (wmb%wma), "\t", (zmb%zma)
- print "mod -+:\t", (wmb%wpa), "\t", (zmb%zpa)
- print "mod +-:\t", (wpb%wma), "\t", (zpb%zma)
- print "mod ++:\t", (wpb%wpa), "\t", (zpb%zpa)
-
- print "rem --:\t", divmod(wma, wmb), "\t", divmod(zma, zmb)
- print "rem -+:\t", divmod(wma, wpb), "\t", divmod(zma, zpb)
- print "rem +-:\t", divmod(wpa, wmb), "\t", divmod(zpa, zmb)
- print "rem ++:\t", divmod(wpa, wpb), "\t", divmod(zpa, zpb)
- print "rem --:\t", divmod(wmb, wma), "\t", divmod(zmb, zma)
- print "rem -+:\t", divmod(wmb, wpa), "\t", divmod(zmb, zpa)
- print "rem +-:\t", divmod(wpb, wma), "\t", divmod(zpb, zma)
- print "rem ++:\t", divmod(wpb, wpa), "\t", divmod(zpb, zpa)
- pass
-
- #----------------------------------------
- def test04_KnuthPoly(self):
- self.t = 8
- tfmt = "%o"
- if verbose:
- print '\n', '-=' * 30
- print "Running %s.test04_KnuthPoly..." % \
- self.__class__.__name__
- print "\t(%d**m - 1) * (%d**n - 1), m,n in [%d,%d)" % (self.t,self.t,self.lo,self.hi)
- tm1 = tfmt % (self.t - 1)
- tm2 = tfmt % (self.t - 2)
- for m in range(self.lo,self.hi):
- for n in range(m+1,self.hi+1):
- wt = mpw(self.t)
- wa = (wt**m - 1) * (wt**n - 1)
- ws = tfmt % long(wa)
- zs = tm1 * (m - 1) + tm2 + tm1 * (n - m) + "0" * (m - 1) + "1"
- if ws != zs:
- print "(%d**%d - 1) * (%d**%d - 1)\t%s" % (self.t,m,self.t,n,ws)
- assert ws == zs
-
- self.t = 10
- tfmt = "%d"
- if verbose:
- print "\t(%d**m - 1) * (%d**n - 1), m,n in [%d,%d)" % (self.t,self.t,self.lo,self.hi)
- tm1 = tfmt % (self.t - 1)
- tm2 = tfmt % (self.t - 2)
- for m in range(self.lo,self.hi):
- for n in range(m+1,self.hi+1):
- wt = mpw(self.t)
- wa = (wt**m - 1) * (wt**n - 1)
- ws = tfmt % long(wa)
- zs = tm1 * (m - 1) + tm2 + tm1 * (n - m) + "0" * (m - 1) + "1"
- if ws != zs:
- print "(%d**%d - 1) * (%d**%d - 1)\t%s" % (self.t,m,self.t,n,ws)
- assert ws == zs
-
- self.t = 16
- tfmt = "%x"
- if verbose:
- print "\t(%d**m - 1) * (%d**n - 1), m,n in [%d,%d)" % (self.t,self.t,self.lo,self.hi)
- tm1 = tfmt % (self.t - 1)
- tm2 = tfmt % (self.t - 2)
- for m in range(self.lo,self.hi):
- for n in range(m+1,self.hi+1):
- wt = mpw(self.t)
- wa = (wt**m - 1) * (wt**n - 1)
- ws = tfmt % long(wa)
- zs = tm1 * (m - 1) + tm2 + tm1 * (n - m) + "0" * (m - 1) + "1"
- if ws != zs:
- print "(%d**%d - 1) * (%d**%d - 1)\t%s" % (self.t,m,self.t,n,ws)
- assert ws == zs
- pass
-
- #----------------------------------------
- def test05_IterativePowers(self):
- if verbose:
- print '\n', '-=' * 30
- print "Running %s.test05_IterativePowers..." % \
- self.__class__.__name__
- print "\t(m**n)/(m**(n-1)) == m for m,n in [%d,%d)" % (self.lo,self.hi)
- for m in range(self.lo,self.hi):
- wa = mpw(m)
- wd = wa
- for n in range(self.lo,self.hi):
- wc = wa**n
- we = wc/wd
- if we != m:
- print m, '^', n, '=', we
- assert we == m
- if wc != 0:
- wd = wc
- pass
-
-#----------------------------------------------------------------------
-#----------------------------------------------------------------------
-
-def test_suite():
- suite = unittest.TestSuite()
-
- suite.addTest(unittest.makeSuite(BasicTestCase))
-
- return suite
-
-
-if __name__ == '__main__':
- unittest.main(defaultTest='test_suite')
+++ /dev/null
-#!/usr/bin/env python
-'''
-Python unit testing framework, based on Erich Gamma's JUnit and Kent Beck's
-Smalltalk testing framework.
-
-This module contains the core framework classes that form the basis of
-specific test cases and suites (TestCase, TestSuite etc.), and also a
-text-based utility class for running the tests and reporting the results
- (TextTestRunner).
-
-Simple usage:
-
- import unittest
-
- class IntegerArithmenticTestCase(unittest.TestCase):
- def testAdd(self): ## test method names begin 'test*'
- self.assertEquals((1 + 2), 3)
- self.assertEquals(0 + 1, 1)
- def testMultiply(self):
- self.assertEquals((0 * 10), 0)
- self.assertEquals((5 * 8), 40)
-
- if __name__ == '__main__':
- unittest.main()
-
-Further information is available in the bundled documentation, and from
-
- http://pyunit.sourceforge.net/
-
-Copyright (c) 1999, 2000, 2001 Steve Purcell
-This module is free software, and you may redistribute it and/or modify
-it under the same terms as Python itself, so long as this copyright message
-and disclaimer are retained in their original form.
-
-IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
-SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF
-THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGE.
-
-THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS,
-AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
-SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
-'''
-
-__author__ = "Steve Purcell"
-__email__ = "stephen_purcell at yahoo dot com"
-__version__ = "#Revision: 1.46 $"[11:-2]
-
-import time
-import sys
-import traceback
-import string
-import os
-import types
-
-##############################################################################
-# Test framework core
-##############################################################################
-
-# All classes defined herein are 'new-style' classes, allowing use of 'super()'
-__metaclass__ = type
-
-def _strclass(cls):
- return "%s.%s" % (cls.__module__, cls.__name__)
-
-class TestResult:
- """Holder for test result information.
-
- Test results are automatically managed by the TestCase and TestSuite
- classes, and do not need to be explicitly manipulated by writers of tests.
-
- Each instance holds the total number of tests run, and collections of
- failures and errors that occurred among those test runs. The collections
- contain tuples of (testcase, exceptioninfo), where exceptioninfo is the
- formatted traceback of the error that occurred.
- """
- def __init__(self):
- self.failures = []
- self.errors = []
- self.testsRun = 0
- self.shouldStop = 0
-
- def startTest(self, test):
- "Called when the given test is about to be run"
- self.testsRun = self.testsRun + 1
-
- def stopTest(self, test):
- "Called when the given test has been run"
- pass
-
- def addError(self, test, err):
- """Called when an error has occurred. 'err' is a tuple of values as
- returned by sys.exc_info().
- """
- self.errors.append((test, self._exc_info_to_string(err)))
-
- def addFailure(self, test, err):
- """Called when an error has occurred. 'err' is a tuple of values as
- returned by sys.exc_info()."""
- self.failures.append((test, self._exc_info_to_string(err)))
-
- def addSuccess(self, test):
- "Called when a test has completed successfully"
- pass
-
- def wasSuccessful(self):
- "Tells whether or not this result was a success"
- return len(self.failures) == len(self.errors) == 0
-
- def stop(self):
- "Indicates that the tests should be aborted"
- self.shouldStop = 1
-
- def _exc_info_to_string(self, err):
- """Converts a sys.exc_info()-style tuple of values into a string."""
- return string.join(traceback.format_exception(*err), '')
-
- def __repr__(self):
- return "<%s run=%i errors=%i failures=%i>" % \
- (_strclass(self.__class__), self.testsRun, len(self.errors),
- len(self.failures))
-
-
-class TestCase:
- """A class whose instances are single test cases.
-
- By default, the test code itself should be placed in a method named
- 'runTest'.
-
- If the fixture may be used for many test cases, create as
- many test methods as are needed. When instantiating such a TestCase
- subclass, specify in the constructor arguments the name of the test method
- that the instance is to execute.
-
- Test authors should subclass TestCase for their own tests. Construction
- and deconstruction of the test's environment ('fixture') can be
- implemented by overriding the 'setUp' and 'tearDown' methods respectively.
-
- If it is necessary to override the __init__ method, the base class
- __init__ method must always be called. It is important that subclasses
- should not change the signature of their __init__ method, since instances
- of the classes are instantiated automatically by parts of the framework
- in order to be run.
- """
-
- # This attribute determines which exception will be raised when
- # the instance's assertion methods fail; test methods raising this
- # exception will be deemed to have 'failed' rather than 'errored'
-
- failureException = AssertionError
-
- def __init__(self, methodName='runTest'):
- """Create an instance of the class that will use the named test
- method when executed. Raises a ValueError if the instance does
- not have a method with the specified name.
- """
- try:
- self.__testMethodName = methodName
- testMethod = getattr(self, methodName)
- self.__testMethodDoc = testMethod.__doc__
- except AttributeError:
- raise ValueError, "no such test method in %s: %s" % \
- (self.__class__, methodName)
-
- def setUp(self):
- "Hook method for setting up the test fixture before exercising it."
- pass
-
- def tearDown(self):
- "Hook method for deconstructing the test fixture after testing it."
- pass
-
- def countTestCases(self):
- return 1
-
- def defaultTestResult(self):
- return TestResult()
-
- def shortDescription(self):
- """Returns a one-line description of the test, or None if no
- description has been provided.
-
- The default implementation of this method returns the first line of
- the specified test method's docstring.
- """
- doc = self.__testMethodDoc
- return doc and string.strip(string.split(doc, "\n")[0]) or None
-
- def id(self):
- return "%s.%s" % (_strclass(self.__class__), self.__testMethodName)
-
- def __str__(self):
- return "%s (%s)" % (self.__testMethodName, _strclass(self.__class__))
-
- def __repr__(self):
- return "<%s testMethod=%s>" % \
- (_strclass(self.__class__), self.__testMethodName)
-
- def run(self, result=None):
- return self(result)
-
- def __call__(self, result=None):
- if result is None: result = self.defaultTestResult()
- result.startTest(self)
- testMethod = getattr(self, self.__testMethodName)
- try:
- try:
- self.setUp()
- except KeyboardInterrupt:
- raise
- except:
- result.addError(self, self.__exc_info())
- return
-
- ok = 0
- try:
- testMethod()
- ok = 1
- except self.failureException, e:
- result.addFailure(self, self.__exc_info())
- except KeyboardInterrupt:
- raise
- except:
- result.addError(self, self.__exc_info())
-
- try:
- self.tearDown()
- except KeyboardInterrupt:
- raise
- except:
- result.addError(self, self.__exc_info())
- ok = 0
- if ok: result.addSuccess(self)
- finally:
- result.stopTest(self)
-
- def debug(self):
- """Run the test without collecting errors in a TestResult"""
- self.setUp()
- getattr(self, self.__testMethodName)()
- self.tearDown()
-
- def __exc_info(self):
- """Return a version of sys.exc_info() with the traceback frame
- minimised; usually the top level of the traceback frame is not
- needed.
- """
- exctype, excvalue, tb = sys.exc_info()
- if sys.platform[:4] == 'java': ## tracebacks look different in Jython
- return (exctype, excvalue, tb)
- newtb = tb.tb_next
- if newtb is None:
- return (exctype, excvalue, tb)
- return (exctype, excvalue, newtb)
-
- def fail(self, msg=None):
- """Fail immediately, with the given message."""
- raise self.failureException, msg
-
- def failIf(self, expr, msg=None):
- "Fail the test if the expression is true."
- if expr: raise self.failureException, msg
-
- def failUnless(self, expr, msg=None):
- """Fail the test unless the expression is true."""
- if not expr: raise self.failureException, msg
-
- def failUnlessRaises(self, excClass, callableObj, *args, **kwargs):
- """Fail unless an exception of class excClass is thrown
- by callableObj when invoked with arguments args and keyword
- arguments kwargs. If a different type of exception is
- thrown, it will not be caught, and the test case will be
- deemed to have suffered an error, exactly as for an
- unexpected exception.
- """
- try:
- callableObj(*args, **kwargs)
- except excClass:
- return
- else:
- if hasattr(excClass,'__name__'): excName = excClass.__name__
- else: excName = str(excClass)
- raise self.failureException, excName
-
- def failUnlessEqual(self, first, second, msg=None):
- """Fail if the two objects are unequal as determined by the '=='
- operator.
- """
- if not first == second:
- raise self.failureException, \
- (msg or '%s != %s' % (`first`, `second`))
-
- def failIfEqual(self, first, second, msg=None):
- """Fail if the two objects are equal as determined by the '=='
- operator.
- """
- if first == second:
- raise self.failureException, \
- (msg or '%s == %s' % (`first`, `second`))
-
- def failUnlessAlmostEqual(self, first, second, places=7, msg=None):
- """Fail if the two objects are unequal as determined by their
- difference rounded to the given number of decimal places
- (default 7) and comparing to zero.
-
- Note that decimal places (from zero) is usually not the same
- as significant digits (measured from the most signficant digit).
- """
- if round(second-first, places) != 0:
- raise self.failureException, \
- (msg or '%s != %s within %s places' % (`first`, `second`, `places` ))
-
- def failIfAlmostEqual(self, first, second, places=7, msg=None):
- """Fail if the two objects are equal as determined by their
- difference rounded to the given number of decimal places
- (default 7) and comparing to zero.
-
- Note that decimal places (from zero) is usually not the same
- as significant digits (measured from the most signficant digit).
- """
- if round(second-first, places) == 0:
- raise self.failureException, \
- (msg or '%s == %s within %s places' % (`first`, `second`, `places`))
-
- assertEqual = assertEquals = failUnlessEqual
-
- assertNotEqual = assertNotEquals = failIfEqual
-
- assertAlmostEqual = assertAlmostEquals = failUnlessAlmostEqual
-
- assertNotAlmostEqual = assertNotAlmostEquals = failIfAlmostEqual
-
- assertRaises = failUnlessRaises
-
- assert_ = failUnless
-
-
-
-class TestSuite:
- """A test suite is a composite test consisting of a number of TestCases.
-
- For use, create an instance of TestSuite, then add test case instances.
- When all tests have been added, the suite can be passed to a test
- runner, such as TextTestRunner. It will run the individual test cases
- in the order in which they were added, aggregating the results. When
- subclassing, do not forget to call the base class constructor.
- """
- def __init__(self, tests=()):
- self._tests = []
- self.addTests(tests)
-
- def __repr__(self):
- return "<%s tests=%s>" % (_strclass(self.__class__), self._tests)
-
- __str__ = __repr__
-
- def countTestCases(self):
- cases = 0
- for test in self._tests:
- cases = cases + test.countTestCases()
- return cases
-
- def addTest(self, test):
- self._tests.append(test)
-
- def addTests(self, tests):
- for test in tests:
- self.addTest(test)
-
- def run(self, result):
- return self(result)
-
- def __call__(self, result):
- for test in self._tests:
- if result.shouldStop:
- break
- test(result)
- return result
-
- def debug(self):
- """Run the tests without collecting errors in a TestResult"""
- for test in self._tests: test.debug()
-
-
-class FunctionTestCase(TestCase):
- """A test case that wraps a test function.
-
- This is useful for slipping pre-existing test functions into the
- PyUnit framework. Optionally, set-up and tidy-up functions can be
- supplied. As with TestCase, the tidy-up ('tearDown') function will
- always be called if the set-up ('setUp') function ran successfully.
- """
-
- def __init__(self, testFunc, setUp=None, tearDown=None,
- description=None):
- TestCase.__init__(self)
- self.__setUpFunc = setUp
- self.__tearDownFunc = tearDown
- self.__testFunc = testFunc
- self.__description = description
-
- def setUp(self):
- if self.__setUpFunc is not None:
- self.__setUpFunc()
-
- def tearDown(self):
- if self.__tearDownFunc is not None:
- self.__tearDownFunc()
-
- def runTest(self):
- self.__testFunc()
-
- def id(self):
- return self.__testFunc.__name__
-
- def __str__(self):
- return "%s (%s)" % (_strclass(self.__class__), self.__testFunc.__name__)
-
- def __repr__(self):
- return "<%s testFunc=%s>" % (_strclass(self.__class__), self.__testFunc)
-
- def shortDescription(self):
- if self.__description is not None: return self.__description
- doc = self.__testFunc.__doc__
- return doc and string.strip(string.split(doc, "\n")[0]) or None
-
-
-
-##############################################################################
-# Locating and loading tests
-##############################################################################
-
-class TestLoader:
- """This class is responsible for loading tests according to various
- criteria and returning them wrapped in a Test
- """
- testMethodPrefix = 'test'
- sortTestMethodsUsing = cmp
- suiteClass = TestSuite
-
- def loadTestsFromTestCase(self, testCaseClass):
- """Return a suite of all tests cases contained in testCaseClass"""
- return self.suiteClass(map(testCaseClass,
- self.getTestCaseNames(testCaseClass)))
-
- def loadTestsFromModule(self, module):
- """Return a suite of all tests cases contained in the given module"""
- tests = []
- for name in dir(module):
- obj = getattr(module, name)
- if (isinstance(obj, (type, types.ClassType)) and
- issubclass(obj, TestCase)):
- tests.append(self.loadTestsFromTestCase(obj))
- return self.suiteClass(tests)
-
- def loadTestsFromName(self, name, module=None):
- """Return a suite of all tests cases given a string specifier.
-
- The name may resolve either to a module, a test case class, a
- test method within a test case class, or a callable object which
- returns a TestCase or TestSuite instance.
-
- The method optionally resolves the names relative to a given module.
- """
- parts = string.split(name, '.')
- if module is None:
- if not parts:
- raise ValueError, "incomplete test name: %s" % name
- else:
- parts_copy = parts[:]
- while parts_copy:
- try:
- module = __import__(string.join(parts_copy,'.'))
- break
- except ImportError:
- del parts_copy[-1]
- if not parts_copy: raise
- parts = parts[1:]
- obj = module
- for part in parts:
- obj = getattr(obj, part)
-
- import unittest
- if type(obj) == types.ModuleType:
- return self.loadTestsFromModule(obj)
- elif (isinstance(obj, (type, types.ClassType)) and
- issubclass(obj, unittest.TestCase)):
- return self.loadTestsFromTestCase(obj)
- elif type(obj) == types.UnboundMethodType:
- return obj.im_class(obj.__name__)
- elif callable(obj):
- test = obj()
- if not isinstance(test, unittest.TestCase) and \
- not isinstance(test, unittest.TestSuite):
- raise ValueError, \
- "calling %s returned %s, not a test" % (obj,test)
- return test
- else:
- raise ValueError, "don't know how to make test from: %s" % obj
-
- def loadTestsFromNames(self, names, module=None):
- """Return a suite of all tests cases found using the given sequence
- of string specifiers. See 'loadTestsFromName()'.
- """
- suites = []
- for name in names:
- suites.append(self.loadTestsFromName(name, module))
- return self.suiteClass(suites)
-
- def getTestCaseNames(self, testCaseClass):
- """Return a sorted sequence of method names found within testCaseClass
- """
- testFnNames = filter(lambda n,p=self.testMethodPrefix: n[:len(p)] == p,
- dir(testCaseClass))
- for baseclass in testCaseClass.__bases__:
- for testFnName in self.getTestCaseNames(baseclass):
- if testFnName not in testFnNames: # handle overridden methods
- testFnNames.append(testFnName)
- if self.sortTestMethodsUsing:
- testFnNames.sort(self.sortTestMethodsUsing)
- return testFnNames
-
-
-
-defaultTestLoader = TestLoader()
-
-
-##############################################################################
-# Patches for old functions: these functions should be considered obsolete
-##############################################################################
-
-def _makeLoader(prefix, sortUsing, suiteClass=None):
- loader = TestLoader()
- loader.sortTestMethodsUsing = sortUsing
- loader.testMethodPrefix = prefix
- if suiteClass: loader.suiteClass = suiteClass
- return loader
-
-def getTestCaseNames(testCaseClass, prefix, sortUsing=cmp):
- return _makeLoader(prefix, sortUsing).getTestCaseNames(testCaseClass)
-
-def makeSuite(testCaseClass, prefix='test', sortUsing=cmp, suiteClass=TestSuite):
- return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromTestCase(testCaseClass)
-
-def findTestCases(module, prefix='test', sortUsing=cmp, suiteClass=TestSuite):
- return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromModule(module)
-
-
-##############################################################################
-# Text UI
-##############################################################################
-
-class _WritelnDecorator:
- """Used to decorate file-like objects with a handy 'writeln' method"""
- def __init__(self,stream):
- self.stream = stream
-
- def __getattr__(self, attr):
- return getattr(self.stream,attr)
-
- def writeln(self, *args):
- if args: self.write(*args)
- self.write('\n') # text-mode streams translate to \r\n if needed
-
-
-class _TextTestResult(TestResult):
- """A test result class that can print formatted text results to a stream.
-
- Used by TextTestRunner.
- """
- separator1 = '=' * 70
- separator2 = '-' * 70
-
- def __init__(self, stream, descriptions, verbosity):
- TestResult.__init__(self)
- self.stream = stream
- self.showAll = verbosity > 1
- self.dots = verbosity == 1
- self.descriptions = descriptions
-
- def getDescription(self, test):
- if self.descriptions:
- return test.shortDescription() or str(test)
- else:
- return str(test)
-
- def startTest(self, test):
- TestResult.startTest(self, test)
- if self.showAll:
- self.stream.write(self.getDescription(test))
- self.stream.write(" ... ")
-
- def addSuccess(self, test):
- TestResult.addSuccess(self, test)
- if self.showAll:
- self.stream.writeln("ok")
- elif self.dots:
- self.stream.write('.')
-
- def addError(self, test, err):
- TestResult.addError(self, test, err)
- if self.showAll:
- self.stream.writeln("ERROR")
- elif self.dots:
- self.stream.write('E')
-
- def addFailure(self, test, err):
- TestResult.addFailure(self, test, err)
- if self.showAll:
- self.stream.writeln("FAIL")
- elif self.dots:
- self.stream.write('F')
-
- def printErrors(self):
- if self.dots or self.showAll:
- self.stream.writeln()
- self.printErrorList('ERROR', self.errors)
- self.printErrorList('FAIL', self.failures)
-
- def printErrorList(self, flavour, errors):
- for test, err in errors:
- self.stream.writeln(self.separator1)
- self.stream.writeln("%s: %s" % (flavour,self.getDescription(test)))
- self.stream.writeln(self.separator2)
- self.stream.writeln("%s" % err)
-
-
-class TextTestRunner:
- """A test runner class that displays results in textual form.
-
- It prints out the names of tests as they are run, errors as they
- occur, and a summary of the results at the end of the test run.
- """
- def __init__(self, stream=sys.stderr, descriptions=1, verbosity=1):
- self.stream = _WritelnDecorator(stream)
- self.descriptions = descriptions
- self.verbosity = verbosity
-
- def _makeResult(self):
- return _TextTestResult(self.stream, self.descriptions, self.verbosity)
-
- def run(self, test):
- "Run the given test case or test suite."
- result = self._makeResult()
- startTime = time.time()
- test(result)
- stopTime = time.time()
- timeTaken = float(stopTime - startTime)
- result.printErrors()
- self.stream.writeln(result.separator2)
- run = result.testsRun
- self.stream.writeln("Ran %d test%s in %.3fs" %
- (run, run != 1 and "s" or "", timeTaken))
- self.stream.writeln()
- if not result.wasSuccessful():
- self.stream.write("FAILED (")
- failed, errored = map(len, (result.failures, result.errors))
- if failed:
- self.stream.write("failures=%d" % failed)
- if errored:
- if failed: self.stream.write(", ")
- self.stream.write("errors=%d" % errored)
- self.stream.writeln(")")
- else:
- self.stream.writeln("OK")
- return result
-
-
-
-##############################################################################
-# Facilities for running tests from the command line
-##############################################################################
-
-class TestProgram:
- """A command-line program that runs a set of tests; this is primarily
- for making test modules conveniently executable.
- """
- USAGE = """\
-Usage: %(progName)s [options] [test] [...]
-
-Options:
- -h, --help Show this message
- -v, --verbose Verbose output
- -q, --quiet Minimal output
-
-Examples:
- %(progName)s - run default set of tests
- %(progName)s MyTestSuite - run suite 'MyTestSuite'
- %(progName)s MyTestCase.testSomething - run MyTestCase.testSomething
- %(progName)s MyTestCase - run all 'test*' test methods
- in MyTestCase
-"""
- def __init__(self, module='__main__', defaultTest=None,
- argv=None, testRunner=None, testLoader=defaultTestLoader):
- if type(module) == type(''):
- self.module = __import__(module)
- for part in string.split(module,'.')[1:]:
- self.module = getattr(self.module, part)
- else:
- self.module = module
- if argv is None:
- argv = sys.argv
- self.verbosity = 1
- self.defaultTest = defaultTest
- self.testRunner = testRunner
- self.testLoader = testLoader
- self.progName = os.path.basename(argv[0])
- self.parseArgs(argv)
- self.runTests()
-
- def usageExit(self, msg=None):
- if msg: print msg
- print self.USAGE % self.__dict__
- sys.exit(2)
-
- def parseArgs(self, argv):
- import getopt
- try:
- options, args = getopt.getopt(argv[1:], 'hHvq',
- ['help','verbose','quiet'])
- for opt, value in options:
- if opt in ('-h','-H','--help'):
- self.usageExit()
- if opt in ('-q','--quiet'):
- self.verbosity = 0
- if opt in ('-v','--verbose'):
- self.verbosity = 2
- if len(args) == 0 and self.defaultTest is None:
- self.test = self.testLoader.loadTestsFromModule(self.module)
- return
- if len(args) > 0:
- self.testNames = args
- else:
- self.testNames = (self.defaultTest,)
- self.createTests()
- except getopt.error, msg:
- self.usageExit(msg)
-
- def createTests(self):
- self.test = self.testLoader.loadTestsFromNames(self.testNames,
- self.module)
-
- def runTests(self):
- if self.testRunner is None:
- self.testRunner = TextTestRunner(verbosity=self.verbosity)
- result = self.testRunner.run(self.test)
- sys.exit(not result.wasSuccessful())
-
-main = TestProgram
-
-
-##############################################################################
-# Executing this module from the command line
-##############################################################################
-
-if __name__ == "__main__":
- main(module=None)
projects / platform / upstream / rpm.git / commitdiff