Added author to all java files with class comments.
[utils] / support / src / test / java / org / wamblee / cache / CachedObjectTest.java
1 /*
2  * Copyright 2005 the original author or authors.
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
17 package org.wamblee.cache;
18
19 import java.io.IOException;
20
21 import junit.framework.TestCase;
22 import net.sf.ehcache.CacheException;
23
24 import org.wamblee.io.TestResource;
25 import org.wamblee.test.TimingUtils;
26
27 /**
28  * Cached object test. 
29  *
30  * @author Erik Brakkee
31  */
32 public class CachedObjectTest extends TestCase {
33     
34     /**
35      * 
36      */
37     private static final String EHCACHE_CONFIG = "ehcache.xml";
38
39     private static final int OBJECT_KEY = 10; 
40     
41     private CachedObject.Computation<Integer,Integer> _computation;
42     private int _ncomputations; 
43     
44     /* (non-Javadoc)
45      * @see junit.framework.TestCase#setUp()
46      */
47     @Override
48     protected void setUp() throws Exception {
49         super.setUp();
50         _computation = new CachedObject.Computation<Integer,Integer>() { 
51             public Integer getObject(Integer aObjectKey) {
52                 _ncomputations++;
53                 return compute(aObjectKey);
54             };
55         };
56         _ncomputations = 0; 
57     }
58     
59     private int compute(int aValue) { 
60         return aValue + 10;
61     }
62     
63     private CachedObject<Integer, Integer> createCached(Cache<Integer,Integer> aCache) { 
64         return new CachedObject<Integer, Integer>(aCache, OBJECT_KEY, _computation);
65     }
66
67     /**
68      * Verifies that upon first use, the cached object uses the computation to 
69      * retrieve the object.  
70      *
71      */
72     public void testComputation() { 
73         CachedObject<Integer, Integer> cached = createCached(new ZeroCache<Integer,Integer>());
74         int value = cached.get();
75         assertEquals(compute(OBJECT_KEY), value);
76         assertEquals(1, _ncomputations); 
77     }
78     
79     public void testInvalidateCache() { 
80         CachedObject<Integer, Integer> cached = createCached(new ForeverCache<Integer,Integer>());
81         int value = cached.get();
82         assertEquals(compute(OBJECT_KEY), value);
83         assertEquals(1, _ncomputations);
84         cached.invalidate(); 
85         value = cached.get();
86         assertEquals(compute(OBJECT_KEY), value);
87         assertEquals(2, _ncomputations);
88     }
89     
90     public void testBehaviorEhCache() throws CacheException, IOException {
91         Cache<Integer,Integer> cache = new EhCache<Integer,Integer>(new TestResource(CachedObjectTest.class, EHCACHE_CONFIG), "test");
92         CachedObject<Integer, Integer> cached = createCached(cache);
93         
94         assertTrue( cache == cached.getCache());
95         int value = cached.get();
96         assertEquals(compute(OBJECT_KEY), value);
97         assertEquals(1, _ncomputations);
98         // The value must still be cached. 
99         value = cached.get(); 
100         assertEquals(compute(OBJECT_KEY), value);
101         assertEquals(1, _ncomputations);
102         
103         // Cache expiry. 
104         TimingUtils.sleep(6000); 
105         value = cached.get(); 
106         assertEquals(compute(OBJECT_KEY), value);
107         assertEquals(2, _ncomputations);
108         
109         // Should still be cached now.
110         value = cached.get(); 
111         assertEquals(compute(OBJECT_KEY), value);
112         assertEquals(2, _ncomputations);
113         
114         // explicit invalidation.
115         cached.invalidate(); 
116         value = cached.get(); 
117         assertEquals(compute(OBJECT_KEY), value);
118         assertEquals(3, _ncomputations);
119         
120     }
121     
122     public void testBehaviorEhCacheDefault() throws CacheException, IOException {
123         Cache<Integer,Integer> cache = new EhCache<Integer,Integer>(new TestResource(CachedObjectTest.class, EHCACHE_CONFIG), "undefined");
124         CachedObject<Integer, Integer> cached = createCached(cache);
125         
126         assertTrue( cache == cached.getCache());
127         int value = cached.get();
128         assertEquals(compute(OBJECT_KEY), value);
129         assertEquals(1, _ncomputations);
130         // The value must still be cached. 
131         value = cached.get(); 
132         assertEquals(compute(OBJECT_KEY), value);
133         assertEquals(1, _ncomputations);
134         
135         // Cache expiry. 
136         TimingUtils.sleep(6000); 
137         value = cached.get(); 
138         assertEquals(compute(OBJECT_KEY), value);
139         assertEquals(2, _ncomputations);
140         
141         // Should still be cached now.
142         value = cached.get(); 
143         assertEquals(compute(OBJECT_KEY), value);
144         assertEquals(2, _ncomputations);
145         
146     }
147     
148     
149     public void testBehaviorForeverCache() { 
150         CachedObject<Integer, Integer> cached = createCached(new ForeverCache<Integer,Integer>());
151         int value = cached.get();
152         assertEquals(compute(OBJECT_KEY), value);
153         assertEquals(1, _ncomputations); 
154         for (int ncomp = 2; ncomp <= 100; ncomp++) { 
155             value = cached.get(); 
156             assertEquals(compute(OBJECT_KEY), value);
157             assertEquals(1, _ncomputations);
158         }
159     }
160     
161     public void testBehaviorZeroCache() { 
162         CachedObject<Integer, Integer> cached = createCached(new ZeroCache<Integer,Integer>());
163         int value = cached.get();
164         assertEquals(compute(OBJECT_KEY), value);
165         assertEquals(1, _ncomputations); 
166         for (int ncomp = 2; ncomp <= 100; ncomp++) { 
167             value = cached.get(); 
168             assertEquals(compute(OBJECT_KEY), value);
169             assertEquals(ncomp, _ncomputations);
170         }
171         cached.invalidate(); 
172         value = cached.get(); 
173         assertEquals(compute(OBJECT_KEY), value);
174         assertEquals(101, _ncomputations);
175     }
176 }