public void cannot_move_rover()
{
var rover = new Rover(new Coordinate(0, 0), CameraDirection.West);
rover.OnMoving(c => false);
Assert.Throws<RoverCannotMoveException>(() => rover.SendInstruction(RoverInstruction.M));
}
public void TestRoverWrapsAroundPlanetBackward()
{
var rover = new Rover(new Point { X = -50, Y = 0 }, 'E', stateFactory, planet);
rover.MoveBackward();
Assert.That(rover.GetCurrentPosition().ToString(), Is.EqualTo("50,0"));
}
public void when_the_rover_is_created()
{
var initialPosition = new Position(1, 2, Direction.North);
var rover = new Rover(initialPosition, _plateau, _instructionHandler);
"It should set the position".AssertThat(rover.Position, Is.EqualTo(initialPosition));
}
public void TestRoverEncountersObstacleOnOtherSideOfXAxis()
{
var planetWithObstacles = new Planet(50, new[] { new Point { X = 0, Y = -25 } });
var rover = new Rover(new Point(0, 25), 'N', planetWithObstacles);
var driver = new RoverDriver(rover);
Assert.That(driver.MoveRover("ffrff"), Is.EqualTo("Rover encountered obstacle at position (0,-25), rover stopped at (0,25)."));
}
public void TestRoverEncountersObstacle()
{
var planetWithObstacles = new Planet(50, new [] { new Point { X = 3, Y = 3} } );
var rover = new Rover(new Point(3, 2), 'N', planetWithObstacles);
var driver = new RoverDriver(rover);
Assert.That(driver.MoveRover("ffrff"), Is.EqualTo("Rover encountered obstacle at position (3,3), rover stopped at (3,2)."));
}
protected void GivenRoverWithDirection(IDirectionState direction)
{
var coordinate = new Coordinate(5, 5);
var plateau = new Plateau(100, 100);
Rover = new Rover(plateau, coordinate, direction);
}
public void BecauseOf()
{
var input = "LMLMLMLMM";
var plateau = new Plateau(5, 5);
var rover = new Rover(new Position(1, 2), "N", plateau);
_commandProcessorResult = new CommandProcessor().Process(input, rover, plateau);
}
public void TestMoveForward()
{
var rover = new Rover(new Point { X = 0, Y = 0 }, 'E', stateFactory, planet);
rover.MoveForward();
Assert.That(rover.GetCurrentPosition().ToString(), Is.EqualTo("1,0"));
}
public void moves_west()
{
var rover = new Rover(new Coordinate(1, 0), CameraDirection.West);
rover.SendInstruction(RoverInstruction.M);
Assert.AreEqual(new Coordinate(0, 0), rover.Coordinate);
}
public void TestEnountersObstructionAndDoesNotMoveForward()
{
var planetWithObstruction = new Planet(50, new Point[] { new Point { X = 1, Y = 0 } });
var rover = new Rover(new Point { X = 0, Y = 0 }, 'E', stateFactory, planetWithObstruction);
rover.MoveForward();
Assert.That(rover.GetCurrentPosition().ToString(), Is.EqualTo("0,0"));
}
public void changes_direction(RoverInstruction instruction, CameraDirection initialDirection, CameraDirection expectedDirection)
{
var rover = new Rover(new Coordinate(0, 0), initialDirection);
rover.SendInstruction(instruction);
Assert.AreEqual(expectedDirection, rover.CameraDirection);
}
public void TestEncounterObstacleOnOtherSideOfAxisAndDoesNotMoveForward()
{
var planetWithObstruction = new Planet(50, new Point[] { new Point { X = -25, Y = 0 } });
var rover = new Rover(new Point { X = 25, Y = 0 }, 'E', stateFactory, planetWithObstruction);
rover.MoveForward();
Assert.That(rover.GetCurrentPosition().ToString(), Is.EqualTo("25,0"));
}
public void GoingOffTheGridToTheTopWrapsToTheBottom()
{
var rover = new Rover(new Position(1, 99), Direction.N, new Grid(100, 100));
rover.Go(@"ff");
Assert.Equal(new Position(1, 1), rover.RoverState.Position);
}
public void MoveRoverBackwardFacingSouth()
{
var rover = new Rover(new Position(1, 1), Direction.S);
rover.Go(@"b");
Assert.Equal(new Position(1, 2), rover.RoverState.Position);
}
public void Asks_if_deploy_point_is_valid_for_landing_surface()
{
var aPoint = new Point(0, 0);
mockLandingSurface.Setup(x => x.IsValid(aPoint)).Returns(true);
var rover = new Rover();
rover.Deploy(mockLandingSurface.Object, aPoint, CardinalDirection.South);
mockLandingSurface.Verify(x => x.IsValid(aPoint), Times.Once());
}
public void GoingOffTheGridToTheRightWrapsToTheLeft()
{
var rover = new Rover(new Position(99, 1), Direction.E, new Grid(100, 100));
rover.Go(@"f");
Assert.Equal(new Position(0, 1), rover.RoverState.Position);
}
public void AsARoverIShouldDecrementMyXPositionWhenMovingToWest()
{
var rover = new Rover(new West(), new Coordinate("1 0"), _terrain);
rover.Move();
Assert.AreEqual("0 0 W", rover.Position);
}
public void cannot_move_rover_outside_of_plateau(int x, int y, CameraDirection cameraDirection)
{
var mars = new Plateau(new Size(1, 1));
var rover = new Rover(new Coordinate(x, y), cameraDirection);
mars.PlaceRover(rover);
Assert.Throws<RoverCannotMoveException>(() => rover.SendInstruction(RoverInstruction.M));
}
public void AsARoverIShouldRaiseAnExceptionBeforeMovingToAInvalidTerrainUpperBoundaryXAxisValue()
{
var rover = new Rover(new East(), new Coordinate("1 0"), _terrain);
rover.Move();
Assert.AreEqual("1 0 E", rover.Position);
}
public void AsARoverIShouldIncrementMyYPositionWhenMovingToNorth()
{
var rover = new Rover(new North(), new Coordinate("0 0"), _terrain);
rover.Move();
Assert.AreEqual("0 1 N", rover.Position);
}
public override void Execute(Rover rover)
{
base.Execute(rover);
rover.CurrentPosition = CalculateNewRoverPosition(
new Position(rover.CurrentPosition.XCoordinate,
rover.CurrentPosition.YCoordinate),
rover.Orientation);
}
public void should_navigate_correcty_on_Left_command_when_rover_at_1_1_heading_West()
{
var rover = new Rover(1, 1, Direction.West);
rover.Navigate(Command.Left);
Assert.AreEqual(1, rover.Easting);
Assert.AreEqual(1, rover.Northing);
Assert.AreEqual(Direction.South, rover.Heading);
}
public void moves_south()
{
var rover = new Rover(new Coordinate(0, 1), CameraDirection.South);
rover.SendInstruction(RoverInstruction.M);
Assert.AreEqual(new Coordinate(0, 0), rover.Coordinate);
}
public void should_navigate_correcty_on_Move_command_when_rover_at_1_1_heading_East()
{
var rover = new Rover(1, 1, Direction.East);
rover.Navigate(Command.Move);
Assert.AreEqual(2, rover.Easting);
Assert.AreEqual(1, rover.Northing);
Assert.AreEqual(Direction.East, rover.Heading);
}
public void AsARoverIShouldRaiseAnExceptionBeforeMovingToAInvalidTerrainLowerBoundaryXAxisValue()
{
var terrain = new Terrain(new Coordinate("1 1"));
var rover = new Rover(new West(), new Coordinate("0 0"), _terrain);
rover.Move();
Assert.AreEqual("0 0 W", rover.Position);
}
public void when_updated_position_is_outside_the_plateau()
{
var initialPosition = new Position(1, 2, Direction.North);
var updatedPosition = new Position(10, 20, Direction.South);
_instructionHandler.Stub(x => x.Handle("L", initialPosition)).Return(updatedPosition);
var rover = new Rover(initialPosition, _plateau, _instructionHandler);
"It should throw an exception".AssertThrows<InvalidOperationException>(() => rover.ProcessInstructions("L"));
}
public void Given_valid_deploy_point_and_direction_exposes_as_properties(int expectedX, int expectedY, CardinalDirection expectedCardinalDirection)
{
var expectedPoint = new Point(expectedX, expectedY);
mockLandingSurface.Setup(x => x.IsValid(expectedPoint)).Returns(true);
var rover = new Rover();
rover.Deploy(mockLandingSurface.Object, expectedPoint, expectedCardinalDirection);
Assert.AreEqual(expectedPoint, rover.Position);
Assert.AreEqual(expectedCardinalDirection, rover.CardinalDirection);
}
public void cannot_move_rover_if_it_will_collide_with_another_rover()
{
var mars = new Plateau(new Size(3, 3));
var rover = new Rover(new Coordinate(1, 1), CameraDirection.North);
mars.PlaceRover(rover);
var rover2 = new Rover(new Coordinate(1, 2), CameraDirection.South);
mars.PlaceRover(rover2);
Assert.Throws<RoverCannotMoveException>(() => rover2.SendInstruction(RoverInstruction.M));
}
public override void Execute(Rover rover)
{
base.Execute(rover);
var currentOrientationIndex =
Constants.Orientations.FindIndex(x => x == rover.Orientation);
var orientationIndex = CalculateOrientationIndex(
currentOrientationIndex, Constants.Orientations);
rover.Orientation = Constants.Orientations[orientationIndex];
}
public void BecauseOf()
{
_rover = new Rover(new Position(5, 5), "N", new Plateau(5, 5));
try
{
new MoveCommand().Execute(_rover);
}
catch (ApplicationException)
{
_exceptionThrown = true;
}
}
public void Execute(Rover _rover)
{
_rover.Move();
}
public void Check_Second_Rover_Position()
{
Rover rover = new Rover(_plateau, _routerFactory, new Position(3, 3, Orientation.East), "MMRMMRMRRM");
Assert.Equal("5 1 E", rover.GetCurrentPosition().ToString());
}
public FireMissileCommand(Rover rover)
{
Rover = rover;
}
public void Apply(Rover rover)
{
DirectionBase.Directions[rover.Position.Facing].Apply(rover);
}
public RoverMover(Rover rover)
{
Rover = rover;
}
public void Run(Rover rover)
{
RunCount++;
}
public RoverTest()
{
rover = new Rover(new Position(3, 3, 'N'));
}
private static void PrintLocation(Rover rover)
{
Console.WriteLine($"X: {rover.X}, Y: {rover.Y}, Direction: {rover.Direction}");
}
public RotateRightCommand(Rover rover) : base(rover)
{
}
public void Empty_Or_Null_Command_Should_Do_Nothing(string command)
{
var rover = new Rover(0, 0, 'N'.ToDirection());
rover.HandleCommand(command);
}
public MoveRoverResult(Coordinate finalCord, Rover rover, LegalityOfMove legalityOfMove)
{
_finalCord = finalCord;
_rover = rover;
_legalityOfMove = legalityOfMove;
}
public override void moveForward(Rover rover)
{
rover.setCoordinateY(rover.getCoordinateY() - 1);
}
protected Decorator(Rover roverBase)
{
this._roverBase = roverBase;
}
public Forward(Rover rover)
{
_rover = rover;
}
public void Check_First_Rover_Position()
{
Rover rover = new Rover(_plateau, _routerFactory, new Position(1, 2, Orientation.North), "LMLMLMLMM");
Assert.Equal("1 3 N", rover.GetCurrentPosition().ToString());
}
public RoverCommandFactory(Rover rover, int[] dimentions)
{
_rover = rover;
_dimentions = dimentions;
}
public override void MoveForward(Rover rover)
{
rover.SetCoordinateX(rover.GetCoordinateX() + 1);
}
public override void moveBack(Rover rover)
{
rover.setCoordinateY(rover.getCoordinateY() + 1);
}
public void Execute(Rover rover)
{
rover?.TurnRight();
}
void InitMars()
{
Debug.Log(configFile.text);
bool hasReadFirstLine = false;
bool hasNewRover = false;
foreach (var line in configFile.text.Split('\n'))
{
// Debug.Log("line:" + line);
string trimedLine = line.Trim();
if (!hasReadFirstLine)
{
Width = int.Parse(trimedLine.Split(',')[0]);
Height = int.Parse(trimedLine.Split(',')[1]);
Map = new int[Width, Height];
for (int i = 0; i < Width; ++i)
{
for (int j = 0; j < Height; ++j)
{
Map[i, j] = FLOOR;
}
}
hasReadFirstLine = true;
}
else
{
if (!hasNewRover)
{
hasNewRover = true;
string[] roverDetails = trimedLine.Split(',');
int x = int.Parse(roverDetails[0]);
int y = int.Parse(roverDetails[1]);
Rover.Direction dir = (Rover.Direction)Enum.Parse(typeof(Rover.Direction), roverDetails[2]);
GameObject newRover = Instantiate(roverPrefab) as GameObject;
newRover.name = "Rover" + (Rovers.Count + 1);
Rover newRoverScript = newRover.GetComponent <Rover>();
newRoverScript.DrawRover(x, y, dir);
Rovers.Add(newRoverScript);
Map[x, y] = ROVER;
}
else
{
Rover.Command[] commands = new Rover.Command[trimedLine.Length];
for (int i = 0; i < trimedLine.Length; ++i)
{
// Debug.Log(trimedLine[i]);
commands[i] = (Rover.Command)Enum.Parse(typeof(Rover.Command), trimedLine[i].ToString());
}
Rovers[Rovers.Count - 1].SetRoverCommands(commands);
hasNewRover = false;
}
}
}
if (hasNewRover)
{
Debug.LogError("Config file format error!");
return;
}
}
public override void Execute() => Rover.RotateRight();
public virtual void CreateNewRover(string x, string y, string cardinalDirection)
{
var rover = new Rover(int.Parse(x), int.Parse(y), CardinalDirectionExtensions.Parse(cardinalDirection));
this.Plateau.AddRover(rover);
}
public override bool Execute()
{
return(Rover.TurnLeft());
}
public RoverCommandTurnLeft(Rover rover) : base(rover)
{
}
public RoverTest()
{
_rover = new Rover(3, 3, "N");
}
public Rover Move(Rover rover, Planet planet)
{
return(new Rover(rover.Position, rover.Direction.Right()));
}
public void Invalid_COmmands_Should_Throw_Exception(string command)
{
var rover = new Rover(0, 0, 'N'.ToDirection());
rover.HandleCommand(command);
}
public void Init()
{
rover = new Rover(1, 1);
}
protected bool Equals(Rover other)
{
return(XCoordinate == other.XCoordinate && YCoordinate == other.YCoordinate && CompassDirection == other.CompassDirection);
}
public void MyTestInitialize()
{
command = new RotateLeftCommand();
roverMock = Substitute.For <Rover>();
}
