trackler 2.2.1.22 → 2.2.1.23

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

@@ -1,35 +1,41 @@
 module RaindropsTest
     
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Raindrops
 
-[<TestCase(1, ExpectedResult = "1")>]
-[<TestCase(52, ExpectedResult = "52", Ignore = "Remove to run test case")>]
-[<TestCase(12121, ExpectedResult = "12121", Ignore = "Remove to run test case")>]
-let ``Non primes pass through`` (number) =
-    convert number
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(1, "1")>]
+[<InlineData(52, "52")>]
+[<InlineData(12121, "12121")>]
+let ``Non primes pass through`` number expected =
+    convert number |> should equal expected
 
-[<TestCase(3, Ignore = "Remove to run test case")>]
-[<TestCase(6, Ignore = "Remove to run test case")>]
-[<TestCase(9, Ignore = "Remove to run test case")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(3)>]
+[<InlineData(6)>]
+[<InlineData(9)>]
 let ``Numbers containing 3 as a prime factor give pling`` (number) =
-    Assert.That(convert number, Is.EqualTo("Pling"))
+    convert number |> should equal "Pling"
 
-[<TestCase(5, Ignore = "Remove to run test case")>]
-[<TestCase(10, Ignore = "Remove to run test case")>]
-[<TestCase(25, Ignore = "Remove to run test case")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(5)>]
+[<InlineData(10)>]
+[<InlineData(25)>]
 let ``Numbers containing 5 as a prime factor give plang`` (number) =
-    Assert.That(convert number, Is.EqualTo("Plang"))
+    convert number |> should equal "Plang"
 
-[<TestCase(7, Ignore = "Remove to run test case")>]
-[<TestCase(14, Ignore = "Remove to run test case")>]
-[<TestCase(49, Ignore = "Remove to run test case")>]
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(7)>]
+[<InlineData(14)>]
+[<InlineData(49)>]
 let ``Numbers containing 7 as a prime factor give plong`` (number) =
-    Assert.That(convert number, Is.EqualTo("Plong"))
+    convert number |> should equal "Plong"
 
-[<TestCase(15, ExpectedResult = "PlingPlang", Ignore = "Remove to run test case")>]
-[<TestCase(21, ExpectedResult = "PlingPlong", Ignore = "Remove to run test case")>]
-[<TestCase(35, ExpectedResult = "PlangPlong", Ignore = "Remove to run test case")>]
-[<TestCase(105, ExpectedResult = "PlingPlangPlong", Ignore = "Remove to run test case")>]    
-let ``Numbers containing multiple prime factors give all results concatenated`` (number) =
-    convert number
+[<Theory(Skip = "Remove to run test")>]
+[<InlineData(15, "PlingPlang")>]
+[<InlineData(21, "PlingPlong")>]
+[<InlineData(35, "PlangPlong")>]
+[<InlineData(105, "PlingPlangPlong")>]    
+let ``Numbers containing multiple prime factors give all results concatenated`` number expected =
+    convert number |> should equal expected

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

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

data/tracks/fsharp/exercises/react/React.fs

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

data/tracks/fsharp/exercises/react/React.fsproj

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

@@ -1,31 +1,30 @@
-module ReactTest
+module ReactTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open React
 
-[<Test>]
+[<Fact>]
 let ``Setting the value of an input cell changes the observable value`` () =
   let reactor = new Reactor()
   let inputCell1 = reactor.createInputCell 1
 
-  Assert.That(inputCell1.Value, Is.EqualTo(1))
+  inputCell1.Value |> should equal 1
   inputCell1.Value <- 2
-  Assert.That(inputCell1.Value, Is.EqualTo(2))
+  inputCell1.Value |> should equal 2
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``The value of a compute is determined by the value of the dependencies`` () =
   let reactor = new Reactor()
   let inputCell1 = reactor.createInputCell 1    
   let computeCell1 = reactor.createComputeCell [inputCell1] (fun values -> values.[0] + 1)
 
-  Assert.That(computeCell1.Value, Is.EqualTo(2))  
+  computeCell1.Value |> should equal 2  
   inputCell1.Value <- 2
-  Assert.That(computeCell1.Value, Is.EqualTo(3))
+  computeCell1.Value |> should equal 3
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Compute cells can depend on other compute cells`` () =
   let reactor = new Reactor()
   let inputCell1 = reactor.createInputCell 1
@@ -33,12 +32,11 @@ let ``Compute cells can depend on other compute cells`` () =
   let computeCell2 = reactor.createComputeCell [inputCell1] (fun values -> values.[0] - 1)
   let computeCell3 = reactor.createComputeCell [computeCell1; computeCell2] (fun values -> values.[0] * values.[1])
   
-  Assert.That(computeCell3.Value, Is.EqualTo(0))  
+  computeCell3.Value |> should equal 0  
   inputCell1.Value <- 3
-  Assert.That(computeCell3.Value, Is.EqualTo(8))
+  computeCell3.Value |> should equal 8
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Compute cells can have callbacks`` () =
   let reactor = new Reactor()
   let inputCell1 = reactor.createInputCell 1
@@ -46,12 +44,11 @@ let ``Compute cells can have callbacks`` () =
   let mutable observed = []
   computeCell1.Changed.Add(fun value -> observed <- observed @ [value]) |> ignore
   
-  Assert.That(observed, Is.EqualTo([]))
+  observed |> should be Empty
   inputCell1.Value <- 2
-  Assert.That(observed, Is.EqualTo([3]))
+  observed |> should equal [3]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Callbacks only trigger on change`` () =
   let reactor = new Reactor()
   let inputCell1 = reactor.createInputCell 1
@@ -60,14 +57,13 @@ let ``Callbacks only trigger on change`` () =
   computecell1.Changed.Add(fun value -> observerCalled <- observerCalled + 1) |> ignore
 
   inputCell1.Value <- 1
-  Assert.That(observerCalled, Is.EqualTo(0))
+  observerCalled |> should equal 0
   inputCell1.Value <- 2
-  Assert.That(observerCalled, Is.EqualTo(0))
+  observerCalled |> should equal 0
   inputCell1.Value <- 3
-  Assert.That(observerCalled, Is.EqualTo(1))
+  observerCalled |> should equal 1
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Callbacks can be removed`` () =
   let reactor = new Reactor()
   let inputCell1 = reactor.createInputCell 1
@@ -80,16 +76,15 @@ let ``Callbacks can be removed`` () =
   computeCell1.Changed.Add(fun value -> observed2 <- observed2 @ [value]) |> ignore
     
   inputCell1.Value <- 2
-  Assert.That(observed1, Is.EqualTo([3]))  
-  Assert.That(observed2, Is.EqualTo([3]))
+  observed1 |> should equal [3]  
+  observed2 |> should equal [3]
 
   computeCell1.Changed.RemoveHandler changedHandler1
   inputCell1.Value <- 3
-  Assert.That(observed1, Is.EqualTo([3]))  
-  Assert.That(observed2, Is.EqualTo([3; 4]))
+  observed1 |> should equal [3]  
+  observed2 |> should equal [3; 4]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Callbacks should only be called once even if multiple dependencies have changed`` () =
   let reactor = new Reactor()
   let inputCell1 = reactor.createInputCell 1
@@ -100,4 +95,4 @@ let ``Callbacks should only be called once even if multiple dependencies have ch
   let mutable changed4 = 0
   computeCell4.Changed.Add(fun value -> changed4 <- changed4 + 1) |> ignore
   inputCell1.Value <- 3
-  Assert.That(changed4, Is.EqualTo(1))  
+  changed4 |> should equal 1  

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

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

data/tracks/fsharp/exercises/rectangles/Rectangles.fs

@@ -0,0 +1,3 @@
+module Rectangle
+
+let rectangles lines = failwith "You need to implement this function."

data/tracks/fsharp/exercises/rectangles/Rectangles.fsproj

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

@@ -1,39 +1,36 @@
-module RectanglesTest
+module RectanglesTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open System
 
 open Rectangle
 
-[<Test>]
+[<Fact>]
 let ``No rows`` () =
     let input = []
-    Assert.That(rectangles input, Is.EqualTo(0))
+    rectangles input |> should equal 0
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``No columns`` () =
     let input = [""]
-    Assert.That(rectangles input, Is.EqualTo(0))
+    rectangles input |> should equal 0
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``No rectangles`` () =
     let input = [" "]
-    Assert.That(rectangles input, Is.EqualTo(0))
+    rectangles input |> should equal 0
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One rectangle`` () =
     let input = 
         [ "+-+";
           "| |";
           "+-+" ]        
-    Assert.That(rectangles input, Is.EqualTo(1))
+    rectangles input |> should equal 1
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``two rectangles without shared parts`` () =
     let input = 
         [ "  +-+";
@@ -41,10 +38,9 @@ let ``two rectangles without shared parts`` () =
           "+-+-+";
           "| |  ";
           "+-+  " ]        
-    Assert.That(rectangles input, Is.EqualTo(2))
+    rectangles input |> should equal 2
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Five rectangles with shared parts`` () =
     let input = 
         [ "  +-+";
@@ -52,10 +48,9 @@ let ``Five rectangles with shared parts`` () =
           "+-+-+";
           "| | |";
           "+-+-+" ]        
-    Assert.That(rectangles input, Is.EqualTo(5))
+    rectangles input |> should equal 5
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Only complete rectangles are counted`` () =
     let input = 
         [ "  +-+";
@@ -63,10 +58,9 @@ let ``Only complete rectangles are counted`` () =
           "+-+-+";
           "| | -";
           "+-+-+" ]       
-    Assert.That(rectangles input, Is.EqualTo(1))
+    rectangles input |> should equal 1
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Rectangles can be of different sizes`` () =
     let input =
          ["+------+----+";
@@ -74,10 +68,9 @@ let ``Rectangles can be of different sizes`` () =
           "+---+--+    |";
           "|   |       |";
           "+---+-------+" ]       
-    Assert.That(rectangles input, Is.EqualTo(3))
+    rectangles input |> should equal 3
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Corner is required for a rectangle to be complete`` () =
     let input = 
         [ "+------+----+";
@@ -85,10 +78,9 @@ let ``Corner is required for a rectangle to be complete`` () =
           "+------+    |";
           "|   |       |";
           "+---+-------+" ]       
-    Assert.That(rectangles input, Is.EqualTo(2))
+    rectangles input |> should equal 2
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Large input with many rectangles`` () =
     let input = 
         [ "+---+--+----+";
@@ -99,4 +91,4 @@ let ``Large input with many rectangles`` () =
           "+---+--+--+-+";
           "+------+  | |";
           "          +-+" ]       
-    Assert.That(rectangles input, Is.EqualTo(60))
+    rectangles input |> should equal 60

data/tracks/fsharp/exercises/rna-transcription/Program.fs

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

data/tracks/fsharp/exercises/rna-transcription/RnaTranscription.fs

@@ -0,0 +1,3 @@
+module RNATranscription
+
+let toRna (dna: string): string = failwith "You need to implement this function."

data/tracks/fsharp/exercises/rna-transcription/RnaTranscription.fsproj

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

@@ -0,0 +1,26 @@
+module RNATranscriptionTest
+
+open Xunit
+open FsUnit.Xunit
+
+open RNATranscription
+    
+[<Fact>]
+let ``Rna complement of cytosine is guanine`` () =
+    toRna "C" |> should equal "G"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Rna complement of guanine is cytosine`` () =
+    toRna "G" |> should equal "C"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Rna complement of thymine is adenine`` () =
+    toRna "T" |> should equal "A"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Rna complement of adenine is uracil`` () =
+    toRna "A" |> should equal "U"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Rna complement`` () =
+    toRna "ACGTGGTCTTAA" |> should equal "UGCACCAGAAUU"

data/tracks/fsharp/exercises/robot-name/Program.fs

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

data/tracks/fsharp/exercises/robot-name/RobotName.fs

@@ -0,0 +1,7 @@
+module RobotName
+
+let mkRobot() = failwith "You need to implement this function."
+
+let name robot = failwith "You need to implement this function."
+
+let reset robot = failwith "You need to implement this function."

data/tracks/fsharp/exercises/robot-name/RobotName.fsproj

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

@@ -1,30 +1,29 @@
-module RobotNameTest
+module RobotNameTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
+open System.Text.RegularExpressions
 open RobotName
 
-[<Test>]
+[<Fact>]
 let ``Robot has a name`` () =     
     let robot = mkRobot()
-    StringAssert.IsMatch(@"\w{2}\d{3}", name robot)
+    Regex.IsMatch(name robot, @"\w{2}\d{3}") |> should equal true
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Name is the same each time`` () =     
     let robot = mkRobot()
-    Assert.That(name robot, Is.EqualTo(name robot))
+    name robot |> should equal (name robot)
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Different robots have different names`` () = 
     let robot = mkRobot()
     let robot2 = mkRobot()
-    Assert.That(name robot, Is.Not.EqualTo(name robot2))
+    name robot |> should not' (equal (name robot2))
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can reset the name`` () =  
     let robot = mkRobot()
     let originalName = name robot
     let resetRobot = reset robot
-    Assert.That(originalName, Is.Not.EqualTo(name resetRobot))
+    originalName |> should not' (equal (name resetRobot))

data/tracks/fsharp/exercises/robot-simulator/Program.fs

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

data/tracks/fsharp/exercises/robot-simulator/RobotSimulator.fs

@@ -0,0 +1,13 @@
+module RobotSimulator
+
+type Bearing = North | East | South | West
+
+let createRobot bearing coordinate = failwith "You need to implement this function."
+
+let turnLeft robot = failwith "You need to implement this function."
+
+let turnRight robot = failwith "You need to implement this function."
+
+let advance robot = failwith "You need to implement this function."
+
+let simulate robot instructions = failwith "You need to implement this function."

data/tracks/fsharp/exercises/robot-simulator/RobotSimulator.fsproj

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

@@ -1,48 +1,44 @@
-module RobotSimulatorTest
+module RobotSimulatorTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open RobotSimulator
 
-[<Test>]
+[<Fact>]
 let ``Turn right edge case`` () =
     let robot = createRobot Bearing.West (0, 0)
     let movedRobot = turnRight robot
-    Assert.That(movedRobot, Is.EqualTo(createRobot Bearing.North (0, 0)))
+    movedRobot |> should equal <| createRobot Bearing.North (0, 0)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Turn left edge case`` () =
     let robot = createRobot Bearing.North (0, 0)
     let movedRobot = turnLeft robot
-    Assert.That(movedRobot, Is.EqualTo(createRobot Bearing.West (0, 0)))
+    movedRobot |> should equal <| createRobot Bearing.West (0, 0)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Robbie`` () =
     let robbie = createRobot Bearing.East (-2, 1)
-    Assert.That(robbie, Is.EqualTo(createRobot Bearing.East (-2, 1)))
+    robbie |> should equal <| createRobot Bearing.East (-2, 1)
 
     let movedRobbie = simulate robbie "RLAALAL"
-    Assert.That(movedRobbie, Is.EqualTo(createRobot Bearing.West (0, 2)))
+    movedRobbie |> should equal <| createRobot Bearing.West (0, 2)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Clutz`` () =
     let clutz = createRobot Bearing.North (0, 0)
     let movedClutz = simulate clutz "LAAARALA"
-    Assert.That(movedClutz, Is.EqualTo(createRobot Bearing.West (-4, 1)))
+    movedClutz |> should equal <| createRobot Bearing.West (-4, 1)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Sphero`` () =
     let sphero = createRobot Bearing.East (2, -7)
     let movedSphero = simulate sphero "RRAAAAALA"
-    Assert.That(movedSphero, Is.EqualTo(createRobot Bearing.South (-3, -8)))
+    movedSphero |> should equal <| createRobot Bearing.South (-3, -8)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Roomba`` () =
     let roomba = createRobot Bearing.South (8, 4)
     let movedRoomba = simulate roomba "LAAARRRALLLL"
-    Assert.That(movedRoomba, Is.EqualTo(createRobot Bearing.North (11, 5)))
+    movedRoomba |> should equal <| createRobot Bearing.North (11, 5)

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

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

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

@@ -0,0 +1,3 @@
+module RomanNumeral
+
+let toRoman arabicNumeral = failwith "You need to implement this function."

data/tracks/fsharp/exercises/roman-numerals/RomanNumerals.fsproj

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