1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package net.sourceforge.rcache;
20
21 import static org.junit.Assert.assertEquals;
22 import static org.junit.Assert.assertFalse;
23 import static org.junit.Assert.assertNotNull;
24 import static org.junit.Assert.assertNull;
25 import static org.junit.Assert.assertSame;
26 import static org.junit.Assert.assertTrue;
27 import static org.junit.Assert.fail;
28
29 import java.util.ArrayList;
30 import java.util.HashSet;
31
32 import net.sourceforge.rcache.decorator.CacheProfiler;
33
34 import org.apache.commons.logging.Log;
35 import org.apache.commons.logging.LogFactory;
36 import org.junit.Test;
37
38
39
40
41
42
43 public abstract class BaseCacheTest {
44
45
46
47
48 private static final Log LOG = LogFactory.getLog(BaseCacheTest.class);
49
50
51
52
53
54
55 protected abstract BaseCache<Integer, Object> createCache();
56
57
58
59
60
61
62
63 protected abstract BaseCache<Integer, Object> createCache(int capacity);
64
65
66
67
68
69
70
71
72 protected abstract BaseCache<Integer, Object> createCache(int capacity, float factor);
73
74
75
76
77
78
79
80
81
82 protected abstract BaseCache<Integer, Object> createCache(int capacity, float factor,
83 int level);
84
85
86
87
88 @Test public final void testGet() {
89 BaseCache<Integer, Object> cache = createCache(
90 Cache.DEFAULT_INITIAL_CAPACITY,
91 Cache.DEFAULT_LOAD_FACTOR
92 );
93 StringBuffer sb1 = new StringBuffer("1");
94 StringBuffer sb2 = new StringBuffer("2");
95
96 cache.put(1, sb1);
97 cache.put(2, sb2);
98
99 assertNull(cache.get(0));
100
101 assertSame(sb1, cache.get(1));
102 assertSame(sb2, cache.get(2));
103
104 cache.clear();
105 }
106
107
108
109
110 @Test public final void testRemove() {
111 BaseCache<Integer, Object> cache = createCache(1);
112 assertNull(cache.remove(1));
113
114 assertNull(cache.put(1, "One"));
115 assertEquals("One", cache.remove(1));
116 }
117
118
119
120
121 @Test public final void testPurge() {
122 BaseCache<Integer, Object> cache = createCache();
123 StringBuffer sb1 = new StringBuffer("1");
124 StringBuffer sb2 = new StringBuffer("2");
125
126 cache.put(1, sb1);
127 cache.put(2, sb2);
128
129
130 sb1 = null;
131 forcePurge();
132
133 assertEquals("Incorrect cache size;", 1, cache.size());
134
135 cache.clear();
136 }
137
138
139
140
141 @Test public final void testUnsupported() {
142 BaseCache<Integer, Object> cache = createCache();
143 try {
144 cache.entrySet();
145 fail("Expected exception not thrown");
146 } catch (UnsupportedOperationException e) {
147 LOG.debug("Expected exception");
148 }
149 try {
150 cache.values();
151 fail("Expected exception not thrown");
152 } catch (UnsupportedOperationException e) {
153 LOG.debug("Expected exception");
154 }
155 }
156
157
158
159
160
161
162
163
164
165
166
167
168 @Test public final void testRemoveAndPut() {
169 final int[] levels = { -1, 0, 1 };
170
171 for (int level : levels) {
172
173 BaseCache<Integer, Object> cache = createCache(
174 Cache.DEFAULT_INITIAL_CAPACITY,
175 Cache.DEFAULT_LOAD_FACTOR,
176 level);
177 testRemoveAndPut(cache);
178 }
179 }
180
181
182
183
184
185
186 private void testRemoveAndPut(BaseCache<Integer, Object> cache) {
187 StringBuffer sb1 = new StringBuffer("1");
188 StringBuffer sb2 = new StringBuffer("2");
189
190 cache.put(1, sb1);
191
192 assertSame(sb1, cache.get(1));
193 assertSame(sb1, cache.put(1, sb2));
194 assertSame(sb1, cache.get(1));
195
196 sb1 = null;
197 cache.remove(1);
198 cache.put(1, sb2);
199
200
201 forcePurge();
202
203 assertEquals(1, cache.size());
204 assertEquals(sb2, cache.get(1));
205
206 cache.clear();
207 }
208
209
210
211
212 @Test public final void testObjectMethods() {
213 BaseCache<Integer, Object> cache1 = createCache();
214 BaseCache<Integer, Object> cache2 = createCache();
215
216
217 assertFalse(cache1.equals(cache2));
218 assertTrue(cache1.equals(cache1));
219
220 HashSet<Object> set = new HashSet<Object>();
221 set.add(cache1);
222 set.add(cache2);
223 assertEquals(2, set.size());
224 }
225
226
227
228
229 @Test public final void testProfiler() {
230 CacheProfiler<Integer, Object> cache = new CacheProfiler<Integer, Object>(
231 createCache()
232 );
233
234 check(new long[] { 0, 0, 0, 0 }, cache.getNums());
235 check(new double[] { 0, 0, 0, 0 }, cache.getAverages());
236 cache.put(1, "One");
237 cache.put(2, "Two");
238 check(new long[] { 0, 2, 0, 0 }, cache.getNums());
239
240 cache.get(1);
241 cache.get(2);
242 check(new long[] { 2, 2, 0, 0 }, cache.getNums());
243
244 cache.remove(0);
245 cache.remove(1);
246 check(new long[] { 2, 2, 2, 0 }, cache.getNums());
247
248 cache.clear();
249 check(new long[] { 2, 2, 2, 1 }, cache.getNums());
250
251 assertEquals(cache.getNum(Cache.Operation.GET), cache.getNums()[0]);
252 assertEquals(cache.getAverage(Cache.Operation.GET), cache.getAverages()[0], 0.0);
253
254 }
255
256
257
258
259
260 protected final void forcePurge() {
261 ArrayList<int[]> list = new ArrayList<int[]>();
262 final int factor = 4096;
263 try {
264 while (true) {
265 list.add(new int[Integer.MAX_VALUE / factor]);
266 }
267 } catch (OutOfMemoryError e) {
268 LOG.debug("Forced an OOM for cache purging in " + list.size() + " iterations");
269 }
270 }
271
272
273
274
275
276
277
278 protected final void check(long[] a1, long[] a2) {
279 if (a1 != a2) {
280 assertNotNull(a1);
281 assertNotNull(a2);
282 assertEquals(a1.length, a2.length);
283
284 for (int i = 0; i < a1.length; i++) {
285 assertEquals("Item '" + i + "' differs;", a1[i], a2[i]);
286 }
287 }
288 }
289
290
291
292
293
294
295
296 protected final void check(double[] a1, double[] a2) {
297 if (a1 != a2) {
298 assertNotNull(a1);
299 assertNotNull(a2);
300 assertEquals(a1.length, a2.length);
301
302 for (int i = 0; i < a1.length; i++) {
303 assertEquals("Item '" + i + "' differs;", a1[i], a2[i], 0.0);
304 }
305 }
306 }
307 }