/*
 * 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.artemis.jms.tests.message;

import javax.jms.Connection;
import javax.jms.JMSContext;
import javax.jms.JMSException;
import javax.jms.JMSProducer;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageFormatException;
import javax.jms.MessageFormatRuntimeException;
import javax.jms.MessageProducer;
import javax.jms.Session;

import org.apache.activemq.artemis.api.core.SimpleString;
import org.apache.activemq.artemis.jms.tests.ActiveMQServerTestCase;
import org.apache.activemq.artemis.jms.tests.util.ProxyAssertSupport;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

/**
 * Testing of message property conversion. See {@link javax.jms.Message} for details
 */
public class MessagePropertyConversionTest extends ActiveMQServerTestCase {
   // Attributes ----------------------------------------------------

   private Connection producerConnection, consumerConnection;

   private Session queueProducerSession, queueConsumerSession;

   private MessageProducer queueProducer;

   private MessageConsumer queueConsumer;

   // Constructors --------------------------------------------------

   // Public --------------------------------------------------------

   @Override
   @Before
   public void setUp() throws Exception {
      super.setUp();

      producerConnection = getConnectionFactory().createConnection();
      consumerConnection = getConnectionFactory().createConnection();

      queueProducerSession = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      queueConsumerSession = consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);

      queueProducer = queueProducerSession.createProducer(queue1);
      queueConsumer = queueConsumerSession.createConsumer(queue1);

      consumerConnection.start();
   }

   @Override
   @After
   public void tearDown() throws Exception {
      producerConnection.close();
      consumerConnection.close();
   }

   @Test
   public void testObjectString() throws Exception {
      JMSContext ctx = addContext(getConnectionFactory().createContext());

      JMSProducer producer = ctx.createProducer();

      producer.setProperty("astring", "test");

      Object prop = producer.getObjectProperty("astring");

      ProxyAssertSupport.assertNotNull(prop);

      ProxyAssertSupport.assertTrue(prop instanceof String);
   }

   @Test
   public void msgNullPropertyConversionTests() throws Exception {
      JMSContext ctx = addContext(getConnectionFactory().createContext());

      JMSProducer producer = ctx.createProducer();

      try {
         producer.setProperty(null, true);
         ProxyAssertSupport.fail("expected IllegalArgumentException");
      } catch (IllegalArgumentException e) {
         //pass
      }
      try {
         producer.setProperty(null, "string");
         ProxyAssertSupport.fail("expected IllegalArgumentException");
      } catch (IllegalArgumentException e) {
         //pass
      }
      try {
         producer.setProperty(null, 1);
         ProxyAssertSupport.fail("expected IllegalArgumentException");
      } catch (IllegalArgumentException e) {
         //pass
      }
      try {
         producer.setProperty(null, 1.0);
         ProxyAssertSupport.fail("expected IllegalArgumentException");
      } catch (IllegalArgumentException e) {
         //pass
      }
      try {
         producer.setProperty(null, 1L);
         ProxyAssertSupport.fail("expected IllegalArgumentException");
      } catch (IllegalArgumentException e) {
         //pass
      }
      try {
         producer.setProperty(null, 1.10f);
         ProxyAssertSupport.fail("expected IllegalArgumentException");
      } catch (IllegalArgumentException e) {
         //pass
      }
      try {
         producer.setProperty(null, (byte) 1);
         ProxyAssertSupport.fail("expected IllegalArgumentException");
      } catch (IllegalArgumentException e) {
         //pass
      }
      try {
         producer.setProperty(null, (short) 1);
         ProxyAssertSupport.fail("expected IllegalArgumentException");
      } catch (IllegalArgumentException e) {
         //pass
      }
      try {
         producer.setProperty(null, new SimpleString("foo"));
         ProxyAssertSupport.fail("expected IllegalArgumentException");
      } catch (IllegalArgumentException e) {
         //pass
      }
   }

   @Test
   public void msgPropertyConversionTests() throws Exception {
      JMSContext ctx = addContext(getConnectionFactory().createContext());

      JMSProducer producer = ctx.createProducer();

      boolean bool = true;
      byte bValue = 1;
      short nShort = 2;
      int nInt = 3;
      long nLong = 4;
      float nFloat = 5;
      double nDouble = 6;

      producer.setProperty("aboolean", bool);
      producer.setProperty("abyte", bValue);
      producer.setProperty("ashort", nShort);
      producer.setProperty("anint", nInt);
      producer.setProperty("afloat", nFloat);
      producer.setProperty("adouble", nDouble);
      producer.setProperty("astring", "test");
      producer.setProperty("along", nLong);
      producer.setProperty("true", "true");
      producer.setProperty("false", "false");
      producer.setProperty("anotherString", "1");
      String myBool = producer.getStringProperty("aboolean");

      if (Boolean.valueOf(myBool).booleanValue() != bool) {
         ProxyAssertSupport.fail("conversion from boolean to string failed");
      }

      try {
         producer.getByteProperty("aboolean");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("did not catch expected Exception -- boolean to byte");
      }

      try {
         producer.getShortProperty("aboolean");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getIntProperty("aboolean");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getLongProperty("aboolean");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getFloatProperty("aboolean");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      // invalid - boolean to double
      try {
         producer.getDoubleProperty("aboolean");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      String myByte = producer.getStringProperty("abyte");

      if (Byte.valueOf(myByte).byteValue() != bValue) {
         ProxyAssertSupport.fail("conversion from byte to string failed");
      }

      if (producer.getShortProperty("abyte") != bValue) {
         ProxyAssertSupport.fail("conversion from byte to short failed");
      }

      if (producer.getIntProperty("abyte") != bValue) {
         ProxyAssertSupport.fail("conversion from byte to int failed");
      }

      if (producer.getLongProperty("abyte") != bValue) {
         ProxyAssertSupport.fail("conversion from byte to long failed");
      }

      try {
         producer.getBooleanProperty("abyte");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");

      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getFloatProperty("abyte");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);

      }

      try {
         producer.getDoubleProperty("abyte");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");

      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      String myshort = producer.getStringProperty("ashort");

      if (Short.valueOf(myshort).shortValue() != nShort) {
         ProxyAssertSupport.fail("conversion from short to string failed");
      }

      if (producer.getIntProperty("ashort") != nShort) {
         ProxyAssertSupport.fail("conversion from short to int failed");
      }

      if (producer.getLongProperty("ashort") != nShort) {
         ProxyAssertSupport.fail("conversion from short to long failed");
      }

      try {
         producer.getBooleanProperty("ashort");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");

      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);

      }

      try {
         producer.getByteProperty("ashort");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");

      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);

      }

      try {
         producer.getFloatProperty("ashort");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");

      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getDoubleProperty("ashort");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");

      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);

      }

      if (Integer.valueOf(producer.getStringProperty("anint")).intValue() != nInt) {
         ProxyAssertSupport.fail("conversion from int to string failed");
      }

      if (producer.getLongProperty("anint") != nInt) {
         ProxyAssertSupport.fail("conversion from int to long failed");
      }

      try {
         producer.getBooleanProperty("anint");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");

      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getByteProperty("anint");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");

      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getShortProperty("anint");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");

      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getFloatProperty("anint");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getDoubleProperty("anint");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      if (Long.valueOf(producer.getStringProperty("along")).longValue() != nLong) {
         ProxyAssertSupport.fail("conversion from long to string failed");
      }

      try {
         producer.getBooleanProperty("along");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getByteProperty("along");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getShortProperty("along");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getIntProperty("along");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getFloatProperty("along");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getDoubleProperty("along");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      if (Float.valueOf(producer.getStringProperty("afloat")).floatValue() != nFloat) {
         ProxyAssertSupport.fail("conversion from float to string failed");
      }

      if (producer.getDoubleProperty("afloat") != nFloat) {
         ProxyAssertSupport.fail("conversion from long to double failed");
      }

      try {
         producer.getBooleanProperty("afloat");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getByteProperty("afloat");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getShortProperty("afloat");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getIntProperty("afloat");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getLongProperty("afloat");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");

      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      if (Double.valueOf(producer.getStringProperty("adouble")).doubleValue() != nDouble) {
         ProxyAssertSupport.fail("conversion from double to string failed");
      }

      try {
         producer.getBooleanProperty("adouble");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getByteProperty("adouble");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getShortProperty("adouble");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getIntProperty("adouble");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      try {
         producer.getLongProperty("adouble");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      // invalid - double to float
      try {
         producer.getFloatProperty("adouble");
         ProxyAssertSupport.fail("MessageFormatRuntimeException expected");
      } catch (MessageFormatRuntimeException me) {
         //pass
      } catch (Exception ee) {
         ProxyAssertSupport.fail("Caught unexpected exception: " + ee);
      }

      if ((producer.getBooleanProperty("true")) != true) {
         ProxyAssertSupport.fail("conversion from string to boolean - expect true  - failed");
      }
      if ((producer.getBooleanProperty("false")) != false) {
         ProxyAssertSupport.fail("conversion from string to boolean expect false - failed");
      }

      if (producer.getByteProperty("anotherString") != 1) {
         ProxyAssertSupport.fail("conversion from string to byte failed");
      }

      if (producer.getShortProperty("anotherString") != 1) {
         ProxyAssertSupport.fail("conversion from string to short failed");
      }

      if (producer.getIntProperty("anotherString") != 1) {
         ProxyAssertSupport.fail("conversion from string to int failed");
      }

      if (producer.getLongProperty("anotherString") != 1) {
         ProxyAssertSupport.fail("conversion from string to long failed");
      }

      if (producer.getFloatProperty("anotherString") != 1) {
         ProxyAssertSupport.fail("conversion from string to float failed");
      }

      if (producer.getDoubleProperty("anotherString") != 1) {
         ProxyAssertSupport.fail("conversion from string to double failed");
      }
   }

   @Test
   public void testResetToNull() throws JMSException {
      Message m1 = queueProducerSession.createMessage();
      m1.setStringProperty("key", "fish");
      m1.setBooleanProperty("key", true);
      m1.setStringProperty("key2", "fish");
      m1.setStringProperty("key2", null);
      m1.setStringProperty("key3", "fish");
      m1.setObjectProperty("key3", null);

      queueProducer.send(m1);
      Message m2 = queueConsumer.receive(1000);
      Assert.assertEquals("key should be true", m2.getObjectProperty("key"), Boolean.TRUE);
      Assert.assertEquals("key2 should be null", null, m2.getObjectProperty("key2"));
      Assert.assertEquals("key3 should be null", null, m2.getObjectProperty("key3"));
   }

   @Test
   public void testBooleanConversion() throws Exception {
      Message m1 = queueProducerSession.createMessage();

      boolean myBool = true;
      m1.setBooleanProperty("myBool", myBool);

      queueProducer.send(m1);
      Message m2 = queueConsumer.receive(2000);

      // Boolean property can be read as boolean and String but not anything
      // else

      ProxyAssertSupport.assertEquals(myBool, m2.getBooleanProperty("myBool"));
      ProxyAssertSupport.assertEquals(String.valueOf(myBool), m2.getStringProperty("myBool"));

      try {
         m2.getByteProperty("myBool");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getShortProperty("myBool");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getIntProperty("myBool");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getLongProperty("myBool");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getFloatProperty("myBool");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getDoubleProperty("myBool");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }
   }

   @Test
   public void testByteConversion() throws Exception {
      Message m1 = queueProducerSession.createMessage();

      byte myByte = 13;
      m1.setByteProperty("myByte", myByte);

      queueProducer.send(m1);
      Message m2 = queueConsumer.receive(2000);

      // Byte property can be read as byte, short, int, long or String

      ProxyAssertSupport.assertEquals(myByte, m2.getByteProperty("myByte"));
      ProxyAssertSupport.assertEquals(myByte, m2.getShortProperty("myByte"));
      ProxyAssertSupport.assertEquals(myByte, m2.getIntProperty("myByte"));
      ProxyAssertSupport.assertEquals(myByte, m2.getLongProperty("myByte"));
      ProxyAssertSupport.assertEquals(String.valueOf(myByte), m2.getStringProperty("myByte"));

      try {
         m2.getBooleanProperty("myByte");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getFloatProperty("myByte");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getDoubleProperty("myByte");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }
   }

   @Test
   public void testShortConversion() throws Exception {
      Message m1 = queueProducerSession.createMessage();

      short myShort = 15321;
      m1.setShortProperty("myShort", myShort);

      queueProducer.send(m1);
      Message m2 = queueConsumer.receive(2000);

      // Short property can be read as short, int, long or String

      ProxyAssertSupport.assertEquals(myShort, m2.getShortProperty("myShort"));
      ProxyAssertSupport.assertEquals(myShort, m2.getIntProperty("myShort"));
      ProxyAssertSupport.assertEquals(myShort, m2.getLongProperty("myShort"));
      ProxyAssertSupport.assertEquals(String.valueOf(myShort), m2.getStringProperty("myShort"));

      try {
         m2.getByteProperty("myShort");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getBooleanProperty("myShort");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getFloatProperty("myShort");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getDoubleProperty("myShort");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }
   }

   @Test
   public void testIntConversion() throws Exception {
      Message m1 = queueProducerSession.createMessage();

      int myInt = 0x71ab6c80;
      m1.setIntProperty("myInt", myInt);

      queueProducer.send(m1);
      Message m2 = queueConsumer.receive(2000);

      // Int property can be read as int, long or String

      ProxyAssertSupport.assertEquals(myInt, m2.getIntProperty("myInt"));
      ProxyAssertSupport.assertEquals(myInt, m2.getLongProperty("myInt"));
      ProxyAssertSupport.assertEquals(String.valueOf(myInt), m2.getStringProperty("myInt"));

      try {
         m2.getShortProperty("myInt");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getByteProperty("myInt");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getBooleanProperty("myInt");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getFloatProperty("myInt");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getDoubleProperty("myInt");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }
   }

   @Test
   public void testLongConversion() throws Exception {
      Message m1 = queueProducerSession.createMessage();

      long myLong = 0x20bf1e3fb6fa31dfL;
      m1.setLongProperty("myLong", myLong);

      queueProducer.send(m1);
      Message m2 = queueConsumer.receive(2000);

      // Long property can be read as long and String

      ProxyAssertSupport.assertEquals(myLong, m2.getLongProperty("myLong"));
      ProxyAssertSupport.assertEquals(String.valueOf(myLong), m2.getStringProperty("myLong"));

      try {
         m2.getIntProperty("myLong");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getShortProperty("myLong");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getByteProperty("myLong");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getBooleanProperty("myLong");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getFloatProperty("myLong");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getDoubleProperty("myLong");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }
   }

   @Test
   public void testFloatConversion() throws Exception {
      Message m1 = queueProducerSession.createMessage();

      float myFloat = Float.MAX_VALUE - 23465;
      m1.setFloatProperty("myFloat", myFloat);

      queueProducer.send(m1);
      Message m2 = queueConsumer.receive(2000);

      // Float property can be read as float, double or String

      ProxyAssertSupport.assertEquals(myFloat, m2.getFloatProperty("myFloat"), 0);
      ProxyAssertSupport.assertEquals(String.valueOf(myFloat), m2.getStringProperty("myFloat"));
      ProxyAssertSupport.assertEquals(myFloat, m2.getDoubleProperty("myFloat"), 0);

      try {
         m2.getIntProperty("myFloat");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getShortProperty("myFloat");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getLongProperty("myFloat");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getByteProperty("myFloat");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getBooleanProperty("myFloat");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }
   }

   @Test
   public void testDoubleConversion() throws Exception {
      Message m1 = queueProducerSession.createMessage();

      double myDouble = Double.MAX_VALUE - 72387633;
      m1.setDoubleProperty("myDouble", myDouble);

      queueProducer.send(m1);
      Message m2 = queueConsumer.receive(2000);

      // Double property can be read as double and String

      ProxyAssertSupport.assertEquals(myDouble, m2.getDoubleProperty("myDouble"), 0);
      ProxyAssertSupport.assertEquals(String.valueOf(myDouble), m2.getStringProperty("myDouble"));

      try {
         m2.getFloatProperty("myDouble");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getIntProperty("myDouble");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getShortProperty("myDouble");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getByteProperty("myDouble");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getBooleanProperty("myDouble");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }

      try {
         m2.getFloatProperty("myDouble");
         ProxyAssertSupport.fail();
      } catch (MessageFormatException e) {
      }
   }

   @Test
   public void testStringConversion() throws Exception {
      Message m1 = queueProducerSession.createMessage();

      boolean myBool = true;
      byte myByte = 13;
      short myShort = 15321;
      int myInt = 0x71ab6c80;
      long myLong = 0x20bf1e3fb6fa31dfL;
      float myFloat = Float.MAX_VALUE - 23465;
      double myDouble = Double.MAX_VALUE - 72387633;
      String myString = "abcdef&^*&!^ghijkl";

      m1.setStringProperty("myString", myString);

      queueProducer.send(m1);
      Message m2 = queueConsumer.receive(2000);

      ProxyAssertSupport.assertEquals(myString, m2.getStringProperty("myString"));

      // Test String -> Numeric and bool conversions.

      // String property can be read as boolean, byte, short,
      // int, long, float, double and String, with the possibility to
      // throw a runtime exception if the primitive's valueOf method does not
      // accept the String as a valid representation of the primitive

      Message m3 = queueProducerSession.createMessage();

      m3.setStringProperty("myBool", String.valueOf(myBool));
      m3.setStringProperty("myByte", String.valueOf(myByte));
      m3.setStringProperty("myShort", String.valueOf(myShort));
      m3.setStringProperty("myInt", String.valueOf(myInt));
      m3.setStringProperty("myLong", String.valueOf(myLong));
      m3.setStringProperty("myFloat", String.valueOf(myFloat));
      m3.setStringProperty("myDouble", String.valueOf(myDouble));
      m3.setStringProperty("myIllegal", "xyz123");

      queueProducer.send(m3);

      Message m4 = queueConsumer.receive(2000);

      ProxyAssertSupport.assertEquals(myBool, m4.getBooleanProperty("myBool"));
      ProxyAssertSupport.assertEquals(myByte, m4.getByteProperty("myByte"));
      ProxyAssertSupport.assertEquals(myShort, m4.getShortProperty("myShort"));
      ProxyAssertSupport.assertEquals(myInt, m4.getIntProperty("myInt"));
      ProxyAssertSupport.assertEquals(myLong, m4.getLongProperty("myLong"));
      ProxyAssertSupport.assertEquals(myFloat, m4.getFloatProperty("myFloat"), 0);
      ProxyAssertSupport.assertEquals(myDouble, m4.getDoubleProperty("myDouble"), 0);

      ProxyAssertSupport.assertEquals(false, m4.getBooleanProperty("myIllegal"));

      try {
         m4.getByteProperty("myIllegal");
         ProxyAssertSupport.fail();
      } catch (NumberFormatException e) {
      }
      try {
         m4.getShortProperty("myIllegal");
         ProxyAssertSupport.fail();
      } catch (NumberFormatException e) {
      }
      try {
         m4.getIntProperty("myIllegal");
         ProxyAssertSupport.fail();
      } catch (NumberFormatException e) {
      }
      try {
         m4.getLongProperty("myIllegal");
         ProxyAssertSupport.fail();
      } catch (NumberFormatException e) {
      }
      try {
         m4.getFloatProperty("myIllegal");
         ProxyAssertSupport.fail();
      } catch (NumberFormatException e) {
      }
      try {
         m4.getDoubleProperty("myIllegal");
         ProxyAssertSupport.fail();
      } catch (NumberFormatException e) {
      }
   }

   @Test
   public void testJMSXDeliveryCountConversion() throws Exception {
      Message m1 = queueProducerSession.createMessage();
      queueProducer.send(m1);

      Message m2 = queueConsumer.receive(2000);

      int count = m2.getIntProperty("JMSXDeliveryCount");
      ProxyAssertSupport.assertEquals(String.valueOf(count), m2.getStringProperty("JMSXDeliveryCount"));
      ProxyAssertSupport.assertEquals(count, m2.getLongProperty("JMSXDeliveryCount"));
   }
}
