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 TestBaseObjectPool extends TestObjectPool {
028        private ObjectPool _pool = null;
029    
030        public TestBaseObjectPool(String testName) {
031            super(testName);
032        }
033    
034        public static Test suite() {
035            return new TestSuite(TestBaseObjectPool.class);
036        }
037        
038        protected ObjectPool makeEmptyPool(int mincapacity) {
039            if (this.getClass() != TestBaseObjectPool.class) {
040                fail("Subclasses of TestBaseObjectPool must reimplement this method.");
041            }
042            throw new UnsupportedOperationException("BaseObjectPool isn't a complete implementation.");
043        }
044    
045        protected ObjectPool makeEmptyPool(final PoolableObjectFactory factory) {
046            if (this.getClass() != TestBaseObjectPool.class) {
047                fail("Subclasses of TestBaseObjectPool must reimplement this method.");
048            }
049            throw new UnsupportedOperationException("BaseObjectPool isn't a complete implementation.");
050        }
051    
052        protected Object getNthObject(final int n) {
053            if (this.getClass() != TestBaseObjectPool.class) {
054                fail("Subclasses of TestBaseObjectPool must reimplement this method.");
055            }
056            throw new UnsupportedOperationException("BaseObjectPool isn't a complete implementation.");
057        }
058    
059        protected boolean isLifo() {
060            if (this.getClass() != TestBaseObjectPool.class) {
061                fail("Subclasses of TestBaseObjectPool must reimplement this method.");
062            }
063            return false;
064        }
065    
066        protected boolean isFifo() {
067            if (this.getClass() != TestBaseObjectPool.class) {
068                fail("Subclasses of TestBaseObjectPool must reimplement this method.");
069            }
070            return false;
071        }
072    
073        // tests
074        public void testUnsupportedOperations() throws Exception {
075            if (!getClass().equals(TestBaseObjectPool.class)) {
076                return; // skip redundant tests
077            }
078            ObjectPool pool = new BaseObjectPool() { 
079                public Object borrowObject() {
080                    return null;
081                }
082                public void returnObject(Object obj) {
083                }
084                public void invalidateObject(Object obj) {
085                }            
086            };   
087    
088            assertTrue("Negative expected.", pool.getNumIdle() < 0);
089            assertTrue("Negative expected.", pool.getNumActive() < 0);
090    
091            try {
092                pool.clear();
093                fail("Expected UnsupportedOperationException");
094            } catch(UnsupportedOperationException e) {
095                // expected
096            }
097    
098            try {
099                pool.addObject();
100                fail("Expected UnsupportedOperationException");
101            } catch(UnsupportedOperationException e) {
102                // expected
103            }
104    
105            try {
106                pool.setFactory(null);
107                fail("Expected UnsupportedOperationException");
108            } catch(UnsupportedOperationException e) {
109                // expected
110            }
111        }
112    
113        public void testClose() throws Exception {
114            ObjectPool pool = new BaseObjectPool() {
115                public Object borrowObject() {
116                    return null;
117                }
118                public void returnObject(Object obj) {
119                }
120                public void invalidateObject(Object obj) {
121                }
122            };
123    
124            pool.close();
125            pool.close(); // should not error as of Pool 2.0.
126        }
127    
128        public void testBaseBorrow() throws Exception {
129            try {
130                _pool = makeEmptyPool(3);
131            } catch(UnsupportedOperationException e) {
132                return; // skip this test if unsupported
133            }
134            assertEquals(getNthObject(0),_pool.borrowObject());
135            assertEquals(getNthObject(1),_pool.borrowObject());
136            assertEquals(getNthObject(2),_pool.borrowObject());
137        }
138    
139        public void testBaseAddObject() throws Exception {
140            try {
141                _pool = makeEmptyPool(3);
142            } catch(UnsupportedOperationException e) {
143                return; // skip this test if unsupported
144            }
145            try {
146                assertEquals(0,_pool.getNumIdle());
147                assertEquals(0,_pool.getNumActive());
148                _pool.addObject();
149                assertEquals(1,_pool.getNumIdle());
150                assertEquals(0,_pool.getNumActive());
151                Object obj = _pool.borrowObject();
152                assertEquals(getNthObject(0),obj);
153                assertEquals(0,_pool.getNumIdle());
154                assertEquals(1,_pool.getNumActive());
155                _pool.returnObject(obj);
156                assertEquals(1,_pool.getNumIdle());
157                assertEquals(0,_pool.getNumActive());
158            } catch(UnsupportedOperationException e) {
159                return; // skip this test if one of those calls is unsupported
160            }
161        }
162    
163        public void testBaseBorrowReturn() throws Exception {
164            try {
165                _pool = makeEmptyPool(3);
166            } catch(UnsupportedOperationException e) {
167                return; // skip this test if unsupported
168            }
169            Object obj0 = _pool.borrowObject();
170            assertEquals(getNthObject(0),obj0);
171            Object obj1 = _pool.borrowObject();
172            assertEquals(getNthObject(1),obj1);
173            Object obj2 = _pool.borrowObject();
174            assertEquals(getNthObject(2),obj2);
175            _pool.returnObject(obj2);
176            obj2 = _pool.borrowObject();
177            assertEquals(getNthObject(2),obj2);
178            _pool.returnObject(obj1);
179            obj1 = _pool.borrowObject();
180            assertEquals(getNthObject(1),obj1);
181            _pool.returnObject(obj0);
182            _pool.returnObject(obj2);
183            obj2 = _pool.borrowObject();
184            if (isLifo()) {
185                assertEquals(getNthObject(2),obj2);
186            }
187            if (isFifo()) {
188                assertEquals(getNthObject(0),obj2);
189            }
190    
191            obj0 = _pool.borrowObject();
192            if (isLifo()) {
193                assertEquals(getNthObject(0),obj0);
194            }
195            if (isFifo()) {
196                assertEquals(getNthObject(2),obj0);
197            }
198        }
199    
200        public void testBaseNumActiveNumIdle() throws Exception {
201            try {
202                _pool = makeEmptyPool(3);
203            } catch(UnsupportedOperationException e) {
204                return; // skip this test if unsupported
205            }
206            assertEquals(0,_pool.getNumActive());
207            assertEquals(0,_pool.getNumIdle());
208            Object obj0 = _pool.borrowObject();
209            assertEquals(1,_pool.getNumActive());
210            assertEquals(0,_pool.getNumIdle());
211            Object obj1 = _pool.borrowObject();
212            assertEquals(2,_pool.getNumActive());
213            assertEquals(0,_pool.getNumIdle());
214            _pool.returnObject(obj1);
215            assertEquals(1,_pool.getNumActive());
216            assertEquals(1,_pool.getNumIdle());
217            _pool.returnObject(obj0);
218            assertEquals(0,_pool.getNumActive());
219            assertEquals(2,_pool.getNumIdle());
220        }
221    
222        public void testBaseClear() throws Exception {
223            try {
224                _pool = makeEmptyPool(3);
225            } catch(UnsupportedOperationException e) {
226                return; // skip this test if unsupported
227            }
228            assertEquals(0,_pool.getNumActive());
229            assertEquals(0,_pool.getNumIdle());
230            Object obj0 = _pool.borrowObject();
231            Object obj1 = _pool.borrowObject();
232            assertEquals(2,_pool.getNumActive());
233            assertEquals(0,_pool.getNumIdle());
234            _pool.returnObject(obj1);
235            _pool.returnObject(obj0);
236            assertEquals(0,_pool.getNumActive());
237            assertEquals(2,_pool.getNumIdle());
238            _pool.clear();
239            assertEquals(0,_pool.getNumActive());
240            assertEquals(0,_pool.getNumIdle());
241            Object obj2 = _pool.borrowObject();
242            assertEquals(getNthObject(2),obj2);
243        }
244    
245        public void testBaseInvalidateObject() throws Exception {
246            try {
247                _pool = makeEmptyPool(3);
248            } catch(UnsupportedOperationException e) {
249                return; // skip this test if unsupported
250            }
251            assertEquals(0,_pool.getNumActive());
252            assertEquals(0,_pool.getNumIdle());
253            Object obj0 = _pool.borrowObject();
254            Object obj1 = _pool.borrowObject();
255            assertEquals(2,_pool.getNumActive());
256            assertEquals(0,_pool.getNumIdle());
257            _pool.invalidateObject(obj0);
258            assertEquals(1,_pool.getNumActive());
259            assertEquals(0,_pool.getNumIdle());
260            _pool.invalidateObject(obj1);
261            assertEquals(0,_pool.getNumActive());
262            assertEquals(0,_pool.getNumIdle());
263        }
264    
265        public void testBaseClosePool() throws Exception {
266            try {
267                _pool = makeEmptyPool(3);
268            } catch(UnsupportedOperationException e) {
269                return; // skip this test if unsupported
270            }
271            Object obj = _pool.borrowObject();
272            _pool.returnObject(obj);
273    
274            _pool.close();
275            try {
276                _pool.borrowObject();
277                fail("Expected IllegalStateException");
278            } catch(IllegalStateException e) {
279                // expected
280            }
281        }
282    }