trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/diffie-hellman/DiffieHellman.fs

@@ -0,0 +1,7 @@
+module DiffieHellman
+
+let privateKey primeP = failwith "You need to implement this function."
+
+let publicKey primeP primeG privateKey = failwith "You need to implement this function."
+
+let secret primeP publicKey privateKey = failwith "You need to implement this function."

data/tracks/fsharp/exercises/diffie-hellman/DiffieHellman.fsproj

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

@@ -1,58 +1,55 @@
-module DiffieHellmanTest
+module DiffieHellmanTest
 
 open System.Numerics
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open DiffieHellman
 
-[<Test>]
+[<Fact>]
 let ``Private key in range`` () =   
     let primeP = 23I
     let privateKeys = [for _ in 0 .. 10 -> privateKey primeP]
-    Assert.That(privateKeys, Is.All.InRange(1I, primeP - 1I))
+    privateKeys |> List.iter (fun x -> x |> should be (greaterThanOrEqualTo 1I))
+    privateKeys |> List.iter (fun x -> x |> should be (lessThanOrEqualTo (primeP - 1I)))
 
 // Note: due to the nature of randomness, there is always a chance that this test fails
 // Be sure to check the actual generated values
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Private key randomly generated`` () =   
     let primeP = 7919I
     let privateKeys = [for _ in 0 .. 5 -> privateKey primeP]
-    Assert.That(privateKeys.Length, Is.EqualTo(privateKeys |> List.distinct |> List.length))
+    privateKeys.Length |> should equal <| List.length (List.distinct privateKeys) 
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Public key correctly calculated`` () =
     let primeP = 23I
     let primeG = 5I
     let privateKey = 6I
 
     let actual = publicKey primeP primeG privateKey    
-    Assert.That(actual, Is.EqualTo(8I))
+    actual |> should equal 8I
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Secret key correctly calculated`` () =
     let primeP = 23I
     let publicKey = 19I
     let privateKey = 6I
 
     let actual = secret primeP publicKey privateKey
-    Assert.That(actual, Is.EqualTo(2I))
+    actual |> should equal 2I
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Secret key correctly calculated when using large primes`` () =
     let primeP = 120227323036150778550155526710966921740030662694578947298423549235265759593711587341037426347114541533006628856300552706996143592240453345642869233562886752930249953227657883929905072620233073626594386072962776144691433658814261874113232461749035425712805067202910389407991986070558964461330091797026762932543I
     let publicKey = 75205441154357919442925546169208711235485855904969178206313309299205868312399046149367516336607966149689640419216591714331722664409474612463910928128055994157922930443733535659848264364106037925315974095321112757711756912144137705613776063541350548911512715512539186192176020596861210448363099541947258202188I
     let privateKey = 2483479393625932939911081304356888505153797135447327501792696199190469015215177630758617902200417377685436170904594686456961202706692908603181062371925882I
     let expected = 70900735223964890815905879227737819348808518698920446491346508980461201746567735331455825644429877946556431095820785835497384849778344216981228226252639932672153547963980483673419756271345828771971984887453014488572245819864454136618980914729839523581263886740821363010486083940557620831348661126601106717071I
     let actual = secret primeP publicKey privateKey
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test exchange`` () =
     let primeP = 23I
     let primeG = 5I
@@ -66,4 +63,4 @@ let ``Test exchange`` () =
     let secretA = secret primeP publicKeyB privateKeyA
     let secretB = secret primeP publicKeyA privateKeyB
 
-    Assert.That(secretA, Is.EqualTo(secretB))
+    secretA |> should equal secretB

data/tracks/fsharp/exercises/diffie-hellman/Program.fs

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

data/tracks/fsharp/exercises/dominoes/Dominoes.fs

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

data/tracks/fsharp/exercises/dominoes/Dominoes.fsproj

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

@@ -1,76 +1,66 @@
-module DominoesTest
+module DominoesTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Dominoes
 
-[<Test>]
+[<Fact>]
 let ``Empty input = empty output`` () =
     let actual = []
-    Assert.That(canChain actual, Is.True)
+    canChain actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Singleton input = singleton output`` () =
     let actual = [(1, 1)]
-    Assert.That(canChain actual, Is.True)
+    canChain actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Singleton that can't be chained`` () =
     let actual = [(1, 2)]
-    Assert.That(canChain actual, Is.False)
+    canChain actual |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Three elements`` () =
     let actual = [(1, 2); (3, 1); (2, 3)]
-    Assert.That(canChain actual, Is.True)
+    canChain actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can reverse dominoes`` () =
     let actual = [(1, 2); (1, 3); (2, 3)]
-    Assert.That(canChain actual, Is.True)
+    canChain actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can't be chained`` () =
     let actual = [(1, 2); (4, 1); (2, 3)]
-    Assert.That(canChain actual, Is.False)
+    canChain actual |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Disconnected - simple`` () =
     let actual = [(1, 1); (2, 2)]
-    Assert.That(canChain actual, Is.False)
+    canChain actual |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Disconnected - double loop`` () =
     let actual = [(1, 2); (2, 1); (3, 4); (4, 3)]
-    Assert.That(canChain actual, Is.False)
+    canChain actual |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Disconnected - single isolated`` () =
     let actual = [(1, 2); (2, 3); (3, 1); (4, 4)]
-    Assert.That(canChain actual, Is.False)
+    canChain actual |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Need backtrack`` () =
     let actual = [(1, 2); (2, 3); (3, 1); (2, 4); (2, 4)]
-    Assert.That(canChain actual, Is.True)
+    canChain actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Separate loops`` () =
     let actual = [(1, 2); (2, 3); (3, 1); (1, 1); (2, 2); (3, 3)]
-    Assert.That(canChain actual, Is.True)
+    canChain actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Ten elements`` () =
     let actual = [(1, 2); (5, 3); (3, 1); (1, 2); (2, 4); (1, 6); (2, 3); (3, 4); (5, 6)]
-    Assert.That(canChain actual, Is.True)
+    canChain actual |> should equal true

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

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

data/tracks/fsharp/exercises/dot-dsl/DotDsl.fs

@@ -0,0 +1,15 @@
+module DotDsl
+
+let graph children = failwith "You need to implement this function."
+
+let attr key value = failwith "You need to implement this function."
+
+let node key attrs = failwith "You need to implement this function."
+
+let edge left right attrs = failwith "You need to implement this function."
+
+let attrs graph = failwith "You need to implement this function."
+
+let nodes graph = failwith "You need to implement this function."
+
+let edges graph = failwith "You need to implement this function."

data/tracks/fsharp/exercises/dot-dsl/DotDsl.fsproj

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

@@ -1,63 +1,59 @@
-module DotDslTest
+module DotDslTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open DotDsl
 
-[<Test>]
+[<Fact>]
 let ``Empty graph`` () =
     let g = graph []
 
-    Assert.That(nodes g, Is.Empty)
-    Assert.That(edges g, Is.Empty)
-    Assert.That(attrs g, Is.Empty)
+    nodes g |> should be Empty
+    edges g |> should be Empty
+    attrs g |> should be Empty
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Graph with one node`` () =
     let g = graph [
                 node "a" []
             ]            
 
-    Assert.That(nodes g, Is.EqualTo([node "a" []]))
-    Assert.That(edges g, Is.Empty)
-    Assert.That(attrs g, Is.Empty)
+    nodes g |> should equal [node "a" []]
+    edges g |> should be Empty
+    attrs g |> should be Empty
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Graph with one node with keywords`` () =    
     let g = graph [
                 node "a" [("color", "green")]
             ]            
 
-    Assert.That(nodes g, Is.EqualTo([node "a" [("color", "green")]]))
-    Assert.That(edges g, Is.Empty)
-    Assert.That(attrs g, Is.Empty)
+    nodes g |> should equal [node "a" [("color", "green")]]
+    edges g |> should be Empty
+    attrs g |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Graph with one edge`` () =    
     let g = graph [
                 edge "a" "b" []
             ]             
 
-    Assert.That(nodes g, Is.Empty)
-    Assert.That(edges g, Is.EqualTo([edge "a" "b" []]))
-    Assert.That(attrs g, Is.Empty)
+    nodes g |> should be Empty
+    edges g |> should equal [edge "a" "b" []]
+    attrs g |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Graph with one attribute`` () = 
     let g = graph [
                 attr "foo" "1"
             ]             
 
-    Assert.That(nodes g, Is.Empty)
-    Assert.That(edges g, Is.Empty)
-    Assert.That(attrs g, Is.EqualTo([attr "foo" "1"]))
+    nodes g |> should be Empty
+    edges g |> should be Empty
+    attrs g |> should equal [attr "foo" "1"]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Graph with attributes`` () =    
     let g = graph [
                 attr "foo" "1"
@@ -70,6 +66,6 @@ let ``Graph with attributes`` () =
                 attr "bar" "true"
             ]             
 
-    Assert.That(nodes g, Is.EqualTo([node "a" [("color", "green")]; node "b" [("label", "Beta!")]; node "c" []]))
-    Assert.That(edges g, Is.EqualTo([edge "a" "b" [("color", "blue")]; edge "b" "c" []]))
-    Assert.That(attrs g, Is.EqualTo([attr "bar" "true"; attr "foo" "1"; attr "title" "Testing Attrs"]))
+    nodes g |> should equal [node "a" [("color", "green")]; node "b" [("label", "Beta!")]; node "c" []]
+    edges g |> should equal [edge "a" "b" [("color", "blue")]; edge "b" "c" []]
+    attrs g |> should equal [attr "bar" "true"; attr "foo" "1"; attr "title" "Testing Attrs"]

data/tracks/fsharp/exercises/dot-dsl/Program.fs

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

data/tracks/fsharp/exercises/error-handling/ErrorHandling.fs

@@ -0,0 +1,11 @@
+module ErrorHandling
+
+let handleErrorByThrowingException() = ()
+
+let handleErrorByReturningOption input = failwith "You need to implement this function."
+
+let handleErrorByReturningResult input = failwith "You need to implement this function."
+
+let bind switchFunction twoTrackInput = failwith "You need to implement this function."
+
+let cleanupDisposablesWhenThrowingException resource = failwith "You need to implement this function."

data/tracks/fsharp/exercises/error-handling/ErrorHandling.fsproj

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

@@ -1,6 +1,8 @@
 module ErrorHandlingTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
+open System
 
 open ErrorHandling
 
@@ -16,40 +18,35 @@ type Resource() =
 
 // Throwing exceptions is not the preferred approach to handling errors in F#, 
 // but it becomes relevant when you use .NET framework methods from your F# code
-[<Test>]
+[<Fact>]
 let ``Throwing exception`` () =    
-    Assert.That((fun () -> handleErrorByThrowingException() |> ignore), Throws.Exception)
+    (fun () -> handleErrorByThrowingException() |> ignore) |> should throw typeof<Exception>
 
 // A better approach than exceptions is to use the Option<'T> discriminated union. 
 // If the function is successful, Some x is returned (with x being the value).
 // Upon failure, None is returned. The caller can then pattern match on the
 // returned value. As Option<'T> is a discriminated union, the user is forced to
 // consider both possible outputs: success and failure.
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Returning Option<'T>`` () =
     let successResult = handleErrorByReturningOption "1"
-    Assert.That(successResult, Is.EqualTo(Some 1))
+    successResult |> should equal <| Some 1
     
     let failureResult = handleErrorByReturningOption "a"
-    Assert.That(failureResult, Is.EqualTo(None))
+    failureResult |> should equal None
 
 // If the caller is also interested what error occured, the Option<'T> type does not suffice.
-// In that case, one usually defines a new discriminated union: Result<'TSuccess, 'TError>.
+// In that case, one can use a different discriminated union: Result<'TSuccess, 'TError>.
 // This discriminated union has two possible cases: Ok and Error, which contain data
 // of type 'TSuccess and 'TError respectively. Note that these types can be different, so
 // you are free to return an integer upon success and a string upon failure.
-//
-// Note: F# 4.1 will include the Result<'TSuccess, 'TError> type.
-// See: https://blogs.msdn.microsoft.com/dotnet/2016/07/25/a-peek-into-f-4-1/
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Returning Result<'TSuccess, 'TError>`` () =
     let successResult = handleErrorByReturningResult "1"
-    Assert.True((successResult = Ok 1))
+    (successResult = Ok 1) |> should equal true
     
     let failureResult = handleErrorByReturningResult "a"
-    Assert.True((failureResult = Error "Could not convert input to integer"))
+    (failureResult = Error "Could not convert input to integer") |> should equal true
 
 // In the previous test, we defined a Result<'TSuccess, 'TError> type. The next step is
 // to be able to execute several validations in sequence. The problem that quickly
@@ -66,8 +63,7 @@ let ``Returning Result<'TSuccess, 'TError>`` () =
 //
 // In this test, your task is to write a function "bind", that allows you to combine
 // two functions that take a 'TSuccess instance and return a Result<'TSuccess, 'TError> instance.
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Using railway-oriented programming`` () =
     let validate1 x = if x > 5 then Ok x else Error "Input less than or equal to five"
     let validate2 x = if x < 10 then Ok x else Error "Input greater than or equal to ten"
@@ -81,23 +77,22 @@ let ``Using railway-oriented programming`` () =
         >> bind validate3
 
     let firstValidationFailureResult = combinedValidation 1            
-    Assert.True((firstValidationFailureResult = Error "Input less than or equal to five"))
+    (firstValidationFailureResult = Error "Input less than or equal to five") |> should equal true
 
     let secondValidationFailureResult = combinedValidation 23          
-    Assert.True((secondValidationFailureResult = Error "Input greater than or equal to ten"))
+    (secondValidationFailureResult = Error "Input greater than or equal to ten") |> should equal true
 
     let thirdValidationFailureResult = combinedValidation 8        
-    Assert.True((thirdValidationFailureResult = Error "Input is not odd"))
+    (thirdValidationFailureResult = Error "Input is not odd") |> should equal true
 
     let successResult = combinedValidation 7        
-    Assert.True((successResult = Ok 7))
+    (successResult = Ok 7) |> should equal true
     
 // If you are dealing with code that throws exceptions, you should ensure that any
 // disposable resources that are used are being disposed of
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cleaning up disposables when throwing exception`` () =    
     let resource = new Resource()
 
-    Assert.That((fun () -> cleanupDisposablesWhenThrowingException resource |> ignore), Throws.Exception)
-    Assert.True(resource.Disposed())
+    (fun () -> cleanupDisposablesWhenThrowingException resource |> ignore) |> should throw typeof<Exception>
+    resource.Disposed() |> should equal true

data/tracks/fsharp/exercises/error-handling/Program.fs

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

data/tracks/fsharp/exercises/etl/Etl.fs

@@ -0,0 +1,3 @@
+module ETL
+
+let transform (scoresWithLetters: Map<int, string list>): Map<string, int> = failwith "You need to implement this function."

data/tracks/fsharp/exercises/etl/Etl.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Etl.fs" />
+    <Compile Include="EtlTest.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/etl/{ETLTest.fs → EtlTest.fs}

@@ -1,30 +1,28 @@
-module ETLTest
+module ETLTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open ETL
 
-[<Test>]
+[<Fact>]
 let ``Transforms one value`` () =
     let old = [(1, ["A"])] |> Map.ofSeq
     let expected = [("a", 1)] |> Map.ofSeq
-    Assert.That(transform old, Is.EqualTo(expected))
+    transform old |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Transforms multiple values`` () =
     let old = [(1, ["A"; "E"; "I"; "O"; "U"])] |> Map.ofSeq
     let expected = [("a", 1); ("e", 1); ("i", 1); ("o", 1); ("u", 1)] |> Map.ofSeq
-    Assert.That(transform old, Is.EqualTo(expected))
+    transform old |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Transforms multiple keys`` () =
     let old = [(1, ["A"; "E"]); (2, ["D"; "G"])] |> Map.ofSeq
     let expected = [("a", 1); ("e", 1); ("d", 2); ("g", 2); ] |> Map.ofSeq
-    Assert.That(transform old, Is.EqualTo(expected))
+    transform old |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Transforms a full dataset`` () =
     let old = [(1, ["A"; "E"; "I"; "O"; "U"; "L"; "N"; "R"; "S"; "T"]); 
                 (2, ["D"; "G"]); 
@@ -38,4 +36,4 @@ let ``Transforms a full dataset`` () =
                     ("j", 8);  ("k", 5);  ("l", 1);  ("m", 3);  ("n", 1);  ("o", 1);  ("p", 3);  ("q", 10);  ("r", 1); 
                     ("s", 1);  ("t", 1);  ("u", 1);  ("v", 4);  ("w", 4);  ("x", 8);  ("y", 4);  ("z", 10 )] |> Map.ofSeq
 
-    Assert.That(transform old, Is.EqualTo(expected))
+    transform old |> should equal expected

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

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

data/tracks/fsharp/exercises/food-chain/FoodChain.fs

@@ -0,0 +1,5 @@
+module FoodChain
+
+let verse number = failwith "You need to implement this function."
+
+let song: string = failwith "You need to implement this function."

data/tracks/fsharp/exercises/food-chain/FoodChain.fsproj

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