def test_utils_ne(self):
act = vector(1, 2)
w = vector(1, 2)
z = vector(1, 3)
x = vector(3, 2)
self.assertEquals(False, act != w)
self.assertEquals(True, act != z)
self.assertEquals(True, act != x)
self.assertEquals(True, act != 4)
def test_bounce_draw(self):
from freegames.bounce import ball, aim, draw
aim = vector(201, -201)
ball = vector(201, -201)
ball.x = 201
ball.y = -201
draw()
self.assertEquals(201, aim.x)
self.assertEquals(-201, aim.y)
def test_snake_change(self):
from freegames.snake import change, aim
from freegames.utils import vector
aim = vector(0, -10)
changevector = vector(10, 15)
change(changevector.x, changevector.y)
self.assertEquals(10, aim.x)
self.assertEquals(15, aim.y)
def test_utils_add(self):
exp_x = 4
exp_y = 6
v = vector(1, 2)
w = vector(3, 4)
act = v + w
self.assertEquals(False, act is v)
self.assertEquals(False, act is w)
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
def test_utils_iadd(self):
exp_x = 4
exp_y = 6
act = vector(1, 2)
w = vector(3, 4)
act += w
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
h = hash(act)
with self.assertRaises(Exception): act += w
def test_utils_sub(self):
exp_x = -2
exp_y = -2
v = vector(1, 2)
w = vector(3, 4)
act = v - w
self.assertEquals(False, act is v)
self.assertEquals(False, act is w)
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
def test_utils_isub(self):
exp_x = -2
exp_y = -2
act = vector(1, 2)
w = vector(3, 4)
act -= w
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
h = hash(act)
with self.assertRaises(Exception): act -= w
def test_pacman_change(self):
from freegames.pacman import change, aim
# Positive Test
newDir = vector(100, 100)
change(newDir.x, newDir.y)
self.assertEqual(newDir.x, aim.x)
self.assertEqual(newDir.y, aim.y)
# Negative Test
newDir = vector(200, 200)
change(newDir.x, newDir.y)
self.assertEqual(100, aim.x)
self.assertEqual(100, aim.y)
def test_snake_inside(self):
from freegames.flappy import inside
from freegames.utils import vector
testbounds = vector(150, 150)
self.assertTrue(inside(testbounds))
testpt = vector(90, 90)
self.assertTrue(inside(testpt))
testneg = vector(205, 205)
self.assertFalse(inside(testneg))
def test_pacman_valid(self):
from freegames.pacman import valid
# Positive Test
point = vector(100,100)
self.assertTrue(valid(point))
# Negative Test
point = vector(101,101)
self.assertFalse(valid(point))
# Boundary Test 1
point = vector(200,200)
self.assertFalse(valid(point))
# Boundary Test 2
point = vector(-220,-220)
self.assertFalse(valid(point))
def test_cannon_inside(self):
from freegames.cannon import inside
# Positive Test
point = vector(100, 100)
self.assertTrue(inside(point))
# Negative Test
point = vector(201, 201)
self.assertFalse(inside(point))
# Boundary Test
point = vector(199, 199)
self.assertTrue(inside(point))
# Boundary Test
point = vector(-199, -199)
self.assertTrue(inside(point))
def test_utils_x(self):
exp_x = 3
exp_y = 2
act = vector(1, 2)
act.x = 3
self.assertEqual(exp_x, act.x)
self.assertEqual(exp_y, act.y)
def test_utils_y(self):
exp_x = 1
exp_y = 4
act = vector(1, 2)
act.y = 4
self.assertEqual(exp_x, act.x)
self.assertEqual(exp_y, act.y)
def test_utils_getitem(self):
exp_x = 3
exp_y = 4
act = vector(3, 4)
self.assertEqual(exp_x, act[0])
self.assertEqual(exp_y, act[1])
with self.assertRaises(Exception): act[2]
def test_utils_scale(self):
# Check scaling with vector
exp_x = 3
exp_y = 8
act = vector(1, 2)
w = vector(3, 4)
act.scale(w)
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
# Check scaling with normal numbers
exp_x = 3
exp_y = 6
act = vector(1, 2)
act.scale(3)
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
def test_utils_copy(self):
exp_x = 1
exp_y = 2
v = vector(1, 2)
c = v.copy()
self.assertEquals(False, v is c)
self.assertEquals(exp_x, c.x)
self.assertEquals(exp_y, c.y)
def test_utils_neg(self):
exp_x = -1
exp_y = -2
v = vector(1, 2)
act = -v
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
self.assertEquals(False, v is -v)
def test_utils_truediv(self):
exp_x = 3
exp_y = 2
v = vector(3, 4)
w = vector(1, 2)
act = v / w
self.assertEquals(False, act is v)
self.assertEquals(False, act is w)
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
# Check dividing by normal numbers
exp_x = 1
exp_y = 2
v = vector(2, 4)
act = v /2
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
def test_utils_itruediv(self):
exp_x = 3
exp_y = 2
act = vector(3, 4)
w = vector(1, 2)
act /= w
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
# Check dividing by normal numbers
exp_x = 1
exp_y = 2
act = vector(2, 4)
act /= 2
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
# Check hash
h = hash(act)
with self.assertRaises(Exception): act /= w
def test_utils_imul(self):
exp_x = 3
exp_y = 8
act = vector(1, 2)
w = vector(3, 4)
act *= w
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
# Check multiplying by normal numbers
exp_x = 3
exp_y = 6
act = vector(1, 2)
act *= 3
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
# Check hash
h = hash(act)
with self.assertRaises(Exception): act *= w
def test_pacman_offset(self):
from freegames.pacman import offset
# test 1
point = vector(100,100)
act = offset(point)
exp = 95
self.assertEqual(act, exp)
# test 2
point = vector(0,0)
act = offset(point)
exp =190
self.assertEqual(act, exp)
# test 3
point = vector(200,200)
act = offset(point)
exp = 0
self.assertEqual(act, exp)
# test 4
point = vector(-220,-220)
act = offset(point)
exp = 399
self.assertEqual(act, exp)
def test_cannon_tap(self):
from freegames.cannon import tap, ball, speed
# Positive Test
ball.x = 201
ball.y = -201
point = vector(100, 100)
tap(point.x, point.y)
self.assertEqual(ball.x, -199)
self.assertEqual(ball.y, -199)
self.assertEqual(speed.x, 12)
self.assertEqual(speed.y, 12)
# Negative Test
ball.x = 199
ball.y = -199
speed.x = 0
speed.y = 0
point = vector(100, 100)
tap(point.x, point.y)
self.assertEqual(ball.x, 199)
self.assertEqual(ball.y, -199)
self.assertEqual(speed.x, 0)
self.assertEqual(speed.y, 0)
def test_utils_rotate(self):
# Check positive rotation
exp_x = -2
exp_y = 1
act = vector(1, 2)
act.rotate(90)
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
# Check negative rotation
exp_x = 1
exp_y = 2
act.rotate(-90)
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
def test_utils_mul(self):
exp_x = 3
exp_y = 8
v = vector(1, 2)
w = vector(3, 4)
act = v * w
self.assertEquals(False, act is v)
self.assertEquals(False, act is w)
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
# Check multiplying by normal numbers
exp_x = 3
exp_y = 6
v = vector(1, 2)
act = v * 3
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
# Check right hand multiplying by normal numbers
exp_x = 3
exp_y = 6
v = vector(1, 2)
act = 3 * v
self.assertEquals(exp_x, act.x)
self.assertEquals(exp_y, act.y)
def test_change_after_hash():
v = utils.vector(0, 0)
hash(v)
with raises(ValueError):
v.x = 1
with raises(ValueError):
v.y = 1
with raises(ValueError):
v += 1
with raises(ValueError):
v -= 1
with raises(ValueError):
v *= 2
with raises(ValueError):
v /= 2
with raises(ValueError):
v.rotate(90)
def test_change_after_hash():
v = utils.vector(0, 0)
hash(v)
with raises(ValueError):
v.x = 1
with raises(ValueError):
v.y = 1
with raises(ValueError):
v += 1
with raises(ValueError):
v -= 1
with raises(ValueError):
v *= 2
with raises(ValueError):
v /= 2
with raises(ValueError):
v.rotate(90)
def test_not_implemented_paths():
v = utils.vector(0, 0)
assert not (v == 0)
assert v != 0
def test_utils_len(self):
exp = 2
v = vector(1, 5)
act = len(v)
self.assertEqual(exp, act)
def test_utils_hash(self):
act = vector(1, 2)
h = hash(act)
with self.assertRaises(Exception): act.x = 3
def test_utils_init(self):
exp_x = 1
exp_y = 2
act = vector(1, 2)
self.assertEqual(exp_x, act.x)
self.assertEqual(exp_y, act.y)
def test_utils_repr(self):
exp = 'vector(1, 2)'
v = vector(1, 2)
act = repr(v)
self.assertEquals(exp, act)
def test_utils_abs(self):
exp = 5
v = vector(3, 4)
act = abs(v)
self.assertEquals(exp, act)
