def test_constructors(self):
"""
Test NumDict constructors
"""
# dicts for testing
dict_0 = {} # Empty dictionary
dict_1 = {1: 'Elephant'} # Single numeric key
dict_2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys
dict_3 = {'3': 'Aardvark'} # Numeric string key
dict_4 = {'3': 'Aardvark', '4': 'Ant'} # Multiple numeric string keys
dict_5 = {
5: 'Cat',
'6': 'Dog'
} # Mixed numeric and numeric string keys
dict_6 = {1: None, '2': None} # None as values
dict_7 = {None: 'Empty'} # None as key
# Construct NumDicts from dicts
num_dict = NumDict()
num_dict_0 = NumDict(dict_0)
num_dict_1 = NumDict(dict_1)
num_dict_2 = NumDict(dict_2)
num_dict_3 = NumDict(dict_3)
num_dict_4 = NumDict(dict_4)
num_dict_5 = NumDict(dict_5)
num_dict_6 = NumDict(dict_6)
num_dict_7 = NumDict(dict_7)
# Most NumDicts from dicts should compare equal...
self.assertEqual(num_dict, {})
self.assertEqual(num_dict_0, dict_0)
self.assertEqual(num_dict_1, dict_1)
self.assertEqual(num_dict_2, dict_2)
# ...however, numeric keys are not equal to numeric string keys...
self.assertNotEqual(num_dict_3, dict_3)
self.assertNotEqual(num_dict_4, dict_4)
self.assertNotEqual(num_dict_5, dict_5)
self.assertNotEqual(num_dict_6, dict_6)
# ...but None keys work just fine
self.assertEqual(num_dict_7, dict_7)
# Construct dicts from NumDicts
dict_from_num_dict = dict(num_dict)
dict_from_num_dict_1 = dict(num_dict_1)
dict_from_num_dict_2 = dict(num_dict_2)
dict_from_num_dict_3 = dict(num_dict_3)
dict_from_num_dict_4 = dict(num_dict_4)
dict_from_num_dict_5 = dict(num_dict_5)
dict_from_num_dict_6 = dict(num_dict_6)
dict_from_num_dict_7 = dict(num_dict_7)
# All dicts from NumDicts should compare equal
self.assertEqual(num_dict, dict_from_num_dict)
self.assertEqual(num_dict_1, dict_from_num_dict_1)
self.assertEqual(num_dict_2, dict_from_num_dict_2)
self.assertEqual(num_dict_3, dict_from_num_dict_3)
self.assertEqual(num_dict_4, dict_from_num_dict_4)
self.assertEqual(num_dict_5, dict_from_num_dict_5)
self.assertEqual(num_dict_6, dict_from_num_dict_6)
self.assertEqual(num_dict_7, dict_from_num_dict_7)
# Construct NumDicts from NumDicts
num_dict_from_num_dict = NumDict(num_dict)
num_dict_from_num_dict_0 = NumDict(num_dict_0)
num_dict_from_num_dict_1 = NumDict(num_dict_1)
num_dict_from_num_dict_2 = NumDict(num_dict_2)
num_dict_from_num_dict_3 = NumDict(num_dict_3)
num_dict_from_num_dict_4 = NumDict(num_dict_4)
num_dict_from_num_dict_5 = NumDict(num_dict_5)
num_dict_from_num_dict_6 = NumDict(num_dict_6)
num_dict_from_num_dict_7 = NumDict(num_dict_7)
# All NumDicts from NumDicts should compare equal
self.assertEqual(num_dict, num_dict_from_num_dict)
self.assertEqual(num_dict_0, num_dict_from_num_dict_0)
self.assertEqual(num_dict_1, num_dict_from_num_dict_1)
self.assertEqual(num_dict_2, num_dict_from_num_dict_2)
self.assertEqual(num_dict_3, num_dict_from_num_dict_3)
self.assertEqual(num_dict_4, num_dict_from_num_dict_4)
self.assertEqual(num_dict_5, num_dict_from_num_dict_5)
self.assertEqual(num_dict_6, num_dict_from_num_dict_6)
self.assertEqual(num_dict_7, num_dict_from_num_dict_7)
# keyword arg constructor should fail
with self.assertRaises(TypeError):
NumDict(
one=1,
two=2) # Raise TypeError since we can't have numeric keywords
# item sequence constructors work fine...
self.assertEqual(NumDict([(1, 'Elephant'), (2, 'Mouse')]),
dict_from_num_dict_2)
self.assertEqual(NumDict(dict=[(1, 'Elephant'), (2, 'Mouse')]),
dict_from_num_dict_2)
self.assertEqual(NumDict([(1, 'Elephant'), ('2', 'Mouse')]),
dict_from_num_dict_2)
self.assertEqual(NumDict(dict=[('1', 'Elephant'), (2, 'Mouse')]),
dict_from_num_dict_2)
# ...unless you have a non-numeric key
with self.assertRaises(TypeError):
NumDict([('Rat', 11), ('Snake', 12)])
with self.assertRaises(TypeError):
NumDict(dict=[('Rat', 11), ('Snake', 12)])
# combining item sequence constructors with keyword args does not work
with self.assertRaises(
TypeError
): # Raise TypeError since we can't have numeric keywords
NumDict([(1, 'one'), (2, 'two')], two=3, five=4)
# alternate constructors
dict_8 = {1: 'Echo', 2: 'Echo'}
self.assertEqual(NumDict.fromkeys('1 2'.split()), dict_from_num_dict_6)
self.assertEqual(NumDict().fromkeys('1 2'.split()),
dict_from_num_dict_6)
self.assertEqual(NumDict.fromkeys('1 2'.split(), 'Echo'), dict_8)
self.assertEqual(NumDict().fromkeys('1 2'.split(), 'Echo'), dict_8)
self.assertTrue(num_dict_1.fromkeys('1 2'.split()) is not num_dict_1)
self.assertIsInstance(num_dict_1.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(num_dict_2.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(num_dict_3.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(num_dict_4.fromkeys('1 2'.split()), NumDict)
def test_constructors(self):
"""
Test NumDict constructors
"""
# dicts for testing
d0 = {} # Empty dictionary
d1 = {1: 'Elephant'} # Single numeric key
d2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys
d3 = {'3': 'Aardvark'} # Numeric string key
d4 = {'3': 'Aardvark', '4': 'Ant'} # Multiple numeric string keys
d5 = {5: 'Cat', '6': 'Dog'} # Mixed numeric and numeric string keys
d6 = {1: None, '2': None} # None as values
d7 = {None: 'Empty'} # None as key
# Construct NumDicts from dicts
n = NumDict()
n0 = NumDict(d0)
n1 = NumDict(d1)
n2 = NumDict(d2)
n3 = NumDict(d3)
n4 = NumDict(d4)
n5 = NumDict(d5)
n6 = NumDict(d6)
n7 = NumDict(d7)
# Most NumDicts from dicts should compare equal...
self.assertEqual(n, {})
self.assertEqual(n0, d0)
self.assertEqual(n1, d1)
self.assertEqual(n2, d2)
# ...however, numeric keys are not equal to numeric string keys...
self.assertNotEqual(n3, d3)
self.assertNotEqual(n4, d4)
self.assertNotEqual(n5, d5)
self.assertNotEqual(n6, d6)
# ...but None keys work just fine
self.assertEqual(n7, d7)
# Construct dicts from NumDicts
dn = dict(n)
dn1 = dict(n1)
dn2 = dict(n2)
dn3 = dict(n3)
dn4 = dict(n4)
dn5 = dict(n5)
dn6 = dict(n6)
dn7 = dict(n7)
# All dicts from NumDicts should compare equal
self.assertEqual(n, dn)
self.assertEqual(n1, dn1)
self.assertEqual(n2, dn2)
self.assertEqual(n3, dn3)
self.assertEqual(n4, dn4)
self.assertEqual(n5, dn5)
self.assertEqual(n6, dn6)
self.assertEqual(n7, dn7)
# Construct NumDicts from NumDicts
nn = NumDict(n)
nn0 = NumDict(n0)
nn1 = NumDict(n1)
nn2 = NumDict(n2)
nn3 = NumDict(n3)
nn4 = NumDict(n4)
nn5 = NumDict(n5)
nn6 = NumDict(n6)
nn7 = NumDict(n7)
# All NumDicts from NumDicts should compare equal
self.assertEqual(n, nn)
self.assertEqual(n0, nn0)
self.assertEqual(n1, nn1)
self.assertEqual(n2, nn2)
self.assertEqual(n3, nn3)
self.assertEqual(n4, nn4)
self.assertEqual(n5, nn5)
self.assertEqual(n6, nn6)
self.assertEqual(n7, nn7)
# keyword arg constructor should fail
with self.assertRaises(TypeError):
NumDict(one=1, two=2) # Raise TypeError since we can't have numeric keywords
# item sequence constructors work fine...
self.assertEqual(NumDict([(1, 'Elephant'), (2, 'Mouse')]), dn2)
self.assertEqual(NumDict(dict=[(1, 'Elephant'), (2, 'Mouse')]), dn2)
self.assertEqual(NumDict([(1, 'Elephant'), ('2', 'Mouse')]), dn2)
self.assertEqual(NumDict(dict=[('1', 'Elephant'), (2, 'Mouse')]), dn2)
# ...unless you have a non-numeric key
with self.assertRaises(TypeError):
NumDict([('Rat', 11), ('Snake', 12)])
with self.assertRaises(TypeError):
NumDict(dict=[('Rat', 11), ('Snake', 12)])
# combining item sequence constructors with keyword args does not work
with self.assertRaises(TypeError): # Raise TypeError since we can't have numeric keywords
NumDict([(1, 'one'), (2, 'two')], two=3, five=4)
# alternate constructors
d8 = {1: 'Echo', 2: 'Echo'}
self.assertEqual(NumDict.fromkeys('1 2'.split()), dn6)
self.assertEqual(NumDict().fromkeys('1 2'.split()), dn6)
self.assertEqual(NumDict.fromkeys('1 2'.split(), 'Echo'), d8)
self.assertEqual(NumDict().fromkeys('1 2'.split(), 'Echo'), d8)
self.assertTrue(n1.fromkeys('1 2'.split()) is not n1)
self.assertIsInstance(n1.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(n2.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(n3.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(n4.fromkeys('1 2'.split()), NumDict)
def test_constructors(self): # pylint: disable=too-many-locals, too-many-statements
"""
Test NumDict constructors
"""
# dicts for testing
dict_0 = {} # Empty dictionary
dict_1 = {1: 'Elephant'} # Single numeric key
dict_2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys
dict_3 = {'3': 'Aardvark'} # Numeric string key
dict_4 = {'3': 'Aardvark', '4': 'Ant'} # Multiple numeric string keys
dict_5 = {5: 'Cat', '6': 'Dog'} # Mixed numeric and numeric string keys
dict_6 = {1: None, '2': None} # None as values
dict_7 = {None: 'Empty'} # None as key
# Construct NumDicts from dicts
num_dict = NumDict()
num_dict_0 = NumDict(dict_0)
num_dict_1 = NumDict(dict_1)
num_dict_2 = NumDict(dict_2)
num_dict_3 = NumDict(dict_3)
num_dict_4 = NumDict(dict_4)
num_dict_5 = NumDict(dict_5)
num_dict_6 = NumDict(dict_6)
num_dict_7 = NumDict(dict_7)
# Most NumDicts from dicts should compare equal...
self.assertEqual(num_dict, {})
self.assertEqual(num_dict_0, dict_0)
self.assertEqual(num_dict_1, dict_1)
self.assertEqual(num_dict_2, dict_2)
# ...however, numeric keys are not equal to numeric string keys...
self.assertNotEqual(num_dict_3, dict_3)
self.assertNotEqual(num_dict_4, dict_4)
self.assertNotEqual(num_dict_5, dict_5)
self.assertNotEqual(num_dict_6, dict_6)
# ...but None keys work just fine
self.assertEqual(num_dict_7, dict_7)
# Construct dicts from NumDicts
dict_from_num_dict = dict(num_dict)
dict_from_num_dict_1 = dict(num_dict_1)
dict_from_num_dict_2 = dict(num_dict_2)
dict_from_num_dict_3 = dict(num_dict_3)
dict_from_num_dict_4 = dict(num_dict_4)
dict_from_num_dict_5 = dict(num_dict_5)
dict_from_num_dict_6 = dict(num_dict_6)
dict_from_num_dict_7 = dict(num_dict_7)
# All dicts from NumDicts should compare equal
self.assertEqual(num_dict, dict_from_num_dict)
self.assertEqual(num_dict_1, dict_from_num_dict_1)
self.assertEqual(num_dict_2, dict_from_num_dict_2)
self.assertEqual(num_dict_3, dict_from_num_dict_3)
self.assertEqual(num_dict_4, dict_from_num_dict_4)
self.assertEqual(num_dict_5, dict_from_num_dict_5)
self.assertEqual(num_dict_6, dict_from_num_dict_6)
self.assertEqual(num_dict_7, dict_from_num_dict_7)
# Construct NumDicts from NumDicts
num_dict_from_num_dict = NumDict(num_dict)
num_dict_from_num_dict_0 = NumDict(num_dict_0)
num_dict_from_num_dict_1 = NumDict(num_dict_1)
num_dict_from_num_dict_2 = NumDict(num_dict_2)
num_dict_from_num_dict_3 = NumDict(num_dict_3)
num_dict_from_num_dict_4 = NumDict(num_dict_4)
num_dict_from_num_dict_5 = NumDict(num_dict_5)
num_dict_from_num_dict_6 = NumDict(num_dict_6)
num_dict_from_num_dict_7 = NumDict(num_dict_7)
# All NumDicts from NumDicts should compare equal
self.assertEqual(num_dict, num_dict_from_num_dict)
self.assertEqual(num_dict_0, num_dict_from_num_dict_0)
self.assertEqual(num_dict_1, num_dict_from_num_dict_1)
self.assertEqual(num_dict_2, num_dict_from_num_dict_2)
self.assertEqual(num_dict_3, num_dict_from_num_dict_3)
self.assertEqual(num_dict_4, num_dict_from_num_dict_4)
self.assertEqual(num_dict_5, num_dict_from_num_dict_5)
self.assertEqual(num_dict_6, num_dict_from_num_dict_6)
self.assertEqual(num_dict_7, num_dict_from_num_dict_7)
# keyword arg constructor should fail
with self.assertRaises(TypeError):
NumDict(one=1, two=2) # Raise TypeError since we can't have numeric keywords
# item sequence constructors work fine...
self.assertEqual(NumDict([(1, 'Elephant'), (2, 'Mouse')]), dict_from_num_dict_2)
self.assertEqual(NumDict(dict=[(1, 'Elephant'), (2, 'Mouse')]), dict_from_num_dict_2)
self.assertEqual(NumDict([(1, 'Elephant'), ('2', 'Mouse')]), dict_from_num_dict_2)
self.assertEqual(NumDict(dict=[('1', 'Elephant'), (2, 'Mouse')]), dict_from_num_dict_2)
# ...unless you have a non-numeric key
with self.assertRaises(TypeError):
NumDict([('Rat', 11), ('Snake', 12)])
with self.assertRaises(TypeError):
NumDict(dict=[('Rat', 11), ('Snake', 12)])
# combining item sequence constructors with keyword args does not work
with self.assertRaises(TypeError): # Raise TypeError since we can't have numeric keywords
NumDict([(1, 'one'), (2, 'two')], two=3, five=4)
# alternate constructors
dict_8 = {1: 'Echo', 2: 'Echo'}
self.assertEqual(NumDict.fromkeys('1 2'.split()), dict_from_num_dict_6)
self.assertEqual(NumDict().fromkeys('1 2'.split()), dict_from_num_dict_6)
self.assertEqual(NumDict.fromkeys('1 2'.split(), 'Echo'), dict_8)
self.assertEqual(NumDict().fromkeys('1 2'.split(), 'Echo'), dict_8)
self.assertTrue(num_dict_1.fromkeys('1 2'.split()) is not num_dict_1)
self.assertIsInstance(num_dict_1.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(num_dict_2.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(num_dict_3.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(num_dict_4.fromkeys('1 2'.split()), NumDict)
def test_constructors(self):
"""
Test NumDict constructors
"""
# dicts for testing
d0 = {} # Empty dictionary
d1 = {1: 'Elephant'} # Single numeric key
d2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys
d3 = {'3': 'Aardvark'} # Numeric string key
d4 = {'3': 'Aardvark', '4': 'Ant'} # Multiple numeric string keys
d5 = {5: 'Cat', '6': 'Dog'} # Mixed numeric and numeric string keys
d6 = {1: None, '2': None} # None as values
d7 = {None: 'Empty'} # None as key
# Construct NumDicts from dicts
n = NumDict()
n0 = NumDict(d0)
n1 = NumDict(d1)
n2 = NumDict(d2)
n3 = NumDict(d3)
n4 = NumDict(d4)
n5 = NumDict(d5)
n6 = NumDict(d6)
n7 = NumDict(d7)
# Most NumDicts from dicts should compare equal...
self.assertEqual(n, {})
self.assertEqual(n0, d0)
self.assertEqual(n1, d1)
self.assertEqual(n2, d2)
# ...however, numeric keys are not equal to numeric string keys...
self.assertNotEqual(n3, d3)
self.assertNotEqual(n4, d4)
self.assertNotEqual(n5, d5)
self.assertNotEqual(n6, d6)
# ...but None keys work just fine
self.assertEqual(n7, d7)
# Construct dicts from NumDicts
dn = dict(n)
dn1 = dict(n1)
dn2 = dict(n2)
dn3 = dict(n3)
dn4 = dict(n4)
dn5 = dict(n5)
dn6 = dict(n6)
dn7 = dict(n7)
# All dicts from NumDicts should compare equal
self.assertEqual(n, dn)
self.assertEqual(n1, dn1)
self.assertEqual(n2, dn2)
self.assertEqual(n3, dn3)
self.assertEqual(n4, dn4)
self.assertEqual(n5, dn5)
self.assertEqual(n6, dn6)
self.assertEqual(n7, dn7)
# Construct NumDicts from NumDicts
nn = NumDict(n)
nn0 = NumDict(n0)
nn1 = NumDict(n1)
nn2 = NumDict(n2)
nn3 = NumDict(n3)
nn4 = NumDict(n4)
nn5 = NumDict(n5)
nn6 = NumDict(n6)
nn7 = NumDict(n7)
# All NumDicts from NumDicts should compare equal
self.assertEqual(n, nn)
self.assertEqual(n0, nn0)
self.assertEqual(n1, nn1)
self.assertEqual(n2, nn2)
self.assertEqual(n3, nn3)
self.assertEqual(n4, nn4)
self.assertEqual(n5, nn5)
self.assertEqual(n6, nn6)
self.assertEqual(n7, nn7)
# keyword arg constructor should fail
with self.assertRaises(TypeError):
NumDict(
one=1,
two=2) # Raise TypeError since we can't have numeric keywords
# item sequence constructors work fine...
self.assertEqual(NumDict([(1, 'Elephant'), (2, 'Mouse')]), dn2)
self.assertEqual(NumDict(dict=[(1, 'Elephant'), (2, 'Mouse')]), dn2)
self.assertEqual(NumDict([(1, 'Elephant'), ('2', 'Mouse')]), dn2)
self.assertEqual(NumDict(dict=[('1', 'Elephant'), (2, 'Mouse')]), dn2)
# ...unless you have a non-numeric key
with self.assertRaises(TypeError):
NumDict([('Rat', 11), ('Snake', 12)])
with self.assertRaises(TypeError):
NumDict(dict=[('Rat', 11), ('Snake', 12)])
# combining item sequence constructors with keyword args does not work
with self.assertRaises(
TypeError
): # Raise TypeError since we can't have numeric keywords
NumDict([(1, 'one'), (2, 'two')], two=3, five=4)
# alternate constructors
d8 = {1: 'Echo', 2: 'Echo'}
self.assertEqual(NumDict.fromkeys('1 2'.split()), dn6)
self.assertEqual(NumDict().fromkeys('1 2'.split()), dn6)
self.assertEqual(NumDict.fromkeys('1 2'.split(), 'Echo'), d8)
self.assertEqual(NumDict().fromkeys('1 2'.split(), 'Echo'), d8)
self.assertTrue(n1.fromkeys('1 2'.split()) is not n1)
self.assertIsInstance(n1.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(n2.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(n3.fromkeys('1 2'.split()), NumDict)
self.assertIsInstance(n4.fromkeys('1 2'.split()), NumDict)
