elm-rails 0.2.0 → 0.2.1

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/src/Tuple.elm

@@ -1,61 +0,0 @@
-module Tuple exposing
-  ( first, second
-  , mapFirst, mapSecond
-  )
-
-{-| Some helpers for working with 2-tuples.
-
-**Note:** For larger chunks of data, it is best to switch to using records. So
-instead of representing a 3D point as `(3,4,5)` and wondering why there are no
-helper functions, represent it as `{ x = 3, y = 4, z = 5 }` and use all the
-built-in syntax for records.
-
-@docs first, second, mapFirst, mapSecond
-
--}
-
-
-
-{-| Extract the first value from a tuple.
-
-    first (3, 4) == 3
-    first ("john", "doe") == "john"
--}
-first : (a1, a2) -> a1
-first (x,_) =
-  x
-
-
-{-| Extract the second value from a tuple.
-
-    second (3, 4) == 4
-    second ("john", "doe") == "doe"
--}
-second : (a1, a2) -> a2
-second (_,y) =
-  y
-
-
-{-| Transform the first value in a tuple.
-
-    import String
-
-    mapFirst String.reverse ("stressed", 16) == ("desserts", 16)
-    mapFirst String.length  ("stressed", 16) == (8, 16)
--}
-mapFirst : (a -> b) -> (a, a2) -> (b, a2)
-mapFirst func (x,y) =
-  (func x, y)
-
-
-{-| Transform the second value in a tuple.
-
-    import String
-
-    mapSecond sqrt          ("stressed", 16) == ("stressed", 4)
-    mapSecond (\x -> x + 1) ("stressed", 16) == ("stressed", 17)
--}
-mapSecond : (a -> b) -> (a1, a) -> (a1, b)
-mapSecond func (x,y) =
-  (x, func y)
-

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test.elm

@@ -1,40 +0,0 @@
-module Main exposing (..)
-
-import Basics exposing (..)
-import ElmTest exposing (..)
-
-import Test.Array as Array
-import Test.Basics as Basics
-import Test.Bitwise as Bitwise
-import Test.Char as Char
-import Test.CodeGen as CodeGen
-import Test.Dict as Dict
-import Test.Equality as Equality
-import Test.Json as Json
-import Test.List as List
-import Test.Result as Result
-import Test.Set as Set
-import Test.String as String
-import Test.Regex as Regex
-
-tests : Test
-tests =
-    suite "Elm Standard Library Tests"
-        [ Array.tests
-        , Basics.tests
-        , Bitwise.tests
-        , Char.tests
-        , CodeGen.tests
-        , Dict.tests
-        , Equality.tests
-        , Json.tests
-        , List.tests
-        , Result.tests
-        , Set.tests
-        , String.tests
-        , Regex.tests
-        ]
-
-
-main =
-    runSuite tests

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Array.elm

@@ -1,90 +0,0 @@
-module Test.Array exposing (tests)
-
-import Array
-import Basics exposing (..)
-import List
-import List exposing ((::))
-import Maybe exposing (..)
-import Native.Array
-
-import ElmTest exposing (..)
-
-mergeSplit : Int -> Array.Array a -> Array.Array a
-mergeSplit n arr =
-  let left = Array.slice 0 n arr
-      right = Array.slice n (Array.length arr) arr
-  in Array.append left right
-
-holeArray : Array.Array Int
-holeArray = List.foldl mergeSplit (Array.fromList [0..100]) [0..100]
-
-mapArray: Array.Array a -> Array.Array a
-mapArray array =
-    Array.indexedMap (\i el ->
-        case (Array.get i array) of
-            Just x -> x
-            Nothing -> el
-    ) array
-
-tests : Test
-tests =
-  let creationTests = suite "Creation"
-        [ test "empty" <| assertEqual Array.empty (Array.fromList [])
-        , test "initialize" <| assertEqual (Array.initialize 4 identity) (Array.fromList [0,1,2,3])
-        , test "initialize 2" <| assertEqual (Array.initialize 4 (\n -> n*n)) (Array.fromList [0,1,4,9])
-        , test "initialize 3" <| assertEqual (Array.initialize 4 (always 0)) (Array.fromList [0,0,0,0])
-        , test "initialize Empty" <| assertEqual (Array.initialize 0 identity) Array.empty
-        , test "initialize 4" <| assertEqual (Array.initialize 2 (always 0)) (Array.fromList [0,0])
-        , test "initialize negative" <| assertEqual (Array.initialize -1 identity) Array.empty
-        , test "repeat" <| assertEqual (Array.repeat 5 40) (Array.fromList [40,40,40,40,40])
-        , test "repeat 2" <| assertEqual (Array.repeat 5 0) (Array.fromList [0,0,0,0,0])
-        , test "repeat 3" <| assertEqual (Array.repeat 3 "cat") (Array.fromList ["cat","cat","cat"])
-        , test "fromList" <| assertEqual (Array.fromList []) Array.empty
-        ]
-      basicsTests = suite "Basics"
-        [ test "length" <| assertEqual 3 (Array.length (Array.fromList [1,2,3]))
-        , test "length - Long" <| assertEqual 10000 (Array.length (Array.repeat 10000 0))
-        , test "push" <| assertEqual (Array.fromList [1,2,3]) (Array.push 3 (Array.fromList [1,2]))
-        , test "append" <| assertEqual [42,42,81,81,81] (Array.toList (Array.append (Array.repeat 2 42) (Array.repeat 3 81)))
-        , test "appendEmpty 1" <| assertEqual [1..33] (Array.toList (Array.append Array.empty (Array.fromList [1..33])))
-        , test "appendEmpty 2" <| assertEqual [1..33] (Array.toList (Array.append (Array.fromList [1..33]) Array.empty))
-        , test "appendSmall 1" <| assertEqual [1..33] (Array.toList (Array.append (Array.fromList [1..30]) (Array.fromList [31..33])))
-        , test "appendSmall 2" <| assertEqual [1..33] (Array.toList (Array.append (Array.fromList [1..3]) (Array.fromList [4..33])))
-        , test "appendAndSlice" <| assertEqual [0..100] (Array.toList holeArray)
-        ]
-      getAndSetTests = suite "Get and Set"
-        [ test "get" <| assertEqual (Just 2) (Array.get 1 (Array.fromList [3,2,1]))
-        , test "get 2" <| assertEqual Nothing (Array.get 5 (Array.fromList [3,2,1]))
-        , test "get 3" <| assertEqual Nothing (Array.get -1 (Array.fromList [3,2,1]))
-        , test "set" <| assertEqual (Array.fromList [1,7,3]) (Array.set 1 7 (Array.fromList [1,2,3]))
-        ]
-      takingArraysApartTests = suite "Taking Arrays Apart"
-        [ test "toList" <| assertEqual [3,5,8] (Array.toList (Array.fromList [3,5,8]))
-        , test "toIndexedList" <| assertEqual [(0,"cat"), (1,"dog")] (Array.toIndexedList (Array.fromList ["cat","dog"]))
-        , test "slice 1" <| assertEqual (Array.fromList [0,1,2]) (Array.slice  0  3 (Array.fromList [0,1,2,3,4]))
-        , test "slice 2" <| assertEqual (Array.fromList [1,2,3]) (Array.slice  1  4 (Array.fromList [0,1,2,3,4]))
-        , test "slice 3" <| assertEqual (Array.fromList [1,2,3]) (Array.slice  1 -1 (Array.fromList [0,1,2,3,4]))
-        , test "slice 4" <| assertEqual (Array.fromList [2])     (Array.slice -3 -2 (Array.fromList [0,1,2,3,4]))
-        , test "slice 5" <| assertEqual 63 (Array.length <| Array.slice 65 (65 + 63) <| Array.fromList [1..200])
-        ]
-      mappingAndFoldingTests = suite "Mapping and Folding"
-        [ test "map" <| assertEqual (Array.fromList [1,2,3]) (Array.map sqrt (Array.fromList [1,4,9]))
-        , test "indexedMap 1" <| assertEqual (Array.fromList [0,5,10]) (Array.indexedMap (*) (Array.fromList [5,5,5]))
-        , test "indexedMap 2" <| assertEqual [0..99] (Array.toList (Array.indexedMap always (Array.repeat 100 0)))
-        , test "large indexed map" <| assertEqual [0..32768 - 1] (Array.toList <| mapArray <| Array.initialize 32768 identity)
-        , test "foldl 1" <| assertEqual [3,2,1] (Array.foldl (::) [] (Array.fromList [1,2,3]))
-        , test "foldl 2" <| assertEqual 33 (Array.foldl (+) 0 (Array.repeat 33 1))
-        , test "foldr 1" <| assertEqual 15 (Array.foldr (+) 0 (Array.repeat 3 5))
-        , test "foldr 2" <| assertEqual [1,2,3] (Array.foldr (::) [] (Array.fromList [1,2,3]))
-        , test "foldr 3" <| assertEqual 53 (Array.foldr (-) 54 (Array.fromList [10,11]))
-        , test "filter" <| assertEqual (Array.fromList [2,4,6]) (Array.filter (\x -> x % 2 == 0) (Array.fromList [1..6]))
-        ]
-
-      nativeTests = suite "Conversion to JS Arrays"
-        [ test "jsArrays" <| assertEqual (Array.fromList [1..1100]) (Native.Array.fromJSArray (Native.Array.toJSArray (Array.fromList [1..1100])))
-        ]
-  in
-      suite "Array"
-        [ creationTests, basicsTests, getAndSetTests
-        , takingArraysApartTests, mappingAndFoldingTests, nativeTests
-        ]

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Basics.elm

@@ -1,158 +0,0 @@
-module Test.Basics exposing (tests)
-
-import Array
-import Basics exposing (..)
-import Date
-import Set
-import Dict
-import ElmTest exposing (..)
-
-tests : Test
-tests =
-    let comparison =
-            suite "Comparison"
-            [ test "max" <| assertEqual 42 (max 32 42)
-            , test "min" <| assertEqual 42 (min 91 42)
-            , test "clamp low" <| assertEqual 10 (clamp 10 20 5)
-            , test "clamp mid" <| assertEqual 15 (clamp 10 20 15)
-            , test "clamp high" <| assertEqual 20 (clamp 10 20 25)
-            , test "5 < 6" <| assertEqual True (5 < 6)
-            , test "6 < 5" <| assertEqual False (6 < 5)
-            , test "6 < 6" <| assertEqual False (6 < 6)
-            , test "5 > 6" <| assertEqual False (5 > 6)
-            , test "6 > 5" <| assertEqual True (6 > 5)
-            , test "6 > 6" <| assertEqual False (6 > 6)
-            , test "5 <= 6" <| assertEqual True (5 <= 6)
-            , test "6 <= 5" <| assertEqual False (6 <= 5)
-            , test "6 <= 6" <| assertEqual True (6 <= 6)
-            , test "compare \"A\" \"B\"" <| assertEqual LT (compare "A" "B")
-            , test "compare 'f' 'f'" <| assertEqual EQ (compare 'f' 'f')
-            , test "compare (1, 2, 3, 4, 5, 6) (0, 1, 2, 3, 4, 5)" <| assertEqual GT (compare (1, 2, 3, 4, 5, 6) (0, 1, 2, 3, 4, 5))
-            , test "compare ['a'] ['b']" <| assertEqual LT (compare ['a'] ['b'])
-            , test "array equality" <| assertEqual (Array.fromList [1,1,1,1]) (Array.repeat 4 1)
-            , test "set equality" <| assertEqual (Set.fromList [1,2]) (Set.fromList [2,1])
-            , test "dict equality" <| assertEqual (Dict.fromList [(1,1),(2,2)]) (Dict.fromList [(2,2),(1,1)])
-            , test "char equality" <| assertNotEqual '0' '饑'
-            , test "date equality" <| assertEqual (Date.fromString "2/7/1992") (Date.fromString "2/7/1992")
-            , test "date equality" <| assertNotEqual (Date.fromString "11/16/1995") (Date.fromString "2/7/1992")
-            ]
-        toStringTests = suite "toString Tests"
-            [ test "toString Int" <| assertEqual "42" (toString 42)
-            , test "toString Float" <| assertEqual "42.52" (toString 42.52)
-            , test "toString Char" <| assertEqual "'c'" (toString 'c')
-            , test "toString Char single quote" <| assertEqual "'\\''" (toString '\'')
-            , test "toString Char double quote" <| assertEqual "'\"'" (toString '"')
-            , test "toString String single quote" <| assertEqual "\"not 'escaped'\"" (toString "not 'escaped'")
-            , test "toString String double quote" <| assertEqual "\"are \\\"escaped\\\"\"" (toString "are \"escaped\"")
-            ]
-        trigTests = suite "Trigonometry Tests"
-            [ test "radians 0" <| assertEqual 0 (radians 0)
-            , test "radians positive" <| assertEqual 5 (radians 5)
-            , test "radians negative" <| assertEqual -5 (radians -5)
-            , test "degrees 0" <| assertEqual 0 (degrees 0)
-            , test "degrees 90" <| assert (abs (1.57 - degrees 90) < 0.01) -- This should test to enough precision to know if anything's breaking
-            , test "degrees -145" <| assert (abs (-2.53 - degrees -145) < 0.01) -- This should test to enough precision to know if anything's breaking
-            , test "turns 0" <| assertEqual 0 (turns 0)
-            , test "turns 8" <| assert (abs (50.26 - turns 8) < 0.01) -- This should test to enough precision to know if anything's breaking
-            , test "turns -133" <| assert (abs (-835.66 - turns -133) < 0.01) -- This should test to enough precision to know if anything's breaking
-            , test "fromPolar (0, 0)" <| assertEqual (0, 0) (fromPolar (0, 0))
-            , test "fromPolar (1, 0)" <| assertEqual (1, 0) (fromPolar (1, 0))
-            , test "fromPolar (0, 1)" <| assertEqual (0, 0) (fromPolar (0, 1))
-            , test "fromPolar (1, 1)" <| assert (let (x, y) = fromPolar (1, 1) in 0.54 - x < 0.01 && 0.84 - y < 0.01)
-            , test "toPolar (0, 0)" <| assertEqual (0, 0) (toPolar (0, 0))
-            , test "toPolar (1, 0)" <| assertEqual (1, 0) (toPolar (1, 0))
-            , test "toPolar (0, 1)" <| assert (let (r, theta) = toPolar (0, 1) in r == 1 && abs (1.57 - theta) < 0.01)
-            , test "toPolar (1, 1)" <| assert (let (r, theta) = toPolar (1, 1) in abs (1.41 - r) < 0.01 && abs (0.78 - theta) < 0.01)
-            , test "cos" <| assertEqual 1 (cos 0)
-            , test "sin" <| assertEqual 0 (sin 0)
-            , test "tan" <| assert (abs (12.67 - tan 17.2) < 0.01)
-            , test "acos" <| assert (abs (3.14 - acos -1) < 0.01)
-            , test "asin" <| assert (abs (0.30 - asin 0.3) < 0.01)
-            , test "atan" <| assert (abs (1.57 - atan 4567.8) < 0.01)
-            , test "atan2" <| assert (abs (1.55 - atan2 36 0.65) < 0.01)
-            , test "pi" <| assert (abs (3.14 - pi) < 0.01)
-            ]
-        basicMathTests = suite "Basic Math Tests"
-            [ test "add float" <| assertEqual 159 (155.6 + 3.4)
-            , test "add int" <| assertEqual 17 ((round 10) + (round 7))
-            , test "subtract float" <| assertEqual -6.3 (1 - 7.3)
-            , test "subtract int" <| assertEqual 1130 ((round 9432) - (round 8302))
-            , test "multiply float" <| assertEqual 432 (96 * 4.5)
-            , test "multiply int" <| assertEqual 90 ((round 10) * (round 9))
-            , test "divide float" <| assertEqual 13.175 (527 / 40)
-            , test "divide int" <| assertEqual 23 (70 // 3)
-            , test "7 `rem` 2" <| assertEqual 1 (7 `rem` 2)
-            , test "-1 `rem` 4" <| assertEqual -1 (-1 `rem` 4)
-            , test "7 % 2" <| assertEqual 1 (7 % 2)
-            , test "-1 % 4" <| assertEqual 3 (-1 % 4)
-            , test "3^2" <| assertEqual 9 (3^2)
-            , test "sqrt" <| assertEqual 9 (sqrt 81)
-            , test "negate 42" <| assertEqual -42 (negate 42)
-            , test "negate -42" <| assertEqual 42 (negate -42)
-            , test "negate 0" <| assertEqual 0 (negate 0)
-            , test "abs -25" <| assertEqual 25 (abs -25)
-            , test "abs 76" <| assertEqual 76 (abs 76)
-            , test "logBase 10 100" <| assertEqual 2 (logBase 10 100)
-            , test "logBase 2 256" <| assertEqual 8 (logBase 2 256)
-            , test "e" <| assert (abs (2.72 - e) < 0.01)
-            ]
-        booleanTests = suite "Boolean Tests"
-            [ test "False && False" <| assertEqual False (False && False)
-            , test "False && True" <| assertEqual False (False && True)
-            , test "True && False" <| assertEqual False (True && False)
-            , test "True && True" <| assertEqual True (True && True)
-            , test "False || False" <| assertEqual False (False || False)
-            , test "False || True" <| assertEqual True (False || True)
-            , test "True || False" <| assertEqual True (True || False)
-            , test "True || True" <| assertEqual True (True || True)
-            , test "xor False False" <| assertEqual False (xor False False)
-            , test "xor False True" <| assertEqual True (xor False True)
-            , test "xor True False" <| assertEqual True (xor True False)
-            , test "xor True True" <| assertEqual False (xor True True)
-            , test "not True" <| assertEqual False (not True)
-            , test "not False" <| assertEqual True (not False)
-            ]
-        conversionTests = suite "Conversion Tests"
-            [ test "round 0.6" <| assertEqual 1 (round 0.6)
-            , test "round 0.4" <| assertEqual 0 (round 0.4)
-            , test "round 0.5" <| assertEqual 1 (round 0.5)
-            , test "truncate -2367.9267" <| assertEqual -2367 (truncate -2367.9267)
-            , test "floor -2367.9267" <| assertEqual -2368 (floor -2367.9267)
-            , test "ceiling 37.2" <| assertEqual 38 (ceiling 37.2)
-            , test "toFloat 25" <| assertEqual 25 (toFloat 25)
-            ]
-        miscTests = suite "Miscellaneous Tests"
-            [ test "isNaN (0/0)" <| assertEqual True (isNaN (0/0))
-            , test "isNaN (sqrt -1)" <| assertEqual True (isNaN (sqrt -1))
-            , test "isNaN (1/0)" <| assertEqual False (isNaN (1/0))
-            , test "isNaN 1" <| assertEqual False (isNaN 1)
-            , test "isInfinite (0/0)" <| assertEqual False (isInfinite (0/0))
-            , test "isInfinite (sqrt -1)" <| assertEqual False (isInfinite (sqrt -1))
-            , test "isInfinite (1/0)" <| assertEqual True (isInfinite (1/0))
-            , test "isInfinite 1" <| assertEqual False (isInfinite 1)
-            , test "\"hello\" ++ \"world\"" <| assertEqual "helloworld" ("hello" ++ "world")
-            , test "[1, 1, 2] ++ [3, 5, 8]" <| assertEqual [1, 1, 2, 3, 5, 8] ([1, 1, 2] ++ [3, 5, 8])
-            , test "fst (1, 2)" <| assertEqual 1 (fst (1, 2))
-            , test "snd (1, 2)" <| assertEqual 2 (snd (1, 2))
-            ]
-        higherOrderTests = suite "Higher Order Helpers Tests"
-            [ test "identity 'c'" <| assertEqual 'c' (identity 'c')
-            , test "always 42 ()" <| assertEqual 42 (always 42 ())
-            , test "<|" <| assertEqual 9 (identity <| 3 + 6)
-            , test "|>" <| assertEqual 9 (3 + 6 |> identity)
-            , test "<<" <| assertEqual True (not << xor True <| True)
-            , test ">>" <| assertEqual True (True |> xor True >> not)
-            , test "flip" <| assertEqual 10 ((flip (//)) 2 20)
-            , test "curry" <| assertEqual 1 ((curry (\(a, b) -> a + b)) -5 6)
-            , test "uncurry" <| assertEqual 1 ((uncurry (+)) (-5, 6))
-            ]
-    in
-        suite "Basics"
-            [ comparison
-            , toStringTests
-            , trigTests
-            , basicMathTests
-            , booleanTests
-            , miscTests
-            , higherOrderTests
-            ]

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Bitwise.elm

@@ -1,50 +0,0 @@
-module Test.Bitwise exposing (tests)
-
-import Basics exposing (..)
-import Bitwise
-
-import ElmTest exposing (..)
-
-tests : Test
-tests =
-    suite "Bitwise"
-        [ suite "and"
-            [ test "and with 32 bit integers" <| assertEqual 1 (Bitwise.and 5 3)
-            , test "and with 0 as first argument" <| assertEqual 0 (Bitwise.and 0 1450)
-            , test "and with 0 as second argument" <| assertEqual 0 (Bitwise.and 274 0)
-            , test "and with -1 as first argument" <| assertEqual 2671 (Bitwise.and -1 2671)
-            , test "and with -1 as second argument" <| assertEqual 96 (Bitwise.and 96 -1)
-            ]
-        , suite "or"
-            [ test "or with 32 bit integers" <| assertEqual 15 (Bitwise.or 9 14)
-            , test "or with 0 as first argument" <| assertEqual 843 (Bitwise.or 0 843)
-            , test "or with 0 as second argument" <| assertEqual 19 (Bitwise.or 19 0)
-            , test "or with -1 as first argument" <| assertEqual -1 (Bitwise.or -1 2360)
-            , test "or with -1 as second argument" <| assertEqual -1 (Bitwise.or 3 -1)
-            ]
-        , suite "xor"
-            [ test "xor with 32 bit integers" <| assertEqual 604 (Bitwise.xor 580 24)
-            , test "xor with 0 as first argument" <| assertEqual 56 (Bitwise.xor 0 56)
-            , test "xor with 0 as second argument" <| assertEqual -268 (Bitwise.xor -268 0)
-            , test "xor with -1 as first argument" <| assertEqual -25 (Bitwise.xor -1 24)
-            , test "xor with -1 as second argument" <| assertEqual 25601 (Bitwise.xor -25602 -1)
-            ]
-        , suite "complement"
-            [ test "complement a positive" <| assertEqual -9 (Bitwise.complement 8)
-            , test "complement a negative" <| assertEqual 278 (Bitwise.complement -279)
-            ]
-        , suite "shiftLeft"
-            [ test "8 `shiftLeft` 1 == 16" <| assertEqual 16 (Bitwise.shiftLeft 8 1)
-            , test "8 `shiftLeft` 2 == 32" <| assertEqual 32 (Bitwise.shiftLeft 8 2)
-            ]
-        , suite "shiftRight"
-            [ test "32 `shiftRight` 1 == 16" <| assertEqual 16 (Bitwise.shiftRight 32 1)
-            , test "32 `shiftRight` 2 == 8" <| assertEqual 8 (Bitwise.shiftRight 32 2)
-            , test "-32 `shiftRight` 1 == -16" <| assertEqual -16 (Bitwise.shiftRight -32 1)
-            ]
-        , suite "shiftRightLogical"
-            [ test "32 `shiftRightLogical` 1 == 16" <| assertEqual 16 (Bitwise.shiftRightLogical 32 1)
-            , test "32 `shiftRightLogical` 2 == 8" <| assertEqual 8 (Bitwise.shiftRightLogical 32 2)
-            , test "-32 `shiftRightLogical` 1 == 2147483632" <| assertEqual 2147483632 (Bitwise.shiftRightLogical -32 1)
-            ]
-        ]

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Char.elm

@@ -1,93 +0,0 @@
-module Test.Char exposing (tests)
-
-import Basics exposing (..)
-import Char exposing (..)
-import List
-
-import ElmTest exposing (..)
-
-
-lower = [ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' ]
-upper = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' ]
-dec = [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' ]
-oct = List.take 8 dec
-hexLower = List.take 6 lower
-hexUpper = List.take 6 upper
-hex = List.append hexLower hexUpper |> List.append dec
-
-lowerCodes = [97..(97 + List.length lower - 1)]
-upperCodes = [65..(65 + List.length upper - 1)]
-decCodes = [48..(48 + List.length dec - 1)]
-
-oneOf : List a -> a -> Bool
-oneOf = flip List.member
-
-
-tests : Test
-tests = suite "Char"
-  [ suite "toCode"
-      [ test "a-z" <| assertEqual (lowerCodes) (List.map toCode lower)
-      , test "A-Z" <| assertEqual (upperCodes) (List.map toCode upper)
-      , test "0-9" <| assertEqual (decCodes) (List.map toCode dec)
-      ]
-
-  , suite "fromCode"
-      [ test "a-z" <| assertEqual (lower) (List.map fromCode lowerCodes)
-      , test "A-Z" <| assertEqual (upper) (List.map fromCode upperCodes)
-      , test "0-9" <| assertEqual (dec) (List.map fromCode decCodes)
-      ]
-
-  , suite "toLocaleLower"
-      [ test "a-z" <| assertEqual (lower) (List.map toLocaleLower lower)
-      , test "A-Z" <| assertEqual (lower) (List.map toLocaleLower upper)
-      , test "0-9" <| assertEqual (dec) (List.map toLocaleLower dec)
-      ]
-
-  , suite "toLocaleUpper"
-      [ test "a-z" <| assertEqual (upper) (List.map toLocaleUpper lower)
-      , test "A-Z" <| assertEqual (upper) (List.map toLocaleUpper upper)
-      , test "0-9" <| assertEqual (dec) (List.map toLocaleUpper dec)
-      ]
-
-  , suite "toLower"
-      [ test "a-z" <| assertEqual (lower) (List.map toLower lower)
-      , test "A-Z" <| assertEqual (lower) (List.map toLower upper)
-      , test "0-9" <| assertEqual (dec) (List.map toLower dec)
-      ]
-
-  , suite "toUpper"
-      [ test "a-z" <| assertEqual (upper) (List.map toUpper lower)
-      , test "A-Z" <| assertEqual (upper) (List.map toUpper upper)
-      , test "0-9" <| assertEqual (dec) (List.map toUpper dec)
-      ]
-
-  , suite "isLower"
-      [ test "a-z" <| assertEqual (True) (List.all isLower lower)
-      , test "A-Z" <| assertEqual (False) (List.any isLower upper)
-      , test "0-9" <| assertEqual (False) (List.any isLower dec)
-      ]
-
-  , suite "isUpper"
-      [ test "a-z" <| assertEqual (False) (List.any isUpper lower)
-      , test "A-Z" <| assertEqual (True) (List.all isUpper upper)
-      , test "0-9" <| assertEqual (False) (List.any isUpper dec)
-      ]
-
-  , suite "isDigit"
-      [ test "a-z" <| assertEqual (False) (List.any isDigit lower)
-      , test "A-Z" <| assertEqual (False) (List.any isDigit upper)
-      , test "0-9" <| assertEqual (True) (List.all isDigit dec)
-      ]
-
-  , suite "isHexDigit"
-      [ test "a-z" <| assertEqual (List.map (oneOf hex) lower) (List.map isHexDigit lower)
-      , test "A-Z" <| assertEqual (List.map (oneOf hex) upper) (List.map isHexDigit upper)
-      , test "0-9" <| assertEqual (True) (List.all isHexDigit dec)
-      ]
-
-  , suite "isOctDigit"
-      [ test "a-z" <| assertEqual (False) (List.any isOctDigit lower)
-      , test "A-Z" <| assertEqual (False) (List.any isOctDigit upper)
-      , test "0-9" <| assertEqual (List.map (oneOf oct) dec) (List.map isOctDigit dec)
-      ]
-  ]