trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/secret-handshake/SecretHandshake.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="SecretHandshake.fs" />
+    <Compile Include="SecretHandshakeTest.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/secret-handshake/SecretHandshakeTest.fs

@@ -1,39 +1,34 @@
-module SecretHandshakeTest
+module SecretHandshakeTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open SecretHandshake
 
-[<Test>]
+[<Fact>]
 let ``Test 1 handshake to wink`` () =
-    Assert.That(handshake 1, Is.EqualTo(["wink"]))
+    handshake 1 |> should equal ["wink"]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 10 handshake to double blink`` () =
-    Assert.That(handshake 2, Is.EqualTo(["double blink"]))
+    handshake 2 |> should equal ["double blink"]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 100 handshake to close your eyes`` () =
-    Assert.That(handshake 4, Is.EqualTo(["close your eyes"]))
+    handshake 4 |> should equal ["close your eyes"]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 1000 handshake to close your eyes`` () =
-    Assert.That(handshake 8, Is.EqualTo(["jump"]))
+    handshake 8 |> should equal ["jump"]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test handshake 11 to wink and double blink`` () =
-    Assert.That(handshake 3, Is.EqualTo(["wink"; "double blink"]))
+    handshake 3 |> should equal ["wink"; "double blink"]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test handshake 10011 to double blink and wink`` () =
-    Assert.That(handshake 19, Is.EqualTo(["double blink"; "wink"]))
+    handshake 19 |> should equal ["double blink"; "wink"]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test handshake 11111 to all commands reversed`` () =
-    Assert.That(handshake 31, Is.EqualTo(["jump"; "close your eyes"; "double blink"; "wink"]))
+    handshake 31 |> should equal ["jump"; "close your eyes"; "double blink"; "wink"]

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

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

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

@@ -0,0 +1,3 @@
+module Series
+
+let slices str length = failwith "You need to implement this function."

data/tracks/fsharp/exercises/series/Series.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Series.fs" />
+    <Compile Include="SeriesTest.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/series/SeriesTest.fs

@@ -1,72 +1,70 @@
 module SeriesTest
 
 open System
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Series
 
 type SeriesTests () =
     static member SliceOneTestData = 
-        [| 
-            ("01234", [[0]; [1]; [2]; [3]; [4]]);
-            ("92834", [[9]; [2]; [8]; [3]; [4]]) 
-        |]
+        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
 
-    [<TestCaseSource("SliceOneTestData")>]
-    member this.``Series of one splits to one digit`` (testData: string * int list list) =
-        let input, expected = testData
-        Assert.That(slices input 1, Is.EqualTo(expected))
+    [<Theory>]
+    [<MemberData("SliceOneTestData")>]
+    member this.``Series of one splits to one digit`` input expected =
+        slices input 1 |> should equal expected
 
-    static member SliceTwoTestData =
-        [| 
-            ("01234", [[0; 1]; [1; 2]; [2; 3]; [3; 4]]);
-            ("98273463", [[9; 8]; [8; 2]; [2; 7]; [7; 3]; [3; 4]; [4; 6]; [6; 3]]);
-            ("37103", [[3; 7]; [7; 1]; [1; 0]; [0; 3]])
-        |]
+    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
 
-    [<TestCaseSource("SliceTwoTestData")>]
-    [<Ignore("Remove to run test")>]  
-    member this.``Series of two splits to two digits`` (testData: string * int list list) =
-        let input, expected = testData
-        Assert.That(slices input 2, Is.EqualTo(expected))
+    [<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
 
-    static member SliceThreeTestData =
-        [| 
-            ("01234", [[0; 1; 2]; [1; 2; 3]; [2; 3; 4]]);
-            ("31001", [[3; 1; 0]; [1; 0; 0]; [0; 0; 1]]);
-            ("982347", [[9; 8; 2]; [8; 2; 3]; [2; 3; 4]; [3; 4; 7]])
-        |]
+    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
 
-    [<TestCaseSource("SliceThreeTestData")>]
-    [<Ignore("Remove to run test")>]
-    member this.``Series of three splits to three digits`` (testData: string * int list list) =
-        let input, expected = testData
-        Assert.That(slices input 3, Is.EqualTo(expected))
+    [<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
 
-    static member SliceFourTestData =
-        [| 
-            ("01234", [[0; 1; 2; 3]; [1; 2; 3; 4]]);
-            ("91274", [[9; 1; 2; 7]; [1; 2; 7; 4]])
-        |]
+    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
 
-    [<TestCaseSource("SliceFourTestData")>]
-    [<Ignore("Remove to run test")>]
-    member this.``Series of four splits to four digits`` (testData: string * int list list) =
-        let input, expected = testData
-        Assert.That(slices input 4, Is.EqualTo(expected))
+    [<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
 
-    static member SliceFiveTestData =
-        [| 
-            ("01234", [[0; 1; 2; 3; 4]]);
-            ("81228", [[8; 1; 2; 2; 8]])
-        |]
+    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
 
-    [<TestCaseSource("SliceFiveTestData")>]    
-    [<Ignore("Remove to run test")>]
-    member this.``Series of five splits to five digits`` (testData: string * int list list) =
-        let input, expected = testData
-        Assert.That(slices input 5, Is.EqualTo(expected))
+    [<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
 
-    [<TestCase("01234", 6, Ignore = "Remove to run test case")>]
-    [<TestCase("01032987583", 19, Ignore = "Remove to run test case")>]
-    member this.``Slice longer than input is not allowed`` (input, slice) =
-        Assert.That((fun () -> slices input slice |> ignore), Throws.Exception)
+    [<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/exercises/sgf-parsing/Program.fs

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

data/tracks/fsharp/exercises/sgf-parsing/SgfParsing.fs

@@ -0,0 +1,3 @@
+module SgfParsing
+
+// TODO: implement this module

data/tracks/fsharp/exercises/sgf-parsing/SgfParsing.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="SgfParsing.fs" />
+    <Compile Include="SgfParsingTest.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/sgf-parsing/SgfParsingTest.fs

@@ -1,6 +1,7 @@
-module SgfParsingTest
+module SgfParsingTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open SgfParsing
 
@@ -20,87 +21,76 @@ let treeWithChildren node children = mkTree (Map.ofList node) children
 let treeWithSingleChild node child = mkTree (Map.ofList node) [child]
 let treeWithNoChildren node = mkTree (Map.ofList node) []
 
-[<Test>]
+[<Fact>]
 let ``Empty value`` () =
     let input = "" 
     let expected = None
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Tree without nodes`` () =
     let input = "()"
     let expected = None
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Node without tree`` () =
     let input = ";"
     let expected = None
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Node without properties`` () =
     let input = "(;)"
     let expected = Some (treeWithNoChildren [])
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Single node tree`` () =
     let input = "(;A[B])"
     let expected = Some (treeWithNoChildren [("A", ["B"])])
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Properties without delimiter`` () =
     let input = "(;a)"
     let expected = None
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``All lowercase property`` () =
     let input = "(;a[b])"
     let expected = None
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Upper- and lowercase property`` () =
     let input = "(;Aa[b])"
     let expected = None
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two nodes`` () =
     let input = "(;A[B];B[C])"
     let expected = Some (treeWithSingleChild [("A", ["B"])] (treeWithNoChildren [("B", ["C"])]))
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two child trees`` () =
     let input = "(;A[B](;B[C])(;C[D]))"
     let expected = Some (treeWithChildren [("A", ["B"])]
                             [ treeWithNoChildren [("B", ["C"])]; 
                               treeWithNoChildren [("C", ["D"])] ])
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Multiple properties`` () =
     let input = "(;A[b][c][d])"
     let expected = Some (treeWithNoChildren [("A", ["b"; "c"; "d"])])
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Escaped property`` () =
     let input = @"(;A[\]b\nc\nd\t\te\\ \n\]])"
     let expected = Some (treeWithNoChildren [("A", [@"]b c d  e\  ]"])])
-    Assert.That(parseSgf input, Is.EqualTo(expected))
+    parseSgf input |> should equal expected

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

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

data/tracks/fsharp/exercises/sieve/Sieve.fs

@@ -0,0 +1,3 @@
+module Sieve
+
+let primesUpTo limit = failwith "You need to implement this function."

data/tracks/fsharp/exercises/sieve/Sieve.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Sieve.fs" />
+    <Compile Include="SieveTest.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/sieve/SieveTest.fs

@@ -1,31 +1,29 @@
 module SieveTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Sieve
 
-[<Test>]
+[<Fact>]
 let ``Finds first prime`` () =
-    Assert.That(primesUpTo 2, Is.EqualTo([ 2 ]))
+    primesUpTo 2 |> should equal [ 2 ]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Finds primes up to 10`` () =
-    Assert.That(primesUpTo 10, Is.EqualTo([ 2; 3; 5; 7 ]))
+    primesUpTo 10 |> should equal [ 2; 3; 5; 7 ]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Finds primes up to 1000`` () =
-    Assert.That(primesUpTo 1000,
-        Is.EqualTo(
-            [
-                2; 3; 5; 7; 11; 13; 17; 19; 23; 29; 31; 37; 41; 43; 47; 53; 59; 61; 67; 71; 73; 79; 83; 89; 97; 101;
-                103; 107; 109; 113; 127; 131; 137; 139; 149; 151; 157; 163; 167; 173; 179; 181; 191; 193; 197; 199;
-                211; 223; 227; 229; 233; 239; 241; 251; 257; 263; 269; 271; 277; 281; 283; 293; 307; 311; 313; 317;
-                331; 337; 347; 349; 353; 359; 367; 373; 379; 383; 389; 397; 401; 409; 419; 421; 431; 433; 439; 443;
-                449; 457; 461; 463; 467; 479; 487; 491; 499; 503; 509; 521; 523; 541; 547; 557; 563; 569; 571; 577;
-                587; 593; 599; 601; 607; 613; 617; 619; 631; 641; 643; 647; 653; 659; 661; 673; 677; 683; 691; 701;
-                709; 719; 727; 733; 739; 743; 751; 757; 761; 769; 773; 787; 797; 809; 811; 821; 823; 827; 829; 839;
-                853; 857; 859; 863; 877; 881; 883; 887; 907; 911; 919; 929; 937; 941; 947; 953; 967; 971; 977; 983;
-                991; 997
-            ]))
+    primesUpTo 1000 |> should equal 
+        [
+            2; 3; 5; 7; 11; 13; 17; 19; 23; 29; 31; 37; 41; 43; 47; 53; 59; 61; 67; 71; 73; 79; 83; 89; 97; 101;
+            103; 107; 109; 113; 127; 131; 137; 139; 149; 151; 157; 163; 167; 173; 179; 181; 191; 193; 197; 199;
+            211; 223; 227; 229; 233; 239; 241; 251; 257; 263; 269; 271; 277; 281; 283; 293; 307; 311; 313; 317;
+            331; 337; 347; 349; 353; 359; 367; 373; 379; 383; 389; 397; 401; 409; 419; 421; 431; 433; 439; 443;
+            449; 457; 461; 463; 467; 479; 487; 491; 499; 503; 509; 521; 523; 541; 547; 557; 563; 569; 571; 577;
+            587; 593; 599; 601; 607; 613; 617; 619; 631; 641; 643; 647; 653; 659; 661; 673; 677; 683; 691; 701;
+            709; 719; 727; 733; 739; 743; 751; 757; 761; 769; 773; 787; 797; 809; 811; 821; 823; 827; 829; 839;
+            853; 857; 859; 863; 877; 881; 883; 887; 907; 911; 919; 929; 937; 941; 947; 953; 967; 971; 977; 983;
+            991; 997
+        ]

data/tracks/fsharp/exercises/simple-cipher/Program.fs

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

data/tracks/fsharp/exercises/simple-cipher/SimpleCipher.fs

@@ -0,0 +1,7 @@
+module SimpleCipher
+        
+let encode key input = failwith "You need to implement this function."
+
+let decode key input = failwith "You need to implement this function."
+    
+let encodeRandom input = failwith "You need to implement this function."

data/tracks/fsharp/exercises/simple-cipher/SimpleCipher.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="SimpleCipher.fs" />
+    <Compile Include="SimpleCipherTest.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>