@Test
public void testReceptionOfMultipleMessages() {
    WeldContainer container = prepare();

    RawMessageConsumerBean bean = container.select(RawMessageConsumerBean.class).get();
    assertThat(bean.messages()).isEmpty();

    Queue q = jms.createQueue("queue-one");
    JMSProducer producer = jms.createProducer();

    new Thread(() -> {
        for (int i = 0; i < 50; i++) {
            TextMessage message = jms.createTextMessage(Integer.toString(i));
            producer.send(q, message);
        }
    }).start();

    await().until(() -> bean.messages().size() == 50);
}
 

@Test(timeout = 20000)
public void testJMSProducerHasDefaultConfiguration() throws Exception {
    try (TestAmqpPeer testPeer = new TestAmqpPeer();) {
        JMSContext context = testFixture.createJMSContext(testPeer, SERVER_ANONYMOUS_RELAY);
        testPeer.expectBegin();
        testPeer.expectSenderAttach();

        JMSProducer producer = context.createProducer();
        assertNotNull(producer);

        assertEquals(Message.DEFAULT_DELIVERY_DELAY, producer.getDeliveryDelay());
        assertEquals(Message.DEFAULT_DELIVERY_MODE, producer.getDeliveryMode());
        assertEquals(Message.DEFAULT_PRIORITY, producer.getPriority());
        assertEquals(Message.DEFAULT_TIME_TO_LIVE, producer.getTimeToLive());

        testPeer.expectEnd();
        testPeer.expectClose();
        context.close();

        testPeer.waitForAllHandlersToComplete(1000);
    }
}
 

@Test
public void testBytesBodyIsApplied() throws JMSException {
    JMSProducer producer = context.createProducer();

    final byte[] bodyValue = new byte[] { 0, 1, 2, 3, 4 };

    producer.send(JMS_DESTINATION, bodyValue);
    JmsOutboundMessageDispatch envelope = remotePeer.getLastReceivedMessage();
    assertNotNull(envelope);
    JmsMessage message = envelope.getMessage();

    byte[] payload = message.getBody(byte[].class);
    assertNotNull(payload);
    assertEquals(bodyValue.length, payload.length);

    for (int i = 0; i < payload.length; ++i) {
        assertEquals(bodyValue[i], payload[i]);
    }
}
 

@Test(timeout = 20000)
public void testOnlyOneProducerCreatedInSingleContext() throws Exception {
    try (TestAmqpPeer testPeer = new TestAmqpPeer();) {
        JMSContext context = testFixture.createJMSContext(testPeer, SERVER_ANONYMOUS_RELAY);
        assertEquals(JMSContext.AUTO_ACKNOWLEDGE, context.getSessionMode());
        testPeer.expectBegin();
        testPeer.expectSenderAttach();

        // One producer created should send an attach.
        JMSProducer producer1 = context.createProducer();
        assertNotNull(producer1);

        // An additional one should not result in an attach
        JMSProducer producer2 = context.createProducer();
        assertNotNull(producer2);

        testPeer.expectEnd();
        testPeer.expectClose();
        context.close();

        testPeer.waitForAllHandlersToComplete(1000);
    }
}
 

@Override
public JMSProducer createProducer() {
    try {
        if (sharedProducer == null) {
            synchronized (this) {
                if (sharedProducer == null) {
                    sharedProducer = (JmsMessageProducer) getSession().createProducer(null);
                }
            }
        }

        return new JmsProducer(getSession(), sharedProducer);
    } catch (JMSException jmse) {
        throw JmsExceptionSupport.createRuntimeException(jmse);
    }
}
 

@Test
public void testSimpleSendNoXAJMSContext() throws Exception {
   Queue q = ActiveMQJMSClient.createQueue(MDBQUEUE);

   try (ClientSessionFactory sf = locator.createSessionFactory();
        ClientSession session = sf.createSession();
        ClientConsumer consVerify = session.createConsumer(MDBQUEUE);
        JMSContext jmsctx = qraConnectionFactory.createContext();
   ) {
      session.start();
      // These next 4 lines could be written in a single line however it makes difficult for debugging
      JMSProducer producer = jmsctx.createProducer();
      producer.setProperty("strvalue", "hello");
      TextMessage msgsend = jmsctx.createTextMessage("hello");
      producer.send(q, msgsend);

      ClientMessage msg = consVerify.receive(1000);
      assertNotNull(msg);
      assertEquals("hello", msg.getStringProperty("strvalue"));
   }
}
 

@Test
public void testRuntimeExceptionFromSendMapBody() throws JMSException {
    JMSProducer producer = context.createProducer();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            throw new IllegalStateException("Send Failed");
        }
    });

    try {
        producer.send(context.createTemporaryQueue(), Collections.<String, Object>emptyMap());
        fail("Should have thrown an exception");
    } catch (IllegalStateRuntimeException isre) {}
}
 

@Test
public void testMapBodyIsApplied() throws JMSException {
    JMSProducer producer = context.createProducer();

    final Map<String, Object> bodyValue = new HashMap<String, Object>();

    bodyValue.put("Value-1", "First");
    bodyValue.put("Value-2", "Second");

    final AtomicBoolean bodyValidated = new AtomicBoolean();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            assertEquals(bodyValue, message.getBody(Map.class));
            bodyValidated.set(true);
        }
    });

    producer.send(JMS_DESTINATION, bodyValue);
    assertTrue(bodyValidated.get());
}
 

@Test
public void testInvalidDestination() {
   JMSProducer producer = context.createProducer();
   Message msg = context.createMessage();
   try {
      producer.send((Destination) null, msg);
      Assert.fail("null Destination");
   } catch (InvalidDestinationRuntimeException expected) {
      // no-op
   }
}
 

@Test
public void testWithLong() {
    WeldContainer container = prepare();

    RawMessageConsumerBean bean = container.select(RawMessageConsumerBean.class).get();
    assertThat(bean.messages()).isEmpty();

    Queue q = jms.createQueue("queue-one");
    JMSProducer producer = jms.createProducer();
    producer.send(q, 10000L);

    await().until(() -> bean.messages().size() == 1);
    IncomingJmsMessage<?> incomingJmsMessage = bean.messages().get(0);
    assertThat(incomingJmsMessage.getPayload()).isEqualTo(10000L);
}
 

@Test
public void illegalStateRuntimeExceptionTests() throws Exception {
   JMSProducer producer = context.createProducer();
   JMSConsumer consumer = context.createConsumer(queue1);
   TextMessage expTextMessage = context.createTextMessage("Call commit");
   CountDownLatch latch = new CountDownLatch(1);
   JMSCOntextStopCompletionListener listener = new JMSCOntextStopCompletionListener(context, latch);
   producer.setAsync(listener);
   producer.send(queue1, expTextMessage);
   assertTrue(latch.await(5, TimeUnit.SECONDS));
   assertNull(listener.ex);
}
 

@Override
public JMSProducer setPriority(int priority) {
    if (priority < 0 || priority > 9) {
        throw new JMSRuntimeException(String.format("Priority value given {%d} is out of range (0..9)", priority));
    }

    this.priority = priority;
    return this;
}
 

@Test
public void testDeliveryMode() {
    JMSProducer producer = context.createProducer();

    producer.setDeliveryMode(DeliveryMode.PERSISTENT);
    assertEquals(DeliveryMode.PERSISTENT, producer.getDeliveryMode());
    producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
    assertEquals(DeliveryMode.NON_PERSISTENT, producer.getDeliveryMode());
}
 

@Override
public JMSProducer send(Destination destination, Map<String, Object> body) {
    try {
        MapMessage message = session.createMapMessage();
        for (Map.Entry<String, Object> entry : body.entrySet()) {
            message.setObject(entry.getKey(), entry.getValue());
        }

        doSend(destination, message);
    } catch (JMSException jmse) {
        throw JMSExceptionSupport.createRuntimeException(jmse);
    }

    return this;
}
 

@Test
public void testSetBytePropetryWithBadPropetyName() {
    JMSProducer producer = context.createProducer();

    try {
        producer.setProperty(BAD_PROPERTY_NAME, (byte) 1);
        fail("Should not accept invalid property name");
    } catch (IllegalArgumentException iae) {}
}
 

@Override
public JMSProducer setDeliveryMode(int deliveryMode) {
    switch (deliveryMode) {
        case DeliveryMode.PERSISTENT:
        case DeliveryMode.NON_PERSISTENT:
            this.deliveryMode = deliveryMode;
            return this;
        default:
            throw new JMSRuntimeException(String.format("Invalid DeliveryMode specified: %d", deliveryMode));
    }
}
 

@Override
public JMSProducer send(final Destination destination, final Message message) {
    if (message == null) {
        throw new MessageFormatRuntimeException("null message");
    }

    try {
        if (jmsHeaderCorrelationID != null) {
            message.setJMSCorrelationID(jmsHeaderCorrelationID);
        }
        if (jmsHeaderCorrelationIDAsBytes != null && jmsHeaderCorrelationIDAsBytes.length > 0) {
            message.setJMSCorrelationIDAsBytes(jmsHeaderCorrelationIDAsBytes);
        }
        if (jmsHeaderReplyTo != null) {
            message.setJMSReplyTo(jmsHeaderReplyTo);
        }
        if (jmsHeaderType != null) {
            message.setJMSType(jmsHeaderType);
        }

        setProperties(message);
        if (completionListener != null) {
            producer.send(destination, message, completionListener);
        } else {
            producer.send(destination, message);
        }
    } catch (final JMSException e) {
        throw toRuntimeException(e);
    }
    return this;
}
 

@Test
public void testAsync() {
    JMSProducer producer = context.createProducer();
    TestJmsCompletionListener listener = new TestJmsCompletionListener();

    producer.setAsync(listener);
    assertEquals(listener, producer.getAsync());
}
 

@Override
public JMSProducer send(Destination destination, Map<String, Object> body) {
    try {
        MapMessage message = session.createMapMessage();
        for (Map.Entry<String, Object> entry : body.entrySet()) {
            message.setObject(entry.getKey(), entry.getValue());
        }

        doSend(destination, message);
    } catch (JMSException jmse) {
        throw JmsExceptionSupport.createRuntimeException(jmse);
    }

    return this;
}
 

@Override
public JMSProducer setDeliveryMode(int deliveryMode) {
   try {
      producer.setDeliveryMode(deliveryMode);
   } catch (JMSException e) {
      JMSRuntimeException e2 = new JMSRuntimeException(e.getMessage());
      e2.initCause(e);
      throw e2;
   }
   return this;
}
 

@Override
public JMSProducer setTimeToLive(long timeToLive) {
   try {
      producer.setTimeToLive(timeToLive);
      return this;
   } catch (JMSException e) {
      JMSRuntimeException e2 = new JMSRuntimeException(e.getMessage());
      e2.initCause(e);
      throw e2;
   }
}
 

@Override
public JMSProducer setDeliveryDelay(final long deliveryDelay) {
    try {
        producer.setDeliveryDelay(deliveryDelay);
        return this;
    } catch (final JMSException e) {
        JMSRuntimeException e2 = new JMSRuntimeException(e.getMessage());
        e2.initCause(e);
        throw e2;
    }
}
 

@Override
public JMSProducer setPriority(int priority) {
    if (priority < 0 || priority > 9) {
        throw new JMSRuntimeException(String.format("Priority value given {%d} is out of range (0..9)", priority));
    }

    this.priority = priority;
    return this;
}
 

@Test
public void testGetPropertyNames() {
    JMSProducer producer = context.createProducer();

    producer.setProperty("Property_1", "1");
    producer.setProperty("Property_2", "2");
    producer.setProperty("Property_3", "3");

    assertEquals(3, producer.getPropertyNames().size());

    assertTrue(producer.getPropertyNames().contains("Property_1"));
    assertTrue(producer.getPropertyNames().contains("Property_2"));
    assertTrue(producer.getPropertyNames().contains("Property_3"));
}
 

@Test
public void testClearProperties() {
    JMSProducer producer = context.createProducer();

    producer.setProperty("Property_1", "1");
    producer.setProperty("Property_2", "2");
    producer.setProperty("Property_3", "3");

    assertEquals(3, producer.getPropertyNames().size());

    producer.clearProperties();

    assertEquals(0, producer.getPropertyNames().size());
}
 

@Test
public void testJMSCorrelationIDBytes() {
    JMSProducer producer = context.createProducer();

    producer.setJMSCorrelationIDAsBytes(JMS_CORRELATION_ID.getBytes(StandardCharsets.UTF_8));
    assertEquals(JMS_CORRELATION_ID, new String(producer.getJMSCorrelationIDAsBytes(), StandardCharsets.UTF_8));
}
 

@Test
public void testJMSType() {
    JMSProducer producer = context.createProducer();

    producer.setJMSType(JMS_TYPE_STRING);
    assertEquals(JMS_TYPE_STRING, producer.getJMSType());
}
 

@Override
public JMSProducer send(Destination destination, String body) {
    try {
        TextMessage message = session.createTextMessage(body);
        doSend(destination, message);
    } catch (JMSException jmse) {
        throw JmsExceptionSupport.createRuntimeException(jmse);
    }

    return this;
}
 

@Override
public JMSProducer send(final Destination destination, final byte[] body) {
    final BytesMessage message = wrap(context.createBytesMessage());
    if (body != null) {
        try {
            message.writeBytes(body);
        } catch (final JMSException e) {
            throw new MessageFormatRuntimeException(e.getMessage());
        }
    }
    send(destination, message);
    return this;
}
 

@Test
public void testSetPropertyConversions() {
    JMSProducer producer = context.createProducer();

    producer.setProperty(STRING_PROPERTY_NAME, STRING_PROPERTY_VALUE);
    producer.setProperty(BYTE_PROPERTY_NAME, Byte.valueOf(BYTE_PROPERTY_VALUE));
    producer.setProperty(BOOLEAN_PROPERTY_NAME, Boolean.valueOf(BOOLEAN_PROPERTY_VALUE));
    producer.setProperty(SHORT_PROPERTY_NAME, Short.valueOf(SHORT_PROPERTY_VALUE));
    producer.setProperty(INTEGER_PROPERTY_NAME, Integer.valueOf(INTEGER_PROPERTY_VALUE));
    producer.setProperty(LONG_PROPERTY_NAME, Long.valueOf(LONG_PROPERTY_VALUE));
    producer.setProperty(FLOAT_PROPERTY_NAME, Float.valueOf(FLOAT_PROPERTY_VALUE));
    producer.setProperty(DOUBLE_PROPERTY_NAME, Double.valueOf(DOUBLE_PROPERTY_VALUE));

    try {
        producer.setProperty(STRING_PROPERTY_NAME, UUID.randomUUID());
        fail("Should not be able to set non-primitive type");
    } catch (MessageFormatRuntimeException mfe) {
    }

    assertNull(producer.getObjectProperty("Unknown"));

    assertEquals(STRING_PROPERTY_VALUE, producer.getStringProperty(STRING_PROPERTY_NAME));
    assertEquals(BYTE_PROPERTY_VALUE, producer.getByteProperty(BYTE_PROPERTY_NAME));
    assertEquals(BOOLEAN_PROPERTY_VALUE, producer.getBooleanProperty(BOOLEAN_PROPERTY_NAME));
    assertEquals(SHORT_PROPERTY_VALUE, producer.getShortProperty(SHORT_PROPERTY_NAME));
    assertEquals(INTEGER_PROPERTY_VALUE, producer.getIntProperty(INTEGER_PROPERTY_NAME));
    assertEquals(LONG_PROPERTY_VALUE, producer.getLongProperty(LONG_PROPERTY_NAME));
    assertEquals(FLOAT_PROPERTY_VALUE, producer.getFloatProperty(FLOAT_PROPERTY_NAME), 0.0);
    assertEquals(DOUBLE_PROPERTY_VALUE, producer.getDoubleProperty(DOUBLE_PROPERTY_NAME), 0.0);

    assertEquals(STRING_PROPERTY_VALUE, producer.getObjectProperty(STRING_PROPERTY_NAME));
    assertEquals(BYTE_PROPERTY_VALUE, producer.getObjectProperty(BYTE_PROPERTY_NAME));
    assertEquals(BOOLEAN_PROPERTY_VALUE, producer.getObjectProperty(BOOLEAN_PROPERTY_NAME));
    assertEquals(SHORT_PROPERTY_VALUE, producer.getObjectProperty(SHORT_PROPERTY_NAME));
    assertEquals(INTEGER_PROPERTY_VALUE, producer.getObjectProperty(INTEGER_PROPERTY_NAME));
    assertEquals(LONG_PROPERTY_VALUE, producer.getObjectProperty(LONG_PROPERTY_NAME));
    assertEquals(FLOAT_PROPERTY_VALUE, producer.getObjectProperty(FLOAT_PROPERTY_NAME));
    assertEquals(DOUBLE_PROPERTY_VALUE, producer.getObjectProperty(DOUBLE_PROPERTY_NAME));
}