Author: rdonkin Date: Sat Oct 29 02:45:10 2005 New Revision: 329382 URL: http://svn.apache.org/viewcvs?rev=329382&view=rev Log: Added missing calls to validate object. Submitted by Sandy McArthur. Issue#36719
Modified: jakarta/commons/proper/pool/trunk/src/java/org/apache/commons/pool/impl/SoftReferenceObjectPool.java jakarta/commons/proper/pool/trunk/src/java/org/apache/commons/pool/impl/StackObjectPool.java jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestGenericObjectPool.java jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestSoftReferenceObjectPool.java jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestStackObjectPool.java Modified: jakarta/commons/proper/pool/trunk/src/java/org/apache/commons/pool/impl/SoftReferenceObjectPool.java URL: http://svn.apache.org/viewcvs/jakarta/commons/proper/pool/trunk/src/java/org/apache/commons/pool/impl/SoftReferenceObjectPool.java?rev=329382&r1=329381&r2=329382&view=diff ============================================================================== --- jakarta/commons/proper/pool/trunk/src/java/org/apache/commons/pool/impl/SoftReferenceObjectPool.java (original) +++ jakarta/commons/proper/pool/trunk/src/java/org/apache/commons/pool/impl/SoftReferenceObjectPool.java Sat Oct 29 02:45:10 2005 @@ -70,9 +70,13 @@ SoftReference ref = (SoftReference)(_pool.remove(_pool.size() - 1)); obj = ref.get(); } - } - if(null != _factory && null != obj) { - _factory.activateObject(obj); + if(null != _factory && null != obj) { + _factory.activateObject(obj); + } + if (null != _factory && null != obj && !_factory.validateObject(obj)) { + _factory.destroyObject(obj); + obj = null; + } } _numActive++; return obj; Modified: jakarta/commons/proper/pool/trunk/src/java/org/apache/commons/pool/impl/StackObjectPool.java URL: http://svn.apache.org/viewcvs/jakarta/commons/proper/pool/trunk/src/java/org/apache/commons/pool/impl/StackObjectPool.java?rev=329382&r1=329381&r2=329382&view=diff ============================================================================== --- jakarta/commons/proper/pool/trunk/src/java/org/apache/commons/pool/impl/StackObjectPool.java (original) +++ jakarta/commons/proper/pool/trunk/src/java/org/apache/commons/pool/impl/StackObjectPool.java Sat Oct 29 02:45:10 2005 @@ -122,17 +122,23 @@ public synchronized Object borrowObject() throws Exception { assertOpen(); Object obj = null; - if (!_pool.empty()) { - obj = _pool.pop(); - } else { - if(null == _factory) { - throw new NoSuchElementException(); + while (null == obj) { + if (!_pool.empty()) { + obj = _pool.pop(); } else { - obj = _factory.makeObject(); + if(null == _factory) { + throw new NoSuchElementException(); + } else { + obj = _factory.makeObject(); + } + } + if(null != _factory && null != obj) { + _factory.activateObject(obj); + } + if (null != _factory && null != obj && !_factory.validateObject(obj)) { + _factory.destroyObject(obj); + obj = null; } - } - if(null != _factory && null != obj) { - _factory.activateObject(obj); } _numActive++; return obj; Modified: jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestGenericObjectPool.java URL: http://svn.apache.org/viewcvs/jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestGenericObjectPool.java?rev=329382&r1=329381&r2=329382&view=diff ============================================================================== --- jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestGenericObjectPool.java (original) +++ jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestGenericObjectPool.java Sat Oct 29 02:45:10 2005 @@ -17,6 +17,9 @@ package org.apache.commons.pool.impl; import java.util.NoSuchElementException; +import java.util.List; +import java.util.ArrayList; +import java.util.Arrays; import junit.framework.Test; import junit.framework.TestSuite; @@ -841,6 +844,75 @@ assertEquals("should be zero active", 0, pool.getNumActive()); } + private List testFactorySequenceStates = new ArrayList(5); + public void testFactorySequence() throws Exception { + // setup + // We need a factory that tracks method call sequence. + PoolableObjectFactory pof = new PoolableObjectFactory() { + public Object makeObject() throws Exception { + testFactorySequenceStates.add("makeObject"); + return new Object(); + } + + public void activateObject(Object obj) throws Exception { + testFactorySequenceStates.add("activateObject"); + } + + public boolean validateObject(Object obj) { + testFactorySequenceStates.add("validateObject"); + return true; + } + + public void passivateObject(Object obj) throws Exception { + testFactorySequenceStates.add("passivateObject"); + } + + public void destroyObject(Object obj) throws Exception { + testFactorySequenceStates.add("destroyObject"); + } + }; + + GenericObjectPool pool = new GenericObjectPool(pof); + pool.setTestOnBorrow(true); + pool.setTestOnReturn(true); + + // check the order in which the factory is called during borrow + testFactorySequenceStates.clear(); + Object o = pool.borrowObject(); + List desiredSequence = Arrays.asList(new String[] { + "makeObject", + "activateObject", + "validateObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); + + // check the order in which the factory is called when returning an object + testFactorySequenceStates.clear(); + pool.returnObject(o); + desiredSequence = Arrays.asList(new String[] { + "validateObject", + "passivateObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); + + // check the order in which the factory is called during borrow again + testFactorySequenceStates.clear(); + o = pool.borrowObject(); + desiredSequence = Arrays.asList(new String[] { + "activateObject", + "validateObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); + + // check the order in which the factory is called when invalidating an object + testFactorySequenceStates.clear(); + pool.invalidateObject(o); + desiredSequence = Arrays.asList(new String[] { + "destroyObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); + } + private GenericObjectPool pool = null; private void assertConfiguration(GenericObjectPool.Config expected, GenericObjectPool actual) throws Exception { Modified: jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestSoftReferenceObjectPool.java URL: http://svn.apache.org/viewcvs/jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestSoftReferenceObjectPool.java?rev=329382&r1=329381&r2=329382&view=diff ============================================================================== --- jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestSoftReferenceObjectPool.java (original) +++ jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestSoftReferenceObjectPool.java Sat Oct 29 02:45:10 2005 @@ -23,6 +23,10 @@ import org.apache.commons.pool.PoolableObjectFactory; import org.apache.commons.pool.TestObjectPool; +import java.util.List; +import java.util.ArrayList; +import java.util.Arrays; + /** * @author Rodney Waldhoff * @version $Revision$ $Date$ @@ -51,6 +55,73 @@ protected Object getNthObject(int n) { return String.valueOf(n); + } + + private List testFactorySequenceStates = new ArrayList(5); + public void testFactorySequence() throws Exception { + // setup + // We need a factory that tracks method call sequence. + PoolableObjectFactory pof = new PoolableObjectFactory() { + public Object makeObject() throws Exception { + testFactorySequenceStates.add("makeObject"); + return new Object(); + } + + public void activateObject(Object obj) throws Exception { + testFactorySequenceStates.add("activateObject"); + } + + public boolean validateObject(Object obj) { + testFactorySequenceStates.add("validateObject"); + return true; + } + + public void passivateObject(Object obj) throws Exception { + testFactorySequenceStates.add("passivateObject"); + } + + public void destroyObject(Object obj) throws Exception { + testFactorySequenceStates.add("destroyObject"); + } + }; + + ObjectPool pool = new SoftReferenceObjectPool(pof); + + // check the order in which the factory is called during borrow + testFactorySequenceStates.clear(); + Object o = pool.borrowObject(); + List desiredSequence = Arrays.asList(new String[] { + "makeObject", + "activateObject", + "validateObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); + + // check the order in which the factory is called when returning an object + testFactorySequenceStates.clear(); + pool.returnObject(o); + desiredSequence = Arrays.asList(new String[] { + "validateObject", + "passivateObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); + + // check the order in which the factory is called during borrow again + testFactorySequenceStates.clear(); + o = pool.borrowObject(); + desiredSequence = Arrays.asList(new String[] { + "activateObject", + "validateObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); + + // check the order in which the factory is called when invalidating an object + testFactorySequenceStates.clear(); + pool.invalidateObject(o); + desiredSequence = Arrays.asList(new String[] { + "destroyObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); } } Modified: jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestStackObjectPool.java URL: http://svn.apache.org/viewcvs/jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestStackObjectPool.java?rev=329382&r1=329381&r2=329382&view=diff ============================================================================== --- jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestStackObjectPool.java (original) +++ jakarta/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestStackObjectPool.java Sat Oct 29 02:45:10 2005 @@ -20,6 +20,7 @@ import java.util.NoSuchElementException; import java.util.List; import java.util.ArrayList; +import java.util.Arrays; import junit.framework.Test; import junit.framework.TestSuite; @@ -142,14 +143,17 @@ } } - public void testBorrowReturnWithSometimesInvalidObjects() throws Exception { + + public void testBorrowWithSometimesInvalidObjects() throws Exception { ObjectPool pool = new StackObjectPool(20); pool.setFactory( new PoolableObjectFactory() { + // factory makes Integer objects int counter = 0; public Object makeObject() { return new Integer(counter++); } public void destroyObject(Object obj) { } public boolean validateObject(Object obj) { + // only odd objects are valid if(obj instanceof Integer) { return ((((Integer)obj).intValue() % 2) == 1); } else { @@ -172,9 +176,67 @@ Object[] obj = new Object[10]; for(int i=0;i<10;i++) { obj[i] = pool.borrowObject(); + assertEquals("Each time we borrow, get one more active.", i+1, pool.getNumActive()); + } for(int i=0;i<10;i++) { pool.returnObject(obj[i]); + assertEquals("Each time we borrow, get one less active.", 9-i, pool.getNumActive()); + } + assertEquals(7,pool.getNumIdle()); + } + + public void testBorrowReturnWithSometimesInvalidObjects() throws Exception { + ObjectPool pool = new StackObjectPool(20); + + class TestingPoolableObjectFactory implements PoolableObjectFactory { + // factory makes Integer objects + int counter = 0; + boolean reject = false; + public Object makeObject() { return new Integer(counter++); } + public void destroyObject(Object obj) { } + public boolean validateObject(Object obj) { + if (reject) { + // only odd objects are valid + if(obj instanceof Integer) { + return ((((Integer)obj).intValue() % 2) == 1); + } else { + return false; + } + } else { + return true; + } + + } + public void activateObject(Object obj) { } + public void passivateObject(Object obj) { + if(obj instanceof Integer) { + if((((Integer)obj).intValue() % 3) == 0) { + throw new RuntimeException("Couldn't passivate"); + } + } else { + throw new RuntimeException("Couldn't passivate"); + } + } + }; + + TestingPoolableObjectFactory factory = new TestingPoolableObjectFactory(); + + pool.setFactory(factory); + + Object[] obj = new Object[10]; + for(int i=0;i<10;i++) { + obj[i] = pool.borrowObject(); + assertEquals("Each time we borrow, get one more active.", i+1, pool.getNumActive()); + + } + + // now reject even numbers + factory.reject = true; + + for(int i=0;i<10;i++) { + pool.returnObject(obj[i]); + assertEquals("Each time we borrow, get one less active.", 9-i, pool.getNumActive()); } assertEquals(3,pool.getNumIdle()); } @@ -254,6 +316,73 @@ // check to see what object was destroyed Integer d = (Integer)destroyed.get(0); assertEquals("Destoryed objects should have the stalest object.", i0, d); + } + + private List testFactorySequenceStates = new ArrayList(5); + public void testFactorySequence() throws Exception { + // setup + // We need a factory that tracks method call sequence. + PoolableObjectFactory pof = new PoolableObjectFactory() { + public Object makeObject() throws Exception { + testFactorySequenceStates.add("makeObject"); + return new Object(); + } + + public void activateObject(Object obj) throws Exception { + testFactorySequenceStates.add("activateObject"); + } + + public boolean validateObject(Object obj) { + testFactorySequenceStates.add("validateObject"); + return true; + } + + public void passivateObject(Object obj) throws Exception { + testFactorySequenceStates.add("passivateObject"); + } + + public void destroyObject(Object obj) throws Exception { + testFactorySequenceStates.add("destroyObject"); + } + }; + + ObjectPool pool = new StackObjectPool(pof, 1); + + // check the order in which the factory is called during borrow + testFactorySequenceStates.clear(); + Object o = pool.borrowObject(); + List desiredSequence = Arrays.asList(new String[] { + "makeObject", + "activateObject", + "validateObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); + + // check the order in which the factory is called when returning an object + testFactorySequenceStates.clear(); + pool.returnObject(o); + desiredSequence = Arrays.asList(new String[] { + "validateObject", + "passivateObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); + + // check the order in which the factory is called during borrow again + testFactorySequenceStates.clear(); + o = pool.borrowObject(); + desiredSequence = Arrays.asList(new String[] { + "activateObject", + "validateObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); + + // check the order in which the factory is called when invalidating an object + testFactorySequenceStates.clear(); + pool.invalidateObject(o); + desiredSequence = Arrays.asList(new String[] { + "destroyObject" + }); + assertEquals("Wrong sequence", desiredSequence, testFactorySequenceStates); } static class SimpleFactory implements PoolableObjectFactory { --------------------------------------------------------------------- To unsubscribe, e-mail: [EMAIL PROTECTED] For additional commands, e-mail: [EMAIL PROTECTED]