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)
