trackler 2.2.1.171 → 2.2.1.172

data/tracks/rust/exercises/prime-factors/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/protein-translation/README.md

@@ -54,11 +54,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.
@@ -72,6 +92,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/protein-translation/src/lib.rs

@@ -0,0 +1 @@
+

data/tracks/rust/exercises/protein-translation/tests/proteins.rs

@@ -75,24 +75,30 @@ fn too_long_is_invalid() {
 #[ignore]
 fn test_translates_rna_strand_into_correct_protein() {
     let info = proteins::parse(make_pairs());
-    assert_eq!(info.of_rna("AUGUUUUGG"),
-               Ok(vec!["methionine", "phenylalanine", "tryptophan"]));
+    assert_eq!(
+        info.of_rna("AUGUUUUGG"),
+        Ok(vec!["methionine", "phenylalanine", "tryptophan"])
+    );
 }
 
 #[test]
 #[ignore]
 fn test_stops_translation_if_stop_codon_present() {
     let info = proteins::parse(make_pairs());
-    assert_eq!(info.of_rna("AUGUUUUAA"),
-               Ok(vec!["methionine", "phenylalanine"]));
+    assert_eq!(
+        info.of_rna("AUGUUUUAA"),
+        Ok(vec!["methionine", "phenylalanine"])
+    );
 }
 
 #[test]
 #[ignore]
 fn test_stops_translation_of_longer_strand() {
     let info = proteins::parse(make_pairs());
-    assert_eq!(info.of_rna("UGGUGUUAUUAAUGGUUU"),
-               Ok(vec!["tryptophan", "cysteine", "tyrosine"]));
+    assert_eq!(
+        info.of_rna("UGGUGUUAUUAAUGGUUU"),
+        Ok(vec!["tryptophan", "cysteine", "tyrosine"])
+    );
 }
 
 #[test]
@@ -124,13 +130,14 @@ fn make_pairs() -> Vec<(&'static str, &'static str)> {
         ("aspartic acid", vec!["GAU", "GAC"]),
         ("lysine", vec!["AAA", "AAG"]),
         ("arginine", vec!["CGU", "CGC", "CGA", "CGG", "AGA", "AGG"]),
-        ("stop codon", vec!["UAA", "UAG", "UGA"])];
+        ("stop codon", vec!["UAA", "UAG", "UGA"]),
+    ];
     let mut pairs = Vec::<(&'static str, &'static str)>::new();
     for (name, codons) in grouped.into_iter() {
         for codon in codons {
             pairs.push((codon, name));
         }
-    };
+    }
     pairs.sort_by(|&(_, a), &(_, b)| a.cmp(b));
-    return pairs
+    return pairs;
 }

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

@@ -29,11 +29,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.
@@ -47,6 +67,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/proverb/tests/proverb.rs

@@ -45,13 +45,7 @@ fn test_zero_pieces() {
 #[ignore]
 fn test_full() {
     let input = vec![
-        "nail",
-        "shoe",
-        "horse",
-        "rider",
-        "message",
-        "battle",
-        "kingdom",
+        "nail", "shoe", "horse", "rider", "message", "battle", "kingdom",
     ];
     let expected = vec![
         "For want of a nail the shoe was lost.",

data/tracks/rust/exercises/pythagorean-triplet/README.md

@@ -30,11 +30,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.
@@ -48,6 +68,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/queen-attack/README.md

@@ -39,11 +39,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.
@@ -57,6 +77,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/queen-attack/src/lib.rs

@@ -0,0 +1 @@
+

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

@@ -30,11 +30,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.
@@ -48,6 +68,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/raindrops/tests/raindrops.rs

@@ -1,76 +1,114 @@
 extern crate raindrops;
 
 #[test]
-fn test_1() { assert_eq!("1", raindrops::raindrops(1)); }
+fn test_1() {
+    assert_eq!("1", raindrops::raindrops(1));
+}
 
 #[test]
 #[ignore]
-fn test_3() { assert_eq!("Pling", raindrops::raindrops(3)); }
+fn test_3() {
+    assert_eq!("Pling", raindrops::raindrops(3));
+}
 
 #[test]
 #[ignore]
-fn test_5() { assert_eq!("Plang", raindrops::raindrops(5)); }
+fn test_5() {
+    assert_eq!("Plang", raindrops::raindrops(5));
+}
 
 #[test]
 #[ignore]
-fn test_7() { assert_eq!("Plong", raindrops::raindrops(7)); }
+fn test_7() {
+    assert_eq!("Plong", raindrops::raindrops(7));
+}
 
 #[test]
 #[ignore]
-fn test_6() { assert_eq!("Pling", raindrops::raindrops(6)); }
+fn test_6() {
+    assert_eq!("Pling", raindrops::raindrops(6));
+}
 
 #[test]
 #[ignore]
-fn test_8() { assert_eq!("8", raindrops::raindrops(8)); }
+fn test_8() {
+    assert_eq!("8", raindrops::raindrops(8));
+}
 
 #[test]
 #[ignore]
-fn test_9() { assert_eq!("Pling", raindrops::raindrops(9)); }
+fn test_9() {
+    assert_eq!("Pling", raindrops::raindrops(9));
+}
 
 #[test]
 #[ignore]
-fn test_10() { assert_eq!("Plang", raindrops::raindrops(10)); }
+fn test_10() {
+    assert_eq!("Plang", raindrops::raindrops(10));
+}
 
 #[test]
 #[ignore]
-fn test_14() { assert_eq!("Plong", raindrops::raindrops(14)); }
+fn test_14() {
+    assert_eq!("Plong", raindrops::raindrops(14));
+}
 
 #[test]
 #[ignore]
-fn test_15() { assert_eq!("PlingPlang", raindrops::raindrops(15)); }
+fn test_15() {
+    assert_eq!("PlingPlang", raindrops::raindrops(15));
+}
 
 #[test]
 #[ignore]
-fn test_21() { assert_eq!("PlingPlong", raindrops::raindrops(21)); }
+fn test_21() {
+    assert_eq!("PlingPlong", raindrops::raindrops(21));
+}
 
 #[test]
 #[ignore]
-fn test_25() { assert_eq!("Plang", raindrops::raindrops(25)); }
+fn test_25() {
+    assert_eq!("Plang", raindrops::raindrops(25));
+}
 
 #[test]
 #[ignore]
-fn test_27() { assert_eq!("Pling", raindrops::raindrops(27)); }
+fn test_27() {
+    assert_eq!("Pling", raindrops::raindrops(27));
+}
 
 #[test]
 #[ignore]
-fn test_35() { assert_eq!("PlangPlong", raindrops::raindrops(35)); }
+fn test_35() {
+    assert_eq!("PlangPlong", raindrops::raindrops(35));
+}
 
 #[test]
 #[ignore]
-fn test_49() { assert_eq!("Plong", raindrops::raindrops(49)); }
+fn test_49() {
+    assert_eq!("Plong", raindrops::raindrops(49));
+}
 
 #[test]
 #[ignore]
-fn test_52() { assert_eq!("52", raindrops::raindrops(52)); }
+fn test_52() {
+    assert_eq!("52", raindrops::raindrops(52));
+}
 
 #[test]
 #[ignore]
-fn test_105() { assert_eq!("PlingPlangPlong", raindrops::raindrops(105)); }
+fn test_105() {
+    assert_eq!("PlingPlangPlong", raindrops::raindrops(105));
+}
 
 #[test]
 #[ignore]
-fn test_3125() { assert_eq!("Plang", raindrops::raindrops(3125)); }
+fn test_3125() {
+    assert_eq!("Plang", raindrops::raindrops(3125));
+}
 
 #[test]
 #[ignore]
-fn test_12121() { assert_eq!("12121", raindrops::raindrops(12121)); }
+fn test_12121() {
+    assert_eq!("12121", raindrops::raindrops(12121));
+}