trackler 2.2.1.137 → 2.2.1.138

data/tracks/elisp/exercises/bob/example.el

@@ -5,10 +5,12 @@
 ;;; Code:
 (defun response-for (phrase)
   "Provides Bob's response to PHRASE."
-  (cond ((shoutp phrase) "Whoa, chill out!")
-        ((string-match-p "^[[:space:]]*$" phrase) "Fine. Be that way!")
-        ((questionp phrase) "Sure.")
-        (t "Whatever.")))
+  (let ((stripped-phrase (chomp phrase)))
+    (cond ((shout-questionp stripped-phrase) "Calm down, I know what I'm doing!")
+          ((shoutp stripped-phrase) "Whoa, chill out!")
+          ((string-match-p "^[[:space:]]*$" stripped-phrase) "Fine. Be that way!")
+          ((questionp stripped-phrase) "Sure.")
+          (t "Whatever."))))
 
 (defun shoutp (phrase)
   "Determines if PHRASE is shouted."
@@ -20,8 +22,16 @@
   (and (> (length phrase) 0)
    (= ?? (aref phrase (1- (length phrase))))))
 
+(defun shout-questionp (phrase)
+  "Determines if PHRASE is a shouted question."
+  (and (shoutp phrase) (questionp phrase)))
 
-
+(defun chomp (str)
+  "Chomp leading and tailing whitespace from STR."
+  (replace-regexp-in-string (rx (or (: bos (* (any " \t\n")))
+                                    (: (* (any " \t\n")) eos)))
+                            ""
+                            str))
 
 (provide 'bob)
 ;;; bob.el ends here

data/tracks/elisp/exercises/hamming/hamming-test.el

@@ -48,7 +48,7 @@
 (ert-deftest disallow-first-strand-longer ()
   (should-error (hamming-distance "AATG" "AAA")))
 
-(ert-deftest disallow-first-strand-longer ()
+(ert-deftest disallow-second-strand-longer ()
   (should-error (hamming-distance "ATA" "AGTG")))
 
 (provide 'hamming-test)

data/tracks/fsharp/build.ps1

@@ -25,12 +25,12 @@ Param(
 
 $SCRIPT_DIR = $PSScriptRoot
 $TOOLS_DIR = Join-Path $SCRIPT_DIR "tools"
-$CAKE_VERSION = "0.26.1"
+$CAKE_VERSION = "0.27.1"
 $CAKE_DIR = Join-Path $TOOLS_DIR "Cake.$CAKE_VERSION"
 $CAKE_DLL = Join-Path $CAKE_DIR "Cake.dll"
 $CAKE_ZIP = Join-Path $TOOLS_DIR "Cake.$CAKE_VERSION.zip"
-$CAKE_ZIP_URL = "https://github.com/cake-build/cake/releases/download/v0.26.1/Cake-bin-coreclr-v$CAKE_VERSION.zip"
-$DOTNET_VERSION = "2.0.3"
+$CAKE_ZIP_URL = "https://github.com/cake-build/cake/releases/download/v$CAKE_VERSION/Cake-bin-coreclr-v$CAKE_VERSION.zip"
+$DOTNET_VERSION = "2.1.105"
 $DOTNET_DIR = Join-Path $TOOLS_DIR "dotnet.$DOTNET_VERSION"
 $DOTNET_COMMAND = Join-Path $DOTNET_DIR "dotnet.exe"
 $DOTNET_INSTALL_SCRIPT = Join-Path $DOTNET_DIR "dotnet-install.ps1"

data/tracks/fsharp/build.sh

@@ -2,12 +2,12 @@
 
 SCRIPT_DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
 TOOLS_DIR=$SCRIPT_DIR/tools
-CAKE_VERSION=0.26.1
+CAKE_VERSION=0.27.1
 CAKE_DIR=$TOOLS_DIR/Cake.$CAKE_VERSION
 CAKE_DLL=$CAKE_DIR/Cake.dll
 CAKE_ZIP=$TOOLS_DIR/Cake.$CAKE_VERSION.zip
-CAKE_ZIP_URL=https://github.com/cake-build/cake/releases/download/v0.26.1/Cake-bin-coreclr-v$CAKE_VERSION.zip
-DOTNET_VERSION=2.0.3
+CAKE_ZIP_URL=https://github.com/cake-build/cake/releases/download/v$CAKE_VERSION/Cake-bin-coreclr-v$CAKE_VERSION.zip
+DOTNET_VERSION=2.1.105
 DOTNET_DIR=$TOOLS_DIR/dotnet.$DOTNET_VERSION
 DOTNET_COMMAND=$DOTNET_DIR/dotnet
 DOTNET_INSTALL_SCRIPT=$DOTNET_DIR/dotnet-install.sh

data/tracks/fsharp/exercises/bracket-push/BracketPushTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.2.0 of the canonical data.
+// This file was auto-generated based on version 1.3.0 of the canonical data.
 
 module BracketPushTest
 
@@ -31,6 +31,10 @@ let ``Wrong closing bracket`` () =
 let ``Paired with whitespace`` () =
     isPaired "{ }" |> should equal true
 
+[<Fact(Skip = "Remove to run test")>]
+let ``Partially paired brackets`` () =
+    isPaired "{[])" |> should equal false
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Simple nested brackets`` () =
     isPaired "{[]}" |> should equal true

data/tracks/fsharp/exercises/isbn-verifier/IsbnVerifierTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 2.3.0 of the canonical data.
+// This file was auto-generated based on version 2.4.0 of the canonical data.
 
 module IsbnVerifierTest
 
@@ -63,3 +63,7 @@ let ``Check digit of X should not be used for 0`` () =
 let ``Empty isbn`` () =
     isValid "" |> should equal false
 
+[<Fact(Skip = "Remove to run test")>]
+let ``Input is 9 characters`` () =
+    isValid "134456729" |> should equal false
+

data/tracks/fsharp/exercises/kindergarten-garden/KindergartenGardenTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.0 of the canonical data.
+// This file was auto-generated based on version 1.1.1 of the canonical data.
 
 module KindergartenGardenTest
 

data/tracks/fsharp/exercises/pov/PovTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.2.0 of the canonical data.
+// This file was auto-generated based on version 1.3.0 of the canonical data.
 
 module PovTest
 
@@ -76,6 +76,11 @@ let ``Can find path to cousin`` () =
     let tree = mkGraph "grandparent" [mkGraph "parent" [mkGraph "x" [mkGraph "kid-0" []; mkGraph "kid-1" []]; mkGraph "sibling-0" []; mkGraph "sibling-1" []]; mkGraph "uncle" [mkGraph "cousin-0" []; mkGraph "cousin-1" []]]
     tracePathBetween "x" "cousin-1" tree |> should equal <| Some ["x"; "parent"; "grandparent"; "uncle"; "cousin-1"]
 
+[<Fact(Skip = "Remove to run test")>]
+let ``Can find path not involving root`` () =
+    let tree = mkGraph "grandparent" [mkGraph "parent" [mkGraph "x" []; mkGraph "sibling-0" []; mkGraph "sibling-1" []]]
+    tracePathBetween "x" "sibling-1" tree |> should equal <| Some ["x"; "parent"; "sibling-1"]
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Can find path from nodes other than x`` () =
     let tree = mkGraph "parent" [mkGraph "a" []; mkGraph "x" []; mkGraph "b" []; mkGraph "c" []]

data/tracks/fsharp/exercises/react/Example.fs

@@ -55,10 +55,10 @@ type Reactor() =
         cells <- cells @ [cell]
         cell
 
-    member this.createInputCell value =
+    member __.createInputCell value =
         addCell value
 
-    member this.createComputeCell (producers: Cell list) (compute: (int list -> int)) =
+    member __.createComputeCell (producers: Cell list) (compute: (int list -> int)) =
         let value = computeValue producers compute
         let cell = addCell value
         cell.Producers <- producers

data/tracks/fsharp/exercises/react/React.fsproj

@@ -17,6 +17,7 @@
     <PackageReference Include="xunit" Version="2.3.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
     <PackageReference Include="FsUnit.xUnit" Version="3.1.0" />
+    <PackageReference Include="FakeItEasy" Version="4.5.1" />
     <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.1" />
   </ItemGroup>
 

data/tracks/fsharp/exercises/react/ReactTest.fs

@@ -1,9 +1,10 @@
-// This file was auto-generated based on version 1.2.0 of the canonical data.
+// This file was auto-generated based on version 2.0.0 of the canonical data.
 
 module ReactTest
 
 open FsUnit.Xunit
 open Xunit
+open FakeItEasy
 
 open React
 
@@ -59,76 +60,95 @@ let ``Compute cells fire callbacks`` () =
     let reactor = new Reactor()
     let input = reactor.createInputCell 1
     let output = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
-    let mutable callback1 = []
-    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    let callback1Handler = A.Fake<Handler<int>>()
     output.Changed.AddHandler callback1Handler
     input.Value <- 3
-    callback1 |> should equal [4]
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, 4)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback1Handler) |> ignore
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Callback cells only fire on change`` () =
     let reactor = new Reactor()
     let input = reactor.createInputCell 1
     let output = reactor.createComputeCell [input] (fun values -> if values.[0] < 3 then 111 else 222)
-    let mutable callback1 = []
-    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    let callback1Handler = A.Fake<Handler<int>>()
     output.Changed.AddHandler callback1Handler
     input.Value <- 2
-    callback1 |> should equal List.empty<int>
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, A<int>.``_``)).MustNotHaveHappened() |> ignore
     input.Value <- 4
-    callback1 |> should equal [222]
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, 222)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback1Handler) |> ignore
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Callbacks do not report already reported values`` () =
     let reactor = new Reactor()
     let input = reactor.createInputCell 1
     let output = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
-    let mutable callback1 = []
-    let callback1Handler = Handler<int>(fun _ value -> callback1 <- [value])
+    let callback1Handler = A.Fake<Handler<int>>()
     output.Changed.AddHandler callback1Handler
     input.Value <- 2
-    callback1 |> should equal [3]
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, 3)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback1Handler) |> ignore
     input.Value <- 3
-    callback1 |> should equal [4]
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, 4)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback1Handler) |> ignore
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Callbacks can fire from multiple cells`` () =
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 1
+    let plus_one = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
+    let minus_one = reactor.createComputeCell [input] (fun values -> values.[0] - 1)
+    let callback1Handler = A.Fake<Handler<int>>()
+    plus_one.Changed.AddHandler callback1Handler
+    let callback2Handler = A.Fake<Handler<int>>()
+    minus_one.Changed.AddHandler callback2Handler
+    input.Value <- 10
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, 11)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback1Handler) |> ignore
+    A.CallTo(fun() -> callback2Handler.Invoke(A<obj>.``_``, 9)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback2Handler) |> ignore
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Callbacks can be added and removed`` () =
     let reactor = new Reactor()
     let input = reactor.createInputCell 11
     let output = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
-    let mutable callback1 = []
-    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    let callback1Handler = A.Fake<Handler<int>>()
     output.Changed.AddHandler callback1Handler
-    let mutable callback2 = []
-    let callback2Handler = Handler<int>(fun _ value -> callback2 <- callback2 @ [value])
+    let callback2Handler = A.Fake<Handler<int>>()
     output.Changed.AddHandler callback2Handler
     input.Value <- 31
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, 32)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback1Handler) |> ignore
+    A.CallTo(fun() -> callback2Handler.Invoke(A<obj>.``_``, 32)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback2Handler) |> ignore
     output.Changed.RemoveHandler callback1Handler
-    let mutable callback3 = []
-    let callback3Handler = Handler<int>(fun _ value -> callback3 <- callback3 @ [value])
+    let callback3Handler = A.Fake<Handler<int>>()
     output.Changed.AddHandler callback3Handler
     input.Value <- 41
-    callback1 |> should equal [32]
-    callback2 |> should equal [32; 42]
-    callback3 |> should equal [42]
+    A.CallTo(fun() -> callback2Handler.Invoke(A<obj>.``_``, 42)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback2Handler) |> ignore
+    A.CallTo(fun() -> callback3Handler.Invoke(A<obj>.``_``, 42)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback3Handler) |> ignore
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, A<int>.``_``)).MustNotHaveHappened() |> ignore
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Removing a callback multiple times doesn't interfere with other callbacks`` () =
     let reactor = new Reactor()
     let input = reactor.createInputCell 1
     let output = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
-    let mutable callback1 = []
-    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    let callback1Handler = A.Fake<Handler<int>>()
     output.Changed.AddHandler callback1Handler
-    let mutable callback2 = []
-    let callback2Handler = Handler<int>(fun _ value -> callback2 <- callback2 @ [value])
+    let callback2Handler = A.Fake<Handler<int>>()
     output.Changed.AddHandler callback2Handler
     output.Changed.RemoveHandler callback1Handler
     output.Changed.RemoveHandler callback1Handler
     output.Changed.RemoveHandler callback1Handler
     input.Value <- 2
-    callback1 |> should equal List.empty<int>
-    callback2 |> should equal [3]
+    A.CallTo(fun() -> callback2Handler.Invoke(A<obj>.``_``, 3)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback2Handler) |> ignore
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, A<int>.``_``)).MustNotHaveHappened() |> ignore
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Callbacks should only be called once even if multiple dependencies change`` () =
@@ -138,11 +158,11 @@ let ``Callbacks should only be called once even if multiple dependencies change`
     let minus_one1 = reactor.createComputeCell [input] (fun values -> values.[0] - 1)
     let minus_one2 = reactor.createComputeCell [minus_one1] (fun values -> values.[0] - 1)
     let output = reactor.createComputeCell [plus_one; minus_one2] (fun values -> values.[0] * values.[1])
-    let mutable callback1 = []
-    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    let callback1Handler = A.Fake<Handler<int>>()
     output.Changed.AddHandler callback1Handler
     input.Value <- 4
-    callback1 |> should equal [10]
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, 10)).MustHaveHappenedOnceExactly() |> ignore
+    Fake.ClearRecordedCalls(callback1Handler) |> ignore
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Callbacks should not be called if dependencies change but output value doesn't change`` () =
@@ -151,12 +171,14 @@ let ``Callbacks should not be called if dependencies change but output value doe
     let plus_one = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
     let minus_one = reactor.createComputeCell [input] (fun values -> values.[0] - 1)
     let always_two = reactor.createComputeCell [plus_one; minus_one] (fun values -> values.[0] - values.[1])
-    let mutable callback1 = []
-    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    let callback1Handler = A.Fake<Handler<int>>()
     always_two.Changed.AddHandler callback1Handler
     input.Value <- 2
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, A<int>.``_``)).MustNotHaveHappened() |> ignore
     input.Value <- 3
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, A<int>.``_``)).MustNotHaveHappened() |> ignore
     input.Value <- 4
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, A<int>.``_``)).MustNotHaveHappened() |> ignore
     input.Value <- 5
-    callback1 |> should equal List.empty<int>
+    A.CallTo(fun() -> callback1Handler.Invoke(A<obj>.``_``, A<int>.``_``)).MustNotHaveHappened() |> ignore
 

data/tracks/fsharp/exercises/series/Example.fs

@@ -1,15 +1,5 @@
 module Series
 
-open System
-
-let charToDigit c = c.ToString() |> Int32.Parse 
-let digits str = str |> List.ofSeq |> List.map charToDigit
-let slice length input = Seq.take length input |> List.ofSeq
-
-let rec slicesHelper length remainder acc = 
-    if remainder |> List.length < length then acc |> List.rev
-    else slicesHelper length (remainder |> List.tail) (slice length remainder:: acc)
-
 let slices (str:string) length = 
-    if length > str.Length then invalidArg "length" "Slice length must not be than input length"
-    else slicesHelper length (digits str) []
+    if length < 1 || length > str.Length || str.Length = 0 then None
+    else Some [for i in 0 .. str.Length - length -> str.[i..i + length - 1]]

data/tracks/fsharp/exercises/series/SeriesTest.fs

@@ -1,72 +1,49 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.0.0 of the canonical data.
 
 module SeriesTest
 
-open System
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open Series
 
-type SeriesTests () =
-    static member SliceOneTestData = 
-        let theoryData = new TheoryData<string, int list list>()
-        theoryData.Add("01234", [[0]; [1]; [2]; [3]; [4]])
-        theoryData.Add("92834", [[9]; [2]; [8]; [3]; [4]])
-        theoryData
+[<Fact>]
+let ``Slices of one from one`` () =
+    slices "1" 1 |> should equal (Some ["1"])
 
-    [<Theory>]
-    [<MemberData("SliceOneTestData")>]
-    member this.``Series of one splits to one digit`` input expected =
-        slices input 1 |> should equal expected
+[<Fact(Skip = "Remove to run test")>]
+let ``Slices of one from two`` () =
+    slices "12" 1 |> should equal (Some ["1"; "2"])
 
-    static member SliceTwoTestData = 
-        let theoryData = new TheoryData<string, int list list>()
-        theoryData.Add("01234", [[0; 1]; [1; 2]; [2; 3]; [3; 4]]);
-        theoryData.Add("98273463", [[9; 8]; [8; 2]; [2; 7]; [7; 3]; [3; 4]; [4; 6]; [6; 3]]);
-        theoryData.Add("37103", [[3; 7]; [7; 1]; [1; 0]; [0; 3]])
-        theoryData
+[<Fact(Skip = "Remove to run test")>]
+let ``Slices of two`` () =
+    slices "35" 2 |> should equal (Some ["35"])
 
-    [<Theory(Skip = "Remove to run test")>]
-    [<MemberData("SliceTwoTestData")>]
-    member this.``Series of two splits to two digits`` input expected =
-        slices input 2 |> should equal expected
+[<Fact(Skip = "Remove to run test")>]
+let ``Slices of two overlap`` () =
+    slices "9142" 2 |> should equal (Some ["91"; "14"; "42"])
 
-    static member SliceThreeTestData = 
-        let theoryData = new TheoryData<string, int list list>()
-        theoryData.Add("01234", [[0; 1; 2]; [1; 2; 3]; [2; 3; 4]]);
-        theoryData.Add("31001", [[3; 1; 0]; [1; 0; 0]; [0; 0; 1]]);
-        theoryData.Add("982347", [[9; 8; 2]; [8; 2; 3]; [2; 3; 4]; [3; 4; 7]])
-        theoryData
+[<Fact(Skip = "Remove to run test")>]
+let ``Slices can include duplicates`` () =
+    slices "777777" 3 |> should equal (Some ["777"; "777"; "777"; "777"])
 
-    [<Theory(Skip = "Remove to run test")>]
-    [<MemberData("SliceThreeTestData")>]
-    member this.``Series of three splits to three digits`` input expected =
-        slices input 3 |> should equal expected
+[<Fact(Skip = "Remove to run test")>]
+let ``Slices of a long series`` () =
+    slices "918493904243" 5 |> should equal (Some ["91849"; "18493"; "84939"; "49390"; "93904"; "39042"; "90424"; "04243"])
 
-    static member SliceFourTestData = 
-        let theoryData = new TheoryData<string, int list list>()
-        theoryData.Add("01234", [[0; 1; 2; 3]; [1; 2; 3; 4]]);
-        theoryData.Add("91274", [[9; 1; 2; 7]; [1; 2; 7; 4]])
-        theoryData
+[<Fact(Skip = "Remove to run test")>]
+let ``Slice length is too large`` () =
+    slices "12345" 6 |> should equal None
 
-    [<Theory(Skip = "Remove to run test")>]
-    [<MemberData("SliceFourTestData")>]
-    member this.``Series of four splits to four digits`` input expected =
-        slices input 4 |> should equal expected
+[<Fact(Skip = "Remove to run test")>]
+let ``Slice length cannot be zero`` () =
+    slices "12345" 0 |> should equal None
 
-    static member SliceFiveTestData = 
-        let theoryData = new TheoryData<string, int list list>()
-        theoryData.Add("01234", [[0; 1; 2; 3; 4]]);
-        theoryData.Add("81228", [[8; 1; 2; 2; 8]])
-        theoryData
+[<Fact(Skip = "Remove to run test")>]
+let ``Slice length cannot be negative`` () =
+    slices "123" -1 |> should equal None
 
-    [<Theory(Skip = "Remove to run test")>]
-    [<MemberData("SliceFiveTestData")>]
-    member this.``Series of five splits to five digits`` input expected =
-        slices input 5 |> should equal expected
+[<Fact(Skip = "Remove to run test")>]
+let ``Empty series is invalid`` () =
+    slices "" 1 |> should equal None
 
-    [<Theory(Skip = "Remove to run test")>]
-    [<InlineData("01234", 6)>]
-    [<InlineData("01032987583", 19)>]
-    member this.``Slice longer than input is not allowed`` input slice =
-        (fun () -> slices input slice |> ignore) |> should throw typeof<ArgumentException>

data/tracks/fsharp/generators/Generators.fs

@@ -1085,9 +1085,7 @@ type RationalNumbers() =
 type React() = 
     inherit GeneratorExercise()
 
-    override __.PropertiesWithIdentifier _ = []
-
-    member private __.RenderCells canonicalDataCase = 
+    let renderCells canonicalDataCase = 
         let reactorVar = sprintf "let %s = new %s()" "reactor" "Reactor"
         let cellVars = 
             canonicalDataCase.Input.["cells"] :?> JArray
@@ -1110,56 +1108,87 @@ type React() =
             |> Seq.toList
         [ reactorVar ] @ cellVars
      
-    member private __.RenderOperations canonicalDataCase = 
+    let renderExpectedCellValueOperation (op: JObject) =
+        seq { 
+            let cellName = op.["cell"].ToObject<string>()
+            let expectedValue = op.["value"].ToObject<int>()
+            yield sprintf "%s.Value |> should equal %i" cellName expectedValue 
+        }
+
+    let renderExpectedCallbacks (jToken: JToken) =
+        match jToken with
+        | :? JObject as jObject ->
+            seq {
+                for child in jObject.Children<JProperty>() ->
+                    let callbackName = child.Name
+                    let callbackValue = child.Value |> string
+                    let callbackHandlerName = sprintf "%sHandler" callbackName
+
+                    seq {
+                        yield sprintf "A.CallTo(fun() -> %s.Invoke(A<obj>.``_``, %s)).MustHaveHappenedOnceExactly() |> ignore" callbackHandlerName callbackValue
+                        yield sprintf "Fake.ClearRecordedCalls(%s) |> ignore" callbackHandlerName
+                    }                
+            } |> Seq.concat
+        | _ -> Seq.empty
+
+    let renderExpectedCallbacksNotToBeCalled (jToken: JToken) =
+        match jToken with
+        | :? JArray as jArray -> 
+            jArray.ToObject<string list>() 
+            |> Seq.map (sprintf "A.CallTo(fun() -> %sHandler.Invoke(A<obj>.``_``, A<int>.``_``)).MustNotHaveHappened() |> ignore")
+        | _ -> Seq.empty
+
+    let renderSetValueOperation (op: JObject) = 
+        seq { 
+            let cellName = op.["cell"].ToObject<string>()
+            let cellValue = op.["value"].ToObject<int>()
+            yield sprintf "%s.Value <- %i" cellName cellValue
+            yield! renderExpectedCallbacks op.["expect_callbacks"]
+            yield! renderExpectedCallbacksNotToBeCalled op.["expect_callbacks_not_to_be_called"]
+        }
+
+    let renderAddCallbackOperation (op: JObject) =
+        seq { 
+            let callbackName = op.["name"].ToObject<string>()
+            let cellName = op.["cell"].ToObject<string>() 
+            let callbackHandlerName = sprintf "%sHandler" callbackName
+            yield sprintf "let %s = A.Fake<Handler<int>>()" callbackHandlerName
+            yield sprintf "%s.Changed.AddHandler %s" cellName callbackHandlerName 
+        }
+
+    let renderRemoveCallbackOperation (op: JObject) =
+        seq {
+            let cellName = op.["cell"].ToObject<string>()
+            let callbackName = op.["name"].ToObject<string>()
+            yield sprintf "%s.Changed.RemoveHandler %sHandler" cellName callbackName
+        }
+
+    let renderOperation (op: JObject) =
+        let opType = op.["type"].ToObject<string>()
+        match opType with
+        | "expect_cell_value" -> renderExpectedCellValueOperation op
+        | "set_value" -> renderSetValueOperation op
+        | "add_callback" -> renderAddCallbackOperation op
+        | "remove_callback" -> renderRemoveCallbackOperation op
+        | _ -> failwith "Unknown operation type"
+
+    let renderOperations canonicalDataCase = 
         canonicalDataCase.Input.["operations"] :?> JArray
-        // we can generate more than 1 line per operation
-        // so we need to flatten results here
-        // collect does it automatically for us 
-        // and every operation should emit seq<string>
-        |> Seq.collect (fun (opToken: JToken) -> 
-            let op = opToken :?> JObject
-            match op.["type"].ToObject<string>() with
-            | "expect_cell_value" -> seq { 
-                let cellName = op.["cell"].ToObject<string>()
-                let expectedValue = op.["value"].ToObject<int>()
-                yield sprintf "%s.Value |> should equal %i" cellName expectedValue }
-            | "set_value" -> seq { 
-                let cellName = op.["cell"].ToObject<string>()
-                let cellValue = op.["value"].ToObject<int>()
-                yield sprintf "%s.Value <- %i" cellName cellValue }
-            | "add_callback" -> seq { 
-                let callbackName = op.["name"].ToObject<string>()
-                let cellName = op.["cell"].ToObject<string>() 
-                let callback = 
-                    if canonicalDataCase.Description.Contains("do not report") then 
-                        "[value]" 
-                    else 
-                        sprintf "%s @ [value]" callbackName
-                yield sprintf "let mutable %s = []" callbackName 
-                yield sprintf "let %sHandler = Handler<int>(fun _ value -> %s <- %s)" callbackName callbackName callback
-                yield sprintf "%s.Changed.AddHandler %sHandler" cellName callbackName }
-            | "expect_callback_values" -> seq {
-                let callbackName = op.["callback"].ToObject<string>()
-                let callbackValues = op.["values"].ToObject<string[]>()
-                if callbackValues.Length = 0 then
-                    yield sprintf "%s |> should equal List.empty<int>" callbackName
-                else
-                    yield sprintf "%s |> should equal %s" callbackName (formatList callbackValues) }
-            | "remove_callback" -> seq {
-                let cellName = op.["cell"].ToObject<string>()
-                let callbackName = op.["name"].ToObject<string>()
-                yield sprintf "%s.Changed.RemoveHandler %sHandler" cellName callbackName }
-            | _ -> seq { yield "" }
-        )
+        |> Seq.cast<JObject>
+        |> Seq.collect renderOperation
         |> Seq.toList
 
+    override __.PropertiesWithIdentifier _ = []
+
     override __.RenderAssert _ = []
 
-    override this.RenderArrange canonicalDataCase =
-        let initialVars = this.RenderCells canonicalDataCase
-        let operations = this.RenderOperations canonicalDataCase
+    override __.RenderArrange canonicalDataCase =
+        let initialVars = renderCells canonicalDataCase
+        let operations = renderOperations canonicalDataCase
         initialVars @ operations
 
+    override __.AdditionalNamespaces = ["FakeItEasy"]
+
 type Rectangles() = 
     inherit GeneratorExercise()
 
@@ -1330,6 +1359,12 @@ type Sieve() =
 type SecretHandshake() =
     inherit GeneratorExercise()
 
+type Series() =
+    inherit GeneratorExercise()
+    
+    override __.RenderExpected (_, _, value) =
+        value |> Option.ofNonError |> formatValue |> parenthesizeOption
+
 type SpaceAge() =
     inherit GeneratorExercise()