Clover coverage report -
Coverage timestamp: Thu Jul 5 2007 20:02:32 EDT
file stats: LOC: 647   Methods: 16
NCLOC: 539   Classes: 2
 
 Source file Conditionals Statements Methods TOTAL
CacheLoaderManagerTest.java - 98.7% 93.8% 98.4%
coverage coverage
 1    /*
 2    * JBoss, Home of Professional Open Source
 3    *
 4    * Distributable under LGPL license.
 5    * See terms of license at gnu.org.
 6    */
 7    package org.jboss.cache.loader;
 8   
 9    import junit.framework.Assert;
 10    import junit.framework.Test;
 11    import junit.framework.TestSuite;
 12    import org.jboss.cache.Cache;
 13    import org.jboss.cache.config.CacheLoaderConfig;
 14    import org.jboss.cache.factories.XmlConfigurationParser;
 15    import org.jboss.cache.xml.XmlHelper;
 16    import org.w3c.dom.Element;
 17   
 18    import java.util.List;
 19    import java.util.Properties;
 20   
 21    /**
 22    * Tests the construction of a cache laoder based on an XML element passed in.
 23    *
 24    * @author <a href="mailto:manik@jboss.org">Manik Surtani (manik@jboss.org)</a>
 25    */
 26    public class CacheLoaderManagerTest extends AbstractCacheLoaderTestBase
 27    {
 28  10 private CacheLoaderConfig createCacheLoaderCfg(boolean passivation)
 29    {
 30  10 CacheLoaderConfig cfg = new CacheLoaderConfig();
 31  10 cfg.setPassivation(passivation);
 32  10 return cfg;
 33    }
 34   
 35  19 private CacheLoaderConfig.IndividualCacheLoaderConfig createIndividualCacheLoaderConfig(CacheLoaderConfig parent, boolean async, String classname) throws Exception
 36    {
 37  19 CacheLoaderConfig.IndividualCacheLoaderConfig cfg = new CacheLoaderConfig.IndividualCacheLoaderConfig();
 38  19 cfg.setAsync(async);
 39  19 cfg.setClassName(classname);
 40  19 cfg.setFetchPersistentState(false);
 41  19 Properties p = new Properties();
 42  19 p.setProperty("location", getTempDir());
 43  19 p.setProperty("cache.jdbc.driver", "com.mysql.jdbc.Driver");
 44  19 p.setProperty("cache.jdbc.url", "jdbc:mysql://localhost/test");
 45  19 p.setProperty("cache.jdbc.user", "user");
 46  19 p.setProperty("cache.jdbc.password", "pwd");
 47  19 cfg.setProperties(p);
 48  19 return cfg;
 49    }
 50   
 51  39 private String getTempDir()
 52    {
 53  39 return System.getProperty("java.io.tempdir", "/tmp");
 54    }
 55   
 56  14 private static Element strToElement(String s) throws Exception
 57    {
 58  14 return XmlHelper.stringToElement(s);
 59    }
 60   
 61  1 public void testSingleCacheLoader() throws Exception
 62    {
 63    // without async
 64  1 CacheLoaderManager mgr = new CacheLoaderManager();
 65  1 CacheLoaderConfig cfg = createCacheLoaderCfg(false);
 66  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.FileCacheLoader"));
 67   
 68  1 mgr.setConfig(cfg, null);
 69  1 CacheLoader cl = mgr.getCacheLoader();
 70   
 71  1 Assert.assertEquals(FileCacheLoader.class, cl.getClass());
 72   
 73    // with async
 74  1 cfg = createCacheLoaderCfg(false);
 75  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader"));
 76   
 77  1 mgr.setConfig(cfg, null);
 78  1 cl = mgr.getCacheLoader();
 79   
 80  1 Assert.assertEquals(AsyncCacheLoader.class, cl.getClass());
 81    }
 82   
 83  1 public void testSingleCacheLoaderPassivation() throws Exception
 84    {
 85    // without async
 86  1 CacheLoaderConfig cfg = createCacheLoaderCfg(true);
 87  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.FileCacheLoader"));
 88  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.bdbje.BdbjeCacheLoader"));
 89  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.JDBCCacheLoader"));
 90   
 91  1 CacheLoaderManager mgr = new CacheLoaderManager();
 92  1 mgr.setConfig(cfg, null);
 93  1 CacheLoader cl = mgr.getCacheLoader();
 94   
 95  1 Assert.assertEquals(FileCacheLoader.class, cl.getClass());
 96   
 97    // with async
 98  1 cfg = createCacheLoaderCfg(true);
 99  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader"));
 100  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.bdbje.BdbjeCacheLoader"));
 101  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.JDBCCacheLoader"));
 102   
 103  1 mgr.setConfig(cfg, null);
 104  1 cl = mgr.getCacheLoader();
 105   
 106  1 Assert.assertEquals(AsyncCacheLoader.class, cl.getClass());
 107    }
 108   
 109  1 public void testSingleCacheLoaderFromXml() throws Exception
 110    {
 111    // without async
 112  1 CacheLoaderConfig clc = getSingleCacheLoaderConfig("", "org.jboss.cache.loader.FileCacheLoader", "location=" + getTempDir(), false, false, false);
 113   
 114  1 CacheLoaderManager mgr = new CacheLoaderManager();
 115  1 mgr.setConfig(clc, null);
 116  1 CacheLoader cl = mgr.getCacheLoader();
 117   
 118  1 Assert.assertEquals(FileCacheLoader.class, cl.getClass());
 119   
 120    // with async
 121  1 clc = getSingleCacheLoaderConfig("", "org.jboss.cache.loader.FileCacheLoader", "location=" + getTempDir(), true, false, false);
 122   
 123  1 mgr.setConfig(clc, null);
 124  1 cl = mgr.getCacheLoader();
 125  1 Assert.assertEquals(AsyncCacheLoader.class, cl.getClass());
 126    }
 127   
 128  1 public void testSingleCacheLoaderPassivationFromXml() throws Exception
 129    {
 130    // without async
 131  1 String conf = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
 132    "<config><passivation>true</passivation>" +
 133    "<cacheloader>" +
 134    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 135    " <async>false</async>" +
 136    " <fetchPersistentState>false</fetchPersistentState>" +
 137    " <ignoreModifications>false</ignoreModifications>" +
 138    " <properties>" +
 139    " location=" + getTempDir() +
 140    " </properties>" +
 141    "</cacheloader>" +
 142    "<cacheloader>" +
 143    " <class>org.jboss.cache.loader.bdbje.BdbjeCacheLoader</class>" +
 144    " <async>false</async>" +
 145    " <fetchPersistentState>false</fetchPersistentState>" +
 146    " <ignoreModifications>false</ignoreModifications>" +
 147    " <properties>" +
 148    " location=" + getTempDir() +
 149    " </properties>" +
 150    "</cacheloader>" +
 151    "<cacheloader>" +
 152    " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" +
 153    " <async>false</async>" +
 154    " <fetchPersistentState>false</fetchPersistentState>" +
 155    " <ignoreModifications>false</ignoreModifications>" +
 156    " <properties>" +
 157    " location=" + getTempDir() +
 158    " </properties>" +
 159    "</cacheloader></config>";
 160  1 CacheLoaderConfig clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 161  1 CacheLoaderManager mgr = new CacheLoaderManager();
 162  1 mgr.setConfig(clc, null);
 163  1 CacheLoader cl = mgr.getCacheLoader();
 164   
 165  1 Assert.assertEquals(FileCacheLoader.class, cl.getClass());
 166   
 167    // with async
 168  1 conf = "<config><passivation>true</passivation>" +
 169    "<cacheloader>" +
 170    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 171    " <async>true</async>" +
 172    " <fetchPersistentState>false</fetchPersistentState>" +
 173    " <ignoreModifications>false</ignoreModifications>" +
 174    " <properties>" +
 175    " location=" + getTempDir() +
 176    " </properties>" +
 177    "</cacheloader>" +
 178    "<cacheloader>" +
 179    " <class>org.jboss.cache.loader.bdbje.BdbjeCacheLoader</class>" +
 180    " <async>true</async>" +
 181    " <fetchPersistentState>false</fetchPersistentState>" +
 182    " <ignoreModifications>false</ignoreModifications>" +
 183    " <properties>" +
 184    " location=" + getTempDir() +
 185    " </properties>" +
 186    "</cacheloader>" +
 187    "<cacheloader>" +
 188    " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" +
 189    " <async>true</async>" +
 190    " <fetchPersistentState>false</fetchPersistentState>" +
 191    " <ignoreModifications>false</ignoreModifications>" +
 192    " <properties>" +
 193    " location=" + getTempDir() +
 194    " </properties>" +
 195    "</cacheloader></config>";
 196  1 clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 197  1 mgr.setConfig(clc, null);
 198  1 cl = mgr.getCacheLoader();
 199   
 200  1 Assert.assertEquals(AsyncCacheLoader.class, cl.getClass());
 201    }
 202   
 203  1 public void testChainingCacheLoader() throws Exception
 204    {
 205    // async = false
 206  1 CacheLoaderConfig cfg = createCacheLoaderCfg(false);
 207  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.FileCacheLoader"));
 208  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.JDBCCacheLoader"));
 209   
 210  1 CacheLoaderManager mgr = new CacheLoaderManager();
 211  1 mgr.setConfig(cfg, null);
 212  1 CacheLoader cl = mgr.getCacheLoader();
 213   
 214  1 Assert.assertEquals(ChainingCacheLoader.class, cl.getClass());
 215  1 Assert.assertEquals(2, ((ChainingCacheLoader) cl).getSize());
 216  1 List loaders = ((ChainingCacheLoader) cl).getCacheLoaders();
 217  1 Assert.assertEquals(FileCacheLoader.class, loaders.get(0).getClass());
 218  1 Assert.assertEquals(JDBCCacheLoader.class, loaders.get(1).getClass());
 219   
 220    // async = true
 221  1 cfg = createCacheLoaderCfg(false);
 222  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.FileCacheLoader"));
 223  1 cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.JDBCCacheLoader"));
 224   
 225  1 mgr.setConfig(cfg, null);
 226  1 cl = mgr.getCacheLoader();
 227   
 228  1 Assert.assertEquals(ChainingCacheLoader.class, cl.getClass());
 229  1 Assert.assertEquals(2, ((ChainingCacheLoader) cl).getSize());
 230  1 loaders = ((ChainingCacheLoader) cl).getCacheLoaders();
 231  1 Assert.assertEquals(FileCacheLoader.class, loaders.get(0).getClass());
 232  1 Assert.assertEquals(AsyncCacheLoader.class, loaders.get(1).getClass());
 233    }
 234   
 235  1 public void testChainingCacheLoaderFromXml() throws Exception
 236    {
 237    // async = false
 238  1 String conf = "<config><passivation>false</passivation>" +
 239    "<cacheloader>" +
 240    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 241    " <async>false</async>" +
 242    " <fetchPersistentState>false</fetchPersistentState>" +
 243    " <ignoreModifications>false</ignoreModifications>" +
 244    " <properties>" +
 245    " location=" + getTempDir() +
 246    " </properties>" +
 247    "</cacheloader>" +
 248    "<cacheloader>" +
 249    " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" +
 250    " <async>false</async>" +
 251    " <fetchPersistentState>false</fetchPersistentState>" +
 252    " <ignoreModifications>false</ignoreModifications>" +
 253    " <properties>" +
 254    "cache.jdbc.driver=com.mysql.jdbc.Driver\ncache.jdbc.url=jdbc:mysql://localhost/test\ncache.jdbc.user=user\ncache.jdbc.password=pwd" +
 255    " </properties>" +
 256    "</cacheloader></config>";
 257   
 258  1 CacheLoaderConfig clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 259  1 CacheLoaderManager mgr = new CacheLoaderManager();
 260  1 mgr.setConfig(clc, null);
 261  1 CacheLoader cl = mgr.getCacheLoader();
 262   
 263   
 264  1 Assert.assertEquals(ChainingCacheLoader.class, cl.getClass());
 265  1 Assert.assertEquals(2, ((ChainingCacheLoader) cl).getSize());
 266  1 List loaders = ((ChainingCacheLoader) cl).getCacheLoaders();
 267  1 Assert.assertEquals(FileCacheLoader.class, loaders.get(0).getClass());
 268  1 Assert.assertEquals(JDBCCacheLoader.class, loaders.get(1).getClass());
 269   
 270    // async = true
 271  1 conf = "<config>" +
 272    "<passivation>false</passivation>" +
 273    "<cacheloader>" +
 274    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 275    " <async>false</async>" +
 276    " <fetchPersistentState>false</fetchPersistentState>" +
 277    " <ignoreModifications>false</ignoreModifications>" +
 278    " <properties>" +
 279    " location=" + getTempDir() +
 280    " </properties>" +
 281    "</cacheloader>" +
 282    "<cacheloader>" +
 283    " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" +
 284    " <async>true</async>" +
 285    " <fetchPersistentState>false</fetchPersistentState>" +
 286    " <ignoreModifications>false</ignoreModifications>" +
 287    " <properties>" +
 288    "cache.jdbc.driver=com.mysql.jdbc.Driver\ncache.jdbc.url=jdbc:mysql://localhost/test\ncache.jdbc.user=user\ncache.jdbc.password=pwd" +
 289    " </properties>" +
 290    "</cacheloader></config>";
 291  1 clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 292  1 mgr.setConfig(clc, null);
 293  1 cl = mgr.getCacheLoader();
 294   
 295  1 Assert.assertEquals(ChainingCacheLoader.class, cl.getClass());
 296  1 Assert.assertEquals(2, ((ChainingCacheLoader) cl).getSize());
 297  1 loaders = ((ChainingCacheLoader) cl).getCacheLoaders();
 298  1 Assert.assertEquals(FileCacheLoader.class, loaders.get(0).getClass());
 299  1 Assert.assertEquals(AsyncCacheLoader.class, loaders.get(1).getClass());
 300    }
 301   
 302  1 public void testMoreThanOneFetchPersistentState() throws Exception
 303    {
 304  1 CacheLoaderManager mgr = new CacheLoaderManager();
 305  1 CacheLoaderConfig cfg = createCacheLoaderCfg(false);
 306  1 CacheLoaderConfig.IndividualCacheLoaderConfig i = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
 307  1 i.setFetchPersistentState(true);
 308  1 CacheLoaderConfig.IndividualCacheLoaderConfig i2 = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
 309  1 i2.setFetchPersistentState(true);
 310   
 311  1 cfg.addIndividualCacheLoaderConfig(i);
 312  1 cfg.addIndividualCacheLoaderConfig(i2);
 313   
 314  1 Assert.assertEquals(2, cfg.getIndividualCacheLoaderConfigs().size());
 315   
 316  1 try
 317    {
 318  1 mgr.setConfig(cfg, null);
 319  0 Assert.assertTrue("Should throw exception since we have > 1 cache loader with fetchPersistentState as true", false);
 320    }
 321    catch (Exception e)
 322    {
 323  1 Assert.assertTrue(true);
 324    }
 325   
 326    // control cases which should not throw exceptions
 327  1 mgr = new CacheLoaderManager();
 328  1 cfg = createCacheLoaderCfg(false);
 329  1 i = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
 330  1 i.setFetchPersistentState(true);
 331   
 332  1 cfg.addIndividualCacheLoaderConfig(i);
 333   
 334  1 Assert.assertEquals(1, cfg.getIndividualCacheLoaderConfigs().size());
 335  1 mgr.setConfig(cfg, null);
 336   
 337    // control cases which should not throw exceptions
 338  1 mgr = new CacheLoaderManager();
 339  1 cfg = createCacheLoaderCfg(false);
 340  1 i = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
 341  1 i.setFetchPersistentState(true);
 342  1 i2 = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
 343  1 i2.setFetchPersistentState(false);
 344   
 345  1 cfg.addIndividualCacheLoaderConfig(i);
 346  1 cfg.addIndividualCacheLoaderConfig(i2);
 347   
 348  1 Assert.assertEquals(2, cfg.getIndividualCacheLoaderConfigs().size());
 349  1 mgr.setConfig(cfg, null);
 350   
 351    // control cases which should not throw exceptions
 352  1 mgr = new CacheLoaderManager();
 353  1 cfg = createCacheLoaderCfg(false);
 354  1 i = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
 355  1 i.setFetchPersistentState(false);
 356  1 i2 = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
 357  1 i2.setFetchPersistentState(false);
 358   
 359  1 cfg.addIndividualCacheLoaderConfig(i);
 360  1 cfg.addIndividualCacheLoaderConfig(i2);
 361   
 362  1 Assert.assertEquals(2, cfg.getIndividualCacheLoaderConfigs().size());
 363  1 mgr.setConfig(cfg, null);
 364    }
 365   
 366  1 public void testConfigurationParsing() throws Exception
 367    {
 368   
 369  1 String conf = "<config>" +
 370    "<passivation>false</passivation>" +
 371    "<preload>/, /blah, /blah2</preload>" +
 372    "<cacheloader>" +
 373    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 374    " <async>false</async>" +
 375    " <fetchPersistentState>false</fetchPersistentState>" +
 376    " <ignoreModifications>true</ignoreModifications>" +
 377    " <properties>" +
 378    " location=" + getTempDir() +
 379    " </properties>" +
 380    "</cacheloader>" +
 381    "<cacheloader>" +
 382    " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" +
 383    " <async>true</async>" +
 384    " <fetchPersistentState>true</fetchPersistentState>" +
 385    " <ignoreModifications>false</ignoreModifications>" +
 386    " <properties>" +
 387    "cache.jdbc.driver=com.mysql.jdbc.Driver\ncache.jdbc.url=jdbc:mysql://localhost/test\ncache.jdbc.user=user\ncache.jdbc.password=pwd" +
 388    " </properties>" +
 389    "</cacheloader></config>";
 390  1 CacheLoaderConfig clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 391  1 CacheLoaderManager mgr = new CacheLoaderManager();
 392  1 mgr.setConfig(clc, null);
 393   
 394  1 Assert.assertEquals(ChainingCacheLoader.class, mgr.getCacheLoader().getClass());
 395  1 Assert.assertTrue("Should be true", mgr.isFetchPersistentState());
 396  1 Assert.assertTrue("Passivation shuld be false", !mgr.isPassivation());
 397  1 CacheLoaderConfig c = mgr.getCacheLoaderConfig();
 398  1 Assert.assertTrue("Should be using a chaining cache loader", c.useChainingCacheLoader());
 399  1 Assert.assertEquals("/, /blah, /blah2", c.getPreload());
 400  1 Assert.assertEquals(2, c.getIndividualCacheLoaderConfigs().size());
 401   
 402  1 CacheLoaderConfig.IndividualCacheLoaderConfig icfg = c.getIndividualCacheLoaderConfigs().get(0);
 403  1 Assert.assertEquals("org.jboss.cache.loader.FileCacheLoader", icfg.getClassName());
 404  1 Assert.assertTrue("Async shld be false", !icfg.isAsync());
 405  1 Assert.assertTrue("fetchPersistentState shld be false", !icfg.isFetchPersistentState());
 406  1 Assert.assertTrue("IgnoreMods should be true", icfg.isIgnoreModifications());
 407  1 Assert.assertEquals(1, icfg.getProperties().size());
 408   
 409  1 icfg = c.getIndividualCacheLoaderConfigs().get(1);
 410  1 Assert.assertEquals("org.jboss.cache.loader.JDBCCacheLoader", icfg.getClassName());
 411  1 Assert.assertTrue("Async shld be true", icfg.isAsync());
 412  1 Assert.assertTrue("fetchPersistentState shld be true", icfg.isFetchPersistentState());
 413  1 Assert.assertTrue("IgnoreMods should be false", !icfg.isIgnoreModifications());
 414  1 Assert.assertEquals(4, icfg.getProperties().size());
 415   
 416    // fetch PersistentState shld be false now
 417  1 conf = "<config>" +
 418    "<passivation>false</passivation>" +
 419    "<preload>/, /blah, /blah2</preload>" +
 420    "<cacheloader>" +
 421    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 422    " <async>false</async>" +
 423    " <fetchPersistentState>false</fetchPersistentState>" +
 424    " <ignoreModifications>true</ignoreModifications>" +
 425    " <properties>" +
 426    " location=" + getTempDir() +
 427    " </properties>" +
 428    "</cacheloader>" +
 429    "<cacheloader>" +
 430    " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" +
 431    " <async>true</async>" +
 432    " <fetchPersistentState>false</fetchPersistentState>" +
 433    " <ignoreModifications>false</ignoreModifications>" +
 434    " <properties>" +
 435    "cache.jdbc.driver=com.mysql.jdbc.Driver\ncache.jdbc.url=jdbc:mysql://localhost/test\ncache.jdbc.user=user\ncache.jdbc.password=pwd" +
 436    " </properties>" +
 437    "</cacheloader></config>";
 438  1 clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 439   
 440  1 mgr = new CacheLoaderManager();
 441  1 mgr.setConfig(clc, null);
 442   
 443  1 Assert.assertTrue("Should be false", !mgr.isFetchPersistentState());
 444   
 445   
 446    }
 447   
 448  1 public void testSingletonConfiguration() throws Exception
 449    {
 450  1 String conf = "<config>" +
 451    "<passivation>false</passivation>" +
 452    "<preload>/, /blah, /blah2</preload>" +
 453    "<cacheloader>" +
 454    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 455    " <async>false</async>" +
 456    " <fetchPersistentState>false</fetchPersistentState>" +
 457    " <ignoreModifications>true</ignoreModifications>" +
 458    " <properties>" +
 459    " location=" + getTempDir() +
 460    " </properties>" +
 461    "</cacheloader>" +
 462    "</config>";
 463  1 CacheLoaderConfig clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 464  1 CacheLoaderManager mgr = new CacheLoaderManager();
 465  1 mgr.setConfig(clc, null);
 466   
 467  1 CacheLoaderConfig.IndividualCacheLoaderConfig iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
 468  1 assertFalse("Singleton has not been configured", iclc.isSingletonStore());
 469  1 assertFalse("Singleton.pushStateWhenCoordinator has not been configured", iclc.isPushStateWhenCoordinator());
 470   
 471  1 conf = "<config>" +
 472    "<passivation>false</passivation>" +
 473    "<preload>/, /blah, /blah2</preload>" +
 474    "<cacheloader>" +
 475    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 476    " <async>false</async>" +
 477    " <fetchPersistentState>false</fetchPersistentState>" +
 478    " <ignoreModifications>true</ignoreModifications>" +
 479    " <properties>" +
 480    " location=" + getTempDir() +
 481    " </properties>" +
 482    " <singletonStore>true</singletonStore>" +
 483    "</cacheloader>" +
 484    "</config>";
 485  1 clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 486  1 mgr = new MockCacheLoaderManager();
 487  1 mgr.setConfig(clc, null);
 488   
 489  1 iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
 490  1 assertTrue("Singleton has been configured", iclc.isSingletonStore());
 491  1 assertFalse("Singleton.pushStateWhenCoordinator has not been configured", iclc.isPushStateWhenCoordinator());
 492   
 493  1 conf = "<config>" +
 494    "<passivation>false</passivation>" +
 495    "<preload>/, /blah, /blah2</preload>" +
 496    "<cacheloader>" +
 497    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 498    " <async>false</async>" +
 499    " <fetchPersistentState>false</fetchPersistentState>" +
 500    " <ignoreModifications>true</ignoreModifications>" +
 501    " <properties>" +
 502    " location=" + getTempDir() +
 503    " </properties>" +
 504    " <singletonStore>false</singletonStore>" +
 505    "</cacheloader>" +
 506    "</config>";
 507  1 clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 508  1 mgr = new CacheLoaderManager();
 509  1 mgr.setConfig(clc, null);
 510   
 511  1 iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
 512  1 assertFalse("Singleton has not been configured", iclc.isSingletonStore());
 513  1 assertFalse("Singleton.pushStateWhenCoordinator has not been configured", iclc.isPushStateWhenCoordinator());
 514   
 515  1 conf = "<config>" +
 516    "<passivation>false</passivation>" +
 517    "<preload>/, /blah, /blah2</preload>" +
 518    "<cacheloader>" +
 519    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 520    " <async>false</async>" +
 521    " <fetchPersistentState>false</fetchPersistentState>" +
 522    " <ignoreModifications>true</ignoreModifications>" +
 523    " <properties>" +
 524    " location=" + getTempDir() +
 525    " </properties>" +
 526    " <singletonStore pushStateWhenCoordinator=\"false\">true</singletonStore>" +
 527    "</cacheloader>" +
 528    "</config>";
 529  1 clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 530  1 mgr = new MockCacheLoaderManager();
 531  1 mgr.setConfig(clc, null);
 532   
 533  1 iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
 534  1 assertTrue("Singleton has been configured", iclc.isSingletonStore());
 535  1 assertFalse("Singleton.pushStateWhenCoordinator has not been configured", iclc.isPushStateWhenCoordinator());
 536   
 537  1 conf = "<config>" +
 538    "<passivation>false</passivation>" +
 539    "<preload>/, /blah, /blah2</preload>" +
 540    "<cacheloader>" +
 541    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 542    " <async>false</async>" +
 543    " <fetchPersistentState>false</fetchPersistentState>" +
 544    " <ignoreModifications>true</ignoreModifications>" +
 545    " <properties>" +
 546    " location=" + getTempDir() +
 547    " </properties>" +
 548    " <singletonStore pushStateWhenCoordinator=\"false\">false</singletonStore>" +
 549    "</cacheloader>" +
 550    "</config>";
 551  1 clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 552  1 mgr = new CacheLoaderManager();
 553  1 mgr.setConfig(clc, null);
 554   
 555  1 iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
 556  1 assertFalse("Singleton has not been configured", iclc.isSingletonStore());
 557  1 assertFalse("Singleton.pushStateWhenCoordinator has not been configured", iclc.isPushStateWhenCoordinator());
 558   
 559  1 conf = "<config>" +
 560    "<passivation>false</passivation>" +
 561    "<preload>/, /blah, /blah2</preload>" +
 562    "<cacheloader>" +
 563    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 564    " <async>false</async>" +
 565    " <fetchPersistentState>false</fetchPersistentState>" +
 566    " <ignoreModifications>true</ignoreModifications>" +
 567    " <properties>" +
 568    " location=" + getTempDir() +
 569    " </properties>" +
 570    " <singletonStore pushStateWhenCoordinator=\"true\">false</singletonStore>" +
 571    "</cacheloader>" +
 572    "</config>";
 573  1 clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 574  1 mgr = new CacheLoaderManager();
 575  1 mgr.setConfig(clc, null);
 576   
 577  1 iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
 578  1 assertFalse("Singleton has not been configured", iclc.isSingletonStore());
 579  1 assertFalse("Singleton.pushStateWhenCoordinator should be false has not been configured", iclc.isPushStateWhenCoordinator());
 580   
 581  1 conf = "<config>" +
 582    "<passivation>false</passivation>" +
 583    "<preload>/, /blah, /blah2</preload>" +
 584    "<cacheloader>" +
 585    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 586    " <async>false</async>" +
 587    " <fetchPersistentState>false</fetchPersistentState>" +
 588    " <ignoreModifications>true</ignoreModifications>" +
 589    " <properties>" +
 590    " location=" + getTempDir() +
 591    " </properties>" +
 592    " <singletonStore pushStateWhenCoordinator=\"true\">true</singletonStore>" +
 593    "</cacheloader>" +
 594    "</config>";
 595  1 clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 596  1 mgr = new MockCacheLoaderManager();
 597  1 mgr.setConfig(clc, null);
 598   
 599  1 iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
 600  1 assertTrue("Singleton has been configured", iclc.isSingletonStore());
 601  1 assertTrue("Singleton.pushStateWhenCoordinator has been configured", iclc.isPushStateWhenCoordinator());
 602   
 603  1 conf = "<config>" +
 604    "<passivation>false</passivation>" +
 605    "<shared>true</shared>" +
 606    "<preload>/, /blah, /blah2</preload>" +
 607    "<cacheloader>" +
 608    " <class>org.jboss.cache.loader.FileCacheLoader</class>" +
 609    " <async>false</async>" +
 610    " <fetchPersistentState>false</fetchPersistentState>" +
 611    " <ignoreModifications>true</ignoreModifications>" +
 612    " <properties>" +
 613    " location=" + getTempDir() +
 614    " </properties>" +
 615    " <singletonStore pushStateWhenCoordinator=\"true\">true</singletonStore>" +
 616    "</cacheloader>" +
 617    "</config>";
 618  1 clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
 619  1 mgr = new CacheLoaderManager();
 620  1 try
 621    {
 622  1 mgr.setConfig(clc, null);
 623  0 fail("A cache loader cannot be configured as singleton and shared, should have thrown an Exception");
 624    }
 625    catch (Exception e)
 626    {
 627    }
 628    }
 629   
 630    private class MockCacheLoaderManager extends CacheLoaderManager
 631    {
 632  3 protected void addCacheListener(Cache cache, Object listener)
 633    {
 634    /* do nothing... */
 635    }
 636    }
 637   
 638  1 public static Test suite()
 639    {
 640  1 return new TestSuite(CacheLoaderManagerTest.class);
 641    }
 642   
 643  0 public static void main(String[] args)
 644    {
 645  0 junit.textui.TestRunner.run(suite());
 646    }
 647    }