From 8c95f3ac06d9fedfe3ff5b30cda137f426e8e094 Mon Sep 17 00:00:00 2001 From: Rowan Torbitzky-Lane Date: Sat, 1 Feb 2025 20:46:04 -0600 Subject: [PATCH] remove LearnQuickCheck --- src/LearnQuickCheck.hs | 194 ----------------------------------------- 1 file changed, 194 deletions(-) delete mode 100644 src/LearnQuickCheck.hs diff --git a/src/LearnQuickCheck.hs b/src/LearnQuickCheck.hs deleted file mode 100644 index 44ce1f8..0000000 --- a/src/LearnQuickCheck.hs +++ /dev/null @@ -1,194 +0,0 @@ -module LearnQuickCheck where - --- https://jesper.sikanda.be/posts/quickcheck-intro.html - -import Control.Monad -import Data.List (sort) -import Test.QuickCheck - -qsort :: (Ord a) => [a] -> [a] -qsort = sort - -distance :: Int -> Int -> Int -distance x y = abs (x - y) - -prop_dist35 :: Bool -prop_dist35 = distance 3 5 == 2 - -prop_dist_self :: Int -> Bool -prop_dist_self x = distance x x == 0 - -prop_dist_symmetric :: Int -> Int -> Bool -prop_dist_symmetric x y = distance x y == distance y x - -bad_distance :: Int -> Int -> Int -bad_distance x y = y - x - -prop_dist_symmetric_fail :: Int -> Int -> Bool -prop_dist_symmetric_fail x y = bad_distance x y == bad_distance y x - -sorted :: (Ord a) => [a] -> Bool -sorted (x : y : ys) = x <= y && sorted (y : ys) -sorted _ = True - -prop_sorted :: [Int] -> Bool -prop_sorted xs = sorted xs - --- roundtrip property -insert :: Int -> [Int] -> [Int] -insert x [] = [x] -insert x (y : ys) - | x <= y = x : y : ys - | otherwise = y : insert x ys - -delete :: Int -> [Int] -> [Int] -delete x [] = [] -delete x (y : ys) - | x == y = ys - | otherwise = y : delete x ys - -prop_insert_delete :: [Int] -> Int -> Bool -prop_insert_delete xs x = delete x (insert x xs) == xs - --- Equivalent Property -prop_qsort_sort :: [Int] -> Bool -prop_qsort_sort xs = qsort xs == sort xs - --- can test this in ghci with verboseCheck -prop_qsort_sort' :: (Ord a) => [a] -> Bool -prop_qsort_sort' xs = qsort xs == sort xs - --- Algebraic Laws -vAdd :: (Int, Int) -> (Int, Int) -> (Int, Int) -vAdd tup0 tup1 = (fst tup0 + fst tup1, snd tup0 + snd tup1) - -prop_vAdd_commutative :: (Int, Int) -> (Int, Int) -> Bool -prop_vAdd_commutative v w = vAdd v w == vAdd w v - -prop_vAdd_associative :: (Int, Int) -> (Int, Int) -> (Int, Int) -> Bool -prop_vAdd_associative u v w = vAdd (vAdd u v) w == vAdd u (vAdd v w) - -prop_vAdd_neutral_left :: (Int, Int) -> Bool -prop_vAdd_neutral_left u = vAdd (0, 0) u == u - -prop_vAdd_neutral_right :: (Int, Int) -> Bool -prop_vAdd_neutral_right u = vAdd u (0, 0) == u - -prop_qsort_idempotent :: [Int] -> Bool -prop_qsort_idempotent xs = qsort (qsort xs) == qsort xs - --- Testing with different distributions section --- prop_replicate :: Int -> Int -> Int -> Bool --- prop_replicate n x i = replicate n x !! i == x - -prop_replicate :: Int -> Int -> Int -> Property -prop_replicate n x i = - (i >= 0 && i < n) ==> replicate n (x :: Int) !! i == x - -prop_insert_sorted :: Int -> [Int] -> Property -prop_insert_sorted x xs = sorted xs ==> sorted (insert x xs) - --- Quantified properties -prop_insert_sorted' :: Int -> Property -prop_insert_sorted' x = forAll orderedList (\xs -> sorted (insert x xs)) - --- Testing properties of functions -prop_filter :: Fun Int Bool -> [Int] -> Property -prop_filter p xs = - -- Filter elements not satisfying p. - let ys = [x | x <- xs, applyFun p x] - in -- If any elements are left... - ys /= [] ==> - -- ...generate a random index i... - forAll - (choose (0, length ys - 1)) - -- ...and test if p (ys!!i) holds. - (\i -> applyFun p (ys !! i)) - -prop_bananas :: Fun String Int -> Bool -prop_bananas f = - applyFun f "banana" == applyFun f "monkey" - || applyFun f "banana" == applyFun f "elephant" - || applyFun f "monkey" == applyFun f "elephant" - --- main :: IO () --- main = do --- quickCheck prop_dist35 --- quickCheck prop_dist_self --- quickCheck prop_dist_symmetric --- -- Roundtrip tests --- quickCheck prop_insert_delete --- -- Equivalent tests --- quickCheck prop_qsort_sort --- -- quickCheck prop_qsort_sort' --- -- Algebraic tests --- quickCheck prop_vAdd_commutative --- quickCheck prop_vAdd_associative --- quickCheck prop_vAdd_neutral_left --- quickCheck prop_vAdd_neutral_right --- -- Testing with different distributions --- quickCheck prop_replicate --- quickCheck prop_insert_sorted --- -- Quantified Properties --- quickCheck prop_insert_sorted' --- -- Testing properties of functions --- quickCheck prop_filter --- quickCheck prop_bananas - --- This next section is from the Practical Property Testing video on youtube --- by FP Complete Corporation - -genSuit, genVal :: Gen Char -genSuit = elements "HDCS" -genVal = elements "123456789JQK" - --- Applicative so can do this -genCard :: Gen (Char, Char) -genCard = (,) <$> genSuit <*> genVal - --- Monad so can do this -genCards :: Gen [(Char, Char)] -genCards = do - l <- arbitrary - replicateM l genCard - -genListOf15Ints :: Gen [Int] -genListOf15Ints = resize 15 $ sized $ \n -> replicateM n arbitrary - --- Next section covers this. QuickCheck with custom data declarations --- http://geekyplatypus.com/y-u-have-no-code-samples-quickcheck/ - -data Point = Pt Int Int - -instance Show Point where - show (Pt x y) = "{" ++ show x ++ "," ++ show y ++ "}" - -instance Arbitrary Point where - arbitrary = do - x <- arbitrary - -- y <- arbitrary - -- return $ Pt x y - -- could do - Pt x <$> arbitrary - -data Set a = Set [a] - -instance (Show a) => Show (Set a) where - show s = showSet s - where - showSet (Set []) = "{}" - showSet (Set (x : xs)) = "{" <> show x <> showSubSet xs <> "}" - where - showSubSet [] = "" - showSubSet (ix : ixs) = "," <> show ix <> showSubSet ixs - -instance (Arbitrary a) => Arbitrary (Set a) where - arbitrary = do Set <$> arbitrary - --- list <- arbitrary --- return $ Set list - --- sample $ (arbitrary :: Gen (Set Int)) - --- This link also seems interesting --- https://devtut.github.io/haskell/quickcheck.html