关于scala：使用嵌套的forAll在ScalaCheck中生成的对象之间共享元素

Sharing elements between generated objects in ScalaCheck using nested forAll

最近开始使用 Scala 编码，我尝试编写一些基于属性的测试用例。在这里，我试图生成模拟我正在测试的系统的原始数据。目标是首先生成基本元素(ctrl 和 idz)，然后使用这些值生成两个类(A1 和 B1)，最后检查它们的属性。我首先尝试了以下 -

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

import org.scalatest._
import prop._
import scala.collection.immutable._
import org.scalacheck.{Gen, Arbitrary}

case class A(
controller: String,
id: Double,
x: Double
)

case class B(
controller: String,
id: Double,
y: Double
)

object BaseGenerators {
val ctrl = Gen.const("ABC")
val idz = Arbitrary.arbitrary[Double]
}

trait Generators {
val obj = BaseGenerators

val A1 = for {
controller <- obj.ctrl
id <- obj.idz
x <- Arbitrary.arbitrary[Double]
} yield A(controller, id, x)

val B1 = for {
controller <- obj.ctrl
id <- obj.idz
y <- Arbitrary.arbitrary[Double]
} yield B(controller, id, y)

}

class Something extends PropSpec with PropertyChecks with Matchers with Generators{

property("Controllers are equal") {
forAll(A1, B1) {
(a:A,b:B) =>
a.controller should be (b.controller)
}
}

property("IDs are equal") {
forAll(A1, B1) {
(a:A,b:B) =>
a.id should be (b.id)
}
}

}

在终端中运行 sbt test 给了我以下 -

1
2
3
4
5
6
7
8
9
10

[info] Something:
[info] - Controllers are equal
[info] - IDs are equal *** FAILED ***
[info] TestFailedException was thrown during property evaluation.
[info] Message: 1.1794559135007427E-271 was not equal to 7.871712821709093E212
[info] Location: (testnew.scala:52)
[info] Occurred when passed generated values (
[info] arg0 = A(ABC,1.1794559135007427E-271,-1.6982696700585273E-23),
[info] arg1 = B(ABC,7.871712821709093E212,-8.820696498155311E234)
[info] )

现在很容易看出为什么第二个属性失败了。因为每次我产生 A1 和 B1 我都会为 id 而不是为 ctrl 产生不同的值，因为它是一个常数。以下是我的第二种方法，其中，我创建嵌套 for-yield 来尝试实现我的目标 -

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

case class Popo(
controller: String,
id: Double,
someA: Gen[A],
someB: Gen[B]
)

trait Generators {
val obj = for {
ctrl <- Gen.alphaStr
idz <- Arbitrary.arbitrary[Double]
val someA = for {
x <- Arbitrary.arbitrary[Double]
} yield A(ctrl, idz, someA)
val someB = for {
y <- Arbitrary.arbitrary[Double]
} yield B(ctrl, idz, y)
} yield Popo(ctrl, idz, x, someB)
}

class Something extends PropSpec with PropertyChecks with Matchers with Generators{

property("Controllers are equal") {
forAll(obj) {
(x: Popo) =>
forAll(x.someA, x.someB) {
(a:A,b:B) =>
a.controller should be (b.controller)
}
}
}

property("IDs are equal") {
forAll(obj) {
(x: Popo) =>
forAll(x.someA, x.someB) {
(a:A,b:B) =>
a.id should be (b.id)
}
}
}
}

在第二种方法中运行 sbt test 告诉我所有测试都通过了。

1
2
3
4
5
6
7
8
9

[info] Something:
[info] - Controllers are equal
[info] - IDs are equal
[info] ScalaTest
[info] Run completed in 335 milliseconds.
[info] Total number of tests run: 2
[info] Suites: completed 1, aborted 0
[info] Tests: succeeded 2, failed 0, canceled 0, ignored 0, pending 0
[info] All tests passed.

有没有更好/替代的方法来重现我想要的结果？嵌套 forAll 对我来说似乎相当笨拙。如果我的依赖图中有 R -> S -> ... V -> W 用于共享元素的对象，那么我将不得不创建尽可能多的嵌套 forAll.

相关讨论

我将在 Scalacheck 中给出答案。我知道 Scalatest 很受欢迎，但我发现将其包含在有关 Scalacheck 的问题中会分散注意力，尤其是当没有理由没有理由无法编写示例时。

您似乎想测试 A 和 B，但它们共享信息。表示该依赖关系的一种方法是您编写的 Popo 类。它既包含共享信息，也包含 A 和 B 的生成值。另一种选择是在类中生成 A 和 B 之间的共享值。

最简单的解决方案是成对生成 A 和 B(两个元组)。
不幸的是，有一些技巧可以让它发挥作用。您需要在 forAll 属性中使用 case 关键字。您不能为 Arbitrary 元组的 implicit 值提供证据，因此您必须在 forAll.

中明确指定元组的生成器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

import org.scalacheck.Gen
import org.scalacheck.Arbitrary
import org.scalacheck.Prop
import org.scalacheck.Prop.AnyOperators
import org.scalacheck.Properties

case class A(
controller: String,
id: Double,
x: Double
)

case class B(
controller: String,
id: Double,
y: Double
)

object BaseGenerators {
val ctrl = Gen.const("ABC")
val idz = Arbitrary.arbitrary[Double]
}

object Generators {
val obj = BaseGenerators

val genAB: Gen[(A,B)] = for {
controller <- obj.ctrl
id <- obj.idz
x <- Arbitrary.arbitrary[Double]
y <- Arbitrary.arbitrary[Double]
val a = A(controller, id, x)
val b = B(controller, id, y)
} yield (a, b) // !
}

class Something extends Properties("Something") {

property("Controllers and IDs are equal") = {
Prop.forAll(Generators.genAB) { case (a: A, b: B) => // !
a.controller ?= b.controller && a.id ?= b.id
}
}
}

关于您关于让对象共享信息的更广泛的问题，您可以通过编写带有函数参数的生成器来表示它。但是，它仍然需要嵌套的 forAll 生成器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

object Generators {
val obj = BaseGenerators

val genA = for {
controller <- obj.ctrl
id <- obj.idz
x <- Arbitrary.arbitrary[Double]
} yield A(controller, id, x)

def genB(a: A) = for { // !
y <- Arbitrary.arbitrary[Double]
} yield B(a.controller, a.id, y)
}

class Something extends Properties("Something") {

implicit val arbA: Arbitrary[A] = Arbitrary {
Generators.genA
}

property("Controllers and IDs are equal") = {
Prop.forAll { a: A => // !
Prop.forAll(Generators.genB(a)) { b: B => // !
(a.controller ?= b.controller) && (a.id ?= b.id)
}
}
}
}