1   /*
2    * Copyright 1999-2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.commons.pool;
17  
18  import junit.framework.TestCase;
19  
20  /***
21   * Abstract {@link TestCase} for {@link ObjectPool} implementations.
22   * @author Rodney Waldhoff
23   * @version $Revision: 383290 $ $Date: 2006-03-05 02:00:15 -0500 (Sun, 05 Mar 2006) $
24   */
25  public abstract class TestKeyedObjectPool extends TestCase {
26      public TestKeyedObjectPool(String testName) {
27          super(testName);
28      }
29  
30      /*** 
31       * Create an {@link KeyedObjectPool} instance
32       * that can contain at least <i>mincapacity</i>
33       * idle and active objects, or
34       * throw {@link IllegalArgumentException}
35       * if such a pool cannot be created.
36       */
37      protected abstract KeyedObjectPool makeEmptyPool(int mincapacity);
38  
39      /***
40       * Return what we expect to be the n<sup>th</sup>
41       * object (zero indexed) created by the pool
42       * for the given key.
43       */
44      protected abstract Object getNthObject(Object key, int n);
45  
46      protected abstract Object makeKey(int n);
47  
48      /***
49       * Is the implementations LIFO?
50       * @return
51       */
52      protected abstract boolean isLifo();
53      
54      /***
55       * Is the implementationn FIFO?
56       * @return
57       */
58      protected abstract boolean isFifo();
59  
60      public void setUp() throws Exception {
61      }
62      
63      public void tearDown() throws Exception {
64          _pool = null;
65      }
66      
67      public void testBaseBorrow() throws Exception {
68          try {
69              _pool = makeEmptyPool(3);
70          } catch(IllegalArgumentException e) {
71              return; // skip this test if unsupported
72          }
73          Object keya = makeKey(0);
74          Object keyb = makeKey(1);
75          assertEquals("1",getNthObject(keya,0),_pool.borrowObject(keya));
76          assertEquals("2",getNthObject(keyb,0),_pool.borrowObject(keyb));
77          assertEquals("3",getNthObject(keyb,1),_pool.borrowObject(keyb));
78          assertEquals("4",getNthObject(keya,1),_pool.borrowObject(keya));
79          assertEquals("5",getNthObject(keyb,2),_pool.borrowObject(keyb));
80          assertEquals("6",getNthObject(keya,2),_pool.borrowObject(keya));
81      }
82  
83      public void testBaseBorrowReturn() throws Exception {
84          try {
85              _pool = makeEmptyPool(3);
86          } catch(IllegalArgumentException e) {
87              return; // skip this test if unsupported
88          }
89          Object keya = makeKey(0);
90          Object obj0 = _pool.borrowObject(keya);
91          assertEquals(getNthObject(keya,0),obj0);
92          Object obj1 = _pool.borrowObject(keya);
93          assertEquals(getNthObject(keya,1),obj1);
94          Object obj2 = _pool.borrowObject(keya);
95          assertEquals(getNthObject(keya,2),obj2);
96          _pool.returnObject(keya,obj2);
97          obj2 = _pool.borrowObject(keya);
98          assertEquals(getNthObject(keya,2),obj2);
99          _pool.returnObject(keya,obj1);
100         obj1 = _pool.borrowObject(keya);
101         assertEquals(getNthObject(keya,1),obj1);
102         _pool.returnObject(keya,obj0);
103         _pool.returnObject(keya,obj2);
104         obj2 = _pool.borrowObject(keya);
105         if (isLifo()) {
106             assertEquals(getNthObject(keya,2),obj2);
107         }
108         if (isFifo()) {
109             assertEquals(getNthObject(keya,0),obj2);
110         }
111         obj0 = _pool.borrowObject(keya);
112         if (isLifo()) {
113             assertEquals(getNthObject(keya,0),obj0);
114         }
115         if (isFifo()) {
116             assertEquals(getNthObject(keya,2),obj0);
117         }
118     }
119 
120     public void testBaseNumActiveNumIdle() throws Exception {
121         try {
122             _pool = makeEmptyPool(3);
123         } catch(IllegalArgumentException e) {
124             return; // skip this test if unsupported
125         }
126         Object keya = makeKey(0);
127         assertEquals(0,_pool.getNumActive(keya));
128         assertEquals(0,_pool.getNumIdle(keya));
129         Object obj0 = _pool.borrowObject(keya);
130         assertEquals(1,_pool.getNumActive(keya));
131         assertEquals(0,_pool.getNumIdle(keya));
132         Object obj1 = _pool.borrowObject(keya);
133         assertEquals(2,_pool.getNumActive(keya));
134         assertEquals(0,_pool.getNumIdle(keya));
135         _pool.returnObject(keya,obj1);
136         assertEquals(1,_pool.getNumActive(keya));
137         assertEquals(1,_pool.getNumIdle(keya));
138         _pool.returnObject(keya,obj0);
139         assertEquals(0,_pool.getNumActive(keya));
140         assertEquals(2,_pool.getNumIdle(keya));
141         
142         assertEquals(0,_pool.getNumActive("xyzzy12345"));
143         assertEquals(0,_pool.getNumIdle("xyzzy12345"));
144     }
145 
146     public void testBaseNumActiveNumIdle2() throws Exception {
147         try {
148             _pool = makeEmptyPool(6);
149         } catch(IllegalArgumentException e) {
150             return; // skip this test if unsupported
151         }
152         Object keya = makeKey(0);
153         Object keyb = makeKey(1);
154         assertEquals(0,_pool.getNumActive());
155         assertEquals(0,_pool.getNumIdle());
156         assertEquals(0,_pool.getNumActive(keya));
157         assertEquals(0,_pool.getNumIdle(keya));
158         assertEquals(0,_pool.getNumActive(keyb));
159         assertEquals(0,_pool.getNumIdle(keyb));
160 
161         Object objA0 = _pool.borrowObject(keya);
162         Object objB0 = _pool.borrowObject(keyb);
163 
164         assertEquals(2,_pool.getNumActive());
165         assertEquals(0,_pool.getNumIdle());
166         assertEquals(1,_pool.getNumActive(keya));
167         assertEquals(0,_pool.getNumIdle(keya));
168         assertEquals(1,_pool.getNumActive(keyb));
169         assertEquals(0,_pool.getNumIdle(keyb));
170 
171         Object objA1 = _pool.borrowObject(keya);
172         Object objB1 = _pool.borrowObject(keyb);
173 
174         assertEquals(4,_pool.getNumActive());
175         assertEquals(0,_pool.getNumIdle());
176         assertEquals(2,_pool.getNumActive(keya));
177         assertEquals(0,_pool.getNumIdle(keya));
178         assertEquals(2,_pool.getNumActive(keyb));
179         assertEquals(0,_pool.getNumIdle(keyb));
180 
181         _pool.returnObject(keya,objA0);
182         _pool.returnObject(keyb,objB0);
183 
184         assertEquals(2,_pool.getNumActive());
185         assertEquals(2,_pool.getNumIdle());
186         assertEquals(1,_pool.getNumActive(keya));
187         assertEquals(1,_pool.getNumIdle(keya));
188         assertEquals(1,_pool.getNumActive(keyb));
189         assertEquals(1,_pool.getNumIdle(keyb));
190 
191         _pool.returnObject(keya,objA1);
192         _pool.returnObject(keyb,objB1);
193 
194         assertEquals(0,_pool.getNumActive());
195         assertEquals(4,_pool.getNumIdle());
196         assertEquals(0,_pool.getNumActive(keya));
197         assertEquals(2,_pool.getNumIdle(keya));
198         assertEquals(0,_pool.getNumActive(keyb));
199         assertEquals(2,_pool.getNumIdle(keyb));
200     }
201 
202     public void testBaseClear() throws Exception {
203         try {
204             _pool = makeEmptyPool(3);
205         } catch(IllegalArgumentException e) {
206             return; // skip this test if unsupported
207         }
208         Object keya = makeKey(0);
209         assertEquals(0,_pool.getNumActive(keya));
210         assertEquals(0,_pool.getNumIdle(keya));
211         Object obj0 = _pool.borrowObject(keya);
212         Object obj1 = _pool.borrowObject(keya);
213         assertEquals(2,_pool.getNumActive(keya));
214         assertEquals(0,_pool.getNumIdle(keya));
215         _pool.returnObject(keya,obj1);
216         _pool.returnObject(keya,obj0);
217         assertEquals(0,_pool.getNumActive(keya));
218         assertEquals(2,_pool.getNumIdle(keya));
219         _pool.clear(keya);
220         assertEquals(0,_pool.getNumActive(keya));
221         assertEquals(0,_pool.getNumIdle(keya));
222         Object obj2 = _pool.borrowObject(keya);
223         assertEquals(getNthObject(keya,2),obj2);
224     }
225 
226     public void testBaseInvalidateObject() throws Exception {
227         try {
228             _pool = makeEmptyPool(3);
229         } catch(IllegalArgumentException e) {
230             return; // skip this test if unsupported
231         }
232         Object keya = makeKey(0);
233         assertEquals(0,_pool.getNumActive(keya));
234         assertEquals(0,_pool.getNumIdle(keya));
235         Object obj0 = _pool.borrowObject(keya);
236         Object obj1 = _pool.borrowObject(keya);
237         assertEquals(2,_pool.getNumActive(keya));
238         assertEquals(0,_pool.getNumIdle(keya));
239         _pool.invalidateObject(keya,obj0);
240         assertEquals(1,_pool.getNumActive(keya));
241         assertEquals(0,_pool.getNumIdle(keya));
242         _pool.invalidateObject(keya,obj1);
243         assertEquals(0,_pool.getNumActive(keya));
244         assertEquals(0,_pool.getNumIdle(keya));
245     }
246 
247     public void testBaseAddObject() throws Exception {
248         try {
249             _pool = makeEmptyPool(3);
250         } catch(IllegalArgumentException e) {
251             return; // skip this test if unsupported
252         }
253         Object key = makeKey(0);
254         try {
255             assertEquals(0,_pool.getNumIdle());
256             assertEquals(0,_pool.getNumActive());
257             assertEquals(0,_pool.getNumIdle(key));
258             assertEquals(0,_pool.getNumActive(key));
259             _pool.addObject(key);
260             assertEquals(1,_pool.getNumIdle());
261             assertEquals(0,_pool.getNumActive());
262             assertEquals(1,_pool.getNumIdle(key));
263             assertEquals(0,_pool.getNumActive(key));
264             Object obj = _pool.borrowObject(key);
265             assertEquals(getNthObject(key,0),obj);
266             assertEquals(0,_pool.getNumIdle());
267             assertEquals(1,_pool.getNumActive());
268             assertEquals(0,_pool.getNumIdle(key));
269             assertEquals(1,_pool.getNumActive(key));
270             _pool.returnObject(key,obj);
271             assertEquals(1,_pool.getNumIdle());
272             assertEquals(0,_pool.getNumActive());
273             assertEquals(1,_pool.getNumIdle(key));
274             assertEquals(0,_pool.getNumActive(key));
275         } catch(UnsupportedOperationException e) {
276             return; // skip this test if one of those calls is unsupported
277         }
278     }
279 
280     private KeyedObjectPool _pool = null;
281 }