标签: quickcheck

我为一个我正在工作的小足球比赛写了一个有限状态机模块.它提供了一个用于设置FSM的接口(基本上是它的状态和转换).对于每个状态,您可以提供将在进入和退出时触发的函数,或者当FSM保持相同状态时,这些函数然后返回一些消息.它还提供了一个反应接口(Yampa),它产生时变状态并收集随时间发生的消息.该代码是在这里数据/ FSM.hs.

我正在寻找一种测试这个模块的好方法.由于它是纯净的,我想考虑快速检查一下.我没有经验快速检查,所以任何提示将不胜感激!到目前为止我的基本理解是:一个人会提供一些或多或少随机构建FSM的函数,然后在它们上运行一些(或多或少随机)转换.但我不太明白如何以这种方式构建测试......

我正在将QuickCheck移植到Rust,我写了一切,除非for_all我不确定类型签名应该是什么.

我知道,一般来说,for_all将接受属性lambda和生成器lambda的集合.它将评估生成器以创建随机测试用例以将属性作为输入.

它应该打印+++ OK, passed 100 tests.,如果属性返回true,否则要打印*** Failed!,打印违规测试用例值.

QuickCheck库似乎捕获了测试属性时抛出的所有异常.特别是,这种行为使我无法对整个QuickCheck计算设置时间限制.例如:

module QuickCheckTimeout where

import System.Timeout (timeout)
import Control.Concurrent (threadDelay)
import Test.QuickCheck (quickCheck, within, Property)
import Test.QuickCheck.Monadic (monadicIO, run, assert)

-- use threadDelay to simulate a slow computation
prop_slow_plus_zero_right_identity :: Int -> Property
prop_slow_plus_zero_right_identity i = monadicIO $ do
  run (threadDelay (100000 * i))
  assert (i + 0 == i)

runTests :: IO ()
runTests = do
  result <- timeout 3000000 (quickCheck prop_slow_plus_zero_right_identity)
  case result of
    Nothing -> putStrLn "timed out!"
    Just _  -> putStrLn "completed!"

因为QuickCheck捕获了所有异常,所以timeout中断:它实际上并没有中止计算!相反,QuickCheck将属性视为失败,并尝试缩小导致失败的输入.然后,该缩小过程不会以时间限制运行,导致计算使用的总时间超过规定的时间限制.

有人可能会认为我可以使用QuickCheck的 …

我想为一套Parsec解析器编写测试.这是我想用QuickCheck测试的解析器的一个简单示例:

identifier = do
  c <- letter
  cs <- many (alphaNum <|> oneOf identSymbols)
  skipSpaces
  return $ Ident $ c:cs

所以,理想情况下,我希望QuickCheck生成有效的标识符,并确保我得到正确的结果,以及生成无效的标识符并确保它们返回ParseError.是否有任何实用程序可以使这种事情变得更容易？有没有办法可以"反向运行我的解析器",可以说,生成这样的输入？

一般来说,这个解析器的一套优秀的QuickCheck测试是什么样的？在某种程度上,似乎我基本上必须在QuickCheck中复制解析器的逻辑以实现彻底的测试.这真的是一个好主意,或者这可能是像HUnit这样的传统工具比QuickCheck更合适的情况吗？

我想为Parsec解析器编写测试.以下是解析器和数据结构的示例:

data Event = Event { keyEvent :: String }
    deriving Show

parseKey :: Parser Event
parseKey = do
             char '<'
             k <- many1 (letter <|> digit <|> oneOf "_")
             char '>'
             return $ Event k

我知道我需要检查parse = parse . pretty . parse房产.但是,我应该如何生成正确和不正确的测试用例？一般来说,我应该如何为给定的BNF生成测试用例？我知道instance Arbitrary,但这并没有多大帮助.

如果您为这个简单的解析器提供一个评论良好的生成器示例,我将不胜感激.

鉴于以下内容:

test :: (Int -> Int) -> Int -> Bool
test _ _ = True

编译源代码后,我尝试运行quickCheck test:

> quickCheck test
<interactive>:27:1:
    No instance for (Show (Int -> Int))
      arising from a use of ‘quickCheck’
    In the expression: quickCheck test
    In an equation for ‘it’: it = quickCheck test

看看这个函数的Show实例,我觉得不存在这样的实例.

我该如何运行quickCheck test,即绕过或解决丢失的Show实例Int -> Int？

我正在尝试使用Haskell的QuickCheck,虽然我熟悉测试方法背后的概念,但这是我第一次尝试将它用于一个超出测试类似的项目的那个项目reverse . reverse == id.事情.我想知道将它应用于业务逻辑是否有用(我认为非常可能).

因此,我想测试的几个现有业务逻辑类型函数如下所示:

shouldDiscountProduct :: User -> Product -> Bool
shouldDiscountProduct user product =
  if M.isNothing (userDiscountCode user)
     then False
     else if (productDiscount product) then True
                                       else False

对于此功能,我可以编写如下的QuickCheck规范:

data ShouldDiscountProductParams
  = ShouldDiscountProductParams User Product

instance Show ShouldDiscountProductParams where
  show (ShouldDiscountProductParams u p) =
    "ShouldDiscountProductParams:\n\n" <>
    "- " <> show u <> "\n\n" <>
    "- " <> show p

instance Arbitrary ShouldDiscountProductParams where
  arbitrary = ShouldDiscountProductParams <$> arbitrary <*> arbitrary

shouldDiscountProduct :: Spec
shouldDiscountProduct = …

为什么没有QuickCheck类似于hedgehog's的函数success？我特别想知道如何翻译如下属性：

prop_specialPair :: Property
prop_specialPair = property $ do
  (_, xs) <- forAll specialPair
  case xs of
    x:_ -> x /== 3
    _   -> success

在QuickCheck如果我使用=/=，然后我被迫返回类型的东西Property，而且似乎有没有固定函数返回一个通过性。

所以我要么不得不求助于Bool类型：

prop_specialPair :: SpecialPair -> Bool
prop_specialPair SpecialPair { xs } =
  case xs of
    x:_ -> x == 3
    _   -> True

或者对 使用非常尴尬的编码success，例如：

prop_specialPair :: SpecialPair -> Property
prop_specialPair SpecialPair { xs } =
  case xs …

我正在阅读精彩的Haskell Book。在 Traversable 一章（21）的最后，我需要为以下 Tree 编写一个实例：

data Tree a =
    Empty
  | Leaf a
  | Node (Tree a) a (Tree a)

这是我的解决方案的完整代码的链接。练习建议尝试同时实现foldMap和foldr。这就是我的实现方式foldr（没有考虑调用顺序）：

foldr _ z Empty = z
foldr f z (Leaf x) = f x z
foldr f z (Node left x right) = 
  f x $ foldr f (foldr f z left) right

然后我实现foldMap如下：

foldMap f Empty = mempty
foldMap f (Leaf x) = …

我有两个功能。他们是：

f1 [] = []
f1 (x:xs) = if contains x xs then f1 xs else x:f1 xs

和

f6 xs = f1 (rev xs)

除了空列表和任何具有一个元素的列表之外，这两个函数返回相同的列表是没有意义的，但是在此函数上运行 quickcheck 时：

prop_sort6 xs = (f1 xs == f6 xs) == True

所有的测试都通过了。为什么会这样？

编辑：

例如这样做：(f1 [1,2,3] == f6 [1, 2, 3])显然会导致 False，但 quickcheck 仍然通过。