You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2017/10/31 14:41:50 UTC
commons-pool git commit: [POOL-332] ObjectPool and KeyedObject pool
should extend Closeable. Start cleaning up tests by managing pools with
try-with-resource blocks. More to do. Any help appreciated. 'mvn clean
verify' passes.
Repository: commons-pool
Updated Branches:
refs/heads/master c686a9e1d -> 462c3f940
[POOL-332] ObjectPool and KeyedObject pool should extend Closeable.
Start cleaning up tests by managing pools with try-with-resource blocks.
More to do. Any help appreciated. 'mvn clean verify' passes.
Project: http://git-wip-us.apache.org/repos/asf/commons-pool/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-pool/commit/462c3f94
Tree: http://git-wip-us.apache.org/repos/asf/commons-pool/tree/462c3f94
Diff: http://git-wip-us.apache.org/repos/asf/commons-pool/diff/462c3f94
Branch: refs/heads/master
Commit: 462c3f940f8097618b310bb52548fca8f82362ff
Parents: c686a9e
Author: Gary Gregory <gg...@apache.org>
Authored: Tue Oct 31 08:41:47 2017 -0600
Committer: Gary Gregory <gg...@apache.org>
Committed: Tue Oct 31 08:41:47 2017 -0600
----------------------------------------------------------------------
.../pool2/impl/TestGenericKeyedObjectPool.java | 839 +++++++++----------
.../pool2/impl/TestGenericObjectPool.java | 415 +++++----
2 files changed, 613 insertions(+), 641 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-pool/blob/462c3f94/src/test/java/org/apache/commons/pool2/impl/TestGenericKeyedObjectPool.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/pool2/impl/TestGenericKeyedObjectPool.java b/src/test/java/org/apache/commons/pool2/impl/TestGenericKeyedObjectPool.java
index 4aef60b..97e9587 100644
--- a/src/test/java/org/apache/commons/pool2/impl/TestGenericKeyedObjectPool.java
+++ b/src/test/java/org/apache/commons/pool2/impl/TestGenericKeyedObjectPool.java
@@ -426,15 +426,21 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
config.setTimeBetweenEvictionRunsMillis(500);
config.setMinEvictableIdleTimeMillis(50);
config.setNumTestsPerEvictionRun(5);
- final GenericKeyedObjectPool<String, String> p = new GenericKeyedObjectPool<>(factory, config);
- for(int i=0;i<5;i++) {
- p.addObject("one");
+ try (final GenericKeyedObjectPool<String, String> p = new GenericKeyedObjectPool<>(factory, config)) {
+ for (int i = 0; i < 5; i++) {
+ p.addObject("one");
+ }
+ try {
+ Thread.sleep(100);
+ } catch (final InterruptedException e) {
+ }
+ assertEquals(5, p.getNumIdle("one"));
+ try {
+ Thread.sleep(500);
+ } catch (final InterruptedException e) {
+ }
+ assertEquals(0, p.getNumIdle("one"));
}
- try { Thread.sleep(100); } catch(final InterruptedException e) { }
- assertEquals(5, p.getNumIdle("one"));
- try { Thread.sleep(500); } catch(final InterruptedException e) { }
- assertEquals(0, p.getNumIdle("one"));
- p.close();
}
@@ -761,115 +767,113 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
private void checkEvictionOrder(final boolean lifo) throws Exception {
final SimpleFactory<Integer> intFactory = new SimpleFactory<>();
- final GenericKeyedObjectPool<Integer,String> intPool =
- new GenericKeyedObjectPool<>(intFactory);
- intPool.setNumTestsPerEvictionRun(2);
- intPool.setMinEvictableIdleTimeMillis(100);
- intPool.setLifo(lifo);
-
- for (int i = 0; i < 3; i ++) {
- final Integer key = Integer.valueOf(i);
- for (int j = 0; j < 5; j++) {
- intPool.addObject(key);
+ try (final GenericKeyedObjectPool<Integer, String> intPool = new GenericKeyedObjectPool<>(intFactory)) {
+ intPool.setNumTestsPerEvictionRun(2);
+ intPool.setMinEvictableIdleTimeMillis(100);
+ intPool.setLifo(lifo);
+
+ for (int i = 0; i < 3; i++) {
+ final Integer key = Integer.valueOf(i);
+ for (int j = 0; j < 5; j++) {
+ intPool.addObject(key);
+ }
}
- }
- // Make all evictable
- Thread.sleep(200);
+ // Make all evictable
+ Thread.sleep(200);
- /*
- * Initial state (Key, Object) pairs in order of age:
- *
- * (0,0), (0,1), (0,2), (0,3), (0,4)
- * (1,5), (1,6), (1,7), (1,8), (1,9)
- * (2,10), (2,11), (2,12), (2,13), (2,14)
- */
-
- intPool.evict(); // Kill (0,0),(0,1)
- assertEquals(3, intPool.getNumIdle(KEY_ZERO));
- final String objZeroA = intPool.borrowObject(KEY_ZERO);
- assertTrue(lifo ? objZeroA.equals("04") : objZeroA.equals("02"));
- assertEquals(2, intPool.getNumIdle(KEY_ZERO));
- final String objZeroB = intPool.borrowObject(KEY_ZERO);
- assertTrue(objZeroB.equals("03"));
- assertEquals(1, intPool.getNumIdle(KEY_ZERO));
-
- intPool.evict(); // Kill remaining 0 survivor and (1,5)
- assertEquals(0, intPool.getNumIdle(KEY_ZERO));
- assertEquals(4, intPool.getNumIdle(KEY_ONE));
- final String objOneA = intPool.borrowObject(KEY_ONE);
- assertTrue(lifo ? objOneA.equals("19") : objOneA.equals("16"));
- assertEquals(3, intPool.getNumIdle(KEY_ONE));
- final String objOneB = intPool.borrowObject(KEY_ONE);
- assertTrue(lifo ? objOneB.equals("18") : objOneB.equals("17"));
- assertEquals(2, intPool.getNumIdle(KEY_ONE));
-
- intPool.evict(); // Kill remaining 1 survivors
- assertEquals(0, intPool.getNumIdle(KEY_ONE));
- intPool.evict(); // Kill (2,10), (2,11)
- assertEquals(3, intPool.getNumIdle(KEY_TWO));
- final String objTwoA = intPool.borrowObject(KEY_TWO);
- assertTrue(lifo ? objTwoA.equals("214") : objTwoA.equals("212"));
- assertEquals(2, intPool.getNumIdle(KEY_TWO));
- intPool.evict(); // All dead now
- assertEquals(0, intPool.getNumIdle(KEY_TWO));
-
- intPool.evict(); // Should do nothing - make sure no exception
- // Currently 2 zero, 2 one and 1 two active. Return them
- intPool.returnObject(KEY_ZERO, objZeroA);
- intPool.returnObject(KEY_ZERO, objZeroB);
- intPool.returnObject(KEY_ONE, objOneA);
- intPool.returnObject(KEY_ONE, objOneB);
- intPool.returnObject(KEY_TWO, objTwoA);
- // Remove all idle objects
- intPool.clear();
-
- // Reload
- intPool.setMinEvictableIdleTimeMillis(500);
- intFactory.counter = 0; // Reset counter
- for (int i = 0; i < 3; i ++) {
- final Integer key = Integer.valueOf(i);
- for (int j = 0; j < 5; j++) {
- intPool.addObject(key);
+ /*
+ * Initial state (Key, Object) pairs in order of age:
+ *
+ * (0,0), (0,1), (0,2), (0,3), (0,4) (1,5), (1,6), (1,7), (1,8), (1,9) (2,10), (2,11), (2,12), (2,13),
+ * (2,14)
+ */
+
+ intPool.evict(); // Kill (0,0),(0,1)
+ assertEquals(3, intPool.getNumIdle(KEY_ZERO));
+ final String objZeroA = intPool.borrowObject(KEY_ZERO);
+ assertTrue(lifo ? objZeroA.equals("04") : objZeroA.equals("02"));
+ assertEquals(2, intPool.getNumIdle(KEY_ZERO));
+ final String objZeroB = intPool.borrowObject(KEY_ZERO);
+ assertTrue(objZeroB.equals("03"));
+ assertEquals(1, intPool.getNumIdle(KEY_ZERO));
+
+ intPool.evict(); // Kill remaining 0 survivor and (1,5)
+ assertEquals(0, intPool.getNumIdle(KEY_ZERO));
+ assertEquals(4, intPool.getNumIdle(KEY_ONE));
+ final String objOneA = intPool.borrowObject(KEY_ONE);
+ assertTrue(lifo ? objOneA.equals("19") : objOneA.equals("16"));
+ assertEquals(3, intPool.getNumIdle(KEY_ONE));
+ final String objOneB = intPool.borrowObject(KEY_ONE);
+ assertTrue(lifo ? objOneB.equals("18") : objOneB.equals("17"));
+ assertEquals(2, intPool.getNumIdle(KEY_ONE));
+
+ intPool.evict(); // Kill remaining 1 survivors
+ assertEquals(0, intPool.getNumIdle(KEY_ONE));
+ intPool.evict(); // Kill (2,10), (2,11)
+ assertEquals(3, intPool.getNumIdle(KEY_TWO));
+ final String objTwoA = intPool.borrowObject(KEY_TWO);
+ assertTrue(lifo ? objTwoA.equals("214") : objTwoA.equals("212"));
+ assertEquals(2, intPool.getNumIdle(KEY_TWO));
+ intPool.evict(); // All dead now
+ assertEquals(0, intPool.getNumIdle(KEY_TWO));
+
+ intPool.evict(); // Should do nothing - make sure no exception
+ // Currently 2 zero, 2 one and 1 two active. Return them
+ intPool.returnObject(KEY_ZERO, objZeroA);
+ intPool.returnObject(KEY_ZERO, objZeroB);
+ intPool.returnObject(KEY_ONE, objOneA);
+ intPool.returnObject(KEY_ONE, objOneB);
+ intPool.returnObject(KEY_TWO, objTwoA);
+ // Remove all idle objects
+ intPool.clear();
+
+ // Reload
+ intPool.setMinEvictableIdleTimeMillis(500);
+ intFactory.counter = 0; // Reset counter
+ for (int i = 0; i < 3; i++) {
+ final Integer key = Integer.valueOf(i);
+ for (int j = 0; j < 5; j++) {
+ intPool.addObject(key);
+ }
+ Thread.sleep(200);
}
- Thread.sleep(200);
- }
- // 0's are evictable, others not
- intPool.evict(); // Kill (0,0),(0,1)
- assertEquals(3, intPool.getNumIdle(KEY_ZERO));
- intPool.evict(); // Kill (0,2),(0,3)
- assertEquals(1, intPool.getNumIdle(KEY_ZERO));
- intPool.evict(); // Kill (0,4), leave (1,5)
- assertEquals(0, intPool.getNumIdle(KEY_ZERO));
- assertEquals(5, intPool.getNumIdle(KEY_ONE));
- assertEquals(5, intPool.getNumIdle(KEY_TWO));
- intPool.evict(); // (1,6), (1,7)
- assertEquals(5, intPool.getNumIdle(KEY_ONE));
- assertEquals(5, intPool.getNumIdle(KEY_TWO));
- intPool.evict(); // (1,8), (1,9)
- assertEquals(5, intPool.getNumIdle(KEY_ONE));
- assertEquals(5, intPool.getNumIdle(KEY_TWO));
- intPool.evict(); // (2,10), (2,11)
- assertEquals(5, intPool.getNumIdle(KEY_ONE));
- assertEquals(5, intPool.getNumIdle(KEY_TWO));
- intPool.evict(); // (2,12), (2,13)
- assertEquals(5, intPool.getNumIdle(KEY_ONE));
- assertEquals(5, intPool.getNumIdle(KEY_TWO));
- intPool.evict(); // (2,14), (1,5)
- assertEquals(5, intPool.getNumIdle(KEY_ONE));
- assertEquals(5, intPool.getNumIdle(KEY_TWO));
- Thread.sleep(200); // Ones now timed out
- intPool.evict(); // kill (1,6), (1,7) - (1,5) missed
- assertEquals(3, intPool.getNumIdle(KEY_ONE));
- assertEquals(5, intPool.getNumIdle(KEY_TWO));
- final String obj = intPool.borrowObject(KEY_ONE);
- if (lifo) {
- assertEquals("19", obj);
- } else {
- assertEquals("15", obj);
- }
- intPool.close();
+ // 0's are evictable, others not
+ intPool.evict(); // Kill (0,0),(0,1)
+ assertEquals(3, intPool.getNumIdle(KEY_ZERO));
+ intPool.evict(); // Kill (0,2),(0,3)
+ assertEquals(1, intPool.getNumIdle(KEY_ZERO));
+ intPool.evict(); // Kill (0,4), leave (1,5)
+ assertEquals(0, intPool.getNumIdle(KEY_ZERO));
+ assertEquals(5, intPool.getNumIdle(KEY_ONE));
+ assertEquals(5, intPool.getNumIdle(KEY_TWO));
+ intPool.evict(); // (1,6), (1,7)
+ assertEquals(5, intPool.getNumIdle(KEY_ONE));
+ assertEquals(5, intPool.getNumIdle(KEY_TWO));
+ intPool.evict(); // (1,8), (1,9)
+ assertEquals(5, intPool.getNumIdle(KEY_ONE));
+ assertEquals(5, intPool.getNumIdle(KEY_TWO));
+ intPool.evict(); // (2,10), (2,11)
+ assertEquals(5, intPool.getNumIdle(KEY_ONE));
+ assertEquals(5, intPool.getNumIdle(KEY_TWO));
+ intPool.evict(); // (2,12), (2,13)
+ assertEquals(5, intPool.getNumIdle(KEY_ONE));
+ assertEquals(5, intPool.getNumIdle(KEY_TWO));
+ intPool.evict(); // (2,14), (1,5)
+ assertEquals(5, intPool.getNumIdle(KEY_ONE));
+ assertEquals(5, intPool.getNumIdle(KEY_TWO));
+ Thread.sleep(200); // Ones now timed out
+ intPool.evict(); // kill (1,6), (1,7) - (1,5) missed
+ assertEquals(3, intPool.getNumIdle(KEY_ONE));
+ assertEquals(5, intPool.getNumIdle(KEY_TWO));
+ final String obj = intPool.borrowObject(KEY_ONE);
+ if (lifo) {
+ assertEquals("19", obj);
+ } else {
+ assertEquals("15", obj);
+ }
+ }
}
@@ -887,88 +891,83 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
private void checkEvictorVisiting(final boolean lifo) throws Exception {
VisitTrackerFactory<Integer> trackerFactory = new VisitTrackerFactory<>();
- GenericKeyedObjectPool<Integer,VisitTracker<Integer>> intPool =
- new GenericKeyedObjectPool<>(trackerFactory);
- intPool.setNumTestsPerEvictionRun(2);
- intPool.setMinEvictableIdleTimeMillis(-1);
- intPool.setTestWhileIdle(true);
- intPool.setLifo(lifo);
- intPool.setTestOnReturn(false);
- intPool.setTestOnBorrow(false);
- for (int i = 0; i < 3; i ++) {
- trackerFactory.resetId();
- final Integer key = Integer.valueOf(i);
- for (int j = 0; j < 8; j++) {
- intPool.addObject(key);
+ try (GenericKeyedObjectPool<Integer, VisitTracker<Integer>> intPool = new GenericKeyedObjectPool<>(
+ trackerFactory)) {
+ intPool.setNumTestsPerEvictionRun(2);
+ intPool.setMinEvictableIdleTimeMillis(-1);
+ intPool.setTestWhileIdle(true);
+ intPool.setLifo(lifo);
+ intPool.setTestOnReturn(false);
+ intPool.setTestOnBorrow(false);
+ for (int i = 0; i < 3; i++) {
+ trackerFactory.resetId();
+ final Integer key = Integer.valueOf(i);
+ for (int j = 0; j < 8; j++) {
+ intPool.addObject(key);
+ }
}
- }
- intPool.evict(); // Visit oldest 2 - 00 and 01
- VisitTracker<Integer> obj = intPool.borrowObject(KEY_ZERO);
- intPool.returnObject(KEY_ZERO, obj);
- obj = intPool.borrowObject(KEY_ZERO);
- intPool.returnObject(KEY_ZERO, obj);
- // borrow, return, borrow, return
- // FIFO will move 0 and 1 to end - 2,3,4,5,6,7,0,1
- // LIFO, 7 out, then in, then out, then in - 7,6,5,4,3,2,1,0
- intPool.evict(); // Should visit 02 and 03 in either case
- for (int i = 0; i < 8; i++) {
- final VisitTracker<Integer> tracker = intPool.borrowObject(KEY_ZERO);
- if (tracker.getId() >= 4) {
- assertEquals("Unexpected instance visited " + tracker.getId(),
- 0, tracker.getValidateCount());
- } else {
- assertEquals("Instance " + tracker.getId() +
- " visited wrong number of times.",
- 1, tracker.getValidateCount());
+ intPool.evict(); // Visit oldest 2 - 00 and 01
+ VisitTracker<Integer> obj = intPool.borrowObject(KEY_ZERO);
+ intPool.returnObject(KEY_ZERO, obj);
+ obj = intPool.borrowObject(KEY_ZERO);
+ intPool.returnObject(KEY_ZERO, obj);
+ // borrow, return, borrow, return
+ // FIFO will move 0 and 1 to end - 2,3,4,5,6,7,0,1
+ // LIFO, 7 out, then in, then out, then in - 7,6,5,4,3,2,1,0
+ intPool.evict(); // Should visit 02 and 03 in either case
+ for (int i = 0; i < 8; i++) {
+ final VisitTracker<Integer> tracker = intPool.borrowObject(KEY_ZERO);
+ if (tracker.getId() >= 4) {
+ assertEquals("Unexpected instance visited " + tracker.getId(), 0, tracker.getValidateCount());
+ } else {
+ assertEquals("Instance " + tracker.getId() + " visited wrong number of times.", 1,
+ tracker.getValidateCount());
+ }
}
- }
- // 0's are all out
-
- intPool.setNumTestsPerEvictionRun(3);
-
- intPool.evict(); // 10, 11, 12
- intPool.evict(); // 13, 14, 15
-
- obj = intPool.borrowObject(KEY_ONE);
- intPool.returnObject(KEY_ONE, obj);
- obj = intPool.borrowObject(KEY_ONE);
- intPool.returnObject(KEY_ONE, obj);
- obj = intPool.borrowObject(KEY_ONE);
- intPool.returnObject(KEY_ONE, obj);
- // borrow, return, borrow, return
- // FIFO 3,4,5,^,6,7,0,1,2
- // LIFO 7,6,^,5,4,3,2,1,0
- // In either case, pointer should be at 6
- intPool.evict();
- // LIFO - 16, 17, 20
- // FIFO - 16, 17, 10
- intPool.evict();
- // LIFO - 21, 22, 23
- // FIFO - 11, 12, 20
- intPool.evict();
- // LIFO - 24, 25, 26
- // FIFO - 21, 22, 23
- intPool.evict();
- // LIFO - 27, 10, 11
- // FIFO - 24, 25, 26
- for (int i = 0; i < 8; i++) {
- final VisitTracker<Integer> tracker = intPool.borrowObject(KEY_ONE);
- if ((lifo && tracker.getId() > 1) ||
- (!lifo && tracker.getId() > 2)) {
- assertEquals("Instance " + tracker.getId() +
- " visited wrong number of times.",
- 1, tracker.getValidateCount());
- } else {
- assertEquals("Instance " + tracker.getId() +
- " visited wrong number of times.",
- 2, tracker.getValidateCount());
+ // 0's are all out
+
+ intPool.setNumTestsPerEvictionRun(3);
+
+ intPool.evict(); // 10, 11, 12
+ intPool.evict(); // 13, 14, 15
+
+ obj = intPool.borrowObject(KEY_ONE);
+ intPool.returnObject(KEY_ONE, obj);
+ obj = intPool.borrowObject(KEY_ONE);
+ intPool.returnObject(KEY_ONE, obj);
+ obj = intPool.borrowObject(KEY_ONE);
+ intPool.returnObject(KEY_ONE, obj);
+ // borrow, return, borrow, return
+ // FIFO 3,4,5,^,6,7,0,1,2
+ // LIFO 7,6,^,5,4,3,2,1,0
+ // In either case, pointer should be at 6
+ intPool.evict();
+ // LIFO - 16, 17, 20
+ // FIFO - 16, 17, 10
+ intPool.evict();
+ // LIFO - 21, 22, 23
+ // FIFO - 11, 12, 20
+ intPool.evict();
+ // LIFO - 24, 25, 26
+ // FIFO - 21, 22, 23
+ intPool.evict();
+ // LIFO - 27, 10, 11
+ // FIFO - 24, 25, 26
+ for (int i = 0; i < 8; i++) {
+ final VisitTracker<Integer> tracker = intPool.borrowObject(KEY_ONE);
+ if ((lifo && tracker.getId() > 1) || (!lifo && tracker.getId() > 2)) {
+ assertEquals("Instance " + tracker.getId() + " visited wrong number of times.", 1,
+ tracker.getValidateCount());
+ } else {
+ assertEquals("Instance " + tracker.getId() + " visited wrong number of times.", 2,
+ tracker.getValidateCount());
+ }
}
}
- intPool.close();
// Randomly generate some pools with random numTests
// and make sure evictor cycles through elements appropriately
- final int[] smallPrimes = {2, 3, 5, 7};
+ final int[] smallPrimes = { 2, 3, 5, 7 };
final Random random = new Random();
random.setSeed(System.currentTimeMillis());
for (int i = 0; i < smallPrimes.length; i++) {
@@ -976,80 +975,80 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
// Can't use clear as some objects are still active so create
// a new pool
trackerFactory = new VisitTrackerFactory<>();
- intPool = new GenericKeyedObjectPool<>(trackerFactory);
- intPool.setMaxIdlePerKey(-1);
- intPool.setMaxTotalPerKey(-1);
- intPool.setNumTestsPerEvictionRun(smallPrimes[i]);
- intPool.setMinEvictableIdleTimeMillis(-1);
- intPool.setTestWhileIdle(true);
- intPool.setLifo(lifo);
- intPool.setTestOnReturn(false);
- intPool.setTestOnBorrow(false);
-
- final int zeroLength = 10 + random.nextInt(20);
- for (int k = 0; k < zeroLength; k++) {
- intPool.addObject(KEY_ZERO);
- }
- final int oneLength = 10 + random.nextInt(20);
- for (int k = 0; k < oneLength; k++) {
- intPool.addObject(KEY_ONE);
- }
- final int twoLength = 10 + random.nextInt(20);
- for (int k = 0; k < twoLength; k++) {
- intPool.addObject(KEY_TWO);
- }
+ try (GenericKeyedObjectPool<Integer, VisitTracker<Integer>> intPool = new GenericKeyedObjectPool<>(
+ trackerFactory)) {
+ intPool.setMaxIdlePerKey(-1);
+ intPool.setMaxTotalPerKey(-1);
+ intPool.setNumTestsPerEvictionRun(smallPrimes[i]);
+ intPool.setMinEvictableIdleTimeMillis(-1);
+ intPool.setTestWhileIdle(true);
+ intPool.setLifo(lifo);
+ intPool.setTestOnReturn(false);
+ intPool.setTestOnBorrow(false);
+
+ final int zeroLength = 10 + random.nextInt(20);
+ for (int k = 0; k < zeroLength; k++) {
+ intPool.addObject(KEY_ZERO);
+ }
+ final int oneLength = 10 + random.nextInt(20);
+ for (int k = 0; k < oneLength; k++) {
+ intPool.addObject(KEY_ONE);
+ }
+ final int twoLength = 10 + random.nextInt(20);
+ for (int k = 0; k < twoLength; k++) {
+ intPool.addObject(KEY_TWO);
+ }
- // Choose a random number of evictor runs
- final int runs = 10 + random.nextInt(50);
- for (int k = 0; k < runs; k++) {
- intPool.evict();
- }
+ // Choose a random number of evictor runs
+ final int runs = 10 + random.nextInt(50);
+ for (int k = 0; k < runs; k++) {
+ intPool.evict();
+ }
- // Total instances in pool
- final int totalInstances = zeroLength + oneLength + twoLength;
-
- // Number of times evictor should have cycled through pools
- final int cycleCount = (runs * intPool.getNumTestsPerEvictionRun()) /
- totalInstances;
-
- // Look at elements and make sure they are visited cycleCount
- // or cycleCount + 1 times
- VisitTracker<Integer> tracker = null;
- int visitCount = 0;
- for (int k = 0; k < zeroLength; k++) {
- tracker = intPool.borrowObject(KEY_ZERO);
- visitCount = tracker.getValidateCount();
- if (visitCount < cycleCount || visitCount > cycleCount + 1){
- fail(formatSettings("ZERO", "runs", runs, "lifo", lifo, "i", i, "j", j,
- "k", k, "visitCount", visitCount, "cycleCount", cycleCount,
- "totalInstances", totalInstances, zeroLength, oneLength, twoLength));
+ // Total instances in pool
+ final int totalInstances = zeroLength + oneLength + twoLength;
+
+ // Number of times evictor should have cycled through pools
+ final int cycleCount = (runs * intPool.getNumTestsPerEvictionRun()) / totalInstances;
+
+ // Look at elements and make sure they are visited cycleCount
+ // or cycleCount + 1 times
+ VisitTracker<Integer> tracker = null;
+ int visitCount = 0;
+ for (int k = 0; k < zeroLength; k++) {
+ tracker = intPool.borrowObject(KEY_ZERO);
+ visitCount = tracker.getValidateCount();
+ if (visitCount < cycleCount || visitCount > cycleCount + 1) {
+ fail(formatSettings("ZERO", "runs", runs, "lifo", lifo, "i", i, "j", j, "k", k,
+ "visitCount", visitCount, "cycleCount", cycleCount, "totalInstances",
+ totalInstances, zeroLength, oneLength, twoLength));
+ }
}
- }
- for (int k = 0; k < oneLength; k++) {
- tracker = intPool.borrowObject(KEY_ONE);
- visitCount = tracker.getValidateCount();
- if (visitCount < cycleCount || visitCount > cycleCount + 1){
- fail(formatSettings("ONE", "runs", runs, "lifo", lifo, "i", i, "j", j,
- "k", k, "visitCount", visitCount, "cycleCount", cycleCount,
- "totalInstances", totalInstances, zeroLength, oneLength, twoLength));
+ for (int k = 0; k < oneLength; k++) {
+ tracker = intPool.borrowObject(KEY_ONE);
+ visitCount = tracker.getValidateCount();
+ if (visitCount < cycleCount || visitCount > cycleCount + 1) {
+ fail(formatSettings("ONE", "runs", runs, "lifo", lifo, "i", i, "j", j, "k", k, "visitCount",
+ visitCount, "cycleCount", cycleCount, "totalInstances", totalInstances, zeroLength,
+ oneLength, twoLength));
+ }
}
- }
- final int visits[] = new int[twoLength];
- for (int k = 0; k < twoLength; k++) {
- tracker = intPool.borrowObject(KEY_TWO);
- visitCount = tracker.getValidateCount();
- visits[k] = visitCount;
- if (visitCount < cycleCount || visitCount > cycleCount + 1){
- final StringBuilder sb = new StringBuilder("Visits:");
- for (int l = 0; l <= k; l++){
- sb.append(visits[l]).append(' ');
+ final int visits[] = new int[twoLength];
+ for (int k = 0; k < twoLength; k++) {
+ tracker = intPool.borrowObject(KEY_TWO);
+ visitCount = tracker.getValidateCount();
+ visits[k] = visitCount;
+ if (visitCount < cycleCount || visitCount > cycleCount + 1) {
+ final StringBuilder sb = new StringBuilder("Visits:");
+ for (int l = 0; l <= k; l++) {
+ sb.append(visits[l]).append(' ');
+ }
+ fail(formatSettings("TWO " + sb.toString(), "runs", runs, "lifo", lifo, "i", i, "j", j, "k",
+ k, "visitCount", visitCount, "cycleCount", cycleCount, "totalInstances",
+ totalInstances, zeroLength, oneLength, twoLength));
}
- fail(formatSettings("TWO "+sb.toString(), "runs", runs, "lifo", lifo, "i", i, "j", j,
- "k", k, "visitCount", visitCount, "cycleCount", cycleCount,
- "totalInstances", totalInstances, zeroLength, oneLength, twoLength));
}
}
- intPool.close();
}
}
}
@@ -1133,35 +1132,31 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
final long timeBetweenEvictionRunsMillis = 8;
final boolean blockWhenExhausted = false;
final boolean lifo = false;
- final KeyedPooledObjectFactory<Object,Object> dummyFactory = new DummyFactory();
-
- GenericKeyedObjectPool<Object,Object> objPool =
- new GenericKeyedObjectPool<>(dummyFactory);
- assertEquals(GenericKeyedObjectPoolConfig.DEFAULT_MAX_TOTAL_PER_KEY, objPool.getMaxTotalPerKey());
- assertEquals(GenericKeyedObjectPoolConfig.DEFAULT_MAX_IDLE_PER_KEY, objPool.getMaxIdlePerKey());
- assertEquals(BaseObjectPoolConfig.DEFAULT_MAX_WAIT_MILLIS, objPool.getMaxWaitMillis());
- assertEquals(GenericKeyedObjectPoolConfig.DEFAULT_MIN_IDLE_PER_KEY, objPool.getMinIdlePerKey());
- assertEquals(GenericKeyedObjectPoolConfig.DEFAULT_MAX_TOTAL, objPool.getMaxTotal());
- assertEquals(BaseObjectPoolConfig.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
- objPool.getMinEvictableIdleTimeMillis());
- assertEquals(BaseObjectPoolConfig.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
- objPool.getNumTestsPerEvictionRun());
- assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_ON_BORROW),
- Boolean.valueOf(objPool.getTestOnBorrow()));
- assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_ON_RETURN),
- Boolean.valueOf(objPool.getTestOnReturn()));
- assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_WHILE_IDLE),
- Boolean.valueOf(objPool.getTestWhileIdle()));
- assertEquals(BaseObjectPoolConfig.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
- objPool.getTimeBetweenEvictionRunsMillis());
- assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_BLOCK_WHEN_EXHAUSTED),
- Boolean.valueOf(objPool.getBlockWhenExhausted()));
- assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_LIFO),
- Boolean.valueOf(objPool.getLifo()));
- objPool.close();
-
- final GenericKeyedObjectPoolConfig config =
- new GenericKeyedObjectPoolConfig();
+ final KeyedPooledObjectFactory<Object, Object> dummyFactory = new DummyFactory();
+
+ try (GenericKeyedObjectPool<Object, Object> objPool = new GenericKeyedObjectPool<>(dummyFactory)) {
+ assertEquals(GenericKeyedObjectPoolConfig.DEFAULT_MAX_TOTAL_PER_KEY, objPool.getMaxTotalPerKey());
+ assertEquals(GenericKeyedObjectPoolConfig.DEFAULT_MAX_IDLE_PER_KEY, objPool.getMaxIdlePerKey());
+ assertEquals(BaseObjectPoolConfig.DEFAULT_MAX_WAIT_MILLIS, objPool.getMaxWaitMillis());
+ assertEquals(GenericKeyedObjectPoolConfig.DEFAULT_MIN_IDLE_PER_KEY, objPool.getMinIdlePerKey());
+ assertEquals(GenericKeyedObjectPoolConfig.DEFAULT_MAX_TOTAL, objPool.getMaxTotal());
+ assertEquals(BaseObjectPoolConfig.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
+ objPool.getMinEvictableIdleTimeMillis());
+ assertEquals(BaseObjectPoolConfig.DEFAULT_NUM_TESTS_PER_EVICTION_RUN, objPool.getNumTestsPerEvictionRun());
+ assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_ON_BORROW),
+ Boolean.valueOf(objPool.getTestOnBorrow()));
+ assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_ON_RETURN),
+ Boolean.valueOf(objPool.getTestOnReturn()));
+ assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_WHILE_IDLE),
+ Boolean.valueOf(objPool.getTestWhileIdle()));
+ assertEquals(BaseObjectPoolConfig.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
+ objPool.getTimeBetweenEvictionRunsMillis());
+ assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_BLOCK_WHEN_EXHAUSTED),
+ Boolean.valueOf(objPool.getBlockWhenExhausted()));
+ assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_LIFO), Boolean.valueOf(objPool.getLifo()));
+ }
+
+ final GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
config.setLifo(lifo);
config.setMaxTotalPerKey(maxTotalPerKey);
config.setMaxIdlePerKey(maxIdle);
@@ -1175,28 +1170,21 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
config.setTestWhileIdle(testWhileIdle);
config.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
config.setBlockWhenExhausted(blockWhenExhausted);
- objPool = new GenericKeyedObjectPool<>(dummyFactory, config);
- assertEquals(maxTotalPerKey, objPool.getMaxTotalPerKey());
- assertEquals(maxIdle, objPool.getMaxIdlePerKey());
- assertEquals(maxWait, objPool.getMaxWaitMillis());
- assertEquals(minIdle, objPool.getMinIdlePerKey());
- assertEquals(maxTotal, objPool.getMaxTotal());
- assertEquals(minEvictableIdleTimeMillis,
- objPool.getMinEvictableIdleTimeMillis());
- assertEquals(numTestsPerEvictionRun, objPool.getNumTestsPerEvictionRun());
- assertEquals(Boolean.valueOf(testOnBorrow),
- Boolean.valueOf(objPool.getTestOnBorrow()));
- assertEquals(Boolean.valueOf(testOnReturn),
- Boolean.valueOf(objPool.getTestOnReturn()));
- assertEquals(Boolean.valueOf(testWhileIdle),
- Boolean.valueOf(objPool.getTestWhileIdle()));
- assertEquals(timeBetweenEvictionRunsMillis,
- objPool.getTimeBetweenEvictionRunsMillis());
- assertEquals(Boolean.valueOf(blockWhenExhausted),
- Boolean.valueOf(objPool.getBlockWhenExhausted()));
- assertEquals(Boolean.valueOf(lifo),
- Boolean.valueOf(objPool.getLifo()));
- objPool.close();
+ try (GenericKeyedObjectPool<Object, Object> objPool = new GenericKeyedObjectPool<>(dummyFactory, config)) {
+ assertEquals(maxTotalPerKey, objPool.getMaxTotalPerKey());
+ assertEquals(maxIdle, objPool.getMaxIdlePerKey());
+ assertEquals(maxWait, objPool.getMaxWaitMillis());
+ assertEquals(minIdle, objPool.getMinIdlePerKey());
+ assertEquals(maxTotal, objPool.getMaxTotal());
+ assertEquals(minEvictableIdleTimeMillis, objPool.getMinEvictableIdleTimeMillis());
+ assertEquals(numTestsPerEvictionRun, objPool.getNumTestsPerEvictionRun());
+ assertEquals(Boolean.valueOf(testOnBorrow), Boolean.valueOf(objPool.getTestOnBorrow()));
+ assertEquals(Boolean.valueOf(testOnReturn), Boolean.valueOf(objPool.getTestOnReturn()));
+ assertEquals(Boolean.valueOf(testWhileIdle), Boolean.valueOf(objPool.getTestWhileIdle()));
+ assertEquals(timeBetweenEvictionRunsMillis, objPool.getTimeBetweenEvictionRunsMillis());
+ assertEquals(Boolean.valueOf(blockWhenExhausted), Boolean.valueOf(objPool.getBlockWhenExhausted()));
+ assertEquals(Boolean.valueOf(lifo), Boolean.valueOf(objPool.getLifo()));
+ }
}
@Test(expected=IllegalArgumentException.class)
@@ -1379,16 +1367,15 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
public void testMaxActivePerKeyExceeded() throws Exception {
final WaiterFactory<String> waiterFactory = new WaiterFactory<>(0, 20, 0, 0, 0, 0, 8, 5, 0);
// TODO Fix this. Can't use local pool since runTestThreads uses the
- // protected pool field
- final GenericKeyedObjectPool<String,Waiter> waiterPool =
- new GenericKeyedObjectPool<>(waiterFactory);
- waiterPool.setMaxTotalPerKey(5);
- waiterPool.setMaxTotal(8);
- waiterPool.setTestOnBorrow(true);
- waiterPool.setMaxIdlePerKey(5);
- waiterPool.setMaxWaitMillis(-1);
- runTestThreads(20, 300, 250, waiterPool);
- waiterPool.close();
+ // protected pool field
+ try (final GenericKeyedObjectPool<String, Waiter> waiterPool = new GenericKeyedObjectPool<>(waiterFactory)) {
+ waiterPool.setMaxTotalPerKey(5);
+ waiterPool.setMaxTotal(8);
+ waiterPool.setTestOnBorrow(true);
+ waiterPool.setMaxIdlePerKey(5);
+ waiterPool.setMaxWaitMillis(-1);
+ runTestThreads(20, 300, 250, waiterPool);
+ }
}
/**
@@ -1400,31 +1387,30 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
public void testClearOldest() throws Exception {
// Make destroy have some latency so clearOldest takes some time
final WaiterFactory<String> waiterFactory = new WaiterFactory<>(0, 20, 0, 0, 0, 0, 50, 5, 0);
- final GenericKeyedObjectPool<String,Waiter> waiterPool =
- new GenericKeyedObjectPool<>(waiterFactory);
- waiterPool.setMaxTotalPerKey(5);
- waiterPool.setMaxTotal(50);
- waiterPool.setLifo(false);
- // Load the pool with idle instances - 5 each for 10 keys
- for (int i = 0; i < 10; i++) {
- final String key = Integer.valueOf(i).toString();
- for (int j = 0; j < 5; j++) {
- waiterPool.addObject(key);
+ try (final GenericKeyedObjectPool<String, Waiter> waiterPool = new GenericKeyedObjectPool<>(waiterFactory)) {
+ waiterPool.setMaxTotalPerKey(5);
+ waiterPool.setMaxTotal(50);
+ waiterPool.setLifo(false);
+ // Load the pool with idle instances - 5 each for 10 keys
+ for (int i = 0; i < 10; i++) {
+ final String key = Integer.valueOf(i).toString();
+ for (int j = 0; j < 5; j++) {
+ waiterPool.addObject(key);
+ }
+ // Make sure order is maintained
+ Thread.sleep(20);
}
- // Make sure order is maintained
- Thread.sleep(20);
+ // Now set up a race - one thread wants a new instance, triggering clearOldest
+ // Other goes after an element on death row
+ // See if we end up with dead man walking
+ final SimpleTestThread<Waiter> t2 = new SimpleTestThread<>(waiterPool, "51");
+ final Thread thread2 = new Thread(t2);
+ thread2.start(); // Triggers clearOldest, killing all of the 0's and the 2 oldest 1's
+ Thread.sleep(50); // Wait for clearOldest to kick off, but not long enough to reach the 1's
+ final Waiter waiter = waiterPool.borrowObject("1");
+ Thread.sleep(200); // Wait for execution to happen
+ waiterPool.returnObject("1", waiter); // Will throw IllegalStateException if dead
}
- // Now set up a race - one thread wants a new instance, triggering clearOldest
- // Other goes after an element on death row
- // See if we end up with dead man walking
- final SimpleTestThread<Waiter> t2 = new SimpleTestThread<>(waiterPool, "51");
- final Thread thread2 = new Thread(t2);
- thread2.start(); // Triggers clearOldest, killing all of the 0's and the 2 oldest 1's
- Thread.sleep(50); // Wait for clearOldest to kick off, but not long enough to reach the 1's
- final Waiter waiter = waiterPool.borrowObject("1");
- Thread.sleep(200); // Wait for execution to happen
- waiterPool.returnObject("1", waiter); // Will throw IllegalStateException if dead
- waiterPool.close();
}
@@ -2063,26 +2049,26 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
* @throws Exception May occur in some failure modes
*/
@Test
- public void testInvalidateFreesCapacity()
- throws Exception {
+ public void testInvalidateFreesCapacity() throws Exception {
final SimpleFactory<String> factory = new SimpleFactory<>();
- final GenericKeyedObjectPool<String, String> pool = new GenericKeyedObjectPool<>(factory);
- pool.setMaxTotalPerKey(2);
- pool.setMaxWaitMillis(500);
- // Borrow an instance and hold if for 5 seconds
- final WaitingTestThread thread1 = new WaitingTestThread(pool, "one", 5000);
- thread1.start();
- // Borrow another instance
- final String obj = pool.borrowObject("one");
- // Launch another thread - will block, but fail in 500 ms
- final WaitingTestThread thread2 = new WaitingTestThread(pool, "one", 100);
- thread2.start();
- // Invalidate the object borrowed by this thread - should allow thread2 to create
- Thread.sleep(20);
- pool.invalidateObject("one", obj);
- Thread.sleep(600); // Wait for thread2 to timeout
- if (thread2._thrown != null) {
- fail(thread2._thrown.toString());
+ try (final GenericKeyedObjectPool<String, String> pool = new GenericKeyedObjectPool<>(factory)) {
+ pool.setMaxTotalPerKey(2);
+ pool.setMaxWaitMillis(500);
+ // Borrow an instance and hold if for 5 seconds
+ final WaitingTestThread thread1 = new WaitingTestThread(pool, "one", 5000);
+ thread1.start();
+ // Borrow another instance
+ final String obj = pool.borrowObject("one");
+ // Launch another thread - will block, but fail in 500 ms
+ final WaitingTestThread thread2 = new WaitingTestThread(pool, "one", 100);
+ thread2.start();
+ // Invalidate the object borrowed by this thread - should allow thread2 to create
+ Thread.sleep(20);
+ pool.invalidateObject("one", obj);
+ Thread.sleep(600); // Wait for thread2 to timeout
+ if (thread2._thrown != null) {
+ fail(thread2._thrown.toString());
+ }
}
}
@@ -2096,25 +2082,26 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
*/
@Test
public void testValidationFailureOnReturnFreesCapacity()
- throws Exception {
+ throws Exception {
final SimpleFactory<String> factory = new SimpleFactory<>();
factory.setValid(false); // Validate will always fail
factory.setValidationEnabled(true);
- final GenericKeyedObjectPool<String, String> pool = new GenericKeyedObjectPool<>(factory);
- pool.setMaxTotalPerKey(2);
- pool.setMaxWaitMillis(1500);
- pool.setTestOnReturn(true);
- pool.setTestOnBorrow(false);
- // Borrow an instance and hold if for 5 seconds
- final WaitingTestThread thread1 = new WaitingTestThread(pool,"one", 5000);
- thread1.start();
- // Borrow another instance and return it after 500 ms (validation will fail)
- final WaitingTestThread thread2 = new WaitingTestThread(pool,"one", 500);
- thread2.start();
- Thread.sleep(50);
- // Try to borrow an object
- final String obj = pool.borrowObject("one");
- pool.returnObject("one", obj);
+ try (final GenericKeyedObjectPool<String, String> pool = new GenericKeyedObjectPool<>(factory)) {
+ pool.setMaxTotalPerKey(2);
+ pool.setMaxWaitMillis(1500);
+ pool.setTestOnReturn(true);
+ pool.setTestOnBorrow(false);
+ // Borrow an instance and hold if for 5 seconds
+ final WaitingTestThread thread1 = new WaitingTestThread(pool, "one", 5000);
+ thread1.start();
+ // Borrow another instance and return it after 500 ms (validation will fail)
+ final WaitingTestThread thread2 = new WaitingTestThread(pool, "one", 500);
+ thread2.start();
+ Thread.sleep(50);
+ // Try to borrow an object
+ final String obj = pool.borrowObject("one");
+ pool.returnObject("one", obj);
+ }
}
/**
@@ -2153,30 +2140,30 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
public void testReturnToHead() throws Exception {
final SimpleFactory<String> factory = new SimpleFactory<>();
factory.setValidateLatency(100);
- factory.setValid(true); // Validation always succeeds
- final GenericKeyedObjectPool<String, String> pool = new GenericKeyedObjectPool<>(factory);
- pool.setMaxWaitMillis(1000);
- pool.setTestWhileIdle(true);
- pool.setMaxTotalPerKey(2);
- pool.setNumTestsPerEvictionRun(1);
- pool.setTimeBetweenEvictionRunsMillis(500);
-
- // Load pool with two objects
- pool.addObject("one"); // call this o1
- pool.addObject("one"); // call this o2
- // Default is LIFO, so "one" pool is now [o2, o1] in offer order.
- // Evictor will visit in oldest-to-youngest order, so o1 then o2
-
- Thread.sleep(800); // Wait for first eviction run to complete
-
- // At this point, one eviction run should have completed, visiting o1
- // and eviction cursor should be pointed at o2, which is the next offered instance
- Thread.sleep(250); // Wait for evictor to start
- final String o1 = pool.borrowObject("one"); // o2 is under eviction, so this will return o1
- final String o2 = pool.borrowObject("one"); // Once validation completes, o2 should be offered
- pool.returnObject("one", o1);
- pool.returnObject("one", o2);
- pool.close();
+ factory.setValid(true); // Validation always succeeds
+ try (final GenericKeyedObjectPool<String, String> pool = new GenericKeyedObjectPool<>(factory)) {
+ pool.setMaxWaitMillis(1000);
+ pool.setTestWhileIdle(true);
+ pool.setMaxTotalPerKey(2);
+ pool.setNumTestsPerEvictionRun(1);
+ pool.setTimeBetweenEvictionRunsMillis(500);
+
+ // Load pool with two objects
+ pool.addObject("one"); // call this o1
+ pool.addObject("one"); // call this o2
+ // Default is LIFO, so "one" pool is now [o2, o1] in offer order.
+ // Evictor will visit in oldest-to-youngest order, so o1 then o2
+
+ Thread.sleep(800); // Wait for first eviction run to complete
+
+ // At this point, one eviction run should have completed, visiting o1
+ // and eviction cursor should be pointed at o2, which is the next offered instance
+ Thread.sleep(250); // Wait for evictor to start
+ final String o1 = pool.borrowObject("one"); // o2 is under eviction, so this will return o1
+ final String o2 = pool.borrowObject("one"); // Once validation completes, o2 should be offered
+ pool.returnObject("one", o1);
+ pool.returnObject("one", o2);
+ }
}
/**
@@ -2188,14 +2175,13 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
@Test
public void testEqualsIndiscernible() throws Exception {
final HashSetFactory factory = new HashSetFactory();
- final GenericKeyedObjectPool<String,HashSet<String>> pool =
- new GenericKeyedObjectPool<>(
- factory, new GenericKeyedObjectPoolConfig());
- final HashSet<String> s1 = pool.borrowObject("a");
- final HashSet<String> s2 = pool.borrowObject("a");
- pool.returnObject("a", s1);
- pool.returnObject("a", s2);
- pool.close();
+ try (final GenericKeyedObjectPool<String, HashSet<String>> pool = new GenericKeyedObjectPool<>(factory,
+ new GenericKeyedObjectPoolConfig())) {
+ final HashSet<String> s1 = pool.borrowObject("a");
+ final HashSet<String> s2 = pool.borrowObject("a");
+ pool.returnObject("a", s1);
+ pool.returnObject("a", s2);
+ }
}
/**
@@ -2207,16 +2193,15 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
@Test
public void testMutable() throws Exception {
final HashSetFactory factory = new HashSetFactory();
- final GenericKeyedObjectPool<String,HashSet<String>> pool =
- new GenericKeyedObjectPool<>(
- factory, new GenericKeyedObjectPoolConfig());
- final HashSet<String> s1 = pool.borrowObject("a");
- final HashSet<String> s2 = pool.borrowObject("a");
- s1.add("One");
- s2.add("One");
- pool.returnObject("a", s1);
- pool.returnObject("a", s2);
- pool.close();
+ try (final GenericKeyedObjectPool<String, HashSet<String>> pool = new GenericKeyedObjectPool<>(factory,
+ new GenericKeyedObjectPoolConfig())) {
+ final HashSet<String> s1 = pool.borrowObject("a");
+ final HashSet<String> s2 = pool.borrowObject("a");
+ s1.add("One");
+ s2.add("One");
+ pool.returnObject("a", s1);
+ pool.returnObject("a", s2);
+ }
}
/**
@@ -2228,20 +2213,20 @@ public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
@Test
public void testMultipleReturn() throws Exception {
final WaiterFactory<String> factory = new WaiterFactory<>(0, 0, 0, 0, 0, 0);
- final GenericKeyedObjectPool<String, Waiter> pool =
- new GenericKeyedObjectPool<>(factory);
- pool.setTestOnReturn(true);
- final Waiter waiter = pool.borrowObject("a");
- pool.returnObject("a",waiter);
- Assert.assertEquals(1, waiter.getValidationCount());
- Assert.assertEquals(1, waiter.getPassivationCount());
- try {
- pool.returnObject("a",waiter);
- fail("Expecting IllegalStateException from multiple return");
- } catch (final IllegalStateException ex) {
- // Exception is expected, now check no repeat validation/passivation
+ try (final GenericKeyedObjectPool<String, Waiter> pool = new GenericKeyedObjectPool<>(factory)) {
+ pool.setTestOnReturn(true);
+ final Waiter waiter = pool.borrowObject("a");
+ pool.returnObject("a", waiter);
Assert.assertEquals(1, waiter.getValidationCount());
Assert.assertEquals(1, waiter.getPassivationCount());
+ try {
+ pool.returnObject("a", waiter);
+ fail("Expecting IllegalStateException from multiple return");
+ } catch (final IllegalStateException ex) {
+ // Exception is expected, now check no repeat validation/passivation
+ Assert.assertEquals(1, waiter.getValidationCount());
+ Assert.assertEquals(1, waiter.getPassivationCount());
+ }
}
}
http://git-wip-us.apache.org/repos/asf/commons-pool/blob/462c3f94/src/test/java/org/apache/commons/pool2/impl/TestGenericObjectPool.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/pool2/impl/TestGenericObjectPool.java b/src/test/java/org/apache/commons/pool2/impl/TestGenericObjectPool.java
index c21e68c..c27411d 100644
--- a/src/test/java/org/apache/commons/pool2/impl/TestGenericObjectPool.java
+++ b/src/test/java/org/apache/commons/pool2/impl/TestGenericObjectPool.java
@@ -139,32 +139,29 @@ public class TestGenericObjectPool extends TestBaseObjectPool {
final boolean blockWhenExhausted = false;
final boolean lifo = false;
final PooledObjectFactory<Object> dummyFactory = new DummyFactory();
- GenericObjectPool<Object> dummyPool =
- new GenericObjectPool<>(dummyFactory);
- assertEquals(GenericObjectPoolConfig.DEFAULT_MAX_IDLE, dummyPool.getMaxIdle());
- assertEquals(BaseObjectPoolConfig.DEFAULT_MAX_WAIT_MILLIS, dummyPool.getMaxWaitMillis());
- assertEquals(GenericObjectPoolConfig.DEFAULT_MIN_IDLE, dummyPool.getMinIdle());
- assertEquals(GenericObjectPoolConfig.DEFAULT_MAX_TOTAL, dummyPool.getMaxTotal());
- assertEquals(BaseObjectPoolConfig.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
- dummyPool.getMinEvictableIdleTimeMillis());
- assertEquals(BaseObjectPoolConfig.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
- dummyPool.getNumTestsPerEvictionRun());
- assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_ON_BORROW),
- Boolean.valueOf(dummyPool.getTestOnBorrow()));
- assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_ON_RETURN),
- Boolean.valueOf(dummyPool.getTestOnReturn()));
- assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_WHILE_IDLE),
- Boolean.valueOf(dummyPool.getTestWhileIdle()));
- assertEquals(BaseObjectPoolConfig.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
- dummyPool.getTimeBetweenEvictionRunsMillis());
- assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_BLOCK_WHEN_EXHAUSTED),
- Boolean.valueOf(dummyPool.getBlockWhenExhausted()));
- assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_LIFO),
- Boolean.valueOf(dummyPool.getLifo()));
- dummyPool.close();
-
- final GenericObjectPoolConfig config =
- new GenericObjectPoolConfig();
+ try (GenericObjectPool<Object> dummyPool = new GenericObjectPool<>(dummyFactory)) {
+ assertEquals(GenericObjectPoolConfig.DEFAULT_MAX_IDLE, dummyPool.getMaxIdle());
+ assertEquals(BaseObjectPoolConfig.DEFAULT_MAX_WAIT_MILLIS, dummyPool.getMaxWaitMillis());
+ assertEquals(GenericObjectPoolConfig.DEFAULT_MIN_IDLE, dummyPool.getMinIdle());
+ assertEquals(GenericObjectPoolConfig.DEFAULT_MAX_TOTAL, dummyPool.getMaxTotal());
+ assertEquals(BaseObjectPoolConfig.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
+ dummyPool.getMinEvictableIdleTimeMillis());
+ assertEquals(BaseObjectPoolConfig.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
+ dummyPool.getNumTestsPerEvictionRun());
+ assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_ON_BORROW),
+ Boolean.valueOf(dummyPool.getTestOnBorrow()));
+ assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_ON_RETURN),
+ Boolean.valueOf(dummyPool.getTestOnReturn()));
+ assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_TEST_WHILE_IDLE),
+ Boolean.valueOf(dummyPool.getTestWhileIdle()));
+ assertEquals(BaseObjectPoolConfig.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
+ dummyPool.getTimeBetweenEvictionRunsMillis());
+ assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_BLOCK_WHEN_EXHAUSTED),
+ Boolean.valueOf(dummyPool.getBlockWhenExhausted()));
+ assertEquals(Boolean.valueOf(BaseObjectPoolConfig.DEFAULT_LIFO), Boolean.valueOf(dummyPool.getLifo()));
+ }
+
+ final GenericObjectPoolConfig config = new GenericObjectPoolConfig();
config.setLifo(lifo);
config.setMaxIdle(maxIdle);
config.setMinIdle(minIdle);
@@ -177,26 +174,20 @@ public class TestGenericObjectPool extends TestBaseObjectPool {
config.setTestWhileIdle(testWhileIdle);
config.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
config.setBlockWhenExhausted(blockWhenExhausted);
- dummyPool = new GenericObjectPool<>(dummyFactory, config);
- assertEquals(maxIdle, dummyPool.getMaxIdle());
- assertEquals(maxWait, dummyPool.getMaxWaitMillis());
- assertEquals(minIdle, dummyPool.getMinIdle());
- assertEquals(maxTotal, dummyPool.getMaxTotal());
- assertEquals(minEvictableIdleTimeMillis,
- dummyPool.getMinEvictableIdleTimeMillis());
- assertEquals(numTestsPerEvictionRun, dummyPool.getNumTestsPerEvictionRun());
- assertEquals(Boolean.valueOf(testOnBorrow),
- Boolean.valueOf(dummyPool.getTestOnBorrow()));
- assertEquals(Boolean.valueOf(testOnReturn),
- Boolean.valueOf(dummyPool.getTestOnReturn()));
- assertEquals(Boolean.valueOf(testWhileIdle),
- Boolean.valueOf(dummyPool.getTestWhileIdle()));
- assertEquals(timeBetweenEvictionRunsMillis,
- dummyPool.getTimeBetweenEvictionRunsMillis());
- assertEquals(Boolean.valueOf(blockWhenExhausted),
- Boolean.valueOf(dummyPool.getBlockWhenExhausted()));
- assertEquals(Boolean.valueOf(lifo), Boolean.valueOf(dummyPool.getLifo()));
- dummyPool.close();
+ try (GenericObjectPool<Object> dummyPool = new GenericObjectPool<>(dummyFactory, config)) {
+ assertEquals(maxIdle, dummyPool.getMaxIdle());
+ assertEquals(maxWait, dummyPool.getMaxWaitMillis());
+ assertEquals(minIdle, dummyPool.getMinIdle());
+ assertEquals(maxTotal, dummyPool.getMaxTotal());
+ assertEquals(minEvictableIdleTimeMillis, dummyPool.getMinEvictableIdleTimeMillis());
+ assertEquals(numTestsPerEvictionRun, dummyPool.getNumTestsPerEvictionRun());
+ assertEquals(Boolean.valueOf(testOnBorrow), Boolean.valueOf(dummyPool.getTestOnBorrow()));
+ assertEquals(Boolean.valueOf(testOnReturn), Boolean.valueOf(dummyPool.getTestOnReturn()));
+ assertEquals(Boolean.valueOf(testWhileIdle), Boolean.valueOf(dummyPool.getTestWhileIdle()));
+ assertEquals(timeBetweenEvictionRunsMillis, dummyPool.getTimeBetweenEvictionRunsMillis());
+ assertEquals(Boolean.valueOf(blockWhenExhausted), Boolean.valueOf(dummyPool.getBlockWhenExhausted()));
+ assertEquals(Boolean.valueOf(lifo), Boolean.valueOf(dummyPool.getLifo()));
+ }
}
@Test(timeout=60000)
@@ -407,122 +398,116 @@ public class TestGenericObjectPool extends TestBaseObjectPool {
}
private void checkEvictorVisiting(final boolean lifo) throws Exception {
+ VisitTracker<Object> obj;
VisitTrackerFactory<Object> trackerFactory = new VisitTrackerFactory<>();
- GenericObjectPool<VisitTracker<Object>> trackerPool =
- new GenericObjectPool<>(trackerFactory);
- trackerPool.setNumTestsPerEvictionRun(2);
- trackerPool.setMinEvictableIdleTimeMillis(-1);
- trackerPool.setTestWhileIdle(true);
- trackerPool.setLifo(lifo);
- trackerPool.setTestOnReturn(false);
- trackerPool.setTestOnBorrow(false);
- for (int i = 0; i < 8; i++) {
- trackerPool.addObject();
- }
- trackerPool.evict(); // Visit oldest 2 - 0 and 1
- VisitTracker<Object> obj = trackerPool.borrowObject();
- trackerPool.returnObject(obj);
- obj = trackerPool.borrowObject();
- trackerPool.returnObject(obj);
- // borrow, return, borrow, return
- // FIFO will move 0 and 1 to end
- // LIFO, 7 out, then in, then out, then in
- trackerPool.evict(); // Should visit 2 and 3 in either case
- for (int i = 0; i < 8; i++) {
- final VisitTracker<Object> tracker = trackerPool.borrowObject();
- if (tracker.getId() >= 4) {
- assertEquals("Unexpected instance visited " + tracker.getId(),
- 0, tracker.getValidateCount());
- } else {
- assertEquals("Instance " + tracker.getId() +
- " visited wrong number of times.",
- 1, tracker.getValidateCount());
+ try (GenericObjectPool<VisitTracker<Object>> trackerPool = new GenericObjectPool<>(trackerFactory)) {
+ trackerPool.setNumTestsPerEvictionRun(2);
+ trackerPool.setMinEvictableIdleTimeMillis(-1);
+ trackerPool.setTestWhileIdle(true);
+ trackerPool.setLifo(lifo);
+ trackerPool.setTestOnReturn(false);
+ trackerPool.setTestOnBorrow(false);
+ for (int i = 0; i < 8; i++) {
+ trackerPool.addObject();
+ }
+ trackerPool.evict(); // Visit oldest 2 - 0 and 1
+ obj = trackerPool.borrowObject();
+ trackerPool.returnObject(obj);
+ obj = trackerPool.borrowObject();
+ trackerPool.returnObject(obj);
+ // borrow, return, borrow, return
+ // FIFO will move 0 and 1 to end
+ // LIFO, 7 out, then in, then out, then in
+ trackerPool.evict(); // Should visit 2 and 3 in either case
+ for (int i = 0; i < 8; i++) {
+ final VisitTracker<Object> tracker = trackerPool.borrowObject();
+ if (tracker.getId() >= 4) {
+ assertEquals("Unexpected instance visited " + tracker.getId(), 0, tracker.getValidateCount());
+ } else {
+ assertEquals("Instance " + tracker.getId() + " visited wrong number of times.", 1,
+ tracker.getValidateCount());
+ }
}
}
- trackerPool.close();
trackerFactory = new VisitTrackerFactory<>();
- trackerPool = new GenericObjectPool<>(trackerFactory);
- trackerPool.setNumTestsPerEvictionRun(3);
- trackerPool.setMinEvictableIdleTimeMillis(-1);
- trackerPool.setTestWhileIdle(true);
- trackerPool.setLifo(lifo);
- trackerPool.setTestOnReturn(false);
- trackerPool.setTestOnBorrow(false);
- for (int i = 0; i < 8; i++) {
- trackerPool.addObject();
- }
- trackerPool.evict(); // 0, 1, 2
- trackerPool.evict(); // 3, 4, 5
- obj = trackerPool.borrowObject();
- trackerPool.returnObject(obj);
- obj = trackerPool.borrowObject();
- trackerPool.returnObject(obj);
- obj = trackerPool.borrowObject();
- trackerPool.returnObject(obj);
- // borrow, return, borrow, return
- // FIFO 3,4,5,6,7,0,1,2
- // LIFO 7,6,5,4,3,2,1,0
- // In either case, pointer should be at 6
- trackerPool.evict();
- // Should hit 6,7,0 - 0 for second time
- for (int i = 0; i < 8; i++) {
- final VisitTracker<Object> tracker = trackerPool.borrowObject();
- if (tracker.getId() != 0) {
- assertEquals("Instance " + tracker.getId() +
- " visited wrong number of times.",
- 1, tracker.getValidateCount());
- } else {
- assertEquals("Instance " + tracker.getId() +
- " visited wrong number of times.",
- 2, tracker.getValidateCount());
+ try (GenericObjectPool<VisitTracker<Object>> trackerPool = new GenericObjectPool<>(trackerFactory)) {
+ trackerPool.setNumTestsPerEvictionRun(3);
+ trackerPool.setMinEvictableIdleTimeMillis(-1);
+ trackerPool.setTestWhileIdle(true);
+ trackerPool.setLifo(lifo);
+ trackerPool.setTestOnReturn(false);
+ trackerPool.setTestOnBorrow(false);
+ for (int i = 0; i < 8; i++) {
+ trackerPool.addObject();
+ }
+ trackerPool.evict(); // 0, 1, 2
+ trackerPool.evict(); // 3, 4, 5
+ obj = trackerPool.borrowObject();
+ trackerPool.returnObject(obj);
+ obj = trackerPool.borrowObject();
+ trackerPool.returnObject(obj);
+ obj = trackerPool.borrowObject();
+ trackerPool.returnObject(obj);
+ // borrow, return, borrow, return
+ // FIFO 3,4,5,6,7,0,1,2
+ // LIFO 7,6,5,4,3,2,1,0
+ // In either case, pointer should be at 6
+ trackerPool.evict();
+ // Should hit 6,7,0 - 0 for second time
+ for (int i = 0; i < 8; i++) {
+ final VisitTracker<Object> tracker = trackerPool.borrowObject();
+ if (tracker.getId() != 0) {
+ assertEquals("Instance " + tracker.getId() + " visited wrong number of times.", 1,
+ tracker.getValidateCount());
+ } else {
+ assertEquals("Instance " + tracker.getId() + " visited wrong number of times.", 2,
+ tracker.getValidateCount());
+ }
}
}
- trackerPool.close();
// Randomly generate a pools with random numTests
// and make sure evictor cycles through elements appropriately
- final int[] smallPrimes = {2, 3, 5, 7};
+ final int[] smallPrimes = { 2, 3, 5, 7 };
final Random random = new Random();
random.setSeed(System.currentTimeMillis());
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 5; j++) {
- trackerPool = new GenericObjectPool<>(trackerFactory);
- trackerPool.setNumTestsPerEvictionRun(smallPrimes[i]);
- trackerPool.setMinEvictableIdleTimeMillis(-1);
- trackerPool.setTestWhileIdle(true);
- trackerPool.setLifo(lifo);
- trackerPool.setTestOnReturn(false);
- trackerPool.setTestOnBorrow(false);
- trackerPool.setMaxIdle(-1);
- final int instanceCount = 10 + random.nextInt(20);
- trackerPool.setMaxTotal(instanceCount);
- for (int k = 0; k < instanceCount; k++) {
- trackerPool.addObject();
- }
+ try (GenericObjectPool<VisitTracker<Object>> trackerPool = new GenericObjectPool<>(trackerFactory)) {
+ trackerPool.setNumTestsPerEvictionRun(smallPrimes[i]);
+ trackerPool.setMinEvictableIdleTimeMillis(-1);
+ trackerPool.setTestWhileIdle(true);
+ trackerPool.setLifo(lifo);
+ trackerPool.setTestOnReturn(false);
+ trackerPool.setTestOnBorrow(false);
+ trackerPool.setMaxIdle(-1);
+ final int instanceCount = 10 + random.nextInt(20);
+ trackerPool.setMaxTotal(instanceCount);
+ for (int k = 0; k < instanceCount; k++) {
+ trackerPool.addObject();
+ }
- // Execute a random number of evictor runs
- final int runs = 10 + random.nextInt(50);
- for (int k = 0; k < runs; k++) {
- trackerPool.evict();
- }
+ // Execute a random number of evictor runs
+ final int runs = 10 + random.nextInt(50);
+ for (int k = 0; k < runs; k++) {
+ trackerPool.evict();
+ }
- // Number of times evictor should have cycled through the pool
- final int cycleCount = (runs * trackerPool.getNumTestsPerEvictionRun()) /
- instanceCount;
-
- // Look at elements and make sure they are visited cycleCount
- // or cycleCount + 1 times
- VisitTracker<Object> tracker = null;
- int visitCount = 0;
- for (int k = 0; k < instanceCount; k++) {
- tracker = trackerPool.borrowObject();
- assertTrue(trackerPool.getNumActive() <= trackerPool.getMaxTotal());
- visitCount = tracker.getValidateCount();
- assertTrue(visitCount >= cycleCount &&
- visitCount <= cycleCount + 1);
+ // Number of times evictor should have cycled through the pool
+ final int cycleCount = (runs * trackerPool.getNumTestsPerEvictionRun()) / instanceCount;
+
+ // Look at elements and make sure they are visited cycleCount
+ // or cycleCount + 1 times
+ VisitTracker<Object> tracker = null;
+ int visitCount = 0;
+ for (int k = 0; k < instanceCount; k++) {
+ tracker = trackerPool.borrowObject();
+ assertTrue(trackerPool.getNumActive() <= trackerPool.getMaxTotal());
+ visitCount = tracker.getValidateCount();
+ assertTrue(visitCount >= cycleCount && visitCount <= cycleCount + 1);
+ }
}
- trackerPool.close();
}
}
}
@@ -1115,92 +1100,94 @@ public class TestGenericObjectPool extends TestBaseObjectPool {
public void testEvictionSoftMinIdle() throws Exception {
class TimeTest extends BasePooledObjectFactory<TimeTest> {
private final long createTime;
+
public TimeTest() {
createTime = System.currentTimeMillis();
}
+
@Override
public TimeTest create() throws Exception {
return new TimeTest();
}
+
@Override
public PooledObject<TimeTest> wrap(final TimeTest value) {
return new DefaultPooledObject<>(value);
}
+
public long getCreateTime() {
return createTime;
}
}
- final GenericObjectPool<TimeTest> timePool =
- new GenericObjectPool<>(new TimeTest());
+ try (final GenericObjectPool<TimeTest> timePool = new GenericObjectPool<>(new TimeTest())) {
- timePool.setMaxIdle(5);
- timePool.setMaxTotal(5);
- timePool.setNumTestsPerEvictionRun(5);
- timePool.setMinEvictableIdleTimeMillis(3000L);
- timePool.setSoftMinEvictableIdleTimeMillis(1000L);
- timePool.setMinIdle(2);
+ timePool.setMaxIdle(5);
+ timePool.setMaxTotal(5);
+ timePool.setNumTestsPerEvictionRun(5);
+ timePool.setMinEvictableIdleTimeMillis(3000L);
+ timePool.setSoftMinEvictableIdleTimeMillis(1000L);
+ timePool.setMinIdle(2);
- final TimeTest[] active = new TimeTest[5];
- final Long[] creationTime = new Long[5] ;
- for(int i=0;i<5;i++) {
- active[i] = timePool.borrowObject();
- creationTime[i] = Long.valueOf((active[i]).getCreateTime());
- }
+ final TimeTest[] active = new TimeTest[5];
+ final Long[] creationTime = new Long[5];
+ for (int i = 0; i < 5; i++) {
+ active[i] = timePool.borrowObject();
+ creationTime[i] = Long.valueOf((active[i]).getCreateTime());
+ }
- for(int i=0;i<5;i++) {
- timePool.returnObject(active[i]);
- }
+ for (int i = 0; i < 5; i++) {
+ timePool.returnObject(active[i]);
+ }
- // Soft evict all but minIdle(2)
- Thread.sleep(1500L);
- timePool.evict();
- assertEquals("Idle count different than expected.", 2, timePool.getNumIdle());
+ // Soft evict all but minIdle(2)
+ Thread.sleep(1500L);
+ timePool.evict();
+ assertEquals("Idle count different than expected.", 2, timePool.getNumIdle());
- // Hard evict the rest.
- Thread.sleep(2000L);
- timePool.evict();
- assertEquals("Idle count different than expected.", 0, timePool.getNumIdle());
- timePool.close();
+ // Hard evict the rest.
+ Thread.sleep(2000L);
+ timePool.evict();
+ assertEquals("Idle count different than expected.", 0, timePool.getNumIdle());
+ }
}
@Test(timeout=60000)
public void testEvictionInvalid() throws Exception {
- final GenericObjectPool<Object> invalidFactoryPool =
- new GenericObjectPool<>(new InvalidFactory());
+ try (final GenericObjectPool<Object> invalidFactoryPool = new GenericObjectPool<>(new InvalidFactory())) {
- invalidFactoryPool.setMaxIdle(1);
- invalidFactoryPool.setMaxTotal(1);
- invalidFactoryPool.setTestOnBorrow(false);
- invalidFactoryPool.setTestOnReturn(false);
- invalidFactoryPool.setTestWhileIdle(true);
- invalidFactoryPool.setMinEvictableIdleTimeMillis(100000);
- invalidFactoryPool.setNumTestsPerEvictionRun(1);
+ invalidFactoryPool.setMaxIdle(1);
+ invalidFactoryPool.setMaxTotal(1);
+ invalidFactoryPool.setTestOnBorrow(false);
+ invalidFactoryPool.setTestOnReturn(false);
+ invalidFactoryPool.setTestWhileIdle(true);
+ invalidFactoryPool.setMinEvictableIdleTimeMillis(100000);
+ invalidFactoryPool.setNumTestsPerEvictionRun(1);
- final Object p = invalidFactoryPool.borrowObject();
- invalidFactoryPool.returnObject(p);
+ final Object p = invalidFactoryPool.borrowObject();
+ invalidFactoryPool.returnObject(p);
- // Run eviction in a separate thread
- final Thread t = new EvictionThread<>(invalidFactoryPool);
- t.start();
+ // Run eviction in a separate thread
+ final Thread t = new EvictionThread<>(invalidFactoryPool);
+ t.start();
- // Sleep to make sure evictor has started
- Thread.sleep(300);
+ // Sleep to make sure evictor has started
+ Thread.sleep(300);
- try {
- invalidFactoryPool.borrowObject(1);
- } catch (final NoSuchElementException nsee) {
- // Ignore
- }
+ try {
+ invalidFactoryPool.borrowObject(1);
+ } catch (final NoSuchElementException nsee) {
+ // Ignore
+ }
- // Make sure evictor has finished
- Thread.sleep(1000);
+ // Make sure evictor has finished
+ Thread.sleep(1000);
- // Should have an empty pool
- assertEquals("Idle count different than expected.", 0, invalidFactoryPool.getNumIdle());
- assertEquals("Total count different than expected.", 0, invalidFactoryPool.getNumActive());
- invalidFactoryPool.close();
+ // Should have an empty pool
+ assertEquals("Idle count different than expected.", 0, invalidFactoryPool.getNumIdle());
+ assertEquals("Total count different than expected.", 0, invalidFactoryPool.getNumActive());
+ }
}
/**
@@ -2433,13 +2420,13 @@ public class TestGenericObjectPool extends TestBaseObjectPool {
@Test
public void testEqualsIndiscernible() throws Exception {
final HashSetFactory factory = new HashSetFactory();
- final GenericObjectPool<HashSet<String>> pool = new GenericObjectPool<>(
- factory, new GenericObjectPoolConfig());
- final HashSet<String> s1 = pool.borrowObject();
- final HashSet<String> s2 = pool.borrowObject();
- pool.returnObject(s1);
- pool.returnObject(s2);
- pool.close();
+ try (final GenericObjectPool<HashSet<String>> pool = new GenericObjectPool<>(factory,
+ new GenericObjectPoolConfig())) {
+ final HashSet<String> s1 = pool.borrowObject();
+ final HashSet<String> s2 = pool.borrowObject();
+ pool.returnObject(s1);
+ pool.returnObject(s2);
+ }
}
/**
@@ -2451,15 +2438,15 @@ public class TestGenericObjectPool extends TestBaseObjectPool {
@Test
public void testMutable() throws Exception {
final HashSetFactory factory = new HashSetFactory();
- final GenericObjectPool<HashSet<String>> pool = new GenericObjectPool<>(
- factory, new GenericObjectPoolConfig());
- final HashSet<String> s1 = pool.borrowObject();
- final HashSet<String> s2 = pool.borrowObject();
- s1.add("One");
- s2.add("One");
- pool.returnObject(s1);
- pool.returnObject(s2);
- pool.close();
+ try (final GenericObjectPool<HashSet<String>> pool = new GenericObjectPool<>(factory,
+ new GenericObjectPoolConfig())) {
+ final HashSet<String> s1 = pool.borrowObject();
+ final HashSet<String> s2 = pool.borrowObject();
+ s1.add("One");
+ s2.add("One");
+ pool.returnObject(s1);
+ pool.returnObject(s2);
+ }
}
/**