Example usage for org.apache.commons.pool KeyedObjectPool addObject

Introduction

In this page you can find the example usage for org.apache.commons.pool KeyedObjectPool addObject.

Prototype

void addObject(Object key) throws Exception, IllegalStateException, UnsupportedOperationException;

Source Link

Document

Create an object using the KeyedPoolableObjectFactory factory or other implementation dependent mechanism, passivate it, and then place it in the idle object pool.

Usage

From source file:edu.illinois.enforcemop.examples.apache.pool.TestBaseKeyedObjectPool.java

public void testUnsupportedOperations() throws Exception {
    if (!getClass().equals(TestBaseKeyedObjectPool.class)) {
        return; // skip redundant tests
    }//from   w  ww  .  j  av a2 s .  co m
    KeyedObjectPool pool = new BaseKeyedObjectPool() {
        public Object borrowObject(Object key) {
            return null;
        }

        public void returnObject(Object key, Object obj) {
        }

        public void invalidateObject(Object key, Object obj) {
        }
    };

    try {
        pool.addObject("key");
        fail("Expected UnsupportedOperationException");
    } catch (UnsupportedOperationException e) {
        // expected
    }

    assertTrue("Negative expected.", pool.getNumIdle() < 0);
    assertTrue("Negative expected.", pool.getNumIdle("key") < 0);
    assertTrue("Negative expected.", pool.getNumActive() < 0);
    assertTrue("Negative expected.", pool.getNumActive("key") < 0);

    try {
        pool.clear();
        fail("Expected UnsupportedOperationException");
    } catch (UnsupportedOperationException e) {
        // expected
    }

    try {
        pool.clear("key");
        fail("Expected UnsupportedOperationException");
    } catch (UnsupportedOperationException e) {
        // expected
    }

    try {
        pool.setFactory(null);
        fail("Expected UnsupportedOperationException");
    } catch (UnsupportedOperationException e) {
        // expected
    }

    pool.close(); // a no-op, probably should be remove

}

---

From source file:edu.illinois.enforcemop.examples.apache.pool.TestKeyedObjectPool.java

public void testKPOFAddObjectUsage() throws Exception {
    final FailingKeyedPoolableObjectFactory factory = new FailingKeyedPoolableObjectFactory();
    final KeyedObjectPool pool;
    try {/*from   w w w  .  ja  va2 s .  c  o m*/
        pool = makeEmptyPool(factory);
    } catch (UnsupportedOperationException uoe) {
        return; // test not supported
    }
    final List expectedMethods = new ArrayList();

    // addObject should make a new object, pasivate it and put it in the pool
    pool.addObject(KEY);
    expectedMethods.add(new MethodCall("makeObject", KEY).returned(ZERO));
    if (pool instanceof StackKeyedObjectPool) {
        expectedMethods.add(new MethodCall("validateObject", KEY, ZERO).returned(Boolean.TRUE));
    }
    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 (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 (PrivateException pe) {
        // expected
    }
    expectedMethods.add(new MethodCall("makeObject", KEY).returned(ONE));
    if (pool instanceof StackKeyedObjectPool) {
        expectedMethods.add(new MethodCall("validateObject", KEY, ONE).returned(Boolean.TRUE));
    }
    expectedMethods.add(new MethodCall("passivateObject", KEY, ONE));
    assertEquals(expectedMethods, factory.getMethodCalls());
}

---

From source file:edu.illinois.enforcemop.examples.apache.pool.TestKeyedObjectPool.java

public void testClosedPoolBehavior() throws Exception {
    final KeyedObjectPool pool;
    try {//ww w  .  j  av  a  2s  .  co m
        pool = makeEmptyPool(new BaseKeyedPoolableObjectFactory() {
            public Object makeObject(final Object key) throws Exception {
                return new Object();
            }
        });
    } catch (UnsupportedOperationException uoe) {
        return; // test not supported
    }

    Object o1 = pool.borrowObject(KEY);
    Object o2 = pool.borrowObject(KEY);

    pool.close();

    try {
        pool.addObject(KEY);
        fail("A closed pool must throw an IllegalStateException when addObject is called.");
    } catch (IllegalStateException ise) {
        // expected
    }

    try {
        pool.borrowObject(KEY);
        fail("A closed pool must throw an IllegalStateException when borrowObject is called.");
    } catch (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();
}

---

From source file:edu.illinois.enforcemop.examples.apache.pool.TestKeyedObjectPool.java

public void testKPOFBorrowObjectUsages() throws Exception {
    final FailingKeyedPoolableObjectFactory factory = new FailingKeyedPoolableObjectFactory();
    final KeyedObjectPool pool;
    try {//w  w  w.  j a v  a2s  . co  m
        pool = makeEmptyPool(factory);
    } catch (UnsupportedOperationException uoe) {
        return; // test not supported
    }
    final List expectedMethods = new ArrayList();
    Object obj;

    if (pool instanceof GenericKeyedObjectPool) {
        ((GenericKeyedObjectPool) 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 (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 {
        obj = pool.borrowObject(KEY);
        fail("Expecting NoSuchElementException");
    } catch (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 {
        obj = pool.borrowObject(KEY);
        fail("Expecting NoSuchElementException");
    } catch (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());
}

---

From source file:edu.illinois.enforcemop.examples.apache.pool.TestKeyedObjectPool.java

public void testKPOFReturnObjectUsages() throws Exception {
    final FailingKeyedPoolableObjectFactory factory = new FailingKeyedPoolableObjectFactory();
    final KeyedObjectPool pool;
    try {/*  www .  ja  v a2 s  .c  om*/
        pool = makeEmptyPool(factory);
    } catch (UnsupportedOperationException uoe) {
        return; // test not supported
    }
    final List 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);
    if (pool instanceof StackKeyedObjectPool) {
        expectedMethods.add(new MethodCall("validateObject", KEY, obj).returned(Boolean.TRUE));
    }
    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);
    if (pool instanceof StackKeyedObjectPool) {
        expectedMethods.add(new MethodCall("validateObject", KEY, obj).returned(Boolean.TRUE));
    }
    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 (PrivateException ex) {
        // Expected
    }
}

---