1 |
| |
2 |
| |
3 |
| |
4 |
| |
5 |
| |
6 |
| |
7 |
| package org.jboss.cache.eviction; |
8 |
| |
9 |
| import junit.framework.Test; |
10 |
| import junit.framework.TestCase; |
11 |
| import junit.framework.TestSuite; |
12 |
| import org.jboss.cache.CacheImpl; |
13 |
| import org.jboss.cache.DefaultCacheFactory; |
14 |
| import org.jboss.cache.Fqn; |
15 |
| import org.jboss.cache.Region; |
16 |
| import org.jboss.cache.RegionManager; |
17 |
| |
18 |
| import java.util.Iterator; |
19 |
| |
20 |
| |
21 |
| |
22 |
| |
23 |
| |
24 |
| |
25 |
| |
26 |
| public class LFUAlgorithmTest extends TestCase |
27 |
| { |
28 |
| |
29 |
| RegionManager regionManager; |
30 |
| LFUAlgorithm algo; |
31 |
| |
32 |
6
| public LFUAlgorithmTest(String s)
|
33 |
| { |
34 |
6
| super(s);
|
35 |
| } |
36 |
| |
37 |
6
| public void setUp() throws Exception
|
38 |
| { |
39 |
6
| super.setUp();
|
40 |
| |
41 |
6
| algo = new LFUAlgorithm();
|
42 |
6
| LFUConfiguration config = new LFUConfiguration();
|
43 |
6
| regionManager = new RegionManager((CacheImpl) DefaultCacheFactory.getInstance().createCache(false));
|
44 |
6
| config.setEvictionPolicyClass(DummyEvictionPolicy.class.getName());
|
45 |
6
| regionManager.getRegion("/a/b", true).setEvictionPolicy(config);
|
46 |
| |
47 |
| |
48 |
| } |
49 |
| |
50 |
6
| public void tearDown() throws Exception
|
51 |
| { |
52 |
6
| super.tearDown();
|
53 |
| } |
54 |
| |
55 |
1
| public void testMaxNode1()
|
56 |
| { |
57 |
1
| Fqn fqn1 = Fqn.fromString("/a/b/c");
|
58 |
1
| Fqn fqn2 = Fqn.fromString("/a/b/d");
|
59 |
1
| Region region = regionManager.getRegion("/a/b", true);
|
60 |
1
| LFUConfiguration config = new LFUConfiguration();
|
61 |
1
| config.setMaxNodes(0);
|
62 |
1
| config.setMinNodes(20);
|
63 |
1
| region.setEvictionPolicy(config);
|
64 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
|
65 |
1
| region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
|
66 |
1
| try
|
67 |
| { |
68 |
1
| algo.process(region);
|
69 |
| } |
70 |
| catch (EvictionException e) |
71 |
| { |
72 |
0
| fail("testMaxNode: process failed " + e);
|
73 |
0
| e.printStackTrace();
|
74 |
| } |
75 |
1
| assertEquals("Queue size should be ", 2, algo.getEvictionQueue().getNumberOfNodes());
|
76 |
| |
77 |
| } |
78 |
| |
79 |
1
| public void testMaxNode2()
|
80 |
| { |
81 |
1
| Fqn fqn1 = Fqn.fromString("/a/b/c");
|
82 |
1
| Fqn fqn2 = Fqn.fromString("/a/b/d");
|
83 |
1
| Fqn fqn3 = Fqn.fromString("/a/b/e");
|
84 |
1
| Region region = regionManager.getRegion("/a/b", true);
|
85 |
1
| LFUConfiguration config = new LFUConfiguration();
|
86 |
1
| config.setMaxNodes(1);
|
87 |
1
| config.setMinNodes(20);
|
88 |
1
| region.setEvictionPolicy(config);
|
89 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
|
90 |
1
| region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
|
91 |
| |
92 |
1
| try
|
93 |
| { |
94 |
1
| algo.process(region);
|
95 |
| } |
96 |
| catch (EvictionException e) |
97 |
| { |
98 |
0
| fail("testMaxNode: process failed " + e);
|
99 |
0
| e.printStackTrace();
|
100 |
| } |
101 |
1
| assertEquals("Queue size should be ", 1, algo.getEvictionQueue().getNumberOfNodes());
|
102 |
| |
103 |
1
| region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
|
104 |
1
| region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
|
105 |
| |
106 |
| |
107 |
1
| try
|
108 |
| { |
109 |
1
| algo.process(region);
|
110 |
| } |
111 |
| catch (EvictionException e) |
112 |
| { |
113 |
0
| fail("testMaxNode: process failed " + e);
|
114 |
0
| e.printStackTrace();
|
115 |
| } |
116 |
1
| assertEquals("Queue size should be ", 1, algo.getEvictionQueue().getNumberOfNodes());
|
117 |
| } |
118 |
| |
119 |
| |
120 |
| |
121 |
| |
122 |
| |
123 |
| |
124 |
| |
125 |
| |
126 |
| |
127 |
| |
128 |
| |
129 |
| |
130 |
| |
131 |
| |
132 |
| |
133 |
| |
134 |
| |
135 |
| |
136 |
| |
137 |
| |
138 |
| |
139 |
| |
140 |
| |
141 |
| |
142 |
| |
143 |
| |
144 |
| |
145 |
| |
146 |
| |
147 |
| |
148 |
1
| public void testMinNode1() throws Exception
|
149 |
| { |
150 |
1
| Fqn fqn1 = Fqn.fromString("/a/b/c");
|
151 |
1
| Fqn fqn2 = Fqn.fromString("/a/b/c/d");
|
152 |
1
| Fqn fqn3 = Fqn.fromString("/a/b/c/d/e");
|
153 |
1
| Fqn fqn4 = Fqn.fromString("/a/b/c/d/e/f");
|
154 |
| |
155 |
1
| Region region = regionManager.getRegion("/a/b", true);
|
156 |
1
| LFUConfiguration config = (LFUConfiguration) region.getEvictionPolicyConfig();
|
157 |
| |
158 |
1
| config.setMaxNodes(0);
|
159 |
1
| config.setMinNodes(2);
|
160 |
| |
161 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
|
162 |
1
| region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
|
163 |
1
| region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
|
164 |
1
| region.putNodeEvent(new EvictedEventNode(fqn4, NodeEventType.ADD_NODE_EVENT));
|
165 |
| |
166 |
1
| algo.process(region);
|
167 |
| |
168 |
1
| assertEquals("Queue size should be ", 2, algo.getEvictionQueue().getNumberOfNodes());
|
169 |
| } |
170 |
| |
171 |
1
| public void testMinNode2() throws Exception
|
172 |
| { |
173 |
1
| Fqn fqn1 = Fqn.fromString("/a/b/c");
|
174 |
1
| Fqn fqn2 = Fqn.fromString("/a/b/d");
|
175 |
| |
176 |
1
| Region region = regionManager.getRegion("/a/b", true);
|
177 |
1
| LFUConfiguration config = (LFUConfiguration) region.getEvictionPolicyConfig();
|
178 |
| |
179 |
1
| config.setMaxNodes(0);
|
180 |
1
| config.setMinNodes(0);
|
181 |
| |
182 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
|
183 |
1
| region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
|
184 |
| |
185 |
1
| algo.process(region);
|
186 |
| |
187 |
1
| assertEquals("Queue size should be ", 0, algo.getEvictionQueue().getNumberOfNodes());
|
188 |
| } |
189 |
| |
190 |
1
| public void testEvictionQueueSortOrder1() throws Exception
|
191 |
| { |
192 |
1
| Fqn fqn1 = Fqn.fromString("/a/b/c");
|
193 |
1
| Fqn fqn2 = Fqn.fromString("/a/b/c/d");
|
194 |
1
| Fqn fqn3 = Fqn.fromString("/a/b/c/d/e");
|
195 |
1
| Fqn fqn4 = Fqn.fromString("/a/b/c/d/e/f");
|
196 |
1
| Fqn fqn5 = Fqn.fromString("/a/b/c/d/e/f/g/h");
|
197 |
1
| Fqn fqn6 = Fqn.fromString("/a/b/c/d/e/f/g/h/i");
|
198 |
1
| Fqn fqn7 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j");
|
199 |
1
| Fqn fqn8 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j/k");
|
200 |
1
| Fqn fqn9 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j/k/l");
|
201 |
1
| Fqn fqn10 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j/k/l/m");
|
202 |
| |
203 |
| |
204 |
1
| Region region = regionManager.getRegion("/a/b", true);
|
205 |
1
| LFUConfiguration config = (LFUConfiguration) region.getEvictionPolicyConfig();
|
206 |
1
| config.setMaxNodes(0);
|
207 |
1
| config.setMinNodes(100);
|
208 |
| |
209 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
|
210 |
1
| region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
|
211 |
1
| region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
|
212 |
1
| region.putNodeEvent(new EvictedEventNode(fqn4, NodeEventType.ADD_NODE_EVENT));
|
213 |
1
| region.putNodeEvent(new EvictedEventNode(fqn5, NodeEventType.ADD_NODE_EVENT));
|
214 |
1
| region.putNodeEvent(new EvictedEventNode(fqn6, NodeEventType.ADD_NODE_EVENT));
|
215 |
1
| region.putNodeEvent(new EvictedEventNode(fqn7, NodeEventType.ADD_NODE_EVENT));
|
216 |
1
| region.putNodeEvent(new EvictedEventNode(fqn8, NodeEventType.ADD_NODE_EVENT));
|
217 |
1
| region.putNodeEvent(new EvictedEventNode(fqn9, NodeEventType.ADD_NODE_EVENT));
|
218 |
1
| region.putNodeEvent(new EvictedEventNode(fqn10, NodeEventType.ADD_NODE_EVENT));
|
219 |
| |
220 |
1
| algo.process(region);
|
221 |
1
| LFUQueue queue = (LFUQueue) algo.evictionQueue;
|
222 |
1
| assertEquals(10, algo.getEvictionQueue().getNumberOfNodes());
|
223 |
1
| Iterator it = queue.iterate();
|
224 |
| |
225 |
1
| while (it.hasNext())
|
226 |
| { |
227 |
10
| NodeEntry ne = (NodeEntry) it.next();
|
228 |
10
| System.out.println("Fqn: " + ne.getFqn() + " NodeVisits: " + ne.getNumberOfNodeVisits());
|
229 |
10
| assertEquals(1, ne.getNumberOfNodeVisits());
|
230 |
| } |
231 |
| |
232 |
| |
233 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
|
234 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
|
235 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
|
236 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
|
237 |
| |
238 |
| |
239 |
1
| region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.VISIT_NODE_EVENT));
|
240 |
1
| region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.VISIT_NODE_EVENT));
|
241 |
1
| region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.VISIT_NODE_EVENT));
|
242 |
| |
243 |
| |
244 |
1
| region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.VISIT_NODE_EVENT));
|
245 |
| |
246 |
| |
247 |
1
| region.putNodeEvent(new EvictedEventNode(fqn4, NodeEventType.VISIT_NODE_EVENT));
|
248 |
1
| region.putNodeEvent(new EvictedEventNode(fqn4, NodeEventType.VISIT_NODE_EVENT));
|
249 |
| |
250 |
| |
251 |
1
| region.putNodeEvent(new EvictedEventNode(fqn9, NodeEventType.VISIT_NODE_EVENT));
|
252 |
| |
253 |
| |
254 |
1
| region.putNodeEvent(new EvictedEventNode(fqn10, NodeEventType.VISIT_NODE_EVENT));
|
255 |
1
| region.putNodeEvent(new EvictedEventNode(fqn10, NodeEventType.VISIT_NODE_EVENT));
|
256 |
| |
257 |
1
| algo.process(region);
|
258 |
1
| System.out.println();
|
259 |
1
| System.out.println();
|
260 |
| |
261 |
1
| it = queue.iterate();
|
262 |
1
| int count = 0;
|
263 |
1
| while (it.hasNext())
|
264 |
| { |
265 |
10
| count++;
|
266 |
10
| NodeEntry ne = (NodeEntry) it.next();
|
267 |
10
| System.out.println("Fqn: " + ne.getFqn() + " NodeVisits: " + ne.getNumberOfNodeVisits());
|
268 |
10
| if (count == 5 || count == 6)
|
269 |
| { |
270 |
2
| assertEquals(2, ne.getNumberOfNodeVisits());
|
271 |
| } |
272 |
8
| else if (count == 7 || count == 8)
|
273 |
| { |
274 |
2
| assertEquals(3, ne.getNumberOfNodeVisits());
|
275 |
| } |
276 |
6
| else if (count == 9)
|
277 |
| { |
278 |
1
| assertEquals(4, ne.getNumberOfNodeVisits());
|
279 |
| } |
280 |
5
| else if (count == 10)
|
281 |
| { |
282 |
1
| assertEquals(5, ne.getNumberOfNodeVisits());
|
283 |
| } |
284 |
| else |
285 |
| { |
286 |
4
| assertEquals(1, ne.getNumberOfNodeVisits());
|
287 |
| } |
288 |
| } |
289 |
| |
290 |
| |
291 |
1
| assertEquals(10, algo.getEvictionQueue().getNumberOfNodes());
|
292 |
| |
293 |
1
| Fqn fqn11 = Fqn.fromString("/a");
|
294 |
1
| Fqn fqn12 = Fqn.fromString("/a/b");
|
295 |
| |
296 |
1
| region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.ADD_NODE_EVENT));
|
297 |
1
| region.putNodeEvent(new EvictedEventNode(fqn12, NodeEventType.ADD_NODE_EVENT));
|
298 |
| |
299 |
1
| algo.process(region);
|
300 |
1
| System.out.println();
|
301 |
1
| System.out.println();
|
302 |
| |
303 |
1
| it = queue.iterate();
|
304 |
1
| count = 0;
|
305 |
1
| while (it.hasNext())
|
306 |
| { |
307 |
12
| count++;
|
308 |
12
| NodeEntry ne = (NodeEntry) it.next();
|
309 |
12
| System.out.println("Fqn: " + ne.getFqn() + " NodeVisits: " + ne.getNumberOfNodeVisits());
|
310 |
12
| if (count == 7 || count == 8)
|
311 |
| { |
312 |
2
| assertEquals(2, ne.getNumberOfNodeVisits());
|
313 |
| } |
314 |
10
| else if (count == 9 || count == 10)
|
315 |
| { |
316 |
2
| assertEquals(3, ne.getNumberOfNodeVisits());
|
317 |
| } |
318 |
8
| else if (count == 11)
|
319 |
| { |
320 |
1
| assertEquals(4, ne.getNumberOfNodeVisits());
|
321 |
| } |
322 |
7
| else if (count == 12)
|
323 |
| { |
324 |
1
| assertEquals(5, ne.getNumberOfNodeVisits());
|
325 |
| } |
326 |
| else |
327 |
| { |
328 |
6
| assertEquals(1, ne.getNumberOfNodeVisits());
|
329 |
| } |
330 |
| } |
331 |
| |
332 |
1
| assertEquals(12, algo.getEvictionQueue().getNumberOfNodes());
|
333 |
| |
334 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.REMOVE_NODE_EVENT));
|
335 |
1
| region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.REMOVE_NODE_EVENT));
|
336 |
1
| region.putNodeEvent(new EvictedEventNode(fqn12, NodeEventType.REMOVE_NODE_EVENT));
|
337 |
1
| region.putNodeEvent(new EvictedEventNode(fqn10, NodeEventType.REMOVE_NODE_EVENT));
|
338 |
| |
339 |
1
| algo.process(region);
|
340 |
| |
341 |
1
| System.out.println();
|
342 |
1
| System.out.println();
|
343 |
1
| it = queue.iterate();
|
344 |
1
| count = 0;
|
345 |
1
| while (it.hasNext())
|
346 |
| { |
347 |
8
| count++;
|
348 |
8
| NodeEntry ne = (NodeEntry) it.next();
|
349 |
8
| System.out.println("Fqn: " + ne.getFqn() + " NodeVisits: " + ne.getNumberOfNodeVisits());
|
350 |
8
| if (count == 5 || count == 6)
|
351 |
| { |
352 |
2
| assertEquals(2, ne.getNumberOfNodeVisits());
|
353 |
| } |
354 |
6
| else if (count == 7)
|
355 |
| { |
356 |
1
| assertEquals(3, ne.getNumberOfNodeVisits());
|
357 |
| } |
358 |
5
| else if (count == 8)
|
359 |
| { |
360 |
1
| assertEquals(4, ne.getNumberOfNodeVisits());
|
361 |
| } |
362 |
| else |
363 |
| { |
364 |
4
| assertEquals(1, ne.getNumberOfNodeVisits());
|
365 |
| } |
366 |
| } |
367 |
| |
368 |
1
| assertEquals(8, algo.getEvictionQueue().getNumberOfNodes());
|
369 |
| |
370 |
| |
371 |
1
| region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.ADD_NODE_EVENT));
|
372 |
1
| region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.VISIT_NODE_EVENT));
|
373 |
1
| region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.VISIT_NODE_EVENT));
|
374 |
1
| region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.VISIT_NODE_EVENT));
|
375 |
1
| region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.VISIT_NODE_EVENT));
|
376 |
1
| region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.VISIT_NODE_EVENT));
|
377 |
1
| region.putNodeEvent(new EvictedEventNode(fqn4, NodeEventType.VISIT_NODE_EVENT));
|
378 |
| |
379 |
| |
380 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
|
381 |
1
| region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
|
382 |
| |
383 |
1
| region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.REMOVE_NODE_EVENT));
|
384 |
| |
385 |
| |
386 |
1
| algo.process(region);
|
387 |
| |
388 |
1
| System.out.println();
|
389 |
1
| System.out.println();
|
390 |
1
| it = queue.iterate();
|
391 |
1
| count = 0;
|
392 |
1
| while (it.hasNext())
|
393 |
| { |
394 |
9
| count++;
|
395 |
9
| NodeEntry ne = (NodeEntry) it.next();
|
396 |
9
| System.out.println("Fqn: " + ne.getFqn() + " NodeVisits: " + ne.getNumberOfNodeVisits());
|
397 |
9
| if (count == 5 || count == 6)
|
398 |
| { |
399 |
2
| assertEquals(2, ne.getNumberOfNodeVisits());
|
400 |
| } |
401 |
7
| else if (count == 7 || count == 8)
|
402 |
| { |
403 |
2
| assertEquals(4, ne.getNumberOfNodeVisits());
|
404 |
| } |
405 |
5
| else if (count == 9)
|
406 |
| { |
407 |
1
| assertEquals(6, ne.getNumberOfNodeVisits());
|
408 |
| } |
409 |
| else |
410 |
| { |
411 |
4
| assertEquals(1, ne.getNumberOfNodeVisits());
|
412 |
| } |
413 |
| } |
414 |
1
| assertEquals(9, algo.getEvictionQueue().getNumberOfNodes());
|
415 |
| } |
416 |
| |
417 |
1
| public void testEvictionQueueSortOrder2() throws Exception
|
418 |
| { |
419 |
1
| Region region = regionManager.getRegion("/a/b", true);
|
420 |
1
| LFUConfiguration config = (LFUConfiguration) region.getEvictionPolicyConfig();
|
421 |
| |
422 |
1
| config.setMaxNodes(0);
|
423 |
1
| config.setMinNodes(10000);
|
424 |
1
| for (int i = 0; i < 10000; i++)
|
425 |
| { |
426 |
10000
| Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
|
427 |
10000
| region.putNodeEvent(new EvictedEventNode(fqn, NodeEventType.ADD_NODE_EVENT));
|
428 |
| } |
429 |
| |
430 |
1
| algo.process(region);
|
431 |
1
| LFUQueue queue = (LFUQueue) algo.evictionQueue;
|
432 |
1
| Iterator it = queue.iterate();
|
433 |
| |
434 |
1
| long lastModifiedTimestamp = 0;
|
435 |
1
| while (it.hasNext())
|
436 |
| { |
437 |
10000
| NodeEntry ne = (NodeEntry) it.next();
|
438 |
10000
| assertTrue(lastModifiedTimestamp <= ne.getModifiedTimeStamp());
|
439 |
10000
| lastModifiedTimestamp = ne.getModifiedTimeStamp();
|
440 |
| } |
441 |
| |
442 |
1
| for (int i = 0; i < 10000; i++)
|
443 |
| { |
444 |
10000
| if ((i % 2) == 0)
|
445 |
| { |
446 |
5000
| Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
|
447 |
5000
| region.putNodeEvent(new EvictedEventNode(fqn, NodeEventType.VISIT_NODE_EVENT));
|
448 |
| } |
449 |
| } |
450 |
| |
451 |
1
| algo.process(region);
|
452 |
| |
453 |
1
| it = queue.iterate();
|
454 |
1
| int count = 0;
|
455 |
1
| lastModifiedTimestamp = 0;
|
456 |
1
| while (it.hasNext())
|
457 |
| { |
458 |
10000
| NodeEntry ne = (NodeEntry) it.next();
|
459 |
10000
| assertTrue(lastModifiedTimestamp <= ne.getModifiedTimeStamp());
|
460 |
10000
| lastModifiedTimestamp = ne.getModifiedTimeStamp();
|
461 |
| |
462 |
10000
| if (count < 5000)
|
463 |
| { |
464 |
5000
| assertEquals(1, ne.getNumberOfNodeVisits());
|
465 |
| } |
466 |
| else |
467 |
| { |
468 |
5000
| assertEquals(2, ne.getNumberOfNodeVisits());
|
469 |
| } |
470 |
10000
| count++;
|
471 |
| |
472 |
| } |
473 |
| |
474 |
1
| assertEquals(10000, algo.getEvictionQueue().getNumberOfNodes());
|
475 |
| } |
476 |
| |
477 |
1
| public static Test suite()
|
478 |
| { |
479 |
1
| return new TestSuite(LFUAlgorithmTest.class);
|
480 |
| } |
481 |
| |
482 |
0
| public static void main(String[] args)
|
483 |
| { |
484 |
0
| junit.textui.TestRunner.run(suite());
|
485 |
| } |
486 |
| |
487 |
| } |