CacheConfigTest.java

/*
 * Copyright (c) 2008-2017, Hazelcast, Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.hazelcast.config;

import com.hazelcast.cache.HazelcastCacheManager;
import com.hazelcast.cache.HazelcastCachingProvider;
import com.hazelcast.cache.impl.HazelcastServerCachingProvider;
import com.hazelcast.cache.impl.ICacheService;
import com.hazelcast.config.CacheSimpleConfig.ExpiryPolicyFactoryConfig;
import com.hazelcast.config.CacheSimpleConfig.ExpiryPolicyFactoryConfig.DurationConfig;
import com.hazelcast.config.CacheSimpleConfig.ExpiryPolicyFactoryConfig.TimedExpiryPolicyFactoryConfig;
import com.hazelcast.config.CacheSimpleConfig.ExpiryPolicyFactoryConfig.TimedExpiryPolicyFactoryConfig.ExpiryPolicyType;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.instance.HazelcastInstanceFactory;
import com.hazelcast.instance.Node;
import com.hazelcast.instance.TestUtil;
import com.hazelcast.spi.NodeEngine;
import com.hazelcast.test.AssertTask;
import com.hazelcast.test.HazelcastSerialClassRunner;
import com.hazelcast.test.HazelcastTestSupport;
import com.hazelcast.test.TestHazelcastInstanceFactory;
import com.hazelcast.test.annotation.QuickTest;
import com.hazelcast.util.EmptyStatement;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;

import javax.cache.Cache;
import javax.cache.CacheManager;
import javax.cache.Caching;
import javax.cache.configuration.Configuration;
import javax.cache.configuration.Factory;
import javax.cache.event.CacheEntryCreatedListener;
import javax.cache.event.CacheEntryListenerException;
import javax.cache.integration.CacheLoader;
import javax.cache.integration.CacheLoaderException;
import javax.cache.integration.CacheWriter;
import javax.cache.integration.CacheWriterException;
import javax.cache.spi.CachingProvider;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

@RunWith(HazelcastSerialClassRunner.class)
@Category(QuickTest.class)
public class CacheConfigTest extends HazelcastTestSupport {

    private final URL configUrl1 = getClass().getClassLoader().getResource("test-hazelcast-jcache.xml");
    private final URL configUrl2 = getClass().getClassLoader().getResource("test-hazelcast-jcache2.xml");

    @Before
    @After
    public void cleanup() {
        HazelcastInstanceFactory.terminateAll();
        Caching.getCachingProvider().close();
    }

    @Test
    public void testCacheConfigLoaderWriterXml() throws Exception {
        Config config = new XmlConfigBuilder(configUrl2).build();

        CacheSimpleConfig simpleConfig = config.getCacheConfig("cache3");
        CacheConfig<Object, String> cacheConfig = new CacheConfig<Object, String>(simpleConfig);

        Factory<CacheWriter<? super Object, ? super String>> writerFactory = cacheConfig.getCacheWriterFactory();
        CacheWriter<? super Object, ? super String> cacheWriter = writerFactory.create();
        assertTrue(cacheWriter instanceof EmptyCacheWriter);

        Factory<CacheLoader<Object, String>> loaderFactory = cacheConfig.getCacheLoaderFactory();
        CacheLoader<Object, String> cacheLoader = loaderFactory.create();
        assertTrue(cacheLoader instanceof MyCacheLoader);
    }

    @Test
    public void testCacheConfigLoaderWriter() throws Exception {
        CacheSimpleConfig simpleConfig = new CacheSimpleConfig();
        simpleConfig.setCacheLoader(MyCacheLoader.class.getName());
        simpleConfig.setCacheWriter(EmptyCacheWriter.class.getName());

        CacheConfig cacheConfig = new CacheConfig(simpleConfig);

        CacheLoader loader = (CacheLoader) cacheConfig.getCacheLoaderFactory().create();
        CacheWriter writer = (CacheWriter) cacheConfig.getCacheWriterFactory().create();

        assertTrue(loader instanceof MyCacheLoader);
        assertTrue(writer instanceof EmptyCacheWriter);
    }

    @Test
    public void cacheConfigXmlTest() throws IOException {
        Config config1 = new XmlConfigBuilder(configUrl1).build();

        assertEquals("test-group1", config1.getGroupConfig().getName());
        assertEquals("test-pass1", config1.getGroupConfig().getPassword());

        CacheSimpleConfig cacheConfig1 = config1.getCacheConfig("cache1");
        assertEquals("com.hazelcast.config.CacheConfigTest$MyCacheLoaderFactory",
                cacheConfig1.getCacheLoaderFactory());
        assertEquals("com.hazelcast.config.CacheConfigTest$MyCacheWriterFactory",
                cacheConfig1.getCacheWriterFactory());
        assertEquals("com.hazelcast.config.CacheConfigTest$MyExpirePolicyFactory",
                cacheConfig1.getExpiryPolicyFactoryConfig().getClassName());
        assertTrue(cacheConfig1.isReadThrough());
        assertTrue(cacheConfig1.isWriteThrough());
        assertTrue(cacheConfig1.isStatisticsEnabled());
        assertTrue(cacheConfig1.isManagementEnabled());

        EvictionConfig evictionConfig = cacheConfig1.getEvictionConfig();
        assertNotNull(evictionConfig);
        assertEquals(EvictionPolicy.LFU, evictionConfig.getEvictionPolicy());
        assertEquals(50, evictionConfig.getSize());
        assertEquals(EvictionConfig.MaxSizePolicy.ENTRY_COUNT, evictionConfig.getMaximumSizePolicy());

        List<CacheSimpleEntryListenerConfig> cacheEntryListeners = cacheConfig1.getCacheEntryListeners();
        assertEquals(2, cacheEntryListeners.size());

        CacheSimpleEntryListenerConfig listenerConfig0 = cacheEntryListeners.get(0);
        assertFalse(listenerConfig0.isSynchronous());
        assertFalse(listenerConfig0.isOldValueRequired());
        assertEquals("com.hazelcast.config.CacheConfigTest$MyEntryListenerFactory",
                listenerConfig0.getCacheEntryListenerFactory());
        assertEquals("com.hazelcast.config.CacheConfigTest$MyEntryEventFilterFactory",
                listenerConfig0.getCacheEntryEventFilterFactory());

        CacheSimpleEntryListenerConfig listenerConfig1 = cacheEntryListeners.get(1);
        assertTrue(listenerConfig1.isSynchronous());
        assertTrue(listenerConfig1.isOldValueRequired());
        assertEquals("com.hazelcast.config.CacheConfigTest$MySyncEntryListenerFactory",
                listenerConfig1.getCacheEntryListenerFactory());
        assertEquals("com.hazelcast.config.CacheConfigTest$MySyncEntryEventFilterFactory",
                listenerConfig1.getCacheEntryEventFilterFactory());

        WanReplicationRef wanRefCacheConfig = config1.getCacheConfig("wanRefTestCache").getWanReplicationRef();
        assertEquals("testWanRef", wanRefCacheConfig.getName());
        assertEquals("TestMergePolicy", wanRefCacheConfig.getMergePolicy());
        assertTrue(wanRefCacheConfig.isRepublishingEnabled());

        WanReplicationRef wanRefDisabledRepublishingTestCache =
                config1.getCacheConfig("wanRefDisabledRepublishingTestCache").getWanReplicationRef();
        assertFalse(wanRefDisabledRepublishingTestCache.isRepublishingEnabled());

        assertTrue(cacheConfig1.isDisablePerEntryInvalidationEvents());
    }

    @Test
    public void cacheConfigXmlTest_CustomEvictionPolicyComparator() throws IOException {
        Config config = new XmlConfigBuilder(configUrl1).build();

        CacheSimpleConfig cacheConfig = config.getCacheConfig("cacheWithCustomEvictionPolicyComparator");
        assertNotNull(cacheConfig);

        EvictionConfig evictionConfig = cacheConfig.getEvictionConfig();
        assertNotNull(evictionConfig);
        assertEquals(50, evictionConfig.getSize());
        assertEquals(EvictionConfig.MaxSizePolicy.ENTRY_COUNT, evictionConfig.getMaximumSizePolicy());
        assertEquals("my-custom-eviction-policy-comparator", evictionConfig.getComparatorClassName());
    }

    @Test
    public void cacheConfigXmlTest_TimedCreatedExpiryPolicyFactory() throws IOException {
        Config config1 = new XmlConfigBuilder(configUrl1).build();

        CacheSimpleConfig cacheWithTimedCreatedExpiryPolicyFactoryConfig =
                config1.getCacheConfig("cacheWithTimedCreatedExpiryPolicyFactory");
        ExpiryPolicyFactoryConfig expiryPolicyFactoryConfig =
                cacheWithTimedCreatedExpiryPolicyFactoryConfig.getExpiryPolicyFactoryConfig();
        TimedExpiryPolicyFactoryConfig timedExpiryPolicyFactoryConfig =
                expiryPolicyFactoryConfig.getTimedExpiryPolicyFactoryConfig();
        DurationConfig durationConfig = timedExpiryPolicyFactoryConfig.getDurationConfig();

        assertNotNull(expiryPolicyFactoryConfig);
        assertNotNull(timedExpiryPolicyFactoryConfig);
        assertNotNull(durationConfig);
        assertNull(expiryPolicyFactoryConfig.getClassName());

        assertEquals(ExpiryPolicyType.CREATED, timedExpiryPolicyFactoryConfig.getExpiryPolicyType());
        assertEquals(1, durationConfig.getDurationAmount());
        assertEquals(TimeUnit.DAYS, durationConfig.getTimeUnit());
    }

    @Test
    public void cacheConfigXmlTest_TimedAccessedExpiryPolicyFactory() throws IOException {
        Config config1 = new XmlConfigBuilder(configUrl1).build();

        CacheSimpleConfig cacheWithTimedAccessedExpiryPolicyFactoryConfig =
                config1.getCacheConfig("cacheWithTimedAccessedExpiryPolicyFactory");
        ExpiryPolicyFactoryConfig expiryPolicyFactoryConfig =
                cacheWithTimedAccessedExpiryPolicyFactoryConfig.getExpiryPolicyFactoryConfig();
        TimedExpiryPolicyFactoryConfig timedExpiryPolicyFactoryConfig =
                expiryPolicyFactoryConfig.getTimedExpiryPolicyFactoryConfig();
        DurationConfig durationConfig = timedExpiryPolicyFactoryConfig.getDurationConfig();

        assertNotNull(expiryPolicyFactoryConfig);
        assertNotNull(timedExpiryPolicyFactoryConfig);
        assertNotNull(durationConfig);
        assertNull(expiryPolicyFactoryConfig.getClassName());

        assertEquals(ExpiryPolicyType.ACCESSED, timedExpiryPolicyFactoryConfig.getExpiryPolicyType());
        assertEquals(2, durationConfig.getDurationAmount());
        assertEquals(TimeUnit.HOURS, durationConfig.getTimeUnit());
    }

    @Test
    public void cacheConfigXmlTest_TimedModifiedExpiryPolicyFactory() throws IOException {
        Config config1 = new XmlConfigBuilder(configUrl1).build();

        CacheSimpleConfig cacheWithTimedModifiedExpiryPolicyFactoryConfig =
                config1.getCacheConfig("cacheWithTimedModifiedExpiryPolicyFactory");
        ExpiryPolicyFactoryConfig expiryPolicyFactoryConfig =
                cacheWithTimedModifiedExpiryPolicyFactoryConfig.getExpiryPolicyFactoryConfig();
        TimedExpiryPolicyFactoryConfig timedExpiryPolicyFactoryConfig =
                expiryPolicyFactoryConfig.getTimedExpiryPolicyFactoryConfig();
        DurationConfig durationConfig = timedExpiryPolicyFactoryConfig.getDurationConfig();

        assertNotNull(expiryPolicyFactoryConfig);
        assertNotNull(timedExpiryPolicyFactoryConfig);
        assertNotNull(durationConfig);
        assertNull(expiryPolicyFactoryConfig.getClassName());

        assertEquals(ExpiryPolicyType.MODIFIED, timedExpiryPolicyFactoryConfig.getExpiryPolicyType());
        assertEquals(3, durationConfig.getDurationAmount());
        assertEquals(TimeUnit.MINUTES, durationConfig.getTimeUnit());
    }

    @Test
    public void cacheConfigXmlTest_TimedModifiedTouchedPolicyFactory() throws IOException {
        Config config1 = new XmlConfigBuilder(configUrl1).build();

        CacheSimpleConfig cacheWithTimedTouchedExpiryPolicyFactoryConfig =
                config1.getCacheConfig("cacheWithTimedTouchedExpiryPolicyFactory");
        ExpiryPolicyFactoryConfig expiryPolicyFactoryConfig =
                cacheWithTimedTouchedExpiryPolicyFactoryConfig.getExpiryPolicyFactoryConfig();
        TimedExpiryPolicyFactoryConfig timedExpiryPolicyFactoryConfig =
                expiryPolicyFactoryConfig.getTimedExpiryPolicyFactoryConfig();
        DurationConfig durationConfig = timedExpiryPolicyFactoryConfig.getDurationConfig();

        assertNotNull(expiryPolicyFactoryConfig);
        assertNotNull(timedExpiryPolicyFactoryConfig);
        assertNotNull(durationConfig);
        assertNull(expiryPolicyFactoryConfig.getClassName());

        assertEquals(ExpiryPolicyType.TOUCHED, timedExpiryPolicyFactoryConfig.getExpiryPolicyType());
        assertEquals(4, durationConfig.getDurationAmount());
        assertEquals(TimeUnit.SECONDS, durationConfig.getTimeUnit());
    }

    @Test
    public void cacheConfigXmlTest_TimedEternalTouchedPolicyFactory() throws IOException {
        Config config1 = new XmlConfigBuilder(configUrl1).build();

        CacheSimpleConfig cacheWithTimedEternalExpiryPolicyFactoryConfig =
                config1.getCacheConfig("cacheWithTimedEternalExpiryPolicyFactory");
        ExpiryPolicyFactoryConfig expiryPolicyFactoryConfig =
                cacheWithTimedEternalExpiryPolicyFactoryConfig.getExpiryPolicyFactoryConfig();
        TimedExpiryPolicyFactoryConfig timedExpiryPolicyFactoryConfig =
                expiryPolicyFactoryConfig.getTimedExpiryPolicyFactoryConfig();
        DurationConfig durationConfig = timedExpiryPolicyFactoryConfig.getDurationConfig();

        assertNotNull(expiryPolicyFactoryConfig);
        assertNotNull(timedExpiryPolicyFactoryConfig);
        assertNull(durationConfig);
        assertNull(expiryPolicyFactoryConfig.getClassName());

        assertEquals(ExpiryPolicyType.ETERNAL, timedExpiryPolicyFactoryConfig.getExpiryPolicyType());
    }

    @Test
    public void cacheConfigXmlTest_DefaultMergePolicy() throws IOException {
        Config config = new XmlConfigBuilder(configUrl1).build();

        CacheSimpleConfig cacheWithDefaultMergePolicyConfig = config.getCacheConfig("cacheWithDefaultMergePolicy");

        assertNotNull(cacheWithDefaultMergePolicyConfig);
        assertEquals(CacheSimpleConfig.DEFAULT_CACHE_MERGE_POLICY, cacheWithDefaultMergePolicyConfig.getMergePolicy());
    }

    @Test
    public void cacheConfigXmlTest_CustomMergePolicy() throws IOException {
        Config config = new XmlConfigBuilder(configUrl1).build();

        CacheSimpleConfig cacheWithCustomMergePolicyConfig = config.getCacheConfig("cacheWithCustomMergePolicy");

        assertNotNull(cacheWithCustomMergePolicyConfig);
        assertEquals("MyDummyMergePolicy", cacheWithCustomMergePolicyConfig.getMergePolicy());
    }

    @Test
    public void cacheConfigXmlTest_constructingToCacheConfig() throws Exception {
        Config config1 = new XmlConfigBuilder(configUrl1).build();

        assertEquals("test-group1", config1.getGroupConfig().getName());
        assertEquals("test-pass1", config1.getGroupConfig().getPassword());

        CacheSimpleConfig cacheSimpleConfig1 = config1.getCacheConfig("cache1");
        CacheConfig cacheConfig1 = new CacheConfig(cacheSimpleConfig1);
        assertTrue(cacheConfig1.getCacheLoaderFactory() instanceof MyCacheLoaderFactory);
        assertTrue(cacheConfig1.getCacheWriterFactory() instanceof MyCacheWriterFactory);
        assertTrue(cacheConfig1.getExpiryPolicyFactory() instanceof MyExpirePolicyFactory);
        assertTrue(cacheConfig1.isReadThrough());
        assertTrue(cacheConfig1.isWriteThrough());
        assertTrue(cacheConfig1.isStatisticsEnabled());
        assertTrue(cacheConfig1.isManagementEnabled());

        assertNotNull(cacheConfig1.getEvictionConfig());
        assertEquals(50, cacheConfig1.getEvictionConfig().getSize());
        assertEquals(EvictionConfig.MaxSizePolicy.ENTRY_COUNT, cacheConfig1.getEvictionConfig().getMaximumSizePolicy());
        assertEquals(EvictionPolicy.LFU, cacheConfig1.getEvictionConfig().getEvictionPolicy());

        assertTrue(cacheConfig1.isDisablePerEntryInvalidationEvents());
    }

    @Test
    public void cacheManagerByLocationClasspathTest() throws URISyntaxException {
        URI uri1 = new URI("MY-SCOPE");
        Properties properties = new Properties();
        properties.setProperty(HazelcastCachingProvider.HAZELCAST_CONFIG_LOCATION,
                "classpath:test-hazelcast-jcache.xml");
        CacheManager cacheManager = Caching.getCachingProvider().getCacheManager(uri1, null, properties);
        assertNotNull(cacheManager);

        Cache<Integer, String> testCache = cacheManager.getCache("testCache", Integer.class, String.class);
        assertNotNull(testCache);
    }

    @Test
    public void cacheManagerByLocationFileTest() throws URISyntaxException {
        URI uri = new URI("MY-SCOPE");

        String urlStr = configUrl1.toString();
        assertEquals("file", urlStr.substring(0, 4));
        Properties properties = new Properties();
        properties.setProperty(HazelcastCachingProvider.HAZELCAST_CONFIG_LOCATION, urlStr);
        CacheManager cacheManager = Caching.getCachingProvider().getCacheManager(uri, null, properties);
        assertNotNull(cacheManager);

        URI uri2 = new URI("MY-SCOPE-OTHER");
        String urlStr2 = configUrl2.toString();
        assertEquals("file", urlStr2.substring(0, 4));
        Properties properties2 = new Properties();
        properties2.setProperty(HazelcastCachingProvider.HAZELCAST_CONFIG_LOCATION, urlStr2);
        CacheManager cacheManager2 = Caching.getCachingProvider().getCacheManager(uri2, null, properties2);
        assertNotNull(cacheManager2);

        assertEquals(2, Hazelcast.getAllHazelcastInstances().size());
    }

    @Test
    public void cacheManagerByInstanceNameTest() throws URISyntaxException {
        final String instanceName = randomName();
        Config config = new Config();
        config.setInstanceName(instanceName);
        Hazelcast.newHazelcastInstance(config);

        URI uri1 = new URI("MY-SCOPE");
        Properties properties = new Properties();
        properties.setProperty(HazelcastCachingProvider.HAZELCAST_INSTANCE_NAME, instanceName);
        CacheManager cacheManager = Caching.getCachingProvider().getCacheManager(uri1, null, properties);
        assertNotNull(cacheManager);

        assertEquals(1, Hazelcast.getAllHazelcastInstances().size());
    }

    @Test
    public void instanceNameShouldBeUsedIfItIsSpecified()
            throws URISyntaxException, IOException {
        Config config = new XmlConfigBuilder(configUrl1).build();
        URI uri = new URI("MY-SCOPE");
        Properties properties = new Properties();
        properties.setProperty(HazelcastCachingProvider.HAZELCAST_CONFIG_LOCATION, configUrl1.toString());
        HazelcastCacheManager cacheManager =
                (HazelcastCacheManager) Caching.getCachingProvider().getCacheManager(uri, null, properties);

        assertNotNull(cacheManager);
        assertEquals(config.getInstanceName(), cacheManager.getHazelcastInstance().getName());
    }

    @Test
    public void configUrlShouldBeUsedAsInstanceNameIfInstanceNameIsNotSpecified() throws Exception {
        URI uri = new URI("MY-SCOPE");
        Properties properties = new Properties();
        properties.setProperty(HazelcastCachingProvider.HAZELCAST_CONFIG_LOCATION, configUrl2.toString());
        HazelcastCacheManager cacheManager =
                (HazelcastCacheManager) Caching.getCachingProvider().getCacheManager(uri, null, properties);

        assertNotNull(cacheManager);
        assertEquals(configUrl2.toString(), cacheManager.getHazelcastInstance().getName());
    }

    @Test
    public void instanceNamePropertyShouldBeUsedWhenNoInstanceNameIsSpecified() throws Exception {
        String instanceName = randomName();
        URI uri = new URI("MY-SCOPE");
        Properties properties = new Properties();
        properties.setProperty(HazelcastCachingProvider.HAZELCAST_CONFIG_LOCATION, configUrl2.toString());
        properties.setProperty(HazelcastCachingProvider.HAZELCAST_INSTANCE_NAME, instanceName);
        HazelcastCacheManager cacheManager =
                (HazelcastCacheManager) Caching.getCachingProvider().getCacheManager(uri, null, properties);

        assertNotNull(cacheManager);
        assertEquals(instanceName, cacheManager.getHazelcastInstance().getName());
    }

    @Test
    public void instanceNamePropertyShouldBeUsedEvenThoughInstanceNameIsSpecifiedInTheConfig() throws Exception {
        String instanceName = randomName();
        URI uri = new URI("MY-SCOPE");
        Properties properties = new Properties();
        properties.setProperty(HazelcastCachingProvider.HAZELCAST_CONFIG_LOCATION, configUrl1.toString());
        properties.setProperty(HazelcastCachingProvider.HAZELCAST_INSTANCE_NAME, instanceName);
        HazelcastCacheManager cacheManager =
                (HazelcastCacheManager) Caching.getCachingProvider().getCacheManager(uri, null, properties);

        assertNotNull(cacheManager);
        assertEquals(instanceName, cacheManager.getHazelcastInstance().getName());
    }

    @Test
    public void defaultCacheTest() {
        CacheManager cacheManager = Caching.getCachingProvider().getCacheManager();
        assertNotNull(cacheManager);

        Cache testCache = cacheManager.getCache("default");
        assertNull(testCache);
    }

    @Test(expected = IllegalArgumentException.class)
    public void setAsyncBackupCount_whenItsNegative() {
        CacheConfig config = new CacheConfig();
        config.setAsyncBackupCount(-1);
    }

    @Test
    public void setAsyncBackupCount_whenItsZero() {
        CacheConfig config = new CacheConfig();
        config.setAsyncBackupCount(0);
    }

    @Test(expected = IllegalArgumentException.class)
    public void setAsyncBackupCount_whenTooLarge() {
        CacheConfig config = new CacheConfig();
        config.setAsyncBackupCount(200); //max allowed is 6..
    }

    @Test(expected = IllegalArgumentException.class)
    public void setBackupCount_whenItsNegative() {
        CacheConfig config = new CacheConfig();
        config.setBackupCount(-1);
    }

    @Test
    public void setBackupCount_whenItsZero() {
        CacheConfig config = new CacheConfig();
        config.setBackupCount(0);
    }

    @Test(expected = IllegalArgumentException.class)
    public void setBackupCount_whenTooLarge() {
        CacheConfig config = new CacheConfig();
        config.setBackupCount(200); //max allowed is 6..
    }

    @Test
    public void createCache_WhenCacheConfigIsNull() {
        String cacheName = "cacheNull";

        CacheManager cacheManager = Caching.getCachingProvider().getCacheManager();

        try {
            cacheManager.createCache(cacheName, (Configuration<Object, Object>) null);
            fail("NullPointerException expected");
        } catch (NullPointerException expected) {
            EmptyStatement.ignore(expected);
        }
    }

    @Test
    public void testGetPreConfiguredCache() {
        Config config = new Config();
        config.addCacheConfig(new CacheSimpleConfig().setName("test"));

        int count = 4;
        TestHazelcastInstanceFactory factory = new TestHazelcastInstanceFactory(count);
        for (int i = 0; i < count; i++) {
            HazelcastInstance instance = factory.newHazelcastInstance(config);
            CachingProvider provider = HazelcastServerCachingProvider.createCachingProvider(instance);
            CacheManager cacheManager = provider.getCacheManager();

            Cache<Object, Object> cache = cacheManager.getCache("test");
            assertNotNull("Pre-configured cache cannot be retrieved on instance: " + i, cache);
        }
    }

    @Test
    public void testEntryListenerFactoryFromSimpleCacheConfig() {
        String cacheName = randomString();
        Config config = createConfig(cacheName);
        HazelcastInstance instance = createHazelcastInstance(config);
        HazelcastServerCachingProvider cachingProvider = HazelcastServerCachingProvider.createCachingProvider(instance);
        CacheManager cacheManager = cachingProvider.getCacheManager();
        Cache<Object, Object> cache = cacheManager.getCache(cacheName);
        EntryListener.latch = new CountDownLatch(1);
        cache.put(randomString(), randomString());
        assertOpenEventually(EntryListener.latch);
    }

    Config createConfig(String cacheName) {
        Config config = new Config();
        CacheSimpleConfig cacheSimpleConfig = new CacheSimpleConfig();
        cacheSimpleConfig.setName(cacheName);
        CacheSimpleEntryListenerConfig cacheSimpleEntryListenerConfig = new CacheSimpleEntryListenerConfig();
        cacheSimpleEntryListenerConfig.setCacheEntryListenerFactory(EntryListenerFactory.class.getName());
        cacheSimpleConfig.addEntryListenerConfig(cacheSimpleEntryListenerConfig);
        config.addCacheConfig(cacheSimpleConfig);
        return config;
    }

    private ICacheService getCacheService(HazelcastInstance instance) {
        Node node = TestUtil.getNode(instance);
        return node.getNodeEngine().getService(ICacheService.SERVICE_NAME);
    }

    private NodeEngine getNodeEngine(HazelcastInstance instance) {
        Node node = TestUtil.getNode(instance);
        return node.getNodeEngine();
    }

    @Test
    public void testGetCacheConfigsAtJoin() {
        final String cacheName = randomString();
        final String managerPrefix = "hz:";
        final String fullCacheName = managerPrefix + cacheName;
        final Config config = new Config();
        final CacheConfig cacheConfig = new CacheConfig()
                .setName(cacheName)
                .setManagerPrefix(managerPrefix);

        final TestHazelcastInstanceFactory instanceFactory = createHazelcastInstanceFactory(2);
        final HazelcastInstance instance1 = instanceFactory.newHazelcastInstance(config);
        final ICacheService cacheService1 = getCacheService(instance1);

        assertNull(cacheService1.getCacheConfig(fullCacheName));

        cacheService1.putCacheConfigIfAbsent(cacheConfig);

        assertNotNull(cacheService1.getCacheConfig(fullCacheName));

        final HazelcastInstance instance2 = instanceFactory.newHazelcastInstance(config);
        final ICacheService cacheService2 = getCacheService(instance2);

        assertTrueEventually(new AssertTask() {
            @Override
            public void run() throws Exception {
                assertNotNull(cacheService2.getCacheConfig(fullCacheName));
            }
        });
    }

    public static class EntryListenerFactory implements Factory<EntryListener> {
        @Override
        public EntryListener create() {
            return new EntryListener();
        }
    }

    public static class EntryListener implements CacheEntryCreatedListener {

        static volatile CountDownLatch latch;

        @Override
        public void onCreated(Iterable iterable) throws CacheEntryListenerException {
            latch.countDown();
        }
    }

    public static class MyCacheLoaderFactory implements Factory {
        @Override
        public Object create() {
            return null;
        }
    }

    public static class MyCacheWriterFactory implements Factory {
        @Override
        public Object create() {
            return null;
        }
    }

    public static class MyExpirePolicyFactory implements Factory {
        @Override
        public Object create() {
            return null;
        }
    }

    public static class MyEntryListenerFactory implements Factory {
        @Override
        public Object create() {
            return null;
        }
    }

    public static class MyEntryEventFilterFactory implements Factory {
        @Override
        public Object create() {
            return null;
        }
    }

    public static class MySyncEntryListenerFactory implements Factory {
        @Override
        public Object create() {
            return null;
        }
    }

    public static class MySyncEntryEventFilterFactory implements Factory {
        @Override
        public Object create() {
            return null;
        }
    }

    public static class MyCacheLoader<K> implements CacheLoader<K, String> {
        @Override
        public String load(K key) throws CacheLoaderException {
            return String.valueOf(key);
        }

        @Override
        public Map<K, String> loadAll(Iterable<? extends K> keys) throws CacheLoaderException {
            Map<K, String> result = new HashMap<K, String>();
            for (K key : keys) {
                result.put(key, String.valueOf(key));
            }
            return result;
        }
    }

    public static class EmptyCacheWriter<K> implements CacheWriter<K, String> {

        @Override
        public void write(Cache.Entry<? extends K, ? extends String> entry) throws CacheWriterException {

        }

        @Override
        public void writeAll(Collection<Cache.Entry<? extends K, ? extends String>> entries) throws CacheWriterException {

        }

        @Override
        public void delete(Object key) throws CacheWriterException {

        }

        @Override
        public void deleteAll(Collection<?> keys) throws CacheWriterException {

        }
    }
}