Private GIT

Skip to content
Snippets Groups Projects
Commit 83bad581 authored by labrys's avatar labrys
Browse files

Lint 10/10

parent 4b6acf51
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 284 additions and 266 deletions
tests/numdict_tests.py
+ 284
− 266
View file @ 83bad581
...@@ -4,6 +4,8 @@ ...@@ -4,6 +4,8 @@
Unit Tests for sickbeard/numdict.py Unit Tests for sickbeard/numdict.py
""" """
# pylint: disable=line-too-long
import sys import sys
import os.path import os.path
import unittest import unittest
...@@ -16,7 +18,7 @@ from sickbeard.numdict import NumDict ...@@ -16,7 +18,7 @@ from sickbeard.numdict import NumDict
PY3 = sys.version_info >= (3, ) PY3 = sys.version_info >= (3, )
if PY3: if PY3:
from collections import UserDict from collections import UserDict # pylint: disable=no-name-in-module
else: else:
from UserDict import UserDict from UserDict import UserDict
...@@ -25,97 +27,97 @@ class NumDictTest(unittest.TestCase): ...@@ -25,97 +27,97 @@ class NumDictTest(unittest.TestCase):
""" """
Test the NumDict class Test the NumDict class
""" """
def test_constructors(self): def test_constructors(self): # pylint: disable=too-many-locals, too-many-statements
""" """
Test NumDict constructors Test NumDict constructors
""" """
# dicts for testing # dicts for testing
d0 = {} # Empty dictionary dict_0 = {} # Empty dictionary
d1 = {1: 'Elephant'} # Single numeric key dict_1 = {1: 'Elephant'} # Single numeric key
d2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys dict_2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys
d3 = {'3': 'Aardvark'} # Numeric string key dict_3 = {'3': 'Aardvark'} # Numeric string key
d4 = {'3': 'Aardvark', '4': 'Ant'} # Multiple numeric string keys dict_4 = {'3': 'Aardvark', '4': 'Ant'} # Multiple numeric string keys
d5 = {5: 'Cat', '6': 'Dog'} # Mixed numeric and numeric string keys dict_5 = {5: 'Cat', '6': 'Dog'} # Mixed numeric and numeric string keys
d6 = {1: None, '2': None} # None as values dict_6 = {1: None, '2': None} # None as values
d7 = {None: 'Empty'} # None as key dict_7 = {None: 'Empty'} # None as key
# Construct NumDicts from dicts # Construct NumDicts from dicts
n = NumDict() num_dict = NumDict()
n0 = NumDict(d0) num_dict_0 = NumDict(dict_0)
n1 = NumDict(d1) num_dict_1 = NumDict(dict_1)
n2 = NumDict(d2) num_dict_2 = NumDict(dict_2)
n3 = NumDict(d3) num_dict_3 = NumDict(dict_3)
n4 = NumDict(d4) num_dict_4 = NumDict(dict_4)
n5 = NumDict(d5) num_dict_5 = NumDict(dict_5)
n6 = NumDict(d6) num_dict_6 = NumDict(dict_6)
n7 = NumDict(d7) num_dict_7 = NumDict(dict_7)
# Most NumDicts from dicts should compare equal... # Most NumDicts from dicts should compare equal...
self.assertEqual(n, {}) self.assertEqual(num_dict, {})
self.assertEqual(n0, d0) self.assertEqual(num_dict_0, dict_0)
self.assertEqual(n1, d1) self.assertEqual(num_dict_1, dict_1)
self.assertEqual(n2, d2) self.assertEqual(num_dict_2, dict_2)
# ...however, numeric keys are not equal to numeric string keys... # ...however, numeric keys are not equal to numeric string keys...
self.assertNotEqual(n3, d3) self.assertNotEqual(num_dict_3, dict_3)
self.assertNotEqual(n4, d4) self.assertNotEqual(num_dict_4, dict_4)
self.assertNotEqual(n5, d5) self.assertNotEqual(num_dict_5, dict_5)
self.assertNotEqual(n6, d6) self.assertNotEqual(num_dict_6, dict_6)
# ...but None keys work just fine # ...but None keys work just fine
self.assertEqual(n7, d7) self.assertEqual(num_dict_7, dict_7)
# Construct dicts from NumDicts # Construct dicts from NumDicts
dn = dict(n) dict_from_num_dict = dict(num_dict)
dn1 = dict(n1) dict_from_num_dict_1 = dict(num_dict_1)
dn2 = dict(n2) dict_from_num_dict_2 = dict(num_dict_2)
dn3 = dict(n3) dict_from_num_dict_3 = dict(num_dict_3)
dn4 = dict(n4) dict_from_num_dict_4 = dict(num_dict_4)
dn5 = dict(n5) dict_from_num_dict_5 = dict(num_dict_5)
dn6 = dict(n6) dict_from_num_dict_6 = dict(num_dict_6)
dn7 = dict(n7) dict_from_num_dict_7 = dict(num_dict_7)
# All dicts from NumDicts should compare equal # All dicts from NumDicts should compare equal
self.assertEqual(n, dn) self.assertEqual(num_dict, dict_from_num_dict)
self.assertEqual(n1, dn1) self.assertEqual(num_dict_1, dict_from_num_dict_1)
self.assertEqual(n2, dn2) self.assertEqual(num_dict_2, dict_from_num_dict_2)
self.assertEqual(n3, dn3) self.assertEqual(num_dict_3, dict_from_num_dict_3)
self.assertEqual(n4, dn4) self.assertEqual(num_dict_4, dict_from_num_dict_4)
self.assertEqual(n5, dn5) self.assertEqual(num_dict_5, dict_from_num_dict_5)
self.assertEqual(n6, dn6) self.assertEqual(num_dict_6, dict_from_num_dict_6)
self.assertEqual(n7, dn7) self.assertEqual(num_dict_7, dict_from_num_dict_7)
# Construct NumDicts from NumDicts # Construct NumDicts from NumDicts
nn = NumDict(n) num_dict_from_num_dict = NumDict(num_dict)
nn0 = NumDict(n0) num_dict_from_num_dict_0 = NumDict(num_dict_0)
nn1 = NumDict(n1) num_dict_from_num_dict_1 = NumDict(num_dict_1)
nn2 = NumDict(n2) num_dict_from_num_dict_2 = NumDict(num_dict_2)
nn3 = NumDict(n3) num_dict_from_num_dict_3 = NumDict(num_dict_3)
nn4 = NumDict(n4) num_dict_from_num_dict_4 = NumDict(num_dict_4)
nn5 = NumDict(n5) num_dict_from_num_dict_5 = NumDict(num_dict_5)
nn6 = NumDict(n6) num_dict_from_num_dict_6 = NumDict(num_dict_6)
nn7 = NumDict(n7) num_dict_from_num_dict_7 = NumDict(num_dict_7)
# All NumDicts from NumDicts should compare equal # All NumDicts from NumDicts should compare equal
self.assertEqual(n, nn) self.assertEqual(num_dict, num_dict_from_num_dict)
self.assertEqual(n0, nn0) self.assertEqual(num_dict_0, num_dict_from_num_dict_0)
self.assertEqual(n1, nn1) self.assertEqual(num_dict_1, num_dict_from_num_dict_1)
self.assertEqual(n2, nn2) self.assertEqual(num_dict_2, num_dict_from_num_dict_2)
self.assertEqual(n3, nn3) self.assertEqual(num_dict_3, num_dict_from_num_dict_3)
self.assertEqual(n4, nn4) self.assertEqual(num_dict_4, num_dict_from_num_dict_4)
self.assertEqual(n5, nn5) self.assertEqual(num_dict_5, num_dict_from_num_dict_5)
self.assertEqual(n6, nn6) self.assertEqual(num_dict_6, num_dict_from_num_dict_6)
self.assertEqual(n7, nn7) self.assertEqual(num_dict_7, num_dict_from_num_dict_7)
# keyword arg constructor should fail # keyword arg constructor should fail
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
NumDict(one=1, two=2) # Raise TypeError since we can't have numeric keywords NumDict(one=1, two=2) # Raise TypeError since we can't have numeric keywords
# item sequence constructors work fine... # item sequence constructors work fine...
self.assertEqual(NumDict([(1, 'Elephant'), (2, 'Mouse')]), dn2) self.assertEqual(NumDict([(1, 'Elephant'), (2, 'Mouse')]), dict_from_num_dict_2)
self.assertEqual(NumDict(dict=[(1, 'Elephant'), (2, 'Mouse')]), dn2) self.assertEqual(NumDict(dict=[(1, 'Elephant'), (2, 'Mouse')]), dict_from_num_dict_2)
self.assertEqual(NumDict([(1, 'Elephant'), ('2', 'Mouse')]), dn2) self.assertEqual(NumDict([(1, 'Elephant'), ('2', 'Mouse')]), dict_from_num_dict_2)
self.assertEqual(NumDict(dict=[('1', 'Elephant'), (2, 'Mouse')]), dn2) self.assertEqual(NumDict(dict=[('1', 'Elephant'), (2, 'Mouse')]), dict_from_num_dict_2)
# ...unless you have a non-numeric key # ...unless you have a non-numeric key
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
...@@ -128,39 +130,42 @@ class NumDictTest(unittest.TestCase): ...@@ -128,39 +130,42 @@ class NumDictTest(unittest.TestCase):
NumDict([(1, 'one'), (2, 'two')], two=3, five=4) NumDict([(1, 'one'), (2, 'two')], two=3, five=4)
# alternate constructors # alternate constructors
d8 = {1: 'Echo', 2: 'Echo'} dict_8 = {1: 'Echo', 2: 'Echo'}
self.assertEqual(NumDict.fromkeys('1 2'.split()), dn6) self.assertEqual(NumDict.fromkeys('1 2'.split()), dict_from_num_dict_6)
self.assertEqual(NumDict().fromkeys('1 2'.split()), dn6) self.assertEqual(NumDict().fromkeys('1 2'.split()), dict_from_num_dict_6)
self.assertEqual(NumDict.fromkeys('1 2'.split(), 'Echo'), d8) self.assertEqual(NumDict.fromkeys('1 2'.split(), 'Echo'), dict_8)
self.assertEqual(NumDict().fromkeys('1 2'.split(), 'Echo'), d8) self.assertEqual(NumDict().fromkeys('1 2'.split(), 'Echo'), dict_8)
self.assertTrue(n1.fromkeys('1 2'.split()) is not n1) self.assertTrue(num_dict_1.fromkeys('1 2'.split()) is not num_dict_1)
self.assertIsInstance(n1.fromkeys('1 2'.split()), NumDict) self.assertIsInstance(num_dict_1.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(n2.fromkeys('1 2'.split()), NumDict) self.assertIsInstance(num_dict_2.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(n3.fromkeys('1 2'.split()), NumDict) self.assertIsInstance(num_dict_3.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(n4.fromkeys('1 2'.split()), NumDict) self.assertIsInstance(num_dict_4.fromkeys('1 2'.split()), NumDict)
def test_repr(self): def test_repr(self): # pylint: disable=too-many-locals
"""
Test representation of NumDicts
"""
# dicts for testing # dicts for testing
d0 = {} # Empty dictionary dict_0 = {} # Empty dictionary
d1 = {1: 'Elephant'} # Single numeric key dict_1 = {1: 'Elephant'} # Single numeric key
d2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys dict_2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys
d3 = {'3': 'Aardvark'} # Numeric string key dict_3 = {'3': 'Aardvark'} # Numeric string key
d4 = {'3': 'Aardvark', '4': 'Ant'} # Multiple numeric string keys dict_4 = {'3': 'Aardvark', '4': 'Ant'} # Multiple numeric string keys
d5 = {5: 'Cat', '6': 'Dog'} # Mixed numeric and numeric string keys dict_5 = {5: 'Cat', '6': 'Dog'} # Mixed numeric and numeric string keys
d6 = {1: None, '2': None} # None as values dict_6 = {1: None, '2': None} # None as values
d7 = {None: 'Empty'} # None as key dict_7 = {None: 'Empty'} # None as key
# Construct NumDicts from dicts # Construct NumDicts from dicts
n = NumDict() num_dict = NumDict()
n0 = NumDict(d0) num_dict_0 = NumDict(dict_0)
n1 = NumDict(d1) num_dict_1 = NumDict(dict_1)
n2 = NumDict(d2) num_dict_2 = NumDict(dict_2)
n3 = NumDict(d3) num_dict_3 = NumDict(dict_3)
n4 = NumDict(d4) num_dict_4 = NumDict(dict_4)
n5 = NumDict(d5) num_dict_5 = NumDict(dict_5)
n6 = NumDict(d6) num_dict_6 = NumDict(dict_6)
n7 = NumDict(d7) num_dict_7 = NumDict(dict_7)
reps = ( reps = (
"{}", "{}",
...@@ -174,137 +179,143 @@ class NumDictTest(unittest.TestCase): ...@@ -174,137 +179,143 @@ class NumDictTest(unittest.TestCase):
) )
# Most representations of NumDicts should compare equal to dicts... # Most representations of NumDicts should compare equal to dicts...
self.assertEqual(str(n), str({})) self.assertEqual(str(num_dict), str({}))
self.assertEqual(repr(n), repr({})) self.assertEqual(repr(num_dict), repr({}))
self.assertIn(repr(n), reps) self.assertIn(repr(num_dict), reps)
self.assertEqual(str(n0), str(d0)) self.assertEqual(str(num_dict_0), str(dict_0))
self.assertEqual(repr(n0), repr(d0)) self.assertEqual(repr(num_dict_0), repr(dict_0))
self.assertIn(repr(n0), reps) self.assertIn(repr(num_dict_0), reps)
self.assertEqual(str(n1), str(d1)) self.assertEqual(str(num_dict_1), str(dict_1))
self.assertEqual(repr(n1), repr(d1)) self.assertEqual(repr(num_dict_1), repr(dict_1))
self.assertIn(repr(n1), reps) self.assertIn(repr(num_dict_1), reps)
self.assertEqual(str(n2), str(d2)) self.assertEqual(str(num_dict_2), str(dict_2))
self.assertEqual(repr(n2), repr(d2)) self.assertEqual(repr(num_dict_2), repr(dict_2))
self.assertIn(repr(n2), reps) self.assertIn(repr(num_dict_2), reps)
# ...however, numeric keys are not equal to numeric string keys... # ...however, numeric keys are not equal to numeric string keys...
# ...so the string representations for those are different... # ...so the string representations for those are different...
self.assertNotEqual(str(n3), str(d3)) self.assertNotEqual(str(num_dict_3), str(dict_3))
self.assertNotEqual(repr(n3), repr(d3)) self.assertNotEqual(repr(num_dict_3), repr(dict_3))
self.assertNotIn(repr(n3), reps) self.assertNotIn(repr(num_dict_3), reps)
self.assertNotEqual(str(n4), str(d4)) self.assertNotEqual(str(num_dict_4), str(dict_4))
self.assertNotEqual(repr(n4), repr(d4)) self.assertNotEqual(repr(num_dict_4), repr(dict_4))
self.assertNotIn(repr(n4), reps) self.assertNotIn(repr(num_dict_4), reps)
self.assertNotEqual(str(n5), str(d5)) self.assertNotEqual(str(num_dict_5), str(dict_5))
self.assertNotEqual(repr(n5), repr(d5)) self.assertNotEqual(repr(num_dict_5), repr(dict_5))
self.assertNotIn(repr(n5), reps) self.assertNotIn(repr(num_dict_5), reps)
self.assertNotEqual(str(n6), str(d6)) self.assertNotEqual(str(num_dict_6), str(dict_6))
self.assertNotEqual(repr(n6), repr(d6)) self.assertNotEqual(repr(num_dict_6), repr(dict_6))
self.assertNotIn(repr(n6), reps) self.assertNotIn(repr(num_dict_6), reps)
# ...but None keys work just fine # ...but None keys work just fine
self.assertEqual(str(n7), str(d7)) self.assertEqual(str(num_dict_7), str(dict_7))
self.assertEqual(repr(n7), repr(d7)) self.assertEqual(repr(num_dict_7), repr(dict_7))
self.assertIn(repr(n7), reps) self.assertIn(repr(num_dict_7), reps)
def test_rich_comparison_and_len(self): def test_rich_comparison_and_len(self):
"""
Test rich comparison and length
"""
# dicts for testing # dicts for testing
d0 = {} # Empty dictionary dict_0 = {} # Empty dictionary
d1 = {1: 'Elephant'} # Single numeric key dict_1 = {1: 'Elephant'} # Single numeric key
d2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys dict_2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys
# Construct NumDicts from dicts # Construct NumDicts from dicts
n = NumDict() num_dict = NumDict()
n0 = NumDict(d0) num_dict_0 = NumDict(dict_0)
n1 = NumDict(d1) num_dict_1 = NumDict(dict_1)
n2 = NumDict(d2) num_dict_2 = NumDict(dict_2)
# Construct NumDicts from NumDicts # Construct NumDicts from NumDicts
nn = NumDict(n) num_dict_from_num_dict = NumDict(num_dict)
nn0 = NumDict(n0) num_dict_from_num_dict_0 = NumDict(num_dict_0)
nn1 = NumDict(n1) num_dict_from_num_dict_1 = NumDict(num_dict_1)
nn2 = NumDict(n2) num_dict_from_num_dict_2 = NumDict(num_dict_2)
all_dicts = [d0, d1, d2, n, n0, n1, n2, nn, nn0, nn1, nn2] all_dicts = [dict_0, dict_1, dict_2, num_dict, num_dict_0, num_dict_1, num_dict_2, num_dict_from_num_dict, num_dict_from_num_dict_0, num_dict_from_num_dict_1, num_dict_from_num_dict_2]
for a in all_dicts: for val_a in all_dicts:
for b in all_dicts: for val_b in all_dicts:
self.assertEqual(a == b, len(a) == len(b)) self.assertEqual(val_a == val_b, len(val_a) == len(val_b))
def test_dict_access_and_modification(self): def test_dict_access_and_mod(self): # pylint: disable=too-many-locals, too-many-statements
"""
Test num dict access and modification
"""
# dicts for testing # dicts for testing
d0 = {} # Empty dictionary dict_0 = {} # Empty dictionary
d1 = {1: 'Elephant'} # Single numeric key dict_1 = {1: 'Elephant'} # Single numeric key
d2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys dict_2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys
# Construct NumDicts from dicts # Construct NumDicts from dicts
n0 = NumDict() num_dict_0 = NumDict()
n1 = NumDict(d1) num_dict_1 = NumDict(dict_1)
n2 = NumDict(d2) num_dict_2 = NumDict(dict_2)
# test __getitem__ # test __getitem__
self.assertEqual(n2[1], 'Elephant') self.assertEqual(num_dict_2[1], 'Elephant')
with self.assertRaises(KeyError): with self.assertRaises(KeyError):
n1['Mouse'] # key is not numeric _ = num_dict_1['Mouse'] # key is not numeric
with self.assertRaises(KeyError): with self.assertRaises(KeyError):
n1.__getitem__('Mouse') # key is not numeric _ = num_dict_1.__getitem__('Mouse') # key is not numeric
with self.assertRaises(KeyError): with self.assertRaises(KeyError):
n1[None] # key does not exist _ = num_dict_1[None] # key does not exist
with self.assertRaises(KeyError): with self.assertRaises(KeyError):
n1.__getitem__(None) # key does not exist _ = num_dict_1.__getitem__(None) # key does not exist
# Test __setitem__ # Test __setitem__
n3 = NumDict(n2) num_dict_3 = NumDict(num_dict_2)
self.assertEqual(n2, n3) self.assertEqual(num_dict_2, num_dict_3)
n3[2] = 'Frog' num_dict_3[2] = 'Frog'
self.assertNotEqual(n2, n3) self.assertNotEqual(num_dict_2, num_dict_3)
# Check None keys and numeric key conversion # Check None keys and numeric key conversion
n3['3'] = 'Armadillo' num_dict_3['3'] = 'Armadillo'
n3[None] = 'Cockroach' num_dict_3[None] = 'Cockroach'
# Check long ints # Check long ints
n3[12390809518259081208909880312] = 'Squid' num_dict_3[12390809518259081208909880312] = 'Squid'
n3['12390809518259081208909880312'] = 'Octopus' num_dict_3['12390809518259081208909880312'] = 'Octopus'
self.assertEqual(n3[12390809518259081208909880312], 'Octopus') self.assertEqual(num_dict_3[12390809518259081208909880312], 'Octopus')
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
n3.__setitem__('Gorilla', 1) # key is not numeric num_dict_3.__setitem__('Gorilla', 1) # key is not numeric
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
n3['Chimpanzee'] = 1 # key is not numeric num_dict_3['Chimpanzee'] = 1 # key is not numeric
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
n3[(4, 1)] = 1 # key is not numeric num_dict_3[(4, 1)] = 1 # key is not numeric
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
n3[[1, 3, 4]] = 1 # key is not numeric and is not hashable num_dict_3[[1, 3, 4]] = 1 # key is not numeric and is not hashable
# Test __delitem__ # Test __delitem__
del n3[3] del num_dict_3[3]
del n3[None] del num_dict_3[None]
with self.assertRaises(KeyError): with self.assertRaises(KeyError):
del n3[3] # already deleted del num_dict_3[3] # already deleted
with self.assertRaises(KeyError): with self.assertRaises(KeyError):
n3.__delitem__(3) # already deleted num_dict_3.__delitem__(3) # already deleted
with self.assertRaises(KeyError): with self.assertRaises(KeyError):
del n3['Mouse'] # key would not exist, since it is not numeric del num_dict_3['Mouse'] # key would not exist, since it is not numeric
# Test clear # Test clear
n3.clear() num_dict_3.clear()
self.assertEqual(n3, {}) self.assertEqual(num_dict_3, {})
# Test copy() # Test copy()
n2a = d2.copy() num_dict_2a = dict_2.copy()
self.assertEqual(n2, n2a) self.assertEqual(num_dict_2, num_dict_2a)
n2b = n2.copy() num_dict_2b = num_dict_2.copy()
self.assertEqual(n2b, n2) self.assertEqual(num_dict_2b, num_dict_2)
n2c = UserDict({1: 'Elephant', 2: 'Mouse'}) num_dict_2c = UserDict({1: 'Elephant', 2: 'Mouse'})
n2d = n2c.copy() # making a copy of a UserDict is special cased num_dict_2d = num_dict_2c.copy() # making a copy of a UserDict is special cased
self.assertEqual(n2c, n2d) self.assertEqual(num_dict_2c, num_dict_2d)
class MyNumDict(NumDict): class MyNumDict(NumDict):
""" """
...@@ -316,131 +327,135 @@ class NumDictTest(unittest.TestCase): ...@@ -316,131 +327,135 @@ class NumDictTest(unittest.TestCase):
""" """
print('MyNumDict:', self) print('MyNumDict:', self)
m2 = MyNumDict(n2) my_num_dict = MyNumDict(num_dict_2)
m2a = m2.copy() my_num_dict_a = my_num_dict.copy()
self.assertEqual(m2a, m2) self.assertEqual(my_num_dict_a, my_num_dict)
m2[1] = 'Frog' my_num_dict[1] = 'Frog'
self.assertNotEqual(m2a, m2) self.assertNotEqual(my_num_dict_a, my_num_dict)
# Test keys, items, values # Test keys, items, values
self.assertEqual(sorted(n2.keys()), sorted(d2.keys())) self.assertEqual(sorted(num_dict_2.keys()), sorted(dict_2.keys()))
self.assertEqual(sorted(n2.items()), sorted(d2.items())) self.assertEqual(sorted(num_dict_2.items()), sorted(dict_2.items()))
self.assertEqual(sorted(n2.values()), sorted(d2.values())) self.assertEqual(sorted(num_dict_2.values()), sorted(dict_2.values()))
# Test "in". # Test "in".
for i in n2: for i in num_dict_2:
self.assertIn(i, n2) self.assertIn(i, num_dict_2)
self.assertEqual(i in n1, i in d1) self.assertEqual(i in num_dict_1, i in dict_1)
self.assertEqual(i in n0, i in d0) self.assertEqual(i in num_dict_0, i in dict_0)
self.assertFalse(None in n2) self.assertFalse(None in num_dict_2)
self.assertEqual(None in n2, None in d2) self.assertEqual(None in num_dict_2, None in dict_2)
d2[None] = 'Cow' dict_2[None] = 'Cow'
n2[None] = d2[None] num_dict_2[None] = dict_2[None]
self.assertTrue(None in n2) self.assertTrue(None in num_dict_2)
self.assertEqual(None in n2, None in d2) self.assertEqual(None in num_dict_2, None in dict_2)
self.assertEqual(n2.has_key(None), None in d2) self.assertEqual(num_dict_2.has_key(None), None in dict_2)
if not PY3: if not PY3:
self.assertEqual(n2.has_key(None), d2.has_key(None)) self.assertEqual(num_dict_2.has_key(None), dict_2.has_key(None))
self.assertFalse('Penguin' in n2) self.assertFalse('Penguin' in num_dict_2)
# Test update # Test update
t = NumDict() test = NumDict()
t.update(d2) test.update(dict_2)
self.assertEqual(t, n2) self.assertEqual(test, num_dict_2)
# Test get # Test get
for i in n2: for i in num_dict_2:
self.assertEqual(n2.get(i), n2[i]) self.assertEqual(num_dict_2.get(i), num_dict_2[i])
self.assertEqual(n1.get(i), d1.get(i)) self.assertEqual(num_dict_1.get(i), dict_1.get(i))
self.assertEqual(n0.get(i), d0.get(i)) self.assertEqual(num_dict_0.get(i), dict_0.get(i))
for i in ['purple', None, 12312301924091284, 23]: for i in ['purple', None, 12312301924091284, 23]:
self.assertEqual(n2.get(i), d2.get(i), i) self.assertEqual(num_dict_2.get(i), dict_2.get(i), i)
with self.assertRaises(AssertionError): with self.assertRaises(AssertionError):
i = '1' i = '1'
self.assertEqual(n2.get(i), d2.get(i), i) # d2 expects string key which does not exist self.assertEqual(num_dict_2.get(i), dict_2.get(i), i) # dict_2 expects string key which does not exist
# Test "in" iteration. # Test "in" iteration.
n2b = n2 num_dict_2b = num_dict_2
for i in range(20): for i in range(20):
n2[i] = str(i) num_dict_2[i] = str(i)
n2b[str(i)] = str(i) num_dict_2b[str(i)] = str(i)
self.assertEqual(n2, n2b) self.assertEqual(num_dict_2, num_dict_2b)
ikeys = [] ikeys = []
for k in n2: for k in num_dict_2:
ikeys.append(k) ikeys.append(k)
self.assertEqual(set(ikeys), set(n2.keys())) self.assertEqual(set(ikeys), set(num_dict_2.keys()))
# Test setdefault # Test setdefault
x = 1 val = 1
t = NumDict() test = NumDict()
self.assertEqual(t.setdefault(x, 42), 42) self.assertEqual(test.setdefault(val, 42), 42)
self.assertEqual(t.setdefault(x, '42'), 42) self.assertEqual(test.setdefault(val, '42'), 42)
self.assertNotEqual(t.setdefault(x, 42), '42') self.assertNotEqual(test.setdefault(val, 42), '42')
self.assertNotEqual(t.setdefault(x, '42'), '42') self.assertNotEqual(test.setdefault(val, '42'), '42')
self.assertIn(x, t) self.assertIn(val, test)
self.assertEqual(t.setdefault(x, 23), 42) self.assertEqual(test.setdefault(val, 23), 42)
self.assertEqual(t.setdefault(x, '23'), 42) self.assertEqual(test.setdefault(val, '23'), 42)
self.assertNotEqual(t.setdefault(x, 23), '42') self.assertNotEqual(test.setdefault(val, 23), '42')
self.assertNotEqual(t.setdefault(x, '23'), '42') self.assertNotEqual(test.setdefault(val, '23'), '42')
self.assertIn(x, t) self.assertIn(val, test)
# Test pop # Test pop
x = 1 val = 1
t = NumDict({x: 42}) test = NumDict({val: 42})
self.assertEqual(t.pop(x), 42) self.assertEqual(test.pop(val), 42)
self.assertRaises(KeyError, t.pop, x) self.assertRaises(KeyError, test.pop, val)
self.assertEqual(t.pop(x, 1), 1) self.assertEqual(test.pop(val, 1), 1)
t[x] = 42 test[val] = 42
self.assertEqual(t.pop(x, 1), 42) self.assertEqual(test.pop(val, 1), 42)
# Test popitem # Test popitem
x = 1 val = 1
t = NumDict({x: 42}) test = NumDict({val: 42})
self.assertEqual(t.popitem(), (x, 42)) self.assertEqual(test.popitem(), (val, 42))
self.assertRaises(KeyError, t.popitem) self.assertRaises(KeyError, test.popitem)
def test_missing(self): def test_missing(self):
"""
Test missing keys
"""
# Make sure NumDict doesn't have a __missing__ method # Make sure NumDict doesn't have a __missing__ method
self.assertEqual(hasattr(NumDict, "__missing__"), False) self.assertEqual(hasattr(NumDict, "__missing__"), False)
class D(NumDict): class NumDictD(NumDict):
""" """
subclass defines __missing__ method returning a value subclass defines __missing__ method returning a value
""" """
def __missing__(self, key): def __missing__(self, key): # pylint: disable=no-self-use
return 42 key = 42
return key
d = D({1: 2, 3: 4})
self.assertEqual(d[1], 2) num_dict_d = NumDictD({1: 2, 3: 4})
self.assertEqual(d[3], 4) self.assertEqual(num_dict_d[1], 2)
self.assertNotIn(2, d) self.assertEqual(num_dict_d[3], 4)
self.assertNotIn(2, d.keys()) self.assertNotIn(2, num_dict_d)
self.assertEqual(d[2], 42) self.assertNotIn(2, num_dict_d.keys())
self.assertEqual(num_dict_d[2], 42)
class E(NumDict):
class NumDictE(NumDict):
""" """
subclass defines __missing__ method raising RuntimeError subclass defines __missing__ method raising RuntimeError
""" """
def __missing__(self, key): def __missing__(self, key): # pylint: disable=no-self-use
raise RuntimeError(key) raise RuntimeError(key)
e = E() num_dict_e = NumDictE()
try: try:
e[42] num_dict_e[42]
except RuntimeError as err: except RuntimeError as err:
self.assertEqual(err.args, (42,)) self.assertEqual(err.args, (42,))
else: else:
self.fail("e[42] didn't raise RuntimeError") self.fail("num_dict_e[42] didn't raise RuntimeError")
class F(NumDict): class NumDictF(NumDict):
""" """
subclass sets __missing__ instance variable (no effect) subclass sets __missing__ instance variable (no effect)
""" """
...@@ -448,40 +463,43 @@ class NumDictTest(unittest.TestCase): ...@@ -448,40 +463,43 @@ class NumDictTest(unittest.TestCase):
# An instance variable __missing__ should have no effect # An instance variable __missing__ should have no effect
self.__missing__ = lambda key: None self.__missing__ = lambda key: None
NumDict.__init__(self) NumDict.__init__(self)
f = F() num_dict_f = NumDictF()
try: try:
f[42] num_dict_f[42]
except KeyError as err: except KeyError as err:
self.assertEqual(err.args, (42,)) self.assertEqual(err.args, (42,))
else: else:
self.fail("f[42] didn't raise KeyError") self.fail("num_dict_f[42] didn't raise KeyError")
class G(NumDict): class NumDictG(NumDict):
""" """
subclass doesn't define __missing__ at a all subclass doesn't define __missing__ at a all
""" """
pass pass
g = G() num_dict_g = NumDictG()
try: try:
g[42] num_dict_g[42]
except KeyError as err: except KeyError as err:
self.assertEqual(err.args, (42,)) self.assertEqual(err.args, (42,))
else: else:
self.fail("g[42] didn't raise KeyError") self.fail("num_dict_g[42] didn't raise KeyError")
class H(D): class NumDictH(NumDictD):
""" """
subclass calls super classes __missing__ and modifies the value before returning it subclass calls super classes __missing__ and modifies the value before returning it
""" """
def __missing__(self, key): def __missing__(self, key): # pylint: disable=arguments-differ
return super(H, self).__missing__(key) + 1 return super(NumDictH, self).__missing__(key) + 1
h = H() num_dict_h = NumDictH()
self.assertEqual(h[None], d[None]+1) self.assertEqual(num_dict_h[None], num_dict_d[None]+1)
def test_main(): def test_main():
"""
Run tests when run as main
"""
import logging import logging
log = logging.getLogger(__name__) log = logging.getLogger(__name__)
logging.basicConfig(level=logging.DEBUG) logging.basicConfig(level=logging.DEBUG)
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment

Another place to be (or not)