home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / test_recno.py < prev    next >
Encoding:
Python Source  |  2003-12-30  |  6.4 KB  |  266 lines
  1. """TestCases for exercising a Recno DB.
  2. """
  3.  
  4. import os
  5. import sys
  6. import errno
  7. import tempfile
  8. from pprint import pprint
  9. import unittest
  10.  
  11. from test_all import verbose
  12.  
  13. try:
  14.     # For Python 2.3
  15.     from bsddb import db
  16. except ImportError:
  17.     # For earlier Pythons w/distutils pybsddb
  18.     from bsddb3 import db
  19.  
  20. letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
  21.  
  22.  
  23. #----------------------------------------------------------------------
  24.  
  25. class SimpleRecnoTestCase(unittest.TestCase):
  26.     def setUp(self):
  27.         self.filename = tempfile.mktemp()
  28.  
  29.     def tearDown(self):
  30.         try:
  31.             os.remove(self.filename)
  32.         except OSError, e:
  33.             if e.errno <> errno.EEXIST: raise
  34.  
  35.     def test01_basic(self):
  36.         d = db.DB()
  37.         d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
  38.  
  39.         for x in letters:
  40.             recno = d.append(x * 60)
  41.             assert type(recno) == type(0)
  42.             assert recno >= 1
  43.             if verbose:
  44.                 print recno,
  45.  
  46.         if verbose: 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.             assert type(data) == type("")
  58.             assert data == d.get(recno)
  59.  
  60.         try:
  61.             data = d[0]  # This should raise a KeyError!?!?!
  62.         except db.DBInvalidArgError, val:
  63.             assert val[0] == db.EINVAL
  64.             if verbose: print val
  65.         else:
  66.             self.fail("expected exception")
  67.  
  68.         try:
  69.             data = d[100]
  70.         except KeyError:
  71.             pass
  72.         else:
  73.             self.fail("expected exception")
  74.  
  75.         data = d.get(100)
  76.         assert data == None
  77.  
  78.         keys = d.keys()
  79.         if verbose:
  80.             print keys
  81.         assert type(keys) == type([])
  82.         assert type(keys[0]) == type(123)
  83.         assert len(keys) == len(d)
  84.  
  85.         items = d.items()
  86.         if verbose:
  87.             pprint(items)
  88.         assert type(items) == type([])
  89.         assert type(items[0]) == type(())
  90.         assert len(items[0]) == 2
  91.         assert type(items[0][0]) == type(123)
  92.         assert type(items[0][1]) == type("")
  93.         assert len(items) == len(d)
  94.  
  95.         assert d.has_key(25)
  96.  
  97.         del d[25]
  98.         assert not d.has_key(25)
  99.  
  100.         d.delete(13)
  101.         assert not d.has_key(13)
  102.  
  103.         data = d.get_both(26, "z" * 60)
  104.         assert data == "z" * 60
  105.         if verbose:
  106.             print data
  107.  
  108.         fd = d.fd()
  109.         if verbose:
  110.             print fd
  111.  
  112.         c = d.cursor()
  113.         rec = c.first()
  114.         while rec:
  115.             if verbose:
  116.                 print rec
  117.             rec = c.next()
  118.  
  119.         c.set(50)
  120.         rec = c.current()
  121.         if verbose:
  122.             print rec
  123.  
  124.         c.put(-1, "a replacement record", db.DB_CURRENT)
  125.  
  126.         c.set(50)
  127.         rec = c.current()
  128.         assert rec == (50, "a replacement record")
  129.         if verbose:
  130.             print rec
  131.  
  132.         rec = c.set_range(30)
  133.         if verbose:
  134.             print rec
  135.  
  136.         c.close()
  137.         d.close()
  138.  
  139.         d = db.DB()
  140.         d.open(self.filename)
  141.         c = d.cursor()
  142.  
  143.         # put a record beyond the consecutive end of the recno's
  144.         d[100] = "way out there"
  145.         assert d[100] == "way out there"
  146.  
  147.         try:
  148.             data = d[99]
  149.         except KeyError:
  150.             pass
  151.         else:
  152.             self.fail("expected exception")
  153.  
  154.         try:
  155.             d.get(99)
  156.         except db.DBKeyEmptyError, val:
  157.             assert val[0] == db.DB_KEYEMPTY
  158.             if verbose: print val
  159.         else:
  160.             self.fail("expected exception")
  161.  
  162.         rec = c.set(40)
  163.         while rec:
  164.             if verbose:
  165.                 print rec
  166.             rec = c.next()
  167.  
  168.         c.close()
  169.         d.close()
  170.  
  171.     def test02_WithSource(self):
  172.         """
  173.         A Recno file that is given a "backing source file" is essentially a
  174.         simple ASCII file.  Normally each record is delimited by \n and so is
  175.         just a line in the file, but you can set a different record delimiter
  176.         if needed.
  177.         """
  178.         source = os.path.join(os.path.dirname(sys.argv[0]),
  179.                               'db_home/test_recno.txt')
  180.         f = open(source, 'w') # create the file
  181.         f.close()
  182.  
  183.         d = db.DB()
  184.         # This is the default value, just checking if both int
  185.         d.set_re_delim(0x0A)
  186.         d.set_re_delim('\n')  # and char can be used...
  187.         d.set_re_source(source)
  188.         d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
  189.  
  190.         data = "The quick brown fox jumped over the lazy dog".split()
  191.         for datum in data:
  192.             d.append(datum)
  193.         d.sync()
  194.         d.close()
  195.  
  196.         # get the text from the backing source
  197.         text = open(source, 'r').read()
  198.         text = text.strip()
  199.         if verbose:
  200.             print text
  201.             print data
  202.             print text.split('\n')
  203.  
  204.         assert text.split('\n') == data
  205.  
  206.         # open as a DB again
  207.         d = db.DB()
  208.         d.set_re_source(source)
  209.         d.open(self.filename, db.DB_RECNO)
  210.  
  211.         d[3] = 'reddish-brown'
  212.         d[8] = 'comatose'
  213.  
  214.         d.sync()
  215.         d.close()
  216.  
  217.         text = open(source, 'r').read()
  218.         text = text.strip()
  219.         if verbose:
  220.             print text
  221.             print text.split('\n')
  222.  
  223.         assert text.split('\n') == \
  224.              "The quick reddish-brown fox jumped over the comatose dog".split()
  225.  
  226.     def test03_FixedLength(self):
  227.         d = db.DB()
  228.         d.set_re_len(40)  # fixed length records, 40 bytes long
  229.         d.set_re_pad('-') # sets the pad character...
  230.         d.set_re_pad(45)  # ...test both int and char
  231.         d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
  232.  
  233.         for x in letters:
  234.             d.append(x * 35)    # These will be padded
  235.  
  236.         d.append('.' * 40)      # this one will be exact
  237.  
  238.         try:                    # this one will fail
  239.             d.append('bad' * 20)
  240.         except db.DBInvalidArgError, val:
  241.             assert val[0] == db.EINVAL
  242.             if verbose: print val
  243.         else:
  244.             self.fail("expected exception")
  245.  
  246.         c = d.cursor()
  247.         rec = c.first()
  248.         while rec:
  249.             if verbose:
  250.                 print rec
  251.             rec = c.next()
  252.  
  253.         c.close()
  254.         d.close()
  255.  
  256.  
  257. #----------------------------------------------------------------------
  258.  
  259.  
  260. def test_suite():
  261.     return unittest.makeSuite(SimpleRecnoTestCase)
  262.  
  263.  
  264. if __name__ == '__main__':
  265.     unittest.main(defaultTest='test_suite')
  266.