EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / test_bsddb.py

#! /usr/bin/env python\r
"""Test script for the bsddb C module by Roger E. Masse\r
   Adapted to unittest format and expanded scope by Raymond Hettinger\r
"""\r
import os, sys\r
import unittest\r
from test import test_support\r
\r
# Skip test if _bsddb wasn't built.\r
test_support.import_module('_bsddb')\r
\r
bsddb = test_support.import_module('bsddb', deprecated=True)\r
# Just so we know it's imported:\r
test_support.import_module('dbhash', deprecated=True)\r
\r
\r
class TestBSDDB(unittest.TestCase):\r
    openflag = 'c'\r
\r
    def setUp(self):\r
        self.f = self.openmethod[0](self.fname, self.openflag, cachesize=32768)\r
        self.d = dict(q='Guido', w='van', e='Rossum', r='invented', t='Python', y='')\r
        for k, v in self.d.iteritems():\r
            self.f[k] = v\r
\r
    def tearDown(self):\r
        self.f.sync()\r
        self.f.close()\r
        if self.fname is None:\r
            return\r
        try:\r
            os.remove(self.fname)\r
        except os.error:\r
            pass\r
\r
    def test_getitem(self):\r
        for k, v in self.d.iteritems():\r
            self.assertEqual(self.f[k], v)\r
\r
    def test_len(self):\r
        self.assertEqual(len(self.f), len(self.d))\r
\r
    def test_change(self):\r
        self.f['r'] = 'discovered'\r
        self.assertEqual(self.f['r'], 'discovered')\r
        self.assertIn('r', self.f.keys())\r
        self.assertIn('discovered', self.f.values())\r
\r
    def test_close_and_reopen(self):\r
        if self.fname is None:\r
            # if we're using an in-memory only db, we can't reopen it\r
            # so finish here.\r
            return\r
        self.f.close()\r
        self.f = self.openmethod[0](self.fname, 'w')\r
        for k, v in self.d.iteritems():\r
            self.assertEqual(self.f[k], v)\r
\r
    def assertSetEquals(self, seqn1, seqn2):\r
        self.assertEqual(set(seqn1), set(seqn2))\r
\r
    def test_mapping_iteration_methods(self):\r
        f = self.f\r
        d = self.d\r
        self.assertSetEquals(d, f)\r
        self.assertSetEquals(d.keys(), f.keys())\r
        self.assertSetEquals(d.values(), f.values())\r
        self.assertSetEquals(d.items(), f.items())\r
        self.assertSetEquals(d.iterkeys(), f.iterkeys())\r
        self.assertSetEquals(d.itervalues(), f.itervalues())\r
        self.assertSetEquals(d.iteritems(), f.iteritems())\r
\r
    def test_iter_while_modifying_values(self):\r
        di = iter(self.d)\r
        while 1:\r
            try:\r
                key = di.next()\r
                self.d[key] = 'modified '+key\r
            except StopIteration:\r
                break\r
\r
        # it should behave the same as a dict.  modifying values\r
        # of existing keys should not break iteration.  (adding\r
        # or removing keys should)\r
        loops_left = len(self.f)\r
        fi = iter(self.f)\r
        while 1:\r
            try:\r
                key = fi.next()\r
                self.f[key] = 'modified '+key\r
                loops_left -= 1\r
            except StopIteration:\r
                break\r
        self.assertEqual(loops_left, 0)\r
\r
        self.test_mapping_iteration_methods()\r
\r
    def test_iter_abort_on_changed_size(self):\r
        def DictIterAbort():\r
            di = iter(self.d)\r
            while 1:\r
                try:\r
                    di.next()\r
                    self.d['newkey'] = 'SPAM'\r
                except StopIteration:\r
                    break\r
        self.assertRaises(RuntimeError, DictIterAbort)\r
\r
        def DbIterAbort():\r
            fi = iter(self.f)\r
            while 1:\r
                try:\r
                    fi.next()\r
                    self.f['newkey'] = 'SPAM'\r
                except StopIteration:\r
                    break\r
        self.assertRaises(RuntimeError, DbIterAbort)\r
\r
    def test_iteritems_abort_on_changed_size(self):\r
        def DictIteritemsAbort():\r
            di = self.d.iteritems()\r
            while 1:\r
                try:\r
                    di.next()\r
                    self.d['newkey'] = 'SPAM'\r
                except StopIteration:\r
                    break\r
        self.assertRaises(RuntimeError, DictIteritemsAbort)\r
\r
        def DbIteritemsAbort():\r
            fi = self.f.iteritems()\r
            while 1:\r
                try:\r
                    key, value = fi.next()\r
                    del self.f[key]\r
                except StopIteration:\r
                    break\r
        self.assertRaises(RuntimeError, DbIteritemsAbort)\r
\r
    def test_iteritems_while_modifying_values(self):\r
        di = self.d.iteritems()\r
        while 1:\r
            try:\r
                k, v = di.next()\r
                self.d[k] = 'modified '+v\r
            except StopIteration:\r
                break\r
\r
        # it should behave the same as a dict.  modifying values\r
        # of existing keys should not break iteration.  (adding\r
        # or removing keys should)\r
        loops_left = len(self.f)\r
        fi = self.f.iteritems()\r
        while 1:\r
            try:\r
                k, v = fi.next()\r
                self.f[k] = 'modified '+v\r
                loops_left -= 1\r
            except StopIteration:\r
                break\r
        self.assertEqual(loops_left, 0)\r
\r
        self.test_mapping_iteration_methods()\r
\r
    def test_first_next_looping(self):\r
        items = [self.f.first()]\r
        for i in xrange(1, len(self.f)):\r
            items.append(self.f.next())\r
        self.assertSetEquals(items, self.d.items())\r
\r
    def test_previous_last_looping(self):\r
        items = [self.f.last()]\r
        for i in xrange(1, len(self.f)):\r
            items.append(self.f.previous())\r
        self.assertSetEquals(items, self.d.items())\r
\r
    def test_first_while_deleting(self):\r
        # Test for bug 1725856\r
        self.assertTrue(len(self.d) >= 2, "test requires >=2 items")\r
        for _ in self.d:\r
            key = self.f.first()[0]\r
            del self.f[key]\r
        self.assertEqual([], self.f.items(), "expected empty db after test")\r
\r
    def test_last_while_deleting(self):\r
        # Test for bug 1725856's evil twin\r
        self.assertTrue(len(self.d) >= 2, "test requires >=2 items")\r
        for _ in self.d:\r
            key = self.f.last()[0]\r
            del self.f[key]\r
        self.assertEqual([], self.f.items(), "expected empty db after test")\r
\r
    def test_set_location(self):\r
        self.assertEqual(self.f.set_location('e'), ('e', self.d['e']))\r
\r
    def test_contains(self):\r
        for k in self.d:\r
            self.assertIn(k, self.f)\r
        self.assertNotIn('not here', self.f)\r
\r
    def test_has_key(self):\r
        for k in self.d:\r
            self.assertTrue(self.f.has_key(k))\r
        self.assertTrue(not self.f.has_key('not here'))\r
\r
    def test_clear(self):\r
        self.f.clear()\r
        self.assertEqual(len(self.f), 0)\r
\r
    def test__no_deadlock_first(self, debug=0):\r
        # do this so that testers can see what function we're in in\r
        # verbose mode when we deadlock.\r
        sys.stdout.flush()\r
\r
        # in pybsddb's _DBWithCursor this causes an internal DBCursor\r
        # object is created.  Other test_ methods in this class could\r
        # inadvertently cause the deadlock but an explicit test is needed.\r
        if debug: print "A"\r
        k,v = self.f.first()\r
        if debug: print "B", k\r
        self.f[k] = "deadlock.  do not pass go.  do not collect $200."\r
        if debug: print "C"\r
        # if the bsddb implementation leaves the DBCursor open during\r
        # the database write and locking+threading support is enabled\r
        # the cursor's read lock will deadlock the write lock request..\r
\r
        # test the iterator interface\r
        if True:\r
            if debug: print "D"\r
            i = self.f.iteritems()\r
            k,v = i.next()\r
            if debug: print "E"\r
            self.f[k] = "please don't deadlock"\r
            if debug: print "F"\r
            while 1:\r
                try:\r
                    k,v = i.next()\r
                except StopIteration:\r
                    break\r
            if debug: print "F2"\r
\r
            i = iter(self.f)\r
            if debug: print "G"\r
            while i:\r
                try:\r
                    if debug: print "H"\r
                    k = i.next()\r
                    if debug: print "I"\r
                    self.f[k] = "deadlocks-r-us"\r
                    if debug: print "J"\r
                except StopIteration:\r
                    i = None\r
            if debug: print "K"\r
\r
        # test the legacy cursor interface mixed with writes\r
        self.assertIn(self.f.first()[0], self.d)\r
        k = self.f.next()[0]\r
        self.assertIn(k, self.d)\r
        self.f[k] = "be gone with ye deadlocks"\r
        self.assertTrue(self.f[k], "be gone with ye deadlocks")\r
\r
    def test_for_cursor_memleak(self):\r
        # do the bsddb._DBWithCursor iterator internals leak cursors?\r
        nc1 = len(self.f._cursor_refs)\r
        # create iterator\r
        i = self.f.iteritems()\r
        nc2 = len(self.f._cursor_refs)\r
        # use the iterator (should run to the first yield, creating the cursor)\r
        k, v = i.next()\r
        nc3 = len(self.f._cursor_refs)\r
        # destroy the iterator; this should cause the weakref callback\r
        # to remove the cursor object from self.f._cursor_refs\r
        del i\r
        nc4 = len(self.f._cursor_refs)\r
\r
        self.assertEqual(nc1, nc2)\r
        self.assertEqual(nc1, nc4)\r
        self.assertTrue(nc3 == nc1+1)\r
\r
    def test_popitem(self):\r
        k, v = self.f.popitem()\r
        self.assertIn(k, self.d)\r
        self.assertIn(v, self.d.values())\r
        self.assertNotIn(k, self.f)\r
        self.assertEqual(len(self.d)-1, len(self.f))\r
\r
    def test_pop(self):\r
        k = 'w'\r
        v = self.f.pop(k)\r
        self.assertEqual(v, self.d[k])\r
        self.assertNotIn(k, self.f)\r
        self.assertNotIn(v, self.f.values())\r
        self.assertEqual(len(self.d)-1, len(self.f))\r
\r
    def test_get(self):\r
        self.assertEqual(self.f.get('NotHere'), None)\r
        self.assertEqual(self.f.get('NotHere', 'Default'), 'Default')\r
        self.assertEqual(self.f.get('q', 'Default'), self.d['q'])\r
\r
    def test_setdefault(self):\r
        self.assertEqual(self.f.setdefault('new', 'dog'), 'dog')\r
        self.assertEqual(self.f.setdefault('r', 'cat'), self.d['r'])\r
\r
    def test_update(self):\r
        new = dict(y='life', u='of', i='brian')\r
        self.f.update(new)\r
        self.d.update(new)\r
        for k, v in self.d.iteritems():\r
            self.assertEqual(self.f[k], v)\r
\r
    def test_keyordering(self):\r
        if self.openmethod[0] is not bsddb.btopen:\r
            return\r
        keys = self.d.keys()\r
        keys.sort()\r
        self.assertEqual(self.f.first()[0], keys[0])\r
        self.assertEqual(self.f.next()[0], keys[1])\r
        self.assertEqual(self.f.last()[0], keys[-1])\r
        self.assertEqual(self.f.previous()[0], keys[-2])\r
        self.assertEqual(list(self.f), keys)\r
\r
class TestBTree(TestBSDDB):\r
    fname = test_support.TESTFN\r
    openmethod = [bsddb.btopen]\r
\r
class TestBTree_InMemory(TestBSDDB):\r
    fname = None\r
    openmethod = [bsddb.btopen]\r
\r
class TestBTree_InMemory_Truncate(TestBSDDB):\r
    fname = None\r
    openflag = 'n'\r
    openmethod = [bsddb.btopen]\r
\r
class TestHashTable(TestBSDDB):\r
    fname = test_support.TESTFN\r
    openmethod = [bsddb.hashopen]\r
\r
class TestHashTable_InMemory(TestBSDDB):\r
    fname = None\r
    openmethod = [bsddb.hashopen]\r
\r
##         # (bsddb.rnopen,'Record Numbers'), 'put' for RECNO for bsddb 1.85\r
##         #                                   appears broken... at least on\r
##         #                                   Solaris Intel - rmasse 1/97\r
\r
def test_main(verbose=None):\r
    test_support.run_unittest(\r
        TestBTree,\r
        TestHashTable,\r
        TestBTree_InMemory,\r
        TestHashTable_InMemory,\r
        TestBTree_InMemory_Truncate,\r
    )\r
\r
if __name__ == "__main__":\r
    test_main(verbose=True)\r