trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/roman-numerals/RomanNumeralsTest.fs

@@ -0,0 +1,28 @@
+module RomanNumeralTest
+
+open Xunit
+open FsUnit.Xunit
+open RomanNumeral
+    
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(0, "")>]
+[<InlineData(1, "I")>]
+[<InlineData(2, "II")>]
+[<InlineData(3, "III")>]
+[<InlineData(4, "IV")>]
+[<InlineData(5, "V")>]
+[<InlineData(6, "VI")>]
+[<InlineData(9, "IX")>]
+[<InlineData(27, "XXVII")>]
+[<InlineData(48, "XLVIII")>]
+[<InlineData(59, "LIX")>]
+[<InlineData(93, "XCIII")>]
+[<InlineData(141, "CXLI")>]
+[<InlineData(163, "CLXIII")>]
+[<InlineData(402, "CDII")>]
+[<InlineData(575, "DLXXV")>]
+[<InlineData(911, "CMXI")>]
+[<InlineData(1024, "MXXIV")>]
+[<InlineData(3000, "MMM")>]
+let ``Convert roman to arabic numerals`` arabicNumeral expected =
+    toRoman arabicNumeral |> should equal expected

data/tracks/fsharp/exercises/run-length-encoding/Program.fs

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

data/tracks/fsharp/exercises/run-length-encoding/RunLengthEncoding.fs

@@ -0,0 +1,5 @@
+module RunLengthEncoding
+
+let encode input = failwith "You need to implement this function."
+
+let decode input = failwith "You need to implement this function."

data/tracks/fsharp/exercises/run-length-encoding/RunLengthEncoding.fsproj

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

@@ -1,54 +1,49 @@
-module RunLengthEncodingTest
+module RunLengthEncodingTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open System.Text
 
 open RunLengthEncoding
 
-[<Test>]
+[<Fact>]
 let ``Encode simple`` () =
     let input = "AABBBCCCC"
     let expected = "2A3B4C"
-    Assert.That(encode input, Is.EqualTo(expected))
+    encode input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Decode simple`` () =
     let input = "2A3B4C"
     let expected = "AABBBCCCC"
-    Assert.That(decode input, Is.EqualTo(expected))
+    decode input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode with single values`` () =
     let input = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
     let expected = "12WB12W3B24WB"
-    Assert.That(encode input, Is.EqualTo(expected))
+    encode input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Decode with single values`` () =
     let input = "12WB12W3B24WB"
     let expected = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
-    Assert.That(decode input, Is.EqualTo(expected))
+    decode input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode and then decode`` () =
     let input = "zzz ZZ  zZ"
     let expected = "zzz ZZ  zZ"
-    Assert.That(encode input |> decode, Is.EqualTo(expected))
+    encode input |> decode |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode unicode`` () =
     let input = Encoding.Unicode.GetString([|240uy; 35uy; 189uy; 38uy; 189uy; 38uy; 189uy; 38uy; 80uy; 43uy; 80uy; 43uy; 240uy; 35uy|])
     let expected = Encoding.Unicode.GetString([|240uy; 35uy; 51uy; 0uy; 189uy; 38uy; 50uy; 0uy; 80uy; 43uy; 240uy; 35uy|])
-    Assert.That(encode input, Is.EqualTo(expected))
+    encode input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Decode unicode`` () =
     let input = Encoding.Unicode.GetString([|240uy; 35uy; 51uy; 0uy; 189uy; 38uy; 50uy; 0uy; 80uy; 43uy; 240uy; 35uy|])
     let expected = Encoding.Unicode.GetString([|240uy; 35uy; 189uy; 38uy; 189uy; 38uy; 189uy; 38uy; 80uy; 43uy; 80uy; 43uy; 240uy; 35uy|])
-    Assert.That(decode input, Is.EqualTo(expected))
+    decode input |> should equal expected

data/tracks/fsharp/exercises/saddle-points/Program.fs

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

data/tracks/fsharp/exercises/saddle-points/SaddlePoints.fs

@@ -0,0 +1,3 @@
+module SaddlePoints
+
+let saddlePoints matrix = failwith "You need to implement this function."

data/tracks/fsharp/exercises/saddle-points/SaddlePoints.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="SaddlePoints.fs" />
+    <Compile Include="SaddlePointsTest.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/saddle-points/{SaddlePointTest.fs → SaddlePointsTest.fs}

@@ -1,47 +1,44 @@
-module SaddlePointTest
+module SaddlePointTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open SaddlePoints
 
-[<Test>]
+[<Fact>]
 let ``Readme example`` () =
     let values = [ [ 9; 8; 7 ]; 
                    [ 5; 3; 2 ]; 
                    [ 6; 6; 7 ] ]
     let actual = saddlePoints values
-    Assert.That(actual, Is.EqualTo([(1, 0)]))
+    actual |> should equal [(1, 0)]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``No saddle point`` () =
     let values = [ [ 2; 1 ]; 
                    [ 1; 2 ] ]
     let actual = saddlePoints values
-    Assert.That(actual, Is.Empty)
+    actual |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Saddle point`` () =
     let values = [ [ 1; 2 ]; 
                    [ 3; 4 ] ]
     let actual = saddlePoints values
-    Assert.That(actual, Is.EqualTo([(0, 1)]))
+    actual |> should equal [(0, 1)]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Another saddle point`` () =
     let values = [ [ 18;  3; 39; 19;  91 ]; 
                    [ 38; 10;  8; 77; 320 ]; 
                    [  3;  4;  8;  6;   7 ] ]
     let actual = saddlePoints values
-    Assert.That(actual, Is.EqualTo([(2, 2)]))
+    actual |> should equal [(2, 2)]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Multiple saddle points`` () =
     let values = [ [ 4; 5; 4 ];
                    [ 3; 5; 5 ];
                    [ 1; 5; 4 ] ]
     let actual = saddlePoints values
-    Assert.That(actual, Is.EqualTo([(0, 1); (1, 1); (2, 1)]))   
+    actual |> should equal [(0, 1); (1, 1); (2, 1)]   

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

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

data/tracks/fsharp/exercises/say/Say.fs

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

data/tracks/fsharp/exercises/say/Say.fsproj

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

@@ -1,84 +1,70 @@
-module SayTest
+module SayTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Say
 
-[<Test>]
+[<Fact>]
 let ``Zero`` () =
-    Assert.That(inEnglish 0L, Is.EqualTo(Some "zero"))
+    inEnglish 0L |> should equal <| Some "zero"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One`` () =
-    Assert.That(inEnglish 1L, Is.EqualTo(Some "one"))
+    inEnglish 1L |> should equal <| Some "one"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Fourteen`` () =
-    Assert.That(inEnglish 14L, Is.EqualTo(Some "fourteen"))
+    inEnglish 14L |> should equal <| Some "fourteen"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Twenty`` () =
-    Assert.That(inEnglish 20L, Is.EqualTo(Some "twenty"))
+    inEnglish 20L |> should equal <| Some "twenty"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Twenty-two`` () =
-    Assert.That(inEnglish 22L, Is.EqualTo(Some "twenty-two"))
+    inEnglish 22L |> should equal <| Some "twenty-two"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One hundred`` () =
-    Assert.That(inEnglish 100L, Is.EqualTo(Some "one hundred"))
+    inEnglish 100L |> should equal <| Some "one hundred"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One hundred twenty-three`` () =
-    Assert.That(inEnglish 123L, Is.EqualTo(Some "one hundred twenty-three"))
+    inEnglish 123L |> should equal <| Some "one hundred twenty-three"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One thousand`` () =
-    Assert.That(inEnglish 1000L, Is.EqualTo(Some "one thousand"))
+    inEnglish 1000L |> should equal <| Some "one thousand"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One thousand two hundred thirty-four`` () =
-    Assert.That(inEnglish 1234L, Is.EqualTo(Some "one thousand two hundred thirty-four"))
+    inEnglish 1234L |> should equal <| Some "one thousand two hundred thirty-four"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One million`` () =
-    Assert.That(inEnglish 1000000L, Is.EqualTo(Some "one million"))
+    inEnglish 1000000L |> should equal <| Some "one million"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One million two`` () =
-    Assert.That(inEnglish 1000002L, Is.EqualTo(Some "one million two"))
+    inEnglish 1000002L |> should equal <| Some "one million two"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One million two thousand three hundred forty-five`` () =
-    Assert.That(inEnglish 1002345L, Is.EqualTo(Some "one million two thousand three hundred forty-five"))
+    inEnglish 1002345L |> should equal <| Some "one million two thousand three hundred forty-five"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One billion`` () =
-    Assert.That(inEnglish 1000000000L, Is.EqualTo(Some "one billion"))
+    inEnglish 1000000000L |> should equal <| Some "one billion"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``A big number`` () =
-    Assert.That(inEnglish 987654321123L, Is.EqualTo(Some "nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three"))
+    inEnglish 987654321123L |> should equal <| Some "nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three"
  
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Lower bound`` () =
-    Assert.That(inEnglish -1L, Is.EqualTo(None))
+    inEnglish -1L |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Upper bound`` () =
-    Assert.That(inEnglish 1000000000000L, Is.EqualTo(None))
+    inEnglish 1000000000000L |> should equal None

data/tracks/fsharp/exercises/scale-generator/Program.fs

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

data/tracks/fsharp/exercises/scale-generator/ScaleGenerator.fs

@@ -0,0 +1,3 @@
+module ScaleGenerator
+
+let pitches tonic pattern = failwith "You need to implement this function."

data/tracks/fsharp/exercises/scale-generator/ScaleGenerator.fsproj

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

@@ -1,102 +1,90 @@
-module ScaleGeneratorTest
+module ScaleGeneratorTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open ScaleGenerator
 
-[<Test>]
+[<Fact>]
 let ``Major scale`` () =
     let major = pitches "C" "MMmMMMm"
     let expected = ["C"; "D"; "E"; "F"; "G"; "A"; "B"]
-    Assert.That(major, Is.EqualTo(expected))
+    major |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Another major scale`` () =
     let major = pitches "G" "MMmMMMm"
     let expected = ["G"; "A"; "B"; "C"; "D"; "E"; "F#"]
-    Assert.That(major, Is.EqualTo(expected))
+    major |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Minor scale`` () =
     let minor = pitches "f#" "MmMMmMM"
     let expected = ["F#"; "G#"; "A"; "B"; "C#"; "D"; "E"]
-    Assert.That(minor, Is.EqualTo(expected))
+    minor |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Another minor scale`` () =
     let minor = pitches "bb" "MmMMmMM"
     let expected = ["Bb"; "C"; "Db"; "Eb"; "F"; "Gb"; "Ab"]
-    Assert.That(minor, Is.EqualTo(expected))
+    minor |> should equal expected
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Dorian mode`` () =
     let dorian = pitches "d" "MmMMMmM"
     let expected = ["D"; "E"; "F"; "G"; "A"; "B"; "C"]
-    Assert.That(dorian, Is.EqualTo(expected))
+    dorian |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Mixolydian mode`` () =
     let mixolydian = pitches "Eb" "MMmMMmM"
     let expected = ["Eb"; "F"; "G"; "Ab"; "Bb"; "C"; "Db"]
-    Assert.That(mixolydian, Is.EqualTo(expected))
+    mixolydian |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Lydian mode`` () =
     let lydian = pitches "a" "MMMmMMm"
     let expected = ["A"; "B"; "C#"; "D#"; "E"; "F#"; "G#"]
-    Assert.That(lydian, Is.EqualTo(expected))
+    lydian |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Phrygian mode`` () =
     let phrygian = pitches "e" "mMMMmMM"
     let expected = ["E"; "F"; "G"; "A"; "B"; "C"; "D"]
-    Assert.That(phrygian, Is.EqualTo(expected))
+    phrygian |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Locrian mode`` () =
     let locrian = pitches "g" "mMMmMMM"
     let expected = ["G"; "Ab"; "Bb"; "C"; "Db"; "Eb"; "F"]
-    Assert.That(locrian, Is.EqualTo(expected))
+    locrian |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Harmonic minor`` () =
     let harmonicMinor = pitches "d" "MmMMmAm"
     let expected = ["D"; "E"; "F"; "G"; "A"; "Bb"; "Db"]
-    Assert.That(harmonicMinor, Is.EqualTo(expected))
+    harmonicMinor |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Octatonic`` () =
     let octatonic = pitches "C" "MmMmMmMm"
     let expected = ["C"; "D"; "D#"; "F"; "F#"; "G#"; "A"; "B"]
-    Assert.That(octatonic, Is.EqualTo(expected))
+    octatonic |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Hexatonic`` () =
     let hexatonic = pitches "Db" "MMMMMM"
     let expected = ["Db"; "Eb"; "F"; "G"; "A"; "B"]
-    Assert.That(hexatonic, Is.EqualTo(expected))
+    hexatonic |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Pentatonic`` () =
     let pentatonic = pitches "A" "MMAMA"
     let expected = ["A"; "B"; "C#"; "E"; "F#"]
-    Assert.That(pentatonic, Is.EqualTo(expected))
+    pentatonic |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Enigmatic`` () =
     let enigmatic = pitches "G" "mAMMMmm"
     let expected = ["G"; "G#"; "B"; "C#"; "D#"; "F"; "F#"]
-    Assert.That(enigmatic, Is.EqualTo(expected))
+    enigmatic |> should equal expected

data/tracks/fsharp/exercises/scrabble-score/Program.fs

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

data/tracks/fsharp/exercises/scrabble-score/ScrabbleScore.fs

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

data/tracks/fsharp/exercises/scrabble-score/ScrabbleScore.fsproj

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

@@ -1,43 +1,37 @@
 module ScrabbleScoreTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open ScrabbleScore
   
-[<Test>]
+[<Fact>]
 let ``Empty word scores zero`` () =
-    Assert.That(score "", Is.EqualTo(0))
+    score "" |> should equal 0
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Whitespace scores zero`` () =
-    Assert.That(score " \t\n", Is.EqualTo(0))
+    score " \t\n" |> should equal 0
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Scores very short word`` () =
-    Assert.That(score "a", Is.EqualTo(1))
+    score "a" |> should equal 1
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Scores other very short word`` () =
-    Assert.That(score "f", Is.EqualTo(4))
+    score "f" |> should equal 4
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Simple word scores the number of letters`` () =
-    Assert.That(score "street", Is.EqualTo(6))
+    score "street" |> should equal 6
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Complicated word scores more`` () =
-    Assert.That(score "quirky", Is.EqualTo(22))
+    score "quirky" |> should equal 22
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Scores are case insensitive`` () =
-    Assert.That(score "OXYPHENBUTAZONE", Is.EqualTo(41))
+    score "OXYPHENBUTAZONE" |> should equal 41
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Entire alphabet`` () =
-    Assert.That(score "abcdefghijklmnopqrstuvwxyz", Is.EqualTo(87))
+    score "abcdefghijklmnopqrstuvwxyz" |> should equal 87

data/tracks/fsharp/exercises/secret-handshake/Program.fs

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

data/tracks/fsharp/exercises/secret-handshake/SecretHandshake.fs

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