public void ISerializable()
        {
            byte[] buffer = new byte[20480];
            var    writer = new BufferValueWriter(buffer);

            SerializableTester tester = new SerializableTester
            {
                Name    = "MONKEY!",
                Numbers = new[] { 1, 2, 4, 8, 16, 32 }
            };

            var test = new AsyncTest();

            tester.SerializeCalled += test.PassHandler;

            writer.Write(context, tester);
            writer.Flush();

            var reader     = new BufferValueReader(buffer);
            var serialized = SerializerExtensions.Read <SerializableTester> (reader, context);

            Assert.IsNotNull(serialized);
            Assert.AreEqual(tester.Name, serialized.Name);
            Assert.IsTrue(tester.Numbers.SequenceEqual(serialized.Numbers), "Numbers does not match");

            test.Assert(1000);
        }
Beispiel #2
0
        public void Enum()
        {
            byte[] buffer = new byte[1024];
            var writer = new BufferValueWriter (buffer);
            writer.Write (context, TestEnum.High);
            int len = writer.Length;
            writer.Flush();

            var reader = new BufferValueReader (buffer);

            Assert.AreEqual (TestEnum.High, reader.Read<TestEnum> (context));
            Assert.AreEqual (len, reader.Position);
        }
        public void Enum()
        {
            byte[] buffer = new byte[1024];
            var    writer = new BufferValueWriter(buffer);

            writer.Write(context, TestEnum.High);
            int len = writer.Length;

            writer.Flush();

            var reader = new BufferValueReader(buffer);

            Assert.AreEqual(TestEnum.High, reader.Read <TestEnum> (context));
            Assert.AreEqual(len, reader.Position);
        }
        // [Test] Testing core APIs that now have NETFX_CORE turned on everywhere
        public void Serializable()
        {
            var inner = new Exception("Inner exception");
            var ex    = new InvalidOperationException("Don't do this, fool.", inner);

            byte[] buffer = new byte[20480];
            var    writer = new BufferValueWriter(buffer);

            writer.Write(context, ex);
            writer.Flush();

            var reader = new BufferValueReader(buffer);

            InvalidOperationException ioex = SerializerExtensions.Read <InvalidOperationException> (reader, context);

            Assert.IsNotNull(ioex);
            Assert.AreEqual(ex.Message, ioex.Message);
            Assert.AreEqual(ex.StackTrace, ioex.StackTrace);

            Assert.IsNotNull(ioex.InnerException);
            Assert.AreEqual(inner.Message, ioex.InnerException.Message);
            Assert.AreEqual(inner.StackTrace, ioex.InnerException.StackTrace);
        }
Beispiel #5
0
        public void ISerializable()
        {
            byte[] buffer = new byte[20480];
            var writer = new BufferValueWriter (buffer);

            SerializableTester tester = new SerializableTester
            {
                Name = "MONKEY!",
                Numbers = new[] { 1, 2, 4, 8, 16, 32 }
            };

            var test = new AsyncTest();
            tester.SerializeCalled += test.PassHandler;

            writer.Write (context, tester);
            writer.Flush();

            var reader = new BufferValueReader (buffer);
            var serialized = SerializerExtensions.Read<SerializableTester> (reader, context);

            Assert.IsNotNull (serialized);
            Assert.AreEqual (tester.Name, serialized.Name);
            Assert.IsTrue (tester.Numbers.SequenceEqual (serialized.Numbers), "Numbers does not match");

            test.Assert (1000);
        }
Beispiel #6
0
        // [Test] Testing core APIs that now have NETFX_CORE turned on everywhere
        public void Serializable()
        {
            var inner = new Exception ("Inner exception");
            var ex = new InvalidOperationException ("Don't do this, fool.", inner);

            byte[] buffer = new byte[20480];
            var writer = new BufferValueWriter (buffer);

            writer.Write (context, ex);
            writer.Flush();

            var reader = new BufferValueReader (buffer);

            InvalidOperationException ioex = SerializerExtensions.Read<InvalidOperationException> (reader, context);

            Assert.IsNotNull (ioex);
            Assert.AreEqual (ex.Message, ioex.Message);
            Assert.AreEqual (ex.StackTrace, ioex.StackTrace);

            Assert.IsNotNull (ioex.InnerException);
            Assert.AreEqual (inner.Message, ioex.InnerException.Message);
            Assert.AreEqual (inner.StackTrace, ioex.InnerException.StackTrace);
        }
        public void ValueReaderCtor()
        {
            byte[] buffer = new byte[20480];
            var writer = new BufferValueWriter (buffer);

            ValueReaderTester test = new ValueReaderTester ("TheName");

            writer.Write (context, test);
            writer.Flush();

            var reader = new BufferValueReader (buffer);
            var serialized = SerializerExtensions.Read<ValueReaderTester> (reader, context);

            Assert.AreEqual (test.Name, serialized.Name);
        }
        public void PrimitiveAsObject()
        {
            byte[] buffer = new byte[1024];
            var writer = new BufferValueWriter (buffer);

            writer.Write (context, (object)20f);
            writer.Flush();

            var reader = new BufferValueReader (buffer);
            object value = SerializerExtensions.Read<object> (reader, context);

            Assert.IsNotNull (value);
            Assert.AreEqual (20f, value);
        }
        public void Contracted()
        {
            byte[] buffer = new byte[20480];
            var writer = new BufferValueWriter (buffer);

            ISerializableTester test = new SerializableTester
            {
                Name = "MONKEY!",
                Numbers = new[] { 1, 2, 4, 8, 16, 32 }
            };

            writer.Write (context, test);
            writer.Flush();

            var reader = new BufferValueReader (buffer);
            var serialized = SerializerExtensions.Read<ISerializableTester> (reader, context);

            Assert.IsNotNull (serialized);
            Assert.AreEqual (test.Name, serialized.Name);
            Assert.IsTrue (test.Numbers.SequenceEqual (serialized.Numbers), "Numbers does not match");
        }