trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/list-ops/ListOpsTest.fs

@@ -1,6 +1,7 @@
-module ListOpsTest
+module ListOpsTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open ListOps
 
@@ -8,121 +9,98 @@ let big = 100000
 let bigList = [1 .. big]
 let odd x = x % 2 = 1
 
-[<Test>]
+[<Fact>]
 let ``length of empty list`` () =
-    Assert.That(length [], Is.EqualTo(0))
+    length [] |> should equal 0
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``length of non-empty list`` () =
-    Assert.That(length [1 .. 4], Is.EqualTo(4))
+    length [1 .. 4] |> should equal 4
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``length of large list`` () =
-    Assert.That(length [1 .. big], Is.EqualTo(big))
+    length [1 .. big] |> should equal big
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``reverse of empty list`` () =
-    Assert.That(reverse [], Is.EqualTo([]))
+    reverse [] |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``reverse of non-empty list`` () =
-    Assert.That(reverse [1 .. 100], Is.EqualTo([100 .. -1 .. 1]))
+    reverse [1 .. 100] |> should equal [100 .. -1 .. 1]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``map of empty list`` () =
-    Assert.That(map ((+) 1) [], Is.EqualTo([]))
+    map ((+) 1) [] |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``map of non-empty list`` () =
-    Assert.That(map ((+) 1) [1 .. 2 .. 7], Is.EqualTo([2 .. 2 .. 8]))
+    map ((+) 1) [1 .. 2 .. 7] |> should equal [2 .. 2 .. 8]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``filter of empty list`` () =
-    Assert.That(filter id [], Is.EqualTo([]))
+    filter id [] |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``filter of normal list`` () =
-    Assert.That(filter odd [1 .. 4], Is.EqualTo([1; 3]))
+    filter odd [1 .. 4] |> should equal [1; 3]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``foldl of empty list`` () =
-    Assert.That(foldl (+) 0 [], Is.EqualTo(0))
+    foldl (+) 0 [] |> should equal 0
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``foldl of non-empty list`` () =
-    Assert.That(foldl (+) -3 [1 .. 4], Is.EqualTo(7))
+    foldl (+) -3 [1 .. 4] |> should equal 7
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``foldl of huge list`` () =
-    Assert.That(foldl (+) 0 [1 .. big], Is.EqualTo(big * (big + 1) / 2))
+    foldl (+) 0 [1 .. big] |> should equal (big * (big + 1) / 2)
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``foldl with non-commutative function`` () =
-    Assert.That(foldl (-) 10 [1 .. 4], Is.EqualTo(0))
+    foldl (-) 10 [1 .. 4] |> should equal 0
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``foldl is not just foldr . flip`` () =
-    Assert.That(foldl (fun acc item -> item :: acc) [] (List.ofSeq "asdf"), Is.EqualTo(List.ofSeq "fdsa"))
+    foldl (fun acc item -> item :: acc) [] (List.ofSeq "asdf") |> should equal (List.ofSeq "fdsa")
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``foldr as id`` () =
-    Assert.That(foldr (fun item acc -> item :: acc) [1 .. big] [] = bigList, Is.True)
+    foldr (fun item acc -> item :: acc) [1 .. big] [] = bigList |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``foldr as append`` () =
-    Assert.That(foldr (fun item acc -> item :: acc) [1 .. 99] [100 .. big] = bigList, Is.True)
+    foldr (fun item acc -> item :: acc) [1 .. 99] [100 .. big] = bigList |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``append of empty lists`` () =
-    Assert.That(append [] [], Is.EqualTo([]))
+    append [] [] |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``append of empty and non-empty lists`` () =
-    Assert.That(append [] [1 .. 4], Is.EqualTo([1 .. 4]))
+    append [] [1 .. 4] |> should equal [1 .. 4]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``append of non-empty and empty lists`` () =
-    Assert.That(append [1 .. 4] [], Is.EqualTo([1 .. 4]))
+    append [1 .. 4] [] |> should equal [1 .. 4]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``append of non-empty lists`` () =
-    Assert.That(append [1 .. 3] [4; 5], Is.EqualTo([1 .. 5]))
+    append [1 .. 3] [4; 5] |> should equal [1 .. 5]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``append of large lists`` () =
-    Assert.That(append [1 .. (big / 2)] [1 + big / 2 .. big] = bigList, Is.True)
+    append [1 .. (big / 2)] [1 + big / 2 .. big] = bigList |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``concat of no lists`` () =
-    Assert.That(concat [], Is.EqualTo([]))
+    concat [] |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``concat of list of lists`` () =
-    Assert.That(concat [[1; 2]; [3]; []; [4; 5; 6]], Is.EqualTo([1 .. 6]))
+    concat [[1; 2]; [3]; []; [4; 5; 6]] |> should equal [1 .. 6]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``concat of large list of small lists`` () =
-    Assert.That(concat (map (fun x -> [x]) [1 .. big]) = bigList, Is.True)
+    concat (map (fun x -> [x]) [1 .. big]) = bigList |> should equal true

data/tracks/fsharp/exercises/list-ops/Program.fs

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

data/tracks/fsharp/exercises/luhn/Luhn.fs

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

data/tracks/fsharp/exercises/luhn/Luhn.fsproj

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

@@ -1,107 +1,96 @@
 module LuhnTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Luhn
 
-[<Test>]
+[<Fact>]
 let ``Single digit strings cannot be valid`` () =
     let input = "1"
     let expected = false
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``A single zero is invalid`` () =
     let input = "0"
     let expected = false
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Single zero with space is invalid`` () =
     let input = "0 "
     let expected = false
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Lots of zeros are valid`` () =
     let input = "00000"
     let expected = true
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Nine doubled is nine`` () =
     let input = "091"
     let expected = true
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Simple valid number`` () =
     let input = " 5 9 "
     let expected = true
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Valid Canadian SIN`` () =
     let input = "046 454 286"
     let expected = true
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Another valid SIN`` () =
     let input = "055 444 285"
     let expected = true
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Invalid Canadian SIN`` () =
     let input = "046 454 287"
     let expected = false
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Invalid credit card`` () =
     let input = "8273 1232 7352 0569"
     let expected = false
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Strings that contain non-digits are not valid`` () =
     let input = "827a 1232 7352 0569"
     let expected = false
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Punctuation is not allowed`` () =
     let input = "055-444-285"
     let expected = false
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Symbols are not allowed`` () =
     let input = "055£ 444$ 285"
     let expected = false
     let actual = valid input
-    Assert.That(actual, Is.EqualTo(expected))
+    actual |> should equal expected

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

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

data/tracks/fsharp/exercises/markdown/Markdown.fsproj

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

@@ -1,59 +1,60 @@
-module MarkdownTest
+module MarkdownTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Markdown
 
-[<Test>]
+[<Fact>]
 let ``Parses normal text as a paragraph`` () =
     let input = "This will be a paragraph"
     let expected = "<p>This will be a paragraph</p>"
-    Assert.That(parse input, Is.EqualTo(expected))
+    parse input |> should equal expected
     
-[<Test>]
+[<Fact>]
 let ``Parsing italics`` () =
     let input = "_This will be italic_"
     let expected = "<p><em>This will be italic</em></p>"
-    Assert.That(parse input, Is.EqualTo(expected))
+    parse input |> should equal expected
 
-[<Test>]
+[<Fact>]
 let ``Parsing bold text`` () =
     let input = "__This will be bold__"
     let expected = "<p><strong>This will be bold</strong></p>"
-    Assert.That(parse input, Is.EqualTo(expected))
+    parse input |> should equal expected
 
-[<Test>]
+[<Fact>]
 let ``Mixed normal, italics and bold text`` () =
     let input = "This will _be_ __mixed__"
     let expected = "<p>This will <em>be</em> <strong>mixed</strong></p>"
-    Assert.That(parse input, Is.EqualTo(expected))
+    parse input |> should equal expected
 
-[<Test>]
+[<Fact>]
 let ``With h1 header level`` () =
     let input = "# This will be an h1"
     let expected = "<h1>This will be an h1</h1>"
-    Assert.That(parse input, Is.EqualTo(expected))
+    parse input |> should equal expected
 
-[<Test>]
+[<Fact>]
 let ``With h2 header level`` () =
     let input = "## This will be an h2"
     let expected = "<h2>This will be an h2</h2>"
-    Assert.That(parse input, Is.EqualTo(expected))
+    parse input |> should equal expected
 
-[<Test>]
+[<Fact>]
 let ``With h6 header level`` () =
     let input = "###### This will be an h6"
     let expected = "<h6>This will be an h6</h6>"
-    Assert.That(parse input, Is.EqualTo(expected))
+    parse input |> should equal expected
 
-[<Test>]
+[<Fact>]
 let ``Unordered lists`` () =
     let input = "* Item 1\n* Item 2"
     let expected = "<ul><li>Item 1</li><li>Item 2</li></ul>"
-    Assert.That(parse input, Is.EqualTo(expected))
+    parse input |> should equal expected
 
-[<Test>]
+[<Fact>]
 let ``With a little bit of everything`` () =
     let input = "# Header!\n* __Bold Item__\n* _Italic Item_"
     let expected = "<h1>Header!</h1><ul><li><strong>Bold Item</strong></li><li><em>Italic Item</em></li></ul>"
-    Assert.That(parse input, Is.EqualTo(expected))
+    parse input |> should equal expected

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

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

data/tracks/fsharp/exercises/matrix/Matrix.fs

@@ -0,0 +1,7 @@
+module Matrix
+
+let fromString str = failwith "You need to implement this function."
+
+let rows matrix = failwith "You need to implement this function."
+
+let cols matrix = failwith "You need to implement this function."

data/tracks/fsharp/exercises/matrix/Matrix.fsproj

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

@@ -1,52 +1,80 @@
-module MatrixTest
+module MatrixTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Matrix
 
-[<TestCase("1", ExpectedResult = [| 1 |])>]
-[<TestCase("4 7", ExpectedResult = [| 4; 7 |], Ignore = "Remove to run test case")>]
-[<TestCase("1 2\n10 20", ExpectedResult = [| 1; 2 |], Ignore = "Remove to run test case")>]
-[<TestCase("9 7 6\n8 6 5\n5 3 2", ExpectedResult = [| 9; 7; 6 |], Ignore = "Remove to run test case")>]
-let ``Extract first row`` (input: string) =    
-    let matrix = fromString input    
-    rows matrix |> Array.head
-
-[<TestCase("5", ExpectedResult = [| 5 |], Ignore = "Remove to run test case")>]
-[<TestCase("9 7", ExpectedResult = [| 9; 7 |], Ignore = "Remove to run test case")>]
-[<TestCase("9 8 7\n19 18 17", ExpectedResult = [| 19; 18; 17 |], Ignore = "Remove to run test case")>]
-[<TestCase("1 4 9\n16 25 36\n5 6 7", ExpectedResult = [| 5; 6; 7 |], Ignore = "Remove to run test case")>]
-let ``Extract last row`` (input: string) =
-    let matrix = fromString input
-    rows matrix |> Array.last
-
-[<TestCase("55 44", ExpectedResult = [| 55 |], Ignore = "Remove to run test case")>]
-[<TestCase("89 1903\n18 3", ExpectedResult = [| 89; 18 |], Ignore = "Remove to run test case")>]
-[<TestCase("1 2 3\n4 5 6\n7 8 9\n8 7 6", ExpectedResult = [| 1; 4; 7; 8 |], Ignore = "Remove to run test case")>]
-let ``Extract first column`` (input: string) =
-    let matrix = fromString input
-    cols matrix |> Array.head
-
-[<TestCase("28", ExpectedResult = [| 28 |], Ignore = "Remove to run test case")>]
-[<TestCase("13\n16\n19", ExpectedResult = [| 13; 16; 19 |], Ignore = "Remove to run test case")>]
-[<TestCase("289 21903 23\n218 23 21", ExpectedResult = [| 23; 21 |], Ignore = "Remove to run test case")>]
-[<TestCase("11 12 13\n14 15 16\n17 18 19\n18 17 16", ExpectedResult = [| 13; 16; 19; 16 |], Ignore = "Remove to run test case")>]
-let ``Extract last column`` (input: string) =
-    let matrix = fromString input
-    cols matrix |> Array.last
-
-[<TestCase("28", ExpectedResult = 1, Ignore = "Remove to run test case")>]
-[<TestCase("13\n16", ExpectedResult = 2, Ignore = "Remove to run test case")>]
-[<TestCase("289 21903\n23 218\n23 21", ExpectedResult = 3, Ignore = "Remove to run test case")>]
-[<TestCase("11 12 13\n14 15 16\n17 18 19\n18 17 16", ExpectedResult = 4, Ignore = "Remove to run test case")>]
-let ``Number of rows`` (input: string) =
-    let matrix = fromString input
-    rows matrix |> Array.length
-
-[<TestCase("28", ExpectedResult = 1, Ignore = "Remove to run test case")>]
-[<TestCase("13 2\n16 3\n19 4", ExpectedResult = 2, Ignore = "Remove to run test case")>]
-[<TestCase("289 21903\n23 218\n23 21", ExpectedResult = 2, Ignore = "Remove to run test case")>]
-[<TestCase("11 12 13\n14 15 16\n17 18 19\n18 17 16", ExpectedResult = 3, Ignore = "Remove to run test case")>]
-let ``Number of columns`` (input: string) =
-    let matrix = fromString input
-    cols matrix |> Array.length
+type MatrixTest() =
+    static member ExtractFirstRowData = 
+        let theoryData = new TheoryData<string, int[]>()
+        theoryData.Add("1", [| 1 |])
+        theoryData.Add("4 7", [| 4; 7 |])
+        theoryData.Add("1 2\n10 20", [| 1; 2 |])
+        theoryData.Add("9 7 6\n8 6 5\n5 3 2", [| 9; 7; 6 |])
+        theoryData
+
+    [<Theory>]
+    [<MemberData("ExtractFirstRowData")>]
+    member this.``Extract first row`` (input: string) expected =    
+        let matrix = fromString input    
+        rows matrix |> Array.head |> should equal expected
+
+    static member ExtractLastRowData = 
+        let theoryData = new TheoryData<string, int[]>()
+        theoryData.Add("5", [| 5 |])
+        theoryData.Add("9 7", [| 9; 7 |])
+        theoryData.Add("9 8 7\n19 18 17", [| 19; 18; 17 |])
+        theoryData.Add("1 4 9\n16 25 36\n5 6 7", [| 5; 6; 7 |])
+        theoryData
+
+    [<Theory(Skip = "Remove to run test")>]
+    [<MemberData("ExtractLastRowData")>]
+    member this.``Extract last row`` (input: string) expected =
+        let matrix = fromString input
+        rows matrix |> Array.last |> should equal expected
+
+    static member ExtractFirstColumnData = 
+        let theoryData = new TheoryData<string, int[]>()
+        theoryData.Add("55 44", [| 55 |])
+        theoryData.Add("89 1903\n18 3", [| 89; 18 |])
+        theoryData.Add("1 2 3\n4 5 6\n7 8 9\n8 7 6", [| 1; 4; 7; 8 |])
+        theoryData
+
+    [<Theory(Skip = "Remove to run test")>]
+    [<MemberData("ExtractFirstColumnData")>]
+    member this.``Extract first column`` (input: string) expected =
+        let matrix = fromString input
+        cols matrix |> Array.head |> should equal expected
+
+    static member ExtractLastColumnData = 
+        let theoryData = new TheoryData<string, int[]>()
+        theoryData.Add("28", [| 28 |])
+        theoryData.Add("13\n16\n19", [| 13; 16; 19 |])
+        theoryData.Add("289 21903 23\n218 23 21", [| 23; 21 |])
+        theoryData.Add("11 12 13\n14 15 16\n17 18 19\n18 17 16", [| 13; 16; 19; 16 |])
+        theoryData
+
+    [<Theory(Skip = "Remove to run test")>]
+    [<MemberData("ExtractLastColumnData")>]
+    member this.``Extract last column`` (input: string) expected =
+        let matrix = fromString input
+        cols matrix |> Array.last |> should equal expected
+
+    [<Theory(Skip = "Remove to run test")>]
+    [<InlineData("28", 1)>]
+    [<InlineData("13\n16", 2)>]
+    [<InlineData("289 21903\n23 218\n23 21", 3)>]
+    [<InlineData("11 12 13\n14 15 16\n17 18 19\n18 17 16", 4)>]
+    member this.``Number of rows`` (input: string) expected =
+        let matrix = fromString input
+        rows matrix |> Array.length |> should equal expected
+
+    [<Theory(Skip = "Remove to run test")>]
+    [<InlineData("28", 1)>]
+    [<InlineData("13 2\n16 3\n19 4", 2)>]
+    [<InlineData("289 21903\n23 218\n23 21", 2)>]
+    [<InlineData("11 12 13\n14 15 16\n17 18 19\n18 17 16", 3)>]
+    member this.``Number of columns`` (input: string) expected =
+        let matrix = fromString input
+        cols matrix |> Array.length |> should equal expected

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

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

data/tracks/fsharp/exercises/meetup/Meetup.fs

@@ -0,0 +1,7 @@
+module Meetup
+
+open System
+
+type Schedule = First | Second | Third | Fourth | Last | Teenth
+
+let meetupDay dayOfWeek schedule year month: DateTime = failwith "You need to implement this function."