Fixed unit tests

3 files changed, 63 insertions, 25 deletions

diff --git a/model/src/board.rs b/model/src/board.rs
index 75c29cb..d2d136d 100644
--- a/model/src/board.rs
+++ b/model/src/board.rs
@@ -299,6 +299,7 @@ impl CheckersBitBoard {
 	/// # Safety
 	///
 	/// Results in undefined behavior if `start` does not contain a piece
+	// TODO rip out so we don't need to check for both black and white promotion
 	pub const unsafe fn move_piece_to_unchecked(self, start: usize, dest: usize) -> Self {
 		// Clears the bit at the starting value
 		// Sets the bit at the destination value
@@ -317,8 +318,8 @@ impl CheckersBitBoard {
 		// Promotes if the end of the board was reached
 		let kings = (self.kings & !(1 << dest))
 			| (((self.kings >> start) & 1) << dest)
-			| (self.color & DARK_PROMOTION_MASK)
-			| (!self.color & LIGHT_PROMOTION_MASK);
+			| (color & DARK_PROMOTION_MASK)
+			| (!color & LIGHT_PROMOTION_MASK);
 
 		let turn = self.turn.flip();
 
@@ -545,14 +546,14 @@ impl CheckersBitBoard {
 			.move_piece_backward_unchecked(value, 2)
 			.clear_piece(value.wrapping_sub(1) & 31);
 
-		const KING_MASK: u32 = 0b00000000000010000010000010000010;
-		if PossibleMoves::has_jumps(board.flip_turn())
-			&& not_king && (((1 << value) & KING_MASK) == 0)
-		{
-			board.flip_turn()
-		} else {
-			board
-		}
+			const KING_MASK: u32 = 0b00000000000010000010000010000010;
+			if PossibleMoves::has_jumps(board.flip_turn())
+				&& not_king && (((1 << value) & KING_MASK) == 0)
+			{
+				board.flip_turn()
+			} else {
+				board
+			}
 	}
 
 	/// Tries to move the piece backward and to the right, without checking if it's a legal move.
diff --git a/model/src/board/tests.rs b/model/src/board/tests.rs
index ea3dece..249b374 100644
--- a/model/src/board/tests.rs
+++ b/model/src/board/tests.rs
@@ -371,7 +371,7 @@ fn test_king_at_unchecked_one_king() {
 fn test_default_bitboard() {
 	let board = CheckersBitBoard::default();
 	let exemptions = vec![2, 28, 22, 16, 27, 21, 15, 9];
-	let black = vec![11, 5, 31, 25, 10, 4, 30, 24, 3, 29, 23, 17];
+	let black = vec![18, 12, 6, 0, 19, 13, 7, 1, 26, 20, 14, 8];
 
 	for i in 0..32 {
 		if !exemptions.contains(&i) {
@@ -536,8 +536,8 @@ fn test_move_piece_to_default_board() {
 	let board = unsafe { board.move_piece_to_unchecked(0, 5) };
 	assert!(!board.piece_at(0));
 	assert!(board.piece_at(5));
-	assert_eq!(board.color_at(5).unwrap(), PieceColor::Light);
-	assert!(!board.king_at(5).unwrap());
+	assert_eq!(board.color_at(5).unwrap(), PieceColor::Dark);
+	assert!(board.king_at(5).unwrap());
 	assert_eq!(board.turn, PieceColor::Light);
 }
 
@@ -547,7 +547,7 @@ fn test_move_piece_forward_standard() {
 	let board = unsafe { board.move_piece_forward_unchecked(14, 2) }; // go to 16
 	assert!(!board.piece_at(14));
 	assert!(board.piece_at(16));
-	assert_eq!(board.color_at(16).unwrap(), PieceColor::Light);
+	assert_eq!(board.color_at(16).unwrap(), PieceColor::Dark);
 	assert!(!board.king_at(16).unwrap());
 	assert_eq!(board.turn, PieceColor::Light);
 }
@@ -558,7 +558,7 @@ fn test_move_piece_forward_wrap() {
 	let board = unsafe { board.move_piece_forward_unchecked(31, 10) }; // go to 9
 	assert!(!board.piece_at(31));
 	assert!(board.piece_at(9));
-	assert_eq!(board.color_at(9).unwrap(), PieceColor::Dark);
+	assert_eq!(board.color_at(9).unwrap(), PieceColor::Light);
 	assert!(!board.king_at(9).unwrap());
 	assert_eq!(board.turn, PieceColor::Light);
 }
@@ -567,8 +567,8 @@ fn test_move_piece_forward_wrap() {
 fn test_move_piece_forward_left_to_king() {
 	let board = CheckersBitBoard::new(0b10000, 0b10000, 0, PieceColor::Dark);
 	let board = unsafe { board.move_piece_forward_left_unchecked(4) };
-	assert!(board.piece_at(5));
-	assert!(board.king_at(5).unwrap());
+	assert!(board.piece_at(11));
+	assert!(board.king_at(11).unwrap());
 }
 
 #[test]
@@ -585,7 +585,7 @@ fn test_move_piece_backward_standard() {
 	let board = unsafe { board.move_piece_backward_unchecked(29, 14) }; // go to 15
 	assert!(!board.piece_at(29));
 	assert!(board.piece_at(15));
-	assert_eq!(board.color_at(15).unwrap(), PieceColor::Dark);
+	assert_eq!(board.color_at(15).unwrap(), PieceColor::Light);
 	assert!(!board.king_at(15).unwrap());
 	assert_eq!(board.turn, PieceColor::Light);
 }
@@ -596,7 +596,7 @@ fn test_move_piece_backward_wrap() {
 	let board = unsafe { board.move_piece_backward_unchecked(0, 4) }; // go to 28
 	assert!(!board.piece_at(0));
 	assert!(board.piece_at(28));
-	assert_eq!(board.color_at(28).unwrap(), PieceColor::Light);
+	assert_eq!(board.color_at(28).unwrap(), PieceColor::Dark);
 	assert!(!board.king_at(28).unwrap());
 	assert_eq!(board.turn, PieceColor::Light);
 }
@@ -617,7 +617,7 @@ fn test_jump_forward_left_specific() {
 	assert!(board2.piece_at(14));
 	assert_eq!(board2.color_at(14).unwrap(), board.color_at(0).unwrap());
 	assert_eq!(board2.king_at(14).unwrap(), board.king_at(0).unwrap());
-	assert_eq!(board.turn, PieceColor::Light);
+	assert_eq!(board2.turn, PieceColor::Light);
 }
 
 #[test]
@@ -635,7 +635,7 @@ fn test_jump_forward_right_specific() {
 	assert!(board2.piece_at(20));
 	assert_eq!(board2.color_at(20).unwrap(), board.color_at(18).unwrap());
 	assert_eq!(board2.king_at(20).unwrap(), board.king_at(18).unwrap());
-	assert_eq!(board.turn, PieceColor::Light);
+	assert_eq!(board2.turn, PieceColor::Light);
 }
 
 #[test]
@@ -653,7 +653,7 @@ fn test_jump_backward_left_specific() {
 	assert!(board2.piece_at(23));
 	assert_eq!(board2.color_at(23).unwrap(), board.color_at(25).unwrap());
 	assert_eq!(board2.king_at(23).unwrap(), board.king_at(25).unwrap());
-	assert_eq!(board.turn, PieceColor::Light);
+	assert_eq!(board2.turn, PieceColor::Light);
 }
 
 #[test]
@@ -671,7 +671,7 @@ fn test_jump_backward_right_specific() {
 	assert!(board2.piece_at(29));
 	assert_eq!(board2.color_at(29).unwrap(), board.color_at(11).unwrap());
 	assert_eq!(board2.king_at(29).unwrap(), board.king_at(11).unwrap());
-	assert_eq!(board.turn, PieceColor::Light);
+	assert_eq!(board2.turn, PieceColor::Light);
 }
 
 #[test]
diff --git a/model/src/moves.rs b/model/src/moves.rs
index 626d85a..b8e58ee 100644
--- a/model/src/moves.rs
+++ b/model/src/moves.rs
@@ -1,6 +1,6 @@
 use crate::CheckersBitBoard;
 
-#[derive(Copy, Clone, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum MoveDirection {
 	ForwardLeft = 0,
 	ForwardRight = 1,
@@ -9,7 +9,7 @@ pub enum MoveDirection {
 }
 
 /// A checkers move
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub struct Move {
 	/// The position of the piece to move
 	start: u32,
@@ -30,6 +30,7 @@ impl Move {
 	/// * `direction` - The direction the piece should move in
 	/// * `jump` - Whether or not the piece should jump
 	pub const fn new(start: usize, direction: MoveDirection, jump: bool) -> Self {
+		// TODO what are the semantics of usize as u32?
 		Self {
 			start: start as u32,
 			direction,
@@ -87,3 +88,39 @@ impl Move {
 		}
 	}
 }
+
+#[cfg(test)]
+mod tests {
+
+	use proptest::prelude::*;
+	use super::*;
+
+	proptest!{
+		#[test]
+		fn new(start in 0usize..32, jump in proptest::bool::ANY) {
+			let direction = MoveDirection::ForwardLeft;
+			let move_test = Move::new(start, direction, jump);
+			assert_eq!(move_test.start as usize, start);
+			assert_eq!(move_test.direction, direction);
+			assert_eq!(move_test.jump, jump);
+
+			let direction = MoveDirection::ForwardRight;
+			let move_test = Move::new(start, direction, jump);
+			assert_eq!(move_test.start as usize, start);
+			assert_eq!(move_test.direction, direction);
+			assert_eq!(move_test.jump, jump);
+
+			let direction = MoveDirection::BackwardLeft;
+			let move_test = Move::new(start, direction, jump);
+			assert_eq!(move_test.start as usize, start);
+			assert_eq!(move_test.direction, direction);
+			assert_eq!(move_test.jump, jump);
+
+			let direction = MoveDirection::BackwardRight;
+			let move_test = Move::new(start, direction, jump);
+			assert_eq!(move_test.start as usize, start);
+			assert_eq!(move_test.direction, direction);
+			assert_eq!(move_test.jump, jump);
+		}
+	}
+}
\ No newline at end of file