1 |
| |
2 |
| |
3 |
| |
4 |
| |
5 |
| |
6 |
| |
7 |
| package org.jboss.cache.eviction; |
8 |
| |
9 |
| import junit.framework.TestCase; |
10 |
| import org.jboss.cache.Fqn; |
11 |
| |
12 |
| import java.util.Iterator; |
13 |
| |
14 |
| |
15 |
| |
16 |
| |
17 |
| |
18 |
| |
19 |
| |
20 |
| public class LRUQueueTest extends TestCase |
21 |
| { |
22 |
| private LRUQueue queue; |
23 |
| |
24 |
4
| public void setUp() throws Exception
|
25 |
| { |
26 |
4
| super.setUp();
|
27 |
4
| queue = new LRUQueue();
|
28 |
| } |
29 |
| |
30 |
4
| public void tearDown() throws Exception
|
31 |
| { |
32 |
4
| super.tearDown();
|
33 |
| } |
34 |
| |
35 |
1
| public void testQueue() throws Exception
|
36 |
| { |
37 |
1
| for (int i = 0; i < 500; i++)
|
38 |
| { |
39 |
500
| NodeEntry ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
|
40 |
500
| queue.addNodeEntry(ne);
|
41 |
| } |
42 |
| |
43 |
1
| assertEquals(500, queue.getNumberOfNodes());
|
44 |
| |
45 |
1
| for (int i = 0; i < 500; i++)
|
46 |
| { |
47 |
500
| Fqn fqn = Fqn.fromString("/a/b/c/" + Integer.toString(i));
|
48 |
500
| if ((i < 100) || (i >= 300 && i < 400))
|
49 |
| { |
50 |
| |
51 |
200
| queue.reorderByLRU(fqn);
|
52 |
| } |
53 |
| } |
54 |
| |
55 |
| |
56 |
1
| Iterator maxAgeIt = queue.iterateMaxAgeQueue();
|
57 |
1
| int count = 0;
|
58 |
1
| long lastTs = 0;
|
59 |
1
| while (maxAgeIt.hasNext())
|
60 |
| { |
61 |
500
| NodeEntry ne = (NodeEntry) maxAgeIt.next();
|
62 |
500
| assertTrue(lastTs <= ne.getCreationTimeStamp());
|
63 |
500
| lastTs = ne.getCreationTimeStamp();
|
64 |
500
| count++;
|
65 |
| } |
66 |
| |
67 |
1
| assertEquals(500, count);
|
68 |
| |
69 |
1
| Iterator lruIt = queue.iterateLRUQueue();
|
70 |
1
| count = 0;
|
71 |
1
| while (lruIt.hasNext())
|
72 |
| { |
73 |
500
| NodeEntry ne = (NodeEntry) lruIt.next();
|
74 |
500
| int nodeIndex = Integer.parseInt((String) ne.getFqn().get(3));
|
75 |
| |
76 |
| |
77 |
500
| if (count >= 300 && count < 400)
|
78 |
| { |
79 |
100
| int expectedNodeIndex = count - 300;
|
80 |
100
| assertEquals(expectedNodeIndex, nodeIndex);
|
81 |
| } |
82 |
400
| else if (count >= 400 && count < 500)
|
83 |
| { |
84 |
100
| int expectedNodeIndex = count - 100;
|
85 |
100
| assertEquals(expectedNodeIndex, nodeIndex);
|
86 |
| } |
87 |
300
| else if (count < 200)
|
88 |
| { |
89 |
200
| int expectedNodeIndex = count + 100;
|
90 |
200
| assertEquals(expectedNodeIndex, nodeIndex);
|
91 |
| } |
92 |
100
| else if (count >= 200 && count < 300)
|
93 |
| { |
94 |
100
| int expectedNodeIndex = count + 200;
|
95 |
100
| assertEquals(expectedNodeIndex, nodeIndex);
|
96 |
| } |
97 |
| |
98 |
500
| count++;
|
99 |
| } |
100 |
| |
101 |
1
| assertEquals(500, count);
|
102 |
| |
103 |
1
| NodeEntry ne = queue.getFirstMaxAgeNodeEntry();
|
104 |
1
| queue.removeNodeEntry(ne);
|
105 |
1
| assertEquals(499, queue.getNumberOfNodes());
|
106 |
| |
107 |
1
| assertFalse(queue.containsNodeEntry(ne));
|
108 |
| |
109 |
1
| ne = queue.getFirstLRUNodeEntry();
|
110 |
1
| queue.removeNodeEntry(ne);
|
111 |
1
| assertEquals(498, queue.getNumberOfNodes());
|
112 |
| |
113 |
1
| assertFalse(queue.containsNodeEntry(ne));
|
114 |
| |
115 |
| |
116 |
| } |
117 |
| |
118 |
1
| public void testGetFirstLRUNodeEntry() throws Exception
|
119 |
| { |
120 |
1
| for (int i = 0; i < 100; i++)
|
121 |
| { |
122 |
100
| NodeEntry ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
|
123 |
100
| queue.addNodeEntry(ne);
|
124 |
| } |
125 |
| |
126 |
1
| for (int i = 0; i < 100; i++)
|
127 |
| { |
128 |
| |
129 |
| |
130 |
100
| if (i % 2 == 0)
|
131 |
| { |
132 |
50
| Fqn fqn = Fqn.fromString("/a/b/c/" + Integer.toString(i));
|
133 |
50
| queue.reorderByLRU(fqn);
|
134 |
| } |
135 |
| } |
136 |
| |
137 |
1
| assertEquals(100, queue.getNumberOfNodes());
|
138 |
| |
139 |
1
| NodeEntry ne;
|
140 |
1
| int count = 0;
|
141 |
?
| while ((ne = queue.getFirstLRUNodeEntry()) != null)
|
142 |
| { |
143 |
100
| int nodeIndex = Integer.parseInt((String) ne.getFqn().get(3));
|
144 |
| |
145 |
100
| if (count < 50)
|
146 |
| { |
147 |
| |
148 |
50
| assertTrue(nodeIndex % 2 != 0);
|
149 |
| } |
150 |
| else |
151 |
| { |
152 |
| |
153 |
50
| assertTrue(nodeIndex % 2 == 0);
|
154 |
| } |
155 |
100
| queue.removeNodeEntry(ne);
|
156 |
100
| count++;
|
157 |
| } |
158 |
1
| assertEquals(0, queue.getNumberOfNodes());
|
159 |
| } |
160 |
| |
161 |
1
| public void testGetFirstMaxAgeNodeEntriy() throws Exception
|
162 |
| { |
163 |
1
| for (int i = 0; i < 100; i++)
|
164 |
| { |
165 |
100
| NodeEntry ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
|
166 |
100
| queue.addNodeEntry(ne);
|
167 |
| } |
168 |
| |
169 |
1
| for (int i = 0; i < 100; i++)
|
170 |
| { |
171 |
| |
172 |
| |
173 |
100
| if (i % 2 == 0)
|
174 |
| { |
175 |
50
| Fqn fqn = Fqn.fromString("/a/b/c/" + Integer.toString(i));
|
176 |
50
| queue.reorderByLRU(fqn);
|
177 |
| } |
178 |
| } |
179 |
| |
180 |
1
| assertEquals(100, queue.getNumberOfNodes());
|
181 |
| |
182 |
1
| NodeEntry ne;
|
183 |
1
| int count = 0;
|
184 |
?
| while ((ne = queue.getFirstMaxAgeNodeEntry()) != null)
|
185 |
| { |
186 |
100
| int nodeIndex = Integer.parseInt((String) ne.getFqn().get(3));
|
187 |
100
| assertEquals(count, nodeIndex);
|
188 |
100
| queue.removeNodeEntry(ne);
|
189 |
100
| count++;
|
190 |
| } |
191 |
| |
192 |
1
| assertEquals(0, queue.getNumberOfNodes());
|
193 |
| } |
194 |
| |
195 |
1
| public void testNumElements() throws Exception
|
196 |
| { |
197 |
1
| LRUQueue queue = new LRUQueue();
|
198 |
| |
199 |
1
| NodeEntry ne = new NodeEntry("/a/b/c");
|
200 |
1
| ne.setNumberOfElements(50);
|
201 |
1
| queue.addNodeEntry(ne);
|
202 |
| |
203 |
1
| assertEquals(50, queue.getNumberOfElements());
|
204 |
1
| assertEquals(1, queue.getNumberOfNodes());
|
205 |
| |
206 |
1
| queue.removeNodeEntry(ne);
|
207 |
1
| assertEquals(0, queue.getNumberOfElements());
|
208 |
| |
209 |
1
| for(int i = 0; i < 10; i++)
|
210 |
| { |
211 |
10
| ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
|
212 |
10
| ne.setNumberOfElements(i);
|
213 |
10
| queue.addNodeEntry(ne);
|
214 |
| } |
215 |
| |
216 |
1
| assertEquals(45, queue.getNumberOfElements());
|
217 |
1
| assertEquals(10, queue.getNumberOfNodes());
|
218 |
| |
219 |
1
| ne = queue.getNodeEntry("/a/b/c/0");
|
220 |
1
| assertNotNull(ne);
|
221 |
1
| assertEquals(0, ne.getNumberOfElements());
|
222 |
1
| ne.setNumberOfElements(500);
|
223 |
| |
224 |
1
| assertEquals(545, queue.getNumberOfElements());
|
225 |
1
| ne = queue.getNodeEntry("/a/b/c/0");
|
226 |
1
| assertEquals(500, ne.getNumberOfElements());
|
227 |
| |
228 |
1
| queue.removeNodeEntry(ne);
|
229 |
| |
230 |
1
| assertEquals(45, queue.getNumberOfElements());
|
231 |
1
| assertEquals(9, queue.getNumberOfNodes());
|
232 |
1
| for(int i = 1; i < 10; i++)
|
233 |
| { |
234 |
9
| ne = queue.getNodeEntry("/a/b/c/" + Integer.toString(i));
|
235 |
9
| assertEquals(i, ne.getNumberOfElements());
|
236 |
9
| queue.removeNodeEntry(ne);
|
237 |
| } |
238 |
| |
239 |
1
| assertEquals(0, queue.getNumberOfNodes());
|
240 |
1
| assertEquals(0, queue.getNumberOfElements());
|
241 |
| |
242 |
1
| assertNull(queue.getNodeEntry("/a/b/c/0"));
|
243 |
1
| assertNull(queue.getFirstNodeEntry());
|
244 |
| } |
245 |
| |
246 |
| } |