From 4710c53dcad1ebf3755f3efb9e80ac24bd72a9b2 Mon Sep 17 00:00:00 2001 From: darylm503 Date: Mon, 16 Apr 2012 22:12:42 +0000 Subject: AppPkg/Applications/Python: Add Python 2.7.2 sources since the release of Python 2.7.3 made them unavailable from the python.org web site. These files are a subset of the python-2.7.2.tgz distribution from python.org. Changed files from PyMod-2.7.2 have been copied into the corresponding directories of this tree, replacing the original files in the distribution. Signed-off-by: daryl.mcdaniel@intel.com git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@13197 6f19259b-4bc3-4df7-8a09-765794883524 --- .../Python/Python-2.7.2/Lib/test/test_dumbdbm.py | 179 +++++++++++++++++++++ 1 file changed, 179 insertions(+) create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_dumbdbm.py (limited to 'AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_dumbdbm.py') diff --git a/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_dumbdbm.py b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_dumbdbm.py new file mode 100644 index 0000000000..142f7782c6 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_dumbdbm.py @@ -0,0 +1,179 @@ +#! /usr/bin/env python +"""Test script for the dumbdbm module + Original by Roger E. Masse +""" + +import os +import unittest +import dumbdbm +from test import test_support + +_fname = test_support.TESTFN + +def _delete_files(): + for ext in [".dir", ".dat", ".bak"]: + try: + os.unlink(_fname + ext) + except OSError: + pass + +class DumbDBMTestCase(unittest.TestCase): + _dict = {'0': '', + 'a': 'Python:', + 'b': 'Programming', + 'c': 'the', + 'd': 'way', + 'f': 'Guido', + 'g': 'intended' + } + + def __init__(self, *args): + unittest.TestCase.__init__(self, *args) + + def test_dumbdbm_creation(self): + f = dumbdbm.open(_fname, 'c') + self.assertEqual(f.keys(), []) + for key in self._dict: + f[key] = self._dict[key] + self.read_helper(f) + f.close() + + def test_dumbdbm_creation_mode(self): + # On platforms without chmod, don't do anything. + if not (hasattr(os, 'chmod') and hasattr(os, 'umask')): + return + + try: + old_umask = os.umask(0002) + f = dumbdbm.open(_fname, 'c', 0637) + f.close() + finally: + os.umask(old_umask) + + expected_mode = 0635 + if os.name != 'posix': + # Windows only supports setting the read-only attribute. + # This shouldn't fail, but doesn't work like Unix either. + expected_mode = 0666 + + import stat + st = os.stat(_fname + '.dat') + self.assertEqual(stat.S_IMODE(st.st_mode), expected_mode) + st = os.stat(_fname + '.dir') + self.assertEqual(stat.S_IMODE(st.st_mode), expected_mode) + + def test_close_twice(self): + f = dumbdbm.open(_fname) + f['a'] = 'b' + self.assertEqual(f['a'], 'b') + f.close() + f.close() + + def test_dumbdbm_modification(self): + self.init_db() + f = dumbdbm.open(_fname, 'w') + self._dict['g'] = f['g'] = "indented" + self.read_helper(f) + f.close() + + def test_dumbdbm_read(self): + self.init_db() + f = dumbdbm.open(_fname, 'r') + self.read_helper(f) + f.close() + + def test_dumbdbm_keys(self): + self.init_db() + f = dumbdbm.open(_fname) + keys = self.keys_helper(f) + f.close() + + def test_write_write_read(self): + # test for bug #482460 + f = dumbdbm.open(_fname) + f['1'] = 'hello' + f['1'] = 'hello2' + f.close() + f = dumbdbm.open(_fname) + self.assertEqual(f['1'], 'hello2') + f.close() + + def test_line_endings(self): + # test for bug #1172763: dumbdbm would die if the line endings + # weren't what was expected. + f = dumbdbm.open(_fname) + f['1'] = 'hello' + f['2'] = 'hello2' + f.close() + + # Mangle the file by adding \r before each newline + data = open(_fname + '.dir').read() + data = data.replace('\n', '\r\n') + open(_fname + '.dir', 'wb').write(data) + + f = dumbdbm.open(_fname) + self.assertEqual(f['1'], 'hello') + self.assertEqual(f['2'], 'hello2') + + + def read_helper(self, f): + keys = self.keys_helper(f) + for key in self._dict: + self.assertEqual(self._dict[key], f[key]) + + def init_db(self): + f = dumbdbm.open(_fname, 'w') + for k in self._dict: + f[k] = self._dict[k] + f.close() + + def keys_helper(self, f): + keys = f.keys() + keys.sort() + dkeys = self._dict.keys() + dkeys.sort() + self.assertEqual(keys, dkeys) + return keys + + # Perform randomized operations. This doesn't make assumptions about + # what *might* fail. + def test_random(self): + import random + d = {} # mirror the database + for dummy in range(5): + f = dumbdbm.open(_fname) + for dummy in range(100): + k = random.choice('abcdefghijklm') + if random.random() < 0.2: + if k in d: + del d[k] + del f[k] + else: + v = random.choice('abc') * random.randrange(10000) + d[k] = v + f[k] = v + self.assertEqual(f[k], v) + f.close() + + f = dumbdbm.open(_fname) + expected = d.items() + expected.sort() + got = f.items() + got.sort() + self.assertEqual(expected, got) + f.close() + + def tearDown(self): + _delete_files() + + def setUp(self): + _delete_files() + +def test_main(): + try: + test_support.run_unittest(DumbDBMTestCase) + finally: + _delete_files() + +if __name__ == "__main__": + test_main() -- cgit v1.2.3