//
// Copyright (c) 2012-2021 Antmicro
//
// This file is licensed under the MIT License.
// Full license text is available in the LICENSE file.

using System;
using System.Threading;
using NUnit.Framework;
using System.Collections.Generic;
using System.Collections;
using System.Collections.Concurrent;
using System.Linq;
using System.IO;
using System.Collections.ObjectModel;
using Antmicro.Migrant.Hooks;

namespace Antmicro.Migrant.Tests
{
    [TestFixture(false, false, false, false, true)]
    [TestFixture(true, false, false, false, true)]
    [TestFixture(false, true, false, false, true)]
    [TestFixture(true, true, false, false, true)]
    [TestFixture(false, false, true, false, true)]
    [TestFixture(true, false, true, false, true)]
    [TestFixture(false, true, true, false, true)]
    [TestFixture(true, true, true, false, true)]
    [TestFixture(false, false, false, true, true)]
    [TestFixture(true, false, false, true, true)]
    [TestFixture(false, true, false, true, true)]
    [TestFixture(true, true, false, true, true)]
    [TestFixture(false, false, true, true, true)]
    [TestFixture(true, false, true, true, true)]
    [TestFixture(false, true, true, true, true)]
    [TestFixture(true, true, true, true, true)]
    [TestFixture(false, false, false, false, false)]
    [TestFixture(true, false, false, false, false)]
    [TestFixture(false, true, false, false, false)]
    [TestFixture(true, true, false, false, false)]
    [TestFixture(false, false, true, false, false)]
    [TestFixture(true, false, true, false, false)]
    [TestFixture(false, true, true, false, false)]
    [TestFixture(true, true, true, false, false)]
    [TestFixture(false, false, false, true, false)]
    [TestFixture(true, false, false, true, false)]
    [TestFixture(false, true, false, true, false)]
    [TestFixture(true, true, false, true, false)]
    [TestFixture(false, false, true, true, false)]
    [TestFixture(true, false, true, true, false)]
    [TestFixture(false, true, true, true, false)]
    [TestFixture(true, true, true, true, false)]
    public class SerializationTests : BaseTestWithSettings
    {
        public SerializationTests(bool useGeneratedSerializer, bool useGeneratedDeserializer, bool treatCollectionsAsUserObjects, bool supportForISerializable, bool useTypeStamping) : base(useGeneratedSerializer, useGeneratedDeserializer, treatCollectionsAsUserObjects, supportForISerializable, false, useTypeStamping, true)
        {
            useGeneratedSerialization = useGeneratedSerializer;
        }

        [Test]
        public void ShouldSerializeObject()
        {
            var obj = new object();
            var copy = SerializerClone(obj);
            Assert.AreEqual(copy.GetType(), typeof(object));
        }

        [Test]
        public void ShouldSerializeSimpleClass()
        {
            var simpleClass = new SimpleClass { Value = 0x69, Str = "Magic" };
            var copy = SerializerClone(simpleClass);
            Assert.AreEqual(simpleClass, copy);
        }

        [Test]
        public void ShouldSerializeCyclicReference()
        {
            var one = new CyclicRef();
            var another = new CyclicRef { Another = one, Val = 1 };
            one.Another = another;
            var oneCopy = SerializerClone(one);
            Assert.AreEqual(oneCopy, oneCopy.Another.Another, "Cyclic reference was not properly serialized.");
        }

        [Test]
        public void ShouldSerializeReferenceToSelf()
        {
            var one = new CyclicRef();
            one.Another = one;
            var copy = SerializerClone(one);
            Assert.AreSame(copy, copy.Another);
        }

        [Test]
        public void ShouldSerializeArrayReferenceToSelf()
        {
            var array = new object[2];
            array[0] = array;
            array[1] = array;
            var copy = SerializerClone(array);
            Assert.AreSame(copy, copy[0]);
            Assert.AreSame(copy[0], copy[1]);
        }

        [Test]
        public void ShouldSerializeNullReference()
        {
            var simpleClass = new SimpleClass();
            var copy = SerializerClone(simpleClass);
            Assert.AreEqual(simpleClass, copy);
        }

        [Test]
        public void ShouldPreserveIdentity()
        {
            var str = "This is a string";
            var simple1 = new SimpleClass { Str = str };
            var simple2 = new SimpleClass { Str = str };
            var container = new SimpleContainer { First = simple1, Second = simple2 };
            var copy = SerializerClone(container);
            Assert.AreSame(copy.First.Str, copy.Second.Str);
        }

        [Test]
        public void ShouldSerializeReadonlyField()
        {
            const int testValue = 0xABCD;
            var readonlyClass = new ClassWithReadonly(testValue);
            var copy = SerializerClone(readonlyClass);
            Assert.AreEqual(readonlyClass.ReadonlyValue, copy.ReadonlyValue);
        }

        [Test]
        public void ShouldNotSerializeIntPtr()
        {
            var intPtrClass = new ClassWithIntPtr{ Ptr = new IntPtr(0x666) };
            try
            {
                SerializerClone(intPtrClass);
                Assert.Fail("Class with IntPtr was serialized without exception.");
            }
            catch(InvalidOperationException)
            {

            }
        }

        [Test]
        public void ShouldNotSerializeSpinLock()
        {
            var spinLockClass = new ClassWithSpinLock{ SLock = new SpinLock() };
            try
            {
                SerializerClone(spinLockClass);
                Assert.Fail("Class with SpinLock was serialized without exception.");
            }
            catch(InvalidOperationException)
            {

            }
        }

        [Test]
        public void ShouldSerializeWithInheritance()
        {
            SimpleBaseClass derived = new SimpleDerivedClass { BaseField = 1, DerivedField = 2 };
            var copy = (SimpleDerivedClass)SerializerClone(derived);
            Assert.AreEqual(copy.DerivedField, 2);
            Assert.AreEqual(copy.BaseField, 1);
        }

        [Test]
        public void ShouldSerializeBoxWithLazyScan()
        {
            var str = "Something";
            var box = new Box { Element = str };
            var copy = SerializerClone(box);
            Assert.AreEqual(str, copy.Element);
        }

        [Test]
        public void ShouldSerializeFieldWithDifferentFormalAndActualType()
        {
            var box = new Box();
            var anotherBox = new Box { Element = box };
            var copy = SerializerClone(anotherBox);
            Assert.AreEqual(typeof(Box), copy.Element.GetType());
        }

        [Test]
        public void ShouldSerializeListOfPrimitives()
        {
            var list = new List<int> { 1, 2, 3 };
            var copy = SerializerClone(list);
            CollectionAssert.AreEqual(list, copy);
        }

        [Test]
        public void ShouldSerializeLongListOfPrimitives()
        {
            var list = new List<int>();
            for(var i = 0; i < 100000; i++)
            {
                list.Add(i);
            }
            var copy = SerializerClone(list);
            CollectionAssert.AreEqual(list, copy);
        }

        [Test]
        public void ShouldSerializeListOfLists()
        {
            var first = new List<int> { 1, 2, 3 };
            var second = new List<int> { 97, 98, 99 };
            var list = new List<List<int>> { first, second };
            var copy = SerializerClone(list);
            for(var i = 0; i < 2; i++)
            {
                CollectionAssert.AreEqual(list[i], copy[i]);
            }
        }

        [Test]
        public void ShouldPreserveIdentityOnLists()
        {
            var list = new List<Box>();
            var box1 = new Box { Element = list };
            var box2 = new Box { Element = list };
            list.Add(box1);
            list.Add(box2);

            var copy = SerializerClone(list);
            Assert.AreSame(copy, copy[0].Element);
            Assert.AreSame(copy[0].Element, copy[1].Element);
        }

        [Test]
        public void ShouldSerializeArrayListWithStrings()
        {
            var list = new ArrayList { "Word 1", "Word 2", new SimpleClass { Value = 6, Str = "Word 4" }, "Word 3" };
            var copy = SerializerClone(list);
            CollectionAssert.AreEqual(list, copy);
        }

        [Test]
        public void ShouldSerializeArrayListWithPrimitives()
        {
            var list = new ArrayList { 1, 2, 3 };
            var copy = SerializerClone(list);
            CollectionAssert.AreEqual(list, copy);
        }

        [Test]
        public void ShouldSerializeHashSetWithPrimitives()
        {
            var collection = new HashSet<int> { 1, 2, 3 };
            var copy = SerializerClone(collection);
            CollectionAssert.AreEquivalent(collection, copy);
        }

        [Test]
        public void ShouldSerializeReadOnlyCollection()
        {
            var list = new List<object> { "asdasd", 1, "cvzxcv" };
            var roList = new ReadOnlyCollection<object>(list);
            var copy = SerializerClone(roList);
            CollectionAssert.AreEqual(roList, copy);
        }

        [Test]
        public void ShouldSerializeBoxedPrimitve()
        {
            var box = new Box { Element = 3 };
            var copy = SerializerClone(box);
            Assert.AreEqual(3, copy.Element);
        }

        [Test]
        public void ShouldPreserveIdentityWithBoxedPrimitives()
        {
            object primitive = 1234;
            var box1 = new Box { Element = primitive };
            var box2 = new Box { Element = primitive };
            var list = new List<Box> { box1, box2 };
            var copy = SerializerClone(list);
            Assert.AreSame(copy[0].Element, copy[1].Element);
        }

        [Test]
        public void ShouldSerializeListWithNull()
        {
            var list = new List<object> { "One", null, "Two" };
            var copy = SerializerClone(list);
            CollectionAssert.AreEqual(list, copy);
        }

        [Test]
        public void ShouldSerializeArrayWithPrimitives()
        {
            var array = new [] { 1, 2, 3, 4, 5, 6 };
            var copy = SerializerClone(array);
            CollectionAssert.AreEqual(array, copy);
        }

        [Test]
        public void ShouldSerializeTwodimensionalArrayWithPrimitives()
        {
            var array = new [,] { { 1, 2 }, { 3, 4 }, { 5, 6 } };
            var copy = SerializerClone(array);
            CollectionAssert.AreEqual(array, copy);
        }

        [Test]
        public void ShouldSerializeArrayWithStrings()
        {
            var array = new [] { "One", "Two", "Three" };
            var copy = SerializerClone(array);
            CollectionAssert.AreEqual(array, copy);
        }

        [Test]
        public void ShouldSerializeTwodimensionalArrayWithStrings()
        {
            var array = new [,] { { "One", "Two" }, { "Three", "Four" } };
            var copy = SerializerClone(array);
            CollectionAssert.AreEqual(array, copy);
        }

        [Test]
        public void ShouldSerialize4DArrayWithPrimitives()
        {
            var array = new int[2, 2, 3, 4];
            array[0, 0, 0, 0] = 1;
            array[1, 0, 1, 0] = 2;
            array[0, 1, 0, 1] = 3;
            array[0, 1, 2, 2] = 4;
            array[1, 0, 2, 3] = 5;
            var copy = SerializerClone(array);
            Assert.AreEqual(array, copy);
        }

        [Test]
        public void ShouldSerializeMixedArray()
        {
            var obj = new object();
            var array = new [] { "One", obj, "Two", obj, new object() };
            var copy = SerializerClone(array);
            CollectionAssert.AreEqual(array.Where(x => x is String), copy.Where(x => x is String));
            Assert.AreSame(copy[1], copy[3]);
            Assert.AreNotSame(copy[3], copy[4]);
        }

        [Test]
        public void ShouldSerializeDictionaryWithPrimitives()
        {
            var dictionary = new Dictionary<int, int>();
            for(var i = 0; i < 100; i++)
            {
                dictionary.Add(i, i + 1);
            }
            var copy = SerializerClone(dictionary);
            CollectionAssert.AreEquivalent(dictionary, copy);
        }

        [Test]
        public void ShouldSerializeHashtable()
        {
            var hashtable = new Hashtable();
            for(var i = 0; i < 100; i++)
            {
                hashtable.Add(i, i + 1);
            }
            var copy = SerializerClone(hashtable);
            CollectionAssert.AreEquivalent(hashtable, copy);
        }

        [Test]
        public void ShouldSerializeDictionaryWithStrings()
        {
            var dictionary = new Dictionary<string, string> {
                { "Ball", "Piłka" },
                { "Cat", "Kot" },
                { "Line", "Linia" }
            };
            var copy = SerializerClone(dictionary);
            CollectionAssert.AreEquivalent(dictionary, copy);
        }

        [Test]
        public void ShouldPreserveIdentityWithDictionary()
        {
            var str = "Word";
            var dictionary = new Dictionary<int, string> {
                { 10, str },
                { 20, "One" },
                { 30, str }
            };
            var copy = SerializerClone(dictionary);
            CollectionAssert.AreEquivalent(dictionary, copy);
            Assert.AreSame(copy[10], copy[30]);
            Assert.AreNotSame(copy[10], copy[20]);
        }

        [Test]
        public void ShouldSerializeSimpleEnum()
        {
            var e = SimpleEnum.Two;
            var copy = SerializerClone(e);
            Assert.AreEqual(e, copy);
        }

        [Test]
        public void ShouldSerializeEnums()
        {
            var enumLongValues = Enum.GetValues(typeof(EnumLong)).Cast<EnumLong>().ToArray();
            var enumShortValues = Enum.GetValues(typeof(EnumShort)).Cast<EnumShort>().ToArray();
            var enumFlagsValues = Enum.GetValues(typeof(TestEnumFlags)).Cast<TestEnumFlags>()
            .Union(new [] {
                TestEnumFlags.First | TestEnumFlags.Second
                , TestEnumFlags.First | TestEnumFlags.Second | TestEnumFlags.Third
                , TestEnumFlags.Second | TestEnumFlags.Third
            }).ToArray();

            foreach(var item in enumLongValues)
            {
                Assert.AreEqual(item, SerializerClone(item));
            }
            foreach(var item in enumShortValues)
            {
                Assert.AreEqual(item, SerializerClone(item));
            }
            foreach(var item in enumFlagsValues)
            {
                Assert.AreEqual(item, SerializerClone(item));
            }
        }

        [Test]
        public void ShouldSerializeSimplerStruct()
        {
            var str = new SimplerStruct { A = 1234567, B = 543 };
            var copy = SerializerClone(str);
            Assert.AreEqual(str, copy);
        }

        [Test]
        public void ShouldSerializeSimpleStruct()
        {
            var str = new SimpleStruct {
                A = 5,
                B = "allman"
            };
            var copy = SerializerClone(str);
            Assert.AreEqual(str, copy);
        }

        [Test]
        public void ShouldSerializeComplexStruct()
        {
            var str = new SimpleStruct {
                A = 5,
                B = "allman"
            };

            var compstr = new ComplexStruct {
                A = 6,
                B = str
            };
            var newStr = SerializerClone(compstr);

            Assert.AreEqual(compstr, newStr);
        }

        [Test]
        public void ShouldSerializeStructInClass()
        {
            var str = new SimpleStruct { A = 1, B = "allman" };
            var box = new GenericBox<SimpleStruct> { Element = str };
            var copy = SerializerClone(box);
            Assert.AreEqual(str, copy.Element);
        }

        [Test]
        public void ShouldSerializeSpeciallySerializable()
        {
            var special = new SpeciallySerializable();
            special.Fill(100);
            var copy = SerializerClone(special);
            CollectionAssert.AreEqual(special.Data, copy.Data);
        }

        [Test]
        public void ShouldSerializeSpeciallySerializableInArrayAndPreserveIdentity()
        {
            var special = new SpeciallySerializable();
            special.Fill(100);
            var str = "Some string";
            var box = new Box { Element = special };
            var anotherSpecial = new SpeciallySerializable();
            anotherSpecial.Fill(100);
            var array = new object[] { special, str, box, anotherSpecial };
            var copy = SerializerClone(array);
            Assert.AreSame(copy[0], ((Box)copy[2]).Element);
            Assert.AreNotSame(copy[0], copy[3]);
            CollectionAssert.AreEqual(((SpeciallySerializable)copy[0]).Data, special.Data);
            CollectionAssert.AreEqual(((SpeciallySerializable)copy[3]).Data, anotherSpecial.Data);
        }

        [Test]
        public void ShouldSerializeBoxWithLong()
        {
            var box = new GenericBox<long> { Element = 1234 };
            var copy = SerializerClone(box);
            Assert.AreEqual(box.Element, copy.Element);
        }

        [Test]
        public void ShouldSerializeStructWithSpeciallySerializable()
        {
            var special = new SpeciallySerializable();
            special.Fill(100);
            var box = new StructGenericBox<SpeciallySerializable> { Element = special };
            var copy = SerializerClone(box);
            Assert.AreEqual(box.Element.Data, copy.Element.Data);
        }

        [Test]
        public void ShouldSerializeNonNullNullable()
        {
            var box = new GenericBox<int?> { Element = 3 };
            var copy = SerializerClone(box);
            Assert.AreEqual(box.Element, copy.Element);
        }

        [Test]
        public void ShouldSerializeNullNullable()
        {
            var box = new GenericBox<int?> { Element = null };
            var copy = SerializerClone(box);
            Assert.AreEqual(box.Element, copy.Element);
        }

        [Test]
        public void ShouldSerializeBoxedNullNullable()
        {
            int? value = 66;
            var box = new Box { Element = value };
            var copy = SerializerClone(box);
            Assert.AreEqual(box.Element, copy.Element);
        }

        [Test]
        public void ShouldSerializeBoxedNonNullNullable()
        {
            int? value = null;
            var box = new Box { Element = value };
            var copy = SerializerClone(box);
            Assert.AreEqual(box.Element, copy.Element);
        }

        [Test]
        public void ShouldSerializeConcurrentDictionary()
        {
            var dictionary = new ConcurrentDictionary<int, int>();
            for(var i = 0; i < 10; i++)
            {
                dictionary.TryAdd(i, 2 * i);
            }
            var copy = SerializerClone(dictionary);
            CollectionAssert.AreEquivalent(dictionary, copy);
        }

        [Test]
        public void ShouldHandleTwoSerializations()
        {
            var someObjects = new object[] { "One", 2, null, "Four" };
            var stream = new MemoryStream();
            var serializer = new Serializer(GetSettings());
            serializer.Serialize(someObjects, stream);
            serializer.Serialize(someObjects, stream);
            stream.Seek(0, SeekOrigin.Begin);
            var copy = serializer.Deserialize<object[]>(stream);
            CollectionAssert.AreEqual(someObjects, copy);
            copy = serializer.Deserialize<object[]>(stream);
            CollectionAssert.AreEqual(someObjects, copy);
        }

        [Test]
        public void ShouldDetectStreamShift()
        {
            var errorneousObject = new BadlySerializable();
            try
            {
                SerializerClone(errorneousObject);
                Assert.Fail("Exception was not thrown despite stream corruption.");
            }
            catch(InvalidOperationException)
            {
            }
        }

        [Test]
        public void ShouldSerializeTuple()
        {
            var tuple = Tuple.Create("One", "Two", "Three");
            var copy = SerializerClone(tuple);
            Assert.AreEqual(tuple, copy);
        }

        [Test]
        public void ShouldInvokeConstructorForFieldInStruct()
        {
            var withCtor = new StructWithConstructorAttribute();
            var copy = SerializerClone(withCtor);
            Assert.IsTrue(copy.IsFieldConstructed, "[Constructor] marked field was not initialized.");
        }

        [Test]
        public void ShouldInvokeConstructorForFieldInStructComplex()
        {
            var withCtor = new StructWithConstructorAttributeOnNestedStruct();
            var copy = SerializerClone(withCtor);
            Assert.IsTrue(copy.IsFieldConstructed, "[Constructor] marked field was not initialized.");
        }

        [Test]
        public void ShouldInvokeConstructorForField()
        {
            var withCtor = new WithConstructorAttribute();
            var copy = SerializerClone(withCtor);
            Assert.IsTrue(copy.IsFieldConstructed, "[Constructor] marked field was not initialized.");
        }

        [Test]
        public void ShouldOmitTransientClass()
        {
            SerializerClone(new Box { Element = new TransientClass() });
        }

        [Test]
        public void ShouldOmitTransientField()
        {
            var trans = new ClassWithTransientField() { a = 147, b = 256, c = 850 };
            var scd = SerializerClone(trans);

            Assert.AreEqual(trans.a, scd.a);
            Assert.AreEqual(default(int), scd.b);
            Assert.AreEqual(trans.c, scd.c);
        }

        [Test]
        public void ShouldSerializeQueue()
        {
            var queue = new Queue<int>();
            queue.Enqueue(1);
            queue.Enqueue(3);
            queue.Enqueue(5);
            var copy = SerializerClone(queue);
            CollectionAssert.AreEqual(queue, copy);
        }

        [Test]
        public void ShouldSerializeByteArray()
        {
            var array = new byte[] { 2, 4, 6, 8, 10 };
            var copy = SerializerClone(array);
            CollectionAssert.AreEqual(array, copy);
        }

        [Test]
        public void ShouldSerializeEvent()
        {
            var withEvent = new ClassWithEvent();
            var companion = new CompanionToClassWithEvent();
            withEvent.Event += companion.Method;
            var pair = Tuple.Create(withEvent, companion);

            var copy = SerializerClone(pair);
            copy.Item1.Invoke();
            Assert.AreEqual(1, copy.Item2.Counter);
        }

        [Test]
        public void ShouldSerializeMulticastEvent()
        {
            var withEvent = new ClassWithEvent();
            var companion1 = new CompanionToClassWithEvent();
            withEvent.Event += companion1.Method;
            var companion2 = new CompanionToClassWithEvent();
            withEvent.Event += companion2.Method;
            var triple = Tuple.Create(withEvent, companion1, companion2);

            var copy = SerializerClone(triple);
            copy.Item1.Invoke();
            Assert.AreEqual(1, copy.Item2.Counter);
            Assert.AreEqual(1, copy.Item3.Counter);
        }

        [Test]
        public void ShouldSerializeDelegateWithTargetFromDifferentModule()
        {
            var withEvent = new ClassWithEvent();
            var companion = new CompanionSecondModule();
            withEvent.Event += companion.MethodAsExtension;
            var pair = Tuple.Create(withEvent, companion);

            var copy = SerializerClone(pair);
            copy.Item1.Invoke();
            Assert.AreEqual(1, copy.Item2.Counter);
        }

        [Test]
        public void ShouldSerializeDelegateWithInterfaceMethod()
        {
            var withEvent = new ClassWithEvent<IInterfaceForDelegate>();
            var companion = new ClassImplementingInterfaceForDelegate();
            withEvent.Event += companion.Method;
            var pair = Tuple.Create(withEvent, companion);

            var copy = SerializerClone(pair);
            copy.Item1.Invoke(null);
            Assert.AreEqual(true, copy.Item2.Invoked);
        }

        [Test]
        public void ShouldSerializeDelegateWithLambdaAttached()
        {
            var withEvent = new ClassWithEvent();
            var companion = new ClassImplementingInterfaceForDelegate();
            withEvent.Event += () => companion.Method(null);
            var pair = Tuple.Create(withEvent, companion);

            var copy = SerializerClone(pair);
            copy.Item1.Invoke();
            Assert.AreEqual(true, copy.Item2.Invoked);
        }

        [Test]
        public void ShouldSerializeEmptyArray()
        {
            var emptyArray = new int[0];
            var copy = SerializerClone(emptyArray);
            CollectionAssert.AreEqual(emptyArray, copy);
        }

        [Test]
        public void ShouldSerializeEmptyList()
        {
            var emptyList = new List<int>();
            var copy = SerializerClone(emptyList);
            CollectionAssert.AreEqual(emptyList, copy);
        }

        [Test]
        public void ShouldSerializeByteEnum()
        {
            var byteEnum = EnumByte.Two;
            var copy = SerializerClone(byteEnum);
            Assert.AreEqual(byteEnum, copy);
        }

        [Test]
        public void ShouldThrowOnThreadLocalSerialization()
        {
            var classWithThreadLocal = new ClassWithThreadLocal();
            Assert.Throws(typeof(InvalidOperationException), () => SerializerClone(classWithThreadLocal));
        }

        [Test]
        public void ShouldOmitDelegateWithTransientTarget()
        {
            var withEvent = new ClassWithEvent();
            var target1 = new TransientClassWithMethod();
            var target2 = new CompanionToClassWithEvent();
            withEvent.Event += target2.Method;
            withEvent.Event += target1.Method;
            var copy = SerializerClone(withEvent);
            copy.Invoke();
        }

        [Test]
        public void ShouldSerializeEmptyDelegateList()
        {
            var withEvent = new ClassWithEvent();
            var target = new TransientClassWithMethod();
            withEvent.Event += target.Method;
            SerializerClone(withEvent);
        }

        [Test]
        public void TransientDerivedShouldAlsoBeTransient()
        {
            var transientDerived = new TransientDerived();
            var values = new object[] { 0, transientDerived };
            var copy = SerializerClone(values);
            CollectionAssert.AreEqual(new object[] { 0, null }, copy);
        }

        [Test]
        public void ShouldSerializeNongenericStack()
        {
            var stack = new Stack();

            var test = "It works!";
            foreach(var chr in test)
            {
                stack.Push(chr);
            }
            var copy = SerializerClone(stack);
            CollectionAssert.AreEqual(stack, copy);


        }

        [Test]
        public void ShouldSerializeGenericStack()
        {
            var stack = new Stack<char>();

            var test = "It works!";
            foreach(var chr in test)
            {
                stack.Push(chr);
            }
            var copy = SerializerClone(stack);
            CollectionAssert.AreEqual(stack, copy);
        }

        [Test]
        public void ShouldSerializeBoxWithGuid()
        {
            var box = new GenericBox<Guid>();
            box.Element = Guid.NewGuid();
            var copy = SerializerClone(box);
            Assert.AreEqual(box.Element, copy.Element);
        }

        [Test]
        public void ShouldSerializeClassWithGuid()
        {
            var withGuid = new ClassWithGuid();
            var copy = SerializerClone(withGuid);
            Assert.AreEqual(withGuid, copy);
        }

        [Test]
        public void ShouldFindPathToPointerContainingObject()
        {
            Exception exception = null;
            var toClone = new GenericBox<AnotherContainingType>();
            toClone.Element = new AnotherContainingType();
            try
            {
                SerializerClone(toClone);
                Assert.Fail("Exception was not thrown.");
            }
            catch(Exception e)
            {
                exception = e;
            }
            if(!useGeneratedSerialization)
            {
                Assert.IsTrue(exception.Message.Contains(toClone.GetType().Name));
                Assert.IsTrue(exception.Message.Contains(toClone.Element.GetType().Name));
                Assert.IsTrue(exception.Message.Contains(toClone.Element.WithIntPtr.GetType().Name));
            }
        }

        [Test]
        public void GithubIssue60()
        {
            object instance = new Issue60OuterClass() {
                Field1 = 0,
                Inner = new Issue60InnerClass() {
                    Field2 = 1,
                    Field3 = 2,
                }
            };

            SerializerClone(instance);
        }

        [Test]
        public void ShouldSerializeKeyValuePair()
        {
            var src = new KeyValuePair<int, int>(12, 34);
            var dst = SerializerClone(src);

            Assert.AreEqual(src.Key, dst.Key);
            Assert.AreEqual(src.Value, dst.Value);
        }

        [Test]
        public void ShouldSerializeNullableEnum()
        {
            var src = new ClassWithNullableEnum() { e = SimpleEnum.Two };
            var dst = SerializerClone(src);

            Assert.AreEqual(SimpleEnum.Two, dst.e);
        }

        [Test]
        public void ShouldSerializeGenericClassWithLatePostDeserializationHook()
        {
            var src = new GenericClassWithLatePostDeserializationHook { x = 150 };
            var dst = SerializerClone(src);

            Assert.AreEqual(147, dst.x);
        }

        [Test]
        public void ShouldSerialize2DArrayWithAllDimensionZero()
        {
            var array = new int[0, 0];
            var copy = SerializerClone(array);
            CollectionAssert.AreEqual(array, copy);
        }

        [Test]
        public void ShouldSerialize3DArrayWithOneDimensionZero()
        {
            var array = new int[2, 0, 2];
            var copy = SerializerClone(array);
            CollectionAssert.AreEqual(array, copy);
        }

        [Test]
        public void ShouldNotSerializePointer()
        {
            if(Environment.OSVersion.Platform == PlatformID.Unix && Environment.OSVersion.Version < Version.Parse("4.0"))
            {
                Assert.Inconclusive("Due to a bug in mono implementation this test is ignored on Linux");
            }

            var classWithPtr = new ClassWithPointer();
            try
            {
                SerializerClone(classWithPtr);
                Assert.Fail("A class with pointer was serialized, but it should have been not.");
            }
            catch(InvalidOperationException)
            {

            }
        }

        [Test]
        public void ShouldNotSerializeNull()
        {
            try
            {
                SerializerClone<object>(null);
                Assert.Fail("Serialization of null succeeded while it should not.");
            }
            catch(ArgumentException)
            {
            }
        }

        [Test]
        public void ShouldNotSerializeTransient()
        {
            try
            {
                SerializerClone(new TransientClass());
                Assert.Fail("Serialization of a transient object succeeded while it should not.");
            }
            catch(ArgumentException)
            {
            }
        }

        [Test]
        public void ShouldSerializeTwoTimesDifferentObjects()
        {
            var serializer = new Serializer(GetSettings());

            using(var stream = new MemoryStream())
            {
                var obj = new SimpleContainer();
                obj.First = new SimpleClass();
                obj.Second = new SimpleClass();
                serializer.Serialize(obj, stream);
                stream.Seek(0, SeekOrigin.Begin);
                var copy = serializer.Deserialize<SimpleContainer>(stream);
                Assert.IsNotNull(copy);
            }

            using(var stream = new MemoryStream())
            {
                var obj = new object[] { new SimpleClass(), new SimpleContainer(), new SimpleContainer() };
                serializer.Serialize(obj, stream);
                stream.Seek(0, SeekOrigin.Begin);
                var copy = serializer.Deserialize<object[]>(stream);
                Assert.IsNotNull(copy);
                Assert.IsInstanceOf<SimpleClass>(copy[0]);
                Assert.IsInstanceOf<SimpleContainer>(copy[1]);
                Assert.IsInstanceOf<SimpleContainer>(copy[2]);
            }
        }

        [Test]
        public void ShouldSerializeClassWithGenericMethodDelegate()
        {
            var serializer = new Serializer(GetSettings());

            var obj = new GenericClassWithGenericDelegate<List<bool>>();
            using(var stream = new MemoryStream())
            {
                serializer.Serialize(obj, stream);
                stream.Seek(0, SeekOrigin.Begin);
                var copy = serializer.Deserialize<GenericClassWithGenericDelegate<List<bool>>>(stream);
                Assert.IsNotNull(copy);
            }
        }

        [Test]
        public void ShouldSerializeClassWithArrayOfNestedGenericArguments()
        {
            var serializer = new Serializer(GetSettings());

            var obj = new GenericClassWithNestedGenericArgument<string>("test");
            using(var stream = new MemoryStream())
            {
                serializer.Serialize(obj, stream);
                stream.Seek(0, SeekOrigin.Begin);
                var copy = serializer.Deserialize<GenericClassWithNestedGenericArgument<string>>(stream);
                Assert.IsNotNull(copy);
                Assert.AreEqual("test", copy.field[0].field);
            }
        }

        [Test]
        public void ShouldSerializeDeepGraph()
        {
            var obj = new ClassWithReferenceToTheObjectOfTheSameType();
            var current = obj;
            for(int i = 0; i < 45000; i++)
            {
                current.reference = new ClassWithReferenceToTheObjectOfTheSameType();
                current = current.reference;
            }

            var serializer = new Serializer(GetSettings());

            ClassWithReferenceToTheObjectOfTheSameType copy;
            using(var stream = new MemoryStream())
            {
                serializer.Serialize(obj, stream);
                stream.Seek(0, SeekOrigin.Begin);
                copy = serializer.Deserialize<ClassWithReferenceToTheObjectOfTheSameType>(stream);
            }

            Assert.IsNotNull(copy);
            var depth = 0;
            current = copy;
            while(current.reference != null)
            {
                depth++;
                current = current.reference;
            }

             Assert.AreEqual(45000, depth);
        }

        [Test]
        public void ShouldSerializeListOfInterfaces()
        {
            var serializer = new Serializer(GetSettings());

            var obj = new ClassWithTheListOfInterfaces();
            obj.list = new List<IInterface>();
            for(int i = 0; i < 100; i++)
            {
                obj.list.Add(i % 2 == 0 ? (IInterface)new ImplementingInterfaceOne() : (IInterface)new ImplementingInterfaceTwo());
            }
            using(var stream = new MemoryStream())
            {
                serializer.Serialize(obj, stream);
                stream.Seek(0, SeekOrigin.Begin);
                var copy = serializer.Deserialize<ClassWithTheListOfInterfaces>(stream);
                Assert.IsNotNull(copy);
                Assert.AreEqual(100, copy.list.Count);
            }
        }

        [Test]
        public void ShouldHandleEventWithBackreference()
        {
            var machine = new BoxingClass();
            var copy = SerializerClone(machine);

            Assert.IsNotNull(copy);
            for(var i = 0; i < copy.objectWithItems.items.Length; i++)
            {
                Assert.IsFalse(copy.objectWithItems.items [i].ActionIsNull, string.Format("Array element: {0}", i));
            }
        }

        [Test]
        public void ShouldSerializeDictionaryWithCustomObject()
        {
            var dic = new Dictionary<CustomObject, string>();
            dic.Add(new CustomObject(new object()), "test1");
            dic.Add(new CustomObject(new object()), "test2");
            dic.Add(new CustomObject(new object()), "test3");

            var copy = SerializerClone(dic);

            Assert.AreEqual(3, copy.Count);
        }

        [Test]
        public void ShouldSerializeHashsetWithCustomObject()
        {
            var hset = new HashSet<CustomObject>();
            hset.Add(new CustomObject(new object()));
            hset.Add(new CustomObject(new object()));
            hset.Add(new CustomObject(new object()));

            var copy = SerializerClone(hset);
            Assert.AreEqual(3, copy.Count);
        }

        private class CustomObject
        {
            public CustomObject(object field)
            {
                this.field = field;
            }

            public override int GetHashCode()
            {
                return field.GetHashCode();
            }

            private object field;
        }

        private class BoxingClass
        {
            // it is necessary for fields to be serialized in proper order
            // to detect a problem;
            // as fileds are ordered alphabetically, please be
            // carefull while renaming them
            public ClassWithAction objectWithAction;
            public ClassWithItems objectWithItems;

            public BoxingClass()
            {
                objectWithItems = new ClassWithItems(this);
            }
        }

        private class ClassWithItems
        {
            public ClassWithItems(BoxingClass mach)
            {
                items = new ClassWithAction[2];
                for(var i = 0; i < items.Length; i++)
                {
                    items[i] = new ClassWithAction(mach);
                    // passing 'i' variable to the method is crucial here
                    items[i].Action += () => Method(i);
                }
            }

            private void Method(int i) { }

            public ClassWithAction[] items;
        }

        private class ClassWithAction
        {
            public ClassWithAction(BoxingClass box)
            {
                box.objectWithAction = this;
            }

            public event Action Action;

            public bool ActionIsNull
            {
                get { return Action == null; }
            }
        }

        public class ClassWithTheListOfInterfaces
        {
            public List<IInterface> list;
        }

        public interface IInterface
        {
            void Method();
        }

        public class ImplementingInterfaceOne : IInterface
        {
            public void Method() {}
        }

        public class ImplementingInterfaceTwo : IInterface
        {
            public void Method() {}
        }

        public class ClassWithReferenceToTheObjectOfTheSameType
        {
            public ClassWithReferenceToTheObjectOfTheSameType reference;
        }

        public class GenericClassWithNestedGenericArgument<T>
        {
            public GenericClassWithNestedGenericArgument(T t)
            {
                field = new [] { new GenericClass<T>() } ;
                field[0].field = t;
            }

            public GenericClass<T>[] field;
        }

        public class GenericClass<T>
        {
            public T field;
        }

        public class GenericClassWithGenericDelegate<T>
        {
            public GenericClassWithGenericDelegate()
            {
                del = Action;
            }

            public void CallDelegate(T c)
            {
                del(c, "string");
            }

            private void Action<TInner>(TInner x, string y)
            {
            }

            private readonly Action<T, string> del;
        }

        public class GenericClassWithTransient<T>
        {
            [Transient]
            public T x;
        }

        public class GenericClassWithLatePostDeserializationHook : GenericClassWithTransient<int>
        {
            [LatePostDeserialization]
            public void LatePostDeserialization()
            {
                if(x == 0)
                {
                    x = 147;
                }
            }
        }

        public class ClassWithNullableEnum
        {
            public SimpleEnum? e { get; set; }
        }

        public class SimpleClass
        {
            public int Value { get; set; }

            public string Str { get; set; }

            public override bool Equals(object obj)
            {
                if(obj == null)
                {
                    return false;
                }
                if(ReferenceEquals(this, obj))
                {
                    return true;
                }
                if(obj.GetType() != typeof(SimpleClass))
                {
                    return false;
                }
                var other = (SimpleClass)obj;
                return Value == other.Value && Str == other.Str;
            }

            public override int GetHashCode()
            {
                unchecked
                {
                    return Value.GetHashCode() ^ 33 * (Str != null ? Str.GetHashCode() : 0);
                }
            }

            public override string ToString()
            {
                return string.Format("[SimpleClass: Value={0}, Str={1}]", Value, Str);
            }
        }

        public class SimpleContainer
        {
            public SimpleClass First { get; set; }

            public SimpleClass Second { get; set; }
        }

        public class CyclicRef
        {
            public CyclicRef Another { get; set; }

            public int Val { get; set; }
        }

        public class ClassWithReadonly
        {
            public ClassWithReadonly(int readonlyValue)
            {
                privateReadonlyField = readonlyValue;
            }

            public int ReadonlyValue
            {
                get
                {
                    return privateReadonlyField;
                }
            }

            private readonly int privateReadonlyField;
        }

        public class ClassWithIntPtr
        {
            public IntPtr Ptr { get; set; }
        }

        public class ClassWithSpinLock
        {
            public SpinLock SLock { get; set; }
        }

        public class SimpleBaseClass
        {
            public int BaseField { get; set; }
        }

        public class SimpleDerivedClass : SimpleBaseClass
        {
            public int DerivedField { get; set; }
        }

        public class Box
        {
            public object Element { get; set; }
        }

        public sealed class GenericBox<T>
        {
            public T Element { get; set; }

            public override bool Equals(object obj)
            {
                if(obj == null)
                {
                    return false;
                }
                if(ReferenceEquals(this, obj))
                {
                    return true;
                }
                if(obj.GetType() != typeof(GenericBox<T>))
                {
                    return false;
                }
                var other = (GenericBox<T>)obj;
                if(Element != null)
                {
                    return Element.Equals(other.Element);
                }
                return other.Element == null;
            }

            public override int GetHashCode()
            {
                unchecked
                {
                    return (Element != null ? Element.GetHashCode() : 0);
                }
            }
        }

        public struct StructGenericBox<T>
        {
            public T Element;
        }

        public enum SimpleEnum
        {
            One,
            Two,
            Three
        }

        private enum EnumLong : long
        {
            First = -1,
            Second = long.MaxValue - 12345,
            Third
        }

        private enum EnumShort : short
        {
            First = short.MinValue + 2,
            Second = 6,
            Third
        }

        private enum EnumByte : byte
        {
            One = 1,
            Two = 200
        }

        [Flags]
        private enum TestEnumFlags
        {
            First = 1,
            Second = 2,
            Third = 4
        }

        private struct SimplerStruct
        {
            public int A;
            public long B;

            public override string ToString()
            {
                return string.Format("[SimplerStruct: A={0}, B={1}]", A, B);
            }
        }

        private struct SimpleStruct
        {
            public int A;
            public String B;

            public override string ToString()
            {
                return string.Format("[SimpleStruct: A={0}, B={1}]", A, B);
            }
        }

        private struct ComplexStruct
        {
            public int A;
            public SimpleStruct B;

            public override string ToString()
            {
                return string.Format("[ComplexStruct: A={0}, B={1}]", A, B);
            }
        }

        private class SpeciallySerializable : ISpeciallySerializable
        {
            public void Fill(int length)
            {
                var bytes = new byte[length];
                Helpers.Random.NextBytes(bytes);
                data = bytes.Select(x => new IntPtr(x)).ToArray();
            }

            public byte[] Data
            {
                get
                {
                    return data.Select(x => (byte)x).ToArray();
                }
            }

            public void Load(PrimitiveReader reader)
            {
                var length = reader.ReadInt32();
                data = new IntPtr[length];
                for(var i = 0; i < length; i++)
                {
                    data[i] = new IntPtr(reader.ReadByte());
                }
            }

            public void Save(PrimitiveWriter writer)
            {
                writer.Write(data.Length);
                for(var i = 0; i < data.Length; i++)
                {
                    writer.Write((byte)data[i]);
                }
            }

            private IntPtr[] data;
        }

        private class BadlySerializable : ISpeciallySerializable
        {
            public void Load(PrimitiveReader reader)
            {
                reader.ReadInt32();
                reader.ReadInt32();
            }

            public void Save(PrimitiveWriter writer)
            {
                for(var i = 0; i < 3; i++)
                {
                    writer.Write(666 + i);
                }
            }
        }

        private struct StructWithConstructorAttribute
        {
            public bool IsFieldConstructed
            {
                get
                {
                    return resetEvent != null;
                }
            }

            #pragma warning disable 649
            [Constructor(false)]
            private ManualResetEvent resetEvent;
            #pragma warning restore 649
        }

        private struct StructWithConstructorAttributeOnNestedStruct
        {
            public bool IsFieldConstructed
            {
                get
                {
                    return s.field == 5;
                }
            }

            #pragma warning disable 649
            [ConstructorAttribute(true)]
            private NestedStruct s;
            #pragma warning restore 649
        }

        private struct NestedStruct
        {
            public NestedStruct(bool condition)
            {
                field = (condition ? 5 : 0);
            }

            #pragma warning disable 649
            public int field;
            #pragma warning restore 649
        }

        private class WithConstructorAttribute
        {
            public bool IsFieldConstructed
            {
                get
                {
                    return resetEvent != null;
                }
            }

            #pragma warning disable 649
            [Constructor(false)]
            private ManualResetEvent resetEvent;
            #pragma warning restore 649
        }

        [Transient]
        private class TransientClass
        {
            public IntPtr Pointer { get; set; }
        }

        private class TransientDerived : TransientClass
        {
            public int Integer { get; set; }
        }

        private class ClassWithTransientField
        {
            public int a;
            [Transient]
            public int
                b;
            public int c;
        }

        private class ClassWithEvent
        {
            public event Action Event;

            public void Invoke()
            {
                var toInvoke = Event;
                if(toInvoke != null)
                {
                    toInvoke();
                }
            }
        }

        private class CompanionToClassWithEvent
        {
            public int Counter { get; set; }

            public void Method()
            {
                Counter++;
            }
        }

        private class ClassWithThreadLocal
        {
            public ClassWithThreadLocal()
            {
                ThreadLocal = new ThreadLocal<int>();
            }

            public ThreadLocal<int> ThreadLocal { get; set; }
        }

        [Transient]
        private class TransientClassWithMethod
        {
            public TransientClassWithMethod()
            {
                a = 1;
            }

            public void Method()
            {
                a++;
            }

            private int a;
        }

        public class Issue60OuterClass
        {
            public decimal Field1;

            public Issue60InnerClass Inner { get; set; }
        }

        public class Issue60InnerClass
        {
            public decimal? Field2;
            public decimal? Field3;
        }

        public class ClassWithGuid
        {
            public ClassWithGuid()
            {
                Id = Guid.NewGuid();
                Number = Id.ToByteArray()[1] * Id.ToByteArray()[0];
                Str = Helpers.GetRandomString(Number / 256);
            }

            public override bool Equals(object obj)
            {
                if(obj == null)
                {
                    return false;
                }
                if(ReferenceEquals(this, obj))
                {
                    return true;
                }
                if(obj.GetType() != typeof(ClassWithGuid))
                {
                    return false;
                }
                ClassWithGuid other = (ClassWithGuid)obj;
                return Id == other.Id && Number == other.Number && Str == other.Str;
            }

            public override int GetHashCode()
            {
                unchecked
                {
                    return Id.GetHashCode() ^ Number.GetHashCode() ^ (Str != null ? Str.GetHashCode() : 0);
                }
            }

            public override string ToString()
            {
                return string.Format("[ClassWithGuid: Id={0}, Number={1}, Str={2}]", Id, Number, Str);
            }

            public Guid Id { get; private set; }

            public int Number { get; private set; }

            public string Str { get; private set; }
        }

        public class AnotherContainingType
        {
            public AnotherContainingType()
            {
                WithIntPtr = new ClassWithIntPtr();
            }

            public ClassWithIntPtr WithIntPtr { get; private set; }
        }

        public unsafe class ClassWithPointer
        {
            protected int* Pointer;
        }

        private class ClassWithEvent<T>
        {
            public event Action<T> Event;

            public void Invoke(T arg)
            {
                var toInvoke = Event;
                if(toInvoke != null)
                {
                    toInvoke(arg);
                }
            }
        }

        private interface IInterfaceForDelegate
        {
            void Method(IInterfaceForDelegate arg);
        }

        private class ClassImplementingInterfaceForDelegate : IInterfaceForDelegate
        {
            public bool Invoked { get; private set; }

            public void Method(IInterfaceForDelegate arg)
            {
                Invoked = true;
            }
        }

        private readonly bool useGeneratedSerialization;
    }

    public static class CompanionExtensions
    {
        public static void MethodAsExtension(this CompanionSecondModule companion)
        {
            companion.Counter++;
        }
    }
}