trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/two-bucket/TwoBucketTest.fs

@@ -1,10 +1,11 @@
-module TwoBucketTest
+module TwoBucketTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open TwoBucket
 
-[<Test>]
+[<Fact>]
 let ``First example``() =
     let bucketOneSize = 3
     let bucketTwoSize = 5
@@ -12,10 +13,9 @@ let ``First example``() =
     let startBucket = Bucket.One
 
     let actual = moves bucketOneSize bucketTwoSize goal startBucket
-    Assert.That(actual, Is.EqualTo(Some (4, Bucket.One, 5)))
+    actual |> should equal <| Some (4, Bucket.One, 5)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Second example``() =
     let bucketOneSize = 3
     let bucketTwoSize = 5
@@ -23,10 +23,9 @@ let ``Second example``() =
     let startBucket = Bucket.Two
 
     let actual = moves bucketOneSize bucketTwoSize goal startBucket
-    Assert.That(actual, Is.EqualTo(Some (8, Bucket.Two, 3)))
+    actual |> should equal <| Some (8, Bucket.Two, 3)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Third example``() =
     let bucketOneSize = 7
     let bucketTwoSize = 11
@@ -34,10 +33,9 @@ let ``Third example``() =
     let startBucket = Bucket.One
 
     let actual = moves bucketOneSize bucketTwoSize goal startBucket
-    Assert.That(actual, Is.EqualTo(Some (14, Bucket.One, 11)))
+    actual |> should equal <| Some (14, Bucket.One, 11)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Fourth example``() =
     let bucketOneSize = 7
     let bucketTwoSize = 11
@@ -45,4 +43,4 @@ let ``Fourth example``() =
     let startBucket = Bucket.Two
 
     let actual = moves bucketOneSize bucketTwoSize goal startBucket
-    Assert.That(actual, Is.EqualTo(Some (18, Bucket.Two, 7)))
+    actual |> should equal <| Some (18, Bucket.Two, 7)

data/tracks/fsharp/exercises/two-fer/Program.fs

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

data/tracks/fsharp/exercises/two-fer/TwoFer.fs

@@ -0,0 +1,3 @@
+module TwoFer
+
+let getResponse (input: string option): string = failwith "You need to implement this function."

data/tracks/fsharp/exercises/two-fer/TwoFer.fsproj

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

@@ -1,19 +1,18 @@
-module TwoFerTest
+module TwoFerTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open TwoFer
 
-[<Test>]
+[<Fact>]
 let ``No name given`` () =
-    Assert.That(getResponse None, Is.EqualTo("One for you, one for me."))
+    getResponse None |> should equal "One for you, one for me."
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``A name given`` () =
-    Assert.That(getResponse (Some "Alice"), Is.EqualTo("One for Alice, one for me."))
+    getResponse (Some "Alice") |> should equal "One for Alice, one for me."
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Another name given`` () =
-    Assert.That(getResponse (Some "Bob"), Is.EqualTo("One for Bob, one for me."))
+    getResponse (Some "Bob") |> should equal "One for Bob, one for me."

data/tracks/fsharp/exercises/variable-length-quantity/Program.fs

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

data/tracks/fsharp/exercises/variable-length-quantity/VariableLengthQuantity.fs

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

data/tracks/fsharp/exercises/variable-length-quantity/VariableLengthQuantity.fsproj

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

@@ -1,76 +1,68 @@
-module VariableLengthQuantityTest
+module VariableLengthQuantityTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
+open System
 
 open VariableLengthQuantity
 
-[<Test>]
+[<Fact>]
 let ``To single byte`` () =
-    Assert.That(toBytes [0x00u], Is.EqualTo([0x00uy]))
-    Assert.That(toBytes [0x40u], Is.EqualTo([0x40uy]))
-    Assert.That(toBytes [0x7fu], Is.EqualTo([0x7fuy]))
+    toBytes [0x00u] |> should equal [0x00uy]
+    toBytes [0x40u] |> should equal [0x40uy]
+    toBytes [0x7fu] |> should equal [0x7fuy]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``To double byte`` () =
-    Assert.That(toBytes [0x80u], Is.EqualTo([0x81uy; 0x00uy]))
-    Assert.That(toBytes [0x2000u], Is.EqualTo([0xc0uy; 0x00uy]))
-    Assert.That(toBytes [0x3fffu], Is.EqualTo([0xffuy; 0x7fuy]))
+    toBytes [0x80u] |> should equal [0x81uy; 0x00uy]
+    toBytes [0x2000u] |> should equal [0xc0uy; 0x00uy]
+    toBytes [0x3fffu] |> should equal [0xffuy; 0x7fuy]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``To triple byte`` () =
-    Assert.That(toBytes [0x4000u], Is.EqualTo([0x81uy; 0x80uy; 0x00uy]))
-    Assert.That(toBytes [0x100000u], Is.EqualTo([0xc0uy; 0x80uy; 0x00uy]))
-    Assert.That(toBytes [0x1fffffu], Is.EqualTo([0xffuy; 0xffuy; 0x7fuy]))
+    toBytes [0x4000u] |> should equal [0x81uy; 0x80uy; 0x00uy]
+    toBytes [0x100000u] |> should equal [0xc0uy; 0x80uy; 0x00uy]
+    toBytes [0x1fffffu] |> should equal [0xffuy; 0xffuy; 0x7fuy]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``To quadruple byte`` () =
-    Assert.That(toBytes [0x200000u], Is.EqualTo([0x81uy; 0x80uy; 0x80uy; 0x00uy]))
-    Assert.That(toBytes [0x08000000u], Is.EqualTo([0xc0uy; 0x80uy; 0x80uy; 0x00uy]))
-    Assert.That(toBytes [0x0fffffffu], Is.EqualTo([0xffuy; 0xffuy; 0xffuy; 0x7fuy]))
+    toBytes [0x200000u] |> should equal [0x81uy; 0x80uy; 0x80uy; 0x00uy]
+    toBytes [0x08000000u] |> should equal [0xc0uy; 0x80uy; 0x80uy; 0x00uy]
+    toBytes [0x0fffffffu] |> should equal [0xffuy; 0xffuy; 0xffuy; 0x7fuy]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``To quintuple byte`` () =
-    Assert.That(toBytes [0x10000000u], Is.EqualTo([0x81uy; 0x80uy; 0x80uy; 0x80uy; 0x00uy]))
-    Assert.That(toBytes [0xff000000u], Is.EqualTo([0x8fuy; 0xf8uy; 0x80uy; 0x80uy; 0x00uy]))
-    Assert.That(toBytes [0xffffffffu], Is.EqualTo([0x8fuy; 0xffuy; 0xffuy; 0xffuy; 0x7fuy]))
+    toBytes [0x10000000u] |> should equal [0x81uy; 0x80uy; 0x80uy; 0x80uy; 0x00uy]
+    toBytes [0xff000000u] |> should equal [0x8fuy; 0xf8uy; 0x80uy; 0x80uy; 0x00uy]
+    toBytes [0xffffffffu] |> should equal [0x8fuy; 0xffuy; 0xffuy; 0xffuy; 0x7fuy]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``From bytes`` () =
-    Assert.That(fromBytes [0x7fuy], Is.EqualTo([0x7fu]))
-    Assert.That(fromBytes [0xc0uy; 0x00uy], Is.EqualTo([0x2000u]))
-    Assert.That(fromBytes [0xffuy; 0xffuy; 0x7fuy], Is.EqualTo([0x1fffffu]))
-    Assert.That(fromBytes [0x81uy; 0x80uy; 0x80uy; 0x00uy], Is.EqualTo([0x200000u]))
-    Assert.That(fromBytes [0x8fuy; 0xffuy; 0xffuy; 0xffuy; 0x7fuy], Is.EqualTo([0xffffffffu]))
+    fromBytes [0x7fuy] |> should equal [0x7fu]
+    fromBytes [0xc0uy; 0x00uy] |> should equal [0x2000u]
+    fromBytes [0xffuy; 0xffuy; 0x7fuy] |> should equal [0x1fffffu]
+    fromBytes [0x81uy; 0x80uy; 0x80uy; 0x00uy] |> should equal [0x200000u]
+    fromBytes [0x8fuy; 0xffuy; 0xffuy; 0xffuy; 0x7fuy] |> should equal [0xffffffffu]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``To bytes multiple values`` () =
-    Assert.That(toBytes [0x40u; 0x7fu], Is.EqualTo([0x40uy; 0x7fuy]))
-    Assert.That(toBytes [0x4000u; 0x123456u], Is.EqualTo([0x81uy; 0x80uy; 0x00uy; 0xc8uy; 0xe8uy; 0x56uy]))
-    Assert.That(toBytes [0x2000u; 0x123456u; 0x0fffffffu; 0x00u; 0x3fffu; 0x4000u], Is.EqualTo([0xc0uy; 0x00uy; 0xc8uy; 0xe8uy; 0x56uy; 0xffuy; 0xffuy; 0xffuy; 0x7fuy; 0x00uy; 0xffuy; 0x7fuy; 0x81uy; 0x80uy; 0x00uy]))
+    toBytes [0x40u; 0x7fu] |> should equal [0x40uy; 0x7fuy]
+    toBytes [0x4000u; 0x123456u] |> should equal [0x81uy; 0x80uy; 0x00uy; 0xc8uy; 0xe8uy; 0x56uy]
+    toBytes [0x2000u; 0x123456u; 0x0fffffffu; 0x00u; 0x3fffu; 0x4000u] |> should equal [0xc0uy; 0x00uy; 0xc8uy; 0xe8uy; 0x56uy; 0xffuy; 0xffuy; 0xffuy; 0x7fuy; 0x00uy; 0xffuy; 0x7fuy; 0x81uy; 0x80uy; 0x00uy]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``From bytes multiple values`` () =
-    Assert.That(fromBytes [0xc0uy; 0x00uy; 0xc8uy; 0xe8uy; 0x56uy; 0xffuy; 0xffuy; 0xffuy; 0x7fuy; 0x00uy; 0xffuy; 0x7fuy; 0x81uy; 0x80uy; 0x00uy], Is.EqualTo([0x2000u; 0x123456u; 0x0fffffffu; 0x00u; 0x3fffu; 0x4000u]))
+    fromBytes [0xc0uy; 0x00uy; 0xc8uy; 0xe8uy; 0x56uy; 0xffuy; 0xffuy; 0xffuy; 0x7fuy; 0x00uy; 0xffuy; 0x7fuy; 0x81uy; 0x80uy; 0x00uy] |> should equal [0x2000u; 0x123456u; 0x0fffffffu; 0x00u; 0x3fffu; 0x4000u]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Incomplete byte sequence`` () =
-    Assert.That((fun () -> fromBytes [0xffuy] |> ignore), Throws.Exception)
+    (fun () -> fromBytes [0xffuy] |> ignore) |> should throw typeof<Exception>
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Overflow`` () =    
-    Assert.That((fun () -> fromBytes [0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x7fuy] |> ignore), Throws.Exception)
+    (fun () -> fromBytes [0xffuy; 0xffuy; 0xffuy; 0xffuy; 0x7fuy] |> ignore) |> should throw typeof<Exception>
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Chained execution is identity`` () =
     let test = [0xf2u; 0xf6u; 0x96u; 0x9cu; 0x3bu; 0x39u; 0x2eu; 0x30u; 0xb3u; 0x24u];
-    Assert.That(toBytes test |> fromBytes, Is.EqualTo(test))
+    toBytes test |> fromBytes |> should equal test

data/tracks/fsharp/exercises/word-count/Program.fs

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

data/tracks/fsharp/exercises/word-count/WordCount.fs

@@ -0,0 +1,3 @@
+module Phrase
+
+let wordCount phrase = failwith "You need to implement this function."

data/tracks/fsharp/exercises/word-count/WordCount.fsproj

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

@@ -1,27 +1,26 @@
-module WordCountTest
+module WordCountTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Phrase
 
-[<Test>]
+[<Fact>]
 let ``Count one word`` () =
     let phrase = "word"
     let counts = Map.ofSeq [("word", 1)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Count one of each`` () =
     let phrase = "one of each"
     let counts = Map.ofSeq [("one",  1);
                             ("of",   1);
                             ("each", 1)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Count multiple occurrences`` () =
     let phrase = "one fish two fish red fish blue fish"
     let counts = Map.ofSeq [("one",  1);
@@ -30,10 +29,9 @@ let ``Count multiple occurrences`` () =
                             ("red",  1);
                             ("blue", 1)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Count everything just once`` () =
     let phrase = "all the kings horses and all the kings men"
     let counts = Map.ofSeq [("all",    2);
@@ -43,10 +41,9 @@ let ``Count everything just once`` () =
                             ("and",    1);
                             ("men",    1)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Ignore punctuation`` () =
     let phrase = "car : carpet as java : javascript!!&@$%^&"
     let counts = Map.ofSeq [("car",        1);
@@ -55,38 +52,34 @@ let ``Ignore punctuation`` () =
                             ("java",       1);
                             ("javascript", 1)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Handles cramped list`` () =
     let phrase = "one,two,three"
     let counts = Map.ofSeq [("one",   1);
                             ("two",   1);
                             ("three", 1)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Include numbers`` () =
     let phrase = "testing, 1, 2 testing"
     let counts = Map.ofSeq [("testing", 2);
                             ("1",       1);
                             ("2",       1)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Normalize case`` () =
     let phrase = "go Go GO"
     let counts = Map.ofSeq [("go", 3)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``With apostrophes`` () =
     let phrase = "First: don't laugh. Then: don't cry."
     let counts = Map.ofSeq [("first", 1);
@@ -95,18 +88,16 @@ let ``With apostrophes`` () =
                             ("then",  1);
                             ("cry",   1)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``With free standing apostrophes`` () =
     let phrase = "go ' Go '' GO"
     let counts = Map.ofSeq [("go", 3)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``With apostrophes as quotes`` () =
     let phrase = "She said, 'let's meet at twelve o'clock'"
     let counts = Map.ofSeq [("she",     1);
@@ -117,10 +108,9 @@ let ``With apostrophes as quotes`` () =
                             ("twelve",  1);
                             ("o'clock", 1)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``With multiple lines`` () =
     let phrase = "Your time will come. You will face the same Evil, and you will defeat it."
     let counts = Map.ofSeq [("and",    1);
@@ -136,4 +126,4 @@ let ``With multiple lines`` () =
                             ("you",    2);
                             ("your",   1)]
 
-    Assert.That(wordCount phrase, Is.EqualTo(counts))
+    wordCount phrase |> should equal counts

data/tracks/fsharp/exercises/word-search/Program.fs

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

data/tracks/fsharp/exercises/word-search/WordSearch.fs

@@ -0,0 +1,3 @@
+module WordSearch
+
+let find puzzle word = failwith "You need to implement this function."

data/tracks/fsharp/exercises/word-search/WordSearch.fsproj

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

@@ -1,6 +1,7 @@
-module WordSearchTest
+module WordSearchTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open WordSearch
 
@@ -16,61 +17,52 @@ let puzzle =
      "jalaycalmp";
      "clojurermt"]
 
-[<Test>]
+[<Fact>]
 let ``Should find horizontal words written left-to-right`` () =
     let actual = find puzzle "clojure"
-    Assert.That(actual, Is.EqualTo(Some ((1, 10), (7, 10))))
+    actual |> should equal <| Some ((1, 10), (7, 10))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Should find horizontal words written right-to-left`` () =
     let actual = find puzzle "elixir"
-    Assert.That(actual, Is.EqualTo(Some ((6, 5), (1, 5))))
+    actual |> should equal <| Some ((6, 5), (1, 5))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Should find vertical words written top-to-bottom`` () =
     let actual = find puzzle "ecmascript"
-    Assert.That(actual, Is.EqualTo(Some ((10, 1), (10, 10))))
+    actual |> should equal <| Some ((10, 1), (10, 10))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Should find vertical words written bottom-to-top`` () =
     let actual = find puzzle "rust"
-    Assert.That(actual, Is.EqualTo(Some ((9, 5), (9, 2))))
+    actual |> should equal <| Some ((9, 5), (9, 2))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Should find diagonal words written top-left-to-bottom-right`` () =
     let actual = find puzzle "java"
-    Assert.That(actual, Is.EqualTo(Some ((1, 1), (4, 4))))
+    actual |> should equal <| Some ((1, 1), (4, 4))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Should find diagonal upper written bottom-right-to-top-left`` () =
     let actual = find puzzle "lua"
-    Assert.That(actual, Is.EqualTo(Some ((8, 9), (6, 7))))
+    actual |> should equal <| Some ((8, 9), (6, 7))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Should find diagonal upper written bottom-left-to-top-right`` () =
     let actual = find puzzle "lisp"
-    Assert.That(actual, Is.EqualTo(Some ((3, 6), (6, 3))))
+    actual |> should equal <| Some ((3, 6), (6, 3))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Should find diagonal upper written top-right-to-bottom-left`` () =
     let actual = find puzzle "ruby"    
-    Assert.That(actual, Is.EqualTo(Some ((8, 6), (5, 9))))
+    actual |> should equal <| Some ((8, 6), (5, 9))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Should not find words that are not in the puzzle`` () =
     let actual = find puzzle "haskell"
-    Assert.That(actual, Is.EqualTo(None))
+    actual |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Should be able to search differently-sized puzzles`` () =
     let differentSizePuzzle =
         ["qwertyuiopz";
@@ -78,4 +70,4 @@ let ``Should be able to search differently-sized puzzles`` () =
          "abcdefghijk"]
 
     let actual = find differentSizePuzzle "exercism"    
-    Assert.That(actual, Is.EqualTo(Some ((11, 2), (4, 2))))
+    actual |> should equal <| Some ((11, 2), (4, 2))

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

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

data/tracks/fsharp/exercises/wordy/Wordy.fs

@@ -0,0 +1,3 @@
+module Wordy
+
+let solve question = failwith "You need to implement this function."

data/tracks/fsharp/exercises/wordy/Wordy.fsproj

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