AltSerializer - An Alternate Binary Serializer

using System;
using System.Collections.Generic;
using System.Text;

using AltSerialize;
using NUnit.Framework;
using AltSerializeTest.TestObjects;

namespace AltSerializeTest
{
    /// <summary>
    /// Tests object types.
    /// </summary>
    [TestFixture]
    public class TestClasses : SerializerTestBase
    {
        public override string Name
        {
            get { return "Class Test"; }
        }

        [Test]
        public void ClassTest()
        {
            ClassObject myObject = new ClassObject("Hello");
            object ret = SerializeObject(myObject);

            Assert.IsTrue(CompareObject(myObject, ret), "Class object didnt work.");
        }

        [Test]
        public void StructTest()
        {
            StructObject myObject = new StructObject(this);
            myObject.Value1 = 1;
            myObject.Value2 = Int32.MaxValue;
            object ret = SerializeObject(myObject);
            Assert.IsTrue(CompareObject(myObject, ret), "Struct object didnt work.");
        }

        public void ArrayTest(int arraySize)
        {
            ClassObject[] array = new ClassObject[arraySize];
            for (int i = 0; i < arraySize; i++)
            {
                array[i] = new ClassObject(Rand.Next().ToString());
            }
            object resultObject = SerializeObject(array);
            Assert.IsTrue(CompareObject(array, resultObject), "Failed on type " + array.GetType().FullName);
        }

        /// <summary>
        /// Test all value type arrays with random data.
        /// </summary>
        [Test]
        public void ArrayTest()
        {
            foreach (Type type in ValueTypes)
            {
                ArrayTest(10);
                ArrayTest(32);
            }
        }

        public void ObjectArrayTest(int arraySize)
        {
            object [] array = new object[arraySize];
            for (int i = 0; i < arraySize; i++)
            {
                array[i] = new ClassObject((string)GetRandomData(typeof(string)));
            }
            object resultObject = SerializeObject(array);
            Assert.IsTrue(CompareObject(array,  resultObject), "Failed on type " + array.GetType().FullName);
        }

        /// <summary>
        /// Test all value type arrays with random data.
        /// </summary>
        [Test]
        public void ObjectArrayTest()
        {
            foreach (Type type in ValueTypes)
            {
                ObjectArrayTest(10);
                ObjectArrayTest(32);
            }
        }

        [Test]
        public void NullTest()
        {
            object value = null;
            object result = SerializeObject(value);
            Assert.IsTrue(CompareObject(value, result));
        }

        [Test]
        public void NullArrayTest()
        {
            object[]  value = new object[10];
            object result = SerializeObject(value);

            Assert.IsTrue(CompareObject(value, result));
        }

        [Test]
        public void ComplexObjectTest()
        {
            DebugOut("Testing ComplexObject");
            ComplexObject obj = new ComplexObject(this);
            object result = SerializeObject(obj);
            Assert.IsTrue(CompareObject(obj, result));
        }

        [Test]
        public void NestedObjectTest()
        {
            DebugOut("Testing Recursive Object");
            RecursiveObject obj = new RecursiveObject();
            object result = SerializeObject(obj);
            Assert.IsTrue(CompareObject(obj, result));

            obj.Recurse = new RecursiveObject();
            result = SerializeObject(obj);
            Assert.IsTrue(CompareObject(obj, result));

            obj.Recurse = obj;
            result = SerializeObject(obj);
            Assert.IsTrue(CompareObject(obj, result));
        }
    }

    
}