View Javadoc

1   package com.atlassian.cache;
2   
3   import java.util.SortedMap;
4   import java.util.concurrent.TimeUnit;
5   
6   import com.atlassian.util.concurrent.Supplier;
7   
8   import org.junit.Test;
9   
10  import static com.atlassian.cache.CacheStatisticsKey.EVICTION_COUNT;
11  import static com.atlassian.cache.CacheStatisticsKey.HIT_COUNT;
12  import static com.atlassian.cache.CacheStatisticsKey.MISS_COUNT;
13  import static com.atlassian.cache.CacheStatisticsKey.PUT_COUNT;
14  import static com.atlassian.cache.CacheStatisticsKey.REMOVE_COUNT;
15  import static com.atlassian.cache.CacheStatisticsKey.SIZE;
16  import static com.atlassian.cache.StatisticMatcher.stat;
17  import static org.hamcrest.MatcherAssert.assertThat;
18  import static org.hamcrest.Matchers.equalTo;
19  import static org.hamcrest.Matchers.not;
20  import static org.hamcrest.Matchers.nullValue;
21  import static org.junit.Assert.assertEquals;
22  import static org.junit.Assert.assertFalse;
23  import static org.junit.Assert.assertNull;
24  import static org.junit.Assert.assertTrue;
25  
26  /**
27   * Test the Eager Cache
28   *
29   * @since 2.0
30   */
31  public abstract class AbstractCacheEagerTest extends AbstractCacheTest
32  {
33      @Test
34      public void testGetName() throws Exception
35      {
36          Cache<String, Long> cache = makeSimpleCache();
37  
38          assertThat(cache.getName(), equalTo("mycache"));
39      }
40  
41      @Test
42      public void testFactoryGeneratedName() throws Exception
43      {
44          Cache<String, Long> cache = factory.getCache(Object.class, "mycache");
45  
46          assertThat(cache.getName(), equalTo("java.lang.Object.mycache"));
47      }
48  
49      @SuppressWarnings("ConstantConditions")
50      @Test
51      public void testGetKeys() throws Exception
52      {
53          Cache<String, Long> cache = makeSimpleCache();
54          // Add some entries using put
55          cache.put("1", 1L);
56          cache.put("2", 2L);
57          cache.put("3", 3L);
58          cache.put("4", 4L);
59          assertThat(cache.get("1"), equalTo(1L));
60          assertThat(cache.get("2"), equalTo(2L));
61          assertThat(cache.get("3"), equalTo(3L));
62          assertThat(cache.get("4"), equalTo(4L));
63          assertSize(cache, 4);
64  
65          final SortedMap<CacheStatisticsKey, Supplier<Long>> stats = ((ManagedCache)cache).getStatistics();
66          assertThat(stats.get(SIZE), stat(4L));
67          assertThat(stats.get(PUT_COUNT), stat(4L));
68          assertThat(stats.get(HIT_COUNT), stat(4L));
69          assertThat(stats.get(REMOVE_COUNT), stat(0L));
70          assertThat(stats.get(EVICTION_COUNT), stat(0L));
71          assertThat(stats.get(MISS_COUNT), stat(0L));
72      }
73  
74      @Test
75      public void testPut() throws Exception
76      {
77          Cache<String, Long> cache = makeSimpleCache();
78          // Add some entries using the builder
79          cache.put("1", 11L);
80          cache.put("2", 12L);
81          cache.put("3", 13L);
82          cache.put("4", 14L);
83          assertThat(cache.get("1"), equalTo(11L));
84          assertThat(cache.get("2"), equalTo(12L));
85          assertThat(cache.get("3"), equalTo(13L));
86          assertThat(cache.get("4"), equalTo(14L));
87          assertSize(cache, 4);
88      }
89  
90      @SuppressWarnings("ConstantConditions")
91      @Test
92      public void testGet() throws Exception
93      {
94          Cache<String, Long> cache = makeSimpleCache();
95          // Add some entries using the builder
96          cache.put("1", 11L);
97          cache.put("2", 12L);
98          cache.put("3", 13L);
99          cache.put("4", 14L);
100         assertThat(cache.get("1"), equalTo(11L));
101         assertThat(cache.get("2"), equalTo(12L));
102         assertThat(cache.get("3"), equalTo(13L));
103         assertThat(cache.get("4"), equalTo(14L));
104         assertThat(cache.get("5"), nullValue());
105         assertThat(cache.get("6"), nullValue());
106         assertThat(cache.get("7"), nullValue());
107         assertSize(cache, 4);
108 
109         final SortedMap<CacheStatisticsKey, Supplier<Long>> stats = ((ManagedCache)cache).getStatistics();
110         assertThat(stats.get(SIZE), stat(4L));
111         assertThat(stats.get(PUT_COUNT), stat(4L));
112         assertThat(stats.get(HIT_COUNT), stat(4L));
113         assertThat(stats.get(REMOVE_COUNT), stat(0L));
114         assertThat(stats.get(EVICTION_COUNT), stat(0L));
115         assertThat(stats.get(MISS_COUNT), stat(3L));
116     }
117 
118     @SuppressWarnings("ConstantConditions")
119     @Test
120     public void testRemove() throws Exception
121     {
122         Cache<String, Long> cache = makeSimpleCache();
123         // Add some entries using the builder
124         cache.put("1", 11L);
125         cache.put("2", 12L);
126         cache.put("3", 13L);
127         cache.put("4", 14L);
128         assertThat(cache.get("1"), equalTo(11L));
129         assertThat(cache.get("2"), equalTo(12L));
130         assertThat(cache.get("3"), equalTo(13L));
131         assertThat(cache.get("4"), equalTo(14L));
132         assertSize(cache, 4);
133 
134         cache.remove("1");
135         cache.remove("2");
136         cache.remove("3");
137         assertSize(cache, 1);
138 
139         // Removed values should be null
140         assertThat(cache.get("1"), nullValue());
141         assertThat(cache.get("2"), nullValue());
142         assertThat(cache.get("3"), nullValue());
143         assertThat(cache.get("4"), equalTo(14L));
144         assertSize(cache, 1);
145 
146         final SortedMap<CacheStatisticsKey, Supplier<Long>> stats = ((ManagedCache)cache).getStatistics();
147         assertThat(stats.get(SIZE), stat(1L));
148         assertThat(stats.get(PUT_COUNT), stat(4L));
149         assertThat(stats.get(HIT_COUNT), stat(5L));
150         assertThat(stats.get(REMOVE_COUNT), stat(3L));
151         assertThat(stats.get(EVICTION_COUNT), stat(0L));
152         assertThat(stats.get(MISS_COUNT), stat(3L));
153     }
154 
155     @Test
156     public void testRemoveTwice() throws Exception
157     {
158         Cache<String, Long> cache = makeSimpleCache();
159         // Add some entries using the builder
160         cache.put("1", 11L);
161         cache.put("2", 12L);
162         cache.put("3", 13L);
163         cache.put("4", 14L);
164         assertThat(cache.get("1"), equalTo(11L));
165         assertThat(cache.get("2"), equalTo(12L));
166         assertThat(cache.get("3"), equalTo(13L));
167         assertThat(cache.get("4"), equalTo(14L));
168         assertSize(cache, 4);
169 
170         cache.remove("1");
171         // Remove again should be a no-op
172         cache.remove("1");
173         assertSize(cache, 3);
174 
175         // Removed values should be null
176         assertThat(cache.get("1"), nullValue());
177         assertThat(cache.get("2"), equalTo(12L));
178         assertThat(cache.get("3"), equalTo(13L));
179         assertThat(cache.get("4"), equalTo(14L));
180         assertSize(cache, 3);
181     }
182 
183     @SuppressWarnings("ConstantConditions")
184     @Test
185     public void testRemoveAll() throws Exception
186     {
187         Cache<String, Long> cache = makeSimpleCache();
188         // Add some entries using the builder
189         cache.put("1", 11L);
190         cache.put("2", 12L);
191         cache.put("3", 13L);
192         cache.put("4", 14L);
193         assertThat(cache.get("1"), equalTo(11L));
194         assertThat(cache.get("2"), equalTo(12L));
195         assertThat(cache.get("3"), equalTo(13L));
196         assertThat(cache.get("4"), equalTo(14L));
197         assertSize(cache, 4);
198 
199         cache.removeAll();
200         assertEmpty(cache);
201 
202         // Removed values should be recomputed
203         assertThat(cache.get("1"), nullValue());
204         assertThat(cache.get("2"), nullValue());
205         assertThat(cache.get("3"), nullValue());
206         assertThat(cache.get("4"), nullValue());
207         assertEmpty(cache);
208 
209         final SortedMap<CacheStatisticsKey, Supplier<Long>> stats = ((ManagedCache)cache).getStatistics();
210         assertThat(stats.get(SIZE), stat(0L));
211         assertThat(stats.get(PUT_COUNT), stat(4L));
212         assertThat(stats.get(HIT_COUNT), stat(4L));
213         assertThat(stats.get(REMOVE_COUNT), stat(0L));
214         assertThat(stats.get(EVICTION_COUNT), stat(0L));
215         assertThat(stats.get(MISS_COUNT), stat(4L));
216     }
217 
218     @Test
219     public void testClear() throws Exception
220     {
221         Cache<String, Long> cache = makeSimpleCache();
222         // Add some entries using the builder
223         cache.put("1", 11L);
224         cache.put("2", 12L);
225         cache.put("3", 13L);
226         cache.put("4", 14L);
227         assertThat(cache.get("1"), equalTo(11L));
228         assertThat(cache.get("2"), equalTo(12L));
229         assertThat(cache.get("3"), equalTo(13L));
230         assertThat(cache.get("4"), equalTo(14L));
231         assertSize(cache, 4);
232         // A cache that doesn't expire any entries should return all the keys
233 
234         ((ManagedCache)cache).clear();
235         assertEmpty(cache);
236 
237         // Removed values should be recomputed
238         assertThat(cache.get("1"), nullValue());
239         assertThat(cache.get("2"), nullValue());
240         assertThat(cache.get("3"), nullValue());
241         assertThat(cache.get("4"), nullValue());
242         assertEmpty(cache);
243     }
244 
245     @Test
246     public void conditionalPutPutsIfAbsent()
247     {
248         Cache<String, Long> cache = makeSimpleCache();
249         assertNull(cache.putIfAbsent("A", 1L));
250         assertEquals(Long.valueOf(1), cache.get("A"));
251     }
252 
253     @Test
254     public void conditionalPutDoesNotPutIfPresent()
255     {
256         Cache<String, Long> cache = makeSimpleCache();
257         cache.putIfAbsent("A", 1L);
258         assertEquals(Long.valueOf(1), cache.putIfAbsent("A", 2L));
259         assertEquals(Long.valueOf(1), cache.get("A"));
260     }
261 
262     @Test
263     public void replaceDoesNotReplaceIfAbsent()
264     {
265         Cache<String, Long> cache = makeSimpleCache();
266         assertFalse(cache.replace("A", 1L, 2L));
267         assertNull(cache.get("A"));
268     }
269 
270     @Test
271     public void replaceReplacesWhenValueMatches()
272     {
273         Cache<String, Long> cache = makeSimpleCache();
274         cache.put("A", 1L);
275         assertTrue(cache.replace("A", 1L, 2L));
276         assertEquals(Long.valueOf(2), cache.get("A"));
277     }
278 
279     @Test
280     public void replaceDoesNothingWhenValueDoesNotMatch()
281     {
282         Cache<String, Long> cache = makeSimpleCache();
283         cache.put("A", 1L);
284         assertFalse(cache.replace("A", 2L, 3L));
285         assertEquals(Long.valueOf(1), cache.get("A"));
286     }
287 
288     @Test
289     public void removeDoesNothingWhenNoKeyIsPresent()
290     {
291         Cache<String, Long> cache = makeSimpleCache();
292         assertFalse(cache.remove("A", 1L));
293     }
294 
295     @Test
296     public void removeRemovesWhenValueMatches()
297     {
298         Cache<String, Long> cache = makeSimpleCache();
299         cache.put("A", 1L);
300         assertTrue(cache.remove("A", 1L));
301         assertNull(cache.get("A"));
302     }
303 
304     @Test
305     public void removeDoesNotRemoveWhenValueDoesNotMatch()
306     {
307         Cache<String, Long> cache = makeSimpleCache();
308         cache.put("A", 2L);
309         assertFalse(cache.remove("A", 1L));
310         assertEquals(Long.valueOf(2), cache.get("A"));
311     }
312 
313     @Test
314     public void testMaxEntries() throws Exception
315     {
316         Cache<String, Long> cache = makeSizeLimitedCache(3);
317 
318         // Add some entries using the builder
319         cache.put("1", 11L);
320         cache.put("2", 12L);
321         cache.put("3", 13L);
322         assertThat(cache.get("1"), equalTo(11L));
323         assertThat(cache.get("2"), equalTo(12L));
324         assertThat(cache.get("3"), equalTo(13L));
325         assertSize(cache, 3);
326         cache.put("4", 14L);
327         assertSize(cache, 3);
328     }
329 
330     @Test
331     public void testBothExpireHintsSpecified()
332     {
333         CacheSettings required = new CacheSettingsBuilder()
334                 .expireAfterAccess(60, TimeUnit.SECONDS)
335                 .expireAfterWrite(30, TimeUnit.SECONDS)
336                 .build();
337         Cache<String, String> cache = factory.getCache("fruity", null, required);
338         assertThat(cache, not(nullValue()));
339     }
340 }
341