trackler 2.2.1.22 → 2.2.1.23

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

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

@@ -1,54 +1,46 @@
 module PrimeFactorsTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open PrimeFactors
 
-[<Test>]
+[<Fact>]
 let ``Test 1`` () =
-    Assert.That(primeFactorsFor 1L, Is.EqualTo([]))
+    primeFactorsFor 1L |> should be Empty
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 2`` () =
-    Assert.That(primeFactorsFor 2L, Is.EqualTo([2]))
+    primeFactorsFor 2L |> should equal [2]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 3`` () =
-    Assert.That(primeFactorsFor 3L, Is.EqualTo([3]))
+    primeFactorsFor 3L |> should equal [3]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 4`` () =
-    Assert.That(primeFactorsFor 4L, Is.EqualTo([2; 2]))
+    primeFactorsFor 4L |> should equal [2; 2]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 6`` () =
-    Assert.That(primeFactorsFor 6L, Is.EqualTo([2; 3]))
+    primeFactorsFor 6L |> should equal [2; 3]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 8`` () =
-    Assert.That(primeFactorsFor 8L, Is.EqualTo([2; 2; 2]))
+    primeFactorsFor 8L |> should equal [2; 2; 2]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 9`` () =
-    Assert.That(primeFactorsFor 9L, Is.EqualTo([3; 3]))
+    primeFactorsFor 9L |> should equal [3; 3]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 27`` () =
-    Assert.That(primeFactorsFor 27L, Is.EqualTo([3; 3; 3]))
+    primeFactorsFor 27L |> should equal [3; 3; 3]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 625`` () =
-    Assert.That(primeFactorsFor 625L, Is.EqualTo([5; 5; 5; 5]))
+    primeFactorsFor 625L |> should equal [5; 5; 5; 5]
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Test 901255`` () =
-    Assert.That(primeFactorsFor 901255L, Is.EqualTo([5; 17; 23; 461]))
+    primeFactorsFor 901255L |> should equal [5; 17; 23; 461]

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

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

data/tracks/fsharp/exercises/protein-translation/Program.fs

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

data/tracks/fsharp/exercises/protein-translation/ProteinTranslation.fs

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

data/tracks/fsharp/exercises/protein-translation/ProteinTranslation.fsproj

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

@@ -1,60 +1,65 @@
-module ProteinTranslationTest
+module ProteinTranslationTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
+open System
 
 open ProteinTranslation
 
-[<TestCase("AUG")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData("AUG")>]
 let ``Identifies Methionine codons`` (codon) =
-    Assert.That(translate codon, Is.EqualTo(["Methionine"]))
+    translate codon |> should equal ["Methionine"]
     
-[<TestCase("UUU", Ignore = "Remove to run test case")>]
-[<TestCase("UUC", Ignore = "Remove to run test case")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData("UUU")>]
+[<InlineData("UUC")>]
 let ``Identifies Phenylalanine codons`` (codon) =
-    Assert.That(translate codon, Is.EqualTo(["Phenylalanine"]))
-    
-[<TestCase("UUA", Ignore = "Remove to run test case")>]
-[<TestCase("UUG", Ignore = "Remove to run test case")>]
+    translate codon |> should equal ["Phenylalanine"]
+ 
+[<Theory(Skip = "Remove to run test")>]   
+[<InlineData("UUA")>]
+[<InlineData("UUG")>]
 let ``Identifies Leucine codons`` (codon) =
-    Assert.That(translate codon, Is.EqualTo(["Leucine"]))
+    translate codon |> should equal ["Leucine"]
     
-[<TestCase("UCU", Ignore = "Remove to run test case")>]
-[<TestCase("UCC", Ignore = "Remove to run test case")>]
-[<TestCase("UCA", Ignore = "Remove to run test case")>]
-[<TestCase("UCG", Ignore = "Remove to run test case")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData("UCU")>]
+[<InlineData("UCC")>]
+[<InlineData("UCA")>]
+[<InlineData("UCG")>]
 let ``Identifies Serine codons`` (codon) =
-    Assert.That(translate codon, Is.EqualTo(["Serine"]))
+    translate codon |> should equal ["Serine"]
     
-[<TestCase("UAU", Ignore = "Remove to run test case")>]
-[<TestCase("UAC", Ignore = "Remove to run test case")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData("UAU")>]
+[<InlineData("UAC")>]
 let ``Identifies Tyrosine codons`` (codon) =
-    Assert.That(translate codon, Is.EqualTo(["Tyrosine"]))
+    translate codon |> should equal ["Tyrosine"]
     
-[<TestCase("UGU", Ignore = "Remove to run test case")>]
-[<TestCase("UGC", Ignore = "Remove to run test case")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData("UGU")>]
+[<InlineData("UGC")>]
 let ``Identifies Cysteine codons`` (codon) =
-    Assert.That(translate codon, Is.EqualTo(["Cysteine"]))
+    translate codon |> should equal ["Cysteine"]
     
-[<TestCase("UGG", Ignore = "Remove to run test case")>] 
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData("UGG")>] 
 let ``Identifies Tryptophan codons`` (codon) =
-    Assert.That(translate codon, Is.EqualTo(["Tryptophan"]))
+    translate codon |> should equal ["Tryptophan"]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Translates rna strand into correct protein`` () =
-    Assert.That(translate "AUGUUUUGG", Is.EqualTo(["Methionine"; "Phenylalanine"; "Tryptophan"]))
+    translate "AUGUUUUGG" |> should equal ["Methionine"; "Phenylalanine"; "Tryptophan"]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Stops translation if stop codon present`` () =
-    Assert.That(translate "AUGUUUUAA", Is.EqualTo(["Methionine"; "Phenylalanine"]))
+    translate "AUGUUUUAA" |> should equal ["Methionine"; "Phenylalanine"]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Stops translation of longer strand`` () =
-    Assert.That(translate "UGGUGUUAUUAAUGGUUU'", Is.EqualTo(["Tryptophan"; "Cysteine"; "Tyrosine"]))
+    translate "UGGUGUUAUUAAUGGUUU'" |> should equal ["Tryptophan"; "Cysteine"; "Tyrosine"]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Throws for invalid codons`` () =
-    Assert.That((fun () -> translate "CARROT'" |> List.ofSeq |> ignore), Throws.Exception)
+    (fun () -> translate "CARROT'" |> List.ofSeq |> ignore) |> should throw typeof<Exception>

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

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

data/tracks/fsharp/exercises/proverb/Proverb.fs

@@ -0,0 +1,5 @@
+module Proverb
+
+let line number = failwith "You need to implement this function."
+
+let proverb: string = failwith "You need to implement this function."

data/tracks/fsharp/exercises/proverb/Proverb.fsproj

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

@@ -1,25 +1,23 @@
-module ProverbTest
+module ProverbTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Proverb
 
-[<Test>]
+[<Fact>]
 let ``Line one`` () =
-    Assert.That(line 1, Is.EqualTo("For want of a nail the shoe was lost."))
+    line 1 |> should equal "For want of a nail the shoe was lost."
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Line four`` () =
-    Assert.That(line 4, Is.EqualTo("For want of a rider the message was lost."))
+    line 4 |> should equal "For want of a rider the message was lost."
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Line seven`` () =
-    Assert.That(line 7, Is.EqualTo("And all for the want of a horseshoe nail."))
+    line 7 |> should equal "And all for the want of a horseshoe nail."
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Proverb`` () =
     let expected =
         ["For want of a nail the shoe was lost.";
@@ -31,4 +29,4 @@ let ``Proverb`` () =
          "And all for the want of a horseshoe nail."]
         |> List.reduce (fun x y -> x + "\n" + y)
 
-    Assert.That(proverb, Is.EqualTo(expected))
+    proverb |> should equal expected

data/tracks/fsharp/exercises/pythagorean-triplet/Program.fs

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

data/tracks/fsharp/exercises/pythagorean-triplet/PythagoreanTriplet.fs

@@ -0,0 +1,7 @@
+module PythagoreanTriplet
+
+let triplet x y z = failwith "You need to implement this function."
+
+let isPythagorean triplet = failwith "You need to implement this function."
+
+let pythagoreanTriplets min max = failwith "You need to implement this function."

data/tracks/fsharp/exercises/pythagorean-triplet/PythagoreanTriplet.fsproj

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

@@ -1,35 +1,34 @@
 module PythagoreanTripletTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open PythagoreanTriplet
     
-[<TestCase(3, 4, 5, ExpectedResult = true)>]
-[<TestCase(3, 5, 4, ExpectedResult = true, Ignore = "Remove to run test case")>]
-[<TestCase(4, 3, 5, ExpectedResult = true, Ignore = "Remove to run test case")>]
-[<TestCase(4, 5, 3, ExpectedResult = true, Ignore = "Remove to run test case")>]
-[<TestCase(5, 3, 4, ExpectedResult = true, Ignore = "Remove to run test case")>]
-[<TestCase(5, 4, 3, ExpectedResult = true, Ignore = "Remove to run test case")>]
-[<TestCase(3, 3, 3, ExpectedResult = false, Ignore = "Remove to run test case")>]
-[<TestCase(5, 6, 7, ExpectedResult = false, Ignore = "Remove to run test case")>]
-let ``Can recognize a valid pythagorean`` (x: int) (y: int) (z: int) =
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(3, 4, 5, true)>]
+[<InlineData(3, 5, 4, true)>]
+[<InlineData(4, 3, 5, true)>]
+[<InlineData(4, 5, 3, true)>]
+[<InlineData(5, 3, 4, true)>]
+[<InlineData(5, 4, 3, true)>]
+[<InlineData(3, 3, 3, false)>]
+[<InlineData(5, 6, 7, false)>]
+let ``Can recognize a valid pythagorean`` (x: int) (y: int) (z: int) (expected: bool) =
     let actual = triplet x y z
-    isPythagorean actual
+    isPythagorean actual |> should equal expected
    
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can create simple triplets`` () =
     let actual = pythagoreanTriplets 1 10
-    Assert.That(actual, Is.EqualTo([triplet 3 4 5; triplet 6 8 10]))
+    actual |> should equal [triplet 3 4 5; triplet 6 8 10]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can create more triplets`` () =
     let actual = pythagoreanTriplets 11 20
-    Assert.That(actual, Is.EqualTo([triplet 12 16 20]))
+    actual |> should equal [triplet 12 16 20]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can create complex triplets`` () =
     let actual = pythagoreanTriplets 56 95
-    Assert.That(actual, Is.EqualTo([triplet 57 76 95; triplet 60 63 87]))
+    actual |> should equal [triplet 57 76 95; triplet 60 63 87]

data/tracks/fsharp/exercises/queen-attack/Program.fs

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

data/tracks/fsharp/exercises/queen-attack/QueenAttack.fs

@@ -0,0 +1,3 @@
+module QueenAttack
+
+let canAttack (queen1: int * int) (queen2: int * int) = failwith "You need to implement this function."

data/tracks/fsharp/exercises/queen-attack/QueenAttack.fsproj

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

@@ -1,47 +1,41 @@
-module QueenAttackTest
+module QueenAttackTest
 
 open System
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open QueenAttack
 
-[<Test>]
+[<Fact>]
 let ``Cannot occupy same space`` () =
     let white = (2, 4)
     let black = (2, 4)
-    Assert.That((fun () -> canAttack white black |> ignore), Throws.Exception)
+    (fun () -> canAttack white black |> ignore) |> should throw typeof<Exception>
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Cannot attack`` () =
-    Assert.False(canAttack (2, 3) (4, 7))
+    canAttack (2, 3) (4, 7) |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can attack on same row`` () =
-    Assert.True(canAttack (2, 4) (2, 7))
+    canAttack (2, 4) (2, 7) |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can attack on same column`` () =
-    Assert.True(canAttack (5, 4) (2, 4))
+    canAttack (5, 4) (2, 4) |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can attack on diagonal`` () =
-    Assert.True(canAttack (1, 1) (6, 6))
+    canAttack (1, 1) (6, 6) |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can attack on other diagonal`` () =
-    Assert.True(canAttack (0, 6) (1, 7))
+    canAttack (0, 6) (1, 7) |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can attack on yet another diagonal`` () =
-    Assert.True(canAttack (4, 1) (6, 3))
+    canAttack (4, 1) (6, 3) |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can attack on a diagonal slanted the other way`` () =
-    Assert.True(canAttack (6, 1) (1, 6))
+    canAttack (6, 1) (1, 6) |> should equal true

data/tracks/fsharp/exercises/rail-fence-cipher/Program.fs

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

data/tracks/fsharp/exercises/rail-fence-cipher/RailFenceCipher.fs

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

data/tracks/fsharp/exercises/rail-fence-cipher/RailFenceCipher.fsproj

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

@@ -1,46 +1,42 @@
-module RailFenceCipherTest
+module RailFenceCipherTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open RailFenceCipher
 
-[<Test>]
+[<Fact>]
 let ``Encode with two rails`` () =
     let actual = encode 2 "XOXOXOXOXOXOXOXOXO"
     let expected = "XXXXXXXXXOOOOOOOOO"
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode with three rails`` () =
     let actual = encode 3 "WEAREDISCOVEREDFLEEATONCE"
     let expected = "WECRLTEERDSOEEFEAOCAIVDEN"
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode with ending in the middle`` () =
     let actual = encode 4 "EXERCISES"
     let expected = "ESXIEECSR"
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Decode with three rails`` () =
     let actual = decode 3 "TEITELHDVLSNHDTISEIIEA"
     let expected = "THEDEVILISINTHEDETAILS"
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Decode with five rails`` () =
     let actual = decode 5 "EIEXMSMESAORIWSCE"
     let expected = "EXERCISMISAWESOME"
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Decode with six rails`` () =
     let actual = decode 6 "133714114238148966225439541018335470986172518171757571896261"
     let expected = "112358132134558914423337761098715972584418167651094617711286"
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected

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

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

data/tracks/fsharp/exercises/raindrops/Raindrops.fs

@@ -0,0 +1,3 @@
+module Raindrops
+
+let convert (number: int): string = failwith "You need to implement this function."

data/tracks/fsharp/exercises/raindrops/Raindrops.fsproj

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