home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_300 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  6.5 KB  |  293 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import errno
  6. from pprint import pprint
  7. import unittest
  8. from test_all import db, test_support, verbose, get_new_environment_path, get_new_database_path
  9. letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
  10.  
  11. class SimpleRecnoTestCase(unittest.TestCase):
  12.     import sys
  13.     if sys.version_info[:3] < (2, 4, 0):
  14.         
  15.         def assertFalse(self, expr, msg = None):
  16.             self.failIf(expr, msg = msg)
  17.  
  18.     
  19.     
  20.     def setUp(self):
  21.         self.filename = get_new_database_path()
  22.         self.homeDir = None
  23.  
  24.     
  25.     def tearDown(self):
  26.         test_support.unlink(self.filename)
  27.         if self.homeDir:
  28.             test_support.rmtree(self.homeDir)
  29.         
  30.  
  31.     
  32.     def test01_basic(self):
  33.         d = db.DB()
  34.         get_returns_none = d.set_get_returns_none(2)
  35.         d.set_get_returns_none(get_returns_none)
  36.         d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
  37.         for x in letters:
  38.             recno = d.append(x * 60)
  39.             self.assertEqual(type(recno), type(0))
  40.             self.assert_(recno >= 1)
  41.             if verbose:
  42.                 print recno,
  43.                 continue
  44.         
  45.         if verbose:
  46.             print 
  47.         
  48.         stat = d.stat()
  49.         if verbose:
  50.             pprint(stat)
  51.         
  52.         for recno in range(1, len(d) + 1):
  53.             data = d[recno]
  54.             if verbose:
  55.                 print data
  56.             
  57.             self.assertEqual(type(data), type(''))
  58.             self.assertEqual(data, d.get(recno))
  59.         
  60.         
  61.         try:
  62.             data = d[0]
  63.         except db.DBInvalidArgError:
  64.             val = None
  65.             import sys
  66.             if sys.version_info[0] < 3:
  67.                 self.assertEqual(val[0], db.EINVAL)
  68.             else:
  69.                 self.assertEqual(val.args[0], db.EINVAL)
  70.             if verbose:
  71.                 print val
  72.             
  73.         except:
  74.             verbose
  75.  
  76.         self.fail('expected exception')
  77.         
  78.         try:
  79.             d.has_key(0)
  80.         except db.DBError:
  81.             val = None
  82.  
  83.         self.fail('has_key did not raise a proper exception')
  84.         
  85.         try:
  86.             data = d[100]
  87.         except KeyError:
  88.             pass
  89.  
  90.         self.fail('expected exception')
  91.         
  92.         try:
  93.             data = d.get(100)
  94.         except db.DBNotFoundError:
  95.             val = None
  96.             if get_returns_none:
  97.                 self.fail('unexpected exception')
  98.             
  99.         except:
  100.             get_returns_none
  101.  
  102.         self.assertEqual(data, None)
  103.         keys = d.keys()
  104.         if verbose:
  105.             print keys
  106.         
  107.         self.assertEqual(type(keys), type([]))
  108.         self.assertEqual(type(keys[0]), type(123))
  109.         self.assertEqual(len(keys), len(d))
  110.         items = d.items()
  111.         if verbose:
  112.             pprint(items)
  113.         
  114.         self.assertEqual(type(items), type([]))
  115.         self.assertEqual(type(items[0]), type(()))
  116.         self.assertEqual(len(items[0]), 2)
  117.         self.assertEqual(type(items[0][0]), type(123))
  118.         self.assertEqual(type(items[0][1]), type(''))
  119.         self.assertEqual(len(items), len(d))
  120.         self.assert_(d.has_key(25))
  121.         del d[25]
  122.         self.assertFalse(d.has_key(25))
  123.         d.delete(13)
  124.         self.assertFalse(d.has_key(13))
  125.         data = d.get_both(26, 'z' * 60)
  126.         self.assertEqual(data, 'z' * 60, 'was %r' % data)
  127.         if verbose:
  128.             print data
  129.         
  130.         fd = d.fd()
  131.         if verbose:
  132.             print fd
  133.         
  134.         c = d.cursor()
  135.         rec = c.first()
  136.         while rec:
  137.             if verbose:
  138.                 print rec
  139.             
  140.             rec = c.next()
  141.         c.set(50)
  142.         rec = c.current()
  143.         if verbose:
  144.             print rec
  145.         
  146.         c.put(-1, 'a replacement record', db.DB_CURRENT)
  147.         c.set(50)
  148.         rec = c.current()
  149.         self.assertEqual(rec, (50, 'a replacement record'))
  150.         if verbose:
  151.             print rec
  152.         
  153.         rec = c.set_range(30)
  154.         if verbose:
  155.             print rec
  156.         
  157.         rec = c.set_range(999999)
  158.         self.assertEqual(rec, None)
  159.         if verbose:
  160.             print rec
  161.         
  162.         c.close()
  163.         d.close()
  164.         d = db.DB()
  165.         d.open(self.filename)
  166.         c = d.cursor()
  167.         d[100] = 'way out there'
  168.         self.assertEqual(d[100], 'way out there')
  169.         
  170.         try:
  171.             data = d[99]
  172.         except KeyError:
  173.             pass
  174.  
  175.         self.fail('expected exception')
  176.         
  177.         try:
  178.             d.get(99)
  179.         except db.DBKeyEmptyError:
  180.             val = None
  181.             if get_returns_none:
  182.                 self.fail('unexpected DBKeyEmptyError exception')
  183.             else:
  184.                 self.assertEqual(val[0], db.DB_KEYEMPTY)
  185.                 if verbose:
  186.                     print val
  187.                 
  188.         except:
  189.             get_returns_none
  190.  
  191.         if not get_returns_none:
  192.             self.fail('expected exception')
  193.         
  194.         rec = c.set(40)
  195.         while rec:
  196.             if verbose:
  197.                 print rec
  198.             
  199.             rec = c.next()
  200.         c.close()
  201.         d.close()
  202.  
  203.     
  204.     def test02_WithSource(self):
  205.         homeDir = get_new_environment_path()
  206.         self.homeDir = homeDir
  207.         source = os.path.join(homeDir, 'test_recno.txt')
  208.         if not os.path.isdir(homeDir):
  209.             os.mkdir(homeDir)
  210.         
  211.         f = open(source, 'w')
  212.         f.close()
  213.         d = db.DB()
  214.         d.set_re_delim(10)
  215.         d.set_re_delim('\n')
  216.         d.set_re_source(source)
  217.         d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
  218.         data = 'The quick brown fox jumped over the lazy dog'.split()
  219.         for datum in data:
  220.             d.append(datum)
  221.         
  222.         d.sync()
  223.         d.close()
  224.         text = open(source, 'r').read()
  225.         text = text.strip()
  226.         if verbose:
  227.             print text
  228.             print data
  229.             print text.split('\n')
  230.         
  231.         self.assertEqual(text.split('\n'), data)
  232.         d = db.DB()
  233.         d.set_re_source(source)
  234.         d.open(self.filename, db.DB_RECNO)
  235.         d[3] = 'reddish-brown'
  236.         d[8] = 'comatose'
  237.         d.sync()
  238.         d.close()
  239.         text = open(source, 'r').read()
  240.         text = text.strip()
  241.         if verbose:
  242.             print text
  243.             print text.split('\n')
  244.         
  245.         self.assertEqual(text.split('\n'), 'The quick reddish-brown fox jumped over the comatose dog'.split())
  246.  
  247.     
  248.     def test03_FixedLength(self):
  249.         d = db.DB()
  250.         d.set_re_len(40)
  251.         d.set_re_pad('-')
  252.         d.set_re_pad(45)
  253.         d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
  254.         for x in letters:
  255.             d.append(x * 35)
  256.         
  257.         d.append('.' * 40)
  258.         
  259.         try:
  260.             d.append('bad' * 20)
  261.         except db.DBInvalidArgError:
  262.             val = None
  263.             import sys
  264.             if sys.version_info[0] < 3:
  265.                 self.assertEqual(val[0], db.EINVAL)
  266.             else:
  267.                 self.assertEqual(val.args[0], db.EINVAL)
  268.             if verbose:
  269.                 print val
  270.             
  271.         except:
  272.             verbose
  273.  
  274.         self.fail('expected exception')
  275.         c = d.cursor()
  276.         rec = c.first()
  277.         while rec:
  278.             if verbose:
  279.                 print rec
  280.             
  281.             rec = c.next()
  282.         c.close()
  283.         d.close()
  284.  
  285.  
  286.  
  287. def test_suite():
  288.     return unittest.makeSuite(SimpleRecnoTestCase)
  289.  
  290. if __name__ == '__main__':
  291.     unittest.main(defaultTest = 'test_suite')
  292.  
  293.