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