Remove Flakes caused by assertEquals

core/src/test/java/io/grpc/CallOptionsTest.java

@@ -31,6 +31,8 @@
 
 package io.grpc;
 
+import static io.grpc.DeadlineTest.assertDeadlineEquals;
+import static io.grpc.DeadlineTest.extractRemainingTime;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.MINUTES;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
@@ -45,16 +47,14 @@ import com.google.common.base.Objects;
 import com.google.common.util.concurrent.MoreExecutors;
 
 import io.grpc.Attributes.Key;
-
 import io.grpc.internal.SerializingExecutor;
+
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 /** Unit tests for {@link CallOptions}. */
 @RunWith(JUnit4.class)
@@ -117,17 +117,14 @@ public class CallOptionsTest {
   }
 
   @Test
-  public void testWithDeadlineAfter() {
+  public void withDeadlineAfter() {
     Deadline deadline = CallOptions.DEFAULT.withDeadlineAfter(1, MINUTES).getDeadline();
-    long expected = MINUTES.toNanos(1);
+    Deadline expected = Deadline.after(1, MINUTES);
-    // 10 milliseconds of leeway
+    assertDeadlineEquals(deadline, expected, 10, MILLISECONDS);
-    long epsilon = MILLISECONDS.toNanos(10);
-    assertNotNull(deadline);
-    assertEquals(expected, deadline.timeRemaining(NANOSECONDS), epsilon);
   }
 
   @Test
-  public void testToString() {
+  public void toStringMatches() {
     assertEquals("CallOptions{deadline=null, authority=null, "
         + "affinity={}, executor=null, compressorName=null}", CallOptions.DEFAULT.toString());
 
@@ -138,31 +135,19 @@ public class CallOptionsTest {
         allSet.withDeadline(null)
             .withExecutor(new SerializingExecutor(MoreExecutors.directExecutor())).toString());
 
-    long remainingNanos = extractRemainingTime(allSet.toString());
+    assertDeadlineEquals(
-    long delta = TimeUnit.MILLISECONDS.toNanos(20);
+        allSet.getDeadline(), extractRemainingTime(allSet.toString()), 20, MILLISECONDS);
-    assertNotNull(allSet.getDeadline());
-    assertEquals(remainingNanos, allSet.getDeadline().timeRemaining(NANOSECONDS), delta);
   }
 
   @Test
-  @Deprecated
+  @SuppressWarnings("deprecation")
-  public void testWithDeadlineNanoTime() {
+  public void withDeadlineNanoTime() {
     CallOptions opts = CallOptions.DEFAULT.withDeadlineNanoTime(System.nanoTime());
     assertNotNull(opts.getDeadlineNanoTime());
     assertTrue(opts.getDeadlineNanoTime() <= System.nanoTime());
-    assertNotNull(opts.getDeadline());
-    long delta = MILLISECONDS.toNanos(10);
-    assertEquals(0, opts.getDeadline().timeRemaining(NANOSECONDS), delta);
     assertTrue(opts.getDeadline().isExpired());
-  }
 
-  private static long extractRemainingTime(String deadlineStr) {
+    assertDeadlineEquals(opts.getDeadline(), Deadline.after(0, SECONDS), 20, TimeUnit.MILLISECONDS);
-    final Pattern p = Pattern.compile(".+deadline=(\\-?[0-9]+) ns from now,.+");
-    Matcher m = p.matcher(deadlineStr);
-    assertTrue(m.matches());
-    assertEquals(1, m.groupCount());
-
-    return Long.valueOf(m.group(1));
   }
 
   private static boolean equal(CallOptions o1, CallOptions o2) {

core/src/test/java/io/grpc/DeadlineTest.java

@@ -31,6 +31,8 @@
 
 package io.grpc;
 
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertSame;
@@ -41,6 +43,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
+import java.math.BigInteger;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
@@ -54,13 +57,12 @@ import java.util.regex.Pattern;
 public class DeadlineTest {
 
   // Allowed inaccuracy when comparing the remaining time of a deadline.
-  private final long delta = TimeUnit.MILLISECONDS.toNanos(20);
+  private final long maxDelta = TimeUnit.MILLISECONDS.toNanos(20);
 
   @Test
   public void immediateDeadlineIsExpired() {
     Deadline deadline = Deadline.after(0, TimeUnit.SECONDS);
     assertTrue(deadline.isExpired());
-    assertEquals(0, deadline.timeRemaining(TimeUnit.NANOSECONDS), delta);
   }
 
   @Test
@@ -69,15 +71,25 @@ public class DeadlineTest {
     assertTrue(deadline.timeRemaining(TimeUnit.NANOSECONDS) > 0);
     assertFalse(deadline.isExpired());
     Thread.sleep(101);
+
     assertTrue(deadline.isExpired());
-    assertEquals(0, deadline.timeRemaining(TimeUnit.NANOSECONDS), delta);
+    assertFalse(deadline.timeRemaining(TimeUnit.NANOSECONDS) > 0);
+    assertDeadlineEquals(deadline, Deadline.after(0, SECONDS), maxDelta, NANOSECONDS);
+  }
+
+  @Test
+  public void deadlineMatchesLongValue() {
+    long minutes = Deadline.after(10, TimeUnit.MINUTES).timeRemaining(TimeUnit.MINUTES);
+
+    assertTrue(minutes + " != " + 10, Math.abs(minutes - 10) <= 1);
   }
 
   @Test
   public void pastDeadlineIsExpired() {
     Deadline deadline = Deadline.after(-1, TimeUnit.SECONDS);
     assertTrue(deadline.isExpired());
-    assertEquals(TimeUnit.SECONDS.toNanos(-1), deadline.timeRemaining(TimeUnit.NANOSECONDS), delta);
+
+    assertDeadlineEquals(deadline, Deadline.after(-1, SECONDS), maxDelta, NANOSECONDS);
   }
 
   @Test
@@ -144,23 +156,45 @@ public class DeadlineTest {
   }
 
   @Test
-  public void testToString() {
+  public void toString_exact() {
     Deadline d = Deadline.after(0, TimeUnit.MILLISECONDS);
-    assertEquals(0, extractRemainingTime(d.toString()), delta);
 
-    d = Deadline.after(-1, TimeUnit.HOURS);
+    assertDeadlineEquals(d, extractRemainingTime(d.toString()), maxDelta, NANOSECONDS);
-    assertEquals(d.timeRemaining(TimeUnit.NANOSECONDS), extractRemainingTime(d.toString()), delta);
-
-    d = Deadline.after(10, TimeUnit.SECONDS);
-    assertEquals(d.timeRemaining(TimeUnit.NANOSECONDS), extractRemainingTime(d.toString()), delta);
   }
 
-  private static long extractRemainingTime(String deadlineStr) {
+  @Test
-    final Pattern p = Pattern.compile("(\\-?[0-9]+) ns from now");
+  public void toString_after() {
-    Matcher m = p.matcher(deadlineStr);
+    Deadline d = Deadline.after(-1, TimeUnit.HOURS);
-    assertTrue(m.matches());
-    assertEquals(1, m.groupCount());
 
-    return Long.valueOf(m.group(1));
+    assertDeadlineEquals(d, extractRemainingTime(d.toString()), maxDelta, NANOSECONDS);
+  }
+
+  @Test
+  public void toString_before() {
+    Deadline d = Deadline.after(10, TimeUnit.SECONDS);
+
+    assertDeadlineEquals(d, extractRemainingTime(d.toString()), maxDelta, NANOSECONDS);
+  }
+
+  /**
+   * Asserts two deadlines are roughly equal.
+   */
+  public static void assertDeadlineEquals(
+      Deadline expected, Deadline actual, long delta, TimeUnit timeUnit) {
+    // This is probably overkill, but easier than thinking about overflow.
+    BigInteger actualTimeRemaining = BigInteger.valueOf(actual.timeRemaining(NANOSECONDS));
+    BigInteger expectedTimeRemaining = BigInteger.valueOf(expected.timeRemaining(NANOSECONDS));
+    BigInteger deltaNanos = BigInteger.valueOf(timeUnit.toNanos(delta));
+    if (actualTimeRemaining.subtract(expectedTimeRemaining).abs().compareTo(deltaNanos) > 0) {
+      throw new AssertionError(String.format("%s != %s", expected, actual));
+    }
+  }
+
+  static Deadline extractRemainingTime(String deadlineStr) {
+    final Pattern p = Pattern.compile(".*?(-?\\d+) ns from now.*");
+    Matcher m = p.matcher(deadlineStr);
+    assertTrue(deadlineStr, m.matches());
+    assertEquals(deadlineStr, 1, m.groupCount());
+    return Deadline.after(Long.valueOf(m.group(1)), NANOSECONDS);
   }
 }