trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/tree-building/TreeBuildingTest.fs

@@ -1,10 +1,12 @@
-module TreeBuildingTest
+module TreeBuildingTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
+open System
 
 open TreeBuilding
 
-[<Test>]
+[<Fact>]
 let ``One node`` () =
     let input = 
         [ 
@@ -13,11 +15,11 @@ let ``One node`` () =
 
     let tree = buildTree input
 
-    Assert.That(isBranch tree, Is.False)
-    Assert.That(recordId tree, Is.EqualTo(0))    
-    Assert.That(children tree, Is.EqualTo([]))
+    isBranch tree |> should equal false
+    recordId tree |> should equal 0    
+    children tree |> should be Empty
 
-[<Test>]
+[<Fact>]
 let ``Three nodes in order`` () =
     let input = 
         [
@@ -28,17 +30,17 @@ let ``Three nodes in order`` () =
 
     let tree = buildTree input
 
-    Assert.That(isBranch tree, Is.True)
-    Assert.That(recordId tree, Is.EqualTo(0))
-    Assert.That(children tree |> List.length, Is.EqualTo(2))
+    isBranch tree |> should equal true
+    recordId tree |> should equal 0
+    children tree |> List.length |> should equal 2
 
-    Assert.That(children tree |> List.item 0 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 0 |> recordId, Is.EqualTo(1))
+    children tree |> List.item 0 |> isBranch |> should equal false
+    children tree |> List.item 0 |> recordId |> should equal 1
 
-    Assert.That(children tree |> List.item 1 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 1 |> recordId, Is.EqualTo(2))
+    children tree |> List.item 1 |> isBranch |> should equal false
+    children tree |> List.item 1 |> recordId |> should equal 2
 
-[<Test>]
+[<Fact>]
 let ``Three nodes in reverse order`` () =
     let input = 
         [
@@ -49,17 +51,17 @@ let ``Three nodes in reverse order`` () =
 
     let tree = buildTree input
     
-    Assert.That(isBranch tree, Is.True)
-    Assert.That(recordId tree, Is.EqualTo(0))
-    Assert.That(children tree |> List.length, Is.EqualTo(2))
+    isBranch tree |> should equal true
+    recordId tree |> should equal 0
+    children tree |> List.length |> should equal 2
 
-    Assert.That(children tree |> List.item 0 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 0 |> recordId, Is.EqualTo(1))
+    children tree |> List.item 0 |> isBranch |> should equal false
+    children tree |> List.item 0 |> recordId |> should equal 1
 
-    Assert.That(children tree |> List.item 1 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 1 |> recordId, Is.EqualTo(2))
+    children tree |> List.item 1 |> isBranch |> should equal false
+    children tree |> List.item 1 |> recordId |> should equal 2
 
-[<Test>]
+[<Fact>]
 let ``More than two children`` () =
     let input = 
         [
@@ -71,20 +73,20 @@ let ``More than two children`` () =
 
     let tree = buildTree input
     
-    Assert.That(isBranch tree, Is.True)
-    Assert.That(recordId tree, Is.EqualTo(0))
-    Assert.That(children tree |> List.length, Is.EqualTo(3))
+    isBranch tree |> should equal true
+    recordId tree |> should equal 0
+    children tree |> List.length |> should equal 3
 
-    Assert.That(children tree |> List.item 0 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 0 |> recordId, Is.EqualTo(1))
+    children tree |> List.item 0 |> isBranch |> should equal false
+    children tree |> List.item 0 |> recordId |> should equal 1
 
-    Assert.That(children tree |> List.item 1 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 1 |> recordId, Is.EqualTo(2))
+    children tree |> List.item 1 |> isBranch |> should equal false
+    children tree |> List.item 1 |> recordId |> should equal 2
 
-    Assert.That(children tree |> List.item 2 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 2 |> recordId, Is.EqualTo(3))
+    children tree |> List.item 2 |> isBranch |> should equal false
+    children tree |> List.item 2 |> recordId |> should equal 3
 
-[<Test>]
+[<Fact>]
 let ``Binary tree`` () =
     let input = 
         [
@@ -99,31 +101,31 @@ let ``Binary tree`` () =
 
     let tree = buildTree input
         
-    Assert.That(isBranch tree, Is.True)
-    Assert.That(recordId tree, Is.EqualTo(0))
-    Assert.That(children tree |> List.length, Is.EqualTo(2))
+    isBranch tree |> should equal true
+    recordId tree |> should equal 0
+    children tree |> List.length |> should equal 2
 
-    Assert.That(children tree |> List.item 0 |> isBranch, Is.True)
-    Assert.That(children tree |> List.item 0 |> recordId, Is.EqualTo(1))    
-    Assert.That(children tree |> List.item 0 |> children |> List.length, Is.EqualTo(2))
+    children tree |> List.item 0 |> isBranch |> should equal true
+    children tree |> List.item 0 |> recordId |> should equal 1    
+    children tree |> List.item 0 |> children |> List.length |> should equal 2
 
-    Assert.That(children tree |> List.item 0 |> children |> List.item 0 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 0 |> children |> List.item 0 |> recordId, Is.EqualTo(4))
+    children tree |> List.item 0 |> children |> List.item 0 |> isBranch |> should equal false
+    children tree |> List.item 0 |> children |> List.item 0 |> recordId |> should equal 4
 
-    Assert.That(children tree |> List.item 0 |> children |> List.item 1 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 0 |> children |> List.item 1 |> recordId, Is.EqualTo(5))
+    children tree |> List.item 0 |> children |> List.item 1 |> isBranch |> should equal false
+    children tree |> List.item 0 |> children |> List.item 1 |> recordId |> should equal 5
     
-    Assert.That(children tree |> List.item 1 |> isBranch, Is.True)
-    Assert.That(children tree |> List.item 1 |> recordId, Is.EqualTo(2))    
-    Assert.That(children tree |> List.item 1 |> children |> List.length, Is.EqualTo(2))
+    children tree |> List.item 1 |> isBranch |> should equal true
+    children tree |> List.item 1 |> recordId |> should equal 2    
+    children tree |> List.item 1 |> children |> List.length |> should equal 2
     
-    Assert.That(children tree |> List.item 1 |> children |> List.item 0 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 1 |> children |> List.item 0 |> recordId, Is.EqualTo(3))
+    children tree |> List.item 1 |> children |> List.item 0 |> isBranch |> should equal false
+    children tree |> List.item 1 |> children |> List.item 0 |> recordId |> should equal 3
 
-    Assert.That(children tree |> List.item 1 |> children |> List.item 1 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 1 |> children |> List.item 1 |> recordId, Is.EqualTo(6))
+    children tree |> List.item 1 |> children |> List.item 1 |> isBranch |> should equal false
+    children tree |> List.item 1 |> children |> List.item 1 |> recordId |> should equal 6
 
-[<Test>]
+[<Fact>]
 let ``Unbalanced tree`` () =
     let input =
         [
@@ -138,48 +140,48 @@ let ``Unbalanced tree`` () =
 
     let tree = buildTree input
         
-    Assert.That(isBranch tree, Is.True)
-    Assert.That(recordId tree, Is.EqualTo(0))
-    Assert.That(children tree |> List.length, Is.EqualTo(2))
+    isBranch tree |> should equal true
+    recordId tree |> should equal 0
+    children tree |> List.length |> should equal 2
 
-    Assert.That(children tree |> List.item 0 |> isBranch, Is.True)
-    Assert.That(children tree |> List.item 0 |> recordId, Is.EqualTo(1))    
-    Assert.That(children tree |> List.item 0 |> children |> List.length, Is.EqualTo(1))
+    children tree |> List.item 0 |> isBranch |> should equal true
+    children tree |> List.item 0 |> recordId |> should equal 1    
+    children tree |> List.item 0 |> children |> List.length |> should equal 1
 
-    Assert.That(children tree |> List.item 0 |> children |> List.item 0 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 0 |> children |> List.item 0 |> recordId, Is.EqualTo(4))
+    children tree |> List.item 0 |> children |> List.item 0 |> isBranch |> should equal false
+    children tree |> List.item 0 |> children |> List.item 0 |> recordId |> should equal 4
     
-    Assert.That(children tree |> List.item 1 |> isBranch, Is.True)
-    Assert.That(children tree |> List.item 1 |> recordId, Is.EqualTo(2))
-    Assert.That(children tree |> List.item 1 |> children |> List.length, Is.EqualTo(3))
+    children tree |> List.item 1 |> isBranch |> should equal true
+    children tree |> List.item 1 |> recordId |> should equal 2
+    children tree |> List.item 1 |> children |> List.length |> should equal 3
     
-    Assert.That(children tree |> List.item 1 |> children |> List.item 0 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 1 |> children |> List.item 0 |> recordId, Is.EqualTo(3))
+    children tree |> List.item 1 |> children |> List.item 0 |> isBranch |> should equal false
+    children tree |> List.item 1 |> children |> List.item 0 |> recordId |> should equal 3
 
-    Assert.That(children tree |> List.item 1 |> children |> List.item 1 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 1 |> children |> List.item 1 |> recordId, Is.EqualTo(5))
+    children tree |> List.item 1 |> children |> List.item 1 |> isBranch |> should equal false
+    children tree |> List.item 1 |> children |> List.item 1 |> recordId |> should equal 5
 
-    Assert.That(children tree |> List.item 1 |> children |> List.item 2 |> isBranch, Is.False)
-    Assert.That(children tree |> List.item 1 |> children |> List.item 2 |> recordId, Is.EqualTo(6))
+    children tree |> List.item 1 |> children |> List.item 2 |> isBranch |> should equal false
+    children tree |> List.item 1 |> children |> List.item 2 |> recordId |> should equal 6
 
-[<Test>]
+[<Fact>]
 let ``Empty input`` () =
     let input = []
-    Assert.That((fun () -> buildTree input |> ignore), Throws.Exception)
+    (fun () -> buildTree input |> ignore) |> should throw typeof<Exception>
 
-[<Test>]
+[<Fact>]
 let ``Root node has parent`` () =
     let input = 
         [ { RecordId = 0; ParentId = 1 };
           { RecordId = 1; ParentId = 0 } ]
-    Assert.That((fun () -> buildTree input |> ignore), Throws.Exception)
+    (fun () -> buildTree input |> ignore) |> should throw typeof<Exception>
 
-[<Test>]
+[<Fact>]
 let ``No root node`` () =
     let input = [ { RecordId = 1; ParentId = 0 } ]
-    Assert.That((fun () -> buildTree input |> ignore), Throws.Exception)
+    (fun () -> buildTree input |> ignore) |> should throw typeof<Exception>
     
-[<Test>]
+[<Fact>]
 let ``Non-continuous`` () =
     let input = 
         [
@@ -188,9 +190,9 @@ let ``Non-continuous`` () =
             { RecordId = 1; ParentId = 0 };
             { RecordId = 0; ParentId = 0 } 
         ]
-    Assert.That((fun () -> buildTree input |> ignore), Throws.Exception)
+    (fun () -> buildTree input |> ignore) |> should throw typeof<Exception>
 
-[<Test>]
+[<Fact>]
 let ``Cycle directly`` () =
     let input = 
         [
@@ -202,9 +204,9 @@ let ``Cycle directly`` () =
             { RecordId = 0; ParentId = 0 };
             { RecordId = 6; ParentId = 3 } 
         ]
-    Assert.That((fun () -> buildTree input |> ignore), Throws.Exception)
+    (fun () -> buildTree input |> ignore) |> should throw typeof<Exception>
 
-[<Test>]
+[<Fact>]
 let ``Cycle indirectly`` () =
     let input = 
         [ 
@@ -216,9 +218,9 @@ let ``Cycle indirectly`` () =
             { RecordId = 0; ParentId = 0 };
             { RecordId = 6; ParentId = 3 } 
         ]
-    Assert.That((fun () -> buildTree input |> ignore), Throws.Exception)
+    (fun () -> buildTree input |> ignore) |> should throw typeof<Exception>
 
-[<Test>]
+[<Fact>]
 let ``Higher id parent of lower id`` () =
     let input = 
         [ 
@@ -226,4 +228,4 @@ let ``Higher id parent of lower id`` () =
             { RecordId = 2; ParentId = 0 };
             { RecordId = 1; ParentId = 2 } 
         ]
-    Assert.That((fun () -> buildTree input |> ignore), Throws.Exception)
+    (fun () -> buildTree input |> ignore) |> should throw typeof<Exception>

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

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

data/tracks/fsharp/exercises/triangle/Triangle.fs

@@ -0,0 +1,8 @@
+module Triangle
+
+type TriangleKind =
+    | Equilateral
+    | Isosceles
+    | Scalene
+
+let kind x y z = failwith "You need to implement this function."

data/tracks/fsharp/exercises/triangle/Triangle.fsproj

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

@@ -1,74 +1,62 @@
-module TriangleTest
+module TriangleTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Triangle
 open System
 
-[<Test>]
+[<Fact>]
 let ``Equilateral triangles have equal sides`` () =
-    Assert.That(kind 2m 2m 2m, Is.EqualTo(TriangleKind.Equilateral))
+    kind 2m 2m 2m |> should equal TriangleKind.Equilateral
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Larger equilateral triangles also have equal sides`` () =
-    Assert.That(kind 10m 10m 10m, Is.EqualTo(TriangleKind.Equilateral))
+    kind 10m 10m 10m |> should equal TriangleKind.Equilateral
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Isosceles triangles have last two sides equal`` () =
-    Assert.That(kind 3m 4m 4m, Is.EqualTo(TriangleKind.Isosceles))
+    kind 3m 4m 4m |> should equal TriangleKind.Isosceles
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Isosceles triangles have first and last sides equal`` () =
-    Assert.That(kind 4m 3m 4m, Is.EqualTo(TriangleKind.Isosceles))
+    kind 4m 3m 4m |> should equal TriangleKind.Isosceles
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Isosceles triangles have two first sides equal`` () =
-    Assert.That(kind 4m 4m 3m, Is.EqualTo(TriangleKind.Isosceles))
+    kind 4m 4m 3m |> should equal TriangleKind.Isosceles
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Isosceles triangles have in fact exactly two sides equal`` () =
-    Assert.That(kind 10m 10m 3m, Is.EqualTo(TriangleKind.Isosceles))
+    kind 10m 10m 3m |> should equal TriangleKind.Isosceles
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Scalene triangles have no equal sides`` () =
-    Assert.That(kind 3m 4m 5m, Is.EqualTo(TriangleKind.Scalene))
+    kind 3m 4m 5m |> should equal TriangleKind.Scalene
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Scalene triangles have no equal sides at a larger scale too`` () =
-    Assert.That(kind 10m 11m 12m, Is.EqualTo(TriangleKind.Scalene))
+    kind 10m 11m 12m |> should equal TriangleKind.Scalene
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Scalene triangles have no equal sides in descending order either`` () =
-    Assert.That(kind 5m 4m 2m, Is.EqualTo(TriangleKind.Scalene))
+    kind 5m 4m 2m |> should equal TriangleKind.Scalene
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Very small triangles are legal`` () =
-    Assert.That(kind 0.4m 0.6m 0.3m, Is.EqualTo(TriangleKind.Scalene))
+    kind 0.4m 0.6m 0.3m |> should equal TriangleKind.Scalene
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Triangles with no size are illegal`` () =
-    Assert.That((fun () -> kind 0m 0m 0m |> ignore), Throws.InvalidOperationException)
+    (fun () -> kind 0m 0m 0m |> ignore) |> should throw typeof<InvalidOperationException>
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Triangles with negative sides are illegal`` () =
-    Assert.That((fun () -> kind 3m 4m -5m |> ignore), Throws.InvalidOperationException)
+    (fun () -> kind 3m 4m -5m |> ignore) |> should throw typeof<InvalidOperationException>
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Triangles violating triangle inequality are illegal`` () =
-    Assert.That((fun () -> kind 1m 1m 3m |> ignore), Throws.InvalidOperationException)
+    (fun () -> kind 1m 1m 3m |> ignore) |> should throw typeof<InvalidOperationException>
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Triangles violating triangle inequality are illegal 3`` () =
-    Assert.That((fun () -> kind 7m 3m 2m |> ignore), Throws.InvalidOperationException)
+    (fun () -> kind 7m 3m 2m |> ignore) |> should throw typeof<InvalidOperationException>

data/tracks/fsharp/exercises/twelve-days/Program.fs

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

data/tracks/fsharp/exercises/twelve-days/TwelveDays.fs

@@ -0,0 +1,7 @@
+module TwelveDaysSong
+
+let verse number = failwith "You need to implement this function."
+
+let verses start stop = failwith "You need to implement this function."
+
+let song: string = failwith "You need to implement this function."

data/tracks/fsharp/exercises/twelve-days/TwelveDays.fsproj

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

@@ -1,90 +1,78 @@
-module TwelveDaysTest
+module TwelveDaysTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open TwelveDaysSong
 
-[<Test>]
+[<Fact>]
 let ``Return verse 1`` () =
     let expected = "On the first day of Christmas my true love gave to me, a Partridge in a Pear Tree.\n"
-    Assert.That(verse 1, Is.EqualTo(expected))
+    verse 1 |> should equal expected
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return verse 2`` () =
     let expected = "On the second day of Christmas my true love gave to me, two Turtle Doves, and a Partridge in a Pear Tree.\n"
-    Assert.That(verse 2, Is.EqualTo(expected))
+    verse 2 |> should equal expected
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return verse 3`` () =
     let expected = "On the third day of Christmas my true love gave to me, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.\n"
-    Assert.That(verse 3, Is.EqualTo(expected))
+    verse 3 |> should equal expected
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return verse 4`` () =
     let expected = "On the fourth day of Christmas my true love gave to me, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.\n"
-    Assert.That(verse 4, Is.EqualTo(expected))
+    verse 4 |> should equal expected
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return verse 5`` () =
     let expected = "On the fifth day of Christmas my true love gave to me, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.\n"
-    Assert.That(verse 5, Is.EqualTo(expected))
+    verse 5 |> should equal expected
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return verse 6`` () =
     let expected = "On the sixth day of Christmas my true love gave to me, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.\n"
-    Assert.That(verse 6, Is.EqualTo(expected))
+    verse 6 |> should equal expected
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return verse 7`` () =
     let expected = "On the seventh day of Christmas my true love gave to me, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.\n"
-    Assert.That(verse 7, Is.EqualTo(expected))
+    verse 7 |> should equal expected
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return verse 8`` () =
     let expected = "On the eighth day of Christmas my true love gave to me, eight Maids-a-Milking, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.\n"
-    Assert.That(verse 8, Is.EqualTo(expected))
+    verse 8 |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return verse 9`` () =
     let expected = "On the ninth day of Christmas my true love gave to me, nine Ladies Dancing, eight Maids-a-Milking, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.\n"
-    Assert.That(verse 9, Is.EqualTo(expected))
+    verse 9 |> should equal expected
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return verse 10`` () =
     let expected = "On the tenth day of Christmas my true love gave to me, ten Lords-a-Leaping, nine Ladies Dancing, eight Maids-a-Milking, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.\n"
-    Assert.That(verse 10, Is.EqualTo(expected))
+    verse 10 |> should equal expected
    
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return verse 11`` () =
     let expected = "On the eleventh day of Christmas my true love gave to me, eleven Pipers Piping, ten Lords-a-Leaping, nine Ladies Dancing, eight Maids-a-Milking, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.\n"
-    Assert.That(verse 11, Is.EqualTo(expected))
+    verse 11 |> should equal expected
    
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return verse 12`` () =
     let expected = "On the twelfth day of Christmas my true love gave to me, twelve Drummers Drumming, eleven Pipers Piping, ten Lords-a-Leaping, nine Ladies Dancing, eight Maids-a-Milking, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.\n"
-    Assert.That(verse 12, Is.EqualTo(expected))
+    verse 12 |> should equal expected
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return multiple verses`` () =
     let expected = "On the first day of Christmas my true love gave to me, a Partridge in a Pear Tree.\n\n" +
                    "On the second day of Christmas my true love gave to me, two Turtle Doves, and a Partridge in a Pear Tree.\n\n" +
                    "On the third day of Christmas my true love gave to me, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.\n\n"
 
-    Assert.That(verses 1 3, Is.EqualTo(expected))
+    verses 1 3 |> should equal expected
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Return entire song`` () =
-    Assert.That(verses 1 12, Is.EqualTo(song))
+    verses 1 12 |> should equal song

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

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

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

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

data/tracks/fsharp/exercises/two-bucket/TwoBucket.fsproj

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