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)