@Test
 public void testBaseBorrow() throws Exception {
   try {
     _pool = makeEmptyPool(3);
   } catch (UnsupportedOperationException e) {
     return; // skip this test if unsupported
   }
   assertEquals(getNthObject(0), _pool.borrowObject());
   assertEquals(getNthObject(1), _pool.borrowObject());
   assertEquals(getNthObject(2), _pool.borrowObject());
   _pool.close();
 }
  @Test
  public void testBaseClosePool() throws Exception {
    try {
      _pool = makeEmptyPool(3);
    } catch (UnsupportedOperationException e) {
      return; // skip this test if unsupported
    }
    Object obj = _pool.borrowObject();
    _pool.returnObject(obj);

    _pool.close();
    try {
      _pool.borrowObject();
      fail("Expected IllegalStateException");
    } catch (IllegalStateException e) {
      // expected
    }
  }
  @Test
  public void testClose() throws Exception {
    ObjectPool<Object> pool =
        new BaseObjectPool<Object>() {
          @Override
          public Object borrowObject() {
            return null;
          }

          @Override
          public void returnObject(Object obj) {}

          @Override
          public void invalidateObject(Object obj) {}
        };

    pool.close();
    pool.close(); // should not error as of Pool 2.0.
  }
  // tests
  @Test
  public void testUnsupportedOperations() throws Exception {
    if (!getClass().equals(TestBaseObjectPool.class)) {
      return; // skip redundant tests
    }
    ObjectPool<Object> pool =
        new BaseObjectPool<Object>() {
          @Override
          public Object borrowObject() {
            return null;
          }

          @Override
          public void returnObject(Object obj) {}

          @Override
          public void invalidateObject(Object obj) {}
        };

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

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

    try {
      pool.addObject();
      fail("Expected UnsupportedOperationException");
    } catch (UnsupportedOperationException e) {
      // expected
    }
  }
 @Test
 public void testBaseInvalidateObject() throws Exception {
   try {
     _pool = makeEmptyPool(3);
   } catch (UnsupportedOperationException e) {
     return; // skip this test if unsupported
   }
   assertEquals(0, _pool.getNumActive());
   assertEquals(0, _pool.getNumIdle());
   Object obj0 = _pool.borrowObject();
   Object obj1 = _pool.borrowObject();
   assertEquals(2, _pool.getNumActive());
   assertEquals(0, _pool.getNumIdle());
   _pool.invalidateObject(obj0);
   assertEquals(1, _pool.getNumActive());
   assertEquals(0, _pool.getNumIdle());
   _pool.invalidateObject(obj1);
   assertEquals(0, _pool.getNumActive());
   assertEquals(0, _pool.getNumIdle());
   _pool.close();
 }
  @Test
  public void testBaseBorrowReturn() throws Exception {
    try {
      _pool = makeEmptyPool(3);
    } catch (UnsupportedOperationException e) {
      return; // skip this test if unsupported
    }
    Object obj0 = _pool.borrowObject();
    assertEquals(getNthObject(0), obj0);
    Object obj1 = _pool.borrowObject();
    assertEquals(getNthObject(1), obj1);
    Object obj2 = _pool.borrowObject();
    assertEquals(getNthObject(2), obj2);
    _pool.returnObject(obj2);
    obj2 = _pool.borrowObject();
    assertEquals(getNthObject(2), obj2);
    _pool.returnObject(obj1);
    obj1 = _pool.borrowObject();
    assertEquals(getNthObject(1), obj1);
    _pool.returnObject(obj0);
    _pool.returnObject(obj2);
    obj2 = _pool.borrowObject();
    if (isLifo()) {
      assertEquals(getNthObject(2), obj2);
    }
    if (isFifo()) {
      assertEquals(getNthObject(0), obj2);
    }

    obj0 = _pool.borrowObject();
    if (isLifo()) {
      assertEquals(getNthObject(0), obj0);
    }
    if (isFifo()) {
      assertEquals(getNthObject(2), obj0);
    }
    _pool.close();
  }
 @Test
 public void testBaseAddObject() throws Exception {
   try {
     _pool = makeEmptyPool(3);
   } catch (UnsupportedOperationException e) {
     return; // skip this test if unsupported
   }
   try {
     assertEquals(0, _pool.getNumIdle());
     assertEquals(0, _pool.getNumActive());
     _pool.addObject();
     assertEquals(1, _pool.getNumIdle());
     assertEquals(0, _pool.getNumActive());
     Object obj = _pool.borrowObject();
     assertEquals(getNthObject(0), obj);
     assertEquals(0, _pool.getNumIdle());
     assertEquals(1, _pool.getNumActive());
     _pool.returnObject(obj);
     assertEquals(1, _pool.getNumIdle());
     assertEquals(0, _pool.getNumActive());
   } catch (UnsupportedOperationException e) {
     return; // skip this test if one of those calls is unsupported
   } finally {
     _pool.close();
   }
 }