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 <ggreg...@apache.org> Authored: Tue Oct 31 08:41:47 2017 -0600 Committer: Gary Gregory <ggreg...@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); + } } /**
