def assertMove(self, x, y, orientation, direction, expX, expY):
self.p.setPosition(c.Coordinate(x, y))
self.p.setMovementDirection(direction)
self.p.setOrientation(orientation)
expectedPos = c.Coordinate(expX, expY)
self.p.move()
self.assertEqual(expectedPos, self.p.getPosition())
def testStep_setsFinishedStateToTrueWhenNextPosIsFirstCollisionPos(self): setupFakes(self, ori = self.b.ORIENTATION_RIGHT, collision = False, direction = self.b.DIRECTION_FOREWARD) b = theseusBrain.TheseusBrain(self.inputs, self.outputs) b.mObj.expandMap(6, 6, True, True) b.firstCollision = c.Coordinate(3, 4) b.pos = c.Coordinate(2, 4) b.step() self.assertEqual(True, b.finished)
def setUp(self):
self.brainClass = dullBrain.DullBrain
self.mapFile = "maps/test-room1-box.txt"
self.mObj = gameMap.GameMap()
self.mObj.loadMapFile(self.mapFile)
self.pos = c.Coordinate(3, 3)
self.p = player.Player(self.brainClass, self.mObj, self.pos)
def testGetNextPosition_raisesExceptionWhenCalledWithNoneValueAsDirection(
self):
e = baseBrain.ArgumentIsNoneException
msg = "Direction can't be None!"
with self.assertRaises(e) as ex:
self.b.getNextPosition(c.Coordinate(1, 1), 3, None)
self.assertEqual(msg, ex.exception.message)
def testStep_setsPosToNextPositionValue(self): global getNextPositionValue getNextPositionValue = c.Coordinate(66, 88) self.b.getNextPosition = fakeGetNextPosition self.inputs["getOrientation"] = fakeGetOrientation self.b.step() self.assertEqual(getNextPositionValue, self.b._getPosition())
def getNonCollisionFields(self):
fields = []
for y in range(1, len(self.mArr) + 1):
for x in range(1, len(self.mArr[y - 1]) + 1):
if self.getLocation(x, y) == self.COLLISION_FIELD_VALUE:
continue
fields.append(c.Coordinate(x, y))
return fields
def testInit_startPosition_raisesExceptionWhenStartPositonIsNotANonCollisionField(
self):
with self.assertRaises(Exception) as ex:
s1 = sim.Sim(self.gameMapFile, self.brainClass,
sim.Sim.DEFAULT_TIMEOUT, 0, False, c.Coordinate(2, 1))
self.assertEqual(
"startPosition is not a non-collision field (in this map)!",
ex.exception.message)
def testStep_translatesFirstCollisionPosWhenPrependingVertically(self): global getOrientationValue global isCollisionValue setupFakes(self, ori = self.b.ORIENTATION_RIGHT, collision = True, direction = self.b.DIRECTION_FOREWARD) b = theseusBrain.TheseusBrain(self.inputs, self.outputs) b.step() getOrientationValue = setOrientationValue isCollisionValue = False b.step() getOrientationValue = setOrientationValue isCollisionValue = False b.step() self.assertEqual(c.Coordinate(1, 3), b._getFirstCollisionPos())
def positionStrToValue(positionStr):
if positionStr in slCls.RAND_STRINGS:
position = None
elif len(positionStr.split(",")) == 2:
xyArr = positionStr.split(",")
# TODO Move string to coordinate parsing into Coordinate class
x = int(xyArr[0])
y = int(xyArr[1])
position = coord.Coordinate(x, y)
# TODO might check if coordinate is within game map (requires creating a game map obj)
else:
sys.stderr.write("ERROR: Failed to parse coordinate \"%s\"!\n" %
positionStr)
sys.exit(1)
return position
def testDrawPlayerMap_drawsGameMapWithPlayerPositionAndOrientation(self):
global playerGetMapValue
setLoc = gameMap.GameMap.setLocationInArray
ori = self.s.player.getOrientation()
playerSymbol = gameMap.GameMap.PLAYER_POSITION_VALUE_ARR
pos = c.Coordinate(2, 2)
simMapObj = self.s.getSimMap()
simMapArray = simMapObj.getMapArray()
setLoc(simMapArray, pos.y, pos.x, playerSymbol[ori])
playerGetMapValue = gameMap.GameMap()
playerGetMapValue.mArr = simMapArray
txtMap = gameMap.GameMap.arrayToText(simMapArray)
self.s.player.getPlayerMap = fakePlayerGetMap
self.assertEqual(txtMap, self.s.drawPlayerMap())
def testGetNonCollisionFields_forLShapeMap(self):
self.maxDiff = None
mObj = gameMap.GameMap()
mObj.loadMapFile("maps/test-room2-l-shape.txt")
fields = []
mapArray = mObj.getMapArray()
maxY = mObj.getHeight()
for y in range(1, maxY + 1):
if y == 1 or y == maxY:
continue
maxX = len(mapArray[y - 1])
for x in range(1, maxX + 1):
if x == 1 or x == maxX:
continue
# verify that the map location is really a non-collision field
if mObj.getLocation(x, y) == 1:
continue
fields.append(c.Coordinate(x, y))
self.assertEqual(fields, mObj.getNonCollisionFields())
def testGetNonCollisionFields_forBoxMap(self):
mObj = gameMap.GameMap()
mObj.loadMapFile("maps/test-room1-box.txt")
# construct the array of non-collision fields (that matches test-room1-box.txt)
# calculate all coordinates while skipping all collision fields (result is all non-collision fields)
# - skip line with y=1 completely
# - skip line with y=7 comletely
# - subtract first and last x coordinate in every line in between line y=1 and y=7
fields = []
mapArray = mObj.getMapArray()
maxY = mObj.getHeight()
for y in range(1, maxY + 1):
if y == 1 or y == maxY:
continue
maxX = len(mapArray[y - 1])
for x in range(1, maxX + 1):
if x == 1 or x == maxX:
continue
# verify that the map location is really a non-collision field
if mObj.getLocation(x, y) == 1:
continue
fields.append(c.Coordinate(x, y))
self.assertEqual(fields, mObj.getNonCollisionFields())
def testStep_storesFirstCollision(self): setupFakes(self, ori = self.b.ORIENTATION_UP, collision = True, direction = self.b.DIRECTION_FOREWARD) b = theseusBrain.TheseusBrain(self.inputs, self.outputs) b.step() self.assertEqual(c.Coordinate(1, 1), b._getFirstCollisionPos())
def testStep_translatesStartPositionWhenPrependingBrainMapHorizontally(self): setupFakes(self, ori = self.b.ORIENTATION_LEFT, collision = True, direction = self.b.DIRECTION_FOREWARD) b = theseusBrain.TheseusBrain(self.inputs, self.outputs) b.step() self.assertEqual(c.Coordinate(2, 1), b._getStartPosition())
def testInit_startPosition_isUserSpecified(self):
s1 = sim.Sim(self.gameMapFile, self.brainClass,
sim.Sim.DEFAULT_TIMEOUT, 0, False, c.Coordinate(2, 2))
self.assertEqual(c.Coordinate(2, 2), s1.getStartPosition())
def __init__(self, inputs, outputs):
self.inputs = None
self.outputs = None
y = lambda element: element.startswith("is") and element.endswith("Collision")
arg = "inputs"
if not isinstance(inputs, dict):
raise NotADictException(arg)
arg = "outputs"
if not isinstance(outputs, dict):
raise NotADictException(arg)
arg = "inputs"
if len(inputs) == 0:
raise IsEmptyException(arg)
arg = "outputs"
if len(outputs) == 0:
raise IsEmptyException(arg)
# test keys in inputs argument exists
arg = "inputs"
field = "isCollision"
if not self._isInList(inputs.keys(), y):
raise IsNotAKeyException("%s: %s" % (arg, field))
field = "getOrientation"
if not field in inputs.keys():
raise IsNotAKeyException("%s: %s" % (arg, field))
field = "getMovementDirection"
if not field in inputs.keys():
raise IsNotAKeyException("%s: %s" % (arg, field))
# test keys in outputs argument exist
arg = "outputs"
field = "setOrientation"
if not field in outputs.keys():
raise IsNotAKeyException("%s: %s" % (arg, field))
field = "setMovementDirection"
if not field in outputs.keys():
raise IsNotAKeyException("%s: %s" % (arg, field))
field = "move"
if not field in outputs.keys():
raise IsNotAKeyException("%s: %s" % (arg, field))
# test values of inputs argument dict are callable
arg = "inputs"
field = "isCollision"
if not self._isCallable(inputs, y):
raise NotAFunctionException("%s: %s" % (arg, field))
field = "getOrientation"
if not callable(inputs[field]):
raise NotAFunctionException("%s: %s" % (arg, field))
field = "getMovementDirection"
if not callable(inputs[field]):
raise NotAFunctionException("%s: %s" % (arg, field))
# test values of outputs argument dict are callable
arg = "outputs"
field = "setOrientation"
if not callable(outputs[field]):
raise NotAFunctionException("%s: %s" % (arg, field))
field = "setMovementDirection"
if not callable(outputs[field]):
raise NotAFunctionException("%s: %s" % (arg, field))
field = "move"
if not callable(outputs[field]):
raise NotAFunctionException("%s: %s" % (arg, field))
self.inputs = inputs
self.outputs = outputs
self.mObj = gameMap.GameMap()
self.mObj.mArr.append([0])
self.startPos = c.Coordinate(1, 1)
self.pos = c.Coordinate(1, 1)
self.lastPos = None
self.firstCollision = None
self.stepLog = []
self.finished = False
def testTranslate_translatesXAccordingToFirstArgument(self):
self.c.x = 2
self.c.y = 5
self.c.translate(1, 0)
self.assertEqual(coord.Coordinate(3, 5), self.c)
def testFromStr_parsesStringAndSetsXY(self):
self.c.fromStr("<23, 42>")
self.assertEqual(coord.Coordinate(23, 42), self.c)
def testCompare_returnsTrueWhenDataIsEqual(self):
self.c.x = 111
self.c.y = 222
c2 = coord.Coordinate(111, 222)
self.assertEqual(c2, self.c)
def setUp(self):
self.c = coord.Coordinate()
def testGetNextPosition_doesNotChangePosArg(self):
pos = c.Coordinate(7, 7)
self.b.getNextPosition(pos, 1, 1)
self.assertEqual(c.Coordinate(7, 7), pos)
def testInit_startOrientation_isUserSpecified(self):
s1 = sim.Sim(self.gameMapFile,
self.brainClass, sim.Sim.DEFAULT_TIMEOUT, 0, False,
c.Coordinate(2, 2), bb.BaseBrain.ORIENTATION_LEFT)
self.assertEqual(3, s1.getStartOrientation())
def testTranslate_translatesYAccordingToSecondArgument(self):
self.c.x = 2
self.c.y = 5
self.c.translate(0, 1)
self.assertEqual(coord.Coordinate(2, 6), self.c)
def testInit_startOrientation_raisesExceptionWhenValueIsInvalid(self):
with self.assertRaises(Exception) as ex:
s1 = sim.Sim(self.gameMapFile,
self.brainClass, sim.Sim.DEFAULT_TIMEOUT, 0, False,
c.Coordinate(2, 2), 19)
self.assertEqual("startOrientation is invalid!", ex.exception.message)
def testTranslate_translatesXAccordingToFirstArgumentSubtraction(self):
self.c.x = 4
self.c.y = 5
self.c.translate(-2, 0)
self.assertEqual(coord.Coordinate(2, 5), self.c)
def testStep_translatesStepLogWhenPrependingMapOnOrientationLeft(self):
setupFakes(self, ori = self.b.ORIENTATION_LEFT, collision = True, direction = self.b.DIRECTION_FOREWARD)
expected = {"pos": c.Coordinate(2, 1), "ori": getOrientationValue, "direction": getMovementDirectionValue}
self.b.step()
self.assertEqual(expected, self.b.stepLog[0])
def testStep_appendsStepLogWithCurrentPosOriAndDirection(self):
setupFakes(self, ori = self.b.ORIENTATION_UP, collision = False, direction = self.b.DIRECTION_FOREWARD)
expected = {"pos": c.Coordinate(1, 1), "ori": getOrientationValue, "direction": getMovementDirectionValue}
self.b.step()
self.assertEqual(expected, self.b._getStepLog()[0])
def testInit_xIsUserSpecified(self):
c = coord.Coordinate(9, None)
self.assertEqual(9, c.x)
def testGetLastPosition_returnsPreviousPositionAfterMoving(self): setupFakes(self, ori = self.b.ORIENTATION_UP, collision = False, direction = self.b.DIRECTION_FOREWARD) self.b.step() self.assertEqual(c.Coordinate(1, 1), self.b._getLastPosition())
def testInit_yIsUserSpecified(self):
c = coord.Coordinate(None, 32)
self.assertEqual(32, c.y)
