001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.pool; 018 019 import junit.framework.Test; 020 import junit.framework.TestSuite; 021 022 /** 023 * @author Rodney Waldhoff 024 * @author Sandy McArthur 025 * @version $Revision: 606064 $ $Date: 2007-12-20 19:12:02 -0500 (Thu, 20 Dec 2007) $ 026 */ 027 public class TestBaseKeyedObjectPool extends TestKeyedObjectPool { 028 private KeyedObjectPool _pool = null; 029 030 public TestBaseKeyedObjectPool(final String testName) { 031 super(testName); 032 } 033 034 protected KeyedObjectPool makeEmptyPool(KeyedPoolableObjectFactory factory) { 035 if (this.getClass() != TestBaseKeyedObjectPool.class) { 036 fail("Subclasses of TestBaseKeyedObjectPool must reimplement this method."); 037 } 038 throw new UnsupportedOperationException("BaseKeyedObjectPool isn't a complete implementation."); 039 } 040 041 /** 042 * Create an {@link KeyedObjectPool} instance 043 * that can contain at least <i>mincapacity</i> 044 * idle and active objects, or 045 * throw {@link IllegalArgumentException} 046 * if such a pool cannot be created. 047 */ 048 protected KeyedObjectPool makeEmptyPool(int mincapacity) { 049 if (this.getClass() != TestBaseKeyedObjectPool.class) { 050 fail("Subclasses of TestBaseKeyedObjectPool must reimplement this method."); 051 } 052 throw new UnsupportedOperationException("BaseKeyedObjectPool isn't a complete implementation."); 053 } 054 055 /** 056 * Return what we expect to be the n<sup>th</sup> 057 * object (zero indexed) created by the pool 058 * for the given key. 059 */ 060 protected Object getNthObject(Object key, int n) { 061 if (this.getClass() != TestBaseKeyedObjectPool.class) { 062 fail("Subclasses of TestBaseKeyedObjectPool must reimplement this method."); 063 } 064 throw new UnsupportedOperationException("BaseKeyedObjectPool isn't a complete implementation."); 065 } 066 067 protected Object makeKey(int n) { 068 if (this.getClass() != TestBaseKeyedObjectPool.class) { 069 fail("Subclasses of TestBaseKeyedObjectPool must reimplement this method."); 070 } 071 throw new UnsupportedOperationException("BaseKeyedObjectPool isn't a complete implementation."); 072 } 073 074 public static Test suite() { 075 return new TestSuite(TestBaseKeyedObjectPool.class); 076 } 077 078 // tests 079 public void setUp() throws Exception { 080 super.setUp(); 081 } 082 083 public void tearDown() throws Exception { 084 _pool = null; 085 super.tearDown(); 086 } 087 088 public void testUnsupportedOperations() throws Exception { 089 if (!getClass().equals(TestBaseKeyedObjectPool.class)) { 090 return; // skip redundant tests 091 } 092 KeyedObjectPool pool = new BaseKeyedObjectPool() { 093 public Object borrowObject(Object key) { 094 return null; 095 } 096 public void returnObject(Object key, Object obj) { 097 } 098 public void invalidateObject(Object key, Object obj) { 099 } 100 }; 101 102 try { 103 pool.addObject("key"); 104 fail("Expected UnsupportedOperationException"); 105 } catch(UnsupportedOperationException e) { 106 // expected 107 } 108 109 assertTrue("Negative expected.", pool.getNumIdle() < 0); 110 assertTrue("Negative expected.", pool.getNumIdle("key") < 0); 111 assertTrue("Negative expected.", pool.getNumActive() < 0); 112 assertTrue("Negative expected.", pool.getNumActive("key") < 0); 113 114 try { 115 pool.clear(); 116 fail("Expected UnsupportedOperationException"); 117 } catch(UnsupportedOperationException e) { 118 // expected 119 } 120 121 try { 122 pool.clear("key"); 123 fail("Expected UnsupportedOperationException"); 124 } catch(UnsupportedOperationException e) { 125 // expected 126 } 127 128 try { 129 pool.setFactory(null); 130 fail("Expected UnsupportedOperationException"); 131 } catch(UnsupportedOperationException e) { 132 // expected 133 } 134 135 pool.close(); // a no-op, probably should be remove 136 137 } 138 139 protected boolean isLifo() { 140 if (getClass() != TestBaseKeyedObjectPool.class) { 141 fail("Subclasses of TestBaseKeyedObjectPool must reimplement this method."); 142 } 143 return false; 144 } 145 146 protected boolean isFifo() { 147 if (getClass() != TestBaseKeyedObjectPool.class) { 148 fail("Subclasses of TestBaseKeyedObjectPool must reimplement this method."); 149 } 150 return false; 151 } 152 153 public void testBaseBorrowReturn() throws Exception { 154 try { 155 _pool = makeEmptyPool(3); 156 } catch(UnsupportedOperationException uoe) { 157 return; // skip this test if unsupported 158 } 159 Object keya = makeKey(0); 160 Object obj0 = _pool.borrowObject(keya); 161 assertEquals(getNthObject(keya,0),obj0); 162 Object obj1 = _pool.borrowObject(keya); 163 assertEquals(getNthObject(keya,1),obj1); 164 Object obj2 = _pool.borrowObject(keya); 165 assertEquals(getNthObject(keya,2),obj2); 166 _pool.returnObject(keya,obj2); 167 obj2 = _pool.borrowObject(keya); 168 assertEquals(getNthObject(keya,2),obj2); 169 _pool.returnObject(keya,obj1); 170 obj1 = _pool.borrowObject(keya); 171 assertEquals(getNthObject(keya,1),obj1); 172 _pool.returnObject(keya,obj0); 173 _pool.returnObject(keya,obj2); 174 obj2 = _pool.borrowObject(keya); 175 if (isLifo()) { 176 assertEquals(getNthObject(keya,2),obj2); 177 } 178 if (isFifo()) { 179 assertEquals(getNthObject(keya,0),obj2); 180 } 181 obj0 = _pool.borrowObject(keya); 182 if (isLifo()) { 183 assertEquals(getNthObject(keya,0),obj0); 184 } 185 if (isFifo()) { 186 assertEquals(getNthObject(keya,2),obj0); 187 } 188 } 189 190 public void testBaseBorrow() throws Exception { 191 try { 192 _pool = makeEmptyPool(3); 193 } catch(UnsupportedOperationException uoe) { 194 return; // skip this test if unsupported 195 } 196 Object keya = makeKey(0); 197 Object keyb = makeKey(1); 198 assertEquals("1",getNthObject(keya,0),_pool.borrowObject(keya)); 199 assertEquals("2",getNthObject(keyb,0),_pool.borrowObject(keyb)); 200 assertEquals("3",getNthObject(keyb,1),_pool.borrowObject(keyb)); 201 assertEquals("4",getNthObject(keya,1),_pool.borrowObject(keya)); 202 assertEquals("5",getNthObject(keyb,2),_pool.borrowObject(keyb)); 203 assertEquals("6",getNthObject(keya,2),_pool.borrowObject(keya)); 204 } 205 206 public void testBaseNumActiveNumIdle() throws Exception { 207 try { 208 _pool = makeEmptyPool(3); 209 } catch(UnsupportedOperationException uoe) { 210 return; // skip this test if unsupported 211 } 212 Object keya = makeKey(0); 213 assertEquals(0,_pool.getNumActive(keya)); 214 assertEquals(0,_pool.getNumIdle(keya)); 215 Object obj0 = _pool.borrowObject(keya); 216 assertEquals(1,_pool.getNumActive(keya)); 217 assertEquals(0,_pool.getNumIdle(keya)); 218 Object obj1 = _pool.borrowObject(keya); 219 assertEquals(2,_pool.getNumActive(keya)); 220 assertEquals(0,_pool.getNumIdle(keya)); 221 _pool.returnObject(keya,obj1); 222 assertEquals(1,_pool.getNumActive(keya)); 223 assertEquals(1,_pool.getNumIdle(keya)); 224 _pool.returnObject(keya,obj0); 225 assertEquals(0,_pool.getNumActive(keya)); 226 assertEquals(2,_pool.getNumIdle(keya)); 227 228 assertEquals(0,_pool.getNumActive("xyzzy12345")); 229 assertEquals(0,_pool.getNumIdle("xyzzy12345")); 230 } 231 232 public void testBaseNumActiveNumIdle2() throws Exception { 233 try { 234 _pool = makeEmptyPool(6); 235 } catch(UnsupportedOperationException uoe) { 236 return; // skip this test if unsupported 237 } 238 Object keya = makeKey(0); 239 Object keyb = makeKey(1); 240 assertEquals(0,_pool.getNumActive()); 241 assertEquals(0,_pool.getNumIdle()); 242 assertEquals(0,_pool.getNumActive(keya)); 243 assertEquals(0,_pool.getNumIdle(keya)); 244 assertEquals(0,_pool.getNumActive(keyb)); 245 assertEquals(0,_pool.getNumIdle(keyb)); 246 247 Object objA0 = _pool.borrowObject(keya); 248 Object objB0 = _pool.borrowObject(keyb); 249 250 assertEquals(2,_pool.getNumActive()); 251 assertEquals(0,_pool.getNumIdle()); 252 assertEquals(1,_pool.getNumActive(keya)); 253 assertEquals(0,_pool.getNumIdle(keya)); 254 assertEquals(1,_pool.getNumActive(keyb)); 255 assertEquals(0,_pool.getNumIdle(keyb)); 256 257 Object objA1 = _pool.borrowObject(keya); 258 Object objB1 = _pool.borrowObject(keyb); 259 260 assertEquals(4,_pool.getNumActive()); 261 assertEquals(0,_pool.getNumIdle()); 262 assertEquals(2,_pool.getNumActive(keya)); 263 assertEquals(0,_pool.getNumIdle(keya)); 264 assertEquals(2,_pool.getNumActive(keyb)); 265 assertEquals(0,_pool.getNumIdle(keyb)); 266 267 _pool.returnObject(keya,objA0); 268 _pool.returnObject(keyb,objB0); 269 270 assertEquals(2,_pool.getNumActive()); 271 assertEquals(2,_pool.getNumIdle()); 272 assertEquals(1,_pool.getNumActive(keya)); 273 assertEquals(1,_pool.getNumIdle(keya)); 274 assertEquals(1,_pool.getNumActive(keyb)); 275 assertEquals(1,_pool.getNumIdle(keyb)); 276 277 _pool.returnObject(keya,objA1); 278 _pool.returnObject(keyb,objB1); 279 280 assertEquals(0,_pool.getNumActive()); 281 assertEquals(4,_pool.getNumIdle()); 282 assertEquals(0,_pool.getNumActive(keya)); 283 assertEquals(2,_pool.getNumIdle(keya)); 284 assertEquals(0,_pool.getNumActive(keyb)); 285 assertEquals(2,_pool.getNumIdle(keyb)); 286 } 287 288 public void testBaseClear() throws Exception { 289 try { 290 _pool = makeEmptyPool(3); 291 } catch(UnsupportedOperationException uoe) { 292 return; // skip this test if unsupported 293 } 294 Object keya = makeKey(0); 295 assertEquals(0,_pool.getNumActive(keya)); 296 assertEquals(0,_pool.getNumIdle(keya)); 297 Object obj0 = _pool.borrowObject(keya); 298 Object obj1 = _pool.borrowObject(keya); 299 assertEquals(2,_pool.getNumActive(keya)); 300 assertEquals(0,_pool.getNumIdle(keya)); 301 _pool.returnObject(keya,obj1); 302 _pool.returnObject(keya,obj0); 303 assertEquals(0,_pool.getNumActive(keya)); 304 assertEquals(2,_pool.getNumIdle(keya)); 305 _pool.clear(keya); 306 assertEquals(0,_pool.getNumActive(keya)); 307 assertEquals(0,_pool.getNumIdle(keya)); 308 Object obj2 = _pool.borrowObject(keya); 309 assertEquals(getNthObject(keya,2),obj2); 310 } 311 312 public void testBaseInvalidateObject() throws Exception { 313 try { 314 _pool = makeEmptyPool(3); 315 } catch(UnsupportedOperationException uoe) { 316 return; // skip this test if unsupported 317 } 318 Object keya = makeKey(0); 319 assertEquals(0,_pool.getNumActive(keya)); 320 assertEquals(0,_pool.getNumIdle(keya)); 321 Object obj0 = _pool.borrowObject(keya); 322 Object obj1 = _pool.borrowObject(keya); 323 assertEquals(2,_pool.getNumActive(keya)); 324 assertEquals(0,_pool.getNumIdle(keya)); 325 _pool.invalidateObject(keya,obj0); 326 assertEquals(1,_pool.getNumActive(keya)); 327 assertEquals(0,_pool.getNumIdle(keya)); 328 _pool.invalidateObject(keya,obj1); 329 assertEquals(0,_pool.getNumActive(keya)); 330 assertEquals(0,_pool.getNumIdle(keya)); 331 } 332 333 public void testBaseAddObject() throws Exception { 334 try { 335 _pool = makeEmptyPool(3); 336 } catch(UnsupportedOperationException uoe) { 337 return; // skip this test if unsupported 338 } 339 Object key = makeKey(0); 340 try { 341 assertEquals(0,_pool.getNumIdle()); 342 assertEquals(0,_pool.getNumActive()); 343 assertEquals(0,_pool.getNumIdle(key)); 344 assertEquals(0,_pool.getNumActive(key)); 345 _pool.addObject(key); 346 assertEquals(1,_pool.getNumIdle()); 347 assertEquals(0,_pool.getNumActive()); 348 assertEquals(1,_pool.getNumIdle(key)); 349 assertEquals(0,_pool.getNumActive(key)); 350 Object obj = _pool.borrowObject(key); 351 assertEquals(getNthObject(key,0),obj); 352 assertEquals(0,_pool.getNumIdle()); 353 assertEquals(1,_pool.getNumActive()); 354 assertEquals(0,_pool.getNumIdle(key)); 355 assertEquals(1,_pool.getNumActive(key)); 356 _pool.returnObject(key,obj); 357 assertEquals(1,_pool.getNumIdle()); 358 assertEquals(0,_pool.getNumActive()); 359 assertEquals(1,_pool.getNumIdle(key)); 360 assertEquals(0,_pool.getNumActive(key)); 361 } catch(UnsupportedOperationException e) { 362 return; // skip this test if one of those calls is unsupported 363 } 364 } 365 }