public void RoverExecutesCommandSequenceThatLeadsIntoObstacle()
{
var grid = new GridBuilder()
.WithDimensions(2, 2)
.WithObstacleAt(1, 1)
.Build();
var startingPosition = new PositionBuilder()
.OnGrid(grid)
.WithCoordinates(new Coordinates(0, 0))
.Facing(DirectionEnum.North)
.Build();
var rover = new RoverBuilder()
.AtPosition(startingPosition)
.Build();
var roverControl = new RoverControlBuilder()
.ForRover(rover)
.Build();
roverControl.SendCommands("frf");
roverControl.InvokeCommands();
var endingPosition = new PositionBuilder()
.OnGrid(grid)
.WithCoordinates(new Coordinates(0, 1))
.Facing(DirectionEnum.East)
.Build();
Assert.Equal(endingPosition, rover.Position);
}
public void GetRover_WithNavigationOnExistingRoverPosition_ThrowsIndexOutOfRangeException()
{
Assert.ThrowsException <IndexOutOfRangeException>(() =>
{
string rover1Name = "Rover 1";
uint landing1X = 5;
uint landing1Y = 5;
string rover2Name = "Rover 2";
uint landing2X = 4;
uint landing2Y = 5;
RoverOrientation orientation = RoverOrientation.N;
var plateau = GetPlateau();
RoverBuilder.Builder(plateau)
.SetName(rover1Name)
.Landing(landing1X, landing1Y, orientation)
.Create();
RoverBuilder.Builder(plateau)
.SetName(rover2Name)
.Landing(landing2X, landing2Y, orientation)
.Navigate('R', 'M')
.Create();
});
}
public void RoverRunsIntoObstacleAndReports()
{
var grid = new GridBuilder()
.WithDimensions(2, 2)
.WithObstacleAt(1, 0)
.Build();
var startingPosition = new PositionBuilder()
.OnGrid(grid)
.WithCoordinates(new Coordinates(0, 0))
.Facing(DirectionEnum.West)
.Build();
var rover = new RoverBuilder()
.AtPosition(startingPosition)
.Build();
var roverControl = new RoverControlBuilder()
.ForRover(rover)
.Build();
roverControl.SendCommands("f");
var detectedObstacle = roverControl.InvokeCommands();
Assert.Equal(startingPosition, rover.Position);
Assert.True(detectedObstacle);
Assert.Empty(roverControl.Commands);
}
public void GivenACommandFor2RoversWithFirstInvalid_ShouldGenerateACorrectPlanForSecondRover_AndFirstRoverHasError(string command)
{
var plateau = new Plateau(5, 5);
var rover1 = new RoverBuilder(1).Operational(1, 1, Direction.North).Build();
var rover2 = new RoverBuilder(2).Operational(3, 3, Direction.West).Build();
object[] commands2 = { Command.Move, Command.TurnLeft, Command.Move };
var plan = _planControl.GeneratePlan(command);
plan.Plateau.Should().Be(plateau);
plan.RoverRoutes.Count().Should().Be(1, "One route should be planned.");
// First Rover is with error
plan.RoversWithError.Should().Contain(rover1);
// Second Rover has routes
var roverRoute1 = plan.RoverRoutes.ElementAt(0);
roverRoute1.Rover.Should().Be(rover2);
roverRoute1.Commands.Should().BeEquivalentTo(commands2);
roverRoute1.Rover.Position.Should().Be(rover2.Position);
roverRoute1.Rover.FacingDirection.Should().Be(rover2.FacingDirection);
}
public void GivenInvalidInput_ForANotDeployedRover_ShouldNotBuild(string error)
{
Action action = () =>
{
_ = new RoverBuilder(SomeId).NotDeployed(error).Build();
};
action.Should().Throw <ArgumentNullException>();
}
public void GivenInvalidInput_ForAStoppedBeforeCrashRover_ShouldNotBuild(Direction facingDirection, string error)
{
Action action = () =>
{
_ = new RoverBuilder(SomeId).StoppedBeforeCrash(1, 1, facingDirection, error).Build();
};
action.Should().Throw <ArgumentNullException>();
}
public void ExecuteCommandSequence_InvalidCommand()
{
var rover = new RoverBuilder().Build();
var commands = new char[] { 'Z' };
var result = rover.ExecuteCommandSequence(commands);
Assert.AreEqual(ResultCode.CommandNotRecognized, result.Result);
}
public void GivenInvalidInput_ForAnOperationalRover_ShouldNotBuild()
{
Action action = () =>
{
_ = new RoverBuilder(SomeId).Operational(1, 1, null).Build();
};
action.Should().Throw <ArgumentNullException>();
}
public void GivenValidInput_ForAnOperationalRover_ShouldBuild_AndNotWaitRescue(uint positionX, uint positionY, Direction facingDirection)
{
Action action = () =>
{
var rover = new RoverBuilder(SomeId).Operational(positionX, positionY, facingDirection).Build();
rover.IsWaitingRescue.Should().BeFalse();
};
action.Should().NotThrow("Rover was correctly built.");
}
public void GivenValidInput_ForANotDeployedRover_ShouldBuild_AndRoverShouldWaitForRescue()
{
Action action = () =>
{
var rover = new RoverBuilder(SomeId).NotDeployed("Some error").Build();
rover.IsWaitingRescue.Should().BeTrue();
};
action.Should().NotThrow("Rover was correctly built.");
}
public void GivenValidInput_ForAStoppedBeforeCrashRover_ShouldBuild_AndRoverShouldWaitForRescue(uint positionX, uint positionY, Direction facingDirection, string error)
{
Action action = () =>
{
var rover = new RoverBuilder(SomeId).StoppedBeforeCrash(positionX, positionY, facingDirection, error).Build();
rover.IsWaitingRescue.Should().BeTrue();
};
action.Should().NotThrow("Rover was correctly built.");
}
public void GivenValidInputForARoverRoute_ShouldCreateARoverRoute()
{
var rover = new RoverBuilder(1).Operational(1, 1, Direction.North).Build();
var commands = new[] { Command.Move, Command.TurnRight, Command.Move, };
Action action = () =>
{
_ = new RoverRoute(rover, commands);
};
action.Should().NotThrow("Rover route was correctly created");
}
public void GivenARoverRouteWithEmptyCommands_ShouldThrowInvalidOperationException()
{
var rover = new RoverBuilder(1).Operational(1, 1, Direction.North).Build();
var commands = Array.Empty <Command>();
Action action = () =>
{
_ = new RoverRoute(rover, commands);
};
action.Should().Throw <InvalidOperationException>();
}
public void ParseBackwardsCommand()
{
var rover = new RoverBuilder()
.AtDefaultPosition()
.Build();
var roverCommandParser = new RoverCommandFactoryBuilder()
.ForRover(rover)
.Build();
var command = roverCommandParser.Parse('B');
Assert.True(command is RoverCommandBackwards);
}
public void WhenParameterCountIs3_And_ParametersAreValid__ResponseShouldNotBeNull(string arg,
int expectedX, int expectedY, CompassDirections expectedDirection)
{
var sut = new RoverBuilder();
Vehicle vehicle = sut.Build(arg);
Assert.NotNull(vehicle);
Assert.Equal(expectedX, vehicle.CurrentPoint.X);
Assert.Equal(expectedY, vehicle.CurrentPoint.Y);
Assert.Equal(expectedDirection, vehicle.Facade);
}
public void TurnRight()
{
var rover = new RoverBuilder().Build();
var position = rover.Position;
var direction = rover.Direction;
var commands = new char[] { 'r' };
var result = rover.ExecuteCommandSequence(commands);
Assert.AreEqual(ResultCode.CommandExecuted, result.Result);
Assert.AreEqual(position, rover.Position);
Assert.AreEqual(direction.TurnRight(), rover.Direction);
}
public void ParseTurnLeftCommand()
{
var rover = new RoverBuilder()
.AtDefaultPosition()
.Build();
var roverCommandParser = new RoverCommandFactoryBuilder()
.ForRover(rover)
.Build();
var command = roverCommandParser.Parse('l');
Assert.True(command is RoverCommandTurnLeft);
}
public void MoveBackward()
{
var rover = new RoverBuilder().Build();
var position = rover.Position;
var direction = rover.Direction;
var commands = new char[] { 'b' };
var result = rover.ExecuteCommandSequence(commands);
Assert.AreEqual(ResultCode.CommandExecuted, result.Result);
Assert.AreEqual(position.GetBackwardMovementCoordinates(direction), rover.Position);
Assert.AreEqual(direction, rover.Direction);
}
public void RoverWrapsGridMovingForward(Position startingPosition, Position positionAfterWrap)
{
var rover = new RoverBuilder()
.AtPosition(startingPosition)
.Build();
var roverControl = new RoverControlBuilder()
.ForRover(rover)
.Build();
roverControl.SendCommands("f");
roverControl.InvokeCommands();
Assert.Equal(positionAfterWrap, rover.Position);
}
public void RoverMovesBackwards(Position startingPosition, Position positionAfterMovement)
{
var rover = new RoverBuilder()
.AtPosition(startingPosition)
.Build();
var roverControl = new RoverControlBuilder()
.ForRover(rover)
.Build();
roverControl.SendCommands("B");
roverControl.InvokeCommands();
Assert.Equal(positionAfterMovement, rover.Position);
}
public void rover_camera_should_take_a_photo()
{
var rover = new RoverBuilder().Build();
Assert.IsNotNull(rover.Camera);
Assert.IsNotNull(rover.Photos);
int oldPhotoCount = rover.Photos.Count;
rover.TakePhoto();
int newPhotoCount = rover.Photos.Count;
Assert.AreEqual(oldPhotoCount + 1, newPhotoCount);
}
public void RoverBuilderTest()
{
int initialPositionX = 1;
int initialPositionY = 2;
string direction = "E";
var obstacleDetector = ObstacleDetector.Create(new List <Coordinates>());
var actual = new RoverBuilder().LandedIn(initialPositionX, initialPositionY)
.DirectedTowards(direction)
.Build();
Assert.AreEqual(direction, actual.Direction.Code);
Assert.AreEqual(initialPositionX, actual.Position.X);
Assert.AreEqual(initialPositionY, actual.Position.Y);
}
public void KnightMovement_InvalidSequence()
{
var rover = new RoverBuilder().LandedIn(1, 1)
.DirectedTowards("N")
.Build();
var commands = new char[] { 'f', 'f', 'Z', 'f' };
var expectedPosition = Coordinates.Create(1, 3);
var expectedDirection = DirectionsList.N;
var result = rover.ExecuteCommandSequence(commands);
Assert.AreEqual(ResultCode.CommandNotRecognized, result.Result);
Assert.AreEqual(expectedPosition, rover.Position);
Assert.AreEqual(expectedDirection, rover.Direction);
}
public void KnightMovement_Reversed()
{
var rover = new RoverBuilder().LandedIn(2, 3)
.DirectedTowards("E")
.Build();
var commands = new char[] { 'r', 'r', 'f', 'l', 'f', 'f' };
var expectedPosition = Coordinates.Create(1, 1);
var expectedDirection = DirectionsList.S;
var result = rover.ExecuteCommandSequence(commands);
Assert.AreEqual(ResultCode.CommandExecuted, result.Result);
Assert.AreEqual(expectedPosition, rover.Position);
Assert.AreEqual(expectedDirection, rover.Direction);
}
public void rover_should_have_compasspoint_position_and_x_y_coordinate_location()
{
var rover = new RoverBuilder().Build();
rover.Position = CompassPoint.North;
rover.Location = new Location {
X = 0, Y = 0
};
Assert.IsNotNull(rover.Position);
Assert.IsNotNull(rover.Location);
Assert.AreEqual(rover.Position, CompassPoint.North);
Assert.AreEqual(rover.Location.X, 0);
Assert.AreEqual(rover.Location.Y, 0);
}
public void GetRover_WithLandingOutsidePlateauCoordinates_ThrowsIndexOutOfRangeException()
{
Assert.ThrowsException <IndexOutOfRangeException>(() =>
{
string roverName = "Rover 1";
uint landingX = 6;
uint landingY = 6;
RoverOrientation orientation = RoverOrientation.N;
var plateau = GetPlateau();
RoverBuilder.Builder(plateau)
.SetName(roverName)
.Landing(landingX, landingY, orientation)
.Create();
});
}
public void RoverReceievesCommands()
{
var rover = new RoverBuilder()
.AtDefaultPosition()
.Build();
var roverControl = new RoverControlBuilder()
.ForRover(rover)
.Build();
roverControl.SendCommands("fblr");
Assert.Equal(4, roverControl.Commands.Count);
Assert.Contains(roverControl.Commands, command => command is RoverCommandForward);
Assert.Contains(roverControl.Commands, command => command is RoverCommandBackwards);
Assert.Contains(roverControl.Commands, command => command is RoverCommandTurnLeft);
Assert.Contains(roverControl.Commands, command => command is RoverCommandTurnRight);
}
public void GetRover_WithNavigationOutsidePlateauCoordinates_ThrowsIndexOutOfRangeException()
{
Assert.ThrowsException <IndexOutOfRangeException>(() =>
{
string roverName = "Rover 1";
uint landingX = 1;
uint landingY = 2;
RoverOrientation orientation = RoverOrientation.N;
char[] navigations = "LMLMLMLMMMMMM".ToCharArray();
var plateau = GetPlateau();
RoverBuilder.Builder(plateau)
.SetName(roverName)
.Landing(landingX, landingY, orientation)
.Navigate(navigations)
.Create();
});
}
public void GetRover_WithNavigation_ReturnsRoverOnNavigatedPosition()
{
string roverName = "Rover 1";
uint landingX = 1;
uint landingY = 2;
RoverOrientation orientation = RoverOrientation.N;
char[] navigations = "LMLMLMLMM".ToCharArray();
var plateau = GetPlateau();
var rover = RoverBuilder.Builder(plateau)
.SetName(roverName)
.Landing(landingX, landingY, orientation)
.Navigate(navigations)
.Create();
Assert.AreEqual((uint)1, rover.X);
Assert.AreEqual((uint)3, rover.Y);
Assert.AreEqual(RoverOrientation.N, rover.Orientation);
}
public void MovementWithObstacleOnThePath()
{
var obstacleMap = new Dictionary <int, int>()
{
{ 99, 3 }
};
var rover = new RoverBuilder().LandedIn(1, 1)
.DirectedTowards("N")
.WithObstacleDetectionSystem(obstacleMap)
.Build();
var commands = new char[] { 'f', 'f', 'r', 'b', 'b' };
var expectedPosition = Coordinates.Create(0, 3);
var expectedDirection = DirectionsList.E;
var result = rover.ExecuteCommandSequence(commands);
Assert.AreEqual(ResultCode.ObstacleFound, result.Result);
Assert.AreEqual(expectedPosition, rover.Position);
Assert.AreEqual(expectedDirection, rover.Direction);
}
