Menu
▾
▴
[Objectlabkit-svn] SF.net SVN: objectlabkit:[376] trunk/utils/src
|
From: <be...@us...> - 2010-11-20 22:49:14
|
Revision: 376
http://objectlabkit.svn.sourceforge.net/objectlabkit/?rev=376&view=rev
Author: benoitx
Date: 2010-11-20 22:49:07 +0000 (Sat, 20 Nov 2010)
Log Message:
-----------
Added Unit Test for the immutable collections with timeout...
Modified Paths:
--------------
trunk/utils/src/main/java/net/objectlab/kit/collections/AbstractImmutabeExpiringCollection.java
trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringCollection.java
trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringCollectionBuilder.java
trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashMap.java
trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashSet.java
trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashSetBuilder.java
trunk/utils/src/main/java/net/objectlab/kit/collections/MapBuilder.java
trunk/utils/src/main/java/net/objectlab/kit/collections/SetBuilder.java
Added Paths:
-----------
trunk/utils/src/main/java/net/objectlab/kit/collections/DefaultMapBuilder.java
trunk/utils/src/main/java/net/objectlab/kit/collections/DefaultSetBuilder.java
trunk/utils/src/main/java/net/objectlab/kit/util/PeriodBuilder.java
trunk/utils/src/test/java/net/objectlab/kit/collections/
trunk/utils/src/test/java/net/objectlab/kit/collections/ImmutableExpiringHashMapTest.java
trunk/utils/src/test/java/net/objectlab/kit/collections/ImmutableExpiringHashSetTest.java
Modified: trunk/utils/src/main/java/net/objectlab/kit/collections/AbstractImmutabeExpiringCollection.java
===================================================================
--- trunk/utils/src/main/java/net/objectlab/kit/collections/AbstractImmutabeExpiringCollection.java 2010-11-05 11:41:20 UTC (rev 375)
+++ trunk/utils/src/main/java/net/objectlab/kit/collections/AbstractImmutabeExpiringCollection.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -8,15 +8,24 @@
/**
* @author xhensevalb
- *
*/
public abstract class AbstractImmutabeExpiringCollection {
private long expiryTimeoutMilliseconds;
- private boolean loadOnExpiry = true;
+ private boolean reloadOnExpiry = true;
+ private boolean reloadWhenExpired = true;
private boolean loadOnFirstAccess = true;
private long lastLoadingTime;
+ private String id;
private Timer timer;
+ protected void setId(final String id) {
+ this.id = id;
+ }
+
+ public String getId() {
+ return id;
+ }
+
protected void setLastLoadingTime(final long lastLoadingTime) {
this.lastLoadingTime = lastLoadingTime;
}
@@ -25,20 +34,24 @@
this.expiryTimeoutMilliseconds = milliseconds;
}
- public void setLoadOnExpiry(final boolean loadOnExpiry) {
- this.loadOnExpiry = loadOnExpiry;
+ public void setReloadOnExpiry(final boolean reloadOnExpiry) {
+ this.reloadOnExpiry = reloadOnExpiry;
}
public void setLoadOnFirstAccess(final boolean loadOnFirstAccess) {
this.loadOnFirstAccess = loadOnFirstAccess;
}
+ public void setReloadWhenExpired(final boolean reloadWhenExpired) {
+ this.reloadWhenExpired = reloadWhenExpired;
+ }
+
protected boolean hasExpired() {
return System.currentTimeMillis() - lastLoadingTime > expiryTimeoutMilliseconds;
}
public void start() {
- if (loadOnExpiry) {
+ if (reloadOnExpiry) {
// start timer
timer = new Timer();
timer.scheduleAtFixedRate(new TimerTask() {
@@ -55,7 +68,11 @@
protected void validateOnAccess() {
if (hasExpired()) {
- load();
+ if (reloadWhenExpired || loadOnFirstAccess && lastLoadingTime == 0) {
+ load();
+ } else {
+ doClear();
+ }
}
}
@@ -66,12 +83,14 @@
protected abstract void doLoad();
+ protected abstract void doClear();
+
protected long getExpiryTimeoutMilliseconds() {
return expiryTimeoutMilliseconds;
}
- protected boolean isLoadOnExpiry() {
- return loadOnExpiry;
+ protected boolean isReloadOnExpiry() {
+ return reloadOnExpiry;
}
protected boolean isLoadOnFirstAccess() {
Added: trunk/utils/src/main/java/net/objectlab/kit/collections/DefaultMapBuilder.java
===================================================================
--- trunk/utils/src/main/java/net/objectlab/kit/collections/DefaultMapBuilder.java (rev 0)
+++ trunk/utils/src/main/java/net/objectlab/kit/collections/DefaultMapBuilder.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -0,0 +1,74 @@
+/**
+ *
+ */
+package net.objectlab.kit.collections;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import net.objectlab.kit.util.Pair;
+
+/**
+ * Inspired by the Google Collection builder.
+ *
+ * @author Benoit Xhenseval
+ *
+ */
+public class DefaultMapBuilder<K, V> implements MapBuilder<K, V> {
+ private final List<Pair<K, V>> entries = new ArrayList<Pair<K, V>>();
+ private final String id;
+
+ public DefaultMapBuilder(final String id) {
+ this.id = id;
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ /**
+ * Associates {@code key} with {@code value} in the built map.
+ */
+ public DefaultMapBuilder<K, V> put(final K key, final V value) {
+ entries.add(new Pair<K, V>(key, value));
+ return this;
+ }
+
+ /**
+ * Associates all of the given map's keys and values in the built map.
+ *
+ * @throws NullPointerException if any key or value in {@code map} is null
+ */
+ public DefaultMapBuilder<K, V> putAll(final Map<? extends K, ? extends V> map) {
+ for (final Entry<? extends K, ? extends V> entry : map.entrySet()) {
+ put(entry.getKey(), entry.getValue());
+ }
+ return this;
+ }
+
+ /**
+ * Returns a newly-created immutable map.
+ *
+ * @throws IllegalArgumentException if duplicate keys were added
+ */
+ public Map<K, V> build() {
+ return fromEntryList(entries);
+ }
+
+ private static <K, V> Map<K, V> fromEntryList(final List<Pair<K, V>> entries) {
+ final int size = entries.size();
+ switch (size) {
+ case 0:
+ return new HashMap<K, V>();
+ default:
+ final Map<K, V> m = new HashMap<K, V>();
+ for (final Pair<K, V> entry : entries) {
+ m.put(entry.getElement1(), entry.getElement2());
+ }
+ return m;
+ }
+ }
+}
Added: trunk/utils/src/main/java/net/objectlab/kit/collections/DefaultSetBuilder.java
===================================================================
--- trunk/utils/src/main/java/net/objectlab/kit/collections/DefaultSetBuilder.java (rev 0)
+++ trunk/utils/src/main/java/net/objectlab/kit/collections/DefaultSetBuilder.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -0,0 +1,38 @@
+/**
+ *
+ */
+package net.objectlab.kit.collections;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author xhensevalb
+ *
+ */
+public class DefaultSetBuilder<T> implements SetBuilder<T> {
+ private final Set<T> set = new HashSet<T>();
+ private final String id;
+
+ public DefaultSetBuilder(final String id) {
+ super();
+ this.id = id;
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ public void add(final T t) {
+ set.add(t);
+ }
+
+ public void addAll(final Collection<T> t) {
+ set.addAll(t);
+ }
+
+ Set<T> build() {
+ return new HashSet<T>(set);
+ }
+}
Modified: trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringCollection.java
===================================================================
--- trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringCollection.java 2010-11-05 11:41:20 UTC (rev 375)
+++ trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringCollection.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -12,7 +12,9 @@
void setLoadOnFirstAccess(boolean loadOnFirstAccess);
- void setLoadOnExpiry(boolean loadOnExpiry);
+ void setReloadOnExpiry(boolean loadOnExpiry);
+ void setReloadWhenExpired(boolean loadWhenExpired);
+
void start();
}
Modified: trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringCollectionBuilder.java
===================================================================
--- trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringCollectionBuilder.java 2010-11-05 11:41:20 UTC (rev 375)
+++ trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringCollectionBuilder.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -1,20 +1,52 @@
package net.objectlab.kit.collections;
+import net.objectlab.kit.util.PeriodBuilder;
+
+/**
+ * Builder for the immutable classes.
+ * Default:
+ * - no time out
+ * - reload on expiry: true
+ * - load on first access only (ie not at construction time)
+ *
+ * @author xhensevalb
+ *
+ */
public class ImmutableExpiringCollectionBuilder {
- private long expiryTimeoutMilliseconds;
- private boolean loadOnExpiry = true;
+ private long expiryTimeoutMilliseconds = -1;
+ private boolean reloadOnExpiry = true;
+ private boolean reloadWhenExpired = true;
private boolean loadOnFirstAccess = true;
+ private String id;
- public ImmutableExpiringCollectionBuilder expiryTimeoutMilliseconds(final long expiryTimeourMilliseconds) {
- this.expiryTimeoutMilliseconds = expiryTimeourMilliseconds;
+ public ImmutableExpiringCollectionBuilder id(final String id) {
+ this.id = id;
return this;
}
- public ImmutableExpiringCollectionBuilder loadOnExpiry(final boolean loadOnExpiry) {
- this.loadOnExpiry = loadOnExpiry;
+ public ImmutableExpiringCollectionBuilder expiryTimeout(final PeriodBuilder expiryTimeout) {
+ assert expiryTimeout != null;
+ if (expiryTimeout != null) {
+ this.expiryTimeoutMilliseconds = expiryTimeout.calculateMilliseconds();
+ }
return this;
}
+ public ImmutableExpiringCollectionBuilder expiryTimeoutMilliseconds(final long expiryTimeoutMilliseconds) {
+ this.expiryTimeoutMilliseconds = expiryTimeoutMilliseconds;
+ return this;
+ }
+
+ public ImmutableExpiringCollectionBuilder reloadWhenExpired(final boolean reloadWhenExpired) {
+ this.reloadWhenExpired = reloadWhenExpired;
+ return this;
+ }
+
+ public ImmutableExpiringCollectionBuilder reloadOnExpiry(final boolean loadOnExpiry) {
+ this.reloadOnExpiry = loadOnExpiry;
+ return this;
+ }
+
public ImmutableExpiringCollectionBuilder loadOnFirstAccess(final boolean loadOnFirstAccess) {
this.loadOnFirstAccess = loadOnFirstAccess;
return this;
@@ -24,12 +56,19 @@
return expiryTimeoutMilliseconds;
}
- final boolean isLoadOnExpiry() {
- return loadOnExpiry;
+ final boolean isReloadOnExpiry() {
+ return reloadOnExpiry;
}
+ final boolean isReloadWhenExpired() {
+ return reloadWhenExpired;
+ }
+
final boolean isLoadOnFirstAccess() {
return loadOnFirstAccess;
}
+ final String getId() {
+ return id;
+ }
}
Modified: trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashMap.java
===================================================================
--- trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashMap.java 2010-11-05 11:41:20 UTC (rev 375)
+++ trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashMap.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -18,15 +18,17 @@
public ImmutableExpiringHashMap(final ImmutableExpiringHashMapBuilder<K, V> builder) {
loader = builder.getLoader();
+ setId(builder.getId());
setExpiryTimeoutMilliseconds(builder.getExpiryTimeoutMilliseconds());
- setLoadOnExpiry(builder.isLoadOnExpiry());
+ setReloadOnExpiry(builder.isReloadOnExpiry());
setLoadOnFirstAccess(builder.isLoadOnFirstAccess());
+ setReloadWhenExpired(builder.isReloadWhenExpired());
start();
}
@Override
protected void doLoad() {
- final MapBuilder<K, V> builder = new MapBuilder<K, V>();
+ final DefaultMapBuilder<K, V> builder = new DefaultMapBuilder<K, V>(getId());
loader.load(builder);
delegate = builder.build();
}
@@ -86,4 +88,9 @@
validateOnAccess();
return delegate.values();
}
+
+ @Override
+ protected void doClear() {
+ delegate.clear();
+ }
}
Modified: trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashSet.java
===================================================================
--- trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashSet.java 2010-11-05 11:41:20 UTC (rev 375)
+++ trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashSet.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -18,15 +18,17 @@
public ImmutableExpiringHashSet(final ImmutableExpiringHashSetBuilder<T> builder) {
this.loader = builder.getLoader();
+ setId(builder.getId());
setExpiryTimeoutMilliseconds(builder.getExpiryTimeoutMilliseconds());
- setLoadOnExpiry(builder.isLoadOnExpiry());
+ setReloadOnExpiry(builder.isReloadOnExpiry());
setLoadOnFirstAccess(builder.isLoadOnFirstAccess());
+ setReloadWhenExpired(builder.isReloadWhenExpired());
start();
}
@Override
protected void doLoad() {
- final SetBuilder<T> builder = new SetBuilder<T>();
+ final DefaultSetBuilder<T> builder = new DefaultSetBuilder<T>(getId());
loader.load(builder);
delegate = builder.build();
}
@@ -90,4 +92,9 @@
validateOnAccess();
return delegate.toArray(a);
}
+
+ @Override
+ protected void doClear() {
+ delegate.clear();
+ }
}
Modified: trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashSetBuilder.java
===================================================================
--- trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashSetBuilder.java 2010-11-05 11:41:20 UTC (rev 375)
+++ trunk/utils/src/main/java/net/objectlab/kit/collections/ImmutableExpiringHashSetBuilder.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -1,5 +1,12 @@
package net.objectlab.kit.collections;
+/**
+ * The builder in charge of providing the parameters for the Set.
+ *
+ * @author xhensevalb
+ *
+ * @param <T>
+ */
public class ImmutableExpiringHashSetBuilder<T> extends ImmutableExpiringCollectionBuilder {
private final SetLoader<T> loader;
Modified: trunk/utils/src/main/java/net/objectlab/kit/collections/MapBuilder.java
===================================================================
--- trunk/utils/src/main/java/net/objectlab/kit/collections/MapBuilder.java 2010-11-05 11:41:20 UTC (rev 375)
+++ trunk/utils/src/main/java/net/objectlab/kit/collections/MapBuilder.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -3,66 +3,26 @@
*/
package net.objectlab.kit.collections;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
import java.util.Map;
-import java.util.Map.Entry;
-import net.objectlab.kit.util.Pair;
-
/**
* Inspired by the Google Collection builder.
*
* @author Benoit Xhenseval
*
*/
-public class MapBuilder<K, V> {
- final List<Pair<K, V>> entries = new ArrayList<Pair<K, V>>();
+public interface MapBuilder<K, V> {
+ String getId();
- public MapBuilder() {
- }
-
/**
* Associates {@code key} with {@code value} in the built map.
*/
- public MapBuilder<K, V> put(final K key, final V value) {
- entries.add(new Pair<K, V>(key, value));
- return this;
- }
+ MapBuilder<K, V> put(K key, V value);
/**
* Associates all of the given map's keys and values in the built map.
*
* @throws NullPointerException if any key or value in {@code map} is null
*/
- public MapBuilder<K, V> putAll(final Map<? extends K, ? extends V> map) {
- for (final Entry<? extends K, ? extends V> entry : map.entrySet()) {
- put(entry.getKey(), entry.getValue());
- }
- return this;
- }
-
- /**
- * Returns a newly-created immutable map.
- *
- * @throws IllegalArgumentException if duplicate keys were added
- */
- public Map<K, V> build() {
- return fromEntryList(entries);
- }
-
- private static <K, V> Map<K, V> fromEntryList(final List<Pair<K, V>> entries) {
- final int size = entries.size();
- switch (size) {
- case 0:
- return new HashMap<K, V>();
- default:
- final Map<K, V> m = new HashMap<K, V>();
- for (final Pair<K, V> entry : entries) {
- m.put(entry.getElement1(), entry.getElement2());
- }
- return m;
- }
- }
-}
+ MapBuilder<K, V> putAll(Map<? extends K, ? extends V> map);
+}
\ No newline at end of file
Modified: trunk/utils/src/main/java/net/objectlab/kit/collections/SetBuilder.java
===================================================================
--- trunk/utils/src/main/java/net/objectlab/kit/collections/SetBuilder.java 2010-11-05 11:41:20 UTC (rev 375)
+++ trunk/utils/src/main/java/net/objectlab/kit/collections/SetBuilder.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -3,21 +3,16 @@
*/
package net.objectlab.kit.collections;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.Collection;
/**
* @author xhensevalb
*
*/
-public class SetBuilder<T> {
- private final Set<T> set = new HashSet<T>();
+public interface SetBuilder<T> {
+ String getId();
- public void add(final T t) {
- set.add(t);
- }
+ void add(final T t);
- public Set<T> build() {
- return new HashSet<T>(set);
- }
+ void addAll(final Collection<T> t);
}
Added: trunk/utils/src/main/java/net/objectlab/kit/util/PeriodBuilder.java
===================================================================
--- trunk/utils/src/main/java/net/objectlab/kit/util/PeriodBuilder.java (rev 0)
+++ trunk/utils/src/main/java/net/objectlab/kit/util/PeriodBuilder.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -0,0 +1,60 @@
+/**
+ *
+ */
+package net.objectlab.kit.util;
+
+/**
+ * A simple helper class that is NOT SCIENTIFIC but accurate enough
+ * for the mere mortals, to calculate the number of milliseconds to
+ * be used in say a timer but setup in a easier way...
+ * @author xhensevalb
+ *
+ */
+public class PeriodBuilder {
+ private int weeks = 0;
+ private int days = 0;
+ private int hours = 0;
+ private int minutes = 0;
+ private int seconds = 0;
+ private long milliseconds = 0;
+
+ public long calculateMilliseconds() {
+ return milliseconds //
+ + seconds * 1000L //
+ + minutes * 60L * 1000L //
+ + hours * 60L * 60L * 1000L //
+ + days * 24L * 60L * 60L * 1000L //
+ + weeks * 7L * 24L * 60L * 60L * 1000L //
+ ;
+ }
+
+ public PeriodBuilder weeks(final int weeks) {
+ this.weeks = weeks;
+ return this;
+ }
+
+ public PeriodBuilder days(final int days) {
+ this.days = days;
+ return this;
+ }
+
+ public PeriodBuilder hours(final int hours) {
+ this.hours = hours;
+ return this;
+ }
+
+ public PeriodBuilder minutes(final int minutes) {
+ this.minutes = minutes;
+ return this;
+ }
+
+ public PeriodBuilder seconds(final int seconds) {
+ this.seconds = seconds;
+ return this;
+ }
+
+ public PeriodBuilder milliseconds(final int milliseconds) {
+ this.milliseconds = milliseconds;
+ return this;
+ }
+}
Added: trunk/utils/src/test/java/net/objectlab/kit/collections/ImmutableExpiringHashMapTest.java
===================================================================
--- trunk/utils/src/test/java/net/objectlab/kit/collections/ImmutableExpiringHashMapTest.java (rev 0)
+++ trunk/utils/src/test/java/net/objectlab/kit/collections/ImmutableExpiringHashMapTest.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -0,0 +1,228 @@
+/**
+ *
+ */
+package net.objectlab.kit.collections;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author xhensevalb
+ *
+ */
+public class ImmutableExpiringHashMapTest implements MapLoader<String, Integer> {
+
+ private int reloadCount;
+
+ @Before
+ public void reset() {
+ reloadCount = 0;
+ }
+
+ @Test
+ public void basicConstructorNoReload() {
+ final ImmutableExpiringHashMapBuilder<String, Integer> builder = new ImmutableExpiringHashMapBuilder<String, Integer>(this);
+ builder.expiryTimeoutMilliseconds(1000);
+ builder.loadOnFirstAccess(true);
+ builder.reloadOnExpiry(false);
+ builder.reloadWhenExpired(false);
+ builder.id("Greetings");
+
+ final ImmutableExpiringMap<String, Integer> ims = new ImmutableExpiringHashMap<String, Integer>(builder);
+
+ assertEquals("Should not call load until called", 0, reloadCount);
+
+ assertFalse(ims.isEmpty());
+ assertEquals(2, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertTrue("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertEquals(Integer.valueOf(2), ims.get("Yo"));
+ try {
+ Thread.sleep(101);
+ } catch (final InterruptedException e) {
+ }
+
+ // second call
+ assertFalse(ims.isEmpty());
+ assertEquals(2, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertTrue("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertEquals(Integer.valueOf(2), ims.get("Yo"));
+ try {
+ Thread.sleep(901);
+ } catch (final InterruptedException e) {
+ }
+
+ // should be gone
+ assertTrue(ims.isEmpty());
+ assertEquals(0, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertFalse("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertNull(ims.get("Yo"));
+ }
+
+ @Test
+ public void basicConstructorWithReloadWhenCalled() {
+ final ImmutableExpiringHashMapBuilder<String, Integer> builder = new ImmutableExpiringHashMapBuilder<String, Integer>(this);
+ builder.expiryTimeoutMilliseconds(1000);
+ builder.loadOnFirstAccess(true);
+ builder.reloadOnExpiry(false);
+ builder.reloadWhenExpired(true);
+ builder.id("Greetings");
+
+ final ImmutableExpiringMap<String, Integer> ims = new ImmutableExpiringHashMap<String, Integer>(builder);
+
+ assertEquals("Should not call load until called", 0, reloadCount);
+
+ assertFalse(ims.isEmpty());
+ assertEquals(2, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertTrue("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertEquals(Integer.valueOf(2), ims.get("Yo"));
+ try {
+ Thread.sleep(101);
+ } catch (final InterruptedException e) {
+ }
+
+ // second call
+ assertFalse(ims.isEmpty());
+ assertEquals(2, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertTrue("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertEquals(Integer.valueOf(2), ims.get("Yo"));
+ try {
+ Thread.sleep(901);
+ } catch (final InterruptedException e) {
+ }
+
+ assertEquals("2) Should not call load until called", 1, reloadCount);
+
+ // should be gone
+ assertFalse(ims.isEmpty());
+ assertEquals(2, ims.size());
+ assertEquals(2, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertTrue("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertEquals(Integer.valueOf(2), ims.get("Yo"));
+ }
+
+ @Test
+ public void basicConstructorWithImmediateLoadAndWhenExpired() {
+ final ImmutableExpiringHashMapBuilder<String, Integer> builder = new ImmutableExpiringHashMapBuilder<String, Integer>(this);
+ builder.expiryTimeoutMilliseconds(1000);
+ builder.loadOnFirstAccess(false);
+ builder.reloadOnExpiry(false);
+ builder.reloadWhenExpired(true);
+ builder.id("Greetings");
+
+ final ImmutableExpiringMap<String, Integer> ims = new ImmutableExpiringHashMap<String, Integer>(builder);
+
+ assertEquals("Should not call load until called", 1, reloadCount);
+
+ assertFalse(ims.isEmpty());
+ assertEquals(2, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertTrue("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertEquals(Integer.valueOf(2), ims.get("Yo"));
+ try {
+ Thread.sleep(101);
+ } catch (final InterruptedException e) {
+ }
+
+ // second call
+ assertFalse(ims.isEmpty());
+ assertEquals(2, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertTrue("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertEquals(Integer.valueOf(2), ims.get("Yo"));
+ try {
+ Thread.sleep(901);
+ } catch (final InterruptedException e) {
+ }
+
+ assertEquals("2) Should not call load until called", 1, reloadCount);
+
+ // should be gone
+ assertFalse(ims.isEmpty());
+ assertEquals(2, ims.size());
+ assertEquals(2, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertTrue("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertEquals(Integer.valueOf(2), ims.get("Yo"));
+ }
+
+ @Test
+ public void basicConstructorWithReloadOnExpiry() {
+ final ImmutableExpiringHashMapBuilder<String, Integer> builder = new ImmutableExpiringHashMapBuilder<String, Integer>(this);
+ builder.expiryTimeoutMilliseconds(1000);
+ builder.loadOnFirstAccess(false);
+ builder.reloadOnExpiry(true);
+ builder.reloadWhenExpired(false);
+ builder.id("Greetings");
+
+ final ImmutableExpiringMap<String, Integer> ims = new ImmutableExpiringHashMap<String, Integer>(builder);
+
+ assertEquals("Should not call load until called", 1, reloadCount);
+
+ assertFalse(ims.isEmpty());
+ assertEquals(2, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertTrue("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertEquals(Integer.valueOf(2), ims.get("Yo"));
+
+ // second call
+ assertFalse(ims.isEmpty());
+ assertEquals(2, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertTrue("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertEquals(Integer.valueOf(2), ims.get("Yo"));
+ try {
+ Thread.sleep(901);
+ } catch (final InterruptedException e) {
+ }
+
+ assertEquals("2) Should not call load until called", 2, reloadCount);
+
+ // should be gone
+ assertFalse(ims.isEmpty());
+ assertEquals(2, ims.size());
+ assertEquals(2, reloadCount);
+ assertFalse("diff key", ims.containsKey("Hi"));
+ assertTrue("Correct key", ims.containsKey("Hello"));
+ assertNull("diff key", ims.get("Hi"));
+ assertEquals(Integer.valueOf(2), ims.get("Yo"));
+ }
+
+ public void load(final MapBuilder<String, Integer> builder) {
+ assertEquals("Greetings", builder.getId());
+ builder.put("Hello", 1);
+ builder.put("Yo", 2);
+ reloadCount++;
+ }
+
+}
Added: trunk/utils/src/test/java/net/objectlab/kit/collections/ImmutableExpiringHashSetTest.java
===================================================================
--- trunk/utils/src/test/java/net/objectlab/kit/collections/ImmutableExpiringHashSetTest.java (rev 0)
+++ trunk/utils/src/test/java/net/objectlab/kit/collections/ImmutableExpiringHashSetTest.java 2010-11-20 22:49:07 UTC (rev 376)
@@ -0,0 +1,206 @@
+/**
+ *
+ */
+package net.objectlab.kit.collections;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author xhensevalb
+ *
+ */
+public class ImmutableExpiringHashSetTest implements SetLoader<String> {
+
+ private int reloadCount;
+
+ @Before
+ public void reset() {
+ reloadCount = 0;
+ }
+
+ @Test
+ public void basicConstructorNoReload() {
+ final ImmutableExpiringHashSetBuilder<String> builder = new ImmutableExpiringHashSetBuilder<String>(this);
+ builder.expiryTimeoutMilliseconds(1000);
+ builder.loadOnFirstAccess(true);
+ builder.reloadOnExpiry(false);
+ builder.reloadWhenExpired(false);
+ builder.id("Greetings");
+
+ final ImmutableExpiringSet<String> ims = new ImmutableExpiringHashSet<String>(builder);
+
+ assertEquals("Should not call load until called", 0, reloadCount);
+
+ assertFalse(ims.isEmpty());
+ assertEquals(1, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.contains("Hi"));
+ assertTrue("Correct key", ims.contains("Hello"));
+ try {
+ Thread.sleep(101);
+ } catch (final InterruptedException e) {
+ }
+
+ // second call
+ assertFalse(ims.isEmpty());
+ assertEquals(1, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.contains("Hi"));
+ assertTrue("Correct key", ims.contains("Hello"));
+ try {
+ Thread.sleep(901);
+ } catch (final InterruptedException e) {
+ }
+
+ // should be gone
+ assertTrue(ims.isEmpty());
+ assertEquals(0, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.contains("Hi"));
+ assertFalse("Correct key", ims.contains("Hello"));
+ }
+
+ @Test
+ public void basicConstructorWithReloadWhenCalled() {
+ final ImmutableExpiringHashSetBuilder<String> builder = new ImmutableExpiringHashSetBuilder<String>(this);
+ builder.expiryTimeoutMilliseconds(1000);
+ builder.loadOnFirstAccess(true);
+ builder.reloadOnExpiry(false);
+ builder.reloadWhenExpired(true);
+ builder.id("Greetings");
+
+ final ImmutableExpiringSet<String> ims = new ImmutableExpiringHashSet<String>(builder);
+
+ assertEquals("Should not call load until called", 0, reloadCount);
+
+ assertFalse(ims.isEmpty());
+ assertEquals(1, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.contains("Hi"));
+ assertTrue("Correct key", ims.contains("Hello"));
+ try {
+ Thread.sleep(101);
+ } catch (final InterruptedException e) {
+ }
+
+ // second call
+ assertFalse(ims.isEmpty());
+ assertEquals(1, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.contains("Hi"));
+ assertTrue("Correct key", ims.contains("Hello"));
+ try {
+ Thread.sleep(901);
+ } catch (final InterruptedException e) {
+ }
+
+ assertEquals("Should NOT have reloaded until called!", 1, reloadCount);
+
+ // should be gone
+ assertFalse(ims.isEmpty());
+ assertEquals("Now it should have called the reload", 2, reloadCount);
+ assertEquals(1, ims.size());
+ assertFalse("diff key", ims.contains("Hi"));
+ assertTrue("Correct key", ims.contains("Hello"));
+ }
+
+ @Test
+ public void basicConstructorWithImmediateLoadAndWhenExpired() {
+ final ImmutableExpiringHashSetBuilder<String> builder = new ImmutableExpiringHashSetBuilder<String>(this);
+ builder.expiryTimeoutMilliseconds(1000);
+ builder.loadOnFirstAccess(false);
+ builder.reloadOnExpiry(false);
+ builder.reloadWhenExpired(true);
+ builder.id("Greetings");
+
+ final ImmutableExpiringSet<String> ims = new ImmutableExpiringHashSet<String>(builder);
+
+ assertEquals("Should call load immediately", 1, reloadCount);
+
+ assertFalse(ims.isEmpty());
+ assertEquals(1, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.contains("Hi"));
+ assertTrue("Correct key", ims.contains("Hello"));
+ try {
+ Thread.sleep(101);
+ } catch (final InterruptedException e) {
+ }
+
+ // second call
+ assertFalse(ims.isEmpty());
+ assertEquals(1, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.contains("Hi"));
+ assertTrue("Correct key", ims.contains("Hello"));
+ try {
+ Thread.sleep(901);
+ } catch (final InterruptedException e) {
+ }
+
+ assertEquals("Should NOT have reloaded until called!", 1, reloadCount);
+
+ // should be gone
+ assertFalse(ims.isEmpty());
+ assertEquals("Now it should have called the reload", 2, reloadCount);
+ assertEquals(1, ims.size());
+ assertFalse("diff key", ims.contains("Hi"));
+ assertTrue("Correct key", ims.contains("Hello"));
+ }
+
+ @Test
+ public void basicConstructorWithReloadOnExpiry() {
+ final ImmutableExpiringHashSetBuilder<String> builder = new ImmutableExpiringHashSetBuilder<String>(this);
+ builder.expiryTimeoutMilliseconds(1000);
+ builder.loadOnFirstAccess(false);
+ builder.reloadOnExpiry(true);
+ builder.reloadWhenExpired(false); // but does not matter
+ builder.id("Greetings");
+
+ final ImmutableExpiringSet<String> ims = new ImmutableExpiringHashSet<String>(builder);
+
+ assertEquals("Should have called load immediately", 1, reloadCount);
+
+ assertFalse(ims.isEmpty());
+ assertEquals(1, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.contains("Hi"));
+ assertTrue("Correct key", ims.contains("Hello"));
+ // try {
+ // Thread.sleep(101);
+ // } catch (final InterruptedException e) {
+ // }
+
+ // second call
+ assertFalse(ims.isEmpty());
+ assertEquals(1, ims.size());
+ assertEquals(1, reloadCount);
+ assertFalse("diff key", ims.contains("Hi"));
+ assertTrue("Correct key", ims.contains("Hello"));
+ try {
+ Thread.sleep(901);
+ } catch (final InterruptedException e) {
+ }
+
+ assertEquals("Should have reloaded until called!", 2, reloadCount);
+
+ // should be gone
+ assertFalse(ims.isEmpty());
+ assertEquals("Now it should have called the reload", 2, reloadCount);
+ assertEquals(1, ims.size());
+ assertFalse("diff key", ims.contains("Hi"));
+ assertTrue("Correct key", ims.contains("Hello"));
+ }
+
+ public void load(final SetBuilder<String> builder) {
+ assertEquals("Greetings", builder.getId());
+ builder.add("Hello");
+ reloadCount++;
+ }
+
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
