home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_286 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  10.0 KB  |  307 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import os
  6. import re
  7. import test_all
  8. from cStringIO import StringIO
  9. import unittest
  10. from test_all import db, dbshelve, test_support, get_new_environment_path, get_new_database_path
  11. lexical_cmp = cmp
  12.  
  13. def lowercase_cmp(left, right):
  14.     return cmp(left.lower(), right.lower())
  15.  
  16.  
  17. def make_reverse_comparator(cmp):
  18.     
  19.     def reverse(left, right, delegate = cmp):
  20.         return -delegate(left, right)
  21.  
  22.     return reverse
  23.  
  24. _expected_lexical_test_data = [
  25.     '',
  26.     'CCCP',
  27.     'a',
  28.     'aaa',
  29.     'b',
  30.     'c',
  31.     'cccce',
  32.     'ccccf']
  33. _expected_lowercase_test_data = [
  34.     '',
  35.     'a',
  36.     'aaa',
  37.     'b',
  38.     'c',
  39.     'CC',
  40.     'cccce',
  41.     'ccccf',
  42.     'CCCP']
  43.  
  44. class ComparatorTests(unittest.TestCase):
  45.     
  46.     def comparator_test_helper(self, comparator, expected_data):
  47.         data = expected_data[:]
  48.         import sys
  49.         if sys.version_info[0] < 3:
  50.             if sys.version_info[:3] < (2, 4, 0):
  51.                 data.sort(comparator)
  52.             else:
  53.                 data.sort(cmp = comparator)
  54.         else:
  55.             data2 = []
  56.             for i in data:
  57.                 for j, k in enumerate(data2):
  58.                     r = comparator(k, i)
  59.                     if r == 1:
  60.                         data2.insert(j, i)
  61.                         break
  62.                         continue
  63.                 
  64.             
  65.             data = data2
  66.         self.failUnless(data == expected_data, "comparator `%s' is not right: %s vs. %s" % (comparator, expected_data, data))
  67.  
  68.     
  69.     def test_lexical_comparator(self):
  70.         self.comparator_test_helper(lexical_cmp, _expected_lexical_test_data)
  71.  
  72.     
  73.     def test_reverse_lexical_comparator(self):
  74.         rev = _expected_lexical_test_data[:]
  75.         rev.reverse()
  76.         self.comparator_test_helper(make_reverse_comparator(lexical_cmp), rev)
  77.  
  78.     
  79.     def test_lowercase_comparator(self):
  80.         self.comparator_test_helper(lowercase_cmp, _expected_lowercase_test_data)
  81.  
  82.  
  83.  
  84. class AbstractBtreeKeyCompareTestCase(unittest.TestCase):
  85.     env = None
  86.     db = None
  87.     
  88.     def setUp(self):
  89.         self.filename = self.__class__.__name__ + '.db'
  90.         self.homeDir = get_new_environment_path()
  91.         env = db.DBEnv()
  92.         env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_THREAD)
  93.         self.env = env
  94.  
  95.     
  96.     def tearDown(self):
  97.         self.closeDB()
  98.         if self.env is not None:
  99.             self.env.close()
  100.             self.env = None
  101.         
  102.         test_support.rmtree(self.homeDir)
  103.  
  104.     
  105.     def addDataToDB(self, data):
  106.         i = 0
  107.         for item in data:
  108.             self.db.put(item, str(i))
  109.             i = i + 1
  110.         
  111.  
  112.     
  113.     def createDB(self, key_comparator):
  114.         self.db = db.DB(self.env)
  115.         self.setupDB(key_comparator)
  116.         self.db.open(self.filename, 'test', db.DB_BTREE, db.DB_CREATE)
  117.  
  118.     
  119.     def setupDB(self, key_comparator):
  120.         self.db.set_bt_compare(key_comparator)
  121.  
  122.     
  123.     def closeDB(self):
  124.         if self.db is not None:
  125.             self.db.close()
  126.             self.db = None
  127.         
  128.  
  129.     
  130.     def startTest(self):
  131.         pass
  132.  
  133.     
  134.     def finishTest(self, expected = None):
  135.         if expected is not None:
  136.             self.check_results(expected)
  137.         
  138.         self.closeDB()
  139.  
  140.     
  141.     def check_results(self, expected):
  142.         curs = self.db.cursor()
  143.         
  144.         try:
  145.             index = 0
  146.             rec = curs.first()
  147.             while rec:
  148.                 (key, ignore) = rec
  149.                 self.failUnless(index < len(expected), 'to many values returned from cursor')
  150.                 self.failUnless(expected[index] == key, "expected value `%s' at %d but got `%s'" % (expected[index], index, key))
  151.                 index = index + 1
  152.                 rec = curs.next()
  153.             self.failUnless(index == len(expected), 'not enough values returned from cursor')
  154.         finally:
  155.             curs.close()
  156.  
  157.  
  158.  
  159.  
  160. class BtreeKeyCompareTestCase(AbstractBtreeKeyCompareTestCase):
  161.     
  162.     def runCompareTest(self, comparator, data):
  163.         self.startTest()
  164.         self.createDB(comparator)
  165.         self.addDataToDB(data)
  166.         self.finishTest(data)
  167.  
  168.     
  169.     def test_lexical_ordering(self):
  170.         self.runCompareTest(lexical_cmp, _expected_lexical_test_data)
  171.  
  172.     
  173.     def test_reverse_lexical_ordering(self):
  174.         expected_rev_data = _expected_lexical_test_data[:]
  175.         expected_rev_data.reverse()
  176.         self.runCompareTest(make_reverse_comparator(lexical_cmp), expected_rev_data)
  177.  
  178.     
  179.     def test_compare_function_useless(self):
  180.         self.startTest()
  181.         
  182.         def socialist_comparator(l, r):
  183.             return 0
  184.  
  185.         self.createDB(socialist_comparator)
  186.         self.addDataToDB([
  187.             'b',
  188.             'a',
  189.             'd'])
  190.         self.finishTest([
  191.             'b'])
  192.  
  193.  
  194.  
  195. class BtreeExceptionsTestCase(AbstractBtreeKeyCompareTestCase):
  196.     
  197.     def test_raises_non_callable(self):
  198.         self.startTest()
  199.         self.assertRaises(TypeError, self.createDB, 'abc')
  200.         self.assertRaises(TypeError, self.createDB, None)
  201.         self.finishTest()
  202.  
  203.     
  204.     def test_set_bt_compare_with_function(self):
  205.         self.startTest()
  206.         self.createDB(lexical_cmp)
  207.         self.finishTest()
  208.  
  209.     
  210.     def check_results(self, results):
  211.         pass
  212.  
  213.     
  214.     def test_compare_function_incorrect(self):
  215.         self.startTest()
  216.         
  217.         def bad_comparator(l, r):
  218.             return 1
  219.  
  220.         self.assertRaises(TypeError, self.createDB, bad_comparator)
  221.         self.finishTest()
  222.  
  223.     
  224.     def verifyStderr(self, method, successRe):
  225.         stdErr = sys.stderr
  226.         sys.stderr = StringIO()
  227.         
  228.         try:
  229.             method()
  230.         finally:
  231.             temp = sys.stderr
  232.             sys.stderr = stdErr
  233.             errorOut = temp.getvalue()
  234.             if not successRe.search(errorOut):
  235.                 self.fail('unexpected stderr output:\n' + errorOut)
  236.             
  237.  
  238.  
  239.     
  240.     def _test_compare_function_exception(self):
  241.         self.startTest()
  242.         
  243.         def bad_comparator(l, r):
  244.             if l == r:
  245.                 return 0
  246.             raise RuntimeError, "i'm a naughty comparison function"
  247.  
  248.         self.createDB(bad_comparator)
  249.         self.addDataToDB([
  250.             'a',
  251.             'b',
  252.             'c'])
  253.         self.finishTest()
  254.  
  255.     
  256.     def test_compare_function_exception(self):
  257.         self.verifyStderr(self._test_compare_function_exception, re.compile('(^RuntimeError:.* naughty.*){2}', re.M | re.S))
  258.  
  259.     
  260.     def _test_compare_function_bad_return(self):
  261.         self.startTest()
  262.         
  263.         def bad_comparator(l, r):
  264.             if l == r:
  265.                 return 0
  266.             return l
  267.  
  268.         self.createDB(bad_comparator)
  269.         self.addDataToDB([
  270.             'a',
  271.             'b',
  272.             'c'])
  273.         self.finishTest()
  274.  
  275.     
  276.     def test_compare_function_bad_return(self):
  277.         self.verifyStderr(self._test_compare_function_bad_return, re.compile('(^TypeError:.* return an int.*){2}', re.M | re.S))
  278.  
  279.     
  280.     def test_cannot_assign_twice(self):
  281.         
  282.         def my_compare(a, b):
  283.             return 0
  284.  
  285.         self.startTest()
  286.         self.createDB(my_compare)
  287.         
  288.         try:
  289.             self.db.set_bt_compare(my_compare)
  290.             self.assert_(0, 'this set should fail')
  291.         except RuntimeError:
  292.             msg = None
  293.  
  294.  
  295.  
  296.  
  297. def test_suite():
  298.     res = unittest.TestSuite()
  299.     res.addTest(unittest.makeSuite(ComparatorTests))
  300.     res.addTest(unittest.makeSuite(BtreeExceptionsTestCase))
  301.     res.addTest(unittest.makeSuite(BtreeKeyCompareTestCase))
  302.     return res
  303.  
  304. if __name__ == '__main__':
  305.     unittest.main(defaultTest = 'suite')
  306.  
  307.