[java-support] branch master updated: JSPT-79 - Review date and time handling for Java 8
Scott Cantor
cantor.2 at osu.edu
Fri Mar 1 13:09:17 EST 2019
This is an automated email from the git hooks/post-receive script.
scantor pushed a commit to branch master
in repository java-support.
View the commit online:
http://git.shibboleth.net/view/?p=java-support.git;a=commit;h=9953c527c2c2f16215c206e06e487d118a9539dc
The following commit(s) were added to refs/heads/master by this push:
new 9953c52 JSPT-79 - Review date and time handling for Java 8
9953c52 is described below
commit 9953c527c2c2f16215c206e06e487d118a9539dc
Author: Scott Cantor <cantor.2 at osu.edu>
AuthorDate: Fri Mar 1 13:09:15 2019 -0500
JSPT-79 - Review date and time handling for Java 8
https://issues.shibboleth.net/jira/browse/JSPT-79
---
pom.xml | 4 -
.../support/service/AbstractReloadableService.java | 19 +++--
.../java/support/service/ReloadableService.java | 8 +-
.../collection/ClassToInstanceMultiMapTest.java | 74 +++++++++----------
.../LockableClassToInstanceMultiMapTest.java | 86 ++++++++++------------
5 files changed, 87 insertions(+), 104 deletions(-)
diff --git a/pom.xml b/pom.xml
index e5e3bdd..40d9609 100644
--- a/pom.xml
+++ b/pom.xml
@@ -57,10 +57,6 @@
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
</dependency>
- <dependency>
- <groupId>joda-time</groupId>
- <artifactId>joda-time</artifactId>
- </dependency>
<!-- OPTIONAL Compile Dependencies -->
<dependency>
diff --git a/src/main/java/net/shibboleth/utilities/java/support/service/AbstractReloadableService.java b/src/main/java/net/shibboleth/utilities/java/support/service/AbstractReloadableService.java
index 79cd226..8e4684f 100644
--- a/src/main/java/net/shibboleth/utilities/java/support/service/AbstractReloadableService.java
+++ b/src/main/java/net/shibboleth/utilities/java/support/service/AbstractReloadableService.java
@@ -17,6 +17,7 @@
package net.shibboleth.utilities.java.support.service;
+import java.time.Instant;
import java.util.Timer;
import java.util.TimerTask;
@@ -31,8 +32,6 @@ import net.shibboleth.utilities.java.support.component.ComponentSupport;
import net.shibboleth.utilities.java.support.component.UnmodifiableComponent;
import net.shibboleth.utilities.java.support.primitive.TimerSupport;
-import org.joda.time.DateTime;
-import org.joda.time.chrono.ISOChronology;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -62,11 +61,11 @@ public abstract class AbstractReloadableService<T> extends AbstractIdentifiableI
/** Watcher that monitors the set of configuration resources for this service for changes. */
@Nullable private ServiceReloadTask reloadTask;
- /** The last time time the service was reloaded, whether successful or not. */
- @Nullable private DateTime lastReloadInstant;
+ /** The last time the service was reloaded, whether successful or not. */
+ @Nullable private Instant lastReloadInstant;
/** The last time the service was reloaded successfully. */
- @Nullable private DateTime lastSuccessfulReleaseInstant;
+ @Nullable private Instant lastSuccessfulReleaseInstant;
/** The cause of the last reload failure, if the last reload failed. */
@Nullable private Throwable reloadFailureCause;
@@ -133,17 +132,17 @@ public abstract class AbstractReloadableService<T> extends AbstractIdentifiableI
}
/** {@inheritDoc} */
- @Override @Nullable public DateTime getLastReloadAttemptInstant() {
+ @Nullable public Instant getLastReloadAttemptInstant() {
return lastReloadInstant;
}
/** {@inheritDoc} */
- @Override @Nullable public DateTime getLastSuccessfulReloadInstant() {
+ @Nullable public Instant getLastSuccessfulReloadInstant() {
return lastSuccessfulReleaseInstant;
}
/** {@inheritDoc} */
- @Override @Nullable public Throwable getReloadFailureCause() {
+ @Nullable public Throwable getReloadFailureCause() {
return reloadFailureCause;
}
@@ -172,7 +171,7 @@ public abstract class AbstractReloadableService<T> extends AbstractIdentifiableI
log.info("{} Performing initial load", getLogPrefix());
try {
- lastReloadInstant = new DateTime(ISOChronology.getInstanceUTC());
+ lastReloadInstant = Instant.now();
doReload();
lastSuccessfulReleaseInstant = lastReloadInstant;
} catch (final ServiceException e) {
@@ -220,7 +219,7 @@ public abstract class AbstractReloadableService<T> extends AbstractIdentifiableI
/** {@inheritDoc} */
@Override public final void reload() {
- final DateTime now = new DateTime(ISOChronology.getInstanceUTC());
+ final Instant now = Instant.now();
lastReloadInstant = now;
try {
diff --git a/src/main/java/net/shibboleth/utilities/java/support/service/ReloadableService.java b/src/main/java/net/shibboleth/utilities/java/support/service/ReloadableService.java
index c36e343..ffe7327 100644
--- a/src/main/java/net/shibboleth/utilities/java/support/service/ReloadableService.java
+++ b/src/main/java/net/shibboleth/utilities/java/support/service/ReloadableService.java
@@ -17,12 +17,12 @@
package net.shibboleth.utilities.java.support.service;
+import java.time.Instant;
+
import javax.annotation.Nullable;
import net.shibboleth.utilities.java.support.component.InitializableComponent;
-import org.joda.time.DateTime;
-
/**
* A service that supports reloading its configuration.
*
@@ -36,7 +36,7 @@ public interface ReloadableService<T> extends InitializableComponent {
*
* @return time when the service was last successfully reloaded
*/
- @Nullable DateTime getLastSuccessfulReloadInstant();
+ @Nullable Instant getLastSuccessfulReloadInstant();
/**
* Gets the time when the service last attempted to reload. If the reload was successful this time should match the
@@ -44,7 +44,7 @@ public interface ReloadableService<T> extends InitializableComponent {
*
* @return time when the service last attempted to reload
*/
- @Nullable DateTime getLastReloadAttemptInstant();
+ @Nullable Instant getLastReloadAttemptInstant();
/**
* Gets the reason the last reload failed.
diff --git a/src/test/java/net/shibboleth/utilities/java/support/collection/ClassToInstanceMultiMapTest.java b/src/test/java/net/shibboleth/utilities/java/support/collection/ClassToInstanceMultiMapTest.java
index 28f2724..2b57124 100644
--- a/src/test/java/net/shibboleth/utilities/java/support/collection/ClassToInstanceMultiMapTest.java
+++ b/src/test/java/net/shibboleth/utilities/java/support/collection/ClassToInstanceMultiMapTest.java
@@ -18,17 +18,15 @@
package net.shibboleth.utilities.java.support.collection;
import java.io.Serializable;
+import java.time.Instant;
+import java.time.ZonedDateTime;
+import java.time.chrono.ChronoZonedDateTime;
+import java.time.chrono.Chronology;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAdjuster;
import java.util.Arrays;
import java.util.List;
-import org.joda.time.Chronology;
-import org.joda.time.DateTime;
-import org.joda.time.Instant;
-import org.joda.time.ReadableDateTime;
-import org.joda.time.ReadableInstant;
-import org.joda.time.base.AbstractDateTime;
-import org.joda.time.base.AbstractInstant;
-import org.joda.time.base.BaseDateTime;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -49,74 +47,70 @@ public class ClassToInstanceMultiMapTest {
}
@Test public void testKeysAndContainsKey() {
- ClassToInstanceMultiMap<AbstractInstant> map = new ClassToInstanceMultiMap<>();
+ ClassToInstanceMultiMap<Temporal> map = new ClassToInstanceMultiMap<>();
populate(map);
Assert.assertEquals(map.keys().size(), 2);
Assert.assertFalse(map.containsKey(null));
Assert.assertFalse(map.containsKey(Chronology.class));
- Assert.assertFalse(map.containsKey(AbstractInstant.class));
- Assert.assertFalse(map.containsKey(AbstractDateTime.class));
- Assert.assertFalse(map.containsKey(BaseDateTime.class));
- Assert.assertTrue(map.containsKey(DateTime.class));
+ Assert.assertFalse(map.containsKey(Temporal.class));
+ Assert.assertFalse(map.containsKey(TemporalAdjuster.class));
+ Assert.assertTrue(map.containsKey(ZonedDateTime.class));
+ Assert.assertFalse(map.containsKey(ChronoZonedDateTime.class));
Assert.assertFalse(map.containsKey(Comparable.class));
- Assert.assertFalse(map.containsKey(ReadableDateTime.class));
- Assert.assertFalse(map.containsKey(ReadableInstant.class));
Assert.assertFalse(map.containsKey(Serializable.class));
Assert.assertTrue(map.containsKey(Instant.class));
map = new ClassToInstanceMultiMap<>(true);
populate(map);
- Assert.assertEquals(map.keys().size(), 9);
+ Assert.assertEquals(map.keys().size(), 8);
Assert.assertFalse(map.containsKey(null));
Assert.assertFalse(map.containsKey(Chronology.class));
- Assert.assertTrue(map.containsKey(AbstractInstant.class));
- Assert.assertTrue(map.containsKey(AbstractDateTime.class));
- Assert.assertTrue(map.containsKey(BaseDateTime.class));
- Assert.assertTrue(map.containsKey(DateTime.class));
+ Assert.assertTrue(map.containsKey(Temporal.class));
+ Assert.assertTrue(map.containsKey(TemporalAdjuster.class));
+ Assert.assertTrue(map.containsKey(ZonedDateTime.class));
+ Assert.assertTrue(map.containsKey(ChronoZonedDateTime.class));
Assert.assertTrue(map.containsKey(Comparable.class));
- Assert.assertTrue(map.containsKey(ReadableDateTime.class));
- Assert.assertTrue(map.containsKey(ReadableInstant.class));
Assert.assertTrue(map.containsKey(Serializable.class));
Assert.assertTrue(map.containsKey(Instant.class));
}
@Test public void testValuesAndContainsValues() {
- ClassToInstanceMultiMap<AbstractInstant> map = new ClassToInstanceMultiMap<>();
+ ClassToInstanceMultiMap<Temporal> map = new ClassToInstanceMultiMap<>();
- DateTime now = new DateTime();
+ ZonedDateTime now = ZonedDateTime.now();
map.put(now);
- DateTime now100 = now.plus(100);
+ ZonedDateTime now100 = now.plusMinutes(100);
map.put(now100);
- Instant instant = new Instant();
+ Instant instant = Instant.now();
map.put(instant);
Assert.assertEquals(map.values().size(), 3);
Assert.assertFalse(map.containsValue(null));
- Assert.assertFalse(map.containsValue(now.minus(100)));
- Assert.assertFalse(map.containsValue(instant.minus(100)));
+ Assert.assertFalse(map.containsValue(now.minusDays(100)));
+ Assert.assertFalse(map.containsValue(instant.minusSeconds(100)));
Assert.assertTrue(map.containsValue(instant));
Assert.assertTrue(map.containsValue(now));
Assert.assertTrue(map.containsValue(now100));
}
@Test public void testEquals() {
- final ClassToInstanceMultiMap<AbstractInstant> map = new ClassToInstanceMultiMap<>();
- final ClassToInstanceMultiMap<AbstractInstant> map2 = new ClassToInstanceMultiMap<>();
- final ClassToInstanceMultiMap<AbstractInstant> map3 = new ClassToInstanceMultiMap<>();
+ final ClassToInstanceMultiMap<Temporal> map = new ClassToInstanceMultiMap<>();
+ final ClassToInstanceMultiMap<Temporal> map2 = new ClassToInstanceMultiMap<>();
+ final ClassToInstanceMultiMap<Temporal> map3 = new ClassToInstanceMultiMap<>();
- final DateTime now = new DateTime();
+ final ZonedDateTime now = ZonedDateTime.now();
map.put(now);
map2.put(now);
map3.put(now);
- final DateTime now100 = now.plus(100);
+ final ZonedDateTime now100 = now.plusMinutes(100);
map.put(now100);
map2.put(now100);
map3.put(now100);
- final Instant instant = new Instant();
+ final Instant instant = Instant.now();
map.put(instant);
map2.put(instant);
@@ -129,13 +123,13 @@ public class ClassToInstanceMultiMapTest {
}
@Test public void testGet() {
- ClassToInstanceMultiMap<AbstractInstant> map = new ClassToInstanceMultiMap<>();
+ ClassToInstanceMultiMap<Temporal> map = new ClassToInstanceMultiMap<>();
populate(map);
List<?> values = map.get(null);
Assert.assertEquals(values.size(), 0);
- values = map.get(DateTime.class);
+ values = map.get(ZonedDateTime.class);
Assert.assertEquals(values.size(), 2);
values = map.get(Instant.class);
@@ -317,14 +311,14 @@ public class ClassToInstanceMultiMapTest {
Assert.assertFalse(map.containsKey(Bar.class));
}
- protected void populate(ClassToInstanceMultiMap<AbstractInstant> map) {
- DateTime now = new DateTime();
+ protected void populate(ClassToInstanceMultiMap<Temporal> map) {
+ ZonedDateTime now = ZonedDateTime.now();
map.put(now);
- DateTime now100 = now.plus(100);
+ ZonedDateTime now100 = now.plusMinutes(100);
map.put(now100);
- Instant instant = new Instant();
+ Instant instant = Instant.now();
map.put(instant);
}
diff --git a/src/test/java/net/shibboleth/utilities/java/support/collection/LockableClassToInstanceMultiMapTest.java b/src/test/java/net/shibboleth/utilities/java/support/collection/LockableClassToInstanceMultiMapTest.java
index 476d085..32726d8 100644
--- a/src/test/java/net/shibboleth/utilities/java/support/collection/LockableClassToInstanceMultiMapTest.java
+++ b/src/test/java/net/shibboleth/utilities/java/support/collection/LockableClassToInstanceMultiMapTest.java
@@ -18,17 +18,15 @@
package net.shibboleth.utilities.java.support.collection;
import java.io.Serializable;
+import java.time.Instant;
+import java.time.ZonedDateTime;
+import java.time.chrono.ChronoZonedDateTime;
+import java.time.chrono.Chronology;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAdjuster;
import java.util.Arrays;
import java.util.List;
-import org.joda.time.Chronology;
-import org.joda.time.DateTime;
-import org.joda.time.Instant;
-import org.joda.time.ReadableDateTime;
-import org.joda.time.ReadableInstant;
-import org.joda.time.base.AbstractDateTime;
-import org.joda.time.base.AbstractInstant;
-import org.joda.time.base.BaseDateTime;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -49,74 +47,70 @@ public class LockableClassToInstanceMultiMapTest {
}
@Test public void testKeysAndContainsKey() {
- LockableClassToInstanceMultiMap<AbstractInstant> map = new LockableClassToInstanceMultiMap<>();
+ LockableClassToInstanceMultiMap<Temporal> map = new LockableClassToInstanceMultiMap<>();
populate(map);
Assert.assertEquals(map.keysWithLock().size(), 2);
Assert.assertFalse(map.containsKeyWithLock(null));
Assert.assertFalse(map.containsKeyWithLock(Chronology.class));
- Assert.assertFalse(map.containsKeyWithLock(AbstractInstant.class));
- Assert.assertFalse(map.containsKeyWithLock(AbstractDateTime.class));
- Assert.assertFalse(map.containsKeyWithLock(BaseDateTime.class));
- Assert.assertTrue(map.containsKeyWithLock(DateTime.class));
+ Assert.assertFalse(map.containsKeyWithLock(Temporal.class));
+ Assert.assertFalse(map.containsKeyWithLock(TemporalAdjuster.class));
+ Assert.assertTrue(map.containsKeyWithLock(ZonedDateTime.class));
+ Assert.assertFalse(map.containsKeyWithLock(ChronoZonedDateTime.class));
Assert.assertFalse(map.containsKeyWithLock(Comparable.class));
- Assert.assertFalse(map.containsKeyWithLock(ReadableDateTime.class));
- Assert.assertFalse(map.containsKeyWithLock(ReadableInstant.class));
Assert.assertFalse(map.containsKeyWithLock(Serializable.class));
Assert.assertTrue(map.containsKeyWithLock(Instant.class));
map = new LockableClassToInstanceMultiMap<>(true);
populate(map);
- Assert.assertEquals(map.keysWithLock().size(), 9);
+ Assert.assertEquals(map.keysWithLock().size(), 8);
Assert.assertFalse(map.containsKeyWithLock(null));
Assert.assertFalse(map.containsKeyWithLock(Chronology.class));
- Assert.assertTrue(map.containsKeyWithLock(AbstractInstant.class));
- Assert.assertTrue(map.containsKeyWithLock(AbstractDateTime.class));
- Assert.assertTrue(map.containsKeyWithLock(BaseDateTime.class));
- Assert.assertTrue(map.containsKeyWithLock(DateTime.class));
+ Assert.assertTrue(map.containsKeyWithLock(Temporal.class));
+ Assert.assertTrue(map.containsKeyWithLock(TemporalAdjuster.class));
+ Assert.assertTrue(map.containsKeyWithLock(ZonedDateTime.class));
+ Assert.assertTrue(map.containsKeyWithLock(ChronoZonedDateTime.class));
Assert.assertTrue(map.containsKeyWithLock(Comparable.class));
- Assert.assertTrue(map.containsKeyWithLock(ReadableDateTime.class));
- Assert.assertTrue(map.containsKeyWithLock(ReadableInstant.class));
Assert.assertTrue(map.containsKeyWithLock(Serializable.class));
Assert.assertTrue(map.containsKeyWithLock(Instant.class));
}
@Test public void testValuesAndContainsValues() {
- LockableClassToInstanceMultiMap<AbstractInstant> map = new LockableClassToInstanceMultiMap<>();
+ LockableClassToInstanceMultiMap<Temporal> map = new LockableClassToInstanceMultiMap<>();
- DateTime now = new DateTime();
- map.putWithLock(now);
+ ZonedDateTime now = ZonedDateTime.now();
+ map.put(now);
- DateTime now100 = now.plus(100);
- map.putWithLock(now100);
+ ZonedDateTime now100 = now.plusMinutes(100);
+ map.put(now100);
- Instant instant = new Instant();
- map.putWithLock(instant);
+ Instant instant = Instant.now();
+ map.put(instant);
Assert.assertEquals(map.valuesWithLock().size(), 3);
Assert.assertFalse(map.containsValueWithLock(null));
- Assert.assertFalse(map.containsValueWithLock(now.minus(100)));
- Assert.assertFalse(map.containsValueWithLock(instant.minus(100)));
+ Assert.assertFalse(map.containsValueWithLock(now.minusMinutes(100)));
+ Assert.assertFalse(map.containsValueWithLock(instant.minusSeconds(100)));
Assert.assertTrue(map.containsValueWithLock(instant));
Assert.assertTrue(map.containsValueWithLock(now));
Assert.assertTrue(map.containsValueWithLock(now100));
}
@Test public void testEquals() {
- final LockableClassToInstanceMultiMap<AbstractInstant> map = new LockableClassToInstanceMultiMap<>();
- final LockableClassToInstanceMultiMap<AbstractInstant> map2 = new LockableClassToInstanceMultiMap<>();
- final LockableClassToInstanceMultiMap<AbstractInstant> map3 = new LockableClassToInstanceMultiMap<>();
+ final LockableClassToInstanceMultiMap<Temporal> map = new LockableClassToInstanceMultiMap<>();
+ final LockableClassToInstanceMultiMap<Temporal> map2 = new LockableClassToInstanceMultiMap<>();
+ final LockableClassToInstanceMultiMap<Temporal> map3 = new LockableClassToInstanceMultiMap<>();
- final DateTime now = new DateTime();
+ final ZonedDateTime now = ZonedDateTime.now();
map.putWithLock(now);
map2.putWithLock(now);
map3.putWithLock(now);
- final DateTime now100 = now.plus(100);
+ final ZonedDateTime now100 = now.plusMinutes(100);
map.putWithLock(now100);
map2.putWithLock(now100);
map3.putWithLock(now100);
- final Instant instant = new Instant();
+ final Instant instant = Instant.now();
map.putWithLock(instant);
map2.putWithLock(instant);
@@ -129,13 +123,13 @@ public class LockableClassToInstanceMultiMapTest {
}
@Test public void testGet() {
- LockableClassToInstanceMultiMap<AbstractInstant> map = new LockableClassToInstanceMultiMap<>();
+ LockableClassToInstanceMultiMap<Temporal> map = new LockableClassToInstanceMultiMap<>();
populate(map);
List<?> values = map.getWithLock(null);
Assert.assertEquals(values.size(), 0);
- values = map.getWithLock(DateTime.class);
+ values = map.getWithLock(ZonedDateTime.class);
Assert.assertEquals(values.size(), 2);
values = map.getWithLock(Instant.class);
@@ -317,15 +311,15 @@ public class LockableClassToInstanceMultiMapTest {
Assert.assertFalse(map.containsKeyWithLock(Bar.class));
}
- protected void populate(LockableClassToInstanceMultiMap<AbstractInstant> map) {
- DateTime now = new DateTime();
- map.putWithLock(now);
+ protected void populate(ClassToInstanceMultiMap<Temporal> map) {
+ ZonedDateTime now = ZonedDateTime.now();
+ map.put(now);
- DateTime now100 = now.plus(100);
- map.putWithLock(now100);
+ ZonedDateTime now100 = now.plusMinutes(100);
+ map.put(now100);
- Instant instant = new Instant();
- map.putWithLock(instant);
+ Instant instant = Instant.now();
+ map.put(instant);
}
// Test classes and interfaces
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
More information about the commits
mailing list