blocks|key|374566|text|是的，好吧。实际上不是，但我曾师从于最初开发QuickCheck的人，他是一个非常有趣的人。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|374567|回到2004年，我们被迫使用QuickCheck来测试我们的Haskell程序，这是好的和坏的结合。大部分都很糟糕，因为Haskell本身有点令人望而生畏，但当你让它工作时，它仍然很棒。|374568|从那时起，John完善了他几年前写的东西，实际上帮助爱立信测试了他们复杂的电信硬件，他在大约2000万行代码中发现了错误，通过他的方法将这一过程减少到了仅仅三步。他是一个伟大的演讲者，所以总是有一个joy在听他讲述他做得很好的东西，但总而言之，他和QuickCheck做的事情对我来说是新的。所以我问他，他对把这个推向市场有什么兴趣。他对这个想法持开放态度，但当时他的业务(基于QuickCheck)相对较新，因此他还会专注于其他领域。现在是2007年了。我的观点是，即使你最终不会使用QuickCheck，你也可以向它学习。|374569|但是什么是QuickCheck呢？它是一个组合测试框架，也是一种有趣的测试程序的方法。微软研究院的人已经开发出了类似的Pex。Pex通过检查您的IL自动生成测试。然而，John会为可能的输入编写一个生成器，并测试函数的属性。属性是很容易测试的东西，而且它更正式。例如，反转列表？嗯，颠倒一个列表，等同于将一个列表一分为二，分别颠倒它们，然后以相反的顺序连接两个颠倒的一半。|offset|length|374570|1,2,3,4+//+original
1,2+3,4+//+split+into+A+and+B
2,1+4,3+//+reverse+A+and+B
4,3,2,1+//+concat+B+and+A|code-block|syntax|javascript|374571|这是使用QuickCheck测试的一个很好的属性，称为规范，结果相当惊人。|374572|Pex很好，但没有QuickCheck那么酷，Pex简化了事情，QuickCheck做到了，但要写出一个好的规范需要付出很多努力。|374573|QuickCheck的强大之处在于，当它遇到失败时，它会将导致测试失败的输入减少到尽可能小的形式。给你一个详细的描述，说明是什么状态的发展导致了你的测试失败。与其他测试框架相比，其他测试框架只会试图以暴力的方式破坏您的代码。|374574|这要归功于您编写测试规范的方式。QuickCheck依靠伪随机性来发明输入，正因为如此，它能够回溯并找到未通过测试的非常小的输入。|374575|编写QuickCheck属性需要更多的工作，但最终的结果是更好的测试。正如John自己所说，70%25的but是通过单元测试捕获的，但正是另外30%25的but导致程序崩溃。QuickCheck正在测试最后30%25的数据。|374576|entityMap|0|LINK|mutability|MUTABLE|url|http://research.microsoft.com/en-us/projects/Pex/^0|0|0|0|1N|3|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|19|8|@]|9|@$H|1A|I|1B|1|1C]]|A|$]]|$1|J|3|K|5|L|7|1D|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1H|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

Yes, well. Actually no, but I've studied under the man who originally developed QuickCheck and he's a really interesting guy.

Back in 2004, we were forced to use QuickCheck to test our Haskell programs and it was combination of good and bad. Mostly bad because Haskell was a bit daunting itself but never the less wonderful when you got it working.

John has since then perfected that which he wrote years back and actually helped Ericssion test their complex telecom hardware, and he found bugs in 20 millions or so lines of code reducing that to a mere three steps through his approach. He's a great speaker so it's always a joy listening to him present what he does so well, but all in all, what he did with QuickCheck was new to me. So I asked him, what his interest was in bringing this to the market. He was open to the idea, but at the time his business (based around QuickCheck) was relatively new and so there were other areas he would focus on. This is now 2007. My point is, you could learn from QuickCheck even if you wont end up using it.

But what is QuickCheck? It's a a combinatorial testing framework and an interesting way to test programs. The people over at Microsoft Research has built <a href="http://research.microsoft.com/en-us/projects/Pex/" rel="noreferrer">Pex</a> which is sort of similar. Pex generates tests automatically by examining your IL. However, John would write a generator for possible input and test properties of a function. A property is something which can easily be tested and it's a lot more formal. e.g. reversing a list? Well, reversing a list, is the same thing as splitting a list in two halves, reversing them each individually and then concatenating the two reversed halves in reverse order.

<pre><code>1,2,3,4 // original
1,2 3,4 // split into A and B
2,1 4,3 // reverse A and B
4,3,2,1 // concat B and A
</code></pre>

This is a great property to test with QuickCheck called the specification and the result is quite astonishing.

Pex is nice, but not as cool as QuickCheck, Pex simplifies things, QuickCheck does to but it takes a lot of effort to write a good specification.

The power of QuickCheck is that when it runs into a failure it will reduce the input which caused your test to fail, to the smallest possible form. Leaving you with a detailed description of what progression of state caused your test to fail. In comparison to other testing frameworks which will just try to break your code in a brute force manner.

This is made possible due to how you write your testing specification. QuickCheck relies on pseudo-randomness to invent input and it's because of this, its capable of backtracking and find really small input which does not pass your test.

It's a lot more work to write QuickCheck properties but the end result is better testing. As John himself said, 70% of bugs are caught by unit testing, but it's that other 30% which causes your program to crash. QuickCheck is testing those last 30%.

blocks|key|3592065|text|我经常使用它，主要是以简单的方式，主要用于测试协议和解析器实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3592066|然而，这里是我个人经验中不那么琐碎的一部分：http://www.haskell.org/haskellwiki/QuickCheck_as_a_test_set_generator|offset|length|3592067|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/haskellwiki/QuickCheck_as_a_test_set_generator^0|0|M|1X|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

I've used it quite a lot, mostly in straighforward manner, chiefly for testing protocol and parser implementations.

However, here is less trivial bit from my personal experience: <a href="http://www.haskell.org/haskellwiki/QuickCheck_as_a_test_set_generator" rel="noreferrer">http://www.haskell.org/haskellwiki/QuickCheck_as_a_test_set_generator</a>

blocks|key|1054859|text|我使用QuickCheck做很多私人的事情。在过去六个月内：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1054860|1054861|运行QuickCheck来测试图像中的颜色变换和离散余弦变换，以测试我为一些numerical++QuickCheck开发的符号微分模块，以测试本特利和塞奇威克风格的三元搜索树。|unordered-list-item|1054862|1054863|QuickCheck很少能满足我所有的单元测试需求，但它是一种很好的入门方式-而且QuickCheck法则提供了很好的文档。|1054864|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|L|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|M|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|J|$]]

I use QuickCheck for a lot of personal stuff. Within the last six months:

<ul>
<li>Ran QuickCheck to test color transformations and discrete cosine transforms in an image compressor.</li>
<li>Ran QuickCheck to test a symbolic-differentiation module I whipped up for some numerical optimization.</li>
<li>Ran QuickCheck to test a ternary-search tree in the style of Bentley and Sedgewick.</li>
</ul>

QuickCheck rarely meets all my unit-testing needs, but it's a great way to get started---and the QuickCheck laws make good documentation.

blocks|key|374681|text|ScalaCheck+(用于Scala的QuickCheck+)用于测试Functional+Java，这是一个实现a+QuickCheck+for+Java的库。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|374682|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/scalacheck/|1|http://functionaljava.org/|2|http://functionaljava.googlecode.com/svn/artifacts/2.17/javadoc/fj/test/package-summary.html^0|0|A|0|10|F|1|1M|L|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

<a href="http://code.google.com/p/scalacheck/" rel="noreferrer">ScalaCheck</a> (a QuickCheck for Scala) is used to test <a href="http://functionaljava.org" rel="noreferrer">Functional Java</a>, a library that, among other things, implements <a href="http://functionaljava.googlecode.com/svn/artifacts/2.17/javadoc/fj/test/package-summary.html" rel="noreferrer">a QuickCheck for Java</a>.

blocks|key|3592385|text|我做了一个真实的Haskell问题，其中包括离散事件模拟。因此，我编写了一个基于continuation的DES库，以及MVars和Channels的等价物。我需要检查这是否正常工作，所以我编写了一组QuickCheck属性来演示，例如，写入通道的两个并发数据流将被正确合并，而不会丢弃任何内容。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3592386|我还使用QuickCheck记录和验证了我的Ranged+Sets和Decimal库中的属性。|offset|length|3592387|根据我的经验，QuickCheck有时是很棒的。如果你能以一种简洁的方式总结一个重要的属性，尽管交付该属性的算法很复杂，那么QuickCheck是一个巨大的胜利。另一方面，我经常发现算法等同于我想要验证的属性。在这种情况下，我寻找更简单的属性。例如，假设函数"foo“是非严格单调的。然后你就可以写|3592388|prop_fooMonotonic+x+y+=+(x+>+y)+==>+(foo+x+>=+foo+y)|code-block|syntax|javascript|3592389|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Ranged-sets-0.2.0|1|http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Decimal^0|0|M|B|0|Y|7|1|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]|$D|11|E|12|1|13]]|A|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]]]

I've done a real Haskell problem which involved a discrete event simulation. So I wrote a DES library based on the continuation monad, along with the equivalents to MVars and Channels. I needed to check that this worked properly, so I wrote a bunch of QuickCheck properties to demonstrate that, for instance, two streams of concurrent data written to a Channel would be correctly merged without dropping anything.

I've also used QuickCheck to document and verify the properties in my <a href="http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Ranged-sets-0.2.0" rel="noreferrer">Ranged Sets</a> and <a href="http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Decimal" rel="noreferrer">Decimal</a> libraries. 

In my experience QuickCheck is sometimes great. If you can summarise an important property in a concise way, although the algorithm that delivers that property is hairy, then QuickCheck is a huge win. On the other hand I often find that the algorithm is equivalent to the property I want to verify. In that case I look for simpler properties. For instance, suppose function "foo" is supposed to be non-strictly monotonic. Then you can write

<pre><code>prop_fooMonotonic x y = (x &gt; y) ==&gt; (foo x &gt;= foo y)
</code></pre>

blocks|key|374744|text|我只在开发小辅助工具的生产环境中使用过Haskell。主要是因为我是我所知道的唯一会阅读Haskell的开发人员。虽然我广泛地使用了QuickCheck，但我真的很恼火，因为C#中没有类似的东西。所以我决定试一试write+it+myself。我也查看了Pex，但发现用于查找最少输入的程序探索技术不如QuickCheck的方式有趣。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|374745|entityMap|0|LINK|mutability|MUTABLE|url|http://kilfour.wordpress.com/2009/08/02/testing-tool-tour-quicknet-preview/^0|2Y|F|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I have only used Haskell in a production environment for the development of little helper tools. Mainly because I'm the only developer I know that reads Haskell. I used QuickCheck extensively though, and got really annoyed that something similar is not available in C#. So I decided to try and <a href="http://kilfour.wordpress.com/2009/08/02/testing-tool-tour-quicknet-preview/" rel="nofollow noreferrer">write it myself</a>. I looked at Pex too, but found the program exploration techniques that are used to find minimal input less interesting than the way QuickCheck does that.

blocks|key|1050058|text|使用QuickCheck对AFAIK+XMonad进行了广泛的测试|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1050059|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

AFAIK XMonad is tested extensively with QuickCheck

blocks|key|3592470|text|我使用QuickCheck来测试用任何语言编写的命令行程序的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3592471|这对于查找低级或动态类型程序崩溃的输入特别有用。|3592472|为方便起见，我编写了http://hackage.haskell.org/package/proctest，其中包括一些结合使用QuickCheck、hspec和HUnit以这种方式测试命令行程序的示例。|offset|length|3592473|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/package/proctest^0|0|0|A|17|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

I use QuickCheck to test the behaviour of command-line programs written in any language.

It is especially useful to find inputs on which low-level or dynamically typed programs crash.

For convenience, I wrote <a href="http://hackage.haskell.org/package/proctest" rel="nofollow">http://hackage.haskell.org/package/proctest</a>, which includes some examples of QuickCheck being used together with hspec and HUnit to test command line programs this way.

blocks|key|1054966|text|我们使用FsCheck检查OCaml到F#的转换是否正确，以及优化后的版本与未优化的版本是否相同。我还计划使用它来测试词法分析器和解析器，因为NHol项目使用了parser组合器。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1054967|我们还有帮助器函数，允许我们在NUnit+(.Net的XUnit)中运行测试。参见assertProp。|1054968|entityMap|0|LINK|mutability|MUTABLE|url|http://fscheck.codeplex.com/|1|https://github.com/jack-pappas/NHol|2|https://github.com/jack-pappas/NHol/blob/master/NHol/parser.fs|3|http://www.nunit.org/|4|https://github.com/jack-pappas/NHol/blob/master/NHol.Tests/TestHelpers.fs^0|4|7|0|1Z|4|1|28|6|2|0|F|5|3|15|A|4|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]|$A|Z|B|10|1|11]|$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|6|7|15|8|@]|9|@$A|16|B|17|1|18]|$A|19|B|1A|1|1B]]|C|$]]|$1|F|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]|P|$5|I|J|K|C|$L|Q]]|R|$5|I|J|K|C|$L|S]]|T|$5|I|J|K|C|$L|U]]]]

We use <a href="http://fscheck.codeplex.com/" rel="nofollow">FsCheck</a> to check that our OCaml to F# translations are correct, and that our optimized versions work the same as the un-optimized versions. I also plan to use it to test the lexer and parser since the <a href="https://github.com/jack-pappas/NHol" rel="nofollow">NHol</a> project uses a <a href="https://github.com/jack-pappas/NHol/blob/master/NHol/parser.fs" rel="nofollow">parser</a> combinator.

We also have helper functions that allow us to run the test within <a href="http://www.nunit.org/" rel="nofollow">NUnit</a> (XUnit for .Net). See <a href="https://github.com/jack-pappas/NHol/blob/master/NHol.Tests/TestHelpers.fs" rel="nofollow">assertProp</a>.

blocks|key|374865|text|我使用QuickCheck在LG+Linux+Mobile平台上对SMS+PDU编解码器进行了测试。我当时开发的一款软件的(旧)版本可从http://hackage.haskell.org/package/GenSmsPdu-0.1下载|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|374866|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/package/GenSmsPdu-0.1^0|1W|1C|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I have used QuickCheck for testing SMS PDU encoder and decoder in LG Linux Mobile platform. A (old) version of a piece of software I developed at that time is available for download at <a href="http://hackage.haskell.org/package/GenSmsPdu-0.1" rel="nofollow">http://hackage.haskell.org/package/GenSmsPdu-0.1</a>

blocks|key|3592551|text|这不是我的项目，但是containers包相当广泛地使用了QuickCheck。就我个人而言，我试着用它来比较我写的一个愚蠢的小素数筛子和arithmoi中的一个，这让我发现arithmoi中的一个有时会有段错误。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3592552|entityMap^0|A|A|1X|8|2F|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

It's not my project, but the <code>containers</code> package uses QuickCheck fairly extensively. Personally, I tried using it to compare a silly little prime sieve I wrote to one in <code>arithmoi</code>, which led me to discover that one in <code>arithmoi</code> sometimes segfaults.

<a href="http://www.cs.chalmers.se/~rjmh/QuickCheck/" rel="noreferrer">Quickcheck</a> and its variants (even there is one in <a href="https://bitbucket.org/blob79/quickcheck" rel="noreferrer">Java</a>), seems to be interesting. However, apart from academic interest, is it really useful in a real application testing (Eg. a GUI application or Client/Server or even take StackOverflow itself)? Any experiences you had with similar test generators is appreciated.

Have you used Quickcheck in a real project

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

及其变体(甚至在中也有)似乎很有趣。然而，除了学术兴趣之外，它在实际的应用程序测试中是否真的有用(例如，图形用户界面应用程序或客户端/服务器，甚至是StackOverflow本身)？如果您有类似测试生成器的经验，我们将不胜感激。

问您是否在实际项目中使用过Quickcheck
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问您是否在实际项目中使用过QuickcheckEN