class DescDict_Iteration_and_Clear_Test(TestCase):
def setUp(self):
self.key1 = Key(1)
self.key2 = Key(2)
self.key3 = Key(3)
self.value1 = 1
self.value2 = 2
self.value3 = 3
self.dict = DescDict({
self.key1: self.value1,
self.key2: self.value2,
self.key3: self.value3
})
def test_iter(self):
keys = []
for key in self.dict:
keys.append(key)
self.assertTrue(self.key1 in keys)
self.assertTrue(self.key2 in keys)
self.assertTrue(self.key3 in keys)
self.assertEqual(len(self.dict), 3)
def test_keys(self):
keys = []
for key in self.dict.keys():
keys.append(key)
self.assertTrue(self.key1 in keys)
self.assertTrue(self.key2 in keys)
self.assertTrue(self.key3 in keys)
self.assertEqual(len(self.dict), 3)
def test_values(self):
values = []
for value in self.dict.values():
values.append(value)
self.assertTrue(self.value1 in values)
self.assertTrue(self.value2 in values)
self.assertTrue(self.value3 in values)
self.assertEqual(len(self.dict), 3)
def test_items(self):
items = []
for item in self.dict.items():
items.append(item)
self.assertTrue((self.key1, self.value1) in items)
self.assertTrue((self.key2, self.value2) in items)
self.assertTrue((self.key3, self.value3) in items)
self.assertEqual(len(items), 3)
def test_clear(self):
self.dict.clear()
self.assertEqual(len(self.dict), 0)
for _ in self.dict:
self.fail()
def test_update_all_new_dict(self):
dict = DescDict()
updater = {Key(1): 1, Key(2): 2}
dict.update(updater)
self.assertEqual(dict, updater)
def test_update_all_new_dict(self):
dict = DescDict()
updater = {Key(1): 1, Key(2): 2}
dict.update(updater)
self.assertEqual(dict, updater)
class DescDict_Iteration_and_Clear_Test(TestCase):
def setUp(self):
self.key1 = Key(1)
self.key2 = Key(2)
self.key3 = Key(3)
self.value1 = 1
self.value2 = 2
self.value3 = 3
self.dict = DescDict({self.key1: self.value1, self.key2: self.value2, self.key3: self.value3})
def test_iter(self):
keys = []
for key in self.dict:
keys.append(key)
self.assertTrue(self.key1 in keys)
self.assertTrue(self.key2 in keys)
self.assertTrue(self.key3 in keys)
self.assertEqual(len(self.dict), 3)
def test_keys(self):
keys = []
for key in self.dict.keys():
keys.append(key)
self.assertTrue(self.key1 in keys)
self.assertTrue(self.key2 in keys)
self.assertTrue(self.key3 in keys)
self.assertEqual(len(self.dict), 3)
def test_values(self):
values = []
for value in self.dict.values():
values.append(value)
self.assertTrue(self.value1 in values)
self.assertTrue(self.value2 in values)
self.assertTrue(self.value3 in values)
self.assertEqual(len(self.dict), 3)
def test_items(self):
items = []
for item in self.dict.items():
items.append(item)
self.assertTrue((self.key1, self.value1) in items)
self.assertTrue((self.key2, self.value2) in items)
self.assertTrue((self.key3, self.value3) in items)
self.assertEqual(len(items), 3)
def test_clear(self):
self.dict.clear()
self.assertEqual(len(self.dict), 0)
for _ in self.dict:
self.fail()
def test_update_all_new_iterable(self):
key1 = Key(1)
key2 = Key(2)
dict = DescDict()
updater = ((key1, 1), (key2, 2))
dict.update(updater)
final = DescDict({key1: 1, key2: 2})
self.assertEqual(dict, final)
def test_update_overlap_dict(self):
key1 = Key(1)
key3 = Key(3)
dict = DescDict({key1: 1, key3: 3})
updater = {key1: 2, Key(2): 2}
dict.update(updater)
updater[key3] = 3 # make `updater` match what `dict` should be
self.assertEqual(dict, updater)
def test_update_all_new_iterable(self):
key1 = Key(1)
key2 = Key(2)
dict = DescDict()
updater = ((key1, 1), (key2, 2))
dict.update(updater)
final = DescDict({key1: 1, key2: 2})
self.assertEqual(dict, final)
def test_update_overlap_dict(self):
key1 = Key(1)
key3 = Key(3)
dict = DescDict({key1: 1, key3: 3})
updater = {key1: 2, Key(2): 2}
dict.update(updater)
updater[key3] = 3 # make `updater` match what `dict` should be
self.assertEqual(dict, updater)
def test_update_overlap_iterable(self):
key1 = Key(1)
key2 = Key(2)
key3 = Key(3)
dict = DescDict({key1: 1, key3: 3})
updater = ((key1, 2), (key2, 2))
dict.update(updater)
final = DescDict({key1: 2, key2: 2, key3: 3})
self.assertEqual(dict, final)
def test_update_overlap_iterable(self):
key1 = Key(1)
key2 = Key(2)
key3 = Key(3)
dict = DescDict({key1: 1, key3: 3})
updater = ((key1, 2), (key2, 2))
dict.update(updater)
final = DescDict({key1: 2, key2: 2, key3: 3})
self.assertEqual(dict, final)
def setUp(self):
self.key1 = Key(1)
self.key2 = Key(2)
self.key3 = Key(3)
self.value1 = 1
self.value2 = 2
self.value3 = 3
self.dict = DescDict({
self.key1: self.value1,
self.key2: self.value2,
self.key3: self.value3
})
def test_4(self):
dict = DescDict({
self.key1: 1,
self.key2: 2,
self.key3: 3,
self.key4: 4
})
self.assertEqual(len(dict), 4)
def __init__(self, *args, **kwargs):
try:
super().__init__(*args, **kwargs)
except TypeError:
# This is expected when the mixin is not used with multiple
# inheritance, in which case, we just ignore it.
pass
self.storage = DescDict()
def setUp(self):
self.key1 = Key(1)
self.key2 = Key(2)
self.key3 = Key(3)
self.value1 = 1
self.value2 = 2
self.value3 = 3
self.dict = DescDict({self.key1: self.value1, self.key2: self.value2, self.key3: self.value3})
def test_new_dict_created_from_old_dict(self):
mc1 = Mock()
mc2 = Mock()
dict = DescDict({mc1: 1, mc2: 2})
self.assertTrue(mc1 in dict)
self.assertTrue(mc2 in dict)
self.assertEqual(dict[mc1], 1)
self.assertEqual(dict[mc2], 2)
def test_finalize(self):
dict = DescDict()
key = Key(1)
dict[key] = 1
self.assertEqual(len(dict), 1)
del key
self.assertEqual(len(dict), 0)
def set_once(setter):
"""
Decorates the `__set__()` method of a descriptor to turn it into a
set-once descriptor, which only allows the attribute to be set one time.
"""
set_instances = DescDict()
@wraps(setter)
def __set__(desc, instance, value):
if instance in set_instances:
raise AttributeError("Cannot set a read-only attribute")
else:
set_instances[instance] = True
setter(desc, instance, value)
return __set__
def test_six_repr(self):
dict = DescDict({
self.key1: 1,
self.key2: 1,
self.key3: 1,
self.key4: 1,
self.key5: 1,
self.key6: 1
})
self.assertEqual(
repr(dict),
"DescDict({StrMock(): 1, StrMock(): 1, StrMock(): 1, StrMock(): 1, StrMock(): 1, StrMock(): 1})"
)
def test_seven_str(self):
dict = DescDict({
self.key1: 1,
self.key2: 1,
self.key3: 1,
self.key4: 1,
self.key5: 1,
self.key6: 1,
self.key7: 1
})
self.assertEqual(
str(dict),
"DescDict{KEY: 1, KEY: 1, KEY: 1, KEY: 1, KEY: 1, KEY: 1, ...}")
def test_six_str(self):
dict = DescDict({
self.key1: 1,
self.key2: 1,
self.key3: 1,
self.key4: 1,
self.key5: 1,
self.key6: 1
})
# Because the order of the items coming back is unknown, I had to use
# keys that would look the same for each instance (values too)
self.assertEqual(
str(dict),
"DescDict{KEY: 1, KEY: 1, KEY: 1, KEY: 1, KEY: 1, KEY: 1}")
def test_new_dict_is_empty(self):
dict = DescDict()
self.assertTrue(len(dict) == 0)
def test_2(self):
dict = DescDict({self.key1: 1, self.key2: 2})
self.assertEqual(len(dict), 2)
def test_empty_str(self):
dict = DescDict()
self.assertEqual(str(dict), "DescDict{}")
def __init__(self):
self.storage = DescDict()
def test_empty_repr(self):
dict = DescDict()
self.assertEqual(repr(dict), "DescDict()")
def test_single_str(self):
dict = DescDict({self.key1: 1})
self.assertEqual(str(dict), "DescDict{KEY: 1}")
def setUp(self):
self.key = Unhashable()
self.value = 1
self.dict = DescDict()
def test_single_repr(self):
dict = DescDict({self.key1: 1})
self.assertEqual(repr(dict), "DescDict({StrMock(): 1})")
def __init__(self, desc):
super().__init__(desc)
self.set_instances = DescDict()
def __init__(self, deleg_prop_creator):
self._deleg_prop_creator = deleg_prop_creator
self._prop_storage = DescDict()
self._names = {}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.storage = DescDict()
