/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 org.apache.ignite.internal.processors.cache;

import java.io.Externalizable;
import java.io.Serializable;
import java.util.concurrent.Callable;
import javax.cache.Cache;
import org.apache.ignite.Ignite;
import org.apache.ignite.IgniteCheckedException;
import org.apache.ignite.cache.CacheInterceptorAdapter;
import org.apache.ignite.cache.CacheMode;
import org.apache.ignite.cache.affinity.AffinityFunction;
import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
import org.apache.ignite.cache.eviction.EvictionFilter;
import org.apache.ignite.cache.eviction.fifo.FifoEvictionPolicy;
import org.apache.ignite.cache.eviction.fifo.FifoEvictionPolicyFactory;
import org.apache.ignite.cache.eviction.lru.LruEvictionPolicy;
import org.apache.ignite.cache.eviction.sorted.SortedEvictionPolicy;
import org.apache.ignite.cache.eviction.sorted.SortedEvictionPolicyFactory;
import org.apache.ignite.cluster.ClusterNode;
import org.apache.ignite.configuration.CacheConfiguration;
import org.apache.ignite.configuration.DeploymentMode;
import org.apache.ignite.configuration.IgniteConfiguration;
import org.apache.ignite.configuration.NearCacheConfiguration;
import org.apache.ignite.internal.util.typedef.C1;
import org.apache.ignite.internal.util.typedef.T2;
import org.apache.ignite.internal.util.typedef.internal.CU;
import org.apache.ignite.lang.IgniteCallable;
import org.apache.ignite.testframework.GridStringLogger;
import org.apache.ignite.testframework.GridTestUtils;
import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
import org.junit.Test;

import static org.apache.ignite.cache.CacheAtomicityMode.ATOMIC;
import static org.apache.ignite.cache.CacheAtomicityMode.TRANSACTIONAL;
import static org.apache.ignite.cache.CacheAtomicityMode.TRANSACTIONAL_SNAPSHOT;
import static org.apache.ignite.cache.CacheMode.LOCAL;
import static org.apache.ignite.cache.CacheMode.PARTITIONED;
import static org.apache.ignite.cache.CacheMode.REPLICATED;
import static org.apache.ignite.cache.CacheRebalanceMode.ASYNC;
import static org.apache.ignite.cache.CacheRebalanceMode.NONE;
import static org.apache.ignite.cache.CacheWriteSynchronizationMode.FULL_ASYNC;
import static org.apache.ignite.cache.CacheWriteSynchronizationMode.FULL_SYNC;
import static org.apache.ignite.configuration.DeploymentMode.CONTINUOUS;
import static org.apache.ignite.configuration.DeploymentMode.SHARED;

/**
 *
 */
@SuppressWarnings("unchecked")
public class GridCacheConfigurationConsistencySelfTest extends GridCommonAbstractTest {
    /** */
    private boolean cacheEnabled;

    /** */
    private String cacheName = DEFAULT_CACHE_NAME;

    /** */
    private CacheMode cacheMode = REPLICATED;

    /** */
    private DeploymentMode depMode = SHARED;

    /** */
    private C1<CacheConfiguration, Void> initCache;

    /** */
    private boolean useStrLog;

    /** */
    private GridStringLogger strLog;

    /** */
    private AffinityFunction aff;

    /** */
    private int backups;

    /** {@inheritDoc} */
    @Override protected void afterTest() throws Exception {
        stopAllGrids();
    }

    /** {@inheritDoc} */
    @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception {
        IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName);

        if (useStrLog) {
            strLog = new GridStringLogger(false, cfg.getGridLogger());
            cfg.setGridLogger(strLog);
        }

        cfg.setDeploymentMode(depMode);

        if (cacheEnabled) {
            CacheConfiguration cacheCfg = defaultCacheConfiguration();

            cacheCfg.setName(cacheName);
            cacheCfg.setCacheMode(cacheMode);
            cacheCfg.setAffinity(aff);
            cacheCfg.setBackups(backups);
            cacheCfg.setAtomicityMode(TRANSACTIONAL);

            if (initCache != null)
                initCache.apply(cacheCfg);

            cfg.setCacheConfiguration(cacheCfg);
        }
        else
            cfg.setCacheConfiguration();

        return cfg;
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testCacheUtilsCheckAttributeMismatch() throws Exception {
        Ignite ignite = startGrid(1);

        final ClusterNode node = ignite.cluster().localNode();

        final GridStringLogger strLog = new GridStringLogger(false, log);

        CU.checkAttributeMismatch(strLog, "cache", node.id(), "cacheMode", "Cache mode", LOCAL, PARTITIONED, false);

        assertTrue("No expected message in log: " + strLog.toString(),
            strLog.toString().contains("Cache mode mismatch"));

        strLog.reset();

        GridTestUtils.assertThrows(log, new Callable<Void>() {
            /** {@inheritDoc} */
            @Override public Void call() throws Exception {
                CU.checkAttributeMismatch(strLog, "cache", node.id(), "cacheMode", "Cache mode", LOCAL, PARTITIONED, true);
                return null;
            }
        }, IgniteCheckedException.class, "Cache mode mismatch");

        final CacheConfiguration cfg1 = defaultCacheConfiguration();

        cfg1.setCacheMode(LOCAL);

        final CacheConfiguration cfg2 = defaultCacheConfiguration();

        cfg2.setCacheMode(PARTITIONED);

        CU.checkAttributeMismatch(strLog, cfg1, cfg2, node.id(), new T2<>("cacheMode", "Cache mode"), false);

        assertTrue("No expected message in log: " + strLog.toString(),
            strLog.toString().contains("Cache mode mismatch"));

        GridTestUtils.assertThrows(log, new Callable<Void>() {
            /** {@inheritDoc} */
            @Override public Void call() throws Exception {
                CU.checkAttributeMismatch(strLog, cfg1, cfg2, node.id(), new T2<>("cacheMode", "Cache mode"), true);
                return null;
            }
        }, IgniteCheckedException.class, "Cache mode mismatch");
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testNullCacheMode() throws Exception {
        // Grid with null cache mode.
        // This is a legal case. The default cache mode should be used.
        cacheEnabled = true;
        cacheName = "myCache";
        cacheMode = null;
        depMode = SHARED;

        assert startGrid(1).cache("myCache").getConfiguration(CacheConfiguration.class).getCacheMode() == CacheConfiguration.DFLT_CACHE_MODE;
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testWithCacheAndWithoutCache() throws Exception {
        // 1st grid without cache.
        cacheEnabled = false;
        depMode = SHARED;

        startGrid(2);

        // 2nd grid with replicated cache on board.
        cacheEnabled = true;
        cacheName = "myCache";
        cacheMode = REPLICATED;
        depMode = SHARED;

        startGrid(1);
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testSameCacheDifferentModes() throws Exception {
        // 1st grid with replicated cache.
        cacheEnabled = true;
        cacheName = "myCache";
        cacheMode = REPLICATED;
        depMode = SHARED;

        startGrid(1);

        // 2nd grid with partitioned cache.
        cacheEnabled = true;
        cacheName = "myCache";
        cacheMode = PARTITIONED;
        depMode = SHARED;

        try {
            startGrid(2);

            fail();
        }
        catch (IgniteCheckedException e) {
            info("Caught expected exception: " + e);
        }
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentCacheDifferentModes() throws Exception {
        // 1st grid with local cache.
        cacheEnabled = true;
        cacheName = "local";
        cacheMode = LOCAL;
        depMode = SHARED;

        startGrid(1);

        // 2nd grid with replicated cache.
        cacheEnabled = true;
        cacheName = "replicated";
        cacheMode = REPLICATED;
        depMode = SHARED;

        startGrid(2);

        // 3d grid with partitioned cache.
        cacheEnabled = true;
        cacheName = "partitioned";
        cacheMode = PARTITIONED;
        depMode = SHARED;

        startGrid(3);

        // 4th grid with null cache mode (legal case, it should turn to REPLICATED mode).
        cacheEnabled = true;
        cacheName = "partitioned";
        cacheMode = null;
        depMode = SHARED;

        startGrid(4);
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentDeploymentModes() throws Exception {
        // 1st grid with SHARED mode.
        cacheEnabled = true;
        cacheName = "partitioned";
        cacheMode = PARTITIONED;
        depMode = SHARED;

        startGrid(1);

        // 2nd grid with CONTINUOUS mode.
        cacheEnabled = true;
        cacheName = "partitioned";
        cacheMode = PARTITIONED;
        depMode = CONTINUOUS;

        GridTestUtils.assertThrows(log, new Callable<Object>() {
            @Override public Object call() throws Exception {
                return startGrid(2);
            }
        }, IgniteCheckedException.class, null);
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentAffinities() throws Exception {
        cacheMode = PARTITIONED;

        checkSecondGridStartFails(
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setAffinity(new TestRendezvousAffinityFunction());
                    return null;
                }
            },
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setAffinity(new RendezvousAffinityFunction());
                    return null;
                }
            }
        );
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentPreloadModes() throws Exception {
        checkSecondGridStartFails(
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setRebalanceMode(NONE);
                    return null;
                }
            },
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setRebalanceMode(ASYNC);
                    return null;
                }
            }
        );
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentEvictionEnabled() throws Exception {
        checkSecondGridStartFails(
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setEvictionPolicy(new FifoEvictionPolicy());
                    cfg.setOnheapCacheEnabled(true);
                    return null;
                }
            },
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    return null;
                }
            }
        );
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentEvictionPolicyEnabled() throws Exception {
        checkSecondGridStartFails(
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setEvictionPolicyFactory(new FifoEvictionPolicyFactory<>());
                    cfg.setOnheapCacheEnabled(true);
                    return null;
                }
            },
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    return null;
                }
            }
        );
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentEvictionPolicies() throws Exception {
        checkSecondGridStartFails(
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setEvictionPolicy(new SortedEvictionPolicy());
                    cfg.setOnheapCacheEnabled(true);
                    return null;
                }
            },
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setEvictionPolicy(new FifoEvictionPolicy());
                    cfg.setOnheapCacheEnabled(true);
                    return null;
                }
            }
        );
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentEvictionPolicyFactories() throws Exception {
        checkSecondGridStartFails(
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setEvictionPolicyFactory(new SortedEvictionPolicyFactory());
                    cfg.setOnheapCacheEnabled(true);
                    return null;
                }
            },
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setEvictionPolicyFactory(new FifoEvictionPolicyFactory<>());
                    cfg.setOnheapCacheEnabled(true);
                    return null;
                }
            }
        );
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentEvictionFilters() throws Exception {
        checkSecondGridStartFails(
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setEvictionFilter(new FirstCacheEvictionFilter());
                    return null;
                }
            },
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setEvictionFilter(new SecondCacheEvictionFilter());
                    return null;
                }
            }
        );
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentAffinityMappers() throws Exception {
        checkSecondGridStartFails(
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setAffinityMapper(new TestCacheDefaultAffinityKeyMapper());
                    return null;
                }
            },
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setAffinityMapper(new GridCacheDefaultAffinityKeyMapper());
                    return null;
                }
            }
        );
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentAtomicity() throws Exception {
        cacheMode = PARTITIONED;

        checkSecondGridStartFails(
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setNearConfiguration(null);
                    cfg.setAtomicityMode(ATOMIC);
                    return null;
                }
            },
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setNearConfiguration(null);
                    cfg.setAtomicityMode(TRANSACTIONAL);
                    return null;
                }
            }
        );
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentTxAtomicity() throws Exception {
        cacheMode = PARTITIONED;

        checkSecondGridStartFails(
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setNearConfiguration(null);
                    cfg.setAtomicityMode(TRANSACTIONAL);
                    return null;
                }
            },
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setNearConfiguration(null);
                    cfg.setAtomicityMode(TRANSACTIONAL_SNAPSHOT);
                    return null;
                }
            }
        );
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentSynchronization() throws Exception {
        cacheMode = PARTITIONED;

        checkSecondGridStartFails(
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setWriteSynchronizationMode(FULL_SYNC);
                    return null;
                }
            },
            new C1<CacheConfiguration, Void>() {
                /** {@inheritDoc} */
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setWriteSynchronizationMode(FULL_ASYNC);
                    return null;
                }
            }
        );
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testAffinityFunctionConsistency() throws Exception {
        cacheEnabled = true;
        cacheMode = PARTITIONED;

        backups = 1;

        aff = new RendezvousAffinityFunction(false, 100);

        startGrid(1);

        // 2nd grid with another affinity.
        // Check include neighbors.
        aff = new RendezvousAffinityFunction(true, 100);

        GridTestUtils.assertThrows(log, new Callable<Object>() {
            @Override public Object call() throws Exception {
                return startGrid(2);
            }
        }, IgniteCheckedException.class, "Affinity include neighbors mismatch");

        backups = 2;

        // Check backups.
        aff = new RendezvousAffinityFunction(false, 100);

        GridTestUtils.assertThrows(log, new Callable<Object>() {
            @Override public Object call() throws Exception {
                return startGrid(2);
            }
        }, IgniteCheckedException.class, "Affinity key backups mismatch");

        backups = 1;

        // Partitions count.
        aff = new RendezvousAffinityFunction(false, 1000);

        GridTestUtils.assertThrows(log, new Callable<Object>() {
            @Override public Object call() throws Exception {
                return startGrid(2);
            }
        }, IgniteCheckedException.class, "Affinity partitions count mismatch");
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testAttributesWarnings() throws Exception {
        cacheEnabled = true;

        initCache = new C1<CacheConfiguration, Void>() {
            /** {@inheritDoc} */
            @Override public Void apply(CacheConfiguration cfg) {
                cfg.setDefaultLockTimeout(1000);

                return null;
            }
        };

        startGrid(1);

        useStrLog = true;

        initCache = new C1<CacheConfiguration, Void>() {
            /** {@inheritDoc} */
            @Override public Void apply(CacheConfiguration cfg) {
                cfg.setDefaultLockTimeout(2 * 1000);

                return null;
            }
        };

        startGrid(2);

        String log = strLog.toString();

        assertTrue(log.contains("Default lock timeout"));
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testPartitionedOnlyAttributesIgnoredForReplicated() throws Exception {
        cacheEnabled = true;

        cacheMode = REPLICATED;

        initCache = new C1<CacheConfiguration, Void>() {
            @Override public Void apply(CacheConfiguration cfg) {
                NearCacheConfiguration nearCfg = new NearCacheConfiguration();

                nearCfg.setNearEvictionPolicyFactory(new FifoEvictionPolicyFactory<>());
                nearCfg.setNearEvictionPolicy(new LruEvictionPolicy());

                cfg.setNearConfiguration(nearCfg);

                return null;
            }
        };

        startGrid(1);

        initCache = new C1<CacheConfiguration, Void>() {
            @Override public Void apply(CacheConfiguration cfg) {
                NearCacheConfiguration nearCfg = new NearCacheConfiguration();

                nearCfg.setNearEvictionPolicyFactory(new FifoEvictionPolicyFactory<>());
                nearCfg.setNearEvictionPolicy(new FifoEvictionPolicy());

                cfg.setNearConfiguration(nearCfg);

                return null;
            }
        };

        startGrid(2);
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testIgnoreMismatchForLocalCaches() throws Exception {
        cacheEnabled = true;

        cacheMode = LOCAL;

        initCache = new C1<CacheConfiguration, Void>() {
            /** {@inheritDoc} */
            @SuppressWarnings("unchecked")
            @Override public Void apply(CacheConfiguration cfg) {
                cfg.setAffinity(new TestRendezvousAffinityFunction());

                cfg.setEvictionPolicyFactory(new FifoEvictionPolicyFactory<>());
                cfg.setEvictionPolicy(new FifoEvictionPolicy());
                cfg.setOnheapCacheEnabled(true);

                cfg.setCacheStoreFactory(new IgniteCacheAbstractTest.TestStoreFactory());
                cfg.setReadThrough(true);
                cfg.setWriteThrough(true);
                cfg.setLoadPreviousValue(true);

                return null;
            }
        };

        startGrid(1);

        initCache = new C1<CacheConfiguration, Void>() {
            /** {@inheritDoc} */
            @Override public Void apply(CacheConfiguration cfg) {
                cfg.setAffinity(new RendezvousAffinityFunction());

                cfg.setEvictionPolicyFactory(new FifoEvictionPolicyFactory<>());
                cfg.setEvictionPolicy(new LruEvictionPolicy());
                cfg.setOnheapCacheEnabled(true);

                cfg.setCacheStoreFactory(null);

                return null;
            }
        };

        startGrid(2);
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testStoreCheckAtomic() throws Exception {
        cacheEnabled = true;

        cacheMode = PARTITIONED;

        initCache = new C1<CacheConfiguration, Void>() {
            @SuppressWarnings("unchecked")
            @Override public Void apply(CacheConfiguration cc) {
                cc.setAtomicityMode(ATOMIC);

                cc.setNearConfiguration(null);

                cc.setCacheStoreFactory(new IgniteCacheAbstractTest.TestStoreFactory());
                cc.setReadThrough(true);
                cc.setWriteThrough(true);
                cc.setLoadPreviousValue(true);

                return null;
            }
        };

        startGrid(1);

        initCache = new C1<CacheConfiguration, Void>() {
            @Override public Void apply(CacheConfiguration cc) {
                cc.setAtomicityMode(ATOMIC);
                cc.setNearConfiguration(null);
                cc.setCacheStoreFactory(null);

                return null;
            }
        };

        GridTestUtils.assertThrows(log, new IgniteCallable<Object>() {
            @Override public Object call() throws Exception {
                startGrid(2);

                return null;
            }
        }, IgniteCheckedException.class, null);
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testStoreCheckTransactional() throws Exception {
        cacheEnabled = true;

        cacheMode = PARTITIONED;

        initCache = new C1<CacheConfiguration, Void>() {
            @SuppressWarnings("unchecked")
            @Override public Void apply(CacheConfiguration cc) {
                cc.setAtomicityMode(TRANSACTIONAL);

                cc.setNearConfiguration(null);

                cc.setCacheStoreFactory(new IgniteCacheAbstractTest.TestStoreFactory());
                cc.setReadThrough(true);
                cc.setWriteThrough(true);
                cc.setLoadPreviousValue(true);

                return null;
            }
        };

        startGrid(1);

        initCache = new C1<CacheConfiguration, Void>() {
            @Override public Void apply(CacheConfiguration cc) {
                cc.setAtomicityMode(TRANSACTIONAL);

                cc.setNearConfiguration(null);

                cc.setCacheStoreFactory(null);

                return null;
            }
        };

        GridTestUtils.assertThrows(log, new IgniteCallable<Object>() {
            @Override public Object call() throws Exception {
                startGrid(2);

                return null;
            }
        }, IgniteCheckedException.class, null);
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testAffinityForReplicatedCache() throws Exception {
        cacheEnabled = true;

        aff = new RendezvousAffinityFunction(false, 100);

        startGrid(1);

        // Try to start node with  different number of partitions.
        aff = new RendezvousAffinityFunction(false, 200);

        GridTestUtils.assertThrows(log, new Callable<Object>() {
            @Override public Object call() throws Exception {
                return startGrid(2);
            }
        }, IgniteCheckedException.class, "Affinity partitions count mismatch");
    }

    /**
     * @throws Exception If failed.
     */
    @Test
    public void testDifferentInterceptors() throws Exception {
        cacheMode = PARTITIONED;

        checkSecondGridStartFails(new C1<CacheConfiguration, Void>() {
                @Override public Void apply(CacheConfiguration cfg) {
                    cfg.setInterceptor(new TestCacheInterceptor());

                    return null;
                }
            }, new C1<CacheConfiguration, Void>() {
                @Override public Void apply(CacheConfiguration cfg) {
                    return null;
                }
            }
        );
    }

    /**
     * @param initCache1 Closure.
     * @param initCache2 Closure.
     * @throws Exception If failed.
     */
    private void checkSecondGridStartFails(C1<CacheConfiguration, Void> initCache1,
                                           C1<CacheConfiguration, Void> initCache2) throws Exception {
        cacheEnabled = true;

        initCache = initCache1;

        startGrid(1);

        initCache = initCache2;

        GridTestUtils.assertThrows(log, new Callable<Object>() {
            @Override public Object call() throws Exception {
                return startGrid(2);
            }
        }, IgniteCheckedException.class, null);
    }

    /**
     *
     */
    private static class TestRendezvousAffinityFunction extends RendezvousAffinityFunction {
        /**
         * Empty constructor required by {@link Externalizable}.
         */
        public TestRendezvousAffinityFunction() {
            // No-op.
        }
    }

    /**
     *
     */
    private static class FirstCacheEvictionFilter implements EvictionFilter<Object, Object> {
        /** {@inheritDoc} */
        @Override public boolean evictAllowed(Cache.Entry<Object, Object> entry) {
            return false;
        }
    }

    /**
     *
     */
    private static class SecondCacheEvictionFilter implements EvictionFilter<Object, Object> {
        /** {@inheritDoc} */
        @Override public boolean evictAllowed(Cache.Entry<Object, Object> entry) {
            return true;
        }
    }

    /**
     *
     */
    private static class TestCacheInterceptor extends CacheInterceptorAdapter implements Serializable {
        // No-op, just different class.
    }

    /**
     *
     */
    private static class TestCacheDefaultAffinityKeyMapper extends GridCacheDefaultAffinityKeyMapper {
        // No-op, just different class.
    }
}