trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/circular-buffer/CircularBufferTest.fs

@@ -1,19 +1,20 @@
-module CircularBufferTest
+module CircularBufferTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
+open System
 
 open CircularBuffer
 
-[<Test>]
+[<Fact>]
 let ``Write and read back one item`` () =
     let buffer1 = mkCircularBuffer 1 |> write '1'    
     let (val2, buffer2) = read buffer1
 
-    Assert.That(val2, Is.EqualTo('1'))    
-    Assert.That((fun () -> read buffer2 |> ignore), Throws.Exception)
+    val2 |> should equal '1'    
+    (fun () -> read buffer2 |> ignore) |> should throw typeof<Exception>
   
-[<Test>]
-[<Ignore("Remove to run test")>] 
+[<Fact(Skip = "Remove to run test")>] 
 let ``Write and read back multiple items`` () =    
     let buffer1 = 
         mkCircularBuffer 2
@@ -23,12 +24,11 @@ let ``Write and read back multiple items`` () =
     let (val2, buffer2) = read buffer1
     let (val3, buffer3) = read buffer2
 
-    Assert.That(val2, Is.EqualTo('1'))
-    Assert.That(val3, Is.EqualTo('2'))
-    Assert.That((fun () -> read buffer3 |> ignore), Throws.Exception)
+    val2 |> should equal '1'
+    val3 |> should equal '2'
+    (fun () -> read buffer3 |> ignore) |> should throw typeof<Exception>
     
-[<Test>]
-[<Ignore("Remove to run test")>] 
+[<Fact(Skip = "Remove to run test")>] 
 let ``Clearing buffer`` () =    
     let buffer1 = mkCircularBuffer 3
     let buffer2 = List.fold (fun buffer value -> write value buffer) buffer1 ['1'..'3']
@@ -43,12 +43,11 @@ let ``Clearing buffer`` () =
     let buffer6 = buffer5 |> write '3'
     let (val7, _) = read buffer6
 
-    Assert.That((fun () -> read buffer3 |> ignore), Throws.Exception)
-    Assert.That(val5, Is.EqualTo('1'))
-    Assert.That(val7, Is.EqualTo('2'))
+    (fun () -> read buffer3 |> ignore) |> should throw typeof<Exception>
+    val5 |> should equal '1'
+    val7 |> should equal '2'
   
-[<Test>]
-[<Ignore("Remove to run test")>] 
+[<Fact(Skip = "Remove to run test")>] 
 let ``Alternate write and read`` () =    
     let buffer1 = mkCircularBuffer 2
     let buffer2 = buffer1 |> write '1'
@@ -56,11 +55,10 @@ let ``Alternate write and read`` () =
     let buffer4 = buffer3 |> write '2'
     let (val5, _) = read buffer4
     
-    Assert.That(val3, Is.EqualTo('1'))
-    Assert.That(val5, Is.EqualTo('2'))
+    val3 |> should equal '1'
+    val5 |> should equal '2'
   
-[<Test>]
-[<Ignore("Remove to run test")>] 
+[<Fact(Skip = "Remove to run test")>] 
 let ``Reads back oldest item`` () =    
     let buffer1 = 
         mkCircularBuffer 3
@@ -71,21 +69,19 @@ let ``Reads back oldest item`` () =
     let buffer3 = buffer2 |> write '3'
     let (val4, buffer4) = read buffer3
     let (val5, _) = read buffer4
-    Assert.That(val4, Is.EqualTo('2'))
-    Assert.That(val5, Is.EqualTo('3'))
+    val4 |> should equal '2'
+    val5 |> should equal '3'
   
-[<Test>]
-[<Ignore("Remove to run test")>] 
+[<Fact(Skip = "Remove to run test")>] 
 let ``Writing to a full buffer throws an exception`` () =    
     let buffer = 
         mkCircularBuffer 2
         |> write '1'
         |> write '2'
 
-    Assert.That((fun () -> buffer |> write 'A' |> ignore), Throws.Exception)
+    (fun () -> buffer |> write 'A' |> ignore) |> should throw typeof<Exception>
   
-[<Test>]
-[<Ignore("Remove to run test")>] 
+[<Fact(Skip = "Remove to run test")>] 
 let ``Overwriting oldest item in a full buffer`` () =    
     let buffer1 = 
         mkCircularBuffer 2
@@ -96,12 +92,11 @@ let ``Overwriting oldest item in a full buffer`` () =
     let (val2, buffer2) = read buffer1
     let (val3, buffer3) = read buffer2
 
-    Assert.That(val2, Is.EqualTo('2'))
-    Assert.That(val3, Is.EqualTo('A'))
-    Assert.That((fun () -> read buffer3 |> ignore), Throws.Exception)
+    val2 |> should equal '2'
+    val3 |> should equal 'A'
+    (fun () -> read buffer3 |> ignore) |> should throw typeof<Exception>
   
-[<Test>]
-[<Ignore("Remove to run test")>] 
+[<Fact(Skip = "Remove to run test")>] 
 let ``Forced writes to non full buffer should behave like writes`` () =    
     let buffer1 = 
         mkCircularBuffer 2
@@ -111,12 +106,11 @@ let ``Forced writes to non full buffer should behave like writes`` () =
     let (val2, buffer2) = read buffer1
     let (val3, buffer3) = read buffer2
 
-    Assert.That(val2, Is.EqualTo('1'))
-    Assert.That(val3, Is.EqualTo('2'))
-    Assert.That((fun () -> read buffer3 |> ignore), Throws.Exception)
+    val2 |> should equal '1'
+    val3 |> should equal '2'
+    (fun () -> read buffer3 |> ignore) |> should throw typeof<Exception>
   
-[<Test>]
-[<Ignore("Remove to run test")>] 
+[<Fact(Skip = "Remove to run test")>] 
 let ``Alternate read and write into buffer overflow`` () =    
     let buffer1 = mkCircularBuffer 5
     let buffer2 = List.fold (fun buffer value -> write value buffer) buffer1 ['1'..'3']
@@ -133,7 +127,7 @@ let ``Alternate read and write into buffer overflow`` () =
 
     let folder buffer value =
         let (val', buffer') = read buffer    
-        Assert.IsTrue((val' = value)) |> ignore
+        val' |> should equal value |> ignore
         buffer'
 
     let buffer8 = List.fold folder buffer7 ['6'..'8']      
@@ -141,6 +135,6 @@ let ``Alternate read and write into buffer overflow`` () =
     let (val9, buffer9) = read buffer8  
     let (val10, buffer10) = read buffer9
     
-    Assert.That(val9, Is.EqualTo('A'))
-    Assert.That(val10, Is.EqualTo('B'))
-    Assert.That((fun () -> read buffer10 |> ignore), Throws.Exception)
+    val9 |> should equal 'A'
+    val10 |> should equal 'B'
+    (fun () -> read buffer10 |> ignore) |> should throw typeof<Exception>

data/tracks/fsharp/exercises/circular-buffer/Program.fs

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

data/tracks/fsharp/exercises/clock/Clock.fs

@@ -0,0 +1,9 @@
+module Clock
+
+let mkClock hours minutes = failwith "You need to implement this function."
+
+let add minutes clock = failwith "You need to implement this function."
+
+let subtract minutes clock = failwith "You need to implement this function."
+
+let display clock = failwith "You need to implement this function."

data/tracks/fsharp/exercises/clock/Clock.fsproj

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

@@ -1,110 +1,96 @@
 module ClockTest
 
 open System
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Clock
 
-[<Test>]
+[<Fact>]
 let ``Prints 8 o'clock`` () =
     let clock = mkClock 8 0
-    Assert.That(display clock, Is.EqualTo("08:00"))
+    display clock |> should equal "08:00"
 
-[<Test>]
-[<Ignore("Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]     
 let ``Prints 9 o'clock`` () =
     let clock = mkClock 9 0
-    Assert.That(display clock, Is.EqualTo("09:00"))
+    display clock |> should equal "09:00"
 
-[<Test>]
-[<Ignore("Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]     
 let ``Can print single-digit minutes`` () =
     let clock = mkClock 11 9
-    Assert.That(display clock, Is.EqualTo("11:09"))
+    display clock |> should equal "11:09"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can print double-digit minutes`` () =
     let clock = mkClock 11 19
-    Assert.That(display clock, Is.EqualTo("11:19"))
+    display clock |> should equal "11:19"
 
-[<Test>] 
-[<Ignore("Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]
 let ``Can add minutes`` () =
     let clock = mkClock 10 0
     let added = clock |> add 3
-    Assert.That(display added, Is.EqualTo("10:03"))
+    display added |> should equal "10:03"
 
-[<Test>] 
-[<Ignore("Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]
 let ``Can add over an hour`` () =
     let clock = mkClock 10 0
     let added = clock |> add 63
-    Assert.That(display added, Is.EqualTo("11:03"))
+    display added |> should equal "11:03"
 
-[<Test>]   
-[<Ignore("Remove to run test")>]   
+[<Fact(Skip = "Remove to run test")>]
 let ``Can add over more than one day`` () =
     let clock = mkClock 10 0
     let added = clock |> add 7224
-    Assert.That(display added, Is.EqualTo("10:24"))
+    display added |> should equal "10:24"
 
-[<Test>]   
-[<Ignore("Remove to run test")>]   
+[<Fact(Skip = "Remove to run test")>]
 let ``Can subtract minutes`` () =
     let clock = mkClock 10 3
     let subtracted = clock |> subtract 3
-    Assert.That(display subtracted, Is.EqualTo("10:00"))
+    display subtracted |> should equal "10:00"
 
-[<Test>]   
-[<Ignore("Remove to run test")>]   
+[<Fact(Skip = "Remove to run test")>]
 let ``Can subtract to previous hour`` () =
     let clock = mkClock 10 3
     let subtracted = clock |> subtract 30
-    Assert.That(display subtracted, Is.EqualTo("09:33"))
+    display subtracted |> should equal "09:33"
 
-[<Test>]  
-[<Ignore("Remove to run test")>]    
+[<Fact(Skip = "Remove to run test")>]
 let ``Can subtract over an hour`` () =
     let clock = mkClock 10 3
     let subtracted = clock |> subtract 70
-    Assert.That(display subtracted, Is.EqualTo("08:53"))
+    display subtracted |> should equal "08:53"
 
-[<Test>]    
-[<Ignore("Remove to run test")>]  
+[<Fact(Skip = "Remove to run test")>]
 let ``Wraps around midnight`` () =
     let clock = mkClock 23 59
     let added = clock |> add 2
-    Assert.That(display added, Is.EqualTo("00:01"))
+    display added |> should equal "00:01"
 
-[<Test>]  
-[<Ignore("Remove to run test")>]    
+[<Fact(Skip = "Remove to run test")>]
 let ``Wraps around midnight backwards`` () =
     let clock = mkClock 0 1
     let subtracted = clock |> subtract 2
-    Assert.That(display subtracted, Is.EqualTo("23:59"))
+    display subtracted |> should equal "23:59"
 
-[<Test>]   
-[<Ignore("Remove to run test")>]   
+[<Fact(Skip = "Remove to run test")>]
 let ``Midnight is zero hundred hours`` () =
     let clock = mkClock 24 0
-    Assert.That(display clock, Is.EqualTo("00:00"))
+    display clock |> should equal "00:00"
 
-[<Test>]    
-[<Ignore("Remove to run test")>]  
+[<Fact(Skip = "Remove to run test")>]
 let ``Sixty minutes is next hour`` () =
     let clock = mkClock 1 60
-    Assert.That(display clock, Is.EqualTo("02:00"))
+    display clock |> should equal "02:00"
 
-[<Test>]   
-[<Ignore("Remove to run test")>]   
+[<Fact(Skip = "Remove to run test")>]
 let ``Clocks with same time are equal`` () =
     let clock1 = mkClock 14 30
     let clock2 = mkClock 14 30
-    Assert.That(clock1, Is.EqualTo(clock2))
+    clock1 |> should equal clock2
 
-[<Test>]   
-[<Ignore("Remove to run test")>]   
+[<Fact(Skip = "Remove to run test")>]
 let ``Overflown clocks with same time are equal`` () =
     let clock1 = mkClock 14 30
     let clock2 = mkClock 38 30
-    Assert.That(clock1, Is.EqualTo(clock2))
+    clock1 |> should equal clock2

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

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

data/tracks/fsharp/exercises/connect/Connect.fs

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

data/tracks/fsharp/exercises/connect/Connect.fsproj

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

@@ -1,13 +1,14 @@
-module ConnectTest
+module ConnectTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open System
 
 open Connect
 
 let makeBoard (board: string list) = board |> List.map (fun x -> x.Replace(" ", "")) 
 
-[<Test>]
+[<Fact>]
 let ``Empty board has no winner`` () =
     let lines = [". . . . .    ";
                  " . . . . .   ";
@@ -15,24 +16,21 @@ let ``Empty board has no winner`` () =
                  "   . . . . . ";
                  "    . . . . ."]
     let board = makeBoard lines
-    Assert.That(resultFor board, Is.EqualTo(None))
+    resultFor board |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``1x1 board with black stone`` () =
     let lines = ["X"]
     let board = makeBoard lines  
-    Assert.That(resultFor board, Is.EqualTo(Some Black))
+    resultFor board |> should equal <| Some Black
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``1x1 board with white stone`` () =
     let lines = ["O"]
     let board = makeBoard lines  
-    Assert.That(resultFor board, Is.EqualTo(Some White))
+    resultFor board |> should equal <| Some White
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Convoluted path`` () =
     let lines = [". X X . .    ";
                  " X . X . X   ";
@@ -40,10 +38,9 @@ let ``Convoluted path`` () =
                  "   . X X . . ";
                  "    O O O O O"]
     let board = makeBoard lines  
-    Assert.That(resultFor board, Is.EqualTo(Some Black))
+    resultFor board |> should equal <| Some Black
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Rectangle, black wins`` () =
     let lines = [". O . .    ";
                  " O X X X   ";
@@ -51,10 +48,9 @@ let ``Rectangle, black wins`` () =
                  "   X X O X ";
                  "    . O X ."]
     let board = makeBoard lines  
-    Assert.That(resultFor board, Is.EqualTo(Some Black))
+    resultFor board |> should equal <| Some Black
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Rectangle, white wins`` () =
     let lines = [". O . .    ";
                  " O X X X   ";
@@ -62,10 +58,9 @@ let ``Rectangle, white wins`` () =
                  "   X X O X ";
                  "    . O X ."]
     let board = makeBoard lines  
-    Assert.That(resultFor board, Is.EqualTo(Some White))
+    resultFor board |> should equal <| Some White
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Spiral, black wins`` () =
     let lines = ["OXXXXXXXX";
                  "OXOOOOOOO";
@@ -77,10 +72,9 @@ let ``Spiral, black wins`` () =
                  "OOOOOOOXO";
                  "XXXXXXXXO"]
     let board = makeBoard lines
-    Assert.That(resultFor board, Is.EqualTo(Some Black))
+    resultFor board |> should equal <| Some Black
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Spiral, nobody wins`` () =
     let lines = ["OXXXXXXXX";
                  "OXOOOOOOO";
@@ -92,4 +86,4 @@ let ``Spiral, nobody wins`` () =
                  "OOOOOOOXO";
                  "XXXXXXXXO"]
     let board = makeBoard lines
-    Assert.That(resultFor board, Is.EqualTo(None))
+    resultFor board |> should equal None

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

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

data/tracks/fsharp/exercises/crypto-square/CryptoSquare.fs

@@ -0,0 +1,44 @@
+module CryptoSquare
+
+open System
+
+let charsToString chars = new String(chars |> Array.ofSeq)
+
+let chunksOfSize n seq = 
+    seq 
+    |> Seq.mapi(fun i x -> i / n, x)
+    |> Seq.groupBy fst
+    |> Seq.map (fun (_, g) -> g |> Seq.map snd |> charsToString)
+
+let transpose seq = 
+    seq
+    |> Seq.collect(fun s -> s |> Seq.mapi(fun i e -> (i, e)))
+    |> Seq.groupBy(fst)
+    |> Seq.map(fun (_, s) -> s |> Seq.map snd |> charsToString)    
+
+let normalizePlaintext (input: string) = seq { for c in input do if Char.IsLetterOrDigit c then yield Char.ToLowerInvariant c } |> charsToString
+
+let size (input: string) = 
+    input 
+    |> normalizePlaintext 
+    |> String.length 
+    |> float 
+    |> Math.Sqrt 
+    |> ceil 
+    |> int
+
+let plaintextSegments (input: string) = 
+    chunksOfSize (size input) (normalizePlaintext input) 
+    |> List.ofSeq
+
+let ciphertext (input: string) = 
+    input 
+    |> plaintextSegments 
+    |> transpose 
+    |> String.concat ""
+
+let normalizeCiphertext (input: string) = 
+    input 
+    |> plaintextSegments 
+    |> transpose 
+    |> String.concat " "

data/tracks/fsharp/exercises/crypto-square/CryptoSquare.fsproj

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

@@ -1,68 +1,57 @@
 module CryptoSquareTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open CryptoSquare
 
-[<Test>]
+[<Fact>]
 let ``Strange characters are stripped during normalization`` () =
-    Assert.That(normalizePlaintext "s#$%^&plunk", Is.EqualTo("splunk"))
+    normalizePlaintext "s#$%^&plunk" |> should equal "splunk"
 
-[<Test>]
-[<Ignore("Remove to run test")>]   
+[<Fact(Skip = "Remove to run test")>]   
 let ``Letters are lowercased during normalization`` () =
-    Assert.That(normalizePlaintext "WHOA HEY!", Is.EqualTo("whoahey"))
+    normalizePlaintext "WHOA HEY!" |> should equal "whoahey"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Numbers are kept during normalization`` () =
-    Assert.That(normalizePlaintext "1, 2, 3, GO!", Is.EqualTo("123go"))
+    normalizePlaintext "1, 2, 3, GO!" |> should equal "123go"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Smallest square size is 2`` () =
-    Assert.That(size "1234", Is.EqualTo(2))
+    size "1234" |> should equal 2
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Size of text whose length is a perfect square is its square root`` () =
-    Assert.That(size "123456789", Is.EqualTo(3))
+    size "123456789" |> should equal 3
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Size of text whose length is not a perfect square is next biggest square root`` () =
-    Assert.That(size "123456789abc", Is.EqualTo(4))
+    size "123456789abc" |> should equal 4
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Size is determined by normalized text`` () =
-    Assert.That(size "Oh hey, this is nuts!", Is.EqualTo(4))
+    size "Oh hey, this is nuts!" |> should equal 4
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Segments are split by square size`` () =
-    Assert.That(plaintextSegments "Never vex thine heart with idle woes", Is.EqualTo(["neverv"; "exthin"; "eheart"; "withid"; "lewoes"]))
+    plaintextSegments "Never vex thine heart with idle woes" |> should equal ["neverv"; "exthin"; "eheart"; "withid"; "lewoes"]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Segments are split by square size until text runs out`` () =
-    Assert.That(plaintextSegments "ZOMG! ZOMBIES!!!", Is.EqualTo(["zomg"; "zomb"; "ies"]))
+    plaintextSegments "ZOMG! ZOMBIES!!!" |> should equal ["zomg"; "zomb"; "ies"]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Ciphertext combines text by column`` () =
-    Assert.That(ciphertext "First, solve the problem. Then, write the code.", Is.EqualTo("foeewhilpmrervrticseohtottbeedshlnte"))
+    ciphertext "First, solve the problem. Then, write the code." |> should equal "foeewhilpmrervrticseohtottbeedshlnte"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Ciphertext skips cells with no text`` () =
-    Assert.That(ciphertext "Time is an illusion. Lunchtime doubly so.", Is.EqualTo("tasneyinicdsmiohooelntuillibsuuml"))
+    ciphertext "Time is an illusion. Lunchtime doubly so." |> should equal "tasneyinicdsmiohooelntuillibsuuml"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Normalized ciphertext is split by 5`` () =
-    Assert.That(normalizeCiphertext "Vampires are people too!", Is.EqualTo("vrel aepe mset paoo irpo"))
+    normalizeCiphertext "Vampires are people too!" |> should equal "vrel aepe mset paoo irpo"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Normalized ciphertext not exactly divisible by 5 spills into a smaller segment`` () =
-    Assert.That(normalizeCiphertext "Madness, and then illumination.", Is.EqualTo("msemo aanin dnin ndla etlt shui"))
+    normalizeCiphertext "Madness, and then illumination." |> should equal "msemo aanin dnin ndla etlt shui"

data/tracks/fsharp/exercises/crypto-square/Program.fs

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