public void PlaceRobotInNotCorrectPositionTheRobotShouldntPlaced() { ToyRobot robot = PlaceRobotInPosition(new Position(10, 2), Direction.NORTH); Assert.IsNull(robot.RobotRoute); Assert.AreEqual(robot.RobotStatus, RobotStatus.InvalidPositionForRobot); }
public void Turnleft_TableTop5Into5RobotTurnedLeftFourTimesSameFaing_IsTrue() { //arrange TableTop tt = new TableTop(5, 5); ToyRobot tr = new ToyRobot(); CommandModel cm = new CommandModel() { Command = Command.PLACE, Coordinate = new Coordinate(3, 4), Facing = Facing.NORTH }; ICommandInterface placeCommand = new PlaceRobotCommand(cm, tr, tt); placeCommand.Execute(); ICommandInterface leftCommand = new TurnLeftCommand(tr); //act leftCommand.Execute(); leftCommand.Execute(); leftCommand.Execute(); leftCommand.Execute(); //assert Assert.AreEqual(tr.robotDirection, Facing.NORTH); }
public void TestPlacingAToyRobotShouldBePlacedCorrectly() { // Arrange uint width = 5; uint height = 5; var table = new Table(width, height); var toyRobot = new ToyRobot(table); uint xPosition = 1; uint yPosition = 3; Direction robotDirection = Direction.EAST; // Assert // make sure robot is not placed Assert.True(!toyRobot.X.HasValue && !toyRobot.Y.HasValue && !toyRobot.Direction.HasValue && !toyRobot.IsPlaced); // ACT toyRobot.Place(xPosition, yPosition, robotDirection); // make sure robot is placed Assert.True(toyRobot.IsPlaced); Assert.True(toyRobot.X.HasValue && toyRobot.X.Value == xPosition); Assert.True(toyRobot.Y.HasValue && toyRobot.Y.Value == yPosition); Assert.True(toyRobot.Direction.HasValue && toyRobot.Direction.Value == robotDirection); }
public ToyRobot PlaceRobotOnTable(string command) { if (command is null) { throw new ArgumentNullException(nameof(command)); } string[] commandComponents = command.Split(' '); string commandType = commandComponents[0]; if (commandType != Constants.Commands.PLACE) { throw new InvalidOperationException($"this is not a place command: {command}"); } if (commandComponents.Length != 2) { throw new InvalidOperationException($"invalid place command: {command}"); } string commandArguments = commandComponents[1]; PlaceArguments placeArguments = GetPlaceArguments(commandArguments); IReportManager reportManager = new ReportManager(); var robot = new ToyRobot(placeArguments.Position, placeArguments.CardinalDirectionManager, reportManager); return(robot); }
public void InterpretCommandTest_Success() { // init ToyTable tb = ToyTableTests.ToyTableCreate_successtest(300, 500); ToyRobot robot = new ToyRobot(tb); // place report check robot.InterpretCommand("PLACE 99,230,EAST"); TestLocation(robot, new CoordinateXY(99, 230), Direction.EAST); robot.InterpretCommand("REPORT"); TestLocation(robot, new CoordinateXY(99, 230), Direction.EAST); robot.InterpretCommand("PLACE 99,230,WEST"); TestLocation(robot, new CoordinateXY(99, 230), Direction.WEST); robot.InterpretCommand("REPORT"); TestLocation(robot, new CoordinateXY(99, 230), Direction.WEST); robot.InterpretCommand("PLACE 230,99,NORTH"); TestLocation(robot, new CoordinateXY(230, 99), Direction.NORTH); robot.InterpretCommand("REPORT"); TestLocation(robot, new CoordinateXY(230, 99), Direction.NORTH); robot.InterpretCommand("PLACE 230,99,SOUTH"); TestLocation(robot, new CoordinateXY(230, 99), Direction.SOUTH); robot.InterpretCommand("REPORT"); TestLocation(robot, new CoordinateXY(230, 99), Direction.SOUTH); //move tests robot.InterpretCommand("MOVE"); TestLocation(robot, new CoordinateXY(230, 98), Direction.SOUTH); robot.InterpretCommand("MOVE"); TestLocation(robot, new CoordinateXY(230, 97), Direction.SOUTH); robot.InterpretCommand("LEFT"); TestLocation(robot, new CoordinateXY(230, 97), Direction.EAST); robot.InterpretCommand("RIGHT"); TestLocation(robot, new CoordinateXY(230, 97), Direction.SOUTH); }
public PlaceCommand(ToyRobot toy, PlacementCoordinates placementVar) { toyRobot = toy; xCoordinate = placementVar.XPlacement; yCooridinate = placementVar.YPlacement; startingOrientation = placementVar.orientations; }
public void CorrectListOfCommandWouldReturnCorrectOutput() { List <string> stringCommands = new List <string>() { "PLACE 0,0, North move ", "Move", "right", "Move", "left", "Report", }; var listOfCommands = Commands.GenerateOutputListOfCommands(stringCommands); Assert.IsNotNull(listOfCommands); Assert.AreEqual(listOfCommands.Count, 7); ToyRobot robot = new ToyRobot(new Board());//Default Borad is 5 x 5 foreach (var command in listOfCommands) { command.CommandAsType.Execute(robot); command.ReportOfRobot = (command.CommandAsType.GetType() == (new ReportCommand()).GetType()) ? ((ReportCommand)command.CommandAsType).LastReportOfRobot : ""; Assert.IsNotNull(robot.RobotRoute); Assert.AreEqual(robot.RobotStatus, RobotStatus.CorrectPlaceToStand); } // report should be "OutPuT: 1,1, NORTH" Assert.AreEqual(listOfCommands[listOfCommands.Count - 1].ReportOfRobot, "OutPuT: 1,2, NORTH"); }
public string Exec(ref ToyRobot toyRobot, TableTop tableTop) { log.Info(string.Format("Exec: {0} - {1}", toyRobot, tableTop)); if (toyRobot.Facing == null) { throw new InvalidFacingException("The first command should be 'PLACE X,Y,F'"); } else if (toyRobot.Facing.Equals(FacingEnum.NORTH) && (toyRobot.Y + 1) <= tableTop.Height) { toyRobot.Y++; } else if (toyRobot.Facing.Equals(FacingEnum.EAST) && (toyRobot.X + 1) <= tableTop.Width) { toyRobot.X++; } else if (toyRobot.Facing.Equals(FacingEnum.SOUTH) && (toyRobot.Y - 1) >= 0) { toyRobot.Y--; } else if (toyRobot.Facing.Equals(FacingEnum.WEST) && (toyRobot.X - 1) >= 0) { toyRobot.X--; } else { throw new InvalidCommandException("The toy robot can not falling from the table"); } log.Info(string.Format("Exec - Result: {0}", toyRobot)); return(null); }
public void TestMoveOnTable() { // Create an instance to test: ToyRobot robot = new ToyRobot(); // Define a test input and output value: int x = 0; int y = 0; Facing facing = Facing.North; robot.Place(x, y, facing); // Run the method under test and verify test when facing North robot.Move(); Assert.AreEqual(robot.X, 0); Assert.AreEqual(robot.Y, 1); Assert.AreEqual(robot.Facing, Facing.North); // Run the method under test and verify test when facing East robot.GetType().GetProperty("Facing").SetValue(robot, Facing.East); robot.Move(); Assert.AreEqual(robot.X, 1); Assert.AreEqual(robot.Y, 1); Assert.AreEqual(robot.Facing, Facing.East); // Run the method under test and verify test when facing South robot.GetType().GetProperty("Facing").SetValue(robot, Facing.South); robot.Move(); Assert.AreEqual(robot.X, 1); Assert.AreEqual(robot.Y, 0); Assert.AreEqual(robot.Facing, Facing.South); // Run the method under test and verify test when facing West robot.GetType().GetProperty("Facing").SetValue(robot, Facing.West); robot.Move(); Assert.AreEqual(robot.X, 0); Assert.AreEqual(robot.Y, 0); Assert.AreEqual(robot.Facing, Facing.West); }
public void MoveRobot_MovingUpAndCheckBounds_ReturnsTrue() { var board = new Board(); var toyRobot = new ToyRobot(); // placing robot at 1,2,NORTH toyRobot.Execute("PLACE 1,2,NORTH", board); // moves to 1,3 toyRobot.MoveForward(board); Assert.AreEqual(expected: toyRobot.CurrentPosition.X, actual: 1); Assert.AreEqual(expected: toyRobot.CurrentPosition.Y, actual: 3); // moves to 1,4 toyRobot.MoveForward(board); Assert.AreEqual(expected: toyRobot.CurrentPosition.X, actual: 1); Assert.AreEqual(expected: toyRobot.CurrentPosition.Y, actual: 4); // moves to 1,4 toyRobot.MoveForward(board); Assert.AreEqual(expected: toyRobot.CurrentPosition.X, actual: 1); Assert.AreEqual(expected: toyRobot.CurrentPosition.Y, actual: 4); // moves to 1,4 toyRobot.MoveForward(board); Assert.AreEqual(expected: toyRobot.CurrentPosition.X, actual: 1); Assert.AreEqual(expected: toyRobot.CurrentPosition.Y, actual: 4); }
public void MoveRobot_MovingRightAndCheckBounds_ReturnsTrue() { var board = new Board(); var toyRobot = new ToyRobot(); // placing robot at 1,2,EAST toyRobot.Execute("PLACE 1,2,EAST", board); // moves to 2,2 toyRobot.MoveForward(board); Assert.AreEqual(expected: toyRobot.CurrentPosition.X, actual: 2); Assert.AreEqual(expected: toyRobot.CurrentPosition.Y, actual: 2); // moves to 3,2 toyRobot.MoveForward(board); Assert.AreEqual(expected: toyRobot.CurrentPosition.X, actual: 3); Assert.AreEqual(expected: toyRobot.CurrentPosition.Y, actual: 2); // moves to 4,2 toyRobot.MoveForward(board); Assert.AreEqual(expected: toyRobot.CurrentPosition.X, actual: 4); Assert.AreEqual(expected: toyRobot.CurrentPosition.Y, actual: 2); // moves to 4,2 toyRobot.MoveForward(board); Assert.AreEqual(expected: toyRobot.CurrentPosition.X, actual: 4); Assert.AreEqual(expected: toyRobot.CurrentPosition.Y, actual: 2); // moves to 4,2 toyRobot.MoveForward(board); Assert.AreEqual(expected: toyRobot.CurrentPosition.X, actual: 4); Assert.AreEqual(expected: toyRobot.CurrentPosition.Y, actual: 2); }
public void Move_TableTop5Into5Placed3Into3RobotMovedFiveTimesForward() { //arrange TableTop tt = new TableTop(5, 5); ToyRobot tr = new ToyRobot(); CommandModel cm = new CommandModel() { Command = Command.PLACE, Coordinate = new Coordinate(3, 3), Facing = Facing.NORTH }; ICommandInterface placeCommand = new PlaceRobotCommand(cm, tr, tt); placeCommand.Execute(); ICommandInterface moveCommand = new MoveForwardCommand(tr, tt); //act moveCommand.Execute(); moveCommand.Execute(); moveCommand.Execute(); moveCommand.Execute(); moveCommand.Execute(); //assert: actual/expected Assert.IsTrue(tr.RobotStillOnTableTop(tt)); }
public void Move_TableTopFiveIntoFiveAlreadyPlacedMovedTwiceForward() { //arrange TableTop tt = new TableTop(5, 5); ToyRobot tr = new ToyRobot(); CommandModel cm = new CommandModel() { Command = Command.PLACE, Coordinate = new Coordinate(3, 3), Facing = Facing.NORTH }; ICommandInterface placeCommand = new PlaceRobotCommand(cm, tr, tt); placeCommand.Execute(); ICommandInterface moveCommand = new MoveForwardCommand(tr, tt); //act moveCommand.Execute(); moveCommand.Execute(); //assert: actual/expected Assert.AreEqual(tr.GetCurrentRobotPosition(), new ToyRobot(new Coordinate(3, 5), Facing.NORTH).GetCurrentRobotPosition()); }
public ToyRobot PlaceRobotInPosition(Position position, Direction direction) { ToyRobot robot = new ToyRobot(new Board());//Default Borad is 5 x 5 robot.Place(new Route(position, direction)); return(robot); }
public void WrongCommandWouldBeIgnored() { List <string> stringCommands = new List <string>() { "Move", "PLACE 0,0, East PLACE 0,20, East", "Turn Left", "Now stop", "Move", "PLACE 0,0West", "move right", "Report", }; var listOfCommands = Commands.GenerateOutputListOfCommands(stringCommands); Assert.IsNotNull(listOfCommands); Assert.AreEqual(listOfCommands.Count, 7); ToyRobot robot = new ToyRobot(new Board());//Default Borad is 5 x 5 Simulator simulator = new Simulator(robot); //All command with Report Result should be written in console simulator.Execute(listOfCommands); // report should be "OutPuT: 2,0, EAST" Assert.AreEqual(listOfCommands[listOfCommands.Count - 1].ReportOfRobot, "OutPuT: 0,2, EAST"); }
public void TestExecutingInTheCommandHandlerByCommandStringReturnCorrectPosAndDirectionInAToyRobot() { // Arrange uint width = 5; uint height = 5; var table = new Table(width, height); var toyRobot = new ToyRobot(table) { X = 0, Y = 0, Direction = Direction.NORTH }; var commandStringSeparator = " "; var ignoreCase = true; string commandString = "PLACE 1,2,NORTH MOVE MOVE RIGHT REPORT PLACE 3,2,EAST REPORT"; // ACT var commandHandler = new CommandHandler(new CommandFactory(), toyRobot); Assert.NotNull(commandHandler); commandHandler.Handle(commandString, new[] { commandStringSeparator }, ignoreCase); var expectX = 3; var expectY = 2; var expectDirection = Direction.EAST; // Assert Assert.True(toyRobot.X == expectX && toyRobot.Y == expectY && toyRobot.Direction == expectDirection); }
public void WhenPlacingARobotInInvalidPositionsMakeSurePlaceCommandIsIgnored() { // create a robot that knows about it's environment var board = new Board(5, 5); var robot = new ToyRobot(board); Assert.IsNotNull(board); Assert.IsNotNull(robot); var direction = Direction.North; robot.Place(new Vector2d <ulong>(new Point2d <ulong>(0, 0), direction)); Assert.IsTrue(robot.HasAPosition); Assert.IsTrue(ComparePosition(robot, 0, 0, direction)); // get robot current position & direction var origRobotX = robot.Vector.Position.X; var origRobotY = robot.Vector.Position.Y; var origRobotDir = robot.Vector.Dir; var extraXDim = (ulong)5; var extraYDim = (ulong)5; // test some invalid positions for (var x = board.Width; x < board.Width + extraXDim; x++) { WhenPlacingARobotInInvalidPositionsMakeSurePlaceCommandIsIgnoredOnEachColumn(board, robot, direction, origRobotX, origRobotY, origRobotDir, extraYDim, x); } }
public void TestValidationOfCommandHandlerIfNoPlaceCommandShouldBeReturnValidationFailed() { // Arrange uint width = 5; uint height = 5; var table = new Table(width, height); var toyRobot = new ToyRobot(table) { // we didn't set up initial position and direction for the toy robot }; var commandStringSeparator = " "; var ignoreCase = true; string commandString = "NORTH MOVE REPORT"; // no PLACE command in there, which means robot IS NOT Placed // ACT var commandHandler = new CommandHandler(new CommandFactory(), toyRobot); Assert.NotNull(commandHandler); // Test key: when we use command handler it will auto validate each command before executing command commandHandler.Handle(commandString, new[] { commandStringSeparator }, ignoreCase); // Assert Assert.False(toyRobot.IsPlaced);// no PLACE Command, so it will return false obviously Assert.False(toyRobot.X.HasValue); Assert.False(toyRobot.Y.HasValue); Assert.False(toyRobot.Direction.HasValue); }
public void IfRobotPlacedCorrectlyAtFirstTimeButNotCorrectlyAfterReportShouldShowLastPosition() { ToyRobot robot = PlaceRobotInPosition(new Position(1, 2), Direction.NORTH); Assert.IsNotNull(robot.RobotRoute); Assert.AreEqual(robot.RobotStatus, RobotStatus.CorrectPlaceToStand); MoveCommand moveCommand = new MoveCommand(); moveCommand.Execute(robot); PlaceCommand placeCommand = new PlaceCommand(new Route(new Position(10, 2), Direction.NORTH)); //This wrong Place will not set placeCommand.Execute(robot); Assert.AreEqual(robot.RobotStatus, RobotStatus.InvalidPositionForRobot); ReportCommand reportCommand = new ReportCommand(); //The report should be Last Position "OutPuT: 1,3, NORTH" reportCommand.Execute(robot); Assert.AreEqual(reportCommand.LastReportOfRobot, "OutPuT: 1,3, NORTH"); Console.WriteLine(reportCommand.LastReportOfRobot); moveCommand.Execute(robot); Assert.AreEqual(robot.RobotStatus, RobotStatus.CorrectPlaceToStand); reportCommand.Execute(robot); Assert.AreEqual(reportCommand.LastReportOfRobot, "OutPuT: 1,4, NORTH"); Console.WriteLine(reportCommand.LastReportOfRobot); }
public void TestExecutingACommandFileProcessingSimulatorByMultipleFilesReturnCorrectResult() { // Arrange uint width = 5; uint height = 5; var table = new Table(width, height); var toyRobot = new ToyRobot(table); var fileExtension = ".txt"; var commandFileProcessingSimulator = new CommandFileProcessingSimulator(toyRobot, fileExtension); var commandStringSeparator = " "; var ignoreCase = true; var fileCommandList = new List <string> { "./TestData/example1.txt", "./TestData/example.txt" // TEST KEY: will always get robot position and direction following last file result }; var fileCommandString = string.Join(commandStringSeparator, fileCommandList); //Assert Assert.NotNull(commandFileProcessingSimulator); //ACT commandFileProcessingSimulator.Execute(fileCommandString, new[] { commandStringSeparator }, ignoreCase); var expectX = 0; var expectY = 1; var expectDirection = Direction.NORTH; Assert.True(toyRobot.X == expectX && toyRobot.Y == expectY && toyRobot.Direction == expectDirection); }
public void WrongCommandWouldBeIgnored() { List <string> stringCommands = new List <string>() { "Move", "PLACE 0,0 East", "Turn Left", "Now stop", "PLACE 0,0, East Move", "PLACE 0,0West", "move right", "Report", }; var listOfCommands = Commands.GenerateOutputListOfCommands(stringCommands); Assert.IsNotNull(listOfCommands); Assert.AreEqual(listOfCommands.Count, 5); ToyRobot robot = new ToyRobot(new Board());//Default Borad is 5 x 5 foreach (var command in listOfCommands) { command.CommandAsType.Execute(robot); command.ReportOfRobot = (command.CommandAsType.GetType() == (new ReportCommand()).GetType()) ? ((ReportCommand)command.CommandAsType).LastReportOfRobot : ""; Assert.IsNotNull(robot.RobotRoute); Assert.AreEqual(robot.RobotStatus, RobotStatus.CorrectPlaceToStand); // report should console writeline "OutPuT: 2,0, EAST" } // report should be "OutPuT: 2,0, EAST" Assert.AreEqual(listOfCommands[listOfCommands.Count - 1].ReportOfRobot, "OutPuT: 2,0, SOUTH"); }
public void TestExecutingAnInteractiveSimulatorByCommandStringShouldReturnCorrectResult() { // Arrange uint width = 5; uint height = 5; var table = new Table(width, height); var toyRobot = new ToyRobot(table); var interactiveSimulator = new InteractiveSimulator(toyRobot); var commandStringSeparator = " "; var ignoreCase = true; var commandList = new List <string> { "PLACE 1,2,NORTH MOVE", "MOVE1", // (Test key) this command shouldn't execute "MOVE RIGHT", "PLACE 0,0,EAST", // using new place, ignoring all of previous actions "MOVE LEFT REPORT" }; var commandString = string.Join(commandStringSeparator, commandList); //Assert Assert.NotNull(interactiveSimulator); //ACT interactiveSimulator.Execute(commandString, new[] { commandStringSeparator }, ignoreCase); var expectX = 1; var expectY = 0; var expectDirection = Direction.NORTH; Assert.True(toyRobot.X == expectX && toyRobot.Y == expectY && toyRobot.Direction == expectDirection); }
public void InterpretCommandTest_Throw() { ToyTable tb = ToyTableTests.ToyTableCreate_successtest(300, 500); ToyRobot robot = new ToyRobot(tb); // test in valid commands AssertInvalidRobotCommandException(() => { robot.InterpretCommand(""); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand("blahblah asd ad 123e 123 312 ,1,1,,1"); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand("PLACE123"); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand("PLACE 123"); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand("PLACE 123,2,NROTH"); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand("PLACE X, ,NORTH"); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand("PLACE ,,"); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand("PLACE 3xs2,xxa,SOUTH"); }); //negative values AssertOutofBoundException(() => { robot.InterpretCommand("PLACE -123,-23,NORTH"); }); //testing limits AssertOutofBoundException(() => { robot.InterpretCommand($"PLACE {int.MaxValue},{int.MinValue},NORTH"); }); AssertOutofBoundException(() => { robot.InterpretCommand($"PLACE {int.MinValue},{int.MinValue},NORTH"); }); AssertOutofBoundException(() => { robot.InterpretCommand($"PLACE {int.MinValue},{int.MaxValue},NORTH"); }); AssertOutofBoundException(() => { robot.InterpretCommand($"PLACE {int.MaxValue},{int.MaxValue},NORTH"); }); //make sure interpreter throws for overflow AssertInvalidRobotCommandException(() => { robot.InterpretCommand($"PLACE {int.MaxValue}3213,{int.MinValue}3213,NORTH"); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand("PLACE !@#!@#()_@!#(<<<mmm,,,,,,,"); }); //out of bound AssertOutofBoundException(() => { robot.InterpretCommand("PLACE 4123,23,NORTH"); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand(" PLACE "); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand(" MOVE bassdasd "); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand("REPORT bassdasd "); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand("LEFTbassdasd "); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand(" LEFTba s sdasd "); }); AssertInvalidRobotCommandException(() => { robot.InterpretCommand("RIGHT sdsad "); }); }
public void TestExecutingAnInteractiveSimulatorUsingSensitiveByCommandStringShouldReturnRobotIsNotPlaced() { // Arrange uint width = 5; uint height = 5; var table = new Table(width, height); var toyRobot = new ToyRobot(table); var interactiveSimulator = new InteractiveSimulator(toyRobot); var commandStringSeparator = " "; var ignoreCase = false; var commandList = new List <string> { "place 1,2,NORTH", // TEST KEY: place is sensitive, so it will always return validation is false before executing command "REPORT" }; var commandString = string.Join(commandStringSeparator, commandList); //Assert Assert.NotNull(interactiveSimulator); //ACT interactiveSimulator.Execute(commandString, new[] { commandStringSeparator }, ignoreCase); // Assert Assert.False(toyRobot.IsPlaced);// no PLACE Command, so it will return false obviously Assert.False(toyRobot.X.HasValue); Assert.False(toyRobot.Y.HasValue); Assert.False(toyRobot.Direction.HasValue); }
public void ToyRobot_internal_TurnTest() { ToyTable tb = ToyTableTests.ToyTableCreate_successtest(100, 500); ToyRobot robot = new ToyRobot(tb); PlaceRobotTest(robot, new CoordinateXY(55, 45), Direction.NORTH); Assert.AreEqual(robot.Report(), "55,45,NORTH"); TestLocation(robot, new CoordinateXY(55, 45), Direction.NORTH); robot.Turn(true); TestLocation(robot, new CoordinateXY(55, 45), Direction.WEST); robot.Turn(true); TestLocation(robot, new CoordinateXY(55, 45), Direction.SOUTH); robot.Turn(true); TestLocation(robot, new CoordinateXY(55, 45), Direction.EAST); robot.Turn(true); TestLocation(robot, new CoordinateXY(55, 45), Direction.NORTH); robot.Turn(false); TestLocation(robot, new CoordinateXY(55, 45), Direction.EAST); Assert.AreEqual(robot.Report(), "55,45,EAST"); robot.Turn(false); TestLocation(robot, new CoordinateXY(55, 45), Direction.SOUTH); robot.Turn(false); TestLocation(robot, new CoordinateXY(55, 45), Direction.WEST); robot.Turn(false); TestLocation(robot, new CoordinateXY(55, 45), Direction.NORTH); Assert.AreEqual(robot.Report(), "55,45,NORTH"); }
public void TestExecutingACommandFileProcessingSimulatorByOneFileReturnCorrectResult() { // Arrange uint width = 5; uint height = 5; var table = new Table(width, height); var toyRobot = new ToyRobot(table); var fileExtension = ".txt"; var commandFileProcessingSimulator = new CommandFileProcessingSimulator(toyRobot, fileExtension); var commandStringSeparator = " "; var ignoreCase = true; var fileCommandList = new List <string> { "./TestData/example1.txt" }; var fileCommandString = string.Join(commandStringSeparator, fileCommandList); //Assert Assert.NotNull(commandFileProcessingSimulator); //ACT commandFileProcessingSimulator.Execute(fileCommandString, new[] { commandStringSeparator }, ignoreCase); var expectX = 4; var expectY = 2; var expectDirection = Direction.SOUTH; Assert.True(toyRobot.X == expectX && toyRobot.Y == expectY && toyRobot.Direction == expectDirection); }
public SFMLSimulator() { window = new RenderWindow(new VideoMode(800, 600), "SFML Simulator"); window.SetView(new View(new FloatRect(0, 0, size * width, size * height))); window.Closed += Window_Closed; window.MouseButtonReleased += Window_MouseButtonReleased; window.KeyReleased += Window_KeyReleased; toyRobot = new ToyRobot(); map = new Map(width, height); grass = new Sprite[width, height]; Image grassImage = new Image("./Resources/grass.png"); Texture grassTexture = new Texture(grassImage); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { grass[x, y] = new Sprite(grassTexture) { Position = new Vector2f((x * size), (y * size)) }; } } Image robotImage = new Image("./Resources/robot.png"); Texture robotTexture = new Texture(robotImage); robot = new Sprite(robotTexture) { Origin = new Vector2f(8, 8) }; }
public void CorrectListOfCommandWouldReturnCorrectOutput() { List <string> stringCommands = new List <string>() { "PLACE 0,0, North", "Move", "right PLACE 1,1, North right", "Move Move ", "left", "Report", }; var listOfCommands = Commands.GenerateOutputListOfCommands(stringCommands); Assert.IsNotNull(listOfCommands); Assert.AreEqual(listOfCommands.Count, 9); ToyRobot robot = new ToyRobot(new Board());//Default Borad is 5 x 5 Simulator simulator = new Simulator(robot); //All command with Report Result should be written in console simulator.Execute(listOfCommands); // report should be "OutPuT: 1,1, NORTH" Assert.AreEqual(listOfCommands[listOfCommands.Count - 1].ReportOfRobot, "OutPuT: 3,1, NORTH"); }
// combining all actions of robots to make sure it returns expect result public void TestAToyRobotWithAllActionsShouldBeReturnCorrectPosAndDirection() { // Arrange uint width = 5; uint height = 5; var table = new Table(width, height); // initializing position for a toy robot var toyRobot = new ToyRobot(table); // add PLACE action toyRobot.Place(1, 1, Direction.NORTH); // add three move actions toyRobot.Move(); toyRobot.Move(); toyRobot.Move(); // then turn right toyRobot.TurnRight(); // then turn left toyRobot.TurnLeft(); // Testing key point, just move once again, should ignore the Move step, because robot position beyond table height toyRobot.Move(); var expectXPostion = 1; var expectYPostion = 4; var expectDirection = Direction.NORTH; // Assert Assert.True(toyRobot.X == expectXPostion && toyRobot.Y == expectYPostion && toyRobot.Direction == expectDirection); }
public void TheRobotCouldWalkThroughTheBoardSurfaceFromSouthToNorthAndReturnAndReportLastPosition() { ToyRobot robot = new ToyRobot(new Board());//Default Borad is 5 x 5 //walk from start position 0,0 face to NORTH, move to the edge of NORTH //then turn Right and one move right, // agian turn Right to face back SOUTH and move to the edge of SOUTH // continue this pattern to seek all the board surface to position 5,0 robot.Place(new Route(new Position(0, 0), Direction.NORTH)); for (int horizontalStep = 0; horizontalStep <= 5; horizontalStep++) { Assert.AreEqual(robot.RobotStatus, RobotStatus.CorrectPlaceToStand); for (int verticalStep = 1; verticalStep <= 5; verticalStep++) { robot.Move(); Assert.AreEqual(robot.RobotStatus, RobotStatus.CorrectPlaceToStand); } if (robot.RobotRoute.RobotFaceDirection == Direction.NORTH) { robot.TurnRight(); robot.Move(); robot.TurnRight(); continue; } if (robot.RobotRoute.RobotFaceDirection == Direction.SOUTH) { robot.TurnLeft(); robot.Move(); robot.TurnLeft(); } } // the report should be "OutPuT: 5,0, NORTH" Assert.AreEqual(robot.Report(), "OutPuT: 5,0, NORTH"); Console.WriteLine(robot.Report()); }