javax.jms.QueueSession.getTransacted java code examples

Common ways to obtain QueueSession

private void myMethod () {
     QueueSession q =QueueConnection connection;connection.createQueueSession(false, acknowledgeMode)
QueueConnection queueConnection;queueConnection.createQueueSession(transacted, acknowledgeMode)
QueueConnection queueConnection;queueConnection.createQueueSession(true, acknowledgeMode)
Smart code suggestions by Codota
}

@Override
public boolean getTransacted() throws JMSException {
  return next.getTransacted();
}

given(txSession.getTransacted()).willReturn(true);
given(con.createQueueSession(false, Session.CLIENT_ACKNOWLEDGE)).willReturn(nonTxSession);

@Override
public boolean getTransacted() throws JMSException {
  return next.getTransacted();
}

/**
 * @return
 * @throws JMSException
 */
public boolean getTransacted() throws JMSException {
  return next.getTransacted();
}

@Override
public boolean getTransacted() throws JMSException {
  return next.getTransacted();
}

@Override
public boolean getTransacted() throws JMSException {
  return next.getTransacted();
}

/**
* Test that the <code>getTransacted()</code> method of a <code>Session</code> returns <code>true</code>
* if the session is transacted, <code>false</code> else.
*/
public void testGetTransacted()
{
 try
 {
   // senderSession has been created as non transacted
   assertEquals(false, senderSession.getTransacted());
   // we re-create senderSession as a transacted session
   senderSession = senderConnection.createQueueSession(true, Session.AUTO_ACKNOWLEDGE);
   assertEquals(true, senderSession.getTransacted());
 }
 catch (Exception e)
 {
   fail(e);
 }
}

/**
* Test that an attempt to call the <code>recover()</code> method on a 
* <strong>transacted </strong> <code>Session</code> throws a 
* <code>javax.jms.IllegalStateException</code>.
*/
public void testRecoverTransactedSession()
{
 try
 {
   // senderSession has been created as non transacted
   assertEquals(false, senderSession.getTransacted());
   // we create it again but as a transacted session
   senderSession = senderConnection.createQueueSession(true, 0);
   assertEquals(true, senderSession.getTransacted());
   senderSession.recover();
   fail("Should raise an IllegalStateException, the session is not transacted.\n");
 }
 catch (javax.jms.IllegalStateException e)
 {
 }
 catch (java.lang.IllegalStateException e)
 {
   fail("Should raise a javax.jms.IllegalStateException, not a java.lang.IllegalStateException.\n");
 }
 catch (Exception e)
 {
   fail("Should raise a javax.jms.IllegalStateException, not a " + e);
 }
}

/**
* Test that the <code>getTransacted()</code> method of a <code>Session</code> returns <code>true</code>
* if the session is transacted, <code>false</code> else.
*/
@Test
public void testGetTransacted() {
 try {
   // senderSession has been created as non transacted
   Assert.assertEquals(false, senderSession.getTransacted());
   // we re-create senderSession as a transacted session
   senderSession = senderConnection.createQueueSession(true, Session.AUTO_ACKNOWLEDGE);
   Assert.assertEquals(true, senderSession.getTransacted());
 } catch (Exception e) {
   fail(e);
 }
}

/**
* Test that an attempt to call the <code>commit()</code> method on a 
* <strong>non transacted</strong> <code>Session</code> throws a 
* <code>javax.jms.IllegalStateException</code>.
*/
public void testCommitNonTransactedSession()
{
 try
 {
   // senderSession has been created as non transacted in the setUp() method
   assertEquals(false, senderSession.getTransacted());
   senderSession.commit();
   fail("Should raise an IllegalStateException, the session is not transacted.\n");
 }
 catch (javax.jms.IllegalStateException e)
 {
 }
 catch (java.lang.IllegalStateException e)
 {
   fail("Should raise a javax.jms.IllegalStateException, not a java.lang.IllegalStateException.\n");
 }
 catch (Exception e)
 {
   fail("Should raise a javax.jms.IllegalStateException, not a " + e);
 }
}

/**
* Test that an attempt to call the <code>roolback()</code> method on a 
* <strong>non transacted</strong> <code>Session</code> throws a 
* <code>javax.jms.IllegalStateException</code>.
*/
public void testRollbackNonTransactedSession()
{
 try
 {
   // senderSession has been created as non transacted in the setUp() method
   assertEquals(false, senderSession.getTransacted());
   senderSession.rollback();
   fail("Should raise an IllegalStateException, the session is not transacted.\n");
 }
 catch (javax.jms.IllegalStateException e)
 {
 }
 catch (java.lang.IllegalStateException e)
 {
   fail("Should raise a javax.jms.IllegalStateException, not a java.lang.IllegalStateException.\n");
 }
 catch (Exception e)
 {
   fail("Should raise a javax.jms.IllegalStateException, not a " + e);
 }
}

/**
* Test that an attempt to call the <code>recover()</code> method on a
* <strong>transacted </strong> <code>Session</code> throws a
* <code>javax.jms.IllegalStateException</code>.
*/
@Test
public void testRecoverTransactedSession() {
 try {
   // senderSession has been created as non transacted
   Assert.assertEquals(false, senderSession.getTransacted());
   // we create it again but as a transacted session
   senderSession = senderConnection.createQueueSession(true, 0);
   Assert.assertEquals(true, senderSession.getTransacted());
   senderSession.recover();
   Assert.fail("Should raise an IllegalStateException, the session is not transacted.\n");
 } catch (javax.jms.IllegalStateException e) {
 } catch (java.lang.IllegalStateException e) {
   Assert.fail("Should raise a javax.jms.IllegalStateException, not a java.lang.IllegalStateException.\n");
 } catch (Exception e) {
   Assert.fail("Should raise a javax.jms.IllegalStateException, not a " + e);
 }
}

assertEquals(true, senderSession.getTransacted());

/**
* Test that a call to the <code>rollback()</code> method on a 
* <strong>transacted</strong> <code>Session</code> rollbacks all
* the messages sent in the transaction.
*/
public void testRollbackTransactedSession()
{
 try
 {
   // re-create senderSession as a transacted session
   senderSession = senderConnection.createQueueSession(true, 0);
   sender = senderSession.createSender(senderQueue);
   assertEquals(true, senderSession.getTransacted());
   TextMessage message = senderSession.createTextMessage();
   message.setText("testRollbackTransactedSession");
   // send a message within a transacted session
   sender.send(message);
   // rollback the transaction -> the sent message shouldn't be received
   senderSession.rollback();
   TextMessage m = (TextMessage) receiver.receiveNoWait();
   // test that no message has been received
   assertEquals(null, m);
 }
 catch (Exception e)
 {
   fail(e);
 }
}

/**
* Test that an attempt to call the <code>roolback()</code> method on a
* <strong>non transacted</strong> <code>Session</code> throws a
* <code>javax.jms.IllegalStateException</code>.
*/
@Test
public void testRollbackNonTransactedSession() {
 try {
   // senderSession has been created as non transacted in the setUp() method
   Assert.assertEquals(false, senderSession.getTransacted());
   senderSession.rollback();
   Assert.fail("Should raise an IllegalStateException, the session is not transacted.\n");
 } catch (javax.jms.IllegalStateException e) {
 } catch (java.lang.IllegalStateException e) {
   Assert.fail("Should raise a javax.jms.IllegalStateException, not a java.lang.IllegalStateException.\n");
 } catch (Exception e) {
   Assert.fail("Should raise a javax.jms.IllegalStateException, not a " + e);
 }
}

/**
* Test that an attempt to call the <code>commit()</code> method on a
* <strong>non transacted</strong> <code>Session</code> throws a
* <code>javax.jms.IllegalStateException</code>.
*/
@Test
public void testCommitNonTransactedSession() {
 try {
   // senderSession has been created as non transacted in the setUp() method
   Assert.assertEquals(false, senderSession.getTransacted());
   senderSession.commit();
   Assert.fail("Should raise an IllegalStateException, the session is not transacted.\n");
 } catch (javax.jms.IllegalStateException e) {
 } catch (java.lang.IllegalStateException e) {
   Assert.fail("Should raise a javax.jms.IllegalStateException, not a java.lang.IllegalStateException.\n");
 } catch (Exception e) {
   Assert.fail("Should raise a javax.jms.IllegalStateException, not a " + e);
 }
}

/**
* Test that a call to the <code>rollback()</code> method on a
* <strong>transacted</strong> <code>Session</code> rollbacks all
* the messages sent in the transaction.
*/
@Test
public void testCommitTransactedSession() {
 try {
   // re-create senderSession as a transacted session
   senderSession = senderConnection.createQueueSession(true, 0);
   sender = senderSession.createSender(senderQueue);
   Assert.assertEquals(true, senderSession.getTransacted());
   TextMessage message = senderSession.createTextMessage();
   message.setText("testCommitTransactedSession");
   // send a message within a transacted session
   sender.send(message);
   TextMessage m = (TextMessage) receiver.receiveNoWait();
   // test that no message has been received (the transaction has not been committed yet)
   Assert.assertEquals(null, m);
   // commit the transaction -> the sent message should be received
   senderSession.commit();
   m = (TextMessage) receiver.receive(TestConfig.TIMEOUT);
   Assert.assertTrue(m != null);
   Assert.assertEquals("testCommitTransactedSession", m.getText());
 } catch (Exception e) {
   fail(e);
 }
}

/**
* Test that a call to the <code>rollback()</code> method on a
* <strong>transacted</strong> <code>Session</code> rollbacks all
* the messages sent in the transaction.
*/
@Test
public void testRollbackTransactedSession() {
 try {
   // re-create senderSession as a transacted session
   senderSession = senderConnection.createQueueSession(true, 0);
   sender = senderSession.createSender(senderQueue);
   Assert.assertEquals(true, senderSession.getTransacted());
   TextMessage message = senderSession.createTextMessage();
   message.setText("testRollbackTransactedSession");
   // send a message within a transacted session
   sender.send(message);
   // rollback the transaction -> the sent message shouldn't be received
   senderSession.rollback();
   TextMessage m = (TextMessage) receiver.receiveNoWait();
   // test that no message has been received
   Assert.assertEquals(null, m);
 } catch (Exception e) {
   fail(e);
 }
}

Assert.assertEquals(true, senderSession.getTransacted());
Assert.assertEquals(true, receiverSession.getTransacted());

Assert.assertEquals(true, senderSession.getTransacted());
Assert.assertEquals(true, receiverSession.getTransacted());

Popular methods of QueueSession

createSender
Creates a QueueSender object to send messages to the specified queue.
createReceiver
Creates a QueueReceiver object to receive messages from the specified queue using a message selector
close
createTemporaryQueue
Creates a TemporaryQueue object. Its lifetime will be that of the QueueConnection unless it is delet
createTextMessage
createQueue
Creates a queue identity given a Queue name.This facility is provided for the rare cases where clien
createObjectMessage
createConsumer
createBrowser
Creates a QueueBrowser object to peek at the messages on the specified queue using a message selecto
createBytesMessage
createMessage
commit

Popular in Java

Reactive rest calls using spring rest template
getContentResolver (Context)
getSystemService (Context)
scheduleAtFixedRate (ScheduledExecutorService)
Creates and executes a periodic action that becomes enabled first after the given initial delay, and
ByteBuffer (java.nio)
A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate(i
Charset (java.nio.charset)
A charset is a named mapping between Unicode characters and byte sequences. Every Charset can decode
KeyStore (java.security)
This class represents an in-memory collection of keys and certificates. It manages two types of entr
Permission (java.security)
Abstract class for representing access to a system resource. All permissions have a name (whose inte
Time (java.sql)
Java representation of an SQL TIME value. Provides utilities to format and parse the time's represen
JCheckBox (javax.swing)

How to use getTransactedmethodin javax.jms.QueueSession

Best Java code snippets using javax.jms.QueueSession.getTransacted (Showing top 20 results out of 315)

How to use
getTransacted
method
in
javax.jms.QueueSession