def test_collidedictall(self):
# __doc__ (as of 2008-08-02) for pygame.rect.Rect.collidedictall:
# Rect.collidedictall(dict): return [(key, value), ...]
# test if all rectangles in a dictionary intersect
#
# Returns a list of all the key and value pairs that intersect with
# the Rect. If no collisions are found an empty dictionary is
# returned.
#
# Rect objects are not hashable and cannot be used as keys in a
# dictionary, only as values.
r = Rect(1, 1, 10, 10)
r2 = Rect(1, 1, 10, 10)
r3 = Rect(5, 5, 10, 10)
r4 = Rect(10, 10, 10, 10)
r5 = Rect(50, 50, 10, 10)
rects_values = 1
d = {2: r2}
l = r.collidedictall(d, rects_values)
self.assertEqual(l, [(2, r2)])
d2 = {2: r2, 3: r3, 4: r4, 5: r5}
l2 = r.collidedictall(d2, rects_values)
self.assertEqual(l2, [(2, r2), (3, r3), (4, r4)])
def test_collidedictall(self):
# __doc__ (as of 2008-08-02) for pygame.rect.Rect.collidedictall:
# Rect.collidedictall(dict): return [(key, value), ...]
# test if all rectangles in a dictionary intersect
#
# Returns a list of all the key and value pairs that intersect with
# the Rect. If no collisions are found an empty dictionary is
# returned.
#
# Rect objects are not hashable and cannot be used as keys in a
# dictionary, only as values.
r = Rect(1, 1, 10, 10)
r2 = Rect(1, 1, 10, 10)
r3 = Rect(5, 5, 10, 10)
r4 = Rect(10, 10, 10, 10)
r5 = Rect(50, 50, 10, 10)
rects_values = 1
d = {2: r2}
l = r.collidedictall(d, rects_values)
self.assertEqual(l, [(2, r2)])
d2 = {2: r2, 3: r3, 4: r4, 5: r5}
l2 = r.collidedictall(d2, rects_values)
self.assertEqual(l2, [(2, r2), (3, r3), (4, r4)])
def test_collidedictall__zero_sized_rects_as_args(self):
"""Ensures collidedictall works correctly with zero sized rects
as args.
There should be no collisions with zero sized rects.
"""
rect = Rect(0, 0, 20, 20)
no_collide_item1 = ('no collide 1', Rect(2, 2, 0, 0))
no_collide_item2 = ('no collide 2', Rect(2, 2, 2, 0))
no_collide_item3 = ('no collide 3', Rect(2, 2, 0, 2))
# Dict to check collisions with values.
rect_values = dict((no_collide_item1, no_collide_item2,
no_collide_item3))
# Dict to check collisions with keys.
rect_keys = {tuple(v) : k for k, v in rect_values.items()}
expected_items = []
for use_values in (True, False):
d = rect_values if use_values else rect_keys
collide_items = rect.collidedictall(d, use_values)
self._assertCountEqual(collide_items, expected_items)
def test_collidedictall__negative_sized_rects(self):
"""Ensures collidedictall works correctly with negative sized rects."""
neg_rect = Rect(2, 2, -2, -2)
collide_item1 = ('collide 1', neg_rect.copy())
collide_item2 = ('collide 2', Rect(0, 0, 20, 20))
no_collide_item1 = ('no collide 1', Rect(1, 1, 20, 20))
# Dict to check collisions with values.
rect_values = dict((collide_item1, collide_item2, no_collide_item1))
value_collide_items = [collide_item1, collide_item2]
# Dict to check collisions with keys.
rect_keys = {tuple(v) : k for k, v in rect_values.items()}
key_collide_items = [(tuple(v), k) for k, v in value_collide_items]
for use_values in (True, False):
if use_values:
expected_items = value_collide_items
d = rect_values
else:
expected_items = key_collide_items
d = rect_keys
collide_items = neg_rect.collidedictall(d, use_values)
self._assertCountEqual(collide_items, expected_items)
def test_collidedictall(self):
"""Ensures collidedictall detects collisions."""
rect = Rect(1, 1, 10, 10)
collide_item1 = ('collide 1', rect.copy())
collide_item2 = ('collide 2', Rect(5, 5, 10, 10))
no_collide_item1 = ('no collide 1', Rect(60, 60, 20, 20))
no_collide_item2 = ('no collide 2', Rect(70, 70, 20, 20))
# Dict to check collisions with values.
rect_values = dict((collide_item1, collide_item2, no_collide_item1,
no_collide_item2))
value_collide_items = [collide_item1, collide_item2]
# Dict to check collisions with keys.
rect_keys = {tuple(v) : k for k, v in rect_values.items()}
key_collide_items = [(tuple(v), k) for k, v in value_collide_items]
for use_values in (True, False):
if use_values:
expected_items = value_collide_items
d = rect_values
else:
expected_items = key_collide_items
d = rect_keys
collide_items = rect.collidedictall(d, use_values)
self._assertCountEqual(collide_items, expected_items)
def test_collidedictall__invalid_dict_key_format(self):
"""Ensures collidedictall correctly handles dicts with invalid keys."""
rect = Rect(0, 0, 10, 10)
rect_values = {'collide' : rect.copy()}
with self.assertRaises(TypeError):
collide_items = rect.collidedictall(rect_values)
def test_collidedictall__invalid_dict_value_format(self):
"""Ensures collidedictall correctly handles dicts with invalid values.
"""
rect = Rect(0, 0, 10, 10)
rect_keys = {tuple(rect) : 'collide'}
with self.assertRaises(TypeError):
collide_items = rect.collidedictall(rect_keys, 1)
def test_collidedictall__invalid_use_values_format(self):
"""Ensures collidedictall correctly handles invalid use_values
parameters.
"""
rect = Rect(0, 0, 1, 1)
d = {}
for invalid_param in (None, d, 1.1):
with self.assertRaises(TypeError):
collide_items = rect.collidedictall(d, invalid_param)
def test_collidedictall__invalid_dict_format(self):
"""Ensures collidedictall correctly handles invalid dict parameters."""
rect = Rect(0, 0, 10, 10)
invalid_value_dict = ('collide', rect.copy())
invalid_key_dict = tuple(invalid_value_dict[1]), invalid_value_dict[0]
for use_values in (True, False):
d = invalid_value_dict if use_values else invalid_key_dict
with self.assertRaises(TypeError):
collide_item = rect.collidedictall(d, use_values)
def test_collidedictall__barely_touching(self):
"""Ensures collidedictall works correctly for rects that barely touch.
"""
rect = Rect(1, 1, 10, 10)
# Small rect to test barely touching collisions.
collide_rect = Rect(0, 0, 1, 1)
collide_item1 = ('collide 1', collide_rect)
no_collide_item1 = ('no collide 1', Rect(50, 50, 20, 20))
no_collide_item2 = ('no collide 2', Rect(60, 60, 20, 20))
no_collide_item3 = ('no collide 3', Rect(70, 70, 20, 20))
# Dict to check collisions with values.
no_collide_rect_values = dict(
(no_collide_item1, no_collide_item2, no_collide_item3))
# Dict to check collisions with keys.
no_collide_rect_keys = {
tuple(v): k
for k, v in no_collide_rect_values.items()
}
# Tests the collide_rect on each of the rect's corners.
for attr in ('topleft', 'topright', 'bottomright', 'bottomleft'):
setattr(collide_rect, attr, getattr(rect, attr))
for use_values in (True, False):
if use_values:
expected_items = [collide_item1]
d = dict(no_collide_rect_values)
else:
expected_items = [(tuple(collide_item1[1]),
collide_item1[0])]
d = dict(no_collide_rect_keys)
d.update(expected_items) # Add in the expected items.
collide_items = rect.collidedictall(d, use_values)
self._assertCountEqual(collide_items, expected_items)
def test_collidedictall__no_collision(self):
"""Ensures collidedictall returns an empty list when no collisions."""
rect = Rect(1, 1, 10, 10)
no_collide_item1 = ('no collide 1', Rect(50, 50, 20, 20))
no_collide_item2 = ('no collide 2', Rect(60, 60, 20, 20))
no_collide_item3 = ('no collide 3', Rect(70, 70, 20, 20))
# Dict to check collisions with values.
rect_values = dict((no_collide_item1, no_collide_item2,
no_collide_item3))
# Dict to check collisions with keys.
rect_keys = {tuple(v) : k for k, v in rect_values.items()}
expected_items = []
for use_values in (True, False):
d = rect_values if use_values else rect_keys
collide_items = rect.collidedictall(d, use_values)
self._assertCountEqual(collide_items, expected_items)
