bpo-22831: Use "with" to avoid possible fd leaks in tests (part 1). (GH-10928)

Author: serhiy-storchaka

Lib/test/test_dbm_dumb.py

@@ -2,6 +2,7 @@
  Original by Roger E. Masse
 """
 
+import contextlib
 import io
 import operator
 import os
@@ -32,12 +33,11 @@ class DumbDBMTestCase(unittest.TestCase):
  }
 
  def test_dumbdbm_creation(self):
- f = dumbdbm.open(_fname, 'c')
- self.assertEqual(list(f.keys()), [])
- for key in self._dict:
- f[key] = self._dict[key]
- self.read_helper(f)
- f.close()
+ with contextlib.closing(dumbdbm.open(_fname, 'c')) as f:
+ self.assertEqual(list(f.keys()), [])
+ for key in self._dict:
+ f[key] = self._dict[key]
+ self.read_helper(f)
 
  @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
  def test_dumbdbm_creation_mode(self):
@@ -69,78 +69,70 @@ def test_close_twice(self):
 
  def test_dumbdbm_modification(self):
  self.init_db()
- f = dumbdbm.open(_fname, 'w')
- self._dict[b'g'] = f[b'g'] = b"indented"
- self.read_helper(f)
- # setdefault() works as in the dict interface
- self.assertEqual(f.setdefault(b'xxx', b'foo'), b'foo')
- self.assertEqual(f[b'xxx'], b'foo')
- f.close()
+ with contextlib.closing(dumbdbm.open(_fname, 'w')) as f:
+ self._dict[b'g'] = f[b'g'] = b"indented"
+ self.read_helper(f)
+ # setdefault() works as in the dict interface
+ self.assertEqual(f.setdefault(b'xxx', b'foo'), b'foo')
+ self.assertEqual(f[b'xxx'], b'foo')
 
  def test_dumbdbm_read(self):
  self.init_db()
- f = dumbdbm.open(_fname, 'r')
- self.read_helper(f)
- with self.assertRaisesRegex(dumbdbm.error,
- 'The database is opened for reading only'):
- f[b'g'] = b'x'
- with self.assertRaisesRegex(dumbdbm.error,
- 'The database is opened for reading only'):
- del f[b'a']
- # get() works as in the dict interface
- self.assertEqual(f.get(b'a'), self._dict[b'a'])
- self.assertEqual(f.get(b'xxx', b'foo'), b'foo')
- self.assertIsNone(f.get(b'xxx'))
- with self.assertRaises(KeyError):
- f[b'xxx']
- f.close()
+ with contextlib.closing(dumbdbm.open(_fname, 'r')) as f:
+ self.read_helper(f)
+ with self.assertRaisesRegex(dumbdbm.error,
+ 'The database is opened for reading only'):
+ f[b'g'] = b'x'
+ with self.assertRaisesRegex(dumbdbm.error,
+ 'The database is opened for reading only'):
+ del f[b'a']
+ # get() works as in the dict interface
+ self.assertEqual(f.get(b'a'), self._dict[b'a'])
+ self.assertEqual(f.get(b'xxx', b'foo'), b'foo')
+ self.assertIsNone(f.get(b'xxx'))
+ with self.assertRaises(KeyError):
+ f[b'xxx']
 
  def test_dumbdbm_keys(self):
  self.init_db()
- f = dumbdbm.open(_fname)
- keys = self.keys_helper(f)
- f.close()
+ with contextlib.closing(dumbdbm.open(_fname)) as f:
+ keys = self.keys_helper(f)
 
  def test_write_contains(self):
- f = dumbdbm.open(_fname)
- f[b'1'] = b'hello'
- self.assertIn(b'1', f)
- f.close()
+ with contextlib.closing(dumbdbm.open(_fname)) as f:
+ f[b'1'] = b'hello'
+ self.assertIn(b'1', f)
 
  def test_write_write_read(self):
  # test for bug #482460
- f = dumbdbm.open(_fname)
- f[b'1'] = b'hello'
- f[b'1'] = b'hello2'
- f.close()
- f = dumbdbm.open(_fname)
- self.assertEqual(f[b'1'], b'hello2')
- f.close()
+ with contextlib.closing(dumbdbm.open(_fname)) as f:
+ f[b'1'] = b'hello'
+ f[b'1'] = b'hello2'
+ with contextlib.closing(dumbdbm.open(_fname)) as f:
+ self.assertEqual(f[b'1'], b'hello2')
 
  def test_str_read(self):
  self.init_db()
- f = dumbdbm.open(_fname, 'r')
- self.assertEqual(f['\u00fc'], self._dict['\u00fc'.encode('utf-8')])
+ with contextlib.closing(dumbdbm.open(_fname, 'r')) as f:
+  self.assertEqual(f['\u00fc'], self._dict['\u00fc'.encode('utf-8')])
 
  def test_str_write_contains(self):
  self.init_db()
- f = dumbdbm.open(_fname)
- f['\u00fc'] = b'!'
- f['1'] = 'a'
- f.close()
- f = dumbdbm.open(_fname, 'r')
- self.assertIn('\u00fc', f)
- self.assertEqual(f['\u00fc'.encode('utf-8')],
- self._dict['\u00fc'.encode('utf-8')])
- self.assertEqual(f[b'1'], b'a')
+ with contextlib.closing(dumbdbm.open(_fname)) as f:
+ f['\u00fc'] = b'!'
+ f['1'] = 'a'
+ with contextlib.closing(dumbdbm.open(_fname, 'r')) as f:
+ self.assertIn('\u00fc', f)
+ self.assertEqual(f['\u00fc'.encode('utf-8')],
+ self._dict['\u00fc'.encode('utf-8')])
+ self.assertEqual(f[b'1'], b'a')
 
  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[b'1'] = b'hello'
- f[b'2'] = b'hello2'
- f.close()
+ with contextlib.closing(dumbdbm.open(_fname)) as f:
+ f[b'1'] = b'hello'
+ f[b'2'] = b'hello2'
 
  # Mangle the file by changing the line separator to Windows or Unix
  with io.open(_fname + '.dir', 'rb') as file:
@@ -163,10 +155,9 @@ def read_helper(self, f):
  self.assertEqual(self._dict[key], f[key])
 
  def init_db(self):
- f = dumbdbm.open(_fname, 'n')
- for k in self._dict:
- f[k] = self._dict[k]
- f.close()
+ with contextlib.closing(dumbdbm.open(_fname, 'n')) as f:
+ for k in self._dict:
+ f[k] = self._dict[k]
 
  def keys_helper(self, f):
  keys = sorted(f.keys())
@@ -180,25 +171,23 @@ 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((b'a', b'b', b'c')) * random.randrange(10000)
- d[k] = v
- f[k] = v
- self.assertEqual(f[k], v)
- f.close()
-
- f = dumbdbm.open(_fname)
- expected = sorted((k.encode("latin-1"), v) for k, v in d.items())
- got = sorted(f.items())
- self.assertEqual(expected, got)
- f.close()
+ with contextlib.closing(dumbdbm.open(_fname)) as f:
+ 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((b'a', b'b', b'c')) * random.randrange(10000)
+ d[k] = v
+ f[k] = v
+ self.assertEqual(f[k], v)
+
+ with contextlib.closing(dumbdbm.open(_fname)) as f:
+ expected = sorted((k.encode("latin-1"), v) for k, v in d.items())
+ got = sorted(f.items())
+ self.assertEqual(expected, got)
 
  def test_context_manager(self):
  with dumbdbm.open(_fname, 'c') as db:

Lib/test/test_mmap.py

@@ -268,13 +268,12 @@ def test_tougher_find(self):
 
  def test_find_end(self):
  # test the new 'end' parameter works as expected
- f = open(TESTFN, 'wb+')
- data = b'one two ones'
- n = len(data)
- f.write(data)
- f.flush()
- m = mmap.mmap(f.fileno(), n)
- f.close()
+ with open(TESTFN, 'wb+') as f:
+ data = b'one two ones'
+ n = len(data)
+ f.write(data)
+ f.flush()
+ m = mmap.mmap(f.fileno(), n)
 
  self.assertEqual(m.find(b'one'), 0)
  self.assertEqual(m.find(b'ones'), 8)
@@ -287,13 +286,12 @@ def test_find_end(self):
 
  def test_rfind(self):
  # test the new 'end' parameter works as expected
- f = open(TESTFN, 'wb+')
- data = b'one two ones'
- n = len(data)
- f.write(data)
- f.flush()
- m = mmap.mmap(f.fileno(), n)
- f.close()
+ with open(TESTFN, 'wb+') as f:
+ data = b'one two ones'
+ n = len(data)
+ f.write(data)
+ f.flush()
+ m = mmap.mmap(f.fileno(), n)
 
  self.assertEqual(m.rfind(b'one'), 8)
  self.assertEqual(m.rfind(b'one '), 0)
@@ -306,30 +304,23 @@ def test_rfind(self):
 
  def test_double_close(self):
  # make sure a double close doesn't crash on Solaris (Bug# 665913)
- f = open(TESTFN, 'wb+')
-
- f.write(2**16 * b'a') # Arbitrary character
- f.close()
+ with open(TESTFN, 'wb+') as f:
+ f.write(2**16 * b'a') # Arbitrary character
 
- f = open(TESTFN, 'rb')
- mf = mmap.mmap(f.fileno(), 2**16, access=mmap.ACCESS_READ)
- mf.close()
- mf.close()
- f.close()
+ with open(TESTFN, 'rb') as f:
+ mf = mmap.mmap(f.fileno(), 2**16, access=mmap.ACCESS_READ)
+ mf.close()
+ mf.close()
 
  def test_entire_file(self):
  # test mapping of entire file by passing 0 for map length
- f = open(TESTFN, "wb+")
+ with open(TESTFN, "wb+") as f:
+ f.write(2**16 * b'm') # Arbitrary character
 
- f.write(2**16 * b'm') # Arbitrary character
- f.close()
-
- f = open(TESTFN, "rb+")
- mf = mmap.mmap(f.fileno(), 0)
- self.assertEqual(len(mf), 2**16, "Map size should equal file size.")
- self.assertEqual(mf.read(2**16), 2**16 * b"m")
- mf.close()
- f.close()
+ with open(TESTFN, "rb+") as f, \
+ mmap.mmap(f.fileno(), 0) as mf:
+ self.assertEqual(len(mf), 2**16, "Map size should equal file size.")
+ self.assertEqual(mf.read(2**16), 2**16 * b"m")
 
  def test_length_0_offset(self):
  # Issue #10916: test mapping of remainder of file by passing 0 for
@@ -355,16 +346,15 @@ def test_length_0_large_offset(self):
 
  def test_move(self):
  # make move works everywhere (64-bit format problem earlier)
- f = open(TESTFN, 'wb+')
+ with open(TESTFN, 'wb+') as f:
 
- f.write(b"ABCDEabcde") # Arbitrary character
- f.flush()
+  f.write(b"ABCDEabcde") # Arbitrary character
+  f.flush()
 
- mf = mmap.mmap(f.fileno(), 10)
- mf.move(5, 0, 5)
- self.assertEqual(mf[:], b"ABCDEABCDE", "Map move should have duplicated front 5")
- mf.close()
- f.close()
+ mf = mmap.mmap(f.fileno(), 10)
+ mf.move(5, 0, 5)
+ self.assertEqual(mf[:], b"ABCDEABCDE", "Map move should have duplicated front 5")
+ mf.close()
 
  # more excessive test
  data = b"0123456789"
@@ -562,10 +552,9 @@ def test_prot_readonly(self):
  mapsize = 10
  with open(TESTFN, "wb") as fp:
  fp.write(b"a"*mapsize)
- f = open(TESTFN, "rb")
- m = mmap.mmap(f.fileno(), mapsize, prot=mmap.PROT_READ)
- self.assertRaises(TypeError, m.write, "foo")
- f.close()
+ with open(TESTFN, "rb") as f:
+ m = mmap.mmap(f.fileno(), mapsize, prot=mmap.PROT_READ)
+ self.assertRaises(TypeError, m.write, "foo")
 
  def test_error(self):
  self.assertIs(mmap.error, OSError)
@@ -574,9 +563,8 @@ def test_io_methods(self):
  data = b"0123456789"
  with open(TESTFN, "wb") as fp:
  fp.write(b"x"*len(data))
- f = open(TESTFN, "r+b")
- m = mmap.mmap(f.fileno(), len(data))
- f.close()
+ with open(TESTFN, "r+b") as f:
+ m = mmap.mmap(f.fileno(), len(data))
  # Test write_byte()
  for i in range(len(data)):
  self.assertEqual(m.tell(), i)