QuickCheck: Property-Based Testing in Haskell and Erlang Deep Dive

import Test.QuickCheck

-- Property: reversing a list twice is identity
prop_reverseReverse :: [Int] -> Bool
prop_reverseReverse xs = reverse (reverse xs) == xs

-- Property: sort is idempotent
prop_sortIdempotent :: [Int] -> Bool
prop_sortIdempotent xs = sort (sort xs) == sort xs

main :: IO ()
main = do
  quickCheck prop_reverseReverse
  quickCheck prop_sortIdempotent

data Priority = Low | Medium | High | Critical
  deriving (Show, Eq, Ord)

instance Arbitrary Priority where
  arbitrary = elements [Low, Medium, High, Critical]
  -- shrink defaults to [] (no shrinking), which is fine for enums

data DateRange = DateRange
  { startDate :: Day
  , endDate   :: Day
  } deriving (Show)

instance Arbitrary DateRange where
  arbitrary = do
    start <- arbitrary
    -- endDate must be >= startDate
    offset <- choose (0, 365)
    let end = addDays offset start
    return $ DateRange start end
  
  shrink (DateRange start end) =
    [ DateRange start' end
    | start' <- shrink start
    , start' <= end
    ]
    ++
    [ DateRange start end'
    | end' <- shrink end
    , end' >= start
    ]

data Transaction = Credit Amount | Debit Amount | Refund Amount
  deriving (Show)

instance Arbitrary Transaction where
  arbitrary = frequency
    [ (60, Credit  <$> positiveAmount)
    , (35, Debit   <$> positiveAmount)
    , (5,  Refund  <$> positiveAmount)
    ]
    where positiveAmount = abs <$> arbitrary

  shrink (Credit a)  = Credit  <$> shrink a
  shrink (Debit a)   = Debit   <$> shrink a
  shrink (Refund a)  = Refund  <$> shrink a

-- Generate a valid IP address
genIPv4 :: Gen String
genIPv4 = do
  octets <- replicateM 4 (choose (0, 255) :: Gen Int)
  return $ intercalate "." (map show octets)

-- Generate a non-empty sorted list
genSortedNonEmpty :: (Arbitrary a, Ord a) => Gen [a]
genSortedNonEmpty = do
  xs <- listOf1 arbitrary
  return (sort xs)

-- Generate a valid email (simplified)
genEmail :: Gen String
genEmail = do
  user   <- listOf1 (elements ['a'..'z'])
  domain <- listOf1 (elements ['a'..'z'])
  tld    <- elements ["com", "org", "net", "io"]
  return $ user ++ "@" ++ domain ++ "." ++ tld

-- Generate a list and a valid index into it
genListWithIndex :: Gen ([Int], Int)
genListWithIndex = do
  xs <- listOf1 arbitrary
  i  <- choose (0, length xs - 1)
  return (xs, i)

prop_indexInBounds :: Property
prop_indexInBounds = forAll genListWithIndex $ \(xs, i) ->
  i >= 0 && i < length xs  -- This always holds by construction

prop_indexRoundtrip :: Property
prop_indexRoundtrip = forAll genListWithIndex $ \(xs, i) ->
  xs !! i == xs !! i  -- Trivial, but demonstrates the pattern

-- Generate even integers (use sparingly—prefer direct generation)
genEven :: Gen Int
genEven = arbitrary `suchThat` even

-- Better: generate directly
genEvenDirect :: Gen Int
genEvenDirect = (2 *) <$> arbitrary

import Test.QuickCheck

-- Instead of:
prop_bad :: [Int] -> Bool
prop_bad xs = sort xs == sort (reverse xs)

-- Use === for better output on failure:
prop_good :: [Int] -> Property
prop_good xs = sort xs === sort (reverse xs)
-- Failure shows: [3,1,2] /= [2,1,3]

prop_insertionSort :: [Int] -> Property
prop_insertionSort xs = 
  classify (null xs) "empty" $
  classify (length xs == 1) "singleton" $
  classify (length xs > 100) "large" $
  sort xs == insertionSort xs

prop_withCoverage :: [Int] -> Property
prop_withCoverage xs =
  cover 30 (length xs > 10) "lists longer than 10" $
  cover 10 (null xs) "empty lists" $
  sort xs == insertionSort xs

import Test.QuickCheck.Monadic

-- Testing a mutable counter
prop_counter :: [CounterOp] -> Property
prop_counter ops = monadicIO $ do
  counter <- run newCounter
  model   <- run $ newIORef (0 :: Int)
  
  forM_ ops $ \op -> case op of
    Increment -> do
      run $ increment counter
      run $ modifyIORef model (+1)
    Decrement -> do
      run $ decrement counter
      run $ modifyIORef model (subtract 1)
    Reset -> do
      run $ reset counter
      run $ writeIORef model 0
  
  expected <- run $ readIORef model
  actual   <- run $ readCounter counter
  assert (actual == expected)

data CounterOp = Increment | Decrement | Reset
  deriving (Show, Arbitrary via GenericArbitrary CounterOp)

-module(prop_queue).
-include_lib("eqc/include/eqc.hrl").

prop_queue_fifo() ->
    ?FORALL(Ops, list(queue_op()),
        begin
            Queue = lists:foldl(fun apply_op/2, queue:new(), Ops),
            Model = lists:foldl(fun apply_op_model/2, [], Ops),
            queue:to_list(Queue) == Model
        end).

queue_op() ->
    frequency([
        {3, {enqueue, int()}},
        {2, dequeue}
    ]).

-module(prop_account).
-include_lib("eqc/include/eqc.hrl").
-include_lib("eqc/include/eqc_statem.hrl").

-record(state, {
    accounts = [],  % [{Id, Balance}]
    next_id  = 1
}).

%% Initial state
initial_state() -> #state{}.

%% Command generation
command(S) ->
    frequency([
        {3, {call, account, create, [pos_integer()]}},
        {2, {call, account, deposit,  [account_id(S), pos_integer()]}},
        {2, {call, account, withdraw, [account_id(S), pos_integer()]}},
        {1, {call, account, balance,  [account_id(S)]}}
    ]).

%% Preconditions
precondition(S, {call, _, deposit, [Id, _]}) ->
    lists:keymember(Id, 1, S#state.accounts);
precondition(S, {call, _, withdraw, [Id, Amount]}) ->
    case lists:keyfind(Id, 1, S#state.accounts) of
        {Id, Balance} -> Balance >= Amount;
        false -> false
    end;
precondition(_, _) -> true.

%% State transitions
next_state(S, Id, {call, _, create, [Initial]}) ->
    S#state{
        accounts = [{S#state.next_id, Initial} | S#state.accounts],
        next_id  = S#state.next_id + 1
    };
next_state(S, _, {call, _, deposit, [Id, Amount]}) ->
    S#state{accounts = update_balance(S#state.accounts, Id, Amount)};
%% ... etc

%% Postconditions
postcondition(S, {call, _, balance, [Id]}, Result) ->
    {Id, Balance} = lists:keyfind(Id, 1, S#state.accounts),
    Result == Balance;
postcondition(_, _, _) -> true.

prop_account() ->
    ?FORALL(Cmds, commands(?MODULE),
        begin
            {H, S, Res} = run_commands(?MODULE, Cmds),
            ?WHENFAIL(
                io:format("History: ~p~nState: ~p~nResult: ~p~n", [H, S, Res]),
                Res == ok
            )
        end).

# .github/workflows/property-tests.yml  
- name: Run QuickCheck tests
  run: |
    cabal test --test-option="--quickcheck-tests=10000" \
               --test-option="--quickcheck-replay=0"

*** Failed! Falsifiable (after 47 tests and 3 shrinks):
...
Use --quickcheck-replay=1234567890 to reproduce.