elm-rails 0.1.2 → 0.2.0

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

@@ -0,0 +1,158 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,93 @@
+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)
+      ]
+  ]

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

@@ -0,0 +1,59 @@
+module Test.CodeGen exposing (tests)
+
+import Basics exposing (..)
+import ElmTest exposing (..)
+
+import Maybe
+import Maybe exposing (..)
+
+
+type Wrapper a = Wrapper a
+
+
+casePrime m' =
+    case m' of
+        Just x -> x
+        Nothing -> 0
+
+patternPrime =
+    case Just 42 of
+        Just x' -> x'
+        Nothing -> 0
+
+letQualified =
+    let (Wrapper x) = Wrapper 42
+    in  x
+
+caseQualified =
+    case Just 42 of
+        Maybe.Just x -> x
+        Nothing -> 0
+
+caseScope : String
+caseScope =
+    case "Not this one!" of
+        string ->
+            case "Hi" of
+                string -> string
+
+tests : Test
+tests =
+    let primes =
+            suite "Primes"
+            [ test "case" <| assertEqual 42 (casePrime (Just 42))
+            , test "pattern" <| assertEqual 42 patternPrime
+            ]
+        qualifiedPatterns =
+            suite "Qualified Patterns"
+            [ test "let" <| assertEqual 42 letQualified
+            , test "case" <| assertEqual 42 caseQualified
+            ]
+        scope =
+            suite "Scoping"
+            [ test "case" <| assertEqual "Hi" caseScope ]
+    in
+        suite "CodeGen"
+            [ primes
+            , qualifiedPatterns
+            , scope
+            ]

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

@@ -0,0 +1,79 @@
+module Test.Dict exposing (tests)
+
+import Basics exposing (..)
+import Dict
+import List
+import Maybe exposing (..)
+
+import ElmTest exposing (..)
+
+animals : Dict.Dict String String
+animals = Dict.fromList [ ("Tom", "cat"), ("Jerry", "mouse") ]
+
+tests : Test
+tests =
+  let buildTests = suite "build Tests"
+        [ test "empty" <| assertEqual (Dict.fromList []) (Dict.empty)
+        , test "singleton" <| assertEqual (Dict.fromList [("k","v")]) (Dict.singleton "k" "v")
+        , test "insert" <| assertEqual (Dict.fromList [("k","v")]) (Dict.insert "k" "v" Dict.empty)
+        , test "insert replace" <| assertEqual (Dict.fromList [("k","vv")]) (Dict.insert "k" "vv" (Dict.singleton "k" "v"))
+        , test "update" <| assertEqual (Dict.fromList [("k","vv")]) (Dict.update "k" (\v->Just "vv") (Dict.singleton "k" "v"))
+        , test "update Nothing" <| assertEqual Dict.empty (Dict.update "k" (\v->Nothing) (Dict.singleton "k" "v"))
+        , test "remove" <| assertEqual Dict.empty (Dict.remove "k" (Dict.singleton "k" "v"))
+        , test "remove not found" <| assertEqual (Dict.singleton "k" "v") (Dict.remove "kk" (Dict.singleton "k" "v"))
+        ]
+      queryTests = suite "query Tests"
+        [ test "member 1" <| assertEqual True (Dict.member "Tom" animals)
+        , test "member 2" <| assertEqual False (Dict.member "Spike" animals)
+        , test "get 1" <| assertEqual (Just "cat") (Dict.get "Tom" animals)
+        , test "get 2" <| assertEqual Nothing (Dict.get "Spike" animals)
+        , test "size of empty dictionary" <| assertEqual 0 (Dict.size Dict.empty)
+        , test "size of example dictionary" <| assertEqual 2 (Dict.size animals)
+        ]
+      combineTests = suite "combine Tests"
+        [ test "union" <| assertEqual animals (Dict.union (Dict.singleton "Jerry" "mouse") (Dict.singleton "Tom" "cat"))
+        , test "union collison" <| assertEqual (Dict.singleton "Tom" "cat") (Dict.union (Dict.singleton "Tom" "cat") (Dict.singleton "Tom" "mouse"))
+        , test "intersect" <| assertEqual (Dict.singleton "Tom" "cat") (Dict.intersect animals (Dict.singleton "Tom" "cat"))
+        , test "diff" <| assertEqual (Dict.singleton "Jerry" "mouse") (Dict.diff animals (Dict.singleton "Tom" "cat"))
+        ]
+      transformTests = suite "transform Tests"
+        [ test "filter" <| assertEqual (Dict.singleton "Tom" "cat") (Dict.filter (\k v -> k == "Tom") animals)
+        , test "partition" <| assertEqual (Dict.singleton "Tom" "cat", Dict.singleton "Jerry" "mouse") (Dict.partition (\k v -> k == "Tom") animals)
+        ]
+      mergeTests =
+          let
+              insertBoth key leftVal rightVal dict =
+                  Dict.insert key (leftVal ++ rightVal) dict
+              s1 =
+                  Dict.empty |> Dict.insert "u1" [ 1 ]
+              s2 =
+                  Dict.empty |> Dict.insert "u2" [ 2 ]
+              s23 =
+                  Dict.empty |> Dict.insert "u2" [ 3 ]
+              b1 =
+                  List.map (\i -> (i, [i])) [1..10] |> Dict.fromList
+              b2 =
+                  List.map (\i -> (i, [i])) [5..15] |> Dict.fromList
+              bExpected =
+                  [(1,[1]),(2,[2]),(3,[3]),(4,[4]),(5,[5,5]),(6,[6,6]),(7,[7,7]),(8,[8,8]),(9,[9,9]),(10,[10,10]),(11,[11]),(12,[12]),(13,[13]),(14,[14]),(15,[15])]
+          in
+              suite "merge Tests"
+                  [ test "merge empties" <| assertEqual (Dict.empty)
+                    (Dict.merge Dict.insert insertBoth Dict.insert Dict.empty Dict.empty Dict.empty)
+                  , test "merge singletons in order" <| assertEqual [("u1", [1]), ("u2", [2])]
+                      ((Dict.merge Dict.insert insertBoth Dict.insert s1 s2 Dict.empty) |> Dict.toList)
+                  , test "merge singletons out of order" <| assertEqual [("u1", [1]), ("u2", [2])]
+                      ((Dict.merge Dict.insert insertBoth Dict.insert s2 s1 Dict.empty) |> Dict.toList)
+                  , test "merge with duplicate key" <| assertEqual [("u2", [2, 3])]
+                      ((Dict.merge Dict.insert insertBoth Dict.insert s2 s23 Dict.empty) |> Dict.toList)
+                  , test "partially overlapping" <| assertEqual bExpected
+                      ((Dict.merge Dict.insert insertBoth Dict.insert b1 b2 Dict.empty) |> Dict.toList)
+                  ]
+  in
+    suite "Dict Tests"
+    [ buildTests
+    , queryTests
+    , combineTests
+    , transformTests
+    , mergeTests
+    ]

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

@@ -0,0 +1,28 @@
+module Test.Equality exposing (tests)
+
+import Basics exposing (..)
+import Maybe exposing (..)
+
+import ElmTest exposing (..)
+
+type Different
+    = A String
+    | B (List Int)
+
+tests : Test
+tests =
+  let diffTests = suite "ADT equality"
+        [ test "As eq" <| assert (A "a" == A "a")
+        , test "Bs eq" <| assert (B [1] == B [1])
+        , test "A left neq" <| assert (A "a" /= B [1])
+        , test "A left neq" <| assert (B [1] /= A "a")
+        ]
+      recordTests = suite "Record equality"
+        [ test "empty same" <| assert ({} == {})
+        , test "ctor same" <| assert ({field = Just 3} == {field = Just 3})
+        , test "ctor same, special case" <| assert ({ctor = Just 3} == {ctor = Just 3})
+        , test "ctor diff" <| assert ({field = Just 3} /= {field = Nothing})
+        , test "ctor diff, special case" <| assert ({ctor = Just 3} /= {ctor = Nothing})
+        ]
+  in
+      suite "Equality Tests" [diffTests, recordTests]

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

@@ -0,0 +1,83 @@
+module Test.Json exposing (tests)
+
+import Basics exposing (..)
+import Result exposing (..)
+import Json.Decode as Json exposing ((:=))
+import String
+
+import ElmTest exposing (..)
+
+
+tests : Test
+tests =
+  suite "Json decode"
+    [ intTests
+    , customTests
+    ]
+
+
+intTests : Test
+intTests =
+  let
+    testInt val str =
+      case Json.decodeString Json.int str of
+        Ok _ ->
+          assertEqual val True
+
+        Err _ ->
+          assertEqual val False
+  in
+    suite "Json decode int"
+      [ test "whole int" <| testInt True "4"
+      , test "-whole int" <| testInt True "-4"
+      , test "whole float" <| testInt True "4.0"
+      , test "-whole float" <| testInt True "-4.0"
+      , test "large int" <| testInt True "1801439850948"
+      , test "-large int" <| testInt True "-1801439850948"
+      , test "float" <| testInt False "4.2"
+      , test "-float" <| testInt False "-4.2"
+      , test "Infinity" <| testInt False "Infinity"
+      , test "-Infinity" <| testInt False "-Infinity"
+      , test "NaN" <| testInt False "NaN"
+      , test "-NaN" <| testInt False "-NaN"
+      , test "true" <| testInt False "true"
+      , test "false" <| testInt False "false"
+      , test "string" <| testInt False "\"string\""
+      , test "object" <| testInt False "{}"
+      , test "null" <| testInt False "null"
+      , test "undefined" <| testInt False "undefined"
+      , test "Decoder expects object finds array, was crashing runtime." <|
+          assertEqual
+            (Err "Expecting an object but instead got: []")
+            (Json.decodeString (Json.dict Json.float) "[]")
+      ]
+
+
+customTests : Test
+customTests =
+  let
+    jsonString =
+      """{ "foo": "bar" }"""
+
+    customErrorMessage =
+      "I want to see this message!"
+
+    myDecoder =
+      Json.customDecoder ("foo" := Json.string) (\_ -> Err customErrorMessage)
+
+    assertion  =
+      case Json.decodeString myDecoder jsonString of
+        Ok _ ->
+          fail "expected `customDecoder` to produce a value of type Err, but got Ok"
+
+        Err message ->
+          if String.contains customErrorMessage message then
+            pass
+
+          else
+            fail <|
+              "expected `customDecoder` to preserve user's error message '"
+              ++ customErrorMessage ++ "', but instead got: " ++ message
+  in
+    test "customDecoder preserves user error messages" assertion
+