trackler 2.2.1.171 → 2.2.1.172

data/tracks/rust/exercises/sum-of-multiples/README.md

@@ -21,11 +21,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.
@@ -39,6 +59,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/sum-of-multiples/src/lib.rs

@@ -1,3 +1,7 @@
 pub fn sum_of_multiples(limit: u32, factors: &[u32]) -> u32 {
-    unimplemented!("Sum the multiples of all of {:?} which are less than {}", factors, limit)
+    unimplemented!(
+        "Sum the multiples of all of {:?} which are less than {}",
+        factors,
+        limit
+    )
 }

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

@@ -77,11 +77,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.
@@ -95,6 +115,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/tournament/src/lib.rs

@@ -0,0 +1 @@
+

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

@@ -12,9 +12,9 @@ fn just_the_header_if_no_input() {
 #[ignore]
 fn a_win_is_three_points_a_loss_is_zero_points() {
     let input = "Allegoric Alaskans;Blithering Badgers;win";
-    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string() +
-        "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n" +
-        "Blithering Badgers             |  1 |  0 |  0 |  1 |  0";
+    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string()
+        + "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n"
+        + "Blithering Badgers             |  1 |  0 |  0 |  1 |  0";
 
     assert_eq!(tournament::tally(&input), expected);
 }
@@ -23,9 +23,9 @@ fn a_win_is_three_points_a_loss_is_zero_points() {
 #[ignore]
 fn a_win_can_also_be_expressed_as_a_loss() {
     let input = "Blithering Badgers;Allegoric Alaskans;loss";
-    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string() +
-        "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n" +
-        "Blithering Badgers             |  1 |  0 |  0 |  1 |  0";
+    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string()
+        + "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n"
+        + "Blithering Badgers             |  1 |  0 |  0 |  1 |  0";
 
     assert_eq!(tournament::tally(&input), expected);
 }
@@ -34,9 +34,9 @@ fn a_win_can_also_be_expressed_as_a_loss() {
 #[ignore]
 fn a_different_team_can_win() {
     let input = "Blithering Badgers;Allegoric Alaskans;win";
-    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string() +
-        "Blithering Badgers             |  1 |  1 |  0 |  0 |  3\n" +
-        "Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0";
+    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string()
+        + "Blithering Badgers             |  1 |  1 |  0 |  0 |  3\n"
+        + "Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0";
 
     assert_eq!(tournament::tally(&input), expected);
 }
@@ -45,9 +45,9 @@ fn a_different_team_can_win() {
 #[ignore]
 fn a_draw_is_one_point_each() {
     let input = "Allegoric Alaskans;Blithering Badgers;draw";
-    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string() +
-        "Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1\n" +
-        "Blithering Badgers             |  1 |  0 |  1 |  0 |  1";
+    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string()
+        + "Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1\n"
+        + "Blithering Badgers             |  1 |  0 |  1 |  0 |  1";
 
     assert_eq!(tournament::tally(&input), expected);
 }
@@ -55,11 +55,11 @@ fn a_draw_is_one_point_each() {
 #[test]
 #[ignore]
 fn there_can_be_more_than_one_match() {
-    let input = "Allegoric Alaskans;Blithering Badgers;win\n".to_string() +
-        "Allegoric Alaskans;Blithering Badgers;win";
-    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string() +
-        "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n" +
-        "Blithering Badgers             |  2 |  0 |  0 |  2 |  0";
+    let input = "Allegoric Alaskans;Blithering Badgers;win\n".to_string()
+        + "Allegoric Alaskans;Blithering Badgers;win";
+    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string()
+        + "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n"
+        + "Blithering Badgers             |  2 |  0 |  0 |  2 |  0";
 
     assert_eq!(tournament::tally(&input), expected);
 }
@@ -67,11 +67,11 @@ fn there_can_be_more_than_one_match() {
 #[test]
 #[ignore]
 fn there_can_be_more_than_one_winner() {
-    let input = "Allegoric Alaskans;Blithering Badgers;loss\n".to_string() +
-        "Allegoric Alaskans;Blithering Badgers;win";
-    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string() +
-        "Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3\n" +
-        "Blithering Badgers             |  2 |  1 |  0 |  1 |  3";
+    let input = "Allegoric Alaskans;Blithering Badgers;loss\n".to_string()
+        + "Allegoric Alaskans;Blithering Badgers;win";
+    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string()
+        + "Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3\n"
+        + "Blithering Badgers             |  2 |  1 |  0 |  1 |  3";
 
     assert_eq!(tournament::tally(&input), expected);
 }
@@ -79,13 +79,13 @@ fn there_can_be_more_than_one_winner() {
 #[test]
 #[ignore]
 fn there_can_be_more_than_two_teams() {
-    let input = "Allegoric Alaskans;Blithering Badgers;win\n".to_string() +
-        "Blithering Badgers;Courageous Californians;win\n" +
-        "Courageous Californians;Allegoric Alaskans;loss";
-    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string() +
-        "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n" +
-        "Blithering Badgers             |  2 |  1 |  0 |  1 |  3\n" +
-        "Courageous Californians        |  2 |  0 |  0 |  2 |  0";
+    let input = "Allegoric Alaskans;Blithering Badgers;win\n".to_string()
+        + "Blithering Badgers;Courageous Californians;win\n"
+        + "Courageous Californians;Allegoric Alaskans;loss";
+    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string()
+        + "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n"
+        + "Blithering Badgers             |  2 |  1 |  0 |  1 |  3\n"
+        + "Courageous Californians        |  2 |  0 |  0 |  2 |  0";
 
     assert_eq!(tournament::tally(&input), expected);
 }
@@ -93,17 +93,17 @@ fn there_can_be_more_than_two_teams() {
 #[test]
 #[ignore]
 fn typical_input() {
-    let input = "Allegoric Alaskans;Blithering Badgers;win\n".to_string() +
-        "Devastating Donkeys;Courageous Californians;draw\n" +
-        "Devastating Donkeys;Allegoric Alaskans;win\n" +
-        "Courageous Californians;Blithering Badgers;loss\n" +
-        "Blithering Badgers;Devastating Donkeys;loss\n" +
-        "Allegoric Alaskans;Courageous Californians;win";
-    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string() +
-        "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7\n" +
-        "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n" +
-        "Blithering Badgers             |  3 |  1 |  0 |  2 |  3\n" +
-        "Courageous Californians        |  3 |  0 |  1 |  2 |  1";
+    let input = "Allegoric Alaskans;Blithering Badgers;win\n".to_string()
+        + "Devastating Donkeys;Courageous Californians;draw\n"
+        + "Devastating Donkeys;Allegoric Alaskans;win\n"
+        + "Courageous Californians;Blithering Badgers;loss\n"
+        + "Blithering Badgers;Devastating Donkeys;loss\n"
+        + "Allegoric Alaskans;Courageous Californians;win";
+    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string()
+        + "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7\n"
+        + "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n"
+        + "Blithering Badgers             |  3 |  1 |  0 |  2 |  3\n"
+        + "Courageous Californians        |  3 |  0 |  1 |  2 |  1";
 
     assert_eq!(tournament::tally(&input), expected);
 }
@@ -111,15 +111,15 @@ fn typical_input() {
 #[test]
 #[ignore]
 fn incomplete_competition_not_all_pairs_have_played() {
-    let input = "Allegoric Alaskans;Blithering Badgers;loss\n".to_string() +
-        "Devastating Donkeys;Allegoric Alaskans;loss\n" +
-        "Courageous Californians;Blithering Badgers;draw\n" +
-        "Allegoric Alaskans;Courageous Californians;win";
-    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string() +
-        "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n" +
-        "Blithering Badgers             |  2 |  1 |  1 |  0 |  4\n" +
-        "Courageous Californians        |  2 |  0 |  1 |  1 |  1\n" +
-        "Devastating Donkeys            |  1 |  0 |  0 |  1 |  0";
+    let input = "Allegoric Alaskans;Blithering Badgers;loss\n".to_string()
+        + "Devastating Donkeys;Allegoric Alaskans;loss\n"
+        + "Courageous Californians;Blithering Badgers;draw\n"
+        + "Allegoric Alaskans;Courageous Californians;win";
+    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string()
+        + "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n"
+        + "Blithering Badgers             |  2 |  1 |  1 |  0 |  4\n"
+        + "Courageous Californians        |  2 |  0 |  1 |  1 |  1\n"
+        + "Devastating Donkeys            |  1 |  0 |  0 |  1 |  0";
 
     assert_eq!(tournament::tally(&input), expected);
 }
@@ -127,17 +127,17 @@ fn incomplete_competition_not_all_pairs_have_played() {
 #[test]
 #[ignore]
 fn ties_broken_alphabetically() {
-    let input = "Courageous Californians;Devastating Donkeys;win\n".to_string() +
-        "Allegoric Alaskans;Blithering Badgers;win\n" +
-        "Devastating Donkeys;Allegoric Alaskans;loss\n" +
-        "Courageous Californians;Blithering Badgers;win\n" +
-        "Blithering Badgers;Devastating Donkeys;draw\n" +
-        "Allegoric Alaskans;Courageous Californians;draw";
-    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string() +
-        "Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7\n" +
-        "Courageous Californians        |  3 |  2 |  1 |  0 |  7\n" +
-        "Blithering Badgers             |  3 |  0 |  1 |  2 |  1\n" +
-        "Devastating Donkeys            |  3 |  0 |  1 |  2 |  1";
+    let input = "Courageous Californians;Devastating Donkeys;win\n".to_string()
+        + "Allegoric Alaskans;Blithering Badgers;win\n"
+        + "Devastating Donkeys;Allegoric Alaskans;loss\n"
+        + "Courageous Californians;Blithering Badgers;win\n"
+        + "Blithering Badgers;Devastating Donkeys;draw\n"
+        + "Allegoric Alaskans;Courageous Californians;draw";
+    let expected = "Team                           | MP |  W |  D |  L |  P\n".to_string()
+        + "Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7\n"
+        + "Courageous Californians        |  3 |  2 |  1 |  0 |  7\n"
+        + "Blithering Badgers             |  3 |  0 |  1 |  2 |  1\n"
+        + "Devastating Donkeys            |  3 |  0 |  1 |  2 |  1";
 
     assert_eq!(tournament::tally(&input), expected);
 }

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

@@ -48,11 +48,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.
@@ -66,6 +86,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/triangle/src/lib.rs

@@ -0,0 +1 @@
+

data/tracks/rust/exercises/two-bucket/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/two-bucket/src/lib.rs

@@ -1,7 +1,7 @@
 #[derive(PartialEq, Eq, Debug)]
 pub enum Bucket {
     One,
-    Two
+    Two,
 }
 
 /// A struct to hold your results in.
@@ -17,11 +17,7 @@ pub struct BucketStats {
 }
 
 /// Solve the bucket problem
-pub fn solve(capacity_1: u8,
-             capacity_2: u8,
-             goal: u8,
-             start_bucket: &Bucket) -> BucketStats
-{
+pub fn solve(capacity_1: u8, capacity_2: u8, goal: u8, start_bucket: &Bucket) -> BucketStats {
     unimplemented!(
         "Given one bucket of capacity {}, another of capacity {}, starting with {:?}, find pours to reach {}",
         capacity_1,

data/tracks/rust/exercises/two-bucket/tests/two-bucket.rs

@@ -1,68 +1,80 @@
 extern crate two_bucket;
 
-use two_bucket::{solve, BucketStats, Bucket};
+use two_bucket::{solve, Bucket, BucketStats};
 
 #[test]
 fn test_case_1() {
-    assert_eq!(solve(3, 5, 1, &Bucket::One),
-               BucketStats {
-                   moves: 4,
-                   goal_bucket: Bucket::One,
-                   other_bucket: 5,
-               });
+    assert_eq!(
+        solve(3, 5, 1, &Bucket::One),
+        BucketStats {
+            moves: 4,
+            goal_bucket: Bucket::One,
+            other_bucket: 5,
+        }
+    );
 }
 
 #[test]
 #[ignore]
 fn test_case_2() {
-    assert_eq!(solve(3, 5, 1, &Bucket::Two),
-               BucketStats {
-                   moves: 8,
-                   goal_bucket: Bucket::Two,
-                   other_bucket: 3,
-               });
+    assert_eq!(
+        solve(3, 5, 1, &Bucket::Two),
+        BucketStats {
+            moves: 8,
+            goal_bucket: Bucket::Two,
+            other_bucket: 3,
+        }
+    );
 }
 
 #[test]
 #[ignore]
 fn test_case_3() {
-    assert_eq!(solve(7, 11, 2, &Bucket::One),
-               BucketStats {
-                   moves: 14,
-                   goal_bucket: Bucket::One,
-                   other_bucket: 11,
-               });
+    assert_eq!(
+        solve(7, 11, 2, &Bucket::One),
+        BucketStats {
+            moves: 14,
+            goal_bucket: Bucket::One,
+            other_bucket: 11,
+        }
+    );
 }
 
 #[test]
 #[ignore]
 fn test_case_4() {
-    assert_eq!(solve(7, 11, 2, &Bucket::Two),
-               BucketStats {
-                   moves: 18,
-                   goal_bucket: Bucket::Two,
-                   other_bucket: 7,
-               });
+    assert_eq!(
+        solve(7, 11, 2, &Bucket::Two),
+        BucketStats {
+            moves: 18,
+            goal_bucket: Bucket::Two,
+            other_bucket: 7,
+        }
+    );
 }
 
 #[test]
 #[ignore]
 fn test_case_5() {
-    assert_eq!(solve(1, 3, 3, &Bucket::Two),
-               BucketStats {
-                   moves: 1,
-                   goal_bucket: Bucket::Two,
-                   other_bucket: 0,
-               });
+    assert_eq!(
+        solve(1, 3, 3, &Bucket::Two),
+        BucketStats {
+            moves: 1,
+            goal_bucket: Bucket::Two,
+            other_bucket: 0,
+        }
+    );
 }
 
 #[test]
 #[ignore]
 fn test_case_6() {
-    assert_eq!(solve(2, 3, 3, &Bucket::One),
-               BucketStats {
-                   moves: 2,
-                   goal_bucket: Bucket::Two,
-                   other_bucket: 2,
-               });
+    assert_eq!(
+        solve(2, 3, 3, &Bucket::One),
+        BucketStats {
+            moves: 2,
+            goal_bucket: Bucket::Two,
+            other_bucket: 2,
+        }
+    );
 }