def test_rich_comparison_and_len(self):
"""
Test rich comparison and length
"""
# dicts for testing
dict_0 = {} # Empty dictionary
dict_1 = {1: 'Elephant'} # Single numeric key
dict_2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys
# 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)
# 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)
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 val_a in all_dicts:
for val_b in all_dicts:
self.assertEqual(val_a == val_b, len(val_a) == len(val_b))
def __init__(self):
# An instance variable __missing__ should have no effect
self.__missing__ = lambda key: None
NumDict.__init__(self)
def test_dict_access_and_mod(self):
"""
Test num dict access and modification
"""
# dicts for testing
dict_0 = {} # Empty dictionary
dict_1 = {1: "Elephant"} # Single numeric key
dict_2 = {1: "Elephant", 2: "Mouse"} # Multiple numeric keys
# Construct NumDicts from dicts
num_dict_0 = NumDict()
num_dict_1 = NumDict(dict_1)
num_dict_2 = NumDict(dict_2)
# test __getitem__
assert num_dict_2[1] == "Elephant"
with pytest.raises(KeyError):
_ = num_dict_1["Mouse"] # key is not numeric
with pytest.raises(KeyError):
_ = num_dict_1.__getitem__("Mouse") # key is not numeric
with pytest.raises(KeyError):
_ = num_dict_1[None] # key does not exist
with pytest.raises(KeyError):
_ = num_dict_1.__getitem__(None) # key does not exist
# Test __setitem__
num_dict_3 = NumDict(num_dict_2)
assert num_dict_2 == num_dict_3
num_dict_3[2] = "Frog"
assert num_dict_2 != num_dict_3
# Check None keys and numeric key conversion
num_dict_3["3"] = "Armadillo"
num_dict_3[None] = "Cockroach"
# Check long ints
num_dict_3[12390809518259081208909880312] = "Squid"
num_dict_3["12390809518259081208909880312"] = "Octopus"
assert num_dict_3[12390809518259081208909880312] == "Octopus"
with pytest.raises(TypeError):
num_dict_3.__setitem__("Gorilla", 1) # key is not numeric
with pytest.raises(TypeError):
num_dict_3["Chimpanzee"] = 1 # key is not numeric
with pytest.raises(TypeError):
num_dict_3[(4, 1)] = 1 # key is not numeric
with pytest.raises(TypeError):
num_dict_3[[1, 3, 4]] = 1 # key is not numeric and is not hashable
# Test __delitem__
del num_dict_3[3]
del num_dict_3[None]
with pytest.raises(KeyError):
del num_dict_3[3] # already deleted
with pytest.raises(KeyError):
num_dict_3.__delitem__(3) # already deleted
with pytest.raises(KeyError):
del num_dict_3[
"Mouse"] # key would not exist, since it is not numeric
# Test clear
num_dict_3.clear()
assert num_dict_3 == {}
# Test copy()
num_dict_2a = dict_2.copy()
assert num_dict_2 == num_dict_2a
num_dict_2b = num_dict_2.copy()
assert num_dict_2b == num_dict_2
num_dict_2c = UserDict({1: "Elephant", 2: "Mouse"})
num_dict_2d = num_dict_2c.copy(
) # making a copy of a UserDict is special cased
assert num_dict_2c == num_dict_2d
class MyNumDict(NumDict):
"""
subclass Numdict for testing
"""
def display(self):
"""
add a method to subclass to differentiate from superclass
"""
print("MyNumDict:", self)
my_num_dict = MyNumDict(num_dict_2)
my_num_dict_a = my_num_dict.copy()
assert my_num_dict_a == my_num_dict
my_num_dict[1] = "Frog"
assert my_num_dict_a != my_num_dict
# Test keys, items, values
assert sorted(num_dict_2) == sorted(dict_2)
assert sorted(num_dict_2.items()) == sorted(dict_2.items())
assert sorted(num_dict_2.values()) == sorted(dict_2.values())
# Test "in".
for i in num_dict_2:
assert i in num_dict_2
assert (i in num_dict_1) == (i in dict_1)
assert (i in num_dict_0) == (i in dict_0)
assert None not in num_dict_2
assert (None in num_dict_2) is (None in dict_2)
dict_2[None] = "Cow"
num_dict_2[None] = dict_2[None]
assert None in num_dict_2
assert (None in num_dict_2) is (None in dict_2)
assert "Penguin" not in num_dict_2
# Test update
test = NumDict()
test.update(dict_2)
assert test == num_dict_2
# Test get
for i in num_dict_2:
assert num_dict_2.get(i) == num_dict_2[i]
assert num_dict_1.get(i) == dict_1.get(i)
assert num_dict_0.get(i) == dict_0.get(i)
for i in ["purple", None, 12312301924091284, 23]:
assert num_dict_2.get(i) == dict_2.get(i), i
with pytest.raises(AssertionError):
assert num_dict_2.get("1") == dict_2.get(
"1"), 1 # dict_2 expects string key which does not exist
# Test "in" iteration.
num_dict_2b = num_dict_2
for i in range(20):
num_dict_2[i] = str(i)
num_dict_2b[str(i)] = str(i)
assert num_dict_2 == num_dict_2b
ikeys = []
for k in num_dict_2:
ikeys.append(k)
assert set(ikeys) == set(num_dict_2)
# Test setdefault
val = 1
test = NumDict()
assert test.setdefault(val, 42) == 42
assert test.setdefault(val, "42") == 42
assert test.setdefault(val, 42) != "42"
assert test.setdefault(val, "42") != "42"
assert val in test
assert test.setdefault(val, 23) == 42
assert test.setdefault(val, "23") == 42
assert test.setdefault(val, 23) != "42"
assert test.setdefault(val, "23") != "42"
assert val in test
# Test pop
val = 1
test = NumDict({val: 42})
assert test.pop(val) == 42
pytest.raises(KeyError, test.pop, val)
assert test.pop(val, 1) == 1
test[val] = 42
assert test.pop(val, 1) == 42
# Test popitem
val = 1
test = NumDict({val: 42})
assert test.popitem() == (val, 42)
pytest.raises(KeyError, test.popitem)
def test_repr(self):
"""
Test representation of NumDicts
"""
# 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 = {0: "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)
reps = (
"{}",
"{1: 'Elephant'}",
"{1: 'Elephant', 2: 'Mouse'}",
"'3': 'Aardvark'",
"{'3': 'Aardvark', '4': 'Ant'}",
"{5: 'Cat', '6': 'Dog'}",
"{1: None, '2': None}",
"{0: 'Empty'}",
)
# Most representations of NumDicts should compare equal to dicts...
assert str(num_dict) == str({})
assert repr(num_dict) == repr({})
assert repr(num_dict) in reps
assert str(num_dict_0) == str(dict_0)
assert repr(num_dict_0) == repr(dict_0)
assert repr(num_dict_0) in reps
assert str(num_dict_1) == str(dict_1)
assert repr(num_dict_1) == repr(dict_1)
assert repr(num_dict_1) in reps
assert str(num_dict_2) == str(dict_2)
assert repr(num_dict_2) == repr(dict_2)
assert repr(num_dict_2) in reps
# ...however, numeric keys are not equal to numeric string keys...
# ...so the string representations for those are different...
assert str(num_dict_3) != str(dict_3)
assert repr(num_dict_3) != repr(dict_3)
assert repr(num_dict_3) not in reps
assert str(num_dict_4) != str(dict_4)
assert repr(num_dict_4) != repr(dict_4)
assert repr(num_dict_4) not in reps
assert str(num_dict_5) != str(dict_5)
assert repr(num_dict_5) != repr(dict_5)
assert repr(num_dict_5) not in reps
assert str(num_dict_6) != str(dict_6)
assert repr(num_dict_6) != repr(dict_6)
assert repr(num_dict_6) not in reps
# ...but None keys work just fine
assert str(num_dict_7) == str(dict_7)
assert repr(num_dict_7) == repr(dict_7)
assert repr(num_dict_7) in reps
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 = {0: "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...
assert num_dict == {}
assert num_dict_0 == dict_0
assert num_dict_1 == dict_1
assert num_dict_2 == dict_2
# ...however, numeric keys are not equal to numeric string keys...
assert num_dict_3 != dict_3
assert num_dict_4 != dict_4
assert num_dict_5 != dict_5
assert num_dict_6 != dict_6
assert 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
assert num_dict == dict_from_num_dict
assert num_dict_1 == dict_from_num_dict_1
assert num_dict_2 == dict_from_num_dict_2
assert num_dict_3 == dict_from_num_dict_3
assert num_dict_4 == dict_from_num_dict_4
assert num_dict_5 == dict_from_num_dict_5
assert num_dict_6 == dict_from_num_dict_6
assert 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
assert num_dict == num_dict_from_num_dict
assert num_dict_0 == num_dict_from_num_dict_0
assert num_dict_1 == num_dict_from_num_dict_1
assert num_dict_2 == num_dict_from_num_dict_2
assert num_dict_3 == num_dict_from_num_dict_3
assert num_dict_4 == num_dict_from_num_dict_4
assert num_dict_5 == num_dict_from_num_dict_5
assert num_dict_6 == num_dict_from_num_dict_6
assert 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...
assert NumDict([(1, "Elephant"), (2, "Mouse")]) == dict_from_num_dict_2
assert NumDict(dict=[(1,
"Elephant"), (2,
"Mouse")]) == dict_from_num_dict_2
assert NumDict([(1, "Elephant"),
("2", "Mouse")]) == dict_from_num_dict_2
assert 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"}
assert NumDict.fromkeys("1 2".split()) == dict_from_num_dict_6
assert NumDict().fromkeys("1 2".split()) == dict_from_num_dict_6
assert NumDict.fromkeys("1 2".split(), "Echo") == dict_8
assert NumDict().fromkeys("1 2".split(), "Echo") == dict_8
assert 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)
USE_TWITTER = False
USENET_RETENTION = None
VERSION_NOTIFY = False
versionCheckScheduler = None
WEB_COOKIE_SECRET = None
WEB_HOST = None
WEB_IPV6 = False
WEB_LOG = False
WEB_PASSWORD = None
WEB_PORT = None
WEB_ROOT = None
WEB_USE_GZIP = True
WEB_USERNAME = None
WINDOWS_SHARES = {}
movie_list: "MovieList" = None
def get_backlog_cycle_time():
cycletime = DAILYSEARCH_FREQUENCY * 2 + 7
return max([cycletime, 720])
unpackStrings = NumDict(
{
UNPACK_DISABLED: _("Ignore (do not process contents)"),
UNPACK_PROCESS_CONTENTS: _("Unpack (process contents)"),
UNPACK_PROCESS_INTACT: _("Treat as video (process archive as-is)"),
}
)
def test_dict_access_and_mod(self):
"""
Test num dict access and modification
"""
# dicts for testing
dict_0 = {} # Empty dictionary
dict_1 = {1: 'Elephant'} # Single numeric key
dict_2 = {1: 'Elephant', 2: 'Mouse'} # Multiple numeric keys
# Construct NumDicts from dicts
num_dict_0 = NumDict()
num_dict_1 = NumDict(dict_1)
num_dict_2 = NumDict(dict_2)
# test __getitem__
self.assertEqual(num_dict_2[1], 'Elephant')
with self.assertRaises(KeyError):
_ = num_dict_1['Mouse'] # key is not numeric
with self.assertRaises(KeyError):
_ = num_dict_1.__getitem__('Mouse') # key is not numeric
with self.assertRaises(KeyError):
_ = num_dict_1[None] # key does not exist
with self.assertRaises(KeyError):
_ = num_dict_1.__getitem__(None) # key does not exist
# Test __setitem__
num_dict_3 = NumDict(num_dict_2)
self.assertEqual(num_dict_2, num_dict_3)
num_dict_3[2] = 'Frog'
self.assertNotEqual(num_dict_2, num_dict_3)
# Check None keys and numeric key conversion
num_dict_3['3'] = 'Armadillo'
num_dict_3[None] = 'Cockroach'
# Check long ints
num_dict_3[12390809518259081208909880312] = 'Squid'
num_dict_3['12390809518259081208909880312'] = 'Octopus'
self.assertEqual(num_dict_3[12390809518259081208909880312], 'Octopus')
with self.assertRaises(TypeError):
num_dict_3.__setitem__('Gorilla', 1) # key is not numeric
with self.assertRaises(TypeError):
num_dict_3['Chimpanzee'] = 1 # key is not numeric
with self.assertRaises(TypeError):
num_dict_3[(4, 1)] = 1 # key is not numeric
with self.assertRaises(TypeError):
num_dict_3[[1, 3, 4]] = 1 # key is not numeric and is not hashable
# Test __delitem__
del num_dict_3[3]
del num_dict_3[None]
with self.assertRaises(KeyError):
del num_dict_3[3] # already deleted
with self.assertRaises(KeyError):
num_dict_3.__delitem__(3) # already deleted
with self.assertRaises(KeyError):
del num_dict_3[
'Mouse'] # key would not exist, since it is not numeric
# Test clear
num_dict_3.clear()
self.assertEqual(num_dict_3, {})
# Test copy()
num_dict_2a = dict_2.copy()
self.assertEqual(num_dict_2, num_dict_2a)
num_dict_2b = num_dict_2.copy()
self.assertEqual(num_dict_2b, num_dict_2)
num_dict_2c = UserDict({1: 'Elephant', 2: 'Mouse'})
num_dict_2d = num_dict_2c.copy(
) # making a copy of a UserDict is special cased
self.assertEqual(num_dict_2c, num_dict_2d)
class MyNumDict(NumDict):
"""
subclass Numdict for testing
"""
def display(self):
"""
add a method to subclass to differentiate from superclass
"""
print('MyNumDict:', self)
my_num_dict = MyNumDict(num_dict_2)
my_num_dict_a = my_num_dict.copy()
self.assertEqual(my_num_dict_a, my_num_dict)
my_num_dict[1] = 'Frog'
self.assertNotEqual(my_num_dict_a, my_num_dict)
# Test keys, items, values
self.assertEqual(sorted(num_dict_2), sorted(dict_2))
self.assertEqual(sorted(num_dict_2.items()), sorted(dict_2.items()))
self.assertEqual(sorted(num_dict_2.values()), sorted(dict_2.values()))
# Test "in".
for i in num_dict_2:
self.assertIn(i, num_dict_2)
self.assertEqual(i in num_dict_1, i in dict_1)
self.assertEqual(i in num_dict_0, i in dict_0)
self.assertFalse(None in num_dict_2)
self.assertEqual(None in num_dict_2, None in dict_2)
dict_2[None] = 'Cow'
num_dict_2[None] = dict_2[None]
self.assertTrue(None in num_dict_2)
self.assertEqual(None in num_dict_2, None in dict_2)
self.assertFalse('Penguin' in num_dict_2)
# Test update
test = NumDict()
test.update(dict_2)
self.assertEqual(test, num_dict_2)
# Test get
for i in num_dict_2:
self.assertEqual(num_dict_2.get(i), num_dict_2[i])
self.assertEqual(num_dict_1.get(i), dict_1.get(i))
self.assertEqual(num_dict_0.get(i), dict_0.get(i))
for i in ['purple', None, 12312301924091284, 23]:
self.assertEqual(num_dict_2.get(i), dict_2.get(i), i)
with self.assertRaises(AssertionError):
i = '1'
self.assertEqual(
num_dict_2.get(i), dict_2.get(i),
i) # dict_2 expects string key which does not exist
# Test "in" iteration.
num_dict_2b = num_dict_2
for i in range(20):
num_dict_2[i] = str(i)
num_dict_2b[str(i)] = str(i)
self.assertEqual(num_dict_2, num_dict_2b)
ikeys = []
for k in num_dict_2:
ikeys.append(k)
self.assertEqual(set(ikeys), set(num_dict_2))
# Test setdefault
val = 1
test = NumDict()
self.assertEqual(test.setdefault(val, 42), 42)
self.assertEqual(test.setdefault(val, '42'), 42)
self.assertNotEqual(test.setdefault(val, 42), '42')
self.assertNotEqual(test.setdefault(val, '42'), '42')
self.assertIn(val, test)
self.assertEqual(test.setdefault(val, 23), 42)
self.assertEqual(test.setdefault(val, '23'), 42)
self.assertNotEqual(test.setdefault(val, 23), '42')
self.assertNotEqual(test.setdefault(val, '23'), '42')
self.assertIn(val, test)
# Test pop
val = 1
test = NumDict({val: 42})
self.assertEqual(test.pop(val), 42)
self.assertRaises(KeyError, test.pop, val)
self.assertEqual(test.pop(val, 1), 1)
test[val] = 42
self.assertEqual(test.pop(val, 1), 42)
# Test popitem
val = 1
test = NumDict({val: 42})
self.assertEqual(test.popitem(), (val, 42))
self.assertRaises(KeyError, test.popitem)
def test_repr(self):
"""
Test representation of NumDicts
"""
# 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 = {0: '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)
reps = (
"{}",
"{1: 'Elephant'}",
"{1: 'Elephant', 2: 'Mouse'}",
"'3': 'Aardvark'",
"{'3': 'Aardvark', '4': 'Ant'}",
"{5: 'Cat', '6': 'Dog'}",
"{1: None, '2': None}",
"{0: 'Empty'}",
)
# Most representations of NumDicts should compare equal to dicts...
self.assertEqual(str(num_dict), str({}))
self.assertEqual(repr(num_dict), repr({}))
self.assertIn(repr(num_dict), reps)
self.assertEqual(str(num_dict_0), str(dict_0))
self.assertEqual(repr(num_dict_0), repr(dict_0))
self.assertIn(repr(num_dict_0), reps)
self.assertEqual(str(num_dict_1), str(dict_1))
self.assertEqual(repr(num_dict_1), repr(dict_1))
self.assertIn(repr(num_dict_1), reps)
self.assertEqual(str(num_dict_2), str(dict_2))
self.assertEqual(repr(num_dict_2), repr(dict_2))
self.assertIn(repr(num_dict_2), reps)
# ...however, numeric keys are not equal to numeric string keys...
# ...so the string representations for those are different...
self.assertNotEqual(str(num_dict_3), str(dict_3))
self.assertNotEqual(repr(num_dict_3), repr(dict_3))
self.assertNotIn(repr(num_dict_3), reps)
self.assertNotEqual(str(num_dict_4), str(dict_4))
self.assertNotEqual(repr(num_dict_4), repr(dict_4))
self.assertNotIn(repr(num_dict_4), reps)
self.assertNotEqual(str(num_dict_5), str(dict_5))
self.assertNotEqual(repr(num_dict_5), repr(dict_5))
self.assertNotIn(repr(num_dict_5), reps)
self.assertNotEqual(str(num_dict_6), str(dict_6))
self.assertNotEqual(repr(num_dict_6), repr(dict_6))
self.assertNotIn(repr(num_dict_6), reps)
# ...but None keys work just fine
self.assertEqual(str(num_dict_7), str(dict_7))
self.assertEqual(repr(num_dict_7), repr(dict_7))
self.assertIn(repr(num_dict_7), reps)
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 = {0: '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)
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)