public void ReadEmptyInt64Test()
        {
            System.IO.Stream stream = new SerializedStreamBuilder()
                .ToStream();

            BinaryReader reader = new BinaryReader(stream, DeserializationHelper.CannedVersion);

            TestHelper.ExpectException<TeslaDeserializationException>(
                  () =>
                  {
                      reader.ReadInt64(string.Empty);
                  },
                  "The end of the stream is reached during deserialization.");
        }
        public void ReadTooSmallUInt16Test()
        {
            System.IO.Stream stream = new SerializedStreamBuilder()
                .Int64(long.MinValue)
                .ToStream();

            BinaryReader reader = new BinaryReader(stream, DeserializationHelper.CannedVersion);

            TestHelper.ExpectException<TeslaDeserializationException>(
                () =>
                {
                    reader.ReadUInt16(string.Empty);
                },
                "Bad format UInt16 value. The value was read is outside the range of the UInt16.");
        }
        public void ReadInvalidBinarySize()
        {
            System.IO.Stream stream = new SerializedStreamBuilder()
                .Int64(long.MaxValue)
                .ToStream();

            BinaryReader reader = new BinaryReader(stream, DeserializationHelper.CannedVersion);

            TestHelper.ExpectException<TeslaDeserializationException>(
                () =>
                {
                    reader.ReadBinary(string.Empty, false);
                },
                "Invalid data was encountered in the stream. The stream is corrupted.");
        }
        public void ReadBinaryTest()
        {
            // Test binary object of length 10:
            // { 0x01, 0x02, 0x32, 0x00, 0x23, 0x90, 0xFE, 0xA3, 0xB8, 0x99 }
            byte[] expected = new byte[] { 0x02, 0x02, 0x32, 0x00, 0x23, 0x90, 0xFE, 0xA3, 0xB8, 0x99 };

            System.IO.Stream stream = new SerializedStreamBuilder()
                .Binary(expected)
                .ToStream();

            BinaryReader reader = new BinaryReader(stream, DeserializationHelper.CannedVersion);

            byte[] actual = reader.ReadBinary(string.Empty, false);

            TestHelper.AssertCollectionEquals<byte>(expected, actual);
        }
        public void ReadNullableStringTest()
        {
            const string Expected = "foo";

            System.IO.Stream stream = new SerializedStreamBuilder()
                .String(Expected, false)
                .String(null, true)
                .ToStream();

            BinaryReader reader = new BinaryReader(stream, DeserializationHelper.CannedVersion);

            string actual;

            actual = reader.ReadString(string.Empty, true);
            Assert.AreEqual<string>(Expected, actual);

            actual = reader.ReadString(string.Empty, true);
            Assert.IsNull(actual);
        }
        public void ReadTooLargeInt64Test()
        {
            System.IO.Stream stream = new SerializedStreamBuilder()
                .RawByte(0xFF, 10)
                .ToStream();

            BinaryReader reader = new BinaryReader(stream, DeserializationHelper.CannedVersion);

            TestHelper.ExpectException<TeslaDeserializationException>(
                () =>
                {
                    reader.ReadInt64(string.Empty);
                },
                "Bad format integer was encounted. The data may be corrupted.");
        }
        public void ReadNullableBinaryTest()
        {
            byte[] expected = new byte[] { 0x12, 0x66, 0x3 };

            System.IO.Stream stream = new SerializedStreamBuilder()
                .NullableFlag(false)
                .Size((ulong)expected.Length)
                .RawBytes(expected)
                .NullableFlag(true)
                .ToStream();

            BinaryReader reader = new BinaryReader(stream, DeserializationHelper.CannedVersion);

            byte[] actual;

            actual = reader.ReadBinary(string.Empty, true);
            TestHelper.AssertCollectionEquals<byte>(expected, actual);

            actual = reader.ReadBinary(string.Empty, true);
            Assert.IsNull(actual);
        }
        public void ReadInvalidBoolTest()
        {
            System.IO.Stream stream = new SerializedStreamBuilder()
                .RawByte(0xFF)
                .ToStream();

            BinaryReader reader = new BinaryReader(stream, DeserializationHelper.CannedVersion);

            TestHelper.ExpectException<TeslaDeserializationException>(
                () =>
                {
                    reader.ReadBoolean(string.Empty);
                },
                "Invalid boolean value: 255.");
        }
        public void ReadTooSmallFloatTest()
        {
            System.IO.Stream stream = new SerializedStreamBuilder()
                .Double(double.MinValue)
                .ToStream();

            BinaryReader reader = new BinaryReader(stream, DeserializationHelper.CannedVersion);

            float actual = reader.ReadFloat(string.Empty);

            Assert.AreEqual<float>(float.NaN, actual);
        }