trackler 2.2.1.105 → 2.2.1.106

data/tracks/common-lisp/exercises/bob/example.lisp

@@ -6,15 +6,19 @@
 
 (defun contains-alpha-chars-p (msg)
   (some #'(lambda (c) (char-not-greaterp #\a c #\z))
-	(coerce msg 'list)))
+        (coerce msg 'list)))
 
-(defun silence-p (msg) (equal "" (string-trim '(#\Space) msg)))
+(defun silence-p (msg) (equal "" (string-trim '(#\Space #\Newline #\Tab #\Page) msg)))
 (defun shouting-p (msg) (and (contains-alpha-chars-p msg)
-			     (equal msg (string-upcase msg))))
-(defun questioning-p (msg) (equal #\? (char msg (1- (length msg)))))
+                             (equal msg (string-upcase msg))))
+(defun questioning-p (msg)
+  (let ((msg (string-trim '(#\Space #\Newline #\Tab #\Page) msg)))
+    (equal #\? (char msg (1- (length msg))))))
 
 (defun response-for (msg)
   (cond ((silence-p msg) "Fine. Be that way!")
-	((shouting-p msg) "Whoa, chill out!")
-	((questioning-p msg) "Sure.")
-	(t "Whatever.")))
+        ((and (shouting-p msg)
+              (questioning-p msg)) "Calm down, I know what I'm doing!")
+        ((shouting-p msg) "Whoa, chill out!")
+        ((questioning-p msg) "Sure.")
+        (t "Whatever.")))

data/tracks/cpp/docs/INSTALLATION.md

@@ -15,7 +15,7 @@ as separate command-line tools.
 ### Prerequisite: A Modern C++11 Compiler
 
 This language track requires a compiler with [C++11](http://en.wikipedia.org/wiki/C%2B%2B11)
-support, which was release in 2011. All major compilers released in the last few years should
+support, which was released in 2011. All major compilers released in the last few years should
 be compatible, so as long as you are on a fairly recent version you should be fine.
 Specifically, GCC version 5.1 or later, Clang version 3.8 or later, or Visual
 Studio 2015 or later.

data/tracks/cpp/exercises/leap/leap_test.cpp

@@ -25,6 +25,6 @@ BOOST_AUTO_TEST_CASE(turn_of_the_21st_century)
 
 BOOST_AUTO_TEST_CASE(turn_of_the_25th_century)
 {
-    BOOST_REQUIRE(leap::is_leap_year(2400));;
+    BOOST_REQUIRE(leap::is_leap_year(2400));
 }
 #endif

data/tracks/elixir/exercises/pig-latin/example.exs

@@ -32,7 +32,7 @@ defmodule PigLatin do
   end
 
   defp consonant_prefix_and_rest(word) do
-    if Regex.match?(~r/^yt|xr/, word) do
+    if Regex.match?(~r/^[yx][bcdfghjklmnpqrstvwxy]+/, word) do
       ["", word]
     else
       ~r/^(s?qu|(?:[^aeiou]*))?([aeiou].*)$/
@@ -40,4 +40,3 @@ defmodule PigLatin do
     end
   end
 end
-

data/tracks/elixir/exercises/pig-latin/pig_latin_test.exs

@@ -82,7 +82,7 @@ defmodule PigLatinTest do
     end
   end
 
-  describe "some letter clusters are treated like a single consonant" do
+  describe "consecutive consonants are treated like a single consonant" do
     @tag :pending
     test "word beginning with ch" do
       assert PigLatin.translate("chair") == "airchay"
@@ -114,16 +114,26 @@ defmodule PigLatinTest do
     end
   end
 
-  describe "some letter clusters are treated like a single vowel" do
+  describe "'x' and 'y', when followed by a consonant, are treated like a vowel" do
     @tag :pending
-    test "word beginning with yt" do
+    test "word beginning with y, followed by a consonant" do
       assert PigLatin.translate("yttria") == "yttriaay"
     end
 
+    @tag :pending
+    test "word beginning with y, followed by another consonant" do
+      assert PigLatin.translate("yddria") == "yddriaay"
+    end
+
     @tag :pending
     test "word beginning with xr" do
       assert PigLatin.translate("xray") == "xrayay"
     end
+
+    @tag :pending
+    test "word beginning with xb" do
+      assert PigLatin.translate("xbot") == "xbotay"
+    end
   end
 
   describe "phrases are translated" do
@@ -133,4 +143,3 @@ defmodule PigLatinTest do
     end
   end
 end
-

data/tracks/elm/config.json

@@ -323,7 +323,7 @@
       ]
     },
     {
-      "uuid": "1f52ab74-02d5-db80-8f95-521aba04d183e704422",
+      "uuid": "0edd5fa2-f1db-4572-9810-55a2c6729753",
       "slug": "collatz-conjecture",
       "core": false,
       "unlocked_by": null,
@@ -333,7 +333,7 @@
       ]
     },
     {
-      "uuid": "7890045d-0cf5-1980-21ae-7bd0228ad2a2993ae82",
+      "uuid": "bdb8364b-d8b2-4d58-a824-1035cddedb42",
       "slug": "all-your-base",
       "core": false,
       "unlocked_by": null,
@@ -343,7 +343,7 @@
       ]
     },
     {
-      "uuid": "a730ca85-057d-db80-e44e-25b8028acede6337cca",
+      "uuid": "b7e456d7-e383-4e03-9126-c9b57c1287e1",
       "slug": "pascals-triangle",
       "core": false,
       "unlocked_by": null,
@@ -354,7 +354,7 @@
       ]
     },
     {
-      "uuid": "5f540090-061e-2f80-40a8-d9782700ed2efdf8965",
+      "uuid": "6b6e9f4d-9c45-4d8c-9e8e-b2144204d2da",
       "slug": "isogram",
       "core": false,
       "unlocked_by": null,

data/tracks/elm/exercises/bob/Bob.example.elm

@@ -6,7 +6,9 @@ import String
 
 hey : String -> String
 hey remark =
-    if isShouting remark then
+    if isShouting remark && isQuestion remark then
+        "Calm down, I know what I'm doing!"
+    else if isShouting remark then
         "Whoa, chill out!"
     else if isQuestion remark then
         "Sure."

data/tracks/elm/exercises/bob/README.md

@@ -6,6 +6,8 @@ Bob answers 'Sure.' if you ask him a question.
 
 He answers 'Whoa, chill out!' if you yell at him.
 
+He answers 'Calm down, I know what I'm doing!' if you yell a question at him.
+
 He says 'Fine. Be that way!' if you address him without actually saying
 anything.
 

data/tracks/elm/exercises/bob/tests/Tests.elm

@@ -61,7 +61,7 @@ tests =
             test "forceful questions" <|
                 \() ->
                     Expect.equal
-                        "Whoa, chill out!"
+                        "Calm down, I know what I'm doing!"
                         (Bob.hey "WHAT THE HELL WERE YOU THINKING?")
         , skip <|
             test "shouting numbers" <|

data/tracks/elm/exercises/phone-number/PhoneNumber.example.elm

@@ -1,28 +1,43 @@
 module PhoneNumber exposing (..)
 
-import String
+import List exposing (head, map)
+import Maybe exposing (andThen)
+import Regex exposing (HowMany(..), Regex, find, regex)
+import String exposing (concat, length, slice, startsWith)
 
 
-nums =
-    [ '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' ]
+matchesFormat : Regex -> String -> Bool
+matchesFormat regex string =
+    case find (AtMost 1) regex string |> head of
+        Just found ->
+            True
 
+        Nothing ->
+            False
 
-getNumber : String -> Maybe String
-getNumber text =
-    getValidNum (String.filter isDigit text)
-
-
-isDigit : Char -> Bool
-isDigit char =
-    List.any (\n -> n == char) nums
 
-
-getValidNum : String -> Maybe String
-getValidNum num =
-    if String.length num == 10 then
-        Just num
-    else if (String.length num == 11) && (String.left 1 num == "1") then
-        Just (String.dropLeft 1 num)
+getNumber : String -> Maybe String
+getNumber phoneNumber =
+    let
+        numberFormat =
+            regex "^\\D*(\\+?1\\s*[\\-\\.]?\\s*)?((\\([2-9]\\d{2}\\))|([2-9]\\d{2}))\\s*[\\-\\.]?\\s*[2-9]\\d{2}\\s*[\\-\\.]?\\s*\\d{4}\\D*$"
+
+        numbers =
+            regex "\\d"
+
+        dropCountryCode matchedNumbers =
+            case matchedNumbers of
+                "1" :: nums ->
+                    nums
+
+                _ ->
+                    matchedNumbers
+
+        stripNumber =
+            concat << dropCountryCode << map .match << find All numbers
+    in
+    if phoneNumber |> matchesFormat numberFormat then
+        Just <| stripNumber <| phoneNumber
     else
         Nothing
 

data/tracks/elm/exercises/phone-number/tests/Tests.elm

@@ -9,38 +9,59 @@ tests : Test
 tests =
     describe "PhoneNumber"
         [ test "cleans number" <|
-            \() -> Expect.equal (Just "1234567890") (getNumber "(123) 456-7890")
+            \() -> Expect.equal (Just "2234567890") (getNumber "(223) 456-7890")
+        , skip <|
+            test "invalid when empty" <|
+                \() -> Expect.equal Nothing (getNumber "")
         , skip <|
             test "cleans number with dots" <|
-                \() -> Expect.equal (Just "1234567890") (getNumber "123.456.7890")
+                \() -> Expect.equal (Just "2234567890") (getNumber "223.456.7890")
+        , skip <|
+            test "invalid when 9 digits" <|
+                \() -> Expect.equal Nothing (getNumber "223456789")
+        , skip <|
+            test "cleans number with multiple spaces" <|
+                \() -> Expect.equal (Just "2234567890") (getNumber "223 456   7890")
+        , skip <|
+            test "invalid when 12 digits" <|
+                \() -> Expect.equal Nothing (getNumber "223456789012")
         , skip <|
             test "valid when 11 digits and first is 1" <|
-                \() -> Expect.equal (Just "1234567890") (getNumber "11234567890")
+                \() -> Expect.equal (Just "2234567890") (getNumber "12234567890")
         , skip <|
-            test "invalid when 11 digits" <|
-                \() -> Expect.equal Nothing (getNumber "21234567890")
+            test "invalid when 11 digits and first is not 1" <|
+                \() -> Expect.equal Nothing (getNumber "22234567890")
         , skip <|
-            test "invalid when 9 digits" <|
-                \() -> Expect.equal Nothing (getNumber "123456789")
+            test "valid when 11 digits and first is 1 with punctuation" <|
+                \() -> Expect.equal (Just "2234567890") (getNumber "+1 (223) 456-7890")
         , skip <|
-            test "invalid when 12 digits" <|
-                \() -> Expect.equal Nothing (getNumber "123456789012")
+            test "invalid with letters" <|
+                \() -> Expect.equal Nothing (getNumber "223-abc-789012")
         , skip <|
-            test "invalid when empty" <|
-                \() -> Expect.equal Nothing (getNumber "")
+            test "invalid with multiple punctuation marks" <|
+                \() -> Expect.equal Nothing (getNumber "223-@:!-789012")
         , skip <|
-            test "invalid when no digits present" <|
-                \() -> Expect.equal Nothing (getNumber " (-) ")
+            test "invalid when area code starts with 1" <|
+                \() -> Expect.equal Nothing (getNumber "(123) 456-7890")
+        , skip <|
+            test "invalid when area code starts with 0" <|
+                \() -> Expect.equal Nothing (getNumber "(023) 456-7890")
         , skip <|
-            test "valid with leading characters" <|
-                \() -> Expect.equal (Just "1234567890") (getNumber "my number is 123 456 7890")
+            test "invalid when exchange code starts with 1" <|
+                \() -> Expect.equal Nothing (getNumber "(223) 156-7890")
         , skip <|
-            test "valid with trailing characters" <|
-                \() -> Expect.equal (Just "1234567890") (getNumber "123 456 7890 - bob")
+            test "invalid when exchange code starts with 0" <|
+                \() -> Expect.equal Nothing (getNumber "(223) 056-7890")
+        , skip <|
+            test "invalid when N in exchange code is 1" <|
+                \() -> Expect.equal Nothing (getNumber "2341567890")
+        , skip <|
+            test "invalid when no digits present" <|
+                \() -> Expect.equal Nothing (getNumber " (-) ")
         , skip <|
             test "pretty print" <|
-                \() -> Expect.equal (Just "(123) 456-7890") (prettyPrint "1234567890")
+                \() -> Expect.equal (Just "(223) 456-7890") (prettyPrint "2234567890")
         , skip <|
             test "pretty print with full us phone number" <|
-                \() -> Expect.equal (Just "(123) 456-7890") (prettyPrint "11234567890")
+                \() -> Expect.equal (Just "(223) 456-7890") (prettyPrint "12234567890")
         ]

data/tracks/elm/exercises/space-age/tests/Tests.elm

@@ -9,26 +9,26 @@ tests : Test
 tests =
     describe "SpaceAge"
         [ test "age in earth years" <|
-            \() -> Expect.equal 32 (round (ageOn Earth 1000000000))
+            \() -> Expect.equal 32 (round (ageOn Earth 1000000000.0))
         , skip <|
             test "age in mercury years" <|
-                \() -> Expect.equal 281 (round (ageOn Mercury 2134835688))
+                \() -> Expect.equal 281 (round (ageOn Mercury 2134835688.0))
         , skip <|
             test "age in venus years" <|
-                \() -> Expect.equal 10 (round (ageOn Venus 189839836))
+                \() -> Expect.equal 10 (round (ageOn Venus 189839836.0))
         , skip <|
             test "age on mars" <|
-                \() -> Expect.equal 39 (round (ageOn Mars 2329871239))
+                \() -> Expect.equal 39 (round (ageOn Mars 2329871239.0))
         , skip <|
             test "age on jupiter" <|
-                \() -> Expect.equal 2 (round (ageOn Jupiter 901876382))
+                \() -> Expect.equal 2 (round (ageOn Jupiter 901876382.0))
         , skip <|
             test "age on saturn" <|
-                \() -> Expect.equal 3 (round (ageOn Saturn 3000000000))
+                \() -> Expect.equal 3 (round (ageOn Saturn 3000000000.0))
         , skip <|
             test "age on uranus" <|
-                \() -> Expect.equal 1 (round (ageOn Uranus 3210123456))
+                \() -> Expect.equal 1 (round (ageOn Uranus 3210123456.0))
         , skip <|
             test "age on neptune" <|
-                \() -> Expect.equal 2 (round (ageOn Neptune 8210123456))
+                \() -> Expect.equal 2 (round (ageOn Neptune 8210123456.0))
         ]

data/tracks/fsharp/exercises/all-your-base/AllYourBaseTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 2.1.0 of the canonical data.
+// This file was auto-generated based on version 2.3.0 of the canonical data.
 
 module AllYourBaseTest
 
@@ -105,7 +105,7 @@ let ``Leading zeros`` () =
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Input base is one`` () =
-    let digits = []
+    let digits = [0]
     let inputBase = 1
     let outputBase = 10
     let expected = None

data/tracks/fsharp/exercises/binary-search-tree/BinarySearchTree.fs

@@ -4,12 +4,8 @@ let left node  = failwith "You need to implement this function."
 
 let right node = failwith "You need to implement this function."
 
-let value node = failwith "You need to implement this function."
+let data node = failwith "You need to implement this function."
 
-let singleton value = failwith "You need to implement this function."
+let create items = failwith "You need to implement this function."
 
-let rec insert newValue tree = failwith "You need to implement this function."
-
-let toList tree = failwith "You need to implement this function."
-
-let fromList xs = failwith "You need to implement this function."
+let sortedData node = failwith "You need to implement this function."

data/tracks/fsharp/exercises/binary-search-tree/BinarySearchTreeTest.fs

@@ -1,61 +1,87 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.0.0 of the canonical data.
 
 module BinarySearchTreeTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open BinarySearchTree
 
 [<Fact>]
 let ``Data is retained`` () =
-    let tree = singleton 4
-    tree |> value |> should equal <| Some 4
+    let treeData = create [4]
+    treeData |> data |> should equal 4
+    treeData |> left |> should equal None
+    treeData |> right |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Inserting less`` () =
-    let tree = singleton 4 |> insert 2
-    tree |> value |> should equal <| Some 4
-    tree |> left |> Option.bind value |> should equal <| Some 2
+let ``Can create complex tree`` () =
+    let treeData = create [4; 2; 6; 1; 3; 5; 7]
+    treeData |> data |> should equal 4
+    treeData |> left |> Option.map data |> should equal (Some 2)
+    treeData |> left |> Option.bind left |> Option.map data |> should equal (Some 1)
+    treeData |> left |> Option.bind left |> Option.bind left |> should equal None
+    treeData |> left |> Option.bind left |> Option.bind right |> should equal None
+    treeData |> left |> Option.bind right |> Option.map data |> should equal (Some 3)
+    treeData |> left |> Option.bind right |> Option.bind left |> should equal None
+    treeData |> left |> Option.bind right |> Option.bind right |> should equal None
+    treeData |> right |> Option.map data |> should equal (Some 6)
+    treeData |> right |> Option.bind left |> Option.map data |> should equal (Some 5)
+    treeData |> right |> Option.bind left |> Option.bind left |> should equal None
+    treeData |> right |> Option.bind left |> Option.bind right |> should equal None
+    treeData |> right |> Option.bind right |> Option.map data |> should equal (Some 7)
+    treeData |> right |> Option.bind right |> Option.bind left |> should equal None
+    treeData |> right |> Option.bind right |> Option.bind right |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Inserting same`` () =
-    let tree = singleton 4 |> insert 4
-    tree |> value |> should equal <| Some 4
-    tree |> left |> Option.bind value |> should equal <| Some 4
+let ``Smaller number at left node`` () =
+    let treeData = create [4; 2]
+    treeData |> data |> should equal 4
+    treeData |> left |> Option.map data |> should equal (Some 2)
+    treeData |> left |> Option.bind left |> should equal None
+    treeData |> left |> Option.bind right |> should equal None
+    treeData |> right |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Inserting greater`` () =
-    let tree = singleton 4 |> insert 5
-    tree |> value |> should equal <| Some 4
-    tree |> right |> Option.bind value |> should equal <| Some 5
+let ``Same number at left node`` () =
+    let treeData = create [4; 4]
+    treeData |> data |> should equal 4
+    treeData |> left |> Option.map data |> should equal (Some 4)
+    treeData |> left |> Option.bind left |> should equal None
+    treeData |> left |> Option.bind right |> should equal None
+    treeData |> right |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Complex tree`` () =
-    let tree = fromList [4; 2; 6; 1; 3; 7; 5]
-    tree |> value |> should equal <| Some 4
-    tree |> left |> Option.bind value |> should equal <| Some 2
-    tree |> left |> Option.bind (fun x -> x |> left) |> Option.bind value |> should equal <| Some 1
-    tree |> left |> Option.bind (fun x -> x |> right) |> Option.bind value |> should equal <| Some 3
-    tree |> right |> Option.bind value |> should equal <| Some 6
-    tree |> right |> Option.bind (fun x -> x |> left) |> Option.bind value |> should equal <| Some 5
-    tree |> right |> Option.bind (fun x -> x |> right) |> Option.bind value |> should equal <| Some 7
+let ``Greater number at right node`` () =
+    let treeData = create [4; 5]
+    treeData |> data |> should equal 4
+    treeData |> left |> should equal None
+    treeData |> right |> Option.map data |> should equal (Some 5)
+    treeData |> right |> Option.bind left |> should equal None
+    treeData |> right |> Option.bind right |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Iterating one element`` () =
-    let elements = singleton 4 |> toList
-    elements |> should equal [4]
+let ``Can sort single number`` () =
+    let treeData = create [2]
+    sortedData treeData |> should equal [2]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Iterating over smaller element`` () =
-    let elements = fromList [4; 2] |> toList
-    elements |> should equal [2; 4]
+let ``Can sort if second number is smaller than first`` () =
+    let treeData = create [2; 1]
+    sortedData treeData |> should equal [1; 2]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Iterating over larger element`` () =
-    let elements = fromList [4; 5] |> toList
-    elements |> should equal [4; 5]
+let ``Can sort if second number is same as first`` () =
+    let treeData = create [2; 2]
+    sortedData treeData |> should equal [2; 2]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Iterating over complex element`` () =
-    let elements = fromList [4; 2; 1; 3; 6; 7; 5] |> toList
-    elements |> should equal [1; 2; 3; 4; 5; 6; 7] 
+let ``Can sort if second number is greater than first`` () =
+    let treeData = create [2; 3]
+    sortedData treeData |> should equal [2; 3]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Can sort complex tree`` () =
+    let treeData = create [2; 1; 3; 6; 7; 5]
+    sortedData treeData |> should equal [1; 2; 3; 5; 6; 7]
+

data/tracks/fsharp/exercises/binary-search-tree/Example.fs

@@ -4,11 +4,11 @@ type Node = { left: Node option; value: int; right: Node option }
 
 let left node  = node.left
 let right node = node.right
-let value node = Some node.value
+let data node = node.value
 
-let singleton value = { left = None; right = None; value = value }
+let private singleton value = { left = None; right = None; value = value }
 
-let rec insert newValue (tree: Node) =
+let rec private insert newValue (tree: Node) =
     let loop newValue = 
         function
         | Some x -> Some <| insert newValue x
@@ -20,7 +20,7 @@ let rec insert newValue (tree: Node) =
     | _ -> 
         { tree with right = loop newValue tree.right }
 
-let toList tree = 
+let sortedData tree = 
     let rec loop = 
         function
         | Some node -> loop node.left @ [node.value] @ loop node.right
@@ -28,7 +28,7 @@ let toList tree =
 
     loop <| Some tree
 
-let fromList = 
+let create = 
     function
     | []    -> failwith "Cannot create tree from empty list."
     | x::xs -> List.fold (fun acc elem -> insert elem acc) (singleton x) xs

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

@@ -12,7 +12,6 @@ open CircularBuffer
 let ``Reading empty buffer should fail`` () =
     let buffer1 = mkCircularBuffer 1
     (fun () -> read buffer1 |> ignore) |> should throw typeof<Exception>
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Can read an item just written`` () =
@@ -20,7 +19,6 @@ let ``Can read an item just written`` () =
     let buffer2 = write 1 buffer1
     let (val3, _) = read buffer2
     val3 |> should equal 1
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Each item may only be read once`` () =
@@ -29,7 +27,6 @@ let ``Each item may only be read once`` () =
     let (val3, buffer3) = read buffer2
     val3 |> should equal 1
     (fun () -> read buffer3 |> ignore) |> should throw typeof<Exception>
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Items are read in the order they are written`` () =
@@ -40,14 +37,12 @@ let ``Items are read in the order they are written`` () =
     val4 |> should equal 1
     let (val5, _) = read buffer4
     val5 |> should equal 2
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Full buffer can't be written to`` () =
     let buffer1 = mkCircularBuffer 1
     let buffer2 = write 1 buffer1
     (fun () -> write 2 buffer2 |> ignore) |> should throw typeof<Exception>
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``A read frees up capacity for another write`` () =
@@ -58,7 +53,6 @@ let ``A read frees up capacity for another write`` () =
     let buffer4 = write 2 buffer3
     let (val5, _) = read buffer4
     val5 |> should equal 2
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Read position is maintained even across multiple writes`` () =
@@ -72,7 +66,6 @@ let ``Read position is maintained even across multiple writes`` () =
     val6 |> should equal 2
     let (val7, _) = read buffer6
     val7 |> should equal 3
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Items cleared out of buffer can't be read`` () =
@@ -80,7 +73,6 @@ let ``Items cleared out of buffer can't be read`` () =
     let buffer2 = write 1 buffer1
     let buffer3 = clear buffer2
     (fun () -> read buffer3 |> ignore) |> should throw typeof<Exception>
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Clear frees up capacity for another write`` () =
@@ -90,7 +82,6 @@ let ``Clear frees up capacity for another write`` () =
     let buffer4 = write 2 buffer3
     let (val5, _) = read buffer4
     val5 |> should equal 2
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Clear does nothing on empty buffer`` () =
@@ -99,7 +90,6 @@ let ``Clear does nothing on empty buffer`` () =
     let buffer3 = write 1 buffer2
     let (val4, _) = read buffer3
     val4 |> should equal 1
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Overwrite acts like write on non-full buffer`` () =
@@ -110,7 +100,6 @@ let ``Overwrite acts like write on non-full buffer`` () =
     val4 |> should equal 1
     let (val5, _) = read buffer4
     val5 |> should equal 2
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Overwrite replaces the oldest item on full buffer`` () =
@@ -122,7 +111,6 @@ let ``Overwrite replaces the oldest item on full buffer`` () =
     val5 |> should equal 2
     let (val6, _) = read buffer5
     val6 |> should equal 3
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Overwrite replaces the oldest item remaining in buffer following a read`` () =
@@ -140,5 +128,4 @@ let ``Overwrite replaces the oldest item remaining in buffer following a read``
     val9 |> should equal 4
     let (val10, _) = read buffer9
     val10 |> should equal 5
-