Clover coverage report -
Coverage timestamp: Wed Jan 31 2007 15:38:53 EST
file stats: LOC: 487   Methods: 11
NCLOC: 365   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
LFUAlgorithmTest.java 100% 97% 90.9% 97.3%
coverage coverage
 1    /*
 2    * JBoss, the OpenSource J2EE webOS
 3    *
 4    * Distributable under LGPL license.
 5    * See terms of license at gnu.org.
 6    */
 7    package org.jboss.cache.eviction;
 8   
 9    import junit.framework.Test;
 10    import junit.framework.TestCase;
 11    import junit.framework.TestSuite;
 12    import org.jboss.cache.CacheImpl;
 13    import org.jboss.cache.DefaultCacheFactory;
 14    import org.jboss.cache.Fqn;
 15    import org.jboss.cache.Region;
 16    import org.jboss.cache.RegionManager;
 17   
 18    import java.util.Iterator;
 19   
 20    /**
 21    * Unit test for LFUAlgorithm.
 22    *
 23    * @author Daniel Huang - dhuang@jboss.org - 10/2005
 24    * @version $Revision: 1.8 $
 25    */
 26    public class LFUAlgorithmTest extends TestCase
 27    {
 28   
 29    RegionManager regionManager;
 30    LFUAlgorithm algo;
 31   
 32  6 public LFUAlgorithmTest(String s)
 33    {
 34  6 super(s);
 35    }
 36   
 37  6 public void setUp() throws Exception
 38    {
 39  6 super.setUp();
 40   
 41  6 algo = new LFUAlgorithm();
 42  6 LFUConfiguration config = new LFUConfiguration();
 43  6 regionManager = new RegionManager((CacheImpl) DefaultCacheFactory.getInstance().createCache(false));
 44  6 config.setEvictionPolicyClass(DummyEvictionPolicy.class.getName());
 45  6 regionManager.getRegion("/a/b", true).setEvictionPolicy(config);
 46    // doesn't this need a cache?!?? :-/
 47   
 48    }
 49   
 50  6 public void tearDown() throws Exception
 51    {
 52  6 super.tearDown();
 53    }
 54   
 55  1 public void testMaxNode1()
 56    {
 57  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 58  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 59  1 Region region = regionManager.getRegion("/a/b", true);
 60  1 LFUConfiguration config = new LFUConfiguration();
 61  1 config.setMaxNodes(0);
 62  1 config.setMinNodes(20);
 63  1 region.setEvictionPolicy(config);
 64  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 65  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 66  1 try
 67    {
 68  1 algo.process(region);
 69    }
 70    catch (EvictionException e)
 71    {
 72  0 fail("testMaxNode: process failed " + e);
 73  0 e.printStackTrace();
 74    }
 75  1 assertEquals("Queue size should be ", 2, algo.getEvictionQueue().getNumberOfNodes());
 76   
 77    }
 78   
 79  1 public void testMaxNode2()
 80    {
 81  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 82  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 83  1 Fqn fqn3 = Fqn.fromString("/a/b/e");
 84  1 Region region = regionManager.getRegion("/a/b", true);
 85  1 LFUConfiguration config = new LFUConfiguration();
 86  1 config.setMaxNodes(1);
 87  1 config.setMinNodes(20);
 88  1 region.setEvictionPolicy(config);
 89  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 90  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 91   
 92  1 try
 93    {
 94  1 algo.process(region);
 95    }
 96    catch (EvictionException e)
 97    {
 98  0 fail("testMaxNode: process failed " + e);
 99  0 e.printStackTrace();
 100    }
 101  1 assertEquals("Queue size should be ", 1, algo.getEvictionQueue().getNumberOfNodes());
 102   
 103  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 104  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
 105   
 106   
 107  1 try
 108    {
 109  1 algo.process(region);
 110    }
 111    catch (EvictionException e)
 112    {
 113  0 fail("testMaxNode: process failed " + e);
 114  0 e.printStackTrace();
 115    }
 116  1 assertEquals("Queue size should be ", 1, algo.getEvictionQueue().getNumberOfNodes());
 117    }
 118   
 119    // What's this doing here? This should be a stress test, not a functional test. There are no assertions, for
 120    // example. :S - Manik, Nov 06
 121   
 122    // public void testMaxNode3() throws Exception
 123    // {
 124    // Region region = regionManager.getRegion("/a/b", true);
 125    // LFUConfiguration config = new LFUConfiguration();
 126    //
 127    // config.setMaxNodes(15000);
 128    // config.setMinNodes(15000);
 129    //
 130    // region.setEvictionPolicy(config);
 131    // for (int i = 0; i < 20000; i++)
 132    // {
 133    // Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
 134    // region.putNodeEvent(new EvictedEventNode(fqn, NodeEventType.ADD_NODE_EVENT));
 135    //
 136    // if ((i % 2) == 0)
 137    // {
 138    // region.putNodeEvent(new EvictedEventNode(fqn, NodeEventType.VISIT_NODE_EVENT));
 139    // }
 140    // }
 141    //
 142    // algo.process(region);
 143    //// LFUQueue queue = (LFUQueue) algo.evictionQueue;
 144    //// Iterator it = queue.iterate();
 145    //
 146    // }
 147   
 148  1 public void testMinNode1() throws Exception
 149    {
 150  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 151  1 Fqn fqn2 = Fqn.fromString("/a/b/c/d");
 152  1 Fqn fqn3 = Fqn.fromString("/a/b/c/d/e");
 153  1 Fqn fqn4 = Fqn.fromString("/a/b/c/d/e/f");
 154   
 155  1 Region region = regionManager.getRegion("/a/b", true);
 156  1 LFUConfiguration config = (LFUConfiguration) region.getEvictionPolicyConfig();
 157   
 158  1 config.setMaxNodes(0);
 159  1 config.setMinNodes(2);
 160   
 161  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 162  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 163  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
 164  1 region.putNodeEvent(new EvictedEventNode(fqn4, NodeEventType.ADD_NODE_EVENT));
 165   
 166  1 algo.process(region);
 167   
 168  1 assertEquals("Queue size should be ", 2, algo.getEvictionQueue().getNumberOfNodes());
 169    }
 170   
 171  1 public void testMinNode2() throws Exception
 172    {
 173  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 174  1 Fqn fqn2 = Fqn.fromString("/a/b/d");
 175   
 176  1 Region region = regionManager.getRegion("/a/b", true);
 177  1 LFUConfiguration config = (LFUConfiguration) region.getEvictionPolicyConfig();
 178   
 179  1 config.setMaxNodes(0);
 180  1 config.setMinNodes(0);
 181   
 182  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 183  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 184   
 185  1 algo.process(region);
 186   
 187  1 assertEquals("Queue size should be ", 0, algo.getEvictionQueue().getNumberOfNodes());
 188    }
 189   
 190  1 public void testEvictionQueueSortOrder1() throws Exception
 191    {
 192  1 Fqn fqn1 = Fqn.fromString("/a/b/c");
 193  1 Fqn fqn2 = Fqn.fromString("/a/b/c/d");
 194  1 Fqn fqn3 = Fqn.fromString("/a/b/c/d/e");
 195  1 Fqn fqn4 = Fqn.fromString("/a/b/c/d/e/f");
 196  1 Fqn fqn5 = Fqn.fromString("/a/b/c/d/e/f/g/h");
 197  1 Fqn fqn6 = Fqn.fromString("/a/b/c/d/e/f/g/h/i");
 198  1 Fqn fqn7 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j");
 199  1 Fqn fqn8 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j/k");
 200  1 Fqn fqn9 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j/k/l");
 201  1 Fqn fqn10 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j/k/l/m");
 202   
 203   
 204  1 Region region = regionManager.getRegion("/a/b", true);
 205  1 LFUConfiguration config = (LFUConfiguration) region.getEvictionPolicyConfig();
 206  1 config.setMaxNodes(0);
 207  1 config.setMinNodes(100);
 208   
 209  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.ADD_NODE_EVENT));
 210  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.ADD_NODE_EVENT));
 211  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.ADD_NODE_EVENT));
 212  1 region.putNodeEvent(new EvictedEventNode(fqn4, NodeEventType.ADD_NODE_EVENT));
 213  1 region.putNodeEvent(new EvictedEventNode(fqn5, NodeEventType.ADD_NODE_EVENT));
 214  1 region.putNodeEvent(new EvictedEventNode(fqn6, NodeEventType.ADD_NODE_EVENT));
 215  1 region.putNodeEvent(new EvictedEventNode(fqn7, NodeEventType.ADD_NODE_EVENT));
 216  1 region.putNodeEvent(new EvictedEventNode(fqn8, NodeEventType.ADD_NODE_EVENT));
 217  1 region.putNodeEvent(new EvictedEventNode(fqn9, NodeEventType.ADD_NODE_EVENT));
 218  1 region.putNodeEvent(new EvictedEventNode(fqn10, NodeEventType.ADD_NODE_EVENT));
 219   
 220  1 algo.process(region);
 221  1 LFUQueue queue = (LFUQueue) algo.evictionQueue;
 222  1 assertEquals(10, algo.getEvictionQueue().getNumberOfNodes());
 223  1 Iterator it = queue.iterate();
 224   
 225  1 while (it.hasNext())
 226    {
 227  10 NodeEntry ne = (NodeEntry) it.next();
 228  10 System.out.println("Fqn: " + ne.getFqn() + " NodeVisits: " + ne.getNumberOfNodeVisits());
 229  10 assertEquals(1, ne.getNumberOfNodeVisits());
 230    }
 231   
 232    // fqn1 visited 4 additional times.
 233  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
 234  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
 235  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
 236  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
 237   
 238    // fqn2 visited 3 additional times.
 239  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.VISIT_NODE_EVENT));
 240  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.VISIT_NODE_EVENT));
 241  1 region.putNodeEvent(new EvictedEventNode(fqn2, NodeEventType.VISIT_NODE_EVENT));
 242   
 243    // fqn3 visited 1 additional time.
 244  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.VISIT_NODE_EVENT));
 245   
 246    // fqn4 visited 2 additional times.
 247  1 region.putNodeEvent(new EvictedEventNode(fqn4, NodeEventType.VISIT_NODE_EVENT));
 248  1 region.putNodeEvent(new EvictedEventNode(fqn4, NodeEventType.VISIT_NODE_EVENT));
 249   
 250    // fqn9 visited 1 additional time.
 251  1 region.putNodeEvent(new EvictedEventNode(fqn9, NodeEventType.VISIT_NODE_EVENT));
 252   
 253    // fqn10 visited 2 additional times.
 254  1 region.putNodeEvent(new EvictedEventNode(fqn10, NodeEventType.VISIT_NODE_EVENT));
 255  1 region.putNodeEvent(new EvictedEventNode(fqn10, NodeEventType.VISIT_NODE_EVENT));
 256   
 257  1 algo.process(region);
 258  1 System.out.println();
 259  1 System.out.println();
 260   
 261  1 it = queue.iterate();
 262  1 int count = 0;
 263  1 while (it.hasNext())
 264    {
 265  10 count++;
 266  10 NodeEntry ne = (NodeEntry) it.next();
 267  10 System.out.println("Fqn: " + ne.getFqn() + " NodeVisits: " + ne.getNumberOfNodeVisits());
 268  10 if (count == 5 || count == 6)
 269    {
 270  2 assertEquals(2, ne.getNumberOfNodeVisits());
 271    }
 272  8 else if (count == 7 || count == 8)
 273    {
 274  2 assertEquals(3, ne.getNumberOfNodeVisits());
 275    }
 276  6 else if (count == 9)
 277    {
 278  1 assertEquals(4, ne.getNumberOfNodeVisits());
 279    }
 280  5 else if (count == 10)
 281    {
 282  1 assertEquals(5, ne.getNumberOfNodeVisits());
 283    }
 284    else
 285    {
 286  4 assertEquals(1, ne.getNumberOfNodeVisits());
 287    }
 288    }
 289   
 290   
 291  1 assertEquals(10, algo.getEvictionQueue().getNumberOfNodes());
 292   
 293  1 Fqn fqn11 = Fqn.fromString("/a");
 294  1 Fqn fqn12 = Fqn.fromString("/a/b");
 295   
 296  1 region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.ADD_NODE_EVENT));
 297  1 region.putNodeEvent(new EvictedEventNode(fqn12, NodeEventType.ADD_NODE_EVENT));
 298   
 299  1 algo.process(region);
 300  1 System.out.println();
 301  1 System.out.println();
 302   
 303  1 it = queue.iterate();
 304  1 count = 0;
 305  1 while (it.hasNext())
 306    {
 307  12 count++;
 308  12 NodeEntry ne = (NodeEntry) it.next();
 309  12 System.out.println("Fqn: " + ne.getFqn() + " NodeVisits: " + ne.getNumberOfNodeVisits());
 310  12 if (count == 7 || count == 8)
 311    {
 312  2 assertEquals(2, ne.getNumberOfNodeVisits());
 313    }
 314  10 else if (count == 9 || count == 10)
 315    {
 316  2 assertEquals(3, ne.getNumberOfNodeVisits());
 317    }
 318  8 else if (count == 11)
 319    {
 320  1 assertEquals(4, ne.getNumberOfNodeVisits());
 321    }
 322  7 else if (count == 12)
 323    {
 324  1 assertEquals(5, ne.getNumberOfNodeVisits());
 325    }
 326    else
 327    {
 328  6 assertEquals(1, ne.getNumberOfNodeVisits());
 329    }
 330    }
 331   
 332  1 assertEquals(12, algo.getEvictionQueue().getNumberOfNodes());
 333   
 334  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.REMOVE_NODE_EVENT));
 335  1 region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.REMOVE_NODE_EVENT));
 336  1 region.putNodeEvent(new EvictedEventNode(fqn12, NodeEventType.REMOVE_NODE_EVENT));
 337  1 region.putNodeEvent(new EvictedEventNode(fqn10, NodeEventType.REMOVE_NODE_EVENT));
 338   
 339  1 algo.process(region);
 340   
 341  1 System.out.println();
 342  1 System.out.println();
 343  1 it = queue.iterate();
 344  1 count = 0;
 345  1 while (it.hasNext())
 346    {
 347  8 count++;
 348  8 NodeEntry ne = (NodeEntry) it.next();
 349  8 System.out.println("Fqn: " + ne.getFqn() + " NodeVisits: " + ne.getNumberOfNodeVisits());
 350  8 if (count == 5 || count == 6)
 351    {
 352  2 assertEquals(2, ne.getNumberOfNodeVisits());
 353    }
 354  6 else if (count == 7)
 355    {
 356  1 assertEquals(3, ne.getNumberOfNodeVisits());
 357    }
 358  5 else if (count == 8)
 359    {
 360  1 assertEquals(4, ne.getNumberOfNodeVisits());
 361    }
 362    else
 363    {
 364  4 assertEquals(1, ne.getNumberOfNodeVisits());
 365    }
 366    }
 367   
 368  1 assertEquals(8, algo.getEvictionQueue().getNumberOfNodes());
 369   
 370    //test add/visit/remove combination
 371  1 region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.ADD_NODE_EVENT));
 372  1 region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.VISIT_NODE_EVENT));
 373  1 region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.VISIT_NODE_EVENT));
 374  1 region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.VISIT_NODE_EVENT));
 375  1 region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.VISIT_NODE_EVENT));
 376  1 region.putNodeEvent(new EvictedEventNode(fqn11, NodeEventType.VISIT_NODE_EVENT));
 377  1 region.putNodeEvent(new EvictedEventNode(fqn4, NodeEventType.VISIT_NODE_EVENT));
 378   
 379    // purposefully revisit a node that has been removed. assert that it is readded.
 380  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
 381  1 region.putNodeEvent(new EvictedEventNode(fqn1, NodeEventType.VISIT_NODE_EVENT));
 382   
 383  1 region.putNodeEvent(new EvictedEventNode(fqn3, NodeEventType.REMOVE_NODE_EVENT));
 384   
 385   
 386  1 algo.process(region);
 387   
 388  1 System.out.println();
 389  1 System.out.println();
 390  1 it = queue.iterate();
 391  1 count = 0;
 392  1 while (it.hasNext())
 393    {
 394  9 count++;
 395  9 NodeEntry ne = (NodeEntry) it.next();
 396  9 System.out.println("Fqn: " + ne.getFqn() + " NodeVisits: " + ne.getNumberOfNodeVisits());
 397  9 if (count == 5 || count == 6)
 398    {
 399  2 assertEquals(2, ne.getNumberOfNodeVisits());
 400    }
 401  7 else if (count == 7 || count == 8)
 402    {
 403  2 assertEquals(4, ne.getNumberOfNodeVisits());
 404    }
 405  5 else if (count == 9)
 406    {
 407  1 assertEquals(6, ne.getNumberOfNodeVisits());
 408    }
 409    else
 410    {
 411  4 assertEquals(1, ne.getNumberOfNodeVisits());
 412    }
 413    }
 414  1 assertEquals(9, algo.getEvictionQueue().getNumberOfNodes());
 415    }
 416   
 417  1 public void testEvictionQueueSortOrder2() throws Exception
 418    {
 419  1 Region region = regionManager.getRegion("/a/b", true);
 420  1 LFUConfiguration config = (LFUConfiguration) region.getEvictionPolicyConfig();
 421   
 422  1 config.setMaxNodes(0);
 423  1 config.setMinNodes(10000);
 424  1 for (int i = 0; i < 10000; i++)
 425    {
 426  10000 Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
 427  10000 region.putNodeEvent(new EvictedEventNode(fqn, NodeEventType.ADD_NODE_EVENT));
 428    }
 429   
 430  1 algo.process(region);
 431  1 LFUQueue queue = (LFUQueue) algo.evictionQueue;
 432  1 Iterator it = queue.iterate();
 433   
 434  1 long lastModifiedTimestamp = 0;
 435  1 while (it.hasNext())
 436    {
 437  10000 NodeEntry ne = (NodeEntry) it.next();
 438  10000 assertTrue(lastModifiedTimestamp <= ne.getModifiedTimeStamp());
 439  10000 lastModifiedTimestamp = ne.getModifiedTimeStamp();
 440    }
 441   
 442  1 for (int i = 0; i < 10000; i++)
 443    {
 444  10000 if ((i % 2) == 0)
 445    {
 446  5000 Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
 447  5000 region.putNodeEvent(new EvictedEventNode(fqn, NodeEventType.VISIT_NODE_EVENT));
 448    }
 449    }
 450   
 451  1 algo.process(region);
 452   
 453  1 it = queue.iterate();
 454  1 int count = 0;
 455  1 lastModifiedTimestamp = 0;
 456  1 while (it.hasNext())
 457    {
 458  10000 NodeEntry ne = (NodeEntry) it.next();
 459  10000 assertTrue(lastModifiedTimestamp <= ne.getModifiedTimeStamp());
 460  10000 lastModifiedTimestamp = ne.getModifiedTimeStamp();
 461   
 462  10000 if (count < 5000)
 463    {
 464  5000 assertEquals(1, ne.getNumberOfNodeVisits());
 465    }
 466    else
 467    {
 468  5000 assertEquals(2, ne.getNumberOfNodeVisits());
 469    }
 470  10000 count++;
 471   
 472    }
 473   
 474  1 assertEquals(10000, algo.getEvictionQueue().getNumberOfNodes());
 475    }
 476   
 477  1 public static Test suite()
 478    {
 479  1 return new TestSuite(LFUAlgorithmTest.class);
 480    }
 481   
 482  0 public static void main(String[] args)
 483    {
 484  0 junit.textui.TestRunner.run(suite());
 485    }
 486   
 487    }