javatime.kt: ensure that time zone does not push the generated timestamp out of the valid range

Author: dconeybe

firebase-dataconnect/testutil/src/main/kotlin/com/google/firebase/dataconnect/testutil/property/arbitrary/javatime.kt

@@ -181,8 +181,10 @@ sealed interface TimeOffset {
 
   data class HhMm(val hours: Int, val minutes: Int, val sign: Sign) : TimeOffset {
     init {
-      require(hours in 0..18) { "invalid hours: $hours (must be in the closed range 0..23)" }
-      require(minutes in 0..59) { "invalid minutes: $minutes (must be in the closed range 0..59)" }
+      require(hours in validHours) { "invalid hours: $hours (must be in the closed range 0..23)" }
+      require(minutes in validMinutes) {
+        "invalid minutes: $minutes (must be in the closed range 0..59)"
+      }
       require(hours != 18 || minutes == 0) { "invalid minutes: $minutes (must be 0 when hours=18)" }
     }
 
@@ -196,15 +198,40 @@ sealed interface TimeOffset {
       append("$minutes".padStart(2, '0'))
     }
 
+    fun toSeconds(): Int {
+      val absValue = hours + (minutes * 60)
+      return when (sign) {
+        Sign.Positive -> absValue
+        Sign.Negative -> -absValue
+      }
+    }
+
     override fun toString() =
       "HhMm(hours=$hours, minutes=$minutes, sign=$sign, " +
         "zoneOffset=$zoneOffset, rfc3339String=$rfc3339String)"
 
+    operator fun compareTo(other: HhMm): Int = toSeconds() - other.toSeconds()
+
     @Suppress("unused")
     enum class Sign(val char: Char, val multiplier: Int) {
       Positive('+', 1),
       Negative('-', -1),
     }
+
+    companion object {
+      val validHours = 0..18
+      val validMinutes = 0..59
+      val maxSeconds: Int = 18 * 60
+
+      fun forSeconds(seconds: Int, sign: Sign): HhMm {
+        require(seconds in 0..maxSeconds) {
+          "invalid seconds: $seconds (must be between 0 and $maxSeconds, inclusive)"
+        }
+        val hours = seconds / 60
+        val minutes = seconds - (hours * 60)
+        return HhMm(hours = hours, minutes = minutes, sign = sign)
+      }
+    }
   }
 }
 
@@ -219,7 +246,6 @@ object JavaTimeArbs {
     val minuteArb = minute()
     val secondArb = second()
     val nanosecondArb = nanosecond().orNull(nullProbability = 0.15)
-    val timeOffsetArb = timeOffset()
 
     return arbitrary(JavaTimeInstantEdgeCases.all) {
       val year = yearArb.bind()
@@ -230,7 +256,55 @@ object JavaTimeArbs {
       val minute = minuteArb.bind()
       val second = secondArb.bind()
       val nanosecond = nanosecondArb.bind()
-      val timeOffset = timeOffsetArb.bind()
+
+      val instantUtc =
+        OffsetDateTime.of(
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            nanosecond?.nanoseconds ?: 0,
+            ZoneOffset.UTC,
+          )
+          .toInstant()
+
+      // The valid range below was copied from:
+      // com.google.firebase.Timestamp.Timestamp.validateRange() 253_402_300_800
+      val validEpochSecondRange = -62_135_596_800..253_402_300_800
+
+      val numSecondsBelowMaxEpochSecond = validEpochSecondRange.last - instantUtc.epochSecond
+      require(numSecondsBelowMaxEpochSecond > 0) {
+        "internal error gh98nqedss: " +
+          "invalid numSecondsBelowMaxEpochSecond: $numSecondsBelowMaxEpochSecond"
+      }
+      val maxTimeZoneOffset =
+        if (numSecondsBelowMaxEpochSecond >= TimeOffset.HhMm.maxSeconds) {
+          null
+        } else {
+          TimeOffset.HhMm.forSeconds(
+            numSecondsBelowMaxEpochSecond.toInt(),
+            TimeOffset.HhMm.Sign.Negative
+          )
+        }
+
+      val numSecondsAboveMinEpochSecond = instantUtc.epochSecond - validEpochSecondRange.first
+      require(numSecondsAboveMinEpochSecond > 0) {
+        "internal error mje6a4mrbm: " +
+          "invalid numSecondsAboveMinEpochSecond: $numSecondsAboveMinEpochSecond"
+      }
+      val minTimeZoneOffset =
+        if (numSecondsAboveMinEpochSecond >= TimeOffset.HhMm.maxSeconds) {
+          null
+        } else {
+          TimeOffset.HhMm.forSeconds(
+            numSecondsAboveMinEpochSecond.toInt(),
+            TimeOffset.HhMm.Sign.Positive
+          )
+        }
+
+      val timeOffset = timeOffset(min = minTimeZoneOffset, max = maxTimeZoneOffset).bind()
 
       val instant =
         OffsetDateTime.of(
@@ -245,14 +319,24 @@ object JavaTimeArbs {
           )
           .toInstant()
 
-      // The valid range below was copied from:
-      // com.google.firebase.Timestamp.Timestamp.validateRange()
-      require(instant.epochSecond in -62_135_596_800 until 253_402_300_800) {
+      require(instant.epochSecond >= validEpochSecondRange.first) {
         "internal error weppxzqj2y: " +
-          "instant.epochSecond out of range: ${instant.epochSecond} (" +
-          "year=$year, month=$month, day=$day, " +
+          "instant.epochSecond out of range by " +
+          "${validEpochSecondRange.first - instant.epochSecond}: ${instant.epochSecond} (" +
+          "validEpochSecondRange.first=${validEpochSecondRange.first}, "
+        "year=$year, month=$month, day=$day, " +
           "hour=$hour, minute=$minute, second=$second, " +
-          "nanosecond=$nanosecond timeOffset=$timeOffset)"
+          "nanosecond=$nanosecond timeOffset=$timeOffset, " +
+          "minTimeZoneOffset=$minTimeZoneOffset, maxTimeZoneOffset=$maxTimeZoneOffset)"
+      }
+      require(instant.epochSecond <= validEpochSecondRange.last) {
+        "internal error yxga5xy9bm: " +
+          "instant.epochSecond out of range by " +
+          "${instant.epochSecond - validEpochSecondRange.last}: ${instant.epochSecond} (" +
+          "validEpochSecondRange.last=${validEpochSecondRange.last}, " +
+          "year=$year, month=$month, day=$day, " +
+          "nanosecond=$nanosecond timeOffset=$timeOffset, " +
+          "minTimeZoneOffset=$minTimeZoneOffset, maxTimeZoneOffset=$maxTimeZoneOffset)"
       }
 
       val string = buildString {
@@ -282,7 +366,10 @@ object JavaTimeArbs {
     }
   }
 
-  fun timeOffset(): Arb<TimeOffset> = Arb.choice(timeOffsetUtc(), timeOffsetHhMm())
+  fun timeOffset(
+    min: TimeOffset.HhMm?,
+    max: TimeOffset.HhMm?,
+  ): Arb<TimeOffset> = Arb.choice(timeOffsetUtc(), timeOffsetHhMm(min = min, max = max))
 
   fun timeOffsetUtc(
     case: Arb<TimeOffset.Utc.Case> = Arb.enum(),
@@ -292,20 +379,42 @@ object JavaTimeArbs {
     sign: Arb<TimeOffset.HhMm.Sign> = Arb.enum(),
     hour: Arb<Int> = Arb.positiveIntWithUniformNumDigitsProbability(0..18),
     minute: Arb<Int> = minute(),
-  ): Arb<TimeOffset.HhMm> =
-    arbitrary(
+    min: TimeOffset.HhMm?,
+    max: TimeOffset.HhMm?,
+  ): Arb<TimeOffset.HhMm> {
+    require(min === null || max === null || min.toSeconds() < max.toSeconds()) {
+      "min must be strictly less than max, but got: " +
+        "min=$min (${min!!.toSeconds()} seconds), " +
+        "max=$max (${max!!.toSeconds()} seconds), " +
+        "a difference of ${min.toSeconds() - max.toSeconds()} seconds"
+    }
+
+    return arbitrary(
       edgecases =
         listOf(
-          TimeOffset.HhMm(hours = 0, minutes = 0, sign = TimeOffset.HhMm.Sign.Positive),
-          TimeOffset.HhMm(hours = 0, minutes = 0, sign = TimeOffset.HhMm.Sign.Negative),
-          TimeOffset.HhMm(hours = 17, minutes = 59, sign = TimeOffset.HhMm.Sign.Positive),
-          TimeOffset.HhMm(hours = 17, minutes = 59, sign = TimeOffset.HhMm.Sign.Negative),
-          TimeOffset.HhMm(hours = 18, minutes = 0, sign = TimeOffset.HhMm.Sign.Positive),
-          TimeOffset.HhMm(hours = 18, minutes = 0, sign = TimeOffset.HhMm.Sign.Negative),
-        )
+            TimeOffset.HhMm(hours = 0, minutes = 0, sign = TimeOffset.HhMm.Sign.Positive),
+            TimeOffset.HhMm(hours = 0, minutes = 0, sign = TimeOffset.HhMm.Sign.Negative),
+            TimeOffset.HhMm(hours = 17, minutes = 59, sign = TimeOffset.HhMm.Sign.Positive),
+            TimeOffset.HhMm(hours = 17, minutes = 59, sign = TimeOffset.HhMm.Sign.Negative),
+            TimeOffset.HhMm(hours = 18, minutes = 0, sign = TimeOffset.HhMm.Sign.Positive),
+            TimeOffset.HhMm(hours = 18, minutes = 0, sign = TimeOffset.HhMm.Sign.Negative),
+          )
+          .filter { (min === null || it >= min) || (max === null || it <= max) }
     ) {
-      TimeOffset.HhMm(hours = hour.bind(), minutes = minute.bind(), sign = sign.bind())
+      var count = 0
+      var hhmm: TimeOffset.HhMm
+      while (true) {
+        count++
+        hhmm = TimeOffset.HhMm(hours = hour.bind(), minutes = minute.bind(), sign = sign.bind())
+        if ((min === null || hhmm >= min) && (max === null || hhmm <= max)) {
+          break
+        } else if (count > 1000) {
+          throw Exception("internal error j878fp4gmr: exhausted attempts to generate HhMm")
+        }
+      }
+      hhmm
     }
+  }
 
   fun year(): Arb<Int> = Arb.int(MIN_YEAR..MAX_YEAR)