From f64a02f2ef38e09d69a45476f050f7e9cd838533 Mon Sep 17 00:00:00 2001 From: Carl Mastrangelo Date: Wed, 30 Mar 2016 17:19:24 -0700 Subject: [PATCH] Remove Flakes caused by assertEquals --- .../test/java/io/grpc/CallOptionsTest.java | 39 ++++------- core/src/test/java/io/grpc/DeadlineTest.java | 68 ++++++++++++++----- 2 files changed, 63 insertions(+), 44 deletions(-) diff --git a/core/src/test/java/io/grpc/CallOptionsTest.java b/core/src/test/java/io/grpc/CallOptionsTest.java index e6bf354f13..2be1057ed6 100644 --- a/core/src/test/java/io/grpc/CallOptionsTest.java +++ b/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); - // 10 milliseconds of leeway - long epsilon = MILLISECONDS.toNanos(10); - assertNotNull(deadline); - assertEquals(expected, deadline.timeRemaining(NANOSECONDS), epsilon); + Deadline expected = Deadline.after(1, MINUTES); + assertDeadlineEquals(deadline, expected, 10, MILLISECONDS); } @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()); - long delta = TimeUnit.MILLISECONDS.toNanos(20); - assertNotNull(allSet.getDeadline()); - assertEquals(remainingNanos, allSet.getDeadline().timeRemaining(NANOSECONDS), delta); + assertDeadlineEquals( + allSet.getDeadline(), extractRemainingTime(allSet.toString()), 20, MILLISECONDS); } @Test - @Deprecated - public void testWithDeadlineNanoTime() { + @SuppressWarnings("deprecation") + 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) { - 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)); + assertDeadlineEquals(opts.getDeadline(), Deadline.after(0, SECONDS), 20, TimeUnit.MILLISECONDS); } private static boolean equal(CallOptions o1, CallOptions o2) { diff --git a/core/src/test/java/io/grpc/DeadlineTest.java b/core/src/test/java/io/grpc/DeadlineTest.java index 92827dffa9..fbc3169a4a 100644 --- a/core/src/test/java/io/grpc/DeadlineTest.java +++ b/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); - assertEquals(d.timeRemaining(TimeUnit.NANOSECONDS), extractRemainingTime(d.toString()), delta); - - d = Deadline.after(10, TimeUnit.SECONDS); - assertEquals(d.timeRemaining(TimeUnit.NANOSECONDS), extractRemainingTime(d.toString()), delta); + assertDeadlineEquals(d, extractRemainingTime(d.toString()), maxDelta, NANOSECONDS); } - private static long extractRemainingTime(String deadlineStr) { - final Pattern p = Pattern.compile("(\\-?[0-9]+) ns from now"); - Matcher m = p.matcher(deadlineStr); - assertTrue(m.matches()); - assertEquals(1, m.groupCount()); + @Test + public void toString_after() { + Deadline d = Deadline.after(-1, TimeUnit.HOURS); - 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); } }