[{"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  - [Floating Point Comparisons](#floating-point-comparisons)\n\n\n## Basic Expectations\n\n@docs Expectation, equal, notEqual, all\n\n\n## Numeric Comparisons\n\n@docs lessThan, atMost, greaterThan, atLeast\n\n\n## Floating Point Comparisons\n\nThese functions allow you to compare `Float` values up to a specified rounding error, which may be relative, absolute,\nor both. For an in-depth look, see our [Guide to Floating Point Comparison](#guide-to-floating-point-comparison).\n\n@docs FloatingPointTolerance, within, notWithin\n\n\n## Booleans\n\n@docs true, false\n\n\n## Collections\n\n@docs ok, err, equalLists, equalDicts, equalSets\n\n\n## Customizing\n\nThese functions will let you build your own expectations.\n\n@docs pass, fail, onFail\n\n\n## Guide to Floating Point Comparison\n\nIn general, if you are multiplying, you want relative tolerance, and if you're adding,\nyou want absolute tolerance. If you are doing both, you want both kinds of tolerance,\nor to split the calculation into smaller parts for testing.\n\n\n### Absolute Tolerance\n\nLet's say we want to figure out if our estimation of pi is precise enough.\n\nIs `3.14` within `0.01` of `pi`? Yes, because `3.13 < pi < 3.15`.\n\n    test \"3.14 approximates pi with absolute precision\" <|\n        \\_ ->\n            3.14 |> Expect.within (Absolute 0.01) pi\n\n\n### Relative Tolerance\n\nWhat if we also want to know if our circle circumference estimation is close enough?\n\nLet's say our circle has a radius of `r` meters. The formula for circle circumference is `C=2*r*pi`.\nTo make the calculations a bit easier ([ahem](https://tauday.com/tau-manifesto)), we'll look at half the circumference; `C/2=r*pi`.\nIs `r * 3.14` within `0.01` of `r * pi`?\nThat depends, what does `r` equal? If `r` is `0.01`mm, or `0.00001` meters, we're comparing\n`0.00001 * 3.14 - 0.01 < r * pi < 0.00001 * 3.14 + 0.01` or `-0.0099686 < 0.0000314159 < 0.0100314`.\nThat's a huge tolerance! A circumference that is _a thousand times longer_ than we expected would pass that test!\n\nOn the other hand, if `r` is very large, we're going to need many more digits of pi.\nFor an absolute tolerance of `0.01` and a pi estimation of `3.14`, this expectation only passes if `r < 2*pi`.\n\nIf we use a relative tolerance of `0.01` instead, the circle area comparison becomes much better. Is `r * 3.14` within\n`1%` of `r * pi`? Yes! In fact, three digits of pi approximation is always good enough for a 0.1% relative tolerance,\nas long as `r` isn't [too close to zero](https://en.wikipedia.org/wiki/Denormal_number).\n\n    fuzz\n        (floatRange 0.000001 100000)\n        \"Circle half-circumference with relative tolerance\"\n        (\\r -> r * 3.14 |> Expect.within (Relative 0.001) (r * pi))\n\n\n### Trouble with Numbers Near Zero\n\nIf you are adding things near zero, you probably want absolute tolerance. If you're comparing values between `-1` and `1`, you should consider using absolute tolerance.\n\nFor example: Is `1 + 2 - 3` within `1%` of `0`? Well, if `1`, `2` and `3` have any amount of rounding error, you might not get exactly zero. What is `1%` above and below `0`? Zero. We just lost all tolerance. Even if we hard-code the numbers, we might not get exactly zero; `0.1 + 0.2` rounds to a value just above `0.3`, since computers, counting in binary, cannot write down any of those three numbers using a finite number of digits, just like we cannot write `0.333...` exactly in base 10.\n\nAnother example is comparing values that are on either side of zero. `0.0001` is more than `100%` away from `-0.0001`. In fact, `infinity` is closer to `0.0001` than `0.0001` is to `-0.0001`, if you are using a relative tolerance. Twice as close, actually. So even though both `0.0001` and `-0.0001` could be considered very close to zero, they are very far apart relative to each other. The same argument applies for any number of zeroes.\n\n","unions":[{"name":"FloatingPointTolerance","comment":" A type to describe how close a floating point number must be to the expected value for the test to pass. This may be\nspecified as absolute or relative.\n\n`AbsoluteOrRelative` tolerance uses a logical OR between the absolute (specified first) and relative tolerance. If you\nwant a logical AND, use [`Expect.all`](#all).\n\n","args":[],"cases":[["Absolute",["Basics.Float"]],["Relative",["Basics.Float"]],["AbsoluteOrRelative",["Basics.Float","Basics.Float"]]]}],"aliases":[{"name":"Expectation","comment":" The result of a single test run: either a [`pass`](#pass) or a\n[`fail`](#fail).\n","args":[],"type":"Test.Expectation.Expectation"}],"values":[{"name":"all","comment":" Passes if each of the given functions passes when applied to the subject.\n\nPassing 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.List (subject -> Expect.Expectation) -> subject -> Expect.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 -> Expect.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 -> Expect.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\nDo not equate `Float` values; use [`within`](#within) instead.\n\n","type":"a -> a -> Expect.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.Dict comparable a -> Dict.Dict comparable a -> Expect.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.List a -> List.List a -> Expect.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.Set comparable -> Set.Set comparable -> Expect.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 what the actual error is.\n\n_(Tip: If your function returns a `Maybe` instead, consider `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.Result a b -> Expect.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.String -> Expect.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.String -> Basics.Bool -> Expect.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 -> Expect.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\nDo not equate `Float` values; use [`notWithin`](#notWithin) instead.\n\n","type":"comparable -> comparable -> Expect.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 -> Expect.Expectation"},{"name":"notWithin","comment":" Passes if (and only if) a call to `within` with the same arguments would have failed.\n","type":"Expect.FloatingPointTolerance -> Basics.Float -> Basics.Float -> Expect.Expectation"},{"name":"ok","comment":" Passes if the\n[`Result`](https://package.elm-lang.org/packages/lang/core/latest/Result) is\nan `Ok` rather than `Err`. This is useful for tests where you expect not to see\nan error, but you don't care what the actual result is.\n\n_(Tip: If your function returns a `Maybe` instead, consider `Expect.notEqual 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.Result a b -> Expect.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.String -> Expect.Expectation -> Expect.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":"Expect.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.String -> Basics.Bool -> Expect.Expectation"},{"name":"within","comment":" Passes if the second and third arguments are equal within a tolerance\nspecified by the first argument. This is intended to avoid failing because of\nminor inaccuracies introduced by floating point arithmetic.\n\n    -- Fails because 0.1 + 0.2 == 0.30000000000000004 (0.1 is non-terminating in base 2)\n    0.1 + 0.2 |> Expect.equal 0.3\n\n\n    -- So instead write this test, which passes\n    0.1 + 0.2 |> Expect.within (Absolute 0.000000001) 0.3\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because 3.14 is not close enough to pi\n    3.14 |> Expect.within (Absolute 0.0001) pi\n\n    {-\n\n    3.14\n    ╷\n    │ Expect.within Absolute 0.0001\n    ╵\n    3.141592653589793\n\n    -}\n\n","type":"Expect.FloatingPointTolerance -> Basics.Float -> Basics.Float -> Expect.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 int, intRange, float, floatRange, percentage, string, bool, maybe, result, list, array\n\n\n## Working with Fuzzers\n\n@docs Fuzzer, oneOf, constant, map, map2, map3, map4, map5, andMap, frequency\n\n\n## Tuple Fuzzers\n\nInstead of using a tuple, consider using `fuzzN`.\n\n@docs tuple, tuple3\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":"Fuzz.Internal.Fuzzer a"}],"values":[{"name":"andMap","comment":" Map over many fuzzers. This can act as mapN for N > 5.\nThe argument order is meant to accommodate chaining:\nmap f aFuzzer\n|> andMap anotherFuzzer\n|> andMap aThirdFuzzer\nNote that shrinking may be better using mapN.\n","type":"Fuzz.Fuzzer a -> Fuzz.Fuzzer (a -> b) -> Fuzz.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":"Fuzz.Fuzzer a -> Fuzz.Fuzzer (Array.Array a)"},{"name":"bool","comment":" A fuzzer for boolean values. It's useful when building up fuzzers of complex\ntypes that contain a boolean somewhere.\n\nWe recommend against writing tests fuzzing over booleans. Write a unit test for\nthe true and false cases explicitly.\n\n","type":"Fuzz.Fuzzer Basics.Bool"},{"name":"char","comment":" A fuzzer for char values. Generates random ascii chars disregarding the control\ncharacters and the extended character set.\n","type":"Fuzz.Fuzzer Char.Char"},{"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 -> Fuzz.Fuzzer a"},{"name":"custom","comment":" Build a custom `Fuzzer a` by providing a `Generator a` and a `Shrinker a`.\nGenerators are defined in [`elm/random`](http://package.elm-lang.org/packages/elm/random/latest),\nwhich is not core's Random module but has a compatible interface. Shrinkers are\ndefined in [`eeue56/elm-shrink`](http://package.elm-lang.org/packages/eeue56/elm-shrink/latest/).\n\nHere is an example for a record:\n\n    import 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\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":"Random.Generator a -> Shrink.Shrinker a -> Fuzz.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":"Fuzz.Fuzzer Basics.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":"Basics.Float -> Basics.Float -> Fuzz.Fuzzer Basics.Float"},{"name":"frequency","comment":" Create a new `Fuzzer` by providing a list of probabilistic weights to use\nwith other fuzzers.\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\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.List ( Basics.Float, Fuzz.Fuzzer a ) -> Fuzz.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":"Fuzz.Fuzzer Basics.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":"Basics.Int -> Basics.Int -> Fuzz.Fuzzer Basics.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.String -> Fuzz.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":"Fuzz.Fuzzer a -> Fuzz.Fuzzer (List.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) -> Fuzz.Fuzzer a -> Fuzz.Fuzzer b"},{"name":"map2","comment":" Map over two fuzzers.\n","type":"(a -> b -> c) -> Fuzz.Fuzzer a -> Fuzz.Fuzzer b -> Fuzz.Fuzzer c"},{"name":"map3","comment":" Map over three fuzzers.\n","type":"(a -> b -> c -> d) -> Fuzz.Fuzzer a -> Fuzz.Fuzzer b -> Fuzz.Fuzzer c -> Fuzz.Fuzzer d"},{"name":"map4","comment":" Map over four fuzzers.\n","type":"(a -> b -> c -> d -> e) -> Fuzz.Fuzzer a -> Fuzz.Fuzzer b -> Fuzz.Fuzzer c -> Fuzz.Fuzzer d -> Fuzz.Fuzzer e"},{"name":"map5","comment":" Map over five fuzzers.\n","type":"(a -> b -> c -> d -> e -> f) -> Fuzz.Fuzzer a -> Fuzz.Fuzzer b -> Fuzz.Fuzzer c -> Fuzz.Fuzzer d -> Fuzz.Fuzzer e -> Fuzz.Fuzzer f"},{"name":"maybe","comment":" Given a fuzzer of a type, create a fuzzer of a maybe for that type.\n","type":"Fuzz.Fuzzer a -> Fuzz.Fuzzer (Maybe.Maybe a)"},{"name":"oneOf","comment":" Choose one of the given fuzzers at random. Each fuzzer has an equal chance\nof being chosen; to customize the probabilities, use [`frequency`](#frequency).\n\n    Fuzz.oneOf\n        [ Fuzz.intRange 0 3\n        , Fuzz.intRange 7 9\n        ]\n\n","type":"List.List (Fuzz.Fuzzer a) -> Fuzz.Fuzzer a"},{"name":"order","comment":" A fuzzer for order values.\n","type":"Fuzz.Fuzzer Basics.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":"Fuzz.Fuzzer Basics.Float"},{"name":"result","comment":" Given fuzzers for an error type and a success type, create a fuzzer for\na result.\n","type":"Fuzz.Fuzzer error -> Fuzz.Fuzzer value -> Fuzz.Fuzzer (Result.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":"Fuzz.Fuzzer String.String"},{"name":"tuple","comment":" Turn a tuple of fuzzers into a fuzzer of tuples.\n","type":"( Fuzz.Fuzzer a, Fuzz.Fuzzer b ) -> Fuzz.Fuzzer ( a, b )"},{"name":"tuple3","comment":" Turn a 3-tuple of fuzzers into a fuzzer of 3-tuples.\n","type":"( Fuzz.Fuzzer a, Fuzz.Fuzzer b, Fuzz.Fuzzer c ) -> Fuzz.Fuzzer ( a, b, c )"},{"name":"unit","comment":" A fuzzer for the unit value. Unit is a type with only one value, commonly\nused as a placeholder.\n","type":"Fuzz.Fuzzer ()"}],"binops":[]},{"name":"Shrink","comment":" Library containing a collection of basic shrinking strategies and\nhelper functions to help you construct shrinking strategies.\n\n\n# Shrinking Basics\n\n@docs Shrinker, shrink\n\n\n# Shrinkers\n\n@docs noShrink, unit, bool, order, int, atLeastInt, float, atLeastFloat, char, atLeastChar, character, string, maybe, result, lazylist, list, array, tuple, tuple3\n\n\n# Functions on Shrinkers\n\n@docs convert, keepIf, dropIf, merge, map, andMap\n\n","unions":[],"aliases":[{"name":"Shrinker","comment":" The shrinker type.\nA shrinker is a function that takes a value and returns a list of values that\nare in some sense \"smaller\" than the given value. If there are no such values\nconceptually, then the shrinker should just return the empty list.\n","args":["a"],"type":"a -> Lazy.List.LazyList a"}],"values":[{"name":"andMap","comment":" Apply a lazy list of functions on a lazy list of values.\n\nThe argument order is so that it is easy to use in `|>` chains.\n\n","type":"Lazy.List.LazyList a -> Lazy.List.LazyList (a -> b) -> Lazy.List.LazyList b"},{"name":"array","comment":" Array shrinker constructor.\nTakes a shrinker of values and returns a shrinker of Arrays.\n","type":"Shrink.Shrinker a -> Shrink.Shrinker (Array.Array a)"},{"name":"atLeastChar","comment":" Construct a shrinker of chars which considers the given char to\nbe most minimal.\n","type":"Char.Char -> Shrink.Shrinker Char.Char"},{"name":"atLeastFloat","comment":" Construct a shrinker of floats which considers the given float to\nbe most minimal.\n","type":"Basics.Float -> Basics.Float -> Lazy.List.LazyList Basics.Float"},{"name":"atLeastInt","comment":" Construct a shrinker of ints which considers the given int to\nbe most minimal.\n","type":"Basics.Int -> Basics.Int -> Lazy.List.LazyList Basics.Int"},{"name":"bool","comment":" Shrinker of bools.\n","type":"Basics.Bool -> Lazy.List.LazyList Basics.Bool"},{"name":"char","comment":" Shrinker of chars.\n","type":"Shrink.Shrinker Char.Char"},{"name":"character","comment":" Shrinker of chars which considers the empty space as the most\nminimal char and omits the control key codes.\n\nEquivalent to:\n\n    atLeastChar (Char.fromCode 32)\n\n","type":"Shrink.Shrinker Char.Char"},{"name":"convert","comment":" Convert a Shrinker of a's into a Shrinker of b's using two inverse functions.\n)\nIf you use this function as follows:\n\n    shrinkerB =\n        f g shrinkerA\n\nMake sure that\n\n    `f(g(x)) == x` for all x\n\nOr else this process will generate garbage.\n\n","type":"(a -> b) -> (b -> a) -> Shrink.Shrinker a -> b -> Lazy.List.LazyList b"},{"name":"dropIf","comment":" Filter out the results of a shrinker. The resulting shrinker\nwill only throw away shrinks which satisfy the given predicate.\n","type":"(a -> Basics.Bool) -> Shrink.Shrinker a -> Shrink.Shrinker a"},{"name":"float","comment":" Shrinker of floats.\n","type":"Basics.Float -> Lazy.List.LazyList Basics.Float"},{"name":"int","comment":" Shrinker of integers.\n","type":"Basics.Int -> Lazy.List.LazyList Basics.Int"},{"name":"keepIf","comment":" Filter out the results of a shrinker. The resulting shrinker\nwill only produce shrinks which satisfy the given predicate.\n","type":"(a -> Basics.Bool) -> Shrink.Shrinker a -> a -> Lazy.List.LazyList a"},{"name":"lazylist","comment":" Lazy List shrinker constructor. Takes a shrinker of values and returns a\nshrinker of Lazy Lists. The lazy list being shrunk must be finite. (I mean\nreally, how do you shrink infinity?)\n","type":"Shrink.Shrinker a -> Lazy.List.LazyList a -> Lazy.List.LazyList (Lazy.List.LazyList a)"},{"name":"list","comment":" List shrinker constructor.\nTakes a shrinker of values and returns a shrinker of Lists.\n","type":"Shrink.Shrinker a -> Shrink.Shrinker (List.List a)"},{"name":"map","comment":" Re-export of `Lazy.List.map`\nThis is useful in order to compose shrinkers, especially when used in\nconjunction with `andMap`. For example:\n\n    type alias Vector =\n        { x : Float\n        , y : Float\n        , z : Float\n        }\n\n    vector : Shrinker Vector\n    vector { x, y, z } =\n        Vector\n            `map` float x\n            `andMap` float y\n            `andMap` float z\n\n","type":"(a -> b) -> Lazy.List.LazyList a -> Lazy.List.LazyList b"},{"name":"maybe","comment":" Maybe shrinker constructor.\nTakes a shrinker of values and returns a shrinker of Maybes.\n","type":"Shrink.Shrinker a -> Maybe.Maybe a -> Lazy.List.LazyList (Maybe.Maybe a)"},{"name":"merge","comment":" Merge two shrinkers. Generates all the values in the first\nshrinker, and then all the non-duplicated values in the second\nshrinker.\n","type":"Shrink.Shrinker a -> Shrink.Shrinker a -> a -> Lazy.List.LazyList a"},{"name":"noShrink","comment":" Perform no shrinking. Equivalent to the empty lazy list.\n","type":"a -> Lazy.List.LazyList a"},{"name":"order","comment":" Shrinker of `Order` values.\n","type":"Basics.Order -> Lazy.List.LazyList Basics.Order"},{"name":"result","comment":" Result shrinker constructor. Takes a shrinker of errors and a shrinker of\nvalues and returns a shrinker of Results.\n","type":"Shrink.Shrinker error -> Shrink.Shrinker value -> Result.Result error value -> Lazy.List.LazyList (Result.Result error value)"},{"name":"shrink","comment":" Perform shrinking. Takes a predicate that returns `True` if you want\nshrinking to continue (e.g. the test failed). Also takes a shrinker and a value\nto shrink. It returns the shrunken value, or the input value if no shrunken\nvalues that satisfy the predicate are found.\n","type":"(a -> Basics.Bool) -> Shrink.Shrinker a -> a -> a"},{"name":"string","comment":" Shrinker of strings. Considers the empty string to be the most\nminimal string and the space to be the most minimal char.\n\nEquivalent to:\n\n    convert String.fromList String.toList (list character)\n\n","type":"Shrink.Shrinker String.String"},{"name":"tuple","comment":" 2-Tuple shrinker constructor.\nTakes a tuple of shrinkers and returns a shrinker of tuples.\n","type":"( Shrink.Shrinker a, Shrink.Shrinker b ) -> ( a, b ) -> Lazy.List.LazyList ( a, b )"},{"name":"tuple3","comment":" 3-Tuple shrinker constructor.\nTakes a tuple of shrinkers and returns a shrinker of tuples.\n","type":"( Shrink.Shrinker a, Shrink.Shrinker b, Shrink.Shrinker c ) -> ( a, b, c ) -> Lazy.List.LazyList ( a, b, c )"},{"name":"unit","comment":" Shrink the empty tuple. Equivalent to `noShrink`.\n","type":"Shrink.Shrinker ()"}],"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, 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 : Basics.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.Internal.Test"}],"values":[{"name":"concat","comment":" Run each of the given tests.\n\n    concat [ testDecoder, testSorting ]\n\n","type":"List.List Test.Test -> 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.String -> List.List Test.Test -> 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":"Fuzz.Fuzzer a -> String.String -> (a -> Expect.Expectation) -> Test.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":"Fuzz.Fuzzer a -> Fuzz.Fuzzer b -> String.String -> (a -> b -> Expect.Expectation) -> Test.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":"Fuzz.Fuzzer a -> Fuzz.Fuzzer b -> Fuzz.Fuzzer c -> String.String -> (a -> b -> c -> Expect.Expectation) -> Test.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":"Test.FuzzOptions -> Fuzz.Fuzzer a -> String.String -> (a -> Expect.Expectation) -> Test.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 <|\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        , 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 -> 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 <|\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        , 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 -> 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.String -> (() -> Expect.Expectation) -> Test.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.String -> Test.Test"}],"binops":[]},{"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 getFailureReason, 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":" Test Runners which have had seeds distributed to them, and which are now\neither invalid or are ready to run. Seeded runners include some metadata:\n\n  - `Invalid` runners had a problem (e.g. two sibling tests had the same description) making them un-runnable.\n  - `Only` runners can be run, but `Test.only` was used somewhere, so ultimately they will lead to a failed test run even if each test that gets run passes.\n  - `Skipping` runners can be run, but `Test.skip` was used somewhere, so ultimately they will lead to a failed test run even if each test that gets run passes.\n  - `Plain` runners are ready to run, and have none of these issues.\n\n","args":[],"cases":[["Plain",["List.List Test.Runner.Runner"]],["Only",["List.List Test.Runner.Runner"]],["Skipping",["List.List Test.Runner.Runner"]],["Invalid",["String.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.List Expect.Expectation, labels : List.List String.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.String -> format) -> (String.String -> format) -> List.List String.String -> List.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.Seed`. `100` is a good run count. To obtain a good random seed, pass a\nrandom 32-bit integer to `Random.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":"Basics.Int -> Random.Seed -> Test.Test -> Test.Runner.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":"Fuzz.Fuzzer a -> Result.Result String.String (Random.Generator ( a, Test.Runner.Shrinkable a ))"},{"name":"getFailureReason","comment":" Return `Nothing` if the given [`Expectation`](#Expectation) is a [`pass`](#pass).\n\nIf it is a [`fail`](#fail), return a record containing the expectation\ndescription, the [`Reason`](#Reason) the test failed, and the given inputs if\nit was a fuzz test. (If it was not a fuzz test, the record's `given` field\nwill be `Nothing`).\n\nFor example:\n\n    getFailureReason (Expect.equal 1 2)\n    -- Just { reason = Equal 1 2, description = \"Expect.equal\", given = Nothing }\n\n    getFailureReason (Expect.equal 1 1)\n    -- Nothing\n\n","type":"Expect.Expectation -> Maybe.Maybe { given : Maybe.Maybe String.String, description : String.String, reason : Test.Runner.Failure.Reason }"},{"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":"Expect.Expectation -> Basics.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":"Basics.Bool -> Test.Runner.Shrinkable a -> Maybe.Maybe ( a, Test.Runner.Shrinkable a )"}],"binops":[]},{"name":"Test.Runner.Failure","comment":" The reason a test failed.\n\n@docs Reason, InvalidReason, format\n\n","unions":[{"name":"InvalidReason","comment":" The reason a test run was invalid.\n\nTest runners should report these to the user in whatever format is appropriate.\n\n","args":[],"cases":[["EmptyList",[]],["NonpositiveFuzzCount",[]],["InvalidFuzzer",[]],["BadDescription",[]],["DuplicatedName",[]]]},{"name":"Reason","comment":" The reason a test failed.\n\nTest runners can use this to provide nice output, e.g. by doing diffs on the\ntwo parts of an `Expect.equal` failure.\n\n","args":[],"cases":[["Custom",[]],["Equality",["String.String","String.String"]],["Comparison",["String.String","String.String"]],["ListDiff",["List.List String.String","List.List String.String"]],["CollectionDiff",["{ expected : String.String, actual : String.String, extra : List.List String.String, missing : List.List String.String }"]],["TODO",[]],["Invalid",["Test.Runner.Failure.InvalidReason"]]]}],"aliases":[],"values":[{"name":"format","comment":" DEPRECATED. In the future, test runners should implement versions of this\nthat make sense for their own environments.\n\nFormat test run failures in a reasonable way.\n\n","type":"String.String -> Test.Runner.Failure.Reason -> String.String"}],"binops":[]}]