/Examples/DictionaryTests.cs

using System.Linq;

using NUnit.Framework;

using System.Collections.Generic;

using ProtoBuf;

using System;

using ProtoBuf.Meta;

using System.IO;

using System.Diagnostics;

using System.Text;



namespace Examples.Dictionary

{

    [ProtoContract]

    class DataWithDictionary<T>

    {

        public DataWithDictionary()

        {

            Data = new Dictionary<int, T>();

        }

        [ProtoMember(1)]

        public IDictionary<int, T> Data { get; private set; }

    }



    [ProtoContract]

    class SimpleData : IEquatable<SimpleData>

    {

        private SimpleData() {}

        public SimpleData(int value) {

            Value = value;}



        [ProtoMember(1)]

        public int Value { get; set; }



        public bool Equals(SimpleData other)

        {

            return Value == other.Value;

        }



        public override int GetHashCode()

        {

            return Value.GetHashCode();

        }

        public override bool Equals(object other)

        {

            return Equals(other as SimpleData);

        }

    }



    [TestFixture]

    public class DictionaryTests

    {

        [Test]

        public void TestNestedDictionaryWithStrings()

        {

            var obj = new DataWithDictionary<string>();

            obj.Data[0] = "abc";

            obj.Data[4] = "def";

            obj.Data[7] = "abc";



            var clone = Serializer.DeepClone(obj);

            Assert.AreNotSame(obj,clone);

            AssertEqual(obj.Data, clone.Data);

        }



        [Test]

        public void TestNestedDictionaryWithSimpleData()

        {

            var obj = new DataWithDictionary<SimpleData>();

            obj.Data[0] = new SimpleData(5);

            obj.Data[4] = new SimpleData(72);

            obj.Data[7] = new SimpleData(72);



            var clone = Serializer.DeepClone(obj);

            Assert.AreNotSame(obj, clone);

            AssertEqual(obj.Data, clone.Data);

        }



        [Test]

        public void RoundtripDictionary()

        {

            var lookup = new Dictionary<int,string>();

            lookup[0] = "abc";

            lookup[4] = "def";

            lookup[7] = "abc";



            var clone = Serializer.DeepClone(lookup);

            

            AssertEqual(lookup, clone);

        }

        static void AssertEqual<TKey, TValue>(

            IDictionary<TKey, TValue> expected,

            IDictionary<TKey, TValue> actual)

        {

            Assert.AreNotSame(expected, actual, "Instance");

            Assert.AreEqual(expected.Count, actual.Count, "Count");

            foreach (var pair in expected)

            {

                TValue value;

                Assert.IsTrue(actual.TryGetValue(pair.Key, out value), "Missing: " + pair.Key);

                Assert.AreEqual(pair.Value, value, "Value: " + pair.Key);

            }

        }

    }

    [TestFixture]

    public class EmptyDictionaryTests

    {

        [Test]

        public void EmptyDictionaryShouldDeserializeAsNonNull()

        {

            using (var ms = new MemoryStream())

            {

                var data = new Dictionary<string, int>();



                Serializer.Serialize(ms, data);

                ms.Position = 0;

                var clone = Serializer.Deserialize<Dictionary<string, int>>(ms);



                Assert.IsNotNull(clone);

                Assert.AreEqual(0, clone.Count);

            }

        }

        [Test]

        public void NonEmptyDictionaryShouldDeserialize()

        {

            using (var ms = new MemoryStream())

            {

                var data = new Dictionary<string, int> { { "abc", 123 } };



                Serializer.Serialize(ms, data);

                ms.Position = 0;

                var clone = Serializer.Deserialize<Dictionary<string, int>>(ms);



                Assert.IsNotNull(clone);

                Assert.AreEqual(1, clone.Count);

                Assert.AreEqual(123, clone["abc"]);

            }

        }

        [Test]

        public void EmptyDictionaryShouldDeserializeAsNonNullViaInterface()

        {

            using (var ms = new MemoryStream())

            {

                var data = new Dictionary<string, int>();



                Serializer.Serialize(ms, data);

                ms.Position = 0;

                var clone = Serializer.Deserialize<IDictionary<string, int>>(ms);



                Assert.IsNotNull(clone);

                Assert.AreEqual(0, clone.Count);

            }



        }

        [Test]

        public void NonEmptyDictionaryShouldDeserializeViaInterface()

        {

            using (var ms = new MemoryStream())

            {

                var data = new Dictionary<string, int> { { "abc", 123 } };



                Serializer.Serialize(ms, data);

                ms.Position = 0;

                var clone = Serializer.Deserialize<IDictionary<string, int>>(ms);



                Assert.IsNotNull(clone);

                Assert.AreEqual(1, clone.Count);

                Assert.AreEqual(123, clone["abc"]);

            }

        }

    }

    [TestFixture]

    public class NestedDictionaryTests {



        [Test]

        public void TestNestedConcreteConcreteDictionary()

        {

            Dictionary<string, Dictionary<string, String>> data = new Dictionary<string, Dictionary<string, string>>

            {

                { "abc", new Dictionary<string,string> {{"def","ghi"}}},

                { "jkl", new Dictionary<string,string> {{"mno","pqr"},{"stu","vwx"}}}

            };

            CheckNested(data, "original");

            var clone = Serializer.DeepClone(data);

            CheckNested(clone, "clone");

        }



        [Test]

        public void TestNestedInterfaceInterfaceDictionary()

        {

            IDictionary<string, IDictionary<string, String>> data = new Dictionary<string, IDictionary<string, string>>

            {

                { "abc", new Dictionary<string,string> {{"def","ghi"}}},

                { "jkl", new Dictionary<string,string> {{"mno","pqr"},{"stu","vwx"}}}

            };

            CheckNested(data, "original");

            var clone = Serializer.DeepClone(data);

            CheckNested(clone, "clone");

        }



        [Test]

        public void TestNestedInterfaceConcreteDictionary()

        {

            IDictionary<string, Dictionary<string, String>> data = new Dictionary<string, Dictionary<string, string>>

            {

                { "abc", new Dictionary<string,string> {{"def","ghi"}}},

                { "jkl", new Dictionary<string,string> {{"mno","pqr"},{"stu","vwx"}}}

            };

            CheckNested(data, "original");

            var clone = Serializer.DeepClone(data);

            CheckNested(clone, "clone");

        }

        [Test]

        public void TestNestedConcreteInterfaceDictionary()

        {

            Dictionary<string, IDictionary<string, String>> data = new Dictionary<string, IDictionary<string, string>>

            {

                { "abc", new Dictionary<string,string> {{"def","ghi"}}},

                { "jkl", new Dictionary<string,string> {{"mno","pqr"},{"stu","vwx"}}}

            };

            CheckNested(data, "original");

            var clone = Serializer.DeepClone(data);

            CheckNested(clone, "clone");

        }



        static void CheckNested<TInner>(IDictionary<string, TInner> data, string message)

            where TInner : IDictionary<string, string>

        {

            Assert.IsNotNull(data, message);

            Assert.AreEqual(2, data.Keys.Count, message);

            var inner = data["abc"];

            Assert.AreEqual(1, inner.Keys.Count, message);

            Assert.AreEqual(inner["def"], "ghi", message);

            inner = data["jkl"];

            Assert.AreEqual(2, inner.Keys.Count, message);

            Assert.AreEqual(inner["mno"], "pqr", message);

            Assert.AreEqual(inner["stu"], "vwx", message);



        }



        [Test]

        public void CheckPerformanceNotInsanelyBad()

        {

            var model = TypeModel.Create();

            model.Add(typeof (PropsViaDictionaryDefault), true);

            model.Add(typeof (PropsViaDictionaryGrouped), true);

            model.Add(typeof (PropsViaProperties), true);

            model.CompileInPlace();

            var o1 = new PropsViaProperties { Field1 = 123, Field2 = 456, Field3 = 789 };



            var o2 = new PropsViaDictionaryDefault()

            {

                Values = new List<KeyValuePair> {

                new KeyValuePair {Key = "Field1", Value =123 },

                new KeyValuePair {Key = "Field2", Value =456 },

                new KeyValuePair {Key = "Field2", Value =789 },

            }

            };

            var o3 = new PropsViaDictionaryGrouped()

            {

                Values = new List<KeyValuePair> {

                new KeyValuePair {Key = "Field1", Value =123 },

                new KeyValuePair {Key = "Field2", Value =456 },

                new KeyValuePair {Key = "Field2", Value =789 },

            }

            };





            int s1, s2, s3, d1, d2, d3;

            int l1 = BulkTest(model, o1, out s1, out d1);

            int l2 = BulkTest(model, o2, out s2, out d2);

            int l3 = BulkTest(model, o2, out s3, out d3);



            Console.WriteLine("Bytes (props)\t" + l1);

            Console.WriteLine("Ser (props)\t" + s1);

            Console.WriteLine("Deser (props)\t" + d1);

            Console.WriteLine("Bytes (kv-default)\t" + l2);

            Console.WriteLine("Ser (kv-default)\t" + s2);

            Console.WriteLine("Deser (kv-default)\t" + d2);

            Console.WriteLine("Bytes (kv-grouped)\t" + l3);

            Console.WriteLine("Ser (kv-grouped)\t" + s3);

            Console.WriteLine("Deser (kv-grouped)\t" + d3);



            var pw = new ProtoWriter(Stream.Null, null, null);

            Stopwatch watch = Stopwatch.StartNew();

            for (int i = 0; i < LOOP; i++ ) {

                ProtoWriter.WriteFieldHeader(1, WireType.String, pw);

                ProtoWriter.WriteString("Field1", pw);

                ProtoWriter.WriteFieldHeader(1, WireType.String, pw);

                ProtoWriter.WriteString("Field2", pw);

                ProtoWriter.WriteFieldHeader(1, WireType.String, pw);

                ProtoWriter.WriteString("Field3", pw);

            }

            watch.Stop();

            pw.Close();

            Console.WriteLine("Encoding: " + watch.ElapsedMilliseconds);

            

        }

        const int LOOP = 500000;

        static int BulkTest<T>(TypeModel model, T obj, out int serialize, out int deserialize) where T: class

        {

            

            using(MemoryStream ms = new MemoryStream())

            {

                Stopwatch watch = Stopwatch.StartNew();

                for (int i = 0; i < LOOP; i++)

                {

                    ms.Position = 0;

                    ms.SetLength(0);

                    model.Serialize(ms, obj);

                }

                watch.Stop();

                serialize = (int)watch.ElapsedMilliseconds;

                watch.Reset();

                Type type = typeof (T);

                watch.Start();

                for (int i = 0; i < LOOP; i++)

                {

                    ms.Position = 0;

                    model.Deserialize(ms, null, type);

                }

                watch.Stop();

                deserialize = (int)watch.ElapsedMilliseconds;

                return (int)ms.Length;

            }

        }





        [ProtoContract]

        public class PropsViaDictionaryDefault

        {

            [ProtoMember(1, DataFormat = DataFormat.Default)] public List<KeyValuePair> Values { get; set;}

        }

        [ProtoContract]

        public class PropsViaDictionaryGrouped

        {

            [ProtoMember(1, DataFormat = DataFormat.Group)]

            public List<KeyValuePair> Values { get; set; }

        }

        [ProtoContract]

        public class KeyValuePair

        {

            [ProtoMember(1)] public string Key { get; set;}

            [ProtoMember(2)] public int Value { get; set;}

        }

        [ProtoContract]

        class PropsViaProperties

        {

            [ProtoMember(1)] public int Field1 { get; set;}

            [ProtoMember(2)] public int Field2 { get; set;}

            [ProtoMember(3)] public int Field3 { get; set;}

        }

    }

}