From: Paul Nasrat Date: Wed, 14 Mar 2007 15:52:12 +0000 (+0000) Subject: Cleanup: Remove old mpw references X-Git-Tag: rpm-4.4.2.1-rc1~127 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=160025c3b921831809f92b8aa51d2d4146d9ce5f;p=platform%2Fupstream%2Frpm.git Cleanup: Remove old mpw references --- diff --git a/python/mpw/.cvsignore b/python/mpw/.cvsignore deleted file mode 100644 index 12664c7..0000000 --- a/python/mpw/.cvsignore +++ /dev/null @@ -1,3 +0,0 @@ -Makefile -Makefile.in -*.pyc diff --git a/python/mpw/Makefile.am b/python/mpw/Makefile.am deleted file mode 100644 index 3589062..0000000 --- a/python/mpw/Makefile.am +++ /dev/null @@ -1,5 +0,0 @@ -# Makefile for rpm library. - -AUTOMAKE_OPTIONS = 1.4 foreign - -SUBDIRS = test diff --git a/python/mpw/test/.cvsignore b/python/mpw/test/.cvsignore deleted file mode 100644 index 12664c7..0000000 --- a/python/mpw/test/.cvsignore +++ /dev/null @@ -1,3 +0,0 @@ -Makefile -Makefile.in -*.pyc diff --git a/python/mpw/test/Makefile.am b/python/mpw/test/Makefile.am deleted file mode 100644 index 7594341..0000000 --- a/python/mpw/test/Makefile.am +++ /dev/null @@ -1,14 +0,0 @@ -# Makefile for rpm library. - -AUTOMAKE_OPTIONS = 1.4 foreign - -VALGRIND = # valgrind --verbose --leak-check=yes - -EXTRA_DIST = \ - test_all.py test_methods.py \ - unittest.py - -all: - -check: - $(VALGRIND) python test_all.py verbose diff --git a/python/mpw/test/test_all.py b/python/mpw/test/test_all.py deleted file mode 100644 index 7690d4e..0000000 --- a/python/mpw/test/test_all.py +++ /dev/null @@ -1,59 +0,0 @@ -"""Run all test cases. -""" - -import sys -import os -import unittest - -verbose = 0 -if 'verbose' in sys.argv: - verbose = 1 - sys.argv.remove('verbose') - -if 'silent' in sys.argv: # take care of old flag, just in case - verbose = 0 - sys.argv.remove('silent') - - -def print_versions(): - from rpm import mpw - print - print '-=' * 38 - print 'python version: %s' % sys.version - print 'My pid: %s' % os.getpid() - print '-=' * 38 - - -class PrintInfoFakeTest(unittest.TestCase): - def testPrintVersions(self): - print_versions() - - -# This little hack is for when this module is run as main and all the -# other modules import it so they will still be able to get the right -# verbose setting. It's confusing but it works. -import test_all -test_all.verbose = verbose - - -def suite(): - test_modules = [ - 'test_methods', - ] - - alltests = unittest.TestSuite() - for name in test_modules: - module = __import__(name) - alltests.addTest(module.test_suite()) - return alltests - - -def test_suite(): - suite = unittest.TestSuite() - suite.addTest(unittest.makeSuite(PrintInfoFakeTest)) - return suite - - -if __name__ == '__main__': - print_versions() - unittest.main(defaultTest='suite') diff --git a/python/mpw/test/test_methods.py b/python/mpw/test/test_methods.py deleted file mode 100644 index e9c1c14..0000000 --- a/python/mpw/test/test_methods.py +++ /dev/null @@ -1,322 +0,0 @@ -""" -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') diff --git a/python/mpw/test/unittest.py b/python/mpw/test/unittest.py deleted file mode 100644 index d31e251..0000000 --- a/python/mpw/test/unittest.py +++ /dev/null @@ -1,759 +0,0 @@ -#!/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) diff --git a/python/pow.py b/python/pow.py deleted file mode 100644 index c641f27..0000000 --- a/python/pow.py +++ /dev/null @@ -1,8 +0,0 @@ -import rpm - -#rpm.mpw().Debug(-1); -for i in range(100): - a = rpm.mpw(i) - for j in range(100): - c = a**j - print i, '^', j, '=', c diff --git a/python/rng.py b/python/rng.py deleted file mode 100644 index 1796ada..0000000 --- a/python/rng.py +++ /dev/null @@ -1,23 +0,0 @@ -import rpm - -rpm.rng().Debug(1); -#rpm.mpw().Debug(-1); - -# Generate random intergers -r = rpm.rng() -for i in range(100): - print r.next() - -# Generate random numbers with lots of bits -m = rpm.mpw("800000000000000000000000000000000000000000000000000000000000000000000000") -for i in range(100): - r.next(m) - -# Generate 160 bit random primes -bits = 160 -trials = -1 -a = r.prime(bits, trials) -for i in range(100): - b = r.prime(bits, trials) - print a.gcd(a,b) - a = b diff --git a/python/rpmrng-py.h b/python/rpmrng-py.h deleted file mode 100644 index 14c60e6..0000000 --- a/python/rpmrng-py.h +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef H_RPMRNG_PY -#define H_RPMRNG_PY - -#include "rpmio_internal.h" - -/** \ingroup py_c - * \file python/rpmrng-py.h - */ - -/** - */ -typedef struct rngObject_s { - PyObject_HEAD - PyObject *md_dict; /*!< to look like PyModuleObject */ - randomGeneratorContext rngc; - mpbarrett b; -} rngObject; - -/** - */ -/*@unchecked@*/ -extern PyTypeObject rng_Type; -#define is_rng(o) ((o)->ob_type == &rng_Type) - -#endif diff --git a/python/sub.py b/python/sub.py deleted file mode 100644 index e4230cb..0000000 --- a/python/sub.py +++ /dev/null @@ -1,53 +0,0 @@ -import rpm - -rpm.mpw().Debug(1) - -Methods = ( '__neg__', '__pos__', '__abs__', '__invert__', '__add__', '__sub__', '__mul__', '__div__', '__mod__', '__divmod__', '__pow__', '__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 = rpm.mpw(self.false_self) - xm = long.__getattribute__(xself, self.method_name) - ym = rpm.mpw.__getattribute__(yself, self.method_name) - xa = xm(long(val)) - ya = ym(rpm.mpw(val)) - print " Comparing", self.method_name, type(xa), xa, type(ya), ya - assert xa == ya - return xa - -class Long(long): - def __getattribute__(self, name): - print "__getattribute__ ~%s~" % name - if name not in Methods: - return long.getattr(self, name) - return Factory(self, name) - -a1 = Long(0x987654321) -a2 = Long(0x10) -a3 = Long(0x0fedcba000000000) - -#print a1.__neg__() -#print a1.__pos__() -#print a1.__abs__() -#print a1.__invert__() - -print a1.__add__(a2) -print a1.__sub__(a2) -print a1.__mul__(a2) -print a1.__div__(a2) -print a1.__mod__(a2) - -#print a1.__divmod(a2) - -print a1.__pow__(a2) - -print a1.__lshift__(a2) -print a1.__rshift__(a2) -print a1.__and__(a3) -print a1.__xor__(a3) -print a1.__or__(a3)