/** * The main program for the DiskDumper class * <p> * Creates a disk cache and then calls dump, which write out the contents to * a debug log. * <p> * @param args * The command line arguments */ public static void main( String[] args ) { if ( args.length != 1 ) { System.out.println( "Usage: java org.apache.commons.jcs.auxiliary.disk.DiskDump <cache_name>" ); System.exit( 0 ); } IndexedDiskCacheAttributes attr = new IndexedDiskCacheAttributes(); attr.setCacheName( args[0] ); attr.setDiskPath( args[0] ); IndexedDiskCache<Serializable, Serializable> dc = new IndexedDiskCache<Serializable, Serializable>( attr ); dc.dump( true ); System.exit( 0 ); } }
/** * The main program for the DiskDumper class * <p> * Creates a disk cache and then calls dump, which write out the contents to * a debug log. * <p> * @param args * The command line arguments */ public static void main( String[] args ) { if ( args.length != 1 ) { System.out.println( "Usage: java org.apache.commons.jcs.auxiliary.disk.DiskDump <cache_name>" ); System.exit( 0 ); } IndexedDiskCacheAttributes attr = new IndexedDiskCacheAttributes(); attr.setCacheName( args[0] ); attr.setDiskPath( args[0] ); IndexedDiskCache<Serializable, Serializable> dc = new IndexedDiskCache<Serializable, Serializable>( attr ); dc.dump( true ); System.exit( 0 ); } }
/** * Test the basic get matching. * <p> * @throws Exception */ public void testPutGetMatching_SmallWait() throws Exception { // SETUP int items = 200; String cacheName = "testPutGetMatching_SmallWait"; IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName( cacheName ); cattr.setMaxKeySize( 100 ); cattr.setDiskPath( "target/test-sandbox/IndexDiskCacheUnitTest" ); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>( cattr ); // DO WORK for ( int i = 0; i <= items; i++ ) { diskCache.update( new CacheElement<String, String>( cacheName, i + ":key", cacheName + " data " + i ) ); } Thread.sleep( 500 ); Map<String, ICacheElement<String, String>> matchingResults = diskCache.getMatching( "1.8.+" ); // VERIFY assertEquals( "Wrong number returned", 10, matchingResults.size() ); //System.out.println( "matchingResults.keySet() " + matchingResults.keySet() ); //System.out.println( "\nAFTER TEST \n" + diskCache.getStats() ); }
/** * Verify event log calls. * <p> * @throws Exception */ public void testGetMultiple_EventLogging_simple() throws Exception { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName( "testGetMultiple_EventLogging_simple" ); cattr.setMaxKeySize( 100 ); cattr.setDiskPath( "target/test-sandbox/IndexDiskCacheUnitTestCEL" ); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>( cattr ); diskCache.processRemoveAll(); MockCacheEventLogger cacheEventLogger = new MockCacheEventLogger(); diskCache.setCacheEventLogger( cacheEventLogger ); Set<String> keys = new HashSet<String>(); keys.add( "junk" ); // DO WORK diskCache.getMultiple( keys ); // VERIFY // 1 for get multiple and 1 for get. assertEquals( "Start should have been called.", 2, cacheEventLogger.startICacheEventCalls ); assertEquals( "End should have been called.", 2, cacheEventLogger.endICacheEventCalls ); }
/** * Verify that the overlap check returns true when there are no overlaps. */ public void testCheckForDedOverlaps_noOverlap() { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName( "testCheckForDedOverlaps_noOverlap" ); cattr.setDiskPath( "target/test-sandbox/UnitTest" ); IndexedDiskCache<String, String> disk = new IndexedDiskCache<String, String>( cattr ); int numDescriptors = 5; int pos = 0; IndexedDiskElementDescriptor[] sortedDescriptors = new IndexedDiskElementDescriptor[numDescriptors]; for ( int i = 0; i < numDescriptors; i++ ) { IndexedDiskElementDescriptor descriptor = new IndexedDiskElementDescriptor( pos, i * 2 ); pos = pos + ( i * 2 ) + IndexedDisk.HEADER_SIZE_BYTES; sortedDescriptors[i] = descriptor; } // DO WORK boolean result = disk.checkForDedOverlaps( sortedDescriptors ); // VERIFY assertTrue( "There should be no overlap. it should be ok", result ); }
/** * Verify event log calls. * <p> * * @throws Exception */ public void testGetMultiple_EventLogging_simple() throws Exception { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName("testGetMultiple_EventLogging_simple"); cattr.setMaxKeySize(100); cattr.setDiskPath("target/test-sandbox/IndexDiskCacheUnitTestCEL"); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>(cattr); diskCache.processRemoveAll(); MockCacheEventLogger cacheEventLogger = new MockCacheEventLogger(); diskCache.setCacheEventLogger(cacheEventLogger); Set<String> keys = new HashSet<String>(); keys.add("junk"); // DO WORK diskCache.getMultiple(keys); // VERIFY // 1 for get multiple and 1 for get. assertEquals("Start should have been called.", 2, cacheEventLogger.startICacheEventCalls); assertEquals("End should have been called.", 2, cacheEventLogger.endICacheEventCalls); }
/** * Test the basic get matching. With no wait this will all come from purgatory. * <p> * @throws Exception */ public void testPutGetMatching_NoWait() throws Exception { // SETUP int items = 200; String cacheName = "testPutGetMatching_NoWait"; IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName( cacheName ); cattr.setMaxKeySize( 100 ); cattr.setDiskPath( "target/test-sandbox/IndexDiskCacheUnitTest" ); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>( cattr ); // DO WORK for ( int i = 0; i <= items; i++ ) { diskCache.update( new CacheElement<String, String>( cacheName, i + ":key", cacheName + " data " + i ) ); } Map<String, ICacheElement<String, String>> matchingResults = diskCache.getMatching( "1.8.+" ); // VERIFY assertEquals( "Wrong number returned", 10, matchingResults.size() ); //System.out.println( "matchingResults.keySet() " + matchingResults.keySet() ); //System.out.println( "\nAFTER TEST \n" + diskCache.getStats() ); }
/** * Verify that the overlap check returns true when there are no overlaps. */ public void testCheckForDedOverlaps_noOverlap() { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName("testCheckForDedOverlaps_noOverlap"); cattr.setDiskPath("target/test-sandbox/UnitTest"); IndexedDiskCache<String, String> disk = new IndexedDiskCache<String, String>(cattr); int numDescriptors = 5; int pos = 0; IndexedDiskElementDescriptor[] sortedDescriptors = new IndexedDiskElementDescriptor[numDescriptors]; for (int i = 0; i < numDescriptors; i++) { IndexedDiskElementDescriptor descriptor = new IndexedDiskElementDescriptor(pos, i * 2); pos = pos + (i * 2) + IndexedDisk.HEADER_SIZE_BYTES; sortedDescriptors[i] = descriptor; } // DO WORK boolean result = disk.checkForDedOverlaps(sortedDescriptors); // VERIFY assertTrue("There should be no overlap. it should be ok", result); }
/** * Verify that the overlap check returns false when there are overlaps. */ public void testCheckForDedOverlaps_overlaps() { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName("testCheckForDedOverlaps_overlaps"); cattr.setDiskPath("target/test-sandbox/UnitTest"); IndexedDiskCache<String, String> disk = new IndexedDiskCache<String, String>(cattr); int numDescriptors = 5; int pos = 0; IndexedDiskElementDescriptor[] sortedDescriptors = new IndexedDiskElementDescriptor[numDescriptors]; for (int i = 0; i < numDescriptors; i++) { IndexedDiskElementDescriptor descriptor = new IndexedDiskElementDescriptor(pos, i * 2); // don't add the header + IndexedDisk.RECORD_HEADER; pos = pos + (i * 2); sortedDescriptors[i] = descriptor; } // DO WORK boolean result = disk.checkForDedOverlaps(sortedDescriptors); // VERIFY assertFalse("There should be overlaps. it should be not ok", result); }
/** * Verify that the overlap check returns false when there are overlaps. */ public void testCheckForDedOverlaps_overlaps() { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName( "testCheckForDedOverlaps_overlaps" ); cattr.setDiskPath( "target/test-sandbox/UnitTest" ); IndexedDiskCache<String, String> disk = new IndexedDiskCache<String, String>( cattr ); int numDescriptors = 5; int pos = 0; IndexedDiskElementDescriptor[] sortedDescriptors = new IndexedDiskElementDescriptor[numDescriptors]; for ( int i = 0; i < numDescriptors; i++ ) { IndexedDiskElementDescriptor descriptor = new IndexedDiskElementDescriptor( pos, i * 2 ); // don't add the header + IndexedDisk.RECORD_HEADER; pos = pos + ( i * 2 ); sortedDescriptors[i] = descriptor; } // DO WORK boolean result = disk.checkForDedOverlaps( sortedDescriptors ); // VERIFY assertFalse( "There should be overlaps. it should be not ok", result ); }
/** * Verify event log calls. * <p> * * @throws Exception */ public void testGet_EventLogging_simple() throws Exception { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName("testGet_EventLogging_simple"); cattr.setMaxKeySize(100); cattr.setDiskPath("target/test-sandbox/IndexDiskCacheUnitTestCEL"); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>(cattr); diskCache.processRemoveAll(); MockCacheEventLogger cacheEventLogger = new MockCacheEventLogger(); diskCache.setCacheEventLogger(cacheEventLogger); // DO WORK diskCache.get("key"); // VERIFY assertEquals("Start should have been called.", 1, cacheEventLogger.startICacheEventCalls); assertEquals("End should have been called.", 1, cacheEventLogger.endICacheEventCalls); }
/** * Verify event log calls. * <p> * * @throws Exception */ public void testRemove_EventLogging_simple() throws Exception { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName("testRemoveAll_EventLogging_simple"); cattr.setMaxKeySize(100); cattr.setDiskPath("target/test-sandbox/IndexDiskCacheUnitTestCEL"); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>(cattr); diskCache.processRemoveAll(); MockCacheEventLogger cacheEventLogger = new MockCacheEventLogger(); diskCache.setCacheEventLogger(cacheEventLogger); // DO WORK diskCache.remove("key"); // VERIFY assertEquals("Start should have been called.", 1, cacheEventLogger.startICacheEventCalls); assertEquals("End should have been called.", 1, cacheEventLogger.endICacheEventCalls); }
/** * Verify event log calls. * <p> * * @throws Exception */ public void testRemoveAll_EventLogging_simple() throws Exception { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName("testRemoveAll_EventLogging_simple"); cattr.setMaxKeySize(100); cattr.setDiskPath("target/test-sandbox/IndexDiskCacheUnitTestCEL"); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>(cattr); diskCache.processRemoveAll(); MockCacheEventLogger cacheEventLogger = new MockCacheEventLogger(); diskCache.setCacheEventLogger(cacheEventLogger); // DO WORK diskCache.remove("key"); // VERIFY assertEquals("Start should have been called.", 1, cacheEventLogger.startICacheEventCalls); assertEquals("End should have been called.", 1, cacheEventLogger.endICacheEventCalls); }
/** * Verify event log calls. * <p> * @throws Exception */ public void testRemove_EventLogging_simple() throws Exception { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName( "testRemoveAll_EventLogging_simple" ); cattr.setMaxKeySize( 100 ); cattr.setDiskPath( "target/test-sandbox/IndexDiskCacheUnitTestCEL" ); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>( cattr ); diskCache.processRemoveAll(); MockCacheEventLogger cacheEventLogger = new MockCacheEventLogger(); diskCache.setCacheEventLogger( cacheEventLogger ); // DO WORK diskCache.remove( "key" ); // VERIFY assertEquals( "Start should have been called.", 1, cacheEventLogger.startICacheEventCalls ); assertEquals( "End should have been called.", 1, cacheEventLogger.endICacheEventCalls ); }
/** * Verify event log calls. * <p> * @throws Exception */ public void testRemoveAll_EventLogging_simple() throws Exception { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName( "testRemoveAll_EventLogging_simple" ); cattr.setMaxKeySize( 100 ); cattr.setDiskPath( "target/test-sandbox/IndexDiskCacheUnitTestCEL" ); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>( cattr ); diskCache.processRemoveAll(); MockCacheEventLogger cacheEventLogger = new MockCacheEventLogger(); diskCache.setCacheEventLogger( cacheEventLogger ); // DO WORK diskCache.remove( "key" ); // VERIFY assertEquals( "Start should have been called.", 1, cacheEventLogger.startICacheEventCalls ); assertEquals( "End should have been called.", 1, cacheEventLogger.endICacheEventCalls ); }
/** * Verify event log calls. * <p> * @throws Exception */ public void testGet_EventLogging_simple() throws Exception { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName( "testGet_EventLogging_simple" ); cattr.setMaxKeySize( 100 ); cattr.setDiskPath( "target/test-sandbox/IndexDiskCacheUnitTestCEL" ); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>( cattr ); diskCache.processRemoveAll(); MockCacheEventLogger cacheEventLogger = new MockCacheEventLogger(); diskCache.setCacheEventLogger( cacheEventLogger ); // DO WORK diskCache.get( "key" ); // VERIFY assertEquals( "Start should have been called.", 1, cacheEventLogger.startICacheEventCalls ); assertEquals( "End should have been called.", 1, cacheEventLogger.endICacheEventCalls ); }
/** * Verify the item makes it to disk. * <p> * @throws IOException */ public void testProcessUpdate_Simple() throws IOException { // SETUP String cacheName = "testProcessUpdate_Simple"; IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName( cacheName ); cattr.setMaxKeySize( 100 ); cattr.setDiskPath( "target/test-sandbox/IndexDiskCacheUnitTest" ); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>( cattr ); String key = "myKey"; String value = "myValue"; ICacheElement<String, String> ce = new CacheElement<String, String>( cacheName, key, value ); // DO WORK diskCache.processUpdate( ce ); ICacheElement<String, String> result = diskCache.processGet( key ); // VERIFY assertNotNull( "Should have a result", result ); long fileSize = diskCache.getDataFileSize(); assertTrue( "File should be greater than 0", fileSize > 0 ); }
/** * Verify the item makes it to disk. * <p> * * @throws IOException */ public void testProcessUpdate_Simple() throws IOException { // SETUP String cacheName = "testProcessUpdate_Simple"; IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName(cacheName); cattr.setMaxKeySize(100); cattr.setDiskPath("target/test-sandbox/IndexDiskCacheUnitTest"); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>(cattr); String key = "myKey"; String value = "myValue"; ICacheElement<String, String> ce = new CacheElement<String, String>(cacheName, key, value); // DO WORK diskCache.processUpdate(ce); ICacheElement<String, String> result = diskCache.processGet(key); // VERIFY assertNotNull("Should have a result", result); long fileSize = diskCache.getDataFileSize(); assertTrue("File should be greater than 0", fileSize > 0); }
/** * Verify event log calls. * <p> * * @throws Exception */ public void testUpdate_EventLogging_simple() throws Exception { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName("testUpdate_EventLogging_simple"); cattr.setMaxKeySize(100); cattr.setDiskPath("target/test-sandbox/IndexDiskCacheUnitTestCEL"); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>(cattr); diskCache.processRemoveAll(); MockCacheEventLogger cacheEventLogger = new MockCacheEventLogger(); diskCache.setCacheEventLogger(cacheEventLogger); ICacheElement<String, String> item = new CacheElement<String, String>("region", "key", "value"); // DO WORK diskCache.update(item); SleepUtil.sleepAtLeast(200); // VERIFY assertEquals("Start should have been called.", 1, cacheEventLogger.startICacheEventCalls); assertEquals("End should have been called.", 1, cacheEventLogger.endICacheEventCalls); }
/** * Verify event log calls. * <p> * @throws Exception */ public void testUpdate_EventLogging_simple() throws Exception { // SETUP IndexedDiskCacheAttributes cattr = getCacheAttributes(); cattr.setCacheName( "testUpdate_EventLogging_simple" ); cattr.setMaxKeySize( 100 ); cattr.setDiskPath( "target/test-sandbox/IndexDiskCacheUnitTestCEL" ); IndexedDiskCache<String, String> diskCache = new IndexedDiskCache<String, String>( cattr ); diskCache.processRemoveAll(); MockCacheEventLogger cacheEventLogger = new MockCacheEventLogger(); diskCache.setCacheEventLogger( cacheEventLogger ); ICacheElement<String, String> item = new CacheElement<String, String>( "region", "key", "value" ); // DO WORK diskCache.update( item ); SleepUtil.sleepAtLeast( 200 ); // VERIFY assertEquals( "Start should have been called.", 1, cacheEventLogger.startICacheEventCalls ); assertEquals( "End should have been called.", 1, cacheEventLogger.endICacheEventCalls ); }