trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/perfect-numbers/PerfectNumbersTest.fs

@@ -1,23 +1,27 @@
-module PerfectNumbersTest
+module PerfectNumbersTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open PerfectNumbers
 
-[<TestCase(3)>]
-[<TestCase(7, Ignore = "Remove to run test case")>]
-[<TestCase(13, Ignore = "Remove to run test case")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(3)>]
+[<InlineData(7)>]
+[<InlineData(13)>]
 let ``Can classify deficient numbers`` (number) =
-    Assert.That(classify number, Is.EqualTo(Deficient))
+    classify number |> should equal Deficient
 
-[<TestCase(6, Ignore = "Remove to run test case")>]
-[<TestCase(28, Ignore = "Remove to run test case")>]
-[<TestCase(496, Ignore = "Remove to run test case")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(6)>]
+[<InlineData(28)>]
+[<InlineData(496)>]
 let ``Can classify perfect numbers`` (number) =
-    Assert.That(classify number, Is.EqualTo(Perfect))
+    classify number |> should equal Perfect
 
-[<TestCase(12, Ignore = "Remove to run test case")>]
-[<TestCase(18, Ignore = "Remove to run test case")>]
-[<TestCase(20, Ignore = "Remove to run test case")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(12)>]
+[<InlineData(18)>]
+[<InlineData(20)>]
 let ``Can classify abundant numbers`` (number) =
-    Assert.That(classify number, Is.EqualTo(Abundant))
+    classify number |> should equal Abundant

data/tracks/fsharp/exercises/perfect-numbers/Program.fs

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

data/tracks/fsharp/exercises/phone-number/PhoneNumber.fs

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

data/tracks/fsharp/exercises/phone-number/PhoneNumber.fsproj

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

@@ -1,54 +1,46 @@
-module PhoneNumberTest
+module PhoneNumberTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open PhoneNumber
 
-[<Test>]
+[<Fact>]
 let ``Cleans phone number`` () =
-    Assert.That(parsePhoneNumber "(123) 456-7890", Is.EqualTo(Some "1234567890"))
+    parsePhoneNumber "(123) 456-7890" |> should equal <| Some "1234567890"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cleans phone number with dots`` () =
-    Assert.That(parsePhoneNumber "123.456.7890", Is.EqualTo(Some "1234567890"))
+    parsePhoneNumber "123.456.7890" |> should equal <| Some "1234567890"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Valid when 11 digits and first is 1`` () =
-    Assert.That(parsePhoneNumber "11234567890", Is.EqualTo(Some "1234567890"))
+    parsePhoneNumber "11234567890" |> should equal <| Some "1234567890"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Invalid when 11 digits`` () =
-    Assert.That(parsePhoneNumber "21234567890", Is.EqualTo(None))
+    parsePhoneNumber "21234567890" |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Invalid when 9 digits`` () =
-    Assert.That(parsePhoneNumber "123456789", Is.EqualTo(None))
+    parsePhoneNumber "123456789" |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Invalid when 12 digits`` () =
-    Assert.That(parsePhoneNumber "123456789012", Is.EqualTo(None))
+    parsePhoneNumber "123456789012" |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Invalid when empty`` () =
-    Assert.That(parsePhoneNumber "", Is.EqualTo(None))
+    parsePhoneNumber "" |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Invalid when no digits present`` () =
-    Assert.That(parsePhoneNumber " (-) ", Is.EqualTo(None))
+    parsePhoneNumber " (-) " |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Valid with leading characters`` () =
-    Assert.That(parsePhoneNumber "my parsePhoneNumber is 123 456 7890", Is.EqualTo(Some "1234567890"))
+    parsePhoneNumber "my parsePhoneNumber is 123 456 7890" |> should equal <| Some "1234567890"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Valid with trailing characters`` () =
-    Assert.That(parsePhoneNumber "123 456 7890 - bob", Is.EqualTo(Some "1234567890"))
+    parsePhoneNumber "123 456 7890 - bob" |> should equal <| Some "1234567890"

data/tracks/fsharp/exercises/phone-number/Program.fs

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

data/tracks/fsharp/exercises/pig-latin/PigLatin.fs

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

data/tracks/fsharp/exercises/pig-latin/PigLatin.fsproj

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

@@ -1,64 +1,59 @@
-module PigLatinTest
+module PigLatinTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open PigLatin
 
-[<TestCase("apple", ExpectedResult = "appleay")>]
-[<TestCase("ear", ExpectedResult = "earay", Ignore = "Remove to run test case")>]
-[<TestCase("igloo", ExpectedResult = "iglooay", Ignore = "Remove to run test case")>]
-[<TestCase("object", ExpectedResult = "objectay", Ignore = "Remove to run test case")>]
-[<TestCase("under", ExpectedResult = "underay", Ignore = "Remove to run test case")>]
-let ``Ay is added to words that start with vowels`` (word) =
-    translate word
-
-[<TestCase("pig", ExpectedResult = "igpay", Ignore = "Remove to run test case")>]
-[<TestCase("koala", ExpectedResult = "oalakay", Ignore = "Remove to run test case")>]
-[<TestCase("yellow", ExpectedResult = "ellowyay", Ignore = "Remove to run test case")>]
-[<TestCase("xenon", ExpectedResult = "enonxay", Ignore = "Remove to run test case")>]
-let ``First letter and ay are moved to the end of words that start with consonants`` (word) =
-    translate word
-
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData("apple", "appleay")>]
+[<InlineData("ear", "earay")>]
+[<InlineData("igloo", "iglooay")>]
+[<InlineData("object", "objectay")>]
+[<InlineData("under", "underay")>]
+let ``Ay is added to words that start with vowels`` (word, expected) =
+    translate word |> should equal expected
+
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData("pig", "igpay")>]
+[<InlineData("koala", "oalakay")>]
+[<InlineData("yellow", "ellowyay")>]
+[<InlineData("xenon", "enonxay")>]
+let ``First letter and ay are moved to the end of words that start with consonants`` (word, expected) =
+    translate word |> should equal expected
+
+
+[<Fact(Skip = "Remove to run test")>]
 let ``Ch is treated like a single consonant`` () =
-    Assert.That(translate "chair", Is.EqualTo("airchay"))
+    translate "chair" |> should equal "airchay"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Qu is treated like a single consonant`` () =
-    Assert.That(translate "queen", Is.EqualTo("eenquay"))
+    translate "queen" |> should equal "eenquay"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Qu and a single preceding consonant are treated like a single consonant`` () =
-    Assert.That(translate "square", Is.EqualTo("aresquay"))
+    translate "square" |> should equal "aresquay"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Th is treated like a single consonant`` () =
-    Assert.That(translate "therapy", Is.EqualTo("erapythay"))
+    translate "therapy" |> should equal "erapythay"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Thr is treated like a single consonant`` () =
-    Assert.That(translate "thrush", Is.EqualTo("ushthray"))
+    translate "thrush" |> should equal "ushthray"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Sch is treated like a single consonant`` () =
-    Assert.That(translate "school", Is.EqualTo("oolschay"))
+    translate "school" |> should equal "oolschay"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Yt is treated like a single vowel`` () =
-    Assert.That(translate "yttria", Is.EqualTo("yttriaay"))
+    translate "yttria" |> should equal "yttriaay"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Xr is treated like a single vowel`` () =
-    Assert.That(translate "xray", Is.EqualTo("xrayay"))
+    translate "xray" |> should equal "xrayay"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Phrases are translated`` () =
-    Assert.That(translate "quick fast run", Is.EqualTo("ickquay astfay unray"))
+    translate "quick fast run" |> should equal "ickquay astfay unray"

data/tracks/fsharp/exercises/pig-latin/Program.fs

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

data/tracks/fsharp/exercises/poker/Poker.fs

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

data/tracks/fsharp/exercises/poker/Poker.fsproj

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

@@ -1,134 +1,118 @@
-module PokerTest
+module PokerTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Poker
 
-[<Test>]
+[<Fact>]
 let ``One hand`` () =
     let hand = "4S 5S 7H 8D JC"
-    Assert.That(bestHands [hand], Is.EqualTo([hand]))
+    bestHands [hand] |> should equal [hand]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Nothing vs one pair`` () =
     let nothing = "4S 5H 6S 8D JH"
     let pairOf4 = "2S 4H 6S 4D JH"
-    Assert.That(bestHands [nothing; pairOf4], Is.EqualTo([pairOf4]))
+    bestHands [nothing; pairOf4] |> should equal [pairOf4]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two pairs`` () =
     let pairOf2 = "4S 2H 6S 2D JH"
     let pairOf4 = "2S 4H 6S 4D JH"
-    Assert.That(bestHands [pairOf2; pairOf4], Is.EqualTo([pairOf4]))
+    bestHands [pairOf2; pairOf4] |> should equal [pairOf4]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One pair vs double pair`` () =
     let pairOf8 = "2S 8H 6S 8D JH"
     let doublePair = "4S 5H 4S 8D 5H"
-    Assert.That(bestHands [pairOf8; doublePair], Is.EqualTo([doublePair]))
+    bestHands [pairOf8; doublePair] |> should equal [doublePair]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two double pairs`` () =
     let doublePair2and8 = "2S 8H 2S 8D JH"
     let doublePair4and5 = "4S 5H 4S 8D 5H"
-    Assert.That(bestHands [doublePair2and8; doublePair4and5], Is.EqualTo([doublePair2and8]))
+    bestHands [doublePair2and8; doublePair4and5] |> should equal [doublePair2and8]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Double pair vs three`` () =
     let doublePair2and8 = "2S 8H 2S 8D JH"
     let threeOf4 = "4S 5H 4S 8D 4H"
-    Assert.That(bestHands [doublePair2and8; threeOf4], Is.EqualTo([threeOf4]))
+    bestHands [doublePair2and8; threeOf4] |> should equal [threeOf4]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two threes`` () =
     let threeOf2 = "2S 2H 2S 8D JH"
     let threeOf1 = "4S AH AS 8D AH"
-    Assert.That(bestHands [threeOf2; threeOf1], Is.EqualTo([threeOf1]))
+    bestHands [threeOf2; threeOf1] |> should equal [threeOf1]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Three vs straight`` () =
     let threeOf4 = "4S 5H 4S 8D 4H"
     let straight = "3S 4H 2S 6D 5H"
-    Assert.That(bestHands [threeOf4; straight], Is.EqualTo([straight]))
+    bestHands [threeOf4; straight] |> should equal [straight]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two straights`` () =
     let straightTo8 = "4S 6H 7S 8D 5H"
     let straightTo9 = "5S 7H 8S 9D 6H"
-    Assert.That(bestHands [straightTo8; straightTo9], Is.EqualTo([straightTo9]))
+    bestHands [straightTo8; straightTo9] |> should equal [straightTo9]
 
     let straightTo1 = "AS QH KS TD JH"
     let straightTo5 = "4S AH 3S 2D 5H"
-    Assert.That(bestHands [straightTo1; straightTo5], Is.EqualTo([straightTo1]))
+    bestHands [straightTo1; straightTo5] |> should equal [straightTo1]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Straight vs flush`` () =
     let straightTo8 = "4S 6H 7S 8D 5H"
     let flushTo7 = "2S 4S 5S 6S 7S"
-    Assert.That(bestHands [straightTo8; flushTo7], Is.EqualTo([flushTo7]))
+    bestHands [straightTo8; flushTo7] |> should equal [flushTo7]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two flushes`` () =
     let flushTo8 = "3H 6H 7H 8H 5H"
     let flushTo7 = "2S 4S 5S 6S 7S"
-    Assert.That(bestHands [flushTo8; flushTo7], Is.EqualTo([flushTo8]))
+    bestHands [flushTo8; flushTo7] |> should equal [flushTo8]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Flush vs full`` () =
     let flushTo8 = "3H 6H 7H 8H 5H"
     let full = "4S 5H 4S 5D 4H"
-    Assert.That(bestHands [full; flushTo8], Is.EqualTo([full]))
+    bestHands [full; flushTo8] |> should equal [full]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two fulls`` () =
     let fullOf4by9 = "4H 4S 4D 9S 9D"
     let fullOf5by8 = "5H 5S 5D 8S 8D"
-    Assert.That(bestHands [fullOf4by9; fullOf5by8], Is.EqualTo([fullOf5by8]))
+    bestHands [fullOf4by9; fullOf5by8] |> should equal [fullOf5by8]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Full vs square`` () =
     let full = "4S 5H 4S 5D 4H"
     let squareOf3 = "3S 3H 2S 3D 3H"
-    Assert.That(bestHands [full; squareOf3], Is.EqualTo([squareOf3]))
+    bestHands [full; squareOf3] |> should equal [squareOf3]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two squares`` () =
     let squareOf2 = "2S 2H 2S 8D 2H"
     let squareOf5 = "4S 5H 5S 5D 5H"
-    Assert.That(bestHands [squareOf2; squareOf5], Is.EqualTo([squareOf5]))
+    bestHands [squareOf2; squareOf5] |> should equal [squareOf5]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Square vs straight flush`` () =
     let squareOf5 = "4S 5H 5S 5D 5H"
     let straightFlushTo9 = "5S 7S 8S 9S 6S"
-    Assert.That(bestHands [squareOf5; straightFlushTo9], Is.EqualTo([straightFlushTo9]))
+    bestHands [squareOf5; straightFlushTo9] |> should equal [straightFlushTo9]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two straight flushes`` () =
     let straightFlushTo8 = "4H 6H 7H 8H 5H"
     let straightFlushTo9 = "5S 7S 8S 9S 6S"
-    Assert.That(bestHands [straightFlushTo8; straightFlushTo9], Is.EqualTo([straightFlushTo9]))
+    bestHands [straightFlushTo8; straightFlushTo9] |> should equal [straightFlushTo9]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Three hand with tie`` () =
     let spadeStraightTo9 = "9S 8S 7S 6S 5S"
     let diamondStraightTo9 = "9D 8D 7D 6D 5D"
     let threeOf4 = "4D 4S 4H QS KS"
-    Assert.That(bestHands [spadeStraightTo9; diamondStraightTo9; threeOf4], Is.EqualTo([spadeStraightTo9; diamondStraightTo9]))
+    bestHands [spadeStraightTo9; diamondStraightTo9; threeOf4] |> should equal [spadeStraightTo9; diamondStraightTo9]

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

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

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

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

data/tracks/fsharp/exercises/pov/Pov.fsproj

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

@@ -1,6 +1,7 @@
-module PovTest
+module PovTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Pov
 
@@ -35,52 +36,43 @@ let cousins' = mkGraph x [
                             mkGraph "cousin-0" [];
                             mkGraph "cousin-1" []]]]]
 
-[<Test>]
+[<Fact>]
 let ``Reparent singleton`` () =
-    Assert.That(fromPOV x singleton, Is.EqualTo(Some singleton'))
+    fromPOV x singleton |> should equal <| Some singleton'
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Reparent flat`` () =
-    Assert.That(fromPOV x flat, Is.EqualTo(Some flat'))
+    fromPOV x flat |> should equal <| Some flat'
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Reparent nested`` () =
-    Assert.That(fromPOV x nested, Is.EqualTo(Some nested'))
+    fromPOV x nested |> should equal <| Some nested'
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Reparent kids`` () =
-    Assert.That(fromPOV x kids, Is.EqualTo(Some kids'))
+    fromPOV x kids |> should equal <| Some kids'
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Reparent cousins`` () =
-    Assert.That(fromPOV x cousins, Is.EqualTo(Some cousins'))
+    fromPOV x cousins |> should equal <| Some cousins'
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Reparent from POV of non-existent node`` () =
-    Assert.That(fromPOV x (leaf "foo"), Is.EqualTo(None))
+    fromPOV x (leaf "foo") |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Should not be able to find a missing node`` () =
     let nodes = [singleton; flat; kids; nested; cousins] |> List.map (fromPOV "NOT THERE")
-    Assert.That(nodes, Is.All.EqualTo(None))
+    nodes |> List.iter (should equal None)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cannot trace between un-connected nodes`` () =
-    Assert.That(tracePathBetween x "NOT THERE" cousins, Is.EqualTo(None))
+    tracePathBetween x "NOT THERE" cousins |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can trace a path from x to cousin`` () = 
-    Assert.That(tracePathBetween x "cousin-1" cousins, Is.EqualTo(Some ["x"; "parent"; "grandparent"; "uncle"; "cousin-1"]))
+    tracePathBetween x "cousin-1" cousins |> should equal <| Some ["x"; "parent"; "grandparent"; "uncle"; "cousin-1"]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can trace from a leaf to a leaf`` () =
-    Assert.That(tracePathBetween "kid-a" "cousin-0" cousins, Is.EqualTo(Some ["kid-a"; "x"; "parent"; "grandparent"; "uncle"; "cousin-0"]))
+    tracePathBetween "kid-a" "cousin-0" cousins |> should equal <| Some ["kid-a"; "x"; "parent"; "grandparent"; "uncle"; "cousin-0"]

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

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

data/tracks/fsharp/exercises/prime-factors/Example.fs

@@ -14,7 +14,7 @@ let primeFactorsFor number =
         | factor::xs ->        
             match remainder with
             | _ when remainder <= 1L -> factors |> List.rev
-            | _ when remainder % factor = 0L -> loop (factor :: factors) (remainder / factor |> int64) possibleFactors
+            | _ when remainder % factor = 0L -> loop (int factor :: factors) (remainder / factor |> int64) possibleFactors
             | _ -> loop factors remainder xs
 
     loop [] number (possiblePrimes number)

data/tracks/fsharp/exercises/prime-factors/PrimeFactors.fs

@@ -0,0 +1,3 @@
+module PrimeFactors
+
+let primeFactorsFor number = failwith "You need to implement this function."