cvs commit: spice/sandbox/sca/src/test/org/realityforge/sca/connector ActivePingerTestCase.java AlwaysReconnectPolicyTestCase.java ConnectorTestCase.java DebugMonitor.java InactivityPingPolicyTestCase.java LimitingReconnectPolicyTestCase.java MockConnector.java NeverPingPolicyTestCase.java NullMonitorTestCase.java PeriodicPingPolicyTestCase.java

donaldp     03/11/04 17:11:59

  Added:       sandbox/sca/src/test/org/realityforge/sca/connector
                        ActivePingerTestCase.java
                        AlwaysReconnectPolicyTestCase.java
                        ConnectorTestCase.java DebugMonitor.java
                        InactivityPingPolicyTestCase.java
                        LimitingReconnectPolicyTestCase.java
                        MockConnector.java NeverPingPolicyTestCase.java
                        NullMonitorTestCase.java
                        PeriodicPingPolicyTestCase.java
  Log:
  Migrate connector code into the sca toolkit
  
  Revision  Changes    Path
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/connector/ActivePingerTestCase.java
  
  Index: ActivePingerTestCase.java
  ===================================================================
  package org.realityforge.sca.connector;
  
  import junit.framework.TestCase;
  
  public class ActivePingerTestCase
     extends TestCase
  {
     public void testActivePingerPassedNullInCtor()
        throws Exception
     {
        try
        {
           new ActivePinger( null );
        }
        catch ( final NullPointerException npe )
        {
           assertEquals( "npe.getMessage()", "connector",npe.getMessage() );
        }
     }
  
     public void testActivePingerUsingNeverPingPolicy()
        throws Exception
     {
        final long now = System.currentTimeMillis();
        final MockConnector connector = new MockConnector( 0, 0, now );
        final ActivePinger pinger = new ActivePinger( connector );
        final Thread thread = new Thread( pinger );
        thread.start();
        while ( !pinger.hasStarted() )
        {
           Thread.sleep( 10 );
        }
  
        //An extra sleep so that it can actually call ping()
        Thread.sleep( 40 );
  
        //Join pinger again
        pinger.deactivate();
        thread.join();
  
        assertEquals( "pingCount", 0, connector.getPingCount() );
     }
  
     public void testActivePingerUsingPeriodicPingPolicy()
        throws Exception
     {
        final long now = System.currentTimeMillis();
        final MockConnector connector = new MockConnector( 0, 0, now );
        final PeriodicPingPolicy policy = new PeriodicPingPolicy( 2, connector );
        connector.setPingPolicy( policy );
        final ActivePinger pinger = new ActivePinger( connector );
        final Thread thread = new Thread( pinger );
        thread.start();
        while ( !pinger.hasStarted() )
        {
           Thread.sleep( 10 );
        }
  
        //An extra sleep so that it can actually call ping()
        Thread.sleep( 40 );
  
        //Join pinger again
        pinger.deactivate();
        thread.join();
  
        assertTrue( "pingCount", 0 < connector.getPingCount() );
     }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/connector/AlwaysReconnectPolicyTestCase.java
  
  Index: AlwaysReconnectPolicyTestCase.java
  ===================================================================
  package org.realityforge.sca.connector;
  
  import junit.framework.TestCase;
  
  public class AlwaysReconnectPolicyTestCase
     extends TestCase
  {
     public void testLimitingReconnectPolicy()
        throws Exception
     {
        final LimitingReconnectPolicy policy = new LimitingReconnectPolicy( 3, 3000 );
        final long now = System.currentTimeMillis();
        assertEquals( "attemptConnection",
                      true,
                      policy.attemptConnection( now, 0 ) );
        assertEquals( "disconnectOnError",
                      true,
                      policy.disconnectOnError( new Throwable() ) );
        assertEquals( "reconnectOnDisconnect",
                      true,
                      policy.reconnectOnDisconnect() );
     }
  
     public void testUnderThreshold()
        throws Exception
     {
        final LimitingReconnectPolicy policy = new LimitingReconnectPolicy( 3, 3000 );
        final long now = System.currentTimeMillis();
        assertEquals( "attemptConnection",
                      true,
                      policy.attemptConnection( now, 2 ) );
     }
  
     public void testOnThresholdNoDelay()
        throws Exception
     {
        final LimitingReconnectPolicy policy = new LimitingReconnectPolicy( 3, 3000 );
        final long now = System.currentTimeMillis();
        assertEquals( "attemptConnection",
                      false,
                      policy.attemptConnection( now, 3 ) );
     }
  
     public void testOnThresholdWithDelay()
        throws Exception
     {
        final LimitingReconnectPolicy policy = new LimitingReconnectPolicy( 3, 3000 );
        final long now = System.currentTimeMillis();
        assertEquals( "attemptConnection",
                      true,
                      policy.attemptConnection( now - 5000, 3 ) );
     }
  
     public void testOverThresholdNoDelay()
        throws Exception
     {
        final LimitingReconnectPolicy policy = new LimitingReconnectPolicy( 3, 3000 );
        final long now = System.currentTimeMillis();
        assertEquals( "attemptConnection",
                      false,
                      policy.attemptConnection( now, 4 ) );
     }
  
     public void testOverThresholdWithDelay()
        throws Exception
     {
        final LimitingReconnectPolicy policy = new LimitingReconnectPolicy( 3, 3000 );
        final long now = System.currentTimeMillis();
        assertEquals( "attemptConnection",
                      true,
                      policy.attemptConnection( now - 5000, 4 ) );
     }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/connector/ConnectorTestCase.java
  
  Index: ConnectorTestCase.java
  ===================================================================
  package org.realityforge.sca.connector;
  
  import com.mockobjects.dynamic.C;
  import com.mockobjects.dynamic.Mock;
  import junit.framework.TestCase;
  
  public class ConnectorTestCase
     extends TestCase
  {
     public void testSetPingPolicy()
        throws Exception
     {
        final Connector connector = new Connector();
        final NeverPingPolicy policy = new NeverPingPolicy();
        connector.setPingPolicy( policy );
        assertEquals( "PingPolicy", policy, connector.getPingPolicy() );
     }
  
     public void testSetNullPingPolicy()
        throws Exception
     {
        final Connector connector = new Connector();
        try
        {
           connector.setPingPolicy( null );
        }
        catch ( final NullPointerException npe )
        {
           assertEquals( "npe.message", "pingPolicy", npe.getMessage() );
           return;
        }
        fail( "Expected to fail due to NPE" );
     }
  
     public void testSetPolicy()
        throws Exception
     {
        final Connector connector = new Connector();
        final LimitingReconnectPolicy policy = new LimitingReconnectPolicy( 1, 1 );
        connector.setReconnectPolicy( policy );
        assertEquals( "policy", policy, connector.getReconnectPolicy() );
     }
  
     public void testSetNullPolicy()
        throws Exception
     {
        final Connector connector = new Connector();
        try
        {
           connector.setReconnectPolicy( null );
        }
        catch ( final NullPointerException npe )
        {
           assertEquals( "npe.message", "reconnectPolicy", npe.getMessage() );
           return;
        }
        fail( "Expected to fail due to NPE" );
     }
  
     public void testSetMonitor()
        throws Exception
     {
        final Connector connector = new Connector();
        final NullMonitor monitor = new NullMonitor();
        connector.setMonitor( monitor );
        assertEquals( "monitor", monitor, connector.getMonitor() );
     }
  
     public void testSetNullMonitor()
        throws Exception
     {
        final Connector connector = new Connector();
        try
        {
           connector.setMonitor( null );
        }
        catch ( final NullPointerException npe )
        {
           assertEquals( "npe.message", "monitor", npe.getMessage() );
           return;
        }
        fail( "Expected to fail due to NPE" );
     }
  
     public void testSetConnection()
        throws Exception
     {
        final Mock mock = new Mock( ConnectorConnection.class );
        final ConnectorConnection connection = (ConnectorConnection) mock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        assertEquals( "connection", connection, connector.getConnection() );
     }
  
     public void testGetConnectionPreSet()
        throws Exception
     {
        final Connector connector = new Connector();
        try
        {
           connector.getConnection();
        }
        catch ( final NullPointerException npe )
        {
           assertEquals( "npe.message", "connection", npe.getMessage() );
           return;
        }
        fail( "Expected to fail due to NPE" );
     }
  
     public void testSetNullConnection()
        throws Exception
     {
        final Connector connector = new Connector();
        try
        {
           connector.setConnection( null );
        }
        catch ( final NullPointerException npe )
        {
           assertEquals( "npe.message", "connection", npe.getMessage() );
           return;
        }
        fail( "Expected to fail due to NPE" );
     }
  
     public void testTransmissionOccured()
        throws Exception
     {
        final Connector connector = new Connector();
        final Object message = new Object();
        assertEquals( "time", 0, connector.getLastTxTime() );
        assertEquals( "message", null, connector.getLastTxMessage() );
        connector.transmissionOccured( message );
        final long now = System.currentTimeMillis();
        assertEqualTime( "time", now, connector.getLastTxTime() );
        assertEquals( "message", message, connector.getLastTxMessage() );
     }
  
     public void testReceiveOccured()
        throws Exception
     {
        final Connector connector = new Connector();
        final Object message = new Object();
        assertEquals( "time", 0, connector.getLastRxTime() );
        assertEquals( "message", null, connector.getLastRxMessage() );
        connector.receiveOccured( message );
        final long now = System.currentTimeMillis();
        assertEqualTime( "time", now, connector.getLastRxTime() );
        assertEquals( "message", message, connector.getLastRxMessage() );
     }
  
     public void testCommOccured()
        throws Exception
     {
        final Connector connector = new Connector();
        final Object message = new Object();
        assertEquals( "rx time", 0, connector.getLastRxTime() );
        assertEquals( "rx message", null, connector.getLastRxMessage() );
        assertEquals( "tx time", 0, connector.getLastTxTime() );
        assertEquals( "tx message", null, connector.getLastTxMessage() );
        connector.commOccured( message );
        final long now = System.currentTimeMillis();
        assertEqualTime( "time", now, connector.getLastRxTime() );
        assertEquals( "tx vs rx time", connector.getLastTxTime(), connector.getLastRxTime() );
        assertEquals( "rx message", message, connector.getLastRxMessage() );
        assertEquals( "tx message", message, connector.getLastTxMessage() );
     }
  
     public void testSuccessfulConnectOnDisconnected()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        connectorMock.expect( "doConnect", C.NO_ARGS );
  
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setActive( true );
        connector.setMonitor( DebugMonitor.MONITOR );
  
        assertEquals( "isConnected pre connect", false, connector.isConnected() );
        connector.connect();
        final long now = System.currentTimeMillis();
  
        assertEqualTime( "getPingTime", now, connector.getLastPingTime() );
  
        assertEquals( "getLastRxMessage", null, connector.getLastRxMessage() );
        assertEquals( "getLastTxMessage", null, connector.getLastTxMessage() );
        assertEqualTime( "getLastRxTime", now, connector.getLastRxTime() );
        assertEqualTime( "getLastTxTime", now, connector.getLastTxTime() );
        assertEqualTime( "getLastConnectionTime", now, connector.getLastConnectionTime() );
        assertEquals( "isConnected post connect", true, connector.isConnected() );
        assertEquals( "getConnectionAttempts", 0, connector.getConnectionAttempts() );
        assertEquals( "getConnectionError", null, connector.getConnectionError() );
  
        connectorMock.verify();
     }
  
     public void testSuccessfulConnectOnConnected()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        connectorMock.expect( "doDisconnect", C.NO_ARGS );
        connectorMock.expect( "doConnect", C.NO_ARGS );
  
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setActive( true );
        connector.setMonitor( DebugMonitor.MONITOR );
  
        connector.setConnected( true );
        connector.connect();
        final long now = System.currentTimeMillis();
  
        assertEqualTime( "getPingTime", now, connector.getLastPingTime() );
        assertEqualTime( "getLastConnectionTime", now, connector.getLastConnectionTime() );
        assertEquals( "getLastRxMessage", null, connector.getLastRxMessage() );
        assertEquals( "getLastTxMessage", null, connector.getLastTxMessage() );
        assertEqualTime( "getLastRxTime", now, connector.getLastRxTime() );
        assertEqualTime( "getLastTxTime", now, connector.getLastTxTime() );
        assertEquals( "isConnected post connect", true, connector.isConnected() );
        assertEquals( "getConnectionAttempts", 0, connector.getConnectionAttempts() );
        assertEquals( "getConnectionError", null, connector.getConnectionError() );
  
        connectorMock.verify();
     }
  
     public void testSuccessfulDisconnectOnConnected()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        connectorMock.expect( "doDisconnect", C.NO_ARGS );
  
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setActive( true );
  
        connector.setConnected( true );
        connector.disconnect();
        assertEquals( "isConnected", false, connector.isConnected() );
  
        connectorMock.verify();
     }
  
     public void testSuccessfulDisconnectOnDisconnected()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
  
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
  
        connector.setConnected( false );
        connector.disconnect();
        assertEquals( "isConnected", false, connector.isConnected() );
  
        connectorMock.verify();
     }
  
     public void testFailedDisconnect()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        final Exception exception = new Exception();
        connectorMock.expectAndThrow( "doDisconnect", C.NO_ARGS, exception );
  
        final Mock monitorMock = new Mock( ConnectorMonitor.class );
        monitorMock.expect( "attemptingDisconnection", C.NO_ARGS );
        monitorMock.expect( "errorDisconnecting", C.args( C.eq( exception ) ) );
        final ConnectorMonitor monitor = (ConnectorMonitor) monitorMock.proxy();
  
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setMonitor( monitor );
  
        connector.setConnected( true );
        connector.disconnect();
        assertEquals( "isConnected", false, connector.isConnected() );
  
        connectorMock.verify();
        monitorMock.verify();
     }
  
     public void testConnectOnInActive()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
  
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setActive( false );
        connector.connect();
        assertEquals( "isConnected", false, connector.isConnected() );
  
        connectorMock.verify();
     }
  
     public void testFailedConnect()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        final Exception exception = new Exception();
        connectorMock.expectAndThrow( "doConnect", C.NO_ARGS, exception );
  
        final Mock monitorMock = new Mock( ConnectorMonitor.class );
        monitorMock.expect( "attemptingConnection", C.NO_ARGS );
        monitorMock.expect( "errorConnecting", C.args( C.eq( exception ) ) );
        monitorMock.expect( "skippingConnectionAttempt", C.NO_ARGS );
        final ConnectorMonitor monitor = (ConnectorMonitor) monitorMock.proxy();
  
        final Mock policyMock = new Mock( ReconnectionPolicy.class );
        policyMock.expectAndReturn( "attemptConnection", C.args( C.eq( 0L ), C.eq( 0 ) ), true );
        policyMock.expectAndReturn( "attemptConnection", C.args( C.IS_ANYTHING, C.eq( 1 ) ), false );
        final ReconnectionPolicy policy = (ReconnectionPolicy) policyMock.proxy();
  
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setMonitor( monitor );
        connector.setReconnectPolicy( policy );
  
        connector.setActive( true );
        connector.connect();
        assertEquals( "isConnected", false, connector.isConnected() );
  
        connectorMock.verify();
        monitorMock.verify();
        policyMock.verify();
     }
  
     public void testVerifyConnectedOnConnected()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
  
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
  
        connector.setActive( true );
        connector.setConnected( true );
        connector.verifyConnected();
        assertEquals( "isConnected", true, connector.isConnected() );
  
        connectorMock.verify();
     }
  
     public void testVerifyConnectedOnDisconnected()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        connectorMock.expect( "doConnect", C.NO_ARGS );
  
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
  
        connector.setActive( true );
        connector.verifyConnected();
        assertEquals( "isConnected", true, connector.isConnected() );
  
        connectorMock.verify();
     }
  
     public void testDoValidateConnection()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        final Exception exception = new Exception();
        connectorMock.expectAndThrow( "doValidateConnection", C.NO_ARGS, exception );
        connectorMock.expect( "doConnect", C.NO_ARGS );
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Mock monitorMock = new Mock( ConnectorMonitor.class );
        monitorMock.expect( "errorValidatingConnection", C.args( C.eq( exception ) ) );
        monitorMock.expect( "attemptingConnection" );
        monitorMock.expect( "connectionEstablished" );
        final ConnectorMonitor monitor = (ConnectorMonitor) monitorMock.proxy();
  
        final Mock policyMock = new Mock( ReconnectionPolicy.class );
        policyMock.expectAndReturn( "reconnectOnDisconnect", C.NO_ARGS, true );
        policyMock.expectAndReturn( "attemptConnection", C.anyArgs( 2 ), true );
  
        final ReconnectionPolicy policy = (ReconnectionPolicy) policyMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setMonitor( monitor );
        connector.setReconnectPolicy( policy );
  
        connector.setActive( true );
        connector.doValidateConnection();
  
        assertEquals( "isConnected", true, connector.isConnected() );
        assertEquals( "getConnectionError",
                      null,
                      connector.getConnectionError() );
  
        connectorMock.verify();
        policyMock.verify();
        monitorMock.verify();
     }
  
     public void testDoValidateConnectionWithNoReconnect()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        final Exception exception = new Exception();
        connectorMock.expectAndThrow( "doValidateConnection", C.NO_ARGS, exception );
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Mock monitorMock = new Mock( ConnectorMonitor.class );
        monitorMock.expect( "errorValidatingConnection", C.args( C.eq( exception ) ) );
        final ConnectorMonitor monitor = (ConnectorMonitor) monitorMock.proxy();
  
        final Mock policyMock = new Mock( ReconnectionPolicy.class );
        policyMock.expectAndReturn( "reconnectOnDisconnect", C.NO_ARGS, false );
  
        final ReconnectionPolicy policy = (ReconnectionPolicy) policyMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setMonitor( monitor );
        connector.setReconnectPolicy( policy );
  
        connector.setActive( true );
        connector.doValidateConnection();
  
        assertEquals( "isConnected", false, connector.isConnected() );
        assertEquals( "getConnectionError",
                      exception.toString(),
                      connector.getConnectionError() );
  
        connectorMock.verify();
        policyMock.verify();
        monitorMock.verify();
     }
  
     public void testValidateConnectionOnConnected()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        connectorMock.expect( "doValidateConnection", C.NO_ARGS );
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Mock monitorMock = new Mock( ConnectorMonitor.class );
        monitorMock.expect( "attemptingValidation", C.NO_ARGS );
        final ConnectorMonitor monitor = (ConnectorMonitor) monitorMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setMonitor( monitor );
  
        connector.setActive( true );
        connector.setConnected( true );
        connector.validateConnection();
  
        assertEquals( "isConnected", true, connector.isConnected() );
  
        connectorMock.verify();
        monitorMock.verify();
     }
  
     public void testValidateConnectionOnNonVerified()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Mock monitorMock = new Mock( ConnectorMonitor.class );
        monitorMock.expect( "attemptingValidation", C.NO_ARGS );
        final ConnectorMonitor monitor = (ConnectorMonitor) monitorMock.proxy();
  
        final Mock policyMock = new Mock( ReconnectionPolicy.class );
        final ReconnectionPolicy policy = (ReconnectionPolicy) policyMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setMonitor( monitor );
        connector.setReconnectPolicy( policy );
  
        connector.setActive( false );
        final boolean result = connector.validateConnection();
  
        assertEquals( "result", false, result );
        assertEquals( "isConnected", false, connector.isConnected() );
  
        connectorMock.verify();
        monitorMock.verify();
        policyMock.verify();
     }
  
     public void testPing()
        throws Exception
     {
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        connectorMock.expect( "doValidateConnection", C.NO_ARGS );
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Mock monitorMock = new Mock( ConnectorMonitor.class );
        monitorMock.expect( "attemptingValidation", C.NO_ARGS );
        final ConnectorMonitor monitor = (ConnectorMonitor) monitorMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setMonitor( monitor );
  
        connector.setActive( true );
        connector.setConnected( true );
        connector.ping();
  
        final long now = System.currentTimeMillis();
        assertEqualTime( "getPingTime", now, connector.getLastPingTime() );
        assertEquals( "isConnected", true, connector.isConnected() );
  
        connectorMock.verify();
        monitorMock.verify();
     }
  
     public void testCommErrorOccuredAndDisconnectAndReconnect()
        throws Exception
     {
        final Exception exception = new Exception();
  
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        connectorMock.expect( "doDisconnect", C.NO_ARGS );
        connectorMock.expect( "doConnect", C.NO_ARGS );
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Mock policyMock = new Mock( ReconnectionPolicy.class );
        policyMock.expectAndReturn( "disconnectOnError", C.args( C.eq( exception ) ), true );
        policyMock.expectAndReturn( "reconnectOnDisconnect", C.NO_ARGS, true );
        policyMock.expectAndReturn( "attemptConnection", C.anyArgs( 2 ), true );
        final ReconnectionPolicy policy = (ReconnectionPolicy) policyMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setReconnectPolicy( policy );
  
        connector.setActive( true );
        connector.setConnected( true );
  
        connector.commErrorOccured( exception );
  
        assertEquals( "isConnected", true, connector.isConnected() );
  
        connectorMock.verify();
        policyMock.verify();
     }
  
     public void testCommErrorOccuredAndDisconnect()
        throws Exception
     {
        final Exception exception = new Exception();
  
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        connectorMock.expect( "doDisconnect", C.NO_ARGS );
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Mock policyMock = new Mock( ReconnectionPolicy.class );
        policyMock.expectAndReturn( "disconnectOnError", C.args( C.eq( exception ) ), true );
        policyMock.expectAndReturn( "reconnectOnDisconnect", C.NO_ARGS, false );
        final ReconnectionPolicy policy = (ReconnectionPolicy) policyMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setReconnectPolicy( policy );
  
        connector.setActive( true );
        connector.setConnected( true );
  
        connector.commErrorOccured( exception );
  
        assertEquals( "isConnected", false, connector.isConnected() );
  
        connectorMock.verify();
        policyMock.verify();
     }
  
     public void testCommErrorOccuredAndNoDisconnect()
        throws Exception
     {
        final Exception exception = new Exception();
  
        final Mock connectorMock = new Mock( ConnectorConnection.class );
        final ConnectorConnection connection = (ConnectorConnection) connectorMock.proxy();
  
        final Mock policyMock = new Mock( ReconnectionPolicy.class );
        policyMock.expectAndReturn( "disconnectOnError", C.args( C.eq( exception ) ), false );
        final ReconnectionPolicy policy = (ReconnectionPolicy) policyMock.proxy();
  
        final Connector connector = new Connector();
        connector.setConnection( connection );
        connector.setReconnectPolicy( policy );
  
        connector.setActive( true );
        connector.setConnected( true );
  
        connector.commErrorOccured( exception );
  
        assertEquals( "isConnected", true, connector.isConnected() );
  
        policyMock.verify();
        connectorMock.verify();
     }
  
     public void testCheckPingThatPings()
        throws Exception
     {
        final Connector connector = new Connector();
  
        final Mock monitorMock = new Mock( ConnectorMonitor.class );
        monitorMock.expect( "attemptingValidation", C.NO_ARGS );
        final ConnectorMonitor monitor = (ConnectorMonitor) monitorMock.proxy();
  
        final Mock policyMock = new Mock( PingPolicy.class );
        policyMock.expectAndReturn( "checkPingConnection", C.NO_ARGS, true );
        policyMock.expectAndReturn( "nextPingCheck", C.NO_ARGS, new Long( 52 ) );
        final PingPolicy policy = (PingPolicy) policyMock.proxy();
  
        connector.setMonitor( monitor );
        connector.setPingPolicy( policy );
        connector.setActive( false );
  
        final long result = connector.checkPing();
        assertEquals( "result", 52, result );
        final long now = System.currentTimeMillis();
        assertEqualTime( "getLastPingTime", now, connector.getLastPingTime() );
  
        policyMock.verify();
        monitorMock.verify();
     }
  
     public void testCheckPingThatNoPings()
        throws Exception
     {
        final Connector connector = new Connector();
  
        final Mock monitorMock = new Mock( ConnectorMonitor.class );
        final ConnectorMonitor monitor = (ConnectorMonitor) monitorMock.proxy();
  
        final Mock policyMock = new Mock( PingPolicy.class );
        policyMock.expectAndReturn( "checkPingConnection", C.NO_ARGS, false );
        policyMock.expectAndReturn( "nextPingCheck", C.NO_ARGS, new Long( 52 ) );
        final PingPolicy policy = (PingPolicy) policyMock.proxy();
  
        connector.setMonitor( monitor );
        connector.setPingPolicy( policy );
        connector.setActive( false );
  
        final long result = connector.checkPing();
        assertEquals( "result", 52, result );
        assertEqualTime( "getLastPingTime", 0, connector.getLastPingTime() );
  
        policyMock.verify();
        monitorMock.verify();
     }
  
     private void assertEqualTime( final String description, final long expected, final long actual )
     {
        assertEquals( description, expected, actual, 500.0 );
     }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/connector/DebugMonitor.java
  
  Index: DebugMonitor.java
  ===================================================================
  package org.realityforge.sca.connector;
  
  /**
   * A debug monitor that prints all messages to standard out.
   */
  class DebugMonitor
     extends NullMonitor
     implements ConnectorMonitor
  {
     /**
      * A constant containing instance of null monitor.
      */
     public static final DebugMonitor MONITOR = new DebugMonitor();
  
     /**
      * @see ConnectorMonitor#attemptingConnection
      */
     public void attemptingConnection()
     {
        System.out.println( "attemptingConnection" );
        super.attemptingConnection();
     }
  
     /**
      * @see ConnectorMonitor#connectionEstablished
      */
     public void connectionEstablished()
     {
        System.out.println( "connectionEstablished" );
        super.connectionEstablished();
     }
  
     /**
      * @see ConnectorMonitor#errorConnecting
      */
     public void errorConnecting( final Throwable t )
     {
        System.out.println( "errorConnecting(" + t + ")" );
        super.errorConnecting( t );
     }
  
     /**
      * @see ConnectorMonitor#errorDisconnecting
      */
     public void errorDisconnecting( final Throwable t )
     {
        System.out.println( "errorDisconnecting(" + t + ")" );
        super.errorDisconnecting( t );
     }
  
     /**
      * @see ConnectorMonitor#attemptingValidation
      */
     public void attemptingValidation()
     {
        System.out.println( "attemptingValidation" );
        super.attemptingValidation();
     }
  
     /**
      * @see ConnectorMonitor#errorValidatingConnection
      */
     public void errorValidatingConnection( final Throwable t )
     {
        System.out.println( "errorValidatingConnection(" + t + ")" );
        super.errorValidatingConnection( t );
     }
  
     /**
      * @see ConnectorMonitor#skippingConnectionAttempt
      */
     public void skippingConnectionAttempt()
     {
        System.out.println( "skippingConnectionAttempt" );
        super.skippingConnectionAttempt();
     }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/connector/InactivityPingPolicyTestCase.java
  
  Index: InactivityPingPolicyTestCase.java
  ===================================================================
  package org.realityforge.sca.connector;
  
  import junit.framework.TestCase;
  
  public class InactivityPingPolicyTestCase
     extends TestCase
  {
     public void testInactivityPingPolicyWithNeitherTxOrRxSet()
        throws Exception
     {
        final MockConnector connector = new MockConnector( 0, 0, 0 );
        final InactivityPingPolicy policy = new InactivityPingPolicy( -1, connector );
        assertEquals( "nextPingCheck",
                      Long.MAX_VALUE,
                      policy.nextPingCheck() );
        assertEquals( "checkPingConnection",
                      false,
                      policy.checkPingConnection() );
     }
  
     public void testInactivityPingPolicyWithNeitherTxSetNeedingPing()
        throws Exception
     {
        final long now = System.currentTimeMillis();
        final long lastTx = now - 100;
        final long tx = 5;
        final MockConnector connector = new MockConnector( lastTx, 0, 0 );
        final InactivityPingPolicy policy = new InactivityPingPolicy( tx, -1, connector );
        assertEquals( "nextPingCheck",
                      lastTx + tx,
                      policy.nextPingCheck() );
        assertEquals( "checkPingConnection",
                      true,
                      policy.checkPingConnection() );
     }
  
     public void testInactivityPingPolicyWithNeitherTxSetNotNeedingPing()
        throws Exception
     {
        final long now = System.currentTimeMillis();
        final long lastTx = now - 100;
        final long tx = 500;
        final MockConnector connector = new MockConnector( lastTx, 0, 0 );
        final InactivityPingPolicy policy = new InactivityPingPolicy( tx, -1, connector );
        assertEquals( "nextPingCheck",
                      lastTx + tx,
                      policy.nextPingCheck() );
        assertEquals( "checkPingConnection",
                      false,
                      policy.checkPingConnection() );
     }
  
     public void testInactivityPingPolicyWithNeitherRxSetNeedingPing()
        throws Exception
     {
        final long now = System.currentTimeMillis();
        final long lastRx = now - 100;
        final long rx = 5;
        final MockConnector connector = new MockConnector( 0, lastRx, 0 );
        final InactivityPingPolicy policy = new InactivityPingPolicy( -1, rx, connector );
        assertEquals( "nextPingCheck",
                      lastRx + rx,
                      policy.nextPingCheck() );
        assertEquals( "checkPingConnection",
                      true,
                      policy.checkPingConnection() );
     }
  
     public void testInactivityPingPolicyWithNeitherRxSetNotNeedingPing()
        throws Exception
     {
        final long now = System.currentTimeMillis();
        final long lastRx = now - 100;
        final long rx = 500;
        final MockConnector connector = new MockConnector( 0, lastRx, 0 );
        final InactivityPingPolicy policy = new InactivityPingPolicy( -1, rx, connector );
        assertEquals( "nextPingCheck",
                      lastRx + rx,
                      policy.nextPingCheck() );
        assertEquals( "checkPingConnection",
                      false,
                      policy.checkPingConnection() );
     }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/connector/LimitingReconnectPolicyTestCase.java
  
  Index: LimitingReconnectPolicyTestCase.java
  ===================================================================
  package org.realityforge.sca.connector;
  
  import junit.framework.TestCase;
  
  public class LimitingReconnectPolicyTestCase
     extends TestCase
  {
     public void testAlwaysReconnectPolicy()
        throws Exception
     {
        final AlwaysReconnectPolicy policy = AlwaysReconnectPolicy.POLICY;
        assertEquals( "attemptConnection",
                      true,
                      policy.attemptConnection( 0, 0 ) );
        assertEquals( "disconnectOnError",
                      true,
                      policy.disconnectOnError( new Throwable() ) );
        assertEquals( "reconnectOnDisconnect",
                      true,
                      policy.reconnectOnDisconnect() );
     }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/connector/MockConnector.java
  
  Index: MockConnector.java
  ===================================================================
  package org.realityforge.sca.connector;
  
  class MockConnector
     extends Connector
  {
     private final long _lastTxTime;
     private final long _lastRxTime;
     private long _lastPingTime;
     private int _pingCount;
  
     MockConnector( final long lastTxTime,
                    final long lastRxTime,
                    final long lastPingTime )
     {
        _lastTxTime = lastTxTime;
        _lastRxTime = lastRxTime;
        _lastPingTime = lastPingTime;
     }
  
     public long getLastPingTime()
     {
        return _lastPingTime;
     }
  
     public long getLastTxTime()
     {
        return _lastTxTime;
     }
  
     public long getLastRxTime()
     {
        return _lastRxTime;
     }
  
     public boolean ping()
     {
        _lastPingTime = System.currentTimeMillis();
        _pingCount++;
        return true;
     }
  
     int getPingCount()
     {
        return _pingCount;
     }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/connector/NeverPingPolicyTestCase.java
  
  Index: NeverPingPolicyTestCase.java
  ===================================================================
  package org.realityforge.sca.connector;
  
  import junit.framework.TestCase;
  
  public class NeverPingPolicyTestCase
     extends TestCase
  {
     public void testNeverPingPolicy()
        throws Exception
     {
        final NeverPingPolicy policy = NeverPingPolicy.POLICY;
        final long lastPingTime = System.currentTimeMillis();
        assertEquals( "nextPingCheck",
                      Long.MAX_VALUE,
                      policy.nextPingCheck() );
        assertEquals( "checkPingConnection",
                      false,
                      policy.checkPingConnection() );
     }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/connector/NullMonitorTestCase.java
  
  Index: NullMonitorTestCase.java
  ===================================================================
  package org.realityforge.sca.connector;
  
  import junit.framework.TestCase;
  
  public class NullMonitorTestCase
     extends TestCase
  {
     public void testNullMonitor()
        throws Exception
     {
        final NullMonitor monitor = new NullMonitor();
        monitor.attemptingConnection();
        monitor.attemptingValidation();
        monitor.connectionEstablished();
        monitor.errorConnecting( null );
        monitor.errorDisconnecting( null );
        monitor.errorValidatingConnection( null );
        monitor.skippingConnectionAttempt();
        monitor.attemptingDisconnection();
     }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/connector/PeriodicPingPolicyTestCase.java
  
  Index: PeriodicPingPolicyTestCase.java
  ===================================================================
  package org.realityforge.sca.connector;
  
  import junit.framework.TestCase;
  
  public class PeriodicPingPolicyTestCase
     extends TestCase
  {
     public void testNeverPingPolicy()
        throws Exception
     {
        final long lastPingTime = System.currentTimeMillis();
        final MockConnector connector = new MockConnector( 0, 0, lastPingTime );
        final PeriodicPingPolicy policy = new PeriodicPingPolicy( 100, connector );
        assertEquals( "nextPingCheck",
                      lastPingTime + 100,
                      policy.nextPingCheck() );
        assertEquals( "checkPingConnection",
                      true,
                      policy.checkPingConnection() );
     }
  }
  
  
  


-------------------------------------------------------
This SF.net email is sponsored by: SF.net Giveback Program.
Does SourceForge.net help you be more productive?  Does it
help you create better code?   SHARE THE LOVE, and help us help
YOU!  Click Here: http://sourceforge.net/donate/