diff --git a/board/src/bitboard.rs b/board/src/bitboard.rs
index ebb1d30..9b8580d 100644
--- a/board/src/bitboard.rs
+++ b/board/src/bitboard.rs
@@ -114,12 +114,11 @@ mod tests {
     fn has_piece_at() {
         let bb = BitBoard(0b1001100);
 
-        assert!(bb.has_piece_at(
-            &Square::from_algebraic_string("a3").expect("Unable to get square for 'a3'")
-        ));
-        assert!(!bb.has_piece_at(
-            &Square::from_algebraic_string("a2").expect("Unable to get square for 'a2'")
-        ));
+        let c1 = Square::from_algebraic_string("c1").expect("Unable to get square for 'c1'");
+        assert!(bb.has_piece_at(&c1));
+
+        let b1 = Square::from_algebraic_string("b1").expect("Unable to get square for 'b1'");
+        assert!(!bb.has_piece_at(&b1));
     }
 
     #[test]
diff --git a/board/src/square.rs b/board/src/square.rs
index a376e81..09f0d76 100644
--- a/board/src/square.rs
+++ b/board/src/square.rs
@@ -49,26 +49,29 @@ impl FromStr for Square {
             return Err(ParseSquareError);
         }
 
-        let chars: Vec<char> = s.chars().collect();
-        let rank_char = chars[0].to_ascii_lowercase();
-        if !rank_char.is_ascii_lowercase() {
+        let mut chars = s.chars();
+
+        let file_char = chars.next().unwrap().to_ascii_lowercase();
+        if !file_char.is_ascii_lowercase() {
             return Err(ParseSquareError);
         }
 
-        let rank = (rank_char as u8) - ('a' as u8);
-        if rank >= 8 {
+        let file = (file_char as u8) - ('a' as u8);
+        if file >= 8 {
             return Err(ParseSquareError);
         }
 
-        let converted_file_digit = chars[1]
+        let converted_rank_digit = chars
+            .next()
+            .unwrap()
             .to_digit(10)
-            .and_then(|x| if x != 0 { Some(x) } else { None })
+            .and_then(|x| if x >= 1 && x <= 8 { Some(x) } else { None })
             .ok_or(ParseSquareError)?;
-        let file = u8::try_from(converted_file_digit).map_err(|_| ParseSquareError)? - 1;
+        let rank = u8::try_from(converted_rank_digit).map_err(|_| ParseSquareError)? - 1;
 
         Ok(Square {
-            rank: rank,
-            file: file,
+            rank,
+            file,
             index: rank * 8 + file,
         })
     }
@@ -78,26 +81,19 @@ impl FromStr for Square {
 mod tests {
     use super::*;
 
-    #[test]
-    fn indexes() {
-        let sq1 = Square::from_algebraic_string("c5").expect("Failed to parse 'c5' square");
-        assert_eq!(sq1.rank_index(), 2, "Rank doesn't match");
-        assert_eq!(sq1.file_index(), 4, "File doesn't match");
-
-        let sq2 = Square::from_algebraic_string("b2").expect("Failed to parse 'b2' square");
-        assert_eq!(sq2.rank_index(), 1, "Rank doesn't match");
-        assert_eq!(sq2.file_index(), 1, "File doesn't match");
-    }
-
     #[test]
     fn good_algebraic_input() {
         let sq1 = Square::from_algebraic_string("a4").expect("Failed to parse 'a4' square");
-        assert_eq!(sq1.rank, 0);
-        assert_eq!(sq1.file, 3);
+        assert_eq!(sq1.file, 0);
+        assert_eq!(sq1.rank, 3);
 
         let sq2 = Square::from_algebraic_string("B8").expect("Failed to parse 'B8' square");
-        assert_eq!(sq2.rank, 1);
-        assert_eq!(sq2.file, 7);
+        assert_eq!(sq2.file, 1);
+        assert_eq!(sq2.rank, 7);
+
+        let sq3 = Square::from_algebraic_string("e4").expect("Failed to parse 'B8' square");
+        assert_eq!(sq3.rank, 3, "Expected rank of e4 to be 3");
+        assert_eq!(sq3.file, 4, "Expected file of e4 to be 4");
     }
 
     #[test]
@@ -115,5 +111,11 @@ mod tests {
         let sq1 = Square::from_index(4).expect("Unable to get Square from index");
         assert_eq!(sq1.rank, 0);
         assert_eq!(sq1.file, 4);
+
+        let sq1 = Square::from_index(28).expect("Unable to get Square from index");
+        assert_eq!(sq1.rank, 3);
+        assert_eq!(sq1.file, 4);
+    }
+
     }
 }