trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/bowling/BowlingTest.fs

@@ -1,174 +1,152 @@
-module BowlingTest
+module BowlingTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Bowling
 
 let rollMany rolls game = List.fold (fun game pins -> roll pins game) game rolls
 
-[<Test>]
+[<Fact>]
 let ``Should be able to score a game with all zeros`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 0))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 0
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Should be able to score a game with no strikes or spares`` () =
     let rolls = [3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 90))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 90
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``A spare followed by zeros is worth ten points`` () =
     let rolls = [6; 4; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 10))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 10
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Points scored in the roll after a spare are counted twice`` () =
     let rolls = [6; 4; 3; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 16))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 16
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Consecutive spares each get a one roll bonus`` () =
     let rolls = [5; 5; 3; 7; 4; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 31))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 31
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``A spare in the last frame gets a one roll bonus that is counted once`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 7; 3; 7]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 17))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 17
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``A strike earns ten points in frame with a single roll`` () =
     let rolls = [10; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 10))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 10
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Points scored in the two rolls after a strike are counted twice as a bonus`` () =
     let rolls = [10; 5; 3; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 26))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 26
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Consecutive strikes each get the two roll bonus`` () =
     let rolls = [10; 10; 10; 5; 3; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 81))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 81
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``A strike in the last frame gets a two roll bonus that is counted once`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 7; 1]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 18))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 18
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Rolling a spare with the two roll bonus does not get a bonus roll`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 7; 3]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 20))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 20
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Strikes with the two roll bonus do not get bonus rolls`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 10; 10]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 30))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 30
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``A strike with the one roll bonus after a spare in the last frame does not get a bonus`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 7; 3; 10]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 20))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 20
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``All strikes is a perfect game`` () =
     let rolls = [10; 10; 10; 10; 10; 10; 10; 10; 10; 10; 10; 10]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(Some 300))
+    let game = rollMany rolls (newGame())
+    score game |> should equal <| Some 300
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Rolls can not score negative points`` () =
     let rolls = [-1; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(None))
+    let game = rollMany rolls (newGame())
+    score game |> should equal None
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``A roll can not score more than 10 points`` () =
     let rolls = [11; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(None))
+    let game = rollMany rolls (newGame())
+    score game |> should equal None
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two rolls in a frame can not score more than 10 points`` () =
     let rolls = [5; 6; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(None))
+    let game = rollMany rolls (newGame())
+    score game |> should equal None
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two bonus rolls after a strike in the last frame can not score more than 10 points`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 5; 6]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(None))
+    let game = rollMany rolls (newGame())
+    score game |> should equal None
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``An unstarted game can not be scored`` () =
     let rolls = []
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(None))
+    let game = rollMany rolls (newGame())
+    score game |> should equal None
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``An incomplete game can not be scored`` () =
     let rolls = [0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(None))
+    let game = rollMany rolls (newGame())
+    score game |> should equal None
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``A game with more than ten frames can not be scored`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(None))
+    let game = rollMany rolls (newGame())
+    score game |> should equal None
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Bonus rolls for a strike in the last frame must be rolled before score can be calculated`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(None))
+    let game = rollMany rolls (newGame())
+    score game |> should equal None
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Both bonus rolls for a strike in the last frame must be rolled before score can be calculated`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 10]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(None))
+    let game = rollMany rolls (newGame())
+    score game |> should equal None
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Bonus roll for a spare in the last frame must be rolled before score can be calculated`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 7; 3]
-    let game = rollMany rolls newGame
-    Assert.That(score game, Is.EqualTo(None))
+    let game = rollMany rolls (newGame())
+    score game |> should equal None

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

@@ -9,7 +9,7 @@ let numberOfFrames = 10
 let maximumFrameScore = 10
 let minimumFrameScore = 0
 
-let newGame = Some []
+let newGame() = Some []
 
 let validatePins pins = 
     if pins < minimumFrameScore || pins > maximumFrameScore then 

data/tracks/fsharp/exercises/bowling/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

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

@@ -0,0 +1,3 @@
+module BracketPush
+
+let matched input = failwith "You need to implement this function."

data/tracks/fsharp/exercises/bracket-push/BracketPush.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="BracketPush.fs" />
+    <Compile Include="BracketPushTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
+    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

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

@@ -1,76 +1,66 @@
-module BracketPushTest
+module BracketPushTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open BracketPush
 
-[<Test>]
+[<Fact>]
 let ``Paired square brackets`` () =
     let actual ="[]"
-    Assert.That(matched actual, Is.True)
+    matched actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Empty string`` () =
     let actual =""
-    Assert.That(matched actual, Is.True)
+    matched actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Unpaired brackets`` () =
     let actual ="[["
-    Assert.That(matched actual, Is.False)
+    matched actual |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Wrong ordered brackets`` () =
     let actual ="}{"
-    Assert.That(matched actual, Is.False)
+    matched actual |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Paired with whitespace`` () =
     let actual ="{ }"
-    Assert.That(matched actual, Is.True)
+    matched actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Simple nested brackets`` () =
     let actual ="{[]}"
-    Assert.That(matched actual, Is.True)
+    matched actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Several paired brackets`` () =
     let actual ="{}[]"
-    Assert.That(matched actual, Is.True)
+    matched actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Paired and nested brackets`` () =
     let actual ="([{}({}[])])"
-    Assert.That(matched actual, Is.True)
+    matched actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Unpaired and nested brackets`` () =
     let actual ="([{])"
-    Assert.That(matched actual, Is.False)
+    matched actual |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Paired and wrong nested brackets`` () =
     let actual ="[({]})"
-    Assert.That(matched actual, Is.False)
+    matched actual |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Math expression`` () =
     let actual ="(((185 + 223.85) * 15) - 543)/2"
-    Assert.That(matched actual, Is.True)
+    matched actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Complex latex expression`` () =
     let actual ="\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)"
-    Assert.That(matched actual, Is.True)
+    matched actual |> should equal true

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

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/change/Change.fs

@@ -0,0 +1,3 @@
+module Change
+
+let change target coins = failwith "You need to implement this function."

data/tracks/fsharp/exercises/change/Change.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Change.fs" />
+    <Compile Include="ChangeTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
+    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/fsharp/exercises/change/ChangeTest.fs

@@ -1,68 +1,62 @@
-module ChangeTest
+module ChangeTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Change
 
-[<Test>]
+[<Fact>]
 let ``Single coin change`` () =
     let actual = [1; 5; 10; 25; 100]
     let target = 25
     let expected = Some [25]
-    Assert.That(change target actual, Is.EqualTo(expected))
+    change target actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Multiple coin change`` () =
     let actual = [1; 5; 10; 25; 100]
     let target = 15
     let expected = Some [5; 10]
-    Assert.That(change target actual, Is.EqualTo(expected))
+    change target actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Change with Lilliputian Coins`` () =
     let actual = [1; 4; 15; 20; 50]
     let target = 23
     let expected = Some [4; 4; 15]
-    Assert.That(change target actual, Is.EqualTo(expected))
+    change target actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Change with Lower Elbonia Coins`` () =
     let actual = [1; 5; 10; 21; 25]
     let target = 63
     let expected = Some [21; 21; 21]
-    Assert.That(change target actual, Is.EqualTo(expected))
+    change target actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Large target values`` () =
     let actual = [1; 2; 5; 10; 20; 50; 100]
     let target = 999
     let expected = Some [2; 2; 5; 20; 20; 50; 100; 100; 100; 100; 100; 100; 100; 100; 100]
-    Assert.That(change target actual, Is.EqualTo(expected))
+    change target actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``No coins make 0 change`` () =
     let actual = [1; 5; 10; 21; 25]
     let target = 0
     let (expected: int list option) = Some []
-    Assert.That(change target actual, Is.EqualTo(expected))
+    change target actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Error testing for change smaller than the smallest of coins`` () =
     let actual = [5; 10]
     let target = 3
     let expected = None
-    Assert.That(change target actual, Is.EqualTo(expected))
+    change target actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cannot find negative change values`` () =
     let actual = [1; 2; 5]
     let target = -5
     let expected = None
-    Assert.That(change target actual, Is.EqualTo(expected))
+    change target actual |> should equal expected

data/tracks/fsharp/exercises/change/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/circular-buffer/CircularBuffer.fs

@@ -0,0 +1,11 @@
+module CircularBuffer
+
+let mkCircularBuffer size = failwith "You need to implement this function."
+
+let clear buffer = failwith "You need to implement this function."
+
+let write value buffer = failwith "You need to implement this function."
+        
+let forceWrite value buffer = failwith "You need to implement this function."
+
+let read buffer = failwith "You need to implement this function."

data/tracks/fsharp/exercises/circular-buffer/CircularBuffer.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="CircularBuffer.fs" />
+    <Compile Include="CircularBufferTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
+    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>