Refine search
/** * Testing putIfAbsent's behaviour on a Local cache. */ public void testonInfinispanLocal() throws Exception { System.out.println("Running test on Infinispan, LOCAL:"); EmbeddedCacheManager cm = TestCacheManagerFactory.createCacheManager(false); ConcurrentMap<String, String> map = cm.getCache(); try { testConcurrentLocking(map); } finally { TestingUtil.killCacheManagers(cm); } }
public void testConfigWarnings() throws Exception { for (String aConfFile : getConfigFileNames()) { log.tracef("Analysing %s", aConfFile); EmbeddedCacheManager dcm = null; try { dcm = TestCacheManagerFactory.fromXml(getRootFolder() + File.separator + aConfFile, false, true); if (dcm.getDefaultCacheConfiguration() != null) dcm.getCache(); assert !appender.isFoundUnknownWarning() : String.format( "Unknown warning discovered in file %s: %s", aConfFile, appender.unknownWarning()); for (String cacheName : dcm.getCacheNames()) { dcm.getCache(cacheName); assert !appender.isFoundUnknownWarning(); } } catch (Exception e) { throw new Exception("Could not parse '"+aConfFile+"'", e); } finally { TestingUtil.killCacheManagers(dcm); } } }
@Override public void call() { EmbeddedCacheManager cm1 = cms[0]; EmbeddedCacheManager cm2 = cms[1]; TestingUtil.waitForNoRebalance(cm1.getCache(), cm2.getCache()); Cache<Object, Object> c1 = cm1.getCache(); GlobalConfiguration globalCfg = cm1.getCacheManagerConfiguration(); Configuration cfg = c1.getCacheConfiguration(); TestingUtil.killCacheManagers(cm1); globalCfg = new GlobalConfigurationBuilder().read(globalCfg).build(); withCacheManager(new CacheManagerCallable( new DefaultCacheManager(globalCfg, cfg)) { @Override public void call() { Cache<Object, Object> c = cm.getCache(); c.put(1, "v1"); assertEquals("v1", c.get(1)); } }); } });
@Override public void call() throws Exception { cm.getCache(); ObjectName cacheObjectName = getCacheObjectName(jmxDomain); assertTrue(cacheObjectName + " should be registered", server.isRegistered(cacheObjectName)); TestingUtil.killCacheManagers(cm); assertFalse(cacheObjectName + " should NOT be registered", server.isRegistered(cacheObjectName)); } });
public void testUnregisterJmxInfoOnStop() throws Exception { GlobalConfigurationBuilder globalConfiguration = GlobalConfigurationBuilder.defaultClusteredBuilder(); globalConfiguration.globalJmxStatistics().enable().mBeanServerLookup(new PerThreadMBeanServerLookup()); cm = TestCacheManagerFactory.createClusteredCacheManager(globalConfiguration, new ConfigurationBuilder()); String jmxDomain = cm.getCacheManagerConfiguration().globalJmxStatistics().domain(); ConfigurationBuilder localCache = config();//local by default localCache.jmxStatistics().enable(); cm.defineConfiguration("local_cache", localCache.build()); cm.getCache("local_cache"); assert existsObject(getCacheObjectName(jmxDomain, "local_cache(local)", "Statistics")); TestingUtil.killCacheManagers(cm); assert !existsObject(getCacheObjectName(jmxDomain, "local_cache(local)", "Statistics")); assert !existsDomains(jmxDomain); }
public void testImproperLocalExecutorServiceForDistributedExecutor() { EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createCacheManager(false); try { Cache<Object, Object> cache = cacheManager.getCache(); expectException(IllegalArgumentException.class, () -> new DefaultExecutorService(cache, null)); } finally { TestingUtil.killCacheManagers(cacheManager); } }
@Test(expectedExceptions = IllegalLifecycleStateException.class) public void testCacheStopManagerStopFollowedByGetCache() { EmbeddedCacheManager localCacheManager = createCacheManager(false); try { Cache<String, String> cache = localCacheManager.getCache(); cache.put("k", "v"); cache.stop(); localCacheManager.stop(); localCacheManager.getCache(); } finally { TestingUtil.killCacheManagers(localCacheManager); } }
public void brokenJGroupsConfigTest() throws Throwable { String config = "<infinispan>\n" + "<jgroups>\n" + " <stack-file name=\"dummy\" path=\"stacks/broken-tcp.xml\"/>\n" + "</jgroups>\n" + "<cache-container default-cache=\"default\">" + " <jmx domain=\"NonExistingJGroupsConfigTest_brokenJGroupsConfigTest\" />\n" + " <transport stack=\"dummy\" cluster=\"demoCluster\" />\n" + " <replicated-cache name=\"default\" />\n" + "</cache-container>\n" + "</infinispan>"; EmbeddedCacheManager cm = null; try { cm = new DefaultCacheManager(new ByteArrayInputStream(config.getBytes())); cm.getCache(); fail("CacheManager construction should have failed"); } catch (Exception e) { TestingUtil.expectCause(e, CacheConfigurationException.class, "ISPN000085:.*"); } finally { TestingUtil.killCacheManagers(cm); } } }
public void testDistributedAndNoTwoWay() { EmbeddedCacheManager cm1; ConfigurationBuilder conf = NonStringKeyPreloadTest.createCacheStoreConfig(TwoWayPersonKey2StringMapper.class.getName(), false, false); conf.clustering().cacheMode(CacheMode.DIST_SYNC); cm1 = TestCacheManagerFactory.createClusteredCacheManager(conf); try { cm1.getCache(); } finally { TestingUtil.killCacheManagers(cm1); } } }
@Test public void testDefault() throws IOException { String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + "<infinispan>" + "<cache-container name=\"1\" default-cache=\"default-cache\">" + "<local-cache name=\"default-cache\" />" + "</cache-container>" + "</infinispan>"; InputStream stream = new ByteArrayInputStream(xml.getBytes()); EmbeddedCacheManager cm = TestCacheManagerFactory.fromStream(stream); try { // Verify that the configuration is correct Assert.assertNull(cm.getDefaultCacheConfiguration().dataContainer().dataContainer()); Assert.assertEquals(cm.getCache().getAdvancedCache().getDataContainer().getClass(), DefaultDataContainer.class); } finally { TestingUtil.killCacheManagers(cm); } }
public void testCacheStopTwice() { EmbeddedCacheManager localCacheManager = createCacheManager(false); try { Cache<String, String> cache = localCacheManager.getCache(); cache.put("k", "v"); cache.stop(); cache.stop(); } finally { TestingUtil.killCacheManagers(localCacheManager); } }
public void testCacheManagerStopTwice() { EmbeddedCacheManager localCacheManager = createCacheManager(false); try { Cache<String, String> cache = localCacheManager.getCache(); cache.put("k", "v"); localCacheManager.stop(); localCacheManager.stop(); } finally { TestingUtil.killCacheManagers(localCacheManager); } }
@Test(expectedExceptions = IllegalLifecycleStateException.class) public void testCacheStopManagerStopFollowedByCacheOp() { EmbeddedCacheManager localCacheManager = createCacheManager(false); try { Cache<String, String> cache = localCacheManager.getCache(); cache.put("k", "v"); cache.stop(); localCacheManager.stop(); cache.put("k", "v2"); } finally { TestingUtil.killCacheManagers(localCacheManager); } }
public void testGetMembers() throws Exception { cm1.getCache("cache"); // this will make sure any lazy components are started. List memb1 = cm1.getMembers(); assert 1 == memb1.size() : "Expected 1 member; was " + memb1; Object coord = memb1.get(0); cm2 = addClusterEnabledCacheManager(); cm2.defineConfiguration("cache", cfg.build()); cm2.getCache("cache"); // this will make sure any lazy components are started. TestingUtil.blockUntilViewsReceived(50000, true, cm1, cm2); memb1 = cm1.getMembers(); List memb2 = cm2.getMembers(); assert 2 == memb1.size(); assert memb1.equals(memb2); TestingUtil.killCacheManagers(cm1); TestingUtil.blockUntilViewsReceived(50000, false, cm2); memb2 = cm2.getMembers(); assert 1 == memb2.size(); assert !coord.equals(memb2.get(0)); }
public void testViewChange() throws Exception { EmbeddedCacheManager cmA = TestCacheManagerFactory.createClusteredCacheManager(); CacheContainer cmB = null; try { cmA.getCache(); GetCacheManagerCheckListener listener = new GetCacheManagerCheckListener(); cmA.addListener(listener); cmB = TestCacheManagerFactory.createClusteredCacheManager(); cmB.getCache(); assertNotNull(listener.firstEvent.get(10, TimeUnit.SECONDS)); } finally { TestingUtil.killCacheManagers(cmA, cmB); } }
private void failIfStoreAsBinaryEnabled(ConfigurationBuilder configuration) { EmbeddedCacheManager cacheManager = null; try { cacheManager = TestCacheManagerFactory.createCacheManager(configuration); cacheManager.defineConfiguration(CACHE_NAME, configuration.build()); Cache cache = cacheManager.getCache(CACHE_NAME); DirectoryBuilder.newDirectoryInstance(cache, cache, cache, INDEX_NAME).create(); } finally { if (cacheManager != null) { TestingUtil.killCacheManagers(cacheManager); } } }
private void doConfigurationTest(ConfigurationBuilder configuration) { EmbeddedCacheManager cacheManager = null; try { cacheManager = TestCacheManagerFactory.createCacheManager(configuration); cacheManager.defineConfiguration(CACHE_NAME, configuration.build()); Cache cache = cacheManager.getCache(CACHE_NAME); DirectoryBuilder.newDirectoryInstance(cache, cache, cache, INDEX_NAME).create(); } finally { if (cacheManager != null) { TestingUtil.killCacheManagers(cacheManager); } } }
public void testLockRelease() { final EmbeddedCacheManager cm1 = manager(0); final EmbeddedCacheManager cm2 = manager(1); Thread t1 = new Thread(new CounterTask(cm1)); Thread t2 = new Thread(new CounterTask(cm2)); t1.start(); t2.start(); sleepThread(1000); t2.interrupt(); TestingUtil.killCacheManagers(cm2); cacheManagers.remove(1); sleepThread(1100); t1.interrupt(); LockManager lm = TestingUtil.extractComponent(cm1.getCache(), LockManager.class); Object owner = lm.getOwner(key); assert ownerIsLocalOrUnlocked(owner, cm1.getAddress()) : "Bad lock owner " + owner; }
public void testPutWithNonExistentCache() { EmbeddedCacheManager cm1 = null, cm2 = null; try { cm1 = createCacheManager(); cm2 = createCacheManager(); cm1.getCache(); cm2.getCache(); cm1.getCache().put("k", "v"); assertEquals("v", cm1.getCache().get("k")); assertEquals("v", cm2.getCache().get("k")); cm1.defineConfiguration("newCache", cm1.getDefaultCacheConfiguration()); cm1.getCache("newCache").put("k", "v"); assertEquals("v", cm1.getCache("newCache").get("k")); } finally { TestingUtil.killCacheManagers(cm1, cm2); } }
public void testDefaultCache() { EmbeddedCacheManager cm = createCacheManager(false); try { assertEquals(ComponentStatus.RUNNING, cm.getCache().getStatus()); assertTrue(cm.getCache().getName().equals(CacheContainer.DEFAULT_CACHE_NAME)); expectException(IllegalArgumentException.class, () -> cm.defineConfiguration(CacheContainer.DEFAULT_CACHE_NAME, new ConfigurationBuilder().build())); } finally { TestingUtil.killCacheManagers(cm); } }