Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
  * 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  junit.framework.*;
 
 import javax.sip.*;
 import java.util.*;
 import java.text.*;
 import test.tck.*;

The test tries to verify that Invite Server Transactions correctly change states as specified by the rfc3261. The Reference Implementation is used to send requests and a Tested Implementation ServerTransaction's states are queried and compared to those in the state machine described in section 17.2.1 of rfc3261

                        |Request received
                                  |pass to TU
                                  V
                            +-----------+
                            |           |
                            | Trying    |-------------+
                            |           |             |
                            +-----------+             |200-699 from TU
                                  |                   |send response
                                  |1xx from TU        |
                                  |send response      |
                                  |                   |
               Request            V      1xx from TU  |
               send response+-----------+send response|
                   +--------|           |--------+    |
                   |        | Proceeding|        |    |
                   +------->|           |<-------+    |
            +<--------------|           |             |
            |Trnsprt Err    +-----------+             |
            |Inform TU            |                   |
            |                     |                   |
            |                     |200-699 from TU    |
            |                     |send response      |
            |  Request            V                   |
            |  send response+-----------+             |
            |      +--------|           |             |
            |      |        | Completed |<------------+
            |      +------->|           |
            +<--------------|           |
            |Trnsprt Err    +-----------+
            |Inform TU            |
            |                     |Timer J fires
            |                     |-
            |                     |
            |                     V
            |               +-----------+
            |               |           |
            +-------------->| Terminated|
                            |           |
                            +-----------+

                Figure 8: non-INVITE server transaction

Author(s):
Emil Ivov Network Research Team, Louis Pasteur University, Strasbourg, France. This code is in the public domain.
Version:
1.0
 
 
     extends MessageFlowHarness {
 
         super(name);
     }
 
     //==================== tests ==============================
 
    
Tries to steer a TI server transaction through the following scenario Trying-->Proceeding-->Completed-->Terminated. Apart from state transitions, we also test, retransmissions and proper hiding/passing of messages to the TU.
    public void testTryingProceedingCompletedScenario() {
        try {
            Request register = createRiRegisterRequest();
            SipEventCollector responseCollector = new SipEventCollector();
            //Before Sending the request we should first register a listener with the
            //RI that would catch the TRYING response
            try {
                responseCollector.collectResponseEvent();
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                    "Failed to register a SipListener with an RI SipProvider",
                    ex);
            }
            //Send the initial request
            try {
                .collectRequestEvent();
                .sendRequest(register);
            } catch (SipException ex) {
                throw new TckInternalError(
                    "A SipExceptionOccurred while trying to send request!",
                    ex);
            } catch (TooManyListenersException ex) {
                throw new TiUnexpectedError(
                    "Failed to register a SipListener with a TI SipProvider",
                    ex);
            }
            waitForMessage();
            RequestEvent registerReceivedEvent =
                .extractCollectedRequestEvent();
            if (registerReceivedEvent == null
                || registerReceivedEvent.getRequest() == null)
                throw new TiUnexpectedError("The initial register request was not received by the TI!");
            //Let's create the transaction
            ServerTransaction tran = null;
            try {
                tran =
                    .getNewServerTransaction(
                        registerReceivedEvent.getRequest());
            } catch (Exception ex) {
                ex.printStackTrace();
                fail(
                    ex.getClass().getName()
                        + "was thrown while trying to "
                        + "create the server transaction");
            }
            assertNotNull(
                "tiSipProvider.getNewServerTransaction() returned null",
                tran);
            //At this point the ServerTransaction should be TRYING!
            assertEquals(.tran.getState());
            //Send a TRYING response
            Response trying = null;
            try {
                trying =
                    .createResponse(
                        .,
                        registerReceivedEvent.getRequest());
                tran.sendResponse(trying);
            } catch (Exception ex) {
                throw new TiUnexpectedError(
                    "Failed to send a TRYING response",
                    ex);
            }
            waitForMessage();
            //The transaction should now be PROCEEDING
            assertEquals(
                "The transaction did not pass into the PROCEEDING state "
                    + "upon transmission of a 1xx response.",
                .,
                tran.getState());
            ResponseEvent responseEvent =
                responseCollector.extractCollectedResponseEvent();
            assertNotNull(
                "The TRYING response has not been sent by the TI.",
                responseEvent);
            assertTrue(
                "A response different from 100 was sent by the TI",
                . == responseEvent.getResponse().getStatusCode());
            //Resend the REGISTER and see that the TRYING response is resent
            try {
                //listen for the Trying response
                responseCollector.collectResponseEvent();
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                    "Failed to register a SipListener with an RI SipProvider",
                    ex);
            }
            try {
                .collectRequestEvent();
                .sendRequest(register);
            } catch (SipException ex) {
                throw new TckInternalError(
                    "A SipExceptionOccurred while trying to send request!",
                    ex);
            } catch (TooManyListenersException ex) {
                throw new TiUnexpectedError(
                    "Failed to register a SipListener with a TI SipProvider",
                    ex);
            }
            //Wait for the REGISTER
            waitForMessage();
            registerReceivedEvent =
                .extractCollectedRequestEvent();
            assertNull(
                "Retransmitted REGISTERs should not be passed to the TU",
                registerReceivedEvent);
            //Wait for a retransmitted TRYING response
            waitForMessage();
            //Verify whether there was a TRYING response
            responseEvent = responseCollector.extractCollectedResponseEvent();
            assertNotNull(
                "No TRYING response has been resent by the TI upon reception "
                    + "of a retransmitted REGISTER request",
                responseEvent);
            assertTrue(
                "A response different from 100 was sent by the TI upon "
                    + "reception of a retransmitted REGISTER",
                . == responseEvent.getResponse().getStatusCode());
            //Create & send RINGING. See that it is properly sent
            //and that tran state doesn't change
            Response ringing = null;
            try {
                ringing =
                    .createResponse(
                        .,
                        tran.getRequest());
                ((ToHeaderringing.getHeader(.)).setTag(
                    Integer.toString(hashCode()));
            } catch (ParseException ex) {
                throw new TiUnexpectedError(
                    "A ParseException was thrown while trying to create a ringing "
                        + "response using TI",
                    ex);
            }
            try {
                //listen for the RINGING response
                responseCollector.collectResponseEvent();
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                    "Failed to register a SipListener with an RI SipProvider",
                    ex);
            }
            try {
                tran.sendResponse(ringing);
            } catch (SipException ex) {
                ex.printStackTrace();
                fail("The TI failed to send a RINGING response");
            }
            //The Transaction should still be PROCEEDING
            assertEquals(
                "The Transaction did not remain PROCEEDING after transmitting a RINGING response",
                .,
                tran.getState());
            //Check whether the RINGING is received by the RI.
            waitForMessage();
            responseEvent = responseCollector.extractCollectedResponseEvent();
            assertNotNull(
                "The RINGING response was not received by the RI",
                responseEvent);
            assertTrue(
                "A response different from RINGING was sent by the TI",
                .
                    == responseEvent.getResponse().getStatusCode());
            //Resend the REGISTER, see that it is hidden from the TU and see that
            //the _RINGING_ response is resent (and not the TRYING)
            try {
                //listen for the Trying response
                responseCollector.collectResponseEvent();
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                    "Failed to register a SipListener with an RI SipProvider",
                    ex);
            }
            try {
                .collectRequestEvent();
                .sendRequest(register);
            } catch (SipException ex) {
                throw new TckInternalError(
                    "A SipExceptionOccurred while trying to send request!",
                    ex);
            } catch (TooManyListenersException ex) {
                throw new TiUnexpectedError(
                    "Failed to register a SipListener with a TI SipProvider",
                    ex);
            }
            //Wait for the REGISTER
            waitForMessage();
            registerReceivedEvent =
                .extractCollectedRequestEvent();
            assertNull(
                "Retransmitted REGISTERs should not be passed to the TU",
                registerReceivedEvent);
            //Wait for a retransmitted RINGING response
            waitForMessage();
            //Verify whether there was a RINGING response
            responseEvent = responseCollector.extractCollectedResponseEvent();
            assertNotNull(
                "No RINGING response has been sent by the TI upon reception "
                    + "of an REGISTER request",
                responseEvent);
            assertTrue(
                "A response different from RINGING was sent by the TI upon "
                    + "reception of a retransmitted REGISTER",
                .
                    == responseEvent.getResponse().getStatusCode());
            //We should still be proceeding
            assertEquals(
                "The server transaction left the PROCEEDING state.",
                .,
                tran.getState());
            //Send 200 - 699 from TU and see the tran goes COMPLETED
            Response ok = null;
            try {
                ok =
                    .createResponse(
                        .,
                        tran.getRequest());
                ((ToHeaderok.getHeader(.)).setTag(
                    Integer.toString(hashCode()));
            } catch (ParseException ex) {
                throw new TiUnexpectedError(
                    "A ParseException was thrown while trying to create a busy_here "
                        + "response using TI",
                    ex);
            }
            try {
                //listen for the BUSY_HERE response
                responseCollector.collectResponseEvent();
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                    "Failed to register a SipListener with an RI SipProvider",
                    ex);
            }
            try {
                tran.sendResponse(ok);
            } catch (SipException ex) {
                ex.printStackTrace();
                fail("The TI failed to send a OK response");
            }
            //The Transaction should now be COMPLETED
            assertEquals(
                "The Transaction did not remain COMPLETED after transmitting a BUSY_HERE response",
                .,
                tran.getState());
            //Check whether the OK is received by the RI.
            waitForMessage();
            responseEvent = responseCollector.extractCollectedResponseEvent();
            assertNotNull(
                "The OK response was not received by the RI",
                responseEvent);
            assertTrue(
                "A response different from OK was sent by the TI",
                . == responseEvent.getResponse().getStatusCode());
            //Resend the initial from REGISTER from the RI and see that TI
            //resends the 200 - 699 (see that tran state remains COMPLETED)
            try {
                //listen for the OK response
                responseCollector.collectResponseEvent();
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                    "Failed to register a SipListener with an RI SipProvider",
                    ex);
            }
            try {
                .collectRequestEvent();
                .sendRequest(register);
            } catch (SipException ex) {
                throw new TckInternalError(
                    "A SipExceptionOccurred while trying to send request!",
                    ex);
            } catch (TooManyListenersException ex) {
                throw new TiUnexpectedError(
                    "Failed to register a SipListener with a TI SipProvider",
                    ex);
            }
            //Wait for the REGISTER
            waitForMessage();
            registerReceivedEvent =
                .extractCollectedRequestEvent();
            assertNull(
                "Retransmitted REGISTERs should not be passed to the TU",
                registerReceivedEvent);
            //Wait for a retransmitted OK response
            waitForMessage();
            //Verify whether there was an OK response
            responseEvent = responseCollector.extractCollectedResponseEvent();
            assertNotNull(
                "No OK response has been sent by the TI upon reception "
                    + "of a retransmitted REGISTER request",
                responseEvent);
            assertTrue(
                "A response different from OK was sent by the TI upon "
                    + "reception of a retransmitted invite REGISTER",
                . == responseEvent.getResponse().getStatusCode());
            //We should still be COMPLETED
            assertEquals(
                "The server transaction left the COMPLETED state.",
                .,
                tran.getState());
        } catch (Throwable exc) {
            exc.printStackTrace();
            fail(exc.getClass().getName() + ": " + exc.getMessage());
        }
        assertTrue(new Exception().getStackTrace()[0].toString(), true);
    }

    
Tries to steer a TI server transaction through the following scenario Trying-->Completed. Apart from state transitions, we also test, retransmissions and proper hiding/passing of messages to the TU.
    public void testTryingCompletedScenario() {
        try {
            Request register = createRiRegisterRequest();
            SipEventCollector responseCollector = new SipEventCollector();
            //Before Sending the request we should first register a listener with the
            //RI that would catch the TRYING response
            try {
                responseCollector.collectResponseEvent();
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                    "Failed to register a SipListener with an RI SipProvider",
                    ex);
            }
            //Send the initial request
            try {
                .collectRequestEvent();
                .sendRequest(register);
            } catch (SipException ex) {
                throw new TckInternalError(
                    "A SipExceptionOccurred while trying to send request!",
                    ex);
            } catch (TooManyListenersException ex) {
                throw new TiUnexpectedError(
                    "Failed to register a SipListener with a TI SipProvider",
                    ex);
            }
            waitForMessage();
            RequestEvent registerReceivedEvent =
                .extractCollectedRequestEvent();
            if (registerReceivedEvent == null
                || registerReceivedEvent.getRequest() == null)
                throw new TiUnexpectedError("The initial REGISTER request was not received by the TI!");
            //Let's create the transaction
            ServerTransaction tran = null;
            try {
                tran =
                    .getNewServerTransaction(
                        registerReceivedEvent.getRequest());
            } catch (Exception ex) {
                ex.printStackTrace();
                fail(
                    ex.getClass().getName()
                        + "was thrown while trying to "
                        + "create the server transaction");
            }
            assertNotNull(
                "tiSipProvider.getNewServerTransaction() returned null",
                tran);
            //At this point the ServerTransaction should be TRYING!
            assertEquals(.tran.getState());
            //Send a TRYING response
            Response trying = null;
            try {
                trying =
                    .createResponse(
                        .,
                        registerReceivedEvent.getRequest());
                tran.sendResponse(trying);
            } catch (Exception ex) {
                throw new TiUnexpectedError(
                    "Failed to send a TRYING response",
                    ex);
            }
            //The transaction should now be PROCEEDING
            assertEquals(
                "The transaction did not pass into the PROCEEDING state "
                    + "upon transmission of a 1xx response.",
                .,
                tran.getState());
            waitForMessage();
            ResponseEvent responseEvent =
                responseCollector.extractCollectedResponseEvent();
            assertNotNull(
                "The TRYING response has not been sent by the TI.",
                responseEvent);
            assertTrue(
                "A response different from 100 was sent by the TI",
                . == responseEvent.getResponse().getStatusCode());
            //Resend the REGISTER and see that the TRYING response is resent
            try {
                //listen for the Trying response
                responseCollector.collectResponseEvent();
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                    "Failed to register a SipListener with an RI SipProvider",
                    ex);
            }
            try {
                .collectRequestEvent();
                .sendRequest(register);
            } catch (SipException ex) {
                throw new TckInternalError(
                    "A SipExceptionOccurred while trying to send request!",
                    ex);
            } catch (TooManyListenersException ex) {
                throw new TiUnexpectedError(
                    "Failed to register a SipListener with a TI SipProvider",
                    ex);
            }
            //Wait for the REGISTER
            waitForMessage();
            registerReceivedEvent =
                .extractCollectedRequestEvent();
            assertNull(
                "Retransmitted REGISTERs should not be passed to the TU",
                registerReceivedEvent);
            //Wait for a retransmitted TRYING response
            waitForMessage();
            //Verify whether there was a TRYING response
            responseEvent = responseCollector.extractCollectedResponseEvent();
            assertNotNull(
                "No TRYING response has been resent by the TI upon reception "
                    + "of a retransmitted REGISTER request",
                responseEvent);
            assertTrue(
                "A response different from 100 was sent by the TI upon "
                    + "reception of a retransmitted REGISTER",
                . == responseEvent.getResponse().getStatusCode());
            //Send 200 - 699 from TU and see the tran goes COMPLETED
            Response ok = null;
            try {
                ok =
                    .createResponse(
                        .,
                        tran.getRequest());
                ((ToHeaderok.getHeader(.)).setTag(
                    Integer.toString(hashCode()));
            } catch (ParseException ex) {
                throw new TiUnexpectedError(
                    "A ParseException was thrown while trying to create a busy_here "
                        + "response using TI",
                    ex);
            }
            try {
                //listen for the BUSY_HERE response
                responseCollector.collectResponseEvent();
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                    "Failed to register a SipListener with an RI SipProvider",
                    ex);
            }
            try {
                tran.sendResponse(ok);
            } catch (SipException ex) {
                ex.printStackTrace();
                fail("The TI failed to send a OK response");
            }
            //The Transaction should now be COMPLETED
            assertEquals(
                "The Transaction did not remain COMPLETED after transmitting a BUSY_HERE response",
                .,
                tran.getState());
            //Check whether the OK is received by the RI.
            waitForMessage();
            responseEvent = responseCollector.extractCollectedResponseEvent();
            assertNotNull(
                "The OK response was not received by the RI",
                responseEvent);
            assertTrue(
                "A response different from OK was sent by the TI",
                . == responseEvent.getResponse().getStatusCode());
            //Resend the initial from REGISTER from the RI and see that TI
            //resends the 200 - 699 (see that tran state remains COMPLETED)
            try {
                //listen for the OK response
                responseCollector.collectResponseEvent();
            } catch (TooManyListenersException ex) {
                throw new TckInternalError(
                    "Failed to register a SipListener with an RI SipProvider",
                    ex);
            }
            try {
                .collectRequestEvent();
                .sendRequest(register);
            } catch (SipException ex) {
                throw new TckInternalError(
                    "A SipExceptionOccurred while trying to send request!",
                    ex);
            } catch (TooManyListenersException ex) {
                throw new TiUnexpectedError(
                    "Failed to register a SipListener with a TI SipProvider",
                    ex);
            }
            //Wait for the REGISTER
            waitForMessage();
            registerReceivedEvent =
                .extractCollectedRequestEvent();
            assertNull(
                "Retransmitted REGISTERs should not be passed to the TU",
                registerReceivedEvent);
            //Wait for a retransmitted OK response
            waitForMessage();
            //Verify whether there was an OK response
            responseEvent = responseCollector.extractCollectedResponseEvent();
            assertNotNull(
                "No OK response has been sent by the TI upon reception "
                    + "of a retransmitted REGISTER request",
                responseEvent);
            assertTrue(
                "A response different from OK was sent by the TI upon "
                    + "reception of a retransmitted invite REGISTER",
                . == responseEvent.getResponse().getStatusCode());
            //We should still be COMPLETED
            assertEquals(
                "The server transaction left the COMPLETED state.",
                .,
                tran.getState());
        } catch (Throwable exc) {
            exc.printStackTrace();
            fail(exc.getClass().getName() + ": " + exc.getMessage());
        }
        assertTrue(new Exception().getStackTrace()[0].toString(), true);
    }
    //==================== end of tests
    //====== STATIC JUNIT ==========
    public static Test suite() {
        return new TestSuite(NonInviteServerTransactionsStateMachineTest.class);
    }
New to GrepCode? Check out our FAQ X