[jbosscache-commits] JBoss Cache SVN: r7671 - core/branches/flat/src/test/java/org/horizon/eviction.

[jbosscache-commits at lists.jboss.org]

Author: manik.surtani at jboss.com
Date: 2009-02-09 16:28:30 -0500 (Mon, 09 Feb 2009)
New Revision: 7671

Modified:
   core/branches/flat/src/test/java/org/horizon/eviction/EvictionFunctionalTest.java
Log:
Improved test

Modified: core/branches/flat/src/test/java/org/horizon/eviction/EvictionFunctionalTest.java
===================================================================
--- core/branches/flat/src/test/java/org/horizon/eviction/EvictionFunctionalTest.java	2009-02-09 18:43:20 UTC (rev 7670)
+++ core/branches/flat/src/test/java/org/horizon/eviction/EvictionFunctionalTest.java	2009-02-09 21:28:30 UTC (rev 7671)
@@ -2,27 +2,26 @@
 
 import org.horizon.Cache;
 import org.horizon.config.Configuration;
+import org.horizon.config.EvictionAlgorithmConfig;
 import org.horizon.config.EvictionConfig;
+import org.horizon.container.DataContainer;
 import org.horizon.eviction.algorithms.fifo.FIFOAlgorithmConfig;
+import org.horizon.eviction.events.EvictionEvent;
 import org.horizon.manager.CacheManager;
 import org.horizon.manager.DefaultCacheManager;
-import org.horizon.notifications.Listener;
-import org.horizon.notifications.cachelistener.annotation.CacheEntryEvicted;
-import org.horizon.notifications.cachelistener.event.CacheEntryEvictedEvent;
+import org.horizon.util.ReflectionUtil;
 import org.horizon.util.TestingUtil;
 import org.testng.annotations.AfterMethod;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import java.util.HashSet;
-import java.util.Set;
+import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
- at Test(groups = "functional", sequential = true, enabled = true)
+ at Test(groups = "functional", sequential = true)
 public class EvictionFunctionalTest {
    Cache cache;
-   EvictionListener el;
 
    @BeforeMethod
    public void setUp() {
@@ -36,8 +35,6 @@
          ec.setWakeUpInterval(50); // 50 millis!
          CacheManager cm = new DefaultCacheManager(cfg);
          cache = cm.getCache();
-         el = new EvictionListener();
-         cache.addListener(el);
       } catch (Exception e) {
          e.printStackTrace();
       }
@@ -49,33 +46,78 @@
    }
 
    public void testEviction() throws InterruptedException {
-      el.latch = new CountDownLatch(1);
+      CountDownLatch evictionCompleteLatch = new CountDownLatch(1);
+      CountDownLatch cacheFillLatch = new CountDownLatch(1);
+      EvictionManager em = cache.getAdvancedCache().getEvictionManager();
+      EvictionAlgorithm actualAlgorithm = (EvictionAlgorithm) TestingUtil.extractField(em, "evictionAlgorithm");
+      DelegatingAlgorithm a = new DelegatingAlgorithm(actualAlgorithm, cacheFillLatch, evictionCompleteLatch);
+      ReflectionUtil.setValue(em, "evictionAlgorithm", a);
+
       for (int i = 0; i < 20; i++) {
          cache.put(i, "value");
       }
+      cacheFillLatch.countDown();
 
-      assert el.latch.await(60, TimeUnit.SECONDS);
-      for (int i = 10; i < 20; i++) assert cache.containsKey(i);
+      assert evictionCompleteLatch.await(600, TimeUnit.SECONDS);
+      for (int i = 10; i < 20; i++)
+         assert cache.get(i).equals("value") : "Key " + i + " should map to 'value', but was " + cache.get(i);
 
-      for (int i = 0; i < 10; i++) assert !cache.containsKey(i);
+      for (int i = 0; i < 10; i++)
+         assert cache.get(i) == null :
+               "Key " + i + " should map to null, but was " + cache.get(i) + " and cache count is " + cache.size();
    }
 
-   @Listener
-   public static class EvictionListener {
-      Set<Integer> expectedKeys = new HashSet<Integer>();
-      CountDownLatch latch;
+   public class DelegatingAlgorithm implements EvictionAlgorithm {
+      EvictionAlgorithm delegate;
+      CountDownLatch cacheFillLatch;
+      CountDownLatch evictionOverLatch;
 
-      public EvictionListener() {
-         for (int i = 0; i < 10; i++) expectedKeys.add(i);
+      public DelegatingAlgorithm(EvictionAlgorithm delegate, CountDownLatch cacheFillLatch, CountDownLatch evictionOverLatch) {
+         this.delegate = delegate;
+         this.cacheFillLatch = cacheFillLatch;
+         this.evictionOverLatch = evictionOverLatch;
       }
 
-      @CacheEntryEvicted
-      public void handle(CacheEntryEvictedEvent event) {
-         System.out.println("Saw event " + event);
-         if (event.isPre()) {
-            assert expectedKeys.remove(event.getKey());
-            if (expectedKeys.isEmpty()) latch.countDown();
+      public void process(BlockingQueue<EvictionEvent> queue) throws EvictionException {
+         try {
+            cacheFillLatch.await();
+         } catch (InterruptedException e) {
+            throw new RuntimeException(e);
          }
+         System.out.println("Queue size=" + queue.size());
+
+         delegate.process(queue);
+
+         // queue should now have processed
+         evictionOverLatch.countDown();
       }
+
+      public void resetEvictionQueue() {
+         delegate.resetEvictionQueue();
+      }
+
+      public void setEvictionAction(EvictionAction evictionAction) {
+         delegate.setEvictionAction(evictionAction);
+      }
+
+      public void init(Cache<?, ?> cache, DataContainer<?, ?> dataContiner, EvictionAlgorithmConfig evictionAlgorithmConfig) {
+         delegate.init(cache, dataContiner, evictionAlgorithmConfig);
+      }
+
+      public boolean canIgnoreEvent(EvictionEvent.Type eventType) {
+         return delegate.canIgnoreEvent(eventType);
+      }
+
+      public Class<? extends EvictionAlgorithmConfig> getConfigurationClass() {
+         return delegate.getConfigurationClass();
+      }
+
+      public void start() {
+         delegate.start();
+      }
+
+      public void stop() {
+         delegate.stop();
+      }
    }
 }