trackler 2.2.1.171 → 2.2.1.172

data/tracks/rust/exercises/diffie-hellman/tests/diffie-hellman.rs

@@ -4,8 +4,9 @@ use diffie_hellman::*;
 
 #[test]
 fn test_private_key_in_range_key() {
-    let primes: Vec<u64> = vec![5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 773, 967,
-                                3461, 6131];
+    let primes: Vec<u64> = vec![
+        5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 773, 967, 3461, 6131,
+    ];
     let private_keys: Vec<u64> = primes.iter().map(|x| private_key(*x)).collect();
 
     for i in 0..primes.len() {
@@ -25,7 +26,6 @@ fn test_public_key_correct() {
     assert_eq!(public_key(p, g, private_key), expected);
 }
 
-
 #[test]
 #[ignore]
 fn test_secret_key_correct() {

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

@@ -27,11 +27,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.
@@ -45,6 +65,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/dominoes/src/lib.rs

@@ -0,0 +1 @@
+

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

@@ -6,7 +6,7 @@ type Domino = (usize, usize);
 
 #[derive(Debug)]
 enum CheckResult {
-    GotInvalid,             // chain returned None
+    GotInvalid, // chain returned None
     Correct,
     ChainingFailure(Vec<Domino>), // failure to match the dots at the right side of one domino with
     // the one on the left side of the next
@@ -17,19 +17,19 @@ enum CheckResult {
 fn normalize(d: &Domino) -> Domino {
     match d {
         &(m, n) if m > n => (n, m),
-        &(m, n) => (m, n)
+        &(m, n) => (m, n),
     }
 }
 
 fn check(input: &[Domino]) -> CheckResult {
     let output = match dominoes::chain(input) {
         None => return GotInvalid,
-        Some(o) => o
+        Some(o) => o,
     };
     if input.len() != output.len() {
         return LengthMismatch(output);
-    }
-    else if input.len() == 0 { // and thus output.len() == 0
+    } else if input.len() == 0 {
+        // and thus output.len() == 0
         return Correct;
     }
 
@@ -51,15 +51,14 @@ fn check(input: &[Domino]) -> CheckResult {
         for &(first, second) in iter {
             if n != first {
                 fail = true;
-                break
+                break;
             }
             n = second
         }
     }
     if fail {
         ChainingFailure(output)
-    }
-    else {
+    } else {
         Correct
     }
 }
@@ -68,16 +67,23 @@ fn assert_correct(input: &[Domino]) {
     match check(&input) {
         Correct => (),
         GotInvalid => panic!("Unexpectedly got invalid on input {:?}", input),
-        ChainingFailure(output) => panic!("Chaining failure for input {:?}, output {:?}", input, output),
-        LengthMismatch(output) => panic!("Length mismatch for input {:?}, output {:?}", input, output),
-        DominoMismatch(output) => panic!("Domino mismatch for input {:?}, output {:?}", input, output),
+        ChainingFailure(output) => panic!(
+            "Chaining failure for input {:?}, output {:?}",
+            input, output
+        ),
+        LengthMismatch(output) => {
+            panic!("Length mismatch for input {:?}, output {:?}", input, output)
+        }
+        DominoMismatch(output) => {
+            panic!("Domino mismatch for input {:?}, output {:?}", input, output)
+        }
     }
 }
 
 #[test]
 fn empty_input_empty_output() {
     let input = &[];
-    assert_eq!(dominoes::chain(input), Some(vec!()));
+    assert_eq!(dominoes::chain(input), Some(vec![]));
 }
 
 #[test]
@@ -153,6 +159,16 @@ fn separate_loops() {
 #[test]
 #[ignore]
 fn nine_elements() {
-    let input = &[(1, 2), (5, 3), (3, 1), (1, 2), (2, 4), (1, 6), (2, 3), (3, 4), (5, 6)];
+    let input = &[
+        (1, 2),
+        (5, 3),
+        (3, 1),
+        (1, 2),
+        (2, 4),
+        (1, 6),
+        (2, 3),
+        (3, 4),
+        (5, 6),
+    ];
     assert_correct(input);
 }

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

@@ -59,11 +59,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.
@@ -77,6 +97,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/etl/src/lib.rs

@@ -0,0 +1 @@
+

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

@@ -4,13 +4,9 @@ use std::collections::BTreeMap;
 
 #[test]
 fn test_transform_one_value() {
-    let input = input_from(&[
-        (1, vec!('A')),
-    ]);
+    let input = input_from(&[(1, vec!['A'])]);
 
-    let expected = expected_from(&[
-        ('a', 1),
-    ]);
+    let expected = expected_from(&[('a', 1)]);
 
     assert_eq!(expected, etl::transform(&input));
 }
@@ -18,13 +14,9 @@ fn test_transform_one_value() {
 #[test]
 #[ignore]
 fn test_transform_more_values() {
-    let input = input_from(&[
-        (1, vec!('A', 'E', 'I', 'O', 'U')),
-    ]);
+    let input = input_from(&[(1, vec!['A', 'E', 'I', 'O', 'U'])]);
 
-    let expected = expected_from(&[
-        ('a', 1), ('e', 1), ('i', 1), ('o', 1), ('u', 1),
-    ]);
+    let expected = expected_from(&[('a', 1), ('e', 1), ('i', 1), ('o', 1), ('u', 1)]);
 
     assert_eq!(expected, etl::transform(&input));
 }
@@ -32,15 +24,9 @@ fn test_transform_more_values() {
 #[test]
 #[ignore]
 fn test_more_keys() {
-    let input = input_from(&[
-        (1, vec!('A', 'E')),
-        (2, vec!('D', 'G')),
-    ]);
+    let input = input_from(&[(1, vec!['A', 'E']), (2, vec!['D', 'G'])]);
 
-    let expected = expected_from(&[
-        ('a', 1), ('e', 1),
-        ('d',  2), ('g', 2),
-    ]);
+    let expected = expected_from(&[('a', 1), ('e', 1), ('d', 2), ('g', 2)]);
 
     assert_eq!(expected, etl::transform(&input));
 }
@@ -49,23 +35,42 @@ fn test_more_keys() {
 #[ignore]
 fn test_full_dataset() {
     let input = input_from(&[
-        (1,  vec!('A', 'E', 'I', 'O', 'U', 'L', 'N', 'R', 'S', 'T')),
-        (2,  vec!('D', 'G')),
-        (3,  vec!('B', 'C', 'M', 'P')),
-        (4,  vec!('F', 'H', 'V', 'W', 'Y')),
-        (5,  vec!('K')),
-        (8,  vec!('J', 'X')),
-        (10, vec!('Q', 'Z')),
+        (1, vec!['A', 'E', 'I', 'O', 'U', 'L', 'N', 'R', 'S', 'T']),
+        (2, vec!['D', 'G']),
+        (3, vec!['B', 'C', 'M', 'P']),
+        (4, vec!['F', 'H', 'V', 'W', 'Y']),
+        (5, vec!['K']),
+        (8, vec!['J', 'X']),
+        (10, vec!['Q', 'Z']),
     ]);
 
     let expected = expected_from(&[
-        ('a',  1), ('b',  3), ('c',  3), ('d',  2),
-        ('e',  1), ('f',  4), ('g',  2), ('h',  4),
-        ('i',  1), ('j',  8), ('k',  5), ('l',  1),
-        ('m',  3), ('n',  1), ('o',  1), ('p',  3),
-        ('q', 10), ('r',  1), ('s',  1), ('t',  1),
-        ('u',  1), ('v',  4), ('w',  4), ('x',  8),
-        ('y',  4), ('z', 10),
+        ('a', 1),
+        ('b', 3),
+        ('c', 3),
+        ('d', 2),
+        ('e', 1),
+        ('f', 4),
+        ('g', 2),
+        ('h', 4),
+        ('i', 1),
+        ('j', 8),
+        ('k', 5),
+        ('l', 1),
+        ('m', 3),
+        ('n', 1),
+        ('o', 1),
+        ('p', 3),
+        ('q', 10),
+        ('r', 1),
+        ('s', 1),
+        ('t', 1),
+        ('u', 1),
+        ('v', 4),
+        ('w', 4),
+        ('x', 8),
+        ('y', 4),
+        ('z', 10),
     ]);
 
     assert_eq!(expected, etl::transform(&input));

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

@@ -38,11 +38,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.
@@ -56,6 +76,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/forth/tests/forth.rs

@@ -1,6 +1,6 @@
 extern crate forth;
 
-use forth::{Forth, Error, Value};
+use forth::{Error, Forth, Value};
 
 #[test]
 fn no_input_no_stack() {
@@ -44,50 +44,35 @@ fn basic_arithmetic_2() {
 #[ignore]
 fn addition_error() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::StackUnderflow),
-        f.eval("+")
-    );
+    assert_eq!(Err(Error::StackUnderflow), f.eval("+"));
 }
 
 #[test]
 #[ignore]
 fn subtraction_error() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::StackUnderflow),
-        f.eval("-")
-    );
+    assert_eq!(Err(Error::StackUnderflow), f.eval("-"));
 }
 
 #[test]
 #[ignore]
 fn multiplication_error() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::StackUnderflow),
-        f.eval("*")
-    );
+    assert_eq!(Err(Error::StackUnderflow), f.eval("*"));
 }
 
 #[test]
 #[ignore]
 fn division_error() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::StackUnderflow),
-        f.eval("/")
-    );
+    assert_eq!(Err(Error::StackUnderflow), f.eval("/"));
 }
 
 #[test]
 #[ignore]
 fn division_by_zero() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::DivisionByZero),
-        f.eval("4 2 2 - /")
-    );
+    assert_eq!(Err(Error::DivisionByZero), f.eval("4 2 2 - /"));
 }
 
 #[test]
@@ -110,10 +95,7 @@ fn dup_case_insensitive() {
 #[ignore]
 fn dup_error() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::StackUnderflow),
-        f.eval("dup")
-    );
+    assert_eq!(Err(Error::StackUnderflow), f.eval("dup"));
 }
 
 #[test]
@@ -136,10 +118,7 @@ fn drop_with_two() {
 #[ignore]
 fn drop_error() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::StackUnderflow),
-        f.eval("drop")
-    );
+    assert_eq!(Err(Error::StackUnderflow), f.eval("drop"));
 }
 
 #[test]
@@ -162,14 +141,8 @@ fn swap_with_three() {
 #[ignore]
 fn swap_error() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::StackUnderflow),
-        f.eval("1 swap")
-    );
-    assert_eq!(
-        Err(Error::StackUnderflow),
-        f.eval("swap")
-    );
+    assert_eq!(Err(Error::StackUnderflow), f.eval("1 swap"));
+    assert_eq!(Err(Error::StackUnderflow), f.eval("swap"));
 }
 
 #[test]
@@ -192,14 +165,8 @@ fn over_with_three() {
 #[ignore]
 fn over_error() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::StackUnderflow),
-        f.eval("1 over")
-    );
-    assert_eq!(
-        Err(Error::StackUnderflow),
-        f.eval("over")
-    );
+    assert_eq!(Err(Error::StackUnderflow), f.eval("1 over"));
+    assert_eq!(Err(Error::StackUnderflow), f.eval("over"));
 }
 
 #[test]
@@ -242,36 +209,21 @@ fn defining_words_with_odd_characters() {
 #[ignore]
 fn defining_a_number() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::InvalidWord),
-        f.eval(": 1 2 ;")
-    );
+    assert_eq!(Err(Error::InvalidWord), f.eval(": 1 2 ;"));
 }
 
 #[test]
 #[ignore]
 fn malformed_word_definition() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::InvalidWord),
-        f.eval(":")
-    );
-    assert_eq!(
-        Err(Error::InvalidWord),
-        f.eval(": foo")
-    );
-    assert_eq!(
-        Err(Error::InvalidWord),
-        f.eval(": foo 1")
-    );
+    assert_eq!(Err(Error::InvalidWord), f.eval(":"));
+    assert_eq!(Err(Error::InvalidWord), f.eval(": foo"));
+    assert_eq!(Err(Error::InvalidWord), f.eval(": foo 1"));
 }
 
 #[test]
 #[ignore]
 fn calling_non_existing_word() {
     let mut f = Forth::new();
-    assert_eq!(
-        Err(Error::UnknownWord),
-        f.eval("1 foo")
-    );
+    assert_eq!(Err(Error::UnknownWord), f.eval("1 foo"));
 }