ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From voze...@apache.org
Subject [36/37] ignite git commit: IGNITE-1513: WIP on .Net.
Date Tue, 22 Sep 2015 07:19:38 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/65bb69da/modules/platform/dotnet/Apache.Ignite.Core.Tests/Cache/CacheAbstractTest.cs
----------------------------------------------------------------------
diff --git a/modules/platform/dotnet/Apache.Ignite.Core.Tests/Cache/CacheAbstractTest.cs b/modules/platform/dotnet/Apache.Ignite.Core.Tests/Cache/CacheAbstractTest.cs
new file mode 100644
index 0000000..ae00c91
--- /dev/null
+++ b/modules/platform/dotnet/Apache.Ignite.Core.Tests/Cache/CacheAbstractTest.cs
@@ -0,0 +1,3252 @@
+/*
+ * 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.
+ */
+
+namespace Apache.Ignite.Core.Tests.Cache
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Linq;
+    using System.Runtime.Serialization;
+    using System.Text;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Apache.Ignite.Core.Cache;
+    using Apache.Ignite.Core.Cache.Expiry;
+    using Apache.Ignite.Core.Cluster;
+    using Apache.Ignite.Core.Common;
+    using Apache.Ignite.Core.Impl;
+    using Apache.Ignite.Core.Impl.Cache;
+    using Apache.Ignite.Core.Portable;
+    using Apache.Ignite.Core.Tests.Query;
+    using Apache.Ignite.Core.Transactions;
+    using NUnit.Framework;
+
+    /// <summary>
+    ///
+    /// </summary>
+    class CacheTestKey
+    {
+        /// <summary>
+        /// Default constructor.
+        /// </summary>
+        public CacheTestKey()
+        {
+            // No-op.
+        }
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="id">ID.</param>
+        public CacheTestKey(int id)
+        {
+            Id = id;
+        }
+
+        /// <summary>
+        /// ID.
+        /// </summary>
+        public int Id
+        {
+            get;
+            set;
+        }
+
+        /** <inheritdoc /> */
+        public override bool Equals(object obj)
+        {
+            CacheTestKey other = obj as CacheTestKey;
+
+            return other != null && Id == other.Id;
+        }
+
+        /** <inheritdoc /> */
+        public override int GetHashCode()
+        {
+            return Id;
+        }
+
+        /** <inheritdoc /> */
+        public override string ToString()
+        {
+            return new StringBuilder()
+                .Append(typeof(CacheTestKey).Name)
+                .Append(" [id=").Append(Id)
+                .Append(']').ToString();
+        }
+    }
+
+    /// <summary>
+    ///
+    /// </summary>
+    class TestReferenceObject
+    {
+        public TestReferenceObject Obj;
+
+        /// <summary>
+        /// Default constructor.
+        /// </summary>
+        public TestReferenceObject()
+        {
+            // No-op.
+        }
+
+        public TestReferenceObject(TestReferenceObject obj)
+        {
+            Obj = obj;
+        }
+    }
+
+    [Serializable]
+    public class TestSerializableObject
+    {
+        public string Name { get; set; }
+        public int Id { get; set; }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+
+            var other = (TestSerializableObject) obj;
+            return obj.GetType() == GetType() && (string.Equals(Name, other.Name) && Id == other.Id);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return ((Name != null ? Name.GetHashCode() : 0) * 397) ^ Id;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Cache entry processor that adds argument value to the entry value.
+    /// </summary>
+    [Serializable]
+    public class AddArgCacheEntryProcessor : ICacheEntryProcessor<int, int, int, int>
+    {
+        // Expected exception text
+        public const string ExceptionText = "Exception from AddArgCacheEntryProcessor.";
+
+        // Error flag
+        public bool ThrowErr { get; set; }
+
+        // Error flag
+        public bool ThrowErrPortable { get; set; }
+
+        // Error flag
+        public bool ThrowErrNonSerializable { get; set; }
+
+        // Key value to throw error on
+        public int ThrowOnKey { get; set; }
+
+        // Remove flag
+        public bool Remove { get; set; }
+
+        // Exists flag
+        public bool Exists { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AddArgCacheEntryProcessor"/> class.
+        /// </summary>
+        public AddArgCacheEntryProcessor()
+        {
+            Exists = true;
+            ThrowOnKey = -1;
+        }
+
+        /** <inheritdoc /> */
+        int ICacheEntryProcessor<int, int, int, int>.Process(IMutableCacheEntry<int, int> entry, int arg)
+        {
+            if (ThrowOnKey < 0 || ThrowOnKey == entry.Key)
+            {
+                if (ThrowErr)
+                    throw new Exception(ExceptionText);
+
+                if (ThrowErrPortable)
+                    throw new PortableTestException {Info = ExceptionText};
+
+                if (ThrowErrNonSerializable)
+                    throw new NonSerializableException();
+            }
+
+            Assert.AreEqual(Exists, entry.Exists);
+
+            if (Remove)
+                entry.Remove();
+            else
+                entry.Value = entry.Value + arg;
+            
+            return entry.Value;
+        }
+
+        /** <inheritdoc /> */
+        public int Process(IMutableCacheEntry<int, int> entry, int arg)
+        {
+            throw new Exception("Invalid method");
+        }
+    }
+
+    /// <summary>
+    /// Portable add processor.
+    /// </summary>
+    public class PortableAddArgCacheEntryProcessor : AddArgCacheEntryProcessor, IPortableMarshalAware
+    {
+        /** <inheritdoc /> */
+        public void WritePortable(IPortableWriter writer)
+        {
+            var w = writer.RawWriter();
+
+            w.WriteBoolean(ThrowErr);
+            w.WriteBoolean(ThrowErrPortable);
+            w.WriteBoolean(ThrowErrNonSerializable);
+            w.WriteInt(ThrowOnKey);
+            w.WriteBoolean(Remove);
+            w.WriteBoolean(Exists);
+        }
+
+        /** <inheritdoc /> */
+        public void ReadPortable(IPortableReader reader)
+        {
+            var r = reader.RawReader();
+
+            ThrowErr = r.ReadBoolean();
+            ThrowErrPortable = r.ReadBoolean();
+            ThrowErrNonSerializable = r.ReadBoolean();
+            ThrowOnKey = r.ReadInt();
+            Remove = r.ReadBoolean();
+            Exists = r.ReadBoolean();
+        }
+    }
+
+    /// <summary>
+    /// Non-serializable processor.
+    /// </summary>
+    public class NonSerializableCacheEntryProcessor : AddArgCacheEntryProcessor
+    {
+        // No-op.
+    }
+
+    /// <summary>
+    /// Portable exception.
+    /// </summary>
+    public class PortableTestException : Exception, IPortableMarshalAware
+    {
+        /// <summary>
+        /// Gets or sets exception info.
+        /// </summary>
+        public string Info { get; set; }
+
+        /** <inheritdoc /> */
+        public override string Message
+        {
+            get { return Info; }
+        }
+
+        /** <inheritdoc /> */
+        public void WritePortable(IPortableWriter writer)
+        {
+            writer.RawWriter().WriteString(Info);
+        }
+
+        /** <inheritdoc /> */
+        public void ReadPortable(IPortableReader reader)
+        {
+            Info = reader.RawReader().ReadString();
+        }
+    }
+
+    /// <summary>
+    /// Non-serializable exception.
+    /// </summary>
+    public class NonSerializableException : Exception
+    {
+        // No-op
+    }
+
+    /// <summary>
+    ///
+    /// </summary>
+    [SuppressMessage("ReSharper", "UnusedVariable")]
+    public abstract class CacheAbstractTest {
+        /// <summary>
+        ///
+        /// </summary>
+        [TestFixtureSetUp]
+        public virtual void StartGrids() {
+            TestUtils.KillProcesses();
+
+            IgniteConfigurationEx cfg = new IgniteConfigurationEx();
+
+            PortableConfiguration portCfg = new PortableConfiguration();
+
+            ICollection<PortableTypeConfiguration> portTypeCfgs = new List<PortableTypeConfiguration>();
+
+            portTypeCfgs.Add(new PortableTypeConfiguration(typeof(PortablePerson)));
+            portTypeCfgs.Add(new PortableTypeConfiguration(typeof(CacheTestKey)));
+            portTypeCfgs.Add(new PortableTypeConfiguration(typeof(TestReferenceObject)));
+            portTypeCfgs.Add(new PortableTypeConfiguration(typeof(PortableAddArgCacheEntryProcessor)));
+            portTypeCfgs.Add(new PortableTypeConfiguration(typeof(PortableTestException)));
+
+            portCfg.TypeConfigurations = portTypeCfgs;
+
+            cfg.PortableConfiguration = portCfg;
+            cfg.JvmClasspath = TestUtils.CreateTestClasspath();
+            cfg.JvmOptions = TestUtils.TestJavaOptions();
+            cfg.SpringConfigUrl = "config\\native-client-test-cache.xml";
+
+            for (int i = 0; i < GridCount(); i++) {
+                cfg.GridName = "grid-" + i;
+
+                Ignition.Start(cfg);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        [TestFixtureTearDown]
+        public virtual void StopGrids() {
+            for (int i = 0; i < GridCount(); i++)
+                Ignition.Stop("grid-" + i, true);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        [SetUp]
+        public virtual void BeforeTest()
+        {
+            Console.WriteLine("Test started: " + TestContext.CurrentContext.Test.Name);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        [TearDown]
+        public virtual void AfterTest() {
+            for (int i = 0; i < GridCount(); i++) 
+                Cache(i).RemoveAll();
+
+            for (int i = 0; i < GridCount(); i++)
+            {
+                var cache = Cache(i);
+
+                if (!cache.IsEmpty())
+                {
+                    var entries = Enumerable.Range(0, 2000)
+                        .Select(x => new KeyValuePair<int, int>(x, cache.LocalPeek(x)))
+                        .Where(x => x.Value != 0)
+                        .Select(pair => pair.ToString() + GetKeyAffinity(cache, pair.Key))
+                        .Aggregate((acc, val) => string.Format("{0}, {1}", acc, val));
+
+                    Assert.Fail("Cache '{0}' is not empty in grid [{1}]: ({2})", CacheName(), i, entries);
+                }
+            }
+
+            Console.WriteLine("Test finished: " + TestContext.CurrentContext.Test.Name);
+        }
+
+        public IIgnite GetIgnite(int idx)
+        {
+            return Ignition.GetIgnite("grid-" + idx);
+        }
+
+        public ICache<int, int> Cache(int idx) {
+            return Cache<int, int>(idx);
+        }
+
+        public ICache<TK, TV> Cache<TK, TV>(int idx) {
+            return GetIgnite(idx).GetCache<TK, TV>(CacheName());
+        }
+
+        public ICache<int, int> Cache()
+        {
+            return Cache<int, int>(0);
+        }
+
+        public ICache<TK, TV> Cache<TK, TV>()
+        {
+            return Cache<TK, TV>(0);
+        }
+
+        public ICacheAffinity Affinity()
+        {
+            return GetIgnite(0).GetAffinity(CacheName());
+        }
+
+        public ITransactions Transactions
+        {
+            get { return GetIgnite(0).GetTransactions(); }
+        }
+
+        [Test]
+        public void TestCircularReference()
+        {
+            var cache = Cache().WithKeepPortable<int, object>();
+
+            TestReferenceObject obj1 = new TestReferenceObject();
+
+            obj1.Obj = new TestReferenceObject(obj1);
+
+            cache.Put(1, obj1);
+
+            var po = (IPortableObject) cache.Get(1);
+
+            Assert.IsNotNull(po);
+
+            TestReferenceObject objRef = po.Deserialize<TestReferenceObject>();
+
+            Assert.IsNotNull(objRef);
+        }
+
+        [Test]
+        public void TestName()
+        {
+            for (int i = 0; i < GridCount(); i++ )
+                Assert.AreEqual(CacheName(), Cache(i).Name);
+        }
+
+        [Test]
+        public void TestIsEmpty()
+        {
+            for (int i = 0; i < GridCount(); i++)
+            {
+                var cache = Cache(i);
+
+                Assert.IsTrue(cache.IsEmpty());
+            }
+
+            for (int i = 0; i < GridCount(); i++)
+            {
+                var cache = Cache(i);
+
+                cache.Put(PrimaryKeyForCache(cache), 1);
+            }
+
+            for (int i = 0; i < GridCount(); i++)
+            {
+                var cache = Cache(i);
+
+                Assert.IsFalse(cache.IsEmpty());
+            }
+        }
+
+        [Test]
+        public void TestContainsKey()
+        {
+            var cache = Cache();
+
+            int key = PrimaryKeyForCache(cache);
+
+            cache.Put(key, 1);
+
+            Assert.IsTrue(cache.ContainsKey(key));
+            Assert.IsFalse(cache.ContainsKey(-1));
+        }
+        
+        [Test]
+        public void TestContainsKeys()
+        {
+            var cache = Cache();
+
+            var keys = PrimaryKeysForCache(cache, 5);
+
+            Assert.IsFalse(cache.ContainsKeys(keys));
+
+            cache.PutAll(keys.ToDictionary(k => k, k => k));
+
+            Assert.IsTrue(cache.ContainsKeys(keys));
+
+            Assert.IsFalse(cache.ContainsKeys(keys.Concat(new[] {int.MaxValue})));
+        }
+        
+        [Test]
+        public void TestPeek()
+        {
+            var cache = Cache();
+
+            int key1 = PrimaryKeyForCache(cache);
+
+            cache.Put(key1, 1);
+
+            Assert.AreEqual(1, cache.LocalPeek(key1));
+            Assert.AreEqual(0, cache.LocalPeek(-1));
+
+            Assert.AreEqual(1, cache.LocalPeek(key1, CachePeekMode.All));
+            Assert.AreEqual(0, cache.LocalPeek(-1, CachePeekMode.All));
+        }
+
+        [Test]
+        public void TestGet()
+        {
+            var cache = Cache();
+
+            cache.Put(1, 1);
+            cache.Put(2, 2);
+
+            Assert.AreEqual(1, cache.Get(1));
+            Assert.AreEqual(2, cache.Get(2));
+            Assert.AreEqual(0, cache.Get(3));
+        }
+
+        [Test]
+        public void TestGetAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            cache.Put(1, 1);
+            cache.Put(2, 2);
+            
+            Assert.AreEqual(1, cache.Get(1));
+            Assert.AreEqual(2, cache.Get(2));
+            Assert.AreEqual(0, cache.Get(3));
+        }
+
+        [Test]
+        public void TestGetAll()
+        {
+            var cache = Cache();
+
+            cache.Put(1, 1);
+            cache.Put(2, 2);
+            cache.Put(3, 3);
+            cache.Put(4, 4);
+            cache.Put(5, 5);
+
+            IDictionary<int, int> map = cache.GetAll(new List<int> { 0, 1, 2, 5 });
+
+            Assert.AreEqual(3, map.Count);
+
+            Assert.AreEqual(1, map[1]);
+            Assert.AreEqual(2, map[2]);
+        }
+
+        [Test]
+        public void TestGetAllAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            cache.Put(1, 1);
+            cache.Put(2, 2);
+            cache.Put(3, 3);
+
+            var map = cache.GetAll(new List<int> { 0, 1, 2 });
+
+            Assert.AreEqual(2, map.Count);
+
+            Assert.AreEqual(1, map[1]);
+            Assert.AreEqual(2, map[2]);
+        }
+
+        [Test]
+        public void TestGetAndPut()
+        {
+            var cache = Cache();
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            int old = cache.GetAndPut(1, 1);
+
+            Assert.AreEqual(0, old);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            old = cache.GetAndPut(1, 2);
+
+            Assert.AreEqual(1, old);
+
+            Assert.AreEqual(2, cache.Get(1));
+        }
+
+        [Test]
+        public void TestGetAndReplace()
+        {
+            var cache = Cache();
+
+            cache.Put(1, 10);
+
+            Assert.AreEqual(10, cache.GetAndReplace(1, 100));
+
+            Assert.AreEqual(0, cache.GetAndReplace(2, 2));
+
+            Assert.AreEqual(0, cache.Get(2));
+
+            Assert.AreEqual(100, cache.Get(1));
+
+            Assert.IsTrue(cache.Remove(1));
+        }
+
+        [Test]
+        public void TestGetAndRemove()
+        {
+            var cache = Cache();
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.AreEqual(0, cache.GetAndRemove(0));
+            
+            Assert.AreEqual(1, cache.GetAndRemove(1));
+            
+            Assert.AreEqual(0, cache.GetAndRemove(1));
+            
+            Assert.AreEqual(0, cache.Get(1));
+        }
+
+        [Test]
+        public void TestGetAndPutAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            int old = cache.GetAndPut(1, 1);
+
+            Assert.AreEqual(0, old);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            old = cache.GetAndPut(1, 2);
+
+            Assert.AreEqual(1, old);
+
+            Assert.AreEqual(2, cache.Get(1));
+        }
+
+        [Test]
+        public void TestPut()
+        {
+            var cache = Cache();
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+        }
+
+        [Test]
+        public void TestPutxAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+        }
+
+        [Test]
+        public void TestPutIfAbsent()
+        {
+            var cache = Cache();
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            Assert.AreEqual(true, cache.PutIfAbsent(1, 1));
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.AreEqual(false, cache.PutIfAbsent(1, 2));
+
+            Assert.AreEqual(1, cache.Get(1));
+        }
+
+        [Test]
+        public void TestGetAndPutIfAbsent()
+        {
+            var cache = Cache();
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            Assert.AreEqual(0, cache.GetAndPutIfAbsent(1, 1));
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.AreEqual(1, cache.GetAndPutIfAbsent(1, 2));
+
+            Assert.AreEqual(1, cache.Get(1));
+        }
+
+        [Test]
+        public void TestGetAndPutIfAbsentAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            int old = cache.GetAndPutIfAbsent(1, 1);
+
+            Assert.AreEqual(0, old);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            old = cache.GetAndPutIfAbsent(1, 2);
+
+            Assert.AreEqual(1, old);
+
+            Assert.AreEqual(1, cache.Get(1));
+        }
+
+        [Test]
+        public void TestPutIfAbsentAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            Assert.IsTrue(cache.PutIfAbsent(1, 1));
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.IsFalse(cache.PutIfAbsent(1, 2));
+
+            Assert.AreEqual(1, cache.Get(1));
+        }
+
+        [Test]
+        public void TestReplace()
+        {
+            var cache = Cache();
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            bool success = cache.Replace(1, 1);
+
+            Assert.AreEqual(false, success);
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            success = cache.Replace(1, 2);
+
+            Assert.AreEqual(true, success);
+
+            Assert.AreEqual(2, cache.Get(1));
+
+            Assert.IsFalse(cache.Replace(1, -1, 3));
+
+            Assert.AreEqual(2, cache.Get(1));
+
+            Assert.IsTrue(cache.Replace(1, 2, 3));
+
+            Assert.AreEqual(3, cache.Get(1));
+        }
+
+        [Test]
+        public void TestGetAndReplaceAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            int old = cache.GetAndReplace(1, 1);
+
+            Assert.AreEqual(0, old);
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            old = cache.GetAndReplace(1, 2);
+
+            Assert.AreEqual(1, old);
+
+            Assert.AreEqual(2, cache.Get(1));
+
+            Assert.IsFalse(cache.Replace(1, -1, 3));
+
+            Assert.AreEqual(2, cache.Get(1));
+
+            Assert.IsTrue(cache.Replace(1, 2, 3));
+
+            Assert.AreEqual(3, cache.Get(1));
+        }
+
+        [Test]
+        public void TestReplacex()
+        {
+            var cache = Cache();
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            Assert.IsFalse(cache.Replace(1, 1));
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.IsTrue(cache.Replace(1, 2));
+
+            Assert.AreEqual(2, cache.Get(1));
+        }
+
+        [Test]
+        public void TestReplaceAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            Assert.IsFalse(cache.Replace(1, 1));
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.IsTrue(cache.Replace(1, 2));
+
+            Assert.AreEqual(2, cache.Get(1));
+        }
+
+        [Test]
+        public void TestPutAll()
+        {
+            var cache = Cache();
+
+            cache.PutAll(new Dictionary<int, int> { { 1, 1 }, { 2, 2 }, { 3, 3 } });
+
+            Assert.AreEqual(1, cache.Get(1));
+            Assert.AreEqual(2, cache.Get(2));
+            Assert.AreEqual(3, cache.Get(3));
+        }
+
+        [Test]
+        public void TestPutAllAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            cache.PutAll(new Dictionary<int, int> { { 1, 1 }, { 2, 2 }, { 3, 3 } });
+
+            Assert.AreEqual(1, cache.Get(1));
+            Assert.AreEqual(2, cache.Get(2));
+            Assert.AreEqual(3, cache.Get(3));
+        }
+
+        /// <summary>
+        /// Expiry policy tests.
+        /// </summary>
+        [Test]
+        public void TestWithExpiryPolicy()
+        {
+            ICache<int, int> cache0 = Cache(0);
+            
+            int key0;
+            int key1;
+
+            if (LocalCache())
+            {
+                key0 = 0;
+                key1 = 1;
+            }
+            else
+            {
+                key0 = PrimaryKeyForCache(cache0);
+                key1 = PrimaryKeyForCache(Cache(1));
+            }
+            
+            // Test unchanged expiration.
+            ICache<int, int> cache = cache0.WithExpiryPolicy(new ExpiryPolicy(null, null, null));
+
+            cache.Put(key0, key0);
+            cache.Put(key1, key1);
+            Thread.Sleep(200);
+            Assert.IsTrue(cache0.ContainsKey(key0));
+            Assert.IsTrue(cache0.ContainsKey(key1));
+
+            cache.Put(key0, key0 + 1);
+            cache.Put(key1, key1 + 1);
+            Thread.Sleep(200);
+            Assert.IsTrue(cache0.ContainsKey(key0));
+            Assert.IsTrue(cache0.ContainsKey(key1));
+
+            cache.Get(key0);
+            cache.Get(key1);
+            Thread.Sleep(200);
+            Assert.IsTrue(cache0.ContainsKey(key0));
+            Assert.IsTrue(cache0.ContainsKey(key1));
+
+            cache0.RemoveAll(new List<int> { key0, key1 });
+
+            // Test eternal expiration.
+            cache = cache0.WithExpiryPolicy(new ExpiryPolicy(TimeSpan.MaxValue, TimeSpan.MaxValue, TimeSpan.MaxValue));
+
+            cache.Put(key0, key0);
+            cache.Put(key1, key1);
+            Thread.Sleep(200);
+            Assert.IsTrue(cache0.ContainsKey(key0));
+            Assert.IsTrue(cache0.ContainsKey(key1));
+
+            cache.Put(key0, key0 + 1);
+            cache.Put(key1, key1 + 1);
+            Thread.Sleep(200);
+            Assert.IsTrue(cache0.ContainsKey(key0));
+            Assert.IsTrue(cache0.ContainsKey(key1));
+
+            cache.Get(key0);
+            cache.Get(key1);
+            Thread.Sleep(200);
+            Assert.IsTrue(cache0.ContainsKey(key0));
+            Assert.IsTrue(cache0.ContainsKey(key1));
+
+            cache0.RemoveAll(new List<int> { key0, key1 });
+
+            // Test zero expiration.
+            cache = cache0.WithExpiryPolicy(new ExpiryPolicy(TimeSpan.Zero, TimeSpan.Zero, TimeSpan.Zero));
+
+            cache.Put(key0, key0);
+            cache.Put(key1, key1);
+            Assert.IsFalse(cache0.ContainsKey(key0));
+            Assert.IsFalse(cache0.ContainsKey(key1));
+
+            cache0.Put(key0, key0);
+            cache0.Put(key1, key1);
+            Assert.IsTrue(cache0.ContainsKey(key0));
+            Assert.IsTrue(cache0.ContainsKey(key1));
+            cache.Put(key0, key0 + 1);
+            cache.Put(key1, key1 + 1);
+            Assert.IsFalse(cache0.ContainsKey(key0));
+            Assert.IsFalse(cache0.ContainsKey(key1));
+
+            cache0.Put(key0, key0);
+            cache0.Put(key1, key1);
+            cache.Get(key0);
+            cache.Get(key1);
+            Assert.IsFalse(cache0.ContainsKey(key0));
+            Assert.IsFalse(cache0.ContainsKey(key1));
+
+            cache0.RemoveAll(new List<int> { key0, key1 });
+
+            // Test negative expiration.
+            cache = cache0.WithExpiryPolicy(new ExpiryPolicy(TimeSpan.FromMilliseconds(-100), 
+                TimeSpan.FromMilliseconds(-100), TimeSpan.FromMilliseconds(-100)));
+
+            cache.Put(key0, key0);
+            cache.Put(key1, key1);
+            Assert.IsFalse(cache0.ContainsKey(key0));
+            Assert.IsFalse(cache0.ContainsKey(key1));
+
+            cache0.Put(key0, key0);
+            cache0.Put(key1, key1);
+            Assert.IsTrue(cache0.ContainsKey(key0));
+            Assert.IsTrue(cache0.ContainsKey(key1));
+            cache.Put(key0, key0 + 1);
+            cache.Put(key1, key1 + 1);
+            Assert.IsFalse(cache0.ContainsKey(key0));
+            Assert.IsFalse(cache0.ContainsKey(key1));
+
+            cache0.Put(key0, key0);
+            cache0.Put(key1, key1);
+            cache.Get(key0);
+            cache.Get(key1);
+            Assert.IsFalse(cache0.ContainsKey(key0));
+            Assert.IsFalse(cache0.ContainsKey(key1));
+
+            cache0.RemoveAll(new List<int> { key0, key1 });
+
+            // Test regular expiration.
+            cache = cache0.WithExpiryPolicy(new ExpiryPolicy(TimeSpan.FromMilliseconds(100),
+                TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(100)));
+
+            cache.Put(key0, key0);
+            cache.Put(key1, key1);
+            Assert.IsTrue(cache0.ContainsKey(key0));
+            Assert.IsTrue(cache0.ContainsKey(key1));
+            Thread.Sleep(200);
+            Assert.IsFalse(cache0.ContainsKey(key0));
+            Assert.IsFalse(cache0.ContainsKey(key1));
+
+            cache0.Put(key0, key0);
+            cache0.Put(key1, key1);
+            cache.Put(key0, key0 + 1);
+            cache.Put(key1, key1 + 1);
+            Assert.IsTrue(cache0.ContainsKey(key0));
+            Assert.IsTrue(cache0.ContainsKey(key1));
+            Thread.Sleep(200);
+            Assert.IsFalse(cache0.ContainsKey(key0));
+            Assert.IsFalse(cache0.ContainsKey(key1));
+
+            cache0.Put(key0, key0);
+            cache0.Put(key1, key1);
+            cache.Get(key0); 
+            cache.Get(key1);
+            Assert.IsTrue(cache0.ContainsKey(key0));
+            Assert.IsTrue(cache0.ContainsKey(key1));
+            Thread.Sleep(200);
+            Assert.IsFalse(cache0.ContainsKey(key0));
+            Assert.IsFalse(cache0.ContainsKey(key1));
+        }
+
+        [Test]
+        public void TestEvict()
+        {
+            var cache = Cache();
+
+            int key = PrimaryKeyForCache(cache);
+
+            cache.Put(key, 1);
+
+            Assert.AreEqual(1, PeekInt(cache, key));
+
+            cache.LocalEvict(new[] {key});
+
+            Assert.AreEqual(0, cache.GetLocalSize(CachePeekMode.Onheap));
+
+            Assert.AreEqual(0, PeekInt(cache, key));
+
+            Assert.AreEqual(1, cache.Get(key));
+
+            Assert.AreEqual(1, cache.GetLocalSize(CachePeekMode.Onheap));
+
+            Assert.AreEqual(1, PeekInt(cache, key));
+        }
+
+        [Test]
+        public void TestEvictAllKeys()
+        {
+            var cache = Cache();
+
+            List<int> keys = PrimaryKeysForCache(cache, 3);
+
+            cache.Put(keys[0], 1);
+            cache.Put(keys[1], 2);
+            cache.Put(keys[2], 3);
+
+            Assert.AreEqual(1, PeekInt(cache, keys[0]));
+            Assert.AreEqual(2, PeekInt(cache, keys[1]));
+            Assert.AreEqual(3, PeekInt(cache, keys[2]));
+
+            cache.LocalEvict(new List<int> { -1, keys[0], keys[1] });
+
+            Assert.AreEqual(1, cache.GetLocalSize(CachePeekMode.Onheap));
+
+            Assert.AreEqual(0, PeekInt(cache, keys[0]));
+            Assert.AreEqual(0, PeekInt(cache, keys[1]));
+            Assert.AreEqual(3, PeekInt(cache, keys[2]));
+
+            Assert.AreEqual(1, cache.Get(keys[0]));
+            Assert.AreEqual(2, cache.Get(keys[1]));
+
+            Assert.AreEqual(3, cache.GetLocalSize());
+
+            Assert.AreEqual(1, PeekInt(cache, keys[0]));
+            Assert.AreEqual(2, PeekInt(cache, keys[1]));
+            Assert.AreEqual(3, PeekInt(cache, keys[2]));
+        }
+
+        [Test]
+        public void TestClear()
+        {
+            for (int i = 0; i < GridCount(); i++)
+            {
+                var cache = Cache(i);
+
+                cache.Put(PrimaryKeyForCache(cache, 500), 1);
+
+                Assert.IsFalse(cache.IsEmpty());
+            }
+
+            Cache().Clear();
+
+            for (int i = 0; i < GridCount(); i++)
+                Assert.IsTrue(Cache(i).IsEmpty());
+        }
+
+        [Test]
+        public void TestClearKey()
+        {
+            var cache = Cache();
+            var keys = PrimaryKeysForCache(cache, 10);
+
+            foreach (var key in keys)
+                cache.Put(key, 3);
+
+            var i = cache.GetSize();
+
+            foreach (var key in keys)
+            {
+                cache.Clear(key);
+
+                Assert.AreEqual(0, cache.Get(key));
+
+                Assert.Less(cache.GetSize(), i);
+
+                i = cache.GetSize();
+            }
+        }
+
+        [Test]
+        public void TestClearKeys()
+        {
+            var cache = Cache();
+            var keys = PrimaryKeysForCache(cache, 10);
+
+            foreach (var key in keys)
+                cache.Put(key, 3);
+
+            cache.ClearAll(keys);
+
+            foreach (var key in keys)
+                Assert.AreEqual(0, cache.Get(key));
+        }
+
+        [Test]
+        public void TestLocalClearKey()
+        {
+            var cache = Cache();
+            var keys = PrimaryKeysForCache(cache, 10);
+
+            foreach (var key in keys)
+                cache.Put(key, 3);
+
+            var i = cache.GetSize();
+
+            foreach (var key in keys)
+            {
+                cache.LocalClear(key);
+
+                Assert.AreEqual(0, cache.LocalPeek(key));
+
+                Assert.Less(cache.GetSize(), i);
+
+                i = cache.GetSize();
+            }
+
+            cache.Clear();
+        }
+
+        [Test]
+        public void TestLocalClearKeys()
+        {
+            var cache = Cache();
+            var keys = PrimaryKeysForCache(cache, 10);
+
+            foreach (var key in keys)
+                cache.Put(key, 3);
+
+            cache.LocalClearAll(keys);
+
+            foreach (var key in keys)
+                Assert.AreEqual(0, cache.LocalPeek(key));
+
+            cache.Clear();
+        }
+
+        [Test]
+        public void TestRemove()
+        {
+            var cache = Cache();
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.AreEqual(true, cache.Remove(1));
+
+            Assert.AreEqual(0, cache.GetSize());
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.IsFalse(cache.Remove(1, -1));
+            Assert.IsTrue(cache.Remove(1, 1));
+
+            Assert.AreEqual(0, cache.GetSize());
+
+            Assert.AreEqual(0, cache.Get(1));
+        }
+
+        [Test]
+        public void TestGetAndRemoveAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.AreEqual(1, cache.GetAndRemove(1));
+
+            Assert.AreEqual(0, cache.GetSize());
+
+            Assert.AreEqual(0, cache.Get(1));
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.IsFalse(cache.Remove(1, -1));
+            Assert.IsTrue(cache.Remove(1, 1));
+
+            Assert.AreEqual(0, cache.GetSize());
+
+            Assert.AreEqual(0, cache.Get(1));
+        }
+
+        [Test]
+        public void TestRemovex()
+        {
+            var cache = Cache();
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.IsFalse(cache.Remove(-1));
+            Assert.IsTrue(cache.Remove(1));
+
+            Assert.AreEqual(0, cache.GetSize());
+
+            Assert.AreEqual(0, cache.Get(1));
+        }
+
+        [Test]
+        public void TestRemoveAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            cache.Put(1, 1);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.IsFalse(cache.Remove(-1));
+            Assert.IsTrue(cache.Remove(1));
+
+            Assert.AreEqual(0, cache.GetSize());
+
+            Assert.AreEqual(0, cache.Get(1));
+        }
+
+        [Test]
+        public void TestRemoveAll()
+        {
+            var cache = Cache();
+
+            List<int> keys = PrimaryKeysForCache(cache, 2);
+
+            cache.Put(keys[0], 1);
+            cache.Put(keys[1], 2);
+
+            Assert.AreEqual(1, cache.Get(keys[0]));
+            Assert.AreEqual(2, cache.Get(keys[1]));
+
+            cache.RemoveAll();
+
+            Assert.AreEqual(0, cache.GetSize());
+
+            Assert.AreEqual(0, cache.Get(keys[0]));
+            Assert.AreEqual(0, cache.Get(keys[1]));
+        }
+
+        [Test]
+        public void TestRemoveAllAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            List<int> keys = PrimaryKeysForCache(cache, 2);
+
+            cache.Put(keys[0], 1);
+            cache.Put(keys[1], 2);
+
+            Assert.AreEqual(1, cache.Get(keys[0]));
+            Assert.AreEqual(2, cache.Get(keys[1]));
+
+            cache.RemoveAll();
+
+            Assert.AreEqual(0, cache.GetSize());
+
+            Assert.AreEqual(0, cache.Get(keys[0]));
+            Assert.AreEqual(0, cache.Get(keys[1]));
+        }
+
+        [Test]
+        public void TestRemoveAllKeys()
+        {
+            var cache = Cache();
+
+            Assert.AreEqual(0, cache.GetSize());
+
+            cache.Put(1, 1);
+            cache.Put(2, 2);
+            cache.Put(3, 3);
+
+            Assert.AreEqual(1, cache.Get(1));
+            Assert.AreEqual(2, cache.Get(2));
+            Assert.AreEqual(3, cache.Get(3));
+
+            cache.RemoveAll(new List<int> { 0, 1, 2 });
+
+            Assert.AreEqual(1, cache.GetSize(CachePeekMode.Primary));
+
+            Assert.AreEqual(0, cache.Get(1));
+            Assert.AreEqual(0, cache.Get(2));
+            Assert.AreEqual(3, cache.Get(3));
+        }
+
+        [Test]
+        public void TestRemoveAllKeysAsync()
+        {
+            var cache = Cache().WithAsync().WrapAsync();
+
+            Assert.AreEqual(0, cache.GetSize());
+
+            cache.Put(1, 1);
+            cache.Put(2, 2);
+            cache.Put(3, 3);
+
+            Assert.AreEqual(1, cache.Get(1));
+            Assert.AreEqual(2, cache.Get(2));
+            Assert.AreEqual(3, cache.Get(3));
+
+            cache.RemoveAll(new List<int> { 0, 1, 2 });
+
+            Assert.AreEqual(1, cache.GetSize(CachePeekMode.Primary));
+
+            Assert.AreEqual(0, cache.Get(1));
+            Assert.AreEqual(0, cache.Get(2));
+            Assert.AreEqual(3, cache.Get(3));
+        }
+
+        [Test]
+        public void TestSizes()
+        {
+            for (int i = 0; i < GridCount(); i++)
+            {
+                var cache = Cache(i);
+
+                List<int> keys = PrimaryKeysForCache(cache, 2);
+
+                foreach (int key in keys)
+                    cache.Put(key, 1);
+
+                Assert.IsTrue(cache.GetSize() >= 2);
+                Assert.AreEqual(2, cache.GetLocalSize(CachePeekMode.Primary));
+            }
+
+            ICache<int, int> cache0 = Cache();
+
+            Assert.AreEqual(GridCount() * 2, cache0.GetSize(CachePeekMode.Primary));
+
+            if (!LocalCache() && !ReplicatedCache())
+            {
+                int nearKey = NearKeyForCache(cache0);
+
+                cache0.Put(nearKey, 1);
+
+                Assert.AreEqual(NearEnabled() ? 1 : 0, cache0.GetSize(CachePeekMode.Near));
+            }
+        }
+
+        [Test]
+        public void TestLocalSize()
+        {
+            var cache = Cache();
+            var keys = PrimaryKeysForCache(cache, 3);
+
+            cache.Put(keys[0], 1);
+            cache.Put(keys[1], 2);
+
+            var localSize = cache.GetLocalSize();
+
+            cache.LocalEvict(keys.Take(2).ToArray());
+
+            Assert.AreEqual(0, cache.GetLocalSize(CachePeekMode.Onheap));
+            Assert.AreEqual(localSize, cache.GetLocalSize(CachePeekMode.All));
+
+            cache.Put(keys[2], 3);
+
+            Assert.AreEqual(localSize + 1, cache.GetLocalSize(CachePeekMode.All));
+
+            cache.RemoveAll(keys.Take(2).ToArray());
+        }
+
+        /// <summary>
+        /// Test enumerators.
+        /// </summary>
+        [Test]
+        [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
+        public void TestEnumerators()
+        {
+            var cache = Cache();
+            var keys = PrimaryKeysForCache(cache, 2);
+
+            cache.Put(keys[0], keys[0] + 1);
+            cache.Put(keys[1], keys[1] + 1);
+
+            // Check distributed enumerator.
+            IEnumerable<ICacheEntry<int, int>> e = cache;
+
+            CheckEnumerator(e.GetEnumerator(), keys);
+            CheckEnumerator(e.GetEnumerator(), keys);
+
+            // Check local enumerator.
+            e = cache.GetLocalEntries();
+
+            CheckEnumerator(e.GetEnumerator(), keys);
+            CheckEnumerator(e.GetEnumerator(), keys);
+
+            // Evict and check peek modes.
+            cache.LocalEvict(new List<int> { keys[0] } );
+
+            e = cache.GetLocalEntries(CachePeekMode.Onheap);
+            CheckEnumerator(e.GetEnumerator(), new List<int> { keys[1] });
+            CheckEnumerator(e.GetEnumerator(), new List<int> { keys[1] });
+
+            e = cache.GetLocalEntries(CachePeekMode.All);
+            CheckEnumerator(e.GetEnumerator(), keys);
+            CheckEnumerator(e.GetEnumerator(), keys);
+
+            e = cache.GetLocalEntries(CachePeekMode.Onheap, CachePeekMode.Swap);
+            CheckEnumerator(e.GetEnumerator(), keys);
+            CheckEnumerator(e.GetEnumerator(), keys);
+
+            cache.Remove(keys[0]);
+        }
+
+        /// <summary>
+        /// Check enumerator content.
+        /// </summary>
+        /// <param name="e">Enumerator.</param>
+        /// <param name="keys">Keys.</param>
+        private static void CheckEnumerator(IEnumerator<ICacheEntry<int, int>> e, IList<int> keys)
+        {
+            CheckEnumerator0(e, keys);
+
+            e.Reset();
+
+            CheckEnumerator0(e, keys);
+
+            e.Dispose();
+
+            Assert.Throws<ObjectDisposedException>(() => { e.MoveNext(); });
+            Assert.Throws<ObjectDisposedException>(() => { var entry = e.Current; });
+            Assert.Throws<ObjectDisposedException>(e.Reset);
+
+            e.Dispose();
+        }
+
+        /// <summary>
+        /// Check enumerator content.
+        /// </summary>
+        /// <param name="e">Enumerator.</param>
+        /// <param name="keys">Keys.</param>
+        private static void CheckEnumerator0(IEnumerator<ICacheEntry<int, int>> e, IList<int> keys)
+        {
+            Assert.Throws<InvalidOperationException>(() => { var entry = e.Current; });
+
+            int cnt = 0;
+
+            while (e.MoveNext())
+            {
+                ICacheEntry<int, int> entry = e.Current;
+
+                Assert.IsTrue(keys.Contains(entry.Key), "Unexpected entry: " + entry);
+
+                Assert.AreEqual(entry.Key + 1, entry.Value);
+
+                cnt++;
+            }
+
+            Assert.AreEqual(keys.Count, cnt);
+
+            Assert.IsFalse(e.MoveNext());
+
+            Assert.Throws<InvalidOperationException>(() => { var entry = e.Current; });
+        }
+
+        [Test]
+        public void TestPromote()
+        {
+            var cache = Cache();
+
+            int key = PrimaryKeyForCache(cache);
+
+            cache.Put(key, 1);
+
+            Assert.AreEqual(1, PeekInt(cache, key));
+
+            cache.LocalEvict(new[] {key});
+
+            Assert.AreEqual(0, cache.GetLocalSize(CachePeekMode.Onheap));
+
+            Assert.AreEqual(0, PeekInt(cache, key));
+
+            cache.LocalPromote(new[] { key });
+
+            Assert.AreEqual(1, cache.GetLocalSize(CachePeekMode.Onheap));
+
+            Assert.AreEqual(1, PeekInt(cache, key));
+        }
+
+        [Test]
+        public void TestPromoteAll()
+        {
+            var cache = Cache();
+
+            List<int> keys = PrimaryKeysForCache(cache, 3);
+
+            cache.Put(keys[0], 1);
+            cache.Put(keys[1], 2);
+            cache.Put(keys[2], 3);
+
+            Assert.AreEqual(1, PeekInt(cache, keys[0]));
+            Assert.AreEqual(2, PeekInt(cache, keys[1]));
+            Assert.AreEqual(3, PeekInt(cache, keys[2]));
+
+            cache.LocalEvict(new List<int> { -1, keys[0], keys[1] });
+
+            Assert.AreEqual(1, cache.GetLocalSize(CachePeekMode.Onheap));
+
+            Assert.AreEqual(0, PeekInt(cache, keys[0]));
+            Assert.AreEqual(0, PeekInt(cache, keys[1]));
+            Assert.AreEqual(3, PeekInt(cache, keys[2]));
+
+            cache.LocalPromote(new[] {keys[0], keys[1]});
+
+            Assert.AreEqual(3, cache.GetLocalSize(CachePeekMode.Onheap));
+
+            Assert.AreEqual(1, PeekInt(cache, keys[0]));
+            Assert.AreEqual(2, PeekInt(cache, keys[1]));
+            Assert.AreEqual(3, PeekInt(cache, keys[2]));
+        }
+
+        [Test]
+        public void TestPutGetPortable()
+        {
+            var cache = Cache<int, PortablePerson>();
+
+            PortablePerson obj1 = new PortablePerson("obj1", 1);
+
+            cache.Put(1, obj1);
+
+            obj1 = cache.Get(1);
+
+            Assert.AreEqual("obj1", obj1.Name);
+            Assert.AreEqual(1, obj1.Age);
+        }
+
+        [Test]
+        public void TestPutGetPortableAsync()
+        {
+            var cache = Cache<int, PortablePerson>().WithAsync().WrapAsync();
+
+            PortablePerson obj1 = new PortablePerson("obj1", 1);
+
+            cache.Put(1, obj1);
+
+            obj1 = cache.Get(1);
+
+            Assert.AreEqual("obj1", obj1.Name);
+            Assert.AreEqual(1, obj1.Age);
+        }
+
+        [Test]
+        public void TestPutGetPortableKey()
+        {
+            var cache = Cache<CacheTestKey, string>();
+
+            int cnt = 100;
+
+            for (int i = 0; i < cnt; i++)
+                cache.Put(new CacheTestKey(i), "val-" + i);
+
+            for (int i = 0; i < cnt; i++)
+                Assert.AreEqual("val-" + i, cache.Get(new CacheTestKey(i)));
+        }
+
+        [Test]
+        public void TestGetAsync2()
+        {
+            var cache = Cache().WithAsync();
+
+            for (int i = 0; i < 100; i++)
+            {
+                cache.Put(i, i);
+
+                cache.GetFuture<object>().Get();
+            }
+
+            var futs = new List<IFuture<int>>();
+
+            for (int i = 0; i < 1000; i++)
+            {
+                cache.Get(i % 100);
+
+                futs.Add(cache.GetFuture<int>());
+            }
+
+            for (int i = 0; i < 1000; i++) {
+                Assert.AreEqual(i % 100, futs[i].Get(), "Unexpected result: " + i);
+
+                Assert.IsTrue(futs[i].IsDone);
+            }
+        }
+
+        [Test]
+        [Category(TestUtils.CategoryIntensive)]
+        public void TestGetAsyncMultithreaded()
+        {
+            var cache = Cache().WithAsync();
+
+            for (int i = 0; i < 100; i++)
+            {
+                cache.Put(i, i);
+
+                cache.GetFuture<object>().Get();
+            }
+
+            TestUtils.RunMultiThreaded(() =>
+            {
+                for (int i = 0; i < 100; i++)
+                {
+                    var futs = new List<IFuture<int>>();
+
+                    for (int j = 0; j < 100; j++)
+                    {
+                        cache.Get(j);
+
+                        futs.Add(cache.GetFuture<int>());
+                    }
+
+                    for (int j = 0; j < 100; j++)
+                        Assert.AreEqual(j, futs[j].Get());
+                }
+            }, 10);
+        }
+
+        [Test]
+        [Category(TestUtils.CategoryIntensive)]
+        public void TestPutxAsyncMultithreaded()
+        {
+            var cache = Cache().WithAsync();
+
+            TestUtils.RunMultiThreaded(() =>
+            {
+                Random rnd = new Random();
+
+                for (int i = 0; i < 50; i++)
+                {
+                    var futs = new List<IFuture<object>>();
+
+                    for (int j = 0; j < 10; j++)
+                    {
+                        cache.Put(rnd.Next(1000), i);
+
+                        futs.Add(cache.GetFuture<object>());
+                    }
+
+                    foreach (var fut in futs)
+                        fut.Get();
+                }
+            }, 5);
+        }
+
+        [Test]
+        [Category(TestUtils.CategoryIntensive)]
+        public void TestPutGetAsyncMultithreaded()
+        {
+            var cache = Cache<CacheTestKey, PortablePerson>().WithAsync();
+
+            const int threads = 10;
+            const int objPerThread = 1000;
+
+            int cntr = 0;
+
+            TestUtils.RunMultiThreaded(() =>
+            {
+                // ReSharper disable once AccessToModifiedClosure
+                int threadIdx = Interlocked.Increment(ref cntr);
+
+                var futs = new List<IFuture<object>>();
+
+                for (int i = 0; i < objPerThread; i++)
+                {
+                    int key = threadIdx * objPerThread + i;
+
+                    cache.Put(new CacheTestKey(key), new PortablePerson("Person-" + key, key));
+
+                    futs.Add(cache.GetFuture<object>());
+                }
+
+                foreach (var fut in futs)
+                {
+                    fut.Get();
+
+                    Assert.IsTrue(fut.IsDone);
+                }
+            }, threads);
+
+            for (int i = 0; i < threads; i++)
+            {
+                int threadIdx = i + 1;
+
+                for (int j = 0; j < objPerThread; j++)
+                {
+                    int key = threadIdx * objPerThread + i;
+
+                    cache.Get(new CacheTestKey(key));
+                    var p = cache.GetFuture<PortablePerson>().Get();
+
+                    Assert.IsNotNull(p);
+                    Assert.AreEqual(key, p.Age);
+                    Assert.AreEqual("Person-" + key, p.Name);
+                }
+            }
+
+            cntr = 0;
+
+            TestUtils.RunMultiThreaded(() =>
+            {
+                int threadIdx = Interlocked.Increment(ref cntr);
+
+                for (int i = 0; i < objPerThread; i++)
+                {
+                    int key = threadIdx * objPerThread + i;
+
+                    cache.Put(new CacheTestKey(key), new PortablePerson("Person-" + key, key));
+
+                    cache.GetFuture<object>().Get();
+                }
+            }, threads);
+
+            cntr = 0;
+
+            TestUtils.RunMultiThreaded(() =>
+            {
+                int threadIdx = Interlocked.Increment(ref cntr);
+
+                var futs = new List<IFuture<PortablePerson>>();
+
+                for (int i = 0; i < objPerThread; i++)
+                {
+                    int key = threadIdx * objPerThread + i;
+
+                    cache.Get(new CacheTestKey(key));
+
+                    futs.Add(cache.GetFuture<PortablePerson>());
+                }
+
+                for (int i = 0; i < objPerThread; i++)
+                {
+                    var fut = futs[i];
+
+                    int key = threadIdx * objPerThread + i;
+
+                    var p = fut.Get();
+
+                    Assert.IsNotNull(p);
+                    Assert.AreEqual(key, p.Age);
+                    Assert.AreEqual("Person-" + key, p.Name);
+                }
+            }, threads);
+        }
+
+        //[Test]
+        //[Category(TestUtils.CATEGORY_INTENSIVE)]
+        public void TestAsyncMultithreadedKeepPortable()
+        {
+            var cache = Cache().WithAsync().WithKeepPortable<CacheTestKey, PortablePerson>();
+            var portCache = Cache().WithAsync().WithKeepPortable<CacheTestKey, IPortableObject>();
+
+            const int threads = 10;
+            const int objPerThread = 1000;
+
+            int cntr = 0;
+
+            TestUtils.RunMultiThreaded(() =>
+            {
+                // ReSharper disable once AccessToModifiedClosure
+                int threadIdx = Interlocked.Increment(ref cntr);
+
+                var futs = new List<IFuture<object>>();
+
+                for (int i = 0; i < objPerThread; i++)
+                {
+                    int key = threadIdx * objPerThread + i;
+
+                    cache.Put(new CacheTestKey(key), new PortablePerson("Person-" + key, key));
+
+                    futs.Add(cache.GetFuture<object>());
+                }
+
+                foreach (var fut in futs)
+                    Assert.IsNull(fut.Get());
+            }, threads);
+
+            for (int i = 0; i < threads; i++)
+            {
+                int threadIdx = i + 1;
+
+                for (int j = 0; j < objPerThread; j++)
+                {
+                    int key = threadIdx * objPerThread + i;
+
+                    IPortableObject p = portCache.Get(new CacheTestKey(key));
+
+                    Assert.IsNotNull(p);
+                    Assert.AreEqual(key, p.GetField<int>("age"));
+                    Assert.AreEqual("Person-" + key, p.GetField<string>("name"));
+                }
+            }
+
+            cntr = 0;
+
+            TestUtils.RunMultiThreaded(() =>
+            {
+                int threadIdx = Interlocked.Increment(ref cntr);
+
+                var futs = new List<IFuture<IPortableObject>>();
+
+                for (int i = 0; i < objPerThread; i++)
+                {
+                    int key = threadIdx * objPerThread + i;
+
+                    portCache.Get(new CacheTestKey(key));
+
+                    futs.Add(cache.GetFuture<IPortableObject>());
+                }
+
+                for (int i = 0; i < objPerThread; i++)
+                {
+                    var fut = futs[i];
+
+                    int key = threadIdx * objPerThread + i;
+
+                    var p = fut.Get();
+
+                    Assert.IsNotNull(p);
+                    Assert.AreEqual(key, p.GetField<int>("age"));
+                    Assert.AreEqual("Person-" + key, p.GetField<string>("name"));
+                }
+            }, threads);
+
+            cntr = 0;
+
+            TestUtils.RunMultiThreaded(() =>
+            {
+                int threadIdx = Interlocked.Increment(ref cntr);
+
+                var futs = new List<IFuture<bool>>();
+
+                for (int i = 0; i < objPerThread; i++)
+                {
+                    int key = threadIdx * objPerThread + i;
+
+                    cache.Remove(new CacheTestKey(key));
+
+                    futs.Add(cache.GetFuture<bool>());
+                }
+
+                for (int i = 0; i < objPerThread; i++)
+                {
+                    var fut = futs[i];
+
+                    Assert.AreEqual(true, fut.Get());
+                }
+            }, threads);
+        }
+
+        [Test]
+        [Ignore("IGNITE-835")]
+        public void TestLock()
+        {
+            if (!LockingEnabled())
+                return;
+
+            var cache = Cache();
+
+            const int key = 7;
+
+            // Lock
+            CheckLock(cache, key, () => cache.Lock(key));
+
+            // LockAll
+            CheckLock(cache, key, () => cache.LockAll(new[] { key, 2, 3, 4, 5 }));
+        }
+
+        /// <summary>
+        /// Internal lock test routine.
+        /// </summary>
+        /// <param name="cache">Cache.</param>
+        /// <param name="key">Key.</param>
+        /// <param name="getLock">Function to get the lock.</param>
+        private static void CheckLock(ICache<int, int> cache, int key, Func<ICacheLock> getLock)
+        {
+            var sharedLock = getLock();
+            
+            using (sharedLock)
+            {
+                Assert.Throws<InvalidOperationException>(() => sharedLock.Exit());  // can't exit if not entered
+
+                sharedLock.Enter();
+
+                try
+                {
+                    Assert.IsTrue(cache.IsLocalLocked(key, true));
+                    Assert.IsTrue(cache.IsLocalLocked(key, false));
+
+                    EnsureCannotLock(getLock, sharedLock);
+
+                    sharedLock.Enter();
+
+                    try
+                    {
+                        Assert.IsTrue(cache.IsLocalLocked(key, true));
+                        Assert.IsTrue(cache.IsLocalLocked(key, false));
+
+                        EnsureCannotLock(getLock, sharedLock);
+                    }
+                    finally
+                    {
+                        sharedLock.Exit();
+                    }
+
+                    Assert.IsTrue(cache.IsLocalLocked(key, true));
+                    Assert.IsTrue(cache.IsLocalLocked(key, false));
+
+                    EnsureCannotLock(getLock, sharedLock);
+
+                    Assert.Throws<SynchronizationLockException>(() => sharedLock.Dispose()); // can't dispose while locked
+                }
+                finally
+                {
+                    sharedLock.Exit();
+                }
+
+                Assert.IsFalse(cache.IsLocalLocked(key, true));
+                Assert.IsFalse(cache.IsLocalLocked(key, false));
+
+                var innerTask = new Task(() =>
+                {
+                    Assert.IsTrue(sharedLock.TryEnter());
+                    sharedLock.Exit();
+
+                    using (var otherLock = getLock())
+                    {
+                        Assert.IsTrue(otherLock.TryEnter());
+                        otherLock.Exit();
+                    }
+                });
+
+                innerTask.Start();
+                innerTask.Wait();
+            }
+            
+            Assert.IsFalse(cache.IsLocalLocked(key, true));
+            Assert.IsFalse(cache.IsLocalLocked(key, false));
+            
+            var outerTask = new Task(() =>
+            {
+                using (var otherLock = getLock())
+                {
+                    Assert.IsTrue(otherLock.TryEnter());
+                    otherLock.Exit();
+                }
+            });
+
+            outerTask.Start();
+            outerTask.Wait();
+
+            Assert.Throws<ObjectDisposedException>(() => sharedLock.Enter());  // Can't enter disposed lock
+        }
+
+        /// <summary>
+        /// ENsure taht lock cannot be obtained by other threads.
+        /// </summary>
+        /// <param name="getLock">Get lock function.</param>
+        /// <param name="sharedLock">Shared lock.</param>
+        private static void EnsureCannotLock(Func<ICacheLock> getLock, ICacheLock sharedLock)
+        {
+            var task = new Task(() =>
+            {
+                Assert.IsFalse(sharedLock.TryEnter());
+                Assert.IsFalse(sharedLock.TryEnter(TimeSpan.FromMilliseconds(100)));
+
+                using (var otherLock = getLock())
+                {
+                    Assert.IsFalse(otherLock.TryEnter());
+                    Assert.IsFalse(otherLock.TryEnter(TimeSpan.FromMilliseconds(100)));
+                }
+            });
+
+            task.Start();
+            task.Wait();
+        }
+
+        [Test]
+        public void TestTxCommit()
+        {
+            TestTxCommit(false);
+        }
+
+        [Test]
+        public void TestTxCommitAsync()
+        {
+            TestTxCommit(true);
+        }
+
+        private void TestTxCommit(bool async)
+        {
+            if (!TxEnabled())
+                return;
+
+            var cache = Cache();
+
+            ITransaction tx = Transactions.Tx;
+
+            Assert.IsNull(tx);
+
+            tx = Transactions.TxStart();
+
+            try
+            {
+                cache.Put(1, 1);
+
+                cache.Put(2, 2);
+
+                if (async)
+                {
+                    var asyncTx = tx.WithAsync();
+                    
+                    asyncTx.Commit();
+
+                    var fut = asyncTx.GetFuture();
+
+                    fut.Get();
+
+                    Assert.IsTrue(fut.IsDone);
+                    Assert.AreEqual(fut.Get(), null);
+                }
+                else
+                    tx.Commit();
+            }
+            finally
+            {
+                tx.Dispose();
+            }
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.AreEqual(2, cache.Get(2));
+
+            tx = Transactions.Tx;
+
+            Assert.IsNull(tx);
+        }
+
+        [Test]
+        public void TestTxRollback()
+        {
+            if (!TxEnabled())
+                return;
+
+            var cache = Cache();
+
+            cache.Put(1, 1);
+
+            cache.Put(2, 2);
+
+            ITransaction tx = Transactions.Tx;
+
+            Assert.IsNull(tx);
+
+            tx = Transactions.TxStart();
+
+            try {
+                cache.Put(1, 10);
+
+                cache.Put(2, 20);
+            }
+            finally {
+                tx.Rollback();
+            }
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.AreEqual(2, cache.Get(2));
+
+            Assert.IsNull(Transactions.Tx);
+        }
+
+        [Test]
+        public void TestTxClose()
+        {
+            if (!TxEnabled())
+                return;
+
+            var cache = Cache();
+
+            cache.Put(1, 1);
+
+            cache.Put(2, 2);
+
+            ITransaction tx = Transactions.Tx;
+
+            Assert.IsNull(tx);
+
+            tx = Transactions.TxStart();
+
+            try
+            {
+                cache.Put(1, 10);
+
+                cache.Put(2, 20);
+            }
+            finally
+            {
+                tx.Dispose();
+            }
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.AreEqual(2, cache.Get(2));
+
+            tx = Transactions.Tx;
+
+            Assert.IsNull(tx);
+        }
+        
+        [Test]
+        public void TestTxAllModes()
+        {
+            TestTxAllModes(false);
+
+            TestTxAllModes(true);
+
+            Console.WriteLine("Done");
+        }
+
+        protected void TestTxAllModes(bool withTimeout)
+        {
+            if (!TxEnabled())
+                return;
+
+            var cache = Cache();
+
+            int cntr = 0;
+
+            foreach (TransactionConcurrency concurrency in Enum.GetValues(typeof(TransactionConcurrency))) {
+                foreach (TransactionIsolation isolation in Enum.GetValues(typeof(TransactionIsolation))) {
+                    Console.WriteLine("Test tx [concurrency=" + concurrency + ", isolation=" + isolation + "]");
+
+                    ITransaction tx = Transactions.Tx;
+
+                    Assert.IsNull(tx);
+
+                    tx = withTimeout 
+                        ? Transactions.TxStart(concurrency, isolation, TimeSpan.FromMilliseconds(1100), 10)
+                        : Transactions.TxStart(concurrency, isolation);
+
+                    Assert.AreEqual(concurrency, tx.Concurrency);
+                    Assert.AreEqual(isolation, tx.Isolation);
+
+                    if (withTimeout)
+                        Assert.AreEqual(1100, tx.Timeout.TotalMilliseconds);
+
+                    try {
+                        cache.Put(1, cntr);
+
+                        tx.Commit();
+                    }
+                    finally {
+                        tx.Dispose();
+                    }
+
+                    tx = Transactions.Tx;
+
+                    Assert.IsNull(tx);
+
+                    Assert.AreEqual(cntr, cache.Get(1));
+
+                    cntr++;
+                }
+            }
+        }
+
+        [Test]
+        public void TestTxAttributes()
+        {
+            if (!TxEnabled())
+                return;
+
+            ITransaction tx = Transactions.TxStart(TransactionConcurrency.Optimistic,
+                TransactionIsolation.RepeatableRead, TimeSpan.FromMilliseconds(2500), 100);
+
+            Assert.IsFalse(tx.IsRollbackOnly);
+            Assert.AreEqual(TransactionConcurrency.Optimistic, tx.Concurrency);
+            Assert.AreEqual(TransactionIsolation.RepeatableRead, tx.Isolation);
+            Assert.AreEqual(2500, tx.Timeout.TotalMilliseconds);
+            Assert.AreEqual(TransactionState.Active, tx.State);
+            Assert.IsTrue(tx.StartTime.Ticks > 0);
+            Assert.AreEqual(tx.NodeId, GetIgnite(0).GetCluster().GetLocalNode().Id);
+
+            DateTime startTime1 = tx.StartTime;
+
+            tx.Commit();
+
+            Assert.IsFalse(tx.IsRollbackOnly);
+            Assert.AreEqual(TransactionState.Committed, tx.State);
+            Assert.AreEqual(TransactionConcurrency.Optimistic, tx.Concurrency);
+            Assert.AreEqual(TransactionIsolation.RepeatableRead, tx.Isolation);
+            Assert.AreEqual(2500, tx.Timeout.TotalMilliseconds);
+            Assert.AreEqual(startTime1, tx.StartTime);
+
+            Thread.Sleep(100);
+
+            tx = Transactions.TxStart(TransactionConcurrency.Pessimistic, TransactionIsolation.ReadCommitted,
+                TimeSpan.FromMilliseconds(3500), 200);
+
+            Assert.IsFalse(tx.IsRollbackOnly);
+            Assert.AreEqual(TransactionConcurrency.Pessimistic, tx.Concurrency);
+            Assert.AreEqual(TransactionIsolation.ReadCommitted, tx.Isolation);
+            Assert.AreEqual(3500, tx.Timeout.TotalMilliseconds);
+            Assert.AreEqual(TransactionState.Active, tx.State);
+            Assert.IsTrue(tx.StartTime.Ticks > 0);
+            Assert.IsTrue(tx.StartTime > startTime1);
+
+            DateTime startTime2 = tx.StartTime;
+
+            tx.Rollback();
+
+            Assert.AreEqual(TransactionState.RolledBack, tx.State);
+            Assert.AreEqual(TransactionConcurrency.Pessimistic, tx.Concurrency);
+            Assert.AreEqual(TransactionIsolation.ReadCommitted, tx.Isolation);
+            Assert.AreEqual(3500, tx.Timeout.TotalMilliseconds);
+            Assert.AreEqual(startTime2, tx.StartTime);
+
+            Thread.Sleep(100);
+
+            tx = Transactions.TxStart(TransactionConcurrency.Optimistic, TransactionIsolation.RepeatableRead,
+                TimeSpan.FromMilliseconds(2500), 100);
+
+            Assert.IsFalse(tx.IsRollbackOnly);
+            Assert.AreEqual(TransactionConcurrency.Optimistic, tx.Concurrency);
+            Assert.AreEqual(TransactionIsolation.RepeatableRead, tx.Isolation);
+            Assert.AreEqual(2500, tx.Timeout.TotalMilliseconds);
+            Assert.AreEqual(TransactionState.Active, tx.State);
+            Assert.IsTrue(tx.StartTime > startTime2);
+
+            DateTime startTime3 = tx.StartTime;
+
+            tx.Commit();
+
+            Assert.IsFalse(tx.IsRollbackOnly);
+            Assert.AreEqual(TransactionState.Committed, tx.State);
+            Assert.AreEqual(TransactionConcurrency.Optimistic, tx.Concurrency);
+            Assert.AreEqual(TransactionIsolation.RepeatableRead, tx.Isolation);
+            Assert.AreEqual(2500, tx.Timeout.TotalMilliseconds);
+            Assert.AreEqual(startTime3, tx.StartTime);
+        }
+
+        [Test]
+        public void TestTxRollbackOnly()
+        {
+            if (!TxEnabled())
+                return;
+
+            var cache = Cache();
+
+            cache.Put(1, 1);
+
+            cache.Put(2, 2);
+
+            ITransaction tx = Transactions.TxStart();
+
+            cache.Put(1, 10);
+
+            cache.Put(2, 20);
+
+            Assert.IsFalse(tx.IsRollbackOnly);
+
+            tx.SetRollbackonly();
+
+            Assert.IsTrue(tx.IsRollbackOnly);
+
+            Assert.AreEqual(TransactionState.MarkedRollback, tx.State);
+
+            try
+            {
+                tx.Commit();
+
+                Assert.Fail("Commit must fail.");
+            }
+            catch (IgniteException e)
+            {
+                Console.WriteLine("Expected exception: " + e);
+            }
+
+            tx.Dispose();
+
+            Assert.AreEqual(TransactionState.RolledBack, tx.State);
+
+            Assert.IsTrue(tx.IsRollbackOnly);
+
+            Assert.AreEqual(1, cache.Get(1));
+
+            Assert.AreEqual(2, cache.Get(2));
+
+            tx = Transactions.Tx;
+
+            Assert.IsNull(tx);
+        }
+
+        [Test]
+        public void TestTxMetrics()
+        {
+            if (!TxEnabled())
+                return;
+
+            var cache = Cache();
+            
+            var startTime = DateTime.UtcNow.AddSeconds(-1);
+
+            Transactions.ResetMetrics();
+
+            var metrics = Transactions.GetMetrics();
+            
+            Assert.AreEqual(0, metrics.TxCommits);
+            Assert.AreEqual(0, metrics.TxRollbacks);
+
+            using (Transactions.TxStart())
+            {
+                cache.Put(1, 1);
+            }
+            
+            using (var tx = Transactions.TxStart())
+            {
+                cache.Put(1, 1);
+                tx.Commit();
+            }
+
+            metrics = Transactions.GetMetrics();
+
+            Assert.AreEqual(1, metrics.TxCommits);
+            Assert.AreEqual(1, metrics.TxRollbacks);
+
+            Assert.LessOrEqual(startTime, metrics.CommitTime);
+            Assert.LessOrEqual(startTime, metrics.RollbackTime);
+
+            Assert.GreaterOrEqual(DateTime.UtcNow, metrics.CommitTime);
+            Assert.GreaterOrEqual(DateTime.UtcNow, metrics.RollbackTime);
+        }
+
+        [Test]
+        public void TestTxStateAndExceptions()
+        {
+            if (!TxEnabled())
+                return;
+
+            var tx = Transactions.TxStart();
+            
+            Assert.AreEqual(TransactionState.Active, tx.State);
+
+            tx.Rollback();
+
+            Assert.AreEqual(TransactionState.RolledBack, tx.State);
+
+            try
+            {
+                tx.Commit();
+                Assert.Fail();
+            }
+            catch (InvalidOperationException)
+            {
+                // Expected
+            }
+
+            tx = Transactions.TxStart().WithAsync();
+
+            Assert.AreEqual(TransactionState.Active, tx.State);
+
+            tx.Commit();
+
+            tx.GetFuture().Get();
+
+            Assert.AreEqual(TransactionState.Committed, tx.State);
+
+            tx.Rollback();  // Illegal, but should not fail here; will fail in future
+
+            try
+            {
+                tx.GetFuture<object>().Get();
+                Assert.Fail();
+            }
+            catch (InvalidOperationException)
+            {
+                // Expected
+            }
+        }
+        
+        /// <summary>
+        /// Test thraed-locals leak.
+        /// </summary>
+        [Test]
+        [Category(TestUtils.CategoryIntensive)]
+        public void TestThreadLocalLeak()
+        {
+            var cache = Cache<string, string>();
+
+            Exception err = null;
+
+            const int threadCnt = 10;
+
+            Thread[] threads = new Thread[threadCnt];
+
+            ThreadStart[] threadStarts = new ThreadStart[threadCnt];
+
+            for (int j = 0; j < threadCnt; j++)
+            {
+                string key = "key" + j;
+
+                threadStarts[j] = () =>
+                {
+                    try
+                    {
+                        cache.Put(key, key);
+
+                        Assert.AreEqual(key, cache.Get(key));
+                    }
+                    catch (Exception e)
+                    {
+                        Interlocked.CompareExchange(ref err, e, null);
+
+                        Assert.Fail("Unexpected error: " + e);
+                    }
+                };
+            }
+
+            for (int i = 0; i < 100 && err == null; i++)
+            {
+                for (int j = 0 ; j < threadCnt; j++) {
+                    Thread t = new Thread(threadStarts[j]);
+
+                    threads[j] = t;
+                }
+
+                foreach (Thread t in threads)
+                    t.Start();
+
+                foreach (Thread t in threads)
+                    t.Join();
+
+                if (i % 500 == 0)
+                {
+                    Console.WriteLine("Iteration: " + i);
+
+                    GC.Collect();
+                }
+            }
+
+            Assert.IsNull(err);
+        }
+        
+        /**
+         * Test tries to provoke garbage collection for .Net future before it was completed to verify
+         * futures pinning works.
+         */
+        [Test]
+        [Category(TestUtils.CategoryIntensive)]
+        public void TestFuturesGc()
+        {
+            var cache = Cache().WithAsync();
+
+            cache.Put(1, 1);
+
+            for (int i = 0; i < 10; i++)
+            {
+                TestUtils.RunMultiThreaded(() =>
+                {
+                    for (int j = 0; j < 1000; j++)
+                        cache.Get(1);
+                }, 5);
+
+                GC.Collect();
+
+                cache.Get(1);
+                Assert.AreEqual(1, cache.GetFuture<int>().Get());
+            }
+
+            Thread.Sleep(2000);
+        }
+
+        [Test]
+        public void TestPartitions()
+        {
+            ICacheAffinity aff = Affinity();
+
+            for (int i = 0; i < 5; i++ )
+                Assert.AreEqual(CachePartitions(), aff.Partitions);
+        }
+
+        [Test]
+        public void TestKeyPartition()
+        {
+            ICacheAffinity aff = Affinity();
+
+            {
+                ISet<int> parts = new HashSet<int>();
+
+                for (int i = 0; i < 1000; i++)
+                    parts.Add(aff.GetPartition(i));
+
+                if (LocalCache())
+                    Assert.AreEqual(1, parts.Count);
+                else
+                    Assert.IsTrue(parts.Count > 10);
+            }
+
+            {
+                ISet<int> parts = new HashSet<int>();
+
+                for (int i = 0; i < 1000; i++)
+                    parts.Add(aff.GetPartition("key" + i));
+
+                if (LocalCache())
+                    Assert.AreEqual(1, parts.Count);
+                else
+                    Assert.IsTrue(parts.Count > 10);
+            }
+        }
+
+        [Test]
+        public void TestIsPrimaryOrBackup()
+        {
+            ICacheAffinity aff = Affinity();
+
+            ICollection<IClusterNode> nodes = GetIgnite(0).GetCluster().GetNodes();
+
+            Assert.IsTrue(nodes.Count > 0);
+
+            IClusterNode node = nodes.First();
+
+            {
+                bool found = false;
+
+                for (int i = 0; i < 1000; i++)
+                {
+                    if (aff.IsPrimary(node, i))
+                    {
+                        Assert.IsTrue(aff.IsPrimaryOrBackup(node, i));
+
+                        found = true;
+
+                        if (nodes.Count > 1)
+                            Assert.IsFalse(aff.IsPrimary(nodes.Last(), i));
+
+                        break;
+                    }
+                }
+
+                Assert.IsTrue(found, "Failed to find primary key for node " + node);
+            }
+
+            if (nodes.Count > 1)
+            {
+                bool found = false;
+
+                for (int i = 0; i < 1000; i++)
+                {
+                    if (aff.IsBackup(node, i))
+                    {
+                        Assert.IsTrue(aff.IsPrimaryOrBackup(node, i));
+
+                        found = true;
+
+                        break;
+                    }
+                }
+
+                Assert.IsTrue(found, "Failed to find backup key for node " + node);
+            }
+        }
+
+        [Test]
+        public void TestNodePartitions()
+        {
+            ICacheAffinity aff = Affinity();
+
+            ICollection<IClusterNode> nodes = GetIgnite(0).GetCluster().GetNodes();
+
+            Assert.IsTrue(nodes.Count > 0);
+
+            if (nodes.Count == 1)
+            {
+                IClusterNode node = nodes.First();
+
+                int[] parts = aff.GetBackupPartitions(node);
+
+                Assert.AreEqual(0, parts.Length);
+
+                parts = aff.GetAllPartitions(node);
+
+                Assert.AreEqual(CachePartitions(), parts.Length);
+            }
+            else
+            {
+                IList<int> allPrimaryParts = new List<int>();
+                IList<int> allBackupParts = new List<int>();
+                IList<int> allParts = new List<int>();
+
+                foreach(IClusterNode node in nodes) {
+                    int[] parts = aff.GetPrimaryPartitions(node);
+
+                    foreach (int part in parts)
+                        allPrimaryParts.Add(part);
+
+                    parts = aff.GetBackupPartitions(node);
+
+                    foreach (int part in parts)
+                        allBackupParts.Add(part);
+
+                    parts = aff.GetAllPartitions(node);
+
+                    foreach (int part in parts)
+                        allParts.Add(part);
+                }
+
+                Assert.AreEqual(CachePartitions(), allPrimaryParts.Count);
+                Assert.AreEqual(CachePartitions() * Backups(), allBackupParts.Count);
+                Assert.AreEqual(CachePartitions() * (Backups() + 1), allParts.Count);
+            }
+        }
+
+        [Test]
+        public void TestAffinityKey()
+        {
+            ICacheAffinity aff = Affinity();
+
+            Assert.AreEqual(10, aff.GetAffinityKey<int, int>(10));
+
+            Assert.AreEqual("string", aff.GetAffinityKey<string, string>("string"));
+        }
+
+        [Test]
+        public void TestMapToNode()
+        {
+            ICacheAffinity aff = Affinity();
+
+            const int key = 1;
+
+            IClusterNode node = aff.MapKeyToNode(key);
+
+            Assert.IsNotNull(node);
+
+            Assert.IsTrue(GetIgnite(0).GetCluster().GetNodes().Contains(node));
+
+            Assert.IsTrue(aff.IsPrimary(node, key));
+
+            Assert.IsTrue(aff.IsPrimaryOrBackup(node, key));
+
+            Assert.IsFalse(aff.IsBackup(node, key));
+
+            int part = aff.GetPartition(key);
+
+            IClusterNode partNode = aff.MapPartitionToNode(part);
+
+            Assert.AreEqual(node, partNode);
+        }
+
+        [Test]
+        public void TestMapToPrimaryAndBackups()
+        {
+            ICacheAffinity aff = Affinity();
+
+            const int key = 1;
+
+            IList<IClusterNode> nodes = aff.MapKeyToPrimaryAndBackups(key);
+
+            Assert.IsTrue(nodes.Count > 0);
+
+            for (int i = 0; i < nodes.Count; i++)
+            {
+                if (i == 0)
+                    Assert.IsTrue(aff.IsPrimary(nodes[i], key));
+                else
+                    Assert.IsTrue(aff.IsBackup(nodes[i], key));
+            }
+
+            int part = aff.GetPartition(key);
+
+            IList<IClusterNode> partNodes = aff.MapPartitionToPrimaryAndBackups(part);
+
+            Assert.AreEqual(nodes, partNodes);
+        }
+
+        [Test]
+        public void TestMapKeysToNodes()
+        {
+            ICacheAffinity aff = Affinity();
+
+            IList<int> keys = new List<int> {1, 2, 3};
+
+            IDictionary<IClusterNode, IList<int>> map = aff.MapKeysToNodes(keys);
+
+            Assert.IsTrue(map.Count > 0);
+
+            foreach (int key in keys)
+            {
+                IClusterNode primary = aff.MapKeyToNode(key);
+
+                Assert.IsTrue(map.ContainsKey(primary));
+
+                IList<int> nodeKeys = map[primary];
+
+                Assert.IsNotNull(nodeKeys);
+
+                Assert.IsTrue(nodeKeys.Contains(key));
+            }
+        }
+
+        [Test]
+        public void TestMapPartitionsToNodes()
+        {
+            ICacheAffinity aff = Affinity();
+
+            if (LocalCache())
+            {
+                IList<int> parts = new List<int> { 0 };
+
+                IDictionary<int, IClusterNode> map = aff.MapPartitionsToNodes(parts);
+
+                Assert.AreEqual(parts.Count, map.Count);
+
+                Assert.AreEqual(GetIgnite(0).GetCluster().GetLocalNode(), map[0]);
+            }
+            else
+            {
+                IList<int> parts = new List<int> { 1, 2, 3 };
+
+                IDictionary<int, IClusterNode> map = aff.MapPartitionsToNodes(parts);
+
+                Assert.AreEqual(parts.Count, map.Count);
+
+                foreach (int part in parts)
+                {
+                    Assert.IsTrue(map.ContainsKey(part));
+
+                    IClusterNode primary = aff.MapPartitionToNode(part);
+
+                    Assert.AreEqual(primary, map[part], "Wrong node for partition: " + part);
+                }
+            }
+        }
+
+        [Test]
+        public void TestKeepPortableFlag()
+        {
+            TestKeepPortableFlag(false);
+        }
+
+        [Test]
+        public void TestKeepPortableFlagAsync()
+        {
+            TestKeepPortableFlag(true);
+        }
+
+        [Test]
+        public void TestNearKeys()
+        {
+            if (!NearEnabled())
+                return;
+
+            const int count = 20;
+
+            var cache = Cache();
+            var aff = cache.Ignite.GetAffinity(cache.Name);
+            var node = cache.Ignite.GetCluster().GetLocalNode();
+
+            for (int i = 0; i < count; i++)
+                cache.Put(i, -i - 1);
+
+            var nearKeys = Enumerable.Range(0, count).Where(x => !aff.IsPrimaryOrBackup(node, x)).ToArray();
+
+            var nearKeysString = nearKeys.Select(x => x.ToString()).Aggregate((x, y) => x + ", " + y);
+
+            Console.WriteLine("Near keys: " + nearKeysString);
+
+            foreach (var nearKey in nearKeys.Take(3))
+                Assert.AreNotEqual(0, cache.Get(nearKey));
+        }
+        
+        [Test]
+        public void TestSerializable()
+        {
+            var cache = Cache<int, TestSerializableObject>();
+
+            var obj = new TestSerializableObject {Name = "Vasya", Id = 128};
+
+            cache.Put(1, obj);
+
+            var resultObj = cache.Get(1);
+
+            Assert.AreEqual(obj, resultObj);
+        }
+
+        [Test]
+        public void TestInvoke()
+        {
+            TestInvoke(false);
+        }
+
+        [Test]
+        public void TestInvokeAsync()
+        {
+            TestInvoke(true);
+        }
+
+        private void TestInvoke(bool async)
+        {
+            TestInvoke<AddArgCacheEntryProcessor>(async);
+            TestInvoke<PortableAddArgCacheEntryProcessor>(async);
+
+            try
+            {
+                TestInvoke<NonSerializableCacheEntryProcessor>(async);
+                Assert.Fail();
+            }
+            catch (SerializationException)
+            {
+                // Expected
+            }
+        }
+
+        private void TestInvoke<T>(bool async) where T: AddArgCacheEntryProcessor, new()
+        {
+            var cache = async ? Cache().WithAsync().WrapAsync() : Cache();
+
+            cache.Clear();
+
+            const int key = 1;
+            const int value = 3;
+            const int arg = 5;
+
+            cache.Put(key, value);
+
+            // Existing entry
+            Assert.AreEqual(value + arg, cache.Invoke(key, new T(), arg));
+            Assert.AreEqual(value + arg, cache.Get(key));
+
+            // Non-existing entry
+            Assert.AreEqual(arg, cache.Invoke(10, new T {Exists = false}, arg));
+            Assert.AreEqual(arg, cache.Get(10));
+
+            // Remove entry
+            Assert.AreEqual(0, cache.Invoke(key, new T {Remove = true}, arg));
+            Assert.AreEqual(0, cache.Get(key));
+
+            // Test exceptions
+            AssertThrowsCacheEntryProcessorException(() => cache.Invoke(key, new T {ThrowErr = true}, arg));
+            AssertThrowsCacheEntryProcessorException(
+                () => cache.Invoke(key, new T {ThrowErrPortable = true}, arg));
+            AssertThrowsCacheEntryProcessorException(
+                () => cache.Invoke(key, new T { ThrowErrNonSerializable = true }, arg), "SerializationException");
+        }
+
+        private static void AssertThrowsCacheEntryProcessorException(Action action, string containsText = null)
+        {
+            try
+            {
+                action();
+
+                Assert.Fail();
+            }
+            catch (Exception ex)
+            {
+                Assert.IsInstanceOf<CacheEntryProcessorException>(ex);
+
+                if (string.IsNullOrEmpty(containsText))
+                    Assert.AreEqual(ex.InnerException.Message, AddArgCacheEntryProcessor.ExceptionText);
+                else
+                    Assert.IsTrue(ex.ToString().Contains(containsText));
+            }
+        }
+
+        [Test]
+        public void TestInvokeAll()
+        {
+            TestInvokeAll(false);
+        }
+
+        [Test]
+        public void TestInvokeAllAsync()
+        {
+            TestInvokeAll(true);
+        }
+
+        private void TestInvokeAll(bool async)
+        {
+            for (var i = 1; i < 10; i++)
+            {
+                TestInvokeAll<AddArgCacheEntryProcessor>(async, i);
+                TestInvokeAll<PortableAddArgCacheEntryProcessor>(async, i);
+
+                try
+                {
+                    TestInvokeAll<NonSerializableCacheEntryProcessor>(async, i);
+                    Assert.Fail();
+                }
+                catch (SerializationException)
+                {
+                    // Expected
+                }
+            }
+        }
+
+        public void TestInvokeAll<T>(bool async, int entryCount) where T : AddArgCacheEntryProcessor, new()
+        {
+            var cache = async ? Cache().WithAsync().WrapAsync() : Cache();
+
+            var entries = Enumerable.Range(1, entryCount).ToDictionary(x => x, x => x + 1);
+
+            cache.PutAll(entries);
+
+            const int arg = 5;
+
+            // Existing entries
+            var res = cache.InvokeAll(entries.Keys, new T(), arg);
+
+            var results = res.OrderBy(x => x.Key).Select(x => x.Value.Result);
+            var expectedResults = entries.OrderBy(x => x.Key).Select(x => x.Value + arg);
+            
+            Assert.IsTrue(results.SequenceEqual(expectedResults));
+
+            var resultEntries = cache.GetAll(entries.Keys);
+
+            Assert.IsTrue(resultEntries.All(x => x.Value == x.Key + 1 + arg));
+
+            // Remove entries
+            res = cache.InvokeAll(entries.Keys, new T {Remove = true}, arg);
+
+            Assert.IsTrue(res.All(x => x.Value.Result == 0));
+            Assert.AreEqual(0, cache.GetAll(entries.Keys).Count);
+
+            // Non-existing entries
+            res = cache.InvokeAll(entries.Keys, new T {Exists = false}, arg);
+
+            Assert.IsTrue(res.All(x => x.Value.Result == arg));
+            Assert.IsTrue(cache.GetAll(entries.Keys).All(x => x.Value == arg)); 
+
+            // Test exceptions
+            var errKey = entries.Keys.Reverse().Take(5).Last();
+
+            TestInvokeAllException(cache, entries, new T { ThrowErr = true, ThrowOnKey = errKey }, arg, errKey);
+            TestInvokeAllException(cache, entries, new T { ThrowErrPortable = true, ThrowOnKey = errKey }, 
+                arg, errKey);
+            TestInvokeAllException(cache, entries, new T { ThrowErrNonSerializable = true, ThrowOnKey = errKey }, 
+                arg, errKey, "SerializationException");
+
+        }
+
+        private static void TestInvokeAllException<T>(ICache<int, int> cache, Dictionary<int, int> entries, 
+            T processor, int arg, int errKey, string exceptionText = null) where T : AddArgCacheEntryProcessor
+        {
+            var res = cache.InvokeAll(entries.Keys, processor, arg);
+
+            foreach (var procRes in res)
+            {
+                if (procRes.Key == errKey)
+                    // ReSharper disable once AccessToForEachVariableInClosure
+                    AssertThrowsCacheEntryProcessorException(() => { var x = procRes.Value.Result; }, exceptionText);
+                else
+                    Assert.Greater(procRes.Value.Result, 0);
+            }
+        }
+
+        /// <summary>
+        /// Test skip-store semantics.
+        /// </summary>
+        [Test]
+        public void TestSkipStore()
+        {
+            CacheProxyImpl<int, int> cache = (CacheProxyImpl<int, int>)Cache();
+
+            Assert.IsFalse(cache.SkipStore);
+
+            // Ensure correct flag set.
+            CacheProxyImpl<int, int> cacheSkipStore1 = (CacheProxyImpl<int, int>)cache.WithSkipStore();
+
+            Assert.AreNotSame(cache, cacheSkipStore1);
+            Assert.IsFalse(cache.SkipStore);
+            Assert.IsTrue(cacheSkipStore1.SkipStore);
+
+            // Ensure that the same instance is returned if flag is already set.
+            CacheProxyImpl<int, int> cacheSkipStore2 = (CacheProxyImpl<int, int>)cacheSkipStore1.WithSkipStore();
+
+            Assert.IsTrue(cacheSkipStore2.SkipStore);
+            Assert.AreSame(cacheSkipStore1, cacheSkipStore2);
+
+            // Ensure other flags are preserved.
+            Assert.IsTrue(((CacheProxyImpl<int, int>)cache.WithKeepPortable<int, int>().WithSkipStore()).IsKeepPortable);
+            Assert.IsTrue(cache.WithAsync().WithSkipStore().IsAsync);
+        }
+
+        [Test]
+        public void TestCacheMetrics()
+        {
+            var cache = Cache();
+
+            cache.Put(1, 1);
+
+            var m = cache.GetMetrics();
+
+            Assert.AreEqual(cache.Name, m.CacheName);
+
+            Assert.AreEqual(cache.GetSize(), m.Size);
+        }
+
+        [Test]
+        public void TestRebalance()
+        {
+            var cache = Cache();
+
+            var fut = cache.Rebalance();
+
+            Assert.IsNull(fut.Get());
+        }
+
+        [Test]
+        public void TestCreate()
+        {
+            // Create a cache with random name
+            var randomName = "template" + Guid.NewGuid();
+
+            // Can't get non-

<TRUNCATED>

Mime
View raw message