test-framework-quickcheck2-0.3.0.3/0000755000000000000000000000000012321741262015205 5ustar0000000000000000test-framework-quickcheck2-0.3.0.3/LICENSE0000644000000000000000000000276612321741262016225 0ustar0000000000000000Copyright (c) 2008, Maximilian Bolingbroke All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Maximilian Bolingbroke nor the names of other contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.test-framework-quickcheck2-0.3.0.3/Setup.lhs0000644000000000000000000000011512321741262017012 0ustar0000000000000000#! /usr/bin/env runhaskell > import Distribution.Simple > main = defaultMaintest-framework-quickcheck2-0.3.0.3/test-framework-quickcheck2.cabal0000644000000000000000000000320412321741262023334 0ustar0000000000000000Name: test-framework-quickcheck2 Version: 0.3.0.3 Cabal-Version: >= 1.6 Category: Testing Synopsis: QuickCheck2 support for the test-framework package. License: BSD3 License-File: LICENSE Author: Max Bolingbroke Maintainer: Haskell Libraries Homepage: https://batterseapower.github.io/test-framework/ Bug-Reports: https://github.com/haskell/test-framework/ Build-Type: Simple Description: QuickCheck2 support for the test-framework package. Flag Base4 Description: Choose base version 4 Default: True Flag Base3 Description: Choose base version 3 Default: False Library Exposed-Modules: Test.Framework.Providers.QuickCheck2 Build-Depends: test-framework >= 0.7.1, QuickCheck >= 2.4 && < 2.8, extensible-exceptions >= 0.1.1 && < 0.2.0 if flag(base3) Build-Depends: base >= 3 && < 4, random >= 1 else if flag(base4) Build-Depends: base >= 4 && < 5, random >= 1 Extensions: TypeSynonymInstances TypeOperators MultiParamTypeClasses ExistentialQuantification CPP Ghc-Options: -Wall Source-Repository head Type: git Location: https://github.com/haskell/test-framework test-framework-quickcheck2-0.3.0.3/Test/0000755000000000000000000000000012321741262016124 5ustar0000000000000000test-framework-quickcheck2-0.3.0.3/Test/Framework/0000755000000000000000000000000012321741262020061 5ustar0000000000000000test-framework-quickcheck2-0.3.0.3/Test/Framework/Providers/0000755000000000000000000000000012321741262022036 5ustar0000000000000000test-framework-quickcheck2-0.3.0.3/Test/Framework/Providers/QuickCheck2.hs0000644000000000000000000001272212321741262024472 0ustar0000000000000000{-# LANGUAGE DeriveDataTypeable #-} -- | Allows QuickCheck2 properties to be used with the test-framework package. -- -- For an example of how to use test-framework, please see module Test.Framework.Providers.QuickCheck2 ( testProperty ) where import Test.Framework.Providers.API import Test.QuickCheck.Property (Testable, Callback(PostTest), CallbackKind(NotCounterexample), callback) import Test.QuickCheck.State (numSuccessTests) import Test.QuickCheck.Test #if MIN_VERSION_QuickCheck(2,7,0) import Test.QuickCheck.Random (QCGen, mkQCGen) #endif import System.Random import Data.Typeable -- | Create a 'Test' for a QuickCheck2 'Testable' property testProperty :: Testable a => TestName -> a -> Test testProperty name = Test name . Property instance TestResultlike PropertyTestCount PropertyResult where testSucceeded = propertySucceeded -- | Used to document numbers which we expect to be intermediate test counts from running properties type PropertyTestCount = Int -- | The failure information from the run of a property data PropertyResult = PropertyResult { pr_status :: PropertyStatus, pr_used_seed :: Int, pr_tests_run :: Maybe PropertyTestCount -- Due to technical limitations, it's currently not possible to find out the number of -- tests previously run if the test times out, hence we need a Maybe here for that case. } data PropertyStatus = PropertyOK -- ^ The property is true as far as we could check it | PropertyArgumentsExhausted -- ^ The property may be true, but we ran out of arguments to try it out on | PropertyFalsifiable String String -- ^ The property was not true. The strings are the reason and the output. | PropertyNoExpectedFailure -- ^ We expected that a property would fail but it didn't | PropertyTimedOut -- ^ The property timed out during execution instance Show PropertyResult where show (PropertyResult { pr_status = status, pr_used_seed = used_seed, pr_tests_run = mb_tests_run }) = case status of PropertyOK -> "OK, passed " ++ tests_run_str ++ " tests" PropertyArgumentsExhausted -> "Arguments exhausted after " ++ tests_run_str ++ " tests" PropertyFalsifiable _rsn otpt -> otpt ++ "(used seed " ++ show used_seed ++ ")" PropertyNoExpectedFailure -> "No expected failure with seed " ++ show used_seed ++ ", after " ++ tests_run_str ++ " tests" PropertyTimedOut -> "Timed out after " ++ tests_run_str ++ " tests" where tests_run_str = fmap show mb_tests_run `orElse` "an unknown number of" propertySucceeded :: PropertyResult -> Bool propertySucceeded (PropertyResult { pr_status = status, pr_tests_run = mb_n }) = case status of PropertyOK -> True PropertyArgumentsExhausted -> maybe False (/= 0) mb_n _ -> False data Property = forall a. Testable a => Property a deriving Typeable instance Testlike PropertyTestCount PropertyResult Property where runTest topts (Property testable) = runProperty topts testable testTypeName _ = "Properties" #if MIN_VERSION_QuickCheck(2,7,0) newSeededQCGen :: Seed -> IO (QCGen, Int) newSeededQCGen (FixedSeed seed) = return $ (mkQCGen seed, seed) newSeededQCGen RandomSeed = do seed <- randomIO return (mkQCGen seed, seed) #else newSeededQCGen :: Seed -> IO (StdGen, Int) newSeededQCGen = newSeededStdGen #endif runProperty :: Testable a => CompleteTestOptions -> a -> IO (PropertyTestCount :~> PropertyResult, IO ()) runProperty topts testable = do (gen, seed) <- newSeededQCGen (unK $ topt_seed topts) let max_success = unK $ topt_maximum_generated_tests topts max_discard = unK $ topt_maximum_unsuitable_generated_tests topts args = stdArgs { replay = Just (gen, 0) -- NB: the 0 is the saved size. Defaults to 0 if you supply "Nothing" for "replay". , maxSuccess = max_success #if MIN_VERSION_QuickCheck(2,5,0) , maxDiscardRatio = max_discard `div` max_success #else , maxDiscard = max_discard #endif , maxSize = unK $ topt_maximum_test_size topts , chatty = False } -- FIXME: yield gradual improvement after each test runImprovingIO $ do tunnel <- tunnelImprovingIO mb_result <- maybeTimeoutImprovingIO (unK (topt_timeout topts)) $ liftIO $ quickCheckWithResult args (callback (PostTest NotCounterexample (\s _r -> tunnel $ yieldImprovement $ numSuccessTests s)) testable) return $ case mb_result of Nothing -> PropertyResult { pr_status = PropertyTimedOut, pr_used_seed = seed, pr_tests_run = Nothing } Just result -> PropertyResult { pr_status = toPropertyStatus result, pr_used_seed = seed, pr_tests_run = Just (numTests result) } where toPropertyStatus (Success {}) = PropertyOK toPropertyStatus (GaveUp {}) = PropertyArgumentsExhausted toPropertyStatus (Failure { reason = rsn, output = otpt }) = PropertyFalsifiable rsn otpt toPropertyStatus (NoExpectedFailure {}) = PropertyNoExpectedFailure