public void SerializationUtility_SaveToString_2()
        {
            CanaryClass first  = new CanaryClass();
            string      text   = first.SaveToString();
            CanaryClass second = text.RestoreObjectFromString <CanaryClass>();

            first.EnsureSame(second);
        }
Example #2
0
 public void EnsureSame([NotNull] CanaryClass other)
 {
     if (string.CompareOrdinal(Name, other.Name) != 0 ||
         Age != other.Age)
     {
         throw new VerificationException();
     }
 }
        public void SerializationUtility_SaveToZipMemory_1()
        {
            CanaryClass first = _GetCanary();

            byte[]      memory = first.SaveToZipMemory();
            CanaryClass second = memory.RestoreObjectFromZipMemory <CanaryClass>();

            first.EnsureSame(second);
        }
        public void SerializationUtility_SaveToFile_1()
        {
            string      fileName = Path.GetTempFileName();
            CanaryClass first    = _GetCanary();

            first.SaveToFile(fileName);
            CanaryClass second = SerializationUtility.RestoreObjectFromFile <CanaryClass>(fileName);

            first.EnsureSame(second);
        }
Example #5
0
        public void Singleton_Roundtrip_1()
        {
            Singleton.Clear();
            Assert.IsFalse(Singleton.HaveInstance <CanaryClass>());

            CanaryClass canary1 = Singleton.Instance <CanaryClass>();

            Assert.IsNotNull(canary1);
            Assert.IsTrue(Singleton.HaveInstance <CanaryClass>());

            CanaryClass canary2 = Singleton.Instance <CanaryClass>();

            Assert.IsNotNull(canary2);
            Assert.AreSame(canary1, canary2);

            Assert.IsTrue(Singleton.RemoveInstance <CanaryClass>());
            Assert.IsFalse(Singleton.HaveInstance <CanaryClass>());
        }
        public void SerializationUtility_SaveToZipMemory_2()
        {
            const int arraySize = 10;

            CanaryClass[] first = new CanaryClass[arraySize];
            for (int i = 0; i < arraySize; i++)
            {
                first[i]     = _GetCanary();
                first[i].Age = i;
            }
            byte[]        memory = first.SaveToZipMemory();
            CanaryClass[] second = memory.RestoreArrayFromZipMemory <CanaryClass>();
            Assert.AreEqual(first.Length, second.Length);
            for (int i = 0; i < arraySize; i++)
            {
                first[i].EnsureSame(second[i]);
            }
        }
        public void SerializationUtility_SaveToFile_2()
        {
            const int arraySize = 10;
            string    fileName  = Path.GetTempFileName();

            CanaryClass[] first = new CanaryClass[arraySize];
            for (int i = 0; i < arraySize; i++)
            {
                first[i]     = _GetCanary();
                first[i].Age = i;
            }
            first.SaveToFile(fileName);
            CanaryClass[] second = SerializationUtility.RestoreArrayFromFile <CanaryClass>(fileName);
            Assert.IsNotNull(second);
            Assert.AreEqual(first.Length, second.Length);
            for (int i = 0; i < arraySize; i++)
            {
                first[i].EnsureSame(second[i]);
            }
        }
        public void SerializationUtility_RestoreNullable_1()
        {
            // ReSharper disable InvokeAsExtensionMethod

            CanaryClass  first  = _GetCanary();
            MemoryStream stream = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(stream);

            SerializationUtility.WriteNullable(writer, first);

            byte[] bytes = stream.ToArray();
            stream = new MemoryStream(bytes);
            BinaryReader reader = new BinaryReader(stream);
            CanaryClass  second = SerializationUtility.RestoreNullable <CanaryClass>(reader);

            Assert.IsNotNull(second);
            first.EnsureSame(second);

            // ReSharper restore InvokeAsExtensionMethod
        }
        public void SerializationUtility_RestoreNullable_2()
        {
            // ReSharper disable InvokeAsExtensionMethod
            // ReSharper disable ExpressionIsAlwaysNull

            CanaryClass  first  = null;
            MemoryStream stream = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(stream);

            SerializationUtility.WriteNullable(writer, first);

            byte[] bytes = stream.ToArray();
            stream = new MemoryStream(bytes);
            BinaryReader reader = new BinaryReader(stream);
            CanaryClass  second = SerializationUtility.RestoreNullable <CanaryClass>(reader);

            Assert.IsNull(second);

            // ReSharper restore ExpressionIsAlwaysNull
            // ReSharper restore InvokeAsExtensionMethod
        }