third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/java/util/src/test/java/com/google/protobuf/util/TimeUtilTest.java

 // 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.
@@ skipping 14 matching lines @@
 // 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 junit.framework.TestCase;
-
-import org.junit.Assert;
-
 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());
@@ skipping 24 matching lines @@
     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();
+          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",
-    };
+    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 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 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();
+      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();
+      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 {
@@ skipping 95 matching lines @@
     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();
+      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();
+      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();
+      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();
+      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.");
@@ skipping 36 matching lines @@
     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");
+    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));
@@ skipping 36 matching lines @@
     }
 
     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)));
+    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)));
-    
+    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)));
-    
+    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());
   }
 }