test/Apache-NMS-AMQP-Test/Message/NmsBytesMessageTest.cs

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using System;
using System.Linq;
using System.Text;
using Apache.NMS;
using Apache.NMS.AMQP.Message;
using NMS.AMQP.Test.Message.Facade;
using NUnit.Framework;

namespace NMS.AMQP.Test.Message
{
    [TestFixture]
    public class NmsBytesMessageTest
    {
        private readonly INmsMessageFactory factory = new TestMessageFactory();

        [Test]
        public void TestToString()
        {
            NmsBytesMessage bytesMessage = factory.CreateBytesMessage();
            Assert.True(bytesMessage.ToString().StartsWith("NmsBytesMessage"));
        }

        [Test]
        public void TestResetOnNewlyPopulatedBytesMessageUpdatesBodyLength()
        {
            byte[] bytes = Encoding.UTF8.GetBytes("myBytes");
            NmsBytesMessage bytesMessage = factory.CreateBytesMessage();
            bytesMessage.WriteBytes(bytes);
            bytesMessage.Reset();
            Assert.AreEqual(bytes.Length, bytesMessage.BodyLength, "Message reports unexpected length");
        }

        [Test]
        public void TestGetBodyLengthOnNewMessageThrowsMessageNotReadableException()
        {
            NmsBytesMessage bytesMessage = factory.CreateBytesMessage();

            try
            {
                long _ = bytesMessage.BodyLength;
                Assert.Fail("Exception expected");
            }
            catch (MessageNotReadableException)
            {
            }
        }

        [Test]
        public void TestReadBytesUsingReceivedMessageWithNoBodyReturnsEOS()
        {
            NmsBytesMessage bytesMessage = factory.CreateBytesMessage();
            bytesMessage.OnDispatch();
            Assert.AreEqual(0, bytesMessage.ReadBytes(new byte[1]));
        }

        [Test]
        public void TestReadBytesUsingReceivedMessageWithBodyReturnsBytes()
        {
            byte[] content = Encoding.UTF8.GetBytes("myBytes");

            NmsTestBytesMessageFacade facade = new NmsTestBytesMessageFacade(content);
            NmsBytesMessage bytesMessage = new NmsBytesMessage(facade);
            bytesMessage.OnDispatch();

            // retrieve the expected bytes, check they match
            byte[] receivedBytes = new byte[content.Length];
            bytesMessage.ReadBytes(receivedBytes);
            CollectionAssert.AreEqual(content, receivedBytes);

            // verify no more bytes remain, i.e EOS
            Assert.AreEqual(0, bytesMessage.ReadBytes(new byte[1]), "Expected input stream to be at end but data was returned");
            Assert.AreEqual(content.Length, bytesMessage.BodyLength);
        }

        /*
         * Test that attempting to write bytes to a received message (without calling BytesMessage#clearBody first)
         * causes a MessageNotWriteableException to be thrown due to being read-only.
         */
        [Test]
        public void TestReceivedBytesMessageThrowsMessageNotWriteableExceptionOnWriteBytes()
        {
            byte[] content = Encoding.UTF8.GetBytes("myBytes");

            NmsTestBytesMessageFacade facade = new NmsTestBytesMessageFacade(content);
            NmsBytesMessage bytesMessage = new NmsBytesMessage(facade);
            bytesMessage.OnDispatch();
            Assert.Throws<MessageNotWriteableException>(() => bytesMessage.WriteBytes(content));
        }

        /*
         * Test that attempting to read bytes from a new message (without calling BytesMessage#reset first) causes a
         * MessageNotReadableException to be thrown due to being write-only.
         */
        [Test]
        public void TestNewBytesMessageThrowsMessageNotReadableOnReadBytes()
        {
            NmsBytesMessage bytesMessage = factory.CreateBytesMessage();
            byte[] receivedBytes = new byte[1];
            Assert.Throws<MessageNotReadableException>(() => bytesMessage.ReadBytes(receivedBytes));
        }

        /*
         * Test that calling BytesMessage#clearBody causes a received
         * message to become writable
         */
        [Test]
        public void TestClearBodyOnReceivedBytesMessageMakesMessageWritable()
        {
            byte[] content = Encoding.UTF8.GetBytes("myBytes");
            NmsTestBytesMessageFacade facade = new NmsTestBytesMessageFacade(content);

            NmsBytesMessage bytesMessage = new NmsBytesMessage(facade);
            bytesMessage.OnDispatch();

            Assert.True(bytesMessage.IsReadOnlyBody);
            bytesMessage.ClearBody();
            Assert.False(bytesMessage.IsReadOnlyBody);
        }

        /*
         * Test that calling BytesMessage#ClearBody of a received message
         * causes the facade input stream to be empty and body length to return 0.         
         */
        [Test]
        public void TestClearBodyOnReceivedBytesMessageClearsFacadeInputStream()
        {
            byte[] content = Encoding.UTF8.GetBytes("myBytes");
            NmsTestBytesMessageFacade facade = new NmsTestBytesMessageFacade(content);

            NmsBytesMessage bytesMessage = new NmsBytesMessage(facade);
            bytesMessage.OnDispatch();

            Assert.True(facade.BodyLength > 0, "Expected message content but none was present");
            Assert.AreEqual(1, facade.GetDataReader().Read(new byte[1], 0, 1), "Expected data from facade");
            bytesMessage.ClearBody();
            Assert.True(facade.BodyLength == 0, "Expected no message content from facade");
            Assert.AreEqual(0, facade.GetDataReader().Read(new byte[1], 0, 1), "Expected no data from facade, but got some");
        }

        /*
         * Test that attempting to call BytesMessage#BodyLength on a received message after calling
         * BytesMessage#ClearBody causes MessageNotReadableException to be thrown due to being write-only.
         */
        [Test]
        public void TestGetBodyLengthOnClearedReceivedMessageThrowsMessageNotReadableException()
        {
            byte[] content = Encoding.UTF8.GetBytes("myBytes");
            NmsTestBytesMessageFacade facade = new NmsTestBytesMessageFacade(content);

            NmsBytesMessage bytesMessage = new NmsBytesMessage(facade);
            bytesMessage.OnDispatch();

            Assert.AreEqual(content.Length, bytesMessage.BodyLength, "Unexpected message length");
            bytesMessage.ClearBody();

            try
            {
                long bodyLength = bytesMessage.BodyLength;
                Assert.Fail("expected exception to be thrown");
            }
            catch (MessageNotReadableException)
            {
                // expected
            }
        }

        /*
         * Test that calling BytesMessage#Reset causes a write-only
         * message to become read-only
         */
        [Test]
        public void TestResetOnReceivedBytesMessageResetsMarker()
        {
            byte[] content = Encoding.UTF8.GetBytes("myBytes");
            NmsTestBytesMessageFacade facade = new NmsTestBytesMessageFacade(content);

            NmsBytesMessage bytesMessage = new NmsBytesMessage(facade);
            bytesMessage.OnDispatch();

            // retrieve a few bytes, check they match the first few expected bytes
            byte[] partialBytes = new byte[3];
            bytesMessage.ReadBytes(partialBytes);
            byte[] partialOriginalBytes = content.Take(3).ToArray();
            CollectionAssert.AreEqual(partialOriginalBytes, partialBytes);

            bytesMessage.Reset();

            // retrieve all the expected bytes, check they match
            byte[] resetBytes = new byte[content.Length];
            bytesMessage.ReadBytes(resetBytes);
            CollectionAssert.AreEqual(content, resetBytes);
        }

        /*
         * Test that calling BytesMessage#Reset on a new message which has been populated
         * causes the marker to be reset and makes the message read-only
         */
        [Test]
        public void TestResetOnNewlyPopulatedBytesMessageResetsMarkerAndMakesReadable()
        {
            byte[] content = Encoding.UTF8.GetBytes("myBytes");
            NmsTestBytesMessageFacade facade = new NmsTestBytesMessageFacade(content);

            NmsBytesMessage bytesMessage = new NmsBytesMessage(facade);

            Assert.False(bytesMessage.IsReadOnlyBody, "Message should be writable");
            bytesMessage.WriteBytes(content);
            bytesMessage.Reset();
            Assert.True(bytesMessage.IsReadOnlyBody, "Message should not be writable");

            // retrieve the bytes, check they match
            byte[] resetBytes = new byte[content.Length];
            bytesMessage.ReadBytes(resetBytes);
            CollectionAssert.AreEqual(content, resetBytes);
        }

        /*
         * Verify that nothing is read when BytesMessage#ReadBytes(byte[])} is
         * called with a zero length destination array.
         */
        [Test]
        public void TestReadBytesWithZeroLengthDestination()
        {
            NmsBytesMessage bytesMessage = factory.CreateBytesMessage();
            bytesMessage.Reset();
            Assert.AreEqual(0, bytesMessage.ReadBytes(new byte[0]), "Did not expect any bytes to be read");
        }

        /*
         * Verify that when BytesMessage#ReadBytes(byte[], int)} is called
         * with a negative length that an IndexOutOfRangeException is thrown.
         */
        [Test]
        public void TestReadBytesWithNegativeLengthThrowsIOORE()
        {
            NmsBytesMessage bytesMessage = factory.CreateBytesMessage();
            bytesMessage.Reset();
            Assert.Throws<IndexOutOfRangeException>(() => bytesMessage.ReadBytes(new byte[0], -1));
        }

        /*
         * Verify that when BytesMessage#ReadBytes(byte[], int)} is called
         * with a length that is greater than the size of the provided array,
         * an IndexOutOfRangeException is thrown.
         */
        [Test]
        public void TestReadBytesWithLengthGreatThanArraySizeThrowsIOORE()
        {
            NmsBytesMessage bytesMessage = factory.CreateBytesMessage();
            bytesMessage.Reset();
            Assert.Throws<IndexOutOfRangeException>(() => bytesMessage.ReadBytes(new byte[0], 2));
        }

        [Test]
        public void TestWriteObjectWithNullThrowsANE()
        {
            NmsBytesMessage bytesMessage = factory.CreateBytesMessage();
            Assert.Throws<ArgumentNullException>(() => bytesMessage.WriteObject(null));
        }

        [Test]
        public void TestWriteObjectWithIllegalTypeThrowsMFE()
        {
            NmsBytesMessage bytesMessage = factory.CreateBytesMessage();
            Assert.Throws<MessageFormatException>(() => bytesMessage.WriteObject(new object()));
        }

        [Test]
        public void TestGetBodyLength()
        {
            NmsBytesMessage bytesMessage = factory.CreateBytesMessage();
            int len = 10;
            for (int i = 0; i < len; i++)
            {
                bytesMessage.WriteInt64(5L);
            }

            bytesMessage.Reset();
            Assert.True(bytesMessage.BodyLength == len * 8);
        }

        [Test]
        public void TestSetGetContent()
        {
            byte[] content = Encoding.UTF8.GetBytes("myBytes");
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.Content = content;
            msg.Reset();
            CollectionAssert.AreEqual(content, msg.Content);
        }

        [Test]
        public void TestReadBoolean()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.WriteBoolean(true);
            msg.Reset();
            Assert.True(msg.ReadBoolean());
        }

        [Test]
        public void TestReadByte()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.WriteByte(2);
            msg.Reset();
            Assert.AreEqual(2, msg.ReadByte());
        }

        [Test]
        public void TestReadShort()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.WriteInt16(3000);
            msg.Reset();
            Assert.AreEqual(3000, msg.ReadInt16());
        }

        [Test]
        public void TestReadChar()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.WriteChar('a');
            msg.Reset();
            Assert.AreEqual('a', msg.ReadChar());
        }

        [Test]
        public void TestReadInt()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.WriteInt32(3000);
            msg.Reset();
            Assert.AreEqual(3000, msg.ReadInt32());
        }

        [Test]
        public void TestReadLong()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.WriteInt64(3000);
            msg.Reset();
            Assert.AreEqual(3000, msg.ReadInt64());
        }

        [Test]
        public void TestReadFloat()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.WriteSingle(3.3f);
            msg.Reset();
            Assert.AreEqual(3.3f, msg.ReadSingle());
        }

        [Test]
        public void TestReadDouble()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.WriteDouble(3.3d);
            msg.Reset();
            Assert.AreEqual(3.3d, msg.ReadDouble());
        }

        [Test]
        public void TestReadUTF()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            string str = "this is a test";
            msg.WriteString(str);
            msg.Reset();
            Assert.AreEqual(str, msg.ReadString());
        }

        [Test]
        public void TestReadBytesArray()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            byte[] data = new byte[50];
            for (int i = 0; i < data.Length; i++)
            {
                data[i] = (byte) i;
            }

            msg.WriteBytes(data);
            msg.Reset();
            byte[] test = new byte[data.Length];
            msg.ReadBytes(test);
            CollectionAssert.AreEqual(data, test);
        }

        [Test]
        public void TestWriteObject()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.WriteObject("fred");
            msg.WriteObject(true);
            msg.WriteObject('a');
            msg.WriteObject((byte) 1);
            msg.WriteObject((short) 3);
            msg.WriteObject((int) 3);
            msg.WriteObject(300L);
            msg.WriteObject(3.3F);
            msg.WriteObject(3.3D);
            msg.WriteObject(new byte[3]);

            Assert.Throws<MessageFormatException>(() => msg.WriteObject(new object()));
        }

        [Test]
        public void TestClearBodyOnNewMessage()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.WriteInt32(1);
            msg.ClearBody();
            Assert.False(msg.IsReadOnlyBody);
            msg.Reset();
            Assert.AreEqual(0, msg.BodyLength);
        }

        [Test]
        public void TestReset()
        {
            NmsBytesMessage msg = factory.CreateBytesMessage();
            msg.WriteDouble(3.3D);
            msg.WriteInt64(311);
            
            msg.Reset();
            
            Assert.True(msg.IsReadOnlyBody);
            Assert.AreEqual(3.3D, msg.ReadDouble());
            Assert.AreEqual(311, msg.ReadInt64());

            Assert.Throws<MessageNotWriteableException>(() => msg.WriteInt32(33));
        }

        [Test]
        public void TestReadOnlyBody()
        {
            NmsBytesMessage message = factory.CreateBytesMessage();
            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.WriteSingle((short) 1);
            message.WriteString("utfstring");
            
            message.Reset();
            
            message.ReadBoolean();
            message.ReadByte();
            message.ReadBytes(new byte[1]);
            message.ReadBytes(new byte[2], 2);
            message.ReadChar();
            message.ReadDouble();
            message.ReadSingle();
            message.ReadInt32();
            message.ReadInt64();
            message.ReadString();
            message.ReadSingle();
            message.ReadString();

            Assert.Throws<MessageNotWriteableException>(() => message.WriteBoolean(true));
            Assert.Throws<MessageNotWriteableException>(() => message.WriteByte(1));
            Assert.Throws<MessageNotWriteableException>(() => message.WriteBytes(new byte[1]));
            Assert.Throws<MessageNotWriteableException>(() => message.WriteBytes(new byte[3], 0, 2));
            Assert.Throws<MessageNotWriteableException>(() => message.WriteChar('a'));
            Assert.Throws<MessageNotWriteableException>(() => message.WriteDouble(1.5));
            Assert.Throws<MessageNotWriteableException>(() => message.WriteSingle(1.5f));
            Assert.Throws<MessageNotWriteableException>(() => message.WriteInt32(1));
            Assert.Throws<MessageNotWriteableException>(() => message.WriteInt64(1));
            Assert.Throws<MessageNotWriteableException>(() => message.WriteObject("utfstring"));
        }

        [Test]
        public void TestWriteOnlyBody()
        {
            NmsBytesMessage message = factory.CreateBytesMessage();
            message.ClearBody();
            
            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.WriteSingle((short) 1);
            message.WriteString("utfstring");
            
            Assert.Throws<MessageNotReadableException>(() => message.ReadBoolean());
            Assert.Throws<MessageNotReadableException>(() => message.ReadByte());
            Assert.Throws<MessageNotReadableException>(() => message.ReadBytes(new byte[1]));
            Assert.Throws<MessageNotReadableException>(() => message.ReadBytes(new byte[2], 2));
            Assert.Throws<MessageNotReadableException>(() => message.ReadChar());
            Assert.Throws<MessageNotReadableException>(() => message.ReadDouble());
            Assert.Throws<MessageNotReadableException>(() => message.ReadSingle());
            Assert.Throws<MessageNotReadableException>(() => message.ReadInt32());
            Assert.Throws<MessageNotReadableException>(() => message.ReadInt64());
            Assert.Throws<MessageNotReadableException>(() => message.ReadString());
            Assert.Throws<MessageNotReadableException>(() => message.ReadInt16());
        }

        [Test]
        public void TestMessageCopy()
        {
            NmsBytesMessage message = factory.CreateBytesMessage();

            NmsBytesMessage copy = message.Copy() as NmsBytesMessage;
            Assert.IsNotNull(copy);
        }
    }
}