Fix after rebasing

Author: dkhalanskyjb

core/commonKotlin/src/Instant.kt

@@ -182,7 +182,7 @@ private class UnboundedLocalDateTime(
         val epochSeconds = run {
             // org.threeten.bp.LocalDate#toEpochDay
             val epochDays = run {
-                val y = year
+                val y = year.toLong()
                 var total = 365 * y
                 if (y >= 0) {
                     total += (y + 3) / 4 - (y + 99) / 100 + (y + 399) / 400
@@ -211,10 +211,12 @@ private class UnboundedLocalDateTime(
         return Instant.fromEpochSeconds(epochSeconds, nanosecond)
     }
 
+    override fun toString(): String = "UnboundedLocalDateTime($year-$month-$day $hour:$minute:$second.$nanosecond)"
+
     companion object {
         fun fromInstant(instant: Instant, offsetSeconds: Int): UnboundedLocalDateTime {
             val localSecond: Long = instant.epochSeconds + offsetSeconds
-            val epochDays = localSecond.floorDiv(SECONDS_PER_DAY.toLong()).toInt()
+            val epochDays = localSecond.floorDiv(SECONDS_PER_DAY.toLong())
             val secsOfDay = localSecond.mod(SECONDS_PER_DAY.toLong()).toInt()
             val year: Int
             val month: Int
@@ -225,27 +227,27 @@ private class UnboundedLocalDateTime(
                 // find the march-based year
                 zeroDay -= 60 // adjust to 0000-03-01 so leap day is at end of four year cycle
 
-                var adjust = 0
+                var adjust = 0L
                 if (zeroDay < 0) { // adjust negative years to positive for calculation
                     val adjustCycles = (zeroDay + 1) / DAYS_PER_CYCLE - 1
                     adjust = adjustCycles * 400
                     zeroDay += -adjustCycles * DAYS_PER_CYCLE
                 }
-                var yearEst = ((400 * zeroDay.toLong() + 591) / DAYS_PER_CYCLE).toInt()
+                var yearEst = ((400 * zeroDay.toLong() + 591) / DAYS_PER_CYCLE)
                 var doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400)
                 if (doyEst < 0) { // fix estimate
                     yearEst--
                     doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400)
                 }
                 yearEst += adjust // reset any negative year
 
-                val marchDoy0 = doyEst
+                val marchDoy0 = doyEst.toInt()
 
                 // convert march-based values back to january-based
                 val marchMonth0 = (marchDoy0 * 5 + 2) / 153
                 month = (marchMonth0 + 2) % 12 + 1
                 day = marchDoy0 - (marchMonth0 * 306 + 5) / 10 + 1
-                year = yearEst + marchMonth0 / 10
+                year = (yearEst + marchMonth0 / 10).toInt()
             }
             val hours = (secsOfDay / SECONDS_PER_HOUR)
             val secondWithoutHours = secsOfDay - hours * SECONDS_PER_HOUR

core/commonKotlin/test/InstantIsoStringsTest.kt

@@ -14,7 +14,7 @@ class InstantIsoStringsTest {
     @Test
     fun parseDates() {
         fun Int.zeroPadded(digits: Int): String = when {
-            this >= 0 -> "${toString().padStart(digits, '0')}"
+            this >= 0 -> toString().padStart(digits, '0')
             else -> "-${absoluteValue.toString().padStart(digits, '0')}"
         }
         fun localDateToString(year: Int, month: Int, day: Int) =
@@ -50,8 +50,8 @@ class InstantIsoStringsTest {
 
     @Test
     fun parseIsoString() {
-        for ((str, seconds, nanos) in arrayOf(
-            // all components are taken into accout
+        for ((str, seconds, nanos) in arrayOf<Triple<String, Long, Int>>(
+            // all components are taken into account
             Triple("1970-01-01T00:00:00Z", 0, 0),
             Triple("1970-01-01T00:00:00.000000001Z", 0, 1),
             Triple("1970-01-01T00:00:00.100Z", 0, 100000000),
@@ -173,13 +173,34 @@ class InstantIsoStringsTest {
             Triple("+83082-01-04T20:18:56.409867424Z", 2559647852336, 409867424),
             Triple("-916839-09-12T22:45:39.091941363Z", -28994789466861, 91941363),
             Triple("-147771-05-07T08:31:34.950238979Z", -4725358615706, 950238979),
+            // random enormous values queried from java.time
+            Triple("+639727757-10-17T17:26:30.359003681Z", 20187795978609990, 359003681),
+            Triple("-375448814-11-11T03:04:48.637504595Z", -11848082341899312, 637504595),
+            Triple("+99162559-10-16T11:21:05.057717803Z", 3129205972303265, 57717803),
+            Triple("-826813174-05-22T21:35:39.018693830Z", -26091765799784661, 18693830),
+            Triple("+254125623-04-28T11:42:22.659957596Z", 8019367929949342, 659957596),
+            Triple("+540978343-01-03T20:31:36.945404442Z", 17071565436102696, 945404442),
+            Triple("+988277529-06-06T13:25:41.942771350Z", 31186964391657941, 942771350),
+            Triple("+566487909-09-04T08:09:46.007490076Z", 17876569606963786, 7490076),
+            Triple("+442225124-02-16T18:23:29.975096773Z", 13955214848034209, 975096773),
+            Triple("-399250586-02-19T22:58:29.585918917Z", -12599193741267691, 585918917),
+            Triple("-190217791-04-28T00:49:29.270751921Z", -6002755857213031, 270751921),
+            Triple("-716173704-05-24T22:05:33.639928802Z", -22600321355469267, 639928802),
+            Triple("+910504788-10-26T05:23:43.517192887Z", 28732693749312223, 517192887),
+            Triple("+515896807-08-17T06:36:25.012343642Z", 16280068627982185, 12343642),
+            Triple("-623794742-03-20T17:09:07.396143995Z", -19685122891483853, 396143995),
+            Triple("-416781718-10-06T01:41:32.866307162Z", -13152422812544308, 866307162),
+            Triple("+287346593-09-30T23:30:55.109337183Z", 9067720499134255, 109337183),
+            Triple("-819839065-09-06T07:25:58.953784983Z", -25871684167672442, 953784983),
+            Triple("+673467211-06-05T02:15:40.712392732Z", 21252510297310540, 712392732),
+            Triple("+982441727-04-13T12:12:06.776817565Z", 31002804263391126, 776817565),
         )) {
             val instant = parseInstant(str)
             assertEquals(
-                seconds.toLong() * 1000 + nanos / 1000000, instant.toEpochMilliseconds(),
+                Instant.fromEpochSeconds(seconds, nanos), instant,
                 "Parsed $instant from $str, with Unix time = `$seconds + 10^-9 * $nanos`"
             )
-            assertEquals(str, formatIso(instant))
+            assertEquals(str, displayInstant(instant))
         }
         // non-canonical strings are parsed as well, but formatted differently
         for ((str, seconds, nanos) in arrayOf(
@@ -338,7 +359,7 @@ class InstantIsoStringsTest {
         strings.forEach { (str, strInZ) ->
             val instant = parseInstant(str)
             assertEquals(parseInstant(strInZ), instant, str)
-            assertEquals(strInZ, formatIso(instant), str)
+            assertEquals(strInZ, displayInstant(instant), str)
         }
         assertInvalidFormat { parseInstant("2020-01-01T00:01:01+18:01") }
         assertInvalidFormat { parseInstant("2020-01-01T00:01:01+1801") }
@@ -378,10 +399,12 @@ class InstantIsoStringsTest {
     }
 
     private fun parseInstant(isoString: String): Instant {
+        // return Instant.parse(isoString)
         return parseIso(isoString)
     }
 
     private fun displayInstant(instant: Instant): String {
+        // return instant.toString()
         return formatIso(instant)
     }
 }
@@ -394,4 +417,4 @@ private fun <T> assertInvalidFormat(message: String? = null, f: () -> T) {
         val result = f()
         fail(result.toString())
     }
-}
+}