test.tck.msgflow.TransactionTimeoutEventTest Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jain-sip-ri Show documentation
There is a newer version: 1.3.0-91
/*
* Conditions Of Use
*
* This software was developed by employees of the National Institute of
* Standards and Technology (NIST), and others.
* This software is has been contributed to the public domain.
* As a result, a formal license is not needed to use the software.
*
* This software is provided "AS IS."
* NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
* OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
* AND DATA ACCURACY.  NIST does not warrant or make any representations
* regarding the use of the software or the results thereof, including but
* not limited to the correctness, accuracy, reliability or usefulness of
* the software.
*
*
*/
package test.tck.msgflow;

import java.util.TooManyListenersException;

import javax.sip.ClientTransaction;
import javax.sip.RequestEvent;
import javax.sip.ServerTransaction;
import javax.sip.SipException;
import javax.sip.Timeout;
import javax.sip.TimeoutEvent;
import javax.sip.header.ContactHeader;
import javax.sip.header.ToHeader;
import javax.sip.message.Request;
import javax.sip.message.Response;

import org.apache.log4j.Logger;

import test.tck.TckInternalError;
import test.tck.TiUnexpectedError;

/**
 * Timeout test for invite client transactions -- test to see if an timeout
 * event is delivered to the listener if the RI refuses to send OK to the INVITE
 * Client Tx.
 *
 * @author M. Ranganathan
 */

public class TransactionTimeoutEventTest extends MessageFlowHarness {
    private static Logger logger = Logger
            .getLogger(InviteClientTransactionsStateMachineTest.class);

    public TransactionTimeoutEventTest(String name) {
        super(name, false); // disable auto-dialog for the RI, else ACKs get
                            // filtered out
    }

    // ==================== tests ==============================

    /**
     * Test if the tx timeout is delivered.
     */
    public void testClientTransactionTimeout() {
        try {
            Request invite = createTiInviteRequest(null, null, null);
            ClientTransaction tran = null;
            try {
                eventCollector.collectRequestEvent(riSipProvider);

                tran = tiSipProvider.getNewClientTransaction(invite);
                tran.sendRequest();
            } catch (SipException ex) {
                throw new TiUnexpectedError(
                        "A SipExceptionOccurred while trying to send request!",
                        ex);
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                        "Failed to regiest a SipListener with an RI SipProvider",
                        ex);
            }
            waitForMessage();
            RequestEvent inviteReceivedEvent = eventCollector
                    .extractCollectedRequestEvent();
            assertNotNull("RequestEvent", inviteReceivedEvent);
            try {
                eventCollector.collectTimeoutEvent(tiSipProvider);
            } catch (TooManyListenersException ex) {
                throw new TiUnexpectedError(
                        "Failed to register a SipListener with TI", ex);
            }
            waitForTimeout();
            TimeoutEvent timeoutEvent = eventCollector
                    .extractCollectedTimeoutEvent();
            assertNotNull("Timeout event", timeoutEvent);
            assertTrue("Timeout event type ", timeoutEvent.getTimeout().equals(
                    Timeout.TRANSACTION));
        } catch (Exception ex) {
            logger.error("unexpected exception ", ex);
            ex.printStackTrace();
            fail("unexpected exception");
        }
    }


    public void testServerTransactionForTimeout() {
        try {
            Request invite = createRiInviteRequest(null, null, null);
            ClientTransaction tran = null;
            try {
                eventCollector.collectRequestEvent(tiSipProvider);
                tran = riSipProvider.getNewClientTransaction(invite);
                tran.sendRequest();
            } catch (SipException ex) {
                throw new TiUnexpectedError(
                        "A SipExceptionOccurred while trying to send request!",
                        ex);
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                        "Failed to regiest a SipListener with an RI SipProvider",
                        ex);
            }
            waitForMessage();
            RequestEvent inviteReceivedEvent = eventCollector
                    .extractCollectedRequestEvent();
            assertNotNull("RequestEvent not seen at TI", inviteReceivedEvent);
            assertTrue("Server Transaction MUST be null", inviteReceivedEvent
                    .getServerTransaction() == null);
            ServerTransaction st = tiSipProvider
                    .getNewServerTransaction(inviteReceivedEvent.getRequest());
            Response response = tiMessageFactory.createResponse(Response.OK,
                    inviteReceivedEvent.getRequest());
            ToHeader toHeader = (ToHeader) response.getHeader(ToHeader.NAME);
            toHeader.setTag("123456");
            ContactHeader contact = super.createTiContact();
            response.setHeader(contact);
            st.sendResponse(response);

            eventCollector.collectTimeoutEvent(tiSipProvider);
            waitForTimeout();
            TimeoutEvent timeoutEvent = eventCollector
                    .extractCollectedTimeoutEvent();
            assertNull("Timeout event", timeoutEvent);
            //assertNotNull("Timeout event", timeoutEvent);
            //assertTrue("Timeout event type must be TRANSACTION ", timeoutEvent
                //.getTimeout().equals(Timeout.TRANSACTION));

        } catch (Exception ex) {
            logger.error("unexpected exception ", ex);
            ex.printStackTrace();
            fail("unexpected exception");
        }
    }


    public void testServerTransactionForRetransmissionAlerts() {
        try {
            Request invite = createRiInviteRequest(null, null, null);
            ClientTransaction tran = null;
            tiSipProvider.setAutomaticDialogSupportEnabled(false);
            try {
                eventCollector.collectRequestEvent(tiSipProvider);
                tran = riSipProvider.getNewClientTransaction(invite);
                tran.sendRequest();
            } catch (SipException ex) {
                throw new TiUnexpectedError(
                        "A SipExceptionOccurred while trying to send request!",
                        ex);
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                        "Failed to regiest a SipListener with an RI SipProvider",
                        ex);
            }
            waitForMessage();
            RequestEvent inviteReceivedEvent = eventCollector
                    .extractCollectedRequestEvent();
            assertNotNull("RequestEvent not seen at TI", inviteReceivedEvent);
            assertTrue("Server Transaction MUST be null", inviteReceivedEvent
                    .getServerTransaction() == null);
            ServerTransaction st = tiSipProvider
                    .getNewServerTransaction(inviteReceivedEvent.getRequest());
            Response response = tiMessageFactory.createResponse(Response.OK,
                    inviteReceivedEvent.getRequest());
            ToHeader toHeader = (ToHeader) response.getHeader(ToHeader.NAME);
            toHeader.setTag("1234567");
            ContactHeader contact = super.createTiContact();
            response.setHeader(contact);
            st.enableRetransmissionAlerts();
            st.sendResponse(response);
            eventCollector.collectTimeoutEvent(tiSipProvider);
            waitForTimeout();
            TimeoutEvent timeoutEvent = eventCollector
                    .extractCollectedTimeoutEvent();
            assertNotNull("Timeout event not found ", timeoutEvent);
            assertTrue("Timeout event type must be retransmit ", timeoutEvent
                    .getTimeout().equals(Timeout.RETRANSMIT));

        } catch (Exception ex) {
            logger.error("unexpected exception ", ex);
            ex.printStackTrace();
            fail("unexpected exception");
        }
    }
}