trackler 2.2.1.22 → 2.2.1.23

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

@@ -1,30 +1,29 @@
-module FoodChainTest
+module FoodChainTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open FoodChain
 
 let combine = List.reduce (fun x y -> x + "\n" + y)
 
-[<Test>]
+[<Fact>]
 let ``Verse one`` () =
     let expected = ["I know an old lady who swallowed a fly.";
                     "I don't know why she swallowed the fly. Perhaps she'll die."] |> combine
 
-    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 ``Verse two`` () =
     let expected = ["I know an old lady who swallowed a spider.";
                     "It wriggled and jiggled and tickled inside her.";
                     "She swallowed the spider to catch the fly.";
                     "I don't know why she swallowed the fly. Perhaps she'll die."] |> combine
 
-    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 ``Verse four`` () =
     let expected = ["I know an old lady who swallowed a cat.";
                     "Imagine that, to swallow a cat!";
@@ -33,18 +32,16 @@ let ``Verse four`` () =
                     "She swallowed the spider to catch the fly.";
                     "I don't know why she swallowed the fly. Perhaps she'll die."] |> combine
 
-    Assert.That(verse 4, Is.EqualTo(expected))
+    verse 4 |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Verse eight`` () =
     let expected = ["I know an old lady who swallowed a horse.";
                     "She's dead, of course!"] |> combine
 
-    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 ``Complete song`` () =
     let expected = ["I know an old lady who swallowed a fly.";
                     "I don't know why she swallowed the fly. Perhaps she'll die.";
@@ -97,4 +94,4 @@ let ``Complete song`` () =
                     "I know an old lady who swallowed a horse.";
                     "She's dead, of course!"] |> combine
 
-    Assert.That(song, Is.EqualTo(expected))
+    song |> should equal expected

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

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

data/tracks/fsharp/exercises/forth/Forth.fs

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

data/tracks/fsharp/exercises/forth/Forth.fsproj

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

@@ -1,6 +1,7 @@
-module ForthTest
+module ForthTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Forth
 
@@ -21,63 +22,54 @@ let run text = eval text empty |> map formatStack
 // contained in a Choice1Of2. If an error occured, that error is contained
 // in a Choice2Of2.
 
-[<Test>]
+[<Fact>]
 let ``No input, no stack`` () =
-    Assert.That(formatStack empty, Is.EqualTo(""))
+    formatStack empty |> should equal ""
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Numbers just get pushed onto the stack`` () =
-    Assert.That(run "1 2 3 4 5", Is.EqualTo(Choice1Of2 "1 2 3 4 5": Choice<string,ForthError>))
+    run "1 2 3 4 5" |> should equal (Choice1Of2 "1 2 3 4 5": Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Non-word characters are separators`` () =
-    Assert.That(run "1\b2\t3\n4\r5 6\t7", Is.EqualTo(Choice1Of2 "1 2 3 4 5 6 7": Choice<string,ForthError>))
+    run "1\b2\t3\n4\r5 6\t7" |> should equal (Choice1Of2 "1 2 3 4 5 6 7": Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Basic arithmetic`` () =
-    Assert.That(run "1 2 + 4 -", Is.EqualTo(Choice1Of2 "-1": Choice<string,ForthError>))
-    Assert.That(run "2 4 * 3 /", Is.EqualTo(Choice1Of2 "2": Choice<string,ForthError>))
+    run "1 2 + 4 -" |> should equal (Choice1Of2 "-1": Choice<string,ForthError>)
+    run "2 4 * 3 /" |> should equal (Choice1Of2 "2": Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Division by zero`` () =
-    Assert.That(run "4 2 2 - /", Is.EqualTo(Choice2Of2 DivisionByZero: Choice<string,ForthError>))
+    run "4 2 2 - /" |> should equal (Choice2Of2 DivisionByZero: Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``dup`` () =
-    Assert.That(run "1 DUP", Is.EqualTo(Choice1Of2 "1 1": Choice<string,ForthError>))
-    Assert.That(run "1 2 Dup", Is.EqualTo(Choice1Of2 "1 2 2": Choice<string,ForthError>))
-    Assert.That(run "dup", Is.EqualTo(Choice2Of2 StackUnderflow: Choice<string,ForthError>))
+    run "1 DUP" |> should equal (Choice1Of2 "1 1": Choice<string,ForthError>)
+    run "1 2 Dup" |> should equal (Choice1Of2 "1 2 2": Choice<string,ForthError>)
+    run "dup" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``drop`` () =
-    Assert.That(run "1 drop", Is.EqualTo(Choice1Of2 "": Choice<string,ForthError>))
-    Assert.That(run "1 2 drop", Is.EqualTo(Choice1Of2 "1": Choice<string,ForthError>))
-    Assert.That(run "drop", Is.EqualTo(Choice2Of2 StackUnderflow: Choice<string,ForthError>))
+    run "1 drop" |> should equal (Choice1Of2 "": Choice<string,ForthError>)
+    run "1 2 drop" |> should equal (Choice1Of2 "1": Choice<string,ForthError>)
+    run "drop" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``swap`` () =
-    Assert.That(run "1 2 swap", Is.EqualTo(Choice1Of2 "2 1": Choice<string,ForthError>))
-    Assert.That(run "1 2 3 swap", Is.EqualTo(Choice1Of2 "1 3 2": Choice<string,ForthError>))
-    Assert.That(run "1 swap", Is.EqualTo(Choice2Of2 StackUnderflow: Choice<string,ForthError>))
-    Assert.That(run "swap", Is.EqualTo(Choice2Of2 StackUnderflow: Choice<string,ForthError>))
+    run "1 2 swap" |> should equal (Choice1Of2 "2 1": Choice<string,ForthError>)
+    run "1 2 3 swap" |> should equal (Choice1Of2 "1 3 2": Choice<string,ForthError>)
+    run "1 swap" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
+    run "swap" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``over`` () =
-    Assert.That(run "1 2 over", Is.EqualTo(Choice1Of2 "1 2 1": Choice<string,ForthError>))
-    Assert.That(run "1 2 3 over", Is.EqualTo(Choice1Of2 "1 2 3 2": Choice<string,ForthError>))
-    Assert.That(run "1 over", Is.EqualTo(Choice2Of2 StackUnderflow: Choice<string,ForthError>))
-    Assert.That(run "over", Is.EqualTo(Choice2Of2 StackUnderflow: Choice<string,ForthError>))
+    run "1 2 over" |> should equal (Choice1Of2 "1 2 1": Choice<string,ForthError>)
+    run "1 2 3 over" |> should equal (Choice1Of2 "1 2 3 2": Choice<string,ForthError>)
+    run "1 over" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
+    run "over" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Defining a new word`` () =
     let actual =
         empty
@@ -85,10 +77,9 @@ let ``Defining a new word`` () =
         |> bind (eval "1 dup-twice")
         |> map formatStack
 
-    Assert.That(actual, Is.EqualTo(Choice1Of2 "1 1 1": Choice<string,ForthError>))
+    actual |> should equal (Choice1Of2 "1 1 1": Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Redefining an existing word`` () =    
     let actual =
         empty
@@ -97,10 +88,9 @@ let ``Redefining an existing word`` () =
         |> bind (eval "1 foo")
         |> map formatStack
         
-    Assert.That(actual, Is.EqualTo(Choice1Of2 "1 1 1": Choice<string,ForthError>))
+    actual |> should equal (Choice1Of2 "1 1 1": Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Redefining an existing built-in word`` () =  
     let actual =
         empty
@@ -108,19 +98,16 @@ let ``Redefining an existing built-in word`` () =
         |> bind (eval "1 swap")
         |> map formatStack
 
-    Assert.That(actual, Is.EqualTo(Choice1Of2 "1 1": Choice<string,ForthError>))
+    actual |> should equal (Choice1Of2 "1 1": Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Defining words with odd characters`` () =
-    Assert.That(run ": € 220371 ; €", Is.EqualTo(Choice1Of2 "220371": Choice<string,ForthError>))
+    run ": € 220371 ; €" |> should equal (Choice1Of2 "220371": Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Defining a number`` () =
-    Assert.That(run ": 1 2 ;", Is.EqualTo(Choice2Of2 InvalidWord: Choice<string,ForthError>))
+    run ": 1 2 ;" |> should equal (Choice2Of2 InvalidWord: Choice<string,ForthError>)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Calling a non-existing word`` () =
-    Assert.That(run "1 foo", Is.EqualTo(Choice2Of2 (UnknownWord "foo"): Choice<string,ForthError>))
+    run "1 foo" |> should equal (Choice2Of2 (UnknownWord "foo"): Choice<string,ForthError>)

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

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

data/tracks/fsharp/exercises/gigasecond/Gigasecond.fs

@@ -0,0 +1,3 @@
+module Gigasecond
+
+let gigasecond beginDate = failwith "You need to implement this function."

data/tracks/fsharp/exercises/gigasecond/Gigasecond.fsproj

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

@@ -1,22 +1,21 @@
-module GigasecondTest
+module GigasecondTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Gigasecond
 open System
     
-[<Test>]
+[<Fact>]
 let ``First date`` () =
     let input = DateTime(2011, 4, 25)
-    Assert.That(gigasecond input, Is.EqualTo(DateTime(2043, 1, 1)))
+    gigasecond input |> should equal (DateTime(2043, 1, 1))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Another date`` () =
     let input = DateTime(1977, 6, 13)
-    Assert.That(gigasecond input, Is.EqualTo(DateTime(2009, 2, 19)))
+    gigasecond input |> should equal (DateTime(2009, 2, 19))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Yet another date`` () =
     let input = DateTime(1959, 7, 19)
-    Assert.That(gigasecond input, Is.EqualTo(DateTime(1991, 3, 27)))
+    gigasecond input |> should equal (DateTime(1991, 3, 27))

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

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

data/tracks/fsharp/exercises/go-counting/GoCounting.fs

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

data/tracks/fsharp/exercises/go-counting/GoCounting.fsproj

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

@@ -1,8 +1,9 @@
-module GoCountingTest
+module GoCountingTest
 
 open System
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open GoCounting
 
@@ -24,60 +25,52 @@ let board9x9 =
      " W BBB W ";
      "   B B   "]
 
-[<Test>]
+[<Fact>]
 let ``5x5 territory for black`` () =
     let expected = Some (Some Black, [(0, 0); (0, 1); (1, 0)])
-    Assert.That(territoryFor board5x5 (0, 1), Is.EqualTo(expected))
+    territoryFor board5x5 (0, 1) |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``5x5 territory for white`` () =
     let expected = Some (Some White, [(2, 3)])
-    Assert.That(territoryFor board5x5 (2, 3), Is.EqualTo(expected))
+    territoryFor board5x5 (2, 3) |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``5x5 open territory`` () =
-    let expected = Some (None, [(0, 3); (0, 4); (1, 4)])
-    Assert.That(territoryFor board5x5 (1, 4) = expected)
+    let expected = Some ((None: Color option), [(0, 3); (0, 4); (1, 4)])
+    territoryFor board5x5 (1, 4) |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``5x5 non-territory (stone)`` () =
-    Assert.That(territoryFor board5x5 (1, 1), Is.EqualTo(None))
+    territoryFor board5x5 (1, 1) |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``5x5 non-territory (too low coordinate)`` () =
-    Assert.That(territoryFor board5x5 (-1, 1), Is.EqualTo(None))
+    territoryFor board5x5 (-1, 1) |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``5x5 non-territory (too high coordinate)`` () =
-    Assert.That(territoryFor board5x5 (1, 5), Is.EqualTo(None))
+    territoryFor board5x5 (1, 5) |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Minimal board, no territories`` () =
     let input = ["B"]
     let expected = []
 
-    Assert.That(territories input, Is.EqualTo(expected))
+    territories input |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One territory, covering the whole board`` () =
     let input = [" "]
-    let expected = [(None, [(0, 0)])] |> Map.ofList
+    let expected = [((None: Color option), [(0, 0)])] |> Map.ofList
 
-    Assert.That(territories input, Is.EqualTo(expected))
+    territories input |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two territories, rectangular board`` () =
     let input = [" BW "; " BW "]
     let expected = [(Some Black, [(0, 0); (0, 1)]);
                     (Some White, [(3, 0); (3, 1)])]
                    |> Map.ofList
 
-    Assert.That(territories input, Is.EqualTo(expected))
+    territories input |> should equal expected

data/tracks/fsharp/exercises/go-counting/Program.fs

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

data/tracks/fsharp/exercises/grade-school/Example.fs

@@ -7,7 +7,7 @@ let add student grade school =
     | Some existing -> Map.add grade (student :: existing |> List.sort) school
     | None -> Map.add grade [student] school
 
-let roster school = school |> Map.toSeq
+let roster school = Map.toList school
 
 let grade number school = 
     match Map.tryFind number school with

data/tracks/fsharp/exercises/grade-school/GradeSchool.fs

@@ -0,0 +1,9 @@
+module GradeSchool
+
+let empty: Map<int, string list> = failwith "You need to implement this function."
+
+let add (student: string) (grade: int) (school: Map<int, string list>): Map<int, string list> = failwith "You need to implement this function."
+
+let roster (school: Map<int, string list>): Map<int, string list> = failwith "You need to implement this function."
+
+let grade (number: int) (school: Map<int, string list>): string list = failwith "You need to implement this function."

data/tracks/fsharp/exercises/grade-school/GradeSchool.fsproj

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

@@ -1,22 +1,21 @@
 module GradeSchoolTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open GradeSchool
 
-[<Test>]
+[<Fact>]
 let ``Empty school has an empty roster`` () =
     let school = empty
-    Assert.That(roster school, Is.Empty)
+    roster school |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Adding a student adds them to the roster for the given grade`` () =
     let school = empty |> add "Aimee" 2
     let expected = ["Aimee"]
-    Assert.That(grade 2 school, Is.EqualTo(expected))
+    grade 2 school |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Adding more students to the same grade adds them to the roster`` () =
     let school = 
         empty
@@ -24,20 +23,18 @@ let ``Adding more students to the same grade adds them to the roster`` () =
         |> add "James" 2
         |> add "Paul" 2
     let expected = ["Blair"; "James"; "Paul"]
-    Assert.That(grade 2 school, Is.EqualTo(expected))
+    grade 2 school |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Adding students to different grades adds them to the roster`` () =
     let school = 
         empty
         |> add "Chelsea" 3
         |> add "Logan" 7
-    Assert.That(grade 3 school, Is.EqualTo(["Chelsea"]))
-    Assert.That(grade 7 school, Is.EqualTo(["Logan"]))
+    grade 3 school |> should equal ["Chelsea"]
+    grade 7 school |> should equal ["Logan"]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Grade returns the students in that grade in alphabetical order`` () =
     let school = 
         empty
@@ -45,16 +42,14 @@ let ``Grade returns the students in that grade in alphabetical order`` () =
         |> add "Bradley" 5
         |> add "Jeff" 1
     let expected = ["Bradley"; "Franklin"]
-    Assert.That(grade 5 school, Is.EqualTo(expected))
+    grade 5 school |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Grade returns an empty list if there are no students in that grade`` () =
     let school = empty
-    Assert.That(grade 1 school, Is.EqualTo([]))
+    grade 1 school |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Student names and grades in roster are sorted`` () =
     let school =
         empty        
@@ -68,4 +63,4 @@ let ``Student names and grades in roster are sorted`` () =
          (4, ["Christopher"; "Jennifer"]);
          (6, ["Kareem"])]
 
-    Assert.That(roster school, Is.EqualTo(expected))
+    roster school |> should equal expected

data/tracks/fsharp/exercises/grade-school/Program.fs

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

data/tracks/fsharp/exercises/grains/Grains.fs

@@ -0,0 +1,6 @@
+module Grains
+
+open System.Numerics
+
+let square (n: int): BigInteger = failwith "You need to implement this function."
+let total: BigInteger = failwith "You need to implement this function."

data/tracks/fsharp/exercises/grains/Grains.fsproj

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