Remove usages of Guava LongMath from opencensus-api (issue #1081).

4 files changed, 72 insertions, 11 deletions

diff --git a/api/src/main/java/io/opencensus/common/Duration.java b/api/src/main/java/io/opencensus/common/Duration.java
index c20bbda7..1ee97191 100644
--- a/api/src/main/java/io/opencensus/common/Duration.java
+++ b/api/src/main/java/io/opencensus/common/Duration.java
@@ -22,7 +22,7 @@ import static io.opencensus.common.TimeUtils.MILLIS_PER_SECOND;
 import static io.opencensus.common.TimeUtils.NANOS_PER_MILLI;
 
 import com.google.auto.value.AutoValue;
-import com.google.common.primitives.Longs;
+import io.opencensus.internal.Utils;
 import javax.annotation.concurrent.Immutable;
 
 /**
@@ -104,11 +104,11 @@ public abstract class Duration implements Comparable<Duration> {
    */
   @Override
   public int compareTo(Duration otherDuration) {
-    int cmp = Longs.compare(getSeconds(), otherDuration.getSeconds());
+    int cmp = Utils.compareLongs(getSeconds(), otherDuration.getSeconds());
     if (cmp != 0) {
       return cmp;
     }
-    return Longs.compare(getNanos(), otherDuration.getNanos());
+    return Utils.compareLongs(getNanos(), otherDuration.getNanos());
   }
 
   Duration() {}
diff --git a/api/src/main/java/io/opencensus/common/Timestamp.java b/api/src/main/java/io/opencensus/common/Timestamp.java
index 970a0031..86c14cda 100644
--- a/api/src/main/java/io/opencensus/common/Timestamp.java
+++ b/api/src/main/java/io/opencensus/common/Timestamp.java
@@ -23,8 +23,8 @@ import static io.opencensus.common.TimeUtils.NANOS_PER_MILLI;
 import static io.opencensus.common.TimeUtils.NANOS_PER_SECOND;
 
 import com.google.auto.value.AutoValue;
-import com.google.common.math.LongMath;
-import com.google.common.primitives.Longs;
+import io.opencensus.internal.Utils;
+import java.math.BigDecimal;
 import java.math.RoundingMode;
 import javax.annotation.concurrent.Immutable;
 
@@ -153,11 +153,11 @@ public abstract class Timestamp implements Comparable<Timestamp> {
    */
   @Override
   public int compareTo(Timestamp otherTimestamp) {
-    int cmp = Longs.compare(getSeconds(), otherTimestamp.getSeconds());
+    int cmp = Utils.compareLongs(getSeconds(), otherTimestamp.getSeconds());
     if (cmp != 0) {
       return cmp;
     }
-    return Longs.compare(getNanos(), otherTimestamp.getNanos());
+    return Utils.compareLongs(getNanos(), otherTimestamp.getNanos());
   }
 
   // Returns a Timestamp with the specified duration added.
@@ -165,8 +165,8 @@ public abstract class Timestamp implements Comparable<Timestamp> {
     if ((secondsToAdd | nanosToAdd) == 0) {
       return this;
     }
-    long epochSec = LongMath.checkedAdd(getSeconds(), secondsToAdd);
-    epochSec = LongMath.checkedAdd(epochSec, nanosToAdd / NANOS_PER_SECOND);
+    long epochSec = Utils.checkedAdd(getSeconds(), secondsToAdd);
+    epochSec = Utils.checkedAdd(epochSec, nanosToAdd / NANOS_PER_SECOND);
     nanosToAdd = nanosToAdd % NANOS_PER_SECOND;
     long nanoAdjustment = getNanos() + nanosToAdd; // safe int + NANOS_PER_SECOND
     return ofEpochSecond(epochSec, nanoAdjustment);
@@ -175,14 +175,14 @@ public abstract class Timestamp implements Comparable<Timestamp> {
   // Returns a Timestamp calculated using seconds from the epoch and nanosecond fraction of
   // second (arbitrary number of nanoseconds).
   private static Timestamp ofEpochSecond(long epochSecond, long nanoAdjustment) {
-    long secs = LongMath.checkedAdd(epochSecond, floorDiv(nanoAdjustment, NANOS_PER_SECOND));
+    long secs = Utils.checkedAdd(epochSecond, floorDiv(nanoAdjustment, NANOS_PER_SECOND));
     int nos = (int) floorMod(nanoAdjustment, NANOS_PER_SECOND);
     return create(secs, nos);
   }
 
   // Returns the result of dividing x by y rounded using floor.
   private static long floorDiv(long x, long y) {
-    return LongMath.divide(x, y, RoundingMode.FLOOR);
+    return BigDecimal.valueOf(x).divide(BigDecimal.valueOf(y), 0, RoundingMode.FLOOR).longValue();
   }
 
   // Returns the floor modulus "x - (floorDiv(x, y) * y)"
diff --git a/api/src/main/java/io/opencensus/internal/Utils.java b/api/src/main/java/io/opencensus/internal/Utils.java
index 85bf3785..044529fa 100644
--- a/api/src/main/java/io/opencensus/internal/Utils.java
+++ b/api/src/main/java/io/opencensus/internal/Utils.java
@@ -16,6 +16,8 @@
 
 package io.opencensus.internal;
 
+import java.math.BigInteger;
+
 /*>>>
 import org.checkerframework.checker.nullness.qual.NonNull;
 */
@@ -83,4 +85,33 @@ public final class Utils {
     }
     return arg;
   }
+
+  /**
+   * Compares two longs. This functionality is provided by {@code Long.compare(long, long)} in Java
+   * 7.
+   */
+  public static int compareLongs(long x, long y) {
+    if (x < y) {
+      return -1;
+    } else if (x == y) {
+      return 0;
+    } else {
+      return 1;
+    }
+  }
+
+  private static final BigInteger MAX_LONG_VALUE = BigInteger.valueOf(Long.MAX_VALUE);
+  private static final BigInteger MIN_LONG_VALUE = BigInteger.valueOf(Long.MIN_VALUE);
+
+  /**
+   * Adds two longs and throws an {@link ArithmeticException} if the result overflows. This
+   * functionality is provided by {@code Math.addExact(long, long)} in Java 8.
+   */
+  public static long checkedAdd(long x, long y) {
+    BigInteger sum = BigInteger.valueOf(x).add(BigInteger.valueOf(y));
+    if (sum.compareTo(MAX_LONG_VALUE) > 0 || sum.compareTo(MIN_LONG_VALUE) < 0) {
+      throw new ArithmeticException("Long sum overflow: x=" + x + ", y=" + y);
+    }
+    return x + y;
+  }
 }
diff --git a/api/src/test/java/io/opencensus/internal/UtilsTest.java b/api/src/test/java/io/opencensus/internal/UtilsTest.java
index 2416eeb8..3313c1fd 100644
--- a/api/src/test/java/io/opencensus/internal/UtilsTest.java
+++ b/api/src/test/java/io/opencensus/internal/UtilsTest.java
@@ -16,6 +16,8 @@
 
 package io.opencensus.internal;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -85,4 +87,32 @@ public final class UtilsTest {
     thrown.expectMessage("Index out of bounds: size=10, index=11");
     Utils.checkIndex(11, 10);
   }
+
+  @Test
+  public void compareLongs() {
+    assertThat(Utils.compareLongs(-1L, 1L)).isLessThan(0);
+    assertThat(Utils.compareLongs(10L, 10L)).isEqualTo(0);
+    assertThat(Utils.compareLongs(1L, 0L)).isGreaterThan(0);
+  }
+
+  @Test
+  public void checkedAdd_TooLow() {
+    thrown.expect(ArithmeticException.class);
+    thrown.expectMessage("Long sum overflow: x=-9223372036854775807, y=-2");
+    Utils.checkedAdd(Long.MIN_VALUE + 1, -2);
+  }
+
+  @Test
+  public void checkedAdd_TooHigh() {
+    thrown.expect(ArithmeticException.class);
+    thrown.expectMessage("Long sum overflow: x=9223372036854775806, y=2");
+    Utils.checkedAdd(Long.MAX_VALUE - 1, 2);
+  }
+
+  @Test
+  public void checkedAdd_Valid() {
+    assertThat(Utils.checkedAdd(1, 2)).isEqualTo(3);
+    assertThat(Utils.checkedAdd(Integer.MAX_VALUE, Integer.MAX_VALUE))
+        .isEqualTo(2L * Integer.MAX_VALUE);
+  }
 }