From 4d81104a85b8f2ff140b704a35ad79382aa9c86c Mon Sep 17 00:00:00 2001 From: Jay Hayes Date: Wed, 5 Jul 2017 15:35:15 -0500 Subject: [PATCH] Skip all but first test of each example This allows learners to gradually approach exercise. However, unlike commented tests, the Elm compiler is still able to infer type information from the skipped tests. --- exercises/accumulate/tests/Tests.elm | 23 +- exercises/allergies/tests/Tests.elm | 63 +++--- exercises/anagram/tests/Tests.elm | 171 +++++++------- exercises/atbash-cipher/tests/Tests.elm | 53 +++-- exercises/bob/tests/Tests.elm | 209 ++++++++++-------- .../difference-of-squares/tests/Tests.elm | 45 ++-- exercises/gigasecond/tests/Tests.elm | 28 ++- exercises/grade-school/tests/Tests.elm | 87 ++++---- exercises/grains/tests/Tests.elm | 35 +-- exercises/hamming/tests/Tests.elm | 65 +++--- exercises/hello-world/tests/Tests.elm | 14 +- .../largest-series-product/tests/Tests.elm | 80 ++++--- exercises/leap/tests/Tests.elm | 30 ++- exercises/list-ops/tests/Tests.elm | 95 ++++---- exercises/nucleotide-count/tests/Tests.elm | 27 ++- exercises/pangram/tests/Tests.elm | 81 ++++--- exercises/phone-number/tests/Tests.elm | 55 +++-- exercises/raindrops/tests/Tests.elm | 70 +++--- exercises/rna-transcription/tests/Tests.elm | 30 ++- exercises/robot-simulator/tests/Tests.elm | 84 ++++--- exercises/roman-numerals/tests/Tests.elm | 153 +++++++------ exercises/run-length-encoding/tests/Tests.elm | 56 +++-- exercises/say/tests/Tests.elm | 156 +++++++------ exercises/scrabble-score/tests/Tests.elm | 50 +++-- exercises/series/tests/Tests.elm | 63 +++--- exercises/space-age/tests/Tests.elm | 35 +-- exercises/strain/tests/Tests.elm | 99 +++++---- exercises/sublist/tests/Tests.elm | 90 +++++--- exercises/sum-of-multiples/tests/Tests.elm | 25 ++- exercises/triangle/tests/Tests.elm | 65 +++--- exercises/word-count/tests/Tests.elm | 45 ++-- 31 files changed, 1250 insertions(+), 932 deletions(-) diff --git a/exercises/accumulate/tests/Tests.elm b/exercises/accumulate/tests/Tests.elm index 33af1dc..ef2ae1d 100644 --- a/exercises/accumulate/tests/Tests.elm +++ b/exercises/accumulate/tests/Tests.elm @@ -16,14 +16,17 @@ tests = describe "Accumulate" [ test "[] Accumulate" <| \() -> Expect.equal [] (accumulate square []) - , test "square Accumulate" <| - \() -> Expect.equal [ 1, 4, 9 ] (accumulate square [ 1, 2, 3 ]) - , test "toUpper Accumulate" <| - \() -> - Expect.equal [ "HELLO", "WORLD" ] - (accumulate String.toUpper [ "hello", "world" ]) - , test "reverse Accumulate" <| - \() -> - Expect.equal [ "olleh", "dlrow" ] - (accumulate String.reverse [ "hello", "world" ]) + , skip <| + test "square Accumulate" <| + \() -> Expect.equal [ 1, 4, 9 ] (accumulate square [ 1, 2, 3 ]) + , skip <| + test "toUpper Accumulate" <| + \() -> + Expect.equal [ "HELLO", "WORLD" ] + (accumulate String.toUpper [ "hello", "world" ]) + , skip <| + test "reverse Accumulate" <| + \() -> + Expect.equal [ "olleh", "dlrow" ] + (accumulate String.reverse [ "hello", "world" ]) ] diff --git a/exercises/allergies/tests/Tests.elm b/exercises/allergies/tests/Tests.elm index 4d98793..a43ff9e 100644 --- a/exercises/allergies/tests/Tests.elm +++ b/exercises/allergies/tests/Tests.elm @@ -13,36 +13,47 @@ tests = [ describe "no allergies means not allergic" [ test "peanuts" <| \() -> Expect.equal False (isAllergicTo "peanuts" 0) - , test "cats" <| - \() -> Expect.equal False (isAllergicTo "cats" 0) - , test "strawberries" <| - \() -> Expect.equal False (isAllergicTo "strawberries" 0) + , skip <| + test "cats" <| + \() -> Expect.equal False (isAllergicTo "cats" 0) + , skip <| + test "strawberries" <| + \() -> Expect.equal False (isAllergicTo "strawberries" 0) ] - , test "is allergic to eggs" <| - \() -> Expect.equal True (isAllergicTo "eggs" 1) + , skip <| + test "is allergic to eggs" <| + \() -> Expect.equal True (isAllergicTo "eggs" 1) , describe "has the right allergies" - [ test "eggs" <| - \() -> Expect.equal True (isAllergicTo "eggs" 5) - , test "shellfish" <| - \() -> Expect.equal True (isAllergicTo "shellfish" 5) - , test "strawberries" <| - \() -> Expect.equal False (isAllergicTo "strawberries" 5) + [ skip <| + test "eggs" <| + \() -> Expect.equal True (isAllergicTo "eggs" 5) + , skip <| + test "shellfish" <| + \() -> Expect.equal True (isAllergicTo "shellfish" 5) + , skip <| + test "strawberries" <| + \() -> Expect.equal False (isAllergicTo "strawberries" 5) ] ] , describe "toList" - [ test "no allergies at all" <| - \() -> Expect.equal [] (toList (0)) - , test "allergic to just peanuts" <| - \() -> Expect.equal [ "peanuts" ] (toList (2)) - , test "allergic to everything" <| - \() -> - Expect.equal (List.sort [ "eggs", "peanuts", "shellfish", "strawberries", "tomatoes", "chocolate", "pollen", "cats" ]) - (255 |> toList |> List.sort) - , test "ignore non allergen score parts" <| - \() -> Expect.equal [ "eggs" ] (toList 257) - , test "ignore all non allergen score parts" <| - \() -> - Expect.equal (List.sort [ "eggs", "shellfish", "strawberries", "tomatoes", "chocolate", "pollen", "cats" ]) - (509 |> toList |> List.sort) + [ skip <| + test "no allergies at all" <| + \() -> Expect.equal [] (toList (0)) + , skip <| + test "allergic to just peanuts" <| + \() -> Expect.equal [ "peanuts" ] (toList (2)) + , skip <| + test "allergic to everything" <| + \() -> + Expect.equal (List.sort [ "eggs", "peanuts", "shellfish", "strawberries", "tomatoes", "chocolate", "pollen", "cats" ]) + (255 |> toList |> List.sort) + , skip <| + test "ignore non allergen score parts" <| + \() -> Expect.equal [ "eggs" ] (toList 257) + , skip <| + test "ignore all non allergen score parts" <| + \() -> + Expect.equal (List.sort [ "eggs", "shellfish", "strawberries", "tomatoes", "chocolate", "pollen", "cats" ]) + (509 |> toList |> List.sort) ] ] diff --git a/exercises/anagram/tests/Tests.elm b/exercises/anagram/tests/Tests.elm index b1dd3fc..d41fa4a 100644 --- a/exercises/anagram/tests/Tests.elm +++ b/exercises/anagram/tests/Tests.elm @@ -12,80 +12,99 @@ tests = \() -> Expect.equal [] (detect "diaper" [ "hello", "world", "zombies", "pants" ]) - , test "detects simple anagram" <| - \() -> - Expect.equal [ "tan" ] - (detect "ant" [ "tan", "stand", "at" ]) - , test "does not detect false positives" <| - \() -> - Expect.equal [] - (detect "galea" [ "eagle" ]) - , test "detects multiple anagrams" <| - \() -> - Expect.equal [ "stream", "maters" ] - (detect "master" [ "stream", "pigeon", "maters" ]) - , test "does not detect anagram subsets" <| - \() -> - Expect.equal [] - (detect "good" [ "dog", "goody" ]) - , test "detects anagram" <| - \() -> - Expect.equal [ "inlets" ] - (detect "listen" [ "enlists", "google", "inlets", "banana" ]) - , test "detects even more anagrams" <| - \() -> - Expect.equal [ "gallery", "regally", "largely" ] - (detect "allergy" [ "gallery", "ballerina", "regally", "clergy", "largely", "leading" ]) - , test "does not detect indentical words" <| - \() -> - Expect.equal [ "cron" ] - (detect "corn" [ "corn", "dark", "Corn", "rank", "CORN", "cron", "park" ]) - , test "does not detect non-anagrams with identical checksum" <| - \() -> - Expect.equal [] - (detect "mass" [ "last" ]) - , test "detects anagrams case-insensitively" <| - \() -> - Expect.equal [ "Carthorse" ] - (detect "Orchestra" [ "cashregister", "Carthorse", "radishes" ]) - , test "detects anagrams using case-insensitive subject" <| - \() -> - Expect.equal [ "carthorse" ] - (detect "Orchestra" [ "cashregister", "carthorse", "radishes" ]) - , test "detects anagrams using case-insensitve possible matches" <| - \() -> - Expect.equal [ "Carthorse" ] - (detect "orchestra" [ "cashregister", "Carthorse", "radishes" ]) - , test "does not detect a word as its own anagram" <| - \() -> - Expect.equal [] - (detect "banana" [ "Banana" ]) - , test "does not detect a anagram if the original word is repeated" <| - \() -> - Expect.equal [] - (detect "go" [ "go Go GO" ]) - , test "anagrams must use all letters exactly once (go)" <| - \() -> - Expect.equal [] - (detect "tapper" [ "patter" ]) - , test "eliminates anagrams with the same checksum" <| - \() -> - Expect.equal [] - (detect "mass" [ "last" ]) - , test "detects unicode anagrams" <| - \() -> - Expect.equal [ "ΒΓΑ", "γβα" ] - (detect "ΑΒΓ" [ "ΒΓΑ", "ΒΓΔ", "γβα" ]) - , test "eliminates misleading unicode anagrams" <| - \() -> - Expect.equal [] - (detect "ΑΒΓ" [ "ABΓ" ]) - , test "capital word is not own anagram" <| - \() -> - Expect.equal [] - (detect "BANANA" [ "Banana" ]) - , test "anagrams must use all letters exactly once (banana)" <| - \() -> - Expect.equal [] - (detect "patter" [ "tapper" ]) + , skip <| + test "detects simple anagram" <| + \() -> + Expect.equal [ "tan" ] + (detect "ant" [ "tan", "stand", "at" ]) + , skip <| + test "does not detect false positives" <| + \() -> + Expect.equal [] + (detect "galea" [ "eagle" ]) + , skip <| + test "detects multiple anagrams" <| + \() -> + Expect.equal [ "stream", "maters" ] + (detect "master" [ "stream", "pigeon", "maters" ]) + , skip <| + test "does not detect anagram subsets" <| + \() -> + Expect.equal [] + (detect "good" [ "dog", "goody" ]) + , skip <| + test "detects anagram" <| + \() -> + Expect.equal [ "inlets" ] + (detect "listen" [ "enlists", "google", "inlets", "banana" ]) + , skip <| + test "detects even more anagrams" <| + \() -> + Expect.equal [ "gallery", "regally", "largely" ] + (detect "allergy" [ "gallery", "ballerina", "regally", "clergy", "largely", "leading" ]) + , skip <| + test "does not detect indentical words" <| + \() -> + Expect.equal [ "cron" ] + (detect "corn" [ "corn", "dark", "Corn", "rank", "CORN", "cron", "park" ]) + , skip <| + test "does not detect non-anagrams with identical checksum" <| + \() -> + Expect.equal [] + (detect "mass" [ "last" ]) + , skip <| + test "detects anagrams case-insensitively" <| + \() -> + Expect.equal [ "Carthorse" ] + (detect "Orchestra" [ "cashregister", "Carthorse", "radishes" ]) + , skip <| + test "detects anagrams using case-insensitive subject" <| + \() -> + Expect.equal [ "carthorse" ] + (detect "Orchestra" [ "cashregister", "carthorse", "radishes" ]) + , skip <| + test "detects anagrams using case-insensitve possible matches" <| + \() -> + Expect.equal [ "Carthorse" ] + (detect "orchestra" [ "cashregister", "Carthorse", "radishes" ]) + , skip <| + test "does not detect a word as its own anagram" <| + \() -> + Expect.equal [] + (detect "banana" [ "Banana" ]) + , skip <| + test "does not detect a anagram if the original word is repeated" <| + \() -> + Expect.equal [] + (detect "go" [ "go Go GO" ]) + , skip <| + test "anagrams must use all letters exactly once (go)" <| + \() -> + Expect.equal [] + (detect "tapper" [ "patter" ]) + , skip <| + test "eliminates anagrams with the same checksum" <| + \() -> + Expect.equal [] + (detect "mass" [ "last" ]) + , skip <| + test "detects unicode anagrams" <| + \() -> + Expect.equal [ "ΒΓΑ", "γβα" ] + (detect "ΑΒΓ" [ "ΒΓΑ", "ΒΓΔ", "γβα" ]) + , skip <| + test "eliminates misleading unicode anagrams" <| + \() -> + Expect.equal [] + (detect "ΑΒΓ" [ "ABΓ" ]) + , skip <| + test "capital word is not own anagram" <| + \() -> + Expect.equal [] + (detect "BANANA" [ "Banana" ]) + , skip <| + test "anagrams must use all letters exactly once (banana)" <| + \() -> + Expect.equal [] + (detect "patter" [ "tapper" ]) ] diff --git a/exercises/atbash-cipher/tests/Tests.elm b/exercises/atbash-cipher/tests/Tests.elm index aab83a0..d33b384 100644 --- a/exercises/atbash-cipher/tests/Tests.elm +++ b/exercises/atbash-cipher/tests/Tests.elm @@ -10,26 +10,35 @@ tests = describe "AtbashCipher" [ test "encode no" <| \() -> Expect.equal "ml" (encode "no") - , test "encode yes" <| - \() -> Expect.equal "bvh" (encode "yes") - , test "encode OMG" <| - \() -> Expect.equal "lnt" (encode "OMG") - , test "encode O M G" <| - \() -> Expect.equal "lnt" (encode "O M G") - , test "encode long word" <| - \() -> Expect.equal "nrmwy oldrm tob" (encode "mindblowingly") - , test "encode numbers" <| - \() -> Expect.equal "gvhgr mt123 gvhgr mt" (encode "Testing, 1 2 3, testing.") - , test "encode sentence" <| - \() -> Expect.equal "gifgs rhurx grlm" (encode "Truth is fiction.") - , test "encode all things" <| - \() -> - Expect.equal "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt" - (encode "The quick brown fox jumps over the lazy dog.") - , test "decode word" <| - \() -> Expect.equal "exercism" (decode "vcvix rhn") - , test "decode sentence" <| - \() -> - Expect.equal "anobstacleisoftenasteppingstone" - (decode "zmlyh gzxov rhlug vmzhg vkkrm thglm v") + , skip <| + test "encode yes" <| + \() -> Expect.equal "bvh" (encode "yes") + , skip <| + test "encode OMG" <| + \() -> Expect.equal "lnt" (encode "OMG") + , skip <| + test "encode O M G" <| + \() -> Expect.equal "lnt" (encode "O M G") + , skip <| + test "encode long word" <| + \() -> Expect.equal "nrmwy oldrm tob" (encode "mindblowingly") + , skip <| + test "encode numbers" <| + \() -> Expect.equal "gvhgr mt123 gvhgr mt" (encode "Testing, 1 2 3, testing.") + , skip <| + test "encode sentence" <| + \() -> Expect.equal "gifgs rhurx grlm" (encode "Truth is fiction.") + , skip <| + test "encode all things" <| + \() -> + Expect.equal "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt" + (encode "The quick brown fox jumps over the lazy dog.") + , skip <| + test "decode word" <| + \() -> Expect.equal "exercism" (decode "vcvix rhn") + , skip <| + test "decode sentence" <| + \() -> + Expect.equal "anobstacleisoftenasteppingstone" + (decode "zmlyh gzxov rhlug vmzhg vkkrm thglm v") ] diff --git a/exercises/bob/tests/Tests.elm b/exercises/bob/tests/Tests.elm index 6ae1d1f..82c7e67 100644 --- a/exercises/bob/tests/Tests.elm +++ b/exercises/bob/tests/Tests.elm @@ -15,101 +15,120 @@ tests = \() -> Expect.equal "Whatever." (Bob.hey "Tom-ay-to, tom-aaaah-to.") - , test "shouting" <| - \() -> - Expect.equal - "Whoa, chill out!" - (Bob.hey "WATCH OUT!") - , test "shouting gibberish" <| - \() -> - Expect.equal - "Whoa, chill out!" - (Bob.hey (uppercaseGibberish 10)) - , test "asking a question" <| - \() -> - Expect.equal - "Sure." - (Bob.hey "Does this cryogenic chamber make me look fat?") - , test "asking a numeric question" <| - \() -> - Expect.equal - "Sure." - (Bob.hey "You are, what, like 15?") - , test "asking gibberish" <| - \() -> - Expect.equal - "Sure." - (Bob.hey (gibberishQuestion 20)) - , test "talking forcefully" <| - \() -> - Expect.equal - "Whatever." - (Bob.hey "Let's go make out behind the gym!") - , test "using acronyms in regular speech" <| - \() -> - Expect.equal - "Whatever." - (Bob.hey "It's OK if you don't want to go to the DMV.") - , test "forceful questions" <| - \() -> - Expect.equal - "Whoa, chill out!" - (Bob.hey "WHAT THE HELL WERE YOU THINKING?") - , test "shouting numbers" <| - \() -> - Expect.equal - "Whoa, chill out!" - (Bob.hey "1, 2, 3 GO!") - , test "only numbers" <| - \() -> - Expect.equal - "Whatever." - (Bob.hey "1, 2, 3") - , test "question with only numbers" <| - \() -> - Expect.equal - "Sure." - (Bob.hey "4?") - , test "shouting with special characters" <| - \() -> - Expect.equal - "Whoa, chill out!" - (Bob.hey "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!") - , test "shouting with no exclamation mark" <| - \() -> - Expect.equal - "Whoa, chill out!" - (Bob.hey "I HATE YOU") - , test "statement containing a question mark" <| - \() -> - Expect.equal - "Whatever." - (Bob.hey "Ending with ? means a question.") - , test "prattling on" <| - \() -> - Expect.equal - "Sure." - (Bob.hey "Wait! Hang on. Are you going to be OK?") - , test "silence" <| - \() -> - Expect.equal - "Fine. Be that way!" - (Bob.hey "") - , test "prolonged silence" <| - \() -> - Expect.equal - "Fine. Be that way!" - (Bob.hey " ") - , test "alternate silences" <| - \() -> - Expect.equal - "Fine. Be that way!" - (Bob.hey "\t \n \t ") - , test "on multiple line questions" <| - \() -> - Expect.equal - "Whatever." - (Bob.hey "\nDoes this cryogenic chamber make me look fat?\nno") + , skip <| + test "shouting" <| + \() -> + Expect.equal + "Whoa, chill out!" + (Bob.hey "WATCH OUT!") + , skip <| + test "shouting gibberish" <| + \() -> + Expect.equal + "Whoa, chill out!" + (Bob.hey (uppercaseGibberish 10)) + , skip <| + test "asking a question" <| + \() -> + Expect.equal + "Sure." + (Bob.hey "Does this cryogenic chamber make me look fat?") + , skip <| + test "asking a numeric question" <| + \() -> + Expect.equal + "Sure." + (Bob.hey "You are, what, like 15?") + , skip <| + test "asking gibberish" <| + \() -> + Expect.equal + "Sure." + (Bob.hey (gibberishQuestion 20)) + , skip <| + test "talking forcefully" <| + \() -> + Expect.equal + "Whatever." + (Bob.hey "Let's go make out behind the gym!") + , skip <| + test "using acronyms in regular speech" <| + \() -> + Expect.equal + "Whatever." + (Bob.hey "It's OK if you don't want to go to the DMV.") + , skip <| + test "forceful questions" <| + \() -> + Expect.equal + "Whoa, chill out!" + (Bob.hey "WHAT THE HELL WERE YOU THINKING?") + , skip <| + test "shouting numbers" <| + \() -> + Expect.equal + "Whoa, chill out!" + (Bob.hey "1, 2, 3 GO!") + , skip <| + test "only numbers" <| + \() -> + Expect.equal + "Whatever." + (Bob.hey "1, 2, 3") + , skip <| + test "question with only numbers" <| + \() -> + Expect.equal + "Sure." + (Bob.hey "4?") + , skip <| + test "shouting with special characters" <| + \() -> + Expect.equal + "Whoa, chill out!" + (Bob.hey "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!") + , skip <| + test "shouting with no exclamation mark" <| + \() -> + Expect.equal + "Whoa, chill out!" + (Bob.hey "I HATE YOU") + , skip <| + test "statement containing a question mark" <| + \() -> + Expect.equal + "Whatever." + (Bob.hey "Ending with ? means a question.") + , skip <| + test "prattling on" <| + \() -> + Expect.equal + "Sure." + (Bob.hey "Wait! Hang on. Are you going to be OK?") + , skip <| + test "silence" <| + \() -> + Expect.equal + "Fine. Be that way!" + (Bob.hey "") + , skip <| + test "prolonged silence" <| + \() -> + Expect.equal + "Fine. Be that way!" + (Bob.hey " ") + , skip <| + test "alternate silences" <| + \() -> + Expect.equal + "Fine. Be that way!" + (Bob.hey "\t \n \t ") + , skip <| + test "on multiple line questions" <| + \() -> + Expect.equal + "Whatever." + (Bob.hey "\nDoes this cryogenic chamber make me look fat?\nno") ] diff --git a/exercises/difference-of-squares/tests/Tests.elm b/exercises/difference-of-squares/tests/Tests.elm index 1aca0a6..d32a496 100644 --- a/exercises/difference-of-squares/tests/Tests.elm +++ b/exercises/difference-of-squares/tests/Tests.elm @@ -11,27 +11,36 @@ tests = [ describe "square the sum of the numbers up to the given number" [ test "square of sum 5" <| \() -> Expect.equal 225 (squareOfSum 5) - , test "square of sum 10" <| - \() -> Expect.equal 3025 (squareOfSum 10) - , test "square of sum 100" <| - \() -> Expect.equal 25502500 (squareOfSum 100) + , skip <| + test "square of sum 10" <| + \() -> Expect.equal 3025 (squareOfSum 10) + , skip <| + test "square of sum 100" <| + \() -> Expect.equal 25502500 (squareOfSum 100) ] , describe "sum the squares of the numbers up to the given number" - [ test "sum of squares 5" <| - \() -> Expect.equal 55 (sumOfSquares 5) - , test "sum of squares 10" <| - \() -> Expect.equal 385 (sumOfSquares 10) - , test "sum of squares 100" <| - \() -> Expect.equal 338350 (sumOfSquares 100) + [ skip <| + test "sum of squares 5" <| + \() -> Expect.equal 55 (sumOfSquares 5) + , skip <| + test "sum of squares 10" <| + \() -> Expect.equal 385 (sumOfSquares 10) + , skip <| + test "sum of squares 100" <| + \() -> Expect.equal 338350 (sumOfSquares 100) ] , describe "subtract sum of squares from square of sums" - [ test "difference of squares 0" <| - \() -> Expect.equal 0 (difference 0) - , test "difference of squares 5" <| - \() -> Expect.equal 170 (difference 5) - , test "difference of squares 10" <| - \() -> Expect.equal 2640 (difference 10) - , test "difference of squares 100" <| - \() -> Expect.equal 25164150 (difference 100) + [ skip <| + test "difference of squares 0" <| + \() -> Expect.equal 0 (difference 0) + , skip <| + test "difference of squares 5" <| + \() -> Expect.equal 170 (difference 5) + , skip <| + test "difference of squares 10" <| + \() -> Expect.equal 2640 (difference 10) + , skip <| + test "difference of squares 100" <| + \() -> Expect.equal 25164150 (difference 100) ] ] diff --git a/exercises/gigasecond/tests/Tests.elm b/exercises/gigasecond/tests/Tests.elm index 1a84b5d..36ee11b 100644 --- a/exercises/gigasecond/tests/Tests.elm +++ b/exercises/gigasecond/tests/Tests.elm @@ -13,18 +13,22 @@ tests = [ test "2011-04-25" <| \() -> Expect.equal (date "2043-01-01T01:46:40") (Gigasecond.add (date "2011-04-25")) - , test "1977-06-13" <| - \() -> - Expect.equal (date "2009-02-19T01:46:40") (Gigasecond.add (date "1977-06-13")) - , test "1959-07-19" <| - \() -> - Expect.equal (date "1991-03-27T01:46:40") (Gigasecond.add (date "1959-07-19")) - , test "full time specified" <| - \() -> - Expect.equal (date "2046-10-02T23:46:40") (Gigasecond.add (date "2015-01-24T22:00:00")) - , test "full time with day roll-over" <| - \() -> - Expect.equal (date "2046-10-03T01:46:39") (Gigasecond.add (date "2015-01-24T23:59:59")) + , skip <| + test "1977-06-13" <| + \() -> + Expect.equal (date "2009-02-19T01:46:40") (Gigasecond.add (date "1977-06-13")) + , skip <| + test "1959-07-19" <| + \() -> + Expect.equal (date "1991-03-27T01:46:40") (Gigasecond.add (date "1959-07-19")) + , skip <| + test "full time specified" <| + \() -> + Expect.equal (date "2046-10-02T23:46:40") (Gigasecond.add (date "2015-01-24T22:00:00")) + , skip <| + test "full time with day roll-over" <| + \() -> + Expect.equal (date "2046-10-03T01:46:39") (Gigasecond.add (date "2015-01-24T23:59:59")) ] ] diff --git a/exercises/grade-school/tests/Tests.elm b/exercises/grade-school/tests/Tests.elm index a21537b..197f362 100644 --- a/exercises/grade-school/tests/Tests.elm +++ b/exercises/grade-school/tests/Tests.elm @@ -15,45 +15,50 @@ tests = |> addStudent 2 "Aimee" |> studentsInGrade 2 ) - , test "add more students in same class" <| - \() -> - Expect.equal [ "Blair", "James", "Paul" ] - (GradeSchool.empty - |> addStudent 2 "James" - |> addStudent 2 "Blair" - |> addStudent 2 "Paul" - |> studentsInGrade 2 - ) - , test "add students to different grades" <| - \() -> - Expect.equal [ [ "Chelsea" ], [ "Logan" ] ] - (let - school = - GradeSchool.empty - |> addStudent 3 "Chelsea" - |> addStudent 7 "Logan" - in - [ studentsInGrade 3 school, studentsInGrade 7 school ] - ) - , test "get students in a grade" <| - \() -> - Expect.equal [ "Bradley", "Franklin" ] - (GradeSchool.empty - |> addStudent 5 "Franklin" - |> addStudent 5 "Bradley" - |> addStudent 1 "Jeff" - |> studentsInGrade 5 - ) - , test "get all students in the school" <| - \() -> - Expect.equal [ ( 3, [ "Kyle" ] ), ( 4, [ "Christopher", "Jennifer" ] ), ( 6, [ "Kareem" ] ) ] - (GradeSchool.empty - |> addStudent 4 "Jennifer" - |> addStudent 6 "Kareem" - |> addStudent 4 "Christopher" - |> addStudent 3 "Kyle" - |> allStudents - ) - , test "get students in a non-existent grade" <| - \() -> Expect.equal [] (studentsInGrade 1 GradeSchool.empty) + , skip <| + test "add more students in same class" <| + \() -> + Expect.equal [ "Blair", "James", "Paul" ] + (GradeSchool.empty + |> addStudent 2 "James" + |> addStudent 2 "Blair" + |> addStudent 2 "Paul" + |> studentsInGrade 2 + ) + , skip <| + test "add students to different grades" <| + \() -> + Expect.equal [ [ "Chelsea" ], [ "Logan" ] ] + (let + school = + GradeSchool.empty + |> addStudent 3 "Chelsea" + |> addStudent 7 "Logan" + in + [ studentsInGrade 3 school, studentsInGrade 7 school ] + ) + , skip <| + test "get students in a grade" <| + \() -> + Expect.equal [ "Bradley", "Franklin" ] + (GradeSchool.empty + |> addStudent 5 "Franklin" + |> addStudent 5 "Bradley" + |> addStudent 1 "Jeff" + |> studentsInGrade 5 + ) + , skip <| + test "get all students in the school" <| + \() -> + Expect.equal [ ( 3, [ "Kyle" ] ), ( 4, [ "Christopher", "Jennifer" ] ), ( 6, [ "Kareem" ] ) ] + (GradeSchool.empty + |> addStudent 4 "Jennifer" + |> addStudent 6 "Kareem" + |> addStudent 4 "Christopher" + |> addStudent 3 "Kyle" + |> allStudents + ) + , skip <| + test "get students in a non-existent grade" <| + \() -> Expect.equal [] (studentsInGrade 1 GradeSchool.empty) ] diff --git a/exercises/grains/tests/Tests.elm b/exercises/grains/tests/Tests.elm index 4310d67..d08062a 100644 --- a/exercises/grains/tests/Tests.elm +++ b/exercises/grains/tests/Tests.elm @@ -12,20 +12,27 @@ tests = [ describe "square" [ test "of 1" <| \() -> Expect.equal (Just 1) (square 1) - , test "of 2" <| - \() -> Expect.equal (Just 2) (square 2) - , test "of 3" <| - \() -> Expect.equal (Just 4) (square 3) - , test "of 4" <| - \() -> Expect.equal (Just 8) (square 4) - , test "of 16" <| - \() -> Expect.equal (Just 32768) (square 16) - , test "of 32" <| - \() -> Expect.equal (Just 2147483648) (square 32) - , test "square 0 raises an exception" <| - \() -> Expect.equal Nothing (square 0) - , test "negative square raises an exception" <| - \() -> Expect.equal Nothing (square -1) + , skip <| + test "of 2" <| + \() -> Expect.equal (Just 2) (square 2) + , skip <| + test "of 3" <| + \() -> Expect.equal (Just 4) (square 3) + , skip <| + test "of 4" <| + \() -> Expect.equal (Just 8) (square 4) + , skip <| + test "of 16" <| + \() -> Expect.equal (Just 32768) (square 16) + , skip <| + test "of 32" <| + \() -> Expect.equal (Just 2147483648) (square 32) + , skip <| + test "square 0 raises an exception" <| + \() -> Expect.equal Nothing (square 0) + , skip <| + test "negative square raises an exception" <| + \() -> Expect.equal Nothing (square -1) {- Where are the bigger test values?!? Because Javascript's numbers diff --git a/exercises/hamming/tests/Tests.elm b/exercises/hamming/tests/Tests.elm index b81d33e..41b741c 100644 --- a/exercises/hamming/tests/Tests.elm +++ b/exercises/hamming/tests/Tests.elm @@ -10,30 +10,43 @@ tests = describe "Hamming" [ test "identical strands" <| \() -> Expect.equal (Just 0) (distance "A" "A") - , test "long identical strands" <| - \() -> Expect.equal (Just 0) (distance "GGACTGA" "GGACTGA") - , test "complete distance in single nucleotide strands" <| - \() -> Expect.equal (Just 1) (distance "A" "G") - , test "complete distance in small strands" <| - \() -> Expect.equal (Just 2) (distance "AG" "CT") - , test "small distance in small strands" <| - \() -> Expect.equal (Just 1) (distance "AT" "CT") - , test "small distance" <| - \() -> Expect.equal (Just 1) (distance "GGACG" "GGTCG") - , test "small distance in long strands" <| - \() -> Expect.equal (Just 2) (distance "ACCAGGG" "ACTATGG") - , test "non-unique character in first strand" <| - \() -> Expect.equal (Just 1) (distance "AGA" "AGG") - , test "non-unique character in second strand" <| - \() -> Expect.equal (Just 1) (distance "AGG" "AGA") - , test "large distance" <| - \() -> Expect.equal (Just 4) (distance "GATACA" "GCATAA") - , test "large distance in off-by-one strand" <| - \() -> Expect.equal (Just 9) (distance "GGACGGATTCTG" "AGGACGGATTCT") - , test "empty strands" <| - \() -> Expect.equal (Just 0) (distance "" "") - , test "disallow first strand longer" <| - \() -> Expect.equal Nothing (distance "AATG" "AAA") - , test "disallow second strand longer" <| - \() -> Expect.equal Nothing (distance "ATA" "AGTG") + , skip <| + test "long identical strands" <| + \() -> Expect.equal (Just 0) (distance "GGACTGA" "GGACTGA") + , skip <| + test "complete distance in single nucleotide strands" <| + \() -> Expect.equal (Just 1) (distance "A" "G") + , skip <| + test "complete distance in small strands" <| + \() -> Expect.equal (Just 2) (distance "AG" "CT") + , skip <| + test "small distance in small strands" <| + \() -> Expect.equal (Just 1) (distance "AT" "CT") + , skip <| + test "small distance" <| + \() -> Expect.equal (Just 1) (distance "GGACG" "GGTCG") + , skip <| + test "small distance in long strands" <| + \() -> Expect.equal (Just 2) (distance "ACCAGGG" "ACTATGG") + , skip <| + test "non-unique character in first strand" <| + \() -> Expect.equal (Just 1) (distance "AGA" "AGG") + , skip <| + test "non-unique character in second strand" <| + \() -> Expect.equal (Just 1) (distance "AGG" "AGA") + , skip <| + test "large distance" <| + \() -> Expect.equal (Just 4) (distance "GATACA" "GCATAA") + , skip <| + test "large distance in off-by-one strand" <| + \() -> Expect.equal (Just 9) (distance "GGACGGATTCTG" "AGGACGGATTCT") + , skip <| + test "empty strands" <| + \() -> Expect.equal (Just 0) (distance "" "") + , skip <| + test "disallow first strand longer" <| + \() -> Expect.equal Nothing (distance "AATG" "AAA") + , skip <| + test "disallow second strand longer" <| + \() -> Expect.equal Nothing (distance "ATA" "AGTG") ] diff --git a/exercises/hello-world/tests/Tests.elm b/exercises/hello-world/tests/Tests.elm index 6017392..9faca63 100644 --- a/exercises/hello-world/tests/Tests.elm +++ b/exercises/hello-world/tests/Tests.elm @@ -11,10 +11,12 @@ tests = [ test "Hello with no name" <| \() -> Expect.equal "Hello, World!" (helloWorld Nothing) - , test "Hello to a sample name" <| - \() -> - Expect.equal "Hello, Alice!" (helloWorld (Just "Alice")) - , test "Hello to another sample name" <| - \() -> - Expect.equal "Hello, Bob!" (helloWorld (Just "Bob")) + , skip <| + test "Hello to a sample name" <| + \() -> + Expect.equal "Hello, Alice!" (helloWorld (Just "Alice")) + , skip <| + test "Hello to another sample name" <| + \() -> + Expect.equal "Hello, Bob!" (helloWorld (Just "Bob")) ] diff --git a/exercises/largest-series-product/tests/Tests.elm b/exercises/largest-series-product/tests/Tests.elm index 598863d..a7ba686 100644 --- a/exercises/largest-series-product/tests/Tests.elm +++ b/exercises/largest-series-product/tests/Tests.elm @@ -10,36 +10,52 @@ tests = describe "largestProduct" [ test "can find the largest product of 2 with numbers in order" <| \() -> Expect.equal (Just 72) (largestProduct 2 "0123456789") - , test "can find the largest product of 2" <| - \() -> Expect.equal (Just 48) (largestProduct 2 "576802143") - , test "finds the largest product if span equals length" <| - \() -> Expect.equal (Just 18) (largestProduct 2 "29") - , test "can find the largest product of 3 with numbers in order" <| - \() -> Expect.equal (Just 504) (largestProduct 3 "0123456789") - , test "can find the largest product of 3" <| - \() -> Expect.equal (Just 270) (largestProduct 3 "1027839564") - , test "can find the largest product of 5 with numbers in order" <| - \() -> Expect.equal (Just 15120) (largestProduct 5 "0123456789") - , test "can get the largest product of a big number" <| - \() -> Expect.equal (Just 23520) (largestProduct 6 "73167176531330624919225119674426574742355349194934") - , test "can get the largest product of a big number II" <| - \() -> Expect.equal (Just 28350) (largestProduct 6 "52677741234314237566414902593461595376319419139427") - , test "can get the largest product of a big number (Project Euler)" <| - \() -> Expect.equal (Just 23514624000) (largestProduct 13 "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450") - , test "reports zero if the only digits are zero" <| - \() -> Expect.equal (Just 0) (largestProduct 2 "0000") - , test "reports zero if all spans include zero" <| - \() -> Expect.equal (Just 0) (largestProduct 3 "99099") - , test "rejects span longer than string length" <| - \() -> Expect.equal Nothing (largestProduct 4 "123") - , test "reports 1 for empty string and empty product (0 span)" <| - \() -> Expect.equal (Just 1) (largestProduct 0 "") - , test "reports 1 for nonempty string and empty product (0 span)" <| - \() -> Expect.equal (Just 1) (largestProduct 0 "123") - , test "rejects empty string and nonzero span" <| - \() -> Expect.equal Nothing (largestProduct 1 "") - , test "rejects invalid character in digits" <| - \() -> Expect.equal Nothing (largestProduct 2 "1234a5") - , test "rejects negative span" <| - \() -> Expect.equal Nothing (largestProduct -1 "12345") + , skip <| + test "can find the largest product of 2" <| + \() -> Expect.equal (Just 48) (largestProduct 2 "576802143") + , skip <| + test "finds the largest product if span equals length" <| + \() -> Expect.equal (Just 18) (largestProduct 2 "29") + , skip <| + test "can find the largest product of 3 with numbers in order" <| + \() -> Expect.equal (Just 504) (largestProduct 3 "0123456789") + , skip <| + test "can find the largest product of 3" <| + \() -> Expect.equal (Just 270) (largestProduct 3 "1027839564") + , skip <| + test "can find the largest product of 5 with numbers in order" <| + \() -> Expect.equal (Just 15120) (largestProduct 5 "0123456789") + , skip <| + test "can get the largest product of a big number" <| + \() -> Expect.equal (Just 23520) (largestProduct 6 "73167176531330624919225119674426574742355349194934") + , skip <| + test "can get the largest product of a big number II" <| + \() -> Expect.equal (Just 28350) (largestProduct 6 "52677741234314237566414902593461595376319419139427") + , skip <| + test "can get the largest product of a big number (Project Euler)" <| + \() -> Expect.equal (Just 23514624000) (largestProduct 13 "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450") + , skip <| + test "reports zero if the only digits are zero" <| + \() -> Expect.equal (Just 0) (largestProduct 2 "0000") + , skip <| + test "reports zero if all spans include zero" <| + \() -> Expect.equal (Just 0) (largestProduct 3 "99099") + , skip <| + test "rejects span longer than string length" <| + \() -> Expect.equal Nothing (largestProduct 4 "123") + , skip <| + test "reports 1 for empty string and empty product (0 span)" <| + \() -> Expect.equal (Just 1) (largestProduct 0 "") + , skip <| + test "reports 1 for nonempty string and empty product (0 span)" <| + \() -> Expect.equal (Just 1) (largestProduct 0 "123") + , skip <| + test "rejects empty string and nonzero span" <| + \() -> Expect.equal Nothing (largestProduct 1 "") + , skip <| + test "rejects invalid character in digits" <| + \() -> Expect.equal Nothing (largestProduct 2 "1234a5") + , skip <| + test "rejects negative span" <| + \() -> Expect.equal Nothing (largestProduct -1 "12345") ] diff --git a/exercises/leap/tests/Tests.elm b/exercises/leap/tests/Tests.elm index 1e4b7cf..b0c39f3 100644 --- a/exercises/leap/tests/Tests.elm +++ b/exercises/leap/tests/Tests.elm @@ -10,16 +10,22 @@ tests = describe "Leap" [ test "leap year" <| \() -> Expect.equal True (Leap.isLeapYear 1996) - , test "non-leap year" <| - \() -> Expect.equal False (Leap.isLeapYear 1997) - , test "non-leap even year" <| - \() -> Expect.equal False (Leap.isLeapYear 1998) - , test "century" <| - \() -> Expect.equal False (Leap.isLeapYear 1900) - , test "second century" <| - \() -> Expect.equal False (Leap.isLeapYear 1800) - , test "fourth century" <| - \() -> Expect.equal True (Leap.isLeapYear 2400) - , test "y2k" <| - \() -> Expect.equal True (Leap.isLeapYear 2000) + , skip <| + test "non-leap year" <| + \() -> Expect.equal False (Leap.isLeapYear 1997) + , skip <| + test "non-leap even year" <| + \() -> Expect.equal False (Leap.isLeapYear 1998) + , skip <| + test "century" <| + \() -> Expect.equal False (Leap.isLeapYear 1900) + , skip <| + test "second century" <| + \() -> Expect.equal False (Leap.isLeapYear 1800) + , skip <| + test "fourth century" <| + \() -> Expect.equal True (Leap.isLeapYear 2400) + , skip <| + test "y2k" <| + \() -> Expect.equal True (Leap.isLeapYear 2000) ] diff --git a/exercises/list-ops/tests/Tests.elm b/exercises/list-ops/tests/Tests.elm index f01b561..198bd19 100644 --- a/exercises/list-ops/tests/Tests.elm +++ b/exercises/list-ops/tests/Tests.elm @@ -11,57 +11,76 @@ tests = [ describe "length" [ test "empty list" <| \() -> Expect.equal 0 (ListOps.length []) - , test "non-empty list" <| - \() -> Expect.equal 4 (ListOps.length (List.range 1 4)) + , skip <| + test "non-empty list" <| + \() -> Expect.equal 4 (ListOps.length (List.range 1 4)) ] , describe "reverse" - [ test "empty list" <| - \() -> Expect.equal [] (ListOps.reverse []) - , test "non-empty list" <| - \() -> Expect.equal [ 4, 3, 2, 1 ] (ListOps.reverse (List.range 1 4)) + [ skip <| + test "empty list" <| + \() -> Expect.equal [] (ListOps.reverse []) + , skip <| + test "non-empty list" <| + \() -> Expect.equal [ 4, 3, 2, 1 ] (ListOps.reverse (List.range 1 4)) ] , describe "map" - [ test "empty list" <| - \() -> Expect.equal [] (ListOps.map ((+) 1) []) - , test "non-empty list" <| - \() -> Expect.equal (List.range 2 5) (ListOps.map ((+) 1) (List.range 1 4)) + [ skip <| + test "empty list" <| + \() -> Expect.equal [] (ListOps.map ((+) 1) []) + , skip <| + test "non-empty list" <| + \() -> Expect.equal (List.range 2 5) (ListOps.map ((+) 1) (List.range 1 4)) ] , describe "filter" - [ test "empty list" <| - \() -> Expect.equal [] (ListOps.filter (\_ -> True) []) - , test "non-empty list" <| - \() -> Expect.equal [ 2, 4 ] (ListOps.filter (\x -> x % 2 == 0) (List.range 1 4)) + [ skip <| + test "empty list" <| + \() -> Expect.equal [] (ListOps.filter (\_ -> True) []) + , skip <| + test "non-empty list" <| + \() -> Expect.equal [ 2, 4 ] (ListOps.filter (\x -> x % 2 == 0) (List.range 1 4)) ] , describe "foldl" - [ test "empty list" <| - \() -> Expect.equal 0 (ListOps.foldl (+) 0 []) - , test "non-empty list" <| - \() -> Expect.equal 10 (ListOps.foldl (+) 0 (List.range 1 4)) - , test "direction" <| - \() -> Expect.equal [ 4, 3, 2, 1 ] (ListOps.foldl (::) [] (List.range 1 4)) + [ skip <| + test "empty list" <| + \() -> Expect.equal 0 (ListOps.foldl (+) 0 []) + , skip <| + test "non-empty list" <| + \() -> Expect.equal 10 (ListOps.foldl (+) 0 (List.range 1 4)) + , skip <| + test "direction" <| + \() -> Expect.equal [ 4, 3, 2, 1 ] (ListOps.foldl (::) [] (List.range 1 4)) ] , describe "foldr" - [ test "empty list" <| - \() -> Expect.equal 0 (ListOps.foldr (+) 0 []) - , test "non-empty list" <| - \() -> Expect.equal 10 (ListOps.foldr (+) 0 (List.range 1 4)) - , test "direction" <| - \() -> Expect.equal (List.range 1 4) (ListOps.foldr (::) [] (List.range 1 4)) + [ skip <| + test "empty list" <| + \() -> Expect.equal 0 (ListOps.foldr (+) 0 []) + , skip <| + test "non-empty list" <| + \() -> Expect.equal 10 (ListOps.foldr (+) 0 (List.range 1 4)) + , skip <| + test "direction" <| + \() -> Expect.equal (List.range 1 4) (ListOps.foldr (::) [] (List.range 1 4)) ] , describe "append" - [ test "empty lists" <| - \() -> Expect.equal [] (ListOps.append [] []) - , test "empty and non-empty lists" <| - \() -> Expect.equal (List.range 1 4) (ListOps.append [] (List.range 1 4)) - , test "non-empty and empty lists" <| - \() -> Expect.equal (List.range 1 4) (ListOps.append (List.range 1 4) []) - , test "non-empty lists" <| - \() -> Expect.equal (List.range 1 8) (ListOps.append (List.range 1 4) (List.range 5 8)) + [ skip <| + test "empty lists" <| + \() -> Expect.equal [] (ListOps.append [] []) + , skip <| + test "empty and non-empty lists" <| + \() -> Expect.equal (List.range 1 4) (ListOps.append [] (List.range 1 4)) + , skip <| + test "non-empty and empty lists" <| + \() -> Expect.equal (List.range 1 4) (ListOps.append (List.range 1 4) []) + , skip <| + test "non-empty lists" <| + \() -> Expect.equal (List.range 1 8) (ListOps.append (List.range 1 4) (List.range 5 8)) ] , describe "concat" - [ test "empty list" <| - \() -> Expect.equal [] (ListOps.concat []) - , test "list of lists" <| - \() -> Expect.equal (List.range 1 10) (ListOps.concat [ List.range 1 3, [], List.range 4 7, List.range 8 10 ]) + [ skip <| + test "empty list" <| + \() -> Expect.equal [] (ListOps.concat []) + , skip <| + test "list of lists" <| + \() -> Expect.equal (List.range 1 10) (ListOps.concat [ List.range 1 3, [], List.range 4 7, List.range 8 10 ]) ] ] diff --git a/exercises/nucleotide-count/tests/Tests.elm b/exercises/nucleotide-count/tests/Tests.elm index bb19367..89490ab 100644 --- a/exercises/nucleotide-count/tests/Tests.elm +++ b/exercises/nucleotide-count/tests/Tests.elm @@ -10,16 +10,19 @@ tests = describe "NucleotideCount" [ test "the solution is for the correct version of the test" <| \() -> Expect.equal 2 version - , test "empty dna strand has no nucleotides" <| - \() -> - Expect.equal { a = 0, t = 0, c = 0, g = 0 } - (nucleotideCounts "") - , test "repetitive sequence has only guanine" <| - \() -> - Expect.equal { a = 0, t = 0, c = 0, g = 8 } - (nucleotideCounts "GGGGGGGG") - , test "counts all nucleotides" <| - \() -> - Expect.equal { a = 20, t = 21, c = 12, g = 17 } - (nucleotideCounts "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC") + , skip <| + test "empty dna strand has no nucleotides" <| + \() -> + Expect.equal { a = 0, t = 0, c = 0, g = 0 } + (nucleotideCounts "") + , skip <| + test "repetitive sequence has only guanine" <| + \() -> + Expect.equal { a = 0, t = 0, c = 0, g = 8 } + (nucleotideCounts "GGGGGGGG") + , skip <| + test "counts all nucleotides" <| + \() -> + Expect.equal { a = 20, t = 21, c = 12, g = 17 } + (nucleotideCounts "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC") ] diff --git a/exercises/pangram/tests/Tests.elm b/exercises/pangram/tests/Tests.elm index 81825c6..adfb995 100644 --- a/exercises/pangram/tests/Tests.elm +++ b/exercises/pangram/tests/Tests.elm @@ -12,40 +12,49 @@ tests = \() -> Expect.equal False (isPangram "") - , test "pangram with only lower case" <| - \() -> - Expect.equal True - (isPangram "the quick brown fox jumps over the lazy dog") - , test "missing character 'x'" <| - \() -> - Expect.equal False - (isPangram "a quick movement of the enemy will jeopardize five gunboats") - , test "missing character 'z'" <| - \() -> - Expect.equal False - (isPangram "a quick movement of the enemy will jeopardixe five gunboats") - , test "another missing character 'x'" <| - \() -> - Expect.equal False - (isPangram "the quick brown fish jumps over the lazy dog") - , test "pangram with underscores" <| - \() -> - Expect.equal True - (isPangram "the_quick_brown_fox_jumps_over_the_lazy_dog") - , test "pangram with numbers" <| - \() -> - Expect.equal True - (isPangram "the 1 quick brown fox jumps over the 2 lazy dogs") - , test "missing letters replaced by numbers" <| - \() -> - Expect.equal False - (isPangram "7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog") - , test "pangram with mixed case and punctuation" <| - \() -> - Expect.equal True - (isPangram "\"Five quacking Zephyrs jolt my wax bed.\"") - , test "pangram with non ascii characters" <| - \() -> - Expect.equal True - (isPangram "Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich.") + , skip <| + test "pangram with only lower case" <| + \() -> + Expect.equal True + (isPangram "the quick brown fox jumps over the lazy dog") + , skip <| + test "missing character 'x'" <| + \() -> + Expect.equal False + (isPangram "a quick movement of the enemy will jeopardize five gunboats") + , skip <| + test "missing character 'z'" <| + \() -> + Expect.equal False + (isPangram "a quick movement of the enemy will jeopardixe five gunboats") + , skip <| + test "another missing character 'x'" <| + \() -> + Expect.equal False + (isPangram "the quick brown fish jumps over the lazy dog") + , skip <| + test "pangram with underscores" <| + \() -> + Expect.equal True + (isPangram "the_quick_brown_fox_jumps_over_the_lazy_dog") + , skip <| + test "pangram with numbers" <| + \() -> + Expect.equal True + (isPangram "the 1 quick brown fox jumps over the 2 lazy dogs") + , skip <| + test "missing letters replaced by numbers" <| + \() -> + Expect.equal False + (isPangram "7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog") + , skip <| + test "pangram with mixed case and punctuation" <| + \() -> + Expect.equal True + (isPangram "\"Five quacking Zephyrs jolt my wax bed.\"") + , skip <| + test "pangram with non ascii characters" <| + \() -> + Expect.equal True + (isPangram "Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich.") ] diff --git a/exercises/phone-number/tests/Tests.elm b/exercises/phone-number/tests/Tests.elm index bd4020d..56d1aee 100644 --- a/exercises/phone-number/tests/Tests.elm +++ b/exercises/phone-number/tests/Tests.elm @@ -10,26 +10,37 @@ tests = describe "PhoneNumber" [ test "cleans number" <| \() -> Expect.equal (Just "1234567890") (getNumber "(123) 456-7890") - , test "cleans number with dots" <| - \() -> Expect.equal (Just "1234567890") (getNumber "123.456.7890") - , test "valid when 11 digits and first is 1" <| - \() -> Expect.equal (Just "1234567890") (getNumber "11234567890") - , test "invalid when 11 digits" <| - \() -> Expect.equal Nothing (getNumber "21234567890") - , test "invalid when 9 digits" <| - \() -> Expect.equal Nothing (getNumber "123456789") - , test "invalid when 12 digits" <| - \() -> Expect.equal Nothing (getNumber "123456789012") - , test "invalid when empty" <| - \() -> Expect.equal Nothing (getNumber "") - , test "invalid when no digits present" <| - \() -> Expect.equal Nothing (getNumber " (-) ") - , test "valid with leading characters" <| - \() -> Expect.equal (Just "1234567890") (getNumber "my number is 123 456 7890") - , test "valid with trailing characters" <| - \() -> Expect.equal (Just "1234567890") (getNumber "123 456 7890 - bob") - , test "pretty print" <| - \() -> Expect.equal (Just "(123) 456-7890") (prettyPrint "1234567890") - , test "pretty print with full us phone number" <| - \() -> Expect.equal (Just "(123) 456-7890") (prettyPrint "11234567890") + , skip <| + test "cleans number with dots" <| + \() -> Expect.equal (Just "1234567890") (getNumber "123.456.7890") + , skip <| + test "valid when 11 digits and first is 1" <| + \() -> Expect.equal (Just "1234567890") (getNumber "11234567890") + , skip <| + test "invalid when 11 digits" <| + \() -> Expect.equal Nothing (getNumber "21234567890") + , skip <| + test "invalid when 9 digits" <| + \() -> Expect.equal Nothing (getNumber "123456789") + , skip <| + test "invalid when 12 digits" <| + \() -> Expect.equal Nothing (getNumber "123456789012") + , skip <| + test "invalid when empty" <| + \() -> Expect.equal Nothing (getNumber "") + , skip <| + test "invalid when no digits present" <| + \() -> Expect.equal Nothing (getNumber " (-) ") + , skip <| + test "valid with leading characters" <| + \() -> Expect.equal (Just "1234567890") (getNumber "my number is 123 456 7890") + , skip <| + test "valid with trailing characters" <| + \() -> Expect.equal (Just "1234567890") (getNumber "123 456 7890 - bob") + , skip <| + test "pretty print" <| + \() -> Expect.equal (Just "(123) 456-7890") (prettyPrint "1234567890") + , skip <| + test "pretty print with full us phone number" <| + \() -> Expect.equal (Just "(123) 456-7890") (prettyPrint "11234567890") ] diff --git a/exercises/raindrops/tests/Tests.elm b/exercises/raindrops/tests/Tests.elm index fd72720..effc878 100644 --- a/exercises/raindrops/tests/Tests.elm +++ b/exercises/raindrops/tests/Tests.elm @@ -10,32 +10,46 @@ tests = describe "Raindrops" [ test "1" <| \() -> Expect.equal "1" (raindrops 1) - , test "3" <| - \() -> Expect.equal "Pling" (raindrops 3) - , test "5" <| - \() -> Expect.equal "Plang" (raindrops 5) - , test "7" <| - \() -> Expect.equal "Plong" (raindrops 7) - , test "6" <| - \() -> Expect.equal "Pling" (raindrops 6) - , test "9" <| - \() -> Expect.equal "Pling" (raindrops 9) - , test "10" <| - \() -> Expect.equal "Plang" (raindrops 10) - , test "14" <| - \() -> Expect.equal "Plong" (raindrops 14) - , test "15" <| - \() -> Expect.equal "PlingPlang" (raindrops 15) - , test "21" <| - \() -> Expect.equal "PlingPlong" (raindrops 21) - , test "25" <| - \() -> Expect.equal "Plang" (raindrops 25) - , test "35" <| - \() -> Expect.equal "PlangPlong" (raindrops 35) - , test "49" <| - \() -> Expect.equal "Plong" (raindrops 49) - , test "52" <| - \() -> Expect.equal "52" (raindrops 52) - , test "105" <| - \() -> Expect.equal "PlingPlangPlong" (raindrops 105) + , skip <| + test "3" <| + \() -> Expect.equal "Pling" (raindrops 3) + , skip <| + test "5" <| + \() -> Expect.equal "Plang" (raindrops 5) + , skip <| + test "7" <| + \() -> Expect.equal "Plong" (raindrops 7) + , skip <| + test "6" <| + \() -> Expect.equal "Pling" (raindrops 6) + , skip <| + test "9" <| + \() -> Expect.equal "Pling" (raindrops 9) + , skip <| + test "10" <| + \() -> Expect.equal "Plang" (raindrops 10) + , skip <| + test "14" <| + \() -> Expect.equal "Plong" (raindrops 14) + , skip <| + test "15" <| + \() -> Expect.equal "PlingPlang" (raindrops 15) + , skip <| + test "21" <| + \() -> Expect.equal "PlingPlong" (raindrops 21) + , skip <| + test "25" <| + \() -> Expect.equal "Plang" (raindrops 25) + , skip <| + test "35" <| + \() -> Expect.equal "PlangPlong" (raindrops 35) + , skip <| + test "49" <| + \() -> Expect.equal "Plong" (raindrops 49) + , skip <| + test "52" <| + \() -> Expect.equal "52" (raindrops 52) + , skip <| + test "105" <| + \() -> Expect.equal "PlingPlangPlong" (raindrops 105) ] diff --git a/exercises/rna-transcription/tests/Tests.elm b/exercises/rna-transcription/tests/Tests.elm index 14dcf24..e14addf 100644 --- a/exercises/rna-transcription/tests/Tests.elm +++ b/exercises/rna-transcription/tests/Tests.elm @@ -10,16 +10,22 @@ tests = describe "RNATranscription" [ test "complement of cytosine is guanine" <| \() -> Expect.equal (Ok "G") (toRNA "C") - , test "complement of guanine is cytosine" <| - \() -> Expect.equal (Ok "C") (toRNA "G") - , test "complement of thymine is adenine" <| - \() -> Expect.equal (Ok "A") (toRNA "T") - , test "complement of adenine is uracil" <| - \() -> Expect.equal (Ok "U") (toRNA "A") - , test "complement" <| - \() -> Expect.equal (Ok "UGCACCAGAAUU") (toRNA "ACGTGGTCTTAA") - , test "correctly handles completely invalid input" <| - \() -> Expect.equal (Err 'X') (toRNA "XXX") - , test "correctly handles partially invalid input" <| - \() -> Expect.equal (Err 'U') (toRNA "UGAAXXXGACAUG") + , skip <| + test "complement of guanine is cytosine" <| + \() -> Expect.equal (Ok "C") (toRNA "G") + , skip <| + test "complement of thymine is adenine" <| + \() -> Expect.equal (Ok "A") (toRNA "T") + , skip <| + test "complement of adenine is uracil" <| + \() -> Expect.equal (Ok "U") (toRNA "A") + , skip <| + test "complement" <| + \() -> Expect.equal (Ok "UGCACCAGAAUU") (toRNA "ACGTGGTCTTAA") + , skip <| + test "correctly handles completely invalid input" <| + \() -> Expect.equal (Err 'X') (toRNA "XXX") + , skip <| + test "correctly handles partially invalid input" <| + \() -> Expect.equal (Err 'U') (toRNA "UGAAXXXGACAUG") ] diff --git a/exercises/robot-simulator/tests/Tests.elm b/exercises/robot-simulator/tests/Tests.elm index 864413d..1558738 100644 --- a/exercises/robot-simulator/tests/Tests.elm +++ b/exercises/robot-simulator/tests/Tests.elm @@ -15,8 +15,9 @@ tests = in [ test "coordinates" <| \() -> Expect.equal { x = 0, y = 0 } robot.coordinates - , test "bearing" <| - \() -> Expect.equal North robot.bearing + , skip <| + test "bearing" <| + \() -> Expect.equal North robot.bearing ] ) , describe "setup" @@ -24,10 +25,12 @@ tests = robot = Robot South { x = -1, y = 1 } in - [ test "coordinates" <| - \() -> Expect.equal { x = -1, y = 1 } robot.coordinates - , test "bearing" <| - \() -> Expect.equal South robot.bearing + [ skip <| + test "coordinates" <| + \() -> Expect.equal { x = -1, y = 1 } robot.coordinates + , skip <| + test "bearing" <| + \() -> Expect.equal South robot.bearing ] ) , describe "turn right" @@ -35,7 +38,7 @@ tests = |> List.scanl (\_ r -> turnRight r) defaultRobot |> List.map .bearing |> assertionList [ North, East, South, West ] - |> List.indexedMap (\i e -> test ("step " ++ toString i) (\() -> e)) + |> List.indexedMap (\i e -> skip <| test ("step " ++ toString i) (\() -> e)) ) , describe "turn left" @@ -43,7 +46,7 @@ tests = |> List.scanl (\_ r -> turnLeft r) defaultRobot |> List.map .bearing |> assertionList [ North, West, South, East ] - |> List.indexedMap (\i e -> test ("step " ++ toString i) (\() -> e)) + |> List.indexedMap (\i e -> skip <| test ("step " ++ toString i) (\() -> e)) ) , describe "advance positive north" (let @@ -51,10 +54,12 @@ tests = Robot North { x = 0, y = 0 } |> advance in - [ test "coordinates" <| - \() -> Expect.equal { x = 0, y = 1 } robot.coordinates - , test "bearing" <| - \() -> Expect.equal North robot.bearing + [ skip <| + test "coordinates" <| + \() -> Expect.equal { x = 0, y = 1 } robot.coordinates + , skip <| + test "bearing" <| + \() -> Expect.equal North robot.bearing ] ) , describe "advance positive east" @@ -63,10 +68,12 @@ tests = Robot East { x = 0, y = 0 } |> advance in - [ test "coordinates" <| - \() -> Expect.equal { x = 1, y = 0 } robot.coordinates - , test "bearing" <| - \() -> Expect.equal East robot.bearing + [ skip <| + test "coordinates" <| + \() -> Expect.equal { x = 1, y = 0 } robot.coordinates + , skip <| + test "bearing" <| + \() -> Expect.equal East robot.bearing ] ) , describe "advance negative south" @@ -75,10 +82,12 @@ tests = Robot South { x = 0, y = 0 } |> advance in - [ test "coordinates" <| - \() -> Expect.equal { x = 0, y = -1 } robot.coordinates - , test "bearing" <| - \() -> Expect.equal South robot.bearing + [ skip <| + test "coordinates" <| + \() -> Expect.equal { x = 0, y = -1 } robot.coordinates + , skip <| + test "bearing" <| + \() -> Expect.equal South robot.bearing ] ) , describe "advance positive west" @@ -87,10 +96,12 @@ tests = Robot West { x = 0, y = 0 } |> advance in - [ test "coordinates" <| - \() -> Expect.equal { x = -1, y = 0 } robot.coordinates - , test "bearing" <| - \() -> Expect.equal West robot.bearing + [ skip <| + test "coordinates" <| + \() -> Expect.equal { x = -1, y = 0 } robot.coordinates + , skip <| + test "bearing" <| + \() -> Expect.equal West robot.bearing ] ) , describe "simulate prog 1" @@ -99,10 +110,12 @@ tests = Robot North { x = 0, y = 0 } |> simulate "LAAARALA" in - [ test "coordinates" <| - \() -> Expect.equal { x = -4, y = 1 } robot.coordinates - , test "bearing" <| - \() -> Expect.equal West robot.bearing + [ skip <| + test "coordinates" <| + \() -> Expect.equal { x = -4, y = 1 } robot.coordinates + , skip <| + test "bearing" <| + \() -> Expect.equal West robot.bearing ] ) , describe "simulate prog 2" @@ -111,8 +124,9 @@ tests = Robot East { x = 2, y = -7 } |> simulate "RRAAAAALA" in - [ test "coordinates" <| - \() -> Expect.equal { x = -3, y = -8 } robot.coordinates + [ skip <| + test "coordinates" <| + \() -> Expect.equal { x = -3, y = -8 } robot.coordinates , test "bearing" <| \() -> Expect.equal South robot.bearing ] @@ -123,10 +137,12 @@ tests = Robot South { x = 8, y = 4 } |> simulate "LAAARRRALLLL" in - [ test "coordinates" <| - \() -> Expect.equal { x = 11, y = 5 } robot.coordinates - , test "bearing" <| - \() -> Expect.equal North robot.bearing + [ skip <| + test "coordinates" <| + \() -> Expect.equal { x = 11, y = 5 } robot.coordinates + , skip <| + test "bearing" <| + \() -> Expect.equal North robot.bearing ] ) ] diff --git a/exercises/roman-numerals/tests/Tests.elm b/exercises/roman-numerals/tests/Tests.elm index 5ca51a3..3429baa 100644 --- a/exercises/roman-numerals/tests/Tests.elm +++ b/exercises/roman-numerals/tests/Tests.elm @@ -12,72 +12,89 @@ tests = \() -> Expect.equal ("I") (toRoman 1) - , test "2" <| - \() -> - Expect.equal ("II") - (toRoman 2) - , test "3" <| - \() -> - Expect.equal ("III") - (toRoman 3) - , test "4" <| - \() -> - Expect.equal ("IV") - (toRoman 4) - , test "5" <| - \() -> - Expect.equal ("V") - (toRoman 5) - , test "6" <| - \() -> - Expect.equal ("VI") - (toRoman 6) - , test "9" <| - \() -> - Expect.equal ("IX") - (toRoman 9) - , test "27" <| - \() -> - Expect.equal ("XXVII") - (toRoman 27) - , test "48" <| - \() -> - Expect.equal ("XLVIII") - (toRoman 48) - , test "59" <| - \() -> - Expect.equal ("LIX") - (toRoman 59) - , test "93" <| - \() -> - Expect.equal ("XCIII") - (toRoman 93) - , test "141" <| - \() -> - Expect.equal ("CXLI") - (toRoman 141) - , test "163" <| - \() -> - Expect.equal ("CLXIII") - (toRoman 163) - , test "402" <| - \() -> - Expect.equal ("CDII") - (toRoman 402) - , test "575" <| - \() -> - Expect.equal ("DLXXV") - (toRoman 575) - , test "911" <| - \() -> - Expect.equal ("CMXI") - (toRoman 911) - , test "1024" <| - \() -> - Expect.equal ("MXXIV") - (toRoman 1024) - , test "3000" <| - \() -> - Expect.equal ("MMM") - (toRoman 3000) + , skip <| + test "2" <| + \() -> + Expect.equal ("II") + (toRoman 2) + , skip <| + test "3" <| + \() -> + Expect.equal ("III") + (toRoman 3) + , skip <| + test "4" <| + \() -> + Expect.equal ("IV") + (toRoman 4) + , skip <| + test "5" <| + \() -> + Expect.equal ("V") + (toRoman 5) + , skip <| + test "6" <| + \() -> + Expect.equal ("VI") + (toRoman 6) + , skip <| + test "9" <| + \() -> + Expect.equal ("IX") + (toRoman 9) + , skip <| + test "27" <| + \() -> + Expect.equal ("XXVII") + (toRoman 27) + , skip <| + test "48" <| + \() -> + Expect.equal ("XLVIII") + (toRoman 48) + , skip <| + test "59" <| + \() -> + Expect.equal ("LIX") + (toRoman 59) + , skip <| + test "93" <| + \() -> + Expect.equal ("XCIII") + (toRoman 93) + , skip <| + test "141" <| + \() -> + Expect.equal ("CXLI") + (toRoman 141) + , skip <| + test "163" <| + \() -> + Expect.equal ("CLXIII") + (toRoman 163) + , skip <| + test "402" <| + \() -> + Expect.equal ("CDII") + (toRoman 402) + , skip <| + test "575" <| + \() -> + Expect.equal ("DLXXV") + (toRoman 575) + , skip <| + test "911" <| + \() -> + Expect.equal ("CMXI") + (toRoman 911) + , skip <| + test "1024" <| + \() -> + Expect.equal ("MXXIV") + (toRoman 1024) + , skip <| + test "3000" <| + \() -> + Expect.equal ("MMM") + (toRoman 3000) ] diff --git a/exercises/run-length-encoding/tests/Tests.elm b/exercises/run-length-encoding/tests/Tests.elm index 2424a60..8c77b18 100644 --- a/exercises/run-length-encoding/tests/Tests.elm +++ b/exercises/run-length-encoding/tests/Tests.elm @@ -10,28 +10,36 @@ tests = describe "RunLengthEncoding" [ test "the solution is for the correct version of the test" <| \() -> Expect.equal 2 version - , test "encode simple" <| - \() -> Expect.equal "2A3B4C" (encode "AABBBCCCC") - , test "decode simple" <| - \() -> Expect.equal "AABBBCCCC" (decode "2A3B4C") - , test "encode with single values" <| - \() -> - Expect.equal "12WB12W3B24WB" - (encode "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB") - , test "decode with single values" <| - \() -> - Expect.equal "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB" - (decode "12WB12W3B24WB") - , test "(decode (encode (...)) combination" <| - \() -> - Expect.equal "zzz ZZ zZ" - (decode (encode "zzz ZZ zZ")) - , test "decode with a x10 value" <| - \() -> - Expect.equal "WWWWWWWWWW" - (decode "10W") - , test "encode unicode" <| - \() -> Expect.equal "⏰3⚽2⭐⏰" (encode "⏰⚽⚽⚽⭐⭐⏰") - , test "decode unicode" <| - \() -> Expect.equal "⏰⚽⚽⚽⭐⭐⏰" (decode "⏰3⚽2⭐⏰") + , skip <| + test "encode simple" <| + \() -> Expect.equal "2A3B4C" (encode "AABBBCCCC") + , skip <| + test "decode simple" <| + \() -> Expect.equal "AABBBCCCC" (decode "2A3B4C") + , skip <| + test "encode with single values" <| + \() -> + Expect.equal "12WB12W3B24WB" + (encode "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB") + , skip <| + test "decode with single values" <| + \() -> + Expect.equal "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB" + (decode "12WB12W3B24WB") + , skip <| + test "(decode (encode (...)) combination" <| + \() -> + Expect.equal "zzz ZZ zZ" + (decode (encode "zzz ZZ zZ")) + , skip <| + test "decode with a x10 value" <| + \() -> + Expect.equal "WWWWWWWWWW" + (decode "10W") + , skip <| + test "encode unicode" <| + \() -> Expect.equal "⏰3⚽2⭐⏰" (encode "⏰⚽⚽⚽⭐⭐⏰") + , skip <| + test "decode unicode" <| + \() -> Expect.equal "⏰⚽⚽⚽⭐⭐⏰" (decode "⏰3⚽2⭐⏰") ] diff --git a/exercises/say/tests/Tests.elm b/exercises/say/tests/Tests.elm index 9204a33..e5abb73 100644 --- a/exercises/say/tests/Tests.elm +++ b/exercises/say/tests/Tests.elm @@ -12,75 +12,91 @@ tests = \() -> Expect.equal (Ok "one") (say 1) - , test "fourteen" <| - \() -> - Expect.equal (Ok "fourteen") - (say 14) - , test "twenty" <| - \() -> - Expect.equal (Ok "twenty") - (say 20) - , test "twenty-two" <| - \() -> - Expect.equal (Ok "twenty-two") - (say 22) - , test "one hundred" <| - \() -> - Expect.equal (Ok "one hundred") - (say 100) - , test "one hundred twenty" <| - \() -> - Expect.equal (Ok "one hundred and twenty") - (say 120) - , test "one hundred twenty-three" <| - \() -> - Expect.equal (Ok "one hundred and twenty-three") - (say 123) - , test "one thousand" <| - \() -> - Expect.equal (Ok "one thousand") - (say 1000) - , test "one thousand two hundred thirty-four" <| - \() -> - Expect.equal (Ok "one thousand two hundred and thirty-four") - (say 1234) - , test "one million" <| - \() -> - Expect.equal (Ok "one million") - (say 1000000) - , test "one million two" <| - \() -> - Expect.equal (Ok "one million and two") - (say 1000002) - , test "1002345" <| - \() -> - Expect.equal (Ok "one million two thousand three hundred and forty-five") - (say 1002345) - , test "one billion" <| - \() -> - Expect.equal (Ok "one billion") - (say 1000000000) - , test "number too large" <| - \() -> - Expect.equal (Err TooLarge) - (say 10000000000000000) - , test "negative number" <| - \() -> - Expect.equal (Err Negative) - (say -42) - , test "zero" <| - \() -> - Expect.equal (Ok "zero") - (say 0) - , test "987654321123" <| - \() -> - Expect.equal - (Ok - ("nine hundred and eighty-seven billion " - ++ "six hundred and fifty-four million " - ++ "three hundred and twenty-one thousand " - ++ "one hundred and twenty-three" + , skip <| + test "fourteen" <| + \() -> + Expect.equal (Ok "fourteen") + (say 14) + , skip <| + test "twenty" <| + \() -> + Expect.equal (Ok "twenty") + (say 20) + , skip <| + test "twenty-two" <| + \() -> + Expect.equal (Ok "twenty-two") + (say 22) + , skip <| + test "one hundred" <| + \() -> + Expect.equal (Ok "one hundred") + (say 100) + , skip <| + test "one hundred twenty" <| + \() -> + Expect.equal (Ok "one hundred and twenty") + (say 120) + , skip <| + test "one hundred twenty-three" <| + \() -> + Expect.equal (Ok "one hundred and twenty-three") + (say 123) + , skip <| + test "one thousand" <| + \() -> + Expect.equal (Ok "one thousand") + (say 1000) + , skip <| + test "one thousand two hundred thirty-four" <| + \() -> + Expect.equal (Ok "one thousand two hundred and thirty-four") + (say 1234) + , skip <| + test "one million" <| + \() -> + Expect.equal (Ok "one million") + (say 1000000) + , skip <| + test "one million two" <| + \() -> + Expect.equal (Ok "one million and two") + (say 1000002) + , skip <| + test "1002345" <| + \() -> + Expect.equal (Ok "one million two thousand three hundred and forty-five") + (say 1002345) + , skip <| + test "one billion" <| + \() -> + Expect.equal (Ok "one billion") + (say 1000000000) + , skip <| + test "number too large" <| + \() -> + Expect.equal (Err TooLarge) + (say 10000000000000000) + , skip <| + test "negative number" <| + \() -> + Expect.equal (Err Negative) + (say -42) + , skip <| + test "zero" <| + \() -> + Expect.equal (Ok "zero") + (say 0) + , skip <| + test "987654321123" <| + \() -> + Expect.equal + (Ok + ("nine hundred and eighty-seven billion " + ++ "six hundred and fifty-four million " + ++ "three hundred and twenty-one thousand " + ++ "one hundred and twenty-three" + ) ) - ) - (say 987654321123) + (say 987654321123) ] diff --git a/exercises/scrabble-score/tests/Tests.elm b/exercises/scrabble-score/tests/Tests.elm index 8e3e5b0..a3fab36 100644 --- a/exercises/scrabble-score/tests/Tests.elm +++ b/exercises/scrabble-score/tests/Tests.elm @@ -10,24 +10,34 @@ tests = describe "Grains" [ test "lowercase letter" <| \() -> Expect.equal 1 (scoreWord "a") - , test "uppercase letter" <| - \() -> Expect.equal 1 (scoreWord "A") - , test "valuable letter" <| - \() -> Expect.equal 4 (scoreWord "f") - , test "short word" <| - \() -> Expect.equal 2 (scoreWord "at") - , test "short, valuable word" <| - \() -> Expect.equal 12 (scoreWord "zoo") - , test "medium word" <| - \() -> Expect.equal 6 (scoreWord "street") - , test "medium, valuable word" <| - \() -> Expect.equal 22 (scoreWord "quirky") - , test "long, mixed-case word" <| - \() -> Expect.equal 41 (scoreWord "OxyphenButazone") - , test "english-like word" <| - \() -> Expect.equal 8 (scoreWord "pinata") - , test "non-english letter is not scored" <| - \() -> Expect.equal 7 (scoreWord "piñata") - , test "empty input" <| - \() -> Expect.equal 0 (scoreWord "") + , skip <| + test "uppercase letter" <| + \() -> Expect.equal 1 (scoreWord "A") + , skip <| + test "valuable letter" <| + \() -> Expect.equal 4 (scoreWord "f") + , skip <| + test "short word" <| + \() -> Expect.equal 2 (scoreWord "at") + , skip <| + test "short, valuable word" <| + \() -> Expect.equal 12 (scoreWord "zoo") + , skip <| + test "medium word" <| + \() -> Expect.equal 6 (scoreWord "street") + , skip <| + test "medium, valuable word" <| + \() -> Expect.equal 22 (scoreWord "quirky") + , skip <| + test "long, mixed-case word" <| + \() -> Expect.equal 41 (scoreWord "OxyphenButazone") + , skip <| + test "english-like word" <| + \() -> Expect.equal 8 (scoreWord "pinata") + , skip <| + test "non-english letter is not scored" <| + \() -> Expect.equal 7 (scoreWord "piñata") + , skip <| + test "empty input" <| + \() -> Expect.equal 0 (scoreWord "") ] diff --git a/exercises/series/tests/Tests.elm b/exercises/series/tests/Tests.elm index bbfa35e..7da27ab 100644 --- a/exercises/series/tests/Tests.elm +++ b/exercises/series/tests/Tests.elm @@ -12,32 +12,39 @@ tests = \() -> Expect.equal (Ok [ [ 0 ], [ 1 ], [ 2 ], [ 3 ], [ 4 ] ]) (slices 1 "01234") - , test "slices of two" <| - \() -> - Expect.equal (Ok [ [ 9, 7 ], [ 7, 8 ], [ 8, 6 ], [ 6, 7 ], [ 7, 5 ], [ 5, 6 ], [ 6, 4 ] ]) - (slices 2 "97867564") - , test "slices of three" <| - \() -> - Expect.equal (Ok [ [ 9, 7, 8 ], [ 7, 8, 6 ], [ 8, 6, 7 ], [ 6, 7, 5 ], [ 7, 5, 6 ], [ 5, 6, 4 ] ]) - (slices 3 "97867564") - , test "slices of four" <| - \() -> - Expect.equal (Ok [ [ 0, 1, 2, 3 ], [ 1, 2, 3, 4 ] ]) - (slices 4 "01234") - , test "slices of five" <| - \() -> - Expect.equal (Ok [ [ 0, 1, 2, 3, 4 ] ]) - (slices 5 "01234") - , test "overly long slice" <| - \() -> - Expect.equal (Ok []) - (slices 4 "012") - , test "overly short slice" <| - \() -> - Expect.equal (Err ("Invalid size: 0")) - (slices 0 "01234") - , test "input has non numbers" <| - \() -> - Expect.equal (Err "could not convert string 'a' to an Int") - (slices 2 "0123abc") + , skip <| + test "slices of two" <| + \() -> + Expect.equal (Ok [ [ 9, 7 ], [ 7, 8 ], [ 8, 6 ], [ 6, 7 ], [ 7, 5 ], [ 5, 6 ], [ 6, 4 ] ]) + (slices 2 "97867564") + , skip <| + test "slices of three" <| + \() -> + Expect.equal (Ok [ [ 9, 7, 8 ], [ 7, 8, 6 ], [ 8, 6, 7 ], [ 6, 7, 5 ], [ 7, 5, 6 ], [ 5, 6, 4 ] ]) + (slices 3 "97867564") + , skip <| + test "slices of four" <| + \() -> + Expect.equal (Ok [ [ 0, 1, 2, 3 ], [ 1, 2, 3, 4 ] ]) + (slices 4 "01234") + , skip <| + test "slices of five" <| + \() -> + Expect.equal (Ok [ [ 0, 1, 2, 3, 4 ] ]) + (slices 5 "01234") + , skip <| + test "overly long slice" <| + \() -> + Expect.equal (Ok []) + (slices 4 "012") + , skip <| + test "overly short slice" <| + \() -> + Expect.equal (Err ("Invalid size: 0")) + (slices 0 "01234") + , skip <| + test "input has non numbers" <| + \() -> + Expect.equal (Err "could not convert string 'a' to an Int") + (slices 2 "0123abc") ] diff --git a/exercises/space-age/tests/Tests.elm b/exercises/space-age/tests/Tests.elm index 4fd2aa4..6ead3b5 100644 --- a/exercises/space-age/tests/Tests.elm +++ b/exercises/space-age/tests/Tests.elm @@ -10,18 +10,25 @@ tests = describe "SpaceAge" [ test "age in earth years" <| \() -> Expect.equal 32 (round (ageOn Earth 1000000000)) - , test "age in mercury years" <| - \() -> Expect.equal 281 (round (ageOn Mercury 2134835688)) - , test "age in venus years" <| - \() -> Expect.equal 10 (round (ageOn Venus 189839836)) - , test "age on mars" <| - \() -> Expect.equal 39 (round (ageOn Mars 2329871239)) - , test "age on jupiter" <| - \() -> Expect.equal 2 (round (ageOn Jupiter 901876382)) - , test "age on saturn" <| - \() -> Expect.equal 3 (round (ageOn Saturn 3000000000)) - , test "age on uranus" <| - \() -> Expect.equal 1 (round (ageOn Uranus 3210123456)) - , test "age on neptune" <| - \() -> Expect.equal 2 (round (ageOn Neptune 8210123456)) + , skip <| + test "age in mercury years" <| + \() -> Expect.equal 281 (round (ageOn Mercury 2134835688)) + , skip <| + test "age in venus years" <| + \() -> Expect.equal 10 (round (ageOn Venus 189839836)) + , skip <| + test "age on mars" <| + \() -> Expect.equal 39 (round (ageOn Mars 2329871239)) + , skip <| + test "age on jupiter" <| + \() -> Expect.equal 2 (round (ageOn Jupiter 901876382)) + , skip <| + test "age on saturn" <| + \() -> Expect.equal 3 (round (ageOn Saturn 3000000000)) + , skip <| + test "age on uranus" <| + \() -> Expect.equal 1 (round (ageOn Uranus 3210123456)) + , skip <| + test "age on neptune" <| + \() -> Expect.equal 2 (round (ageOn Neptune 8210123456)) ] diff --git a/exercises/strain/tests/Tests.elm b/exercises/strain/tests/Tests.elm index 93a40c6..5012dac 100644 --- a/exercises/strain/tests/Tests.elm +++ b/exercises/strain/tests/Tests.elm @@ -33,48 +33,59 @@ tests = \() -> Expect.equal [] (keep lessThanTen []) - , test "keep everything" <| - \() -> - Expect.equal [ 1, 2, 3 ] - (keep lessThanTen [ 1, 2, 3 ]) - , test "keep first and last" <| - \() -> - Expect.equal [ 1, 3 ] - (keep odd [ 1, 2, 3 ]) - , test "keep nothing" <| - \() -> - Expect.equal [] - (keep even [ 1, 3, 5, 7 ]) - , test "keep neither first nor last" <| - \() -> - Expect.equal [ 2 ] - (keep even [ 1, 2, 3 ]) - , test "keep strings" <| - \() -> - Expect.equal [ "zebra", "zombies", "zealot" ] - (keep (isFirstLetter "z") [ "apple", "zebra", "banana", "zombies", "cherimoya", "zealot" ]) - , test "empty discard" <| - \() -> - Expect.equal [] - (discard lessThanTen []) - , test "discard everything" <| - \() -> - Expect.equal [] - (discard lessThanTen [ 1, 2, 3 ]) - , test "discard first and last" <| - \() -> - Expect.equal [ 2 ] - (discard odd [ 1, 2, 3 ]) - , test "discard nothing" <| - \() -> - Expect.equal [ 1, 3, 5, 7 ] - (discard even [ 1, 3, 5, 7 ]) - , test "discard neither first nor last" <| - \() -> - Expect.equal [ 1, 3 ] - (discard even [ 1, 2, 3 ]) - , test "discard strings" <| - \() -> - Expect.equal [ "apple", "banana", "cherimoya" ] - (discard (isFirstLetter "z") [ "apple", "zebra", "banana", "zombies", "cherimoya", "zealot" ]) + , skip <| + test "keep everything" <| + \() -> + Expect.equal [ 1, 2, 3 ] + (keep lessThanTen [ 1, 2, 3 ]) + , skip <| + test "keep first and last" <| + \() -> + Expect.equal [ 1, 3 ] + (keep odd [ 1, 2, 3 ]) + , skip <| + test "keep nothing" <| + \() -> + Expect.equal [] + (keep even [ 1, 3, 5, 7 ]) + , skip <| + test "keep neither first nor last" <| + \() -> + Expect.equal [ 2 ] + (keep even [ 1, 2, 3 ]) + , skip <| + test "keep strings" <| + \() -> + Expect.equal [ "zebra", "zombies", "zealot" ] + (keep (isFirstLetter "z") [ "apple", "zebra", "banana", "zombies", "cherimoya", "zealot" ]) + , skip <| + test "empty discard" <| + \() -> + Expect.equal [] + (discard lessThanTen []) + , skip <| + test "discard everything" <| + \() -> + Expect.equal [] + (discard lessThanTen [ 1, 2, 3 ]) + , skip <| + test "discard first and last" <| + \() -> + Expect.equal [ 2 ] + (discard odd [ 1, 2, 3 ]) + , skip <| + test "discard nothing" <| + \() -> + Expect.equal [ 1, 3, 5, 7 ] + (discard even [ 1, 3, 5, 7 ]) + , skip <| + test "discard neither first nor last" <| + \() -> + Expect.equal [ 1, 3 ] + (discard even [ 1, 2, 3 ]) + , skip <| + test "discard strings" <| + \() -> + Expect.equal [ "apple", "banana", "cherimoya" ] + (discard (isFirstLetter "z") [ "apple", "zebra", "banana", "zombies", "cherimoya", "zealot" ]) ] diff --git a/exercises/sublist/tests/Tests.elm b/exercises/sublist/tests/Tests.elm index 5970ff7..0adacc5 100644 --- a/exercises/sublist/tests/Tests.elm +++ b/exercises/sublist/tests/Tests.elm @@ -10,40 +10,58 @@ tests = describe "Sublist" [ test "the solution is for the correct version of the test" <| \() -> Expect.equal 2 version - , test "empty equals empty" <| - \() -> Expect.equal Equal (sublist [] []) - , test "empty is a sublist of anything" <| - \() -> Expect.equal Sublist (sublist [] [ 1, 2 ]) - , test "anything is a superlist of empty" <| - \() -> Expect.equal Superlist (sublist [ 1, 2 ] []) - , test "1 is not 2" <| - \() -> Expect.equal Unequal (sublist [ 1 ] [ 2 ]) - , test "compare larger equal lists" <| - \() -> Expect.equal Equal (sublist [ 1, 1, 1 ] [ 1, 1, 1 ]) - , test "sublist at start" <| - \() -> Expect.equal Sublist (sublist [ 1, 2, 3 ] [ 1, 2, 3, 4, 5 ]) - , test "sublist in the middle" <| - \() -> Expect.equal Sublist (sublist [ 4, 3, 2 ] [ 5, 4, 3, 2, 1 ]) - , test "sublist at end" <| - \() -> Expect.equal Sublist (sublist [ 3, 4, 5 ] [ 1, 2, 3, 4, 5 ]) - , test "partially matching sublist at start" <| - \() -> Expect.equal Sublist (sublist [ 1, 1, 2 ] [ 1, 1, 1, 2 ]) - , test "sublist early in huge list" <| - \() -> Expect.equal Sublist (sublist [ 3, 4, 5 ] (List.range 1 100000)) - , test "huge sublist not in list" <| - \() -> Expect.equal Unequal (sublist (List.range 10 5001) (List.range 1 5000)) - , test "superlist at start" <| - \() -> Expect.equal Superlist (sublist [ 1, 2, 3, 4, 5 ] [ 1, 2, 3 ]) - , test "superlist in middle" <| - \() -> Expect.equal Superlist (sublist [ 5, 4, 3, 2, 1 ] [ 4, 3, 2 ]) - , test "superlist at end" <| - \() -> Expect.equal Superlist (sublist [ 1, 2, 3, 4, 5 ] [ 3, 4, 5 ]) - , test "partially matching superlist at start" <| - \() -> Expect.equal Superlist (sublist [ 1, 1, 1, 2 ] [ 1, 1, 2 ]) - , test "superlist early in huge list" <| - \() -> Expect.equal Superlist (sublist (List.range 1 100000) [ 3, 4, 5 ]) - , test "recurring values sublist" <| - \() -> Expect.equal Sublist (sublist [ 1, 2, 1, 2, 3 ] [ 1, 2, 3, 1, 2, 1, 2, 3, 2, 1 ]) - , test "recurring values unequal" <| - \() -> Expect.equal Unequal (sublist [ 1, 2, 1, 2, 3 ] [ 1, 2, 3, 1, 2, 3, 2, 3, 2, 1 ]) + , skip <| + test "empty equals empty" <| + \() -> Expect.equal Equal (sublist [] []) + , skip <| + test "empty is a sublist of anything" <| + \() -> Expect.equal Sublist (sublist [] [ 1, 2 ]) + , skip <| + test "anything is a superlist of empty" <| + \() -> Expect.equal Superlist (sublist [ 1, 2 ] []) + , skip <| + test "1 is not 2" <| + \() -> Expect.equal Unequal (sublist [ 1 ] [ 2 ]) + , skip <| + test "compare larger equal lists" <| + \() -> Expect.equal Equal (sublist [ 1, 1, 1 ] [ 1, 1, 1 ]) + , skip <| + test "sublist at start" <| + \() -> Expect.equal Sublist (sublist [ 1, 2, 3 ] [ 1, 2, 3, 4, 5 ]) + , skip <| + test "sublist in the middle" <| + \() -> Expect.equal Sublist (sublist [ 4, 3, 2 ] [ 5, 4, 3, 2, 1 ]) + , skip <| + test "sublist at end" <| + \() -> Expect.equal Sublist (sublist [ 3, 4, 5 ] [ 1, 2, 3, 4, 5 ]) + , skip <| + test "partially matching sublist at start" <| + \() -> Expect.equal Sublist (sublist [ 1, 1, 2 ] [ 1, 1, 1, 2 ]) + , skip <| + test "sublist early in huge list" <| + \() -> Expect.equal Sublist (sublist [ 3, 4, 5 ] (List.range 1 100000)) + , skip <| + test "huge sublist not in list" <| + \() -> Expect.equal Unequal (sublist (List.range 10 5001) (List.range 1 5000)) + , skip <| + test "superlist at start" <| + \() -> Expect.equal Superlist (sublist [ 1, 2, 3, 4, 5 ] [ 1, 2, 3 ]) + , skip <| + test "superlist in middle" <| + \() -> Expect.equal Superlist (sublist [ 5, 4, 3, 2, 1 ] [ 4, 3, 2 ]) + , skip <| + test "superlist at end" <| + \() -> Expect.equal Superlist (sublist [ 1, 2, 3, 4, 5 ] [ 3, 4, 5 ]) + , skip <| + test "partially matching superlist at start" <| + \() -> Expect.equal Superlist (sublist [ 1, 1, 1, 2 ] [ 1, 1, 2 ]) + , skip <| + test "superlist early in huge list" <| + \() -> Expect.equal Superlist (sublist (List.range 1 100000) [ 3, 4, 5 ]) + , skip <| + test "recurring values sublist" <| + \() -> Expect.equal Sublist (sublist [ 1, 2, 1, 2, 3 ] [ 1, 2, 3, 1, 2, 1, 2, 3, 2, 1 ]) + , skip <| + test "recurring values unequal" <| + \() -> Expect.equal Unequal (sublist [ 1, 2, 1, 2, 3 ] [ 1, 2, 3, 1, 2, 3, 2, 3, 2, 1 ]) ] diff --git a/exercises/sum-of-multiples/tests/Tests.elm b/exercises/sum-of-multiples/tests/Tests.elm index 16e22d9..453c08a 100644 --- a/exercises/sum-of-multiples/tests/Tests.elm +++ b/exercises/sum-of-multiples/tests/Tests.elm @@ -10,14 +10,19 @@ tests = describe "Sum Of Multiples" [ test "[3, 5] 15" <| \() -> Expect.equal 45 (sumOfMultiples [ 3, 5 ] 15) - , test "[7, 13, 17] 20" <| - \() -> Expect.equal 51 (sumOfMultiples [ 7, 13, 17 ] 20) - , test "[4, 6] 15" <| - \() -> Expect.equal 30 (sumOfMultiples [ 4, 6 ] 15) - , test "[5, 6, 8] 150" <| - \() -> Expect.equal 4419 (sumOfMultiples [ 5, 6, 8 ] 150) - , test "[43, 47] 10000" <| - \() -> Expect.equal 2203160 (sumOfMultiples [ 43, 47 ] 10000) - , test "[5, 25] 51" <| - \() -> Expect.equal 275 (sumOfMultiples [ 5, 25 ] 51) + , skip <| + test "[7, 13, 17] 20" <| + \() -> Expect.equal 51 (sumOfMultiples [ 7, 13, 17 ] 20) + , skip <| + test "[4, 6] 15" <| + \() -> Expect.equal 30 (sumOfMultiples [ 4, 6 ] 15) + , skip <| + test "[5, 6, 8] 150" <| + \() -> Expect.equal 4419 (sumOfMultiples [ 5, 6, 8 ] 150) + , skip <| + test "[43, 47] 10000" <| + \() -> Expect.equal 2203160 (sumOfMultiples [ 43, 47 ] 10000) + , skip <| + test "[5, 25] 51" <| + \() -> Expect.equal 275 (sumOfMultiples [ 5, 25 ] 51) ] diff --git a/exercises/triangle/tests/Tests.elm b/exercises/triangle/tests/Tests.elm index 861d60e..5b0746d 100644 --- a/exercises/triangle/tests/Tests.elm +++ b/exercises/triangle/tests/Tests.elm @@ -10,30 +10,43 @@ tests = describe "triangleKind" [ test "equilateral triangles have equal sides" <| \() -> Expect.equal (Ok Equilateral) (triangleKind 2 2 2) - , test "larger equilateral triangles also have equal sides" <| - \() -> Expect.equal (Ok Equilateral) (triangleKind 10 10 10) - , test "isosceles triangles have last two sides equal" <| - \() -> Expect.equal (Ok Isosceles) (triangleKind 3 4 4) - , test "isosceles triangles have first and last sides equal" <| - \() -> Expect.equal (Ok Isosceles) (triangleKind 4 3 4) - , test "isosceles triangles have two first sides equal" <| - \() -> Expect.equal (Ok Isosceles) (triangleKind 4 4 3) - , test "isosceles triangles have in fact exactly two sides equal" <| - \() -> Expect.equal (Ok Isosceles) (triangleKind 10 10 2) - , test "scalene triangles have no equal sides" <| - \() -> Expect.equal (Ok Scalene) (triangleKind 3 4 5) - , test "scalene triangles have no equal sides at a larger scale too" <| - \() -> Expect.equal (Ok Scalene) (triangleKind 10 11 12) - , test "scalene triangles have no equal sides at a larger scale too 2" <| - \() -> Expect.equal (Ok Scalene) (triangleKind 5 4 2) - , test "very small triangles are legal" <| - \() -> Expect.equal (Ok Scalene) (triangleKind 0.4 0.6 0.3) - , test "triangles with no size are illegal" <| - \() -> Expect.equal (Err "Invalid lengths") (triangleKind 0 0 0) - , test "triangles with negative sides are illegal" <| - \() -> Expect.equal (Err "Invalid lengths") (triangleKind 3 4 -5) - , test "triangles violating triangle inequality are illegal 1" <| - \() -> Expect.equal (Err "Violates inequality") (triangleKind 1 1 3) - , test "triangles violating triangle inequality are illegal 2" <| - \() -> Expect.equal (Err "Violates inequality") (triangleKind 7 3 2) + , skip <| + test "larger equilateral triangles also have equal sides" <| + \() -> Expect.equal (Ok Equilateral) (triangleKind 10 10 10) + , skip <| + test "isosceles triangles have last two sides equal" <| + \() -> Expect.equal (Ok Isosceles) (triangleKind 3 4 4) + , skip <| + test "isosceles triangles have first and last sides equal" <| + \() -> Expect.equal (Ok Isosceles) (triangleKind 4 3 4) + , skip <| + test "isosceles triangles have two first sides equal" <| + \() -> Expect.equal (Ok Isosceles) (triangleKind 4 4 3) + , skip <| + test "isosceles triangles have in fact exactly two sides equal" <| + \() -> Expect.equal (Ok Isosceles) (triangleKind 10 10 2) + , skip <| + test "scalene triangles have no equal sides" <| + \() -> Expect.equal (Ok Scalene) (triangleKind 3 4 5) + , skip <| + test "scalene triangles have no equal sides at a larger scale too" <| + \() -> Expect.equal (Ok Scalene) (triangleKind 10 11 12) + , skip <| + test "scalene triangles have no equal sides at a larger scale too 2" <| + \() -> Expect.equal (Ok Scalene) (triangleKind 5 4 2) + , skip <| + test "very small triangles are legal" <| + \() -> Expect.equal (Ok Scalene) (triangleKind 0.4 0.6 0.3) + , skip <| + test "triangles with no size are illegal" <| + \() -> Expect.equal (Err "Invalid lengths") (triangleKind 0 0 0) + , skip <| + test "triangles with negative sides are illegal" <| + \() -> Expect.equal (Err "Invalid lengths") (triangleKind 3 4 -5) + , skip <| + test "triangles violating triangle inequality are illegal 1" <| + \() -> Expect.equal (Err "Violates inequality") (triangleKind 1 1 3) + , skip <| + test "triangles violating triangle inequality are illegal 2" <| + \() -> Expect.equal (Err "Violates inequality") (triangleKind 7 3 2) ] diff --git a/exercises/word-count/tests/Tests.elm b/exercises/word-count/tests/Tests.elm index 3ac5873..42b8dfb 100644 --- a/exercises/word-count/tests/Tests.elm +++ b/exercises/word-count/tests/Tests.elm @@ -13,24 +13,29 @@ tests = \() -> Expect.equal [ ( "word", 1 ) ] (wordCount "word" |> Dict.toList) - , test "count one of each word" <| - \() -> - Expect.equal [ ( "each", 1 ), ( "of", 1 ), ( "one", 1 ) ] - (wordCount "one of each" |> Dict.toList) - , test "multiple occurrences of a word" <| - \() -> - Expect.equal [ ( "blue", 1 ), ( "fish", 4 ), ( "one", 1 ), ( "red", 1 ), ( "two", 1 ) ] - (wordCount "one fish two fish red fish blue fish" |> Dict.toList) - , test "ignore punctuation" <| - \() -> - Expect.equal [ ( "as", 1 ), ( "car", 1 ), ( "carpet", 1 ), ( "java", 1 ), ( "javascript", 1 ) ] - (wordCount "car : carpet as java : javascript!!&@$%^&" |> Dict.toList) - , test "include numbers" <| - \() -> - Expect.equal [ ( "1", 1 ), ( "2", 1 ), ( "testing", 2 ) ] - (wordCount "testing, 1, 2 testing" |> Dict.toList) - , test "normalize case" <| - \() -> - Expect.equal [ ( "go", 3 ), ( "stop", 2 ) ] - (wordCount "go Go GO Stop stop" |> Dict.toList) + , skip <| + test "count one of each word" <| + \() -> + Expect.equal [ ( "each", 1 ), ( "of", 1 ), ( "one", 1 ) ] + (wordCount "one of each" |> Dict.toList) + , skip <| + test "multiple occurrences of a word" <| + \() -> + Expect.equal [ ( "blue", 1 ), ( "fish", 4 ), ( "one", 1 ), ( "red", 1 ), ( "two", 1 ) ] + (wordCount "one fish two fish red fish blue fish" |> Dict.toList) + , skip <| + test "ignore punctuation" <| + \() -> + Expect.equal [ ( "as", 1 ), ( "car", 1 ), ( "carpet", 1 ), ( "java", 1 ), ( "javascript", 1 ) ] + (wordCount "car : carpet as java : javascript!!&@$%^&" |> Dict.toList) + , skip <| + test "include numbers" <| + \() -> + Expect.equal [ ( "1", 1 ), ( "2", 1 ), ( "testing", 2 ) ] + (wordCount "testing, 1, 2 testing" |> Dict.toList) + , skip <| + test "normalize case" <| + \() -> + Expect.equal [ ( "go", 3 ), ( "stop", 2 ) ] + (wordCount "go Go GO Stop stop" |> Dict.toList) ]