Merge pull request #165 from dwijnand/cap-Size

Cap Size to [1-100] by clamping

Author: charleso

core/shared/src/main/scala/hedgehog/Range.scala

@@ -7,7 +7,7 @@ import hedgehog.predef.{DecimalPlus, IntegralPlus}
  * Tests are parameterized by the size of the randomly-generated data, the
  * meaning of which depends on the particular generator used.
  */
-case class Size(value: Int) {
+sealed abstract case class Size private (value: Int) {
 
   /** Represents the size as a percentage (0 - 1) which is useful for range calculations */
   def percentage: Double =
@@ -24,6 +24,10 @@ case class Size(value: Int) {
 }
 
 object Size {
+  def apply(value: Int): Size = {
+    val remainder = value % max
+    new Size(if (remainder <= 0) remainder + max else remainder) {}
+  }
 
   def max: Int =
     100
@@ -131,13 +135,13 @@ object Range {
    * parameter.
    *
    * {{{
-   * scala> Range.linear(0, 10).bounds(Size(0))
+   * scala> Range.linear(0, 10).bounds(Size(1))
    * (0,0)
    *
    * scala> Range.linear(0, 10).bounds(Size(50))
    * (0,5)
    *
-   * scala> Range.linear(0, 10).bounds(Size(99))
+   * scala> Range.linear(0, 10).bounds(Size(100))
    * (0,10)
    * }}}
    */
@@ -149,13 +153,13 @@ object Range {
    * parameter.
    *
    * {{{
-   * scala> Range.linearFrom(0, -10, 10).bounds(Size(0))
+   * scala> Range.linearFrom(0, -10, 10).bounds(Size(1))
    * (0,0)
    *
    * scala> Range.linearFrom(0, -10, 20).bounds(Size(50))
    * (-5,10)
    *
-   * scala> Range.linearFrom(0, -10, 20).bounds(Size(20))
+   * scala> Range.linearFrom(0, -10, 20).bounds(Size(100))
    * (-10,20)
    * }}}
    */

core/shared/src/main/scala/hedgehog/core/PropertyT.scala

@@ -170,12 +170,10 @@ trait PropertyTReporting {
     // Increase the size proportionally to the number of tests to ensure better coverage of the desired range
     val sizeInc = Size(Math.max(1, Size.max / config.testLimit.value))
     // Start the size at whatever remainder we have to ensure we run with "max" at least once
-    val sizeInit = Size(Size.max % Math.min(config.testLimit.value, Size.max)).incBy(sizeInc)
+    val sizeInit = Size((Size.max % Math.min(config.testLimit.value, Size.max)) + sizeInc.value)
     @annotation.tailrec
     def loop(successes: SuccessCount, discards: DiscardCount, size: Size, seed: Seed, coverage: Coverage[CoverCount]): Report =
-      if (size.value > Size.max)
-        loop(successes, discards, sizeInit, seed, coverage)
-      else if (successes.value >= config.testLimit.value)
+      if (successes.value >= config.testLimit.value)
         // we've hit the test limit
         Coverage.split(coverage, successes) match {
           case (_, Nil) =>

test/shared/src/test/scala/hedgehog/RangeTest.scala

@@ -10,6 +10,8 @@ object RangeTest extends Properties {
     , example("double", testFractional)
     , example("long", testLong)
     , property("double should not generate values outside of the range", testDoubleWithinRange).withTests(1000)
+    , example("size", testSize)
+    , property("size is always within the 1-100 range", testSizeWithinRange).withTests(1000)
     )
 
   def testIntegral: Result = {
@@ -66,4 +68,44 @@ object RangeTest extends Properties {
       , Result.assert(d >= Double.MinValue).log("min_value")
       , Result.assert(d <= Double.MaxValue).log("max_value")
       ))
+
+  def testSize: Result = {
+    Result.all(List(
+      Size(-1).value ==== 99 // using modulus, not remainder
+    , Size(0).value ==== 100
+    , Size(1).value ==== 1
+    , Size(2).value ==== 2
+    , Size(99).value ==== 99
+    , Size(100).value ==== 100
+    , Size(101).value ==== 1
+    ))
+  }
+
+  def testSizeWithinRange: Property = {
+    for {
+      n <- sizeValueGen.forAll
+        .cover(1, "too small", _ < 1)
+        .cover(1, "min", _ == 1)
+        .cover(9, "normal", x => x > 1 && x < 100)
+        .cover(1, "max", _ == 100)
+        .cover(1, "too big", _ > 100)
+    } yield {
+      val obtained = Size(n).value
+      Result.all(List(
+        Result.assert(obtained >= 1).log(s"expected size value to be >= 1, but it was $obtained")
+      , Result.assert(obtained <= 100).log(s"expected size value to be <= 100, but it was $obtained")
+      ))
+    }
+  }
+
+  def sizeValueGen: Gen[Int] =
+    for {
+      n <- Gen.int(Range.linearFrom(0, -5, 5))
+      i <- Gen.choice1(
+          Gen.constant(n)                                          // near min
+        , Gen.constant(100 - n)                                    // near max
+        , Gen.int(Range.linear(1, 100))                            // normal range
+        , Gen.int(Range.linearFrom(1, Int.MinValue, Int.MaxValue)) // total range
+        )
+    } yield i
 }