trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/custom-set/CustomSet.fs

@@ -0,0 +1,29 @@
+module CustomSet
+
+// TODO: define the Set type
+
+let empty = failwith "You need to implement this function."
+
+let singleton value = { items = [value] }
+
+let isEmpty set = set.items.IsEmpty
+
+let size set = set.items.Length 
+
+let fromList list = { items = list |> List.sort |> List.distinct } 
+
+let toList set = set.items
+
+let contains value set = List.contains value set.items
+
+let insert value set = value::set.items |> fromList
+
+let union left right = left.items @ right.items |> fromList
+
+let intersection left right = left.items |> List.filter (fun x -> List.contains x right.items) |> fromList
+
+let difference left right = left.items |> List.filter (fun x -> List.contains x right.items |> not) |> fromList
+
+let isSubsetOf left right = left.items |> List.forall (fun x -> List.contains x right.items)
+
+let isDisjointFrom left right = left.items |> List.exists (fun x -> List.contains x right.items) |> not

data/tracks/fsharp/exercises/custom-set/CustomSet.fsproj

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

@@ -1,271 +1,229 @@
-module CustomSetTest
+module CustomSetTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open CustomSet
 
-[<Test>]
+[<Fact>]
 let ``Sets with no elements are empty`` () =
     let actual = empty
-    Assert.That(isEmpty actual, Is.True)
+    isEmpty actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Sets with elements are not empty`` () =
     let actual = singleton 1
-    Assert.That(isEmpty actual, Is.False)
+    isEmpty actual |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Nothing is contained in an empty set`` () =
     let actual = empty
-    Assert.That(contains 1 actual, Is.False)
+    contains 1 actual |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Detect if the element is in the set`` () =
     let actual = fromList [1; 2; 3]
-    Assert.That(contains 1 actual, Is.True)
+    contains 1 actual |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Detect if the element is not in the set`` () =
     let actual = fromList [1; 2; 3]
-    Assert.That(contains 4 actual, Is.False)
+    contains 4 actual |> should equal false
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Empty set is a subset of another empty set`` () =
     let left = empty
     let right = empty
-    Assert.That(isSubsetOf left right, Is.True)
+    isSubsetOf left right |> should equal true
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Empty set is a subset of non-empty set`` () =
     let left = empty
     let right = singleton 1
-    Assert.That(isSubsetOf left right, Is.True)
+    isSubsetOf left right |> should equal true
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Non-empty set is not a subset of empty set`` () =
     let left = singleton 1
     let right = empty
-    Assert.That(isSubsetOf left right, Is.False)
+    isSubsetOf left right |> should equal false
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Set is a subset of set with exact same elements`` () =
     let left = fromList [1; 2; 3]
     let right = fromList [1; 2; 3]
-    Assert.That(isSubsetOf left right, Is.True)
+    isSubsetOf left right |> should equal true
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Set is a subset of larger set with same elements`` () =
     let left = fromList [1; 2; 3]
     let right = fromList [4; 1; 2; 3]
-    Assert.That(isSubsetOf left right, Is.True)
+    isSubsetOf left right |> should equal true
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Set is not a subset of set that does not contain its elements`` () =
     let left = fromList [1; 2; 3]
     let right = fromList [4; 1; 3]
-    Assert.That(isSubsetOf left right, Is.False)
+    isSubsetOf left right |> should equal false
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``The empty set is disjoint with itself`` () =
     let left = empty
     let right = empty
-    Assert.That(isDisjointFrom left right, Is.True)    
+    isDisjointFrom left right |> should equal true    
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Empty set is disjoint with non-empty set`` () =
     let left = empty
     let right = singleton 1
-    Assert.That(isDisjointFrom left right, Is.True)
+    isDisjointFrom left right |> should equal true
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Non-empty set is disjoint with empty set`` () =
     let left = singleton 1
     let right = empty
-    Assert.That(isDisjointFrom left right, Is.True)
+    isDisjointFrom left right |> should equal true
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Sets are not disjoint if they share an element`` () =
     let left = fromList [1; 2]
     let right = fromList [2; 3]    
-    Assert.That(isDisjointFrom left right, Is.False)
+    isDisjointFrom left right |> should equal false
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Sets are disjoint if they share no elements`` () =
     let left = fromList [1; 2]
     let right = fromList [3; 4]
-    Assert.That(isDisjointFrom left right, Is.True)
+    isDisjointFrom left right |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Empty sets are equal`` () =
     let left = empty
     let right = empty
-    Assert.That((left = right))
+    (left |> should equal right)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Empty set is not equal to non-empty set`` () =
     let left = empty
     let right = fromList [1; 2; 3]
-    Assert.That(left <> right)
+    left |> should not' (equal right)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Non-empty set is not equal to empty set`` () =
     let left = fromList [1; 2; 3]
     let right = empty
-    Assert.That(left <> right)
+    left |> should not' (equal right)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Sets with the same elements are equal`` () =
     let left = fromList [1; 2]
     let right = fromList [2; 1]
-    Assert.That((left = right))
+    (left |> should equal right)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Sets with different elements are not equal`` () =
     let left = fromList [1; 2; 3]
     let right = fromList [1; 2; 4]
-    Assert.That(left <> right)
+    left |> should not' (equal right)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Add to empty set`` () =
     let actual = empty |> insert 3
     let expected = fromList [3]
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Add to non-empty set`` () =
     let actual = fromList [1; 2; 4] |> insert 3
     let expected = fromList [1; 2; 3; 4]
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Adding an existing element does not change the set`` () =
     let actual = fromList [1; 2; 3] |> insert 3
     let expected = fromList [1; 2; 3]
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
             
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Intersection of two empty sets is an empty set`` () =
     let left = empty
     let right = empty
-    let expected = empty
-    Assert.That(intersection left right = expected)
+    intersection left right |> isEmpty |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Intersection of an empty set and non-empty set is an empty set`` () =
     let left = empty
     let right = fromList [3; 2; 5]
-    let expected = empty
-    Assert.That(intersection left right = expected)
+    intersection left right |> isEmpty |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Intersection of a non-empty set and an empty set is an empty set`` () =
     let left = fromList [1; 2; 3; 4]
     let right = empty
-    let expected = empty
-    Assert.That(intersection left right = expected)
+    intersection left right |> isEmpty |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Intersection of two sets with no shared elements is an empty set`` () =
     let left = fromList [1; 2; 3]
     let right = fromList [4; 5; 6]
-    let expected = empty
-    Assert.That(intersection left right = expected)
+    intersection left right |> isEmpty |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Intersection of two sets with shared elements is a set of the shared elements`` () =
     let left = fromList [1; 2; 3; 4]
     let right = fromList [3; 2; 5]
     let expected = fromList [2; 3]
-    Assert.That(intersection left right = expected)
+    intersection left right |> should equal expected
             
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Difference of two empty sets is an empty set`` () =
     let left = empty
     let right = empty
-    let expected = empty
-    Assert.That(difference left right = expected)
+    difference left right |> isEmpty |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Difference of an empty set and non-empty set is an empty set`` () =
     let left = empty
     let right = fromList [3; 2; 5]
-    let expected = empty
-    Assert.That(difference left right = expected)
+    difference left right |> isEmpty |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Difference of a non-empty set and an empty set is an empty set`` () =
     let left = fromList [1; 2; 3; 4]
     let right = empty
     let expected = fromList [1; 2; 3; 4]
-    Assert.That(difference left right = expected)
+    difference left right |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Difference of two non-empty sets is a set of elements that are only in the first set`` () =
     let left = fromList [3; 2; 1]
     let right = fromList [2; 4]
     let expected = fromList [1; 3]
-    Assert.That(difference left right = expected)
+    difference left right |> should equal expected
            
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Union of two empty sets is an empty set`` () =
     let left = empty
     let right = empty
-    let expected = empty
-    Assert.That(union left right = expected)
+    union left right |> isEmpty |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Union of an empty set and non-empty set is the non-empty set`` () =
     let left = empty
     let right = fromList [2]
     let expected = fromList [2]
-    Assert.That(union left right = expected)
+    union left right |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Union of a non-empty set and empty set is the non-empty set`` () =
     let left = fromList [1; 3]
     let right = empty
     let expected = fromList [1; 3]
-    Assert.That(union left right = expected)
+    union left right |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Union of non-empty sets contains all unique elements`` () =
     let left = fromList [1; 3]
     let right = fromList [2; 3]
     let expected = fromList [3; 2; 1]
-    Assert.That(union left right = expected)
+    union left right |> should equal expected

data/tracks/fsharp/exercises/custom-set/Program.fs

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

data/tracks/fsharp/exercises/diamond/Diamond.fs

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

data/tracks/fsharp/exercises/diamond/Diamond.fsproj

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

@@ -1,8 +1,9 @@
-module DiamondTest
+module DiamondTest
 
 open Diamond
 open System
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 type DiamondTest() =
     let split (x: string) = x.Split([| '\n' |], StringSplitOptions.None)
@@ -12,26 +13,27 @@ type DiamondTest() =
     let leadingSpaces (x:string) = x.Substring(0, x.IndexOfAny [|'A'..'Z'|])
 
     let trailingSpaces (x:string) = x.Substring(x.LastIndexOfAny [|'A'..'Z'|] + 1)
-
-    [<TestCaseSource("Letters")>]
+    
+    [<Theory>]
+    [<MemberData("Letters")>]
     member this.``First row contains 'A'`` (letter:char) =
         let actual = make letter
         let rows = actual |> split
         let firstRowCharacters = rows |> Seq.head |> trim
     
-        Assert.That(firstRowCharacters, Is.EqualTo("A"))
+        firstRowCharacters |> should equal "A"
 
-    [<TestCaseSource("Letters")>]
-    [<Ignore("Remove to run test")>]
+    [<Theory(Skip = "Remove to run test")>]
+    [<MemberData("Letters")>]
     member this.``All rows must have symmetric contour`` (letter:char) =
         let actual = make letter
         let rows = actual |> split
         let symmetric (row:string) = leadingSpaces row = trailingSpaces row
-    
-        Assert.That(rows, Is.All.Matches(symmetric))
 
-    [<TestCaseSource("Letters")>]
-    [<Ignore("Remove to run test")>]
+        rows |> Array.iter (fun x -> symmetric x |> should equal true)
+
+    [<Theory(Skip = "Remove to run test")>]
+    [<MemberData("Letters")>]
     member this.``Top of figure has letters in correct order`` (letter:char) =
         let actual = make letter
 
@@ -40,14 +42,13 @@ type DiamondTest() =
         let firstNonSpaceLetters =
             rows 
             |> Seq.take expected.Length
-            |> Seq.map trim
-            |> Seq.map Seq.head
+            |> Seq.map (trim >> Seq.head)
             |> Seq.toList
 
-        Assert.That(expected, Is.EqualTo(firstNonSpaceLetters))
+        expected |> should equal firstNonSpaceLetters
 
-    [<TestCaseSource("Letters")>]
-    [<Ignore("Remove to run test")>]
+    [<Theory(Skip = "Remove to run test")>]
+    [<MemberData("Letters")>]
     member this.``Figure is symmetric around the horizontal axis`` (letter:char) =
         let actual = make letter
 
@@ -63,10 +64,10 @@ type DiamondTest() =
             |> Seq.takeWhile (fun x -> not (x.Contains(string letter)))
             |> List.ofSeq
 
-        Assert.That(top, Is.EqualTo(bottom))
+        top |> should equal bottom
     
-    [<TestCaseSource("Letters")>]
-    [<Ignore("Remove to run test")>]
+    [<Theory(Skip = "Remove to run test")>]
+    [<MemberData("Letters")>]
     member this.``Diamond has square shape`` (letter:char) =
         let actual = make letter
 
@@ -74,10 +75,10 @@ type DiamondTest() =
         let expected = rows.Length
         let correctWidth (x:string) = x.Length = expected
 
-        Assert.That(rows, Is.All.Matches(correctWidth))
+        rows |> Array.iter (fun x -> correctWidth x |> should equal true)
 
-    [<TestCaseSource("Letters")>]
-    [<Ignore("Remove to run test")>]
+    [<Theory(Skip = "Remove to run test")>]
+    [<MemberData("Letters")>]
     member this.``All rows except top and bottom have two identical letters`` (letter:char) =
         let actual = make letter
 
@@ -91,10 +92,10 @@ type DiamondTest() =
             let identicalCharacters = row.Replace(" ", "") |> Seq.distinct |> Seq.length = 1
             twoCharacters && identicalCharacters
 
-        Assert.That(rows, Is.All.Matches(twoIdenticalLetters))
+        rows |> Array.iter (fun x -> twoIdenticalLetters x |> should equal true)
 
-    [<TestCaseSource("Letters")>]    
-    [<Ignore("Remove to run test")>]
+    [<Theory(Skip = "Remove to run test")>]
+    [<MemberData("Letters")>]
     member this.``Bottom left corner spaces are triangle`` (letter:char) =
         let actual = make letter
 
@@ -116,6 +117,9 @@ type DiamondTest() =
             |> Seq.take spaceCounts.Length
             |> Seq.toList
 
-        Assert.That(spaceCounts, Is.EqualTo(expected))
+        spaceCounts |> should equal expected
 
-    static member Letters = [| 'A' .. 'Z' |]
+    static member Letters = 
+        let theoryData = new TheoryData<char>()
+        [ 'A' .. 'Z' ] |> List.iter (fun c -> theoryData.Add(c))
+        theoryData

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

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

data/tracks/fsharp/exercises/difference-of-squares/DifferenceOfSquares.fs

@@ -0,0 +1,7 @@
+module DifferenceOfSquares
+
+let squareOfSums (number: int): int = failwith "You need to implement this function."
+
+let sumOfSquares (number: int): int = failwith "You need to implement this function."
+
+let difference (number: int): int = failwith "You need to implement this function."

data/tracks/fsharp/exercises/difference-of-squares/DifferenceOfSquares.fsproj

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

@@ -1,48 +1,41 @@
-module DifferenceOfSquaresTest
+module DifferenceOfSquaresTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open DifferenceOfSquares
     
-[<Test>]
+[<Fact>]
 let ``Square of sums to 5`` () =
-    Assert.That(squareOfSums 5, Is.EqualTo(225))
+    squareOfSums 5 |> should equal 225
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Sum of squares to 5`` () =
-    Assert.That(sumOfSquares 5, Is.EqualTo(55))
+    sumOfSquares 5 |> should equal 55
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Difference of sums to 5`` () =
-    Assert.That(difference 5, Is.EqualTo(170))
+    difference 5 |> should equal 170
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Square of sums to 10`` () =
-    Assert.That(squareOfSums 10, Is.EqualTo(3025))
+    squareOfSums 10 |> should equal 3025
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Sum of squares to 10`` () =
-    Assert.That(sumOfSquares 10, Is.EqualTo(385))
+    sumOfSquares 10 |> should equal 385
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Difference of sums to 10`` () =
-    Assert.That(difference 10, Is.EqualTo(2640))
+    difference 10 |> should equal 2640
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Square of sums to 100`` () =
-    Assert.That(squareOfSums 100, Is.EqualTo(25502500))
+    squareOfSums 100 |> should equal 25502500
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Sum of squares to 100`` () =
-    Assert.That(sumOfSquares 100, Is.EqualTo(338350))
+    sumOfSquares 100 |> should equal 338350
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Difference of sums to 100`` () =
-    Assert.That(difference 100, Is.EqualTo(25164150))
+    difference 100 |> should equal 25164150

data/tracks/fsharp/exercises/difference-of-squares/Program.fs

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