test/java/nio/channels/Selector/ChangingInterests.java

*** 50,63 ****
          return "(" + s + ")";
      }
  
      static void write1(SocketChannel peer) throws IOException {
          peer.write(ByteBuffer.wrap(new byte[1]));
-         // give time for other end to be readable
-         try {
-             Thread.sleep(50);
-         } catch (InterruptedException ignore) { }
      }
  
      static void drain(SocketChannel sc) throws IOException {
          ByteBuffer buf = ByteBuffer.allocate(100);
          int n;
--- 50,59 ----
*** 79,119 ****
          sel.selectNow();
          sel.selectedKeys().clear();
  
          // change to the "to" interest set
          key.interestOps(to);
-         System.out.println("select...");
-         int selected = sel.selectNow();
-         System.out.println("" + selected + " channel(s) selected");
  
!         int expected = (to == 0) ? 0 : 1;
!         assertTrue(selected == expected, "Expected " + expected);
  
          // check selected keys
!         for (SelectionKey k: sel.selectedKeys()) {
              assertTrue(k == key, "Unexpected key selected");
  
!             boolean readable = k.isReadable();
!             boolean writable = k.isWritable();
! 
!             System.out.println("key readable: " + readable);
!             System.out.println("key writable: " + writable);
! 
!             if ((to & OP_READ) == 0) {
!                 assertTrue(!readable, "Not expected to be readable");
!             } else {
!                 assertTrue(readable, "Expected to be readable");
!             }
! 
!             if ((to & OP_WRITE) == 0) {
!                 assertTrue(!writable, "Not expected to be writable");
!             } else {
!                 assertTrue(writable, "Expected to be writable");
              }
  
              sel.selectedKeys().clear();
          }
      }
  
      /**
       * Tests that given Selector's select method blocks.
       */
--- 75,143 ----
          sel.selectNow();
          sel.selectedKeys().clear();
  
          // change to the "to" interest set
          key.interestOps(to);
  
!         int readCounter = ((to & OP_READ) == 0) ? 0 : 1;
!         int writeCounter = ((to & OP_WRITE) == 0) ? 0 : 1;
!         System.out.printf("Expected number of readable events %d, writable events %d\n",
!                 readCounter, writeCounter);
! 
!         long start = System.currentTimeMillis();
! 
!         while ((readCounter > 0 || writeCounter > 0) 
!                 && System.currentTimeMillis() - start < 10000) {
!             System.out.println("\ttry selection");
!             try {
!                 Thread.sleep(1000);
!             } catch (InterruptedException ignore) {}
! 
!             sel.selectNow();
  
              // check selected keys
!             for (SelectionKey k : sel.selectedKeys()) {
                  assertTrue(k == key, "Unexpected key selected");
  
!                 if (k.isReadable()) {
!                     readCounter--;
!                 }
!                 if (k.isWritable()) {
!                     writeCounter--;
!                 }
!             }
          }
  
+         verifyEvents(to, readCounter, writeCounter);
          sel.selectedKeys().clear();
      }
+ 
+     /**
+      * Verify actual arrived events with current interest configuration
+      */
+     static void verifyEvents(int op, int readCounter, int writeCounter) {
+         System.out.printf("Verify : %s <-> readCounter %d writeCounter %d\n",
+                 toOpsString(op), readCounter, writeCounter);
+         switch (op) {
+             case 0 :
+                 assertTrue(readCounter == 0 && writeCounter == 0, 
+                         "Expecting no event");
+                 break;
+             case OP_READ :
+                 assertTrue(readCounter == 0, "Expecting only read event");
+                 break;
+             case OP_WRITE :
+                 assertTrue(writeCounter == 0, "Expecting only write event");
+                 break;
+             case OP_READ | OP_WRITE :
+                 assertTrue(readCounter == 0 && writeCounter <= 0, 
+                         "Expecting read and write events");
+                 break;
+             default:
+                 assertTrue(false, "Wrong interest setting");
+                 break;
+         }
      }
  
      /**
       * Tests that given Selector's select method blocks.
       */