ScalaCheck，不同的行爲

Question

我有一個使用ScalaCheck性能，如果測試一些類

package quickcheck.tests 

import org.scalacheck.Arbitrary._ 
import org.scalacheck.Gen._ 
import org.scalacheck.Prop._ 
import org.scalacheck._ 
import org.scalacheck.util.ConsoleReporter 

class Heap 
{ 
} 

object Heap 
{ 
    val empty = new Heap 
    def insert(i: Int, h: Heap) = new Heap 
} 

class TestCheck extends Properties("Heap") 
{ 
    lazy val genHeap: Gen[Heap] = 
    { 
    def sizedHeap(size: Int): Gen[Heap] = 
    { 
     if (size <= 0) 
     Heap.empty 
     else 
     for 
     (
      i <- arbitrary[Int] suchThat(_ > Int.MinValue); 
      s <- choose(0, size); 
      h <- sizedHeap(s) 
     ) 
      yield 
      Heap.insert(i, h) 
    } 

    Gen.sized[Heap](sizedHeap) 
    } 

    implicit lazy val arbHeap: Arbitrary[Heap] = Arbitrary(genHeap) 

    property("test1") = forAll 
    { 
    (h: Heap) => true 
    } 

    property("test2") = forAll 
    { 
    (h1: Heap, h2: Heap, n: Int) => true 
    } 
} 

object MyTest extends App 
{ 
    println("*** TEST 1") 
    val checkHeap = new TestCheck 
    Test.checkProperties(Test.Parameters.default.withTestCallback(ConsoleReporter(1)), 
    checkHeap) 

    println("*** TEST 2") 
    val checkHeap2 = new TestCheck 
    checkHeap2.check 

    println("*** TEST 3") 
    val checkHeap3 = new TestCheck 
    Test.check(Test.Parameters.default.withTestCallback(ConsoleReporter(1)),  checkHeap) 
} 

如果我運行它直通的ScalaCheck Test類我得到不同的結果下面的代碼我使用方法Test.checkProperties或方法Test.check。

這是輸出我得到：

*** TEST 1 
+ Heap.test1: OK, passed 100 tests. 
+ Heap.test2: OK, passed 100 tests. 
*** TEST 2 
+ Heap.test1: OK, passed 100 tests. 
+ Heap.test2: OK, passed 100 tests. 
*** TEST 3 
! Gave up after only 40 passed tests. 202 tests were discarded. 

我的問題是，爲什麼TEST1給出不同的結果，TEST3。

如果我刪除suchThat濾波器和離開for聲明中sizeHead方法是：

for 
(
    i <- arbitrary[Int] 
    s <- choose(0, size); 
    h <- sizedHeap(s) 
) 
    yield 
    Heap.insert(i, h) 

我得到以下結果：

*** TEST 1 
+ Heap.test1: OK, passed 100 tests. 
+ Heap.test2: OK, passed 100 tests. 
*** TEST 2 
+ Heap.test1: OK, passed 100 tests. 
+ Heap.test2: OK, passed 100 tests. 
*** TEST 3 
+ OK, passed 100 tests. 

這是一個錯誤，或者是正確的行爲？請記住，ScalaTest Checkers.check使用Test.check。

Answer 1

因爲你做了不同的事情，你會得到不同的結果。您的前兩項測試 - effectively the same - 單獨檢查所有屬性，而第三項測試將所有屬性視爲單個屬性。

看看Test.check和Test.checkProperties的簽名：前者採用單個Prop，而後者採用Properties容器。

在scarecheck 1.12 Properties繼承自Prop;如果您通過Properties作爲Prop，您將獲得一個新屬性即tests whether all contained properties hold。結果是你用一個單一的檢查配置（即生成器，迭代限制等）來測試你所有的屬性，並且當然在某個點上檢查配置已經耗盡。

所以是的，這是預期的行爲。當然，這是完全令人困惑的，因此scalacheck 1.13刪除了這個特性：Properties不再繼承自Prop;你的例子不會在scalacheck 1.13上編譯。