1 package org.apache.commons.jcs3.jcache;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import org.junit.Test;
23
24 import javax.cache.Cache;
25 import javax.cache.CacheManager;
26 import javax.cache.Caching;
27 import javax.cache.configuration.CacheEntryListenerConfiguration;
28 import javax.cache.configuration.CompleteConfiguration;
29 import javax.cache.configuration.Factory;
30 import javax.cache.configuration.MutableConfiguration;
31 import javax.cache.event.CacheEntryCreatedListener;
32 import javax.cache.event.CacheEntryEventFilter;
33 import javax.cache.event.CacheEntryListener;
34 import javax.cache.event.CacheEntryRemovedListener;
35 import javax.cache.event.CacheEntryUpdatedListener;
36 import javax.cache.expiry.AccessedExpiryPolicy;
37 import javax.cache.expiry.Duration;
38 import javax.cache.expiry.ExpiryPolicy;
39 import javax.cache.integration.CacheLoader;
40 import javax.cache.integration.CacheLoaderException;
41 import javax.cache.integration.CacheWriter;
42 import javax.cache.spi.CachingProvider;
43 import java.util.HashSet;
44 import java.util.Map;
45 import java.util.Set;
46 import java.util.concurrent.TimeUnit;
47
48 import static org.junit.Assert.assertEquals;
49 import static org.junit.Assert.assertFalse;
50 import static org.junit.Assert.assertTrue;
51
52 public class CacheTest
53 {
54 @Test
55 public void accessExpiry() throws InterruptedException
56 {
57 final CachingProvider cachingProvider = Caching.getCachingProvider();
58 final CacheManager cacheManager = cachingProvider.getCacheManager(cachingProvider.getDefaultURI(),
59 Thread.currentThread().getContextClassLoader(),
60 cachingProvider.getDefaultProperties());
61 final Cache<Integer, Integer> cache = cacheManager.createCache(
62 "test",
63 new MutableConfiguration<Integer, Integer>()
64 .setStoreByValue(false)
65 .setStatisticsEnabled(true)
66 .setManagementEnabled(true)
67 .setTypes(Integer.class, Integer.class)
68 .setExpiryPolicyFactory(AccessedExpiryPolicy.factoryOf(new Duration(TimeUnit.MILLISECONDS, 500))));
69
70 try {
71 cache.put(1, 2);
72 cache.get(1);
73 Thread.sleep(650);
74 assertFalse(cache.containsKey(1));
75 cache.put(1, 2);
76 for (int i = 0; i < 3; i++) {
77 Thread.sleep(250);
78 assertTrue("iteration: " + Integer.toString(i), cache.containsKey(1));
79 }
80 assertTrue(cache.containsKey(1));
81 Thread.sleep(650);
82 assertFalse(cache.containsKey(1));
83 } finally {
84 cacheManager.close();
85 cachingProvider.close();
86 }
87 }
88
89 @Test
90 public void getPut()
91 {
92 final CachingProvider cachingProvider = Caching.getCachingProvider();
93 final CacheManager cacheManager = cachingProvider.getCacheManager();
94 final Cache<String, String> cache = cacheManager.createCache("default", new MutableConfiguration<String, String>());
95 assertFalse(cache.containsKey("foo"));
96 cache.put("foo", "bar");
97 assertTrue(cache.containsKey("foo"));
98 assertEquals("bar", cache.get("foo"));
99 cache.remove("foo");
100 assertFalse(cache.containsKey("foo"));
101 cachingProvider.close();
102 }
103
104 @Test
105 public void listeners()
106 {
107 final CachingProvider cachingProvider = Caching.getCachingProvider();
108 final CacheManager cacheManager = cachingProvider.getCacheManager();
109 cacheManager.createCache("default", new MutableConfiguration<>());
110 final Cache<String, String> cache = cacheManager.getCache("default");
111 final Set<String> event = new HashSet<>();
112 cache.registerCacheEntryListener(new CacheEntryListenerConfiguration<String, String>()
113 {
114
115
116
117 private static final long serialVersionUID = -8253611067837660184L;
118
119 @Override
120 public Factory<CacheEntryListener<? super String, ? super String>> getCacheEntryListenerFactory()
121 {
122 return () -> (CacheEntryCreatedListener<String, String>) cacheEntryEvents -> event.add(cacheEntryEvents.iterator().next().getKey());
123 }
124
125 @Override
126 public boolean isOldValueRequired()
127 {
128 return false;
129 }
130
131 @Override
132 public Factory<CacheEntryEventFilter<? super String, ? super String>> getCacheEntryEventFilterFactory()
133 {
134 return null;
135 }
136
137 @Override
138 public boolean isSynchronous()
139 {
140 return false;
141 }
142 });
143 cache.registerCacheEntryListener(new CacheEntryListenerConfiguration<String, String>()
144 {
145
146
147
148 private static final long serialVersionUID = 74774789357823553L;
149
150 @Override
151 public Factory<CacheEntryListener<? super String, ? super String>> getCacheEntryListenerFactory()
152 {
153 return () -> (CacheEntryUpdatedListener<String, String>) cacheEntryEvents -> event.add(cacheEntryEvents.iterator().next().getKey());
154 }
155
156 @Override
157 public boolean isOldValueRequired()
158 {
159 return false;
160 }
161
162 @Override
163 public Factory<CacheEntryEventFilter<? super String, ? super String>> getCacheEntryEventFilterFactory()
164 {
165 return null;
166 }
167
168 @Override
169 public boolean isSynchronous()
170 {
171 return false;
172 }
173 });
174 cache.registerCacheEntryListener(new CacheEntryListenerConfiguration<String, String>()
175 {
176
177
178
179 private static final long serialVersionUID = 2442816458182278519L;
180
181 @Override
182 public Factory<CacheEntryListener<? super String, ? super String>> getCacheEntryListenerFactory()
183 {
184 return () -> (CacheEntryRemovedListener<String, String>) cacheEntryEvents -> event.add(cacheEntryEvents.iterator().next().getKey());
185 }
186
187 @Override
188 public boolean isOldValueRequired()
189 {
190 return false;
191 }
192
193 @Override
194 public Factory<CacheEntryEventFilter<? super String, ? super String>> getCacheEntryEventFilterFactory()
195 {
196 return null;
197 }
198
199 @Override
200 public boolean isSynchronous()
201 {
202 return false;
203 }
204 });
205
206 cache.put("foo", "bar");
207 assertEquals(1, event.size());
208 assertEquals("foo", event.iterator().next());
209 event.clear();
210 cache.put("foo", "new");
211 assertEquals(1, event.size());
212 assertEquals("foo", event.iterator().next());
213 event.clear();
214 cache.remove("foo");
215 assertEquals(1, event.size());
216 assertEquals("foo", event.iterator().next());
217
218 cachingProvider.close();
219 }
220
221 @Test
222 public void loader()
223 {
224 final CachingProvider cachingProvider = Caching.getCachingProvider();
225 final CacheManager cacheManager = cachingProvider.getCacheManager();
226 cacheManager.createCache("default", new CompleteConfiguration<Object, Object>()
227 {
228
229
230
231 private static final long serialVersionUID = -4598329777808827966L;
232
233 @Override
234 public boolean isReadThrough()
235 {
236 return true;
237 }
238
239 @Override
240 public boolean isWriteThrough()
241 {
242 return false;
243 }
244
245 @Override
246 public boolean isStatisticsEnabled()
247 {
248 return false;
249 }
250
251 @Override
252 public boolean isManagementEnabled()
253 {
254 return false;
255 }
256
257 @Override
258 public Iterable<CacheEntryListenerConfiguration<Object, Object>> getCacheEntryListenerConfigurations()
259 {
260 return null;
261 }
262
263 @Override
264 public Factory<CacheLoader<Object, Object>> getCacheLoaderFactory()
265 {
266 return () -> new CacheLoader<Object, Object>()
267 {
268 @Override
269 public Object load(final Object key) throws CacheLoaderException
270 {
271 return "super";
272 }
273
274 @Override
275 public Map<Object, Object> loadAll(final Iterable<?> keys) throws CacheLoaderException
276 {
277 return null;
278 }
279 };
280 }
281
282 @Override
283 public Factory<CacheWriter<? super Object, ? super Object>> getCacheWriterFactory()
284 {
285 return null;
286 }
287
288 @Override
289 public Factory<ExpiryPolicy> getExpiryPolicyFactory()
290 {
291 return null;
292 }
293
294 @Override
295 public Class<Object> getKeyType()
296 {
297 return Object.class;
298 }
299
300 @Override
301 public Class<Object> getValueType()
302 {
303 return Object.class;
304 }
305
306 @Override
307 public boolean isStoreByValue()
308 {
309 return false;
310 }
311 });
312 final Cache<String, String> cache = cacheManager.getCache("default");
313 assertEquals("super", cache.get("lazilyLoaded"));
314 cachingProvider.close();
315 }
316 }