elm-rails 0.2.0 → 0.2.1

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/CodeGen.elm

@@ -1,59 +0,0 @@
-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/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Dict.elm

@@ -1,79 +0,0 @@
-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/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Equality.elm

@@ -1,28 +0,0 @@
-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/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Json.elm

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

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/List.elm

@@ -1,165 +0,0 @@
-module Test.List exposing (tests)
-
-import ElmTest exposing (..)
-
-import Basics exposing (..)
-import Maybe exposing (Maybe(Nothing, Just))
-import List exposing (..)
-
-
-tests : Test
-tests = suite "List Tests"
-  [ testListOfN 0
-  , testListOfN 1
-  , testListOfN 2
-  , testListOfN 5000
-  ]
-
-
-testListOfN : Int -> Test
-testListOfN n =
-  let xs = [1..n]
-      xsOpp = [(-n)..(-1)]
-      xsNeg = foldl (::) [] xsOpp -- assume foldl and (::) work
-      zs = [0..n]
-      sumSeq k = k * (k + 1) // 2
-      xsSum = sumSeq n
-      mid = n // 2
-  in
-      suite (toString n ++ " elements")
-        [ suite "foldl"
-            [ test "order" <| assertEqual (n) (foldl (\x acc -> x) 0 xs)
-            , test "total" <| assertEqual (xsSum) (foldl (+) 0 xs)
-            ]
-
-        , suite "foldr"
-            [ test "order" <| assertEqual (min 1 n) (foldr (\x acc -> x) 0 xs)
-            , test "total" <| assertEqual (xsSum) (foldl (+) 0 xs)
-            ]
-
-        , suite "map"
-            [ test "identity" <| assertEqual (xs) (map identity xs)
-            , test "linear" <| assertEqual ([2..(n + 1)]) (map ((+) 1) xs)
-            ]
-
-        , test "isEmpty" <| assertEqual (n == 0) (isEmpty xs)
-
-        , test "length" <| assertEqual (n) (length xs)
-
-        , test "reverse" <| assertEqual (xsOpp) (reverse xsNeg)
-
-        , suite "member"
-            [ test "positive" <| assertEqual (True) (member n zs)
-            , test "negative" <| assertEqual (False) (member (n + 1) xs)
-            ]
-
-        , test "head" <|
-            if n == 0
-            then assertEqual (Nothing) (head xs)
-            else assertEqual (Just 1) (head xs)
-
-        , suite "filter"
-            [ test "none" <| assertEqual ([]) (filter (\x -> x > n) xs)
-            , test "one" <| assertEqual ([n]) (filter (\z -> z == n) zs)
-            , test "all" <| assertEqual (xs) (filter (\x -> x <= n) xs)
-            ]
-
-        , suite "take"
-            [ test "none" <| assertEqual ([]) (take 0 xs)
-            , test "some" <| assertEqual ([0..(n - 1)]) (take n zs)
-            , test "all" <| assertEqual (xs) (take n xs)
-            , test "all+" <| assertEqual (xs) (take (n + 1) xs)
-            ]
-
-        , suite "drop"
-            [ test "none" <| assertEqual (xs) (drop 0 xs)
-            , test "some" <| assertEqual ([n]) (drop n zs)
-            , test "all" <| assertEqual ([]) (drop n xs)
-            , test "all+" <| assertEqual ([]) (drop (n + 1) xs)
-            ]
-
-        , test "repeat" <| assertEqual (map (\x -> -1) xs) (repeat n -1)
-
-        , test "append" <| assertEqual (xsSum * 2) (append xs xs |> foldl (+) 0)
-
-        , test "(::)" <| assertEqual (append [-1] xs) (-1 :: xs)
-
-        , test "concat" <| assertEqual (append xs (append zs xs)) (concat [xs, zs, xs])
-
-        , test "intersperse" <| assertEqual
-            (min -(n - 1) 0, xsSum)
-            (intersperse -1 xs |> foldl (\x (c1, c2) -> (c2, c1 + x)) (0, 0))
-
-        , suite "partition"
-            [ test "left" <| assertEqual (xs, []) (partition (\x -> x > 0) xs)
-            , test "right" <| assertEqual ([], xs) (partition (\x -> x < 0) xs)
-            , test "split" <| assertEqual ([mid + 1..n], [1..mid]) (partition (\x -> x > mid) xs)
-            ]
-
-        , suite "map2"
-            [ test "same length" <| assertEqual (map ((*) 2) xs) (map2 (+) xs xs)
-            , test "long first" <| assertEqual (map (\x -> x * 2 - 1) xs) (map2 (+) zs xs)
-            , test "short first" <| assertEqual (map (\x -> x * 2 - 1) xs) (map2 (+) xs zs)
-            ]
-
-        , test "unzip" <| assertEqual (xsNeg, xs) (map (\x -> (-x, x)) xs |> unzip)
-
-        , suite "filterMap"
-            [ test "none" <| assertEqual ([]) (filterMap (\x -> Nothing) xs)
-            , test "all" <| assertEqual (xsNeg) (filterMap (\x -> Just -x) xs)
-            , let halve x =
-                    if x % 2 == 0
-                      then Just (x // 2)
-                      else Nothing
-              in
-                  test "some" <| assertEqual ([1..mid]) (filterMap halve xs)
-            ]
-
-        , suite "concatMap"
-            [ test "none" <| assertEqual ([]) (concatMap (\x -> []) xs)
-            , test "all" <| assertEqual (xsNeg) (concatMap (\x -> [-x]) xs)
-            ]
-
-        , test "indexedMap" <| assertEqual (map2 (,) zs xsNeg) (indexedMap (\i x -> (i, -x)) xs)
-
-        , test "sum" <| assertEqual (xsSum) (sum xs)
-
-        , test "product" <| assertEqual (0) (product zs)
-
-        , test "maximum" <|
-            if n == 0
-            then assertEqual (Nothing) (maximum xs)
-            else assertEqual (Just n) (maximum xs)
-
-        , test "minimum" <|
-            if n == 0
-            then assertEqual (Nothing) (minimum xs)
-            else assertEqual (Just 1) (minimum xs)
-
-        , suite "all"
-            [ test "false" <| assertEqual (False) (all (\z -> z < n) zs)
-            , test "true" <| assertEqual (True) (all (\x -> x <= n) xs)
-            ]
-
-        , suite "any"
-            [ test "false" <| assertEqual (False) (any (\x -> x > n) xs)
-            , test "true" <| assertEqual (True) (any (\z -> z >= n) zs)
-            ]
-
-        , suite "sort"
-            [ test "sorted" <| assertEqual (xs) (sort xs)
-            , test "unsorted" <| assertEqual (xsOpp) (sort xsNeg)
-            ]
-
-        , suite "sortBy"
-            [ test "sorted" <| assertEqual (xsNeg) (sortBy negate xsNeg)
-            , test "unsorted" <| assertEqual (xsNeg) (sortBy negate xsOpp)
-            ]
-
-        , suite "sortWith"
-            [ test "sorted" <| assertEqual (xsNeg) (sortWith (flip compare) xsNeg)
-            , test "unsorted" <| assertEqual (xsNeg) (sortWith (flip compare) xsOpp)
-            ]
-
-        , test "scanl" <| assertEqual (0 :: map sumSeq xs) (scanl (+) 0 xs)
-        ]

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/tests/Test/Regex.elm

@@ -1,46 +0,0 @@
-module Test.Regex exposing (tests)
-
-import Basics exposing (..)
-
-import Regex exposing (..)
-
-import ElmTest exposing (..)
-
-
-tests : Test
-tests =
-  let simpleTests = suite "Simple Stuff"
-        [ test "split All" <| assertEqual ["a", "b"] (split All (regex ",") "a,b")
-        , test "split" <| assertEqual ["a","b,c"] (split (AtMost 1) (regex ",") "a,b,c")
-        , test "split idempotent" <|
-            let
-                findComma = regex ","
-            in
-                assertEqual
-                    (split (AtMost 1) findComma "a,b,c,d,e")
-                    (split (AtMost 1) findComma "a,b,c,d,e")
-
-        , test "find All" <| assertEqual
-            ([Match "a" [] 0 1, Match "b" [] 1 2])
-            (find All (regex ".") "ab")
-        , test "find All" <| assertEqual
-            ([Match "" [] 0 1])
-            (find All (regex ".*") "")
-
-        , test "replace AtMost 0" <| assertEqual             "The quick brown fox"
-            (replace (AtMost 0) (regex "[aeiou]") (\_ -> "") "The quick brown fox")
-
-        , test "replace AtMost 1" <| assertEqual             "Th quick brown fox"
-            (replace (AtMost 1) (regex "[aeiou]") (\_ -> "") "The quick brown fox")
-
-        , test "replace AtMost 2" <| assertEqual             "Th qick brown fox"
-            (replace (AtMost 2) (regex "[aeiou]") (\_ -> "") "The quick brown fox")
-
-        , test "replace All" <| assertEqual           "Th qck brwn fx"
-            (replace All (regex "[aeiou]") (\_ -> "") "The quick brown fox")
-
-        , test "replace using index" <| assertEqual                   "a1b3c"
-            (replace All (regex ",") (\match -> toString match.index) "a,b,c")
-        ]
-  in
-      suite "Regex" [ simpleTests ]