trackler 2.2.1.50 → 2.2.1.51

data/tracks/rust/.travis.yml

@@ -2,6 +2,7 @@
 language: rust
 script:
 - "./_test/check-exercises.sh"
+- "sh ./_test/count-ignores.sh"
 - "./bin/fetch-configlet"
 - "./bin/configlet lint ."
 sudo: false

data/tracks/rust/_test/count-ignores.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+
+dir=$(dirname $(dirname $0))
+exitcode=0
+
+for t in $dir/exercises/*/tests/*.rs; do
+  tests=$(grep "^\s*\#\[test\]" $t | wc -l | tr -d '[:space:]')
+  ignores=$(grep "^\s*\#\[ignore\]" $t | wc -l | tr -d '[:space:]')
+  want_ignores=$(expr $tests - 1)
+  if [ "$ignores" != "$want_ignores" ]; then
+    echo "\033[1;31m$t: Has $tests tests and $ignores ignores (should be $want_ignores)\033[0m"
+    exitcode=1
+  fi
+done
+
+exit $exitcode

data/tracks/rust/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]

data/tracks/rust/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]

data/tracks/rust/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]

data/tracks/rust/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());
     }
 }

data/tracks/rust/exercises/hamming/tests/hamming.rs

@@ -2,31 +2,31 @@ extern crate hamming;
 
 #[test]
 fn test_no_difference_between_empty_strands() {
-    assert_eq!(hamming::hamming_distance("", "").unwrap(), 0);
+    assert_eq!(hamming::hamming_distance("", ""), Ok(0));
 }
 
 #[test]
 #[ignore]
 fn test_no_difference_between_identical_strands() {
-    assert_eq!(hamming::hamming_distance("GGACTGA", "GGACTGA").unwrap(), 0);
+    assert_eq!(hamming::hamming_distance("GGACTGA", "GGACTGA"), Ok(0));
 }
 
 #[test]
 #[ignore]
 fn test_complete_hamming_distance_in_small_strand() {
-    assert_eq!(hamming::hamming_distance("ACT", "GGA").unwrap(), 3);
+    assert_eq!(hamming::hamming_distance("ACT", "GGA"), Ok(3));
 }
 
 #[test]
 #[ignore]
 fn test_small_hamming_distance_in_the_middle_somewhere() {
-    assert_eq!(hamming::hamming_distance("GGACG", "GGTCG").unwrap(), 1);
+    assert_eq!(hamming::hamming_distance("GGACG", "GGTCG"), Ok(1));
 }
 
 #[test]
 #[ignore]
 fn test_larger_distance() {
-    assert_eq!(hamming::hamming_distance("ACCAGGG", "ACTATGG").unwrap(), 2);
+    assert_eq!(hamming::hamming_distance("ACCAGGG", "ACTATGG"), Ok(2));
 }
 
 #[test]

data/tracks/rust/exercises/largest-series-product/tests/largest-series-product.rs

@@ -10,56 +10,56 @@ fn return_is_a_result() {
 #[test]
 #[ignore]
 fn find_the_largest_product_when_span_equals_length() {
-    assert_eq!(18, lsp("29", 2).unwrap());
+    assert_eq!(Ok(18), lsp("29", 2));
 }
 
 #[test]
 #[ignore]
 fn find_the_largest_product_of_two_with_numbers_in_order() {
-    assert_eq!(72, lsp("0123456789", 2).unwrap());
+    assert_eq!(Ok(72), lsp("0123456789", 2));
 }
 
 #[test]
 #[ignore]
 fn find_the_largest_product_of_two_with_numbers_not_in_order() {
-    assert_eq!(48, lsp("576802143", 2).unwrap());
+    assert_eq!(Ok(48), lsp("576802143", 2));
 }
 
 #[test]
 #[ignore]
 fn find_the_largest_product_of_three_with_numbers_in_order() {
-    assert_eq!(504, lsp("0123456789", 3).unwrap());
+    assert_eq!(Ok(504), lsp("0123456789", 3));
 }
 
 #[test]
 #[ignore]
 fn find_the_largest_product_of_three_with_numbers_not_in_order() {
-    assert_eq!(270, lsp("1027839564", 3).unwrap());
+    assert_eq!(Ok(270), lsp("1027839564", 3));
 }
 
 #[test]
 #[ignore]
 fn find_the_largest_product_of_five_with_numbers_in_order() {
-    assert_eq!(15120, lsp("0123456789", 5).unwrap());
+    assert_eq!(Ok(15120), lsp("0123456789", 5));
 }
 
 #[test]
 #[ignore]
 fn span_of_six_in_a_large_number() {
-    assert_eq!(23520,
-               lsp("73167176531330624919225119674426574742355349194934", 6).unwrap());
+    assert_eq!(Ok(23520),
+               lsp("73167176531330624919225119674426574742355349194934", 6));
 }
 
 #[test]
 #[ignore]
 fn returns_zero_if_number_is_zeros() {
-    assert_eq!(0, lsp("0000", 2).unwrap());
+    assert_eq!(Ok(0), lsp("0000", 2));
 }
 
 #[test]
 #[ignore]
 fn returns_zero_if_all_products_are_zero() {
-    assert_eq!(0, lsp("99099", 3).unwrap());
+    assert_eq!(Ok(0), lsp("99099", 3));
 }
 
 #[test]
@@ -83,13 +83,13 @@ fn a_span_is_longer_than_number_is_an_error() {
 #[test]
 #[ignore]
 fn an_empty_string_and_no_span_returns_one() {
-    assert_eq!(1, lsp("", 0).unwrap());
+    assert_eq!(Ok(1), lsp("", 0));
 }
 
 #[test]
 #[ignore]
 fn a_non_empty_string_and_no_span_returns_one() {
-    assert_eq!(1, lsp("123", 0).unwrap());
+    assert_eq!(Ok(1), lsp("123", 0));
 }
 
 #[test]