commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pste...@apache.org
Subject svn commit: r960644 - /commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestStackObjectPool.java
Date Mon, 05 Jul 2010 17:15:07 GMT
Author: psteitz
Date: Mon Jul  5 17:15:07 2010
New Revision: 960644

URL: http://svn.apache.org/viewvc?rev=960644&view=rev
Log:
Consolidated test factories, improved test coverage.

Modified:
    commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestStackObjectPool.java

Modified: commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestStackObjectPool.java
URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestStackObjectPool.java?rev=960644&r1=960643&r2=960644&view=diff
==============================================================================
--- commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestStackObjectPool.java
(original)
+++ commons/proper/pool/trunk/src/test/org/apache/commons/pool/impl/TestStackObjectPool.java
Mon Jul  5 17:15:07 2010
@@ -64,6 +64,9 @@ public class TestStackObjectPool extends
         }
     }
 
+    /**
+     * @deprecated - to be removed in pool 2.0
+     */
     public void testPoolWithNullFactory() throws Exception {
         ObjectPool pool = new StackObjectPool(10);
         for(int i=0;i<10;i++) {
@@ -87,6 +90,9 @@ public class TestStackObjectPool extends
         pool.clear();        
     }
     
+    /**
+     * @deprecated - to be removed in pool 2.0
+     */
     public void testBorrowFromEmptyPoolWithNullFactory() throws Exception {
         ObjectPool pool = new StackObjectPool();
         try {
@@ -97,6 +103,9 @@ public class TestStackObjectPool extends
         }
     }
     
+    /**
+     * @deprecated - to be removed in pool 2.0
+     */
     public void testSetFactory() throws Exception {
         ObjectPool pool = new StackObjectPool();
         try {
@@ -111,6 +120,9 @@ public class TestStackObjectPool extends
         pool.returnObject(obj);
     }
 
+    /**
+     * @deprecated - to be removed in pool 2.0
+     */
     public void testCantResetFactoryWithActiveObjects() throws Exception {
         ObjectPool pool = new StackObjectPool();
         pool.setFactory(new SimpleFactory());
@@ -125,6 +137,9 @@ public class TestStackObjectPool extends
         }        
     }
     
+    /**
+     * @deprecated - to be removed in pool 2.0
+     */
     public void testCanResetFactoryWithoutActiveObjects() throws Exception {
         ObjectPool pool = new StackObjectPool();
         {
@@ -141,33 +156,16 @@ public class TestStackObjectPool extends
         }
     }
 
-
+    /**
+     * Verifies that validation failures when borrowing newly created instances
+     * from the pool result in NoSuchElementExceptions and passivation failures
+     * result in instances not being returned to the pool.
+     */
     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 {
-                        return false;
-                    }
-                }
-                public void activateObject(Object obj) { }
-                public void passivateObject(Object obj) { 
-                    final Integer integer = (Integer)obj;
-                    if (integer.intValue() % 3 == 0) {
-                        throw new RuntimeException("Couldn't passivate: " + integer);
-                    }
-                }
-            }
-        );
-
+        SelectiveFactory factory = new SelectiveFactory();
+        factory.setValidateSelectively(true);  // Even numbers fail validation
+        factory.setPassivateSelectively(true); // Multiples of 3 fail passivation
+        ObjectPool pool = new StackObjectPool(factory, 20);
         Object[] obj = new Object[10];
         for(int i=0;i<10;i++) {
             Object object = null;
@@ -176,9 +174,13 @@ public class TestStackObjectPool extends
                 try {
                     k++;
                     object = pool.borrowObject();
-                    obj[i] = object;
+                    if (((Integer) object).intValue() % 2 == 0) {
+                        fail("Expecting NoSuchElementException");
+                    } else {
+                        obj[i] = object; 
+                    }
                 } catch (NoSuchElementException ex) {
-                    // Expected for evens, which fail validation
+                    // Should fail for evens
                 }
             }
             assertEquals("Each time we borrow, get one more active.", i+1, pool.getNumActive());
@@ -199,43 +201,13 @@ public class TestStackObjectPool extends
         assertEquals(new Integer(1), pool.borrowObject());     
     }
     
+    /**
+     * Verifies that validation and passivation failures returning objects are handled
+     * properly - instances destroyed and not returned to the pool, but no exceptions propagated.
+     */
     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);
+        SelectiveFactory factory = new SelectiveFactory();
+        ObjectPool pool = new StackObjectPool(factory, 20);
 
         Object[] obj = new Object[10];
         for(int i=0;i<10;i++) {
@@ -244,8 +216,8 @@ public class TestStackObjectPool extends
             
         }
         
-        // now reject even numbers
-        factory.reject = true;
+        factory.setValidateSelectively(true);  // Even numbers fail validation
+        factory.setPassivateSelectively(true); // Multiples of 3 fail passivation
 
         for(int i=0;i<10;i++) {
             pool.returnObject(obj[i]);
@@ -254,7 +226,7 @@ public class TestStackObjectPool extends
         // 0,2,4,6,8 fail validation, 3, 9 fail passivation - 3 left.
         assertEquals(3,pool.getNumIdle());
     }
-    
+     
     public void testVariousConstructors() throws Exception {
         {
             StackObjectPool pool = new StackObjectPool();
@@ -281,32 +253,25 @@ public class TestStackObjectPool extends
             assertNotNull(pool);
         }
     }
+    
+    /**
+     * Verify that out of range constructor arguments are ignored.
+     */
+    public void testMaxIdleInitCapacityOutOfRange() throws Exception {
+        SimpleFactory factory = new SimpleFactory();
+        StackObjectPool pool = new StackObjectPool(factory, -1, 0);
+        assertEquals(pool.getMaxSleeping(), StackObjectPool.DEFAULT_MAX_SLEEPING);
+        pool.addObject();
+        pool.close();
+    }
 
-    private final List destroyed = new ArrayList();
+    /**
+     * Verifies that when returning objects cause maxSleeping exceeded, oldest instances
+     * are destroyed to make room for returning objects.
+     */
     public void testReturnObjectDiscardOrder() throws Exception {
-        // setup
-        // We need a factory that tracks what was discarded.
-        PoolableObjectFactory pof = new PoolableObjectFactory() {
-            int i = 0;
-            public Object makeObject() throws Exception {
-                return new Integer(i++);
-            }
-
-            public void destroyObject(Object obj) throws Exception {
-                destroyed.add(obj);
-            }
-
-            public boolean validateObject(Object obj) {
-                return obj instanceof Integer;
-            }
-
-            public void activateObject(Object obj) throws Exception {
-            }
-
-            public void passivateObject(Object obj) throws Exception {
-            }
-        };
-        ObjectPool pool = new StackObjectPool(pof, 3);
+        SelectiveFactory factory = new SelectiveFactory();
+        ObjectPool pool = new StackObjectPool(factory, 3);
 
         // borrow more objects than the pool can hold
         Integer i0 = (Integer)pool.borrowObject();
@@ -321,17 +286,215 @@ public class TestStackObjectPool extends
         pool.returnObject(i2);
 
         // the pool should now be full.
-        assertEquals("No returned objects should have been destroyed yet.",0, destroyed.size());
+        assertEquals("No returned objects should have been destroyed yet.", 0,  factory.getDestroyed().size());
 
-        // cause the pool to discard a returned object.
+        // cause the pool to discard a stale object.
         pool.returnObject(i3);
-        assertEquals("One object should have been destroyed.", 1, destroyed.size());
+        assertEquals("One object should have been destroyed.", 1, factory.getDestroyed().size());
 
         // check to see what object was destroyed
-        Integer d = (Integer)destroyed.get(0);
-        assertEquals("Destoryed objects should have the stalest object.", i0, d);
+        Integer d = (Integer)factory.getDestroyed().get(0);
+        assertEquals("Destoryed object should be the stalest object.", i0, d);
+    }
+    
+    /**
+     * Verifies that exceptions thrown by factory activate method are not propagated to
+     * the caller.  Objects that throw on activate are destroyed and if none succeed,
+     * the caller gets NoSuchElementException.
+     */
+    public void testExceptionOnActivate() throws Exception {
+        SelectiveFactory factory = new SelectiveFactory();
+        ObjectPool pool = new StackObjectPool(factory);
+        pool.addObject();
+        pool.addObject();
+        factory.setThrowOnActivate(true);
+        try {
+            pool.borrowObject();
+            fail("Expecting NoSuchElementException");
+        } catch (NoSuchElementException ex) {
+            // expected
+        }
+        assertEquals(0, pool.getNumIdle());
+        assertEquals(0, pool.getNumActive());
+    }
+    
+    /**
+     * Verifies that exceptions thrown by factory destroy are swallowed
+     * by both addObject and returnObject.
+     */
+    public void testExceptionOnDestroy() throws Exception {
+        SelectiveFactory factory = new SelectiveFactory();
+        ObjectPool pool = new StackObjectPool(factory, 2);
+        factory.setThrowOnDestroy(true);
+        for (int i = 0; i < 3; i++) {
+            pool.addObject(); // Third one will destroy, exception should be swallowed
+        }
+        assertEquals(2, pool.getNumIdle());
+        
+        Object[] objects = new Object[3];
+        for (int i = 0; i < 3; i++) {
+            objects[i] = pool.borrowObject();
+        }
+        for (int i = 0; i < 3; i++) {
+            pool.returnObject(objects[i]); // Third triggers destroy
+        } 
+        assertEquals(2, pool.getNumIdle());
+    }
+    
+    /**
+     * Verifies that addObject propagates exceptions thrown by
+     * factory passivate, but returnObject swallows these.
+     */
+    public void testExceptionOnPassivate() throws Exception {
+        SelectiveFactory factory = new SelectiveFactory();
+        ObjectPool pool = new StackObjectPool(factory, 2);
+        factory.setThrowOnPassivate(true);
+        
+        // addObject propagates
+        try {
+            pool.addObject();
+            fail("Expecting IntegerFactoryException");
+        } catch (IntegerFactoryException ex) {
+            assertEquals("passivateObject", ex.getType());
+            assertEquals(0, ex.getValue());
+        }
+        assertEquals(0, pool.getNumIdle());
+        
+        // returnObject swallows 
+        Object obj = pool.borrowObject();
+        pool.returnObject(obj);
+        assertEquals(0, pool.getNumIdle());
+    }
+    
+    /**
+     * Verifies that validation exceptions always propagate
+     */
+    public void testExceptionOnValidate() throws Exception {
+        SelectiveFactory factory = new SelectiveFactory();
+        ObjectPool pool = new StackObjectPool(factory, 2);
+        factory.setThrowOnValidate(true);
+        
+        // addObject
+        try {
+            pool.addObject();
+            fail("Expecting IntegerFactoryException");
+        } catch (IntegerFactoryException ex) {
+            assertEquals("validateObject", ex.getType());
+        }
+        assertEquals(0, pool.getNumIdle());
+        
+        // returnObject 
+        factory.setThrowOnValidate(false);
+        Object obj = pool.borrowObject();
+        factory.setThrowOnValidate(true);
+        try {
+            pool.returnObject(obj);
+            fail("Expecting IntegerFactoryException");
+        } catch (IntegerFactoryException ex) {
+            assertEquals("validateObject", ex.getType());
+        }
+        assertEquals(0, pool.getNumIdle());
+        
+        // borrowObject - throws NoSuchElementException
+        try {
+            pool.borrowObject();
+            fail("Expecting NoSuchElementException");
+        } catch (NoSuchElementException ex) {
+            // Expected
+        }
+    }
+    
+    /**
+     * Verifies that exceptions thrown by makeObject are propagated.
+     */
+    public void testExceptionOnMake() throws Exception {
+        SelectiveFactory factory = new SelectiveFactory();
+        factory.setThrowOnMake(true);
+        ObjectPool pool = new StackObjectPool(factory);
+        try {
+            pool.borrowObject();
+            fail("Expecting IntegerFactoryException");
+        } catch (IntegerFactoryException ex) {
+            assertEquals("makeObject", ex.getType());
+        }
+        try {
+            pool.addObject();
+            fail("Expecting IntegerFactoryException");
+        } catch (IntegerFactoryException ex) {
+            assertEquals("makeObject", ex.getType());
+        }
+    }
+    
+    /**
+     * Verifies NoSuchElementException when the factory returns a null object in borrowObject
+     */
+    public void testMakeNull() throws Exception {
+        SelectiveFactory factory = new SelectiveFactory();
+        ObjectPool pool = new StackObjectPool(factory);
+        factory.setMakeNull(true);
+        try {
+            pool.borrowObject();
+            fail("Expecting NoSuchElementException");
+        } catch (NoSuchElementException ex) {
+            // Expected
+        }
+    }
+    
+    /**
+     * Verifies that initIdleCapacity is not a hard limit, but maxIdle is.
+     */
+    public void testInitIdleCapacityExceeded() throws Exception {
+        PoolableObjectFactory factory = new SimpleFactory();
+        ObjectPool pool = new StackObjectPool(factory, 2, 1);
+        pool.addObject();
+        pool.addObject();
+        assertEquals(2, pool.getNumIdle());
+        pool.close();
+        pool = new StackObjectPool(factory, 1, 2);
+        pool.addObject();
+        pool.addObject();
+        assertEquals(1, pool.getNumIdle());
+    }
+    
+    /**
+     * Verifies close contract - idle instances are destroyed, returning instances
+     * are destroyed, add/borrowObject throw IllegalStateException.
+     */
+    public void testClose() throws Exception {
+        SelectiveFactory factory = new SelectiveFactory();
+        ObjectPool pool = new StackObjectPool(factory);
+        pool.addObject(); // 0
+        pool.addObject(); // 1
+        pool.addObject(); // 2
+        Integer two = (Integer) pool.borrowObject();
+        assertEquals(2, two.intValue());
+        pool.close();
+        assertEquals(0, pool.getNumIdle());
+        assertEquals(1, pool.getNumActive());
+        List destroyed = factory.getDestroyed();
+        assertEquals(2, destroyed.size());
+        assertTrue(destroyed.contains(new Integer(0)));
+        assertTrue(destroyed.contains(new Integer(0)));
+        pool.returnObject(two);
+        assertTrue(destroyed.contains(two));
+        try {
+            pool.addObject();
+            fail("Expecting IllegalStateException");
+        } catch (IllegalStateException ex) {
+            // Expected
+        }
+        try {
+            pool.borrowObject();
+            fail("Expecting IllegalStateException");
+        } catch (IllegalStateException ex) {
+            // Expected
+        }
     }
 
+    /**
+     * Simple factory that creates Integers. Validation and other factory methods
+     * always succeed.
+     */
     static class SimpleFactory implements PoolableObjectFactory {
         int counter = 0;
         public Object makeObject() { return String.valueOf(counter++); }
@@ -340,6 +503,117 @@ public class TestStackObjectPool extends
         public void activateObject(Object obj) { }
         public void passivateObject(Object obj) { }
     }
+    
+    /**
+     * Integer factory that fails validation and other factory methods "selectively" and
+     * tracks object destruction.
+     */
+    static class SelectiveFactory implements PoolableObjectFactory {
+        private List destroyed = new ArrayList();
+        private int counter = 0;
+        private boolean validateSelectively = false;  // true <-> validate returns
false for even Integers
+        private boolean passivateSelectively = false; // true <-> passivate throws
RTE if Integer = 0 mod 3
+        private boolean throwOnDestroy = false;       // true <-> destroy throws RTE
(always)
+        private boolean throwOnActivate = false;      // true <-> activate throws RTE
(always)
+        private boolean throwOnMake = false;          // true <-> make throws RTE (always)
+        private boolean throwOnValidate= false;       // true <-> validate throws RTE
(always)
+        private boolean throwOnPassivate = false;     // true <-> passivate throws
RTE (always)
+        private boolean makeNull = false;             // true <-> make returns null
+        public Object makeObject() {
+            if (throwOnMake) {
+                final int next = counter + 1;
+                throw new IntegerFactoryException("makeObject", next);
+            } else {
+                return makeNull? null : new Integer(counter++);
+            }
+        }
+        public void destroyObject(Object obj) {
+            if (throwOnDestroy) {
+                final Integer integer = (Integer)obj;
+                throw new IntegerFactoryException("destroyObject", integer.intValue());
+            }
+            destroyed.add(obj);
+        }
+        public boolean validateObject(Object obj) {
+            if (throwOnValidate) {
+                final Integer integer = (Integer)obj;
+                throw new IntegerFactoryException("validateObject", integer.intValue());
+            }
+            if (validateSelectively) {
+                // only odd objects are valid
+                if(obj instanceof Integer) {
+                    return ((((Integer)obj).intValue() % 2) == 1);
+                } else {
+                    return false;
+                }
+            }
+            return true;
+        }
+        public void activateObject(Object obj) {
+            if (throwOnActivate) {
+                final Integer integer = (Integer)obj;
+                throw new IntegerFactoryException("activateObject", integer.intValue());
+            }
+        }
+        public void passivateObject(Object obj) { 
+            if (throwOnPassivate) {
+                final Integer integer = (Integer)obj;
+                throw new IntegerFactoryException("passivateObject", integer.intValue());
+            }
+            if (passivateSelectively) {
+                final Integer integer = (Integer)obj;
+                if (integer.intValue() % 3 == 0) {
+                    throw new IntegerFactoryException("passivateObject", integer.intValue());
+                }
+            }
+        }
+        public List getDestroyed() {
+            return destroyed;
+        }
+        public void setCounter(int counter) {
+            this.counter = counter;
+        }
+        public void setValidateSelectively(boolean validateSelectively) {
+            this.validateSelectively = validateSelectively;
+        }
+        public void setPassivateSelectively(boolean passivateSelectively) {
+            this.passivateSelectively = passivateSelectively;
+        }
+        public void setThrowOnDestroy(boolean throwOnDestroy) {
+            this.throwOnDestroy = throwOnDestroy;
+        }
+        public void setThrowOnActivate(boolean throwOnActivate) {
+            this.throwOnActivate = throwOnActivate;
+        }
+        public void setThrowOnMake(boolean throwOnMake) {
+            this.throwOnMake = throwOnMake;
+        }
+        public void setThrowOnPassivate(boolean throwOnPassivate) {
+            this.throwOnPassivate = throwOnPassivate;
+        }
+        public void setThrowOnValidate(boolean throwOnValidate) {
+            this.throwOnValidate = throwOnValidate;
+        }
+        public void setMakeNull(boolean makeNull) {
+            this.makeNull = makeNull;
+        }
+    }
+    
+    static class IntegerFactoryException extends RuntimeException {
+        private String type;
+        private int value;
+        public IntegerFactoryException(String type, int value) {
+            super(type + " failed. Value: " + value);
+            this.type = type;
+            this.value = value;
+        }
+        public String getType() {
+            return type;
+        }
+        public int getValue() {
+            return value;
+        }
+    }
 
     protected boolean isLifo() {
         return true;



Mime
View raw message