cauterize 0.0.1.pre1 → 0.0.1.pre5

data/support/cs/test/CauterizeFormatterTest.cs

@@ -0,0 +1,40 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Cauterize;
+using Moq;
+
+namespace Cauterize.Test
+{
+    [TestFixture]
+    public class CauterizeFormatterTest
+    {
+        [Test]
+        public void TestDeserialize()
+        {
+            var subFormatter = new Mock<ICauterizeTypeFormatter>();
+            var serializationStream = new MemoryStream();
+            subFormatter.Setup(sf => sf.Deserialize(serializationStream, typeof (string))).Returns("hello world");
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            factory.Setup(f => f.GetFormatter(typeof (string))).Returns(subFormatter.Object);
+            var formatter = new CauterizeFormatter(factory.Object);
+            Assert.AreEqual("hello world", formatter.Deserialize<string>(serializationStream));
+        }
+
+        [Test]
+        public void TestSerialize()
+        {
+            var subFormatter = new Mock<ICauterizeTypeFormatter>();
+            var serializationStream = new MemoryStream();
+            subFormatter.Setup(sf => sf.Serialize(serializationStream, "hello world"));
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            factory.Setup(f => f.GetFormatter(typeof (string))).Returns(subFormatter.Object);
+            var formatter = new CauterizeFormatter(factory.Object);
+            formatter.Serialize(serializationStream, "hello world");
+            subFormatter.VerifyAll();
+        }
+    }
+}

data/support/cs/test/CauterizeGroupFormatterTest.cs

@@ -0,0 +1,147 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using Moq;
+using NUnit.Framework;
+using Cauterize;
+
+namespace Cauterize.Test
+{
+    enum TestGroupType
+    {
+        TestGroupTypeFoo = 0,
+        TestGroupTypeBar,
+        TestGroupTypeBaz
+    }
+    class TestGroup : CauterizeGroup
+    {
+        [Order(0)]
+        public TestGroupType Type { get; set; }
+
+        [Order(1)]
+        public int Foo { get; set; }
+        /* unused for 2/Bar */
+        [Order(3)]
+        public byte Baz { get; set; }
+    }
+
+    [TestFixture]
+    public class CauterizeGroupFormatterTest
+    {
+        [Test]
+        public void TestDeserialize()
+        {
+            var stream = new MemoryStream();
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            var enumFormatter = new Mock<ICauterizeTypeFormatter>();
+            var intFormatter = new Mock<ICauterizeTypeFormatter>();
+            factory.Setup(f => f.GetFormatter(It.IsAny<Type>())).Returns((Type t) =>
+                {
+                    if (t == typeof (TestGroupType))
+                    {
+                        return enumFormatter.Object;
+                    }
+                    else if (t == typeof (int))
+                    {
+                        return intFormatter.Object;
+                    }
+                    else
+                    {
+                        return null;
+                    }
+                });
+            enumFormatter.Setup(f => f.Deserialize(stream, typeof (TestGroupType)))
+                         .Returns(TestGroupType.TestGroupTypeFoo);
+            intFormatter.Setup(f => f.Deserialize(stream, typeof (int)))
+                        .Returns(1024);
+            var formatter = new CauterizeGroupFormatter(factory.Object);
+            var result = (TestGroup) formatter.Deserialize(stream, typeof (TestGroup));
+            Assert.AreEqual(TestGroupType.TestGroupTypeFoo, result.Type);
+            Assert.AreEqual(1024, result.Foo);
+        }
+
+        [Test]
+        public void TestSerialize()
+        {
+            var stream = new MemoryStream();
+            var group = new TestGroup();
+            group.Type = TestGroupType.TestGroupTypeBaz;
+            group.Baz = 4;
+            var enumFormatter = new Mock<ICauterizeTypeFormatter>();
+            var byteFormatter = new Mock<ICauterizeTypeFormatter>();
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            factory.Setup(f => f.GetFormatter(It.IsAny<Type>())).Returns((Type t) =>
+                {
+                    if (t == typeof (TestGroupType))
+                    {
+                        return enumFormatter.Object;
+                    }
+                    else if (t == typeof (Byte))
+                    {
+                        return byteFormatter.Object;
+                    }
+                    else
+                    {
+                        return null;
+                    }
+                });
+            enumFormatter.Setup(f => f.Serialize(stream, TestGroupType.TestGroupTypeBaz));
+            byteFormatter.Setup(f => f.Serialize(stream, (Byte)4));
+            var formatter = new CauterizeGroupFormatter(factory.Object);
+            formatter.Serialize(stream, group);
+            enumFormatter.VerifyAll();
+            byteFormatter.VerifyAll();
+        }
+
+        [Test]
+        public void TestDeserialized_UnusedGroupData()
+        {
+            var stream = new MemoryStream();
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            var enumFormatter = new Mock<ICauterizeTypeFormatter>();
+            factory.Setup(f => f.GetFormatter(It.IsAny<Type>())).Returns((Type t) =>
+                {
+                    if (t == typeof (TestGroupType))
+                    {
+                        return enumFormatter.Object;
+                    }
+                    else
+                    {
+                        return null;
+                    }
+                });
+            enumFormatter.Setup(f => f.Deserialize(stream, typeof (TestGroupType)))
+                         .Returns(TestGroupType.TestGroupTypeBar);
+            var formatter = new CauterizeGroupFormatter(factory.Object);
+            var result = (TestGroup) formatter.Deserialize(stream, typeof (TestGroup));
+            Assert.AreEqual(TestGroupType.TestGroupTypeBar, result.Type);
+        }
+
+        [Test]
+        public void TestSerialized_UnusedGroupData()
+        {
+            var stream = new MemoryStream();
+            var group = new TestGroup();
+            group.Type = TestGroupType.TestGroupTypeBar;
+            var enumFormatter = new Mock<ICauterizeTypeFormatter>();
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            factory.Setup(f => f.GetFormatter(It.IsAny<Type>())).Returns((Type t) =>
+                {
+                    if (t == typeof (TestGroupType))
+                    {
+                        return enumFormatter.Object;
+                    }
+                    else
+                    {
+                        return null;
+                    }
+                });
+            enumFormatter.Setup(f => f.Serialize(stream, TestGroupType.TestGroupTypeBar));
+            var formatter = new CauterizeGroupFormatter(factory.Object);
+            formatter.Serialize(stream, group);
+            enumFormatter.VerifyAll();
+        }
+    }
+}

data/support/cs/test/CauterizeIntegrationTest.cs

@@ -0,0 +1,129 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Cauterize;
+
+namespace Cauterize.Test
+{
+    class TestTopLevel : CauterizeComposite
+    {
+        [Order(0)]
+        public TestSubComp SubComp { get; set; }
+
+        [Order(1)]
+        public TestSubFixed SubFixed { get; set; }
+
+        [Order(2)]
+        public TestSubGroup SubGroup { get; set; }
+
+        [Order(3)]
+        public Int32 SubInt { get; set; } 
+    }
+
+    class TestSubComp : CauterizeComposite
+    {
+        [Order(0)]
+        public Byte Byte1 { get; set; }
+
+        [Order(1)]
+        public Byte Byte2 { get; set; }
+    }
+
+    class TestSubFixed : CauterizeFixedArrayTyped<Int64>
+    {
+        public TestSubFixed()
+        {
+            Allocate(4);
+        }
+
+        public TestSubFixed(Int64[] data)
+        {
+            Allocate(data);
+        }
+
+        protected override int Size
+        {
+            get { return 4; }
+        }
+    }
+    
+    [SerializedRepresentation(typeof(Byte))]
+    public enum TestSubGroupType
+    {
+        TestSubGroupTypeVariable,
+        TestSUbGroupTypeNothing,
+        TestSubGroupTypeShort
+    }
+
+    class TestSubGroup : CauterizeGroup
+    {
+        [Order(0)]
+        public TestSubGroupType Type { get; set; }
+
+        [Order(1)]
+        public TestSubVariable SubVar { get; set; }
+
+        /* no data for nothing */
+        [Order(3)]
+        public Int16 SubShort { get; set; }
+    }
+
+    class TestSubVariable : CauterizeVariableArrayTyped<Byte>
+    {
+        public static Type SizeType = typeof (Byte);
+
+        public TestSubVariable(int size)
+        {
+            Allocate(size);
+        }
+
+        public TestSubVariable(Byte[] data)
+        {
+            Allocate(data);
+        }
+
+        protected override int MaxSize
+        {
+            get { return Byte.MaxValue; }
+        }
+
+    }
+
+    [TestFixture]
+    public class CauterizeIntegrationTest
+    {
+        [Test]
+        public void TestThereAndBackAgain()
+        {
+            var inputTopLevel = new TestTopLevel();
+            inputTopLevel.SubComp = new TestSubComp();
+            inputTopLevel.SubComp.Byte1 = 101;
+            inputTopLevel.SubComp.Byte2 = 202;
+            inputTopLevel.SubFixed = new TestSubFixed();
+            inputTopLevel.SubFixed[2] = 1234123412341234;
+            inputTopLevel.SubGroup = new TestSubGroup();
+            inputTopLevel.SubGroup.Type = TestSubGroupType.TestSubGroupTypeVariable;
+            inputTopLevel.SubGroup.SubVar = new TestSubVariable(3);
+            inputTopLevel.SubGroup.SubVar[1] = 55;
+            inputTopLevel.SubInt = 1000000;
+
+            var formatter = new CauterizeFormatter();
+            var stream = new MemoryStream(2048);
+            formatter.Serialize(stream, inputTopLevel);
+
+            stream.Position = 0;
+            var outputTopLevel = formatter.Deserialize<TestTopLevel>(stream);
+            Assert.AreEqual(inputTopLevel.SubComp.Byte1, outputTopLevel.SubComp.Byte1);
+            Assert.AreEqual(inputTopLevel.SubComp.Byte2, outputTopLevel.SubComp.Byte2);
+            Assert.AreEqual(inputTopLevel.SubFixed[0], outputTopLevel.SubFixed[0]);
+            Assert.AreEqual(inputTopLevel.SubFixed[2], outputTopLevel.SubFixed[2]);
+            Assert.AreEqual(inputTopLevel.SubGroup.Type, outputTopLevel.SubGroup.Type);
+            Assert.AreEqual(inputTopLevel.SubGroup.SubVar[0], outputTopLevel.SubGroup.SubVar[0]);
+            Assert.AreEqual(inputTopLevel.SubGroup.SubVar[1], outputTopLevel.SubGroup.SubVar[1]);
+            Assert.AreEqual(inputTopLevel.SubInt, outputTopLevel.SubInt);
+        }
+    }
+}

data/support/cs/test/CauterizePrimitiveFormatterTest.cs

@@ -0,0 +1,98 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+
+namespace Cauterize.Test
+{
+    [TestFixture]
+    public class CauterizePrimitiveFormatterTest
+    {
+        [Test]
+        public void TestDeserialize()
+        {
+            var formatter = new CauterizePrimitiveFormatter();
+            var bytes = new byte[8];
+            bytes[0] = 2;
+            bytes[1] = 128;
+            bytes[2] = 1;
+            bytes[3] = 0;
+            bytes[4] = 1;
+            var stream = new MemoryStream(bytes);
+            object value = formatter.Deserialize(stream, typeof(Byte));
+            Assert.AreEqual(2,value);
+            stream = new MemoryStream(bytes);
+            value = formatter.Deserialize(stream, typeof(Int16));
+            Assert.AreEqual(Int16.MinValue + 2, value);
+            stream = new MemoryStream(bytes);
+            value = formatter.Deserialize(stream, typeof(UInt16));
+            Assert.AreEqual(32770, value);
+            stream = new MemoryStream(bytes);
+            value = formatter.Deserialize(stream, typeof(Int32));
+            Assert.AreEqual(98306, value);
+            stream = new MemoryStream(bytes);
+            value = formatter.Deserialize(stream, typeof(Int64));
+            Assert.AreEqual(4295065602, value);
+        }
+
+        [Test]
+        public void TestDeserializeTwoBytesInARow()
+        {
+            var formatter = new CauterizePrimitiveFormatter();
+            var bytes = new byte[2];
+            bytes[0] = 2;
+            bytes[1] = 128;
+            var stream = new MemoryStream(bytes);
+            object value = formatter.Deserialize(stream, typeof(Byte));
+            Assert.AreEqual(2,value);
+            value = formatter.Deserialize(stream, typeof(Byte));
+            Assert.AreEqual(128,value);
+        }
+
+        [Test]
+        public void TestSerialize()
+        {
+            var formatter = new CauterizePrimitiveFormatter();
+            var bytes = new byte[8];
+            var stream = new MemoryStream(bytes);
+            formatter.Serialize(stream, (Byte)2);
+            Assert.AreEqual(2, bytes[0]);
+            Assert.AreEqual(0, bytes[1]);
+
+            bytes = new byte[8];
+            stream = new MemoryStream(bytes);
+            formatter.Serialize(stream, (Int16)(Int16.MinValue + 2));
+            Assert.AreEqual(2, bytes[0]);
+            Assert.AreEqual(128, bytes[1]);
+            Assert.AreEqual(0, bytes[2]);
+
+            bytes = new byte[8];
+            stream = new MemoryStream(bytes);
+            formatter.Serialize(stream, (UInt16)(32770));
+            Assert.AreEqual(2, bytes[0]);
+            Assert.AreEqual(128, bytes[1]);
+            Assert.AreEqual(0, bytes[2]);
+
+            bytes = new byte[8];
+            stream = new MemoryStream(bytes);
+            formatter.Serialize(stream, 98306);
+            Assert.AreEqual(2, bytes[0]);
+            Assert.AreEqual(128, bytes[1]);
+            Assert.AreEqual(1, bytes[2]);
+            Assert.AreEqual(0, bytes[3]);
+            Assert.AreEqual(0, bytes[4]);
+
+            bytes = new byte[8];
+            stream = new MemoryStream(bytes);
+            formatter.Serialize(stream, 4295065602);
+            Assert.AreEqual(2, bytes[0]);
+            Assert.AreEqual(128, bytes[1]);
+            Assert.AreEqual(1, bytes[2]);
+            Assert.AreEqual(0, bytes[3]);
+            Assert.AreEqual(1, bytes[4]);
+            Assert.AreEqual(0, bytes[5]);
+        }
+    }
+}

data/support/cs/test/CauterizeTypeFormatterFactoryTest.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Cauterize;
+
+namespace Cauterize.Test
+{
+    class MyComposite : CauterizeComposite
+    {
+        public int MyInt1 { get; set; }
+        public int MyInt2 { get; set; }
+    }
+
+    enum GroupType
+    {
+        GroupTypeInt32,
+        GroupTypeInt16
+    }
+    class MyGroup : CauterizeGroup
+    {
+        public GroupType Type { get; set; }
+
+        public Int32 NormalInt { get; set; }
+        public Int16 SmallInt { get; set; }
+    }
+
+    class MyFixedArray : CauterizeFixedArray
+    {
+        private int[] _data;
+        MyFixedArray()
+        {
+            _data = new int[4];
+        }
+        int this[int i]
+        {
+            get { return _data[i]; }
+            set { _data[i] = value; }
+        }
+    }
+
+    class MyVariableArray : CauterizeVariableArray
+    {
+        private int[] _data;
+        MyVariableArray(int size)
+        {
+            _data = new int[size];
+        }
+        int this[int i]
+        {
+            get { return _data[i]; }
+            set { _data[i] = value; }
+        }
+    }
+
+    [TestFixture]
+    public class CauterizeTypeFormatterFactoryTest
+    {
+        [Test]
+        public void TestGetFormatter()
+        {
+            var factory = new CauterizeTypeFormatterFactory();
+            Assert.AreEqual(typeof(CauterizeCompositeFormatter), factory.GetFormatter(typeof(MyComposite)).GetType());
+            Assert.AreEqual(typeof(CauterizeGroupFormatter), factory.GetFormatter(typeof(MyGroup)).GetType());
+            Assert.AreEqual(typeof(CauterizeFixedArrayFormatter), factory.GetFormatter(typeof(MyFixedArray)).GetType());
+            Assert.AreEqual(typeof(CauterizeVariableArrayFormatter), factory.GetFormatter(typeof(MyVariableArray)).GetType());
+            Assert.AreEqual(typeof(CauterizePrimitiveFormatter), factory.GetFormatter(typeof(int)).GetType());
+            Assert.AreEqual(typeof(CauterizePrimitiveFormatter), factory.GetFormatter(typeof(double)).GetType());
+            Assert.AreEqual(typeof(CauterizeEnumFormatter), factory.GetFormatter(typeof(GroupType)).GetType());
+        }
+    }
+}