home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_290 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  12.4 KB  |  375 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import string
  6. import random
  7. import unittest
  8. from test_all import db, dbshelve, test_support, verbose, get_new_environment_path, get_new_database_path
  9.  
  10. class DataClass:
  11.     
  12.     def __init__(self):
  13.         self.value = random.random()
  14.  
  15.     
  16.     def __repr__(self):
  17.         return 'DataClass %f' % self.value
  18.  
  19.     
  20.     def __cmp__(self, other):
  21.         return cmp(self.value, other)
  22.  
  23.  
  24.  
  25. class DBShelveTestCase(unittest.TestCase):
  26.     
  27.     def setUp(self):
  28.         import sys
  29.         if sys.version_info[0] >= 3:
  30.             do_proxy_db_py3k = do_proxy_db_py3k
  31.             import test_all
  32.             self._flag_proxy_db_py3k = do_proxy_db_py3k(False)
  33.         
  34.         self.filename = get_new_database_path()
  35.         self.do_open()
  36.  
  37.     
  38.     def tearDown(self):
  39.         import sys
  40.         if sys.version_info[0] >= 3:
  41.             do_proxy_db_py3k = do_proxy_db_py3k
  42.             import test_all
  43.             do_proxy_db_py3k(self._flag_proxy_db_py3k)
  44.         
  45.         self.do_close()
  46.         test_support.unlink(self.filename)
  47.  
  48.     
  49.     def mk(self, key):
  50.         import sys
  51.         if sys.version_info[0] < 3:
  52.             return key
  53.         return bytes(key, 'iso8859-1')
  54.  
  55.     
  56.     def populateDB(self, d):
  57.         for x in string.letters:
  58.             d[self.mk('S' + x)] = 10 * x
  59.             d[self.mk('I' + x)] = ord(x)
  60.             d[self.mk('L' + x)] = [
  61.                 x] * 10
  62.             inst = DataClass()
  63.             inst.S = 10 * x
  64.             inst.I = ord(x)
  65.             inst.L = [
  66.                 x] * 10
  67.             d[self.mk('O' + x)] = inst
  68.         
  69.  
  70.     
  71.     def do_open(self):
  72.         self.d = dbshelve.open(self.filename)
  73.  
  74.     
  75.     def do_close(self):
  76.         self.d.close()
  77.  
  78.     
  79.     def test01_basics(self):
  80.         if verbose:
  81.             print '\n', '-=' * 30
  82.             print 'Running %s.test01_basics...' % self.__class__.__name__
  83.         
  84.         self.populateDB(self.d)
  85.         self.d.sync()
  86.         self.do_close()
  87.         self.do_open()
  88.         d = self.d
  89.         l = len(d)
  90.         k = d.keys()
  91.         s = d.stat()
  92.         f = d.fd()
  93.         if verbose:
  94.             print 'length:', l
  95.             print 'keys:', k
  96.             print 'stats:', s
  97.         
  98.         self.assertEqual(0, d.has_key(self.mk('bad key')))
  99.         self.assertEqual(1, d.has_key(self.mk('IA')))
  100.         self.assertEqual(1, d.has_key(self.mk('OA')))
  101.         d.delete(self.mk('IA'))
  102.         del d[self.mk('OA')]
  103.         self.assertEqual(0, d.has_key(self.mk('IA')))
  104.         self.assertEqual(0, d.has_key(self.mk('OA')))
  105.         self.assertEqual(len(d), l - 2)
  106.         values = []
  107.         for key in d.keys():
  108.             value = d[key]
  109.             values.append(value)
  110.             if verbose:
  111.                 print '%s: %s' % (key, value)
  112.             
  113.             self.checkrec(key, value)
  114.         
  115.         dbvalues = d.values()
  116.         self.assertEqual(len(dbvalues), len(d.keys()))
  117.         import sys
  118.         if sys.version_info[0] < 3:
  119.             values.sort()
  120.             dbvalues.sort()
  121.             self.assertEqual(values, dbvalues)
  122.         else:
  123.             values.sort(key = (lambda x: str(x)))
  124.             dbvalues.sort(key = (lambda x: str(x)))
  125.             self.assertEqual(repr(values), repr(dbvalues))
  126.         items = d.items()
  127.         self.assertEqual(len(items), len(values))
  128.         for key, value in items:
  129.             self.checkrec(key, value)
  130.         
  131.         self.assertEqual(d.get(self.mk('bad key')), None)
  132.         self.assertEqual(d.get(self.mk('bad key'), None), None)
  133.         self.assertEqual(d.get(self.mk('bad key'), 'a string'), 'a string')
  134.         self.assertEqual(d.get(self.mk('bad key'), [
  135.             1,
  136.             2,
  137.             3]), [
  138.             1,
  139.             2,
  140.             3])
  141.         d.set_get_returns_none(0)
  142.         self.assertRaises(db.DBNotFoundError, d.get, self.mk('bad key'))
  143.         d.set_get_returns_none(1)
  144.         d.put(self.mk('new key'), 'new data')
  145.         self.assertEqual(d.get(self.mk('new key')), 'new data')
  146.         self.assertEqual(d[self.mk('new key')], 'new data')
  147.  
  148.     
  149.     def test02_cursors(self):
  150.         if verbose:
  151.             print '\n', '-=' * 30
  152.             print 'Running %s.test02_cursors...' % self.__class__.__name__
  153.         
  154.         self.populateDB(self.d)
  155.         d = self.d
  156.         count = 0
  157.         c = d.cursor()
  158.         rec = c.first()
  159.         while rec is not None:
  160.             count = count + 1
  161.             if verbose:
  162.                 print rec
  163.             
  164.             (key, value) = rec
  165.             self.checkrec(key, value)
  166.             rec = getattr(c, 'next')()
  167.         del c
  168.         self.assertEqual(count, len(d))
  169.         count = 0
  170.         c = d.cursor()
  171.         rec = c.last()
  172.         while rec is not None:
  173.             count = count + 1
  174.             if verbose:
  175.                 print rec
  176.             
  177.             (key, value) = rec
  178.             self.checkrec(key, value)
  179.             rec = c.prev()
  180.         self.assertEqual(count, len(d))
  181.         c.set(self.mk('SS'))
  182.         (key, value) = c.current()
  183.         self.checkrec(key, value)
  184.         del c
  185.  
  186.     
  187.     def test03_append(self):
  188.         if verbose:
  189.             print '\n', '-=' * 30
  190.             print 'Running %s.test03_append...' % self.__class__.__name__
  191.         
  192.         self.assertRaises(dbshelve.DBShelveError, self.d.append, 'unit test was here')
  193.  
  194.     
  195.     def checkrec(self, key, value):
  196.         import sys
  197.         if sys.version_info[0] >= 3:
  198.             if isinstance(key, bytes):
  199.                 key = key.decode('iso8859-1')
  200.             
  201.         
  202.         x = key[1]
  203.         if key[0] == 'S':
  204.             self.assertEqual(type(value), str)
  205.             self.assertEqual(value, 10 * x)
  206.         elif key[0] == 'I':
  207.             self.assertEqual(type(value), int)
  208.             self.assertEqual(value, ord(x))
  209.         elif key[0] == 'L':
  210.             self.assertEqual(type(value), list)
  211.             self.assertEqual(value, [
  212.                 x] * 10)
  213.         elif key[0] == 'O':
  214.             import sys
  215.             if sys.version_info[0] < 3:
  216.                 InstanceType = InstanceType
  217.                 import types
  218.                 self.assertEqual(type(value), InstanceType)
  219.             else:
  220.                 self.assertEqual(type(value), DataClass)
  221.             self.assertEqual(value.S, 10 * x)
  222.             self.assertEqual(value.I, ord(x))
  223.             self.assertEqual(value.L, [
  224.                 x] * 10)
  225.         else:
  226.             self.assert_(0, 'Unknown key type, fix the test')
  227.  
  228.  
  229.  
  230. class BasicShelveTestCase(DBShelveTestCase):
  231.     
  232.     def do_open(self):
  233.         self.d = dbshelve.DBShelf()
  234.         self.d.open(self.filename, self.dbtype, self.dbflags)
  235.  
  236.     
  237.     def do_close(self):
  238.         self.d.close()
  239.  
  240.  
  241.  
  242. class BTreeShelveTestCase(BasicShelveTestCase):
  243.     dbtype = db.DB_BTREE
  244.     dbflags = db.DB_CREATE
  245.  
  246.  
  247. class HashShelveTestCase(BasicShelveTestCase):
  248.     dbtype = db.DB_HASH
  249.     dbflags = db.DB_CREATE
  250.  
  251.  
  252. class ThreadBTreeShelveTestCase(BasicShelveTestCase):
  253.     dbtype = db.DB_BTREE
  254.     dbflags = db.DB_CREATE | db.DB_THREAD
  255.  
  256.  
  257. class ThreadHashShelveTestCase(BasicShelveTestCase):
  258.     dbtype = db.DB_HASH
  259.     dbflags = db.DB_CREATE | db.DB_THREAD
  260.  
  261.  
  262. class BasicEnvShelveTestCase(DBShelveTestCase):
  263.     
  264.     def do_open(self):
  265.         self.env = db.DBEnv()
  266.         self.env.open(self.homeDir, self.envflags | db.DB_INIT_MPOOL | db.DB_CREATE)
  267.         self.filename = os.path.split(self.filename)[1]
  268.         self.d = dbshelve.DBShelf(self.env)
  269.         self.d.open(self.filename, self.dbtype, self.dbflags)
  270.  
  271.     
  272.     def do_close(self):
  273.         self.d.close()
  274.         self.env.close()
  275.  
  276.     
  277.     def setUp(self):
  278.         self.homeDir = get_new_environment_path()
  279.         DBShelveTestCase.setUp(self)
  280.  
  281.     
  282.     def tearDown(self):
  283.         import sys
  284.         if sys.version_info[0] >= 3:
  285.             do_proxy_db_py3k = do_proxy_db_py3k
  286.             import test_all
  287.             do_proxy_db_py3k(self._flag_proxy_db_py3k)
  288.         
  289.         self.do_close()
  290.         test_support.rmtree(self.homeDir)
  291.  
  292.  
  293.  
  294. class EnvBTreeShelveTestCase(BasicEnvShelveTestCase):
  295.     envflags = 0
  296.     dbtype = db.DB_BTREE
  297.     dbflags = db.DB_CREATE
  298.  
  299.  
  300. class EnvHashShelveTestCase(BasicEnvShelveTestCase):
  301.     envflags = 0
  302.     dbtype = db.DB_HASH
  303.     dbflags = db.DB_CREATE
  304.  
  305.  
  306. class EnvThreadBTreeShelveTestCase(BasicEnvShelveTestCase):
  307.     envflags = db.DB_THREAD
  308.     dbtype = db.DB_BTREE
  309.     dbflags = db.DB_CREATE | db.DB_THREAD
  310.  
  311.  
  312. class EnvThreadHashShelveTestCase(BasicEnvShelveTestCase):
  313.     envflags = db.DB_THREAD
  314.     dbtype = db.DB_HASH
  315.     dbflags = db.DB_CREATE | db.DB_THREAD
  316.  
  317.  
  318. class RecNoShelveTestCase(BasicShelveTestCase):
  319.     dbtype = db.DB_RECNO
  320.     dbflags = db.DB_CREATE
  321.     
  322.     def setUp(self):
  323.         BasicShelveTestCase.setUp(self)
  324.         self.key_pool = list(range(1, 5000))
  325.         self.key_map = { }
  326.         self.intkey_map = { }
  327.  
  328.     
  329.     def mk(self, key):
  330.         if key not in self.key_map:
  331.             self.key_map[key] = self.key_pool.pop(0)
  332.             self.intkey_map[self.key_map[key]] = key
  333.         
  334.         return self.key_map[key]
  335.  
  336.     
  337.     def checkrec(self, intkey, value):
  338.         key = self.intkey_map[intkey]
  339.         BasicShelveTestCase.checkrec(self, key, value)
  340.  
  341.     
  342.     def test03_append(self):
  343.         if verbose:
  344.             print '\n', '-=' * 30
  345.             print 'Running %s.test03_append...' % self.__class__.__name__
  346.         
  347.         self.d[1] = 'spam'
  348.         self.d[5] = 'eggs'
  349.         self.assertEqual(6, self.d.append('spam'))
  350.         self.assertEqual(7, self.d.append('baked beans'))
  351.         self.assertEqual('spam', self.d.get(6))
  352.         self.assertEqual('spam', self.d.get(1))
  353.         self.assertEqual('baked beans', self.d.get(7))
  354.         self.assertEqual('eggs', self.d.get(5))
  355.  
  356.  
  357.  
  358. def test_suite():
  359.     suite = unittest.TestSuite()
  360.     suite.addTest(unittest.makeSuite(DBShelveTestCase))
  361.     suite.addTest(unittest.makeSuite(BTreeShelveTestCase))
  362.     suite.addTest(unittest.makeSuite(HashShelveTestCase))
  363.     suite.addTest(unittest.makeSuite(ThreadBTreeShelveTestCase))
  364.     suite.addTest(unittest.makeSuite(ThreadHashShelveTestCase))
  365.     suite.addTest(unittest.makeSuite(EnvBTreeShelveTestCase))
  366.     suite.addTest(unittest.makeSuite(EnvHashShelveTestCase))
  367.     suite.addTest(unittest.makeSuite(EnvThreadBTreeShelveTestCase))
  368.     suite.addTest(unittest.makeSuite(EnvThreadHashShelveTestCase))
  369.     suite.addTest(unittest.makeSuite(RecNoShelveTestCase))
  370.     return suite
  371.  
  372. if __name__ == '__main__':
  373.     unittest.main(defaultTest = 'test_suite')
  374.  
  375.