    {-# LANGUAGE CPP #-}
    #ifndef NO_SAFE_HASKELL
    {-# LANGUAGE Safe #-}
    #endif
    {-# OPTIONS_HADDOCK hide #-}
    -- | QuickCheck's internal state. Internal QuickCheck module.
    module Test.QuickCheck.State where

    import Test.QuickCheck.Text
    import Test.QuickCheck.Random
    import Data.Map(Map)

    --------------------------------------------------------------------------
    -- State

    -- | State represents QuickCheck's internal state while testing a property.
    -- The state is made visible to callback functions.
    data State
      = MkState
      -- static
      { State -> Terminal
    terminal                  :: Terminal
        -- ^ the current terminal
      , State -> Int
    maxSuccessTests           :: Int
        -- ^ maximum number of successful tests needed
      , State -> Int
    maxDiscardedRatio         :: Int
        -- ^ maximum number of discarded tests per successful test
      , State -> Maybe Confidence
    coverageConfidence        :: Maybe Confidence
        -- ^ how to compute the size of test cases from
        --   #tests and #discarded tests
      , State -> Int
    numTotMaxShrinks          :: !Int
        -- ^ How many shrinks to try before giving up
      , State -> Maybe Int
    replayStartSize           :: Maybe Int
        -- ^ Size to start at when replaying
      , State -> Int
    maxTestSize               :: !Int
        -- ^ Maximum size of test

        -- dynamic
      , State -> Int
    numSuccessTests           :: !Int
        -- ^ the current number of tests that have succeeded
      , State -> Int
    numDiscardedTests         :: !Int
        -- ^ the current number of discarded tests
      , State -> Int
    numRecentlyDiscardedTests :: !Int
        -- ^ the number of discarded tests since the last successful test
      , State -> Map [String] Int
    labels                    :: !(Map [String] Int)
        -- ^ counts for each combination of labels (label/collect)
      , State -> Map String Int
    classes                   :: !(Map String Int)
        -- ^ counts for each class of test case (classify/cover)
      , State -> Map String (Map String Int)
    tables                    :: !(Map String (Map String Int))
        -- ^ tables collected using tabulate
      , State -> Map (Maybe String, String) Double
    requiredCoverage          :: !(Map (Maybe String, String) Double)
        -- ^ coverage requirements
      , State -> Bool
    expected                  :: !Bool
        -- ^ indicates the expected result of the property
      , State -> QCGen
    randomSeed                :: !QCGen
        -- ^ the current random seed

        -- shrinking
      , State -> Int
    numSuccessShrinks         :: !Int
        -- ^ number of successful shrinking steps so far
      , State -> Int
    numTryShrinks             :: !Int
        -- ^ number of failed shrinking steps since the last successful shrink
      , State -> Int
    numTotTryShrinks          :: !Int
        -- ^ total number of failed shrinking steps
      }

    -- | The statistical parameters used by 'checkCoverage'.
    data Confidence =
      Confidence {
        Confidence -> Integer
    certainty :: Integer,
        -- ^ How certain 'checkCoverage' must be before the property fails.
        -- If the coverage requirement is met, and the certainty parameter is @n@,
        -- then you should get a false positive at most one in @n@ runs of QuickCheck.
        -- The default value is @10^9@.
        --
        -- Lower values will speed up 'checkCoverage' at the cost of false
        -- positives.
        --
        -- If you are using 'checkCoverage' as part of a test suite, you should
        -- be careful not to set @certainty@ too low. If you want, say, a 1% chance
        -- of a false positive during a project's lifetime, then @certainty@ should
        -- be set to at least @100 * m * n@, where @m@ is the number of uses of
        -- 'cover' in the test suite, and @n@ is the number of times you expect the
        -- test suite to be run during the project's lifetime. The default value
        -- is chosen to be big enough for most projects.
        Confidence -> Double
    tolerance :: Double
        -- ^ For statistical reasons, 'checkCoverage' will not reject coverage
        -- levels that are only slightly below the required levels.
        -- If the required level is @p@ then an actual level of @tolerance * p@
        -- will be accepted. The default value is @0.9@.
        --
        -- Lower values will speed up 'checkCoverage' at the cost of not detecting
        -- minor coverage violations.
        }
      deriving Int -> Confidence -> ShowS
    [Confidence] -> ShowS
    Confidence -> String
    (Int -> Confidence -> ShowS)
    -> (Confidence -> String)
    -> ([Confidence] -> ShowS)
    -> Show Confidence
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Confidence -> ShowS
    showsPrec :: Int -> Confidence -> ShowS
    $cshow :: Confidence -> String
    show :: Confidence -> String
    $cshowList :: [Confidence] -> ShowS
    showList :: [Confidence] -> ShowS
    Show

    --------------------------------------------------------------------------
    -- the end.