ScalaCheck，调用Test.check或Test.checkProperties时的不同行为

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

你得到了不同的结果，因为你在做不同的事情。前两个测试--分别是有效地相同-check所有属性，而第三个测试测试所有属性，就好像它们是单个属性一样。

看看Test.check和Test.checkProperties的签名:前者使用单个Prop，而后者使用Properties容器。

在scalacheck 1.12中，Properties继承了Prop；如果将Properties作为Prop传递给Prop，则会得到一个新属性测试所有包含的属性是否都保持。其结果是，您使用单个检查配置(即生成器、迭代限制等)测试所有TestCheck属性，当然，检查配置在某个点会耗尽。

所以是的，这是预期的行为。当然，这是绝对令人困惑的，因此scalacheck 1.13删除了这个特性：Properties不再从Prop继承；您的示例将不再在scalacheck 1.13上编译。