/*
* 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.
*/
package org.apache.qpid.jms.message;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import javax.jms.BytesMessage;
import javax.jms.JMSException;
import javax.jms.MessageEOFException;
import javax.jms.MessageFormatException;
import javax.jms.MessageNotReadableException;
import javax.jms.MessageNotWriteableException;
import org.apache.qpid.jms.message.facade.JmsBytesMessageFacade;
import org.apache.qpid.jms.message.facade.test.JmsTestBytesMessageFacade;
import org.apache.qpid.jms.message.facade.test.JmsTestMessageFactory;
import org.junit.Test;
import org.mockito.Mockito;
/**
* Test for JMS Spec compliance for the JmsBytesMessage class using the default message facade.
*/
public class JmsBytesMessageTest {
private static final int END_OF_STREAM = -1;
private final JmsMessageFactory factory = new JmsTestMessageFactory();
@Test
public void testToString() throws Exception {
JmsBytesMessage bytesMessage = factory.createBytesMessage();
assertTrue(bytesMessage.toString().startsWith("JmsBytesMessage"));
}
/**
* Test that calling {@link BytesMessage#getBodyLength()} on a new message which has been
* populated and {@link BytesMessage#reset()} causes the length to be reported correctly.
*
* @throws Exception if an error occurs during the test.
*/
@Test
public void testResetOnNewlyPopulatedBytesMessageUpdatesBodyLength() throws Exception {
byte[] bytes = "newResetTestBytes".getBytes();
JmsBytesMessage bytesMessage = factory.createBytesMessage();
bytesMessage.writeBytes(bytes);
bytesMessage.reset();
assertEquals("Message reports unexpected length", bytes.length, bytesMessage.getBodyLength());
}
/**
* Test that attempting to call {@link BytesMessage#getBodyLength()} on a new message causes
* a {@link MessageNotReadableException} to be thrown due to being write-only.
*
* @throws Exception if an error occurs during the test.
*/
@Test(expected = MessageNotReadableException.class)
public void testGetBodyLengthOnNewMessageThrowsMessageNotReadableException() throws Exception {
JmsBytesMessage bytesMessage = factory.createBytesMessage();
bytesMessage.getBodyLength();
}
@Test
public void testReadBytesUsingReceivedMessageWithNoBodyReturnsEOS() throws Exception {
JmsBytesMessage bytesMessage = factory.createBytesMessage();
bytesMessage.onDispatch();
//verify attempting to read bytes returns -1, i.e EOS
assertEquals("Expected input stream to be at end but data was returned", END_OF_STREAM, bytesMessage.readBytes(new byte[1]));
}
@Test
public void testReadBytesUsingReceivedMessageWithBodyReturnsBytes() throws Exception {
byte[] content = "myBytesData".getBytes();
JmsTestBytesMessageFacade facade = new JmsTestBytesMessageFacade(content);
JmsBytesMessage bytesMessage = new JmsBytesMessage(facade);
bytesMessage.onDispatch();
// retrieve the expected bytes, check they match
byte[] receivedBytes = new byte[content.length];
bytesMessage.readBytes(receivedBytes);
assertTrue(Arrays.equals(content, receivedBytes));
// verify no more bytes remain, i.e EOS
assertEquals("Expected input stream to be at end but data was returned",
END_OF_STREAM, bytesMessage.readBytes(new byte[1]));
assertEquals("Message reports unexpected length", content.length, bytesMessage.getBodyLength());
}
/**
* Test that attempting to write bytes to a received message (without calling {@link BytesMessage#clearBody()} first)
* causes a {@link MessageNotWriteableException} to be thrown due to being read-only.
*
* @throws Exception if an error occurs during the test.
*/
@Test(expected = MessageNotWriteableException.class)
public void testReceivedBytesMessageThrowsMessageNotWriteableExceptionOnWriteBytes() throws Exception {
byte[] content = "myBytesData".getBytes();
JmsTestBytesMessageFacade facade = new JmsTestBytesMessageFacade(content);
JmsBytesMessage bytesMessage = new JmsBytesMessage(facade);
bytesMessage.onDispatch();
bytesMessage.writeBytes(content);
}
/**
* Test that attempting to read bytes from a new message (without calling {@link BytesMessage#reset()} first) causes a
* {@link MessageNotReadableException} to be thrown due to being write-only.
*
* @throws Exception if an error occurs during the test.
*/
@Test(expected = MessageNotReadableException.class)
public void testNewBytesMessageThrowsMessageNotReadableOnReadBytes() throws Exception {
JmsBytesMessage bytesMessage = factory.createBytesMessage();
byte[] receivedBytes = new byte[1];
bytesMessage.readBytes(receivedBytes);
}
/**
* Test that calling {@link BytesMessage#clearBody()} causes a received
* message to become writable
*
* @throws Exception if an error occurs during the test.
*/
@Test
public void testClearBodyOnReceivedBytesMessageMakesMessageWritable() throws Exception {
byte[] content = "myBytesData".getBytes();
JmsTestBytesMessageFacade facade = new JmsTestBytesMessageFacade(content);
JmsBytesMessage bytesMessage = new JmsBytesMessage(facade);
bytesMessage.onDispatch();
assertTrue("Message should not be writable", bytesMessage.isReadOnlyBody());
bytesMessage.clearBody();
assertFalse("Message should be writable", bytesMessage.isReadOnlyBody());
}
/**
* Test that calling {@link BytesMessage#clearBody()} of a received message
* causes the facade input stream to be empty and body length to return 0.
*
* @throws Exception if an error occurs during the test.
*/
@Test
public void testClearBodyOnReceivedBytesMessageClearsFacadeInputStream() throws Exception {
byte[] content = "myBytesData".getBytes();
JmsTestBytesMessageFacade facade = new JmsTestBytesMessageFacade(content);
JmsBytesMessage bytesMessage = new JmsBytesMessage(facade);
bytesMessage.onDispatch();
assertTrue("Expected message content but none was present", facade.getBodyLength() > 0);
assertEquals("Expected data from facade", 1, facade.getInputStream().read(new byte[1]));
bytesMessage.clearBody();
assertTrue("Expected no message content from facade", facade.getBodyLength() == 0);
assertEquals("Expected no data from facade, but got some", END_OF_STREAM, facade.getInputStream().read(new byte[1]));
}
/**
* Test that attempting to call {@link BytesMessage#getBodyLength()} on a received message after calling
* {@link BytesMessage#clearBody()} causes {@link MessageNotReadableException} to be thrown due to being write-only.
*
* @throws Exception if an error occurs during the test.
*/
@Test
public void testGetBodyLengthOnClearedReceivedMessageThrowsMessageNotReadableException() throws Exception {
byte[] content = "myBytesData".getBytes();
JmsTestBytesMessageFacade facade = new JmsTestBytesMessageFacade(content);
JmsBytesMessage bytesMessage = new JmsBytesMessage(facade);
bytesMessage.onDispatch();
assertEquals("Unexpected message length", content.length, bytesMessage.getBodyLength());
bytesMessage.clearBody();
try {
bytesMessage.getBodyLength();
fail("expected exception to be thrown");
} catch (MessageNotReadableException mnre) {
// expected
}
}
/**
* Test that calling {@link BytesMessage#reset()} causes a write-only
* message to become read-only
*
* @throws Exception if an error occurs during the test.
*/
@Test
public void testResetOnReceivedBytesMessageResetsMarker() throws Exception {
byte[] content = "myBytesData".getBytes();
JmsTestBytesMessageFacade facade = new JmsTestBytesMessageFacade(content);
JmsBytesMessage bytesMessage = new JmsBytesMessage(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 = Arrays.copyOf(content, 3);
assertTrue(Arrays.equals(partialOriginalBytes, partialBytes));
bytesMessage.reset();
// retrieve all the expected bytes, check they match
byte[] resetBytes = new byte[content.length];
bytesMessage.readBytes(resetBytes);
assertTrue(Arrays.equals(content, resetBytes));
}
/**
* Test that calling {@link BytesMessage#reset()} on a new message which has been populated
* causes the marker to be reset and makes the message read-only
*
* @throws Exception if an error occurs during the test.
*/
@Test
public void testResetOnNewlyPopulatedBytesMessageResetsMarkerAndMakesReadable() throws Exception {
byte[] content = "myBytesData".getBytes();
JmsTestBytesMessageFacade facade = new JmsTestBytesMessageFacade(content);
JmsBytesMessage bytesMessage = new JmsBytesMessage(facade);
assertFalse("Message should be writable", bytesMessage.isReadOnlyBody());
bytesMessage.writeBytes(content);
bytesMessage.reset();
assertTrue("Message should not be writable", bytesMessage.isReadOnlyBody());
// retrieve the bytes, check they match
byte[] resetBytes = new byte[content.length];
bytesMessage.readBytes(resetBytes);
assertTrue(Arrays.equals(content, resetBytes));
}
/**
* Verify that nothing is read when {@link BytesMessage#readBytes(byte[])} is
* called with a zero length destination array.
*
* @throws Exception if an error occurs during the test.
*/
@Test
public void testReadBytesWithZeroLengthDestination() throws Exception {
JmsBytesMessage bytesMessage = factory.createBytesMessage();
bytesMessage.reset();
assertEquals("Did not expect any bytes to be read", 0, bytesMessage.readBytes(new byte[0]));
}
/**
* Verify that when {@link BytesMessage#readBytes(byte[], int)} is called
* with a negative length that an {@link IndexOutOfBoundsException} is thrown.
*
* @throws Exception if an error occurs during the test.
*/
@Test(expected=IndexOutOfBoundsException.class)
public void testReadBytesWithNegativeLengthThrowsIOOBE() throws Exception
{
JmsBytesMessage bytesMessage = factory.createBytesMessage();
bytesMessage.reset();
bytesMessage.readBytes(new byte[0], -1);
}
/**
* Verify that when {@link BytesMessage#readBytes(byte[], int)} is called
* with a length that is greater than the size of the provided array,
* an {@link IndexOutOfBoundsException} is thrown.
*
* @throws Exception if an error occurs during the test.
*/
@Test(expected=IndexOutOfBoundsException.class)
public void testReadBytesWithLengthGreatThanArraySizeThrowsIOOBE() throws Exception {
JmsBytesMessage bytesMessage = factory.createBytesMessage();
bytesMessage.reset();
bytesMessage.readBytes(new byte[1], 2);
}
/**
* Test that writing a null using {@link BytesMessage#writeObject(Object)}
* results in a NPE being thrown.
*
* @throws Exception if an error occurs during the test.
*/
@Test(expected=NullPointerException.class)
public void testWriteObjectWithNullThrowsNPE() throws Exception {
JmsBytesMessage bytesMessage = factory.createBytesMessage();
bytesMessage.writeObject(null);
}
/**
* Test that writing a null using {@link BytesMessage#writeObject(Object)}
* results in an {@link MessageFormatException} being thrown.
*
* @throws Exception if an error occurs during the test.
*/
@Test(expected=MessageFormatException.class)
public void testWriteObjectWithIllegalTypeThrowsMFE() throws Exception {
JmsBytesMessage bytesMessage = factory.createBytesMessage();
bytesMessage.writeObject(new Object());
}
@Test
public void testGetBodyLength() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
int len = 10;
for (int i = 0; i < len; i++) {
msg.writeLong(5L);
}
msg.reset();
assertTrue(msg.getBodyLength() == (len * 8));
}
@Test
public void testReadBoolean() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
msg.writeBoolean(true);
msg.reset();
assertTrue(msg.readBoolean());
}
@Test
public void testReadByte() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
msg.writeByte((byte) 2);
msg.reset();
assertTrue(msg.readByte() == 2);
}
@Test
public void testReadUnsignedByte() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
msg.writeByte((byte) 2);
msg.reset();
assertTrue(msg.readUnsignedByte() == 2);
}
@Test
public void testReadShort() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
msg.writeShort((short) 3000);
msg.reset();
assertTrue(msg.readShort() == 3000);
}
@Test
public void testReadUnsignedShort() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
msg.writeShort((short) 3000);
msg.reset();
assertTrue(msg.readUnsignedShort() == 3000);
}
@Test
public void testReadChar() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
msg.writeChar('a');
msg.reset();
assertTrue(msg.readChar() == 'a');
}
@Test
public void testReadInt() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
msg.writeInt(3000);
msg.reset();
assertTrue(msg.readInt() == 3000);
}
@Test
public void testReadLong() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
msg.writeLong(3000);
msg.reset();
assertTrue(msg.readLong() == 3000);
}
@Test
public void testReadFloat() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
msg.writeFloat(3.3f);
msg.reset();
assertTrue(msg.readFloat() == 3.3f);
}
@Test
public void testReadDouble() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
msg.writeDouble(3.3d);
msg.reset();
assertTrue(msg.readDouble() == 3.3d);
}
@Test
public void testReadUTF() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
String str = "this is a test";
msg.writeUTF(str);
msg.reset();
assertTrue(msg.readUTF().equals(str));
}
@Test
public void testReadBytesbyteArray() throws JMSException {
JmsBytesMessage 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);
for (int i = 0; i < test.length; i++) {
assertTrue(test[i] == i);
}
}
@Test
public void testWriteObject() throws JMSException {
JmsBytesMessage msg = factory.createBytesMessage();
try {
msg.writeObject("fred");
msg.writeObject(Boolean.TRUE);
msg.writeObject(Character.valueOf('q'));
msg.writeObject(Byte.valueOf((byte) 1));
msg.writeObject(Short.valueOf((short) 3));
msg.writeObject(Integer.valueOf(3));
msg.writeObject(Long.valueOf(300L));
msg.writeObject(new Float(3.3f));
msg.writeObject(new Double(3.3));
msg.writeObject(new byte[3]);
} catch (MessageFormatException mfe) {
fail("objectified primitives should be allowed");
}
try {
msg.writeObject(new Object());
fail("only objectified primitives are allowed");
} catch (MessageFormatException mfe) {
}
}
@Test
public void testClearBodyOnNewMessage() throws JMSException {
JmsBytesMessage bytesMessage = factory.createBytesMessage();
bytesMessage.writeInt(1);
bytesMessage.clearBody();
assertFalse(bytesMessage.isReadOnlyBody());
bytesMessage.reset();
assertEquals(0, bytesMessage.getBodyLength());
}
@Test
public void testReset() throws JMSException {
JmsBytesMessage message = factory.createBytesMessage();
try {
message.writeDouble(24.5);
message.writeLong(311);
} catch (MessageNotWriteableException mnwe) {
fail("should be writeable");
}
message.reset();
try {
assertTrue(message.isReadOnlyBody());
assertEquals(message.readDouble(), 24.5, 0);
assertEquals(message.readLong(), 311);
} catch (MessageNotReadableException mnre) {
fail("should be readable");
}
try {
message.writeInt(33);
fail("should throw exception");
} catch (MessageNotWriteableException mnwe) {
}
}
@Test
public void testReadOnlyBody() throws JMSException {
JmsBytesMessage message = factory.createBytesMessage();
try {
message.writeBoolean(true);
message.writeByte((byte) 1);
message.writeByte((byte) 1);
message.writeBytes(new byte[1]);
message.writeBytes(new byte[3], 0, 2);
message.writeChar('a');
message.writeDouble(1.5);
message.writeFloat((float) 1.5);
message.writeInt(1);
message.writeLong(1);
message.writeObject("stringobj");
message.writeShort((short) 1);
message.writeShort((short) 1);
message.writeUTF("utfstring");
} catch (MessageNotWriteableException mnwe) {
fail("Should be writeable");
}
message.reset();
try {
message.readBoolean();
message.readByte();
message.readUnsignedByte();
message.readBytes(new byte[1]);
message.readBytes(new byte[2], 2);
message.readChar();
message.readDouble();
message.readFloat();
message.readInt();
message.readLong();
message.readUTF();
message.readShort();
message.readUnsignedShort();
message.readUTF();
} catch (MessageNotReadableException mnwe) {
fail("Should be readable");
}
try {
message.writeBoolean(true);
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
try {
message.writeByte((byte) 1);
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
try {
message.writeBytes(new byte[1]);
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
try {
message.writeBytes(new byte[3], 0, 2);
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
try {
message.writeChar('a');
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
try {
message.writeDouble(1.5);
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
try {
message.writeFloat((float) 1.5);
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
try {
message.writeInt(1);
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
try {
message.writeLong(1);
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
try {
message.writeObject("stringobj");
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
try {
message.writeShort((short) 1);
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
try {
message.writeUTF("utfstring");
fail("Should have thrown exception");
} catch (MessageNotWriteableException mnwe) {
}
}
@Test
public void testWriteOnlyBody() throws JMSException {
JmsBytesMessage message = factory.createBytesMessage();
message.clearBody();
try {
message.writeBoolean(true);
message.writeByte((byte) 1);
message.writeByte((byte) 1);
message.writeBytes(new byte[1]);
message.writeBytes(new byte[3], 0, 2);
message.writeChar('a');
message.writeDouble(1.5);
message.writeFloat((float) 1.5);
message.writeInt(1);
message.writeLong(1);
message.writeObject("stringobj");
message.writeShort((short) 1);
message.writeShort((short) 1);
message.writeUTF("utfstring");
} catch (MessageNotWriteableException mnwe) {
fail("Should be writeable");
}
try {
message.readBoolean();
fail("Should have thrown exception");
} catch (MessageNotReadableException mnwe) {
}
try {
message.readByte();
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readUnsignedByte();
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readBytes(new byte[1]);
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readBytes(new byte[2], 2);
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readChar();
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readDouble();
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readFloat();
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readInt();
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readLong();
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readUTF();
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readShort();
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readUnsignedShort();
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
try {
message.readUTF();
fail("Should have thrown exception");
} catch (MessageNotReadableException e) {
}
}
//---------- Test that errors are trapped correctly ----------------------//
@Test
public void testReadMethodsCaptureEOFExceptionThrowsMessageEOFEx() throws Exception {
JmsBytesMessageFacade facade = Mockito.mock(JmsBytesMessageFacade.class);
InputStream bytesIn = Mockito.mock(InputStream.class);
Mockito.when(facade.getInputStream()).thenReturn(bytesIn);
Mockito.when(bytesIn.read()).thenThrow(new EOFException());
Mockito.when(bytesIn.read(Mockito.any(byte[].class))).thenThrow(new EOFException());
Mockito.when(bytesIn.read(Mockito.any(byte[].class), Mockito.anyInt(), Mockito.anyInt())).thenThrow(new EOFException());
JmsBytesMessage message = new JmsBytesMessage(facade);
message.reset();
try {
message.readBoolean();
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readByte();
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readBytes(new byte[10]);
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readBytes(new byte[10], 10);
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readChar();
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readDouble();
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readFloat();
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readInt();
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readLong();
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readShort();
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readUnsignedByte();
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readUnsignedShort();
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
try {
message.readUTF();
} catch (MessageEOFException ex) {
assertTrue(ex.getCause() instanceof EOFException);
}
}
@Test
public void testReadMethodsCaptureIOExceptionThrowsJMSEx() throws Exception {
JmsBytesMessageFacade facade = Mockito.mock(JmsBytesMessageFacade.class);
InputStream bytesIn = Mockito.mock(InputStream.class);
Mockito.when(facade.getInputStream()).thenReturn(bytesIn);
Mockito.when(bytesIn.read()).thenThrow(new IOException());
Mockito.when(bytesIn.read(Mockito.any(byte[].class))).thenThrow(new IOException());
Mockito.when(bytesIn.read(Mockito.any(byte[].class), Mockito.anyInt(), Mockito.anyInt())).thenThrow(new IOException());
JmsBytesMessage message = new JmsBytesMessage(facade);
message.reset();
try {
message.readBoolean();
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readByte();
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readBytes(new byte[10]);
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readBytes(new byte[10], 10);
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readChar();
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readDouble();
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readFloat();
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readInt();
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readLong();
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readShort();
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readUnsignedByte();
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readUnsignedShort();
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.readUTF();
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
}
@Test
public void testWriteMethodsCaptureIOExceptionThrowsJMSEx() throws Exception {
JmsBytesMessageFacade facade = Mockito.mock(JmsBytesMessageFacade.class);
OutputStream bytesOut = Mockito.mock(OutputStream.class);
Mockito.when(facade.getOutputStream()).thenReturn(bytesOut);
Mockito.doThrow(new IOException()).when(bytesOut).write(Mockito.anyByte());
Mockito.doThrow(new IOException()).when(bytesOut).write(Mockito.any(byte[].class));
Mockito.doThrow(new IOException()).when(bytesOut).write(Mockito.any(byte[].class), Mockito.anyInt(), Mockito.anyInt());
JmsBytesMessage message = new JmsBytesMessage(facade);
try {
message.writeBoolean(false);
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.writeByte((byte) 128);
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.writeBytes(new byte[10]);
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.writeBytes(new byte[10], 0, 10);
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.writeChar('a');
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.writeDouble(100.0);
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.writeFloat(10.2f);
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.writeInt(125);
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.writeLong(65536L);
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.writeObject("");
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.writeShort((short) 32768);
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
try {
message.writeUTF("");
} catch (JMSException ex) {
assertTrue(ex.getCause() instanceof IOException);
}
}
@Test
public void testGetBodyThrowsMessageFormatException() throws JMSException {
JmsBytesMessage bytesMessage = factory.createBytesMessage();
bytesMessage.setStringProperty("property", "value");
bytesMessage.writeByte((byte) 1);
bytesMessage.writeInt(22);
try {
bytesMessage.getBody(StringBuffer.class);
fail("should have thrown MessageFormatException");
} catch (MessageFormatException mfe) {
} catch (Exception e) {
fail("should have thrown MessageFormatException");
}
}
//---------- Test for misc message methods -------------------------------//
@Test
public void testHashCode() throws Exception {
String messageId = "ID:SOME-ID:0:1:1";
JmsBytesMessage message = factory.createBytesMessage();
message.setJMSMessageID(messageId);
assertEquals(message.getJMSMessageID().hashCode(), messageId.hashCode());
assertEquals(message.hashCode(), messageId.hashCode());
}
@Test
public void testEqualsObject() throws Exception {
String messageId = "ID:SOME-ID:0:1:1";
JmsBytesMessage message1 = factory.createBytesMessage();
JmsBytesMessage message2 = factory.createBytesMessage();
message1.setJMSMessageID(messageId);
assertTrue(!message1.equals(message2));
assertTrue(!message2.equals(message1));
message2.setJMSMessageID(messageId);
assertTrue(message1.equals(message2));
assertTrue(message2.equals(message1));
message2.setJMSMessageID(messageId + "More");
assertTrue(!message1.equals(message2));
assertTrue(!message2.equals(message1));
assertTrue(message1.equals(message1));
assertFalse(message1.equals(null));
assertFalse(message1.equals(""));
}
}