ref(time): Rename Deadline.in to Deadline.after (JAVA-571)

`in` is a Kotlin hard keyword, so every Kotlin call site had to spell it
`Deadline.`in`(...)`. Tests in this repo are Kotlin, and Kotlin callers
are expected in the Android and Kotlin integration modules, so the
backticks would have spread rather than stayed in one test file.

`after` is a plain identifier in both languages and pairs with the
existing `hasPassed()` and `isAfter()` vocabulary.

Author: runningcode

sentry/src/main/java/io/sentry/time/Deadline.java

@@ -24,7 +24,7 @@ private Deadline(final @NotNull Ticker clock, final long deadlineNanos) {
   }
 
   /** A deadline {@code amount} of {@code unit} from now. */
-  public static @NotNull Deadline in(
+  public static @NotNull Deadline after(
       final @NotNull Ticker clock, final long amount, final @NotNull TimeUnit unit) {
     return new Deadline(clock, clock.tickNanos() + unit.toNanos(amount));
   }

sentry/src/test/java/io/sentry/time/DeadlineTest.kt

@@ -13,7 +13,7 @@ class DeadlineTest {
   @Test
   fun `has not passed before the deadline`() {
     val clock = TestTicker()
-    val deadline = Deadline.`in`(clock, 2, MINUTES)
+    val deadline = Deadline.after(clock, 2, MINUTES)
 
     clock.advance(119, SECONDS)
 
@@ -23,7 +23,7 @@ class DeadlineTest {
   @Test
   fun `has passed once the deadline is reached`() {
     val clock = TestTicker()
-    val deadline = Deadline.`in`(clock, 2, MINUTES)
+    val deadline = Deadline.after(clock, 2, MINUTES)
 
     clock.advance(2, MINUTES)
 
@@ -40,7 +40,7 @@ class DeadlineTest {
   @Test
   fun `remaining counts down and floors at zero`() {
     val clock = TestTicker()
-    val deadline = Deadline.`in`(clock, 1000, MILLISECONDS)
+    val deadline = Deadline.after(clock, 1000, MILLISECONDS)
 
     assertEquals(1000, deadline.remaining(MILLISECONDS))
 
@@ -54,7 +54,7 @@ class DeadlineTest {
   @Test
   fun `remaining rounds up so callers never wake before the deadline`() {
     val clock = TestTicker()
-    val deadline = Deadline.`in`(clock, 1000, MILLISECONDS)
+    val deadline = Deadline.after(clock, 1000, MILLISECONDS)
 
     // half a millisecond in: 999.5ms left, which must not report as 999
     clock.advance(500, java.util.concurrent.TimeUnit.MICROSECONDS)
@@ -65,17 +65,17 @@ class DeadlineTest {
   @Test
   fun `isAfter compares two deadlines`() {
     val clock = TestTicker()
-    val shorter = Deadline.`in`(clock, 1, SECONDS)
-    val longer = Deadline.`in`(clock, 5, SECONDS)
+    val shorter = Deadline.after(clock, 1, SECONDS)
+    val longer = Deadline.after(clock, 5, SECONDS)
 
     assertTrue(longer.isAfter(shorter))
     assertFalse(shorter.isAfter(longer))
   }
 
   @Test
   fun `isAfter rejects deadlines from different clocks`() {
-    val deadline = Deadline.`in`(TestTicker(), 1, SECONDS)
-    val fromAnotherClock = Deadline.`in`(TestTicker(), 5, SECONDS)
+    val deadline = Deadline.after(TestTicker(), 1, SECONDS)
+    val fromAnotherClock = Deadline.after(TestTicker(), 5, SECONDS)
 
     assertFailsWith<IllegalArgumentException> { deadline.isAfter(fromAnotherClock) }
   }
@@ -84,7 +84,7 @@ class DeadlineTest {
   fun `comparisons hold when the tick origin is negative`() {
     // System.nanoTime() may start negative; only differences are meaningful.
     val clock = TestTicker(Long.MIN_VALUE + 1)
-    val deadline = Deadline.`in`(clock, 1, SECONDS)
+    val deadline = Deadline.after(clock, 1, SECONDS)
 
     assertFalse(deadline.hasPassed())
     clock.advance(1, SECONDS)