WIP: Tests, stub file.

Tests come from exercism/problem-specifications#282

As discussed in exercism#117 we are
providing a stub implementation so that ignored tests do not fail when a
student hasn't yet implemented the functionality they exercise.

Author: whit0694

exercises/robot-simulator/Cargo.lock

@@ -0,0 +1,3 @@
+[package]
+name = "robot-simulator"
+version = "0.0.0"

exercises/robot-simulator/Cargo.toml

@@ -0,0 +1,32 @@
+#[derive(PartialEq, Debug)]
+pub enum Direction {
+    North,
+    East,
+    South,
+    West,
+}
+
+pub struct Robot {
+}
+
+impl Robot {
+    pub fn new(x: isize, y: isize, d: &Direction) -> Self {
+        Robot {}
+    }
+
+    pub fn turn_right(&mut self) {}
+
+    pub fn turn_left(&mut self) {}
+
+    pub fn advance(&mut self) {}
+
+    pub fn instructions(&mut self, instructions: &str) {}
+
+    pub fn position(&self) -> (isize, isize) {
+        (0, 0)
+    }
+
+    pub fn direction(&self) -> Direction {
+        Direction::North
+    }
+}

exercises/robot-simulator/src/lib.rs

@@ -0,0 +1,165 @@
+extern crate robot_simulator;
+
+use robot_simulator::*;
+
+#[test]
+fn robots_are_created_with_position_and_direction() {
+    let robot = Robot::new(0, 0, &Direction::North);
+    assert_eq!((0, 0), robot.position());
+    assert_eq!(Direction::North, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn positions_can_be_negative() {
+    let robot = Robot::new(-1, -1, &Direction::South);
+    assert_eq!((-1, -1), robot.position());
+    assert_eq!(Direction::South, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn turning_right_does_not_change_position() {
+    let mut robot = Robot::new(0, 0, &Direction::North);
+    robot.turn_right();
+    assert_eq!((0, 0), robot.position());
+}
+
+#[test]
+#[ignore]
+fn turning_right_from_north_points_the_robot_east() {
+    let mut robot = Robot::new(0, 0, &Direction::North);
+    robot.turn_right();
+    assert_eq!(Direction::East, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn turning_right_from_east_points_the_robot_south() {
+    let mut robot = Robot::new(0, 0, &Direction::East);
+    robot.turn_right();
+    assert_eq!(Direction::South, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn turning_right_from_south_points_the_robot_west() {
+    let mut robot = Robot::new(0, 0, &Direction::South);
+    robot.turn_right();
+    assert_eq!(Direction::West, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn turning_right_from_west_points_the_robot_north() {
+    let mut robot = Robot::new(0, 0, &Direction::West);
+    robot.turn_right();
+    assert_eq!(Direction::North, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn turning_left_does_not_change_position() {
+    let mut robot = Robot::new(0, 0, &Direction::North);
+    robot.turn_left();
+    assert_eq!((0, 0), robot.position());
+}
+
+#[test]
+#[ignore]
+fn turning_left_from_north_points_the_robot_west() {
+    let mut robot = Robot::new(0, 0, &Direction::North);
+    robot.turn_left();
+    assert_eq!(Direction::East, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn turning_left_from_west_points_the_robot_south() {
+    let mut robot = Robot::new(0, 0, &Direction::East);
+    robot.turn_left();
+    assert_eq!(Direction::South, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn turning_left_from_south_points_the_robot_east() {
+    let mut robot = Robot::new(0, 0, &Direction::South);
+    robot.turn_left();
+    assert_eq!(Direction::East, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn turning_left_from_east_points_the_robot_north() {
+    let mut robot = Robot::new(0, 0, &Direction::East);
+    robot.turn_left();
+    assert_eq!(Direction::North, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn advance_does_not_change_the_direction() {
+    let mut robot = Robot::new(0, 0, &Direction::North);
+    robot.advance();
+    assert_eq!(Direction::North, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn advance_increases_the_y_coordinate_by_one_when_facing_north() {
+    let mut robot = Robot::new(0, 0, &Direction::North);
+    robot.advance();
+    assert_eq!((0, 1), robot.position());
+}
+
+#[test]
+#[ignore]
+fn advance_decreases_the_y_coordinate_by_one_when_facing_south() {
+    let mut robot = Robot::new(0, 0, &Direction::South);
+    robot.advance();
+    assert_eq!((0, -1), robot.position());
+}
+
+#[test]
+#[ignore]
+fn advance_increases_the_x_coordinate_by_one_when_facing_east() {
+    let mut robot = Robot::new(0, 0, &Direction::East);
+    robot.advance();
+    assert_eq!((1, 0), robot.position());
+}
+
+#[test]
+#[ignore]
+fn advance_decreases_the_x_coordinate_by_one_when_facing_west() {
+    let mut robot = Robot::new(0, 0, &Direction::West);
+    robot.advance();
+    assert_eq!((-1, 0), robot.position());
+}
+
+#[test]
+#[ignore]
+fn follow_instructions_to_move_west_and_north() {
+    let mut robot = Robot::new(0, 0, &Direction::North);
+    robot.instructions("LAAARALA");
+    assert_eq!((-4, 1), robot.position());
+    assert_eq!(Direction::West, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn follow_instructions_to_move_west_and_south() {
+    let mut robot = Robot::new(0, 0, &Direction::East);
+    robot.instructions("RRAAAAALA");
+    assert_eq!((-3, -8), robot.position());
+    assert_eq!(Direction::South, robot.direction());
+}
+
+#[test]
+#[ignore]
+fn follow_instructions_to_move_east_and_north() {
+    let mut robot = Robot::new(0, 0, &Direction::South);
+    robot.instructions("LAAARRRALLLL");
+    assert_eq!((11, 5), robot.position());
+    assert_eq!(Direction::North, robot.direction());
+}