trackler 2.2.1.22 → 2.2.1.23

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

@@ -1,113 +1,98 @@
 module SimpleCipherTest
 
 open System
-open NUnit.Framework
+open System.Text.RegularExpressions
+open Xunit
+open FsUnit.Xunit
 
 open SimpleCipher
 
 let plainText = "abcdefghij"
 let key = "abcdefghij";
 
-[<Test>]
+[<Fact>]
 let ``Encode random uses key made of letters`` () =
     let (key, _) = encodeRandom plainText
-    Assert.That(key, Does.Match("[a-z]+"))
+    Regex.IsMatch(key, "[a-z]+") |> should equal true
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode random uses key of 100 characters`` () =
     let (key, _) = encodeRandom plainText
-    Assert.That(key, Has.Length.EqualTo(100))
+    key |> should haveLength 100
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode random uses randomly generated key`` () =
     let keys = List.init 100 (fun _ -> encodeRandom plainText |> fst)
-    Assert.That(keys |> List.distinct, Is.EqualTo(keys))
+    keys |> List.distinct |> should equal keys
 
 // Here we take advantage of the fact that plaintext of "aaa..." outputs
 // the key. This is a critical problem with shift ciphers, some characters
 // will always output the key verbatim.
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode random can encode`` () =
     let (key, encoded) = encodeRandom "aaaaaaaaaa"
-    Assert.That(encoded, Is.EqualTo(key.Substring(0, 10)))
+    encoded |> should equal <| key.Substring(0, 10)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode random can decode`` () =    
     let (key, _) = encodeRandom "aaaaaaaaaa"
-    Assert.That(decode key (key.Substring(0, 10)), Is.EqualTo("aaaaaaaaaa"))
+    decode key (key.Substring(0, 10)) |> should equal "aaaaaaaaaa"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode random is reversible`` () =
     let (key, encoded) = encodeRandom plainText
-    Assert.That(decode key encoded, Is.EqualTo(plainText))
+    decode key encoded |> should equal plainText
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cipher can encode with given key`` () =
-    Assert.That(encode key "aaaaaaaaaa", Is.EqualTo("abcdefghij"))
+    encode key "aaaaaaaaaa" |> should equal "abcdefghij"
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cipher can decode with given key`` () =
-    Assert.That(decode key "abcdefghij", Is.EqualTo("aaaaaaaaaa"))
+    decode key "abcdefghij" |> should equal "aaaaaaaaaa"
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cipher is reversible given key`` () =
-    Assert.That(encode key plainText |> decode key, Is.EqualTo(plainText))
+    encode key plainText |> decode key |> should equal plainText
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cipher can double shift encode`` () =
     let plainText = "iamapandabear"
-    Assert.That(encode plainText plainText, Is.EqualTo("qayaeaagaciai"))
+    encode plainText plainText |> should equal "qayaeaagaciai"
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cipher can wrap encode`` () =
-    Assert.That(encode key "zzzzzzzzzz", Is.EqualTo("zabcdefghi"))
+    encode key "zzzzzzzzzz" |> should equal "zabcdefghi"
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cipher can encode a message that is shorter than the key`` () =
-    Assert.That(encode key "aaaaa", Is.EqualTo("abcde"))
+    encode key "aaaaa" |> should equal "abcde"
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cipher can decode a message that is shorter than the key`` () =
-    Assert.That(decode key "abcde", Is.EqualTo("aaaaa"))
+    decode key "abcde" |> should equal "aaaaa"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode throws with an all caps key`` () =
     let key = "ABCDEF"
-    Assert.That((fun () -> encode key plainText |> ignore), Throws.Exception)
+    (fun () -> encode key plainText |> ignore) |> should throw typeof<Exception>
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode throws with any caps key`` () =
     let key = "abcdEFg"
-    Assert.That((fun () -> encode key plainText |> ignore), Throws.Exception)
+    (fun () -> encode key plainText |> ignore) |> should throw typeof<Exception>
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode throws with numeric key`` () =
     let key = "12345"
-    Assert.That((fun () -> encode key plainText |> ignore), Throws.Exception)
+    (fun () -> encode key plainText |> ignore) |> should throw typeof<Exception>
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode throws with any numeric key`` () =
     let key = "abcd345ef"
-    Assert.That((fun () -> encode key plainText |> ignore), Throws.Exception)
+    (fun () -> encode key plainText |> ignore) |> should throw typeof<Exception>
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode throws with empty key`` () =
     let key = ""
-    Assert.That((fun () -> encode key plainText |> ignore), Throws.Exception)
+    (fun () -> encode key plainText |> ignore) |> should throw typeof<Exception>

data/tracks/fsharp/exercises/simple-linked-list/Program.fs

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

data/tracks/fsharp/exercises/simple-linked-list/SimpleLinkedList.fs

@@ -0,0 +1,36 @@
+module SimpleLinkedList
+
+type LinkedList<'a> = 
+    | Nil 
+    | Element of datum:'a * next:LinkedList<'a>
+
+let nil = Nil
+
+let create x n = Element (x, n)
+
+let isNil x = 
+    match x with
+    | Nil -> true
+    | _   -> false
+
+let next x = 
+    match x with
+    | Nil -> Nil
+    | Element (_, n) -> n
+
+let datum x = 
+    match x with
+    | Nil -> failwith "The nil list has no datum."
+    | Element (y, _) -> y
+
+let toList x = 
+    let rec loop acc item = 
+        match item with
+        | Nil -> acc |> List.rev
+        | Element (b, n) -> loop (b :: acc) n
+
+    loop [] x
+
+let fromList xs = List.foldBack create xs Nil
+
+let reverse x = x |> toList |> List.rev |> fromList

data/tracks/fsharp/exercises/simple-linked-list/SimpleLinkedList.fsproj

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

@@ -1,75 +1,71 @@
-module SimpleLinkedListTest
+module SimpleLinkedListTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open SimpleLinkedList
 
-[<Test>]
+[<Fact>]
 let ``Empty list`` () =
     let list = nil
-    Assert.That(isNil list, Is.True)
+    isNil list |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Single item list value`` () =
     let list = create 1 nil
-    Assert.That(datum list, Is.EqualTo(1))
+    datum list |> should equal 1
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Single item list has no next item`` () =
     let list = create 1 nil
-    Assert.That(next list |> isNil, Is.True)
+    next list |> isNil |> should equal true
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two item list first value`` () =
     let list = create 2 (create 1 nil)
-    Assert.That(datum list, Is.EqualTo(2))
+    datum list |> should equal 2
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two item list second value`` () =
     let list = create 2 (create 1 nil)
-    Assert.That(next list |> datum, Is.EqualTo(1))
+    next list |> datum |> should equal 1
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two item list second item has no next`` () =
     let list = create 2 (create 1 nil)
-    Assert.That(next list |> next |> isNil, Is.True)
+    next list |> next |> isNil |> should equal true
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``To list`` () =
     let values = create 2 (create 1 nil) |> toList
-    Assert.That(values, Is.EqualTo([2; 1]))
+    values |> should equal [2; 1]
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``From list`` () =
     let list = fromList [11; 7; 5; 3; 2]
-    Assert.That(list |> datum, Is.EqualTo(11))
-    Assert.That(list |> next |> datum, Is.EqualTo(7))
-    Assert.That(list |> next |> next |> datum, Is.EqualTo(5))
-    Assert.That(list |> next |> next |> next |> datum, Is.EqualTo(3))
-    Assert.That(list |> next |> next |> next |> next |> datum, Is.EqualTo(2))
-    
-[<TestCase(1, Ignore = "Remove to run test case")>]
-[<TestCase(2, Ignore = "Remove to run test case")>]
-[<TestCase(10, Ignore = "Remove to run test case")>]
-[<TestCase(100, Ignore = "Remove to run test case")>]
+    list |> datum |> should equal 11
+    list |> next |> datum |> should equal 7
+    list |> next |> next |> datum |> should equal 5
+    list |> next |> next |> next |> datum |> should equal 3
+    list |> next |> next |> next |> next |> datum |> should equal 2
+
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(1)>]
+[<InlineData(2)>]
+[<InlineData(10)>]
+[<InlineData(100)>]
 let ``Reverse`` (length: int) =
     let values = [1..length]
     let list = fromList values
     let reversed = reverse list
-    Assert.That(reversed |> toList, Is.EqualTo(values |> List.rev))
+    reversed |> toList |> should equal <| List.rev values 
     
-[<TestCase(1, Ignore = "Remove to run test case")>]
-[<TestCase(2, Ignore = "Remove to run test case")>]
-[<TestCase(10, Ignore = "Remove to run test case")>]
-[<TestCase(100, Ignore = "Remove to run test case")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(1)>]
+[<InlineData(2)>]
+[<InlineData(10)>]
+[<InlineData(100)>]
 let ``Roundtrip`` (length: int) =
     let values = [1..length]
     let listValues = fromList values
-    Assert.That(listValues |> toList, Is.EqualTo(values))
+    listValues |> toList |> should equal values

data/tracks/fsharp/exercises/space-age/Program.fs

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

data/tracks/fsharp/exercises/space-age/SpaceAge.fs

@@ -0,0 +1,5 @@
+module SpaceAge
+
+// TODO: define the Planet type
+
+let spaceAge (planet: Planet) (seconds: decimal): decimal = failwith "You need to implement this function."

data/tracks/fsharp/exercises/space-age/SpaceAge.fsproj

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

@@ -1,58 +1,52 @@
-module SpaceAgeTest
+module SpaceAgeTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open SpaceAge
     
-[<Test>]
+[<Fact>]
 let ``Age on earth`` () =
     let seconds = 1000000000m
-    Assert.That(spaceAge Planet.Earth seconds, Is.EqualTo(31.69m))
+    spaceAge Planet.Earth seconds |> should equal 31.69m
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Age on mercury`` () =
     let seconds = 2134835688m
-    Assert.That(spaceAge Planet.Earth seconds, Is.EqualTo(67.65m))
-    Assert.That(spaceAge Planet.Mercury seconds, Is.EqualTo(280.88m))
+    spaceAge Planet.Earth seconds |> should equal 67.65m
+    spaceAge Planet.Mercury seconds |> should equal 280.88m
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Age on venus`` () =
     let seconds = 189839836m
-    Assert.That(spaceAge Planet.Earth seconds, Is.EqualTo(6.02m))
-    Assert.That(spaceAge Planet.Venus seconds, Is.EqualTo(9.78m))
+    spaceAge Planet.Earth seconds |> should equal 6.02m
+    spaceAge Planet.Venus seconds |> should equal 9.78m
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Age on mars`` () =
     let seconds = 2329871239m
-    Assert.That(spaceAge Planet.Earth seconds, Is.EqualTo(73.83m))
-    Assert.That(spaceAge Planet.Mars seconds, Is.EqualTo(39.25m))
+    spaceAge Planet.Earth seconds |> should equal 73.83m
+    spaceAge Planet.Mars seconds |> should equal 39.25m
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Age on jupiter`` () =
     let seconds = 901876382m
-    Assert.That(spaceAge Planet.Earth seconds, Is.EqualTo(28.58m))
-    Assert.That(spaceAge Planet.Jupiter seconds, Is.EqualTo(2.41m))
+    spaceAge Planet.Earth seconds |> should equal 28.58m
+    spaceAge Planet.Jupiter seconds |> should equal 2.41m
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Age on saturn`` () =
     let seconds = 3000000000m
-    Assert.That(spaceAge Planet.Earth seconds, Is.EqualTo(95.06m))
-    Assert.That(spaceAge Planet.Saturn seconds, Is.EqualTo(3.23m))
+    spaceAge Planet.Earth seconds |> should equal 95.06m
+    spaceAge Planet.Saturn seconds |> should equal 3.23m
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Age on uranus`` () =
     let seconds = 3210123456m
-    Assert.That(spaceAge Planet.Earth seconds, Is.EqualTo(101.72m))
-    Assert.That(spaceAge Planet.Uranus seconds, Is.EqualTo(1.21m))
+    spaceAge Planet.Earth seconds |> should equal 101.72m
+    spaceAge Planet.Uranus seconds |> should equal 1.21m
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Age on neptune`` () =
     let seconds = 8210123456m
-    Assert.That(spaceAge Planet.Earth seconds, Is.EqualTo(260.16m))
-    Assert.That(spaceAge Planet.Neptune seconds, Is.EqualTo(1.58m))
+    spaceAge Planet.Earth seconds |> should equal 260.16m
+    spaceAge Planet.Neptune seconds |> should equal 1.58m

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

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

data/tracks/fsharp/exercises/strain/Strain.fs

@@ -0,0 +1,5 @@
+module Seq
+
+let keep pred xs = failwith "You need to implement this function."
+
+let discard pred xs = failwith "You need to implement this function."

data/tracks/fsharp/exercises/strain/Strain.fsproj

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

@@ -1,44 +1,31 @@
 module StrainTest
 
 open System.Collections.Specialized
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
-// Note: to add your own functions to an existing module, just put your 
-// functions in a module matching the existing module name. Your code
-// should thus look something like this:
-
-// module Seq
-//
-// let keep pred xs = ???
-// let discard pred xs = ???
-
-[<Test>]
+[<Fact>]
 let ``Empty keep`` () =
-    Assert.That([] |> Seq.keep (fun x -> x < 10), Is.EqualTo([]))
+    [] |> Seq.keep (fun x -> x < 10) |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]  
+[<Fact(Skip = "Remove to run test")>]  
 let ``Keep everything`` () =
-    Assert.That(set [1; 2; 3] |> Seq.keep (fun x -> x < 10), Is.EqualTo(set [1; 2; 3]))
+    set [1; 2; 3] |> Seq.keep (fun x -> x < 10) |> Seq.toList |> should equal <| [1; 2; 3]
 
-[<Test>]
-[<Ignore("Remove to run test")>] 
+[<Fact(Skip = "Remove to run test")>] 
 let ``Keep first and last`` () =
-    Assert.That([|1; 2; 3|] |> Seq.keep (fun x -> x % 2 <> 0), Is.EqualTo([|1; 3|]))
+    [|1; 2; 3|] |> Seq.keep (fun x -> x % 2 <> 0) |> Seq.toList |> should equal [1; 3]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Keep neither first nor last`` () =
-    Assert.That([1; 2; 3; 4; 5] |> Seq.keep (fun x -> x % 2 = 0), Is.EqualTo([2; 4]))
+    [1; 2; 3; 4; 5] |> Seq.keep (fun x -> x % 2 = 0) |> Seq.toList |> should equal [2; 4]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Keep strings`` () =
     let words = "apple zebra banana zombies cherimoya zelot".Split(' ');
-    Assert.That(words |> Seq.keep (fun (x:string) -> x.StartsWith("z")), Is.EqualTo("zebra zombies zelot".Split(' ')))
+    words |> Seq.keep (fun (x:string) -> x.StartsWith("z")) |> Seq.toList |> should equal <| List.ofArray("zebra zombies zelot".Split(' '))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Keep arrays`` () =
     let actual = [|
                     [|1; 2; 3|];
@@ -49,37 +36,31 @@ let ``Keep arrays`` () =
                     [|2; 2; 1|];
                     [|1; 2; 5|]
                     |]
-    let expected = [| [|5; 5; 5|]; [|5; 1; 2|]; [|1; 5; 2|]; [|1; 2; 5|] |]
-    Assert.That(actual |> Seq.keep (Array.exists ((=) 5)), Is.EqualTo(expected))
+    let expected = [ [|5; 5; 5|]; [|5; 1; 2|]; [|1; 5; 2|]; [|1; 2; 5|] ]
+    actual |> Seq.keep (Array.exists ((=) 5)) |> Seq.toList |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Empty discard`` () =
-    Assert.That([] |> Seq.discard (fun x -> x < 10), Is.EqualTo([]))
+    [] |> Seq.discard (fun x -> x < 10) |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Discard nothing`` () =
-    Assert.That(set [1; 2; 3] |> Seq.discard (fun x -> x > 10), Is.EqualTo(set [1; 2; 3]))
+    set [1; 2; 3] |> Seq.discard (fun x -> x > 10) |> Seq.toList |> should equal <| [1; 2; 3]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Discard first and last`` () =
-    Assert.That([|1; 2; 3|] |> Seq.discard (fun x -> x % 2 <> 0), Is.EqualTo([|2|]))
+    [|1; 2; 3|] |> Seq.discard (fun x -> x % 2 <> 0) |> Seq.toList |> should equal [2]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Discard neither first nor last`` () =
-    Assert.That([1; 2; 3; 4; 5] |> Seq.discard (fun x -> x % 2 = 0), Is.EqualTo([1; 3; 5]))
+    [1; 2; 3; 4; 5] |> Seq.discard (fun x -> x % 2 = 0) |> Seq.toList |> should equal [1; 3; 5]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Discard strings`` () =
     let words = "apple zebra banana zombies cherimoya zelot".Split(' ')
-    Assert.That(words |> Seq.discard (fun (x:string) -> x.StartsWith("z")), Is.EqualTo("apple banana cherimoya".Split(' ')))
+    words |> Seq.discard (fun (x:string) -> x.StartsWith("z")) |> Seq.toList |> should equal <| List.ofArray("apple banana cherimoya".Split(' '))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Discard arrays`` () =
     let actual = [|
                     [|1; 2; 3|];
@@ -90,5 +71,5 @@ let ``Discard arrays`` () =
                     [|2; 2; 1|];
                     [|1; 2; 5|]
                     |]
-    let expected = [| [|1; 2; 3|]; [|2; 1; 2|]; [|2; 2; 1|] |]
-    Assert.That(actual |> Seq.discard (Array.exists ((=) 5)), Is.EqualTo(expected))
+    let expected = [ [|1; 2; 3|]; [|2; 1; 2|]; [|2; 2; 1|] ]
+    actual |> Seq.discard (Array.exists ((=) 5)) |> Seq.toList |> should equal expected

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

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

data/tracks/fsharp/exercises/sublist/Sublist.fs

@@ -0,0 +1,5 @@
+module Sublist
+
+type Sublist = Equal | Sublist | Superlist | Unequal
+
+let sublist xs ys = failwith "You need to implement this function."

data/tracks/fsharp/exercises/sublist/Sublist.fsproj

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