trackler 2.0.0.1 → 2.0.0.2

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

@@ -0,0 +1,373 @@
+extern crate bowling;
+
+use bowling::*;
+
+#[test]
+fn roll_returns_a_result() {
+    let mut game = BowlingGame::new();
+    assert!(game.roll(0).is_ok());
+}
+
+#[test]
+#[ignore]
+fn you_can_not_roll_more_than_ten_pins_in_a_single_roll() {
+    let mut game = BowlingGame::new();
+
+    assert!(game.roll(11).is_err());
+}
+
+#[test]
+#[ignore]
+fn a_game_score_is_ok_if_ten_frames_have_been_rolled() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..10 {
+        let _ = game.roll(0);
+        let _ = game.roll(0);
+    }
+
+    assert!(game.score().is_ok());
+}
+
+#[test]
+#[ignore]
+fn you_can_not_score_a_game_with_no_rolls() {
+    let game = BowlingGame::new();
+
+    assert!(game.score().is_err());
+}
+
+#[test]
+#[ignore]
+fn a_game_score_is_err_if_fewer_than_ten_frames_have_been_rolled() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..9 {
+        let _ = game.roll(0);
+        let _ = game.roll(0);
+    }
+
+    assert!(game.score().is_err());
+}
+
+#[test]
+#[ignore]
+fn a_roll_is_err_if_the_game_is_done() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..10 {
+        let _ = game.roll(0);
+        let _ = game.roll(0);
+    }
+
+    assert!(game.roll(0).is_err());
+}
+
+#[test]
+#[ignore]
+fn twenty_zero_pin_rolls_scores_zero() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..20 {
+        let _ = game.roll(0);
+    }
+
+    assert_eq!(game.score().unwrap(), 0);
+}
+
+#[test]
+#[ignore]
+fn ten_frames_without_a_strike_or_spare() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..10 {
+        let _ = game.roll(3);
+        let _ = game.roll(6);
+    }
+
+    assert_eq!(game.score().unwrap(), 90);
+}
+
+#[test]
+#[ignore]
+fn spare_in_the_first_frame_followed_by_zeros() {
+    let mut game = BowlingGame::new();
+
+    let _ = game.roll(6);
+    let _ = game.roll(4);
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    assert_eq!(game.score().unwrap(), 10);
+}
+
+#[test]
+#[ignore]
+fn points_scored_in_the_roll_after_a_spare_are_counted_twice_as_a_bonus() {
+    let mut game = BowlingGame::new();
+
+    let _ = game.roll(6);
+    let _ = game.roll(4);
+    let _ = game.roll(3);
+
+    for _ in 0..17 {
+        let _ = game.roll(0);
+    }
+
+    assert_eq!(game.score().unwrap(), 16);
+}
+
+#[test]
+#[ignore]
+fn consecutive_spares_each_get_a_one_roll_bonus() {
+    let mut game = BowlingGame::new();
+
+    let _ = game.roll(5);
+    let _ = game.roll(5);
+    let _ = game.roll(3);
+    let _ = game.roll(7);
+    let _ = game.roll(4);
+
+    for _ in 0..15 {
+        let _ = game.roll(0);
+    }
+
+    assert_eq!(game.score().unwrap(), 31);
+}
+
+#[test]
+#[ignore]
+fn if_the_last_frame_is_a_spare_you_get_one_extra_roll_that_is_scored_once() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(5);
+    let _ = game.roll(5);
+    let _ = game.roll(7);
+
+    assert_eq!(game.score().unwrap(), 17);
+}
+
+#[test]
+#[ignore]
+fn a_strike_earns_ten_points_in_a_frame_with_a_single_roll() {
+    let mut game = BowlingGame::new();
+
+    let _ = game.roll(10);
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    assert_eq!(game.score().unwrap(), 10);
+}
+
+#[test]
+#[ignore]
+fn points_scored_in_the_two_rolls_after_a_strike_are_counted_twice_as_a_bonus() {
+    let mut game = BowlingGame::new();
+
+    let _ = game.roll(10);
+    let _ = game.roll(5);
+    let _ = game.roll(3);
+
+    for _ in 0..16 {
+        let _ = game.roll(0);
+    }
+
+    assert_eq!(game.score().unwrap(), 26);
+}
+
+#[test]
+#[ignore]
+fn consecutive_strikes_each_get_the_two_roll_bonus() {
+    let mut game = BowlingGame::new();
+
+    let _ = game.roll(10);
+    let _ = game.roll(10);
+    let _ = game.roll(10);
+    let _ = game.roll(5);
+    let _ = game.roll(3);
+
+    for _ in 0..12 {
+        let _ = game.roll(0);
+    }
+
+    assert_eq!(game.score().unwrap(), 81);
+}
+
+#[test]
+#[ignore]
+fn a_strike_in_the_last_frame_earns_a_two_roll_bonus_that_is_counted_once() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(10);
+    let _ = game.roll(7);
+    let _ = game.roll(1);
+
+    assert_eq!(game.score().unwrap(), 18);
+}
+
+#[test]
+#[ignore]
+fn a_spare_with_the_two_roll_bonus_does_not_get_a_bonus_roll() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(10);
+    let _ = game.roll(7);
+    let _ = game.roll(3);
+
+    assert_eq!(game.score().unwrap(), 20);
+}
+
+#[test]
+#[ignore]
+fn strikes_with_the_two_roll_bonus_do_not_get_a_bonus_roll() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(10);
+    let _ = game.roll(10);
+    let _ = game.roll(10);
+
+    assert_eq!(game.score().unwrap(), 30);
+}
+
+#[test]
+#[ignore]
+fn a_strike_with_the_one_roll_bonus_after_a_spare_in_the_last_frame_does_not_get_a_bonus() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(7);
+    let _ = game.roll(3);
+    let _ = game.roll(10);
+
+    assert_eq!(game.score().unwrap(), 20);
+}
+
+#[test]
+#[ignore]
+fn all_strikes_is_a_perfect_score_of_300() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..12 {
+        let _ = game.roll(10);
+    }
+
+    assert_eq!(game.score().unwrap(), 300);
+}
+
+#[test]
+#[ignore]
+fn you_can_not_roll_more_than_ten_pins_in_a_single_frame() {
+    let mut game = BowlingGame::new();
+
+    assert!(game.roll(5).is_ok());
+    assert!(game.roll(6).is_err());
+}
+
+#[test]
+#[ignore]
+fn the_two_balls_after_a_final_strike_can_not_score_an_invalid_number_of_pins() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(10);
+
+    assert!(game.roll(5).is_ok());
+    assert!(game.roll(6).is_err());
+}
+
+#[test]
+#[ignore]
+fn the_two_balls_after_a_final_strike_can_be_a_strike_and_non_strike() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(10);
+
+    assert!(game.roll(10).is_ok());
+    assert!(game.roll(6).is_ok());
+}
+
+#[test]
+#[ignore]
+fn the_two_balls_after_a_final_strike_can_not_be_a_non_strike_followed_by_a_strike() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(10);
+
+    assert!(game.roll(6).is_ok());
+    assert!(game.roll(10).is_err());
+}
+
+#[test]
+#[ignore]
+fn if_the_last_frame_is_a_strike_you_can_not_score_before_the_extra_rolls_are_taken() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(10);
+
+    assert!(game.score().is_err());
+
+    let _ = game.roll(10);
+
+    assert!(game.score().is_err());
+
+    let _ = game.roll(10);
+
+    assert!(game.score().is_ok());
+}
+
+#[test]
+#[ignore]
+fn if_the_last_frame_is_a_spare_you_can_not_create_a_score_before_extra_roll_is_taken() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(5);
+    let _ = game.roll(5);
+
+    assert!(game.score().is_err());
+
+    let _ = game.roll(10);
+
+    assert!(game.score().is_ok());
+}

data/tracks/rust/exercises/grains/.gitignore

@@ -0,0 +1,7 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

data/tracks/rust/exercises/grains/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "grains"
+version = "0.0.0"

data/tracks/rust/exercises/grains/example.rs

@@ -0,0 +1,11 @@
+pub fn square(s: u32) -> u64 {
+    if s == 0 || s > 64 {
+        panic!("Square must be between 1 and 64");
+    }
+
+    2u64.pow(s - 1)
+}
+
+pub fn total() -> u64 {
+    (1..65).fold(0, |acc, s| acc + square(s))
+}

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

@@ -0,0 +1,7 @@
+pub fn square(s: u32) -> u64 {
+    unimplemented!();
+}
+
+pub fn total() -> u64 {
+    unimplemented!();
+}

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

@@ -0,0 +1,63 @@
+extern crate grains;
+
+#[test]
+fn square_one() {
+    assert_eq!(grains::square(1), 1);
+}
+
+#[test]
+#[ignore]
+fn square_two() {
+    assert_eq!(grains::square(2), 2);
+}
+
+#[test]
+#[ignore]
+fn square_three() {
+    assert_eq!(grains::square(3), 4);
+}
+
+#[test]
+#[ignore]
+fn square_four() {
+    assert_eq!(grains::square(4), 8);
+}
+
+#[test]
+#[ignore]
+fn square_sixteen() {
+    assert_eq!(grains::square(16), 32_768);
+}
+
+#[test]
+#[ignore]
+fn square_thirty_two() {
+    assert_eq!(grains::square(32), 2_147_483_648);
+}
+
+#[test]
+#[ignore]
+fn square_sixty_four() {
+    assert_eq!(grains::square(64), 9_223_372_036_854_775_808);
+}
+
+#[test]
+#[ignore]
+#[should_panic(expected = "Square must be between 1 and 64")]
+fn square_zero_panics() {
+    grains::square(0);
+}
+
+#[test]
+#[ignore]
+#[should_panic(expected = "Square must be between 1 and 64")]
+fn square_sixty_five_panics() {
+    grains::square(65);
+}
+
+#[test]
+#[ignore]
+fn total_sums_all_squares() {
+    assert_eq!(grains::total(), 18_446_744_073_709_551_615);
+    grains::total();
+}

data/tracks/rust/problems.md

@@ -23,6 +23,7 @@ raindrops |  case (or `format`). Mutable string
 bob |  chars, string functions
 beer-song |  case, string concatenation, vector (optional), loop
 difference-of-squares |  fold & map
+grains | math, panic
 
 ## Getting Rusty
 
@@ -48,6 +49,7 @@ grade-school |  struct, entry api, Vec, Option
 robot-simulator | Immutability, enum
 bracket-push | From trait, stack or recursion
 queen-attack |  struct, trait (optional), Result
+bowling | struct, Result, goofy bowling logic
 sublist |  enum, generic over type
 space-age | Custom Trait, From Trait, Default Trait implementation
 allergies |  struct, enum, bitwise (probably), vectors, filter

data/tracks/scala/README.md

@@ -6,6 +6,44 @@ Exercism Exercises in Scala
 
 Please see the [contributing guide](https://github.com/exercism/x-api/blob/master/CONTRIBUTING.md#the-exercise-data)
 
+### Generated Test Suites
+
+Some of the test suites have been generated from shared test data. If a test suite was
+generated from test data, then the test suite should not be modified by hand. Instead
+the shared test data should be modified, and the generator rerun. To determine if
+a test suite generator was used, look inside the `testgen/src/main/scala` directory. The test
+suite generators are named in the form `ProblemNameTestGenerator.scala`. Where
+`ProblemName` is a close match for the Exercism problem name.
+
+[the shared problem metadata](https://github.com/exercism/x-common).
+
+For example, take a look at the `all-your-base/canonical-data.json` file in the x-common repository, as well
+as the following files in the xscala repository:
+
+1. `testgen/src/main/scala/AllYourBaseTestGenerator.scala` - test suite generator for all-your-base
+1. `exercises/all-your-base/src/test/scala/AllYourBase.scala`- generated test suite
+
+Since a generator was used, the`exercises/all-your-base/src/test/scala/AllYourBase.scala` will never be edited directly. 
+If there's a missing test case, then additional inputs/outputs should be submitted to the x-common repository.
+
+Note that the the test suite generators do not format the test suite source code. The generated test suite should be 
+formatted before being submitted.
+
+When submitting new exercises we encourage that a test suite generator and generated test suite is
+included. 
+
+## Pull Requests
+
+We welcome pull requests that provide fixes to existing test suites (missing
+tests, interesting edge cases, improved APIs), as well as new problems.
+
+If you're unsure, then go ahead and open a GitHub issue, and we'll discuss the
+change.
+
+Please submit changes to a single problem per pull request unless you're
+submitting a general change across many of the problems (e.g. formatting).
+
+
 ## License
 
 The MIT License (MIT)

data/tracks/scala/config.json

@@ -3,75 +3,6 @@
   "language": "Scala",
   "repository": "https://github.com/exercism/xscala",
   "active": true,
-  "problems": [
-    "hello-world",
-    "bob",
-    "sum-of-multiples",
-    "hamming",
-    "word-count",
-    "pangram",
-    "anagram",
-    "nucleotide-count",
-    "phone-number",
-    "grade-school",
-    "robot-name",
-    "leap",
-    "etl",
-    "meetup",
-    "space-age",
-    "grains",
-    "gigasecond",
-    "scrabble-score",
-    "difference-of-squares",
-    "accumulate",
-    "sublist",
-    "rna-transcription",
-    "triangle",
-    "roman-numerals",
-    "prime-factors",
-    "raindrops",
-    "allergies",
-    "atbash-cipher",
-    "all-your-base",
-    "bank-account",
-    "crypto-square",
-    "kindergarten-garden",
-    "robot-simulator",
-    "bracket-push",
-    "queen-attack",
-    "binary-search-tree",
-    "largest-series-product",
-    "luhn",
-    "clock",
-    "matrix",
-    "house",
-    "zebra-puzzle",
-    "minesweeper",
-    "ocr-numbers",
-    "wordy",
-    "food-chain",
-    "linked-list",
-    "custom-set",
-    "nth-prime",
-    "palindrome-products",
-    "pascals-triangle",
-    "pig-latin",
-    "pythagorean-triplet",
-    "saddle-points",
-    "say",
-    "secret-handshake",
-    "series",
-    "sieve",
-    "simple-cipher",
-    "change",
-    "connect",
-    "parallel-letter-frequency",
-    "sgf-parsing",
-    "acronym",
-    "zipper",
-    "forth",
-    "lens-person"
-  ],
   "exercises": [
     {
       "slug": "hello-world",
@@ -84,16 +15,16 @@
       "slug": "bob",
       "difficulty": 1,
       "topics": [
-				"Strings",
+        "Strings",
         "Control-flow (if-else statements)",
-				"Pattern matching"
+        "Pattern matching"
       ]
 		},
     {
       "slug": "sum-of-multiples",
       "difficulty": 1,
       "topics": [
-	"Filtering"
+	    "Filtering"
       ]
 		},
     {
@@ -102,7 +33,7 @@
       "topics": [
         "Strings",
         "Filtering",
-				"Optional values"
+        "Optional values"
       ]
 		},
     {
@@ -411,6 +342,12 @@
       "topics": [
       ]
 		},
+    {
+      "slug": "alphametics",
+      "difficulty": 1,
+      "topics": [
+      ]
+		},
     {
       "slug": "secret-handshake",
       "difficulty": 1,
@@ -482,7 +419,16 @@
       "difficulty": 1,
       "topics": [
       ]
-		}
+		},
+    {
+      "slug": "bowling",
+      "difficulty": 6,
+      "topics": [
+        "Algorithms",
+        "Control-flow (if-else statements)",
+        "Lists"
+      ]
+    }
 	],
   "deprecated": [
     "binary",

data/tracks/scala/exercises/accumulate/src/test/scala/accumulate_test.scala

@@ -9,24 +9,28 @@ class AccumulateTest extends FlatSpec with Matchers {
   }
 
   it should "accumulate squares" in {
+    pending
     val accumulate = new Accumulate
     val accumulation = accumulate.accumulate[Int, Int](x => x * x, List(1, 2, 3))
     accumulation should be (List(1, 4, 9))
   }
 
   it should "accumulate upcases" in {
+    pending
     val accumulate = new Accumulate
     val accumulation = accumulate.accumulate[String, String](_.map(_.toUpper), List("hello", "world"))
     accumulation should be (List("HELLO", "WORLD"))
   }
 
   it should "accumulate reversed strings" in {
+    pending
     val accumulate = new Accumulate
     val accumulation = accumulate.accumulate[String, String](_.reverse, List("eht", "kciuq", "nworb", "xof", "cte"))
     accumulation should be (List("the", "quick", "brown", "fox", "etc"))
   }
 
   it should "allow different return type" in {
+    pending
     val accumulate = new Accumulate
     val accumulation = accumulate.accumulate[Int, String](_.toString, List(1, 2, 3))
     accumulation should be (List("1", "2", "3"))