Changes test assertions to compare wrapped values

exercises/all-your-base/tests/all-your-base.rs

@@ -5,9 +5,9 @@ fn single_bit_one_to_decimal() {
     let input_base = 2;
     let input_digits = &[1];
     let output_base = 10;
-    let output_digits = &[1];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![1];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]
@@ -16,9 +16,9 @@ fn binary_to_single_decimal() {
     let input_base = 2;
     let input_digits = &[1, 0, 1];
     let output_base = 10;
-    let output_digits = &[5];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![5];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]
@@ -27,9 +27,9 @@ fn single_decimal_to_binary() {
     let input_base = 10;
     let input_digits = &[5];
     let output_base = 2;
-    let output_digits = &[1, 0, 1];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![1, 0, 1];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]
@@ -38,9 +38,9 @@ fn binary_to_multiple_decimal() {
     let input_base = 2;
     let input_digits = &[1, 0, 1, 0, 1, 0];
     let output_base = 10;
-    let output_digits = &[4, 2];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![4, 2];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]
@@ -49,9 +49,9 @@ fn decimal_to_binary() {
     let input_base = 10;
     let input_digits = &[4, 2];
     let output_base = 2;
-    let output_digits = &[1, 0, 1, 0, 1, 0];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![1, 0, 1, 0, 1, 0];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]
@@ -60,9 +60,9 @@ fn trinary_to_hexadecimal() {
     let input_base = 3;
     let input_digits = &[1, 1, 2, 0];
     let output_base = 16;
-    let output_digits = &[2, 10];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![2, 10];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]
@@ -71,9 +71,9 @@ fn hexadecimal_to_trinary() {
     let input_base = 16;
     let input_digits = &[2, 10];
     let output_base = 3;
-    let output_digits = &[1, 1, 2, 0];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![1, 1, 2, 0];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]
@@ -82,9 +82,9 @@ fn fifteen_bit_integer() {
     let input_base = 97;
     let input_digits = &[3, 46, 60];
     let output_base = 73;
-    let output_digits = &[6, 10, 45];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![6, 10, 45];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]
@@ -93,9 +93,9 @@ fn empty_list() {
     let input_base = 2;
     let input_digits = &[];
     let output_base = 10;
-    let output_digits = &[];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]
@@ -104,9 +104,9 @@ fn single_zero() {
     let input_base = 10;
     let input_digits = &[0];
     let output_base = 2;
-    let output_digits = &[];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]
@@ -115,9 +115,9 @@ fn multiple_zeros() {
     let input_base = 10;
     let input_digits = &[0, 0, 0];
     let output_base = 2;
-    let output_digits = &[];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]
@@ -126,9 +126,9 @@ fn leading_zeros() {
     let input_base = 7;
     let input_digits = &[0, 6, 0];
     let output_base = 10;
-    let output_digits = &[4, 2];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base).unwrap().as_slice(),
-               output_digits);
+    let output_digits = vec![4, 2];
+    assert_eq!(ayb::convert(input_digits, input_base, output_base),
+               Ok(output_digits));
 }
 
 #[test]

exercises/alphametics/tests/alphametics.rs

@@ -2,9 +2,9 @@ extern crate alphametics;
 use std::collections::HashMap;
 
 fn assert_alphametic_solution_eq(puzzle: &str, solution: &[(char, u8)]) {
-    let answer = alphametics::solve(puzzle).unwrap();
+    let answer = alphametics::solve(puzzle);
     let solution: HashMap<char, u8> = solution.iter().cloned().collect();
-    assert_eq!(answer, solution);
+    assert_eq!(answer, Some(solution));
 }
 
 #[test]

exercises/bowling/tests/bowling.rs

@@ -72,7 +72,7 @@ fn twenty_zero_pin_rolls_scores_zero() {
         let _ = game.roll(0);
     }
 
-    assert_eq!(game.score().unwrap(), 0);
+    assert_eq!(game.score(), Ok(0));
 }
 
 #[test]
@@ -85,7 +85,7 @@ fn ten_frames_without_a_strike_or_spare() {
         let _ = game.roll(6);
     }
 
-    assert_eq!(game.score().unwrap(), 90);
+    assert_eq!(game.score(), Ok(90));
 }
 
 #[test]
@@ -100,7 +100,7 @@ fn spare_in_the_first_frame_followed_by_zeros() {
         let _ = game.roll(0);
     }
 
-    assert_eq!(game.score().unwrap(), 10);
+    assert_eq!(game.score(), Ok(10));
 }
 
 #[test]
@@ -116,7 +116,7 @@ fn points_scored_in_the_roll_after_a_spare_are_counted_twice_as_a_bonus() {
         let _ = game.roll(0);
     }
 
-    assert_eq!(game.score().unwrap(), 16);
+    assert_eq!(game.score(), Ok(16));
 }
 
 #[test]
@@ -134,7 +134,7 @@ fn consecutive_spares_each_get_a_one_roll_bonus() {
         let _ = game.roll(0);
     }
 
-    assert_eq!(game.score().unwrap(), 31);
+    assert_eq!(game.score(), Ok(31));
 }
 
 #[test]
@@ -150,7 +150,7 @@ fn if_the_last_frame_is_a_spare_you_get_one_extra_roll_that_is_scored_once() {
     let _ = game.roll(5);
     let _ = game.roll(7);
 
-    assert_eq!(game.score().unwrap(), 17);
+    assert_eq!(game.score(), Ok(17));
 }
 
 #[test]
@@ -164,7 +164,7 @@ fn a_strike_earns_ten_points_in_a_frame_with_a_single_roll() {
         let _ = game.roll(0);
     }
 
-    assert_eq!(game.score().unwrap(), 10);
+    assert_eq!(game.score(), Ok(10));
 }
 
 #[test]
@@ -180,7 +180,7 @@ fn points_scored_in_the_two_rolls_after_a_strike_are_counted_twice_as_a_bonus()
         let _ = game.roll(0);
     }
 
-    assert_eq!(game.score().unwrap(), 26);
+    assert_eq!(game.score(), Ok(26));
 }
 
 #[test]
@@ -198,7 +198,7 @@ fn consecutive_strikes_each_get_the_two_roll_bonus() {
         let _ = game.roll(0);
     }
 
-    assert_eq!(game.score().unwrap(), 81);
+    assert_eq!(game.score(), Ok(81));
 }
 
 #[test]
@@ -214,7 +214,7 @@ fn a_strike_in_the_last_frame_earns_a_two_roll_bonus_that_is_counted_once() {
     let _ = game.roll(7);
     let _ = game.roll(1);
 
-    assert_eq!(game.score().unwrap(), 18);
+    assert_eq!(game.score(), Ok(18));
 }
 
 #[test]
@@ -230,7 +230,7 @@ fn a_spare_with_the_two_roll_bonus_does_not_get_a_bonus_roll() {
     let _ = game.roll(7);
     let _ = game.roll(3);
 
-    assert_eq!(game.score().unwrap(), 20);
+    assert_eq!(game.score(), Ok(20));
 }
 
 #[test]
@@ -246,7 +246,7 @@ fn strikes_with_the_two_roll_bonus_do_not_get_a_bonus_roll() {
     let _ = game.roll(10);
     let _ = game.roll(10);
 
-    assert_eq!(game.score().unwrap(), 30);
+    assert_eq!(game.score(), Ok(30));
 }
 
 #[test]
@@ -262,7 +262,7 @@ fn a_strike_with_the_one_roll_bonus_after_a_spare_in_the_last_frame_does_not_get
     let _ = game.roll(3);
     let _ = game.roll(10);
 
-    assert_eq!(game.score().unwrap(), 20);
+    assert_eq!(game.score(), Ok(20));
 }
 
 #[test]
@@ -274,7 +274,7 @@ fn all_strikes_is_a_perfect_score_of_300() {
         let _ = game.roll(10);
     }
 
-    assert_eq!(game.score().unwrap(), 300);
+    assert_eq!(game.score(), Ok(300));
 }
 
 #[test]

exercises/circular-buffer/tests/circular-buffer.rs

@@ -16,7 +16,7 @@ mod tests {
     fn write_and_read_back_item() {
         let mut buffer = CircularBuffer::new(1);
         buffer.write('1');
-        assert_eq!('1', buffer.read().unwrap());
+        assert_eq!(Ok('1'), buffer.read());
         assert_eq!(Err(Error::EmptyBuffer), buffer.read());
     }
 
@@ -26,8 +26,8 @@ mod tests {
         let mut buffer = CircularBuffer::new(2);
         buffer.write('1');
         buffer.write('2');
-        assert_eq!('1', buffer.read().unwrap());
-        assert_eq!('2', buffer.read().unwrap());
+        assert_eq!(Ok('1'), buffer.read());
+        assert_eq!(Ok('2'), buffer.read());
         assert_eq!(Err(Error::EmptyBuffer), buffer.read());
     }
 
@@ -36,9 +36,9 @@ mod tests {
     fn alternate_write_and_read() {
         let mut buffer = CircularBuffer::new(2);
         buffer.write('1');
-        assert_eq!('1', buffer.read().unwrap());
+        assert_eq!(Ok('1'), buffer.read());
         buffer.write('2');
-        assert_eq!('2', buffer.read().unwrap());
+        assert_eq!(Ok('2'), buffer.read());
     }
 
     #[test]
@@ -52,9 +52,9 @@ mod tests {
         assert_eq!(Err(Error::EmptyBuffer), buffer.read());
         buffer.write('1');
         buffer.write('2');
-        assert_eq!('1', buffer.read().unwrap());
+        assert_eq!(Ok('1'), buffer.read());
         buffer.write('3');
-        assert_eq!('2', buffer.read().unwrap());
+        assert_eq!(Ok('2'), buffer.read());
     }
 
     #[test]
@@ -72,8 +72,8 @@ mod tests {
         let mut buffer = CircularBuffer::new(2);
         buffer.write('1');
         buffer.overwrite('2');
-        assert_eq!('1', buffer.read().unwrap());
-        assert_eq!('2', buffer.read().unwrap());
+        assert_eq!(Ok('1'), buffer.read());
+        assert_eq!(Ok('2'), buffer.read());
         assert_eq!(Err(Error::EmptyBuffer), buffer.read());
     }
 
@@ -84,8 +84,8 @@ mod tests {
         buffer.write('1');
         buffer.write('2');
         buffer.overwrite('A');
-        assert_eq!('2', buffer.read().unwrap());
-        assert_eq!('A', buffer.read().unwrap());
+        assert_eq!(Ok('2'), buffer.read());
+        assert_eq!(Ok('A'), buffer.read());
     }
 
     #[test]
@@ -94,10 +94,10 @@ mod tests {
         let mut buffer = CircularBuffer::new(2);
         buffer.write(1);
         buffer.write(2);
-        assert_eq!(1,buffer.read().unwrap());
+        assert_eq!(Ok(1), buffer.read());
         buffer.write(-1);
-        assert_eq!(2,buffer.read().unwrap());
-        assert_eq!(-1,buffer.read().unwrap());
+        assert_eq!(Ok(2), buffer.read());
+        assert_eq!(Ok(-1), buffer.read());
         assert_eq!(Err(Error::EmptyBuffer), buffer.read());
     }
 
@@ -107,7 +107,7 @@ mod tests {
         let mut buffer = CircularBuffer::new(2);
         buffer.write("".to_string());
         buffer.write("Testing".to_string());
-        assert_eq!(0,buffer.read().unwrap().len());
-        assert_eq!("Testing",buffer.read().unwrap());
+        assert_eq!(0, buffer.read().unwrap().len());
+        assert_eq!(Ok("Testing".to_string()), buffer.read());
     }
 }