[
    {
        "name": "Test.Runner",
        "comment": " This is an \"experts only\" module that exposes functions needed to run and\ndisplay tests. A typical user will use an existing runner library for Node or\nthe browser, which is implemented using this interface. A list of these runners\ncan be found in the `README`.\n\n\n## Runner\n\n@docs Runner, SeededRunners, fromTest\n\n\n## Expectations\n\n@docs getFailure, isTodo\n\n\n## Formatting\n\n@docs formatLabels\n\n\n## Fuzzers\n\nThese functions give you the ability to run fuzzers separate of running fuzz tests.\n\n@docs Shrinkable, fuzz, shrink\n\n",
        "unions": [
            {
                "name": "SeededRunners",
                "comment": " ",
                "args": [],
                "cases": [
                    [
                        "Plain",
                        [
                            "List Runner"
                        ]
                    ],
                    [
                        "Only",
                        [
                            "List Runner"
                        ]
                    ],
                    [
                        "Skipping",
                        [
                            "List Runner"
                        ]
                    ],
                    [
                        "Invalid",
                        [
                            "String"
                        ]
                    ]
                ]
            },
            {
                "name": "Shrinkable",
                "comment": " A `Shrinkable a` is an opaque type that allows you to obtain a value of type\n`a` that is smaller than the one you've previously obtained.\n",
                "args": [
                    "a"
                ],
                "cases": []
            }
        ],
        "aliases": [
            {
                "name": "Runner",
                "comment": " A function which, when evaluated, produces a list of expectations. Also a\nlist of labels which apply to this outcome.\n",
                "args": [],
                "type": "{ run : () -> List Expectation, labels : List String }"
            }
        ],
        "values": [
            {
                "name": "formatLabels",
                "comment": " A standard way to format descriptions and test labels, to keep things\nconsistent across test runner implementations.\n\nThe HTML, Node, String, and Log runners all use this.\n\nWhat it does:\n\n  - drop any labels that are empty strings\n  - format the first label differently from the others\n  - reverse the resulting list\n\nExample:\n\n    [ \"the actual test that failed\"\n    , \"nested description failure\"\n    , \"top-level description failure\"\n    ]\n    |> formatLabels ((++) \"↓ \") ((++) \"✗ \")\n\n    {-\n    [ \"↓ top-level description failure\"\n    , \"↓ nested description failure\"\n    , \"✗ the actual test that failed\"\n    ]\n    -}\n\n",
                "type": "(String -> format) -> (String -> format) -> List String -> List format"
            },
            {
                "name": "fromTest",
                "comment": " Convert a `Test` into `SeededRunners`.\n\nIn order to run any fuzz tests that the `Test` may have, it requires a default run count as well\nas an initial `Random.Pcg.Seed`. `100` is a good run count. To obtain a good random seed, pass a\nrandom 32-bit integer to `Random.Pcg.initialSeed`. You can obtain such an integer by running\n`Math.floor(Math.random()*0xFFFFFFFF)` in Node. It's typically fine to hard-code this value into\nyour Elm code; it's easy and makes your tests reproducible.\n\n",
                "type": "Int -> Seed -> Test -> SeededRunners"
            },
            {
                "name": "fuzz",
                "comment": " Given a fuzzer, return a random generator to produce a value and a\nShrinkable. The value is what a fuzz test would have received as input.\n",
                "type": "Fuzzer a -> Generator ( a, Shrinkable a )"
            },
            {
                "name": "getFailure",
                "comment": " Return `Nothing` if the given [`Expectation`](#Expectation) is a [`pass`](#pass).\n\nIf it is a [`fail`](#fail), return a record containing the failure message,\nalong with the given inputs if it was a fuzz test. (If no inputs were involved,\nthe record's `given` field will be `Nothing`).\n\nFor example, if a fuzz test generates random integers, this might return\n`{ message = \"it was supposed to be positive\", given = \"-1\" }`\n\n    getFailure (Expect.fail \"this failed\")\n    -- Just { message = \"this failed\", given = \"\" }\n\n    getFailure (Expect.pass)\n    -- Nothing\n\n",
                "type": "Expectation -> Maybe { given : Maybe String, message : String }"
            },
            {
                "name": "isTodo",
                "comment": " Determine if an expectation was created by a call to `Test.todo`. Runners\nmay treat these tests differently in their output.\n",
                "type": "Expectation -> Bool"
            },
            {
                "name": "shrink",
                "comment": " Given a Shrinkable, attempt to shrink the value further. Pass `False` to\nindicate that the last value you've seen (from either `fuzz` or this function)\ncaused the test to **fail**. This will attempt to find a smaller value. Pass\n`True` if the test passed. If you have already seen a failure, this will attempt\nto shrink that failure in another way. In both cases, it may be impossible to\nshrink the value, represented by `Nothing`.\n",
                "type": "Bool -> Shrinkable a -> Maybe ( a, Shrinkable a )"
            }
        ],
        "binops": []
    },
    {
        "name": "Test",
        "comment": " A module containing functions for creating and managing tests.\n\n@docs Test, test\n\n\n## Organizing Tests\n\n@docs describe, concat, todo, skip, only\n\n\n## Fuzz Testing\n\n@docs fuzz, fuzz2, fuzz3, fuzz4, fuzz5, fuzzWith, FuzzOptions\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "FuzzOptions",
                "comment": " Options [`fuzzWith`](#fuzzWith) accepts. Currently there is only one but this\nAPI is designed so that it can accept more in the future.\n\n\n### `runs`\n\nThe number of times to run each fuzz test. (Default is 100.)\n\n    import Test exposing (fuzzWith)\n    import Fuzz exposing (list, int)\n    import Expect\n\n\n    fuzzWith { runs = 350 } (list int) \"List.length should always be positive\" <|\n        -- This anonymous function will be run 350 times, each time with a\n        -- randomly-generated fuzzList value. (It will always be a list of ints\n        -- because of (list int) above.)\n        \\fuzzList ->\n            fuzzList\n                |> List.length\n                |> Expect.atLeast 0\n\n",
                "args": [],
                "type": "{ runs : Int }"
            },
            {
                "name": "Test",
                "comment": " A test which has yet to be evaluated. When evaluated, it produces one\nor more [`Expectation`](../Expect#Expectation)s.\n\nSee [`test`](#test) and [`fuzz`](#fuzz) for some ways to create a `Test`.\n\n",
                "args": [],
                "type": "Test"
            }
        ],
        "values": [
            {
                "name": "concat",
                "comment": " Run each of the given tests.\n\n    concat [ testDecoder, testSorting ]\n\n",
                "type": "List Test -> Test"
            },
            {
                "name": "describe",
                "comment": " Apply a description to a list of tests.\n\n    import Test exposing (describe, test, fuzz)\n    import Fuzz exposing (int)\n    import Expect\n\n\n    describe \"List\"\n        [ describe \"reverse\"\n            [ test \"has no effect on an empty list\" <|\n                \\() ->\n                    List.reverse []\n                        |> Expect.equal []\n            , fuzz int \"has no effect on a one-item list\" <|\n                \\num ->\n                     List.reverse [ num ]\n                        |> Expect.equal [ num ]\n            ]\n        ]\n\nPassing an empty list will result in a failing test, because you either made a\nmistake or are creating a placeholder.\n\n",
                "type": "String -> List Test -> Test"
            },
            {
                "name": "fuzz",
                "comment": " Take a function that produces a test, and calls it several (usually 100) times, using a randomly-generated input\nfrom a [`Fuzzer`](http://package.elm-lang.org/packages/elm-community/elm-test/latest/Fuzz) each time. This allows you to\ntest that a property that should always be true is indeed true under a wide variety of conditions. The function also\ntakes a string describing the test.\n\nThese are called \"[fuzz tests](https://en.wikipedia.org/wiki/Fuzz_testing)\" because of the randomness.\nYou may find them elsewhere called [property-based tests](http://blog.jessitron.com/2013/04/property-based-testing-what-is-it.html),\n[generative tests](http://www.pivotaltracker.com/community/tracker-blog/generative-testing), or\n[QuickCheck-style tests](https://en.wikipedia.org/wiki/QuickCheck).\n\n    import Test exposing (fuzz)\n    import Fuzz exposing (list, int)\n    import Expect\n\n\n    fuzz (list int) \"List.length should always be positive\" <|\n        -- This anonymous function will be run 100 times, each time with a\n        -- randomly-generated fuzzList value.\n        \\fuzzList ->\n            fuzzList\n                |> List.length\n                |> Expect.atLeast 0\n\n",
                "type": "Fuzzer a -> String -> (a -> Expectation) -> Test"
            },
            {
                "name": "fuzz2",
                "comment": " Run a [fuzz test](#fuzz) using two random inputs.\n\nThis is a convenience function that lets you skip calling [`Fuzz.tuple`](Fuzz#tuple).\n\nSee [`fuzzWith`](#fuzzWith) for an example of writing this in tuple style.\n\n    import Test exposing (fuzz2)\n    import Fuzz exposing (list, int)\n\n\n    fuzz2 (list int) int \"List.reverse never influences List.member\" <|\n        \\nums target ->\n            List.member target (List.reverse nums)\n                |> Expect.equal (List.member target nums)\n\n",
                "type": "Fuzzer a -> Fuzzer b -> String -> (a -> b -> Expectation) -> Test"
            },
            {
                "name": "fuzz3",
                "comment": " Run a [fuzz test](#fuzz) using three random inputs.\n\nThis is a convenience function that lets you skip calling [`Fuzz.tuple3`](Fuzz#tuple3).\n\n",
                "type": "Fuzzer a -> Fuzzer b -> Fuzzer c -> String -> (a -> b -> c -> Expectation) -> Test"
            },
            {
                "name": "fuzz4",
                "comment": " Run a [fuzz test](#fuzz) using four random inputs.\n\nThis is a convenience function that lets you skip calling [`Fuzz.tuple4`](Fuzz#tuple4).\n\n",
                "type": "Fuzzer a -> Fuzzer b -> Fuzzer c -> Fuzzer d -> String -> (a -> b -> c -> d -> Expectation) -> Test"
            },
            {
                "name": "fuzz5",
                "comment": " Run a [fuzz test](#fuzz) using five random inputs.\n\nThis is a convenience function that lets you skip calling [`Fuzz.tuple5`](Fuzz#tuple5).\n\n",
                "type": "Fuzzer a -> Fuzzer b -> Fuzzer c -> Fuzzer d -> Fuzzer e -> String -> (a -> b -> c -> d -> e -> Expectation) -> Test"
            },
            {
                "name": "fuzzWith",
                "comment": " Run a [`fuzz`](#fuzz) test with the given [`FuzzOptions`](#FuzzOptions).\n\nNote that there is no `fuzzWith2`, but you can always pass more fuzz values in\nusing [`Fuzz.tuple`](Fuzz#tuple), [`Fuzz.tuple3`](Fuzz#tuple3),\nfor example like this:\n\n    import Test exposing (fuzzWith)\n    import Fuzz exposing (tuple, list, int)\n    import Expect\n\n\n    fuzzWith { runs = 4200 }\n        (tuple ( list int, int ))\n        \"List.reverse never influences List.member\" <|\n            \\(nums, target) ->\n                List.member target (List.reverse nums)\n                    |> Expect.equal (List.member target nums)\n\n",
                "type": "FuzzOptions -> Fuzzer a -> String -> (a -> Expectation) -> Test"
            },
            {
                "name": "only",
                "comment": " Returns a [`Test`](#Test) that causes other tests to be skipped, and\nonly runs the given one.\n\nCalls to `only` aren't meant to be committed to version control. Instead, use\nthem when you want to focus on getting a particular subset of your tests to pass.\nIf you use `only`, your entire test suite will fail, even if\neach of the individual tests pass. This is to help avoid accidentally\ncommitting a `only` to version control.\n\nIf you you use `only` on multiple tests, only those tests will run. If you\nput a `only` inside another `only`, only the outermost `only`\nwill affect which tests gets run.\n\nSee also [`skip`](#skip). Note that `skip` takes precedence over `only`;\nif you use a `skip` inside an `only`, it will still get skipped, and if you use\nan `only` inside a `skip`, it will also get skipped.\n\n    describe \"List\"\n        [ only <| describe \"reverse\"\n            [ test \"has no effect on an empty list\" <|\n                \\() ->\n                    List.reverse []\n                        |> Expect.equal []\n            , fuzz int \"has no effect on a one-item list\" <|\n                \\num ->\n                     List.reverse [ num ]\n                        |> Expect.equal [ num ]\n            ]\n        , test \"This will not get run, because of the `only` above!\" <|\n            \\() ->\n                List.length []\n                    |> Expect.equal 0\n        ]\n\n",
                "type": "Test -> Test"
            },
            {
                "name": "skip",
                "comment": " Returns a [`Test`](#Test) that gets skipped.\n\nCalls to `skip` aren't meant to be committed to version control. Instead, use\nit when you want to focus on getting a particular subset of your tests to\npass. If you use `skip`, your entire test suite will fail, even if\neach of the individual tests pass. This is to help avoid accidentally\ncommitting a `skip` to version control.\n\nSee also [`only`](#only). Note that `skip` takes precedence over `only`;\nif you use a `skip` inside an `only`, it will still get skipped, and if you use\nan `only` inside a `skip`, it will also get skipped.\n\n    describe \"List\"\n        [ skip <| describe \"reverse\"\n            [ test \"has no effect on an empty list\" <|\n                \\() ->\n                    List.reverse []\n                        |> Expect.equal []\n            , fuzz int \"has no effect on a one-item list\" <|\n                \\num ->\n                     List.reverse [ num ]\n                        |> Expect.equal [ num ]\n            ]\n        , test \"This is the only test that will get run; the other was skipped!\" <|\n            \\() ->\n                List.length []\n                    |> Expect.equal 0\n        ]\n\n",
                "type": "Test -> Test"
            },
            {
                "name": "test",
                "comment": " Return a [`Test`](#Test) that evaluates a single\n[`Expectation`](../Expect#Expectation).\n\n    import Test exposing (fuzz)\n    import Expect\n\n\n    test \"the empty list has 0 length\" <|\n        \\() ->\n            List.length []\n                |> Expect.equal 0\n\n",
                "type": "String -> (() -> Expectation) -> Test"
            },
            {
                "name": "todo",
                "comment": " Returns a [`Test`](#Test) that is \"TODO\" (not yet implemented). These tests\nalways fail, but test runners will only include them in their output if there\nare no other failures.\n\nThese tests aren't meant to be committed to version control. Instead, use them\nwhen you're brainstorming lots of tests you'd like to write, but you can't\nimplement them all at once. When you replace `todo` with a real test, you'll be\nable to see if it fails without clutter from tests still not implemented. But,\nunlike leaving yourself comments, you'll be prompted to implement these tests\nbecause your suite will fail.\n\n    describe \"a new thing\"\n        [ todo \"does what is expected in the common case\"\n        , todo \"correctly handles an edge case I just thought of\"\n        ]\n\nThis functionality is similar to \"pending\" tests in other frameworks, except\nthat a TODO test is considered failing but a pending test often is not.\n\n",
                "type": "String -> Test"
            }
        ],
        "binops": []
    },
    {
        "name": "Expect",
        "comment": " A library to create `Expectation`s, which describe a claim to be tested.\n\n\n## Quick Reference\n\n  - [`equal`](#equal) `(arg2 == arg1)`\n  - [`notEqual`](#notEqual) `(arg2 /= arg1)`\n  - [`lessThan`](#lessThan) `(arg2 < arg1)`\n  - [`atMost`](#atMost) `(arg2 <= arg1)`\n  - [`greaterThan`](#greaterThan) `(arg2 > arg1)`\n  - [`atLeast`](#atLeast) `(arg2 >= arg1)`\n  - [`true`](#true) `(arg == True)`\n  - [`false`](#false) `(arg == False)`\n  - [`notWithin`](#notWithin) `(float inequality)`\n\n\n## Basic Expectations\n\n@docs Expectation, equal, notEqual, all\n\n\n## Comparisons\n\n@docs lessThan, atMost, greaterThan, atLeast\n\n\n## Booleans\n\n@docs true, false\n\n\n## Collections\n\n@docs err, equalLists, equalDicts, equalSets\n\n\n## Customizing\n\n@docs pass, fail, onFail\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "Expectation",
                "comment": " The result of a single test run: either a [`pass`](#pass) or a\n[`fail`](#fail).\n",
                "args": [],
                "type": "Expectation"
            }
        ],
        "values": [
            {
                "name": "all",
                "comment": " Passes if each of the given functions passes when applied to the subject.\n**NOTE:** Passing an empty list is assumed to be a mistake, so `Expect.all []`\nwill always return a failed expectation no matter what else it is passed.\n\n    Expect.all\n        [ Expect.greaterThan -2\n        , Expect.lessThan 5\n        ]\n        (List.length [])\n    -- Passes because (0 > -2) is True and (0 < 5) is also True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because (0 < -10) is False\n    List.length []\n        |> Expect.all\n            [ Expect.greaterThan -2\n            , Expect.lessThan -10\n            , Expect.equal 0\n            ]\n    {-\n    0\n    ╷\n    │ Expect.lessThan\n    ╵\n    -10\n    -}\n\n",
                "type": "List (subject -> Expectation) -> subject -> Expectation"
            },
            {
                "name": "atLeast",
                "comment": " Passes if the second argument is greater than or equal to the first.\n\n    Expect.atLeast -2 (List.length [])\n\n    -- Passes because (0 >= -2) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because (0 >= 3) is False\n    List.length []\n        |> Expect.atLeast 3\n\n    {-\n\n    0\n    ╷\n    │ Expect.atLeast\n    ╵\n    3\n\n    -}\n\n",
                "type": "comparable -> comparable -> Expectation"
            },
            {
                "name": "atMost",
                "comment": " Passes if the second argument is less than or equal to the first.\n\n    Expect.atMost 1 (List.length [])\n\n    -- Passes because (0 <= 1) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because (0 <= -3) is False\n    List.length []\n        |> Expect.atMost -3\n\n    {-\n\n    0\n    ╷\n    │ Expect.atMost\n    ╵\n    -3\n\n    -}\n\n",
                "type": "comparable -> comparable -> Expectation"
            },
            {
                "name": "equal",
                "comment": " Passes if the arguments are equal.\n\n    Expect.equal 0 (List.length [])\n\n    -- Passes because (0 == 0) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because the expected value didn't split the space in \"Betty Botter\"\n    String.split \" \" \"Betty Botter bought some butter\"\n        |> Expect.equal [ \"Betty Botter\", \"bought\", \"some\", \"butter\" ]\n\n    {-\n\n    [ \"Betty\", \"Botter\", \"bought\", \"some\", \"butter\" ]\n    ╷\n    │ Expect.equal\n    ╵\n    [ \"Betty Botter\", \"bought\", \"some\", \"butter\" ]\n\n    -}\n\n",
                "type": "a -> a -> Expectation"
            },
            {
                "name": "equalDicts",
                "comment": " Passes if the arguments are equal dicts.\n\n    -- Passes\n    (Dict.fromList [ ( 1, \"one\" ), ( 2, \"two\" ) ])\n        |> Expect.equalDicts (Dict.fromList [ ( 1, \"one\" ), ( 2, \"two\" ) ])\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which, and reports which keys were missing from\nor added to each dict:\n\n    -- Fails\n    (Dict.fromList [ ( 1, \"one\" ), ( 2, \"too\" ) ])\n        |> Expect.equalDicts (Dict.fromList [ ( 1, \"one\" ), ( 2, \"two\" ), ( 3, \"three\" ) ])\n\n    {-\n\n    Dict.fromList [(1,\"one\"),(2,\"too\")]\n    diff: -[ (2,\"two\"), (3,\"three\") ] +[ (2,\"too\") ]\n    ╷\n    │ Expect.equalDicts\n    ╵\n    diff: +[ (2,\"two\"), (3,\"three\") ] -[ (2,\"too\") ]\n    Dict.fromList [(1,\"one\"),(2,\"two\"),(3,\"three\")]\n\n    -}\n\n",
                "type": "Dict comparable a -> Dict comparable a -> Expectation"
            },
            {
                "name": "equalLists",
                "comment": " Passes if the arguments are equal lists.\n\n    -- Passes\n    [1, 2, 3]\n        |> Expect.equalLists [1, 2, 3]\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which, and reports which index the lists first\ndiffered at or which list was longer:\n\n    -- Fails\n    [ 1, 2, 4, 6 ]\n        |> Expect.equalLists [ 1, 2, 5 ]\n\n    {-\n\n    [1,2,4,6]\n    first diff at index index 2: +`4`, -`5`\n    ╷\n    │ Expect.equalLists\n    ╵\n    first diff at index index 2: +`5`, -`4`\n    [1,2,5]\n\n    -}\n\n",
                "type": "List a -> List a -> Expectation"
            },
            {
                "name": "equalSets",
                "comment": " Passes if the arguments are equal sets.\n\n    -- Passes\n    (Set.fromList [1, 2])\n        |> Expect.equalSets (Set.fromList [1, 2])\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which, and reports which keys were missing from\nor added to each set:\n\n    -- Fails\n    (Set.fromList [ 1, 2, 4, 6 ])\n        |> Expect.equalSets (Set.fromList [ 1, 2, 5 ])\n\n    {-\n\n    Set.fromList [1,2,4,6]\n    diff: -[ 5 ] +[ 4, 6 ]\n    ╷\n    │ Expect.equalSets\n    ╵\n    diff: +[ 5 ] -[ 4, 6 ]\n    Set.fromList [1,2,5]\n\n    -}\n\n",
                "type": "Set comparable -> Set comparable -> Expectation"
            },
            {
                "name": "err",
                "comment": " Passes if the\n[`Result`](http://package.elm-lang.org/packages/elm-lang/core/latest/Result) is\nan `Err` rather than `Ok`. This is useful for tests where you expect to get an\nerror but you don't care about what the actual error is. If your possibly\nerroring function returns a `Maybe`, simply use `Expect.equal Nothing`.\n\n    -- Passes\n    String.toInt \"not an int\"\n        |> Expect.err\n\nTest failures will be printed with the unexpected `Ok` value contrasting with\nany `Err`.\n\n    -- Fails\n    String.toInt \"20\"\n        |> Expect.err\n\n    {-\n\n    Ok 20\n    ╷\n    │ Expect.err\n    ╵\n    Err _\n\n    -}\n\n",
                "type": "Result a b -> Expectation"
            },
            {
                "name": "fail",
                "comment": " Fails with the given message.\n\n    import Json.Decode exposing (decodeString, int)\n    import Test exposing (test)\n    import Expect\n\n\n    test \"Json.Decode.int can decode the number 42.\" <|\n        \\() ->\n            case decodeString int \"42\" of\n                Ok _ ->\n                    Expect.pass\n\n                Err err ->\n                    Expect.fail err\n\n",
                "type": "String -> Expectation"
            },
            {
                "name": "false",
                "comment": " Passes if the argument is 'False', and otherwise fails with the given message.\n\n    Expect.false \"Expected the list not to be empty.\" (List.isEmpty [ 42 ])\n\n    -- Passes because (List.isEmpty [ 42 ]) is False\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because (List.isEmpty []) is True\n    List.isEmpty []\n        |> Expect.false \"Expected the list not to be empty.\"\n\n    {-\n\n    Expected the list not to be empty.\n\n    -}\n\n",
                "type": "String -> Bool -> Expectation"
            },
            {
                "name": "greaterThan",
                "comment": " Passes if the second argument is greater than the first.\n\n    Expect.greaterThan -2 List.length []\n\n    -- Passes because (0 > -2) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because (0 > 1) is False\n    List.length []\n        |> Expect.greaterThan 1\n\n    {-\n\n    0\n    ╷\n    │ Expect.greaterThan\n    ╵\n    1\n\n    -}\n\n",
                "type": "comparable -> comparable -> Expectation"
            },
            {
                "name": "lessThan",
                "comment": " Passes if the second argument is less than the first.\n\n    Expect.lessThan 1 (List.length [])\n\n    -- Passes because (0 < 1) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because (0 < -1) is False\n    List.length []\n        |> Expect.lessThan -1\n\n\n    {-\n\n    0\n    ╷\n    │ Expect.lessThan\n    ╵\n    -1\n\n    -}\n\n",
                "type": "comparable -> comparable -> Expectation"
            },
            {
                "name": "notEqual",
                "comment": " Passes if the arguments are not equal.\n\n    -- Passes because (11 /= 100) is True\n    90 + 10\n        |> Expect.notEqual 11\n\n\n    -- Fails because (100 /= 100) is False\n    90 + 10\n        |> Expect.notEqual 100\n\n    {-\n\n    100\n    ╷\n    │ Expect.notEqual\n    ╵\n    100\n\n    -}\n\n",
                "type": "a -> a -> Expectation"
            },
            {
                "name": "onFail",
                "comment": " If the given expectation fails, replace its failure message with a custom one.\n\n    \"something\"\n        |> Expect.equal \"something else\"\n        |> Expect.onFail \"thought those two strings would be the same\"\n\n",
                "type": "String -> Expectation -> Expectation"
            },
            {
                "name": "pass",
                "comment": " Always passes.\n\n    import Json.Decode exposing (decodeString, int)\n    import Test exposing (test)\n    import Expect\n\n\n    test \"Json.Decode.int can decode the number 42.\" <|\n        \\() ->\n            case decodeString int \"42\" of\n                Ok _ ->\n                    Expect.pass\n\n                Err err ->\n                    Expect.fail err\n\n",
                "type": "Expectation"
            },
            {
                "name": "true",
                "comment": " Passes if the argument is 'True', and otherwise fails with the given message.\n\n    Expect.true \"Expected the list to be empty.\" (List.isEmpty [])\n\n    -- Passes because (List.isEmpty []) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because List.isEmpty returns False, but we expect True.\n    List.isEmpty [ 42 ]\n        |> Expect.true \"Expected the list to be empty.\"\n\n    {-\n\n    Expected the list to be empty.\n\n    -}\n\n",
                "type": "String -> Bool -> Expectation"
            }
        ],
        "binops": []
    },
    {
        "name": "Fuzz",
        "comment": " This is a library of *fuzzers* you can use to supply values to your fuzz\ntests. You can typically pick out which ones you need according to their types.\n\nA `Fuzzer a` knows how to create values of type `a` in two different ways. It\ncan create them randomly, so that your test's expectations are run against many\nvalues. Fuzzers will often generate edge cases likely to find bugs. If the\nfuzzer can make your test fail, it also knows how to \"shrink\" that failing input\ninto more minimal examples, some of which might also cause the tests to fail. In\nthis way, fuzzers can usually find the smallest or simplest input that\nreproduces a bug.\n\n\n## Common Fuzzers\n\n@docs bool, int, intRange, float, floatRange, percentage, string, maybe, result, list, array\n\n\n## Working with Fuzzers\n\n@docs Fuzzer, constant, map, map2, map3,map4, map5, andMap, andThen, frequency, conditional\n\n\n## Tuple Fuzzers\n\nInstead of using a tuple, consider using `fuzzN`.\n@docs tuple, tuple3, tuple4, tuple5\n\n\n## Uncommon Fuzzers\n\n@docs custom, char, unit, order, invalid\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "Fuzzer",
                "comment": " The representation of fuzzers is opaque. Conceptually, a `Fuzzer a`\nconsists of a way to randomly generate values of type `a`, and a way to shrink\nthose values.\n",
                "args": [
                    "a"
                ],
                "type": "Fuzzer a"
            }
        ],
        "values": [
            {
                "name": "andMap",
                "comment": " Map over many fuzzers. This can act as mapN for N > 5.\n\nThe argument order is meant to accommodate chaining:\n\n    map f aFuzzer\n        |> andMap anotherFuzzer\n        |> andMap aThirdFuzzer\n\nNote that shrinking may be better using mapN.\n\n",
                "type": "Fuzzer a -> Fuzzer (a -> b) -> Fuzzer b"
            },
            {
                "name": "andThen",
                "comment": " Create a fuzzer based on the result of another fuzzer.\n",
                "type": "(a -> Fuzzer b) -> Fuzzer a -> Fuzzer b"
            },
            {
                "name": "array",
                "comment": " Given a fuzzer of a type, create a fuzzer of an array of that type.\nGenerates random arrays of varying length, favoring shorter arrays.\n",
                "type": "Fuzzer a -> Fuzzer (Array a)"
            },
            {
                "name": "bool",
                "comment": " A fuzzer for bool values.\n",
                "type": "Fuzzer Bool"
            },
            {
                "name": "char",
                "comment": " A fuzzer for char values. Generates random ascii chars disregarding the control\ncharacters.\n",
                "type": "Fuzzer Char"
            },
            {
                "name": "conditional",
                "comment": " Conditionally filter a fuzzer to remove occasional undesirable\ninput. Takes a limit for how many retries to attempt, and a fallback\nfunction to, if no acceptable input can be found, create one from an\nunacceptable one. Also takes a condition to determine if the input is\nacceptable or not, and finally the fuzzer itself.\n\nA good number of max retires is ten. A large number of retries might\nblow the stack.\n\n",
                "type": "{ retries : Int, fallback : a -> a, condition : a -> Bool } -> Fuzzer a -> Fuzzer a"
            },
            {
                "name": "constant",
                "comment": " Create a fuzzer that only and always returns the value provided, and performs no shrinking. This is hardly random,\nand so this function is best used as a helper when creating more complicated fuzzers.\n",
                "type": "a -> Fuzzer a"
            },
            {
                "name": "custom",
                "comment": " Build a custom `Fuzzer a` by providing a `Generator a` and a `Shrinker a`.\nGenerators are defined in [`mgold/elm-random-pcg`](http://package.elm-lang.org/packages/mgold/elm-random-pcg/latest),\nwhich is not core's Random module but has a compatible interface. Shrinkers are\ndefined in [`elm-community/shrink`](http://package.elm-lang.org/packages/elm-community/shrink/latest/).\n\nHere is an example for a record:\n\n    import Random.Pcg as Random\n    import Shrink\n\n    type alias Position =\n        { x : Int, y : Int }\n\n    position : Fuzzer Position\n    position =\n        Fuzz.custom\n            (Random.map2 Position (Random.int -100 100) (Random.int -100 100))\n            (\\{ x, y } -> Shrink.map Position (Shrink.int x) |> Shrink.andMap (Shrink.int y))\n\nHere is an example for a custom union type, assuming there is already a `genName : Generator String` defined:\n\n    type Question\n        = Name String\n        | Age Int\n\n    question =\n        let\n            generator =\n                Random.bool\n                    |> Random.andThen\n                        (\\b ->\n                            if b then\n                                Random.map Name genName\n                            else\n                                Random.map Age (Random.int 0 120)\n                        )\n\n            shrinker question =\n                case question of\n                    Name n ->\n                        Shrink.string n |> Shrink.map Name\n\n                    Age i ->\n                        Shrink.int i |> Shrink.map Age\n        in\n            Fuzz.custom generator shrinker\n\nIt is not possible to extract the generator and shrinker from an existing fuzzer.\n\n",
                "type": "Generator a -> Shrinker a -> Fuzzer a"
            },
            {
                "name": "float",
                "comment": " A fuzzer for float values. It will never produce `NaN`, `Infinity`, or `-Infinity`.\n\nIt's possible for this fuzzer to generate any other floating-point value, but it\nfavors numbers between -50 and 50, numbers between -1 and 1, and especially zero.\n\n",
                "type": "Fuzzer Float"
            },
            {
                "name": "floatRange",
                "comment": " A fuzzer for float values within between a given minimum and maximum\nvalue, inclusive. Shrunken values will also be within the range.\n",
                "type": "Float -> Float -> Fuzzer Float"
            },
            {
                "name": "frequency",
                "comment": " Create a new `Fuzzer` by providing a list of probabilistic weights to use\nwith other fuzzers.\n\nFor example, to create a `Fuzzer` that has a 1/4 chance of generating an int\nbetween -1 and -100, and a 3/4 chance of generating one between 1 and 100,\nyou could do this:\n\n    Fuzz.frequency\n        [ ( 1, Fuzz.intRange -100 -1 )\n        , ( 3, Fuzz.intRange 1 100 )\n        ]\n\nThere are a few circumstances in which this function will return an invalid\nfuzzer, which causes it to fail any test that uses it:\n\n  - If you provide an empty list of frequencies\n  - If any of the weights are less than 0\n  - If the weights sum to 0\n\nBe careful recursively using this fuzzer in its arguments. Often using `map`\nis a better way to do what you want. If you are fuzzing a tree-like data\nstructure, you should include a depth limit so to avoid infinite recursion, like\nso:\n\n    type Tree\n        = Leaf\n        | Branch Tree Tree\n\n    tree : Int -> Fuzzer Tree\n    tree i =\n        if i <= 0 then\n            Fuzz.constant Leaf\n        else\n            Fuzz.frequency\n                [ ( 1, Fuzz.constant Leaf )\n                , ( 2, Fuzz.map2 Branch (tree (i - 1)) (tree (i - 1)) )\n                ]\n\n",
                "type": "List ( Float, Fuzzer a ) -> Fuzzer a"
            },
            {
                "name": "int",
                "comment": " A fuzzer for int values. It will never produce `NaN`, `Infinity`, or `-Infinity`.\n\nIt's possible for this fuzzer to generate any 32-bit integer, but it favors\nnumbers between -50 and 50 and especially zero.\n\n",
                "type": "Fuzzer Int"
            },
            {
                "name": "intRange",
                "comment": " A fuzzer for int values within between a given minimum and maximum value,\ninclusive. Shrunken values will also be within the range.\n\nRemember that [Random.maxInt](http://package.elm-lang.org/packages/elm-lang/core/latest/Random#maxInt)\nis the maximum possible int value, so you can do `intRange x Random.maxInt` to get all\nthe ints x or bigger.\n\n",
                "type": "Int -> Int -> Fuzzer Int"
            },
            {
                "name": "invalid",
                "comment": " A fuzzer that is invalid for the provided reason. Any fuzzers built with it\nare also invalid. Any tests using an invalid fuzzer fail.\n",
                "type": "String -> Fuzzer a"
            },
            {
                "name": "list",
                "comment": " Given a fuzzer of a type, create a fuzzer of a list of that type.\nGenerates random lists of varying length, favoring shorter lists.\n",
                "type": "Fuzzer a -> Fuzzer (List a)"
            },
            {
                "name": "map",
                "comment": " Map a function over a fuzzer. This applies to both the generated and the shrunken values.\n",
                "type": "(a -> b) -> Fuzzer a -> Fuzzer b"
            },
            {
                "name": "map2",
                "comment": " Map over two fuzzers.\n",
                "type": "(a -> b -> c) -> Fuzzer a -> Fuzzer b -> Fuzzer c"
            },
            {
                "name": "map3",
                "comment": " Map over three fuzzers.\n",
                "type": "(a -> b -> c -> d) -> Fuzzer a -> Fuzzer b -> Fuzzer c -> Fuzzer d"
            },
            {
                "name": "map4",
                "comment": " Map over four fuzzers.\n",
                "type": "(a -> b -> c -> d -> e) -> Fuzzer a -> Fuzzer b -> Fuzzer c -> Fuzzer d -> Fuzzer e"
            },
            {
                "name": "map5",
                "comment": " Map over five fuzzers.\n",
                "type": "(a -> b -> c -> d -> e -> f) -> Fuzzer a -> Fuzzer b -> Fuzzer c -> Fuzzer d -> Fuzzer e -> Fuzzer f"
            },
            {
                "name": "maybe",
                "comment": " Given a fuzzer of a type, create a fuzzer of a maybe for that type.\n",
                "type": "Fuzzer a -> Fuzzer (Maybe a)"
            },
            {
                "name": "order",
                "comment": " A fuzzer for order values.\n",
                "type": "Fuzzer Order"
            },
            {
                "name": "percentage",
                "comment": " A fuzzer for percentage values. Generates random floats between `0.0` and\n`1.0`. It will test zero and one about 10% of the time each.\n",
                "type": "Fuzzer Float"
            },
            {
                "name": "result",
                "comment": " Given fuzzers for an error type and a success type, create a fuzzer for\na result.\n",
                "type": "Fuzzer error -> Fuzzer value -> Fuzzer (Result error value)"
            },
            {
                "name": "string",
                "comment": " Generates random printable ASCII strings of up to 1000 characters.\n\nShorter strings are more common, especially the empty string.\n\n",
                "type": "Fuzzer String"
            },
            {
                "name": "tuple",
                "comment": " Turn a tuple of fuzzers into a fuzzer of tuples.\n",
                "type": "( Fuzzer a, Fuzzer b ) -> Fuzzer ( a, b )"
            },
            {
                "name": "tuple3",
                "comment": " Turn a 3-tuple of fuzzers into a fuzzer of 3-tuples.\n",
                "type": "( Fuzzer a, Fuzzer b, Fuzzer c ) -> Fuzzer ( a, b, c )"
            },
            {
                "name": "tuple4",
                "comment": " Turn a 4-tuple of fuzzers into a fuzzer of 4-tuples.\n",
                "type": "( Fuzzer a, Fuzzer b, Fuzzer c, Fuzzer d ) -> Fuzzer ( a, b, c, d )"
            },
            {
                "name": "tuple5",
                "comment": " Turn a 5-tuple of fuzzers into a fuzzer of 5-tuples.\n",
                "type": "( Fuzzer a, Fuzzer b, Fuzzer c, Fuzzer d, Fuzzer e ) -> Fuzzer ( a, b, c, d, e )"
            },
            {
                "name": "unit",
                "comment": " A fuzzer for the unit value. Unit is a type with only one value, commonly\nused as a placeholder.\n",
                "type": "Fuzzer ()"
            }
        ],
        "binops": []
    }
]