cvs commit: spice/sandbox/sca/src/test/org/realityforge/sca/selector/impl DebugSelectorMonitor.java DelayingSelectorEventHandler.java HelloSelectorEventHandler.java MockSelector.java NullSelectorEventHandlerTestCase.java NullSelectorMonitorTestCase.java SelectorEntryTestCase.java SelectorManagerTestCase.java

donaldp     03/10/29 18:46:32

  Added:       sandbox/sca/src/test/org/realityforge/sca/selector/impl
                        DebugSelectorMonitor.java
                        DelayingSelectorEventHandler.java
                        HelloSelectorEventHandler.java MockSelector.java
                        NullSelectorEventHandlerTestCase.java
                        NullSelectorMonitorTestCase.java
                        SelectorEntryTestCase.java
                        SelectorManagerTestCase.java
  Log:
  Initial cut of selector code based on that previously in netserve
  
  Revision  Changes    Path
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/selector/impl/DebugSelectorMonitor.java
  
  Index: DebugSelectorMonitor.java
  ===================================================================
  package org.realityforge.sca.selector.impl;
  
  import java.io.IOException;
  import java.nio.channels.SelectionKey;
  import org.realityforge.sca.selector.impl.SelectorMonitor;
  
  class DebugSelectorMonitor
      implements SelectorMonitor
  {
      public void selectorStartup()
      {
          System.out.println( "selectorStartup()" );
      }
  
      public void enteringSelectorLoop()
      {
          System.out.println( "enteringSelectorLoop()" );
      }
  
      public void enteringSelect()
      {
          System.out.println( "enteringSelect()" );
      }
  
      public void selectCompleted( int count )
      {
          System.out.println( "selectCompleted(" + count + ")" );
      }
  
      public void handlingSelectEvent( SelectionKey key )
      {
          System.out.println( "handlingSelectEvent(" + key + ")" );
      }
  
      public void exitingSelectorLoop()
      {
          System.out.println( "exitingSelectorLoop()" );
      }
  
      public void selectorShutdown()
      {
          System.out.println( "selectorShutdown()" );
      }
  
      public void errorClosingSelector( IOException ioe )
      {
          System.out.println( "errorClosingSelector(" + ioe + ")" );
      }
  
      public void invalidAttachment( SelectionKey key )
      {
          System.out.println( "invalidAttachment(" + key + ")" );
      }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/selector/impl/DelayingSelectorEventHandler.java
  
  Index: DelayingSelectorEventHandler.java
  ===================================================================
  package org.realityforge.sca.selector.impl;
  
  import java.nio.channels.SelectionKey;
  
  import org.realityforge.sca.selector.SelectorEventHandler;
  
  class DelayingSelectorEventHandler
     implements SelectorEventHandler
  {
     private final long m_delay;
  
     DelayingSelectorEventHandler( long delay )
     {
        m_delay = delay;
     }
  
     public void handleSelectorEvent( SelectionKey key, Object userData )
     {
        while ( true )
        {
           try
           {
              Thread.sleep( m_delay );
              System.out.println( "Exiting delay loop" );
              return;
           }
           catch ( InterruptedException e )
           {
           }
        }
     }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/selector/impl/HelloSelectorEventHandler.java
  
  Index: HelloSelectorEventHandler.java
  ===================================================================
  package org.realityforge.sca.selector.impl;
  
  import java.io.IOException;
  import java.nio.channels.SelectionKey;
  import java.nio.channels.ServerSocketChannel;
  import java.nio.channels.SocketChannel;
  import org.realityforge.sca.selector.SelectorEventHandler;
  
  class HelloSelectorEventHandler
      implements SelectorEventHandler
  {
      static final byte[] MESSAGE = "HELLO!".getBytes();
  
      public void handleSelectorEvent( SelectionKey key, Object userData )
      {
          final ServerSocketChannel channel = (ServerSocketChannel)key.channel();
          try
          {
              final SocketChannel socket = channel.accept();
              socket.socket().getOutputStream().write( MESSAGE );
              socket.socket().close();
          }
          catch( IOException e )
          {
              e.printStackTrace();
          }
      }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/selector/impl/MockSelector.java
  
  Index: MockSelector.java
  ===================================================================
  package org.realityforge.sca.selector.impl;
  
  import java.io.IOException;
  import java.nio.channels.Selector;
  import java.nio.channels.spi.SelectorProvider;
  import java.util.Set;
  
  class MockSelector
      extends Selector
  {
      static final IOException EXCEPTION = new IOException( "Blah!" );
  
      public boolean isOpen()
      {
          return false;
      }
  
      public SelectorProvider provider()
      {
          return null;
      }
  
      public Set keys()
      {
          return null;
      }
  
      public Set selectedKeys()
      {
          return null;
      }
  
      public int selectNow() throws IOException
      {
          return 0;
      }
  
      public int select( long timeout )
          throws IOException
      {
          return 0;
      }
  
      public int select() throws IOException
      {
          return 0;
      }
  
      public Selector wakeup()
      {
          return null;
      }
  
      public void close() throws IOException
      {
          EXCEPTION.fillInStackTrace();
          throw EXCEPTION;
      }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/selector/impl/NullSelectorEventHandlerTestCase.java
  
  Index: NullSelectorEventHandlerTestCase.java
  ===================================================================
  package org.realityforge.sca.selector.impl;
  
  import junit.framework.TestCase;
  import org.realityforge.sca.selector.impl.NullSelectorEventHandler;
  
  public class NullSelectorEventHandlerTestCase
      extends TestCase
  {
      public void testNullSelectorEventHandler()
          throws Exception
      {
          NullSelectorEventHandler.HANDLER.handleSelectorEvent( null, null );
      }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/selector/impl/NullSelectorMonitorTestCase.java
  
  Index: NullSelectorMonitorTestCase.java
  ===================================================================
  package org.realityforge.sca.selector.impl;
  
  import junit.framework.TestCase;
  import org.realityforge.sca.selector.impl.NullSelectorMonitor;
  
  public class NullSelectorMonitorTestCase
      extends TestCase
  {
      public void testNullSelectorEventHandler()
          throws Exception
      {
          final NullSelectorMonitor monitor = new NullSelectorMonitor();
          monitor.enteringSelect();
          monitor.enteringSelectorLoop();
          monitor.errorClosingSelector( null );
          monitor.exitingSelectorLoop();
          monitor.handlingSelectEvent( null );
          monitor.selectorStartup();
          monitor.selectorShutdown();
          monitor.selectCompleted( 2 );
          monitor.invalidAttachment( null );
      }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/selector/impl/SelectorEntryTestCase.java
  
  Index: SelectorEntryTestCase.java
  ===================================================================
  package org.realityforge.sca.selector.impl;
  
  import junit.framework.TestCase;
  import org.realityforge.sca.selector.impl.SelectorEntry;
  import org.realityforge.sca.selector.impl.HelloSelectorEventHandler;
  
  public class SelectorEntryTestCase
     extends TestCase
  {
     public void testSelectorEntry()
        throws Exception
     {
        final HelloSelectorEventHandler handler = new HelloSelectorEventHandler();
        final Object userData = new Object();
        final SelectorEntry entry =
           new SelectorEntry( handler, userData );
        assertEquals( "handler", handler, entry.getHandler() );
        assertEquals( "userData", userData, entry.getUserData() );
     }
  
     public void testNullHandlerInSelectorEntryCtor()
        throws Exception
     {
        try
        {
           new SelectorEntry( null, null );
        }
        catch ( final NullPointerException npe )
        {
           assertEquals( "npe.getMessage()", "handler", npe.getMessage() );
           return;
        }
        fail( "Expected to fail due to passing null handler into ctor" );
     }
  }
  
  
  
  1.1                  spice/sandbox/sca/src/test/org/realityforge/sca/selector/impl/SelectorManagerTestCase.java
  
  Index: SelectorManagerTestCase.java
  ===================================================================
  package org.realityforge.sca.selector.impl;
  
  import com.mockobjects.dynamic.C;
  import com.mockobjects.dynamic.Mock;
  import java.io.InputStream;
  import java.net.InetAddress;
  import java.net.InetSocketAddress;
  import java.net.Socket;
  import java.nio.channels.SelectionKey;
  import java.nio.channels.Selector;
  import java.nio.channels.ServerSocketChannel;
  import java.util.Random;
  import junit.framework.TestCase;
  import org.realityforge.sca.selector.impl.DefaultSelectorManager;
  import org.realityforge.sca.selector.impl.NullSelectorMonitor;
  import org.realityforge.sca.selector.impl.SelectorMonitor;
  import org.realityforge.sca.selector.impl.DelayingSelectorEventHandler;
  import org.realityforge.sca.selector.impl.HelloSelectorEventHandler;
  import org.realityforge.sca.selector.impl.MockSelector;
  
  public class SelectorManagerTestCase
      extends TestCase
  {
      public void testSetMonitorUsingNonNull()
          throws Exception
      {
          final DefaultSelectorManager manager = new DefaultSelectorManager();
          final NullSelectorMonitor monitor = new NullSelectorMonitor();
          manager.setMonitor( monitor );
          assertEquals( "monitor", monitor, manager.getMonitor() );
      }
  
      public void testSetMonitorUsingNull()
          throws Exception
      {
          final DefaultSelectorManager manager = new DefaultSelectorManager();
          try
          {
              manager.setMonitor( null );
          }
          catch( final NullPointerException npe )
          {
              assertEquals( "npe.getMessage()", "monitor", npe.getMessage() );
              return;
          }
          fail( "expected to fail with npe" );
      }
  
      public void testRegisterChannelWithNullChanneld()
          throws Exception
      {
          final DefaultSelectorManager manager = new DefaultSelectorManager();
          try
          {
              manager.registerChannel( null, 0, null, null );
          }
          catch( final NullPointerException npe )
          {
              assertEquals( "npe.getMessage()", "channel", npe.getMessage() );
              return;
          }
          fail( "expected to fail with npe" );
      }
  
      public void testStartupAndShutdownSelectorManager()
          throws Exception
      {
          final Mock mockMonitor = new Mock( SelectorMonitor.class );
  
          mockMonitor.expect( "selectorStartup", C.NO_ARGS );
          mockMonitor.expect( "enteringSelectorLoop", C.NO_ARGS );
          mockMonitor.expect( "enteringSelect", C.NO_ARGS );
          mockMonitor.expect( "selectCompleted", C.args( C.eq( 0 ) ) );
          mockMonitor.expect( "exitingSelectorLoop", C.NO_ARGS );
          mockMonitor.expect( "selectorShutdown", C.NO_ARGS );
          final SelectorMonitor monitor = (SelectorMonitor)mockMonitor.proxy();
  
          final DefaultSelectorManager manager = new DefaultSelectorManager();
          manager.setTimeout( 4000 );
          manager.setMonitor( monitor );
          assertEquals( "isRunning pre start", false, manager.isRunning() );
          assertNullSelector( manager );
          manager.startup();
          assertEquals( "isRunning post start", true, manager.isRunning() );
          assertNotNull( "getSelector post start", manager.getSelector() );
          Thread.sleep( 150 );
          manager.shutdown();
          assertNullSelector( manager );
          assertEquals( "isRunning post shutdown", false, manager.isRunning() );
  
          mockMonitor.verify();
      }
  
      public void testShutdownSelectorManagerWithoutStatrup()
          throws Exception
      {
          final Mock mockMonitor = new Mock( SelectorMonitor.class );
          final SelectorMonitor monitor = (SelectorMonitor)mockMonitor.proxy();
  
          final DefaultSelectorManager manager = new DefaultSelectorManager();
          manager.setMonitor( monitor );
          manager.setTimeout( 400 );
          assertEquals( "isRunning pre shutdown", false, manager.isRunning() );
          assertNullSelector( manager );
          manager.shutdown();
          assertNullSelector( manager );
          assertEquals( "isRunning post shutdown", false, manager.isRunning() );
  
          mockMonitor.verify();
      }
  
      public void testShutdownSelectorInErrorState()
          throws Exception
      {
          final Mock mockMonitor = new Mock( SelectorMonitor.class );
  
          mockMonitor.expect( "selectorShutdown", C.NO_ARGS );
          mockMonitor.expect( "errorClosingSelector", C.args( C.eq( MockSelector.EXCEPTION ) ) );
          final SelectorMonitor monitor = (SelectorMonitor)mockMonitor.proxy();
  
          final DefaultSelectorManager manager = new DefaultSelectorManager();
          manager.setTimeout( 4000 );
          manager.setMonitor( monitor );
  
          final Selector selector = new MockSelector();
          manager.setSelector( selector );
          manager.shutdownSelector();
          assertNotNull( "getSelector post start", manager.getSelector() );
  
          mockMonitor.verify();
      }
  
      public void testSimpleConnect()
          throws Exception
      {
          final ServerSocketChannel channel = ServerSocketChannel.open();
          channel.socket().setReuseAddress( true );
          final InetAddress localAddress = InetAddress.getLocalHost();
          final Random random = new Random();
          final int port = Math.abs( random.nextInt() % 5000 ) + 1024;
          final InetSocketAddress address = new InetSocketAddress( localAddress, port );
          channel.socket().bind( address );
          System.out.println( "address = " + address );
          while ( !channel.socket().isBound() )
          {
             System.out.print( "." );
             Thread.yield();
          }
  
          final Mock mockMonitor = new Mock( SelectorMonitor.class );
  
          mockMonitor.expect( "selectorStartup", C.NO_ARGS );
          mockMonitor.expect( "enteringSelectorLoop", C.NO_ARGS );
          mockMonitor.expect( "enteringSelect", C.NO_ARGS );
          mockMonitor.expect( "selectCompleted", C.args( C.eq( 0 ) ) );
          mockMonitor.expect( "enteringSelect", C.NO_ARGS );
          mockMonitor.expect( "selectCompleted", C.args( C.eq( 1 ) ) );
          mockMonitor.expect( "enteringSelect", C.NO_ARGS );
          mockMonitor.expect( "selectorShutdown", C.NO_ARGS );
          mockMonitor.expect( "selectCompleted", C.args( C.eq( 0 ) ) );
          mockMonitor.expect( "exitingSelectorLoop", C.NO_ARGS );
          final SelectorMonitor monitor = (SelectorMonitor)mockMonitor.proxy();
  
          final DefaultSelectorManager manager = new DefaultSelectorManager();
          manager.setTimeout( 5000 );
          manager.setMonitor( monitor );
  
          assertEquals( "isRunning pre start", false, manager.isRunning() );
          assertNullSelector( manager );
          manager.startup();
          assertEquals( "isRunning post start", true, manager.isRunning() );
          assertNotNull( "getSelector post start", manager.getSelector() );
  
          manager.registerChannel( channel,
                                   SelectionKey.OP_ACCEPT,
                                   new HelloSelectorEventHandler(),
                                   null );
  
          final Socket clientSocket = new Socket( localAddress, port );
          System.out.print( "Socket Connecting" );
          while( !clientSocket.isConnected() )
          {
              System.out.print( "." );
              Thread.yield();
          }
          System.out.println( " - Connected" );
  
          final InputStream inputStream = clientSocket.getInputStream();
          final StringBuffer sb = new StringBuffer();
          while( sb.length() < HelloSelectorEventHandler.MESSAGE.length )
          {
              System.out.print( "-" );
              final int ch = inputStream.read();
              if( -1 != ch )
              {
                  sb.append( (char)ch );
              }
          }
          clientSocket.close();
          System.out.println( "Message " + sb );
          assertEquals( "message",
                        new String( HelloSelectorEventHandler.MESSAGE ),
                        sb.toString() );
          Thread.sleep( 50 );
          manager.shutdown();
          assertNullSelector( manager );
          assertEquals( "isRunning post shutdown", false, manager.isRunning() );
  
          mockMonitor.verify();
      }
  
      public void testInvalidAttachment()
          throws Exception
      {
          final ServerSocketChannel channel = ServerSocketChannel.open();
          channel.socket().setReuseAddress( true );
          final InetAddress localAddress = InetAddress.getLocalHost();
          final Random random = new Random();
          final int port = Math.abs( random.nextInt() % 5000 ) + 1024;
          final InetSocketAddress address = new InetSocketAddress( localAddress, port );
          channel.socket().bind( address );
          while ( !channel.socket().isBound() )
          {
             System.out.print( "." );
             Thread.yield();
          }
  
          final Mock mockMonitor = new Mock( SelectorMonitor.class );
  
          mockMonitor.expect( "selectorStartup", C.NO_ARGS );
          mockMonitor.expect( "enteringSelectorLoop", C.NO_ARGS );
          mockMonitor.expect( "enteringSelect", C.NO_ARGS );
          mockMonitor.expect( "selectCompleted", C.args( C.eq( 0 ) ) );
          mockMonitor.expect( "enteringSelect", C.NO_ARGS );
          mockMonitor.expect( "selectCompleted", C.args( C.eq( 1 ) ) );
          mockMonitor.expect( "invalidAttachment", C.anyArgs( 1 ) );
          mockMonitor.expect( "enteringSelect", C.NO_ARGS );
          mockMonitor.expect( "selectorShutdown", C.NO_ARGS );
          mockMonitor.expect( "selectCompleted", C.args( C.eq( 0 ) ) );
          mockMonitor.expect( "exitingSelectorLoop", C.NO_ARGS );
          final SelectorMonitor monitor = (SelectorMonitor)mockMonitor.proxy();
  
          final DefaultSelectorManager manager = new DefaultSelectorManager();
          manager.setTimeout( 5000 );
          manager.setMonitor( monitor );
  
          assertEquals( "isRunning pre start", false, manager.isRunning() );
          assertNullSelector( manager );
          manager.startup();
          assertEquals( "isRunning post start", true, manager.isRunning() );
          assertNotNull( "getSelector post start", manager.getSelector() );
  
          final SelectionKey key =
            manager.registerChannel( channel,
                                          SelectionKey.OP_ACCEPT,
                                          new HelloSelectorEventHandler(),
                                          null );
          key.attach( null );
  
          final Socket clientSocket = new Socket( localAddress, port );
          System.out.print( "Socket Connecting to Key with InvalidAttachment" );
          while( !clientSocket.isConnected() )
          {
              System.out.print( "." );
              Thread.yield();
          }
          System.out.println( " - Connected" );
          clientSocket.close();
          Thread.sleep( 50 );
          manager.shutdown();
          assertNullSelector( manager );
          assertEquals( "isRunning post shutdown", false, manager.isRunning() );
  
          mockMonitor.verify();
      }
  
  
      public void testWaitingForThreadToShutdown()
          throws Exception
      {
          final ServerSocketChannel channel = ServerSocketChannel.open();
          channel.socket().setReuseAddress( true );
          final InetAddress localAddress = InetAddress.getLocalHost();
          final Random random = new Random();
          final int port = Math.abs( random.nextInt() % 5000 ) + 1024;
          final InetSocketAddress address = new InetSocketAddress( localAddress, port );
          channel.socket().bind( address );
          System.out.println( "address = " + address );
          while ( !channel.socket().isBound() )
          {
             System.out.print( "." );
             Thread.yield();
          }
  
          final Mock mockMonitor = new Mock( SelectorMonitor.class );
  
          mockMonitor.expect( "selectorStartup", C.NO_ARGS );
          mockMonitor.expect( "enteringSelectorLoop", C.NO_ARGS );
          mockMonitor.expect( "enteringSelect", C.NO_ARGS );
          mockMonitor.expect( "selectCompleted", C.args( C.eq( 0 ) ) );
          mockMonitor.expect( "enteringSelect", C.NO_ARGS );
          mockMonitor.expect( "selectCompleted", C.args( C.eq( 1 ) ) );
          mockMonitor.expect( "selectorShutdown", C.NO_ARGS );
          mockMonitor.expect( "exitingSelectorLoop", C.NO_ARGS );
          final SelectorMonitor monitor = (SelectorMonitor)mockMonitor.proxy();
  
          final DefaultSelectorManager manager = new DefaultSelectorManager();
          manager.setTimeout( 5000 );
          manager.setMonitor( monitor );
  
          assertEquals( "isRunning pre start", false, manager.isRunning() );
          assertNullSelector( manager );
          manager.startup();
          assertEquals( "isRunning post start", true, manager.isRunning() );
          assertNotNull( "getSelector post start", manager.getSelector() );
  
          manager.registerChannel( channel,
                                   SelectionKey.OP_ACCEPT,
                                   new DelayingSelectorEventHandler( 2000 ),
                                   null );
  
          final Socket clientSocket = new Socket( localAddress, port );
          System.out.print( "Socket Connecting with delay" );
          while( !clientSocket.isConnected() )
          {
              System.out.print( "." );
              Thread.yield();
          }
          System.out.println( " - Connected" );
          clientSocket.close();
          Thread.sleep( 50 );
          System.out.println( "Starting to shutdown" );
          manager.shutdown();
          assertNullSelector( manager );
          assertEquals( "isRunning post shutdown", false, manager.isRunning() );
  
          mockMonitor.verify();
      }
  
      private void assertNullSelector( final DefaultSelectorManager manager )
      {
          try
          {
              manager.getSelector();
              fail( "Expected NPE in getSelector" );
          }
          catch( final NullPointerException npe )
          {
              assertEquals( "getMessage()", "selector", npe.getMessage() );
          }
      }
  }
  
  
  


-------------------------------------------------------
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/