/*
 * Jitsi, the OpenSource Java VoIP and Instant Messaging client.
 *
 * Copyright @ 2015 Atlassian Pty Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.java.sip.communicator.slick.protocol.jabber;

import java.text.*;
import java.util.*;

import junit.framework.*;
import net.java.sip.communicator.service.protocol.*;
import net.java.sip.communicator.service.protocol.event.*;
import net.java.sip.communicator.util.*;

/**
 * Tests Basic telephony functionality by making one provider call the other.
 *
 * @author Emil Ivov
 * @author Symphorien Wanko
 */
public class TestOperationSetBasicTelephonyJabberImpl
    extends TestCase
{
    private static final Logger logger
        = Logger.getLogger(TestOperationSetBasicTelephonyJabberImpl.class);

    /**
     * Provides constants and some utilities method.
     */
    private JabberSlickFixture fixture = new JabberSlickFixture();

    /**
     * Initializes the test with the specified <tt>name</tt>.
     *
     * @param name the name of the test to initialize.
     */
    public TestOperationSetBasicTelephonyJabberImpl(String name)
    {
        super(name);
    }

    /**
     * JUnit setup method.
     * @throws Exception in case anything goes wrong.
     */
    @Override
    protected void setUp() throws Exception
    {
        super.setUp();
        fixture.setUp();
    }

    /**
     * JUnit teardown method.
     * @throws Exception in case anything goes wrong.
     */
    @Override
    protected void tearDown() throws Exception
    {
        fixture.tearDown();
        super.tearDown();
    }

    /**
     * Creates a call from provider1 to provider2 then cancels it without
     * waiting for provider1 to answer.
     *
     * @throws ParseException if we hand a malformed URI to someone
     * @throws OperationFailedException if something weird happens.
     */
    public void testCreateCancelCall()
        throws ParseException, OperationFailedException
    {
        OperationSetBasicTelephony<?> basicTelephonyP1
            = fixture.provider1.getOperationSet(
                OperationSetBasicTelephony.class);
        OperationSetBasicTelephony<?> basicTelephonyP2
            = fixture.provider2.getOperationSet(
                OperationSetBasicTelephony.class);

        CallEventCollector call1Listener
            = new CallEventCollector(basicTelephonyP1);
        CallEventCollector call2Listener
            = new CallEventCollector(basicTelephonyP2);

        //Provider1 calls Provider2
        String provider2Address
            = fixture.provider2.getAccountID().getAccountAddress();

        Call callAtP1 = basicTelephonyP1.createCall(provider2Address);

        call1Listener.waitForEvent(10000);
        call2Listener.waitForEvent(10000);

        //make sure that both listeners have received their events.
        assertEquals("The provider that created the call did not dispatch "
                     + "an event that it has done so."
                     , 1, call1Listener.collectedEvents.size());
        //call1 listener checks
        CallEvent callCreatedEvent
            = (CallEvent)call1Listener.collectedEvents.get(0);

        assertEquals("CallEvent.getEventID()"
                     ,CallEvent.CALL_INITIATED, callCreatedEvent.getEventID());
        assertSame("CallEvent.getSource()"
                     , callAtP1, callCreatedEvent.getSource());

        //call2 listener checks
        assertTrue("The callee provider did not receive a call or did "
                     +"not issue an event."
                     , call2Listener.collectedEvents.size() > 0);
        CallEvent callReceivedEvent
            = (CallEvent)call2Listener.collectedEvents.get(0);
        Call callAtP2 = callReceivedEvent.getSourceCall();

        assertEquals("CallEvent.getEventID()"
                     ,CallEvent.CALL_RECEIVED, callReceivedEvent.getEventID());
        assertNotNull("CallEvent.getSource()", callAtP2);

        //verify that call peers are properly created
        assertEquals("callAtP1.getCallPeerCount()"
                     , 1, callAtP1.getCallPeerCount());
        assertEquals("callAtP2.getCallPeerCount()"
                     , 1, callAtP2.getCallPeerCount());

        CallPeer peerAtP1 = callAtP1.getCallPeers().next();
        CallPeer peerAtP2 = callAtP2.getCallPeers().next();

        //now add listeners to the peers and make sure they have entered
        //the states they were expected to.
        //check states for call peers at both parties
        CallPeerStateEventCollector stateCollectorForPp1
            = new CallPeerStateEventCollector(
                peerAtP1, CallPeerState.ALERTING_REMOTE_SIDE);
        CallPeerStateEventCollector stateCollectorForPp2
            = new CallPeerStateEventCollector(
                peerAtP2, CallPeerState.INCOMING_CALL);

        stateCollectorForPp1.waitForEvent(10000, true);
        stateCollectorForPp2.waitForEvent(10000, true);

        assertSame("peerAtP1.getCall"
                   , peerAtP1.getCall(), callAtP1);
        assertSame("peerAtP2.getCall"
                   , peerAtP2.getCall(), callAtP2);

        //make sure that the peers are in the proper state
        assertEquals("The peer at provider one was not in the "
                     +"right state."
                    , CallPeerState.ALERTING_REMOTE_SIDE
                    , peerAtP1.getState());
        assertEquals("The peer at provider two was not in the "
                     +"right state."
                    , CallPeerState.INCOMING_CALL
                    , peerAtP2.getState());


        //test whether caller/callee info is properly distributed in case
        //the server is said to support it.
        if(Boolean.getBoolean("accounts.jabber.PRESERVE_PEER_INFO"))
        {
            //check properties on the remote call peer for the party that
            //initiated the call.
            String expectedPeer1Address
                = fixture.provider2.getAccountID().getAccountAddress();
            String expectedPeer1DisplayName
                = System.getProperty(
                    JabberProtocolProviderServiceLick.ACCOUNT_2_PREFIX
                    + ProtocolProviderFactory.DISPLAY_NAME);

            //do not asser equals here since one of the addresses may contain a
            //display name or something of the kind
            assertTrue("Provider 2 did not advertise their "
                       + "accountID.getAccoutAddress() address."
                       , expectedPeer1Address.indexOf(
                           peerAtP1.getAddress()) != -1
                       || peerAtP1.getAddress().indexOf(
                           expectedPeer1Address) != -1);
            assertEquals("Provider 2 did not properly advertise their "
                         + "display name."
                         , expectedPeer1DisplayName
                         , peerAtP1.getDisplayName());

            //check properties on the remote call peer for the party that
            //receives the call.
            String expectedPeer2Address
                = fixture.provider1.getAccountID().getAccountAddress();
            String expectedPeer2DisplayName
                = System.getProperty(
                    JabberProtocolProviderServiceLick.ACCOUNT_1_PREFIX
                    + ProtocolProviderFactory.DISPLAY_NAME);

            //do not asser equals here since one of the addresses may contain a
            //display name or something of the kind
            assertTrue("Provider 1 did not advertise their "
                       + "accountID.getAccoutAddress() address."
                       , expectedPeer2Address.indexOf(
                           peerAtP2.getAddress()) != -1
                       || peerAtP2.getAddress().indexOf(
                           expectedPeer2Address) != -1);
            assertEquals("Provider 1 did not properly advertise their "
                         + "display name."
                         , expectedPeer2DisplayName
                         , peerAtP2.getDisplayName());
        }

        //we'll now try to cancel the call

        //listeners monitoring state change of the peer
        stateCollectorForPp1 = new CallPeerStateEventCollector(
                peerAtP1, CallPeerState.DISCONNECTED);
        stateCollectorForPp2 = new CallPeerStateEventCollector(
                peerAtP2, CallPeerState.DISCONNECTED);

        //listeners waiting for the op set to announce the end of the call
        call1Listener = new CallEventCollector(basicTelephonyP1);
        call2Listener = new CallEventCollector(basicTelephonyP2);

        //listeners monitoring the state of the call
        CallStateEventCollector call1StateCollector
            = new CallStateEventCollector(callAtP1, CallState.CALL_ENDED);
        CallStateEventCollector call2StateCollector
            = new CallStateEventCollector(callAtP2, CallState.CALL_ENDED);

        //Now make the caller CANCEL the call.
        basicTelephonyP1.hangupCallPeer(peerAtP1);

        //wait for everything to happen
        call1Listener.waitForEvent(10000);
        call2Listener.waitForEvent(10000);
        stateCollectorForPp1.waitForEvent(10000);
        stateCollectorForPp2.waitForEvent(10000);
        call1StateCollector.waitForEvent(10000);
        call2StateCollector.waitForEvent(10000);


        //make sure that the peer is disconnected
        assertEquals("The peer at provider one was not in the "
                     +"right state."
                    , CallPeerState.DISCONNECTED
                    , peerAtP1.getState());

        //make sure the telephony operation set distributed an event for the end
        //of the call
        assertEquals("The basic telephony operation set did not distribute "
                     +"an event to notify us that a call has been ended."
                    , 1
                    , call1Listener.collectedEvents.size());

        CallEvent collectedEvent
            = (CallEvent)call1Listener.collectedEvents.get(0);

        assertEquals("The basic telephony operation set did not distribute "
                     +"an event to notify us that a call has been ended."
                     , CallEvent.CALL_ENDED
                     , collectedEvent.getEventID());

        //same for provider 2

        //make sure that the peer is disconnected
        assertEquals("The peer at provider one was not in the "
                     +"right state."
                    , CallPeerState.DISCONNECTED
                    , peerAtP2.getState());

        //make sure the telephony operation set distributed an event for the end
        //of the call
        assertEquals("The basic telephony operation set did not distribute "
                     +"an event to notify us that a call has been ended."
                    , 1
                    , call2Listener.collectedEvents.size());

        collectedEvent
            = (CallEvent)call2Listener.collectedEvents.get(0);

        assertEquals("The basic telephony operation set did not distribute "
                     +"an event to notify us that a call has been ended."
                     , CallEvent.CALL_ENDED
                     , collectedEvent.getEventID());

        //make sure that the call objects are in an ENDED state.
        assertEquals("A call did not change its state to CallState.CALL_ENDED "
                     +"when it ended."
                     , CallState.CALL_ENDED
                     , callAtP1.getCallState());
        assertEquals("A call did not change its state to CallState.CALL_ENDED "
                     +"when it ended."
                     , CallState.CALL_ENDED
                     , callAtP2.getCallState());
    }

    /**
     * Creates a call from provider1 to provider2 then rejects the call from the
     * side of provider2 (provider2 replies with busy-tone).
     *
     * @throws ParseException if we hand a malformed URI to someone
     * @throws OperationFailedException if something weird happens.
     */
    public void testCreateRejectCall()
        throws ParseException, OperationFailedException
    {
        OperationSetBasicTelephony<?> basicTelephonyP1
            = fixture.provider1.getOperationSet(
                OperationSetBasicTelephony.class);
        OperationSetBasicTelephony<?> basicTelephonyP2
            = fixture.provider2.getOperationSet(
                OperationSetBasicTelephony.class);

        CallEventCollector call1Listener
            = new CallEventCollector(basicTelephonyP1);
        CallEventCollector call2Listener
            = new CallEventCollector(basicTelephonyP2);

        //Provider1 calls Provider2
        String provider2Address
            = fixture.provider2.getAccountID().getAccountAddress();

        Call callAtP1 = basicTelephonyP1.createCall(provider2Address);

        call1Listener.waitForEvent(10000);
        call2Listener.waitForEvent(10000);

        //make sure that both listeners have received their events.
        assertEquals("The provider that created the call did not dispatch "
                     + "an event that it has done so."
                     , 1, call1Listener.collectedEvents.size());
        //call1 listener checks
        CallEvent callCreatedEvent
            = (CallEvent)call1Listener.collectedEvents.get(0);

        assertEquals("CallEvent.getEventID()"
                     ,CallEvent.CALL_INITIATED, callCreatedEvent.getEventID());
        assertSame("CallEvent.getSource()"
                     , callAtP1, callCreatedEvent.getSource());

        //call2 listener checks
        assertTrue("The callee provider did not receive a call or did "
                     +"not issue an event."
                     , call2Listener.collectedEvents.size() > 0);
        CallEvent callReceivedEvent
            = (CallEvent)call2Listener.collectedEvents.get(0);
        Call callAtP2 = callReceivedEvent.getSourceCall();

        assertEquals("CallEvent.getEventID()"
                     ,CallEvent.CALL_RECEIVED, callReceivedEvent.getEventID());
        assertNotNull("CallEvent.getSource()", callAtP2);

        //verify that call peers are properly created
        assertEquals("callAtP1.getCallPeerCount()"
                     , 1, callAtP1.getCallPeerCount());
        assertEquals("callAtP2.getCallPeerCount()"
                     , 1, callAtP2.getCallPeerCount());

        CallPeer peerAtP1 = callAtP1.getCallPeers().next();
        CallPeer peerAtP2 = callAtP2.getCallPeers().next();

        //now add listeners to the peers and make sure they have entered
        //the states they were expected to.
        //check states for call peers at both parties
        CallPeerStateEventCollector stateCollectorForPp1
            = new CallPeerStateEventCollector(
                peerAtP1, CallPeerState.ALERTING_REMOTE_SIDE);
        CallPeerStateEventCollector stateCollectorForPp2
            = new CallPeerStateEventCollector(
                peerAtP2, CallPeerState.INCOMING_CALL);

        stateCollectorForPp1.waitForEvent(10000, true);
        stateCollectorForPp2.waitForEvent(10000, true);

        assertSame("peerAtP1.getCall"
                   , peerAtP1.getCall(), callAtP1);
        assertSame("peerAtP2.getCall"
                   , peerAtP2.getCall(), callAtP2);

        //make sure that the peers are in the proper state
        assertEquals("The peer at provider one was not in the "
                     +"right state."
                    , CallPeerState.ALERTING_REMOTE_SIDE
                    , peerAtP1.getState());
        assertEquals("The peer at provider two was not in the "
                     +"right state."
                    , CallPeerState.INCOMING_CALL
                    , peerAtP2.getState());


        //test whether caller/callee info is properly distributed in case
        //the server is said to support it.
        if(Boolean.getBoolean("accounts.jabber.PRESERVE_PEER_INFO"))
        {
            //check properties on the remote call peer for the party that
            //initiated the call.
            String expectedPeer1Address
                = fixture.provider2.getAccountID().getAccountAddress();
            String expectedPeer1DisplayName
                = System.getProperty(
                    JabberProtocolProviderServiceLick.ACCOUNT_2_PREFIX
                    + ProtocolProviderFactory.DISPLAY_NAME);

            //do not asser equals here since one of the addresses may contain a
            //display name or something of the kind
            assertTrue("Provider 2 did not advertise their "
                       + "accountID.getAccoutAddress() address."
                       , expectedPeer1Address.indexOf(
                           peerAtP1.getAddress()) != -1
                       || peerAtP1.getAddress().indexOf(
                           expectedPeer1Address) != -1);
            assertEquals("Provider 2 did not properly advertise their "
                         + "display name."
                         , expectedPeer1DisplayName
                         , peerAtP1.getDisplayName());

            //check properties on the remote call peer for the party that
            //receives the call.
            String expectedPeer2Address
                = fixture.provider1.getAccountID().getAccountAddress();
            String expectedPeer2DisplayName
                = System.getProperty(
                    JabberProtocolProviderServiceLick.ACCOUNT_1_PREFIX
                    + ProtocolProviderFactory.DISPLAY_NAME);

            //do not asser equals here since one of the addresses may contain a
            //display name or something of the kind
            assertTrue("Provider 1 did not advertise their "
                       + "accountID.getAccoutAddress() address."
                       , expectedPeer2Address.indexOf(
                           peerAtP2.getAddress()) != -1
                       || peerAtP2.getAddress().indexOf(
                           expectedPeer2Address) != -1);
            assertEquals("Provider 1 did not properly advertise their "
                         + "display name."
                         , expectedPeer2DisplayName
                         , peerAtP2.getDisplayName());
        }

        //we'll now try to send busy tone.

        //listeners monitoring state change of the peer
        CallPeerStateEventCollector busyStateCollectorForPp1
            = new CallPeerStateEventCollector(
                peerAtP1, CallPeerState.BUSY);
        stateCollectorForPp1 = new CallPeerStateEventCollector(
                peerAtP1, CallPeerState.DISCONNECTED);
        stateCollectorForPp2 = new CallPeerStateEventCollector(
                peerAtP2, CallPeerState.DISCONNECTED);

        //listeners waiting for the op set to announce the end of the call
        call1Listener = new CallEventCollector(basicTelephonyP1);
        call2Listener = new CallEventCollector(basicTelephonyP2);

        //listeners monitoring the state of the call
        CallStateEventCollector call1StateCollector
            = new CallStateEventCollector(callAtP1, CallState.CALL_ENDED);
        CallStateEventCollector call2StateCollector
            = new CallStateEventCollector(callAtP2, CallState.CALL_ENDED);

        //Now make the caller CANCEL the call.
        basicTelephonyP2.hangupCallPeer(peerAtP2);
        busyStateCollectorForPp1.waitForEvent(10000);
        basicTelephonyP1.hangupCallPeer(peerAtP1);

        //wait for everything to happen
        call1Listener.waitForEvent(10000);
        call2Listener.waitForEvent(10000);
        stateCollectorForPp1.waitForEvent(10000);
        stateCollectorForPp2.waitForEvent(10000);
        call1StateCollector.waitForEvent(10000);
        call2StateCollector.waitForEvent(10000);


        //make sure that the peer is disconnected
        assertEquals("The peer at provider one was not in the "
                     +"right state."
                    , CallPeerState.DISCONNECTED
                    , peerAtP1.getState());



        //make sure the telephony operation set distributed an event for the end
        //of the call
        assertEquals("The basic telephony operation set did not distribute "
                     +"an event to notify us that a call has been ended."
                    , 1
                    , call1Listener.collectedEvents.size());

        CallEvent collectedEvent
            = (CallEvent)call1Listener.collectedEvents.get(0);

        assertEquals("The basic telephony operation set did not distribute "
                     +"an event to notify us that a call has been ended."
                     , CallEvent.CALL_ENDED
                     , collectedEvent.getEventID());

        //same for provider 2

        //make sure that the peer is disconnected
        assertEquals("The peer at provider one was not in the "
                     +"right state."
                    , CallPeerState.DISCONNECTED
                    , peerAtP2.getState());

        //make sure the telephony operation set distributed an event for the end
        //of the call
        assertEquals("The basic telephony operation set did not distribute "
                     +"an event to notify us that a call has been ended."
                    , 1
                    , call2Listener.collectedEvents.size());

        collectedEvent
            = (CallEvent)call2Listener.collectedEvents.get(0);

        assertEquals("The basic telephony operation set did not distribute "
                     +"an event to notify us that a call has been ended."
                     , CallEvent.CALL_ENDED
                     , collectedEvent.getEventID());

        //make sure that the call objects are in an ENDED state.
        assertEquals("A call did not change its state to CallState.CALL_ENDED "
                     +"when it ended."
                     , CallState.CALL_ENDED
                     , callAtP1.getCallState());
        assertEquals("A call did not change its state to CallState.CALL_ENDED "
                     +"when it ended."
                     , CallState.CALL_ENDED
                     , callAtP2.getCallState());
    }

    /**
     * Creates a call from provider1 to provider2, makes provider2 answer it
     * and then reject it.
     *
     * @throws ParseException if we hand a malformed URI to someone
     * @throws OperationFailedException if something weird happens.
     */
    public void aTestCreateAnswerHangupCall()
        throws ParseException, OperationFailedException
    {
        OperationSetBasicTelephony<?> basicTelephonyP1
            = fixture.provider1.getOperationSet(
                OperationSetBasicTelephony.class);
        OperationSetBasicTelephony<?> basicTelephonyP2
            = fixture.provider2.getOperationSet(
                OperationSetBasicTelephony.class);

        CallEventCollector call1Listener
            = new CallEventCollector(basicTelephonyP1);
        CallEventCollector call2Listener
            = new CallEventCollector(basicTelephonyP2);

        //Provider1 calls Provider2
        String provider2Address
            = fixture.provider2.getAccountID().getAccountAddress();

        Call callAtP1 = basicTelephonyP1.createCall(provider2Address);

        call1Listener.waitForEvent(10000);
        call2Listener.waitForEvent(10000);

        //make sure that both listeners have received their events.
        assertEquals("The provider that created the call did not dispatch "
                     + "an event that it has done so."
                     , 1, call1Listener.collectedEvents.size());
        //call1 listener checks
        CallEvent callCreatedEvent
            = (CallEvent)call1Listener.collectedEvents.get(0);

        assertEquals("CallEvent.getEventID()"
                     ,CallEvent.CALL_INITIATED, callCreatedEvent.getEventID());
        assertSame("CallEvent.getSource()"
                     , callAtP1, callCreatedEvent.getSource());

        //call2 listener checks
        assertTrue("The callee provider did not receive a call or did "
                     +"not issue an event."
                     , call2Listener.collectedEvents.size() > 0);
        CallEvent callReceivedEvent
            = (CallEvent)call2Listener.collectedEvents.get(0);
        Call callAtP2 = callReceivedEvent.getSourceCall();

        assertEquals("CallEvent.getEventID()"
                     ,CallEvent.CALL_RECEIVED, callReceivedEvent.getEventID());
        assertNotNull("CallEvent.getSource()", callAtP2);

        //verify that call peers are properly created
        assertEquals("callAtP1.getCallPeerCount()"
                     , 1, callAtP1.getCallPeerCount());
        assertEquals("callAtP2.getCallPeerCount()"
                     , 1, callAtP2.getCallPeerCount());

        CallPeer peerAtP1 = callAtP1.getCallPeers().next();
        CallPeer peerAtP2 = callAtP2.getCallPeers().next();

        //now add listeners to the peers and make sure they have entered
        //the states they were expected to.
        //check states for call peers at both parties
        CallPeerStateEventCollector stateCollectorForPp1
            = new CallPeerStateEventCollector(
                peerAtP1, CallPeerState.ALERTING_REMOTE_SIDE);
        CallPeerStateEventCollector stateCollectorForPp2
            = new CallPeerStateEventCollector(
                peerAtP2, CallPeerState.INCOMING_CALL);

        stateCollectorForPp1.waitForEvent(10000, true);
        stateCollectorForPp2.waitForEvent(10000, true);

        assertSame("peerAtP1.getCall"
                   , peerAtP1.getCall(), callAtP1);
        assertSame("peerAtP2.getCall"
                   , peerAtP2.getCall(), callAtP2);

        //make sure that the peers are in the proper state
        assertEquals("The peer at provider one was not in the "
                     +"right state."
                    , CallPeerState.ALERTING_REMOTE_SIDE
                    , peerAtP1.getState());
        assertEquals("The peer at provider two was not in the "
                     +"right state."
                    , CallPeerState.INCOMING_CALL
                    , peerAtP2.getState());


        //test whether caller/callee info is properly distributed in case
        //the server is said to support it.
        if(Boolean.getBoolean("accounts.jabber.PRESERVE_PEER_INFO"))
        {
            //check properties on the remote call peer for the party that
            //initiated the call.
            String expectedPeer1Address
                = fixture.provider2.getAccountID().getAccountAddress();
            String expectedPeer1DisplayName
                = System.getProperty(
                    JabberProtocolProviderServiceLick.ACCOUNT_2_PREFIX
                    + ProtocolProviderFactory.DISPLAY_NAME);

            //do not assert equals here since one of the addresses may contain a
            //display name or something of the kind
            assertTrue("Provider 2 did not advertise their "
                       + "accountID.getAccoutAddress() address."
                       , expectedPeer1Address.indexOf(
                           peerAtP1.getAddress()) != -1
                       || peerAtP1.getAddress().indexOf(
                           expectedPeer1Address) != -1);
            assertEquals("Provider 2 did not properly advertise their "
                         + "display name."
                         , expectedPeer1DisplayName
                         , peerAtP1.getDisplayName());

            //check properties on the remote call peer for the party that
            //receives the call.
            String expectedPeer2Address
                = fixture.provider1.getAccountID().getAccountAddress();
            String expectedPeer2DisplayName
                = System.getProperty(
                    JabberProtocolProviderServiceLick.ACCOUNT_1_PREFIX
                    + ProtocolProviderFactory.DISPLAY_NAME);

            //do not asser equals here since one of the addresses may contain a
            //display name or something of the kind
            assertTrue("Provider 1 did not advertise their "
                       + "accountID.getAccoutAddress() address."
                       , expectedPeer2Address.indexOf(
                           peerAtP2.getAddress()) != -1
                       || peerAtP2.getAddress().indexOf(
                           expectedPeer2Address) != -1);
            assertEquals("Provider 1 did not properly advertise their "
                         + "display name."
                         , expectedPeer2DisplayName
                         , peerAtP2.getDisplayName());
        }

        //add listeners to the peers and make sure enter
        //a connected state after we answer
        stateCollectorForPp1
            = new CallPeerStateEventCollector(
                peerAtP1, CallPeerState.CONNECTED);
        stateCollectorForPp2
            = new CallPeerStateEventCollector(
                peerAtP2, CallPeerState.CONNECTED);

        //we will now anser the call and verify that both parties change states
        //accordingly.
        basicTelephonyP2.answerCallPeer(peerAtP2);

        stateCollectorForPp1.waitForEvent(10000);
        stateCollectorForPp2.waitForEvent(10000);

        //make sure that the peers are in the proper state
        assertEquals("The peer at provider one was not in the "
                     +"right state."
                    , CallPeerState.CONNECTED
                    , peerAtP1.getState());
        assertEquals("The peer at provider two was not in the "
                     +"right state."
                    , CallPeerState.CONNECTED
                    , peerAtP2.getState());

        //make sure that events have been distributed when states were changed.
        assertEquals("No event was dispatched when a call peer changed "
                     +"its state."
                    , 1
                    , stateCollectorForPp1.collectedEvents.size());
        assertEquals("No event was dispatched when a call peer changed "
                     +"its state."
                     , 1
                     , stateCollectorForPp2.collectedEvents.size());

        //add listeners to the peers and make sure they have entered
        //the states they are expected to.
        stateCollectorForPp1
            = new CallPeerStateEventCollector(
                peerAtP1, CallPeerState.DISCONNECTED);
        stateCollectorForPp2
            = new CallPeerStateEventCollector(
                peerAtP2, CallPeerState.DISCONNECTED);

        //we will now end the call and verify that both parties change states
        //accordingly.
        basicTelephonyP2.hangupCallPeer(peerAtP2);

        stateCollectorForPp1.waitForEvent(10000);
        stateCollectorForPp2.waitForEvent(10000);

        //make sure that the peers are in the proper state
        assertEquals("The peer at provider one was not in the "
                     +"right state."
                    , CallPeerState.DISCONNECTED
                    , peerAtP1.getState());
        assertEquals("The peer at provider two was not in the "
                     +"right state."
                    , CallPeerState.DISCONNECTED
                    , peerAtP2.getState());

        //make sure that the corresponding events were delivered.
        assertEquals("a provider did not distribute an event when a call "
                     +"peer changed states."
                    , 1
                    , stateCollectorForPp1.collectedEvents.size());
        assertEquals("a provider did not distribute an event when a call "
                     +"peer changed states."
                    , 1
                    , stateCollectorForPp2.collectedEvents.size());

    }

    /**
     * Allows tests to wait for and collect events issued upon creation and
     * reception of calls.
     */
    public class CallEventCollector implements CallListener
    {
        public ArrayList<EventObject> collectedEvents = new ArrayList<EventObject>();
        public OperationSetBasicTelephony<?> listenedOpSet = null;

        /**
         * Creates an instance of this call event collector and registers it
         * with listenedOpSet.
         * @param listenedOpSet the operation set that we will be scanning for
         * new calls.
         */
        public CallEventCollector(OperationSetBasicTelephony<?> listenedOpSet)
        {
            this.listenedOpSet = listenedOpSet;
            this.listenedOpSet.addCallListener(this);
        }

        /**
         * Blocks until at least one event is received or until waitFor
         * miliseconds pass (whichever happens first).
         *
         * @param waitFor the number of miliseconds that we should be waiting
         * for an event before simply bailing out.
         */
        public void waitForEvent(long waitFor)
        {
            logger.trace("Waiting for a CallEvent");

            synchronized(this)
            {
                if(collectedEvents.size() > 0){
                    logger.trace("Event already received. " + collectedEvents);
                    listenedOpSet.removeCallListener(this);
                    return;
                }

                try{
                    wait(waitFor);
                    if(collectedEvents.size() > 0)
                        logger.trace("Received a CallEvent.");
                    else
                        logger.trace("No CallEvent received for "+waitFor+"ms.");

                    listenedOpSet.removeCallListener(this);
                }
                catch (InterruptedException ex)
                {
                    logger.debug(
                        "Interrupted while waiting for a call event", ex);
                }
            }
        }

        /**
         * Stores the received event and notifies all waiting on this object
         * @param event the event containing the source call.
         */
        public void incomingCallReceived(CallEvent event)
        {
            synchronized(this)
            {
                logger.debug(
                    "Collected evt("+collectedEvents.size()+")= "+event);

                this.collectedEvents.add(event);
                notifyAll();
            }
        }

        /**
         * Stores the received event and notifies all waiting on this object
         * @param event the event containing the source call.
         */
        public void outgoingCallCreated(CallEvent event)
        {
            synchronized(this)
            {
                logger.debug(
                    "Collected evt("+collectedEvents.size()+")= "+event);

                this.collectedEvents.add(event);
                notifyAll();
            }

        }

        /**
         * Stores the received event and notifies all waiting on this object
         * @param event the event containing the source call.
         */
        public void callEnded(CallEvent event)
        {
            synchronized(this)
            {
                logger.debug(
                    "Collected evt("+collectedEvents.size()+")= "+event);

                this.collectedEvents.add(event);
                notifyAll();
            }
        }
    }

    /**
     * Allows tests to wait for and collect events issued upon call peer
     * status changes.
     */
    public class CallPeerStateEventCollector
        extends CallPeerAdapter
    {
        public ArrayList<EventObject> collectedEvents = new ArrayList<EventObject>();
        private CallPeer listenedCallPeer = null;
        public CallPeerState awaitedState = null;

        /**
         * Creates an instance of this collector and adds it as a listener
         * to <tt>callPeer</tt>.
         * @param callPeer the CallPeer that we will be listening
         * to.
         * @param awaitedState the state that we will be waiting for inside
         * this collector.
         */
        public CallPeerStateEventCollector(
                                            CallPeer      callPeer,
                                            CallPeerState awaitedState)
        {
            this.listenedCallPeer = callPeer;
            this.listenedCallPeer.addCallPeerListener(this);
            this.awaitedState = awaitedState;
        }

        /**
         * Stores the received event and notifies all waiting on this object
         *
         * @param event the event containing the source call.
         */
        @Override
        public void peerStateChanged(CallPeerChangeEvent event)
        {
            synchronized(this)
            {
                logger.debug(
                    "Collected evt("+collectedEvents.size()+")= "+event);

                if(event.getNewValue()
                    .equals(awaitedState))
                {
                    this.collectedEvents.add(event);
                    notifyAll();
                }
            }
        }

        /**
         * Blocks until an event notifying us of the awaited state change is
         * received or until waitFor miliseconds pass (whichever happens first).
         *
         * @param waitFor the number of miliseconds that we should be waiting
         * for an event before simply bailing out.
         */
        public void waitForEvent(long waitFor)
        {
            waitForEvent(waitFor, false);
        }

        /**
         * Blocks until an event notifying us of the awaited state change is
         * received or until waitFor miliseconds pass (whichever happens first).
         *
         * @param waitFor the number of miliseconds that we should be waiting
         * for an event before simply bailing out.
         * @param exitIfAlreadyInState specifies whether the method is to return
         * if the call peer is already in such a state even if no event
         * has been received for the sate change.
         */
        public void waitForEvent(long waitFor, boolean exitIfAlreadyInState)
        {
            logger.trace("Waiting for a CallPeerEvent with newState="
                            + awaitedState + " for peer "
                            + this.listenedCallPeer);
            synchronized (this)
            {
                if(exitIfAlreadyInState
                   && listenedCallPeer.getState().equals(awaitedState))
                {
                    logger.trace("Src peer is already in the awaited "
                                 + "state."
                                 + collectedEvents);
                    listenedCallPeer.removeCallPeerListener(this);
                    return;
                }
                if(collectedEvents.size() > 0)
                {
                    CallPeerChangeEvent lastEvent
                        = (CallPeerChangeEvent) collectedEvents
                        .get(collectedEvents.size() - 1);

                    if (lastEvent.getNewValue().equals(awaitedState))
                    {
                        logger.trace("Event already received. " +
                                     collectedEvents);
                        listenedCallPeer
                            .removeCallPeerListener(this);
                        return;
                    }
                }
                try
                {
                    wait(waitFor);

                    if (collectedEvents.size() > 0)
                        logger.trace("Received a CallParticpantStateEvent.");
                    else
                        logger.trace("No CallParticpantStateEvent received for "
                                     + waitFor + "ms.");

                    listenedCallPeer
                        .removeCallPeerListener(this);
                }
                catch (InterruptedException ex)
                {
                    logger.debug("Interrupted while waiting for a "
                                 + "CallParticpantEvent"
                                 , ex);
                }
            }
        }
    }

    /**
     * Allows tests to wait for and collect events issued upon call state
     * changes.
     */
    public class CallStateEventCollector
        extends CallChangeAdapter
    {
        public ArrayList<EventObject> collectedEvents = new ArrayList<EventObject>();
        private Call listenedCall = null;
        public CallState awaitedState = null;

        /**
         * Creates an instance of this collector and adds it as a listener
         * to <tt>call</tt>.
         * @param call the Call that we will be listening to.
         * @param awaitedState the state that we will be waiting for inside
         * this collector.
         */
        public CallStateEventCollector(Call      call,
                                       CallState awaitedState)
        {
            this.listenedCall = call;
            this.listenedCall.addCallChangeListener(this);
            this.awaitedState = awaitedState;
        }

        /**
         * Stores the received event and notifies all waiting on this object
         *
         * @param event the event containing the source call.
         */
        @Override
        public void callStateChanged(CallChangeEvent event)
        {
            synchronized(this)
            {
                logger.debug(
                    "Collected evt("+collectedEvents.size()+")= "+event);

                if(event.getNewValue().equals(awaitedState))
                {
                    this.collectedEvents.add(event);
                    notifyAll();
                }
            }
        }

        /**
         * Blocks until an event notifying us of the awaited state change is
         * received or until waitFor miliseconds pass (whichever happens first).
         *
         * @param waitFor the number of miliseconds that we should be waiting
         * for an event before simply bailing out.
         */
        public void waitForEvent(long waitFor)
        {
            logger.trace("Waiting for a CallParticpantEvent");
            synchronized (this)
            {
                if (listenedCall.getCallState() == awaitedState)
                {
                    logger.trace("Event already received. " +
                                 collectedEvents);
                    listenedCall.removeCallChangeListener(this);
                    return;
                }

                try
                {
                    wait(waitFor);

                    if (collectedEvents.size() > 0)
                        logger.trace("Received a CallChangeEvent.");
                    else
                        logger.trace("No CallChangeEvent received for "
                                     + waitFor + "ms.");

                    listenedCall.removeCallChangeListener(this);
                }
                catch (InterruptedException ex)
                {
                    logger.debug("Interrupted while waiting for a "
                                 + "CallParticpantEvent"
                                 , ex);
                }
            }
        }
    }

}
