using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Fire;
using System.IO;
using System.Fire.Serialize;
using System.Fire.Serialize.Property;

namespace Fire.UnitTest {


    [TestClass]
    public class Serializer {
        [TestMethod]
        public void Serializer_SaveInt_ReturnsTrue() {
            string FileName = "UnitTest_SaveInt.dat";
            System.Fire.Serialize.Serializer.SerializeObject(FileName, 123456);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName+ " does not exist");
                return;
            } else {
                byte[] b = File.ReadAllBytes(FileName);
                if (b.Length != 4) {
                    Assert.Fail(FileName+" has " + b.Length + " bytes");
                    return;
                }
                File.Delete(FileName);
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadInt_ReturnsTrue() {
            string FileName = "UnitTest_LoadInt.dat";
            System.Fire.Serialize.Serializer.SerializeObject(FileName, 123456);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                int res = (int)System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(int));
                if(res != 123456) {
                    Assert.Fail("Value in " + FileName + " is " + res);
                    return;
                }
                File.Delete(FileName);
            }
            Assert.IsTrue(true);
        }


        [TestMethod]
        public void Serializer_SaveString_ReturnsTrue() {
            string FileName = "UnitTest_SaveString.dat";
            System.Fire.Serialize.Serializer.SerializeObject(FileName, "Hallo Welt!");
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                byte[] b = File.ReadAllBytes(FileName);
                if (b.Length != 13) {
                    Assert.Fail(FileName + " has " + b.Length + " bytes");
                    return;
                }
                File.Delete(FileName);
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadString_ReturnsTrue() {
            string FileName = "UnitTest_LoadString.dat";
            System.Fire.Serialize.Serializer.SerializeObject(FileName, "Hallo Welt");
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                string res = (string)System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(string));
                if (res != "Hallo Welt") {
                    Assert.Fail("Value in " + FileName + " is ("+res.Length+") " + res);
                    return;
                }
                File.Delete(FileName);
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_SaveStringUtf8_ReturnsTrue() {
            string FileName = "UnitTest_SaveString8.dat";
            System.Fire.Serialize.Serializer.SerializeObject(FileName, "Hällo Welt!", ArraySize.bits_16, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                byte[] b = File.ReadAllBytes(FileName);
                File.Delete(FileName);
                if (b.Length != 14) {
                    Assert.Fail(FileName + " has " + b.Length + " bytes");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadStringUtf8_ReturnsTrue() {
            string FileName = "UnitTest_LoadString8.dat";
            System.Fire.Serialize.Serializer.SerializeObject(FileName, "Hällo Welt", ArraySize.bits_16, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                string res = (string)System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(string), ArraySize.bits_16, StringEncoding.UTF8);
                File.Delete(FileName);
                if (res != "Hällo Welt") {
                    Assert.Fail("Value in " + FileName + " is '" + res + "'");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_SaveStringUtf16_ReturnsTrue() {
            string FileName = "UnitTest_SaveString16.dat";
            System.Fire.Serialize.Serializer.SerializeObject(FileName, "Hällo Welt!", ArraySize.bits_16, StringEncoding.Unicode);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                byte[] b = File.ReadAllBytes(FileName);
                File.Delete(FileName);
                if (b.Length != 24) {
                    Assert.Fail(FileName + " has " + b.Length + " bytes");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadStringUtf16_ReturnsTrue() {
            string FileName = "UnitTest_LoadString16.dat";
            System.Fire.Serialize.Serializer.SerializeObject(FileName, "Hällo Welt", ArraySize.bits_16, StringEncoding.Unicode);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                string res = (string)System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(string), ArraySize.bits_16, StringEncoding.Unicode);
                File.Delete(FileName);
                if (res != "Hällo Welt") {
                    Assert.Fail("Value in " + FileName + " is '" + res + "'");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_SaveStringUtf32_ReturnsTrue() {
            string FileName = "UnitTest_SaveString32.dat";
            System.Fire.Serialize.Serializer.SerializeObject(FileName, "Hällo Welt!", ArraySize.bits_16, StringEncoding.UTF32);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                byte[] b = File.ReadAllBytes(FileName);
                File.Delete(FileName);
                if (b.Length != 46) {
                    Assert.Fail(FileName + " has " + b.Length + " bytes");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadStringUtf32_ReturnsTrue() {
            string FileName = "UnitTest_LoadString32.dat";
            System.Fire.Serialize.Serializer.SerializeObject(FileName, "Hällo Welt", ArraySize.bits_16, StringEncoding.UTF32);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                string res = (string)System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(string), ArraySize.bits_16, StringEncoding.UTF32);
                File.Delete(FileName);
                if (res != "Hällo Welt") {
                    Assert.Fail("Value in " + FileName + " is '" + res + "'");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_SaveArray8_ReturnsTrue() {
            string FileName = "UnitTest_SaveArray8.dat";
            string[] testArray = new string[] { "Hallo", "Welt", "!", "" };
            System.Fire.Serialize.Serializer.SerializeObject(FileName, testArray, ArraySize.bits_8, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                byte[] b = File.ReadAllBytes(FileName);
                File.Delete(FileName);
                if (b.Length != 19) {
                    Assert.Fail(FileName + " has " + b.Length + " bytes");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_SaveIntArray8_ReturnsTrue() {
            string FileName = "UnitTest_SaveIntArray8.dat";
            int[] testArray = new int[] { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20 };
            System.Fire.Serialize.Serializer.SerializeObject(FileName, testArray, ArraySize.bits_8, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                byte[] b = File.ReadAllBytes(FileName);
                File.Delete(FileName);
                if (b.Length != 81) {
                    Assert.Fail(FileName + " has " + b.Length + " bytes");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadArray8_ReturnsTrue() {
            string FileName = "UnitTest_LoadArray8.dat";
            string[] testArray = new string[] { "Hallo", "Welt", "!", "" };
            System.Fire.Serialize.Serializer.SerializeObject(FileName, testArray, ArraySize.bits_8, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                string[] res = (string[])System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(string[]), ArraySize.bits_8, StringEncoding.UTF8);
                //File.Delete(FileName);
                if (res.Length != testArray.Length) {
                    Assert.Fail(FileName + " doesn't have 4 Items");
                    return;
                }
                for (int i = 0, c = testArray.Length; i < c; i++) {
                    if (res[i] != testArray[i]) {
                        Assert.Fail(FileName + " doesn't have the correct value. '" + testArray[i] + "' != '" + res[i] + "'");
                        return;
                    }
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadArrayNullTerminated_ReturnsTrue() {
            string FileName = "UnitTest_LoadArrayNullTerminated.dat";
            string[] testArray = new string[] { "Hallo", "Welt", "!", "" };
            System.Fire.Serialize.Serializer.SerializeObject(FileName, testArray, ArraySize.NullTerminated, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                string[] res = (string[])System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(string[]), ArraySize.bits_8, StringEncoding.UTF8);
                //File.Delete(FileName);
                if (res.Length != testArray.Length) {
                    Assert.Fail(FileName + " doesn't have 4 Items");
                    return;
                }
                for (int i = 0, c = testArray.Length; i < c; i++) {
                    if (res[i] != testArray[i]) {
                        Assert.Fail(FileName + " doesn't have the correct value. '" + testArray[i] + "' != '" + res[i] + "'");
                        return;
                    }
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadIntArray8_ReturnsTrue() {
            string FileName = "UnitTest_LoadIntArray8.dat";
            int[] testArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };
            System.Fire.Serialize.Serializer.SerializeObject(FileName, testArray, ArraySize.bits_8, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                int[] res = (int[])System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(int[]), ArraySize.bits_8, StringEncoding.UTF8);
                File.Delete(FileName);
                if (res.Length != testArray.Length) {
                    Assert.Fail(FileName + " doesn't have " + testArray.Length + " Items");
                    return;
                }
                for (int i = 0, c = testArray.Length; i < c; i++) {
                    if (res[i] != testArray[i]) {
                        Assert.Fail(FileName + " doesn't have the correct value. '" + testArray[i] + "' != '" + res[i] + "'");
                        return;
                    }
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_SaveArray16_ReturnsTrue() {
            string FileName = "UnitTest_SaveArray16.dat";
            string[] testArray = new string[] { "Hallo", "Welt", "!", "" };
            System.Fire.Serialize.Serializer.SerializeObject(FileName, testArray, ArraySize.bits_16, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                byte[] b = File.ReadAllBytes(FileName);
                File.Delete(FileName);
                if (b.Length != 20) {
                    Assert.Fail(FileName + " has " + b.Length + " bytes");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_SaveArray32_ReturnsTrue() {
            string FileName = "UnitTest_SaveArray32.dat";
            string[] testArray = new string[] { "Hallo", "Welt", "!", "" };
            System.Fire.Serialize.Serializer.SerializeObject(FileName, testArray, ArraySize.bits_32, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                byte[] b = File.ReadAllBytes(FileName);
                File.Delete(FileName);
                if (b.Length != 22) {
                    Assert.Fail(FileName + " has " + b.Length + " bytes");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_SaveObject_ReturnsTrue() {
            string FileName = "UnitTest_SaveObject.dat";
            SerializeTestObject obj = new SerializeTestObject();
            obj.Fill();

            System.Fire.Serialize.Serializer.SerializeObject(FileName, obj, ArraySize.bits_32, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                byte[] b = File.ReadAllBytes(FileName);
                File.Delete(FileName);
                if (b.Length != 74) {
                    Assert.Fail(FileName + " has " + b.Length + " bytes");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadObject_ReturnsTrue() {
            string FileName = "UnitTest_LoadObject.dat";
            SerializeTestObject obj = new SerializeTestObject();
            obj.Fill();

            System.Fire.Serialize.Serializer.SerializeObject(FileName, obj, ArraySize.bits_16, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                SerializeTestObject b = (SerializeTestObject)System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(SerializeTestObject), ArraySize.bits_16, StringEncoding.UTF8);
                File.Delete(FileName);
                if (b == null) {
                    Assert.Fail(FileName + " loaded object is null");
                    return;
                }
                if (!obj.Compare(b)) {
                    Assert.Fail(FileName + " doesn't have the correct values.\n" +
                        (b.boolean?"True":"False") + " - " + (obj.boolean ? "True" : "False") + "\n" +

                        b.bNumber + " - " + obj.bNumber + "\n" +
                        b.sNumber + " - " + obj.sNumber + "\n" +
                        b.iNumber + " - " + obj.iNumber + "\n" + 
                        b.lNumber + " - " + obj.lNumber + "\n" +

                        b.sbNumber + " - " + obj.sbNumber + "\n" +
                        b.usNumber + " - " + obj.usNumber + "\n" +
                        b.uiNumber + " - " + obj.uiNumber + "\n" +
                        b.ulNumber + " - " + obj.ulNumber + "\n" +

                        b.fNumber + " - " + obj.fNumber + "\n" +
                        b.dNumber + " - " + obj.dNumber + "\n" + 

                        b.testString + "\n" +
                        b.cChar + " - " + obj.cChar + "\n" +
                        b.time.ToString("dd. MM. yyyy H:mm:ss") + " - " + obj.time.ToString("dd. MM. yyyy H:mm:ss") + "\n" +
                        "");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_SaveDeepObject_ReturnsTrue() {
            string FileName = "UnitTest_SaveDeepObject.dat";
            SerializeDeepTestObject obj = new SerializeDeepTestObject();
            obj.Fill();
            
            System.Fire.Serialize.Serializer.SerializeObject(FileName, obj, ArraySize.bits_32, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                byte[] b = File.ReadAllBytes(FileName);
                File.Delete(FileName);
                if (b.Length != 214) {
                    Assert.Fail(FileName + " has " + b.Length + " bytes");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadDeepObject_ReturnsTrue() {
            string FileName = "UnitTest_LoadDeepObject.dat";
            SerializeDeepTestObject obj = new SerializeDeepTestObject();
            obj.Fill();

            System.Fire.Serialize.Serializer.SerializeObject(FileName, obj, ArraySize.bits_32, StringEncoding.Unicode);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                SerializeDeepTestObject b = (SerializeDeepTestObject)System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(SerializeDeepTestObject), ArraySize.bits_32, StringEncoding.Unicode);
                if (b == null) {
                    Assert.Fail(FileName + " loaded object is null");
                    return;
                }
                if (!b.Compare(obj)) {
                    Assert.Fail(FileName + " doesn't have the correct values.\n" +
                        b.TestString + " - " + obj.TestString + "\n" +
                        "------------------------------\n" +
                        (b.Obj1.boolean ? "True" : "False") + " - " + (obj.Obj1.boolean ? "True" : "False") + "\n" +

                        b.Obj1.bNumber + " - " + obj.Obj1.bNumber + "\n" +
                        b.Obj1.sNumber + " - " + obj.Obj1.sNumber + "\n" +
                        b.Obj1.iNumber + " - " + obj.Obj1.iNumber + "\n" +
                        b.Obj1.lNumber + " - " + obj.Obj1.lNumber + "\n" +

                        b.Obj1.sbNumber + " - " + obj.Obj1.sbNumber + "\n" +
                        b.Obj1.usNumber + " - " + obj.Obj1.usNumber + "\n" +
                        b.Obj1.uiNumber + " - " + obj.Obj1.uiNumber + "\n" +
                        b.Obj1.ulNumber + " - " + obj.Obj1.ulNumber + "\n" +

                        b.Obj1.fNumber + " - " + obj.Obj1.fNumber + "\n" +
                        b.Obj1.dNumber + " - " + obj.Obj1.dNumber + "\n" +

                        b.Obj1.testString + "\n" +
                        b.Obj1.cChar + " - " + obj.Obj1.cChar + "\n" +
                        b.Obj1.time.ToString("dd. MM. yyyy H:mm:ss") + " - " + obj.Obj1.time.ToString("dd. MM. yyyy H:mm:ss") + "\n" +
                        "------------------------------\n" +
                        (b.Obj2.boolean ? "True" : "False") + " - " + (obj.Obj2.boolean ? "True" : "False") + "\n" +

                        b.Obj2.bNumber + " - " + obj.Obj2.bNumber + "\n" +
                        b.Obj2.sNumber + " - " + obj.Obj2.sNumber + "\n" +
                        b.Obj2.iNumber + " - " + obj.Obj2.iNumber + "\n" +
                        b.Obj2.lNumber + " - " + obj.Obj2.lNumber + "\n" +

                        b.Obj2.sbNumber + " - " + obj.Obj2.sbNumber + "\n" +
                        b.Obj2.usNumber + " - " + obj.Obj2.usNumber + "\n" +
                        b.Obj2.uiNumber + " - " + obj.Obj2.uiNumber + "\n" +
                        b.Obj2.ulNumber + " - " + obj.Obj2.ulNumber + "\n" +

                        b.Obj2.fNumber + " - " + obj.Obj2.fNumber + "\n" +
                        b.Obj2.dNumber + " - " + obj.Obj2.dNumber + "\n" +

                        b.Obj2.testString + "\n" +
                        b.Obj2.cChar + " - " + obj.Obj2.cChar + "\n" +
                        b.Obj2.time.ToString("dd. MM. yyyy H:mm:ss") + " - " + obj.Obj2.time.ToString("dd. MM. yyyy H:mm:ss") + "\n" +
                        "");
                    return;
                }
                File.Delete(FileName);
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadDeepObjectNullTerminatedUTF8_ReturnsTrue() {
            string FileName = "UnitTest_LoadDeepObjectNullTerminatedUTF8.dat";
            SerializeDeepTestObject obj = new SerializeDeepTestObject();
            obj.Fill();

            System.Fire.Serialize.Serializer.SerializeObject(FileName, obj, ArraySize.NullTerminated, StringEncoding.UTF8);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                SerializeDeepTestObject b = (SerializeDeepTestObject)System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(SerializeDeepTestObject), ArraySize.NullTerminated, StringEncoding.UTF8);
                //File.Delete(FileName);
                if (b == null) {
                    Assert.Fail(FileName + " loaded object is null");
                    return;
                }
                if (!b.Compare(obj)) {
                    Assert.Fail(FileName + " doesn't have the correct values.\n" +
                        b.TestString + " - " + obj.TestString + "\n" +
                        "------------------------------\n" +
                        (b.Obj1.boolean ? "True" : "False") + " - " + (obj.Obj1.boolean ? "True" : "False") + "\n" +

                        b.Obj1.bNumber + " - " + obj.Obj1.bNumber + "\n" +
                        b.Obj1.sNumber + " - " + obj.Obj1.sNumber + "\n" +
                        b.Obj1.iNumber + " - " + obj.Obj1.iNumber + "\n" +
                        b.Obj1.lNumber + " - " + obj.Obj1.lNumber + "\n" +

                        b.Obj1.sbNumber + " - " + obj.Obj1.sbNumber + "\n" +
                        b.Obj1.usNumber + " - " + obj.Obj1.usNumber + "\n" +
                        b.Obj1.uiNumber + " - " + obj.Obj1.uiNumber + "\n" +
                        b.Obj1.ulNumber + " - " + obj.Obj1.ulNumber + "\n" +

                        b.Obj1.fNumber + " - " + obj.Obj1.fNumber + "\n" +
                        b.Obj1.dNumber + " - " + obj.Obj1.dNumber + "\n" +

                        b.Obj1.testString + "\n" +
                        b.Obj1.cChar + " - " + obj.Obj1.cChar + "\n" +
                        b.Obj1.time.ToString("dd. MM. yyyy H:mm:ss") + " - " + obj.Obj1.time.ToString("dd. MM. yyyy H:mm:ss") + "\n" +
                        "------------------------------\n" +
                        (b.Obj2.boolean ? "True" : "False") + " - " + (obj.Obj2.boolean ? "True" : "False") + "\n" +

                        b.Obj2.bNumber + " - " + obj.Obj2.bNumber + "\n" +
                        b.Obj2.sNumber + " - " + obj.Obj2.sNumber + "\n" +
                        b.Obj2.iNumber + " - " + obj.Obj2.iNumber + "\n" +
                        b.Obj2.lNumber + " - " + obj.Obj2.lNumber + "\n" +

                        b.Obj2.sbNumber + " - " + obj.Obj2.sbNumber + "\n" +
                        b.Obj2.usNumber + " - " + obj.Obj2.usNumber + "\n" +
                        b.Obj2.uiNumber + " - " + obj.Obj2.uiNumber + "\n" +
                        b.Obj2.ulNumber + " - " + obj.Obj2.ulNumber + "\n" +

                        b.Obj2.fNumber + " - " + obj.Obj2.fNumber + "\n" +
                        b.Obj2.dNumber + " - " + obj.Obj2.dNumber + "\n" +

                        b.Obj2.testString + "\n" +
                        b.Obj2.cChar + " - " + obj.Obj2.cChar + "\n" +
                        b.Obj2.time.ToString("dd. MM. yyyy H:mm:ss") + " - " + obj.Obj2.time.ToString("dd. MM. yyyy H:mm:ss") + "\n" +
                        "");
                    return;
                }
            }
            Assert.IsTrue(true);
        }

        [TestMethod]
        public void Serializer_LoadDeepObjectNullTerminatedUTF32_ReturnsTrue() {
            string FileName = "UnitTest_LoadDeepObjectNullTerminatedUTF32.dat";
            SerializeDeepTestObject obj = new SerializeDeepTestObject();
            obj.Fill();

            System.Fire.Serialize.Serializer.SerializeObject(FileName, obj, ArraySize.NullTerminated, StringEncoding.UTF32);
            if (File.Exists(FileName) == false) {
                Assert.Fail(FileName + " does not exist");
                return;
            } else {
                SerializeDeepTestObject b = (SerializeDeepTestObject)System.Fire.Serialize.Serializer.DeserializeObject(FileName, typeof(SerializeDeepTestObject), ArraySize.NullTerminated, StringEncoding.UTF32);
                //File.Delete(FileName);
                if (b == null) {
                    Assert.Fail(FileName + " loaded object is null");
                    return;
                }
                if (!b.Compare(obj)) {
                    Assert.Fail(FileName + " doesn't have the correct values.\n" +
                        b.TestString + " - " + obj.TestString + "\n" +
                        "------------------------------\n" +
                        (b.Obj1.boolean ? "True" : "False") + " - " + (obj.Obj1.boolean ? "True" : "False") + "\n" +

                        b.Obj1.bNumber + " - " + obj.Obj1.bNumber + "\n" +
                        b.Obj1.sNumber + " - " + obj.Obj1.sNumber + "\n" +
                        b.Obj1.iNumber + " - " + obj.Obj1.iNumber + "\n" +
                        b.Obj1.lNumber + " - " + obj.Obj1.lNumber + "\n" +

                        b.Obj1.sbNumber + " - " + obj.Obj1.sbNumber + "\n" +
                        b.Obj1.usNumber + " - " + obj.Obj1.usNumber + "\n" +
                        b.Obj1.uiNumber + " - " + obj.Obj1.uiNumber + "\n" +
                        b.Obj1.ulNumber + " - " + obj.Obj1.ulNumber + "\n" +

                        b.Obj1.fNumber + " - " + obj.Obj1.fNumber + "\n" +
                        b.Obj1.dNumber + " - " + obj.Obj1.dNumber + "\n" +

                        b.Obj1.testString + "\n" +
                        b.Obj1.cChar + " - " + obj.Obj1.cChar + "\n" +
                        b.Obj1.time.ToString("dd. MM. yyyy H:mm:ss") + " - " + obj.Obj1.time.ToString("dd. MM. yyyy H:mm:ss") + "\n" +
                        "------------------------------\n" +
                        (b.Obj2.boolean ? "True" : "False") + " - " + (obj.Obj2.boolean ? "True" : "False") + "\n" +

                        b.Obj2.bNumber + " - " + obj.Obj2.bNumber + "\n" +
                        b.Obj2.sNumber + " - " + obj.Obj2.sNumber + "\n" +
                        b.Obj2.iNumber + " - " + obj.Obj2.iNumber + "\n" +
                        b.Obj2.lNumber + " - " + obj.Obj2.lNumber + "\n" +

                        b.Obj2.sbNumber + " - " + obj.Obj2.sbNumber + "\n" +
                        b.Obj2.usNumber + " - " + obj.Obj2.usNumber + "\n" +
                        b.Obj2.uiNumber + " - " + obj.Obj2.uiNumber + "\n" +
                        b.Obj2.ulNumber + " - " + obj.Obj2.ulNumber + "\n" +

                        b.Obj2.fNumber + " - " + obj.Obj2.fNumber + "\n" +
                        b.Obj2.dNumber + " - " + obj.Obj2.dNumber + "\n" +

                        b.Obj2.testString + "\n" +
                        b.Obj2.cChar + " - " + obj.Obj2.cChar + "\n" +
                        b.Obj2.time.ToString("dd. MM. yyyy H:mm:ss") + " - " + obj.Obj2.time.ToString("dd. MM. yyyy H:mm:ss") + "\n" +
                        "");
                    return;
                }
                File.Delete(FileName);
            }
            Assert.IsTrue(true);
        }
    }


}