ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [14/50] [abbrv] ignite git commit: IGNITE-2703 .NET: Dynamic type registration
Date Thu, 06 Apr 2017 13:31:21 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/CallbacksTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/CallbacksTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/CallbacksTest.cs
new file mode 100644
index 0000000..a014205
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/CallbacksTest.cs
@@ -0,0 +1,369 @@
+/*
+ * 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.Binary.Serializable
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Runtime.Serialization;
+    using Apache.Ignite.Core.Binary;
+    using Apache.Ignite.Core.Impl.Binary;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Tests that deserialization callbacks are invoked correctly.
+    /// </summary>
+    public class CallbacksTest
+    {
+        /** Deserialization messages. */
+        private static readonly List<string> Messages = new List<string>();
+
+        /// <summary>
+        /// Tests that callbacks are invoked in correct order on class with ISerializable interface.
+        /// </summary>
+        [Test]
+        public void TestSerializable()
+        {
+            CheckCallbacks<SerCallbacks>(true);
+        }
+
+        /// <summary>
+        /// Tests that callbacks are invoked in correct order on class without ISerializable interface.
+        /// </summary>
+        [Test]
+        public void TestNonSerializable()
+        {
+            CheckCallbacks<SerCallbacksNoInterface>(false);
+        }
+
+        /// <summary>
+        /// Tests that callbacks are invoked in correct order on class with ISerializable interface.
+        /// </summary>
+        [Test]
+        public void TestSerializableStruct()
+        {
+            var obj = new SerCallbacksStruct
+            {
+                Name = "Foo",
+                Inner = new SerCallbacksStruct
+                {
+                    Name = "Bar"
+                }
+            };
+
+            Messages.Clear();
+            var res = TestUtils.SerializeDeserialize(obj);
+
+            Assert.AreEqual("Foo", res.Name);
+            Assert.AreEqual("Bar", ((SerCallbacksStruct) res.Inner).Name);
+
+            // OnDeserialization callbacks should be called AFTER entire tree is deserialized.
+            // Other callbacks order is not strictly defined.
+            var expected = new[]
+            {
+                "Foo.OnSerializing",
+                "Bar.OnSerializing",
+                "Bar.OnSerialized",
+                "Foo.OnSerialized",
+                ".OnDeserializing",
+                ".OnDeserializing",
+                "Bar.ctor",
+                "Bar.OnDeserialized",
+                "Foo.ctor",
+                "Foo.OnDeserialized",
+                "Foo.OnDeserialization",
+                "Bar.OnDeserialization",
+            };
+
+            Assert.AreEqual(expected, Messages);
+        }
+
+        /// <summary>
+        /// Tests that callbacks are invoked in correct order on class without ISerializable interface.
+        /// </summary>
+        [Test]
+        public void TestNonSerializableStruct()
+        {
+            var obj = new SerCallbacksStructNoInterface
+            {
+                Name = "Foo",
+                Inner = new SerCallbacksStructNoInterface
+                {
+                    Name = "Bar"
+                }
+            };
+
+            Messages.Clear();
+            var res = TestUtils.SerializeDeserialize(obj);
+
+            Assert.AreEqual("Foo", res.Name);
+            Assert.AreEqual("Bar", ((SerCallbacksStructNoInterface) res.Inner).Name);
+
+            // OnDeserialization callbacks should be called AFTER entire tree is deserialized.
+            // Other callbacks order is not strictly defined.
+            var expected = new[]
+            {
+                "Foo.OnSerializing",
+                "Bar.OnSerializing",
+                "Bar.OnSerialized",
+                "Foo.OnSerialized",
+                ".OnDeserializing",
+                ".OnDeserializing",
+                "Bar.OnDeserialized",
+                "Foo.OnDeserialized",
+                "Foo.OnDeserialization",
+                "Bar.OnDeserialization",
+            };
+
+            Assert.AreEqual(expected, Messages);
+        }
+
+        /// <summary>
+        /// Checks the callbacks.
+        /// </summary>
+        private static void CheckCallbacks<T>(bool ctorCall) where T : SerCallbacksNoInterface, new()
+        {
+            var obj = new T
+            {
+                Name = "Foo",
+                Inner = new T
+                {
+                    Name = "Bar",
+                    Inner = new T
+                    {
+                        Name = "Baz"
+                    }
+                }
+            };
+
+            Messages.Clear();
+            var res = TestUtils.SerializeDeserialize(obj);
+
+            Assert.AreEqual("Foo", res.Name);
+            Assert.AreEqual("Bar", res.Inner.Name);
+            Assert.AreEqual("Baz", res.Inner.Inner.Name);
+
+            // OnDeserialization callbacks should be called AFTER entire tree is deserialized.
+            // Other callbacks order is not strictly defined.
+            var expected = new[]
+            {
+                "Foo.OnSerializing",
+                "Bar.OnSerializing",
+                "Baz.OnSerializing",
+                "Baz.OnSerialized",
+                "Bar.OnSerialized",
+                "Foo.OnSerialized",
+                ".OnDeserializing",
+                ".OnDeserializing",
+                ".OnDeserializing",
+                "Baz.ctor",
+                "Baz.OnDeserialized",
+                "Bar.ctor",
+                "Bar.OnDeserialized",
+                "Foo.ctor",
+                "Foo.OnDeserialized",
+                "Foo.OnDeserialization",
+                "Bar.OnDeserialization",
+                "Baz.OnDeserialization"
+            };
+
+            if (!ctorCall)
+                expected = expected.Where(x => !x.Contains("ctor")).ToArray();
+
+            Assert.AreEqual(expected, Messages);
+        }
+
+        /// <summary>
+        /// Tests that incorrect method signature causes a descriptive exception.
+        /// </summary>
+        [Test]
+        public void TestIncorrectMethodSignature()
+        {
+            var ex = Assert.Throws<TypeLoadException>(
+                    () => TestUtils.SerializeDeserialize(new InvalidCallbackSignature()));
+
+            var t = typeof(InvalidCallbackSignature);
+
+            Assert.AreEqual(string.Format("Type '{0}' in assembly '{1}' has method 'OnDeserializing' " +
+                                          "with an incorrect signature for the serialization attribute that it " +
+                                          "is decorated with.", t, t.Assembly), ex.Message);
+        }
+
+        /// <summary>
+        /// Class with serialization callbacks and <see cref="ISerializable" /> implemented.
+        /// This goes through <see cref="SerializableSerializer"/>.
+        /// </summary>
+        [Serializable]
+        private class SerCallbacks : SerCallbacksNoInterface, ISerializable
+        {
+            public SerCallbacks()
+            {
+            }
+
+            protected SerCallbacks(SerializationInfo info, StreamingContext context)
+            {
+                Name = info.GetString("name");
+                Inner = (SerCallbacks) info.GetValue("inner", typeof(SerCallbacks));
+
+                Messages.Add(string.Format("{0}.ctor", Name));
+            }
+
+            public void GetObjectData(SerializationInfo info, StreamingContext context)
+            {
+                info.AddValue("name", Name);
+                info.AddValue("inner", Inner);
+            }
+        }
+
+        /// <summary>
+        /// Class with serialization callbacks and without <see cref="ISerializable" /> implemented.
+        /// This goes through <see cref="BinaryReflectiveSerializer"/>.
+        /// </summary>
+        [Serializable]
+        private class SerCallbacksNoInterface : IDeserializationCallback
+        {
+            public string Name { get; set; }
+
+            public SerCallbacksNoInterface Inner { get; set; }
+
+            public void OnDeserialization(object sender)
+            {
+                Messages.Add(string.Format("{0}.OnDeserialization", Name));
+            }
+
+            [OnSerializing]
+            public void OnSerializing(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnSerializing", Name));
+            }
+
+            [OnSerialized]
+            public void OnSerialized(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnSerialized", Name));
+            }
+
+            [OnDeserializing]
+            public void OnDeserializing(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnDeserializing", Name));
+            }
+
+            [OnDeserialized]
+            public void OnDeserialized(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnDeserialized", Name));
+            }
+        }
+
+        private class InvalidCallbackSignature
+        {
+            [OnDeserializing]
+            public void OnDeserializing()
+            {
+                // No-op.
+            }
+        }
+
+        [Serializable]
+        private struct SerCallbacksStruct : IDeserializationCallback, ISerializable
+        {
+            public string Name { get; set; }
+
+            public object Inner { get; set; }
+
+            public SerCallbacksStruct(SerializationInfo info, StreamingContext context) : this()
+            {
+                Name = info.GetString("name");
+                Inner = info.GetValue("inner", typeof(object));
+                Messages.Add(string.Format("{0}.ctor", Name));
+            }
+
+            public void GetObjectData(SerializationInfo info, StreamingContext context)
+            {
+                info.AddValue("name", Name);
+                info.AddValue("inner", Inner);
+            }
+
+            public void OnDeserialization(object sender)
+            {
+                Messages.Add(string.Format("{0}.OnDeserialization", Name));
+            }
+
+            [OnSerializing]
+            public void OnSerializing(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnSerializing", Name));
+            }
+
+            [OnSerialized]
+            public void OnSerialized(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnSerialized", Name));
+            }
+
+            [OnDeserializing]
+            public void OnDeserializing(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnDeserializing", Name));
+            }
+
+            [OnDeserialized]
+            public void OnDeserialized(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnDeserialized", Name));
+            }
+        }
+
+        private struct SerCallbacksStructNoInterface : IDeserializationCallback
+        {
+            public string Name { get; set; }
+
+            public object Inner { get; set; }
+
+            public void OnDeserialization(object sender)
+            {
+                Messages.Add(string.Format("{0}.OnDeserialization", Name));
+            }
+
+            [OnSerializing]
+            public void OnSerializing(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnSerializing", Name));
+            }
+
+            [OnSerialized]
+            public void OnSerialized(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnSerialized", Name));
+            }
+
+            [OnDeserializing]
+            public void OnDeserializing(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnDeserializing", Name));
+            }
+
+            [OnDeserialized]
+            public void OnDeserialized(StreamingContext context)
+            {
+                Messages.Add(string.Format("{0}.OnDeserialized", Name));
+            }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/DelegatesTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/DelegatesTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/DelegatesTest.cs
new file mode 100644
index 0000000..90720d4
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/DelegatesTest.cs
@@ -0,0 +1,161 @@
+/*
+ * 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.Binary.Serializable
+{
+    using System;
+    using System.Reflection;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Tests delegate serialization.
+    /// </summary>
+    public class DelegatesTest
+    {
+        /** Test int value. */
+        private static int _int;
+
+        /** Test delegate. */
+        private delegate string LowerSubStringDelegate(string s, int startIndex);
+
+        /// <summary>
+        /// Tests that delegates can be serialized.
+        /// </summary>
+        [Test]
+        public void TestAction()
+        {
+            // Action with captured variable.
+            var val = new PrimitivesTest.Primitives {Int = 135};
+
+            Action act = () => {
+                val.Int++;
+                _int = val.Int;
+            };
+
+            var res = TestUtils.SerializeDeserialize(act);
+            Assert.AreEqual(act.Method, res.Method);
+            Assert.AreNotEqual(act.Target, res.Target);
+
+            res();
+            Assert.AreEqual(135, val.Int);   // Captured variable is deserialized to a new instance.
+            Assert.AreEqual(136, _int);
+
+            // Action with arguments.
+            Action<PrimitivesTest.Primitives, int> act1 = (p, i) => { p.Int = i; };
+
+            var res1 = TestUtils.SerializeDeserialize(act1);
+            Assert.AreEqual(act1.Method, res1.Method);
+
+            res1(val, 33);
+            Assert.AreEqual(33, val.Int);
+        }
+
+        /// <summary>
+        /// Tests that anonymous function can be serialized.
+        /// </summary>
+        [Test]
+        public void TestFunc()
+        {
+            int ms = DateTime.Now.Millisecond;
+
+            Func<int, int> func = x => x + ms;
+
+            var resFunc = TestUtils.SerializeDeserialize(func);
+            Assert.AreEqual(func.Method, resFunc.Method);
+            Assert.AreNotEqual(func.Target, resFunc.Target);
+
+            Assert.AreEqual(ms + 20, resFunc(20));
+        }
+
+        /// <summary>
+        /// Tests that old-fashioned delegate can be serialized.
+        /// </summary>
+        [Test]
+        public void TestDelegate()
+        {
+            // Delegate to a static method.
+            LowerSubStringDelegate del1 = LowerSubString;
+
+            var del1Res = TestUtils.SerializeDeserialize(del1);
+
+            Assert.AreEqual(del1.Method, del1Res.Method);
+            Assert.IsNull(del1Res.Target);
+
+            Assert.AreEqual("ooz", del1Res("FOOZ", 1));
+
+            // Delegate to an anonymous method.
+            LowerSubStringDelegate del2 = (s, i) => s.Substring(i).ToLower();
+
+            var del2Res = TestUtils.SerializeDeserialize(del2);
+
+            Assert.AreEqual(del2.Method, del2Res.Method, "Delegate methods are same");
+
+            Assert.AreEqual("ooz", del2Res("FOOZ", 1), "Delegate works as expected");
+        }
+
+        /// <summary>
+        /// Tests that MethodInfo can be serialized.
+        /// </summary>
+        [Test]
+        public void TestMethodInfo()
+        {
+            var methods = typeof(string).GetMethods(BindingFlags.Public | BindingFlags.NonPublic
+                                                    | BindingFlags.Instance | BindingFlags.Static);
+
+            Assert.IsNotEmpty(methods);
+
+            foreach (var methodInfo in methods)
+            {
+                var res = TestUtils.SerializeDeserialize(methodInfo);
+
+                Assert.AreEqual(methodInfo.Name, res.Name);
+                Assert.AreEqual(methodInfo.DeclaringType, res.DeclaringType);
+                Assert.AreEqual(methodInfo.ReturnType, res.ReturnType);
+                Assert.AreEqual(methodInfo.GetParameters(), res.GetParameters());
+            }
+        }
+
+        /// <summary>
+        /// Tests that recursive anonymous function can be serialized.
+        /// </summary>
+        [Test]
+        public void TestRecursiveFunc()
+        {
+            Func<int, int> fib = null;
+            fib = x => x == 0
+                ? 0
+                : x == 1
+                    ? 1
+                    : fib(x - 2) + fib(x - 1);
+
+            Assert.AreEqual(89, fib(11));
+            Assert.AreEqual(144, fib(12));
+
+            var resFib = TestUtils.SerializeDeserialize(fib);
+
+            Assert.AreEqual(fib.Method, resFib.Method);
+
+            Assert.AreEqual(89, resFib(11));
+            Assert.AreEqual(144, resFib(12));
+        }
+
+        private static string LowerSubString(string s, int startIndex)
+        {
+            return s.Substring(startIndex).ToLower();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/ObjectReferenceTests.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/ObjectReferenceTests.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/ObjectReferenceTests.cs
new file mode 100644
index 0000000..71d2f9a
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/ObjectReferenceTests.cs
@@ -0,0 +1,131 @@
+/*
+ * 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.Binary.Serializable
+{
+    using System;
+    using System.Runtime.Serialization;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Tests that <see cref="IObjectReference"/> objects are deserialized properly.
+    /// This only applies to <see cref="ISerializable"/> implementers, which can replace underlying object
+    /// with <see cref="SerializationInfo.SetType"/>, <see cref="SerializationInfo.AssemblyName"/>, and
+    /// <see cref="SerializationInfo.FullTypeName"/>.
+    /// </summary>
+    public class ObjectReferenceTests
+    {
+        /// <summary>
+        /// Tests serialization object replacement with <see cref="SerializationInfo.SetType"/> method.
+        /// </summary>
+        [Test]
+        public void TestSetType()
+        {
+            var obj = new SetTypeReplacer(25);
+
+            var res = TestUtils.SerializeDeserialize(obj);
+
+            Assert.AreEqual(obj.Value, res.Value);
+        }
+
+        /// <summary>
+        /// Tests serialization object replacement with <see cref="SerializationInfo.FullTypeName"/> property.
+        /// </summary>
+        [Test]
+        public void TestTypeName()
+        {
+            var obj = new TypeNameReplacer(36);
+
+            var res = TestUtils.SerializeDeserialize(obj);
+
+            Assert.AreEqual(obj.Value, res.Value);
+        }
+
+        [Serializable]
+        private class SetTypeReplacer : ISerializable
+        {
+            private readonly int _value;
+
+            public SetTypeReplacer(int value)
+            {
+                _value = value;
+            }
+
+            public int Value
+            {
+                get { return _value; }
+            }
+
+            public void GetObjectData(SerializationInfo info, StreamingContext context)
+            {
+                info.SetType(typeof(ObjectInfoHolder));
+
+                info.AddValue("type", GetType());
+                info.AddValue("val", Value);
+            }
+        }
+
+        [Serializable]
+        private class TypeNameReplacer : ISerializable
+        {
+            private readonly int _value;
+
+            public TypeNameReplacer(int value)
+            {
+                _value = value;
+            }
+
+            public int Value
+            {
+                get { return _value; }
+            }
+
+            public void GetObjectData(SerializationInfo info, StreamingContext context)
+            {
+                info.FullTypeName = typeof(ObjectInfoHolder).FullName;
+                info.AssemblyName = typeof(ObjectInfoHolder).Assembly.FullName;
+
+                info.AddValue("type", GetType());
+                info.AddValue("val", Value);
+            }
+        }
+
+        [Serializable]
+        private class ObjectInfoHolder : IObjectReference, ISerializable
+        {
+            public Type ObjectType { get; set; }
+
+            public int Value { get; set; }
+
+            public object GetRealObject(StreamingContext context)
+            {
+                return Activator.CreateInstance(ObjectType, Value);
+            }
+
+            public ObjectInfoHolder(SerializationInfo info, StreamingContext context)
+            {
+                ObjectType = (Type) info.GetValue("type", typeof(Type));
+                Value = info.GetInt32("val");
+            }
+
+            public void GetObjectData(SerializationInfo info, StreamingContext context)
+            {
+                // No-op.
+            }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/PrimitivesTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/PrimitivesTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/PrimitivesTest.cs
new file mode 100644
index 0000000..bbbee60
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/PrimitivesTest.cs
@@ -0,0 +1,754 @@
+/*
+ * 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.
+ */
+
+// ReSharper disable StringLiteralTypo
+// ReSharper disable IdentifierTypo
+namespace Apache.Ignite.Core.Tests.Binary.Serializable
+{
+    using System;
+    using System.Linq;
+    using System.Runtime.Serialization;
+    using Apache.Ignite.Core.Binary;
+    using Apache.Ignite.Core.Impl;
+    using Apache.Ignite.Core.Impl.Binary;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Tests [Serializable] mechanism handling primitive types.
+    /// </summary>
+    public class PrimitivesTest
+    {
+        /** */
+        private IIgnite _ignite;
+        
+        /// <summary>
+        /// Sets up the test fixture.
+        /// </summary>
+        [TestFixtureSetUp]
+        public void FixtureSetUp()
+        {
+            _ignite = Ignition.Start(TestUtils.GetTestConfiguration());
+        }
+
+        /// <summary>
+        /// Tears down the test fixture.
+        /// </summary>
+        [TestFixtureTearDown]
+        public void FixtureTearDown()
+        {
+            Ignition.StopAll(true);
+        }
+
+        /// <summary>
+        /// Tests the DateTime which is ISerializable struct.
+        /// </summary>
+        [Test]
+        public void TestDateTime()
+        {
+            var marsh = GetMarshaller();
+
+            var val = DateTime.Now;
+
+            Assert.AreEqual(val, marsh.Unmarshal<DateTime>(marsh.Marshal(val)));
+
+            Assert.AreEqual(new[] {val}, marsh.Unmarshal<DateTime[]>(marsh.Marshal(new[] {val})));
+
+            Assert.AreEqual(new DateTime?[] {val, null},
+                marsh.Unmarshal<DateTime?[]>(marsh.Marshal(new DateTime?[] {val, null})));
+        }
+
+        /// <summary>
+        /// Tests that primitive types can be serialized with ISerializable mechanism.
+        /// </summary>
+        [Test]
+        public void TestPrimitives()
+        {
+            var marsh = GetMarshaller();
+
+            var val1 = new Primitives
+            {
+                Byte = 1,
+                Bytes = new byte[] {2, 3, byte.MinValue, byte.MaxValue},
+                Sbyte = -64,
+                Sbytes = new sbyte[] {sbyte.MinValue, sbyte.MaxValue, 1, 2, -4, -5},
+                Bool = true,
+                Bools = new[] {true, true, false},
+                Char = 'x',
+                Chars = new[] {'a', 'z', char.MinValue, char.MaxValue},
+                Short = -25,
+                Shorts = new short[] {5, -7, 9, short.MinValue, short.MaxValue},
+                Ushort = 99,
+                Ushorts = new ushort[] {10, 20, 12, ushort.MinValue, ushort.MaxValue},
+                Int = -456,
+                Ints = new[] {-100, 200, -300, int.MinValue, int.MaxValue},
+                Uint = 456,
+                Uints = new uint[] {100, 200, 300, uint.MinValue, uint.MaxValue},
+                Long = long.MaxValue,
+                Longs = new[] {long.MinValue, long.MaxValue, 33, -44},
+                Ulong = ulong.MaxValue,
+                Ulongs = new ulong[] {ulong.MinValue, ulong.MaxValue, 33},
+                Float = 1.33f,
+                Floats = new[]
+                {
+                    float.MinValue, float.MaxValue,
+                    float.Epsilon, float.NegativeInfinity, float.PositiveInfinity, float.NaN,
+                    1.23f, -2.5f
+                },
+                Double = -6.78,
+                Doubles = new[]
+                {
+                    double.MinValue, double.MaxValue, double.Epsilon,
+                    double.NegativeInfinity, double.PositiveInfinity,
+                    3.76, -9.89
+                },
+                Decimal = 1.23456789m,
+                Decimals = new[]
+                {
+                    decimal.MinValue, decimal.MaxValue, decimal.One, decimal.MinusOne, decimal.Zero,
+                    1.35m, -2.46m
+                },
+                DateTime = DateTime.UtcNow,
+                DateTimes = new[] {DateTime.Now, DateTime.MinValue, DateTime.MaxValue, DateTime.UtcNow},
+                Guid = Guid.NewGuid(),
+                Guids = new[] {Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()},
+                String = "hello world",
+                Strings = new[] {"hello", "world"}
+            };
+
+            var vals = new[] {new Primitives(), val1};
+
+            foreach (var val in vals)
+            {
+                Assert.IsFalse(val.GetObjectDataCalled);
+                Assert.IsFalse(val.SerializationCtorCalled);
+
+                // Unmarshal in full and binary form.
+                var bytes = marsh.Marshal(val);
+                var res = marsh.Unmarshal<Primitives>(bytes);
+                var bin = marsh.Unmarshal<IBinaryObject>(bytes, BinaryMode.ForceBinary);
+
+                // Verify flags.
+                Assert.IsTrue(val.GetObjectDataCalled);
+                Assert.IsFalse(val.SerializationCtorCalled);
+
+                Assert.IsFalse(res.GetObjectDataCalled);
+                Assert.IsTrue(res.SerializationCtorCalled);
+
+                // Verify values.
+                Assert.AreEqual(val.Byte, res.Byte);
+                Assert.AreEqual(val.Byte, bin.GetField<byte>("byte"));
+
+                Assert.AreEqual(val.Bytes, res.Bytes);
+                Assert.AreEqual(val.Bytes, bin.GetField<byte[]>("bytes"));
+
+                Assert.AreEqual(val.Sbyte, res.Sbyte);
+                Assert.AreEqual(val.Sbyte, bin.GetField<sbyte>("sbyte"));
+
+                Assert.AreEqual(val.Sbytes, res.Sbytes);
+                Assert.AreEqual(val.Sbytes, bin.GetField<sbyte[]>("sbytes"));
+
+                Assert.AreEqual(val.Bool, res.Bool);
+                Assert.AreEqual(val.Bool, bin.GetField<bool>("bool"));
+
+                Assert.AreEqual(val.Bools, res.Bools);
+                Assert.AreEqual(val.Bools, bin.GetField<bool[]>("bools"));
+
+                Assert.AreEqual(val.Char, res.Char);
+                Assert.AreEqual(val.Char, bin.GetField<char>("char"));
+
+                Assert.AreEqual(val.Chars, res.Chars);
+                Assert.AreEqual(val.Chars, bin.GetField<char[]>("chars"));
+
+                Assert.AreEqual(val.Short, res.Short);
+                Assert.AreEqual(val.Short, bin.GetField<short>("short"));
+
+                Assert.AreEqual(val.Shorts, res.Shorts);
+                Assert.AreEqual(val.Shorts, bin.GetField<short[]>("shorts"));
+
+                Assert.AreEqual(val.Ushort, res.Ushort);
+                Assert.AreEqual(val.Ushort, bin.GetField<ushort>("ushort"));
+
+                Assert.AreEqual(val.Ushorts, res.Ushorts);
+                Assert.AreEqual(val.Ushorts, bin.GetField<ushort[]>("ushorts"));
+
+                Assert.AreEqual(val.Int, res.Int);
+                Assert.AreEqual(val.Int, bin.GetField<int>("int"));
+
+                Assert.AreEqual(val.Ints, res.Ints);
+                Assert.AreEqual(val.Ints, bin.GetField<int[]>("ints"));
+
+                Assert.AreEqual(val.Uint, res.Uint);
+                Assert.AreEqual(val.Uint, bin.GetField<uint>("uint"));
+
+                Assert.AreEqual(val.Uints, res.Uints);
+                Assert.AreEqual(val.Uints, bin.GetField<uint[]>("uints"));
+
+                Assert.AreEqual(val.Long, res.Long);
+                Assert.AreEqual(val.Long, bin.GetField<long>("long"));
+
+                Assert.AreEqual(val.Longs, res.Longs);
+                Assert.AreEqual(val.Longs, bin.GetField<long[]>("longs"));
+
+                Assert.AreEqual(val.Ulong, res.Ulong);
+                Assert.AreEqual(val.Ulong, bin.GetField<ulong>("ulong"));
+
+                Assert.AreEqual(val.Ulongs, res.Ulongs);
+                Assert.AreEqual(val.Ulongs, bin.GetField<ulong[]>("ulongs"));
+
+                Assert.AreEqual(val.Float, res.Float);
+                Assert.AreEqual(val.Float, bin.GetField<float>("float"));
+
+                Assert.AreEqual(val.Floats, res.Floats);
+                Assert.AreEqual(val.Floats, bin.GetField<float[]>("floats"));
+
+                Assert.AreEqual(val.Double, res.Double);
+                Assert.AreEqual(val.Double, bin.GetField<double>("double"));
+
+                Assert.AreEqual(val.Doubles, res.Doubles);
+                Assert.AreEqual(val.Doubles, bin.GetField<double[]>("doubles"));
+
+                Assert.AreEqual(val.Decimal, res.Decimal);
+                Assert.AreEqual(val.Decimal, bin.GetField<decimal>("decimal"));
+
+                Assert.AreEqual(val.Decimals, res.Decimals);
+                Assert.AreEqual(val.Decimals, bin.GetField<decimal[]>("decimals"));
+
+                Assert.AreEqual(val.Guid, res.Guid);
+                Assert.AreEqual(val.Guid, bin.GetField<Guid>("guid"));
+
+                Assert.AreEqual(val.Guids, res.Guids);
+                Assert.AreEqual(val.Guids, bin.GetField<Guid[]>("guids"));
+
+                Assert.AreEqual(val.DateTime, res.DateTime);
+                Assert.AreEqual(val.DateTime, bin.GetField<IBinaryObject>("datetime").Deserialize<DateTime>());
+
+                Assert.AreEqual(val.DateTimes, res.DateTimes);
+                var dts = bin.GetField<IBinaryObject[]>("datetimes");
+                Assert.AreEqual(val.DateTimes, dts == null ? null : dts.Select(x => x.Deserialize<DateTime>()));
+
+                Assert.AreEqual(val.String, res.String);
+                Assert.AreEqual(val.String, bin.GetField<string>("string"));
+
+                Assert.AreEqual(val.Strings, res.Strings);
+                Assert.AreEqual(val.Strings, bin.GetField<string[]>("strings"));
+
+                VerifyFieldTypes(bin);
+            }
+        }
+
+        /// <summary>
+        /// Tests that primitive types in nullable form can be serialized with ISerializable mechanism.
+        /// </summary>
+        [Test]
+        public void TestPrimitivesNullable()
+        {
+            var marsh = GetMarshaller();
+
+            var val1 = new PrimitivesNullable
+            {
+                Byte = 1,
+                Bytes = new byte?[] {2, 3, byte.MinValue, byte.MaxValue, null},
+                Sbyte = -64,
+                Sbytes = new sbyte?[] {sbyte.MinValue, sbyte.MaxValue, 1, 2, -4, -5, null},
+                Bool = true,
+                Bools = new bool?[] {true, true, false, null},
+                Char = 'x',
+                Chars = new char?[] {'a', 'z', char.MinValue, char.MaxValue, null},
+                Short = -25,
+                Shorts = new short?[] {5, -7, 9, short.MinValue, short.MaxValue, null},
+                Ushort = 99,
+                Ushorts = new ushort?[] {10, 20, 12, ushort.MinValue, ushort.MaxValue, null},
+                Int = -456,
+                Ints = new int?[] {-100, 200, -300, int.MinValue, int.MaxValue, null},
+                Uint = 456,
+                Uints = new uint?[] {100, 200, 300, uint.MinValue, uint.MaxValue, null},
+                Long = long.MaxValue,
+                Longs = new long?[] {long.MinValue, long.MaxValue, 33, -44, null},
+                Ulong = ulong.MaxValue,
+                Ulongs = new ulong?[] {ulong.MinValue, ulong.MaxValue, 33, null},
+                Float = 1.33f,
+                Floats = new float?[]
+                {
+                    float.MinValue, float.MaxValue,
+                    float.Epsilon, float.NegativeInfinity, float.PositiveInfinity, float.NaN,
+                    1.23f, -2.5f, null
+                },
+                Double = -6.78,
+                Doubles = new double?[]
+                {
+                    double.MinValue, double.MaxValue, double.Epsilon,
+                    double.NegativeInfinity, double.PositiveInfinity,
+                    3.76, -9.89, null
+                },
+                Decimal = 1.23456789m,
+                Decimals = new decimal?[]
+                {
+                    decimal.MinValue, decimal.MaxValue, decimal.One, decimal.MinusOne, decimal.Zero,
+                    1.35m, -2.46m, null
+                },
+                DateTime = DateTime.UtcNow,
+                DateTimes = new DateTime?[]
+                {
+                    DateTime.Now, DateTime.MinValue, DateTime.MaxValue, DateTime.UtcNow, null
+                },
+                Guid = Guid.NewGuid(),
+                Guids = new Guid?[] {Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), null},
+            };
+
+            var vals = new[] {new PrimitivesNullable(), val1};
+
+            foreach (var val in vals)
+            {
+                Assert.IsFalse(val.GetObjectDataCalled);
+                Assert.IsFalse(val.SerializationCtorCalled);
+
+                // Unmarshal in full and binary form.
+                var bytes = marsh.Marshal(val);
+                var res = marsh.Unmarshal<PrimitivesNullable>(bytes);
+                var bin = marsh.Unmarshal<IBinaryObject>(bytes, BinaryMode.ForceBinary);
+
+                // Verify flags.
+                Assert.IsTrue(val.GetObjectDataCalled);
+                Assert.IsFalse(val.SerializationCtorCalled);
+
+                Assert.IsFalse(res.GetObjectDataCalled);
+                Assert.IsTrue(res.SerializationCtorCalled);
+
+                // Verify values.
+                Assert.AreEqual(val.Byte, res.Byte);
+                Assert.AreEqual(val.Byte, bin.GetField<byte?>("byte"));
+
+                Assert.AreEqual(val.Bytes, res.Bytes);
+                Assert.AreEqual(val.Bytes, bin.GetField<byte?[]>("bytes"));
+
+                Assert.AreEqual(val.Sbyte, res.Sbyte);
+                Assert.AreEqual(val.Sbyte, bin.GetField<sbyte?>("sbyte"));
+
+                Assert.AreEqual(val.Sbytes, res.Sbytes);
+                Assert.AreEqual(val.Sbytes, bin.GetField<sbyte?[]>("sbytes"));
+
+                Assert.AreEqual(val.Bool, res.Bool);
+                Assert.AreEqual(val.Bool, bin.GetField<bool?>("bool"));
+
+                Assert.AreEqual(val.Bools, res.Bools);
+                Assert.AreEqual(val.Bools, bin.GetField<bool?[]>("bools"));
+
+                Assert.AreEqual(val.Char, res.Char);
+                Assert.AreEqual(val.Char, bin.GetField<char?>("char"));
+
+                Assert.AreEqual(val.Chars, res.Chars);
+                Assert.AreEqual(val.Chars, bin.GetField<char?[]>("chars"));
+
+                Assert.AreEqual(val.Short, res.Short);
+                Assert.AreEqual(val.Short, bin.GetField<short?>("short"));
+
+                Assert.AreEqual(val.Shorts, res.Shorts);
+                Assert.AreEqual(val.Shorts, bin.GetField<short?[]>("shorts"));
+
+                Assert.AreEqual(val.Ushort, res.Ushort);
+                Assert.AreEqual(val.Ushort, bin.GetField<ushort?>("ushort"));
+
+                Assert.AreEqual(val.Ushorts, res.Ushorts);
+                Assert.AreEqual(val.Ushorts, bin.GetField<ushort?[]>("ushorts"));
+
+                Assert.AreEqual(val.Int, res.Int);
+                Assert.AreEqual(val.Int, bin.GetField<int?>("int"));
+
+                Assert.AreEqual(val.Ints, res.Ints);
+                Assert.AreEqual(val.Ints, bin.GetField<int?[]>("ints"));
+
+                Assert.AreEqual(val.Uint, res.Uint);
+                Assert.AreEqual(val.Uint, bin.GetField<uint?>("uint"));
+
+                Assert.AreEqual(val.Uints, res.Uints);
+                Assert.AreEqual(val.Uints, bin.GetField<uint?[]>("uints"));
+
+                Assert.AreEqual(val.Long, res.Long);
+                Assert.AreEqual(val.Long, bin.GetField<long?>("long"));
+
+                Assert.AreEqual(val.Longs, res.Longs);
+                Assert.AreEqual(val.Longs, bin.GetField<long?[]>("longs"));
+
+                Assert.AreEqual(val.Ulong, res.Ulong);
+                Assert.AreEqual(val.Ulong, bin.GetField<ulong?>("ulong"));
+
+                Assert.AreEqual(val.Ulongs, res.Ulongs);
+                Assert.AreEqual(val.Ulongs, bin.GetField<ulong?[]>("ulongs"));
+
+                Assert.AreEqual(val.Float, res.Float);
+                Assert.AreEqual(val.Float, bin.GetField<float?>("float"));
+
+                Assert.AreEqual(val.Floats, res.Floats);
+                Assert.AreEqual(val.Floats, bin.GetField<float?[]>("floats"));
+
+                Assert.AreEqual(val.Double, res.Double);
+                Assert.AreEqual(val.Double, bin.GetField<double?>("double"));
+
+                Assert.AreEqual(val.Doubles, res.Doubles);
+                Assert.AreEqual(val.Doubles, bin.GetField<double?[]>("doubles"));
+
+                Assert.AreEqual(val.Decimal, res.Decimal);
+                Assert.AreEqual(val.Decimal, bin.GetField<decimal?>("decimal"));
+
+                Assert.AreEqual(val.Decimals, res.Decimals);
+                Assert.AreEqual(val.Decimals, bin.GetField<decimal?[]>("decimals"));
+
+                Assert.AreEqual(val.Guid, res.Guid);
+                Assert.AreEqual(val.Guid, bin.GetField<Guid?>("guid"));
+
+                Assert.AreEqual(val.Guids, res.Guids);
+                Assert.AreEqual(val.Guids, bin.GetField<Guid?[]>("guids"));
+
+                Assert.AreEqual(val.DateTime, res.DateTime);
+                var dt = bin.GetField<IBinaryObject>("datetime");
+                Assert.AreEqual(val.DateTime, dt == null ? null : dt.Deserialize<DateTime?>());
+
+                Assert.AreEqual(val.DateTimes, res.DateTimes);
+                var dts = bin.GetField<IBinaryObject[]>("datetimes");
+                Assert.AreEqual(val.DateTimes, dts == null
+                    ? null
+                    : dts.Select(x => x == null ? null : x.Deserialize<DateTime?>()));
+            }
+        }
+
+        /// <summary>
+        /// Verifies the field types.
+        /// </summary>
+        private static void VerifyFieldTypes(IBinaryObject bin)
+        {
+            var binType = bin.GetBinaryType();
+            
+            Assert.AreEqual("byte", binType.GetFieldTypeName("byte"));
+            Assert.AreEqual("byte", binType.GetFieldTypeName("sbyte"));
+            
+            Assert.AreEqual("byte[]", binType.GetFieldTypeName("bytes"));
+            Assert.AreEqual("byte[]", binType.GetFieldTypeName("sbytes"));
+            
+            Assert.AreEqual("boolean", binType.GetFieldTypeName("bool"));
+            Assert.AreEqual("boolean[]", binType.GetFieldTypeName("bools"));
+            
+            Assert.AreEqual("char", binType.GetFieldTypeName("char"));
+            Assert.AreEqual("char[]", binType.GetFieldTypeName("chars"));
+
+            Assert.AreEqual("short", binType.GetFieldTypeName("short"));
+            Assert.AreEqual("short[]", binType.GetFieldTypeName("shorts"));
+
+            Assert.AreEqual("short", binType.GetFieldTypeName("ushort"));
+            Assert.AreEqual("short[]", binType.GetFieldTypeName("ushorts"));
+
+            Assert.AreEqual("int", binType.GetFieldTypeName("int"));
+            Assert.AreEqual("int[]", binType.GetFieldTypeName("ints"));
+
+            Assert.AreEqual("int", binType.GetFieldTypeName("uint"));
+            Assert.AreEqual("int[]", binType.GetFieldTypeName("uints"));
+
+            Assert.AreEqual("long", binType.GetFieldTypeName("long"));
+            Assert.AreEqual("long[]", binType.GetFieldTypeName("longs"));
+
+            Assert.AreEqual("long", binType.GetFieldTypeName("ulong"));
+            Assert.AreEqual("long[]", binType.GetFieldTypeName("ulongs"));
+
+            Assert.AreEqual("float", binType.GetFieldTypeName("float"));
+            Assert.AreEqual("float[]", binType.GetFieldTypeName("floats"));
+
+            Assert.AreEqual("double", binType.GetFieldTypeName("double"));
+            Assert.AreEqual("double[]", binType.GetFieldTypeName("doubles"));
+
+            Assert.AreEqual("decimal", binType.GetFieldTypeName("decimal"));
+            Assert.AreEqual("Object", binType.GetFieldTypeName("decimals"));
+
+            Assert.AreEqual("UUID", binType.GetFieldTypeName("guid"));
+            Assert.AreEqual("Object", binType.GetFieldTypeName("guids"));
+
+            Assert.AreEqual("Object", binType.GetFieldTypeName("datetime"));
+            Assert.AreEqual("Object", binType.GetFieldTypeName("datetimes"));
+        }
+
+        /// <summary>
+        /// Gets the marshaller.
+        /// </summary>
+        private Marshaller GetMarshaller()
+        {
+            return ((Ignite) _ignite).Marshaller;
+        }
+
+        [Serializable]
+        public class Primitives : ISerializable
+        {
+            public bool GetObjectDataCalled { get; private set; }
+            public bool SerializationCtorCalled { get; private set; }
+
+            public byte Byte { get; set; }
+            public byte[] Bytes { get; set; }
+            public sbyte Sbyte { get; set; }
+            public sbyte[] Sbytes { get; set; }
+            public bool Bool { get; set; }
+            public bool[] Bools { get; set; }
+            public char Char { get; set; }
+            public char[] Chars { get; set; }
+            public short Short { get; set; }
+            public short[] Shorts { get; set; }
+            public ushort Ushort { get; set; }
+            public ushort[] Ushorts { get; set; }
+            public int Int { get; set; }
+            public int[] Ints { get; set; }
+            public uint Uint { get; set; }
+            public uint[] Uints { get; set; }
+            public long Long { get; set; }
+            public long[] Longs { get; set; }
+            public ulong Ulong { get; set; }
+            public ulong[] Ulongs { get; set; }
+            public float Float { get; set; }
+            public float[] Floats { get; set; }
+            public double Double { get; set; }
+            public double[] Doubles { get; set; }
+            public decimal Decimal { get; set; }
+            public decimal[] Decimals { get; set; }
+            public Guid Guid { get; set; }
+            public Guid[] Guids { get; set; }
+            public DateTime DateTime { get; set; }
+            public DateTime[] DateTimes { get; set; }
+            public string String { get; set; }
+            public string[] Strings { get; set; }
+
+            public Primitives()
+            {
+                // No-op.
+            }
+
+            protected Primitives(SerializationInfo info, StreamingContext context)
+            {
+                SerializationCtorCalled = true;
+
+                Byte = info.GetByte("byte");
+                Bytes = (byte[]) info.GetValue("bytes", typeof(byte[]));
+
+                Sbyte = info.GetSByte("sbyte");
+                Sbytes = (sbyte[]) info.GetValue("sbytes", typeof(sbyte[]));
+
+                Bool = info.GetBoolean("bool");
+                Bools = (bool[]) info.GetValue("bools", typeof(bool[]));
+
+                Char = info.GetChar("char");
+                Chars = (char[]) info.GetValue("chars", typeof(char[]));
+
+                Short = info.GetInt16("short");
+                Shorts = (short[]) info.GetValue("shorts", typeof(short[]));
+
+                Ushort = info.GetUInt16("ushort");
+                Ushorts = (ushort[]) info.GetValue("ushorts", typeof(ushort[]));
+
+                Int = info.GetInt32("int");
+                Ints = (int[]) info.GetValue("ints", typeof(int[]));
+
+                Uint = info.GetUInt32("uint");
+                Uints = (uint[]) info.GetValue("uints", typeof(uint[]));
+
+                Long = info.GetInt64("long");
+                Longs = (long[]) info.GetValue("longs", typeof(long[]));
+
+                Ulong = info.GetUInt64("ulong");
+                Ulongs = (ulong[]) info.GetValue("ulongs", typeof(ulong[]));
+
+                Float = info.GetSingle("float");
+                Floats = (float[]) info.GetValue("floats", typeof(float[]));
+
+                Double = info.GetDouble("double");
+                Doubles = (double[]) info.GetValue("doubles", typeof(double[]));
+
+                Decimal = info.GetDecimal("decimal");
+                Decimals = (decimal[]) info.GetValue("decimals", typeof(decimal[]));
+
+                Guid = (Guid) info.GetValue("guid", typeof(Guid));
+                Guids = (Guid[]) info.GetValue("guids", typeof(Guid[]));
+
+                DateTime = info.GetDateTime("datetime");
+                DateTimes = (DateTime[]) info.GetValue("datetimes", typeof(DateTime[]));
+
+                String = info.GetString("string");
+                Strings = (string[]) info.GetValue("strings", typeof(string[]));
+            }
+
+            public void GetObjectData(SerializationInfo info, StreamingContext context)
+            {
+                GetObjectDataCalled = true;
+
+                info.AddValue("byte", Byte);
+                info.AddValue("bytes", Bytes, typeof(byte[]));
+                info.AddValue("sbyte", Sbyte);
+                info.AddValue("sbytes", Sbytes, typeof(sbyte[]));
+                info.AddValue("bool", Bool);
+                info.AddValue("bools", Bools, typeof(bool[]));
+                info.AddValue("char", Char);
+                info.AddValue("chars", Chars, typeof(char[]));
+                info.AddValue("short", Short);
+                info.AddValue("shorts", Shorts, typeof(short[]));
+                info.AddValue("ushort", Ushort);
+                info.AddValue("ushorts", Ushorts, typeof(ushort[]));
+                info.AddValue("int", Int);
+                info.AddValue("ints", Ints, typeof(int[]));
+                info.AddValue("uint", Uint);
+                info.AddValue("uints", Uints, typeof(uint[]));
+                info.AddValue("long", Long);
+                info.AddValue("longs", Longs, typeof(long[]));
+                info.AddValue("ulong", Ulong);
+                info.AddValue("ulongs", Ulongs, typeof(ulong[]));
+                info.AddValue("float", Float);
+                info.AddValue("floats", Floats, typeof(float[]));
+                info.AddValue("double", Double);
+                info.AddValue("doubles", Doubles, typeof(double[]));
+                info.AddValue("decimal", Decimal);
+                info.AddValue("decimals", Decimals, typeof(decimal[]));
+                info.AddValue("guid", Guid);
+                info.AddValue("guids", Guids, typeof(Guid[]));
+                info.AddValue("datetime", DateTime);
+                info.AddValue("datetimes", DateTimes, typeof(DateTime[]));
+                info.AddValue("string", String, typeof(string));
+                info.AddValue("strings", Strings, typeof(string[]));
+            }
+        }
+
+        [Serializable]
+        private class PrimitivesNullable : ISerializable
+        {
+            public bool GetObjectDataCalled { get; private set; }
+            public bool SerializationCtorCalled { get; private set; }
+
+            public byte? Byte { get; set; }
+            public byte?[] Bytes { get; set; }
+            public sbyte? Sbyte { get; set; }
+            public sbyte?[] Sbytes { get; set; }
+            public bool? Bool { get; set; }
+            public bool?[] Bools { get; set; }
+            public char? Char { get; set; }
+            public char?[] Chars { get; set; }
+            public short? Short { get; set; }
+            public short?[] Shorts { get; set; }
+            public ushort? Ushort { get; set; }
+            public ushort?[] Ushorts { get; set; }
+            public int? Int { get; set; }
+            public int?[] Ints { get; set; }
+            public uint? Uint { get; set; }
+            public uint?[] Uints { get; set; }
+            public long? Long { get; set; }
+            public long?[] Longs { get; set; }
+            public ulong? Ulong { get; set; }
+            public ulong?[] Ulongs { get; set; }
+            public float? Float { get; set; }
+            public float?[] Floats { get; set; }
+            public double? Double { get; set; }
+            public double?[] Doubles { get; set; }
+            public decimal? Decimal { get; set; }
+            public decimal?[] Decimals { get; set; }
+            public Guid? Guid { get; set; }
+            public Guid?[] Guids { get; set; }
+            public DateTime? DateTime { get; set; }
+            public DateTime?[] DateTimes { get; set; }
+
+            public PrimitivesNullable()
+            {
+                // No-op.
+            }
+
+            protected PrimitivesNullable(SerializationInfo info, StreamingContext context)
+            {
+                SerializationCtorCalled = true;
+
+                Byte = (byte?) info.GetValue("byte", typeof(byte?));
+                Bytes = (byte?[]) info.GetValue("bytes", typeof(byte?[]));
+
+                Sbyte = (sbyte?) info.GetValue("sbyte", typeof(sbyte?));
+                Sbytes = (sbyte?[]) info.GetValue("sbytes", typeof(sbyte?[]));
+
+                Bool = (bool?) info.GetValue("bool", typeof(bool?));
+                Bools = (bool?[]) info.GetValue("bools", typeof(bool?[]));
+
+                Char = (char?) info.GetValue("char", typeof(char?));
+                Chars = (char?[]) info.GetValue("chars", typeof(char?[]));
+
+                Short = (short?) info.GetValue("short", typeof(short?));
+                Shorts = (short?[]) info.GetValue("shorts", typeof(short?[]));
+
+                Ushort = (ushort?) info.GetValue("ushort", typeof(ushort?));
+                Ushorts = (ushort?[]) info.GetValue("ushorts", typeof(ushort?[]));
+
+                Int = (int?) info.GetValue("int", typeof(int?));
+                Ints = (int?[]) info.GetValue("ints", typeof(int?[]));
+
+                Uint = (uint?) info.GetValue("uint", typeof(uint?));
+                Uints = (uint?[]) info.GetValue("uints", typeof(uint?[]));
+
+                Long = (long?) info.GetValue("long", typeof(long?));
+                Longs = (long?[]) info.GetValue("longs", typeof(long?[]));
+
+                Ulong = (ulong?) info.GetValue("ulong", typeof(ulong?));
+                Ulongs = (ulong?[]) info.GetValue("ulongs", typeof(ulong?[]));
+
+                Float = (float?) info.GetValue("float", typeof(float?));
+                Floats = (float?[]) info.GetValue("floats", typeof(float?[]));
+
+                Double = (double?) info.GetValue("double", typeof(double?));
+                Doubles = (double?[]) info.GetValue("doubles", typeof(double?[]));
+
+                Decimal = (decimal?) info.GetValue("decimal", typeof(decimal?));
+                Decimals = (decimal?[]) info.GetValue("decimals", typeof(decimal?[]));
+
+                Guid = (Guid?) info.GetValue("guid", typeof(Guid?));
+                Guids = (Guid?[]) info.GetValue("guids", typeof(Guid?[]));
+
+                DateTime = (DateTime?) info.GetValue("datetime", typeof(DateTime?));
+                DateTimes = (DateTime?[]) info.GetValue("datetimes", typeof(DateTime?[]));
+            }
+
+            public void GetObjectData(SerializationInfo info, StreamingContext context)
+            {
+                GetObjectDataCalled = true;
+
+                info.AddValue("byte", Byte, typeof(object));
+                info.AddValue("bytes", Bytes, typeof(object));
+                info.AddValue("sbyte", Sbyte, typeof(object));
+                info.AddValue("sbytes", Sbytes, typeof(object));
+                info.AddValue("bool", Bool, typeof(object));
+                info.AddValue("bools", Bools, typeof(object));
+                info.AddValue("char", Char, typeof(object));
+                info.AddValue("chars", Chars, typeof(object));
+                info.AddValue("short", Short, typeof(object));
+                info.AddValue("shorts", Shorts, typeof(object));
+                info.AddValue("ushort", Ushort, typeof(object));
+                info.AddValue("ushorts", Ushorts, typeof(object));
+                info.AddValue("int", Int, typeof(object));
+                info.AddValue("ints", Ints, typeof(object));
+                info.AddValue("uint", Uint, typeof(object));
+                info.AddValue("uints", Uints, typeof(object));
+                info.AddValue("long", Long, typeof(object));
+                info.AddValue("longs", Longs, typeof(object));
+                info.AddValue("ulong", Ulong, typeof(object));
+                info.AddValue("ulongs", Ulongs, typeof(object));
+                info.AddValue("float", Float, typeof(object));
+                info.AddValue("floats", Floats, typeof(object));
+                info.AddValue("double", Double, typeof(object));
+                info.AddValue("doubles", Doubles, typeof(object));
+                info.AddValue("decimal", Decimal, typeof(object));
+                info.AddValue("decimals", Decimals, typeof(object));
+                info.AddValue("guid", Guid, typeof(object));
+                info.AddValue("guids", Guids, typeof(object));
+                info.AddValue("datetime", DateTime, typeof(object));
+                info.AddValue("datetimes", DateTimes, typeof(object));
+            }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/SqlDmlTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/SqlDmlTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/SqlDmlTest.cs
new file mode 100644
index 0000000..b59247e
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/Serializable/SqlDmlTest.cs
@@ -0,0 +1,277 @@
+/*
+ * 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.
+ */
+
+// ReSharper disable UnusedMember.Local
+// ReSharper disable UnusedParameter.Local
+namespace Apache.Ignite.Core.Tests.Binary.Serializable
+{
+    using System;
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.Serialization;
+    using System.Text;
+    using System.Threading;
+    using Apache.Ignite.Core.Binary;
+    using Apache.Ignite.Core.Cache.Configuration;
+    using Apache.Ignite.Core.Cache.Query;
+    using Apache.Ignite.Linq;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Tests SQL and DML with Serializable types.
+    /// </summary>
+    public class SqlDmlTest
+    {
+        /** */
+        private IIgnite _ignite;
+        
+        /** */
+        private StringBuilder _outSb;
+
+        /// <summary>
+        /// Sets up the test fixture.
+        /// </summary>
+        [TestFixtureSetUp]
+        public void FixtureSetUp()
+        {
+            _outSb = new StringBuilder();
+            Console.SetError(new StringWriter(_outSb));
+
+            var cfg = new IgniteConfiguration(TestUtils.GetTestConfiguration())
+            {
+                BinaryConfiguration = new BinaryConfiguration(typeof(SimpleSerializable))
+            };
+
+            _ignite = Ignition.Start(cfg);
+        }
+
+        /// <summary>
+        /// Tears down the test fixture.
+        /// </summary>
+        [TestFixtureTearDown]
+        public void FixtureTearDown()
+        {
+            Ignition.StopAll(true);
+        }
+
+        /// <summary>
+        /// Tests the simple serializable.
+        /// </summary>
+        [Test]
+        public void TestSimpleSerializable()
+        {
+            var cache = _ignite.CreateCache<int, SimpleSerializable>(
+                new CacheConfiguration("simple", new QueryEntity(typeof(int), typeof(SimpleSerializable))));
+
+            cache[1] = new SimpleSerializable
+            {
+                String = "abc"
+            };
+            cache[2] = new SimpleSerializable
+            {
+                Byte = 25,
+                Bool = true,
+                Short = 66,
+                Int = 2,
+                Long = 98,
+                Float = 2.25f,
+                Double = 1.123,
+                Decimal = 5.67m,
+                Guid = Guid.NewGuid(),
+                String = "bar2"
+            };
+
+            // Test SQL.
+            var res = cache.Query(new SqlQuery(typeof(SimpleSerializable), "where Int = 2")).GetAll().Single();
+
+            Assert.AreEqual(2, res.Key);
+            Assert.AreEqual(2, res.Value.Int);
+            Assert.AreEqual("bar2", res.Value.String);
+
+            // Test DML.
+            var guid = Guid.NewGuid();
+            var insertRes = cache.QueryFields(new SqlFieldsQuery(
+                "insert into SimpleSerializable(_key, Byte, Bool, Short, Int, Long, Float, Double, " +
+                "Decimal, Guid, String) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", 
+                3, 45, true, 43, 33, 99, 4.5f, 6.7, 9.04m, guid, "bar33")).GetAll();
+
+            Assert.AreEqual(1, insertRes.Count);
+            Assert.AreEqual(1, insertRes[0][0]);
+
+            var dmlRes = cache[3];
+            Assert.AreEqual(45, dmlRes.Byte);
+            Assert.AreEqual(true, dmlRes.Bool);
+            Assert.AreEqual(43, dmlRes.Short);
+            Assert.AreEqual(33, dmlRes.Int);
+            Assert.AreEqual(99, dmlRes.Long);
+            Assert.AreEqual(4.5f, dmlRes.Float);
+            Assert.AreEqual(6.7, dmlRes.Double);
+            Assert.AreEqual(9.04m, dmlRes.Decimal);
+            Assert.AreEqual(guid, dmlRes.Guid);
+            Assert.AreEqual("bar33", dmlRes.String);
+        }
+
+        /// <summary>
+        /// Tests the .NET specific serializable.
+        /// </summary>
+        [Test]
+        public void TestDotNetSpecificSerializable()
+        {
+            var cache = _ignite.CreateCache<int, DotNetSpecificSerializable>(new CacheConfiguration("dotnet-ser",
+                new QueryEntity(typeof(int), typeof(DotNetSpecificSerializable))));
+
+            cache[1] = new DotNetSpecificSerializable(uint.MaxValue);
+            Assert.AreEqual(uint.MaxValue, cache[1].Uint);
+
+            // Test SQL.
+            var sqlRes = cache.QueryFields(new SqlFieldsQuery(
+                "select uint from DotNetSpecificSerializable where uint <> 0")).GetAll();
+
+            Assert.AreEqual(1, sqlRes.Count);
+            Assert.AreEqual(uint.MaxValue, (uint) (int) sqlRes[0][0]);
+
+            // Test LINQ.
+            var linqRes = cache.AsCacheQueryable().Select(x => x.Value.Uint).Single();
+            Assert.AreEqual(uint.MaxValue, linqRes);
+
+            // Test DML.
+            var dmlRes = cache.QueryFields(new SqlFieldsQuery(
+                "insert into DotNetSpecificSerializable(_key, uint) values (?, ?), (?, ?)",
+                2, uint.MaxValue, 3, 88)).GetAll();
+            Assert.AreEqual(1, dmlRes.Count);
+
+            Assert.AreEqual(88, cache[3].Uint);  // Works when value is in int range.
+
+            var ex = Assert.Throws<OverflowException>(() => cache.Get(2));  // Fails when out of int range.
+            Assert.AreEqual("Value was either too large or too small for a UInt32.", ex.Message);
+        }
+
+        /// <summary>
+        /// Tests the log warning.
+        /// </summary>
+        [Test]
+        public void TestLogWarning()
+        {
+            Thread.Sleep(10);  // Wait for logger update.
+
+            var expected =
+                string.Format("[WARN ][main][Marshaller] Type '{0}' implements '{1}'. " +
+                              "It will be written in Ignite binary format, however, " +
+                              "the following limitations apply: DateTime fields would not work in SQL; " +
+                              "sbyte, ushort, uint, ulong fields would not work in DML.",
+                    typeof(SimpleSerializable), typeof(ISerializable));
+
+            Assert.IsTrue(_outSb.ToString().Contains(expected));
+        }
+
+        /// <summary>
+        /// Serializable with Java-compatible fields.
+        /// </summary>
+        private class SimpleSerializable : ISerializable
+        {
+            [QuerySqlField]
+            public byte Byte { get; set; }
+
+            [QuerySqlField]
+            public bool Bool { get; set; }
+
+            [QuerySqlField]
+            public short Short { get; set; }
+            
+            [QuerySqlField]
+            public int Int { get; set; }
+            
+            [QuerySqlField]
+            public long Long { get; set; }
+            
+            [QuerySqlField]
+            public float Float { get; set; }
+            
+            [QuerySqlField]
+            public double Double { get; set; }
+            
+            [QuerySqlField]
+            public decimal Decimal { get; set; }
+            
+            [QuerySqlField]
+            public Guid Guid { get; set; }
+            
+            [QuerySqlField]
+            public string String { get; set; }
+
+            public SimpleSerializable()
+            {
+                // No-op.
+            }
+
+            public SimpleSerializable(SerializationInfo info, StreamingContext context)
+            {
+                Byte = info.GetByte("Byte");
+                Bool = info.GetBoolean("Bool");
+                Short = info.GetInt16("Short");
+                Int = info.GetInt32("Int");
+                Long = info.GetInt64("Long");
+                Float = info.GetSingle("Float");
+                Double = info.GetDouble("Double");
+                Decimal = info.GetDecimal("Decimal");
+                Guid = (Guid) info.GetValue("Guid", typeof(Guid));
+                String = info.GetString("String");
+            }
+
+            public void GetObjectData(SerializationInfo info, StreamingContext context)
+            {
+                info.AddValue("Byte", Byte);
+                info.AddValue("Bool", Bool);
+                info.AddValue("Short", Short);
+                info.AddValue("Int", Int);
+                info.AddValue("Long", Long);
+                info.AddValue("Float", Float);
+                info.AddValue("Double", Double);
+                info.AddValue("Decimal", Decimal);
+                info.AddValue("Guid", Guid);
+                info.AddValue("String", String);
+            }
+        }
+
+        /// <summary>
+        /// Serializable with incompatible fields.
+        /// </summary>
+        private class DotNetSpecificSerializable : ISerializable
+        {
+            /// <summary>
+            /// Uint is not supported in Java.
+            /// </summary>
+            [QuerySqlField]
+            public uint Uint { get; set; }
+
+            public DotNetSpecificSerializable(uint u)
+            {
+                Uint = u;
+            }
+
+            public DotNetSpecificSerializable(SerializationInfo info, StreamingContext context)
+            {
+                Uint = info.GetUInt32("uint");
+            }
+
+            public void GetObjectData(SerializationInfo info, StreamingContext context)
+            {
+                info.AddValue("uint", Uint);
+            }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Affinity/AffinityFunctionTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Affinity/AffinityFunctionTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Affinity/AffinityFunctionTest.cs
index 9348449..a3e6252 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Affinity/AffinityFunctionTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Affinity/AffinityFunctionTest.cs
@@ -233,21 +233,6 @@ namespace Apache.Ignite.Core.Tests.Cache.Affinity
         }
 
         /// <summary>
-        /// Tests the error on non-serializable function.
-        /// </summary>
-        [Test]
-        public void TestNonSerializableFunction()
-        {
-            var ex = Assert.Throws<IgniteException>(() =>
-                _ignite.CreateCache<int, int>(new CacheConfiguration("failCache")
-                {
-                    AffinityFunction = new NonSerializableAffinityFunction()
-                }));
-
-            Assert.AreEqual(ex.Message, "AffinityFunction should be serializable.");
-        }
-
-        /// <summary>
         /// Tests the exception propagation.
         /// </summary>
         [Test]
@@ -388,12 +373,6 @@ namespace Apache.Ignite.Core.Tests.Cache.Affinity
             }
         }
 
-        private class NonSerializableAffinityFunction : SimpleAffinityFunction
-        {
-            // No-op.
-        }
-
-        [Serializable]
         private class FailInGetPartitionAffinityFunction : IAffinityFunction
         {
             public int Partitions

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheAbstractTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheAbstractTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheAbstractTest.cs
index f97741a..ce0441d 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheAbstractTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheAbstractTest.cs
@@ -232,9 +232,19 @@ namespace Apache.Ignite.Core.Tests.Cache
     /// <summary>
     /// Non-serializable processor.
     /// </summary>
-    public class NonSerializableCacheEntryProcessor : AddArgCacheEntryProcessor
+    public class NonSerializableCacheEntryProcessor : AddArgCacheEntryProcessor, IBinarizable
     {
-        // No-op.
+        /** <inheritdoc /> */
+        public void WriteBinary(IBinaryWriter writer)
+        {
+            throw new Exception("ExpectedException");
+        }
+
+        /** <inheritdoc /> */
+        public void ReadBinary(IBinaryReader reader)
+        {
+            throw new Exception("ExpectedException");
+        }
     }
 
     /// <summary>
@@ -269,9 +279,19 @@ namespace Apache.Ignite.Core.Tests.Cache
     /// <summary>
     /// Non-serializable exception.
     /// </summary>
-    public class NonSerializableException : Exception
+    public class NonSerializableException : Exception, IBinarizable
     {
-        // No-op
+        /** <inheritdoc /> */
+        public void WriteBinary(IBinaryWriter writer)
+        {
+            throw new Exception("ExpectedException");
+        }
+
+        /** <inheritdoc /> */
+        public void ReadBinary(IBinaryReader reader)
+        {
+            throw new Exception("ExpectedException");
+        }
     }
 
     /// <summary>
@@ -2356,15 +2376,7 @@ namespace Apache.Ignite.Core.Tests.Cache
             TestInvoke<AddArgCacheEntryProcessor>(async);
             TestInvoke<BinarizableAddArgCacheEntryProcessor>(async);
 
-            try
-            {
-                TestInvoke<NonSerializableCacheEntryProcessor>(async);
-                Assert.Fail();
-            }
-            catch (BinaryObjectException)
-            {
-                // Expected
-            }
+            Assert.Throws<Exception>(() => TestInvoke<NonSerializableCacheEntryProcessor>(async));
         }
 
         private void TestInvoke<T>(bool async) where T: AddArgCacheEntryProcessor, new()
@@ -2396,7 +2408,7 @@ namespace Apache.Ignite.Core.Tests.Cache
             AssertThrowsCacheEntryProcessorException(
                 () => cache.Invoke(key, new T {ThrowErrBinarizable = true}, arg));
             AssertThrowsCacheEntryProcessorException(
-                () => cache.Invoke(key, new T { ThrowErrNonSerializable = true }, arg), "BinaryObjectException");
+                () => cache.Invoke(key, new T { ThrowErrNonSerializable = true }, arg), "ExpectedException");
         }
 
         private static void AssertThrowsCacheEntryProcessorException(Action action, string containsText = null)
@@ -2417,7 +2429,8 @@ namespace Apache.Ignite.Core.Tests.Cache
                     Assert.AreEqual(AddArgCacheEntryProcessor.ExceptionText, ex.InnerException.Message);
                 }
                 else
-                    Assert.IsTrue(ex.ToString().Contains(containsText));
+                    Assert.IsTrue(ex.ToString().Contains(containsText), 
+                        "Expected: " + containsText + ", actual: " + ex);
             }
         }
 
@@ -2439,16 +2452,7 @@ namespace Apache.Ignite.Core.Tests.Cache
             {
                 TestInvokeAll<AddArgCacheEntryProcessor>(async, i);
                 TestInvokeAll<BinarizableAddArgCacheEntryProcessor>(async, i);
-
-                try
-                {
-                    TestInvokeAll<NonSerializableCacheEntryProcessor>(async, i);
-                    Assert.Fail();
-                }
-                catch (BinaryObjectException)
-                {
-                    // Expected
-                }
+                Assert.Throws<Exception>(() => TestInvokeAll<NonSerializableCacheEntryProcessor>(async, i));
             }
         }
 
@@ -2493,7 +2497,7 @@ namespace Apache.Ignite.Core.Tests.Cache
             TestInvokeAllException(cache, entries, new T { ThrowErrBinarizable = true, ThrowOnKey = errKey }, 
                 arg, errKey);
             TestInvokeAllException(cache, entries, new T { ThrowErrNonSerializable = true, ThrowOnKey = errKey },
-                arg, errKey, "BinaryObjectException");
+                arg, errKey, "ExpectedException");
 
         }
 

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesTest.cs
index fc47f52..d6705d4 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesTest.cs
@@ -55,7 +55,6 @@ namespace Apache.Ignite.Core.Tests.Cache.Query
         [TestFixtureSetUp]
         public void StartGrids()
         {
-            TestUtils.JvmDebug = true;
             TestUtils.KillProcesses();
 
             IgniteConfiguration cfg = new IgniteConfiguration
@@ -867,8 +866,16 @@ namespace Apache.Ignite.Core.Tests.Cache.Query
     /// <summary>
     /// Filter that can't be serialized.
     /// </summary>
-    public class InvalidScanQueryFilter<TV> : ScanQueryFilter<TV>
+    public class InvalidScanQueryFilter<TV> : ScanQueryFilter<TV>, IBinarizable
     {
-        // No-op.
+        public void WriteBinary(IBinaryWriter writer)
+        {
+            throw new BinaryObjectException("Expected");
+        }
+
+        public void ReadBinary(IBinaryReader reader)
+        {
+            throw new BinaryObjectException("Expected");
+        }
     }
 }

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/Continuous/ContinuousQueryAbstractTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/Continuous/ContinuousQueryAbstractTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/Continuous/ContinuousQueryAbstractTest.cs
index e890198..3c0633d 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/Continuous/ContinuousQueryAbstractTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/Continuous/ContinuousQueryAbstractTest.cs
@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 
+#pragma warning disable 618
 namespace Apache.Ignite.Core.Tests.Cache.Query.Continuous
 {
     using System;
@@ -1108,9 +1109,19 @@ namespace Apache.Ignite.Core.Tests.Cache.Query.Continuous
         /// <summary>
         /// Filter which cannot be serialized.
         /// </summary>
-        public class LocalFilter : AbstractFilter<BinarizableEntry>
+        public class LocalFilter : AbstractFilter<BinarizableEntry>, IBinarizable
         {
-            // No-op.
+            /** <inheritDoc /> */
+            public void WriteBinary(IBinaryWriter writer)
+            {
+                throw new BinaryObjectException("Expected");
+            }
+
+            /** <inheritDoc /> */
+            public void ReadBinary(IBinaryReader reader)
+            {
+                throw new BinaryObjectException("Expected");
+            }
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreTest.cs
index 4b13b9f..76241d2 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreTest.cs
@@ -23,7 +23,9 @@ namespace Apache.Ignite.Core.Tests.Cache.Store
     using System.Linq;
     using Apache.Ignite.Core.Binary;
     using Apache.Ignite.Core.Cache;
+    using Apache.Ignite.Core.Cache.Configuration;
     using Apache.Ignite.Core.Cache.Store;
+    using Apache.Ignite.Core.Common;
     using Apache.Ignite.Core.Impl;
     using NUnit.Framework;
 
@@ -107,9 +109,6 @@ namespace Apache.Ignite.Core.Tests.Cache.Store
             for (int i = 105; i < 110; i++)
                 Assert.AreEqual("val_" + i, cache.Get(i));
 
-            // Test invalid filter
-            Assert.Throws<BinaryObjectException>(() => cache.LoadCache(new InvalidCacheEntryFilter(), 100, 10));
-
             // Test exception in filter
             Assert.Throws<CacheStoreException>(() => cache.LoadCache(new ExceptionalEntryFilter(), 100, 10));
 

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/ComputeApiTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/ComputeApiTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/ComputeApiTest.cs
index e82e238..3ef9ad0 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/ComputeApiTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/ComputeApiTest.cs
@@ -911,10 +911,12 @@ namespace Apache.Ignite.Core.Tests.Compute
             Assert.AreEqual(1, res.GetField<int>("field"));
 
             // This call must fail because "keepBinary" flag is reset.
-            Assert.Catch(typeof(BinaryObjectException), () =>
+            var ex = Assert.Throws<BinaryObjectException>(() =>
             {
                 compute.ExecuteJavaTask<IBinaryObject>(EchoTask, EchoTypeBinarizableJava);
             });
+
+            Assert.AreEqual("Unknown pair [platformId=1, typeId=2009791293]", ex.Message);
         }
 
         /// <summary>
@@ -1386,9 +1388,17 @@ namespace Apache.Ignite.Core.Tests.Compute
         }
     }
 
-    class InvalidNetSimpleJob : NetSimpleJob
+    class InvalidNetSimpleJob : NetSimpleJob, IBinarizable
     {
-        // No-op.
+        public void WriteBinary(IBinaryWriter writer)
+        {
+            throw new BinaryObjectException("Expected");
+        }
+
+        public void ReadBinary(IBinaryReader reader)
+        {
+            throw new BinaryObjectException("Expected");
+        }
     }
 
     [Serializable]
@@ -1460,9 +1470,17 @@ namespace Apache.Ignite.Core.Tests.Compute
         }
     }
 
-    class InvalidComputeAction : ComputeAction
+    class InvalidComputeAction : ComputeAction, IBinarizable
     {
-        // No-op.
+        public void WriteBinary(IBinaryWriter writer)
+        {
+            throw new BinaryObjectException("Expected");
+        }
+
+        public void ReadBinary(IBinaryReader reader)
+        {
+            throw new BinaryObjectException("Expected");
+        }
     }
 
     interface IUserInterface<out T>

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/IgniteExceptionTaskSelfTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/IgniteExceptionTaskSelfTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/IgniteExceptionTaskSelfTest.cs
index 912102c..21cd263 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/IgniteExceptionTaskSelfTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/IgniteExceptionTaskSelfTest.cs
@@ -88,9 +88,7 @@ namespace Apache.Ignite.Core.Tests.Compute
         {
             Mode = ErrorMode.MapJobNotMarshalable;
 
-            var e = ExecuteWithError() as BinaryObjectException;
-
-            Assert.IsNotNull(e);
+            Assert.IsInstanceOf<BinaryObjectException>(ExecuteWithError());
         }
 
         /// <summary>
@@ -168,13 +166,7 @@ namespace Apache.Ignite.Core.Tests.Compute
         {
             Mode = ErrorMode.RmtJobErrNotMarshalable;
 
-            int res = Execute();
-
-            Assert.AreEqual(1, res);
-
-            Assert.AreEqual(4, JobErrs.Count);
-
-            Assert.IsNotNull(JobErrs.ElementAt(0) as IgniteException);
+            Assert.Throws<SerializationException>(() => Execute());
         }
 
         /// <summary>
@@ -566,7 +558,7 @@ namespace Apache.Ignite.Core.Tests.Compute
         /// <summary>
         /// 
         /// </summary>
-        public class BadJob : IComputeJob<object>
+        public class BadJob : IComputeJob<object>, IBinarizable
         {
             [InstanceResource]
 
@@ -581,6 +573,18 @@ namespace Apache.Ignite.Core.Tests.Compute
             {
                 // No-op.
             }
+
+            /** <inheritDoc /> */
+            public void WriteBinary(IBinaryWriter writer)
+            {
+                throw new BinaryObjectException("Expected");
+            }
+
+            /** <inheritDoc /> */
+            public void ReadBinary(IBinaryReader reader)
+            {
+                throw new BinaryObjectException("Expected");
+            }
         }
 
         /// <summary>
@@ -621,7 +625,7 @@ namespace Apache.Ignite.Core.Tests.Compute
         /// <summary>
         /// 
         /// </summary>
-        public class BadJobResult
+        public class BadJobResult : IBinarizable
         {
             /** */
             public bool Rmt;
@@ -634,6 +638,18 @@ namespace Apache.Ignite.Core.Tests.Compute
             {
                 Rmt = rmt;
             }
+
+            /** <inheritDoc /> */
+            public void WriteBinary(IBinaryWriter writer)
+            {
+                throw new BinaryObjectException("Expected");
+            }
+
+            /** <inheritDoc /> */
+            public void ReadBinary(IBinaryReader reader)
+            {
+                throw new BinaryObjectException("Expected");
+            }
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/ResourceTaskTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/ResourceTaskTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/ResourceTaskTest.cs
index 433b635..c693a8b 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/ResourceTaskTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Compute/ResourceTaskTest.cs
@@ -21,6 +21,7 @@ namespace Apache.Ignite.Core.Tests.Compute
     using System.Collections.Generic;
     using System.Linq;
     using System.Runtime.Serialization;
+    using Apache.Ignite.Core.Binary;
     using Apache.Ignite.Core.Cluster;
     using Apache.Ignite.Core.Compute;
     using Apache.Ignite.Core.Resource;
@@ -158,9 +159,17 @@ namespace Apache.Ignite.Core.Tests.Compute
         /// <summary>
         /// Binarizable job.
         /// </summary>
-        public class InjectionJobBinarizable : InjectionJob
+        public class InjectionJobBinarizable : InjectionJob, IBinarizable
         {
-            // No-op.
+            public void WriteBinary(IBinaryWriter writer)
+            {
+                // No-op.
+            }
+
+            public void ReadBinary(IBinaryReader reader)
+            {
+                // No-op.
+            }
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/ignite/blob/79bac4f8/modules/platforms/dotnet/Apache.Ignite.Core.Tests/DeploymentTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/DeploymentTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/DeploymentTest.cs
index ab5a1a6..ece4894 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/DeploymentTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/DeploymentTest.cs
@@ -15,8 +15,6 @@
  * limitations under the License.
  */
 
-#pragma warning disable 649
-#pragma warning disable 169
 namespace Apache.Ignite.Core.Tests
 {
     using System;
@@ -53,15 +51,21 @@ namespace Apache.Ignite.Core.Tests
             Assert.Greater(jars.Length, 3);
 
             foreach (var jar in jars)
-                // ReSharper disable once AssignNullToNotNullAttribute
-                File.Copy(jar, Path.Combine(folder, Path.GetFileName(jar)), true);
+            {
+                var fileName = Path.GetFileName(jar);
+                Assert.IsNotNull(fileName);
+                File.Copy(jar, Path.Combine(folder, fileName), true);
+            }
 
             // Build classpath
             var classpath = string.Join(";", Directory.GetFiles(folder).Select(Path.GetFileName));
 
             // Copy .NET binaries
-            foreach (var asm in new[] {typeof (IgniteRunner).Assembly, typeof (Ignition).Assembly, GetType().Assembly})
+            foreach (var asm in new[] {typeof(IgniteRunner).Assembly, typeof(Ignition).Assembly, GetType().Assembly})
+            {
+                Assert.IsNotNull(asm.Location);
                 File.Copy(asm.Location, Path.Combine(folder, Path.GetFileName(asm.Location)));
+            }
 
             // Copy config
             var springPath = Path.GetFullPath("config\\compute\\compute-grid2.xml");
@@ -76,7 +80,6 @@ namespace Apache.Ignite.Core.Tests
                 "-springConfigUrl=" + springFile,
                 "-jvmClasspath=" + classpath,
                 "-J-ea",
-                "-J-Xcheck:jni",
                 "-J-Xms512m",
                 "-J-Xmx512m"
             });
@@ -157,6 +160,7 @@ namespace Apache.Ignite.Core.Tests
             throw new InvalidOperationException();
         }
 
+        #pragma warning disable 649
         /// <summary>
         /// Function that returns process path.
         /// </summary>


Mime
View raw message