ScalaCheck生成StackOverflowError

Question

我想创建生成器（用于ScalaCheck）以生成命题公式。如果我创建一个生成器以使用变量and-logic运算符（例如：A和B）生成公式，那么一切正确。但是，如果我添加或暗示（不是），ScalaCheck会生成Exception: java.lang.StackOverflowError。

import org.scalacheck.Prop
import org.scalacheck.Properties
import org.scalacheck.Gen

object FormulaWffSpecification extends Properties("FormulaWff") {

  abstract class FormulaWff {
    def size: Int
    def depths: Int
  }
  case class And(left: FormulaWff, right: FormulaWff)     extends FormulaWff
  case class Or(left: FormulaWff, right: FormulaWff)      extends FormulaWff
  case class Implies(left: FormulaWff, right: FormulaWff) extends FormulaWff
  case class Not(son: FormulaWff)                         extends FormulaWff
  case class Var(string: String)                          extends FormulaWff

  val genAnd = for {
    left  <- myGenFormula
    right <- myGenFormula
  } yield And(left, right)

  val genOr = for {
    left  <- myGenFormula
    right <- myGenFormula
  } yield Or(left, right)

  val genImplies = for {
    left  <- myGenFormula
    right <- myGenFormula
  } yield Implies(left, right)

  val genNot = for {
    son <- myGenFormula
  } yield Not(son)

  val genVar = Gen.oneOf(Var("A"),Var("B"))

  def myGenFormula: Gen[FormulaWff] =
    Gen.lzy(Gen.oneOf(genVar, genAnd, genImplies, genOr, genNot))

  property("size(t) <= 2^(depths(t) + 1) - 1") = {
    Prop.forAll(myGenFormula) { f: FormulaWff =>
      f.size <= Math.pow(2, f.depths + 1) - 1
    }
  }
}

Answer 1

显而易见的是，myGenFormula的定义是递归的。那就是堆栈溢出的解释。

解决问题的一部分是确保在Gen.lzy的正确位置添加myGenFormula。这样可以确保执行生成器的单个路径，并避免不必要地执行所有递归生成器。

myGenFormula的定义存在第二个问题，它将导致堆栈溢出。如所写，myGenFormula的定义在统计上不太可能终止。 genVar生成器是终止生成器，但与其他非终止生成器的权重相同。没有什么可以阻止ScalaCheck在到达堆栈溢出之前生成无限深度的数据结构。

有两种方法可以帮助递归生成器在ScalaCheck中终止。您可以将带有Gen.sized的数字深度参数传递给生成器，也可以使用Gen.frequency。

相互递归生成器还存在初始化问题。您需要在引用lazy的生成器val上使用myGenFormula关键字来避免这种情况。

这是一个在您的代码中撒满lazy，Gen.lzy和Gen.frequency的解决方案，以使其运行并终止。您可能需要调整您的测试需求。

lazy val genAnd = for {
  left <- myGenFormula
  right <- myGenFormula
} yield And(left, right)

lazy val genOr = for {
  left <- myGenFormula
  right <- myGenFormula
} yield Or(left, right)

lazy val genImplies = for {
  left <- myGenFormula
  right <- myGenFormula
} yield Implies(left, right)

lazy val genNot = for {
  son <- myGenFormula
} yield Not(son)

val genVar =
  Gen.oneOf(Var("A"), Var("B"))

val myGenFormula: Gen[FormulaWff] =
  Gen.frequency(
    4 -> genVar,
    1 -> Gen.lzy(genAnd),
    1 -> Gen.lzy(genImplies),
    1 -> Gen.lzy(genOr),
    1 -> Gen.lzy(genNot))

property("myGenFormula") = {
  Prop.forAll(myGenFormula) { f: FormulaWff =>
    true
  }
}