Removing deprecated TimeUtil class. (#8749)

pull/8750/head
Derek Perez 4 years ago committed by GitHub
parent 2af13f077a
commit 9d9d8ee18d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 401
      java/util/src/main/java/com/google/protobuf/util/TimeUtil.java
  2. 498
      java/util/src/test/java/com/google/protobuf/util/TimeUtilTest.java

@ -1,401 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package com.google.protobuf.util;
import com.google.protobuf.Duration;
import com.google.protobuf.Timestamp;
import java.math.BigInteger;
import java.text.ParseException;
/**
* Utilities to help create/manipulate Timestamp/Duration
*
* @deprecated Use {@link Durations} and {@link Timestamps} instead.
*/
@Deprecated
public final class TimeUtil {
// Timestamp for "0001-01-01T00:00:00Z"
public static final long TIMESTAMP_SECONDS_MIN = -62135596800L;
// Timestamp for "9999-12-31T23:59:59Z"
public static final long TIMESTAMP_SECONDS_MAX = 253402300799L;
public static final long DURATION_SECONDS_MIN = -315576000000L;
public static final long DURATION_SECONDS_MAX = 315576000000L;
private static final long NANOS_PER_SECOND = 1000000000;
private TimeUtil() {}
/**
* Convert Timestamp to RFC 3339 date string format. The output will always
* be Z-normalized and uses 3, 6 or 9 fractional digits as required to
* represent the exact value. Note that Timestamp can only represent time
* from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. See
* https://www.ietf.org/rfc/rfc3339.txt
*
* <p>Example of generated format: "1972-01-01T10:00:20.021Z"
*
* @return The string representation of the given timestamp.
* @throws IllegalArgumentException if the given timestamp is not in the
* valid range.
* @deprecated Use {@link Timestamps#toString} instead.
*/
@Deprecated
public static String toString(Timestamp timestamp) {
return Timestamps.toString(timestamp);
}
/**
* Parse from RFC 3339 date string to Timestamp. This method accepts all
* outputs of {@link #toString(Timestamp)} and it also accepts any fractional
* digits (or none) and any offset as long as they fit into nano-seconds
* precision.
*
* <p>Example of accepted format: "1972-01-01T10:00:20.021-05:00"
*
* @return A Timestamp parsed from the string.
* @throws ParseException if parsing fails.
* @deprecated Use {@link Timestamps#parse} instead.
*/
@Deprecated
public static Timestamp parseTimestamp(String value) throws ParseException {
return Timestamps.parse(value);
}
/**
* Convert Duration to string format. The string format will contains 3, 6,
* or 9 fractional digits depending on the precision required to represent
* the exact Duration value. For example: "1s", "1.010s", "1.000000100s",
* "-3.100s" The range that can be represented by Duration is from
* -315,576,000,000 to +315,576,000,000 inclusive (in seconds).
*
* @return The string representation of the given duration.
* @throws IllegalArgumentException if the given duration is not in the valid
* range.
* @deprecated Use {@link Durations#toString} instead.
*/
@Deprecated
public static String toString(Duration duration) {
return Durations.toString(duration);
}
/**
* Parse from a string to produce a duration.
*
* @return A Duration parsed from the string.
* @throws ParseException if parsing fails.
* @deprecated Use {@link Durations#parse} instead.
*/
@Deprecated
public static Duration parseDuration(String value) throws ParseException {
return Durations.parse(value);
}
/**
* Create a Timestamp from the number of milliseconds elapsed from the epoch.
*
* @deprecated Use {@link Timestamps#fromMillis} instead.
*/
@Deprecated
public static Timestamp createTimestampFromMillis(long milliseconds) {
return Timestamps.fromMillis(milliseconds);
}
/**
* Create a Duration from the number of milliseconds.
*
* @deprecated Use {@link Durations#fromMillis} instead.
*/
@Deprecated
public static Duration createDurationFromMillis(long milliseconds) {
return Durations.fromMillis(milliseconds);
}
/**
* Convert a Timestamp to the number of milliseconds elapsed from the epoch.
*
* <p>The result will be rounded down to the nearest millisecond. E.g., if the
* timestamp represents "1969-12-31T23:59:59.999999999Z", it will be rounded
* to -1 millisecond.
*
* @deprecated Use {@link Timestamps#toMillis} instead.
*/
@Deprecated
public static long toMillis(Timestamp timestamp) {
return Timestamps.toMillis(timestamp);
}
/**
* Convert a Duration to the number of milliseconds.The result will be
* rounded towards 0 to the nearest millisecond. E.g., if the duration
* represents -1 nanosecond, it will be rounded to 0.
*
* @deprecated Use {@link Durations#toMillis} instead.
*/
@Deprecated
public static long toMillis(Duration duration) {
return Durations.toMillis(duration);
}
/**
* Create a Timestamp from the number of microseconds elapsed from the epoch.
*
* @deprecated Use {@link Timestamps#fromMicros} instead.
*/
@Deprecated
public static Timestamp createTimestampFromMicros(long microseconds) {
return Timestamps.fromMicros(microseconds);
}
/**
* Create a Duration from the number of microseconds.
*
* @deprecated Use {@link Durations#fromMicros} instead.
*/
@Deprecated
public static Duration createDurationFromMicros(long microseconds) {
return Durations.fromMicros(microseconds);
}
/**
* Convert a Timestamp to the number of microseconds elapsed from the epoch.
*
* <p>The result will be rounded down to the nearest microsecond. E.g., if the
* timestamp represents "1969-12-31T23:59:59.999999999Z", it will be rounded
* to -1 millisecond.
*
* @deprecated Use {@link Timestamps#toMicros} instead.
*/
@Deprecated
public static long toMicros(Timestamp timestamp) {
return Timestamps.toMicros(timestamp);
}
/**
* Convert a Duration to the number of microseconds.The result will be
* rounded towards 0 to the nearest microseconds. E.g., if the duration
* represents -1 nanosecond, it will be rounded to 0.
*
* @deprecated Use {@link Durations#toMicros} instead.
*/
@Deprecated
public static long toMicros(Duration duration) {
return Durations.toMicros(duration);
}
/**
* Create a Timestamp from the number of nanoseconds elapsed from the epoch.
*
* @deprecated Use {@link Timestamps#fromNanos} instead.
*/
@Deprecated
public static Timestamp createTimestampFromNanos(long nanoseconds) {
return Timestamps.fromNanos(nanoseconds);
}
/**
* Create a Duration from the number of nanoseconds.
*
* @deprecated Use {@link Durations#fromNanos} instead.
*/
@Deprecated
public static Duration createDurationFromNanos(long nanoseconds) {
return Durations.fromNanos(nanoseconds);
}
/**
* Convert a Timestamp to the number of nanoseconds elapsed from the epoch.
*
* @deprecated Use {@link Timestamps#toNanos} instead.
*/
@Deprecated
public static long toNanos(Timestamp timestamp) {
return Timestamps.toNanos(timestamp);
}
/**
* Convert a Duration to the number of nanoseconds.
*
* @deprecated Use {@link Durations#toNanos} instead.
*/
@Deprecated
public static long toNanos(Duration duration) {
return Durations.toNanos(duration);
}
/**
* Get the current time.
*
* @deprecated Use {@code Timestamps.fromMillis(System.currentTimeMillis())} instead.
*/
@Deprecated
public static Timestamp getCurrentTime() {
return Timestamps.fromMillis(System.currentTimeMillis());
}
/**
* Get the epoch.
*
* @deprecated Use {@code Timestamps.fromMillis(0)} instead.
*/
@Deprecated
public static Timestamp getEpoch() {
return Timestamp.getDefaultInstance();
}
/**
* Calculate the difference between two timestamps.
*
* @deprecated Use {@link Timestamps#between} instead.
*/
@Deprecated
public static Duration distance(Timestamp from, Timestamp to) {
return Timestamps.between(from, to);
}
/**
* Add a duration to a timestamp.
*
* @deprecated Use {@link Timestamps#add} instead.
*/
@Deprecated
public static Timestamp add(Timestamp start, Duration length) {
return Timestamps.add(start, length);
}
/**
* Subtract a duration from a timestamp.
*
* @deprecated Use {@link Timestamps#subtract} instead.
*/
@Deprecated
public static Timestamp subtract(Timestamp start, Duration length) {
return Timestamps.subtract(start, length);
}
/**
* Add two durations.
*
* @deprecated Use {@link Durations#add} instead.
*/
@Deprecated
public static Duration add(Duration d1, Duration d2) {
return Durations.add(d1, d2);
}
/**
* Subtract a duration from another.
*
* @deprecated Use {@link Durations#subtract} instead.
*/
@Deprecated
public static Duration subtract(Duration d1, Duration d2) {
return Durations.subtract(d1, d2);
}
// Multiplications and divisions.
// TODO(kak): Delete this.
@SuppressWarnings("DurationSecondsToDouble")
public static Duration multiply(Duration duration, double times) {
double result = duration.getSeconds() * times + duration.getNanos() * times / 1000000000.0;
if (result < Long.MIN_VALUE || result > Long.MAX_VALUE) {
throw new IllegalArgumentException("Result is out of valid range.");
}
long seconds = (long) result;
int nanos = (int) ((result - seconds) * 1000000000);
return normalizedDuration(seconds, nanos);
}
// TODO(kak): Delete this.
public static Duration divide(Duration duration, double value) {
return multiply(duration, 1.0 / value);
}
// TODO(kak): Delete this.
public static Duration multiply(Duration duration, long times) {
return createDurationFromBigInteger(toBigInteger(duration).multiply(toBigInteger(times)));
}
// TODO(kak): Delete this.
public static Duration divide(Duration duration, long times) {
return createDurationFromBigInteger(toBigInteger(duration).divide(toBigInteger(times)));
}
// TODO(kak): Delete this.
public static long divide(Duration d1, Duration d2) {
return toBigInteger(d1).divide(toBigInteger(d2)).longValue();
}
// TODO(kak): Delete this.
public static Duration remainder(Duration d1, Duration d2) {
return createDurationFromBigInteger(toBigInteger(d1).remainder(toBigInteger(d2)));
}
private static final BigInteger NANOS_PER_SECOND_BIG_INTEGER =
new BigInteger(String.valueOf(NANOS_PER_SECOND));
private static BigInteger toBigInteger(Duration duration) {
return toBigInteger(duration.getSeconds())
.multiply(NANOS_PER_SECOND_BIG_INTEGER)
.add(toBigInteger(duration.getNanos()));
}
private static BigInteger toBigInteger(long value) {
return new BigInteger(String.valueOf(value));
}
private static Duration createDurationFromBigInteger(BigInteger value) {
long seconds = value.divide(new BigInteger(String.valueOf(NANOS_PER_SECOND))).longValue();
int nanos = value.remainder(new BigInteger(String.valueOf(NANOS_PER_SECOND))).intValue();
return normalizedDuration(seconds, nanos);
}
private static Duration normalizedDuration(long seconds, int nanos) {
if (nanos <= -NANOS_PER_SECOND || nanos >= NANOS_PER_SECOND) {
seconds += nanos / NANOS_PER_SECOND;
nanos %= NANOS_PER_SECOND;
}
if (seconds > 0 && nanos < 0) {
nanos += NANOS_PER_SECOND;
seconds -= 1;
}
if (seconds < 0 && nanos > 0) {
nanos -= NANOS_PER_SECOND;
seconds += 1;
}
if (seconds < DURATION_SECONDS_MIN || seconds > DURATION_SECONDS_MAX) {
throw new IllegalArgumentException("Duration is out of valid range.");
}
return Duration.newBuilder().setSeconds(seconds).setNanos(nanos).build();
}
}

@ -1,498 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package com.google.protobuf.util;
import com.google.protobuf.Duration;
import com.google.protobuf.Timestamp;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import junit.framework.TestCase;
import org.junit.Assert;
/** Unit tests for {@link TimeUtil}. */
public class TimeUtilTest extends TestCase {
public void testTimestampStringFormat() throws Exception {
Timestamp start = TimeUtil.parseTimestamp("0001-01-01T00:00:00Z");
Timestamp end = TimeUtil.parseTimestamp("9999-12-31T23:59:59.999999999Z");
assertEquals(TimeUtil.TIMESTAMP_SECONDS_MIN, start.getSeconds());
assertEquals(0, start.getNanos());
assertEquals(TimeUtil.TIMESTAMP_SECONDS_MAX, end.getSeconds());
assertEquals(999999999, end.getNanos());
assertEquals("0001-01-01T00:00:00Z", TimeUtil.toString(start));
assertEquals("9999-12-31T23:59:59.999999999Z", TimeUtil.toString(end));
Timestamp value = TimeUtil.parseTimestamp("1970-01-01T00:00:00Z");
assertEquals(0, value.getSeconds());
assertEquals(0, value.getNanos());
// Test negative timestamps.
value = TimeUtil.parseTimestamp("1969-12-31T23:59:59.999Z");
assertEquals(-1, value.getSeconds());
// Nano part is in the range of [0, 999999999] for Timestamp.
assertEquals(999000000, value.getNanos());
// Test that 3, 6, or 9 digits are used for the fractional part.
value = Timestamp.newBuilder().setNanos(10).build();
assertEquals("1970-01-01T00:00:00.000000010Z", TimeUtil.toString(value));
value = Timestamp.newBuilder().setNanos(10000).build();
assertEquals("1970-01-01T00:00:00.000010Z", TimeUtil.toString(value));
value = Timestamp.newBuilder().setNanos(10000000).build();
assertEquals("1970-01-01T00:00:00.010Z", TimeUtil.toString(value));
// Test that parsing accepts timezone offsets.
value = TimeUtil.parseTimestamp("1970-01-01T00:00:00.010+08:00");
assertEquals("1969-12-31T16:00:00.010Z", TimeUtil.toString(value));
value = TimeUtil.parseTimestamp("1970-01-01T00:00:00.010-08:00");
assertEquals("1970-01-01T08:00:00.010Z", TimeUtil.toString(value));
}
private volatile boolean stopParsingThreads = false;
private volatile String errorMessage = "";
private class ParseTimestampThread extends Thread {
private final String[] strings;
private final Timestamp[] values;
public ParseTimestampThread(String[] strings, Timestamp[] values) {
this.strings = strings;
this.values = values;
}
@Override
public void run() {
int index = 0;
while (!stopParsingThreads) {
Timestamp result;
try {
result = TimeUtil.parseTimestamp(strings[index]);
} catch (ParseException e) {
errorMessage = "Failed to parse timestamp: " + strings[index];
break;
}
if (result.getSeconds() != values[index].getSeconds()
|| result.getNanos() != values[index].getNanos()) {
errorMessage =
"Actual result: " + result.toString() + ", expected: " + values[index].toString();
break;
}
index = (index + 1) % strings.length;
}
}
}
public void testTimestampConcurrentParsing() throws Exception {
String[] timestampStrings =
new String[] {
"0001-01-01T00:00:00Z",
"9999-12-31T23:59:59.999999999Z",
"1970-01-01T00:00:00Z",
"1969-12-31T23:59:59.999Z",
};
Timestamp[] timestampValues = new Timestamp[timestampStrings.length];
for (int i = 0; i < timestampStrings.length; i++) {
timestampValues[i] = TimeUtil.parseTimestamp(timestampStrings[i]);
}
final int THREAD_COUNT = 16;
final int RUNNING_TIME = 5000; // in milliseconds.
final List<Thread> threads = new ArrayList<Thread>();
stopParsingThreads = false;
errorMessage = "";
for (int i = 0; i < THREAD_COUNT; i++) {
Thread thread = new ParseTimestampThread(timestampStrings, timestampValues);
thread.start();
threads.add(thread);
}
Thread.sleep(RUNNING_TIME);
stopParsingThreads = true;
for (Thread thread : threads) {
thread.join();
}
Assert.assertEquals("", errorMessage);
}
public void testTimetampInvalidFormat() throws Exception {
try {
// Value too small.
Timestamp value =
Timestamp.newBuilder().setSeconds(TimeUtil.TIMESTAMP_SECONDS_MIN - 1).build();
TimeUtil.toString(value);
Assert.fail("Exception is expected.");
} catch (IllegalArgumentException e) {
// Expected.
}
try {
// Value too large.
Timestamp value =
Timestamp.newBuilder().setSeconds(TimeUtil.TIMESTAMP_SECONDS_MAX + 1).build();
TimeUtil.toString(value);
Assert.fail("Exception is expected.");
} catch (IllegalArgumentException e) {
// Expected.
}
try {
// Invalid nanos value.
Timestamp value = Timestamp.newBuilder().setNanos(-1).build();
TimeUtil.toString(value);
Assert.fail("Exception is expected.");
} catch (IllegalArgumentException e) {
// Expected.
}
try {
// Invalid nanos value.
Timestamp value = Timestamp.newBuilder().setNanos(1000000000).build();
TimeUtil.toString(value);
Assert.fail("Exception is expected.");
} catch (IllegalArgumentException e) {
// Expected.
}
try {
// Value to small.
TimeUtil.parseTimestamp("0000-01-01T00:00:00Z");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
try {
// Value to large.
TimeUtil.parseTimestamp("10000-01-01T00:00:00Z");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
try {
// Missing 'T'.
TimeUtil.parseTimestamp("1970-01-01 00:00:00Z");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
try {
// Missing 'Z'.
TimeUtil.parseTimestamp("1970-01-01T00:00:00");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
try {
// Invalid offset.
TimeUtil.parseTimestamp("1970-01-01T00:00:00+0000");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
try {
// Trailing text.
TimeUtil.parseTimestamp("1970-01-01T00:00:00Z0");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
try {
// Invalid nanosecond value.
TimeUtil.parseTimestamp("1970-01-01T00:00:00.ABCZ");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
}
public void testDurationStringFormat() throws Exception {
Timestamp start = TimeUtil.parseTimestamp("0001-01-01T00:00:00Z");
Timestamp end = TimeUtil.parseTimestamp("9999-12-31T23:59:59.999999999Z");
Duration duration = TimeUtil.distance(start, end);
assertEquals("315537897599.999999999s", TimeUtil.toString(duration));
duration = TimeUtil.distance(end, start);
assertEquals("-315537897599.999999999s", TimeUtil.toString(duration));
// Generated output should contain 3, 6, or 9 fractional digits.
duration = Duration.newBuilder().setSeconds(1).build();
assertEquals("1s", TimeUtil.toString(duration));
duration = Duration.newBuilder().setNanos(10000000).build();
assertEquals("0.010s", TimeUtil.toString(duration));
duration = Duration.newBuilder().setNanos(10000).build();
assertEquals("0.000010s", TimeUtil.toString(duration));
duration = Duration.newBuilder().setNanos(10).build();
assertEquals("0.000000010s", TimeUtil.toString(duration));
// Parsing accepts an fractional digits as long as they fit into nano
// precision.
duration = TimeUtil.parseDuration("0.1s");
assertEquals(100000000, duration.getNanos());
duration = TimeUtil.parseDuration("0.0001s");
assertEquals(100000, duration.getNanos());
duration = TimeUtil.parseDuration("0.0000001s");
assertEquals(100, duration.getNanos());
// Duration must support range from -315,576,000,000s to +315576000000s
// which includes negative values.
duration = TimeUtil.parseDuration("315576000000.999999999s");
assertEquals(315576000000L, duration.getSeconds());
assertEquals(999999999, duration.getNanos());
duration = TimeUtil.parseDuration("-315576000000.999999999s");
assertEquals(-315576000000L, duration.getSeconds());
assertEquals(-999999999, duration.getNanos());
}
public void testDurationInvalidFormat() throws Exception {
try {
// Value too small.
Duration value = Duration.newBuilder().setSeconds(TimeUtil.DURATION_SECONDS_MIN - 1).build();
TimeUtil.toString(value);
Assert.fail("Exception is expected.");
} catch (IllegalArgumentException e) {
// Expected.
}
try {
// Value too large.
Duration value = Duration.newBuilder().setSeconds(TimeUtil.DURATION_SECONDS_MAX + 1).build();
TimeUtil.toString(value);
Assert.fail("Exception is expected.");
} catch (IllegalArgumentException e) {
// Expected.
}
try {
// Invalid nanos value.
Duration value = Duration.newBuilder().setSeconds(1).setNanos(-1).build();
TimeUtil.toString(value);
Assert.fail("Exception is expected.");
} catch (IllegalArgumentException e) {
// Expected.
}
try {
// Invalid nanos value.
Duration value = Duration.newBuilder().setSeconds(-1).setNanos(1).build();
TimeUtil.toString(value);
Assert.fail("Exception is expected.");
} catch (IllegalArgumentException e) {
// Expected.
}
try {
// Value too small.
TimeUtil.parseDuration("-315576000001s");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
try {
// Value too large.
TimeUtil.parseDuration("315576000001s");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
try {
// Empty.
TimeUtil.parseDuration("");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
try {
// Missing "s".
TimeUtil.parseDuration("0");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
try {
// Invalid trailing data.
TimeUtil.parseDuration("0s0");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
try {
// Invalid prefix.
TimeUtil.parseDuration("--1s");
Assert.fail("Exception is expected.");
} catch (ParseException e) {
// Expected.
}
}
public void testTimestampConversion() throws Exception {
Timestamp timestamp = TimeUtil.parseTimestamp("1970-01-01T00:00:01.111111111Z");
assertEquals(1111111111, TimeUtil.toNanos(timestamp));
assertEquals(1111111, TimeUtil.toMicros(timestamp));
assertEquals(1111, TimeUtil.toMillis(timestamp));
timestamp = TimeUtil.createTimestampFromNanos(1111111111);
assertEquals("1970-01-01T00:00:01.111111111Z", TimeUtil.toString(timestamp));
timestamp = TimeUtil.createTimestampFromMicros(1111111);
assertEquals("1970-01-01T00:00:01.111111Z", TimeUtil.toString(timestamp));
timestamp = TimeUtil.createTimestampFromMillis(1111);
assertEquals("1970-01-01T00:00:01.111Z", TimeUtil.toString(timestamp));
timestamp = TimeUtil.parseTimestamp("1969-12-31T23:59:59.111111111Z");
assertEquals(-888888889, TimeUtil.toNanos(timestamp));
assertEquals(-888889, TimeUtil.toMicros(timestamp));
assertEquals(-889, TimeUtil.toMillis(timestamp));
timestamp = TimeUtil.createTimestampFromNanos(-888888889);
assertEquals("1969-12-31T23:59:59.111111111Z", TimeUtil.toString(timestamp));
timestamp = TimeUtil.createTimestampFromMicros(-888889);
assertEquals("1969-12-31T23:59:59.111111Z", TimeUtil.toString(timestamp));
timestamp = TimeUtil.createTimestampFromMillis(-889);
assertEquals("1969-12-31T23:59:59.111Z", TimeUtil.toString(timestamp));
}
public void testDurationConversion() throws Exception {
Duration duration = TimeUtil.parseDuration("1.111111111s");
assertEquals(1111111111, TimeUtil.toNanos(duration));
assertEquals(1111111, TimeUtil.toMicros(duration));
assertEquals(1111, TimeUtil.toMillis(duration));
duration = TimeUtil.createDurationFromNanos(1111111111);
assertEquals("1.111111111s", TimeUtil.toString(duration));
duration = TimeUtil.createDurationFromMicros(1111111);
assertEquals("1.111111s", TimeUtil.toString(duration));
duration = TimeUtil.createDurationFromMillis(1111);
assertEquals("1.111s", TimeUtil.toString(duration));
duration = TimeUtil.parseDuration("-1.111111111s");
assertEquals(-1111111111, TimeUtil.toNanos(duration));
assertEquals(-1111111, TimeUtil.toMicros(duration));
assertEquals(-1111, TimeUtil.toMillis(duration));
duration = TimeUtil.createDurationFromNanos(-1111111111);
assertEquals("-1.111111111s", TimeUtil.toString(duration));
duration = TimeUtil.createDurationFromMicros(-1111111);
assertEquals("-1.111111s", TimeUtil.toString(duration));
duration = TimeUtil.createDurationFromMillis(-1111);
assertEquals("-1.111s", TimeUtil.toString(duration));
}
public void testTimeOperations() throws Exception {
Timestamp start = TimeUtil.parseTimestamp("0001-01-01T00:00:00Z");
Timestamp end = TimeUtil.parseTimestamp("9999-12-31T23:59:59.999999999Z");
Duration duration = TimeUtil.distance(start, end);
assertEquals("315537897599.999999999s", TimeUtil.toString(duration));
Timestamp value = TimeUtil.add(start, duration);
assertEquals(end, value);
value = TimeUtil.subtract(end, duration);
assertEquals(start, value);
duration = TimeUtil.distance(end, start);
assertEquals("-315537897599.999999999s", TimeUtil.toString(duration));
value = TimeUtil.add(end, duration);
assertEquals(start, value);
value = TimeUtil.subtract(start, duration);
assertEquals(end, value);
// Result is larger than Long.MAX_VALUE.
try {
duration = TimeUtil.parseDuration("315537897599.999999999s");
duration = TimeUtil.multiply(duration, 315537897599.999999999);
Assert.fail("Exception is expected.");
} catch (IllegalArgumentException e) {
// Expected.
}
// Result is lesser than Long.MIN_VALUE.
try {
duration = TimeUtil.parseDuration("315537897599.999999999s");
duration = TimeUtil.multiply(duration, -315537897599.999999999);
Assert.fail("Exception is expected.");
} catch (IllegalArgumentException e) {
// Expected.
}
duration = TimeUtil.parseDuration("-1.125s");
duration = TimeUtil.divide(duration, 2.0);
assertEquals("-0.562500s", TimeUtil.toString(duration));
duration = TimeUtil.multiply(duration, 2.0);
assertEquals("-1.125s", TimeUtil.toString(duration));
duration = TimeUtil.add(duration, duration);
assertEquals("-2.250s", TimeUtil.toString(duration));
duration = TimeUtil.subtract(duration, TimeUtil.parseDuration("-1s"));
assertEquals("-1.250s", TimeUtil.toString(duration));
// Multiplications (with results larger than Long.MAX_VALUE in nanoseconds).
duration = TimeUtil.parseDuration("0.999999999s");
assertEquals(
"315575999684.424s", TimeUtil.toString(TimeUtil.multiply(duration, 315576000000L)));
duration = TimeUtil.parseDuration("-0.999999999s");
assertEquals(
"-315575999684.424s", TimeUtil.toString(TimeUtil.multiply(duration, 315576000000L)));
assertEquals(
"315575999684.424s", TimeUtil.toString(TimeUtil.multiply(duration, -315576000000L)));
// Divisions (with values larger than Long.MAX_VALUE in nanoseconds).
Duration d1 = TimeUtil.parseDuration("315576000000s");
Duration d2 = TimeUtil.subtract(d1, TimeUtil.createDurationFromNanos(1));
assertEquals(1, TimeUtil.divide(d1, d2));
assertEquals(0, TimeUtil.divide(d2, d1));
assertEquals("0.000000001s", TimeUtil.toString(TimeUtil.remainder(d1, d2)));
assertEquals("315575999999.999999999s", TimeUtil.toString(TimeUtil.remainder(d2, d1)));
// Divisions involving negative values.
//
// (-5) / 2 = -2, remainder = -1
d1 = TimeUtil.parseDuration("-5s");
d2 = TimeUtil.parseDuration("2s");
assertEquals(-2, TimeUtil.divide(d1, d2));
assertEquals(-2, TimeUtil.divide(d1, 2).getSeconds());
assertEquals(-1, TimeUtil.remainder(d1, d2).getSeconds());
// (-5) / (-2) = 2, remainder = -1
d1 = TimeUtil.parseDuration("-5s");
d2 = TimeUtil.parseDuration("-2s");
assertEquals(2, TimeUtil.divide(d1, d2));
assertEquals(2, TimeUtil.divide(d1, -2).getSeconds());
assertEquals(-1, TimeUtil.remainder(d1, d2).getSeconds());
// 5 / (-2) = -2, remainder = 1
d1 = TimeUtil.parseDuration("5s");
d2 = TimeUtil.parseDuration("-2s");
assertEquals(-2, TimeUtil.divide(d1, d2));
assertEquals(-2, TimeUtil.divide(d1, -2).getSeconds());
assertEquals(1, TimeUtil.remainder(d1, d2).getSeconds());
}
}
Loading…
Cancel
Save