/** * {@inheritDoc} */ @Override public void clear(final K key) throws Exception, UnsupportedOperationException { keyedPool.clear(key); }
@Override public void clear() throws Exception, UnsupportedOperationException { pool.clear(); }
/** * {@inheritDoc} */ @Override public void clear() throws Exception, UnsupportedOperationException { keyedPool.clear(); }
@Override public void clear(final K key) throws Exception, UnsupportedOperationException { pool.clear(key); }
/** * {@inheritDoc} */ @Override public void clear() throws Exception, UnsupportedOperationException { final WriteLock writeLock = readWriteLock.writeLock(); writeLock.lock(); try { keyedPool.clear(); } finally { writeLock.unlock(); } }
/** * {@inheritDoc} */ @Override public void clear(final K key) throws Exception, UnsupportedOperationException { final WriteLock writeLock = readWriteLock.writeLock(); writeLock.lock(); try { keyedPool.clear(key); } finally { writeLock.unlock(); } }
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 static List<String> invokeEveryMethod(final KeyedObjectPool<Object,Object> kop) throws Exception { kop.addObject(null); kop.borrowObject(null); kop.clear(); kop.clear(null); kop.close(); kop.getNumActive(); kop.getNumActive(null); kop.getNumIdle(); kop.getNumIdle(null); kop.invalidateObject(null, new Object()); kop.returnObject(null, new Object()); kop.toString(); final List<String> expectedMethods = Arrays.asList(new String[] { "addObject", "borrowObject", "clear", "clear", "close", "getNumActive", "getNumActive", "getNumIdle", "getNumIdle", "invalidateObject", "returnObject", "toString" }); return expectedMethods; }
@Override public void clear() throws Exception, UnsupportedOperationException { pool.clear(); }
/** * {@inheritDoc} */ @Override public void clear() throws Exception, UnsupportedOperationException { keyedPool.clear(); }
/** * {@inheritDoc} */ @Override public void clear(final K key) throws Exception, UnsupportedOperationException { keyedPool.clear(key); }
@Override public void clear(final K key) throws Exception, UnsupportedOperationException { pool.clear(key); }
@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 PoolUtils.prefill(pool, KEY, 5); pool.clear(); //// Test exception handling clear should swallow destroy object failures reset(pool, factory, expectedMethods); factory.setDestroyObjectFail(true); PoolUtils.prefill(pool, KEY, 5); pool.clear(); pool.close(); }
/** * {@inheritDoc} */ @Override public void clear() throws Exception, UnsupportedOperationException { final WriteLock writeLock = readWriteLock.writeLock(); writeLock.lock(); try { keyedPool.clear(); } finally { writeLock.unlock(); } }
/** * This implementation does not fully close the KeyedObjectPool, as this would affect all users. Instead, it clears * the pool associated with the given user. This method is not currently used. */ @Override public void closePool(final String userName) throws SQLException { try { pool.clear(new UserPassKey(userName)); } catch (final Exception ex) { throw new SQLException("Error closing connection pool", ex); } }
/** * {@inheritDoc} */ @Override public void clear(final K key) throws Exception, UnsupportedOperationException { final WriteLock writeLock = readWriteLock.writeLock(); writeLock.lock(); try { keyedPool.clear(key); } finally { writeLock.unlock(); } }
expectedMethods.add("getNumIdle"); expectedMethods.add("invalidateObject"); pool.clear();
@Test public void testPassThroughMethods01() throws Exception { assertEquals(0, pool.getNumActive()); assertEquals(0, pool.getNumIdle()); pool.addObject(KEY1); assertEquals(0, pool.getNumActive()); assertEquals(1, pool.getNumIdle()); pool.clear(); assertEquals(0, pool.getNumActive()); assertEquals(0, pool.getNumIdle()); }
@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(); }