Exemplo n.º 1
0
        public void TestReadInt()
        {
            BytesMessage msg = new BytesMessage();

            msg.WriteInt32(3000);
            msg.Reset();
            Assert.IsTrue(msg.ReadInt32() == 3000);
        }
Exemplo n.º 2
0
        public void TestClearBody()
        {
            BytesMessage bytesMessage = new BytesMessage();

            try {
                bytesMessage.WriteInt32(1);
                bytesMessage.ClearBody();
                Assert.IsFalse(bytesMessage.ReadOnlyBody);
                bytesMessage.WriteInt32(1);
                bytesMessage.ReadInt32();
            }
            catch (MessageNotReadableException)
            {
            }
            catch (MessageNotWriteableException)
            {
                Assert.IsTrue(false);
            }
        }
Exemplo n.º 3
0
        public void TestWriteOnlyBody()
        {
            BytesMessage message = new BytesMessage();

            message.ClearBody();

            try
            {
                message.WriteBoolean(true);
                message.WriteByte((byte)1);
                message.WriteBytes(new byte[1]);
                message.WriteBytes(new byte[3], 0, 2);
                message.WriteChar('a');
                message.WriteDouble(1.5);
                message.WriteSingle((float)1.5);
                message.WriteInt32(1);
                message.WriteInt64(1);
                message.WriteObject("stringobj");
                message.WriteInt16((short)1);
                message.WriteString("utfstring");
            }
            catch (MessageNotWriteableException)
            {
                Assert.Fail("Should be writeable");
            }

            try
            {
                message.ReadBoolean();
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }

            try
            {
                message.ReadByte();
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }

            try
            {
                message.ReadBytes(new byte[1]);
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }

            try
            {
                message.ReadBytes(new byte[2], 2);
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }

            try
            {
                message.ReadChar();
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }

            try
            {
                message.ReadDouble();
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }

            try
            {
                message.ReadSingle();
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }

            try
            {
                message.ReadInt32();
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }

            try
            {
                message.ReadInt64();
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }

            try
            {
                message.ReadString();
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }

            try
            {
                message.ReadInt16();
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }

            try
            {
                message.ReadString();
                Assert.Fail("Should have thrown exception");
            }
            catch (MessageNotReadableException)
            {
            }
        }