def test_collidedict__invalid_dict_value_format(self): """Ensures collidedict correctly handles dicts with invalid values.""" rect = Rect(0, 0, 10, 10) rect_keys = {tuple(rect) : 'collide'} with self.assertRaises(TypeError): collide_item = rect.collidedict(rect_keys, 1)
def test_collidedict__invalid_dict_key_format(self): """Ensures collidedict correctly handles dicts with invalid keys.""" rect = Rect(0, 0, 10, 10) rect_values = {'collide' : rect.copy()} with self.assertRaises(TypeError): collide_item = rect.collidedict(rect_values)
def test_collidedict__negative_sized_rects_as_args(self): """Ensures collidedict works correctly with negative sized rect args. """ rect = Rect(0, 0, 10, 10) collide_item1 = ('collide 1', Rect(1, 1, -1, -1)) no_collide_item1 = ('no collide 1', Rect(1, 1, -1, 0)) no_collide_item2 = ('no collide 2', Rect(1, 1, 0, -1)) # Dict to check collisions with values. rect_values = dict((collide_item1, no_collide_item1, no_collide_item2)) # Dict to check collisions with keys. rect_keys = {tuple(v) : k for k, v in rect_values.items()} for use_values in (True, False): if use_values: expected_item = collide_item1 d = rect_values else: expected_item = (tuple(collide_item1[1]), collide_item1[0]) d = rect_keys collide_item = rect.collidedict(d, use_values) self.assertTupleEqual(collide_item, expected_item)
def test_collidedict__negative_sized_rects(self): """Ensures collidedict works correctly with negative sized rects.""" neg_rect = Rect(1, 1, -1, -1) collide_item1 = ('collide 1', neg_rect.copy()) collide_item2 = ('collide 2', Rect(0, 0, 10, 10)) no_collide_item1 = ('no collide 1', Rect(1, 1, 10, 10)) # 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( (tuple(v), k) for k, v in value_collide_items) for use_values in (True, False): if use_values: collide_items = value_collide_items d = rect_values else: collide_items = key_collide_items d = rect_keys collide_item = neg_rect.collidedict(d, use_values) # The detected collision could be any of the possible items. self.assertIn(collide_item, collide_items)
def test_collidedict(self): """Ensures collidedict 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, 10, 10)) no_collide_item2 = ('no collide 2', Rect(70, 70, 10, 10)) # 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( (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_item = rect.collidedict(d, use_values) # The detected collision could be any of the possible items. self.assertIn(collide_item, expected_items)
def test_collidedict__invalid_use_values_format(self): """Ensures collidedict 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_item = rect.collidedict(d, invalid_param)
def test_collidedict__invalid_dict_format(self): """Ensures collidedict 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.collidedict(d, use_values)
def test_collidedict(self): # __doc__ (as of 2008-08-02) for pygame.rect.Rect.collidedict: # Rect.collidedict(dict): return (key, value) # test if one rectangle in a dictionary intersects # # Returns the key and value of the first dictionary value that # collides with the Rect. If no collisions are found, None 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) r1 = Rect(1, 1, 10, 10) r2 = Rect(50, 50, 10, 10) r3 = Rect(70, 70, 10, 10) r4 = Rect(61, 61, 10, 10) d = {1: r1, 2: r2, 3: r3} rects_values = 1 val = r.collidedict(d, rects_values) self.assertTrue(val) self.assertEqual(len(val), 2) self.assertEqual(val[0], 1) self.assertEqual(val[1], r1) none_d = {2: r2, 3: r3} none_val = r.collidedict(none_d, rects_values) self.assertFalse(none_val) barely_d = {1: r1, 2: r2, 3: r3} k3, v3 = r4.collidedict(barely_d, rects_values) self.assertEqual(k3, 3) self.assertEqual(v3, r3)
def test_collidedict__no_collision(self): """Ensures collidedict returns None when no collisions.""" rect = Rect(1, 1, 10, 10) no_collide_item1 = ('no collide 1', Rect(50, 50, 10, 10)) no_collide_item2 = ('no collide 2', Rect(60, 60, 10, 10)) no_collide_item3 = ('no collide 3', Rect(70, 70, 10, 10)) # 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()} for use_values in (True, False): d = rect_values if use_values else rect_keys collide_item = rect.collidedict(d, use_values) self.assertIsNone(collide_item)
def test_collidedict__barely_touching(self): """Ensures collidedict 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, 10, 10)) no_collide_item2 = ('no collide 2', Rect(60, 60, 10, 10)) no_collide_item3 = ('no collide 3', Rect(70, 70, 10, 10)) # 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_item = collide_item1 d = dict(no_collide_rect_values) else: expected_item = (tuple(collide_item1[1]), collide_item1[0]) d = dict(no_collide_rect_keys) d.update((expected_item, )) # Add in the expected item. collide_item = rect.collidedict(d, use_values) self.assertTupleEqual(collide_item, expected_item)
def test_collidedict__zero_sized_rects_as_args(self): """Ensures collidedict works correctly with zero sized rects as args. There should be no collisions with zero sized rects. """ rect = Rect(0, 0, 10, 10) no_collide_item1 = ('no collide 1', Rect(1, 1, 0, 0)) no_collide_item2 = ('no collide 2', Rect(1, 1, 1, 0)) no_collide_item3 = ('no collide 3', Rect(1, 1, 0, 1)) # 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()} for use_values in (True, False): d = rect_values if use_values else rect_keys collide_item = rect.collidedict(d, use_values) self.assertIsNone(collide_item)