trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/alphametics/Alphametics.fsproj

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

@@ -1,58 +1,52 @@
-module AlphameticsTest
+module AlphameticsTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Alphametics
 
-[<Test>]
+[<Fact>]
 let ``Puzzle with three letters`` () =
     let actual = solve "I + BB == ILL"
     let expected = ['I', 1; 'B', 9; 'L', 0] |> Map.ofList |> Some
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Solution must have unique value for each letter`` () =
     let actual = solve "A == B"
-    Assert.That(actual, Is.EqualTo(None))
+    actual |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Leading zero solution is invalid`` () =
     let actual = solve "ACA + DD == BD"        
-    Assert.That(actual, Is.EqualTo(None))
+    actual |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Puzzle with four letters`` () =
     let actual = solve "AS + A == MOM"
     let expected = ['A', 9; 'S', 2; 'M', 1; 'O', 0] |> Map.ofList |> Some
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Puzzle with six letters`` () =
     let actual = solve "NO + NO + TOO == LATE"
     let expected = ['N', 7; 'O', 4; 'T', 9; 'L', 1; 'A', 0; 'E', 2] |> Map.ofList |> Some
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Puzzle with seven letters`` () =
     let actual = solve "HE + SEES + THE == LIGHT"
     let expected = ['E', 4; 'G', 2; 'H', 5; 'I', 0; 'L', 1; 'S', 9; 'T', 7] |> Map.ofList |> Some
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Puzzle with eight letters`` () =
     let actual = solve "SEND + MORE == MONEY"
     let expected = ['S', 9; 'E', 5; 'N', 6; 'D', 7; 'M', 1; 'O', 0; 'R', 8; 'Y', 2] |> Map.ofList |> Some
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Puzzle with ten letters`` () =
     let actual = solve "AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE"
     let expected = ['A', 5; 'D', 3; 'E', 4; 'F', 7; 'G', 8; 'N', 0; 'O', 2; 'R', 1; 'S', 6; 'T', 9] |> Map.ofList |> Some
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected

data/tracks/fsharp/exercises/alphametics/Example.fs

@@ -5,23 +5,23 @@ open System
 open FParsec
 open System.Text.RegularExpressions
 
-let plus = pstring " + "
-let equal = pstring " == "
-let operand = many1Satisfy isAsciiUpper
-let expression = sepBy operand plus
-let equation = expression .>> equal .>>. expression
+let private plus = pstring " + "
+let private equal = pstring " == "
+let private operand = many1Satisfy isAsciiUpper
+let private expression = sepBy operand plus
+let private equation = expression .>> equal .>>. expression
 
-let parseToOption parser (input: string) =
+let private parseToOption parser (input: string) =
     match run parser input with
     | Success(result, _, _)   -> Some result
     | Failure(errorMsg, _, _) -> None
 
-let parseEquation = parseToOption equation
+let private parseEquation = parseToOption equation
 
-let operandToInt (map: Map<char, int>) (operand: string) =
+let private operandToInt (map: Map<char, int>) (operand: string) =
     Seq.fold (fun acc x -> acc * 10 + Map.find x map) 0 operand
 
-let generateCombinations length =
+let private generateCombinations length =
     let rec helper remaining options =
         seq { if remaining = 0 then yield [] else
                 for x in options do
@@ -30,7 +30,7 @@ let generateCombinations length =
 
     helper length ([0..9] |> Set.ofList)
 
-let generateMaps (leftOperands, rightOperands) =
+let private generateMaps (leftOperands, rightOperands) =
     let operands = leftOperands @ rightOperands 
     let chars = operands |> String.concat "" |> Set.ofSeq
     let nonZeroChars = operands |> List.map Seq.head |> Set.ofList
@@ -39,14 +39,14 @@ let generateMaps (leftOperands, rightOperands) =
     |> Seq.map (Seq.zip chars >> Map.ofSeq)
     |> Seq.filter (fun m -> Set.forall (fun x -> Map.find x m <> 0) nonZeroChars)
 
-let sumOperands lettersToDigits = List.sumBy (operandToInt lettersToDigits)
+let private sumOperands lettersToDigits = List.sumBy (operandToInt lettersToDigits)
 
-let trySolve (leftOperands, rightOperands) lettersToDigits =
+let private trySolve (leftOperands, rightOperands) lettersToDigits =
     let left = sumOperands lettersToDigits leftOperands
     let right = sumOperands lettersToDigits rightOperands
     left = right
 
-let solve input = 
+let solve input: Map<char, int> option = 
     match parseEquation input with
     | Some equation -> Seq.tryFind (trySolve equation) (generateMaps equation)
     | None -> None

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

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

data/tracks/fsharp/exercises/anagram/Anagram.fs

@@ -0,0 +1,3 @@
+module Anagram
+
+let anagrams sources target = failwith "You need to implement this function."

data/tracks/fsharp/exercises/anagram/Anagram.fsproj

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

@@ -1,68 +1,57 @@
 module AnagramTest
 
 open System
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Anagram
 
-[<Test>]
+[<Fact>]
 let ``No matches`` () =
     let words = ["hello"; "world"; "zombies"; "pants"]
-    let expected = []
-    Assert.That(anagrams words "diaper", Is.EquivalentTo(expected))
+    anagrams words "diaper" |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Detect simple anagram`` () =
     let words = ["tan"; "stand"; "at"]
     let expected = ["tan"]
-    Assert.That(anagrams words "ant", Is.EquivalentTo(expected))
+    anagrams words "ant" |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Detect multiple anagrams`` () =
     let words = ["stream"; "pigeon"; "maters"]
-    let expected = ["maters"; "stream"]
-    Assert.That(anagrams words "master", Is.EquivalentTo(expected));
+    let expected = ["stream"; "maters"]
+    anagrams words "master" |> should equal expected;
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Does not confuse different duplicates`` () =
     let words = ["eagle"]
-    let expected = []
-    Assert.That(anagrams words "galea", Is.EquivalentTo(expected));
+    anagrams words "galea" |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Identical word is not anagram`` () =
     let words = ["corn"; "dark"; "Corn"; "rank"; "CORN"; "cron"; "park"]
     let expected = ["cron"]
-    Assert.That(anagrams words "corn", Is.EquivalentTo(expected))
+    anagrams words "corn" |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Eliminate anagrams with same checksum`` () =
     let words = ["last"]
-    let expected = []
-    Assert.That(anagrams words "mass", Is.EquivalentTo(expected))
+    anagrams words "mass" |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Eliminate anagram subsets`` () =
     let words = ["dog"; "goody"]
-    let expected = []
-    Assert.That(anagrams words "good", Is.EquivalentTo(expected))
+    anagrams words "good" |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Detect anagrams`` () =
     let words = ["gallery"; "ballerina"; "regally"; "clergy"; "largely"; "leading"]
-    let expected = ["gallery"; "largely"; "regally"]
+    let expected = ["gallery"; "regally"; "largely"]
     let actual = anagrams words "allergy"
-    Assert.That(actual, Is.EquivalentTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Anagrams are case insensitive`` () =
     let words = ["cashregister"; "Carthorse"; "radishes"]
     let expected = ["Carthorse"]
-    Assert.That(anagrams words "Orchestra", Is.EquivalentTo(expected))
+    anagrams words "Orchestra" |> should equal expected

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

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

data/tracks/fsharp/exercises/atbash-cipher/AtbashCipher.fs

@@ -0,0 +1,3 @@
+module Atbash
+
+let encode str = failwith "You need to implement this function."

data/tracks/fsharp/exercises/atbash-cipher/AtbashCipher.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="AtbashCipher.fs" />
+    <Compile Include="AtbashCipherTest.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/atbash-cipher/{AtbashTest.fs → AtbashCipherTest.fs}

@@ -1,67 +1,61 @@
 module AtbashTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Atbash
 
-[<Test>]
+[<Fact>]
 let ``Encode yes`` () =
     let phrase = "yes"
     let expected = "bvh"
     let actual = encode phrase
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]     
 let ``Encode no`` () =
     let phrase = "no"
     let expected = "ml"
     let actual = encode phrase
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]     
 let ``Encode OMG`` () =
     let phrase = "OMG"
     let expected = "lnt"
     let actual = encode phrase
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]     
 let ``Encode spaces`` () =
     let phrase = "O M G"
     let expected = "lnt"
     let actual = encode phrase
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]     
 let ``Encode mindblowingly`` () =
     let phrase = "mindblowingly"
     let expected = "nrmwy oldrm tob"
     let actual = encode phrase
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]     
 let ``Encode numbers`` () =
     let phrase = "Testing, 1 2 3, testing."
     let expected = "gvhgr mt123 gvhgr mt"
     let actual = encode phrase
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]     
 let ``Encode deep thought`` () =
     let phrase = "Truth is fiction."
     let expected = "gifgs rhurx grlm"
     let actual = encode phrase
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]     
 let ``Encode all the letters`` () =
     let phrase = "The quick brown fox jumps over the lazy dog."
     let expected = "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
     let actual = encode phrase
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected

data/tracks/fsharp/exercises/atbash-cipher/Program.fs

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

data/tracks/fsharp/exercises/bank-account/BankAccount.fs

@@ -0,0 +1,11 @@
+module BankAccount
+
+let mkBankAccount() = failwith "You need to implement this function."
+
+let openAccount account = failwith "You need to implement this function."
+
+let closeAccount account = failwith "You need to implement this function."
+
+let getBalance account = failwith "You need to implement this function."
+
+let updateBalance change account = failwith "You need to implement this function."

data/tracks/fsharp/exercises/bank-account/BankAccount.fsproj

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

@@ -1,16 +1,16 @@
-module BankAccountTest
+module BankAccountTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open BankAccount
 
-[<Test>]
+[<Fact>]
 let ``Returns empty balance after opening`` () =
     let account = mkBankAccount() |> openAccount
 
-    Assert.That(getBalance account, Is.EqualTo(Some 0.0))
+    getBalance account |> should equal <| Some 0.0
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Check basic balance`` () =
     let account = mkBankAccount() |> openAccount
     let openingBalance = account |> getBalance 
@@ -20,11 +20,10 @@ let ``Check basic balance`` () =
         |> updateBalance 10.0 
         |> getBalance
 
-    Assert.That(openingBalance, Is.EqualTo(Some 0.0))
-    Assert.That(updatedBalance, Is.EqualTo(Some 10.0))
+    openingBalance |> should equal <| Some 0.0
+    updatedBalance |> should equal <| Some 10.0
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Balance can increment or decrement`` () =    
     let account = mkBankAccount() |> openAccount
     let openingBalance = account |> getBalance 
@@ -39,22 +38,20 @@ let ``Balance can increment or decrement`` () =
         |> updateBalance -15.0
         |> getBalance
 
-    Assert.That(openingBalance, Is.EqualTo(Some 0.0))
-    Assert.That(addedBalance, Is.EqualTo(Some 10.0))
-    Assert.That(subtractedBalance, Is.EqualTo(Some -5.0))
+    openingBalance |> should equal <| Some 0.0
+    addedBalance |> should equal <| Some 10.0
+    subtractedBalance |> should equal <| Some -5.0
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Account can be closed`` () =
     let account = 
         mkBankAccount()
         |> openAccount
         |> closeAccount
 
-    Assert.That(account |> getBalance, Is.EqualTo(None))
+    getBalance account |> should equal None
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Account can be updated from multiple threads`` () =
     let account = 
         mkBankAccount()
@@ -73,4 +70,4 @@ let ``Account can be updated from multiple threads`` () =
     |> Async.RunSynchronously
     |> ignore
 
-    Assert.That(account |> getBalance, Is.EqualTo(Some 1000.0))
+    getBalance account |> should equal <| Some 1000.0

data/tracks/fsharp/exercises/bank-account/Program.fs

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

data/tracks/fsharp/exercises/beer-song/BeerSong.fs

@@ -0,0 +1,7 @@
+module BeerSong
+
+let verse (n: int) = failwith "You need to implement this function."
+
+let verses (stop: int) (start: int) = failwith "You need to implement this function."
+
+let sing: string = failwith "You need to implement this function."

data/tracks/fsharp/exercises/beer-song/BeerSong.fsproj

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

@@ -1,50 +1,45 @@
-module BeerSongTest
+module BeerSongTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open BeerSong
     
-[<Test>]
+[<Fact>]
 let ``Test a typical verse`` () = 
     let expected = 
         "8 bottles of beer on the wall, 8 bottles of beer.\nTake one down and pass it around, 7 bottles of beer on the wall.\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 ``Test another typical verse`` () = 
     let expected = 
         "3 bottles of beer on the wall, 3 bottles of beer.\nTake one down and pass it around, 2 bottles of beer on the wall.\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 ``Test verse 1`` () = 
     let expected = 
         "1 bottle of beer on the wall, 1 bottle of beer.\nTake it down and pass it around, no more bottles of beer on the wall.\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 ``Test verse 2`` () = 
     let expected = 
         "2 bottles of beer on the wall, 2 bottles of beer.\nTake one down and pass it around, 1 bottle of beer on the wall.\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 ``Test verse 0`` () = 
     let expected = 
         "No more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.\n"
-    Assert.That(verse 0, Is.EqualTo(expected))
+    verse 0 |> should equal expected
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test several verses`` () = 
     let expected = 
         "8 bottles of beer on the wall, 8 bottles of beer.\nTake one down and pass it around, 7 bottles of beer on the wall.\n\n7 bottles of beer on the wall, 7 bottles of beer.\nTake one down and pass it around, 6 bottles of beer on the wall.\n\n6 bottles of beer on the wall, 6 bottles of beer.\nTake one down and pass it around, 5 bottles of beer on the wall.\n\n"
-    Assert.That(verses 8 6, Is.EqualTo(expected))
+    verses 8 6 |> should equal expected
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test the whole song`` () = 
-    Assert.That(verses 99 0, Is.EqualTo(sing))
+    verses 99 0 |> should equal sing

data/tracks/fsharp/exercises/beer-song/Program.fs

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

data/tracks/fsharp/exercises/binary-search/BinarySearch.fs

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

data/tracks/fsharp/exercises/binary-search/BinarySearch.fsproj

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