Merge pull request #145 from ujh/reduce-warnings

Reduce warnings

Author: ujh

src/board/chain/mod.rs

@@ -25,8 +25,6 @@ use board::Coord;
 
 use std::collections::HashSet;
 
-mod test;
-
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub struct Chain {
     color:  Color,
@@ -45,10 +43,6 @@ impl Chain {
         }
     }
 
-    pub fn color(&self) -> Color {
-        self.color
-    }
-
     #[inline(always)]
     pub fn coords<'a>(&'a self) -> &'a Vec<Coord> {
         &self.coords
@@ -87,7 +81,4 @@ impl Chain {
         self.libs.len() == 0
     }
 
-    pub fn show(&self) -> String {
-        format!("{:<3}| {:?}, libs: {:?}, stones: {:?}", self.id, self.color, self.libs, self.coords)
-    }
 }

src/board/chain/test.rs

@@ -45,10 +45,6 @@ impl Coord {
         coords
     }
 
-    pub fn from_index(id: usize, board_size: u8) -> Coord {
-        Coord {col: (id%board_size as usize + 1) as u8, row: (id/board_size as usize + 1) as u8}
-    }
-
     pub fn neighbours(&self, board_size: u8) -> Vec<Coord> {
         let mut neighbours = Vec::new();
 

src/board/coord/mod.rs

@@ -582,18 +582,10 @@ impl Board {
         self.consecutive_passes == 2 || self.resigned_by != Empty
     }
 
-    pub fn ruleset(&self) -> Ruleset {
-        self.ruleset
-    }
-
     pub fn size(&self) -> u8 {
         self.size
     }
 
-    pub fn chains<'b>(&'b self) -> &'b Vec<Chain> {
-        &self.chains
-    }
-
     pub fn vacant_point_count(&self) -> u16 {
         self.vacant.len() as u16
     }

src/board/mod.rs

@@ -468,7 +468,7 @@ fn legal_moves_only_contains_legal_moves() {
 #[test]
 fn ruleset_returns_the_correct_ruleset() {
     let b = Board::new(1, 6.5, Minimal);
-    assert_eq!(b.ruleset(), Minimal);
+    assert_eq!(b.ruleset, Minimal);
 }
 
 #[test]

src/board/test/mod.rs

@@ -62,7 +62,7 @@ impl Engine for EarlyReturnEngine {
 #[test]
 fn the_engine_can_use_less_time_than_allocated() {
     let game = Game::new(19, 6.5, Minimal);
-    let color = game.next_player();
+    let color = game.board().next_player();
     let timer = Timer::new(config());
     let budget = timer.budget(&game);
     let engine = Box::new(EarlyReturnEngine::new());
@@ -100,7 +100,7 @@ impl Engine for WaitingEngine {
 #[test]
 fn the_controller_asks_the_engine_for_a_move_when_the_time_is_up() {
     let game = Game::new(19, 6.5, Minimal);
-    let color = game.next_player();
+    let color = game.board().next_player();
     let mut timer = Timer::new(config());
     timer.setup(1, 0, 0);
     let budget = timer.budget(&game);

src/engine/controller/test.rs

@@ -64,10 +64,6 @@ impl MoveStats {
         self.stats.values().all(|stat| stat.all_losses())
     }
 
-    pub fn all_wins(&self) -> bool {
-        self.stats.values().all(|stat| stat.all_wins())
-    }
-
     pub fn best(&self) -> (Move, MoveStat) {
         let mut m = Pass(self.color);
         let mut move_stats = MoveStat::new();
@@ -112,10 +108,6 @@ impl MoveStat {
         self.plays = self.plays + 1;
     }
 
-    pub fn all_wins(&self) -> bool {
-        self.wins == self.plays
-    }
-
     pub fn all_losses(&self) -> bool {
         self.wins == 0
     }

src/engine/move_stats/mod.rs

@@ -55,23 +55,6 @@ mod move_stats {
         assert_eq!(ms.wins, 2);
     }
 
-    #[test]
-    fn all_wins_returns_true_when_no_losses_were_recorded() {
-        let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
-        let mut stats = MoveStats::new(&moves, Black);
-        stats.record_win(Play(Black, 1, 1));
-        stats.record_win(Play(Black, 2, 2));
-        assert!(stats.all_wins());
-    }
-
-    #[test]
-    fn all_wins_returns_false_when_a_loss_was_recorded() {
-        let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
-        let mut stats = MoveStats::new(&moves, Black);
-        stats.record_loss(Play(Black, 1, 1));
-        assert!(!stats.all_wins());
-    }
-
     #[test]
     fn all_losses_returns_true_when_no_wins_were_recorded() {
         let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];

src/engine/move_stats/test.rs

@@ -22,7 +22,6 @@
 
 use board::Board;
 use board::Color;
-use board::Coord;
 use board::IllegalMove;
 use board::Move;
 use board::NoMove;
@@ -47,7 +46,6 @@ pub trait Info {
 pub struct Game {
     board: Board,
     last_move: Move,
-    move_number: u16,
     zobrist_hash_table: ZobristHashTable,
 }
 
@@ -58,16 +56,14 @@ impl Game {
         Game {
             board: new_board,
             last_move: NoMove,
-            move_number: 0,
             zobrist_hash_table: ZobristHashTable::new(size),
         }
     }
 
-    pub fn with_new_state(board: Board, move_number: u16, zobrist_hash_table: ZobristHashTable, last_move: Move) -> Game {
+    pub fn with_new_state(board: Board, zobrist_hash_table: ZobristHashTable, last_move: Move) -> Game {
         Game {
             board: board,
             last_move: last_move,
-            move_number: move_number,
             zobrist_hash_table: zobrist_hash_table,
        }
     }
@@ -77,7 +73,7 @@ impl Game {
 
         match new_board.play(m) {
             Ok(_) => {
-                let mut new_game_state = Game::with_new_state(new_board, self.move_number + 1, self.zobrist_hash_table.clone(), m);
+                let mut new_game_state = Game::with_new_state(new_board, self.zobrist_hash_table.clone(), m);
                 if !m.is_pass() && !m.is_resign() {
                     match new_game_state.check_and_update_super_ko(&m) {
                         Err(_) => return Err(IllegalMove::SuperKo),
@@ -94,20 +90,6 @@ impl Game {
         self.zobrist_hash_table.check_and_update_super_ko(m, &self.board)
     }
 
-    // Note: This method uses 1-1 as the origin point, not 0-0. 19-19 is a valid coordinate in a 19-sized board, while 0-0 is not.
-    //       this is done because I think it makes more sense in the context of go. (Least surprise principle, etc...)
-    pub fn get(&self, col: u8, row: u8) -> Color {
-        self.board.color(&Coord::new(col, row))
-    }
-
-    pub fn ruleset(&self) -> Ruleset {
-        self.board.ruleset()
-    }
-
-    pub fn move_number(&self) -> u16 {
-        self.move_number
-    }
-
     pub fn last_move(&self) -> Move {
         self.last_move
     }
@@ -136,24 +118,10 @@ impl Game {
         self.board.set_komi(komi);
     }
 
-    pub fn board_size(&self) -> u8 {
-        self.board.size()
-    }
-
     pub fn board(&self) -> Board {
         self.board.clone()
     }
 
-    pub fn show_chains(&self) {
-        for c in self.board.chains().iter() {
-            println!("{}", c.show());
-        }
-    }
-
-    pub fn next_player(&self) -> Color {
-        self.board.next_player()
-    }
-
     pub fn legal_moves(&self) -> Vec<Move> {
         self.board
             .legal_moves_without_superko_check()

src/game/mod.rs

@@ -30,23 +30,9 @@ use board::Resign;
 use board::White;
 use game::Game;
 use ruleset::KgsChinese;
-use ruleset::Minimal;
 
 mod ko;
 
-#[test]
-fn should_start_counting_moves_at_0() {
-    let g = Game::new(5, 6.5, Minimal);
-    assert_eq!(0, g.move_number());
-}
-
-#[test]
-fn should_increment_move_count_by_1_for_each_move() {
-    let mut g = Game::new(5, 6.5, Minimal);
-    g = g.play(Play(Black, 1, 1)).unwrap();
-    assert_eq!(1, g.move_number());
-}
-
 #[test]
 fn catch_suicide_moves_in_chinese() {
     let mut g = Game::new(3, 6.5, KgsChinese);
@@ -69,12 +55,6 @@ fn catch_suicide_moves_in_chinese() {
     }
 }
 
-#[test]
-fn next_player_should_return_board_next_player() {
-    let g = Game::new(3, 6.5, KgsChinese);
-    assert_eq!(g.board.next_player(), g.next_player());
-}
-
 #[test]
 fn it_should_handle_resign() {
     let g = Game::new(9, 6.5, KgsChinese);