Move utils used by Duration and Timestamp from i.o.internal.Utils to TimeUtils.

This change breaks the circular dependency between io.opencensus.internal and
io.opencensus.common.

6 files changed, 98 insertions, 68 deletions

diff --git a/api/src/main/java/io/opencensus/common/Duration.java b/api/src/main/java/io/opencensus/common/Duration.java
index 2d90f506..4b7bb367 100644
--- a/api/src/main/java/io/opencensus/common/Duration.java
+++ b/api/src/main/java/io/opencensus/common/Duration.java
@@ -22,7 +22,6 @@ 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 io.opencensus.internal.Utils;
 import java.util.concurrent.TimeUnit;
 import javax.annotation.concurrent.Immutable;
 
@@ -115,11 +114,11 @@ public abstract class Duration implements Comparable<Duration> {
    */
   @Override
   public int compareTo(Duration otherDuration) {
-    int cmp = Utils.compareLongs(getSeconds(), otherDuration.getSeconds());
+    int cmp = TimeUtils.compareLongs(getSeconds(), otherDuration.getSeconds());
     if (cmp != 0) {
       return cmp;
     }
-    return Utils.compareLongs(getNanos(), otherDuration.getNanos());
+    return TimeUtils.compareLongs(getNanos(), otherDuration.getNanos());
   }
 
   Duration() {}
diff --git a/api/src/main/java/io/opencensus/common/TimeUtils.java b/api/src/main/java/io/opencensus/common/TimeUtils.java
index 2429cc90..db119e2e 100644
--- a/api/src/main/java/io/opencensus/common/TimeUtils.java
+++ b/api/src/main/java/io/opencensus/common/TimeUtils.java
@@ -16,6 +16,8 @@
 
 package io.opencensus.common;
 
+import java.math.BigInteger;
+
 /** Util class for {@link Timestamp} and {@link Duration}. */
 final class TimeUtils {
   static final long MAX_SECONDS = 315576000000L;
@@ -25,4 +27,33 @@ final class TimeUtils {
   static final long NANOS_PER_SECOND = NANOS_PER_MILLI * MILLIS_PER_SECOND;
 
   private TimeUtils() {}
+
+  /**
+   * Compares two longs. This functionality is provided by {@code Long.compare(long, long)} in Java
+   * 7.
+   */
+  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.
+   */
+  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/main/java/io/opencensus/common/Timestamp.java b/api/src/main/java/io/opencensus/common/Timestamp.java
index 86c14cda..e3aae3a6 100644
--- a/api/src/main/java/io/opencensus/common/Timestamp.java
+++ b/api/src/main/java/io/opencensus/common/Timestamp.java
@@ -23,7 +23,6 @@ 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 io.opencensus.internal.Utils;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import javax.annotation.concurrent.Immutable;
@@ -153,11 +152,11 @@ public abstract class Timestamp implements Comparable<Timestamp> {
    */
   @Override
   public int compareTo(Timestamp otherTimestamp) {
-    int cmp = Utils.compareLongs(getSeconds(), otherTimestamp.getSeconds());
+    int cmp = TimeUtils.compareLongs(getSeconds(), otherTimestamp.getSeconds());
     if (cmp != 0) {
       return cmp;
     }
-    return Utils.compareLongs(getNanos(), otherTimestamp.getNanos());
+    return TimeUtils.compareLongs(getNanos(), otherTimestamp.getNanos());
   }
 
   // Returns a Timestamp with the specified duration added.
@@ -165,8 +164,8 @@ public abstract class Timestamp implements Comparable<Timestamp> {
     if ((secondsToAdd | nanosToAdd) == 0) {
       return this;
     }
-    long epochSec = Utils.checkedAdd(getSeconds(), secondsToAdd);
-    epochSec = Utils.checkedAdd(epochSec, nanosToAdd / NANOS_PER_SECOND);
+    long epochSec = TimeUtils.checkedAdd(getSeconds(), secondsToAdd);
+    epochSec = TimeUtils.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,7 +174,7 @@ 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 = Utils.checkedAdd(epochSecond, floorDiv(nanoAdjustment, NANOS_PER_SECOND));
+    long secs = TimeUtils.checkedAdd(epochSecond, floorDiv(nanoAdjustment, NANOS_PER_SECOND));
     int nos = (int) floorMod(nanoAdjustment, NANOS_PER_SECOND);
     return create(secs, nos);
   }
diff --git a/api/src/main/java/io/opencensus/internal/Utils.java b/api/src/main/java/io/opencensus/internal/Utils.java
index 0b27511d..1ac2324e 100644
--- a/api/src/main/java/io/opencensus/internal/Utils.java
+++ b/api/src/main/java/io/opencensus/internal/Utils.java
@@ -16,7 +16,6 @@
 
 package io.opencensus.internal;
 
-import java.math.BigInteger;
 import javax.annotation.Nullable;
 
 /*>>>
@@ -94,33 +93,4 @@ public final class Utils {
   public static boolean equalsObjects(@Nullable Object x, @Nullable Object y) {
     return x == null ? y == null : x.equals(y);
   }
-
-  /**
-   * 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/common/TimeUtilsTest.java b/api/src/test/java/io/opencensus/common/TimeUtilsTest.java
new file mode 100644
index 00000000..d6228566
--- /dev/null
+++ b/api/src/test/java/io/opencensus/common/TimeUtilsTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2018, OpenCensus 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 io.opencensus.common;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link TimeUtils}. */
+@RunWith(JUnit4.class)
+public final class TimeUtilsTest {
+
+  @Rule public ExpectedException thrown = ExpectedException.none();
+
+  @Test
+  public void compareLongs() {
+    assertThat(TimeUtils.compareLongs(-1L, 1L)).isLessThan(0);
+    assertThat(TimeUtils.compareLongs(10L, 10L)).isEqualTo(0);
+    assertThat(TimeUtils.compareLongs(1L, 0L)).isGreaterThan(0);
+  }
+
+  @Test
+  public void checkedAdd_TooLow() {
+    thrown.expect(ArithmeticException.class);
+    thrown.expectMessage("Long sum overflow: x=-9223372036854775807, y=-2");
+    TimeUtils.checkedAdd(Long.MIN_VALUE + 1, -2);
+  }
+
+  @Test
+  public void checkedAdd_TooHigh() {
+    thrown.expect(ArithmeticException.class);
+    thrown.expectMessage("Long sum overflow: x=9223372036854775806, y=2");
+    TimeUtils.checkedAdd(Long.MAX_VALUE - 1, 2);
+  }
+
+  @Test
+  public void checkedAdd_Valid() {
+    assertThat(TimeUtils.checkedAdd(1, 2)).isEqualTo(3);
+    assertThat(TimeUtils.checkedAdd(Integer.MAX_VALUE, Integer.MAX_VALUE))
+        .isEqualTo(2L * Integer.MAX_VALUE);
+  }
+}
diff --git a/api/src/test/java/io/opencensus/internal/UtilsTest.java b/api/src/test/java/io/opencensus/internal/UtilsTest.java
index dea7c843..983264f6 100644
--- a/api/src/test/java/io/opencensus/internal/UtilsTest.java
+++ b/api/src/test/java/io/opencensus/internal/UtilsTest.java
@@ -16,7 +16,6 @@
 
 package io.opencensus.internal;
 
-import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
@@ -103,32 +102,4 @@ public final class UtilsTest {
     assertFalse(Utils.equalsObjects(new Object(), null));
     assertFalse(Utils.equalsObjects(new Object(), new Object()));
   }
-
-  @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);
-  }
 }