trackler 2.2.1.171 → 2.2.1.172

data/tracks/rust/exercises/all-your-base/src/lib.rs

@@ -37,5 +37,10 @@ pub enum Error {
 ///     process input with leading 0 digits.
 ///
 pub fn convert(number: &[u32], from_base: u32, to_base: u32) -> Result<Vec<u32>, Error> {
-    unimplemented!("Convert {:?} from base {} to base {}", number, from_base, to_base)
+    unimplemented!(
+        "Convert {:?} from base {} to base {}",
+        number,
+        from_base,
+        to_base
+    )
 }

data/tracks/rust/exercises/all-your-base/tests/all-your-base.rs

@@ -6,8 +6,10 @@ fn single_bit_one_to_decimal() {
     let input_digits = &[1];
     let output_base = 10;
     let output_digits = vec![1];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -17,8 +19,10 @@ fn binary_to_single_decimal() {
     let input_digits = &[1, 0, 1];
     let output_base = 10;
     let output_digits = vec![5];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -28,8 +32,10 @@ fn single_decimal_to_binary() {
     let input_digits = &[5];
     let output_base = 2;
     let output_digits = vec![1, 0, 1];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -39,8 +45,10 @@ fn binary_to_multiple_decimal() {
     let input_digits = &[1, 0, 1, 0, 1, 0];
     let output_base = 10;
     let output_digits = vec![4, 2];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -50,8 +58,10 @@ fn decimal_to_binary() {
     let input_digits = &[4, 2];
     let output_base = 2;
     let output_digits = vec![1, 0, 1, 0, 1, 0];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -61,8 +71,10 @@ fn trinary_to_hexadecimal() {
     let input_digits = &[1, 1, 2, 0];
     let output_base = 16;
     let output_digits = vec![2, 10];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -72,8 +84,10 @@ fn hexadecimal_to_trinary() {
     let input_digits = &[2, 10];
     let output_base = 3;
     let output_digits = vec![1, 1, 2, 0];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -83,8 +97,10 @@ fn fifteen_bit_integer() {
     let input_digits = &[3, 46, 60];
     let output_base = 73;
     let output_digits = vec![6, 10, 45];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -94,8 +110,10 @@ fn empty_list() {
     let input_digits = &[];
     let output_base = 10;
     let output_digits = vec![];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -105,8 +123,10 @@ fn single_zero() {
     let input_digits = &[0];
     let output_base = 2;
     let output_digits = vec![];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -116,8 +136,10 @@ fn multiple_zeros() {
     let input_digits = &[0, 0, 0];
     let output_base = 2;
     let output_digits = vec![];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -127,8 +149,10 @@ fn leading_zeros() {
     let input_digits = &[0, 6, 0];
     let output_base = 10;
     let output_digits = vec![4, 2];
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Ok(output_digits));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Ok(output_digits)
+    );
 }
 
 #[test]
@@ -137,8 +161,10 @@ fn invalid_positive_digit() {
     let input_base = 2;
     let input_digits = &[1, 2, 1, 0, 1, 0];
     let output_base = 10;
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Err(ayb::Error::InvalidDigit(2)));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Err(ayb::Error::InvalidDigit(2))
+    );
 }
 
 #[test]
@@ -147,8 +173,10 @@ fn input_base_is_one() {
     let input_base = 1;
     let input_digits = &[];
     let output_base = 10;
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Err(ayb::Error::InvalidInputBase));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Err(ayb::Error::InvalidInputBase)
+    );
 }
 
 #[test]
@@ -157,8 +185,10 @@ fn output_base_is_one() {
     let input_base = 2;
     let input_digits = &[1, 0, 1, 0, 1, 0];
     let output_base = 1;
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Err(ayb::Error::InvalidOutputBase));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Err(ayb::Error::InvalidOutputBase)
+    );
 }
 
 #[test]
@@ -167,8 +197,10 @@ fn input_base_is_zero() {
     let input_base = 0;
     let input_digits = &[];
     let output_base = 10;
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Err(ayb::Error::InvalidInputBase));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Err(ayb::Error::InvalidInputBase)
+    );
 }
 
 #[test]
@@ -177,6 +209,8 @@ fn output_base_is_zero() {
     let input_base = 10;
     let input_digits = &[7];
     let output_base = 0;
-    assert_eq!(ayb::convert(input_digits, input_base, output_base),
-               Err(ayb::Error::InvalidOutputBase));
+    assert_eq!(
+        ayb::convert(input_digits, input_base, output_base),
+        Err(ayb::Error::InvalidOutputBase)
+    );
 }

data/tracks/rust/exercises/allergies/README.md

@@ -42,11 +42,31 @@ Execute the tests with:
 $ cargo test
 ```
 
-All but the first test have been ignored.  After you get the first test to
-pass, remove the ignore flag (`#[ignore]`) from the next test and get the tests
-to pass again.  The test file is located in the `tests` directory.   You can
-also remove the ignore flag from all the tests to get them to run all at once
-if you wish.
+All but the first test have been ignored. After you get the first test to
+pass, open the tests source file wich is located in the `tests` directory
+and remove the `#[ignore]` flag from the next test and get the tests to pass
+again. Each separate test is a function with `#[test]` flag above it.
+Continue, until you pass every test. 
+
+If you wish to run all tests without editing the tests source file, use:
+
+```bash
+$ cargo test -- --ignored
+```
+
+To run a specific test, for example `some_test`, you can use:
+
+```bash
+$ cargo test some_test
+```
+
+If the specfic test is ignored use:
+
+```bash
+$ cargo test some_test -- --ignored
+```
+
+To learn more about Rust tests refer to the [online test documentation][rust-tests]
 
 Make sure to read the [Modules](https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html) chapter if you
 haven't already, it will help you with organizing your files.
@@ -60,6 +80,7 @@ If you want to know more about Exercism, take a look at the [contribution guide]
 [help-page]: http://exercism.io/languages/rust
 [modules]: https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html
 [cargo]: https://doc.rust-lang.org/book/second-edition/ch14-00-more-about-cargo.html
+[rust-tests]: https://doc.rust-lang.org/book/second-edition/ch11-02-running-tests.html
 
 ## Source
 

data/tracks/rust/exercises/allergies/src/lib.rs

@@ -0,0 +1 @@
+

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

@@ -5,16 +5,18 @@ use allergies::*;
 fn compare_allergy_vectors(expected: &[Allergen], actual: &[Allergen]) {
     for element in expected {
         if !actual.contains(element) {
-            panic!("Allergen missing\n  {:?} should be in {:?}",
-                   element,
-                   actual);
+            panic!(
+                "Allergen missing\n  {:?} should be in {:?}",
+                element, actual
+            );
         }
     }
 
     if actual.len() != expected.len() {
-        panic!("Allergy vectors are of different lengths\n  expected {:?}\n  got {:?}",
-               expected,
-               actual);
+        panic!(
+            "Allergy vectors are of different lengths\n  expected {:?}\n  got {:?}",
+            expected, actual
+        );
     }
 }
 
@@ -98,11 +100,13 @@ fn allergic_to_eggs_and_shellfish() {
 #[test]
 #[ignore]
 fn allergic_to_many_things() {
-    let expected = &[Allergen::Strawberries,
-                     Allergen::Tomatoes,
-                     Allergen::Chocolate,
-                     Allergen::Pollen,
-                     Allergen::Cats];
+    let expected = &[
+        Allergen::Strawberries,
+        Allergen::Tomatoes,
+        Allergen::Chocolate,
+        Allergen::Pollen,
+        Allergen::Cats,
+    ];
     let allergies = Allergies::new(248).allergies();
 
     compare_allergy_vectors(expected, &allergies);
@@ -111,14 +115,16 @@ fn allergic_to_many_things() {
 #[test]
 #[ignore]
 fn allergic_to_everything() {
-    let expected = &[Allergen::Eggs,
-                     Allergen::Peanuts,
-                     Allergen::Shellfish,
-                     Allergen::Strawberries,
-                     Allergen::Tomatoes,
-                     Allergen::Chocolate,
-                     Allergen::Pollen,
-                     Allergen::Cats];
+    let expected = &[
+        Allergen::Eggs,
+        Allergen::Peanuts,
+        Allergen::Shellfish,
+        Allergen::Strawberries,
+        Allergen::Tomatoes,
+        Allergen::Chocolate,
+        Allergen::Pollen,
+        Allergen::Cats,
+    ];
     let allergies = Allergies::new(255).allergies();
 
     compare_allergy_vectors(expected, &allergies);
@@ -127,13 +133,15 @@ fn allergic_to_everything() {
 #[test]
 #[ignore]
 fn scores_over_255_do_not_trigger_false_positives() {
-    let expected = &[Allergen::Eggs,
-                     Allergen::Shellfish,
-                     Allergen::Strawberries,
-                     Allergen::Tomatoes,
-                     Allergen::Chocolate,
-                     Allergen::Pollen,
-                     Allergen::Cats];
+    let expected = &[
+        Allergen::Eggs,
+        Allergen::Shellfish,
+        Allergen::Strawberries,
+        Allergen::Tomatoes,
+        Allergen::Chocolate,
+        Allergen::Pollen,
+        Allergen::Cats,
+    ];
     let allergies = Allergies::new(509).allergies();
 
     compare_allergy_vectors(expected, &allergies);

data/tracks/rust/exercises/alphametics/README.md

@@ -44,11 +44,31 @@ Execute the tests with:
 $ cargo test
 ```
 
-All but the first test have been ignored.  After you get the first test to
-pass, remove the ignore flag (`#[ignore]`) from the next test and get the tests
-to pass again.  The test file is located in the `tests` directory.   You can
-also remove the ignore flag from all the tests to get them to run all at once
-if you wish.
+All but the first test have been ignored. After you get the first test to
+pass, open the tests source file wich is located in the `tests` directory
+and remove the `#[ignore]` flag from the next test and get the tests to pass
+again. Each separate test is a function with `#[test]` flag above it.
+Continue, until you pass every test. 
+
+If you wish to run all tests without editing the tests source file, use:
+
+```bash
+$ cargo test -- --ignored
+```
+
+To run a specific test, for example `some_test`, you can use:
+
+```bash
+$ cargo test some_test
+```
+
+If the specfic test is ignored use:
+
+```bash
+$ cargo test some_test -- --ignored
+```
+
+To learn more about Rust tests refer to the [online test documentation][rust-tests]
 
 Make sure to read the [Modules](https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html) chapter if you
 haven't already, it will help you with organizing your files.
@@ -62,6 +82,7 @@ If you want to know more about Exercism, take a look at the [contribution guide]
 [help-page]: http://exercism.io/languages/rust
 [modules]: https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html
 [cargo]: https://doc.rust-lang.org/book/second-edition/ch14-00-more-about-cargo.html
+[rust-tests]: https://doc.rust-lang.org/book/second-edition/ch11-02-running-tests.html
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -35,28 +35,63 @@ fn test_puzzle_with_four_letters() {
 #[test]
 #[ignore]
 fn test_puzzle_with_six_letters() {
-    assert_alphametic_solution_eq("NO + NO + TOO == LATE",
-                &[('N', 7), ('O', 4), ('T', 9), ('L', 1), ('A', 0), ('E', 2)]);
+    assert_alphametic_solution_eq(
+        "NO + NO + TOO == LATE",
+        &[('N', 7), ('O', 4), ('T', 9), ('L', 1), ('A', 0), ('E', 2)],
+    );
 }
 
 #[test]
 #[ignore]
 fn test_puzzle_with_seven_letters() {
-    assert_alphametic_solution_eq("HE + SEES + THE == LIGHT",
-                &[('E', 4), ('G', 2), ('H', 5), ('I', 0), ('L', 1), ('S', 9), ('T', 7)]);
+    assert_alphametic_solution_eq(
+        "HE + SEES + THE == LIGHT",
+        &[
+            ('E', 4),
+            ('G', 2),
+            ('H', 5),
+            ('I', 0),
+            ('L', 1),
+            ('S', 9),
+            ('T', 7),
+        ],
+    );
 }
 
 #[test]
 #[ignore]
 fn test_puzzle_with_eight_letters() {
-    assert_alphametic_solution_eq("SEND + MORE == MONEY",
-                &[('S', 9), ('E', 5), ('N', 6), ('D', 7), ('M', 1), ('O', 0), ('R', 8), ('Y', 2)]);
+    assert_alphametic_solution_eq(
+        "SEND + MORE == MONEY",
+        &[
+            ('S', 9),
+            ('E', 5),
+            ('N', 6),
+            ('D', 7),
+            ('M', 1),
+            ('O', 0),
+            ('R', 8),
+            ('Y', 2),
+        ],
+    );
 }
 
 #[test]
 #[ignore]
 fn test_puzzle_with_ten_letters() {
-    assert_alphametic_solution_eq("AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE",
-                &[('A', 5), ('D', 3), ('E', 4), ('F', 7), ('G', 8), ('N', 0), ('O', 2), ('R', 1),
-                  ('S', 6), ('T', 9)]);
+    assert_alphametic_solution_eq(
+        "AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE",
+        &[
+            ('A', 5),
+            ('D', 3),
+            ('E', 4),
+            ('F', 7),
+            ('G', 8),
+            ('N', 0),
+            ('O', 2),
+            ('R', 1),
+            ('S', 6),
+            ('T', 9),
+        ],
+    );
 }