快速检查运行时错误

Question

我对使用快速检查库感兴趣，但似乎它是设计用来测试属性的。 我想做的是为我定义的数据类型和编写的测试函数生成随机数据。 我不在乎结果是什么，即使函数在输入随机数据时产生运行时错误。 我看到的所有快速检查示例都是用于测试函数的属性的，例如在输入随机数据时结果大于5。 有没有办法以这种方式使用快速检查？ 就像是

data Result = A | B

fun :: Result -> Int
fun A = 5

main = check fun

在上面的代码中，我有一个自定义数据类型和一个不完整的函数。 如果通过B，此函数将失败。当然，运行时错误的类型不仅仅是不完整的函数。 我想检查生成数据，并将其提供给函数。 不关心结果是什么。 快速检查能够做到这一点吗？

编辑-我应该注意，我不是在寻找检查不完整模式的标志，而不是寻找不完整标志的标志。 我对通用运行时错误检查感兴趣。

Answer 1

相反，要确保不处理IO函数在可能的情况下不会引发异常。 异常只能被IO捕获，它们会破坏您原本希望从纯函数中获得的东西。

通过Control.Exception和Test.QuickCheck.Monadic一些帮助，这是可能的：

> import           Control.Exception       (Exception, PatternMatchFail,
>                                           SomeException, evaluate,
>                                           fromException, try)
> import           Data.Either             (either)
> import           Test.Hspec              (anyException, describe, hspec, it,
>                                           shouldThrow)
> import           Test.QuickCheck         hiding (Result)
> import           Test.QuickCheck.Monadic (assert, monadicIO, run)

首先，让我们编写一个函数，使我们能够检查是否抛出了某些异常：

> throwsExceptionOr :: Exception e => (e -> Bool) -> (a -> Bool) -> a -> IO Bool
> throwsExceptionOr pe pa = fmap (either pe pa) . try . evaluate

这使您可以编写如下测试：

> prop_fun_1 x = monadicIO . run $
>   throwsExceptionOr (const True :: SomeException -> Bool)
>                     (== 5)
>                     (foo x)

throwsExceptionOr非常笼统，因此您可以定义自己的帮助器：

> -- | Should always throw an exception.
> throwsException :: Exception e => (e -> Bool) -> a -> IO Bool
> throwsException p = fmap (either p (const False)) . try . evaluate

> -- | Should either pass the test or throw an exception.
> exceptionOr :: a -> (a -> Bool) -> IO Bool
> exceptionOr x p = fmap (either anyException p) . try . evaluate $ x
>   where
>     anyException :: SomeException -> Bool
>     anyException = const True

现在您可以像往常一样编写测试：

> data Result = A | B deriving (Enum, Show, Eq, Ord, Bounded, Read)
> 
> instance Arbitrary Result where
>   arbitrary = elements [A, B]
> 
> foo :: Result -> Int
> foo A = 5
> 
> prop_foo x = monadicIO . run $ foo x `exceptionOr` (== 5)

您可以走得更远，移动monadicIO . run monadicIO . run另一个帮手，但这是一项练习。 此外，可以使功能与其它测试框架，如兼容hspec或tasty ：

> main :: IO ()
> main = hspec $ do
>   describe "foo" $ do
>     it "either returns five or throws a pattern match fail" $ propertyIO $ \x ->
>       throwsExceptionOr patternMatchFail (==5) (foo x)
> 
>     it "throws an exception on input B" $
>       evaluate (foo B) `shouldThrow` anyException
> 
>  where
>   patternMatchFail :: PatternMatchFail -> Bool
>   patternMatchFail _ = True
> 
>   -- I think there is a better combinator for this
>   propertyIO f = property $ \x -> monadicIO . run $ f x

话虽如此， 无论使用哪种语言，都希望在编译时消除可能的运行时错误。 这包括摆脱部分功能或可能的类型废话。 当然，这取决于实际用途。 如果您可以验证在整个程序中总是总是在非空列表上调用head ，请继续使用它。 如果不能，请使用模式匹配（请参见有关head的类型的讨论 ）。

无论哪种方式，考虑到较旧的GHC版本都不提供堆栈调用，您宁愿希望在编译时出错，而不是在运行时没有堆栈跟踪的错误发生（最近版本的GHC为此提供了一些不错的功能）。