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

@@ -50,14 +50,10 @@
         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;

@@ -79,41 +75,69 @@
         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);
+        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()) {
+            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");
+                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.
      */