Clover coverage report -
Coverage timestamp: Wed Jan 31 2007 15:38:53 EST
file stats: LOC: 524   Methods: 17
NCLOC: 419   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
LRUAlgorithmTest.java 71.4% 80.3% 82.4% 80%
coverage coverage
 1    package org.jboss.cache.eviction;
 2   
 3    import junit.framework.Test;
 4    import junit.framework.TestCase;
 5    import junit.framework.TestSuite;
 6    import org.apache.commons.logging.Log;
 7    import org.apache.commons.logging.LogFactory;
 8    import org.jboss.cache.Fqn;
 9    import org.jboss.cache.Region;
 10    import org.jboss.cache.RegionManager;
 11    import org.jboss.cache.misc.TestingUtil;
 12   
 13    /**
 14    * Unit tests for LRUAlgorithm.
 15    *
 16    * @author Ben Wang, Feb 11, 2004
 17    * @author Daniel Huang (dhuang@jboss.org)
 18    */
 19    public class LRUAlgorithmTest extends TestCase
 20    {
 21    RegionManager regionManager_;
 22    LRUAlgorithm algo_;
 23    LRUConfiguration config_;
 24    Log log = LogFactory.getLog(LRUAlgorithm.class);
 25   
 26  10 public LRUAlgorithmTest(String s)
 27    {
 28  10 super(s);
 29    }
 30   
 31  10 public void setUp() throws Exception
 32    {
 33  10 super.setUp();
 34  10 log.debug("");
 35  10 log.debug("Test case " + getName());
 36  10 log.debug("");
 37   
 38  10 algo_ = new LRUAlgorithm();
 39  10 config_ = new LRUConfiguration();
 40  10 config_.setEvictionPolicyClass(DummyEvictionPolicy.class.getName());
 41    // We have to setCache timeToLiveSeconds!!
 42  10 config_.setTimeToLiveSeconds(0);
 43   
 44  10 regionManager_ = new RegionManager();
 45  10 regionManager_.getRegion("/a/b", true).setEvictionPolicy(config_);
 46    /*
 47    try {
 48    Thread.sleep(10000);
 49    } catch (InterruptedException e) {
 50    e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.
 51    }
 52    */
 53    }
 54   
 55  10 public void tearDown() throws Exception
 56    {
 57  10 super.tearDown();
 58    }
 59   
 60    /**
 61    * maxNodes = 1. Eception is evictFromCacheNode. Should be commented for now.
 62    */
 63  0 public void XtestEvictException()
 64    {
 65  0 Fqn fqn1 = Fqn.fromString("/a/b/c");
 66  0 Fqn fqn2 = Fqn.fromString("/a/b/d");
 67  0 Fqn fqn3 = Fqn.fromString("/a/b/e");
 68  0 Region region = regionManager_.getRegion("/a/b", true);
 69  0 LRUConfiguration config = (LRUConfiguration) region.getEvictionPolicyConfig();
 70  0 config.setMaxNodes(1);
 71  0 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 72  0 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 73   
 74  0 try
 75    {
 76  0 algo_.process(region);
 77    }
 78    catch (EvictionException e)
 79    {
 80  0 fail("testMaxNode: process failed " + e);
 81  0 e.printStackTrace();
 82    }
 83  0 assertEquals("Queue size should be ", 1, algo_.getEvictionQueue().getNumberOfNodes());
 84   
 85  0 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 86  0 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
 87   
 88  0 try
 89    {
 90  0 algo_.process(region);
 91    }
 92    catch (EvictionException e)
 93    {
 94  0 fail("testMaxNode: process failed " + e);
 95  0 e.printStackTrace();
 96    }
 97  0 assertEquals("Queue size should be ", 1, algo_.getEvictionQueue().getNumberOfNodes());
 98    }
 99   
 100   
 101    /**
 102    * maxNodes = 0 case
 103    */
 104  1 public void testMaxNode1()
 105    {
 106  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 107  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 108  1 Region region = regionManager_.getRegion("/a/b", true);
 109  1 LRUConfiguration config = (LRUConfiguration) region.getEvictionPolicyConfig();
 110  1 config.setMaxNodes(0);
 111  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 112  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 113   
 114  1 try
 115    {
 116  1 algo_.process(region);
 117    }
 118    catch (EvictionException e)
 119    {
 120  0 fail("testMaxNode: process failed " + e);
 121  0 e.printStackTrace();
 122    }
 123  1 assertEquals("Queue size should be ", 2, algo_.getEvictionQueue().getNumberOfNodes());
 124   
 125    }
 126   
 127    /**
 128    * maxNodes = 1
 129    */
 130  1 public void testMaxNode2()
 131    {
 132  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 133  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 134  1 Fqn fqn3 = Fqn.fromString("/a/b/e");
 135  1 Region region = regionManager_.getRegion("/a/b", true);
 136  1 LRUConfiguration config = (LRUConfiguration) region.getEvictionPolicyConfig();
 137  1 config.setMaxNodes(1);
 138  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 139  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 140   
 141  1 try
 142    {
 143  1 algo_.process(region);
 144    }
 145    catch (EvictionException e)
 146    {
 147  0 fail("testMaxNode: process failed " + e);
 148  0 e.printStackTrace();
 149    }
 150  1 assertEquals("Queue size should be ", 1, algo_.getEvictionQueue().getNumberOfNodes());
 151   
 152  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 153  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
 154   
 155  1 try
 156    {
 157  1 algo_.process(region);
 158    }
 159    catch (EvictionException e)
 160    {
 161  0 fail("testMaxNode: process failed " + e);
 162  0 e.printStackTrace();
 163    }
 164  1 assertEquals("Queue size should be ", 1, algo_.getEvictionQueue().getNumberOfNodes());
 165    }
 166   
 167    /**
 168    * TimeToIdleSeconds = 0
 169    */
 170  1 public void testIdleTimeSeconds1()
 171    {
 172  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 173  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 174  1 Region region = regionManager_.getRegion("/a/b", true);
 175  1 LRUConfiguration config = (LRUConfiguration) region.getEvictionPolicyConfig();
 176  1 config.setMaxNodes(0);
 177  1 config.setTimeToLiveSeconds(0);
 178  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 179  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 180  1 TestingUtil.sleepThread(2000);
 181  1 try
 182    {
 183  1 algo_.process(region);
 184    }
 185    catch (EvictionException e)
 186    {
 187  0 fail("testMaxNode: process failed " + e);
 188  0 e.printStackTrace();
 189    }
 190  1 assertEquals("Queue size should be ", 2, algo_.getEvictionQueue().getNumberOfNodes());
 191   
 192    }
 193   
 194    /**
 195    * TimeToIdleSeconds = 1
 196    */
 197  1 public void testIdleTimeSeconds2()
 198    {
 199  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 200  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 201  1 Fqn fqn3 = Fqn.fromString("/a/b/e");
 202  1 Region region = regionManager_.getRegion("/a/b", true);
 203  1 LRUConfiguration config = (LRUConfiguration) region.getEvictionPolicyConfig();
 204  1 config.setMaxNodes(0);
 205  1 config.setTimeToLiveSeconds(1);
 206  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 207  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 208  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
 209   
 210  1 try
 211    {
 212  1 algo_.process(region);
 213    }
 214    catch (EvictionException e)
 215    {
 216  0 fail("testMaxNode: process failed " + e);
 217  0 e.printStackTrace();
 218    }
 219  1 assertEquals("Queue size #1: ", 3, algo_.getEvictionQueue().getNumberOfNodes());
 220  1 TestingUtil.sleepThread(2000);
 221  1 try
 222    {
 223  1 algo_.process(region);
 224    }
 225    catch (EvictionException e)
 226    {
 227  0 fail("testMaxNode: process failed " + e);
 228  0 e.printStackTrace();
 229    }
 230  1 assertEquals("Queue size #2: ", 0, algo_.getEvictionQueue().getNumberOfNodes());
 231    }
 232   
 233    /**
 234    * TimeToIdleSeconds = 1 with node visited in between.
 235    */
 236  1 public void testIdleTimeSeconds3()
 237    {
 238  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 239  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 240  1 Fqn fqn3 = Fqn.fromString("/a/b/e");
 241  1 Region region = regionManager_.getRegion("/a/b", true);
 242  1 LRUConfiguration config = (LRUConfiguration) region.getEvictionPolicyConfig();
 243  1 config.setMaxNodes(0);
 244  1 config.setTimeToLiveSeconds(1);
 245  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 246  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 247  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
 248   
 249  1 try
 250    {
 251  1 algo_.process(region);
 252    }
 253    catch (EvictionException e)
 254    {
 255  0 fail("testMaxNode: process failed " + e);
 256  0 e.printStackTrace();
 257    }
 258  1 assertEquals("Queue size #1: ", 3, algo_.getEvictionQueue().getNumberOfNodes());
 259  1 TestingUtil.sleepThread(2000);
 260  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.VISIT_NODE_EVENT));
 261  1 try
 262    {
 263  1 algo_.process(region);
 264    }
 265    catch (EvictionException e)
 266    {
 267  0 fail("testMaxNode: process failed " + e);
 268  0 e.printStackTrace();
 269    }
 270  1 assertEquals("Queue size #2: ", 1, algo_.getEvictionQueue().getNumberOfNodes());
 271    }
 272   
 273    /**
 274    * MaxAgeSeconds = 1 with 3 nodes.
 275    *
 276    * @throws Exception
 277    */
 278  1 public void testMaxAgeSeconds1() throws Exception
 279    {
 280  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 281  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 282  1 Fqn fqn3 = Fqn.fromString("/a/b/e");
 283  1 Region region = regionManager_.getRegion("/a/b", true);
 284  1 LRUConfiguration config = (LRUConfiguration) region.getEvictionPolicyConfig();
 285  1 config.setMaxNodes(0);
 286  1 config.setTimeToLiveSeconds(0);
 287  1 config.setMaxAgeSeconds(1);
 288  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 289  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 290  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
 291   
 292  1 algo_.process(region);
 293  1 assertEquals("Queue size #1: ", 3, algo_.getEvictionQueue().getNumberOfNodes());
 294  1 TestingUtil.sleepThread(2000);
 295  1 algo_.process(region);
 296  1 assertEquals("Queue size #2: ", 0, algo_.getEvictionQueue().getNumberOfNodes());
 297    }
 298   
 299    /**
 300    * MaxAgeSeconds = 2 with 3 nodes.
 301    *
 302    * @throws Exception
 303    */
 304  1 public void testMaxAgeSeconds2() throws Exception
 305    {
 306  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 307  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 308  1 Fqn fqn3 = Fqn.fromString("/a/b/e");
 309  1 Region region = regionManager_.getRegion("/a/b", true);
 310  1 LRUConfiguration config = (LRUConfiguration) region.getEvictionPolicyConfig();
 311   
 312  1 config.setMaxNodes(0);
 313  1 config.setTimeToLiveSeconds(0);
 314  1 config.setMaxAgeSeconds(2);
 315  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 316  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 317  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
 318   
 319  1 algo_.process(region);
 320  1 assertEquals("Queue size #1: ", 3, algo_.getEvictionQueue().getNumberOfNodes());
 321  1 TestingUtil.sleepThread(1000);
 322  1 algo_.process(region);
 323  1 assertEquals("Queue size #2: ", 3, algo_.getEvictionQueue().getNumberOfNodes());
 324  1 TestingUtil.sleepThread(1500);
 325  1 algo_.process(region);
 326  1 assertEquals("Queue size #3: ", 0, algo_.getEvictionQueue().getNumberOfNodes());
 327    }
 328   
 329    /**
 330    * Generic combo case.
 331    */
 332  1 public void testCombo1()
 333    {
 334  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 335  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 336  1 Fqn fqn3 = Fqn.fromString("/a/b/e");
 337  1 Fqn fqn4 = Fqn.fromString("/a/b/f");
 338  1 Region region = regionManager_.getRegion("/a/b", true);
 339  1 LRUConfiguration config = (LRUConfiguration) region.getEvictionPolicyConfig();
 340   
 341  1 config.setMaxNodes(2);
 342  1 config.setTimeToLiveSeconds(1);
 343  1 config.setMaxAgeSeconds(3);
 344  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 345  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 346  1 region.putNodeEvent(new EvictedEventNode(fqn4, NodeEventType.ADD_NODE_EVENT));
 347   
 348  1 try
 349    {
 350  1 algo_.process(region);
 351    }
 352    catch (EvictionException e)
 353    {
 354  0 fail("testMaxNode: process failed " + e);
 355  0 e.printStackTrace();
 356    }
 357  1 assertEquals("Queue size #1: ", 2, algo_.getEvictionQueue().getNumberOfNodes());
 358  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
 359   
 360  1 TestingUtil.sleepThread(2000);
 361  1 try
 362    {
 363  1 algo_.process(region);
 364    }
 365    catch (EvictionException e)
 366    {
 367  0 fail("testMaxNode: process failed " + e);
 368  0 e.printStackTrace();
 369    }
 370  1 assertEquals("Queue size #2: ", 1, algo_.getEvictionQueue().getNumberOfNodes());
 371   
 372  1 TestingUtil.sleepThread(3500);
 373    // visit the node now to prevent the idle time from doing the pruning - node still gets pruned but by
 374    // max age.
 375  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.VISIT_NODE_EVENT));
 376  1 try
 377    {
 378  1 algo_.process(region);
 379    }
 380    catch (EvictionException e)
 381    {
 382  0 fail("testMaxAge: process failed " + e);
 383  0 e.printStackTrace();
 384    }
 385  1 assertEquals("Queue size #3: ", 0, algo_.getEvictionQueue().getNumberOfNodes());
 386    }
 387   
 388    /**
 389    * Generic combo case with newly added node should be around.
 390    */
 391  1 public void testCombo2()
 392    {
 393  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 394  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 395  1 Fqn fqn3 = Fqn.fromString("/a/b/e");
 396  1 Region region = regionManager_.getRegion("/a/b", true);
 397  1 LRUConfiguration config = (LRUConfiguration) region.getEvictionPolicyConfig();
 398   
 399  1 config.setMaxNodes(2);
 400  1 config.setTimeToLiveSeconds(1);
 401  1 config.setMaxAgeSeconds(3);
 402  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 403  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 404  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.REMOVE_NODE_EVENT));
 405  1 try
 406    {
 407  1 algo_.process(region);
 408    }
 409    catch (EvictionException e)
 410    {
 411  0 fail("testMaxNode: process failed " + e);
 412  0 e.printStackTrace();
 413    }
 414  1 assertEquals("Queue size #1: ", 1, algo_.getEvictionQueue().getNumberOfNodes());
 415  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
 416   
 417  1 TestingUtil.sleepThread(2000);
 418  1 try
 419    {
 420  1 algo_.process(region);
 421    }
 422    catch (EvictionException e)
 423    {
 424  0 fail("testMaxNode: process failed " + e);
 425  0 e.printStackTrace();
 426    }
 427  1 assertEquals("Queue size #2: ", 1, algo_.getEvictionQueue().getNumberOfNodes());
 428   
 429  1 TestingUtil.sleepThread(3000);
 430  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.VISIT_NODE_EVENT));
 431  1 try
 432    {
 433  1 algo_.process(region);
 434    }
 435    catch (EvictionException e)
 436    {
 437  0 fail("testCombo: process failed " + e);
 438  0 e.printStackTrace();
 439    }
 440   
 441  1 TestingUtil.sleepThread(1000);
 442  1 assertEquals("Queue size #3: ", 0, algo_.getEvictionQueue().getNumberOfNodes());
 443    }
 444   
 445  1 public void testEvictionSortOrder() throws Exception
 446    {
 447  1 Region region = regionManager_.getRegion("/a/b", true);
 448  1 LRUConfiguration config = (LRUConfiguration) region.getEvictionPolicyConfig();
 449   
 450  1 config.setMaxAgeSeconds(1000);
 451  1 config.setMaxNodes(0);
 452  1 config.setTimeToLiveSeconds(1000);
 453   
 454  1 for (int i = 0; i < 100; i++)
 455    {
 456  100 Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
 457  100 region.putNodeEvent(new EvictedEventNode(fqn, NodeEventType.ADD_NODE_EVENT));
 458    }
 459   
 460  1 algo_.process(region);
 461   
 462  1 TestingUtil.sleepThread(5000);
 463   
 464  1 for (int i = 0; i < 100; i++)
 465    {
 466  100 Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
 467  100 if (i % 2 == 0)
 468    {
 469  50 region.putNodeEvent(new EvictedEventNode(fqn, NodeEventType.VISIT_NODE_EVENT));
 470    }
 471    }
 472   
 473  1 algo_.process(region);
 474   
 475  1 LRUQueue queue = (LRUQueue) algo_.getEvictionQueue();
 476   
 477  1 NodeEntry ne;
 478  1 int count = 0;
 479  ? while ((ne = queue.getFirstLRUNodeEntry()) != null)
 480    {
 481  100 if (count < 50)
 482    {
 483  50 assertEquals(1, ne.getNumberOfNodeVisits());
 484    }
 485    else
 486    {
 487  50 assertEquals(2, ne.getNumberOfNodeVisits());
 488    }
 489  100 queue.removeNodeEntry(ne);
 490  100 count++;
 491    }
 492   
 493  1 for (int i = 0; i < 100; i++)
 494    {
 495  100 Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
 496  100 region.putNodeEvent(new EvictedEventNode(fqn, NodeEventType.ADD_NODE_EVENT));
 497    }
 498   
 499  1 algo_.process(region);
 500  1 long lastCreateTimestamp = 0;
 501  ? while ((ne = queue.getFirstMaxAgeNodeEntry()) != null)
 502    {
 503  100 assertTrue(ne.getCreationTimeStamp() >= lastCreateTimestamp);
 504  100 lastCreateTimestamp = ne.getCreationTimeStamp();
 505  100 queue.removeNodeEntry(ne);
 506    }
 507    }
 508   
 509  0 void log(String msg)
 510    {
 511  0 System.out.println("-- " + msg);
 512    }
 513   
 514  1 public static Test suite()
 515    {
 516  1 return new TestSuite(LRUAlgorithmTest.class);
 517    }
 518   
 519  0 public static void main(String[] args)
 520    {
 521  0 junit.textui.TestRunner.run(suite());
 522    }
 523   
 524    }