Add Robot Simulator Test Generator

exercises/robot-simulator/Example.cs

@@ -1,6 +1,6 @@
 using System;
 
-public enum Bearing
+public enum Direction
 {
     North,
     East,
@@ -22,30 +22,30 @@ public Coordinate(int x, int y)
 
 public class RobotSimulator
 {
-    public RobotSimulator(Bearing bearing, Coordinate coordinate)
+    public RobotSimulator(Direction bearing, Coordinate coordinate)
     {
-        Bearing = bearing;
+        Direction = bearing;
         Coordinate = coordinate;
     }
 
-    public Bearing Bearing { get; private set; }
+    public Direction Direction { get; private set; }
     public Coordinate Coordinate { get; private set; }
 
     public void TurnRight()
     {
-        switch (Bearing)
+        switch (Direction)
         {
-            case Bearing.North:
-                Bearing = Bearing.East;
+            case Direction.North:
+                Direction = Direction.East;
                 break;
-            case Bearing.East:
-                Bearing = Bearing.South;
+            case Direction.East:
+                Direction = Direction.South;
                 break;
-            case Bearing.South:
-                Bearing = Bearing.West;
+            case Direction.South:
+                Direction = Direction.West;
                 break;
-            case Bearing.West:
-                Bearing = Bearing.North;
+            case Direction.West:
+                Direction = Direction.North;
                 break;
             default:
                 throw new ArgumentOutOfRangeException();
@@ -54,19 +54,19 @@ public void TurnRight()
 
     public void TurnLeft()
     {
-        switch (Bearing)
+        switch (Direction)
         {
-            case Bearing.North:
-                Bearing = Bearing.West;
+            case Direction.North:
+                Direction = Direction.West;
                 break;
-            case Bearing.East:
-                Bearing = Bearing.North;
+            case Direction.East:
+                Direction = Direction.North;
                 break;
-            case Bearing.South:
-                Bearing = Bearing.East;
+            case Direction.South:
+                Direction = Direction.East;
                 break;
-            case Bearing.West:
-                Bearing = Bearing.South;
+            case Direction.West:
+                Direction = Direction.South;
                 break;
             default:
                 throw new ArgumentOutOfRangeException();
@@ -75,18 +75,18 @@ public void TurnLeft()
 
     public void Advance()
     {
-        switch (Bearing)
+        switch (Direction)
         {
-            case Bearing.North:
+            case Direction.North:
                 Coordinate = new Coordinate(Coordinate.X, Coordinate.Y + 1);
                 break;
-            case Bearing.East:
+            case Direction.East:
                 Coordinate = new Coordinate(Coordinate.X + 1, Coordinate.Y);
                 break;
-            case Bearing.South:
+            case Direction.South:
                 Coordinate = new Coordinate(Coordinate.X, Coordinate.Y - 1);
                 break;
-            case Bearing.West:
+            case Direction.West:
                 Coordinate = new Coordinate(Coordinate.X - 1, Coordinate.Y);
                 break;
             default:

exercises/robot-simulator/RobotSimulator.cs

@@ -1,6 +1,6 @@
 using System;
 
-public enum Bearing
+public enum Direction
 {
     North,
     East,
@@ -22,11 +22,11 @@ public Coordinate(int x, int y)
 
 public class RobotSimulator
 {
-    public RobotSimulator(Bearing bearing, Coordinate coordinate)
+    public RobotSimulator(Direction direction, Coordinate coordinate)
     {
     }
 
-    public Bearing Bearing
+    public Direction Direction
     {
         get
         {

exercises/robot-simulator/RobotSimulatorTest.cs

@@ -1,59 +1,180 @@
-using Xunit;
+// This file was auto-generated based on version 2.2.0 of the canonical data.
+
+using Xunit;
 
 public class RobotSimulatorTest
 {
     [Fact]
-    public void Turn_right_edge_case()
+    public void A_robot_is_created_with_a_position_and_a_direction_robots_are_created_with_a_position_and_direction()
+    {
+        var sut = new RobotSimulator(Direction.North, new Coordinate(0, 0));
+        Assert.Equal(Direction.North, sut.Direction);
+        Assert.Equal(0, sut.Coordinate.X);
+        Assert.Equal(0, sut.Coordinate.Y);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void A_robot_is_created_with_a_position_and_a_direction_negative_positions_are_allowed()
+    {
+        var sut = new RobotSimulator(Direction.South, new Coordinate(-1, -1));
+        Assert.Equal(Direction.South, sut.Direction);
+        Assert.Equal(-1, sut.Coordinate.X);
+        Assert.Equal(-1, sut.Coordinate.Y);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rotates_the_robots_direction_90_degrees_clockwise_does_not_change_the_position()
+    {
+        var sut = new RobotSimulator(Direction.North, new Coordinate(0, 0));
+        sut.TurnRight();
+        Assert.Equal(0, sut.Coordinate.X);
+        Assert.Equal(0, sut.Coordinate.Y);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rotates_the_robots_direction_90_degrees_clockwise_changes_the_direction_from_north_to_east()
+    {
+        var sut = new RobotSimulator(Direction.North, new Coordinate(0, 0));
+        sut.TurnRight();
+        Assert.Equal(Direction.East, sut.Direction);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rotates_the_robots_direction_90_degrees_clockwise_changes_the_direction_from_east_to_south()
+    {
+        var sut = new RobotSimulator(Direction.East, new Coordinate(0, 0));
+        sut.TurnRight();
+        Assert.Equal(Direction.South, sut.Direction);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rotates_the_robots_direction_90_degrees_clockwise_changes_the_direction_from_south_to_west()
+    {
+        var sut = new RobotSimulator(Direction.South, new Coordinate(0, 0));
+        sut.TurnRight();
+        Assert.Equal(Direction.West, sut.Direction);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rotates_the_robots_direction_90_degrees_clockwise_changes_the_direction_from_west_to_north()
+    {
+        var sut = new RobotSimulator(Direction.West, new Coordinate(0, 0));
+        sut.TurnRight();
+        Assert.Equal(Direction.North, sut.Direction);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rotates_the_robots_direction_90_degrees_counter_clockwise_does_not_change_the_position()
+    {
+        var sut = new RobotSimulator(Direction.North, new Coordinate(0, 0));
+        sut.TurnLeft();
+        Assert.Equal(0, sut.Coordinate.X);
+        Assert.Equal(0, sut.Coordinate.Y);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rotates_the_robots_direction_90_degrees_counter_clockwise_changes_the_direction_from_north_to_west()
+    {
+        var sut = new RobotSimulator(Direction.North, new Coordinate(0, 0));
+        sut.TurnLeft();
+        Assert.Equal(Direction.West, sut.Direction);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rotates_the_robots_direction_90_degrees_counter_clockwise_changes_the_direction_from_west_to_south()
+    {
+        var sut = new RobotSimulator(Direction.West, new Coordinate(0, 0));
+        sut.TurnLeft();
+        Assert.Equal(Direction.South, sut.Direction);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rotates_the_robots_direction_90_degrees_counter_clockwise_changes_the_direction_from_south_to_east()
+    {
+        var sut = new RobotSimulator(Direction.South, new Coordinate(0, 0));
+        sut.TurnLeft();
+        Assert.Equal(Direction.East, sut.Direction);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rotates_the_robots_direction_90_degrees_counter_clockwise_changes_the_direction_from_east_to_north()
+    {
+        var sut = new RobotSimulator(Direction.East, new Coordinate(0, 0));
+        sut.TurnLeft();
+        Assert.Equal(Direction.North, sut.Direction);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Moves_the_robot_forward_1_space_in_the_direction_it_is_pointing_does_not_change_the_direction()
     {
-        var robot = new RobotSimulator(Bearing.West, new Coordinate(0, 0));
-        robot.TurnRight();
-        Assert.Equal(Bearing.North, robot.Bearing);
+        var sut = new RobotSimulator(Direction.North, new Coordinate(0, 0));
+        sut.Advance();
+        Assert.Equal(Direction.North, sut.Direction);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Turn_left_edge_case()
+    public void Moves_the_robot_forward_1_space_in_the_direction_it_is_pointing_increases_the_y_coordinate_one_when_facing_north()
     {
-        var robot = new RobotSimulator(Bearing.North, new Coordinate(0, 0));
-        robot.TurnLeft();
-        Assert.Equal(Bearing.West, robot.Bearing);
+        var sut = new RobotSimulator(Direction.North, new Coordinate(0, 0));
+        sut.Advance();
+        Assert.Equal(0, sut.Coordinate.X);
+        Assert.Equal(1, sut.Coordinate.Y);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Robbie()
+    public void Moves_the_robot_forward_1_space_in_the_direction_it_is_pointing_decreases_the_y_coordinate_by_one_when_facing_south()
     {
-        var robbie = new RobotSimulator(Bearing.East, new Coordinate(-2, 1));
-        Assert.Equal(Bearing.East, robbie.Bearing);
-        Assert.Equal(new Coordinate(-2, 1), robbie.Coordinate);
+        var sut = new RobotSimulator(Direction.South, new Coordinate(0, 0));
+        sut.Advance();
+        Assert.Equal(0, sut.Coordinate.X);
+        Assert.Equal(-1, sut.Coordinate.Y);
+    }
 
-        robbie.Simulate("RLAALAL");
-        Assert.Equal(Bearing.West, robbie.Bearing);
-        Assert.Equal(new Coordinate(0, 2), robbie.Coordinate);
+    [Fact(Skip = "Remove to run test")]
+    public void Moves_the_robot_forward_1_space_in_the_direction_it_is_pointing_increases_the_x_coordinate_by_one_when_facing_east()
+    {
+        var sut = new RobotSimulator(Direction.East, new Coordinate(0, 0));
+        sut.Advance();
+        Assert.Equal(1, sut.Coordinate.X);
+        Assert.Equal(0, sut.Coordinate.Y);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Moves_the_robot_forward_1_space_in_the_direction_it_is_pointing_decreases_the_x_coordinate_by_one_when_facing_west()
+    {
+        var sut = new RobotSimulator(Direction.West, new Coordinate(0, 0));
+        sut.Advance();
+        Assert.Equal(-1, sut.Coordinate.X);
+        Assert.Equal(0, sut.Coordinate.Y);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Clutz()
+    public void Where_r_turn_right_l_turn_left_and_a_advance_the_robot_can_follow_a_series_of_instructions_and_end_up_with_the_correct_position_and_direction_instructions_to_move_west_and_north()
     {
-        var clutz = new RobotSimulator(Bearing.North, new Coordinate(0, 0));
-        clutz.Simulate("LAAARALA");
-        Assert.Equal(Bearing.West, clutz.Bearing);
-        Assert.Equal(new Coordinate(-4, 1), clutz.Coordinate);
+        var sut = new RobotSimulator(Direction.North, new Coordinate(0, 0));
+        sut.Simulate("LAAARALA");
+        Assert.Equal(Direction.West, sut.Direction);
+        Assert.Equal(-4, sut.Coordinate.X);
+        Assert.Equal(1, sut.Coordinate.Y);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Sphero()
+    public void Where_r_turn_right_l_turn_left_and_a_advance_the_robot_can_follow_a_series_of_instructions_and_end_up_with_the_correct_position_and_direction_instructions_to_move_west_and_south()
     {
-        var sphero = new RobotSimulator(Bearing.East, new Coordinate(2, -7));
-        sphero.Simulate("RRAAAAALA");
-        Assert.Equal(Bearing.South, sphero.Bearing);
-        Assert.Equal(new Coordinate(-3, -8), sphero.Coordinate);
+        var sut = new RobotSimulator(Direction.East, new Coordinate(2, -7));
+        sut.Simulate("RRAAAAALA");
+        Assert.Equal(Direction.South, sut.Direction);
+        Assert.Equal(-3, sut.Coordinate.X);
+        Assert.Equal(-8, sut.Coordinate.Y);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Roomba()
+    public void Where_r_turn_right_l_turn_left_and_a_advance_the_robot_can_follow_a_series_of_instructions_and_end_up_with_the_correct_position_and_direction_instructions_to_move_east_and_north()
     {
-        var roomba = new RobotSimulator(Bearing.South, new Coordinate(8, 4));
-        roomba.Simulate("LAAARRRALLLL");
-        Assert.Equal(Bearing.North, roomba.Bearing);
-        Assert.Equal(new Coordinate(11, 5), roomba.Coordinate);
+        var sut = new RobotSimulator(Direction.South, new Coordinate(8, 4));
+        sut.Simulate("LAAARRRALLLL");
+        Assert.Equal(Direction.North, sut.Direction);
+        Assert.Equal(11, sut.Coordinate.X);
+        Assert.Equal(5, sut.Coordinate.Y);
     }
 }