trackler 2.0.1.1 → 2.0.1.2

data/tracks/java/exercises/robot-simulator/src/test/java/RobotTest.java

@@ -0,0 +1,244 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public final class RobotTest {
+
+    @Test
+    public void testRobotIsCreatedWithCorrectInitialPosition() {
+        final GridPosition initialGridPosition = new GridPosition(0, 0);
+        final Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
+
+        assertTrue(robot.getGridPosition().equals(initialGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testRobotIsCreatedWithCorrectInitialOrientation() {
+        final Orientation initialOrientation = Orientation.NORTH;
+        final Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);
+
+        assertTrue(robot.getOrientation().equals(initialOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningRightDoesNotChangePosition() {
+        final GridPosition initialGridPosition = new GridPosition(0, 0);
+        final Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
+
+        robot.turnRight();
+
+        assertTrue(robot.getGridPosition().equals(initialGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningRightCorrectlyChangesOrientationFromNorthToEast() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+
+        robot.turnRight();
+
+        final Orientation expectedOrientation = Orientation.EAST;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningRightCorrectlyChangesOrientationFromEastToSouth() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
+
+        robot.turnRight();
+
+        final Orientation expectedOrientation = Orientation.SOUTH;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningRightCorrectlyChangesOrientationFromSouthToWest() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
+
+        robot.turnRight();
+
+        final Orientation expectedOrientation = Orientation.WEST;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningRightCorrectlyChangesOrientationFromWestToNorth() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
+
+        robot.turnRight();
+
+        final Orientation expectedOrientation = Orientation.NORTH;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningLeftDoesNotChangePosition() {
+        final GridPosition initialGridPosition = new GridPosition(0, 0);
+        final Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
+
+        robot.turnLeft();
+
+        assertTrue(robot.getGridPosition().equals(initialGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningLeftCorrectlyChangesOrientationFromNorthToWest() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+
+        robot.turnLeft();
+
+        final Orientation expectedOrientation = Orientation.WEST;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningLeftCorrectlyChangesOrientationFromWestToSouth() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
+
+        robot.turnLeft();
+
+        final Orientation expectedOrientation = Orientation.SOUTH;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningLeftCorrectlyChangesOrientationFromSouthToEast() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
+
+        robot.turnLeft();
+
+        final Orientation expectedOrientation = Orientation.EAST;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningLeftCorrectlyChangesOrientationFromEastToNorth() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
+
+        robot.turnLeft();
+
+        final Orientation expectedOrientation = Orientation.NORTH;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testAdvancingDoesNotChangeOrientation() {
+        final Orientation initialOrientation = Orientation.NORTH;
+        final Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);
+
+        robot.advance();
+
+        assertTrue(robot.getOrientation().equals(initialOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testAdvancingWhenFacingNorthIncreasesYCoordinateByOne() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+
+        robot.advance();
+
+        final GridPosition expectedGridPosition = new GridPosition(0, 1);
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testAdvancingWhenFacingSouthDecreasesYCoordinateByOne() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
+
+        robot.advance();
+
+        final GridPosition expectedGridPosition = new GridPosition(0, -1);
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testAdvancingWhenFacingEastIncreasesXCoordinateByOne() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
+
+        robot.advance();
+
+        final GridPosition expectedGridPosition = new GridPosition(1, 0);
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testAdvancingWhenFacingWestDecreasesXCoordinateByOne() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
+
+        robot.advance();
+
+        final GridPosition expectedGridPosition = new GridPosition(-1, 0);
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testInstructionsToMoveWestAndNorth() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+
+        robot.simulate("LAAARALA");
+
+        final GridPosition expectedGridPosition = new GridPosition(-4, 1);
+        final Orientation expectedOrientation = Orientation.WEST;
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testInstructionsToMoveWestAndSouth() {
+        final Robot robot = new Robot(new GridPosition(2, -7), Orientation.EAST);
+
+        robot.simulate("RRAAAAALA");
+
+        final GridPosition expectedGridPosition = new GridPosition(-3, -8);
+        final Orientation expectedOrientation = Orientation.SOUTH;
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testInstructionsToMoveEastAndNorth() {
+        final Robot robot = new Robot(new GridPosition(8, 4), Orientation.SOUTH);
+
+        robot.simulate("LAAARRRALLLL");
+
+        final GridPosition expectedGridPosition = new GridPosition(11, 5);
+        final Orientation expectedOrientation = Orientation.NORTH;
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+}

data/tracks/java/exercises/settings.gradle

@@ -6,6 +6,7 @@ include 'atbash-cipher'
 include 'beer-song'
 include 'binary'
 include 'bob'
+include 'bracket-push'
 include 'crypto-square'
 include 'difference-of-squares'
 include 'etl'
@@ -30,6 +31,7 @@ include 'queen-attack'
 include 'raindrops'
 include 'rna-transcription'
 include 'robot-name'
+include 'robot-simulator'
 include 'roman-numerals'
 include 'prime-factors'
 include 'scrabble-score'

data/tracks/ocaml/exercises/say/test.ml

@@ -2,64 +2,60 @@ open Core.Std
 open OUnit2
 open Say
 
-(* A wrapper around the assert_equal function from oUnit to reduce the test
-   boilerplate. *)
-let say_test exp n =
-  exp>::(fun _ctx ->
-    assert_equal ~printer:(Option.value ~default:"None")
-      (Some exp) (in_english n))
+let ae exp got _ctx = assert_equal ~printer:(Option.value ~default:"None") exp got
 
 let tests = [
-  "cannot say numbers below 0">::(fun _ ->
-    assert_bool "-1" (in_english (-1L) |> Option.is_none));
-  "cannot say numbers above 1 trillion">::(fun _ ->
-    assert_bool "1 trillion"
-      (in_english 1_000_000_000_000L |> Option.is_none));
-  say_test "zero" 0L;
-  say_test "one" 1L;
-  say_test "two" 2L;
-  say_test "three" 3L;
-  say_test "seven" 7L;
-  say_test "ten" 10L;
-  say_test "eleven" 11L;
-  say_test "twelve" 12L;
-  say_test "thirteen" 13L;
-  say_test "fourteen" 14L;
-  say_test "fifteen" 15L;
-  say_test "sixteen" 16L;
-  say_test "seventeen" 17L;
-  say_test "eighteen" 18L;
-  say_test "nineteen" 19L;
-  say_test "twenty" 20L;
-  say_test "twenty-four" 24L;
-  say_test "thirty" 30L;
-  say_test "thirty-five" 35L;
-  say_test "forty-eight" 48L;
-  say_test "fifty-seven" 57L;
-  say_test "sixty" 60L;
-  say_test "seventy-one" 71L;
-  say_test "eighty-three" 83L;
-  say_test "ninety-nine" 99L;
-  say_test "one hundred" 100L;
-  say_test "one hundred five" 105L;
-  say_test "four hundred eighty-five" 485L;
-  say_test "nine hundred ninety-nine" 999L;
-  say_test "one thousand" 1000L;
-  say_test "one thousand two" 1002L;
-  say_test "one thousand three hundred twenty-three" 1323L;
-  say_test "eight thousand seven hundred eleven" 8711L;
-  say_test "nine hundred fifty-eight thousand one hundred forty-five" 958145L;
-  say_test "one million" 1_000_000L;
-  say_test "one billion" 1_000_000_000L;
-  say_test ("nine hundred eighty-seven billion six hundred fifty-four " ^
-      "million three hundred twenty-one thousand one hundred " ^
-      "twenty-three") 987_654_321_123L;
+   "zero" >:: (
+      ae (Some "zero")
+         (in_english 0L));
+   "one" >:: (
+      ae (Some "one")
+         (in_english 1L));
+   "fourteen" >:: (
+      ae (Some "fourteen")
+         (in_english 14L));
+   "twenty" >:: (
+      ae (Some "twenty")
+         (in_english 20L));
+   "twenty-two" >:: (
+      ae (Some "twenty-two")
+         (in_english 22L));
+   "one hundred" >:: (
+      ae (Some "one hundred")
+         (in_english 100L));
+   "one hundred twenty-three" >:: (
+      ae (Some "one hundred twenty-three")
+         (in_english 123L));
+   "one thousand" >:: (
+      ae (Some "one thousand")
+         (in_english 1000L));
+   "one thousand two hundred thirty-four" >:: (
+      ae (Some "one thousand two hundred thirty-four")
+         (in_english 1234L));
+   "one million" >:: (
+      ae (Some "one million")
+         (in_english 1000000L));
+   "one million two thousand three hundred forty-five" >:: (
+      ae (Some "one million two thousand three hundred forty-five")
+         (in_english 1002345L));
+   "one billion" >:: (
+      ae (Some "one billion")
+         (in_english 1000000000L));
+   "a big number" >:: (
+      ae (Some "nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three")
+         (in_english 987654321123L));
+   "numbers below zero are out of range" >:: (
+      ae None
+         (in_english (-1L)));
+   "numbers above 999,999,999,999 are out of range" >:: (
+      ae None
+         (in_english 1000000000000L));
   "all numbers from 1 to 10_000 can be spelt">::(fun _ ->
-    assert_bool "range test" (Sequence.range 0 10_000
-      |> Sequence.map ~f:(fun n -> Int64.of_int n |> in_english)
-      |> Sequence.filter ~f:(Option.is_none)
-      |> Sequence.is_empty));
-  ]
+      assert_bool "range test" (Sequence.range 0 10_000
+                                |> Sequence.map ~f:(fun n -> Int64.of_int n |> in_english)
+                                |> Sequence.filter ~f:(Option.is_none)
+                                |> Sequence.is_empty));
+]
 
 let () =
-  run_test_tt_main ("say tests" >::: tests)
+  run_test_tt_main ("say tests" >::: tests)

data/tracks/ocaml/tools/test-generator/src/codegen.ml

@@ -11,7 +11,8 @@ type subst = Subst of string [@@deriving eq, show]
 let subst_to_string (Subst s) = s
 
 let replace_key (key: string) (value: string) (target: string): string =
-  String.substr_replace_all ~pattern:("$" ^ key) ~with_:value target
+  let replace = String.substr_replace_all ~with_:value in
+  replace ~pattern:("$" ^ key) target |> replace ~pattern:("$(" ^ key ^ ")")
 
 let rec replace_keys (f: fixup_parameter_function) (ed: edit_parameters_function) (s: string) (c: case): subst =
   let s = replace_key "description" c.description s in

data/tracks/ocaml/tools/test-generator/src/special_cases.ml

@@ -5,14 +5,19 @@ open Model
 let optional_int ~(none: int) = function
   | Int n when n = none -> "None"
   | Int n -> "(Some " ^ Int.to_string n ^ ")"
-  | _ -> failwith "can't handle non-int parameter"
+  | x -> parameter_to_string x
+
+let optional_int_or_string ~(none: int) = function
+  | String s -> "(Some \"" ^ s ^ "\")"
+  | Int n when n = none -> "None"
+  | x -> parameter_to_string x
 
 let default_value ~(key: string) ~(value: string) (parameters: (string * string) list): (string * string) list =
   if List.exists ~f:(fun (k, _) -> k = key) parameters
   then parameters
   else (key, value) :: parameters
 
-let optional_string ~(f: string -> bool) (parameters: (string * string) list): (string * string) list =
+let optional_strings ~(f: string -> bool) (parameters: (string * string) list): (string * string) list =
   let replace parameter =
     let (k, v) = parameter in
     if f k
@@ -21,11 +26,12 @@ let optional_string ~(f: string -> bool) (parameters: (string * string) list): (
   List.map ~f:replace parameters
 
 let fixup ~(stringify: parameter -> string) ~(slug: string) ~(key: string) ~(value: parameter) = match (slug, key) with
-  | ("hamming", "expected") -> optional_int (-1) value
+  | ("hamming", "expected") -> optional_int ~none:(-1) value
+  | ("say", "expected") -> optional_int_or_string ~none:(-1) value
   | _ -> stringify value
 
 let edit ~(slug: string) (parameters: (string * string) list) = match (slug, parameters) with
   | ("hello-world", ps) -> default_value ~key:"name" ~value:"None"
-    @@ optional_string ~f:(fun _x -> true)
+    @@ optional_strings ~f:(fun _x -> true)
     @@ parameters
   | (_, ps) -> ps

data/tracks/ocaml/tools/test-generator/src/test_generator.ml

@@ -32,10 +32,15 @@ let generate_code ~slug ~template_file ~canonical_data_file =
   let substs = Result.ok_or_failwith @@ generate_code (fixup ~stringify:parameter_to_string ~slug) (edit ~slug) template.template cs in
   Result.return (fill template substs)
 
+(* Hack - right now it's generating -1L, but Ocaml needs (-1L) *)
+let final_fixup (s: string): string =
+  String.substr_replace_all s ~pattern:"-1L" ~with_:"(-1L)"
+
 let output_tests (files: (string * content * content) list) (output_folder: string): unit =
   let output_filepath name = output_folder ^ "/" ^ name ^ "/test.ml" in
   let output1 (slug,t,c) =
     let code = Result.ok_or_failwith @@ generate_code slug t c in
+    let code = final_fixup code in
     Out_channel.write_all (output_filepath slug) code in
   List.iter files ~f:output1
 

data/tracks/ocaml/tools/test-generator/templates/say/template.ml

@@ -0,0 +1,21 @@
+open Core.Std
+open OUnit2
+open Say
+
+let ae exp got _ctx = assert_equal ~printer:(Option.value ~default:"None") exp got
+
+let tests = [
+(* GENERATED-CODE
+   "$description" >:: (
+      ae $expected
+         (in_english $(input)L));
+   END GENERATED-CODE *)
+  "all numbers from 1 to 10_000 can be spelt">::(fun _ ->
+      assert_bool "range test" (Sequence.range 0 10_000
+                                |> Sequence.map ~f:(fun n -> Int64.of_int n |> in_english)
+                                |> Sequence.filter ~f:(Option.is_none)
+                                |> Sequence.is_empty));
+]
+
+let () =
+  run_test_tt_main ("say tests" >::: tests)