def test_passes_verbosity(self): mockRunner = Listener() mockRunner.return_value = TextTestRunner() mockRun = Listener() mockRunner.return_value.run = mockRun from solescion.testutils import testcase as testcase_module orig = testcase_module.TextTestRunner testcase_module.TextTestRunner = mockRunner try: suite = ClassUnderTest("testAlwaysPasses") run(suite, verbosity=33) finally: testcase_module.TextTestRunner = orig self.assertEquals(mockRunner.kwargs['verbosity'], 33, "didnt create a verbose runner") self.assertEquals(mockRun.args, (suite,), "didnt run suite")
def run_all_tests(): suite = combine( AcceptanceTest_test, Gameloop_test, Keyboard_test, Poly_test, Chunk_test, LevelBuilder_test, Room_test, World_test, Material_test, Disc_test, Block_test, TestImage_test, Listener_test, TestCase_test, Camera_test, Screenshot_test, Renderer_test, AT001, ) run(suite)
#!/usr/bin/python -O import fixpath from solescion.testutils.testcase import MyTestCase, run from solescion.model import material as module from solescion.model.material import all_materials class Material_test(MyTestCase): def test_materials(self): self.assertTrue(len(all_materials) > 4, 'not enough') for material in all_materials: self.assertTrue(material.density > 0, "bad density: %s" % (material.name,)) self.assertTrue(0 <= material.elasticity <= 1, "bad elasticity: %s" % (material.name,)) self.assertTrue(material.friction >= 0, "bad friction: %s" % (material.name,)) self.assertValidColor(material.color, "bad color: %s" % (material.name,)) self.assertEquals(getattr(module, material.name), material, "not on module: %s" % (material.name,)) if __name__ == "__main__": run(Material_test)
lambda *_: ["A%03d.png" % idx for idx in range(101)] try: self.assertNone(_get_filename("A", ".png"), "expected None") finally: screenshot_module.listdir = orig def test_save_screenshot(self): self.window = Window( width=12, height=34, visible=False, caption='test_save_screenshot', ) import solescion.utils.screenshot as screenshot_module orig_get = screenshot_module._get_filename filename = join(expanduser("~"), "test_save_screenshot.png") screenshot_module._get_filename = lambda *_: filename try: try: save_screenshot(self.window) finally: screenshot_module._get_filename = orig_get png = image.load(filename) self.assertEquals((png.width, png.height), (12, 34), "bad image") finally: remove(filename) if __name__ == '__main__': run(Save_screenshot_test)
[(0, 0), (0, 1), (1, 0), (0, 0)]) room = Room([(1, 1), (1, 0), (0, 1)]) builder.add_room(room) self.assertEquals(len(builder.geometry.exterior.coords), 5) self.assertEqual( list(builder.geometry.exterior.coords), [(0, 0), (0, 1), (1, 1), (1, 0), (0, 0)]) def test_add_room_works_on_branch_room_and_wall_zero(self): builder = LevelBuilder() branch_room = Room([(1, 0), (0, 0), (0, 1)]) branch_room.id = 0 branch_wall = 0 new_room = Room([(1, 0), (0, 0), (0, 1)]) new_room.neighbours = {} builder.add_room(new_room, branch_room, 0) self.assertEquals(len(builder.rooms), 1) added_room = builder.rooms.values()[0] self.assertEquals(added_room.neighbours, {0: branch_room}) self.assertEquals(branch_room.neighbours, {branch_wall: added_room}) if __name__ == "__main__": run(LevelBuilder_test)
from pymunk.vec2d import Vec2d from solescion.model.game_ent import GameEnt from solescion.testutils.testcase import MyTestCase, run class GameEnt_test(MyTestCase): def testInit(self): ent = GameEnt() self.assertEquals(ent.position, Vec2d(0, 0)) self.assertEquals(ent.angle, 0.0) self.assertNone(ent.batch) if __name__ == "__main__": run(GameEnt_test)
import fixpath from pyglet.window import key from solescion.testutils.listener import Listener from solescion.testutils.testcase import MyTestCase, run from solescion.controller.keyboard import Keyboard, on_key_press class Keyboard_test(MyTestCase): def setUp(self): Keyboard.handlers = {} def test_handlers(self): self.assertEquals(Keyboard.handlers, {}, "bad default handlers") def test_on_key_press(self): listener = Listener() Keyboard.handlers.update({key.SPACE: listener}) on_key_press(key.ESCAPE, 0) self.assertFalse(listener.triggered, "should not trigger") on_key_press(key.SPACE, 0) self.assertTrue(listener.triggered, "should trigger") if __name__=='__main__': run(Keyboard_test)
class Irregular_test(MyTestCase): def test_irregular(self): start = Vec2d(3, -4) face = Vec2d(-6, 0) radius = 5 # irregular poly's circle center is at (0, 0) num_verts = 5 actual = irregular(start, face, radius, num_verts) self.assertEquals(len(actual), 5) self.assertEquals(actual[0], Vec2d(+3, -4)) self.assertEquals(actual[1], Vec2d(-3, -4)) for point in actual: self.assertAlmostEquals(point.get_length_sqrd(), 25.0) def test_irregular_impossible(self): start = Vec2d(-10, -0) face = Vec2d(20, 0) radius = 9 num_verts = 3 self.assertRaises(lambda: irregular(start, face, radius, num_verts), ValueError) Poly_test = combine( Creation_test, Assert_valid_test, Offset_verts_test, Area_test, Centroid_test, Circle_center_test, Irregular_test ) if __name__ == "__main__": run(Poly_test)
self.assertEquals(seg.friction, 0.5, "bad wall friction") self.assertEquals(seg.elasticity, 0.5, "bad wall elasticity") def test_add_to_body_should_not_add_segments_for_neighbours(self): color = (100, 150, 200) v1, v2, v3 = (0,1), (1,2), (2,0) verts = [v1, v2, v3] room = Room(verts) room.neighbours = {1: object(), 2: object()} space = Space() body = Body(inf, inf) room.add_to_body(space, body) segs = set([ ((seg.a[0], seg.a[1]), (seg.b[0], seg.b[1])) for seg in space.static_shapes ]) self.assertEquals(segs, set([(v1, v2)]), "wrong room walls added to space") for seg in space.static_shapes: self.assertEquals(seg.friction, 0.5, "bad wall friction") self.assertEquals(seg.elasticity, 0.5, "bad wall elasticity") if __name__ == "__main__": run(Room_test)
def is_window_visible(): print 'is_visible' win = get_window() return win and win.visible def is_window_fullscreen(): print 'is_fullscreen' win = get_window() return win and win.fullscreen class AT001(AcceptanceTest): # pylint: disable-msg=R0904 # Too many public methods: we are a subclass of unittest.TestCase def test_window(self): conditions = [ is_window_visible, is_window_fullscreen, ] self.set_conditions(conditions) main() if __name__ == "__main__": run(AT001)
chunk.add_to_space.args, (world.space, (1, 2), 0.5), "chunk not added to space") def test_add_chunk_default_angle(self): world = World() chunk = Chunk(Disc(Material.gold, 1)) world.add_chunk(chunk, (10, 20)) body = [b for b in world.space.bodies][0] self.assertEquals(body.angle, 0.0, "bad default angle") def test_tick(self): world = World() world.space.step = Listener() class Mock(object): pass world.player = Mock() world.player.move = lambda *_: None world.tick(1/42) self.assertEquals(world.space.step.args, (1/42,), "didn't step") if __name__ == "__main__": run(World_test)
(1, 4, rectCol), (1, 7, rectCol), (18, 2, rectCol), (18, 4, rectCol), (18, 7, rectCol), ] for x, y, col in roguePixels: image = Image.new('RGB', (20, 10), backCol) draw_rectangle(image, 2, 2, 17, 7, rectCol) image.putpixel((x, y), col) assertion = lambda: assert_rectangle_at( \ image, (2, 2, 17, 7), rectCol, backCol) expectedMsg = "rectangle 2,2 17,7 bad, eg at %d,%d" % (x, y) e = self.assertRaises(assertion, AssertionError) self.assertTrue(e.message.startswith(expectedMsg), \ 'assert_rectange_at raised with bad message') def test_assert_rectangle_at_with_rgba(self): backCol = (123, 45, 6) rectCol = (234, 56, 7) image = Image.new('RGBA', (20, 10), backCol) draw_rectangle(image, 2, 2, 17, 7, rectCol) assert_rectangle_at(image, (2, 2, 17, 7), rectCol, backCol) if __name__ == "__main__": run(TestImage_test)
self.assert_world_projection(rect, expectedRect) def test_world_projection_scale(self): self.camera.scale = 10 rect = (-1, -2, +3, +4) expectedRect = (95, 30, 114, 59) self.assert_world_projection(rect, expectedRect) def test_world_projection_angle(self): self.camera.angle = pi/2 rect = (-0.2, -0.4, +0.6, +0.8) expectedRect = (60, 20, 119, 59) self.assert_world_projection(rect, expectedRect) def test_world_projection_complicated(self): self.camera.angle = -pi/2 self.camera.scale = 10 self.camera.x, self.camera.y = (5, 6) rect = (-1, -2, +3, +4) expectedRect = (60, 20, 89, 39) self.assert_world_projection(rect, expectedRect) if __name__ == "__main__": run(Camera_test)
world.rooms = {1: room1, 2: room2} world.chunks = set([chunk1, chunk2]) listener = Listener() renderer.clear = \ lambda *args: listener("clear", *args) camera.world_projection = \ lambda *args: listener("world_proj", *args) renderer.draw_rooms = \ lambda *args: listener("draw_rooms", *args) renderer.draw_chunk = \ lambda *args: listener("draw_chunk", *args) aspect = 1.5 renderer.draw(world, aspect) expected = [ ("clear", world.material.color), ("world_proj", aspect), ("draw_rooms", {1: room1, 2: room2}), ("draw_chunk", chunk2), ("draw_chunk", chunk1), ] self.assertEquals(listener.args_list, expected, "draw didnt call subfns") if __name__ == "__main__": run(Renderer_test)
#!/usr/bin/python -O import fixpath from solescion.testutils.testcase import MyTestCase, run class AcceptanceTest_test(MyTestCase): def testMe(self): pass if __name__ == "__main__": run(AcceptanceTest_test)
def test_offset(self): disc = Disc(gold, 10, (11, 22)) disc.offset((100, 200)) self.assertEquals(disc.get_centroid(), (111, 222), "didnt apply offset") def test_add_to_body(self): disc = Disc(gold, 5, (1, 2)) body = Body(0, 0) space = Space() space.add(body) disc.add_to_body(space, body) self.assertNotNone(disc.shape, "didnt create shape") self.assertEquals(disc.shape.body, body, "didnt add shape to body") self.assertEquals(disc.shape.radius, 5.0, "bad radius") self.assertEquals(disc.shape.center, Vec2d(1.0, 2.0), "bad center") self.assertAlmostEquals(disc.shape.friction, gold.friction, msg="bad friction") self.assertAlmostEquals(disc.shape.elasticity, gold.elasticity, msg="bad elasticity") self.assertEquals(space.shapes, [disc.shape], "didn't add shape to space") if __name__ == "__main__": run(Disc_test)
listener.return_value = 456 self.assertEquals(listener(), 4, "set return value list 1") self.assertEquals(listener(), 3, "set return value list 2") self.assertEquals(listener(), 2, "set return value list 3") self.assertEquals(listener(), 456, "set return value list over 1") self.assertEquals(listener(), 456, "set return value list over 2") def test_reset(self): listener = Listener() listener.return_values = [4, 3, 2] listener.return_value = 456 listener(1, 2, 3, a=7, b=8, c=9) listener(4, 5, 6, c=10, d=11, e=12) listener.reset() self.assert_is_reset(listener) self.assertEquals(listener(), 2, "reset messed with return_values") self.assertEquals(listener(), 456, "reset messed with return_value") def test_call_preserves_args_identity(self): a = object() listener = Listener() listener(a) self.assertEquals(listener.args, (a,), "args should == a") if __name__ == '__main__': run(Listener_test)
def test_add_to_body(self): space = Space() body = Body(10, 20) verts = [(-1, -1), (-1, +1), (+1, +1), (+1, -1)] offset = (1, 2) block = Block(gold, verts, offset) block.add_to_body(space, body) self.assertEquals(type(block.shape), Poly, "didnt create shape") self.assertEquals(block.shape.body, body, "didnt add shape to body") shapeVerts = block.shape.get_points() expected = [Vec2d(v) for v in offset_verts(verts, offset)] self.assertEquals(shapeVerts, expected, "bad shape verts") self.assertAlmostEquals(block.shape.friction, gold.friction, msg="bad shape friction") self.assertAlmostEquals( block.shape.elasticity, gold.elasticity, msg="bad shape elasticity") spaceShape = [s for s in space.shapes][0] self.assertEquals(block.shape, spaceShape, "didn't add shape to space") if __name__ == "__main__": run(Block_test)
self.gameloop.paused = True self.gameloop.run() self.assertFalse(self.gameloop.world.tick.triggered, "not paused") def test_toggle_pause(self): self.gameloop.toggle_pause() self.assertTrue(self.gameloop.paused, "didn't pause") self.gameloop.toggle_pause() self.assertFalse(self.gameloop.paused, "didn't unpause") def test_quit(self): self.gameloop.window = Mock() self.gameloop.window.close = lambda: None self.gameloop.window.has_exit = False self.gameloop.quit_game() self.assertTrue(self.gameloop.window.has_exit, "window not closed") Gameloop_test = combine( Gameloop_test_with_window, Gameloop_test_without, ) if __name__ == "__main__": run(Gameloop_test)
def test_add_to_space_discs(self): disc1 = Disc(gold, 1) disc2 = Disc(gold, 2) disc3 = Disc(gold, 3) space = Space() chunk = Chunk(disc1, disc2, disc3) chunk.add_to_space(space, (1, 2), 0.75) self.assertEquals(type(chunk.body), Body, "didnt create body") self.assertEquals(chunk.body.position, Vec2d(1, 2), "bad position") self.assertEquals(chunk.body.angle, 0.75, "bad angle") self.assertEquals(space.bodies, set([chunk.body]), "body not added to space") self.assertEquals(len(space.shapes), 3, "shapes not added to space") radii = set() for circle in space.shapes: self.assertEquals(circle.body, chunk.body, "bad Circle body") self.assertEquals(circle.friction, 0.5, "bad friction") self.assertEquals(circle.elasticity, 0.5, "bad elasticity") radii.add(circle.radius) self.assertEquals(radii, set([1, 2, 3]), "bad radii") if __name__ == "__main__": run(Chunk_test)