← Back to branch summary

~ubuntu-branches/ubuntu/trusty/ehcache/trusty

« back to all changes in this revision

Viewing changes to src/test/java/net/sf/ehcache/store/disk/DiskStorePoolingTest.java

  • Committer: Package Import Robot
  • Author(s): Emmanuel Bourg
  • Date: 2013-05-06 14:53:07 UTC
  • mfrom: (1.1.7) (2.1.8 sid)
  • Revision ID: package-import@ubuntu.com-20130506145307-v5bhw5yu70re00l3
Tags: 2.6.7-1
* Team upload.
* New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test/java/net/sf/ehcache/store/disk/DiskStorePoolingTest.java
1
1
package net.sf.ehcache.store.disk;
2
2
 
 
3
import static org.junit.Assert.assertEquals;
 
4
import static org.junit.Assert.assertFalse;
 
5
import static org.junit.Assert.assertNotNull;
 
6
import static org.junit.Assert.assertNull;
 
7
import static org.junit.Assert.assertTrue;
 
8
 
 
9
import java.util.concurrent.ConcurrentLinkedQueue;
 
10
import java.util.concurrent.ExecutorService;
 
11
import java.util.concurrent.Executors;
 
12
import java.util.concurrent.Future;
 
13
 
3
14
import net.sf.ehcache.Cache;
4
15
import net.sf.ehcache.CacheException;
 
16
import net.sf.ehcache.CacheManager;
5
17
import net.sf.ehcache.Ehcache;
6
18
import net.sf.ehcache.Element;
7
19
import net.sf.ehcache.config.CacheConfiguration;
 
20
import net.sf.ehcache.config.Configuration;
8
21
import net.sf.ehcache.event.CacheEventListener;
9
22
import net.sf.ehcache.pool.Pool;
10
23
import net.sf.ehcache.pool.impl.ConstantSizeOfEngine;
12
25
import net.sf.ehcache.pool.impl.FromLargestCacheOnHeapPoolEvictor;
13
26
import net.sf.ehcache.pool.impl.StrictlyBoundedPool;
14
27
import net.sf.ehcache.store.DefaultElementValueComparator;
 
28
 
15
29
import org.junit.After;
16
30
import org.junit.Before;
17
31
import org.junit.Test;
18
32
 
19
 
import java.util.concurrent.ConcurrentLinkedQueue;
20
 
import java.util.concurrent.ExecutorService;
21
 
import java.util.concurrent.Executors;
22
 
import java.util.concurrent.Future;
23
 
 
24
 
import static org.junit.Assert.assertEquals;
25
 
import static org.junit.Assert.assertFalse;
26
 
import static org.junit.Assert.assertNotNull;
27
 
import static org.junit.Assert.assertNull;
28
 
import static org.junit.Assert.assertTrue;
29
 
 
30
33
/**
31
34
 * @author Ludovic Orban
32
35
 */
33
36
public class DiskStorePoolingTest {
34
37
 
35
 
    private static final int ELEMENT_SIZE_ON_DISK = 298;
 
38
    private static final int ELEMENT_SIZE_ON_DISK = 311;
36
39
    private static final int ITERATIONS = 100;
37
40
 
38
41
    private final static DefaultElementValueComparator COMPARATOR = new DefaultElementValueComparator(new CacheConfiguration()
43
46
    private volatile Pool onDiskPool;
44
47
    private volatile DiskStore diskStore;
45
48
    private volatile Element lastEvicted;
 
49
    private volatile CacheManager cacheManager;
46
50
 
47
51
    private void dump() {
48
52
        System.out.println("# # # # # #");
53
57
 
54
58
    @Before
55
59
    public void setUp() {
56
 
        cache = new Cache(new CacheConfiguration("myCache1", 0).eternal(true).diskPersistent(true));
57
 
 
 
60
        cacheManager = new CacheManager(new Configuration().name("DiskStorePoolingTest"));
 
61
        cache = new Cache(new CacheConfiguration().name("myCache1").maxEntriesLocalHeap(100000).eternal(true).diskPersistent(true));
 
62
        cacheManager.addCache(cache);
58
63
        lastEvicted = null;
59
64
        cache.getCacheEventNotificationService().registerListener(new CacheEventListener() {
60
65
            public void notifyElementRemoved(Ehcache cache, Element element) throws CacheException { }
95
100
                null
96
101
        );
97
102
 
98
 
        diskStore = DiskStore.create(cache, System.getProperty("java.io.tmpdir"), onHeapPool, onDiskPool);
 
103
        diskStore = DiskStore.create(cache, onHeapPool, onDiskPool);
99
104
        diskStore.removeAll();
100
105
    }
101
106
 
103
108
    public void tearDown() {
104
109
        cache.dispose();
105
110
        diskStore.dispose();
 
111
        cacheManager.shutdown();
106
112
    }
107
113
 
108
114
    @Test
120
126
        diskStore.put(new Element(1000, "1000"));
121
127
        diskStore.put(new Element(1001, "1001"));
122
128
 
123
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
129
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
124
130
 
125
131
        assertEquals(2, diskStore.getSize());
126
132
        assertEquals(2 * 16384, onHeapPool.getSize());
130
136
        diskStore.dispose();
131
137
 
132
138
        for (int i = 1000; i < 1030; i++) {
133
 
            diskStore = DiskStore.create(cache, System.getProperty("java.io.tmpdir"), onHeapPool, onDiskPool);
 
139
            diskStore = DiskStore.create(cache, onHeapPool, onDiskPool);
134
140
            assertEquals(2, diskStore.getSize());
135
141
            assertEquals(2 * 16384, onHeapPool.getSize());
136
142
            assertEquals(2 * ELEMENT_SIZE_ON_DISK, onDiskPool.getSize());
159
165
            diskStore.put(e);
160
166
        }
161
167
 
162
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
168
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
163
169
 
164
170
        assertEquals(2, diskStore.getSize());
165
171
        assertEquals(16384 * 2, onHeapPool.getSize());
170
176
        diskStore.put(new Element(1999, "1999"));
171
177
        assertNotNull(diskStore.get(1999));
172
178
 
173
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
179
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
174
180
 
175
181
        assertEquals(2, diskStore.getSize());
176
182
        assertEquals(16384 * 2, onHeapPool.getSize());
184
190
            Element e = new Element(1, "" + i);
185
191
            diskStore.put(e);
186
192
        }
187
 
        
 
193
 
188
194
        for (int i = 0; i < 1000; i++) {
189
195
            Element element = diskStore.get(1);
190
196
            assertNotNull(element);
213
219
            assertTrue(diskStore.getSize() <= 10);
214
220
        }
215
221
 
216
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
222
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
217
223
 
218
224
        assertTrue(diskStore.getSize() >= 1);
219
225
        assertTrue(diskStore.getSize() <= 2);
228
234
            }
229
235
        }
230
236
 
231
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
237
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
232
238
 
233
239
        assertEquals(0, diskStore.getSize());
234
240
        assertEquals(0, onHeapPool.getSize());
253
259
            diskStore.putIfAbsent(e);
254
260
        }
255
261
 
256
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
262
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
257
263
 
258
264
        assertEquals(2, diskStore.getSize());
259
265
        assertEquals(16384 * 2, onHeapPool.getSize());
260
266
        assertEquals(ELEMENT_SIZE_ON_DISK * 2, onDiskPool.getSize());
261
267
 
262
268
        // put a new element on-heap
263
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
269
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
264
270
        diskStore.putIfAbsent(new Element(1999, "1999"));
265
271
        assertNotNull(diskStore.get(1999));
266
272
 
267
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
273
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
268
274
 
269
275
        assertEquals(2, diskStore.getSize());
270
276
        assertEquals(16384 * 2, onHeapPool.getSize());
286
292
        diskStore.put(new Element(1002, "1002"));
287
293
        diskStore.put(new Element(1003, "1003"));
288
294
 
289
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
295
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
290
296
 
291
297
        assertEquals(2, diskStore.getSize());
292
298
        assertEquals(16384 * 2, onHeapPool.getSize());
295
301
        // update element 1x
296
302
        Object key = diskStore.getKeys().iterator().next();
297
303
        diskStore.put(new Element(key, key.toString()));
298
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
304
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
299
305
 
300
306
        assertEquals(2, diskStore.getSize());
301
307
        assertEquals(16384 * 2, onHeapPool.getSize());
305
311
        // update element 2x
306
312
        key = diskStore.getKeys().iterator().next();
307
313
        diskStore.put(new Element(key, key.toString()));
308
 
        
309
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
314
 
 
315
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
310
316
 
311
317
        assertEquals(2, diskStore.getSize());
312
318
        assertEquals(16384 * 2, onHeapPool.getSize());
327
333
        // warm up
328
334
        assertNull(diskStore.putIfAbsent(new Element(1001, "11#1")));
329
335
        assertNotNull(diskStore.putIfAbsent(new Element(1001, "11#2")));
330
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
336
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
331
337
        assertNull(diskStore.putIfAbsent(new Element(1002, "12#1")));
332
338
        assertNotNull(diskStore.putIfAbsent(new Element(1002, "12#2")));
333
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
339
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
334
340
 
335
341
        assertNull(diskStore.putIfAbsent(new Element(1003, "13#1")));
336
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
342
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
337
343
        Element oldElement = diskStore.putIfAbsent(new Element(1003, "13#2"));
338
344
 
339
345
        assertNotNull(oldElement);
358
364
        diskStore.put(new Element(1002, "1002"));
359
365
        diskStore.put(new Element(1003, "1003"));
360
366
 
361
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
367
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
362
368
 
363
369
        assertEquals(2, diskStore.getSize());
364
370
        assertEquals(16384 * 2, onHeapPool.getSize());
388
394
        diskStore.put(new Element(1001, "11#1"));
389
395
        diskStore.put(new Element(1002, "12#1"));
390
396
        diskStore.put(new Element(1003, "13#1"));
391
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
397
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
392
398
 
393
399
        assertEquals(2, diskStore.getSize());
394
400
        assertEquals(16384 * 2, onHeapPool.getSize());
397
403
        // replace element on disk
398
404
        Object key = diskStore.getKeys().iterator().next();
399
405
        Element replaced = diskStore.replace(new Element(key, "22#2"));
400
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
406
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
401
407
 
402
408
        assertEquals(new Element(key, "22#2"), replaced);
403
409
        assertEquals(2, diskStore.getSize());
406
412
 
407
413
        // replace non-existent key
408
414
        assertNull(diskStore.replace(new Element(1999, 1999 + "19#2")));
409
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
415
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
410
416
 
411
417
        assertEquals(2, diskStore.getSize());
412
418
        assertEquals(16384 * 2, onHeapPool.getSize());
428
434
        diskStore.put(new Element(1001, "11#1"));
429
435
        diskStore.put(new Element(1002, "12#1"));
430
436
        diskStore.put(new Element(1003, "13#1"));
431
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
437
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
432
438
 
433
439
        assertEquals(2, diskStore.getSize());
434
440
        assertEquals(16384 * 2, onHeapPool.getSize());
437
443
        // replace element on disk
438
444
        Object key = diskStore.getKeys().iterator().next();
439
445
        assertTrue(diskStore.replace(diskStore.getQuiet(key), new Element(key, "20#2"), COMPARATOR));
440
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
446
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
441
447
 
442
448
        if (lastEvicted.getObjectKey().equals(key)) {
443
449
            // the replaced object itself got evicted -> pool reserved space for it then freed it
452
458
 
453
459
        // replace non-existent key
454
460
        assertFalse(diskStore.replace(new Element(1999, 1999 + "19#1"), new Element(1999, "19#2"), COMPARATOR));
455
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
461
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
456
462
 
457
463
        assertEquals(2, diskStore.getSize());
458
464
        assertEquals(16384 * 2, onHeapPool.getSize());
474
480
        diskStore.put(new Element(1001, "1001"));
475
481
        diskStore.put(new Element(1002, "1002"));
476
482
        diskStore.put(new Element(1003, "1003"));
477
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
483
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
478
484
 
479
485
        assertEquals(2, diskStore.getSize());
480
486
        assertEquals(16384 * 2, onHeapPool.getSize());
501
507
        key = diskStore.getKeys().iterator().next();
502
508
        assertEquals(new Element(key, key + ""), diskStore.removeElement(new Element(key, key + ""), COMPARATOR));
503
509
 
504
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
510
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
505
511
 
506
512
        assertEquals(1, diskStore.getSize());
507
513
        assertEquals(16384, onHeapPool.getSize());
524
530
        diskStore.put(new Element(1002, "1002"));
525
531
        diskStore.put(new Element(1003, "1003"));
526
532
 
527
 
        diskStore.waitUntilEverythingGotFlushedToDisk(3000);
 
533
        DiskStoreHelper.flushAllEntriesToDisk(diskStore).get();
528
534
 
529
535
        assertEquals(2, diskStore.getSize());
530
536
        assertEquals(16384 * 2, onHeapPool.getSize());