src/test/org/apache/commons/pool/impl/TestGenericKeyedObjectPool.java - commons-pool - Git at Google

 /*
  * $Id: TestGenericKeyedObjectPool.java,v 1.13 2003/04/24 20:14:03 rwaldhoff Exp $
  * $Revision: 1.13 $
  * $Date: 2003/04/24 20:14:03 $
  *
  * ====================================================================
  *
  * The Apache Software License, Version 1.1
  *
  * Copyright (c) 2001-2002 The Apache Software Foundation.  All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * 3. The end-user documentation included with the redistribution, if
  *    any, must include the following acknowlegement:
  *       "This product includes software developed by the
  *        Apache Software Foundation (http://www.apache.org/)."
  *    Alternately, this acknowlegement may appear in the software itself,
  *    if and wherever such third-party acknowlegements normally appear.
  *
  * 4. The names "The Jakarta Project", "Commons", and "Apache Software
  *    Foundation" must not be used to endorse or promote products derived
  *    from this software without prior written permission. For written
  *    permission, please contact apache@apache.org.
  *
  * 5. Products derived from this software may not be called "Apache"
  *    nor may "Apache" appear in their names without prior written
  *    permission of the Apache Group.
  *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * ====================================================================
  *
  * This software consists of voluntary contributions made by many
  * individuals on behalf of the Apache Software Foundation.  For more
  * information on the Apache Software Foundation, please see
  * <http://www.apache.org/>.
  *
  */

 package org.apache.commons.pool.impl;

 import java.util.HashMap;
 import java.util.NoSuchElementException;

 import junit.framework.Test;
 import junit.framework.TestSuite;

 import org.apache.commons.pool.KeyedObjectPool;
 import org.apache.commons.pool.KeyedPoolableObjectFactory;
 import org.apache.commons.pool.TestKeyedObjectPool;

 /**
  * @author Rodney Waldhoff
  * @version $Revision: 1.13 $ $Date: 2003/04/24 20:14:03 $
  */
 public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
     public TestGenericKeyedObjectPool(String testName) {
         super(testName);
     }

     public static Test suite() {
         return new TestSuite(TestGenericKeyedObjectPool.class);
     }

     protected KeyedObjectPool makeEmptyPool(int mincapacity) {
         GenericKeyedObjectPool pool = new GenericKeyedObjectPool(
             new KeyedPoolableObjectFactory()  {
                 HashMap map = new HashMap();
                 public Object makeObject(Object key) {
                     int counter = 0;
                     Integer Counter = (Integer)(map.get(key));
                     if(null != Counter) {
                         counter = Counter.intValue();
                     }
                     map.put(key,new Integer(counter + 1));
                     return String.valueOf(key) + String.valueOf(counter);
                 }
                 public void destroyObject(Object key, Object obj) { }
                 public boolean validateObject(Object key, Object obj) { return true; }
                 public void activateObject(Object key, Object obj) { }
                 public void passivateObject(Object key, Object obj) { }
             }
         );
         pool.setMaxActive(mincapacity);
         pool.setMaxIdle(mincapacity);
         return pool;
     }

     protected Object getNthObject(Object key, int n) {
         return String.valueOf(key) + String.valueOf(n);
     }

     protected Object makeKey(int n) {
         return String.valueOf(n);
     }

     private GenericKeyedObjectPool pool = null;

     public void setUp() throws Exception {
         super.setUp();
         pool = new GenericKeyedObjectPool(new SimpleFactory());
     }

     public void tearDown() throws Exception {
         super.tearDown();
         pool.close();
         pool = null;
     }

     public void testWithInitiallyInvalid() throws Exception {
         GenericKeyedObjectPool pool = new GenericKeyedObjectPool(new SimpleFactory(false));
         pool.setTestOnBorrow(true);
         try {
             pool.borrowObject("xyzzy");
             fail("Expected NoSuchElementException");
         } catch(NoSuchElementException e) {
             // expected
         }
     }

     public void testZeroMaxActive() throws Exception {
         pool.setMaxActive(0);
         pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL);
         Object obj = pool.borrowObject("");
         assertEquals("0",obj);
         pool.returnObject("",obj);
     }

     public void testNegativeMaxActive() throws Exception {
         pool.setMaxActive(-1);
         pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL);
         Object obj = pool.borrowObject("");
         assertEquals("0",obj);
         pool.returnObject("",obj);
     }

     public void testNumActiveNumIdle2() throws Exception {
         assertEquals(0,pool.getNumActive());
         assertEquals(0,pool.getNumIdle());
         assertEquals(0,pool.getNumActive("A"));
         assertEquals(0,pool.getNumIdle("A"));
         assertEquals(0,pool.getNumActive("B"));
         assertEquals(0,pool.getNumIdle("B"));

         Object objA0 = pool.borrowObject("A");
         Object objB0 = pool.borrowObject("B");

         assertEquals(2,pool.getNumActive());
         assertEquals(0,pool.getNumIdle());
         assertEquals(1,pool.getNumActive("A"));
         assertEquals(0,pool.getNumIdle("A"));
         assertEquals(1,pool.getNumActive("B"));
         assertEquals(0,pool.getNumIdle("B"));

         Object objA1 = pool.borrowObject("A");
         Object objB1 = pool.borrowObject("B");

         assertEquals(4,pool.getNumActive());
         assertEquals(0,pool.getNumIdle());
         assertEquals(2,pool.getNumActive("A"));
         assertEquals(0,pool.getNumIdle("A"));
         assertEquals(2,pool.getNumActive("B"));
         assertEquals(0,pool.getNumIdle("B"));

         pool.returnObject("A",objA0);
         pool.returnObject("B",objB0);

         assertEquals(2,pool.getNumActive());
         assertEquals(2,pool.getNumIdle());
         assertEquals(1,pool.getNumActive("A"));
         assertEquals(1,pool.getNumIdle("A"));
         assertEquals(1,pool.getNumActive("B"));
         assertEquals(1,pool.getNumIdle("B"));

         pool.returnObject("A",objA1);
         pool.returnObject("B",objB1);

         assertEquals(0,pool.getNumActive());
         assertEquals(4,pool.getNumIdle());
         assertEquals(0,pool.getNumActive("A"));
         assertEquals(2,pool.getNumIdle("A"));
         assertEquals(0,pool.getNumActive("B"));
         assertEquals(2,pool.getNumIdle("B"));
     }

     public void testMaxIdle() throws Exception {
         pool.setMaxActive(100);
         pool.setMaxIdle(8);
         Object[] active = new Object[100];
         for(int i=0;i<100;i++) {
             active[i] = pool.borrowObject("");
         }
         assertEquals(100,pool.getNumActive(""));
         assertEquals(0,pool.getNumIdle(""));
         for(int i=0;i<100;i++) {
             pool.returnObject("",active[i]);
             assertEquals(99 - i,pool.getNumActive(""));
             assertEquals((i < 8 ? i+1 : 8),pool.getNumIdle(""));
         }
     }

     public void testMaxActive() throws Exception {
         pool.setMaxActive(3);
         pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL);

         pool.borrowObject("");
         pool.borrowObject("");
         pool.borrowObject("");
         try {
             pool.borrowObject("");
             fail("Expected NoSuchElementException");
         } catch(NoSuchElementException e) {
             // expected
         }
     }

     public void testSettersAndGetters() throws Exception {
         GenericKeyedObjectPool pool = new GenericKeyedObjectPool();
         {
             pool.setFactory(new SimpleFactory());
         }
         {
             pool.setMaxActive(123);
             assertEquals(123,pool.getMaxActive());
         }
         {
             pool.setMaxIdle(12);
             assertEquals(12,pool.getMaxIdle());
         }
         {
             pool.setMaxWait(1234L);
             assertEquals(1234L,pool.getMaxWait());
         }
         {
             pool.setMinEvictableIdleTimeMillis(12345L);
             assertEquals(12345L,pool.getMinEvictableIdleTimeMillis());
         }
         {
             pool.setNumTestsPerEvictionRun(11);
             assertEquals(11,pool.getNumTestsPerEvictionRun());
         }
         {
             pool.setTestOnBorrow(true);
             assertTrue(pool.getTestOnBorrow());
             pool.setTestOnBorrow(false);
             assertTrue(!pool.getTestOnBorrow());
         }
         {
             pool.setTestOnReturn(true);
             assertTrue(pool.getTestOnReturn());
             pool.setTestOnReturn(false);
             assertTrue(!pool.getTestOnReturn());
         }
         {
             pool.setTestWhileIdle(true);
             assertTrue(pool.getTestWhileIdle());
             pool.setTestWhileIdle(false);
             assertTrue(!pool.getTestWhileIdle());
         }
         {
             pool.setTimeBetweenEvictionRunsMillis(11235L);
             assertEquals(11235L,pool.getTimeBetweenEvictionRunsMillis());
         }
         {
             pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_BLOCK);
             assertEquals(GenericObjectPool.WHEN_EXHAUSTED_BLOCK,pool.getWhenExhaustedAction());
             pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL);
             assertEquals(GenericObjectPool.WHEN_EXHAUSTED_FAIL,pool.getWhenExhaustedAction());
             pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_GROW);
             assertEquals(GenericObjectPool.WHEN_EXHAUSTED_GROW,pool.getWhenExhaustedAction());
         }
     }

     public void testEviction() throws Exception {
         pool.setMaxIdle(500);
         pool.setMaxActive(500);
         pool.setNumTestsPerEvictionRun(100);
         pool.setMinEvictableIdleTimeMillis(500L);
         pool.setTimeBetweenEvictionRunsMillis(500L);

         Object[] active = new Object[500];
         for(int i=0;i<500;i++) {
             active[i] = pool.borrowObject("");
         }
         for(int i=0;i<500;i++) {
             pool.returnObject("",active[i]);
         }

         try { Thread.sleep(1000L); } catch(Exception e) { }
         assertTrue("Should be less than 500 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 500);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 400 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 400);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 300 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 300);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 200 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 200);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 100 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 100);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertEquals("Should be zero idle, found " + pool.getNumIdle(""),0,pool.getNumIdle(""));

         for(int i=0;i<500;i++) {
             active[i] = pool.borrowObject("");
         }
         for(int i=0;i<500;i++) {
             pool.returnObject("",active[i]);
         }

         try { Thread.sleep(1000L); } catch(Exception e) { }
         assertTrue("Should be less than 500 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 500);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 400 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 400);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 300 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 300);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 200 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 200);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 100 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 100);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertEquals("Should be zero idle, found " + pool.getNumIdle(""),0,pool.getNumIdle(""));
     }

     public void testEviction2() throws Exception {
         pool.setMaxIdle(500);
         pool.setMaxActive(500);
         pool.setNumTestsPerEvictionRun(100);
         pool.setMinEvictableIdleTimeMillis(500L);
         pool.setTimeBetweenEvictionRunsMillis(500L);

         Object[] active = new Object[500];
         Object[] active2 = new Object[500];
         for(int i=0;i<500;i++) {
             active[i] = pool.borrowObject("");
             active2[i] = pool.borrowObject("2");
         }
         for(int i=0;i<500;i++) {
             pool.returnObject("",active[i]);
             pool.returnObject("2",active2[i]);
         }

         try { Thread.sleep(1000L); } catch(Exception e) { }
         assertTrue("Should be less than 1000 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 1000);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 900 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 900);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 800 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 800);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 700 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 700);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 600 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 600);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 500 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 500);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 400 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 400);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 300 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 300);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 200 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 200);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertTrue("Should be less than 100 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 100);
         try { Thread.sleep(600L); } catch(Exception e) { }
         assertEquals("Should be zero idle, found " + pool.getNumIdle(),0,pool.getNumIdle());
     }

     public void testThreaded1() throws Exception {
         pool.setMaxActive(15);
         pool.setMaxIdle(15);
         pool.setMaxWait(1000L);
         TestThread[] threads = new TestThread[20];
         for(int i=0;i<20;i++) {
             threads[i] = new TestThread(pool,100,50);
             Thread t = new Thread(threads[i]);
             t.start();
         }
         for(int i=0;i<20;i++) {
             while(!(threads[i]).complete()) {
                 try {
                     Thread.sleep(500L);
                 } catch(Exception e) {
                     // ignored
                 }
             }
             if(threads[i].failed()) {
                 fail();
             }
         }
     }

     class TestThread implements Runnable {
         java.util.Random _random = new java.util.Random();
         KeyedObjectPool _pool = null;
         boolean _complete = false;
         boolean _failed = false;
         int _iter = 100;
         int _delay = 50;

         public TestThread(KeyedObjectPool pool) {
             _pool = pool;
         }

         public TestThread(KeyedObjectPool pool, int iter) {
             _pool = pool;
             _iter = iter;
         }

         public TestThread(KeyedObjectPool pool, int iter, int delay) {
             _pool = pool;
             _iter = iter;
             _delay = delay;
         }

         public boolean complete() {
             return _complete;
         }

         public boolean failed() {
             return _failed;
         }

         public void run() {
             for(int i=0;i<_iter;i++) {
                 String key = String.valueOf(_random.nextInt(3));
                 try {
                     Thread.sleep((long)_random.nextInt(_delay));
                 } catch(Exception e) {
                     // ignored
                 }
                 Object obj = null;
                 try {
                     obj = _pool.borrowObject(key);
                 } catch(Exception e) {
                     _failed = true;
                     _complete = true;
                     break;
                 }

                 try {
                     Thread.sleep((long)_random.nextInt(_delay));
                 } catch(Exception e) {
                     // ignored
                 }
                 try {
                     _pool.returnObject(key,obj);
                 } catch(Exception e) {
                     _failed = true;
                     _complete = true;
                     break;
                 }
             }
             _complete = true;
         }
     }

     static class SimpleFactory implements KeyedPoolableObjectFactory {
         public SimpleFactory() {
             this(true);
         }
         public SimpleFactory(boolean valid) {
             this.valid = valid;
         }
         public Object makeObject(Object key) { return String.valueOf(key) + String.valueOf(counter++); }
         public void destroyObject(Object key, Object obj) { }
         public boolean validateObject(Object key, Object obj) { return valid; }
         public void activateObject(Object key, Object obj) { }
         public void passivateObject(Object key, Object obj) { }
         int counter = 0;
         boolean valid;
     }

 }
	/*
	* $Id: TestGenericKeyedObjectPool.java,v 1.13 2003/04/24 20:14:03 rwaldhoff Exp $
	* $Revision: 1.13 $
	* $Date: 2003/04/24 20:14:03 $
	*
	* ====================================================================
	*
	* The Apache Software License, Version 1.1
	*
	* Copyright (c) 2001-2002 The Apache Software Foundation. All rights
	* reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	*
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in
	* the documentation and/or other materials provided with the
	* distribution.
	*
	* 3. The end-user documentation included with the redistribution, if
	* any, must include the following acknowlegement:
	* "This product includes software developed by the
	* Apache Software Foundation (http://www.apache.org/)."
	* Alternately, this acknowlegement may appear in the software itself,
	* if and wherever such third-party acknowlegements normally appear.
	*
	* 4. The names "The Jakarta Project", "Commons", and "Apache Software
	* Foundation" must not be used to endorse or promote products derived
	* from this software without prior written permission. For written
	* permission, please contact apache@apache.org.
	*
	* 5. Products derived from this software may not be called "Apache"
	* nor may "Apache" appear in their names without prior written
	* permission of the Apache Group.
	*
	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	* ====================================================================
	*
	* This software consists of voluntary contributions made by many
	* individuals on behalf of the Apache Software Foundation. For more
	* information on the Apache Software Foundation, please see
	* <http://www.apache.org/>.
	*
	*/

	package org.apache.commons.pool.impl;

	import java.util.HashMap;
	import java.util.NoSuchElementException;

	import junit.framework.Test;
	import junit.framework.TestSuite;

	import org.apache.commons.pool.KeyedObjectPool;
	import org.apache.commons.pool.KeyedPoolableObjectFactory;
	import org.apache.commons.pool.TestKeyedObjectPool;

	/**
	* @author Rodney Waldhoff
	* @version $Revision: 1.13 $ $Date: 2003/04/24 20:14:03 $
	*/
	public class TestGenericKeyedObjectPool extends TestKeyedObjectPool {
	public TestGenericKeyedObjectPool(String testName) {
	super(testName);
	}

	public static Test suite() {
	return new TestSuite(TestGenericKeyedObjectPool.class);
	}

	protected KeyedObjectPool makeEmptyPool(int mincapacity) {
	GenericKeyedObjectPool pool = new GenericKeyedObjectPool(
	new KeyedPoolableObjectFactory() {
	HashMap map = new HashMap();
	public Object makeObject(Object key) {
	int counter = 0;
	Integer Counter = (Integer)(map.get(key));
	if(null != Counter) {
	counter = Counter.intValue();
	}
	map.put(key,new Integer(counter + 1));
	return String.valueOf(key) + String.valueOf(counter);
	}
	public void destroyObject(Object key, Object obj) { }
	public boolean validateObject(Object key, Object obj) { return true; }
	public void activateObject(Object key, Object obj) { }
	public void passivateObject(Object key, Object obj) { }
	}
	);
	pool.setMaxActive(mincapacity);
	pool.setMaxIdle(mincapacity);
	return pool;
	}

	protected Object getNthObject(Object key, int n) {
	return String.valueOf(key) + String.valueOf(n);
	}

	protected Object makeKey(int n) {
	return String.valueOf(n);
	}

	private GenericKeyedObjectPool pool = null;

	public void setUp() throws Exception {
	super.setUp();
	pool = new GenericKeyedObjectPool(new SimpleFactory());
	}

	public void tearDown() throws Exception {
	super.tearDown();
	pool.close();
	pool = null;
	}

	public void testWithInitiallyInvalid() throws Exception {
	GenericKeyedObjectPool pool = new GenericKeyedObjectPool(new SimpleFactory(false));
	pool.setTestOnBorrow(true);
	try {
	pool.borrowObject("xyzzy");
	fail("Expected NoSuchElementException");
	} catch(NoSuchElementException e) {
	// expected
	}
	}

	public void testZeroMaxActive() throws Exception {
	pool.setMaxActive(0);
	pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL);
	Object obj = pool.borrowObject("");
	assertEquals("0",obj);
	pool.returnObject("",obj);
	}

	public void testNegativeMaxActive() throws Exception {
	pool.setMaxActive(-1);
	pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL);
	Object obj = pool.borrowObject("");
	assertEquals("0",obj);
	pool.returnObject("",obj);
	}

	public void testNumActiveNumIdle2() throws Exception {
	assertEquals(0,pool.getNumActive());
	assertEquals(0,pool.getNumIdle());
	assertEquals(0,pool.getNumActive("A"));
	assertEquals(0,pool.getNumIdle("A"));
	assertEquals(0,pool.getNumActive("B"));
	assertEquals(0,pool.getNumIdle("B"));

	Object objA0 = pool.borrowObject("A");
	Object objB0 = pool.borrowObject("B");

	assertEquals(2,pool.getNumActive());
	assertEquals(0,pool.getNumIdle());
	assertEquals(1,pool.getNumActive("A"));
	assertEquals(0,pool.getNumIdle("A"));
	assertEquals(1,pool.getNumActive("B"));
	assertEquals(0,pool.getNumIdle("B"));

	Object objA1 = pool.borrowObject("A");
	Object objB1 = pool.borrowObject("B");

	assertEquals(4,pool.getNumActive());
	assertEquals(0,pool.getNumIdle());
	assertEquals(2,pool.getNumActive("A"));
	assertEquals(0,pool.getNumIdle("A"));
	assertEquals(2,pool.getNumActive("B"));
	assertEquals(0,pool.getNumIdle("B"));

	pool.returnObject("A",objA0);
	pool.returnObject("B",objB0);

	assertEquals(2,pool.getNumActive());
	assertEquals(2,pool.getNumIdle());
	assertEquals(1,pool.getNumActive("A"));
	assertEquals(1,pool.getNumIdle("A"));
	assertEquals(1,pool.getNumActive("B"));
	assertEquals(1,pool.getNumIdle("B"));

	pool.returnObject("A",objA1);
	pool.returnObject("B",objB1);

	assertEquals(0,pool.getNumActive());
	assertEquals(4,pool.getNumIdle());
	assertEquals(0,pool.getNumActive("A"));
	assertEquals(2,pool.getNumIdle("A"));
	assertEquals(0,pool.getNumActive("B"));
	assertEquals(2,pool.getNumIdle("B"));
	}

	public void testMaxIdle() throws Exception {
	pool.setMaxActive(100);
	pool.setMaxIdle(8);
	Object[] active = new Object[100];
	for(int i=0;i<100;i++) {
	active[i] = pool.borrowObject("");
	}
	assertEquals(100,pool.getNumActive(""));
	assertEquals(0,pool.getNumIdle(""));
	for(int i=0;i<100;i++) {
	pool.returnObject("",active[i]);
	assertEquals(99 - i,pool.getNumActive(""));
	assertEquals((i < 8 ? i+1 : 8),pool.getNumIdle(""));
	}
	}

	public void testMaxActive() throws Exception {
	pool.setMaxActive(3);
	pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL);

	pool.borrowObject("");
	pool.borrowObject("");
	pool.borrowObject("");
	try {
	pool.borrowObject("");
	fail("Expected NoSuchElementException");
	} catch(NoSuchElementException e) {
	// expected
	}
	}

	public void testSettersAndGetters() throws Exception {
	GenericKeyedObjectPool pool = new GenericKeyedObjectPool();
	{
	pool.setFactory(new SimpleFactory());
	}
	{
	pool.setMaxActive(123);
	assertEquals(123,pool.getMaxActive());
	}
	{
	pool.setMaxIdle(12);
	assertEquals(12,pool.getMaxIdle());
	}
	{
	pool.setMaxWait(1234L);
	assertEquals(1234L,pool.getMaxWait());
	}
	{
	pool.setMinEvictableIdleTimeMillis(12345L);
	assertEquals(12345L,pool.getMinEvictableIdleTimeMillis());
	}
	{
	pool.setNumTestsPerEvictionRun(11);
	assertEquals(11,pool.getNumTestsPerEvictionRun());
	}
	{
	pool.setTestOnBorrow(true);
	assertTrue(pool.getTestOnBorrow());
	pool.setTestOnBorrow(false);
	assertTrue(!pool.getTestOnBorrow());
	}
	{
	pool.setTestOnReturn(true);
	assertTrue(pool.getTestOnReturn());
	pool.setTestOnReturn(false);
	assertTrue(!pool.getTestOnReturn());
	}
	{
	pool.setTestWhileIdle(true);
	assertTrue(pool.getTestWhileIdle());
	pool.setTestWhileIdle(false);
	assertTrue(!pool.getTestWhileIdle());
	}
	{
	pool.setTimeBetweenEvictionRunsMillis(11235L);
	assertEquals(11235L,pool.getTimeBetweenEvictionRunsMillis());
	}
	{
	pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_BLOCK);
	assertEquals(GenericObjectPool.WHEN_EXHAUSTED_BLOCK,pool.getWhenExhaustedAction());
	pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL);
	assertEquals(GenericObjectPool.WHEN_EXHAUSTED_FAIL,pool.getWhenExhaustedAction());
	pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_GROW);
	assertEquals(GenericObjectPool.WHEN_EXHAUSTED_GROW,pool.getWhenExhaustedAction());
	}
	}

	public void testEviction() throws Exception {
	pool.setMaxIdle(500);
	pool.setMaxActive(500);
	pool.setNumTestsPerEvictionRun(100);
	pool.setMinEvictableIdleTimeMillis(500L);
	pool.setTimeBetweenEvictionRunsMillis(500L);

	Object[] active = new Object[500];
	for(int i=0;i<500;i++) {
	active[i] = pool.borrowObject("");
	}
	for(int i=0;i<500;i++) {
	pool.returnObject("",active[i]);
	}

	try { Thread.sleep(1000L); } catch(Exception e) { }
	assertTrue("Should be less than 500 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 500);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 400 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 400);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 300 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 300);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 200 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 200);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 100 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 100);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertEquals("Should be zero idle, found " + pool.getNumIdle(""),0,pool.getNumIdle(""));

	for(int i=0;i<500;i++) {
	active[i] = pool.borrowObject("");
	}
	for(int i=0;i<500;i++) {
	pool.returnObject("",active[i]);
	}

	try { Thread.sleep(1000L); } catch(Exception e) { }
	assertTrue("Should be less than 500 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 500);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 400 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 400);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 300 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 300);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 200 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 200);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 100 idle, found " + pool.getNumIdle(""),pool.getNumIdle("") < 100);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertEquals("Should be zero idle, found " + pool.getNumIdle(""),0,pool.getNumIdle(""));
	}

	public void testEviction2() throws Exception {
	pool.setMaxIdle(500);
	pool.setMaxActive(500);
	pool.setNumTestsPerEvictionRun(100);
	pool.setMinEvictableIdleTimeMillis(500L);
	pool.setTimeBetweenEvictionRunsMillis(500L);

	Object[] active = new Object[500];
	Object[] active2 = new Object[500];
	for(int i=0;i<500;i++) {
	active[i] = pool.borrowObject("");
	active2[i] = pool.borrowObject("2");
	}
	for(int i=0;i<500;i++) {
	pool.returnObject("",active[i]);
	pool.returnObject("2",active2[i]);
	}

	try { Thread.sleep(1000L); } catch(Exception e) { }
	assertTrue("Should be less than 1000 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 1000);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 900 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 900);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 800 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 800);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 700 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 700);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 600 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 600);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 500 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 500);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 400 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 400);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 300 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 300);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 200 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 200);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertTrue("Should be less than 100 idle, found " + pool.getNumIdle(),pool.getNumIdle() < 100);
	try { Thread.sleep(600L); } catch(Exception e) { }
	assertEquals("Should be zero idle, found " + pool.getNumIdle(),0,pool.getNumIdle());
	}

	public void testThreaded1() throws Exception {
	pool.setMaxActive(15);
	pool.setMaxIdle(15);
	pool.setMaxWait(1000L);
	TestThread[] threads = new TestThread[20];
	for(int i=0;i<20;i++) {
	threads[i] = new TestThread(pool,100,50);
	Thread t = new Thread(threads[i]);
	t.start();
	}
	for(int i=0;i<20;i++) {
	while(!(threads[i]).complete()) {
	try {
	Thread.sleep(500L);
	} catch(Exception e) {
	// ignored
	}
	}
	if(threads[i].failed()) {
	fail();
	}
	}
	}

	class TestThread implements Runnable {
	java.util.Random _random = new java.util.Random();
	KeyedObjectPool _pool = null;
	boolean _complete = false;
	boolean _failed = false;
	int _iter = 100;
	int _delay = 50;

	public TestThread(KeyedObjectPool pool) {
	_pool = pool;
	}

	public TestThread(KeyedObjectPool pool, int iter) {
	_pool = pool;
	_iter = iter;
	}

	public TestThread(KeyedObjectPool pool, int iter, int delay) {
	_pool = pool;
	_iter = iter;
	_delay = delay;
	}

	public boolean complete() {
	return _complete;
	}

	public boolean failed() {
	return _failed;
	}

	public void run() {
	for(int i=0;i<_iter;i++) {
	String key = String.valueOf(_random.nextInt(3));
	try {
	Thread.sleep((long)_random.nextInt(_delay));
	} catch(Exception e) {
	// ignored
	}
	Object obj = null;
	try {
	obj = _pool.borrowObject(key);
	} catch(Exception e) {
	_failed = true;
	_complete = true;
	break;
	}

	try {
	Thread.sleep((long)_random.nextInt(_delay));
	} catch(Exception e) {
	// ignored
	}
	try {
	_pool.returnObject(key,obj);
	} catch(Exception e) {
	_failed = true;
	_complete = true;
	break;
	}
	}
	_complete = true;
	}
	}

	static class SimpleFactory implements KeyedPoolableObjectFactory {
	public SimpleFactory() {
	this(true);
	}
	public SimpleFactory(boolean valid) {
	this.valid = valid;
	}
	public Object makeObject(Object key) { return String.valueOf(key) + String.valueOf(counter++); }
	public void destroyObject(Object key, Object obj) { }
	public boolean validateObject(Object key, Object obj) { return valid; }
	public void activateObject(Object key, Object obj) { }
	public void passivateObject(Object key, Object obj) { }
	int counter = 0;
	boolean valid;
	}

	}