[Python-checkins] r78583 - in python/branches/py3k: Lib/test/test_dict.py

Tue Mar 2 17:06:24 CET 2010

Author: florent.xicluna
Date: Tue Mar 2 17:06:24 2010
New Revision: 78583
Log:
Recorded merge of revisions 78582 via svnmerge from 
svn+ssh://pythondev@svn.python.org/python/trunk
........
 r78582 | florent.xicluna | 2010年03月02日 17:00:00 +0100 (mar, 02 mar 2010) | 2 lines
 
 Refactor test_dict using assertRaises.
........
Modified:
 python/branches/py3k/ (props changed)
 python/branches/py3k/Lib/test/test_dict.py
Modified: python/branches/py3k/Lib/test/test_dict.py
==============================================================================

--- python/branches/py3k/Lib/test/test_dict.py	(original)
+++ python/branches/py3k/Lib/test/test_dict.py	Tue Mar 2 17:06:24 2010
@@ -1,7 +1,7 @@
 import unittest
 from test import support
 
-import sys, collections, random, string
+import collections, random, string
 import gc, weakref
 
 
@@ -10,24 +10,24 @@
 def test_constructor(self):
 # calling built-in types without argument must return empty
 self.assertEqual(dict(), {})
- self.assertTrue(dict() is not {})
+ self.assertIsNot(dict(), {})
 
 def test_literal_constructor(self):
- # check literal constructor for different sized dicts (to exercise the BUILD_MAP oparg
+ # check literal constructor for different sized dicts
+ # (to exercise the BUILD_MAP oparg).
 for n in (0, 1, 6, 256, 400):
- items = [(''.join([random.choice(string.ascii_letters)
- for j in range(8)]),
- i)
+ items = [(''.join(random.sample(string.ascii_letters, 8)), i)
 for i in range(n)]
 random.shuffle(items)
- dictliteral = '{' + ', '.join('%r: %d' % item for item in items) + '}'
+ formatted_items = ('{!r}: {:d}'.format(k, v) for k, v in items)
+ dictliteral = '{' + ', '.join(formatted_items) + '}'
 self.assertEqual(eval(dictliteral), dict(items))
 
 def test_bool(self):
- self.assertTrue(not {})
+ self.assertIs(not {}, True)
 self.assertTrue({1: 2})
- self.assertTrue(bool({}) is False)
- self.assertTrue(bool({1: 2}) is True)
+ self.assertIs(bool({}), False)
+ self.assertIs(bool({1: 2}), True)
 
 def test_keys(self):
 d = {}
@@ -59,7 +59,7 @@
 def test_contains(self):
 d = {}
 self.assertNotIn('a', d)
- self.assertTrue(not ('a' in d))
+ self.assertFalse('a' in d)
 self.assertTrue('a' not in d)
 d = {'a': 1, 'b': 2}
 self.assertIn('a', d)
@@ -198,7 +198,7 @@
 def test_fromkeys(self):
 self.assertEqual(dict.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
 d = {}
- self.assertTrue(not(d.fromkeys('abc') is d))
+ self.assertIsNot(d.fromkeys('abc'), d)
 self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
 self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0})
 self.assertEqual(d.fromkeys([]), {})
@@ -209,8 +209,8 @@
 class dictlike(dict): pass
 self.assertEqual(dictlike.fromkeys('a'), {'a':None})
 self.assertEqual(dictlike().fromkeys('a'), {'a':None})
- self.assertTrue(type(dictlike.fromkeys('a')) is dictlike)
- self.assertTrue(type(dictlike().fromkeys('a')) is dictlike)
+ self.assertIsInstance(dictlike.fromkeys('a'), dictlike)
+ self.assertIsInstance(dictlike().fromkeys('a'), dictlike)
 class mydict(dict):
 def __new__(cls):
 return collections.UserDict()
@@ -253,10 +253,10 @@
 
 def test_get(self):
 d = {}
- self.assertTrue(d.get('c') is None)
+ self.assertIs(d.get('c'), None)
 self.assertEqual(d.get('c', 3), 3)
- d = {'a' : 1, 'b' : 2}
- self.assertTrue(d.get('c') is None)
+ d = {'a': 1, 'b': 2}
+ self.assertIs(d.get('c'), None)
 self.assertEqual(d.get('c', 3), 3)
 self.assertEqual(d.get('a'), 1)
 self.assertEqual(d.get('a', 3), 1)
@@ -266,9 +266,9 @@
 def test_setdefault(self):
 # dict.setdefault()
 d = {}
- self.assertTrue(d.setdefault('key0') is None)
+ self.assertIs(d.setdefault('key0'), None)
 d.setdefault('key0', [])
- self.assertTrue(d.setdefault('key0') is None)
+ self.assertIs(d.setdefault('key0'), None)
 d.setdefault('key', []).append(3)
 self.assertEqual(d['key'][0], 3)
 d.setdefault('key', []).append(4)
@@ -310,9 +310,9 @@
 self.assertEqual(va, int(ka))
 kb, vb = tb = b.popitem()
 self.assertEqual(vb, int(kb))
- self.assertTrue(not(copymode < 0 and ta != tb))
- self.assertTrue(not a)
- self.assertTrue(not b)
+ self.assertFalse(copymode < 0 and ta != tb)
+ self.assertFalse(a)
+ self.assertFalse(b)
 
 d = {}
 self.assertRaises(KeyError, d.popitem)
@@ -351,15 +351,12 @@
 self.assertRaises(Exc, d.pop, x)
 
 def test_mutatingiteration(self):
+ # changing dict size during iteration
 d = {}
 d[1] = 1
- try:
+ with self.assertRaises(RuntimeError):
 for i in d:
 d[i+1] = 1
- except RuntimeError:
- pass
- else:
- self.fail("changing dict size during iteration doesn't raise Error")
 
 def test_repr(self):
 d = {}
@@ -393,12 +390,9 @@
 
 d1 = {BadCmp(): 1}
 d2 = {1: 1}
- try:
+
+ with self.assertRaises(Exc):
 d1 == d2
- except Exc:
- pass
- else:
- self.fail("< didn't raise Exc")
 
 def test_keys_contained(self):
 self.helper_keys_contained(lambda x: x.keys())
@@ -452,62 +446,70 @@
 class C:
 def __eq__(self, other):
 raise RuntimeError
+
 d1 = {1: C()}
 d2 = {1: C()}
- self.assertRaises(RuntimeError, lambda: d1.items() == d2.items())
- self.assertRaises(RuntimeError, lambda: d1.items() != d2.items())
- self.assertRaises(RuntimeError, lambda: d1.items() <= d2.items())
- self.assertRaises(RuntimeError, lambda: d1.items() >= d2.items())
+ with self.assertRaises(RuntimeError):
+ d1.items() == d2.items()
+ with self.assertRaises(RuntimeError):
+ d1.items() != d2.items()
+ with self.assertRaises(RuntimeError):
+ d1.items() <= d2.items()
+ with self.assertRaises(RuntimeError):
+ d1.items() >= d2.items()
+
 d3 = {1: C(), 2: C()}
- self.assertRaises(RuntimeError, lambda: d2.items() < d3.items())
- self.assertRaises(RuntimeError, lambda: d3.items() > d2.items())
+ with self.assertRaises(RuntimeError):
+ d2.items() < d3.items()
+ with self.assertRaises(RuntimeError):
+ d3.items() > d2.items()
 
 def test_dictview_set_operations_on_keys(self):
 k1 = {1:1, 2:2}.keys()
 k2 = {1:1, 2:2, 3:3}.keys()
 k3 = {4:4}.keys()
 
- self.assertEquals(k1 - k2, set())
- self.assertEquals(k1 - k3, {1,2})
- self.assertEquals(k2 - k1, {3})
- self.assertEquals(k3 - k1, {4})
- self.assertEquals(k1 & k2, {1,2})
- self.assertEquals(k1 & k3, set())
- self.assertEquals(k1 | k2, {1,2,3})
- self.assertEquals(k1 ^ k2, {3})
- self.assertEquals(k1 ^ k3, {1,2,4})
+ self.assertEqual(k1 - k2, set())
+ self.assertEqual(k1 - k3, {1,2})
+ self.assertEqual(k2 - k1, {3})
+ self.assertEqual(k3 - k1, {4})
+ self.assertEqual(k1 & k2, {1,2})
+ self.assertEqual(k1 & k3, set())
+ self.assertEqual(k1 | k2, {1,2,3})
+ self.assertEqual(k1 ^ k2, {3})
+ self.assertEqual(k1 ^ k3, {1,2,4})
 
 def test_dictview_set_operations_on_items(self):
 k1 = {1:1, 2:2}.items()
 k2 = {1:1, 2:2, 3:3}.items()
 k3 = {4:4}.items()
 
- self.assertEquals(k1 - k2, set())
- self.assertEquals(k1 - k3, {(1,1), (2,2)})
- self.assertEquals(k2 - k1, {(3,3)})
- self.assertEquals(k3 - k1, {(4,4)})
- self.assertEquals(k1 & k2, {(1,1), (2,2)})
- self.assertEquals(k1 & k3, set())
- self.assertEquals(k1 | k2, {(1,1), (2,2), (3,3)})
- self.assertEquals(k1 ^ k2, {(3,3)})
- self.assertEquals(k1 ^ k3, {(1,1), (2,2), (4,4)})
+ self.assertEqual(k1 - k2, set())
+ self.assertEqual(k1 - k3, {(1,1), (2,2)})
+ self.assertEqual(k2 - k1, {(3,3)})
+ self.assertEqual(k3 - k1, {(4,4)})
+ self.assertEqual(k1 & k2, {(1,1), (2,2)})
+ self.assertEqual(k1 & k3, set())
+ self.assertEqual(k1 | k2, {(1,1), (2,2), (3,3)})
+ self.assertEqual(k1 ^ k2, {(3,3)})
+ self.assertEqual(k1 ^ k3, {(1,1), (2,2), (4,4)})
 
 def test_dictview_mixed_set_operations(self):
 # Just a few for .keys()
 self.assertTrue({1:1}.keys() == {1})
 self.assertTrue({1} == {1:1}.keys())
- self.assertEquals({1:1}.keys() | {2}, {1, 2})
- self.assertEquals({2} | {1:1}.keys(), {1, 2})
+ self.assertEqual({1:1}.keys() | {2}, {1, 2})
+ self.assertEqual({2} | {1:1}.keys(), {1, 2})
 # And a few for .items()
 self.assertTrue({1:1}.items() == {(1,1)})
 self.assertTrue({(1,1)} == {1:1}.items())
- self.assertEquals({1:1}.items() | {2}, {(1,1), 2})
- self.assertEquals({2} | {1:1}.items(), {(1,1), 2})
+ self.assertEqual({1:1}.items() | {2}, {(1,1), 2})
+ self.assertEqual({2} | {1:1}.items(), {(1,1), 2})
 
 def test_missing(self):
 # Make sure dict doesn't have a __missing__ method
- self.assertEqual(hasattr(dict, "__missing__"), False)
- self.assertEqual(hasattr({}, "__missing__"), False)
+ self.assertFalse(hasattr(dict, "__missing__"))
+ self.assertFalse(hasattr({}, "__missing__"))
 # Test several cases:
 # (D) subclass defines __missing__ method returning a value
 # (E) subclass defines __missing__ method raising RuntimeError
@@ -522,46 +524,37 @@
 self.assertNotIn(2, d)
 self.assertNotIn(2, d.keys())
 self.assertEqual(d[2], 42)
+
 class E(dict):
 def __missing__(self, key):
 raise RuntimeError(key)
 e = E()
- try:
+ with self.assertRaises(RuntimeError) as c:
 e[42]
- except RuntimeError as err:
- self.assertEqual(err.args, (42,))
- else:
- self.fail("e[42] didn't raise RuntimeError")
+ self.assertEqual(c.exception.args, (42,))
+
 class F(dict):
 def __init__(self):
 # An instance variable __missing__ should have no effect
 self.__missing__ = lambda key: None
 f = F()
- try:
+ with self.assertRaises(KeyError) as c:
 f[42]
- except KeyError as err:
- self.assertEqual(err.args, (42,))
- else:
- self.fail("f[42] didn't raise KeyError")
+ self.assertEqual(c.exception.args, (42,))
+
 class G(dict):
 pass
 g = G()
- try:
+ with self.assertRaises(KeyError) as c:
 g[42]
- except KeyError as err:
- self.assertEqual(err.args, (42,))
- else:
- self.fail("g[42] didn't raise KeyError")
+ self.assertEqual(c.exception.args, (42,))
 
 def test_tuple_keyerror(self):
 # SF #1576657
 d = {}
- try:
+ with self.assertRaises(KeyError) as c:
 d[(1,)]
- except KeyError as e:
- self.assertEqual(e.args, ((1,),))
- else:
- self.fail("missing KeyError")
+ self.assertEqual(c.exception.args, ((1,),))
 
 def test_bad_key(self):
 # Dictionary lookups should fail if __eq__() raises an exception.
@@ -588,12 +581,8 @@
 'd.setdefault(x2, 42)',
 'd.pop(x2)',
 'd.update({x2: 2})']:
- try:
+ with self.assertRaises(CustomException):
 exec(stmt, locals())
- except CustomException:
- pass
- else:
- self.fail("Statement %r didn't raise exception" % stmt)
 
 def test_resize1(self):
 # Dict resizing bug, found by Jack Jansen in 2.2 CVS development.
@@ -636,11 +625,9 @@
 def test_empty_presized_dict_in_freelist(self):
 # Bug #3537: if an empty but presized dict with a size larger
 # than 7 was in the freelist, it triggered an assertion failure
- try:
- d = {'a': 1/0, 'b': None, 'c': None, 'd': None, 'e': None,
+ with self.assertRaises(ZeroDivisionError):
+ d = {'a': 1 // 0, 'b': None, 'c': None, 'd': None, 'e': None,
 'f': None, 'g': None, 'h': None}
- except ZeroDivisionError:
- pass
 d = {}
 
 def test_container_iterator(self):
@@ -657,7 +644,7 @@
 obj.x = iter(obj.v)
 del obj, container
 gc.collect()
- self.assertTrue(ref() is None, "Cycle was not collected")
+ self.assertIs(ref(), None, "Cycle was not collected")
 
 def _not_tracked(self, t):
 # Nested containers can take several collections to untrack
