trackler 2.2.1.171 → 2.2.1.172

data/tracks/rust/exercises/simple-cipher/README.md

@@ -94,11 +94,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.
@@ -112,6 +132,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/simple-cipher/src/lib.rs

@@ -1,11 +1,14 @@
 pub fn encode(key: &str, s: &str) -> Option<String> {
-    unimplemented!("Use {} to encode {} using shift cipher",key,s)
+    unimplemented!("Use {} to encode {} using shift cipher", key, s)
 }
 
 pub fn decode(key: &str, s: &str) -> Option<String> {
-    unimplemented!("Use {} to decode {} using shift cipher",key,s)
+    unimplemented!("Use {} to decode {} using shift cipher", key, s)
 }
 
 pub fn encode_random(s: &str) -> (String, String) {
-    unimplemented!("Generate random key with only a-z chars and encode {}. Return tuple (key, encoded s)",s)
+    unimplemented!(
+        "Generate random key with only a-z chars and encode {}. Return tuple (key, encoded s)",
+        s
+    )
 }

data/tracks/rust/exercises/simple-cipher/tests/simple-cipher.rs

@@ -5,7 +5,6 @@ use std::collections::HashSet;
 const PLAIN_TEXT: &str = "thisismysecret";
 const KEY: &str = "abcdefghij";
 
-
 #[test]
 fn cipher_can_encode_with_given_key() {
     assert_eq!(encode(KEY, "aaaaaaaaaa"), Some(KEY.to_string()));

data/tracks/rust/exercises/simple-linked-list/README.md

@@ -69,11 +69,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.
@@ -87,6 +107,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/simple-linked-list/src/lib.rs

@@ -32,7 +32,6 @@ impl<T: Clone> SimpleLinkedList<T> {
     }
 }
 
-
 impl<'a, T: Clone> From<&'a [T]> for SimpleLinkedList<T> {
     fn from(_item: &[T]) -> Self {
         unimplemented!()

data/tracks/rust/exercises/simple-linked-list/tests/simple-linked-list.rs

@@ -76,7 +76,6 @@ fn test_reverse() {
     assert_eq!(rev_list.pop(), None);
 }
 
-
 #[test]
 #[ignore]
 fn test_into_vector() {

data/tracks/rust/exercises/space-age/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
 
 ## Source
 

data/tracks/rust/exercises/space-age/tests/space-age.rs

@@ -6,10 +6,10 @@ fn assert_in_delta(expected: f64, actual: f64) {
     let diff: f64 = (expected - actual).abs();
     let delta: f64 = 0.01;
     if diff > delta {
-        panic!("Your result of {} should be within {} of the expected result {}",
-               actual,
-               delta,
-               expected)
+        panic!(
+            "Your result of {} should be within {} of the expected result {}",
+            actual, delta, expected
+        )
     }
 }
 

data/tracks/rust/exercises/spiral-matrix/README.md

@@ -36,11 +36,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.
@@ -54,6 +74,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/sublist/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
 
 ## 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/sublist/src/lib.rs

@@ -0,0 +1 @@
+

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

@@ -6,37 +6,25 @@ use sublist::{sublist, Comparison};
 fn empty_equals_empty() {
     let v: &[u32] = &[];
 
-    assert_eq!(
-        Comparison::Equal,
-        sublist(&v, &v)
-    );
+    assert_eq!(Comparison::Equal, sublist(&v, &v));
 }
 
 #[test]
 #[ignore]
 fn test_empty_is_a_sublist_of_anything() {
-    assert_eq!(
-        Comparison::Sublist,
-        sublist(&[], &['a', 's', 'd', 'f'])
-    );
+    assert_eq!(Comparison::Sublist, sublist(&[], &['a', 's', 'd', 'f']));
 }
 
 #[test]
 #[ignore]
 fn test_anything_is_a_superlist_of_empty() {
-    assert_eq!(
-        Comparison::Superlist,
-        sublist(&['a', 's', 'd', 'f'], &[])
-    );
+    assert_eq!(Comparison::Superlist, sublist(&['a', 's', 'd', 'f'], &[]));
 }
 
 #[test]
 #[ignore]
 fn test_1_is_not_2() {
-    assert_eq!(
-        Comparison::Unequal,
-        sublist(&[1], &[2])
-    );
+    assert_eq!(Comparison::Unequal, sublist(&[1], &[2]));
 }
 
 #[test]
@@ -46,46 +34,31 @@ fn test_compare_larger_equal_lists() {
 
     let v: Vec<char> = repeat('x').take(1000).collect();
 
-    assert_eq!(
-        Comparison::Equal,
-        sublist(&v, &v)
-    );
+    assert_eq!(Comparison::Equal, sublist(&v, &v));
 }
 
 #[test]
 #[ignore]
 fn test_sublist_at_start() {
-    assert_eq!(
-        Comparison::Sublist,
-        sublist(&[1, 2, 3], &[1, 2, 3, 4, 5])
-    );
+    assert_eq!(Comparison::Sublist, sublist(&[1, 2, 3], &[1, 2, 3, 4, 5]));
 }
 
 #[test]
 #[ignore]
 fn sublist_in_middle() {
-    assert_eq!(
-        Comparison::Sublist,
-        sublist(&[4, 3, 2], &[5, 4, 3, 2, 1])
-    );
+    assert_eq!(Comparison::Sublist, sublist(&[4, 3, 2], &[5, 4, 3, 2, 1]));
 }
 
 #[test]
 #[ignore]
 fn sublist_at_end() {
-    assert_eq!(
-        Comparison::Sublist,
-        sublist(&[3, 4, 5], &[1, 2, 3, 4, 5])
-    );
+    assert_eq!(Comparison::Sublist, sublist(&[3, 4, 5], &[1, 2, 3, 4, 5]));
 }
 
 #[test]
 #[ignore]
 fn partially_matching_sublist_at_start() {
-    assert_eq!(
-        Comparison::Sublist,
-        sublist(&[1, 1, 2], &[1, 1, 1, 2])
-    );
+    assert_eq!(Comparison::Sublist, sublist(&[1, 1, 2], &[1, 1, 1, 2]));
 }
 
 #[test]
@@ -93,10 +66,7 @@ fn partially_matching_sublist_at_start() {
 fn sublist_early_in_huge_list() {
     let huge: Vec<u32> = (1..1000000).collect();
 
-    assert_eq!(
-        Comparison::Sublist,
-        sublist(&[3, 4, 5], &huge)
-    );
+    assert_eq!(Comparison::Sublist, sublist(&[3, 4, 5], &huge));
 }
 
 #[test]
@@ -105,37 +75,25 @@ fn huge_sublist_not_in_huge_list() {
     let v1: Vec<u64> = (10..1000001).collect();
     let v2: Vec<u64> = (1..1000000).collect();
 
-    assert_eq!(
-        Comparison::Unequal,
-        sublist(&v1, &v2)
-    );
+    assert_eq!(Comparison::Unequal, sublist(&v1, &v2));
 }
 
 #[test]
 #[ignore]
 fn superlist_at_start() {
-    assert_eq!(
-        Comparison::Superlist,
-        sublist(&[1, 2, 3, 4, 5], &[1, 2, 3])
-    );
+    assert_eq!(Comparison::Superlist, sublist(&[1, 2, 3, 4, 5], &[1, 2, 3]));
 }
 
 #[test]
 #[ignore]
 fn superlist_in_middle() {
-    assert_eq!(
-        Comparison::Superlist,
-        sublist(&[5, 4, 3, 2, 1], &[4, 3, 2])
-    );
+    assert_eq!(Comparison::Superlist, sublist(&[5, 4, 3, 2, 1], &[4, 3, 2]));
 }
 
 #[test]
 #[ignore]
 fn superlist_at_end() {
-    assert_eq!(
-        Comparison::Superlist,
-        sublist(&[1, 2, 3, 4, 5], &[3, 4, 5])
-    );
+    assert_eq!(Comparison::Superlist, sublist(&[1, 2, 3, 4, 5], &[3, 4, 5]));
 }
 
 #[test]
@@ -143,10 +101,7 @@ fn superlist_at_end() {
 fn superlist_early_in_huge_list() {
     let huge: Vec<u32> = (1..1000000).collect();
 
-    assert_eq!(
-        Comparison::Superlist,
-        sublist(&huge, &[3, 4, 5])
-    );
+    assert_eq!(Comparison::Superlist, sublist(&huge, &[3, 4, 5]));
 }
 
 #[test]
@@ -154,10 +109,7 @@ fn superlist_early_in_huge_list() {
 fn recurring_values_sublist() {
     assert_eq!(
         Comparison::Sublist,
-        sublist(
-            &[1, 2, 1, 2, 3],
-            &[1, 2, 3, 1, 2, 1, 2, 3, 2, 1]
-        )
+        sublist(&[1, 2, 1, 2, 3], &[1, 2, 3, 1, 2, 1, 2, 3, 2, 1])
     );
 }
 
@@ -166,9 +118,6 @@ fn recurring_values_sublist() {
 fn recurring_values_unequal() {
     assert_eq!(
         Comparison::Unequal,
-        sublist(
-            &[1, 2, 1, 2, 3],
-            &[1, 2, 3, 1, 2, 3, 2, 3, 2, 1]
-        )
+        sublist(&[1, 2, 1, 2, 3], &[1, 2, 3, 1, 2, 3, 2, 3, 2, 1])
     );
 }