Testing 为什么QuickCheck会放弃？

我正在使用

QuickCheck

测试以下程序：

{-# LANGUAGE TemplateHaskell #-}

import Test.QuickCheck
import Test.QuickCheck.All

elementAt :: (Integral b) => [a] -> b -> a
elementAt [x] _ = x
elementAt (x:xs) 1 = x
elementAt (x:xs) b = elementAt xs (b - 1)

prop_elementAt xs b = length xs > 0 && b >= 0 && b < length xs ==> elementAt xs (b + 1) == xs !! b

main = $(quickCheckAll)

---

这是我应该关心的事情吗？还是测试输入的性质决定了快速检查将运行多长时间？

第一次快速检查将为

xs

和

b

生成随机值，然后检查谓词

length xs>0&&b>=0&&b

是否满足，只有这样它才会检查属性的可满足性

由于它将生成的测试用例数量是有限制的，所以可能会有很多时间不满足上述谓词。所以quickcheck在生成足够的有效测试用例（满足谓词）之前就放弃了

相反，您应该将

arbitral

实例声明为一个新类型，以仅生成满足这些谓词的测试用例

{-# LANGUAGE TemplateHaskell #-}

import Test.QuickCheck
import Test.QuickCheck.All

elementAt :: (Integral b) => [a] -> b -> a
elementAt [x] _ = x
elementAt (x:xs) 1 = x
elementAt (x:xs) b = elementAt xs (b - 1)

prop_elementAt (Foo xs b) = elementAt xs (b + 1) == xs !! b

data Foo a b = Foo [a] b deriving (Show)

instance (Integral b, Arbitrary a, Arbitrary b) => Arbitrary (Foo a b) where
  arbitrary = do
    as <- listOf1 arbitrary           -- length xs > 0
    b <- choose (0,length as - 1)     -- b >= 0 and b < length xs
    return (Foo as $ fromIntegral b)

main = $(quickCheckAll)

{-#语言模板haskell}
导入测试。快速检查
导入Test.QuickCheck.All
元素AT:：（积分b）=>[a]->b->a
元素at[x]ux=x
元素at（x:xs）1=x
elementAt（x:xs）b=elementAt xs（b-1）
prop_elementAt（Foo xs b）=elementAt xs（b+1）=xs！！B
数据Foo a b=Foo[a]b派生（显示）
实例（积分b，任意a，任意b）=>任意（Foo a b），其中
任意的
as 0
b=0且b

在同一台机器上出现了同样的问题，而且似乎工作正常。但是为我运行

verboseCheck prop_elementAt

会返回无限的列表，其中只包含元素

（）

，这意味着

elementAt（x:xs）\ux=x

的实现仍然会通过。你知道如何生成一个包含实际元素的列表吗？那是因为它推断出了错误类型的prop_elemAt。给它显式类型（例如

prop\u elementAt:：Foo[Int]Int->Bool

）。

{-# LANGUAGE TemplateHaskell #-}

import Test.QuickCheck
import Test.QuickCheck.All

elementAt :: (Integral b) => [a] -> b -> a
elementAt [x] _ = x
elementAt (x:xs) 1 = x
elementAt (x:xs) b = elementAt xs (b - 1)

prop_elementAt (Foo xs b) = elementAt xs (b + 1) == xs !! b

data Foo a b = Foo [a] b deriving (Show)

instance (Integral b, Arbitrary a, Arbitrary b) => Arbitrary (Foo a b) where
  arbitrary = do
    as <- listOf1 arbitrary           -- length xs > 0
    b <- choose (0,length as - 1)     -- b >= 0 and b < length xs
    return (Foo as $ fromIntegral b)

main = $(quickCheckAll)