Implement Queen Attack

config.json

@@ -22,6 +22,7 @@
     "grade-school",
     "phone-number",
     "hexadecimal",
+    "queen-attack",
     "beer-song",
     "minesweeper",
     "dominoes",

exercises/queen-attack/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "queen-attack"
+version = "0.0.0"

exercises/queen-attack/example.rs

@@ -0,0 +1,78 @@
+#[derive(Debug, PartialEq)]
+pub struct Queen { position: ChessPosition }
+
+impl Queen {
+    pub fn new(position: (i8, i8)) -> Result<Queen, ()> {
+        let position = ChessPosition::new(position);
+        if position.valid() {
+            Ok(Queen { position: position })
+        } else {
+            Err(())
+        }
+    }
+
+    pub fn can_attack(&self, piece: Queen) -> bool {
+        self.horizontal_from(&piece) ||
+            self.vertical_from(&piece) ||
+            self.diagonal_from(&piece)
+    }
+
+    fn horizontal_from(&self, piece: &Queen) -> bool {
+        self.rank() == piece.rank()
+    }
+
+    fn vertical_from(&self, piece: &Queen) -> bool {
+        self.file() == piece.file()
+    }
+
+    fn diagonal_from(&self, piece: &Queen) -> bool {
+        self.sum() == piece.sum() ||
+            self.difference() == piece.difference()
+    }
+
+    fn rank(&self) -> i8 {
+        self.position.rank()
+    }
+
+    fn file(&self) -> i8 {
+        self.position.file()
+    }
+
+    fn sum(&self) -> i8 {
+        self.position.sum()
+    }
+
+    fn difference(&self) -> i8 {
+        self.position.difference()
+    }
+}
+
+#[derive(Debug, PartialEq)]
+struct ChessPosition { coordinates: (i8, i8) }
+
+impl ChessPosition {
+    fn new(coordinates: (i8, i8)) -> ChessPosition {
+        ChessPosition {coordinates: coordinates}
+    }
+
+    fn valid(&self) -> bool {
+        (self.rank() >= 0 && self.rank() <= 7) &&
+        (self.file() >= 0 && self.file() <= 7)
+    }
+
+    fn rank(&self) -> i8 {
+        self.coordinates.0
+    }
+
+    fn file(&self) -> i8 {
+        self.coordinates.1
+    }
+
+    fn sum(&self) -> i8 {
+        self.rank() + self.file()
+    }
+
+    fn difference(&self) -> i8 {
+        self.rank() - self.file()
+    }
+}

exercises/queen-attack/tests/queen-attack.rs

@@ -0,0 +1,81 @@
+extern crate queen_attack;
+
+use queen_attack::*;
+
+#[test]
+fn test_queen_creation_with_valid_position() {
+    let white_queen = Queen::new((2,4));
+    assert!(white_queen.is_ok());
+}
+
+#[test]
+#[ignore]
+fn test_queen_creation_with_incorrect_positions() {
+    let white_queen = Queen::new((-1,2));
+    assert!(white_queen.is_err());
+
+    let white_queen = Queen::new((8,2));
+    assert!(white_queen.is_err());
+
+    let white_queen = Queen::new((5,-1));
+    assert!(white_queen.is_err());
+
+    let white_queen = Queen::new((5,8));
+    assert!(white_queen.is_err());
+}
+
+#[test]
+#[ignore]
+fn test_can_not_attack() {
+    let white_queen = Queen::new((2,4)).unwrap();
+    let black_queen = Queen::new((6,6)).unwrap();
+    assert_eq!(false, white_queen.can_attack(black_queen));
+}
+
+#[test]
+#[ignore]
+fn test_can_attack_on_same_rank() {
+    let white_queen = Queen::new((2,4)).unwrap();
+    let black_queen = Queen::new((2,6)).unwrap();
+    assert!(white_queen.can_attack(black_queen));
+}
+
+#[test]
+#[ignore]
+fn test_can_attack_on_same_file() {
+    let white_queen = Queen::new((4,5)).unwrap();
+    let black_queen = Queen::new((3,5)).unwrap();
+    assert!(white_queen.can_attack(black_queen));
+}
+
+#[test]
+#[ignore]
+fn test_can_attack_on_first_diagonal() {
+    let white_queen = Queen::new((2,2)).unwrap();
+    let black_queen = Queen::new((0,4)).unwrap();
+    assert!(white_queen.can_attack(black_queen));
+}
+
+#[test]
+#[ignore]
+fn test_can_attack_on_second_diagonal() {
+    let white_queen = Queen::new((2,2)).unwrap();
+    let black_queen = Queen::new((3,1)).unwrap();
+    assert!(white_queen.can_attack(black_queen));
+}
+
+#[test]
+#[ignore]
+fn test_can_attack_on_third_diagonal() {
+    let white_queen = Queen::new((2,2)).unwrap();
+    let black_queen = Queen::new((1,1)).unwrap();
+    assert!(white_queen.can_attack(black_queen));
+}
+
+#[test]
+#[ignore]
+fn test_can_attack_on_fourth_diagonal() {
+    let white_queen = Queen::new((2,2)).unwrap();
+    let black_queen = Queen::new((5,5)).unwrap();
+    assert!(white_queen.can_attack(black_queen));
+}