1
2
3
4
5
6 package net.sf.ehcache.config;
7
8 import java.util.ArrayList;
9 import java.util.List;
10
11 import net.sf.ehcache.AbstractCacheTest;
12 import org.junit.Assert;
13 import org.junit.Test;
14
15 /***
16 *
17 * @author cdennis
18 */
19 public class CacheConfigurationListenerTest extends AbstractCacheTest {
20
21 @Test
22 public void testTtiFires() {
23 CacheConfiguration config = new CacheConfiguration();
24 RecordingListener listener = new RecordingListener();
25 config.addConfigurationListener(listener);
26
27 assertRegistered(listener, config);
28 listener.clearFiredEvents();
29
30 for (int i = 0; i < 10; i++) {
31 config.setTimeToIdleSeconds(i + 1);
32 }
33
34 List<Event> events = listener.getFiredEvents();
35
36 Assert.assertEquals(10, events.size());
37
38 for (int i = 0; i < events.size(); i++) {
39 Event e = events.get(i);
40
41 Assert.assertEquals("tti", e.type);
42 Assert.assertEquals(Long.valueOf(i), e.oldValue);
43 Assert.assertEquals(Long.valueOf(i+1), e.newValue);
44 }
45 }
46
47 @Test
48 public void testTtlFires() {
49 CacheConfiguration config = new CacheConfiguration();
50 RecordingListener listener = new RecordingListener();
51 config.addConfigurationListener(listener);
52
53 assertRegistered(listener, config);
54 listener.clearFiredEvents();
55
56 for (int i = 0; i < 10; i++) {
57 config.setTimeToLiveSeconds(i + 1);
58 }
59
60 List<Event> events = listener.getFiredEvents();
61
62 Assert.assertEquals(10, events.size());
63
64 for (int i = 0; i < events.size(); i++) {
65 Event e = events.get(i);
66
67 Assert.assertEquals("ttl", e.type);
68 Assert.assertEquals(Long.valueOf(i), e.oldValue);
69 Assert.assertEquals(Long.valueOf(i+1), e.newValue);
70 }
71 }
72
73 @Test
74 public void testDiskCapacityFires() {
75 CacheConfiguration config = new CacheConfiguration();
76 RecordingListener listener = new RecordingListener();
77 config.addConfigurationListener(listener);
78
79 assertRegistered(listener, config);
80 listener.clearFiredEvents();
81
82 for (int i = 0; i < 10; i++) {
83 config.setMaxElementsOnDisk(i + 1);
84 }
85
86 List<Event> events = listener.getFiredEvents();
87
88 Assert.assertEquals(10, events.size());
89
90 for (int i = 0; i < events.size(); i++) {
91 Event e = events.get(i);
92
93 Assert.assertEquals("disk", e.type);
94 Assert.assertEquals(Integer.valueOf(i), e.oldValue);
95 Assert.assertEquals(Integer.valueOf(i+1), e.newValue);
96 }
97 }
98
99 @Test
100 public void testMemoryCapacityFires() {
101 CacheConfiguration config = new CacheConfiguration();
102 RecordingListener listener = new RecordingListener();
103 config.addConfigurationListener(listener);
104
105 assertRegistered(listener, config);
106 listener.clearFiredEvents();
107
108 for (int i = 0; i < 10; i++) {
109 config.setMaxElementsInMemory(i + 1);
110 }
111
112 List<Event> events = listener.getFiredEvents();
113
114 Assert.assertEquals(10, events.size());
115
116 for (int i = 0; i < events.size(); i++) {
117 Event e = events.get(i);
118
119 Assert.assertEquals("mem", e.type);
120 Assert.assertEquals(Integer.valueOf(i), e.oldValue);
121 Assert.assertEquals(Integer.valueOf(i+1), e.newValue);
122 }
123 }
124
125 @Test
126 public void testLoggingEnableDisable() {
127 CacheConfiguration config = new CacheConfiguration();
128 RecordingListener listener = new RecordingListener();
129 config.addConfigurationListener(listener);
130
131 assertRegistered(listener, config);
132 listener.clearFiredEvents();
133
134 config.setLogging(true);
135 List<Event> events = listener.getFiredEvents();
136 Assert.assertEquals(1, events.size());
137
138 config.setLogging(false);
139 events = listener.getFiredEvents();
140 Assert.assertEquals(2, events.size());
141
142 for (int i = 0; i < events.size(); i++) {
143 Event e = events.get(i);
144
145 Assert.assertEquals("logging", e.type);
146 Assert.assertEquals(Boolean.valueOf(i != 0), e.oldValue);
147 Assert.assertEquals(Boolean.valueOf(i == 0), e.newValue);
148 }
149 }
150
151 @Test
152 public void testMultipleListeners() {
153 CacheConfiguration config = new CacheConfiguration();
154 RecordingListener listener1 = new RecordingListener();
155 RecordingListener listener2 = new RecordingListener();
156 config.addConfigurationListener(listener1);
157 config.addConfigurationListener(listener2);
158
159 assertRegistered(listener1, config);
160 assertRegistered(listener2, config);
161 listener1.clearFiredEvents();
162 listener2.clearFiredEvents();
163
164 for (int i = 0; i < 10; i++) {
165 config.setTimeToIdleSeconds(i);
166 config.setTimeToLiveSeconds(i);
167 config.setMaxElementsInMemory(i);
168 config.setMaxElementsOnDisk(i);
169 }
170
171
172 Assert.assertEquals(36, listener1.getFiredEvents().size());
173 Assert.assertEquals(36, listener2.getFiredEvents().size());
174
175 Assert.assertEquals(listener1.getFiredEvents(), listener2.getFiredEvents());
176 }
177
178 @Test
179 public void testRemovingListeners() {
180 CacheConfiguration config = new CacheConfiguration();
181 RecordingListener listener1 = new RecordingListener();
182 RecordingListener listener2 = new RecordingListener();
183 config.addConfigurationListener(listener1);
184 config.addConfigurationListener(listener2);
185
186 assertRegistered(listener1, config);
187 assertRegistered(listener2, config);
188 listener1.clearFiredEvents();
189 listener2.clearFiredEvents();
190
191 for (int i = 0; i < 5; i++) {
192 config.setTimeToIdleSeconds(i);
193 config.setTimeToLiveSeconds(i);
194 config.setMaxElementsInMemory(i);
195 config.setMaxElementsOnDisk(i);
196 }
197
198 config.removeConfigurationListener(listener1);
199 assertDeregistered(listener1, config);
200
201 for (int i = 5; i < 10; i++) {
202 config.setTimeToIdleSeconds(i);
203 config.setTimeToLiveSeconds(i);
204 config.setMaxElementsInMemory(i);
205 config.setMaxElementsOnDisk(i);
206 }
207
208 config.removeConfigurationListener(listener2);
209 assertDeregistered(listener2, config);
210
211 List<Event> events1 = listener1.getFiredEvents();
212 List<Event> events2 = listener2.getFiredEvents();
213
214
215 Assert.assertEquals(17, events1.size());
216
217 Assert.assertEquals(37, events2.size());
218
219 for (Event e : events1) {
220 Assert.assertTrue(events2.contains(e));
221 }
222 }
223
224 private void assertRegistered(RecordingListener listener, CacheConfiguration config) {
225 List<Event> events = listener.getFiredEvents();
226 Assert.assertTrue(events.contains(new Event("registered", null, config)));
227 }
228
229 private void assertDeregistered(RecordingListener listener, CacheConfiguration config) {
230 List<Event> events = listener.getFiredEvents();
231 Assert.assertTrue(events.contains(new Event("deregistered", config, null)));
232 }
233
234 static class RecordingListener implements CacheConfigurationListener {
235
236 private final List<Event> firedEvents = new ArrayList<Event>();
237
238 public void timeToIdleChanged(long oldTti, long newTti) {
239 firedEvents.add(new Event("tti", Long.valueOf(oldTti), Long.valueOf(newTti)));
240 }
241
242 public void timeToLiveChanged(long oldTtl, long newTtl) {
243 firedEvents.add(new Event("ttl", Long.valueOf(oldTtl), Long.valueOf(newTtl)));
244 }
245
246 public void diskCapacityChanged(int oldCapacity, int newCapacity) {
247 firedEvents.add(new Event("disk", Integer.valueOf(oldCapacity), Integer.valueOf(newCapacity)));
248 }
249
250 public void loggingChanged(boolean oldValue, boolean newValue) {
251 firedEvents.add(new Event("logging", Boolean.valueOf(oldValue), Boolean.valueOf(newValue)));
252 }
253
254 public void memoryCapacityChanged(int oldCapacity, int newCapacity) {
255 firedEvents.add(new Event("mem", Integer.valueOf(oldCapacity), Integer.valueOf(newCapacity)));
256 }
257
258 public void registered(CacheConfiguration config) {
259 firedEvents.add(new Event("registered", null, config));
260 }
261
262 public void deregistered(CacheConfiguration config) {
263 firedEvents.add(new Event("deregistered", config, null));
264 }
265
266 public List<Event> getFiredEvents() {
267 return new ArrayList<Event>(firedEvents);
268 }
269
270 public void clearFiredEvents() {
271 firedEvents.clear();
272 }
273 }
274
275 static class Event {
276 public final String type;
277 public final Object oldValue;
278 public final Object newValue;
279
280 public Event(String type, Object oldValue, Object newValue) {
281 this.type = type;
282 this.oldValue = oldValue;
283 this.newValue = newValue;
284 }
285
286 @Override
287 public boolean equals(Object o) {
288 if (o instanceof Event) {
289 Event e = (Event) o;
290 return type.equals(e.type)
291 && (oldValue == null ? e.oldValue == null : oldValue.equals(e.oldValue))
292 && (newValue == null ? e.newValue == null : newValue.equals(e.newValue));
293 } else {
294 return false;
295 }
296 }
297
298 @Override
299 public int hashCode() {
300 int hash = 7;
301 hash = 53 * hash + (this.type != null ? this.type.hashCode() : 0);
302 hash = 53 * hash + (this.oldValue != null ? this.oldValue.hashCode() : 0);
303 hash = 53 * hash + (this.newValue != null ? this.newValue.hashCode() : 0);
304 return hash;
305 }
306 }
307 }