Use toNanosSaturated in Queues.

While there, rename a parameter in a test helper method to match the production parameter name.

I admit that my new test is not necessarily the best of all possible tests: It detects the problem currently, but it wouldn't detect the problem if we were to change the prod code to decompose the `Duration` only [when it actually needs to block](https://github.com/google/guava/blob/e416f493d7f6790cae859aab1ddacb456469f614/guava/src/com/google/common/collect/Queues.java#L336). I kind of doubt we'd ever bother, though.

RELNOTES=n/a
PiperOrigin-RevId: 828005669

Author: cpovirk

android/guava-tests/test/com/google/common/collect/QueuesTest.java

@@ -26,6 +26,7 @@
 import static org.junit.Assert.assertThrows;
 
 import com.google.common.base.Stopwatch;
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -86,14 +87,14 @@ public void tearDown() throws InterruptedException {
   private static <T> int drain(
       BlockingQueue<T> q,
       Collection<? super T> buffer,
-      int maxElements,
+      int numElements,
       long timeout,
       TimeUnit unit,
       boolean interruptibly)
       throws InterruptedException {
     return interruptibly
-        ? Queues.drain(q, buffer, maxElements, timeout, unit)
-        : Queues.drainUninterruptibly(q, buffer, maxElements, timeout, unit);
+        ? Queues.drain(q, buffer, numElements, timeout, unit)
+        : Queues.drainUninterruptibly(q, buffer, numElements, timeout, unit);
   }
 
   public void testMultipleProducers() throws Exception {
@@ -155,6 +156,15 @@ private void checkDrainTimesOut(BlockingQueue<Object> q) throws Exception {
     }
   }
 
+  public void testDrainOverflow() throws InterruptedException {
+    Queues.drain(new SynchronousQueue<>(), new ArrayList<>(), /* numElements= */ 0, MAX_DURATION);
+  }
+
+  public void testDrainUninterruptiblyOverflow() {
+    Queues.drainUninterruptibly(
+        new SynchronousQueue<>(), new ArrayList<>(), /* numElements= */ 0, MAX_DURATION);
+  }
+
   public void testZeroElements() throws Exception {
     for (BlockingQueue<Object> q : blockingQueues()) {
       checkZeroElements(q);
@@ -341,4 +351,6 @@ public void run() {
       }
     }
   }
+
+  private static final Duration MAX_DURATION = Duration.ofSeconds(Long.MAX_VALUE, 999_999_999);
 }

android/guava/src/com/google/common/collect/Internal.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2019 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.common.collect;
+
+import com.google.common.annotations.GwtIncompatible;
+import com.google.common.annotations.J2ktIncompatible;
+import java.time.Duration;
+
+/** This class is for {@code com.google.common.collect} use only! */
+@J2ktIncompatible
+@GwtIncompatible // java.time.Duration
+@IgnoreJRERequirement // We use this method only from within APIs that require a Duration.
+final class Internal {
+
+  /**
+   * Returns the number of nanoseconds of the given duration without throwing or overflowing.
+   *
+   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
+   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
+   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
+   */
+  static long toNanosSaturated(Duration duration) {
+    // Using a try/catch seems lazy, but the catch block will rarely get invoked (except for
+    // durations longer than approximately +/- 292 years).
+    try {
+      return duration.toNanos();
+    } catch (ArithmeticException tooBig) {
+      return duration.isNegative() ? Long.MIN_VALUE : Long.MAX_VALUE;
+    }
+  }
+
+  private Internal() {}
+}

android/guava/src/com/google/common/collect/Queues.java

@@ -14,6 +14,7 @@
 
 package com.google.common.collect;
 
+import static com.google.common.collect.Internal.toNanosSaturated;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
 
 import com.google.common.annotations.GwtCompatible;
@@ -295,8 +296,7 @@ public static <E> SynchronousQueue<E> newSynchronousQueue() {
   public static <E> int drain(
       BlockingQueue<E> q, Collection<? super E> buffer, int numElements, Duration timeout)
       throws InterruptedException {
-    // TODO(b/126049426): Consider using saturateToNanos(timeout) instead.
-    return drain(q, buffer, numElements, timeout.toNanos(), NANOSECONDS);
+    return drain(q, buffer, numElements, toNanosSaturated(timeout), NANOSECONDS);
   }
 
   /**
@@ -365,8 +365,7 @@ public static <E> int drain(
   @IgnoreJRERequirement // Users will use this only if they're already using Duration
   public static <E> int drainUninterruptibly(
       BlockingQueue<E> q, Collection<? super E> buffer, int numElements, Duration timeout) {
-    // TODO(b/126049426): Consider using saturateToNanos(timeout) instead.
-    return drainUninterruptibly(q, buffer, numElements, timeout.toNanos(), NANOSECONDS);
+    return drainUninterruptibly(q, buffer, numElements, toNanosSaturated(timeout), NANOSECONDS);
   }
 
   /**

guava-tests/test/com/google/common/collect/QueuesTest.java

@@ -26,6 +26,7 @@
 import static org.junit.Assert.assertThrows;
 
 import com.google.common.base.Stopwatch;
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -86,14 +87,14 @@ public void tearDown() throws InterruptedException {
   private static <T> int drain(
       BlockingQueue<T> q,
       Collection<? super T> buffer,
-      int maxElements,
+      int numElements,
       long timeout,
       TimeUnit unit,
       boolean interruptibly)
       throws InterruptedException {
     return interruptibly
-        ? Queues.drain(q, buffer, maxElements, timeout, unit)
-        : Queues.drainUninterruptibly(q, buffer, maxElements, timeout, unit);
+        ? Queues.drain(q, buffer, numElements, timeout, unit)
+        : Queues.drainUninterruptibly(q, buffer, numElements, timeout, unit);
   }
 
   public void testMultipleProducers() throws Exception {
@@ -155,6 +156,15 @@ private void checkDrainTimesOut(BlockingQueue<Object> q) throws Exception {
     }
   }
 
+  public void testDrainOverflow() throws InterruptedException {
+    Queues.drain(new SynchronousQueue<>(), new ArrayList<>(), /* numElements= */ 0, MAX_DURATION);
+  }
+
+  public void testDrainUninterruptiblyOverflow() {
+    Queues.drainUninterruptibly(
+        new SynchronousQueue<>(), new ArrayList<>(), /* numElements= */ 0, MAX_DURATION);
+  }
+
   public void testZeroElements() throws Exception {
     for (BlockingQueue<Object> q : blockingQueues()) {
       checkZeroElements(q);
@@ -341,4 +351,6 @@ public void run() {
       }
     }
   }
+
+  private static final Duration MAX_DURATION = Duration.ofSeconds(Long.MAX_VALUE, 999_999_999);
 }

guava/src/com/google/common/collect/Internal.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2019 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.common.collect;
+
+import com.google.common.annotations.GwtIncompatible;
+import com.google.common.annotations.J2ktIncompatible;
+import java.time.Duration;
+
+/** This class is for {@code com.google.common.collect} use only! */
+@J2ktIncompatible
+@GwtIncompatible // java.time.Duration
+final class Internal {
+
+  /**
+   * Returns the number of nanoseconds of the given duration without throwing or overflowing.
+   *
+   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
+   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
+   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
+   */
+  static long toNanosSaturated(Duration duration) {
+    // Using a try/catch seems lazy, but the catch block will rarely get invoked (except for
+    // durations longer than approximately +/- 292 years).
+    try {
+      return duration.toNanos();
+    } catch (ArithmeticException tooBig) {
+      return duration.isNegative() ? Long.MIN_VALUE : Long.MAX_VALUE;
+    }
+  }
+
+  private Internal() {}
+}

guava/src/com/google/common/collect/Queues.java

@@ -14,6 +14,7 @@
 
 package com.google.common.collect;
 
+import static com.google.common.collect.Internal.toNanosSaturated;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
 
 import com.google.common.annotations.GwtCompatible;
@@ -294,8 +295,7 @@ public static <E> SynchronousQueue<E> newSynchronousQueue() {
   public static <E> int drain(
       BlockingQueue<E> q, Collection<? super E> buffer, int numElements, Duration timeout)
       throws InterruptedException {
-    // TODO(b/126049426): Consider using saturateToNanos(timeout) instead.
-    return drain(q, buffer, numElements, timeout.toNanos(), NANOSECONDS);
+    return drain(q, buffer, numElements, toNanosSaturated(timeout), NANOSECONDS);
   }
 
   /**
@@ -363,8 +363,7 @@ public static <E> int drain(
   @GwtIncompatible // BlockingQueue
   public static <E> int drainUninterruptibly(
       BlockingQueue<E> q, Collection<? super E> buffer, int numElements, Duration timeout) {
-    // TODO(b/126049426): Consider using saturateToNanos(timeout) instead.
-    return drainUninterruptibly(q, buffer, numElements, timeout.toNanos(), NANOSECONDS);
+    return drainUninterruptibly(q, buffer, numElements, toNanosSaturated(timeout), NANOSECONDS);
   }
 
   /**