Skip to content

Commit 8e26935

Browse files
garrettjonesgooglegarrettjonesgoogle
committed
Addressing PR feedback
1 parent fee2415 commit 8e26935

9 files changed

Lines changed: 74 additions & 81 deletions

File tree

‎google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/FieldValue.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -205,7 +205,7 @@ public Timestamp getTimestampValue() {
205205
// timestamps are encoded in the format 1408452095.22 where the integer part is seconds since
206206
// epoch (e.g. 1408452095.22 == 2014-08-19 07:41:35.220 -05:00)
207207
long microseconds = new Double(Double.valueOf(getStringValue()) * MICROSECONDS).longValue();
208-
return Timestamp.ofTimeMicroseconds(microseconds);
208+
return Timestamp.ofMicroseconds(microseconds);
209209
}
210210

211211

‎google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/QueryParameterValue.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -359,7 +359,7 @@ private static <T> String valueToStringOrNull(T value, StandardSQLTypeName type)
359359
if (value instanceof Timestamp) {
360360
return ((Timestamp) value).formatMicroCloudTime();
361361
} else if (value instanceof Long) {
362-
return Timestamp.ofTimeMicroseconds((Long) value).formatMicroCloudTime();
362+
return Timestamp.ofMicroseconds((Long) value).formatMicroCloudTime();
363363
} else if (value instanceof String) {
364364
// verify that the String is in the right format
365365
Timestamp.parseCloudTimestamp((String) value);

‎google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/FieldValueTest.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -75,7 +75,7 @@ public void testFromPb() {
7575

7676
value = FieldValue.fromPb(TIMESTAMP_FIELD);
7777
assertEquals(FieldValue.Attribute.PRIMITIVE, value.getAttribute());
78-
assertEquals(Timestamp.ofTimeSecondsAndNanos(42, 550_000_000), value.getTimestampValue());
78+
assertEquals(Timestamp.ofSecondsAndNanos(42, 550_000_000), value.getTimestampValue());
7979

8080
value = FieldValue.fromPb(DATE_FIELD);
8181
assertEquals(FieldValue.Attribute.PRIMITIVE, value.getAttribute());

‎google-cloud-core/src/main/java/com/google/cloud/CivilDateTime.java‎

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -16,11 +16,10 @@
1616

1717
package com.google.cloud;
1818

19-
import com.google.api.client.util.Lists;
2019
import com.google.common.base.Preconditions;
21-
import com.google.common.base.Splitter;
22-
import java.util.List;
2320
import java.util.Objects;
21+
import java.util.regex.Matcher;
22+
import java.util.regex.Pattern;
2423

2524
/**
2625
* Represents a date and time with no timezone, e.g. e.g. 2017-03-17 07:41:35.220000.
@@ -30,6 +29,11 @@
3029
*/
3130
public class CivilDateTime implements Comparable<CivilDateTime> {
3231

32+
private static final Pattern DATE_ONLY_PATTERN = Pattern.compile("([^ tT]+)");
33+
private static final Pattern DATE_TIME_PATTERN = Pattern.compile("([^ tT]+)[ tT](.*)");
34+
35+
private static final CivilTime ZERO_TIME = CivilTime.ofHoursMinutesSecondsNanos(0, 0, 0, 0);
36+
3337
private final CivilDate date;
3438
private final CivilTime time;
3539

@@ -46,7 +50,7 @@ private CivilDateTime(CivilDate date, CivilTime time) {
4650
* @param date civil date
4751
*/
4852
public static CivilDateTime ofDate(CivilDate date) {
49-
return ofDateAndTime(date, CivilTime.ofHoursMinutesSecondsNanos(0, 0, 0, 0));
53+
return ofDateAndTime(date, ZERO_TIME);
5054
}
5155

5256
/**
@@ -60,25 +64,21 @@ public static CivilDateTime ofDateAndTime(CivilDate date, CivilTime time) {
6064
}
6165

6266
/**
63-
* @param dateTime Date plus time: (yyyy-MM-dd HH:mm:ss.SSSSSSSSS) or
64-
* (yyyy-MM-dd'T'HH:mm:ss.SSSSSSSSS).
67+
* @param dateTime Date plus time: (yyyy-MM-dd[ HH:mm:ss.SSSSSSSSS]) or
68+
* (yyyy-MM-dd['T'HH:mm:ss.SSSSSSSSS]).
6569
*/
6670
public static CivilDateTime parseDateTime(String dateTime) {
67-
String splitToken = " ";
68-
if (dateTime.contains("T")) {
69-
splitToken = "T";
70-
}
71-
List<String> parts = Lists.newArrayList(Splitter.on(splitToken).split(dateTime));
72-
if (parts.isEmpty()) {
73-
throw new IllegalArgumentException("Invalid date time format: " + dateTime);
74-
}
75-
CivilDate date = CivilDate.parseDate(parts.get(0));
76-
if (parts.size() == 1) {
77-
return ofDate(date);
78-
} else if (parts.size() == 2) {
79-
return ofDateAndTime(date, CivilTime.parseTime(parts.get(1)));
71+
if (DATE_ONLY_PATTERN.matcher(dateTime).matches()) {
72+
return ofDate(CivilDate.parseDate(dateTime));
8073
} else {
81-
throw new IllegalArgumentException("Invalid date time format: " + dateTime);
74+
Matcher dateTimePattern = DATE_TIME_PATTERN.matcher(dateTime);
75+
if (dateTimePattern.matches()) {
76+
String datePart = dateTimePattern.group(1);
77+
String timePart = dateTimePattern.group(2);
78+
return ofDateAndTime(CivilDate.parseDate(datePart), CivilTime.parseTime(timePart));
79+
} else {
80+
throw new IllegalArgumentException("Invalid date time format: " + dateTime);
81+
}
8282
}
8383
}
8484

‎google-cloud-core/src/main/java/com/google/cloud/CivilTime.java‎

Lines changed: 2 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,7 @@ private CivilTime(int hours, int minutes, int seconds, int nanos) {
4848
}
4949

5050
/**
51-
* Constructs a new CivilDate instance.
51+
* Constructs a new CivilTime instance.
5252
*
5353
* @param hours must be between [0,23]
5454
* @param minutes must be between [0,59]
@@ -70,15 +70,7 @@ public static CivilTime parseTime(String time) {
7070
int seconds = Integer.parseInt(matcher.group(3));
7171
int nanos = 0;
7272
if (matcher.groupCount() > 3) {
73-
String fractional = matcher.group(4);
74-
Integer fractionalNumber = Integer.parseInt(fractional);
75-
if (fractional.length() == 3) {
76-
nanos = (int) TimeUnit.MILLISECONDS.toNanos(fractionalNumber);
77-
} else if (fractional.length() == 6) {
78-
nanos = (int) TimeUnit.MICROSECONDS.toNanos(fractionalNumber);
79-
} else {
80-
nanos = fractionalNumber;
81-
}
73+
nanos = Timestamp.parseFractToNanos(matcher.group(4));
8274
}
8375
return new CivilTime(hours, minutes, seconds, nanos);
8476
}

‎google-cloud-core/src/main/java/com/google/cloud/Timestamp.java‎

Lines changed: 12 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -82,11 +82,11 @@ private Timestamp(long seconds, int nanos) {
8282
this.nanos = nanos;
8383
}
8484

85-
public static Timestamp ofTimeMicroseconds(long microseconds) {
85+
public static Timestamp ofMicroseconds(long microseconds) {
8686
int seconds = (int) (TimeUnit.MICROSECONDS.toSeconds(microseconds));
8787
long fractionalMicros = microseconds % TimeUnit.SECONDS.toMicros(1);
8888
int fractionalNanos = (int) TimeUnit.MICROSECONDS.toNanos(fractionalMicros);
89-
return ofTimeSecondsAndNanos(seconds, fractionalNanos);
89+
return ofSecondsAndNanos(seconds, fractionalNanos);
9090
}
9191

9292
/**
@@ -98,7 +98,7 @@ public static Timestamp ofTimeMicroseconds(long microseconds) {
9898
* @param nanos the fractional seconds component, in the range 0..999999999.
9999
* @throws IllegalArgumentException if the timestamp is outside the representable range
100100
*/
101-
public static Timestamp ofTimeSecondsAndNanos(long seconds, int nanos) {
101+
public static Timestamp ofSecondsAndNanos(long seconds, int nanos) {
102102
checkArgument(
103103
Timestamps.isValid(seconds, nanos), "timestamp out of range: %s, %s", seconds, nanos);
104104
return new Timestamp(seconds, nanos);
@@ -110,7 +110,7 @@ public static Timestamp ofTimeSecondsAndNanos(long seconds, int nanos) {
110110
* @throws IllegalArgumentException if the timestamp is outside the representable range
111111
*/
112112
public static Timestamp of(java.sql.Timestamp timestamp) {
113-
return ofTimeSecondsAndNanos(TimeUnit.MILLISECONDS.toSeconds(timestamp.getTime()),
113+
return ofSecondsAndNanos(TimeUnit.MILLISECONDS.toSeconds(timestamp.getTime()),
114114
timestamp.getNanos());
115115
}
116116

@@ -174,12 +174,13 @@ public static Timestamp parseTimestamp(String timestamp) {
174174
if (nanosPart != null) {
175175
nanos = parseFractToNanos(nanosPart.substring(1));
176176
}
177-
return ofTimeSecondsAndNanos(seconds, nanos);
177+
return ofSecondsAndNanos(seconds, nanos);
178178
}
179179

180180
/**
181181
* Creates a Timestamp instance from the given string. String is in the format
182-
* yyyy-MM-dd HH:mm:ss.SSSSSSZZ. If no timezone is given, UTC is assumed.
182+
* yyyy-MM-dd[ HH:mm:ss[.SSSSSSSSS]][time zone]. Here, time zone is in the form (+|-)HH:mm.
183+
* If no timezone is given, UTC is assumed.
183184
*/
184185
public static Timestamp parseCloudTimestamp(String timestamp) {
185186
String date = null;
@@ -212,21 +213,21 @@ public static Timestamp parseCloudTimestamp(String timestamp) {
212213

213214
DateTime dateTime = new DateTime();
214215
dateTime = parseTz(dateTime, tz);
215-
dateTime = parseDate(dateTime, Preconditions.checkNotNull(date));
216+
dateTime = parseDate(dateTime, date);
216217
dateTime = parseTime(dateTime, time);
217218
int nanos = parseFractToNanos(fract);
218-
return ofTimeSecondsAndNanos(TimeUnit.MILLISECONDS.toSeconds(dateTime.getMillis()), nanos);
219+
return ofSecondsAndNanos(TimeUnit.MILLISECONDS.toSeconds(dateTime.getMillis()), nanos);
219220
}
220221

221-
private static DateTime parseDate(DateTime newDateTime, String dateString) {
222+
private static DateTime parseDate(DateTime dateTime, String dateString) {
222223
Matcher matcher = DATE_PATTERN.matcher(dateString);
223224
if (!matcher.matches()) {
224225
throw new IllegalArgumentException("Invalid date: " + dateString);
225226
}
226227
int year = Integer.parseInt(matcher.group(1));
227228
int month = Integer.parseInt(matcher.group(2));
228229
int day = Integer.parseInt(matcher.group(3));
229-
return newDateTime.withDate(year, month, day);
230+
return dateTime.withDate(year, month, day);
230231
}
231232

232233
private static DateTime parseTime(DateTime newDateTime, String timeString) {
@@ -245,7 +246,7 @@ private static DateTime parseTime(DateTime newDateTime, String timeString) {
245246
return newDateTime.withTime(hour, minute, second, 0);
246247
}
247248

248-
private static int parseFractToNanos(String fract) {
249+
static int parseFractToNanos(String fract) {
249250
if (fract == null) {
250251
return 0;
251252
} else {

‎google-cloud-core/src/test/java/com/google/cloud/TimestampTest.java‎

Lines changed: 31 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -72,25 +72,25 @@ public void toFromSqlTimestamp() {
7272
@Test
7373
public void boundsSecondsMin() {
7474
expectedException.expect(IllegalArgumentException.class);
75-
Timestamp.ofTimeSecondsAndNanos(Timestamp.MIN_VALUE.getSeconds() - 1, 999999999);
75+
Timestamp.ofSecondsAndNanos(Timestamp.MIN_VALUE.getSeconds() - 1, 999999999);
7676
}
7777

7878
@Test
7979
public void boundsSecondsMax() {
8080
expectedException.expect(IllegalArgumentException.class);
81-
Timestamp.ofTimeSecondsAndNanos(Timestamp.MAX_VALUE.getSeconds() + 1, 0);
81+
Timestamp.ofSecondsAndNanos(Timestamp.MAX_VALUE.getSeconds() + 1, 0);
8282
}
8383

8484
@Test
8585
public void boundsNanosMin() {
8686
expectedException.expect(IllegalArgumentException.class);
87-
Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, -1);
87+
Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, -1);
8888
}
8989

9090
@Test
9191
public void boundsNanosMax() {
9292
expectedException.expect(IllegalArgumentException.class);
93-
Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 1000000000);
93+
Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 1000000000);
9494
}
9595

9696
@Test
@@ -109,30 +109,30 @@ public void boundsSqlTimestampMax() {
109109
public void equalsAndHashCode() {
110110
EqualsTester tester = new EqualsTester();
111111
tester.addEqualityGroup(
112-
Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 0),
113-
Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 0),
112+
Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 0),
113+
Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 0),
114114
Timestamp.of(new java.sql.Timestamp(TEST_TIME_SECONDS * 1000)));
115-
tester.addEqualityGroup(Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS + 1, 0));
116-
tester.addEqualityGroup(Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 1));
115+
tester.addEqualityGroup(Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS + 1, 0));
116+
tester.addEqualityGroup(Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 1));
117117
tester.testEquals();
118118
}
119119

120120
@Test
121121
public void testToString() {
122122
assertThat(Timestamp.MIN_VALUE.toString()).isEqualTo("0001-01-01T00:00:00Z");
123123
assertThat(Timestamp.MAX_VALUE.toString()).isEqualTo("9999-12-31T23:59:59.999999999Z");
124-
assertThat(Timestamp.ofTimeSecondsAndNanos(0, 0).toString()).isEqualTo("1970-01-01T00:00:00Z");
125-
assertThat(Timestamp.ofTimeSecondsAndNanos(0, 100).toString())
124+
assertThat(Timestamp.ofSecondsAndNanos(0, 0).toString()).isEqualTo("1970-01-01T00:00:00Z");
125+
assertThat(Timestamp.ofSecondsAndNanos(0, 100).toString())
126126
.isEqualTo("1970-01-01T00:00:00.000000100Z");
127-
assertThat(Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 0).toString())
127+
assertThat(Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 0).toString())
128128
.isEqualTo(TEST_TIME_ISO);
129129
}
130130

131131
@Test
132132
public void ofTimeMicroseconds() {
133-
assertThat(Timestamp.ofTimeMicroseconds(1)).isEqualTo(Timestamp.ofTimeSecondsAndNanos(0, 1000));
134-
assertThat(Timestamp.ofTimeMicroseconds(5_001_777))
135-
.isEqualTo(Timestamp.ofTimeSecondsAndNanos(5, 1_777_000));
133+
assertThat(Timestamp.ofMicroseconds(1)).isEqualTo(Timestamp.ofSecondsAndNanos(0, 1000));
134+
assertThat(Timestamp.ofMicroseconds(5_001_777))
135+
.isEqualTo(Timestamp.ofSecondsAndNanos(5, 1_777_000));
136136
}
137137

138138
@Test
@@ -141,7 +141,7 @@ public void parseTimestamp() {
141141
assertThat(Timestamp.parseTimestamp("9999-12-31T23:59:59.999999999Z"))
142142
.isEqualTo(Timestamp.MAX_VALUE);
143143
assertThat(Timestamp.parseTimestamp(TEST_TIME_ISO))
144-
.isEqualTo(Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 0));
144+
.isEqualTo(Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 0));
145145
}
146146

147147
@Test
@@ -157,13 +157,13 @@ public void parseCloudTimestamp() {
157157
assertThat(Timestamp.parseCloudTimestamp("9999-12-31 23:59:59.999999999+0:00"))
158158
.isEqualTo(Timestamp.MAX_VALUE);
159159
assertThat(Timestamp.parseCloudTimestamp("2015-10-12 15:14:54.000000+00:00"))
160-
.isEqualTo(Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 0));
160+
.isEqualTo(Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 0));
161161
assertThat(Timestamp.parseCloudTimestamp("2015-10-12 15:14:54"))
162-
.isEqualTo(Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 0));
162+
.isEqualTo(Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 0));
163163
assertThat(Timestamp.parseCloudTimestamp("2015-10-12 22:14:54+07:00"))
164-
.isEqualTo(Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 0));
164+
.isEqualTo(Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 0));
165165
assertThat(Timestamp.parseCloudTimestamp("2015-10-11 22:14:54-17:00"))
166-
.isEqualTo(Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 0));
166+
.isEqualTo(Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 0));
167167
}
168168

169169
@Test
@@ -186,19 +186,19 @@ public void comparable() {
186186
assertThat(Timestamp.MIN_VALUE).isLessThan(Timestamp.MAX_VALUE);
187187
assertThat(Timestamp.MAX_VALUE).isGreaterThan(Timestamp.MIN_VALUE);
188188

189-
assertThat(Timestamp.ofTimeSecondsAndNanos(100, 0))
190-
.isAtLeast(Timestamp.ofTimeSecondsAndNanos(100, 0));
191-
assertThat(Timestamp.ofTimeSecondsAndNanos(100, 0))
192-
.isAtMost(Timestamp.ofTimeSecondsAndNanos(100, 0));
189+
assertThat(Timestamp.ofSecondsAndNanos(100, 0))
190+
.isAtLeast(Timestamp.ofSecondsAndNanos(100, 0));
191+
assertThat(Timestamp.ofSecondsAndNanos(100, 0))
192+
.isAtMost(Timestamp.ofSecondsAndNanos(100, 0));
193193

194-
assertThat(Timestamp.ofTimeSecondsAndNanos(100, 1000))
195-
.isLessThan(Timestamp.ofTimeSecondsAndNanos(101, 0));
196-
assertThat(Timestamp.ofTimeSecondsAndNanos(100, 1000))
197-
.isAtMost(Timestamp.ofTimeSecondsAndNanos(101, 0));
194+
assertThat(Timestamp.ofSecondsAndNanos(100, 1000))
195+
.isLessThan(Timestamp.ofSecondsAndNanos(101, 0));
196+
assertThat(Timestamp.ofSecondsAndNanos(100, 1000))
197+
.isAtMost(Timestamp.ofSecondsAndNanos(101, 0));
198198

199-
assertThat(Timestamp.ofTimeSecondsAndNanos(101, 0))
200-
.isGreaterThan(Timestamp.ofTimeSecondsAndNanos(100, 1000));
201-
assertThat(Timestamp.ofTimeSecondsAndNanos(101, 0))
202-
.isAtLeast(Timestamp.ofTimeSecondsAndNanos(100, 1000));
199+
assertThat(Timestamp.ofSecondsAndNanos(101, 0))
200+
.isGreaterThan(Timestamp.ofSecondsAndNanos(100, 1000));
201+
assertThat(Timestamp.ofSecondsAndNanos(101, 0))
202+
.isAtLeast(Timestamp.ofSecondsAndNanos(100, 1000));
203203
}
204204
}

‎google-cloud-spanner/src/test/java/com/google/cloud/spanner/TimestampBoundTest.java‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ public void strong() {
4747

4848
@Test
4949
public void readTimestamp() {
50-
Timestamp ts = Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 0);
50+
Timestamp ts = Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 0);
5151
TimestampBound bound = TimestampBound.ofReadTimestamp(ts);
5252
assertThat(bound.getMode()).isEqualTo(Mode.READ_TIMESTAMP);
5353
assertThat(bound.getReadTimestamp()).isEqualTo(ts);
@@ -57,7 +57,7 @@ public void readTimestamp() {
5757

5858
@Test
5959
public void minReadTimestamp() {
60-
Timestamp ts = Timestamp.ofTimeSecondsAndNanos(TEST_TIME_SECONDS, 0);
60+
Timestamp ts = Timestamp.ofSecondsAndNanos(TEST_TIME_SECONDS, 0);
6161
TimestampBound bound = TimestampBound.ofMinReadTimestamp(ts);
6262
assertThat(bound.getMode()).isEqualTo(Mode.MIN_READ_TIMESTAMP);
6363
assertThat(bound.getMinReadTimestamp()).isEqualTo(ts);
@@ -114,8 +114,8 @@ public void maxStalenessNegative() {
114114

115115
@Test
116116
public void equalsAndHashCode() {
117-
Timestamp ts = Timestamp.ofTimeSecondsAndNanos(1444662894L, 0);
118-
Timestamp ts2 = Timestamp.ofTimeSecondsAndNanos(1444662895L, 0);
117+
Timestamp ts = Timestamp.ofSecondsAndNanos(1444662894L, 0);
118+
Timestamp ts2 = Timestamp.ofSecondsAndNanos(1444662895L, 0);
119119
int staleness = 5;
120120
EqualsTester tester = new EqualsTester();
121121
tester.addEqualityGroup(TimestampBound.strong(), TimestampBound.strong());

‎google-cloud-spanner/src/test/java/com/google/cloud/spanner/ValueBinderTest.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -138,7 +138,7 @@ public static ByteArray defaultByteArray() {
138138
}
139139

140140
public static Timestamp defaultTimestamp() {
141-
return Timestamp.ofTimeSecondsAndNanos(0, 0);
141+
return Timestamp.ofSecondsAndNanos(0, 0);
142142
}
143143

144144
public static CivilDate defaultDate() {
@@ -179,7 +179,7 @@ public static Iterable<ByteArray> defaultByteArrayIterable() {
179179

180180
public static Iterable<Timestamp> defaultTimestampIterable() {
181181
return Arrays.asList(
182-
Timestamp.ofTimeSecondsAndNanos(0, 0), Timestamp.ofTimeSecondsAndNanos(0, 1));
182+
Timestamp.ofSecondsAndNanos(0, 0), Timestamp.ofSecondsAndNanos(0, 1));
183183
}
184184

185185
public static Iterable<CivilDate> defaultDateIterable() {

0 commit comments

Comments
 (0)