test.tck.msgflow.callflows.reinvite.ReInviteTest Maven / Gradle / Ivy

Go to download
/*
* 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.callflows.reinvite;

import gov.nist.javax.sip.SipProviderImpl;

import java.util.EventObject;
import java.util.Hashtable;
import java.util.Timer;
import java.util.TimerTask;

import javax.sip.DialogTerminatedEvent;
import javax.sip.IOExceptionEvent;
import javax.sip.RequestEvent;
import javax.sip.ResponseEvent;
import javax.sip.SipListener;
import javax.sip.SipProvider;
import javax.sip.TimeoutEvent;
import javax.sip.TransactionTerminatedEvent;

import org.apache.log4j.Appender;
import org.apache.log4j.ConsoleAppender;
import org.apache.log4j.FileAppender;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.SimpleLayout;
import org.apache.log4j.helpers.NullEnumeration;

import test.tck.msgflow.callflows.ProtocolObjects;
import test.tck.msgflow.callflows.ScenarioHarness;
import test.tck.TestHarness;

import junit.framework.TestCase;

/**
 * @author M. Ranganathan
 * 
 */
public class ReInviteTest extends ScenarioHarness implements SipListener {

	
	protected Shootist shootist;

	private Shootme shootme;

	private static Logger logger = Logger.getLogger("test.tck");

	static {
		if (!logger.isAttached(console))
			logger.addAppender(console);
	}

	private SipListener getSipListener(EventObject sipEvent) {
		SipProvider source = (SipProvider) sipEvent.getSource();
		SipListener listener = (SipListener) providerTable.get(source);
		assertTrue(listener != null);
		return listener;
	}

	public ReInviteTest() {
		super("reinvitetest", true);
	}

	public void setUp() {

		try {
			this.transport = "udp";
			
			super.setUp();
			shootist = new Shootist(riProtocolObjects);
			SipProvider shootistProvider = shootist.createSipProvider();
			providerTable.put(shootistProvider, shootist);

			shootme = new Shootme(tiProtocolObjects);
			SipProvider shootmeProvider = shootme.createSipProvider();
			providerTable.put(shootmeProvider, shootme);
			shootistProvider.addSipListener(this);
			shootmeProvider.addSipListener(this);

			riProtocolObjects.start();
			if (tiProtocolObjects != riProtocolObjects)
				tiProtocolObjects.start();
		} catch (Exception ex) {
			ex.printStackTrace();
			fail("unexpected exception ");
		}
	}

	public void testSendInvite() {
		this.shootist.sendInvite();
	}

	public void tearDown() {
		try {
			Thread.sleep(2000);
			this.shootist.checkState();
			this.shootme.checkState();
			tiProtocolObjects.destroy();
			if (tiProtocolObjects != riProtocolObjects)
				riProtocolObjects.destroy();
			Thread.sleep(1000);
			this.providerTable.clear();
			logTestCompleted();
		} catch (Exception ex) {
			ex.printStackTrace();
		}

	}

	public void processRequest(RequestEvent requestEvent) {
		getSipListener(requestEvent).processRequest(requestEvent);

	}

	public void processResponse(ResponseEvent responseEvent) {
		getSipListener(responseEvent).processResponse(responseEvent);

	}

	public void processTimeout(TimeoutEvent timeoutEvent) {
		getSipListener(timeoutEvent).processTimeout(timeoutEvent);
	}

	public void processIOException(IOExceptionEvent exceptionEvent) {
		fail("unexpected exception");

	}

	public void processTransactionTerminated(
			TransactionTerminatedEvent transactionTerminatedEvent) {
		getSipListener(transactionTerminatedEvent)
				.processTransactionTerminated(transactionTerminatedEvent);

	}

	public void processDialogTerminated(
			DialogTerminatedEvent dialogTerminatedEvent) {
		getSipListener(dialogTerminatedEvent).processDialogTerminated(
				dialogTerminatedEvent);

	}

}