| /** |
| * 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.activemq.command; |
| |
| import java.io.IOException; |
| import java.util.Enumeration; |
| import java.util.Map; |
| |
| import javax.jms.DeliveryMode; |
| import javax.jms.JMSException; |
| import javax.jms.Message; |
| import javax.jms.MessageFormatException; |
| import javax.jms.MessageNotWriteableException; |
| |
| import junit.framework.TestCase; |
| |
| import org.apache.activemq.openwire.OpenWireFormat; |
| import org.apache.activemq.state.CommandVisitor; |
| import org.apache.activemq.util.ByteSequence; |
| import org.apache.activemq.wireformat.WireFormat; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| public class ActiveMQMessageTest extends TestCase { |
| |
| private static final Logger LOG = LoggerFactory.getLogger(ActiveMQMessageTest.class); |
| |
| protected boolean readOnlyMessage; |
| |
| private String jmsMessageID; |
| private String jmsCorrelationID; |
| private ActiveMQDestination jmsDestination; |
| private ActiveMQDestination jmsReplyTo; |
| private int jmsDeliveryMode; |
| private boolean jmsRedelivered; |
| private String jmsType; |
| private long jmsExpiration; |
| private int jmsPriority; |
| private long jmsTimestamp; |
| private long[] consumerIDs; |
| |
| /** |
| * Constructor for ActiveMQMessageTest. |
| * |
| * @param name |
| */ |
| public ActiveMQMessageTest(String name) { |
| super(name); |
| } |
| |
| public static void main(String[] args) { |
| } |
| |
| /* |
| * @see TestCase#setUp() |
| */ |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| this.jmsMessageID = "ID:TEST-ID:0:0:0:1"; |
| this.jmsCorrelationID = "testcorrelationid"; |
| this.jmsDestination = new ActiveMQTopic("test.topic"); |
| this.jmsReplyTo = new ActiveMQTempTopic("test.replyto.topic:001"); |
| this.jmsDeliveryMode = Message.DEFAULT_DELIVERY_MODE; |
| this.jmsRedelivered = true; |
| this.jmsType = "test type"; |
| this.jmsExpiration = 100000; |
| this.jmsPriority = 5; |
| this.jmsTimestamp = System.currentTimeMillis(); |
| this.readOnlyMessage = false; |
| this.consumerIDs = new long[3]; |
| for (int i = 0; i < this.consumerIDs.length; i++) { |
| this.consumerIDs[i] = i; |
| } |
| } |
| |
| /* |
| * @see TestCase#tearDown() |
| */ |
| @Override |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| } |
| |
| public void testGetDataStructureType() { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| assertEquals(msg.getDataStructureType(), CommandTypes.ACTIVEMQ_MESSAGE); |
| } |
| |
| public void testHashCode() throws Exception { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSMessageID(this.jmsMessageID); |
| assertTrue(msg.getJMSMessageID().hashCode() == jmsMessageID.hashCode()); |
| } |
| |
| public void testSetReadOnly() { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setReadOnlyProperties(true); |
| boolean test = false; |
| try { |
| msg.setIntProperty("test", 1); |
| } catch (MessageNotWriteableException me) { |
| test = true; |
| } catch (JMSException e) { |
| e.printStackTrace(System.err); |
| test = false; |
| } |
| assertTrue(test); |
| } |
| |
| public void testSetToForeignJMSID() throws Exception { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSMessageID("ID:EMS-SERVER.8B443C380083:429"); |
| } |
| |
| /* |
| * Class to test for boolean equals(Object) |
| */ |
| public void testEqualsObject() throws Exception { |
| ActiveMQMessage msg1 = new ActiveMQMessage(); |
| ActiveMQMessage msg2 = new ActiveMQMessage(); |
| msg1.setJMSMessageID(this.jmsMessageID); |
| assertTrue(!msg1.equals(msg2)); |
| msg2.setJMSMessageID(this.jmsMessageID); |
| assertTrue(msg1.equals(msg2)); |
| } |
| |
| public void testShallowCopy() throws Exception { |
| ActiveMQMessage msg1 = new ActiveMQMessage(); |
| msg1.setJMSMessageID(jmsMessageID); |
| ActiveMQMessage msg2 = (ActiveMQMessage) msg1.copy(); |
| assertTrue(msg1 != msg2 && msg1.equals(msg2)); |
| } |
| |
| public void testCopy() throws Exception { |
| this.jmsMessageID = "testid"; |
| this.jmsCorrelationID = "testcorrelationid"; |
| this.jmsDestination = new ActiveMQTopic("test.topic"); |
| this.jmsReplyTo = new ActiveMQTempTopic("test.replyto.topic:001"); |
| this.jmsDeliveryMode = Message.DEFAULT_DELIVERY_MODE; |
| this.jmsRedelivered = true; |
| this.jmsType = "test type"; |
| this.jmsExpiration = 100000; |
| this.jmsPriority = 5; |
| this.jmsTimestamp = System.currentTimeMillis(); |
| this.readOnlyMessage = false; |
| |
| ActiveMQMessage msg1 = new ActiveMQMessage(); |
| msg1.setJMSMessageID(this.jmsMessageID); |
| msg1.setJMSCorrelationID(this.jmsCorrelationID); |
| msg1.setJMSDestination(this.jmsDestination); |
| msg1.setJMSReplyTo(this.jmsReplyTo); |
| msg1.setJMSDeliveryMode(this.jmsDeliveryMode); |
| msg1.setJMSRedelivered(this.jmsRedelivered); |
| msg1.setJMSType(this.jmsType); |
| msg1.setJMSExpiration(this.jmsExpiration); |
| msg1.setJMSPriority(this.jmsPriority); |
| msg1.setJMSTimestamp(this.jmsTimestamp); |
| msg1.setReadOnlyProperties(true); |
| ActiveMQMessage msg2 = new ActiveMQMessage(); |
| msg1.copy(msg2); |
| assertEquals(msg1.getJMSMessageID(), msg2.getJMSMessageID()); |
| assertTrue(msg1.getJMSCorrelationID().equals(msg2.getJMSCorrelationID())); |
| assertTrue(msg1.getJMSDestination().equals(msg2.getJMSDestination())); |
| assertTrue(msg1.getJMSReplyTo().equals(msg2.getJMSReplyTo())); |
| assertTrue(msg1.getJMSDeliveryMode() == msg2.getJMSDeliveryMode()); |
| assertTrue(msg1.getJMSRedelivered() == msg2.getJMSRedelivered()); |
| assertTrue(msg1.getJMSType().equals(msg2.getJMSType())); |
| assertTrue(msg1.getJMSExpiration() == msg2.getJMSExpiration()); |
| assertTrue(msg1.getJMSPriority() == msg2.getJMSPriority()); |
| assertTrue(msg1.getJMSTimestamp() == msg2.getJMSTimestamp()); |
| |
| LOG.info("Message is: " + msg1); |
| } |
| |
| public void testGetAndSetJMSMessageID() throws Exception { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSMessageID(this.jmsMessageID); |
| assertEquals(msg.getJMSMessageID(), this.jmsMessageID); |
| } |
| |
| public void testGetAndSetJMSTimestamp() { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSTimestamp(this.jmsTimestamp); |
| assertTrue(msg.getJMSTimestamp() == this.jmsTimestamp); |
| } |
| |
| public void testGetJMSCorrelationIDAsBytes() throws Exception { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSCorrelationID(this.jmsCorrelationID); |
| byte[] testbytes = msg.getJMSCorrelationIDAsBytes(); |
| String str2 = new String(testbytes); |
| assertTrue(this.jmsCorrelationID.equals(str2)); |
| } |
| |
| public void testSetJMSCorrelationIDAsBytes() throws Exception { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| byte[] testbytes = this.jmsCorrelationID.getBytes(); |
| msg.setJMSCorrelationIDAsBytes(testbytes); |
| testbytes = msg.getJMSCorrelationIDAsBytes(); |
| String str2 = new String(testbytes); |
| assertTrue(this.jmsCorrelationID.equals(str2)); |
| } |
| |
| public void testGetAndSetJMSCorrelationID() { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSCorrelationID(this.jmsCorrelationID); |
| assertTrue(msg.getJMSCorrelationID().equals(this.jmsCorrelationID)); |
| } |
| |
| public void testGetAndSetJMSReplyTo() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSReplyTo(this.jmsReplyTo); |
| assertTrue(msg.getJMSReplyTo().equals(this.jmsReplyTo)); |
| } |
| |
| public void testGetAndSetJMSDestination() throws Exception { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSDestination(this.jmsDestination); |
| assertTrue(msg.getJMSDestination().equals(this.jmsDestination)); |
| } |
| |
| public void testGetAndSetJMSDeliveryMode() { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSDeliveryMode(this.jmsDeliveryMode); |
| assertTrue(msg.getJMSDeliveryMode() == this.jmsDeliveryMode); |
| } |
| |
| public void testGetAndSetMSRedelivered() { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSRedelivered(this.jmsRedelivered); |
| assertTrue(msg.getJMSRedelivered() == this.jmsRedelivered); |
| } |
| |
| public void testGetAndSetJMSType() { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSType(this.jmsType); |
| assertTrue(msg.getJMSType().equals(this.jmsType)); |
| } |
| |
| public void testGetAndSetJMSExpiration() { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSExpiration(this.jmsExpiration); |
| assertTrue(msg.getJMSExpiration() == this.jmsExpiration); |
| } |
| |
| public void testGetAndSetJMSPriority() { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSPriority(this.jmsPriority); |
| assertTrue(msg.getJMSPriority() == this.jmsPriority); |
| |
| msg.setJMSPriority(-90); |
| assertEquals(0, msg.getJMSPriority()); |
| |
| msg.setJMSPriority(90); |
| assertEquals(9, msg.getJMSPriority()); |
| } |
| |
| public void testClearProperties() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setStringProperty("test", "test"); |
| msg.setContent(new ByteSequence(new byte[1], 0, 0)); |
| msg.setJMSMessageID(this.jmsMessageID); |
| msg.clearProperties(); |
| assertNull(msg.getStringProperty("test")); |
| assertNotNull(msg.getJMSMessageID()); |
| assertNotNull(msg.getContent()); |
| } |
| |
| public void testPropertyExists() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setStringProperty("test", "test"); |
| assertTrue(msg.propertyExists("test")); |
| |
| msg.setIntProperty("JMSXDeliveryCount", 1); |
| assertTrue(msg.propertyExists("JMSXDeliveryCount")); |
| } |
| |
| public void testGetBooleanProperty() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name = "booleanProperty"; |
| msg.setBooleanProperty(name, true); |
| assertTrue(msg.getBooleanProperty(name)); |
| } |
| |
| public void testGetByteProperty() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name = "byteProperty"; |
| msg.setByteProperty(name, (byte) 1); |
| assertTrue(msg.getByteProperty(name) == 1); |
| } |
| |
| public void testGetShortProperty() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name = "shortProperty"; |
| msg.setShortProperty(name, (short) 1); |
| assertTrue(msg.getShortProperty(name) == 1); |
| } |
| |
| public void testGetIntProperty() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name = "intProperty"; |
| msg.setIntProperty(name, 1); |
| assertTrue(msg.getIntProperty(name) == 1); |
| } |
| |
| public void testGetLongProperty() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name = "longProperty"; |
| msg.setLongProperty(name, 1); |
| assertTrue(msg.getLongProperty(name) == 1); |
| } |
| |
| public void testGetFloatProperty() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name = "floatProperty"; |
| msg.setFloatProperty(name, 1.3f); |
| assertTrue(msg.getFloatProperty(name) == 1.3f); |
| } |
| |
| public void testGetDoubleProperty() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name = "doubleProperty"; |
| msg.setDoubleProperty(name, 1.3d); |
| assertTrue(msg.getDoubleProperty(name) == 1.3); |
| } |
| |
| public void testGetStringProperty() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name = "stringProperty"; |
| msg.setStringProperty(name, name); |
| assertTrue(msg.getStringProperty(name).equals(name)); |
| } |
| |
| public void testGetObjectProperty() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name = "floatProperty"; |
| msg.setFloatProperty(name, 1.3f); |
| assertTrue(msg.getObjectProperty(name) instanceof Float); |
| assertTrue(((Float) msg.getObjectProperty(name)).floatValue() == 1.3f); |
| } |
| |
| public void testSetJMSDeliveryModeProperty() throws JMSException { |
| ActiveMQMessage message = new ActiveMQMessage(); |
| String propertyName = "JMSDeliveryMode"; |
| |
| // Set as Boolean |
| message.setObjectProperty(propertyName, Boolean.TRUE); |
| assertTrue(message.isPersistent()); |
| message.setObjectProperty(propertyName, Boolean.FALSE); |
| assertFalse(message.isPersistent()); |
| message.setBooleanProperty(propertyName, true); |
| assertTrue(message.isPersistent()); |
| message.setBooleanProperty(propertyName, false); |
| assertFalse(message.isPersistent()); |
| |
| // Set as Integer |
| message.setObjectProperty(propertyName, DeliveryMode.PERSISTENT); |
| assertTrue(message.isPersistent()); |
| message.setObjectProperty(propertyName, DeliveryMode.NON_PERSISTENT); |
| assertFalse(message.isPersistent()); |
| message.setIntProperty(propertyName, DeliveryMode.PERSISTENT); |
| assertTrue(message.isPersistent()); |
| message.setIntProperty(propertyName, DeliveryMode.NON_PERSISTENT); |
| assertFalse(message.isPersistent()); |
| |
| // Set as String |
| message.setObjectProperty(propertyName, "PERSISTENT"); |
| assertTrue(message.isPersistent()); |
| message.setObjectProperty(propertyName, "NON_PERSISTENT"); |
| assertFalse(message.isPersistent()); |
| message.setStringProperty(propertyName, "PERSISTENT"); |
| assertTrue(message.isPersistent()); |
| message.setStringProperty(propertyName, "NON_PERSISTENT"); |
| assertFalse(message.isPersistent()); |
| } |
| |
| @SuppressWarnings("rawtypes") |
| public void testGetPropertyNames() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name1 = "floatProperty"; |
| msg.setFloatProperty(name1, 1.3f); |
| String name2 = "JMSXDeliveryCount"; |
| msg.setIntProperty(name2, 1); |
| String name3 = "JMSRedelivered"; |
| msg.setBooleanProperty(name3, false); |
| boolean found1 = false; |
| boolean found2 = false; |
| boolean found3 = false; |
| for (Enumeration iter = msg.getPropertyNames(); iter.hasMoreElements();) { |
| Object element = iter.nextElement(); |
| found1 |= element.equals(name1); |
| found2 |= element.equals(name2); |
| found3 |= element.equals(name3); |
| } |
| assertTrue("prop name1 found", found1); |
| // spec compliance, only non JMS (and JMSX) props returned |
| assertFalse("prop name2 not found", found2); |
| assertFalse("prop name4 not found", found3); |
| } |
| |
| @SuppressWarnings("rawtypes") |
| public void testGetAllPropertyNames() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name1 = "floatProperty"; |
| msg.setFloatProperty(name1, 1.3f); |
| String name2 = "JMSXDeliveryCount"; |
| msg.setIntProperty(name2, 1); |
| String name3 = "JMSRedelivered"; |
| msg.setBooleanProperty(name3, false); |
| boolean found1 = false; |
| boolean found2 = false; |
| boolean found3 = false; |
| for (Enumeration iter = msg.getAllPropertyNames(); iter.hasMoreElements();) { |
| Object element = iter.nextElement(); |
| found1 |= element.equals(name1); |
| found2 |= element.equals(name2); |
| found3 |= element.equals(name3); |
| } |
| assertTrue("prop name1 found", found1); |
| assertTrue("prop name2 found", found2); |
| assertTrue("prop name4 found", found3); |
| } |
| |
| public void testSetObjectProperty() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String name = "property"; |
| |
| try { |
| msg.setObjectProperty(name, "string"); |
| msg.setObjectProperty(name, Byte.valueOf("1")); |
| msg.setObjectProperty(name, Short.valueOf("1")); |
| msg.setObjectProperty(name, Integer.valueOf("1")); |
| msg.setObjectProperty(name, Long.valueOf("1")); |
| msg.setObjectProperty(name, Float.valueOf("1.1f")); |
| msg.setObjectProperty(name, Double.valueOf("1.1")); |
| msg.setObjectProperty(name, Boolean.TRUE); |
| msg.setObjectProperty(name, null); |
| } catch (MessageFormatException e) { |
| fail("should accept object primitives and String"); |
| } |
| try { |
| msg.setObjectProperty(name, new byte[5]); |
| fail("should accept only object primitives and String"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.setObjectProperty(name, new Object()); |
| fail("should accept only object primitives and String"); |
| } catch (MessageFormatException e) { |
| } |
| } |
| |
| public void testConvertProperties() throws Exception { |
| org.apache.activemq.command.Message msg = new org.apache.activemq.command.Message() { |
| @Override |
| public org.apache.activemq.command.Message copy() { |
| return null; |
| } |
| |
| @Override |
| public void beforeMarshall(WireFormat wireFormat) throws IOException { |
| super.beforeMarshall(wireFormat); |
| } |
| |
| @Override |
| public byte getDataStructureType() { |
| return 0; |
| } |
| |
| @Override |
| public Response visit(CommandVisitor visitor) throws Exception { |
| return null; |
| } |
| |
| @Override |
| public void clearBody() throws JMSException { |
| } |
| |
| @Override |
| public void storeContent() { |
| } |
| |
| @Override |
| public void storeContentAndClear() { |
| |
| } |
| }; |
| |
| msg.setProperty("stringProperty", "string"); |
| msg.setProperty("byteProperty", Byte.valueOf("1")); |
| msg.setProperty("shortProperty", Short.valueOf("1")); |
| msg.setProperty("intProperty", Integer.valueOf("1")); |
| msg.setProperty("longProperty", Long.valueOf("1")); |
| msg.setProperty("floatProperty", Float.valueOf("1.1f")); |
| msg.setProperty("doubleProperty", Double.valueOf("1.1")); |
| msg.setProperty("booleanProperty", Boolean.TRUE); |
| msg.setProperty("nullProperty", null); |
| |
| msg.beforeMarshall(new OpenWireFormat()); |
| |
| Map<String, Object> properties = msg.getProperties(); |
| assertEquals(properties.get("stringProperty"), "string"); |
| assertEquals(((Byte) properties.get("byteProperty")).byteValue(), 1); |
| assertEquals(((Short) properties.get("shortProperty")).shortValue(), 1); |
| assertEquals(((Integer) properties.get("intProperty")).intValue(), 1); |
| assertEquals(((Long) properties.get("longProperty")).longValue(), 1); |
| assertEquals(((Float) properties.get("floatProperty")).floatValue(), 1.1f, 0); |
| assertEquals(((Double) properties.get("doubleProperty")).doubleValue(), 1.1, 0); |
| assertEquals(((Boolean) properties.get("booleanProperty")).booleanValue(), true); |
| assertNull(properties.get("nullProperty")); |
| } |
| |
| public void testSetNullProperty() throws JMSException { |
| Message msg = new ActiveMQMessage(); |
| String name = "cheese"; |
| msg.setStringProperty(name, "Cheddar"); |
| assertEquals("Cheddar", msg.getStringProperty(name)); |
| |
| msg.setStringProperty(name, null); |
| assertEquals(null, msg.getStringProperty(name)); |
| } |
| |
| public void testSetNullPropertyName() throws JMSException { |
| Message msg = new ActiveMQMessage(); |
| |
| try { |
| msg.setStringProperty(null, "Cheese"); |
| fail("Should have thrown exception"); |
| } catch (IllegalArgumentException e) { |
| LOG.info("Worked, caught: " + e); |
| } |
| } |
| |
| public void testSetEmptyPropertyName() throws JMSException { |
| Message msg = new ActiveMQMessage(); |
| |
| try { |
| msg.setStringProperty("", "Cheese"); |
| fail("Should have thrown exception"); |
| } catch (IllegalArgumentException e) { |
| LOG.info("Worked, caught: " + e); |
| } |
| } |
| |
| public void testGetAndSetJMSXDeliveryCount() throws JMSException { |
| Message msg = new ActiveMQMessage(); |
| msg.setIntProperty("JMSXDeliveryCount", 1); |
| int count = msg.getIntProperty("JMSXDeliveryCount"); |
| assertTrue("expected delivery count = 1 - got: " + count, count == 1); |
| } |
| |
| public void testClearBody() throws JMSException { |
| ActiveMQBytesMessage message = new ActiveMQBytesMessage(); |
| message.clearBody(); |
| assertFalse(message.isReadOnlyBody()); |
| assertNull(message.getContent()); |
| } |
| |
| public void testBooleanPropertyConversion() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String propertyName = "property"; |
| msg.setBooleanProperty(propertyName, true); |
| |
| assertEquals(((Boolean) msg.getObjectProperty(propertyName)).booleanValue(), true); |
| assertTrue(msg.getBooleanProperty(propertyName)); |
| assertEquals(msg.getStringProperty(propertyName), "true"); |
| try { |
| msg.getByteProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getShortProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getIntProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getLongProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getFloatProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getDoubleProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| } |
| |
| public void testBytePropertyConversion() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String propertyName = "property"; |
| msg.setByteProperty(propertyName, (byte) 1); |
| |
| assertEquals(((Byte) msg.getObjectProperty(propertyName)).byteValue(), 1); |
| assertEquals(msg.getByteProperty(propertyName), 1); |
| assertEquals(msg.getShortProperty(propertyName), 1); |
| assertEquals(msg.getIntProperty(propertyName), 1); |
| assertEquals(msg.getLongProperty(propertyName), 1); |
| assertEquals(msg.getStringProperty(propertyName), "1"); |
| try { |
| msg.getBooleanProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getFloatProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getDoubleProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| } |
| |
| public void testShortPropertyConversion() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String propertyName = "property"; |
| msg.setShortProperty(propertyName, (short) 1); |
| |
| assertEquals(((Short) msg.getObjectProperty(propertyName)).shortValue(), 1); |
| assertEquals(msg.getShortProperty(propertyName), 1); |
| assertEquals(msg.getIntProperty(propertyName), 1); |
| assertEquals(msg.getLongProperty(propertyName), 1); |
| assertEquals(msg.getStringProperty(propertyName), "1"); |
| try { |
| msg.getBooleanProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getByteProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getFloatProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getDoubleProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| } |
| |
| public void testIntPropertyConversion() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String propertyName = "property"; |
| msg.setIntProperty(propertyName, 1); |
| |
| assertEquals(((Integer) msg.getObjectProperty(propertyName)).intValue(), 1); |
| assertEquals(msg.getIntProperty(propertyName), 1); |
| assertEquals(msg.getLongProperty(propertyName), 1); |
| assertEquals(msg.getStringProperty(propertyName), "1"); |
| try { |
| msg.getBooleanProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getByteProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getShortProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getFloatProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getDoubleProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| } |
| |
| public void testLongPropertyConversion() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String propertyName = "property"; |
| msg.setLongProperty(propertyName, 1); |
| |
| assertEquals(((Long) msg.getObjectProperty(propertyName)).longValue(), 1); |
| assertEquals(msg.getLongProperty(propertyName), 1); |
| assertEquals(msg.getStringProperty(propertyName), "1"); |
| try { |
| msg.getBooleanProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getByteProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getShortProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getIntProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getFloatProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getDoubleProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| } |
| |
| public void testFloatPropertyConversion() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String propertyName = "property"; |
| msg.setFloatProperty(propertyName, (float) 1.5); |
| assertEquals(((Float) msg.getObjectProperty(propertyName)).floatValue(), 1.5, 0); |
| assertEquals(msg.getFloatProperty(propertyName), 1.5, 0); |
| assertEquals(msg.getDoubleProperty(propertyName), 1.5, 0); |
| assertEquals(msg.getStringProperty(propertyName), "1.5"); |
| try { |
| msg.getBooleanProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getByteProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getShortProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getIntProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getLongProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| } |
| |
| public void testDoublePropertyConversion() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String propertyName = "property"; |
| msg.setDoubleProperty(propertyName, 1.5); |
| assertEquals(((Double) msg.getObjectProperty(propertyName)).doubleValue(), 1.5, 0); |
| assertEquals(msg.getDoubleProperty(propertyName), 1.5, 0); |
| assertEquals(msg.getStringProperty(propertyName), "1.5"); |
| try { |
| msg.getBooleanProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getByteProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getShortProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getIntProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getLongProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getFloatProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| } |
| |
| public void testStringPropertyConversion() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String propertyName = "property"; |
| String stringValue = "true"; |
| msg.setStringProperty(propertyName, stringValue); |
| assertEquals(msg.getStringProperty(propertyName), stringValue); |
| assertEquals((String) msg.getObjectProperty(propertyName), stringValue); |
| assertEquals(msg.getBooleanProperty(propertyName), true); |
| |
| stringValue = "1"; |
| msg.setStringProperty(propertyName, stringValue); |
| assertEquals(msg.getByteProperty(propertyName), 1); |
| assertEquals(msg.getShortProperty(propertyName), 1); |
| assertEquals(msg.getIntProperty(propertyName), 1); |
| assertEquals(msg.getLongProperty(propertyName), 1); |
| |
| stringValue = "1.5"; |
| msg.setStringProperty(propertyName, stringValue); |
| assertEquals(msg.getFloatProperty(propertyName), 1.5, 0); |
| assertEquals(msg.getDoubleProperty(propertyName), 1.5, 0); |
| |
| stringValue = "bad"; |
| msg.setStringProperty(propertyName, stringValue); |
| try { |
| msg.getByteProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (NumberFormatException e) { |
| } |
| try { |
| msg.getShortProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (NumberFormatException e) { |
| } |
| try { |
| msg.getIntProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (NumberFormatException e) { |
| } |
| try { |
| msg.getLongProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (NumberFormatException e) { |
| } |
| try { |
| msg.getFloatProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (NumberFormatException e) { |
| } |
| try { |
| msg.getDoubleProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (NumberFormatException e) { |
| } |
| assertFalse(msg.getBooleanProperty(propertyName)); |
| } |
| |
| public void testObjectPropertyConversion() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String propertyName = "property"; |
| Object obj = new Object(); |
| try { |
| ((org.apache.activemq.command.Message) msg).setProperty(propertyName, obj); // bypass |
| // object |
| // check |
| } catch (IOException e) { |
| } |
| try { |
| msg.getStringProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getBooleanProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getByteProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getShortProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getIntProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getLongProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getFloatProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| try { |
| msg.getDoubleProperty(propertyName); |
| fail("Should have thrown exception"); |
| } catch (MessageFormatException e) { |
| } |
| |
| } |
| |
| public void testReadOnlyProperties() throws JMSException { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| String propertyName = "property"; |
| msg.setReadOnlyProperties(true); |
| |
| try { |
| msg.setObjectProperty(propertyName, new Object()); |
| fail("Should have thrown exception"); |
| } catch (MessageNotWriteableException e) { |
| } |
| try { |
| msg.setStringProperty(propertyName, "test"); |
| fail("Should have thrown exception"); |
| } catch (MessageNotWriteableException e) { |
| } |
| try { |
| msg.setBooleanProperty(propertyName, true); |
| fail("Should have thrown exception"); |
| } catch (MessageNotWriteableException e) { |
| } |
| try { |
| msg.setByteProperty(propertyName, (byte) 1); |
| fail("Should have thrown exception"); |
| } catch (MessageNotWriteableException e) { |
| } |
| try { |
| msg.setShortProperty(propertyName, (short) 1); |
| fail("Should have thrown exception"); |
| } catch (MessageNotWriteableException e) { |
| } |
| try { |
| msg.setIntProperty(propertyName, 1); |
| fail("Should have thrown exception"); |
| } catch (MessageNotWriteableException e) { |
| } |
| try { |
| msg.setLongProperty(propertyName, 1); |
| fail("Should have thrown exception"); |
| } catch (MessageNotWriteableException e) { |
| } |
| try { |
| msg.setFloatProperty(propertyName, (float) 1.5); |
| fail("Should have thrown exception"); |
| } catch (MessageNotWriteableException e) { |
| } |
| try { |
| msg.setDoubleProperty(propertyName, 1.5); |
| fail("Should have thrown exception"); |
| } catch (MessageNotWriteableException e) { |
| } |
| } |
| |
| public void testIsExpired() { |
| ActiveMQMessage msg = new ActiveMQMessage(); |
| msg.setJMSExpiration(System.currentTimeMillis() - 1); |
| assertTrue(msg.isExpired()); |
| msg.setJMSExpiration(System.currentTimeMillis() + 10000); |
| assertFalse(msg.isExpired()); |
| } |
| } |
