/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.pool2;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericKeyedObjectPool;
import org.junit.After;
import org.junit.Test;
/**
* Abstract test case for {@link ObjectPool} implementations.
*/
public abstract class TestKeyedObjectPool {
/**
* Create an {@code KeyedObjectPool} with the specified factory.
* The pool should be in a default configuration and conform to the expected
* behaviors described in {@link KeyedObjectPool}.
* Generally speaking there should be no limits on the various object counts.
*
* @param factory Factory to use to associate with the pool
* @return The newly created empty pool
*/
protected abstract KeyedObjectPool<Object,Object> makeEmptyPool(
KeyedPooledObjectFactory<Object,Object> factory);
protected static final String KEY = "key";
private KeyedObjectPool<Object,Object> _pool = null;
protected abstract Object makeKey(int n);
protected abstract boolean isFifo();
protected abstract boolean isLifo();
@After
public void tearDown() throws Exception {
_pool = null;
}
/**
* Create an {@link KeyedObjectPool} instance
* that can contain at least <i>minCapacity</i>
* idle and active objects, or
* throw {@link IllegalArgumentException}
* if such a pool cannot be created.
* @param minCapacity Minimum capacity of the pool to create
*
* @return the newly created keyed object pool
*/
protected abstract KeyedObjectPool<Object,Object> makeEmptyPool(int minCapacity);
/**
* Return what we expect to be the n<sup>th</sup>
* object (zero indexed) created by the pool
* for the given key.
* @param key Key for the object to be obtained
* @param n index of the object to be obtained
*
* @return the requested object
*/
protected abstract Object getNthObject(Object key, int n);
@Test
public void testClosedPoolBehavior() throws Exception {
final KeyedObjectPool<Object,Object> pool;
try {
pool = makeEmptyPool(new TestFactory());
} catch(final UnsupportedOperationException uoe) {
return; // test not supported
}
final Object o1 = pool.borrowObject(KEY);
final Object o2 = pool.borrowObject(KEY);
pool.close();
try {
pool.addObject(KEY);
fail("A closed pool must throw an IllegalStateException when addObject is called.");
} catch (final IllegalStateException ise) {
// expected
}
try {
pool.borrowObject(KEY);
fail("A closed pool must throw an IllegalStateException when borrowObject is called.");
} catch (final IllegalStateException ise) {
// expected
}
// The following should not throw exceptions just because the pool is closed.
assertEquals("A closed pool shouldn't have any idle objects.", 0, pool.getNumIdle(KEY));
assertEquals("A closed pool shouldn't have any idle objects.", 0, pool.getNumIdle());
pool.getNumActive();
pool.getNumActive(KEY);
pool.returnObject(KEY, o1);
assertEquals("returnObject should not add items back into the idle object pool for a closed pool.", 0, pool.getNumIdle(KEY));
assertEquals("returnObject should not add items back into the idle object pool for a closed pool.", 0, pool.getNumIdle());
pool.invalidateObject(KEY, o2);
pool.clear(KEY);
pool.clear();
pool.close();
}
// Deliberate choice to create a new object in case future unit tests check
// for a specific object.
private final Integer ZERO = new Integer(0);
private final Integer ONE = new Integer(1);
@Test
public void testKPOFAddObjectUsage() throws Exception {
final FailingKeyedPooledObjectFactory factory = new FailingKeyedPooledObjectFactory();
final KeyedObjectPool<Object,Object> pool;
try {
pool = makeEmptyPool(factory);
} catch(final UnsupportedOperationException uoe) {
return; // test not supported
}
final List<MethodCall> expectedMethods = new ArrayList<>();
// addObject should make a new object, passivate it and put it in the pool
pool.addObject(KEY);
expectedMethods.add(new MethodCall("makeObject", KEY).returned(ZERO));
expectedMethods.add(new MethodCall("passivateObject", KEY, ZERO));
assertEquals(expectedMethods, factory.getMethodCalls());
//// Test exception handling of addObject
reset(pool, factory, expectedMethods);
// makeObject Exceptions should be propagated to client code from addObject
factory.setMakeObjectFail(true);
try {
pool.addObject(KEY);
fail("Expected addObject to propagate makeObject exception.");
} catch (final PrivateException pe) {
// expected
}
expectedMethods.add(new MethodCall("makeObject", KEY));
assertEquals(expectedMethods, factory.getMethodCalls());
clear(factory, expectedMethods);
// passivateObject Exceptions should be propagated to client code from addObject
factory.setMakeObjectFail(false);
factory.setPassivateObjectFail(true);
try {
pool.addObject(KEY);
fail("Expected addObject to propagate passivateObject exception.");
} catch (final PrivateException pe) {
// expected
}
expectedMethods.add(new MethodCall("makeObject", KEY).returned(ONE));
expectedMethods.add(new MethodCall("passivateObject", KEY, ONE));
assertEquals(expectedMethods, factory.getMethodCalls());
pool.close();
}
@Test
public void testKPOFBorrowObjectUsages() throws Exception {
final FailingKeyedPooledObjectFactory factory = new FailingKeyedPooledObjectFactory();
final KeyedObjectPool<Object,Object> pool;
try {
pool = makeEmptyPool(factory);
} catch(final UnsupportedOperationException uoe) {
return; // test not supported
}
final List<MethodCall> expectedMethods = new ArrayList<>();
Object obj;
if (pool instanceof GenericKeyedObjectPool) {
((GenericKeyedObjectPool<Object,Object>) pool).setTestOnBorrow(true);
}
/// Test correct behavior code paths
// existing idle object should be activated and validated
pool.addObject(KEY);
clear(factory, expectedMethods);
obj = pool.borrowObject(KEY);
expectedMethods.add(new MethodCall("activateObject", KEY, ZERO));
expectedMethods.add(new MethodCall("validateObject", KEY, ZERO).returned(Boolean.TRUE));
assertEquals(expectedMethods, factory.getMethodCalls());
pool.returnObject(KEY, obj);
//// Test exception handling of borrowObject
reset(pool, factory, expectedMethods);
// makeObject Exceptions should be propagated to client code from borrowObject
factory.setMakeObjectFail(true);
try {
obj = pool.borrowObject(KEY);
fail("Expected borrowObject to propagate makeObject exception.");
} catch (final PrivateException pe) {
// expected
}
expectedMethods.add(new MethodCall("makeObject", KEY));
assertEquals(expectedMethods, factory.getMethodCalls());
// when activateObject fails in borrowObject, a new object should be borrowed/created
reset(pool, factory, expectedMethods);
pool.addObject(KEY);
clear(factory, expectedMethods);
factory.setActivateObjectFail(true);
expectedMethods.add(new MethodCall("activateObject", KEY, obj));
try {
pool.borrowObject(KEY);
fail("Expecting NoSuchElementException");
} catch (final NoSuchElementException e) {
//Activate should fail
}
// After idle object fails validation, new on is created and activation
// fails again for the new one.
expectedMethods.add(new MethodCall("makeObject", KEY).returned(ONE));
expectedMethods.add(new MethodCall("activateObject", KEY, ONE));
TestObjectPool.removeDestroyObjectCall(factory.getMethodCalls()); // The exact timing of destroyObject is flexible here.
assertEquals(expectedMethods, factory.getMethodCalls());
// when validateObject fails in borrowObject, a new object should be borrowed/created
reset(pool, factory, expectedMethods);
pool.addObject(KEY);
clear(factory, expectedMethods);
factory.setValidateObjectFail(true);
// testOnBorrow is on, so this will throw when the newly created instance
// fails validation
try {
pool.borrowObject(KEY);
fail("Expecting NoSuchElementException");
} catch (final NoSuchElementException ex) {
// expected
}
// Activate, then validate for idle instance
expectedMethods.add(new MethodCall("activateObject", KEY, ZERO));
expectedMethods.add(new MethodCall("validateObject", KEY, ZERO));
// Make new instance, activate succeeds, validate fails
expectedMethods.add(new MethodCall("makeObject", KEY).returned(ONE));
expectedMethods.add(new MethodCall("activateObject", KEY, ONE));
expectedMethods.add(new MethodCall("validateObject", KEY, ONE));
TestObjectPool.removeDestroyObjectCall(factory.getMethodCalls());
assertEquals(expectedMethods, factory.getMethodCalls());
pool.close();
}
@Test
public void testKPOFReturnObjectUsages() throws Exception {
final FailingKeyedPooledObjectFactory factory = new FailingKeyedPooledObjectFactory();
final KeyedObjectPool<Object,Object> pool;
try {
pool = makeEmptyPool(factory);
} catch(final UnsupportedOperationException uoe) {
return; // test not supported
}
final List<MethodCall> expectedMethods = new ArrayList<>();
Object obj;
/// Test correct behavior code paths
obj = pool.borrowObject(KEY);
clear(factory, expectedMethods);
// returned object should be passivated
pool.returnObject(KEY, obj);
expectedMethods.add(new MethodCall("passivateObject", KEY, obj));
assertEquals(expectedMethods, factory.getMethodCalls());
//// Test exception handling of returnObject
reset(pool, factory, expectedMethods);
// passivateObject should swallow exceptions and not add the object to the pool
pool.addObject(KEY);
pool.addObject(KEY);
pool.addObject(KEY);
assertEquals(3, pool.getNumIdle(KEY));
obj = pool.borrowObject(KEY);
obj = pool.borrowObject(KEY);
assertEquals(1, pool.getNumIdle(KEY));
assertEquals(2, pool.getNumActive(KEY));
clear(factory, expectedMethods);
factory.setPassivateObjectFail(true);
pool.returnObject(KEY, obj);
expectedMethods.add(new MethodCall("passivateObject", KEY, obj));
TestObjectPool.removeDestroyObjectCall(factory.getMethodCalls()); // The exact timing of destroyObject is flexible here.
assertEquals(expectedMethods, factory.getMethodCalls());
assertEquals(1, pool.getNumIdle(KEY)); // Not added
assertEquals(1, pool.getNumActive(KEY)); // But not active
reset(pool, factory, expectedMethods);
obj = pool.borrowObject(KEY);
clear(factory, expectedMethods);
factory.setPassivateObjectFail(true);
factory.setDestroyObjectFail(true);
try {
pool.returnObject(KEY, obj);
if (!(pool instanceof GenericKeyedObjectPool)) { // ugh, 1.3-compat
fail("Expecting destroyObject exception to be propagated");
}
} catch (final PrivateException ex) {
// Expected
}
pool.close();
}
@Test
public void testKPOFInvalidateObjectUsages() throws Exception {
final FailingKeyedPooledObjectFactory factory = new FailingKeyedPooledObjectFactory();
final KeyedObjectPool<Object,Object> pool;
try {
pool = makeEmptyPool(factory);
} catch(final UnsupportedOperationException uoe) {
return; // test not supported
}
final List<MethodCall> expectedMethods = new ArrayList<>();
Object obj;
/// Test correct behavior code paths
obj = pool.borrowObject(KEY);
clear(factory, expectedMethods);
// invalidated object should be destroyed
pool.invalidateObject(KEY, obj);
expectedMethods.add(new MethodCall("destroyObject", KEY, obj));
assertEquals(expectedMethods, factory.getMethodCalls());
//// Test exception handling of invalidateObject
reset(pool, factory, expectedMethods);
obj = pool.borrowObject(KEY);
clear(factory, expectedMethods);
factory.setDestroyObjectFail(true);
try {
pool.invalidateObject(KEY, obj);
fail("Expecting destroy exception to propagate");
} catch (final PrivateException ex) {
// Expected
}
Thread.sleep(250); // could be defered
TestObjectPool.removeDestroyObjectCall(factory.getMethodCalls());
assertEquals(expectedMethods, factory.getMethodCalls());
pool.close();
}
@Test
public void testKPOFClearUsages() throws Exception {
final FailingKeyedPooledObjectFactory factory = new FailingKeyedPooledObjectFactory();
final KeyedObjectPool<Object,Object> pool;
try {
pool = makeEmptyPool(factory);
} catch(final UnsupportedOperationException uoe) {
return; // test not supported
}
final List<MethodCall> expectedMethods = new ArrayList<>();
/// Test correct behavior code paths
pool.addObjects(KEY, 5);
pool.clear();
//// Test exception handling clear should swallow destroy object failures
reset(pool, factory, expectedMethods);
factory.setDestroyObjectFail(true);
pool.addObjects(KEY, 5);
pool.clear();
pool.close();
}
@Test
public void testKPOFCloseUsages() throws Exception {
final FailingKeyedPooledObjectFactory factory = new FailingKeyedPooledObjectFactory();
KeyedObjectPool<Object, Object> pool;
try {
pool = makeEmptyPool(factory);
} catch (final UnsupportedOperationException uoe) {
return; // test not supported
}
final List<MethodCall> expectedMethods = new ArrayList<>();
/// Test correct behavior code paths
pool.addObjects(KEY, 5);
pool.close();
//// Test exception handling close should swallow failures
try (final KeyedObjectPool<Object, Object> pool2 = makeEmptyPool(factory)) {
reset(pool2, factory, expectedMethods);
factory.setDestroyObjectFail(true);
pool2.addObjects(KEY, 5);
}
}
@Test
public void testToString() throws Exception {
final FailingKeyedPooledObjectFactory factory =
new FailingKeyedPooledObjectFactory();
try (final KeyedObjectPool<Object,Object> pool = makeEmptyPool(factory)) {
pool.toString();
} catch(final UnsupportedOperationException uoe) {
return; // test not supported
}
}
@Test
public void testBaseBorrowReturn() throws Exception {
try {
_pool = makeEmptyPool(3);
} catch(final UnsupportedOperationException uoe) {
return; // skip this test if unsupported
}
final Object keya = makeKey(0);
Object obj0 = _pool.borrowObject(keya);
assertEquals(getNthObject(keya,0),obj0);
Object obj1 = _pool.borrowObject(keya);
assertEquals(getNthObject(keya,1),obj1);
Object obj2 = _pool.borrowObject(keya);
assertEquals(getNthObject(keya,2),obj2);
_pool.returnObject(keya,obj2);
obj2 = _pool.borrowObject(keya);
assertEquals(getNthObject(keya,2),obj2);
_pool.returnObject(keya,obj1);
obj1 = _pool.borrowObject(keya);
assertEquals(getNthObject(keya,1),obj1);
_pool.returnObject(keya,obj0);
_pool.returnObject(keya,obj2);
obj2 = _pool.borrowObject(keya);
if (isLifo()) {
assertEquals(getNthObject(keya,2),obj2);
}
if (isFifo()) {
assertEquals(getNthObject(keya,0),obj2);
}
obj0 = _pool.borrowObject(keya);
if (isLifo()) {
assertEquals(getNthObject(keya,0),obj0);
}
if (isFifo()) {
assertEquals(getNthObject(keya,2),obj0);
}
_pool.close();
}
@Test
public void testBaseBorrow() throws Exception {
try {
_pool = makeEmptyPool(3);
} catch(final UnsupportedOperationException uoe) {
return; // skip this test if unsupported
}
final Object keya = makeKey(0);
final Object keyb = makeKey(1);
assertEquals("1",getNthObject(keya,0),_pool.borrowObject(keya));
assertEquals("2",getNthObject(keyb,0),_pool.borrowObject(keyb));
assertEquals("3",getNthObject(keyb,1),_pool.borrowObject(keyb));
assertEquals("4",getNthObject(keya,1),_pool.borrowObject(keya));
assertEquals("5",getNthObject(keyb,2),_pool.borrowObject(keyb));
assertEquals("6",getNthObject(keya,2),_pool.borrowObject(keya));
_pool.close();
}
@Test
public void testBaseNumActiveNumIdle() throws Exception {
try {
_pool = makeEmptyPool(3);
} catch(final UnsupportedOperationException uoe) {
return; // skip this test if unsupported
}
final Object keya = makeKey(0);
assertEquals(0,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
final Object obj0 = _pool.borrowObject(keya);
assertEquals(1,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
final Object obj1 = _pool.borrowObject(keya);
assertEquals(2,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
_pool.returnObject(keya,obj1);
assertEquals(1,_pool.getNumActive(keya));
assertEquals(1,_pool.getNumIdle(keya));
_pool.returnObject(keya,obj0);
assertEquals(0,_pool.getNumActive(keya));
assertEquals(2,_pool.getNumIdle(keya));
assertEquals(0,_pool.getNumActive("xyzzy12345"));
assertEquals(0,_pool.getNumIdle("xyzzy12345"));
_pool.close();
}
@Test
public void testBaseNumActiveNumIdle2() throws Exception {
try {
_pool = makeEmptyPool(6);
} catch(final UnsupportedOperationException uoe) {
return; // skip this test if unsupported
}
final Object keya = makeKey(0);
final Object keyb = makeKey(1);
assertEquals(0,_pool.getNumActive());
assertEquals(0,_pool.getNumIdle());
assertEquals(0,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
assertEquals(0,_pool.getNumActive(keyb));
assertEquals(0,_pool.getNumIdle(keyb));
final Object objA0 = _pool.borrowObject(keya);
final Object objB0 = _pool.borrowObject(keyb);
assertEquals(2,_pool.getNumActive());
assertEquals(0,_pool.getNumIdle());
assertEquals(1,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
assertEquals(1,_pool.getNumActive(keyb));
assertEquals(0,_pool.getNumIdle(keyb));
final Object objA1 = _pool.borrowObject(keya);
final Object objB1 = _pool.borrowObject(keyb);
assertEquals(4,_pool.getNumActive());
assertEquals(0,_pool.getNumIdle());
assertEquals(2,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
assertEquals(2,_pool.getNumActive(keyb));
assertEquals(0,_pool.getNumIdle(keyb));
_pool.returnObject(keya,objA0);
_pool.returnObject(keyb,objB0);
assertEquals(2,_pool.getNumActive());
assertEquals(2,_pool.getNumIdle());
assertEquals(1,_pool.getNumActive(keya));
assertEquals(1,_pool.getNumIdle(keya));
assertEquals(1,_pool.getNumActive(keyb));
assertEquals(1,_pool.getNumIdle(keyb));
_pool.returnObject(keya,objA1);
_pool.returnObject(keyb,objB1);
assertEquals(0,_pool.getNumActive());
assertEquals(4,_pool.getNumIdle());
assertEquals(0,_pool.getNumActive(keya));
assertEquals(2,_pool.getNumIdle(keya));
assertEquals(0,_pool.getNumActive(keyb));
assertEquals(2,_pool.getNumIdle(keyb));
_pool.close();
}
@Test
public void testBaseClear() throws Exception {
try {
_pool = makeEmptyPool(3);
} catch(final UnsupportedOperationException uoe) {
return; // skip this test if unsupported
}
final Object keya = makeKey(0);
assertEquals(0,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
final Object obj0 = _pool.borrowObject(keya);
final Object obj1 = _pool.borrowObject(keya);
assertEquals(2,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
_pool.returnObject(keya,obj1);
_pool.returnObject(keya,obj0);
assertEquals(0,_pool.getNumActive(keya));
assertEquals(2,_pool.getNumIdle(keya));
_pool.clear(keya);
assertEquals(0,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
final Object obj2 = _pool.borrowObject(keya);
assertEquals(getNthObject(keya,2),obj2);
_pool.close();
}
@Test
public void testBaseInvalidateObject() throws Exception {
try {
_pool = makeEmptyPool(3);
} catch(final UnsupportedOperationException uoe) {
return; // skip this test if unsupported
}
final Object keya = makeKey(0);
assertEquals(0,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
final Object obj0 = _pool.borrowObject(keya);
final Object obj1 = _pool.borrowObject(keya);
assertEquals(2,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
_pool.invalidateObject(keya,obj0);
assertEquals(1,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
_pool.invalidateObject(keya,obj1);
assertEquals(0,_pool.getNumActive(keya));
assertEquals(0,_pool.getNumIdle(keya));
_pool.close();
}
@Test
public void testBaseAddObject() throws Exception {
try {
_pool = makeEmptyPool(3);
} catch(final UnsupportedOperationException uoe) {
return; // skip this test if unsupported
}
final Object key = makeKey(0);
try {
assertEquals(0,_pool.getNumIdle());
assertEquals(0,_pool.getNumActive());
assertEquals(0,_pool.getNumIdle(key));
assertEquals(0,_pool.getNumActive(key));
_pool.addObject(key);
assertEquals(1,_pool.getNumIdle());
assertEquals(0,_pool.getNumActive());
assertEquals(1,_pool.getNumIdle(key));
assertEquals(0,_pool.getNumActive(key));
final Object obj = _pool.borrowObject(key);
assertEquals(getNthObject(key,0),obj);
assertEquals(0,_pool.getNumIdle());
assertEquals(1,_pool.getNumActive());
assertEquals(0,_pool.getNumIdle(key));
assertEquals(1,_pool.getNumActive(key));
_pool.returnObject(key,obj);
assertEquals(1,_pool.getNumIdle());
assertEquals(0,_pool.getNumActive());
assertEquals(1,_pool.getNumIdle(key));
assertEquals(0,_pool.getNumActive(key));
} catch(final UnsupportedOperationException e) {
return; // skip this test if one of those calls is unsupported
} finally {
_pool.close();
}
}
private void reset(final KeyedObjectPool<Object,Object> pool, final FailingKeyedPooledObjectFactory factory, final List<MethodCall> expectedMethods) throws Exception {
pool.clear();
clear(factory, expectedMethods);
factory.reset();
}
private void clear(final FailingKeyedPooledObjectFactory factory, final List<MethodCall> expectedMethods) {
factory.getMethodCalls().clear();
expectedMethods.clear();
}
private static class TestFactory
extends BaseKeyedPooledObjectFactory<Object,Object> {
@Override
public Object create(final Object key) throws Exception {
return new Object();
}
@Override
public PooledObject<Object> wrap(final Object value) {
return new DefaultPooledObject<>(value);
}
}
protected static class FailingKeyedPooledObjectFactory implements KeyedPooledObjectFactory<Object,Object> {
private final List<MethodCall> methodCalls = new ArrayList<>();
private int count = 0;
private boolean makeObjectFail;
private boolean activateObjectFail;
private boolean validateObjectFail;
private boolean passivateObjectFail;
private boolean destroyObjectFail;
public FailingKeyedPooledObjectFactory() {
}
public void reset() {
count = 0;
getMethodCalls().clear();
setMakeObjectFail(false);
setActivateObjectFail(false);
setValidateObjectFail(false);
setPassivateObjectFail(false);
setDestroyObjectFail(false);
}
public List<MethodCall> getMethodCalls() {
return methodCalls;
}
public int getCurrentCount() {
return count;
}
public void setCurrentCount(final int count) {
this.count = count;
}
public boolean isMakeObjectFail() {
return makeObjectFail;
}
public void setMakeObjectFail(final boolean makeObjectFail) {
this.makeObjectFail = makeObjectFail;
}
public boolean isDestroyObjectFail() {
return destroyObjectFail;
}
public void setDestroyObjectFail(final boolean destroyObjectFail) {
this.destroyObjectFail = destroyObjectFail;
}
public boolean isValidateObjectFail() {
return validateObjectFail;
}
public void setValidateObjectFail(final boolean validateObjectFail) {
this.validateObjectFail = validateObjectFail;
}
public boolean isActivateObjectFail() {
return activateObjectFail;
}
public void setActivateObjectFail(final boolean activateObjectFail) {
this.activateObjectFail = activateObjectFail;
}
public boolean isPassivateObjectFail() {
return passivateObjectFail;
}
public void setPassivateObjectFail(final boolean passivateObjectFail) {
this.passivateObjectFail = passivateObjectFail;
}
@Override
public PooledObject<Object> makeObject(final Object key) throws Exception {
final MethodCall call = new MethodCall("makeObject", key);
methodCalls.add(call);
final int originalCount = this.count++;
if (makeObjectFail) {
throw new PrivateException("makeObject");
}
// Deliberate choice to create new object in case future unit test
// checks for a specific object
final Integer obj = new Integer(originalCount);
call.setReturned(obj);
return new DefaultPooledObject<>(obj);
}
@Override
public void activateObject(final Object key, final PooledObject<Object> obj) throws Exception {
methodCalls.add(new MethodCall("activateObject", key, obj.getObject()));
if (activateObjectFail) {
throw new PrivateException("activateObject");
}
}
@Override
public boolean validateObject(final Object key, final PooledObject<Object> obj) {
final MethodCall call = new MethodCall("validateObject", key, obj.getObject());
methodCalls.add(call);
if (validateObjectFail) {
throw new PrivateException("validateObject");
}
final boolean r = true;
call.returned(Boolean.valueOf(r));
return r;
}
@Override
public void passivateObject(final Object key, final PooledObject<Object> obj) throws Exception {
methodCalls.add(new MethodCall("passivateObject", key, obj.getObject()));
if (passivateObjectFail) {
throw new PrivateException("passivateObject");
}
}
@Override
public void destroyObject(final Object key, final PooledObject<Object> obj) throws Exception {
methodCalls.add(new MethodCall("destroyObject", key, obj.getObject()));
if (destroyObjectFail) {
throw new PrivateException("destroyObject");
}
}
}
}
