| Method from org.apache.commons.pool.impl.TestGenericKeyedObjectPool Detail: |
|---|
 protected Object getNthObject(Object key,
int n) {
return String.valueOf(key) + String.valueOf(n);
}
|
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 makeKey(int n) {
return String.valueOf(n);
} |
public void setUp() throws Exception {
super.setUp();
pool = new GenericKeyedObjectPool(new SimpleFactory());
} |
public static Test suite() {
return new TestSuite(TestGenericKeyedObjectPool.class);
} |
public void tearDown() throws Exception {
super.tearDown();
pool.close();
pool = null;
} |
public void testEviction() throws Exception {
pool.setMaxIdle(500);
pool.setMaxActive(500);
pool.setNumTestsPerEvictionRun(100);
pool.setMinEvictableIdleTimeMillis(250L);
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 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 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 testMaxTotal() throws Exception {
pool.setMaxActive(2);
pool.setMaxTotal(3);
pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL);
Object o1 = pool.borrowObject("a");
assertNotNull(o1);
Object o2 = pool.borrowObject("a");
assertNotNull(o2);
Object o3 = pool.borrowObject("b");
assertNotNull(o3);
try {
pool.borrowObject("c");
fail("Expected NoSuchElementException");
} catch(NoSuchElementException e) {
// expected
}
assertEquals(0, pool.getNumIdle());
pool.returnObject("b", o3);
assertEquals(1, pool.getNumIdle());
assertEquals(1, pool.getNumIdle("b"));
Object o4 = pool.borrowObject("b");
assertNotNull(o4);
assertEquals(0, pool.getNumIdle());
assertEquals(0, pool.getNumIdle("b"));
} |
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 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 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();
}
}
} |
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);
} |
junit.framework.TestCase
Save This Page