ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [19/56] [abbrv] incubator-ignite git commit: # ignite-63
Date Fri, 23 Jan 2015 09:36:38 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a916db69/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheEvictionTouchSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheEvictionTouchSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheEvictionTouchSelfTest.java
new file mode 100644
index 0000000..8d8a480
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheEvictionTouchSelfTest.java
@@ -0,0 +1,347 @@
+/*
+ * 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.eviction;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.affinity.*;
+import org.apache.ignite.cache.eviction.*;
+import org.apache.ignite.cache.eviction.fifo.*;
+import org.apache.ignite.cache.store.*;
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.transactions.*;
+import org.gridgain.grid.kernal.processors.cache.*;
+import org.apache.ignite.spi.discovery.tcp.*;
+import org.apache.ignite.spi.discovery.tcp.ipfinder.*;
+import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+import org.apache.ignite.testframework.junits.common.*;
+
+import javax.cache.configuration.*;
+import java.util.*;
+
+import static org.apache.ignite.cache.GridCacheMode.*;
+import static org.apache.ignite.transactions.IgniteTxConcurrency.*;
+import static org.apache.ignite.transactions.IgniteTxIsolation.*;
+import static org.apache.ignite.cache.GridCacheWriteSynchronizationMode.*;
+
+/**
+ *
+ */
+public class GridCacheEvictionTouchSelfTest extends GridCommonAbstractTest {
+    /** IP finder. */
+    private static final TcpDiscoveryIpFinder ipFinder = new TcpDiscoveryVmIpFinder(true);
+
+    /** */
+    private GridCacheEvictionPolicy<?, ?> plc;
+
+    /** {@inheritDoc} */
+    @SuppressWarnings("unchecked")
+    @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
+        IgniteConfiguration c = super.getConfiguration(gridName);
+
+        TransactionsConfiguration txCfg = c.getTransactionsConfiguration();
+
+        txCfg.setDefaultTxConcurrency(PESSIMISTIC);
+        txCfg.setDefaultTxIsolation(REPEATABLE_READ);
+
+        CacheConfiguration cc = defaultCacheConfiguration();
+
+        cc.setCacheMode(REPLICATED);
+
+        cc.setSwapEnabled(false);
+
+        cc.setWriteSynchronizationMode(FULL_SYNC);
+
+        cc.setEvictionPolicy(plc);
+
+        CacheStore store = new GridCacheGenericTestStore<Object, Object>() {
+            @Override public Object load(Object key) {
+                return key;
+            }
+
+            @Override public Map<Object, Object> loadAll(Iterable<?> keys) {
+                Map<Object, Object> loaded = new HashMap<>();
+
+                for (Object key : keys)
+                    loaded.put(key, key);
+
+                return loaded;
+            }
+        };
+
+        cc.setCacheStoreFactory(new FactoryBuilder.SingletonFactory(store));
+        cc.setReadThrough(true);
+        cc.setWriteThrough(true);
+        cc.setLoadPreviousValue(true);
+
+        c.setCacheConfiguration(cc);
+
+        TcpDiscoverySpi disco = new TcpDiscoverySpi();
+
+        disco.setIpFinder(ipFinder);
+
+        c.setDiscoverySpi(disco);
+
+        return c;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void afterTest() throws Exception {
+        plc = null;
+
+        super.afterTest();
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testPolicyConsistency() throws Exception {
+        plc = new GridCacheFifoEvictionPolicy<Object, Object>(500);
+
+        try {
+            Ignite ignite = startGrid(1);
+
+            final GridCache<Integer, Integer> cache = ignite.cache(null);
+
+            final Random rnd = new Random();
+
+            try (IgniteTx tx = cache.txStart()) {
+                int iterCnt = 20;
+                int keyCnt = 5000;
+
+                for (int i = 0; i < iterCnt; i++) {
+                    int j = rnd.nextInt(keyCnt);
+
+                    // Put or remove?
+                    if (rnd.nextBoolean())
+                        cache.putx(j, j);
+                    else
+                        cache.remove(j);
+
+                    if (i != 0 && i % 1000 == 0)
+                        info("Stats [iterCnt=" + i + ", size=" + cache.size() + ']');
+                }
+
+                GridCacheFifoEvictionPolicy<Integer, Integer> plc0 = (GridCacheFifoEvictionPolicy<Integer, Integer>) plc;
+
+                if (!plc0.queue().isEmpty()) {
+                    for (GridCacheEntry<Integer, Integer> e : plc0.queue())
+                        U.warn(log, "Policy queue item: " + e);
+
+                    fail("Test failed, see logs for details.");
+                }
+
+                tx.commit();
+            }
+        }
+        catch (Throwable t) {
+            error("Test failed.", t);
+
+            fail("Test failed, see logs for details.");
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testEvictSingle() throws Exception {
+        plc = new GridCacheFifoEvictionPolicy<Object, Object>(500);
+
+        try {
+            Ignite ignite = startGrid(1);
+
+            final GridCache<Integer, Integer> cache = ignite.cache(null);
+
+            for (int i = 0; i < 100; i++)
+                cache.put(i, i);
+
+            assertEquals(100, ((GridCacheFifoEvictionPolicy)plc).queue().size());
+
+            for (int i = 0; i < 100; i++)
+                cache.evict(i);
+
+            assertEquals(0, ((GridCacheFifoEvictionPolicy)plc).queue().size());
+            assertEquals(0, cache.size());
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testEvictAll() throws Exception {
+        plc = new GridCacheFifoEvictionPolicy<Object, Object>(500);
+
+        try {
+            Ignite ignite = startGrid(1);
+
+            final GridCache<Integer, Integer> cache = ignite.cache(null);
+
+            Collection<Integer> keys = new ArrayList<>(100);
+
+            for (int i = 0; i < 100; i++) {
+                cache.put(i, i);
+
+                keys.add(i);
+            }
+
+            assertEquals(100, ((GridCacheFifoEvictionPolicy)plc).queue().size());
+
+            cache.evictAll(keys);
+
+            assertEquals(0, ((GridCacheFifoEvictionPolicy)plc).queue().size());
+            assertEquals(0, cache.size());
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testGroupLock() throws Exception {
+        plc = new GridCacheFifoEvictionPolicy<>(100);
+
+        try {
+            Ignite g = startGrid(1);
+
+            Integer affKey = 1;
+
+            GridCache<GridCacheAffinityKey<Object>, Integer> cache = g.cache(null);
+
+            IgniteTx tx = cache.txStartAffinity(affKey, PESSIMISTIC, REPEATABLE_READ, 0, 5);
+
+            try {
+                for (int i = 0; i < 5; i++)
+                    cache.put(new GridCacheAffinityKey<Object>(i, affKey), i);
+
+                tx.commit();
+            }
+            finally {
+                tx.close();
+            }
+
+            assertEquals(5, ((GridCacheFifoEvictionPolicy)plc).queue().size());
+
+            tx = cache.txStartAffinity(affKey, PESSIMISTIC, REPEATABLE_READ, 0, 5);
+
+            try {
+                for (int i = 0; i < 5; i++)
+                    cache.remove(new GridCacheAffinityKey<Object>(i, affKey));
+
+                tx.commit();
+            }
+            finally {
+                tx.close();
+            }
+
+            assertEquals(0, ((GridCacheFifoEvictionPolicy)plc).queue().size());
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testPartitionGroupLock() throws Exception {
+        plc = new GridCacheFifoEvictionPolicy<>(100);
+
+        try {
+            Ignite g = startGrid(1);
+
+            Integer affKey = 1;
+
+            GridCache<Object, Integer> cache = g.cache(null);
+
+            IgniteTx tx = cache.txStartPartition(cache.affinity().partition(affKey), PESSIMISTIC, REPEATABLE_READ,
+                0, 5);
+
+            try {
+                for (int i = 0; i < 5; i++)
+                    cache.put(new GridCacheAffinityKey<Object>(i, affKey), i);
+
+                tx.commit();
+            }
+            finally {
+                tx.close();
+            }
+
+            assertEquals(5, ((GridCacheFifoEvictionPolicy)plc).queue().size());
+
+            tx = cache.txStartPartition(cache.affinity().partition(affKey), PESSIMISTIC, REPEATABLE_READ, 0, 5);
+
+            try {
+                for (int i = 0; i < 5; i++)
+                    cache.remove(new GridCacheAffinityKey<Object>(i, affKey));
+
+                tx.commit();
+            }
+            finally {
+                tx.close();
+            }
+
+            assertEquals(0, ((GridCacheFifoEvictionPolicy)plc).queue().size());
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testReload() throws Exception {
+        plc = new GridCacheFifoEvictionPolicy<Object, Object>(100);
+
+        try {
+            Ignite ignite = startGrid(1);
+
+            final GridCache<Integer, Integer> cache = ignite.cache(null);
+
+            for (int i = 0; i < 10000; i++)
+                cache.reload(i);
+
+            assertEquals(100, cache.size());
+            assertEquals(100, cache.size());
+            assertEquals(100, ((GridCacheFifoEvictionPolicy)plc).queue().size());
+
+            Collection<Integer> keys = new ArrayList<>(10000);
+
+            for (int i = 0; i < 10000; i++)
+                keys.add(i);
+
+            cache.reloadAll(keys);
+
+            assertEquals(100, cache.size());
+            assertEquals(100, cache.size());
+            assertEquals(100, ((GridCacheFifoEvictionPolicy)plc).queue().size());
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a916db69/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheMockEntry.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheMockEntry.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheMockEntry.java
new file mode 100644
index 0000000..372feab
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheMockEntry.java
@@ -0,0 +1,365 @@
+/*
+ * 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.eviction;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.lang.*;
+import org.apache.ignite.internal.util.future.*;
+import org.apache.ignite.internal.util.lang.*;
+import org.apache.ignite.internal.util.tostring.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+
+/**
+ * Mock cache entry.
+ */
+public class GridCacheMockEntry<K, V> extends GridMetadataAwareAdapter implements GridCacheEntry<K, V> {
+    /** */
+    @GridToStringInclude
+    private K key;
+
+    /** */
+    @GridToStringInclude
+    private boolean evicted;
+
+    /** */
+    @GridToStringInclude
+    private boolean canEvict = true;
+
+    /**
+     * Constructor.
+     *
+     * @param key Key.
+     */
+    public GridCacheMockEntry(K key) {
+        this.key = key;
+    }
+
+    /**
+     * Constructor.
+     *
+     * @param key Key.
+     * @param canEvict Evict or not.
+     */
+    public GridCacheMockEntry(K key, boolean canEvict) {
+        this.key = key;
+        this.canEvict = canEvict;
+    }
+
+    /** {@inheritDoc} */
+    @Override public K getKey() throws IllegalStateException {
+        return key;
+    }
+
+    /** {@inheritDoc} */
+    @Override public V getValue() throws IllegalStateException {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public V setValue(V val) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean evict() {
+        evicted = true;
+
+        onEvicted();
+
+        return canEvict;
+    }
+
+    /**
+     * Eviction callback.
+     */
+    public void onEvicted() {
+        for (String key : allMeta().keySet())
+            removeMeta(key);
+    }
+
+    /**
+     *
+     * @return Evicted or not.
+     */
+    public boolean isEvicted() {
+        return evicted;
+    }
+
+    /** {@inheritDoc} */
+    @Override public V peek() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public V peek(@Nullable Collection<GridCachePeekMode> modes) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isLocked() {
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isLockedByThread() {
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public Object version() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public long expirationTime() {
+        return 0;
+    }
+
+    /** {@inheritDoc} */
+    @Override public long timeToLive() {
+        return 0;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean primary() {
+        // No-op.
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean backup() {
+        // No-op.
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Override public int partition() {
+        return 0;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public V set(V val,
+        @Nullable IgnitePredicate<GridCacheEntry<K, V>>... filter) throws IgniteCheckedException {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteFuture<V> setAsync(V val,
+        @Nullable IgnitePredicate<GridCacheEntry<K, V>>... filter) {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public V setIfAbsent(V val) throws IgniteCheckedException {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteFuture<V> setIfAbsentAsync(V val) {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean setx(V val,
+        @Nullable IgnitePredicate<GridCacheEntry<K, V>>... filter) throws IgniteCheckedException {
+        // No-op.
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteFuture<Boolean> setxAsync(V val,
+        @Nullable IgnitePredicate<GridCacheEntry<K, V>>... filter) {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean setxIfAbsent(@Nullable V val) throws IgniteCheckedException {
+        // No-op.
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteFuture<Boolean> setxIfAbsentAsync(V val) {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public V replace(V val) throws IgniteCheckedException {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteFuture<V> replaceAsync(V val) {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean replacex(V val) throws IgniteCheckedException {
+        // No-op.
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteFuture<Boolean> replacexAsync(V val) {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean replace(V oldVal, V newVal) throws IgniteCheckedException {
+        // No-op.
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteFuture<Boolean> replaceAsync(V oldVal, V newVal) {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public V remove(
+        @Nullable IgnitePredicate<GridCacheEntry<K, V>>... filter) throws IgniteCheckedException {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteFuture<V> removeAsync(
+        @Nullable IgnitePredicate<GridCacheEntry<K, V>>... filter) {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean removex(@Nullable IgnitePredicate<GridCacheEntry<K, V>>... filter) throws IgniteCheckedException {
+        // No-op.
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteFuture<Boolean> removexAsync(
+        @Nullable IgnitePredicate<GridCacheEntry<K, V>>... filter) {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean remove(V val) throws IgniteCheckedException {
+        // No-op.
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteFuture<Boolean> removeAsync(V val) {
+        // No-op.
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void timeToLive(long ttl) {
+        // No-op.
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean lock(long timeout,
+        @Nullable IgnitePredicate<GridCacheEntry<K, V>>... filter) throws IgniteCheckedException {
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteFuture<Boolean> lockAsync(long timeout,
+        @Nullable IgnitePredicate<GridCacheEntry<K, V>>... filter) {
+        return new GridFinishedFuture<>(null, false);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void unlock(IgnitePredicate<GridCacheEntry<K, V>>... filter) throws IgniteCheckedException {
+        // No-op.
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isCached() {
+        return !evicted;
+    }
+
+    /** {@inheritDoc} */
+    @Override public int memorySize() {
+        return 1024;
+    }
+
+    /** {@inheritDoc} */
+    @Override public GridCacheProjection<K, V> projection() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public V reload() throws IgniteCheckedException {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteFuture<V> reloadAsync() {
+        return new GridFinishedFuture<>();
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public V get() throws IgniteCheckedException {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteFuture<V> getAsync() {
+        return new GridFinishedFuture<>();
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean clear() {
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean compact() throws IgniteCheckedException {
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> T unwrap(Class<T> clazz) {
+        if(clazz.isAssignableFrom(getClass()))
+            return clazz.cast(this);
+
+        throw new IllegalArgumentException();
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(GridCacheMockEntry.class, this);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a916db69/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheSynchronousEvictionsFailoverSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheSynchronousEvictionsFailoverSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheSynchronousEvictionsFailoverSelfTest.java
new file mode 100644
index 0000000..dc69ffe
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/GridCacheSynchronousEvictionsFailoverSelfTest.java
@@ -0,0 +1,160 @@
+/*
+ * 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.eviction;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.affinity.*;
+import org.apache.ignite.cache.affinity.consistenthash.*;
+import org.apache.ignite.cluster.*;
+import org.apache.ignite.lang.*;
+import org.gridgain.grid.kernal.processors.cache.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+import org.apache.ignite.testframework.*;
+
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+import static org.apache.ignite.cache.GridCacheDistributionMode.*;
+import static org.apache.ignite.cache.GridCacheMode.*;
+
+/**
+ *
+ */
+public class GridCacheSynchronousEvictionsFailoverSelfTest extends GridCacheAbstractSelfTest {
+    /** {@inheritDoc} */
+    @Override protected int gridCount() {
+        return 3;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected GridCacheMode cacheMode() {
+        return PARTITIONED;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected GridCacheDistributionMode distributionMode() {
+        return PARTITIONED_ONLY;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected CacheConfiguration cacheConfiguration(String gridName) throws Exception {
+        CacheConfiguration ccfg = super.cacheConfiguration(gridName);
+
+        ccfg.setSwapEnabled(false);
+        ccfg.setEvictSynchronized(true);
+        ccfg.setEvictSynchronizedKeyBufferSize(10);
+
+        ccfg.setBackups(2);
+
+        ccfg.setAffinity(new GridCacheConsistentHashAffinityFunction(false, 500));
+
+        return ccfg;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected long getTestTimeout() {
+        return 60_000;
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testSynchronousEvictions() throws Exception {
+        GridCache<String, Integer> cache = cache(0);
+
+        final AtomicBoolean stop = new AtomicBoolean();
+
+        IgniteFuture<?> fut = null;
+
+        try {
+            Map<String, Integer> data = new HashMap<>();
+
+            addKeysForNode(cache.affinity(), grid(0).localNode(), data);
+            addKeysForNode(cache.affinity(), grid(1).localNode(), data);
+            addKeysForNode(cache.affinity(), grid(2).localNode(), data);
+
+            fut = GridTestUtils.runAsync(new Callable<Void>() {
+                @Override public Void call() throws Exception {
+                    Random rnd = new Random();
+
+                    while (!stop.get()) {
+                        int idx = rnd.nextBoolean() ? 1 : 2;
+
+                        log.info("Stopping grid: " + idx);
+
+                        stopGrid(idx);
+
+                        U.sleep(100);
+
+                        log.info("Starting grid: " + idx);
+
+                        startGrid(idx);
+                    }
+
+                    return null;
+                }
+            });
+
+            for (int i = 0 ; i < 100; i++) {
+                log.info("Iteration: " + i);
+
+                try {
+                    cache.putAll(data);
+                }
+                catch (IgniteCheckedException ignore) {
+                    continue;
+                }
+
+                for (String key : data.keySet())
+                    cache.evict(key);
+            }
+        }
+        finally {
+            stop.set(true);
+
+            if (fut != null)
+                fut.get();
+        }
+    }
+
+    /**
+     * @param aff Cache affinity.
+     * @param node Primary node for keys.
+     * @param data Map where keys/values should be put to.
+     */
+    private void addKeysForNode(GridCacheAffinity<String> aff, ClusterNode node, Map<String, Integer> data) {
+        int cntr = 0;
+
+        for (int i = 0; i < 100_000; i++) {
+            String key = String.valueOf(i);
+
+            if (aff.isPrimary(node, key)) {
+                data.put(key, i);
+
+                cntr++;
+
+                if (cntr == 500)
+                    break;
+            }
+        }
+
+        assertEquals(500, cntr);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a916db69/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/fifo/GridCacheFifoEvictionPolicySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/fifo/GridCacheFifoEvictionPolicySelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/fifo/GridCacheFifoEvictionPolicySelfTest.java
new file mode 100644
index 0000000..828b73f
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/fifo/GridCacheFifoEvictionPolicySelfTest.java
@@ -0,0 +1,380 @@
+/*
+ * 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.eviction.fifo;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.eviction.fifo.*;
+import org.apache.ignite.internal.processors.cache.eviction.*;
+
+import java.util.*;
+
+import static org.apache.ignite.cache.GridCacheMode.*;
+
+/**
+ * FIFO Eviction test.
+ */
+@SuppressWarnings({"TypeMayBeWeakened"})
+public class GridCacheFifoEvictionPolicySelfTest extends
+    GridCacheEvictionAbstractTest<GridCacheFifoEvictionPolicy<String, String>> {
+    /**
+     * @throws Exception If failed.
+     */
+    public void testPolicy() throws Exception {
+        try {
+            startGrid();
+
+            MockEntry e1 = new MockEntry("1", "1");
+            MockEntry e2 = new MockEntry("2", "2");
+            MockEntry e3 = new MockEntry("3", "3");
+            MockEntry e4 = new MockEntry("4", "4");
+            MockEntry e5 = new MockEntry("5", "5");
+
+            GridCacheFifoEvictionPolicy<String, String> p = policy();
+
+            p.setMaxSize(3);
+
+            p.onEntryAccessed(false, e1);
+
+            check(p.queue(), e1);
+
+            p.onEntryAccessed(false, e2);
+
+            check(p.queue(), e1, e2);
+
+            p.onEntryAccessed(false, e3);
+
+            check(p.queue(), e1, e2, e3);
+
+            assert !e1.isEvicted();
+            assert !e2.isEvicted();
+            assert !e3.isEvicted();
+
+            assertEquals(3, p.getCurrentSize());
+
+            p.onEntryAccessed(false, e4);
+
+            check(p.queue(), e2, e3, e4);
+
+            assertEquals(3, p.getCurrentSize());
+
+            assert e1.isEvicted();
+            assert !e2.isEvicted();
+            assert !e3.isEvicted();
+            assert !e4.isEvicted();
+
+            p.onEntryAccessed(false, e5);
+
+            check(p.queue(), e3, e4, e5);
+
+            assertEquals(3, p.getCurrentSize());
+
+            assert e2.isEvicted();
+            assert !e3.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(false, e1 = new MockEntry("1", "1"));
+
+            check(p.queue(), e4, e5, e1);
+
+            assertEquals(3, p.getCurrentSize());
+
+            assert e3.isEvicted();
+            assert !e1.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(false, e5);
+
+            check(p.queue(), e4, e5, e1);
+
+            assert !e1.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(false, e1);
+
+            assertEquals(3, p.getCurrentSize());
+
+            check(p.queue(), e4, e5, e1);
+
+            assert !e1.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(false, e5);
+
+            assertEquals(3, p.getCurrentSize());
+
+            check(p.queue(), e4, e5, e1);
+
+            assert !e1.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(true, e1);
+
+            assertEquals(2, p.getCurrentSize());
+
+            assert !e1.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(true, e4);
+
+            assertEquals(1, p.getCurrentSize());
+
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(true, e5);
+
+            assertEquals(0, p.getCurrentSize());
+
+            assert !e5.isEvicted();
+
+            info(p);
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testMemory() throws Exception {
+        try {
+            startGrid();
+
+            GridCacheFifoEvictionPolicy<String, String> p = policy();
+
+            int max = 10;
+
+            p.setMaxSize(max);
+
+            int cnt = 11;
+
+            for (int i = 0; i < cnt; i++)
+                p.onEntryAccessed(false, new MockEntry(Integer.toString(i), Integer.toString(i)));
+
+            info(p);
+
+            assertEquals(max, p.getCurrentSize());
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testRandom() throws Exception {
+        try {
+            startGrid();
+
+            GridCacheFifoEvictionPolicy<String, String> p = policy();
+
+            int max = 10;
+
+            p.setMaxSize(max);
+
+            Random rand = new Random();
+
+            int keys = 31;
+
+            MockEntry[] fifos = new MockEntry[keys];
+
+            for (int i = 0; i < fifos.length; i++)
+                fifos[i] = new MockEntry(Integer.toString(i));
+
+            int runs = 5000000;
+
+            for (int i = 0; i < runs; i++) {
+                boolean rmv = rand.nextBoolean();
+
+                int j = rand.nextInt(fifos.length);
+
+                MockEntry e = entry(fifos, j);
+
+                if (rmv)
+                    fifos[j] = new MockEntry(Integer.toString(j));
+
+                p.onEntryAccessed(rmv, e);
+            }
+
+            info(p);
+
+            int curSize = p.getCurrentSize();
+
+            assert curSize <= max : "curSize <= max [curSize=" + curSize + ", max=" + max + ']';
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testAllowEmptyEntries() throws Exception {
+        try {
+            startGrid();
+
+            MockEntry e1 = new MockEntry("1");
+
+            e1.setValue("val");
+
+            MockEntry e2 = new MockEntry("2");
+
+            MockEntry e3 = new MockEntry("3");
+
+            e3.setValue("val");
+
+            MockEntry e4 = new MockEntry("4");
+
+            MockEntry e5 = new MockEntry("5");
+
+            e5.setValue("val");
+
+            GridCacheFifoEvictionPolicy<String, String> p = policy();
+
+            p.setMaxSize(10);
+
+            p.onEntryAccessed(false, e1);
+
+            assertFalse(e1.isEvicted());
+
+            p.onEntryAccessed(false, e2);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e2.isEvicted());
+
+            p.onEntryAccessed(false, e3);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e3.isEvicted());
+
+            p.onEntryAccessed(false, e4);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e3.isEvicted());
+            assertFalse(e4.isEvicted());
+
+            p.onEntryAccessed(false, e5);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e3.isEvicted());
+            assertFalse(e5.isEvicted());
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testPut() throws Exception {
+        mode = LOCAL;
+        syncCommit = true;
+        plcMax = 100;
+
+        Ignite ignite = startGrid();
+
+        try {
+            GridCache<Integer, Integer> cache = ignite.cache(null);
+
+            int cnt = 500;
+
+            int min = Integer.MAX_VALUE;
+
+            int minIdx = 0;
+
+            for (int i = 0; i < cnt; i++) {
+                cache.put(i, i);
+
+                int cacheSize = cache.size();
+
+                if (i > plcMax && cacheSize < min) {
+                    min = cacheSize;
+                    minIdx = i;
+                }
+            }
+
+            assert min >= plcMax : "Min cache size is too small: " + min;
+
+            info("Min cache size [min=" + min + ", idx=" + minIdx + ']');
+            info("Current cache size " + cache.size());
+            info("Current cache key size " + cache.size());
+            info("Current cache entry set size " + cache.entrySet().size());
+
+            min = Integer.MAX_VALUE;
+
+            minIdx = 0;
+
+            // Touch.
+            for (int i = cnt; --i > cnt - plcMax;) {
+                cache.get(i);
+
+                int cacheSize = cache.size();
+
+                if (cacheSize < min) {
+                    min = cacheSize;
+                    minIdx = i;
+                }
+            }
+
+            info("----");
+            info("Min cache size [min=" + min + ", idx=" + minIdx + ']');
+            info("Current cache size " + cache.size());
+            info("Current cache key size " + cache.size());
+            info("Current cache entry set size " + cache.entrySet().size());
+
+            assert min >= plcMax : "Min cache size is too small: " + min;
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override protected GridCacheFifoEvictionPolicy<String, String> createPolicy(int plcMax) {
+        return new GridCacheFifoEvictionPolicy<>(plcMax);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected GridCacheFifoEvictionPolicy<String, String> createNearPolicy(int nearMax) {
+        return new GridCacheFifoEvictionPolicy<>(nearMax);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void checkNearPolicies(int endNearPlcSize) {
+        for (int i = 0; i < gridCnt; i++)
+            for (GridCacheEntry<String, String> e : nearPolicy(i).queue())
+                assert !e.isCached() : "Invalid near policy size: " + nearPolicy(i).queue();
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void checkPolicies(int plcMax) {
+        for (int i = 0; i < gridCnt; i++)
+            assert policy(i).queue().size() <= plcMax;
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a916db69/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheLruEvictionPolicySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheLruEvictionPolicySelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheLruEvictionPolicySelfTest.java
new file mode 100644
index 0000000..5035b52
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheLruEvictionPolicySelfTest.java
@@ -0,0 +1,426 @@
+/*
+ * 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.eviction.lru;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.eviction.lru.*;
+import org.apache.ignite.internal.processors.cache.eviction.*;
+
+import java.util.*;
+
+/**
+ * LRU Eviction test.
+ */
+@SuppressWarnings( {"TypeMayBeWeakened"})
+public class GridCacheLruEvictionPolicySelfTest extends
+    GridCacheEvictionAbstractTest<GridCacheLruEvictionPolicy<String, String>> {
+    /**
+     * @throws Exception If failed.
+     */
+    public void testPolicy() throws Exception {
+        startGrid();
+
+        try {
+            MockEntry e1 = new MockEntry("1", "1");
+            MockEntry e2 = new MockEntry("2", "2");
+            MockEntry e3 = new MockEntry("3", "3");
+            MockEntry e4 = new MockEntry("4", "4");
+            MockEntry e5 = new MockEntry("5", "5");
+
+            GridCacheLruEvictionPolicy<String, String> p = policy();
+
+            p.setMaxSize(3);
+
+            p.onEntryAccessed(false, e1);
+
+            check(p.queue(), e1);
+
+            p.onEntryAccessed(false, e2);
+
+            check(p.queue(), e1, e2);
+
+            p.onEntryAccessed(false, e3);
+
+            check(p.queue(), e1, e2, e3);
+
+            assert !e1.isEvicted();
+            assert !e2.isEvicted();
+            assert !e3.isEvicted();
+
+            assertEquals(3, p.getCurrentSize());
+
+            p.onEntryAccessed(false, e4);
+
+            check(p.queue(), e2, e3, e4);
+
+            assertEquals(3, p.getCurrentSize());
+
+            assert e1.isEvicted();
+            assert !e2.isEvicted();
+            assert !e3.isEvicted();
+            assert !e4.isEvicted();
+
+            p.onEntryAccessed(false, e5);
+
+            check(p.queue(), e3, e4, e5);
+
+            assertEquals(3, p.getCurrentSize());
+
+            assert e2.isEvicted();
+            assert !e3.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(false, e1 = new MockEntry("1", "1"));
+
+            check(p.queue(), e4, e5, e1);
+
+            assertEquals(3, p.getCurrentSize());
+
+            assert e3.isEvicted();
+            assert !e1.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(false, e5);
+
+            assertEquals(3, p.getCurrentSize());
+
+            check(p.queue(), e4, e1, e5);
+
+            assert !e1.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(false, e1);
+
+            assertEquals(3, p.getCurrentSize());
+
+            check(p.queue(), e4, e5, e1);
+
+            assert !e1.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(false, e5);
+
+            assertEquals(3, p.getCurrentSize());
+
+            check(p.queue(), e4, e1, e5);
+
+            assert !e1.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(true, e1);
+
+            assertEquals(2, p.getCurrentSize());
+
+            assert !e1.isEvicted();
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(true, e4);
+
+            assertEquals(1, p.getCurrentSize());
+
+            assert !e4.isEvicted();
+            assert !e5.isEvicted();
+
+            p.onEntryAccessed(true, e5);
+
+            assertEquals(0, p.getCurrentSize());
+
+            assert !e5.isEvicted();
+
+            info(p);
+        }
+        finally {
+            stopGrid();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testMemory() throws Exception {
+        startGrid();
+
+        try {
+            GridCacheLruEvictionPolicy<String, String> p = policy();
+
+            int max = 10;
+
+            p.setMaxSize(max);
+
+            int cnt = 11;
+
+            for (int i = 0; i < cnt; i++)
+                p.onEntryAccessed(false, new MockEntry(Integer.toString(i), Integer.toString(i)));
+
+            info(p);
+
+            assertEquals(max, p.getCurrentSize());
+        }
+        finally {
+            stopGrid();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testMiddleAccess() throws Exception {
+        startGrid();
+
+        try {
+            GridCacheLruEvictionPolicy<String, String> p = policy();
+
+            int max = 8;
+
+            p.setMaxSize(max);
+
+            MockEntry entry1 = new MockEntry("1", "1");
+            MockEntry entry2 = new MockEntry("2", "2");
+            MockEntry entry3 = new MockEntry("3", "3");
+
+            p.onEntryAccessed(false, entry1);
+            p.onEntryAccessed(false, entry2);
+            p.onEntryAccessed(false, entry3);
+
+            MockEntry[] freqUsed = new MockEntry[] {
+                new MockEntry("4", "4"),
+                new MockEntry("5", "5"),
+                new MockEntry("6", "6"),
+                new MockEntry("7", "7"),
+                new MockEntry("8", "7")
+            };
+
+            for (MockEntry e : freqUsed)
+                p.onEntryAccessed(false, e);
+
+            for (MockEntry e : freqUsed)
+                assert !e.isEvicted();
+
+            int cnt = 1001;
+
+            for (int i = 0; i < cnt; i++)
+                p.onEntryAccessed(false, entry(freqUsed, i % freqUsed.length));
+
+            info(p);
+
+            assertEquals(max, p.getCurrentSize());
+        }
+        finally {
+            stopGrid();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testRandom() throws Exception {
+        startGrid();
+
+        try {
+            GridCacheLruEvictionPolicy<String, String> p = policy();
+
+            int max = 10;
+
+            p.setMaxSize(max);
+
+            Random rand = new Random();
+
+            int keys = 31;
+
+            MockEntry[] lrus = new MockEntry[keys];
+
+            for (int i = 0; i < lrus.length; i++)
+                lrus[i] = new MockEntry(Integer.toString(i));
+
+            int runs = 500000;
+
+            for (int i = 0; i < runs; i++) {
+                boolean rmv = rand.nextBoolean();
+
+                int j = rand.nextInt(lrus.length);
+
+                MockEntry e = entry(lrus, j);
+
+                if (rmv)
+                    lrus[j] = new MockEntry(Integer.toString(j));
+
+                p.onEntryAccessed(rmv, e);
+            }
+
+            info(p);
+
+            assert p.getCurrentSize() <= max;
+        }
+        finally {
+            stopGrid();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testAllowEmptyEntries() throws Exception {
+        try {
+            startGrid();
+
+            MockEntry e1 = new MockEntry("1");
+
+            e1.setValue("val");
+
+            MockEntry e2 = new MockEntry("2");
+
+            MockEntry e3 = new MockEntry("3");
+
+            e3.setValue("val");
+
+            MockEntry e4 = new MockEntry("4");
+
+            MockEntry e5 = new MockEntry("5");
+
+            e5.setValue("val");
+
+            GridCacheLruEvictionPolicy<String, String> p = policy();
+
+            p.setMaxSize(10);
+
+            p.onEntryAccessed(false, e1);
+
+            assertFalse(e1.isEvicted());
+
+            p.onEntryAccessed(false, e2);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e2.isEvicted());
+
+            p.onEntryAccessed(false, e3);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e3.isEvicted());
+
+            p.onEntryAccessed(false, e4);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e3.isEvicted());
+            assertFalse(e4.isEvicted());
+
+            p.onEntryAccessed(false, e5);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e3.isEvicted());
+            assertFalse(e5.isEvicted());
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testPut() throws Exception {
+        mode = GridCacheMode.LOCAL;
+        syncCommit = true;
+        plcMax = 100;
+
+        Ignite ignite = startGrid();
+
+        try {
+            GridCache<Integer, Integer> cache = ignite.cache(null);
+
+            int cnt = 500;
+
+            int min = Integer.MAX_VALUE;
+
+            int minIdx = 0;
+
+            for (int i = 0; i < cnt; i++) {
+                cache.put(i, i);
+
+                int cacheSize = cache.size();
+
+                if (i > plcMax && cacheSize < min) {
+                    min = cacheSize;
+                    minIdx = i;
+                }
+            }
+
+            assert min >= plcMax : "Min cache size is too small: " + min;
+
+            info("Min cache size [min=" + min + ", idx=" + minIdx + ']');
+            info("Current cache size " + cache.size());
+            info("Current cache key size " + cache.size());
+            info("Current cache entry set size " + cache.entrySet().size());
+
+            min = Integer.MAX_VALUE;
+
+            minIdx = 0;
+
+            // Touch.
+            for (int i = cnt; --i > cnt - plcMax;) {
+                cache.get(i);
+
+                int cacheSize = cache.size();
+
+                if (cacheSize < min) {
+                    min = cacheSize;
+                    minIdx = i;
+                }
+            }
+
+            info("----");
+            info("Min cache size [min=" + min + ", idx=" + minIdx + ']');
+            info("Current cache size " + cache.size());
+            info("Current cache key size " + cache.size());
+            info("Current cache entry set size " + cache.entrySet().size());
+
+            assert min >= plcMax : "Min cache size is too small: " + min;
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override protected GridCacheLruEvictionPolicy<String, String> createPolicy(int plcMax) {
+        return new GridCacheLruEvictionPolicy<>(plcMax);
+    }
+
+    @Override protected GridCacheLruEvictionPolicy<String, String> createNearPolicy(int nearMax) {
+        return new GridCacheLruEvictionPolicy<>(nearMax);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void checkNearPolicies(int endNearPlcSize) {
+        for (int i = 0; i < gridCnt; i++)
+            for (GridCacheEntry<String, String> e : nearPolicy(i).queue())
+                assert !e.isCached() : "Invalid near policy size: " + nearPolicy(i).queue();
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void checkPolicies(int plcMax) {
+        for (int i = 0; i < gridCnt; i++)
+            assert policy(i).queue().size() <= plcMax;
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a916db69/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheLruNearEvictionPolicySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheLruNearEvictionPolicySelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheLruNearEvictionPolicySelfTest.java
new file mode 100644
index 0000000..a552593
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheLruNearEvictionPolicySelfTest.java
@@ -0,0 +1,136 @@
+/*
+ * 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.eviction.lru;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.eviction.lru.*;
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.spi.discovery.tcp.*;
+import org.apache.ignite.spi.discovery.tcp.ipfinder.*;
+import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.*;
+import org.apache.ignite.testframework.junits.common.*;
+
+import java.util.*;
+
+import static org.apache.ignite.cache.GridCacheAtomicityMode.*;
+import static org.apache.ignite.cache.GridCacheDistributionMode.*;
+import static org.apache.ignite.cache.GridCacheMode.*;
+import static org.apache.ignite.cache.GridCachePreloadMode.*;
+import static org.apache.ignite.cache.GridCacheWriteSynchronizationMode.*;
+
+/**
+ * LRU near eviction tests (GG-8884).
+ */
+public class GridCacheLruNearEvictionPolicySelfTest extends GridCommonAbstractTest {
+    /** */
+    private static final TcpDiscoveryIpFinder ipFinder = new TcpDiscoveryVmIpFinder(true);
+
+    /** Maximum size for near eviction policy. */
+    private static final int EVICTION_MAX_SIZE = 10;
+
+    /** Grid count. */
+    private static final int GRID_COUNT = 2;
+
+    /** Cache atomicity mode specified by test. */
+    private GridCacheAtomicityMode atomicityMode;
+
+    /** {@inheritDoc} */
+    @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
+        IgniteConfiguration c = super.getConfiguration(gridName);
+
+        CacheConfiguration cc = new CacheConfiguration();
+
+        cc.setAtomicityMode(atomicityMode);
+        cc.setCacheMode(PARTITIONED);
+        cc.setWriteSynchronizationMode(PRIMARY_SYNC);
+        cc.setDistributionMode(NEAR_PARTITIONED);
+        cc.setPreloadMode(SYNC);
+        cc.setNearEvictionPolicy(new GridCacheLruEvictionPolicy(EVICTION_MAX_SIZE));
+        cc.setStartSize(100);
+        cc.setQueryIndexEnabled(true);
+        cc.setBackups(0);
+
+        c.setCacheConfiguration(cc);
+
+        TcpDiscoverySpi disco = new TcpDiscoverySpi();
+
+        disco.setIpFinder(ipFinder);
+
+        c.setDiscoverySpi(disco);
+
+        return c;
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testAtomicNearEvictionMaxSize() throws Exception {
+        atomicityMode = ATOMIC;
+
+        checkNearEvictionMaxSize();
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testTransactionalNearEvictionMaxSize() throws Exception {
+        atomicityMode = TRANSACTIONAL;
+
+        checkNearEvictionMaxSize();
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    private void checkNearEvictionMaxSize() throws Exception {
+        startGridsMultiThreaded(GRID_COUNT);
+
+        try {
+            Random rand = new Random(0);
+
+            int cnt = 1000;
+
+            info("Inserting " + cnt + " keys to cache.");
+
+            try (IgniteDataLoader<Integer, String> ldr = grid(0).dataLoader(null)) {
+                for (int i = 0; i < cnt; i++)
+                    ldr.addData(i, Integer.toString(i));
+            }
+
+            for (int i = 0; i < GRID_COUNT; i++)
+                assertTrue("Near cache size " + near(i).nearSize() + ", but eviction maximum size " + EVICTION_MAX_SIZE,
+                    near(i).nearSize() <= EVICTION_MAX_SIZE);
+
+            info("Getting " + cnt + " keys from cache.");
+
+            for (int i = 0; i < cnt; i++) {
+                GridCache<Integer, String> cache = grid(rand.nextInt(GRID_COUNT)).cache(null);
+
+                assertTrue(cache.get(i).equals(Integer.toString(i)));
+            }
+
+            for (int i = 0; i < GRID_COUNT; i++)
+                assertTrue("Near cache size " + near(i).nearSize() + ", but eviction maximum size " + EVICTION_MAX_SIZE,
+                    near(i).nearSize() <= EVICTION_MAX_SIZE);
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a916db69/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheNearOnlyLruNearEvictionPolicySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheNearOnlyLruNearEvictionPolicySelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheNearOnlyLruNearEvictionPolicySelfTest.java
new file mode 100644
index 0000000..d536236
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/lru/GridCacheNearOnlyLruNearEvictionPolicySelfTest.java
@@ -0,0 +1,167 @@
+/*
+ * 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.eviction.lru;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.eviction.lru.*;
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.spi.discovery.tcp.*;
+import org.apache.ignite.spi.discovery.tcp.ipfinder.*;
+import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.*;
+import org.apache.ignite.testframework.junits.common.*;
+
+import static org.apache.ignite.cache.GridCacheAtomicityMode.*;
+import static org.apache.ignite.cache.GridCacheDistributionMode.*;
+import static org.apache.ignite.cache.GridCacheMode.*;
+import static org.apache.ignite.cache.GridCachePreloadMode.*;
+import static org.apache.ignite.cache.GridCacheWriteSynchronizationMode.*;
+
+/**
+ * LRU near eviction tests for NEAR_ONLY distribution mode (GG-8884).
+ */
+public class GridCacheNearOnlyLruNearEvictionPolicySelfTest extends GridCommonAbstractTest {
+    /** */
+    private static final TcpDiscoveryIpFinder ipFinder = new TcpDiscoveryVmIpFinder(true);
+
+    /** Grid count. */
+    private static final int GRID_COUNT = 2;
+
+    /** Maximum size for near eviction policy. */
+    private static final int EVICTION_MAX_SIZE = 10;
+
+    /** Node count. */
+    private int cnt;
+
+    /** Caching mode specified by test. */
+    private GridCacheMode cacheMode;
+
+    /** Cache atomicity mode specified by test. */
+    private GridCacheAtomicityMode atomicityMode;
+
+    /** {@inheritDoc} */
+    @Override protected void beforeTest() throws Exception {
+        super.beforeTest();
+
+        cnt = 0;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
+        IgniteConfiguration c = super.getConfiguration(gridName);
+
+        CacheConfiguration cc = new CacheConfiguration();
+
+        cc.setAtomicityMode(atomicityMode);
+        cc.setCacheMode(cacheMode);
+        cc.setWriteSynchronizationMode(PRIMARY_SYNC);
+        cc.setDistributionMode(cnt == 0 ? NEAR_ONLY : PARTITIONED_ONLY);
+        cc.setPreloadMode(SYNC);
+        cc.setNearEvictionPolicy(new GridCacheLruEvictionPolicy(EVICTION_MAX_SIZE));
+        cc.setStartSize(100);
+        cc.setQueryIndexEnabled(true);
+        cc.setBackups(0);
+
+        c.setCacheConfiguration(cc);
+
+        TcpDiscoverySpi disco = new TcpDiscoverySpi();
+
+        disco.setIpFinder(ipFinder);
+
+        c.setDiscoverySpi(disco);
+
+        cnt++;
+
+        return c;
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testPartitionedAtomicNearEvictionMaxSize() throws Exception {
+        atomicityMode = ATOMIC;
+        cacheMode = PARTITIONED;
+
+        checkNearEvictionMaxSize();
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testPartitionedTransactionalNearEvictionMaxSize() throws Exception {
+        atomicityMode = TRANSACTIONAL;
+        cacheMode = PARTITIONED;
+
+        checkNearEvictionMaxSize();
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testReplicatedAtomicNearEvictionMaxSize() throws Exception {
+        atomicityMode = ATOMIC;
+        cacheMode = REPLICATED;
+
+        checkNearEvictionMaxSize();
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testReplicatedTransactionalNearEvictionMaxSize() throws Exception {
+        atomicityMode = TRANSACTIONAL;
+        cacheMode = REPLICATED;
+
+        checkNearEvictionMaxSize();
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    private void checkNearEvictionMaxSize() throws Exception {
+        startGrids(GRID_COUNT);
+
+        try {
+            int cnt = 1000;
+
+            info("Inserting " + cnt + " keys to cache.");
+
+            try (IgniteDataLoader<Integer, String> ldr = grid(1).dataLoader(null)) {
+                for (int i = 0; i < cnt; i++)
+                    ldr.addData(i, Integer.toString(i));
+            }
+
+            assertTrue("Near cache size " + near(0).nearSize() + ", but eviction maximum size " + EVICTION_MAX_SIZE,
+                near(0).nearSize() <= EVICTION_MAX_SIZE);
+
+            info("Getting " + cnt + " keys from cache.");
+
+            for (int i = 0; i < cnt; i++) {
+                GridCache<Integer, String> cache = grid(0).cache(null);
+
+                assertTrue(cache.get(i).equals(Integer.toString(i)));
+            }
+
+            assertTrue("Near cache size " + near(0).nearSize() + ", but eviction maximum size " + EVICTION_MAX_SIZE,
+                near(0).nearSize() <= EVICTION_MAX_SIZE);
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a916db69/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/random/GridCacheRandomEvictionPolicySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/random/GridCacheRandomEvictionPolicySelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/random/GridCacheRandomEvictionPolicySelfTest.java
new file mode 100644
index 0000000..3764260
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/random/GridCacheRandomEvictionPolicySelfTest.java
@@ -0,0 +1,265 @@
+/*
+ * 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.eviction.random;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.eviction.random.*;
+import org.apache.ignite.internal.processors.cache.eviction.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+import java.util.concurrent.*;
+
+/**
+ * Random eviction policy test.
+ */
+public class GridCacheRandomEvictionPolicySelfTest extends
+    GridCacheEvictionAbstractTest<GridCacheRandomEvictionPolicy<String, String>> {
+    /**
+     * @throws Exception If failed.
+     */
+    public void testMemory() throws Exception {
+        try {
+            Ignite g = startGrid(0);
+
+            int max = 10;
+
+            policy(0).setMaxSize(max);
+
+            int keys = 31;
+
+            for (int i = 0; i < keys; i++) {
+                String s = Integer.toString(i);
+
+                g.cache(null).put(s, s);
+            }
+
+            assert g.cache(null).size() <= max;
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testRandom() throws Exception {
+        try {
+            Ignite g = startGrid(0);
+
+            int max = 10;
+
+            policy(0).setMaxSize(max);
+
+            Random rand = new Random();
+
+            int keys = 31;
+
+            String[] t = new String[keys];
+
+            for (int i = 0; i < t.length; i++)
+                t[i] = Integer.toString(i);
+
+            int runs = 10000;
+
+            for (int i = 0; i < runs; i++) {
+                boolean rmv = rand.nextBoolean();
+
+                int j = rand.nextInt(t.length);
+
+                if (rmv)
+                    g.cache(null).remove(t[j]);
+                else
+                    g.cache(null).put(t[j], t[j]);
+
+                if (i % 1000 == 0)
+                    info("Stats [cntr=" + i + ", total=" + runs + ']');
+            }
+
+            assert g.cache(null).size() <= max;
+
+            info(policy(0));
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testAllowEmptyEntries() throws Exception {
+        try {
+            startGrid();
+
+            GridCache<String, String> c = cache();
+
+            MockEntry e1 = new MockEntry("1", c);
+
+            e1.setValue("val");
+
+            MockEntry e2 = new MockEntry("2", c);
+
+            MockEntry e3 = new MockEntry("3", c);
+
+            e3.setValue("val");
+
+            MockEntry e4 = new MockEntry("4", c);
+
+            MockEntry e5 = new MockEntry("5", c);
+
+            e5.setValue("val");
+
+            GridCacheRandomEvictionPolicy<String, String> p = policy();
+
+            p.setMaxSize(10);
+
+            p.onEntryAccessed(false, e1);
+
+            assertFalse(e1.isEvicted());
+
+            p.onEntryAccessed(false, e2);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e2.isEvicted());
+
+            p.onEntryAccessed(false, e3);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e3.isEvicted());
+
+            p.onEntryAccessed(false, e4);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e3.isEvicted());
+            assertFalse(e4.isEvicted());
+
+            p.onEntryAccessed(false, e5);
+
+            assertFalse(e1.isEvicted());
+            assertFalse(e3.isEvicted());
+            assertFalse(e5.isEvicted());
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testRandomMultiThreaded() throws Exception {
+        try {
+            final Ignite g = startGrid(0);
+
+            int max = 10;
+
+            policy(0).setMaxSize(max);
+
+            final Random rand = new Random();
+
+            int keys = 31;
+
+            final String[] t = new String[keys];
+
+            for (int i = 0; i < t.length; i++)
+                t[i] = Integer.toString(i);
+
+            multithreaded(new Callable() {
+                @Nullable @Override public Object call() throws IgniteCheckedException {
+                    int runs = 3000;
+
+                    for (int i = 0; i < runs; i++) {
+                        boolean rmv = rand.nextBoolean();
+
+                        int j = rand.nextInt(t.length);
+
+                        if (rmv)
+                            g.cache(null).remove(t[j]);
+                        else
+                            g.cache(null).put(t[j], t[j]);
+
+                        if (i != 0 && i % 1000 == 0)
+                            info("Stats [cntr=" + i + ", total=" + runs + ']');
+                    }
+
+                    return null;
+                }
+            }, 10);
+
+            assert g.cache(null).size() <= max;
+
+            info(policy(0));
+        }
+        finally {
+            stopAllGrids();
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override public void testPartitionedNearDisabled() throws Exception {
+        // No-op.
+    }
+
+    /** {@inheritDoc} */
+    @Override public void testPartitionedNearEnabled() throws Exception {
+        // No-op.
+    }
+
+    /** {@inheritDoc} */
+    @Override public void testPartitionedNearDisabledMultiThreaded() throws Exception {
+        // No-op.
+    }
+
+    /** {@inheritDoc} */
+    @Override public void testPartitionedNearDisabledBackupSyncMultiThreaded() throws Exception {
+        // No-op.
+    }
+
+    /** {@inheritDoc} */
+    @Override public void testPartitionedNearEnabledMultiThreaded() throws Exception {
+        // No-op.
+    }
+
+    /** {@inheritDoc} */
+    @Override public void testPartitionedNearEnabledBackupSyncMultiThreaded() throws Exception {
+        // No-op.
+    }
+
+    /** {@inheritDoc} */
+    @Override protected GridCacheRandomEvictionPolicy<String, String> createPolicy(int plcMax) {
+        return new GridCacheRandomEvictionPolicy<>(plcMax);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected GridCacheRandomEvictionPolicy<String, String> createNearPolicy(int nearMax) {
+        return new GridCacheRandomEvictionPolicy<>(plcMax);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void checkNearPolicies(int nearMax) {
+        // No-op.
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void checkPolicies(int plcMax) {
+        // No-op.
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a916db69/modules/core/src/test/java/org/apache/ignite/testsuites/GridCacheEvictionSelfTestSuite.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testsuites/GridCacheEvictionSelfTestSuite.java b/modules/core/src/test/java/org/apache/ignite/testsuites/GridCacheEvictionSelfTestSuite.java
index 243360a..051cd62 100644
--- a/modules/core/src/test/java/org/apache/ignite/testsuites/GridCacheEvictionSelfTestSuite.java
+++ b/modules/core/src/test/java/org/apache/ignite/testsuites/GridCacheEvictionSelfTestSuite.java
@@ -20,10 +20,10 @@ package org.apache.ignite.testsuites;
 import junit.framework.*;
 import org.gridgain.grid.kernal.processors.cache.*;
 import org.apache.ignite.internal.processors.cache.distributed.near.*;
-import org.gridgain.grid.kernal.processors.cache.eviction.*;
-import org.gridgain.grid.kernal.processors.cache.eviction.fifo.*;
-import org.gridgain.grid.kernal.processors.cache.eviction.lru.*;
-import org.gridgain.grid.kernal.processors.cache.eviction.random.*;
+import org.apache.ignite.internal.processors.cache.eviction.*;
+import org.apache.ignite.internal.processors.cache.eviction.fifo.*;
+import org.apache.ignite.internal.processors.cache.eviction.lru.*;
+import org.apache.ignite.internal.processors.cache.eviction.random.*;
 
 /**
  * Test suite for cache eviction.

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a916db69/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/eviction/GridCacheBatchEvictUnswapSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/eviction/GridCacheBatchEvictUnswapSelfTest.java b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/eviction/GridCacheBatchEvictUnswapSelfTest.java
deleted file mode 100644
index d9f5752..0000000
--- a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/eviction/GridCacheBatchEvictUnswapSelfTest.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * 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.gridgain.grid.kernal.processors.cache.eviction;
-
-import org.apache.ignite.*;
-import org.apache.ignite.cache.*;
-import org.apache.ignite.cache.eviction.fifo.*;
-import org.apache.ignite.cache.store.*;
-import org.apache.ignite.lang.*;
-import org.gridgain.grid.kernal.processors.cache.*;
-import org.jetbrains.annotations.*;
-
-import javax.cache.*;
-import javax.cache.configuration.*;
-import java.util.*;
-import java.util.concurrent.atomic.*;
-
-import static org.apache.ignite.cache.GridCacheDistributionMode.*;
-
-/**
- * Swap benchmark.
- */
-@SuppressWarnings("BusyWait")
-public class GridCacheBatchEvictUnswapSelfTest extends GridCacheAbstractSelfTest {
-    /** Eviction policy size. */
-    public static final int EVICT_PLC_SIZE = 100000;
-
-    /** Keys count. */
-    public static final int KEYS_CNT = 100000;
-
-    /** Batch size. */
-    private static final int BATCH_SIZE = 200;
-
-    /** Number of threads for concurrent benchmark + concurrency level. */
-    private static final int N_THREADS = 8;
-
-    /** {@inheritDoc} */
-    @Override protected int gridCount() {
-        return 1;
-    }
-
-    /** {@inheritDoc} */
-    @Override protected long getTestTimeout() {
-        // Let this test run 2 minutes as it runs for 20 seconds locally.
-        return 2 * 60 * 1000;
-    }
-
-    /** {@inheritDoc} */
-    @SuppressWarnings("unchecked")
-    @Override protected CacheConfiguration cacheConfiguration(String gridName) throws Exception {
-        CacheConfiguration cacheCfg = super.cacheConfiguration(gridName);
-
-        cacheCfg.setCacheMode(GridCacheMode.PARTITIONED);
-
-        CacheStore store = new CacheStoreAdapter<Long, String>() {
-            @Nullable @Override public String load(Long key) {
-                return null;
-            }
-
-            @Override public void loadCache(final IgniteBiInClosure<Long, String> c,
-                @Nullable Object... args) {
-                for (int i = 0; i < KEYS_CNT; i++)
-                    c.apply((long)i, String.valueOf(i));
-            }
-
-            @Override public void write(Cache.Entry<? extends Long, ? extends String> val) {
-                // No-op.
-            }
-
-            @Override public void delete(Object key) {
-                // No-op.
-            }
-        };
-
-        cacheCfg.setCacheStoreFactory(new FactoryBuilder.SingletonFactory(store));
-        cacheCfg.setReadThrough(true);
-        cacheCfg.setWriteThrough(true);
-        cacheCfg.setLoadPreviousValue(true);
-
-        cacheCfg.setEvictionPolicy(new GridCacheFifoEvictionPolicy(EVICT_PLC_SIZE));
-        cacheCfg.setSwapEnabled(true);
-        cacheCfg.setEvictSynchronized(false);
-        cacheCfg.setDistributionMode(PARTITIONED_ONLY);
-
-        return cacheCfg;
-    }
-
-    /**
-     * @throws Exception If failed.
-     */
-    public void testConcurrentEvictions() throws Exception {
-        runConcurrentTest(grid(0), KEYS_CNT, BATCH_SIZE);
-    }
-
-    /**
-     * @param g Grid instance.
-     * @param keysCnt Number of keys to swap and promote.
-     * @param batchSize Size of batch to swap/promote.
-     * @throws Exception If failed.
-     */
-    private void runConcurrentTest(Ignite g, final int keysCnt, final int batchSize) throws Exception {
-        assert keysCnt % batchSize == 0;
-
-        final AtomicInteger evictedKeysCnt = new AtomicInteger();
-
-        final GridCache<Object, Object> cache = g.cache(null);
-
-        cache.loadCache(null, 0);
-
-        info("Finished load cache.");
-
-        IgniteFuture<?> evictFut = multithreadedAsync(new Runnable() {
-            @Override public void run() {
-                Collection<Long> keys = new ArrayList<>(batchSize);
-
-                int evictedBatches = 0;
-
-                for (long i = 0; i < keysCnt; i++) {
-                    keys.add(i);
-
-                    if (keys.size() == batchSize) {
-                        cache.evictAll(keys);
-
-                        evictedKeysCnt.addAndGet(batchSize);
-
-                        keys.clear();
-
-                        evictedBatches++;
-
-                        if (evictedBatches % 100 == 0 && evictedBatches > 0)
-                            info("Evicted " + (evictedBatches * batchSize) + " entries.");
-                    }
-                }
-            }
-        }, N_THREADS, "evict");
-
-        final AtomicInteger unswappedKeys = new AtomicInteger();
-
-        IgniteFuture<?> unswapFut = multithreadedAsync(new Runnable() {
-            @Override public void run() {
-                try {
-                    Collection<Long> keys = new ArrayList<>(batchSize);
-
-                    int unswappedBatches = 0;
-
-                    for (long i = 0; i < keysCnt; i++) {
-                        keys.add(i);
-
-                        if (keys.size() == batchSize) {
-                            cache.promoteAll(keys);
-
-                            unswappedKeys.addAndGet(batchSize);
-
-                            keys.clear();
-
-                            unswappedBatches++;
-
-                            if (unswappedBatches % 100 == 0 && unswappedBatches > 0)
-                                info("Unswapped " + (unswappedBatches * batchSize) + " entries.");
-                        }
-                    }
-                }
-                catch (IgniteCheckedException e) {
-                    e.printStackTrace();
-                }
-            }
-        }, N_THREADS, "promote");
-
-        evictFut.get();
-
-        unswapFut.get();
-
-        info("Clearing cache.");
-
-        for (long i = 0; i < KEYS_CNT; i++)
-            cache.remove(i);
-    }
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a916db69/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/eviction/GridCacheConcurrentEvictionConsistencySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/eviction/GridCacheConcurrentEvictionConsistencySelfTest.java b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/eviction/GridCacheConcurrentEvictionConsistencySelfTest.java
deleted file mode 100644
index 2e6de1a..0000000
--- a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/eviction/GridCacheConcurrentEvictionConsistencySelfTest.java
+++ /dev/null
@@ -1,267 +0,0 @@
-/*
- * 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.gridgain.grid.kernal.processors.cache.eviction;
-
-import org.apache.ignite.*;
-import org.apache.ignite.cache.*;
-import org.apache.ignite.cache.eviction.*;
-import org.apache.ignite.cache.eviction.fifo.*;
-import org.apache.ignite.cache.eviction.lru.*;
-import org.apache.ignite.configuration.*;
-import org.apache.ignite.lang.*;
-import org.apache.ignite.transactions.*;
-import org.apache.ignite.spi.discovery.tcp.*;
-import org.apache.ignite.spi.discovery.tcp.ipfinder.*;
-import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.*;
-import org.apache.ignite.internal.util.typedef.internal.*;
-import org.apache.ignite.testframework.junits.common.*;
-
-import java.util.*;
-import java.util.concurrent.*;
-
-import static org.apache.ignite.cache.GridCacheMode.*;
-import static org.apache.ignite.cache.GridCacheDistributionMode.*;
-import static org.apache.ignite.transactions.IgniteTxConcurrency.*;
-import static org.apache.ignite.transactions.IgniteTxIsolation.*;
-import static org.apache.ignite.cache.GridCacheWriteSynchronizationMode.*;
-
-/**
- *
- */
-public class GridCacheConcurrentEvictionConsistencySelfTest extends GridCommonAbstractTest {
-    /** IP finder. */
-    private static final TcpDiscoveryIpFinder ipFinder = new TcpDiscoveryVmIpFinder(true);
-
-    /** Default iteration count. */
-    private static final int ITERATION_CNT = 50000;
-
-    /** Size of policy internal queue. */
-    private static final int POLICY_QUEUE_SIZE = 50;
-
-    /** Tested policy. */
-    private GridCacheEvictionPolicy<?, ?> plc;
-
-    /** Key count to put into the cache. */
-    private int keyCnt;
-
-    /** Number of threads. */
-    private int threadCnt = 50;
-
-    /** {@inheritDoc} */
-    @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
-        IgniteConfiguration c = super.getConfiguration(gridName);
-
-        c.getTransactionsConfiguration().setDefaultTxConcurrency(PESSIMISTIC);
-        c.getTransactionsConfiguration().setDefaultTxIsolation(READ_COMMITTED);
-
-        CacheConfiguration cc = defaultCacheConfiguration();
-
-        cc.setCacheMode(LOCAL);
-
-        cc.setSwapEnabled(false);
-
-        cc.setWriteSynchronizationMode(FULL_SYNC);
-
-        cc.setDistributionMode(PARTITIONED_ONLY);
-
-        cc.setEvictionPolicy(plc);
-
-        c.setCacheConfiguration(cc);
-
-        TcpDiscoverySpi disco = new TcpDiscoverySpi();
-
-        disco.setIpFinder(ipFinder);
-
-        c.setDiscoverySpi(disco);
-
-        return c;
-    }
-
-    /** {@inheritDoc} */
-    @Override protected long getTestTimeout() {
-        return 5 * 60 * 1000; // 5 min.
-    }
-
-    /**
-     * @throws Exception If failed.
-     */
-    public void testPolicyConsistencyFifoLocalTwoKeys() throws Exception {
-        plc = new GridCacheFifoEvictionPolicy<Object, Object>(1);
-
-        keyCnt = 2;
-        threadCnt = 10;
-
-        checkPolicyConsistency();
-    }
-
-    /**
-     * @throws Exception If failed.
-     */
-    public void testPolicyConsistencyLruLocalTwoKeys() throws Exception {
-        plc = new GridCacheLruEvictionPolicy<Object, Object>(1);
-
-        keyCnt = 2;
-        threadCnt = 10;
-
-        checkPolicyConsistency();
-    }
-
-    /**
-     * @throws Exception If failed.
-     */
-    public void testPolicyConsistencyFifoLocalFewKeys() throws Exception {
-        plc = new GridCacheFifoEvictionPolicy<Object, Object>(POLICY_QUEUE_SIZE);
-
-        keyCnt = POLICY_QUEUE_SIZE + 5;
-
-        checkPolicyConsistency();
-    }
-
-    /**
-     * @throws Exception If failed.
-     */
-    public void testPolicyConsistencyLruLocalFewKeys() throws Exception {
-        plc = new GridCacheLruEvictionPolicy<Object, Object>(POLICY_QUEUE_SIZE);
-
-        keyCnt = POLICY_QUEUE_SIZE + 5;
-
-        checkPolicyConsistency();
-    }
-
-    /**
-     * @throws Exception If failed.
-     */
-    public void testPolicyConsistencyFifoLocal() throws Exception {
-        plc = new GridCacheFifoEvictionPolicy<Object, Object>(POLICY_QUEUE_SIZE);
-
-        keyCnt = POLICY_QUEUE_SIZE * 10;
-
-        checkPolicyConsistency();
-    }
-
-    /**
-     * @throws Exception If failed.
-     */
-    public void testPolicyConsistencyLruLocal() throws Exception {
-        plc = new GridCacheLruEvictionPolicy<Object, Object>(POLICY_QUEUE_SIZE);
-
-        keyCnt = POLICY_QUEUE_SIZE * 10;
-
-        checkPolicyConsistency();
-    }
-
-    /**
-     * @throws Exception If failed.
-     */
-    private void checkPolicyConsistency() throws Exception {
-        try {
-            Ignite ignite = startGrid(1);
-
-            final GridCache<Integer, Integer> cache = ignite.cache(null);
-
-            long start = System.currentTimeMillis();
-
-            IgniteFuture<?> fut = multithreadedAsync(
-                new Callable<Object>() {
-                    @Override
-                    public Object call() throws Exception {
-                        final Random rnd = new Random();
-
-                        for (int i = 0; i < ITERATION_CNT; i++) {
-
-                            int j = rnd.nextInt(keyCnt);
-
-                            try (IgniteTx tx = cache.txStart()) {
-                                // Put or remove?
-                                if (rnd.nextBoolean())
-                                    cache.putx(j, j);
-                                else
-                                    cache.remove(j);
-
-                                tx.commit();
-                            }
-
-                            if (i != 0 && i % 10000 == 0)
-                                info("Stats [iterCnt=" + i + ", size=" + cache.size() + ']');
-                        }
-
-                        return null;
-                    }
-                },
-                threadCnt
-            );
-
-            fut.get();
-
-            Collection<GridCacheEntry<Integer, Integer>> queue = internalQueue(plc);
-
-            info("Test results [threadCnt=" + threadCnt + ", iterCnt=" + ITERATION_CNT + ", cacheSize=" + cache.size() +
-                ", internalQueueSize" + queue.size() + ", duration=" + (System.currentTimeMillis() - start) + ']');
-
-            for (GridCacheEntry<Integer, Integer> e : queue) {
-                Integer rmv = cache.remove(e.getKey());
-
-                if (rmv == null)
-                    fail("Eviction policy contains key that is not present in cache: " + e);
-                else
-                    info("Entry removed: " + rmv);
-            }
-
-            if (!cache.isEmpty()) {
-                boolean zombies = false;
-
-                for (GridCacheEntry<Integer, Integer> e : cache) {
-                    U.warn(log, "Zombie entry: " + e);
-
-                    zombies = true;
-                }
-
-                if (zombies)
-                    fail("Cache contained zombie entries.");
-            }
-            else
-                info("Cache is empty after test.");
-        }
-        finally {
-            stopAllGrids();
-        }
-    }
-
-    /**
-     * Gets internal policy queue.
-     *
-     * @param plc Policy to get queue from.
-     * @return Internal entries collection.
-     */
-    private Collection<GridCacheEntry<Integer, Integer>> internalQueue(GridCacheEvictionPolicy<?, ?> plc) {
-        if (plc instanceof GridCacheFifoEvictionPolicy) {
-            GridCacheFifoEvictionPolicy<Integer, Integer> plc0 = (GridCacheFifoEvictionPolicy<Integer, Integer>)plc;
-
-            return plc0.queue();
-        }
-        else if (plc instanceof GridCacheLruEvictionPolicy) {
-            GridCacheLruEvictionPolicy<Integer, Integer> plc0 = (GridCacheLruEvictionPolicy<Integer, Integer>)plc;
-
-            return plc0.queue();
-        }
-
-        assert false : "Unexpected policy type: " + plc.getClass().getName();
-
-        return Collections.emptyList();
-    }
-}


Mime
View raw message