Revert of Mojo EDK: Introduce MojoQueryHandleSignalsState API

mojo/android/javatests/src/org/chromium/mojo/system/impl/CoreImplTest.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.mojo.system.impl;
 
 import android.support.test.filters.SmallTest;
 
 import org.chromium.mojo.MojoTestCase;
 import org.chromium.mojo.system.Core;
 import org.chromium.mojo.system.Core.HandleSignals;
+import org.chromium.mojo.system.Core.HandleSignalsState;
+import org.chromium.mojo.system.Core.WaitManyResult;
+import org.chromium.mojo.system.Core.WaitResult;
 import org.chromium.mojo.system.DataPipe;
 import org.chromium.mojo.system.Handle;
 import org.chromium.mojo.system.InvalidHandle;
 import org.chromium.mojo.system.MessagePipeHandle;
 import org.chromium.mojo.system.MojoException;
 import org.chromium.mojo.system.MojoResult;
 import org.chromium.mojo.system.Pair;
 import org.chromium.mojo.system.ResultAnd;
 import org.chromium.mojo.system.SharedBufferHandle;
 
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Random;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Testing the core API.
  */
 public class CoreImplTest extends MojoTestCase {
     private static final long RUN_LOOP_TIMEOUT_MS = 5;
 
     private static final ScheduledExecutorService WORKER =
             Executors.newSingleThreadScheduledExecutor();
 
@@ skipping 25 matching lines @@
 
     private void addHandleToClose(Handle handle) {
         mHandlesToClose.add(handle);
     }
 
     private void addHandlePairToClose(Pair<? extends Handle, ? extends Handle> handles) {
         mHandlesToClose.add(handles.first);
         mHandlesToClose.add(handles.second);
     }
 
+    /**
+     * Runnable that will close the given handle.
+     */
+    private static class CloseHandle implements Runnable {
+        private Handle mHandle;
+
+        CloseHandle(Handle handle) {
+            mHandle = handle;
+        }
+
+        @Override
+        public void run() {
+            mHandle.close();
+        }
+    }
+
     private static void checkSendingMessage(MessagePipeHandle in, MessagePipeHandle out) {
         Random random = new Random();
 
         // Writing a random 8 bytes message.
         byte[] bytes = new byte[8];
         random.nextBytes(bytes);
         ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.length);
         buffer.put(bytes);
         in.writeMessage(buffer, null, MessagePipeHandle.WriteFlags.NONE);
 
@@ skipping 72 matching lines @@
         byte[] receivedBytes = new byte[bytes.length];
         buffer2.get(receivedBytes);
 
         assertTrue(Arrays.equals(bytes, receivedBytes));
 
         in.unmap(buffer1);
         out.unmap(buffer2);
     }
 
     /**
+     * Testing {@link Core#waitMany(List, long)}.
+     */
+    @SmallTest
+    public void testWaitMany() {
+        Core core = CoreImpl.getInstance();
+        Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(null);
+        addHandlePairToClose(handles);
+
+        // Test waiting on handles of a newly created message pipe - each should be writable, but
+        // not readable.
+        List<Pair<Handle, Core.HandleSignals>> handlesToWaitOn =
+                new ArrayList<Pair<Handle, Core.HandleSignals>>();
+        handlesToWaitOn.add(
+                new Pair<Handle, Core.HandleSignals>(handles.second, Core.HandleSignals.READABLE));
+        handlesToWaitOn.add(
+                new Pair<Handle, Core.HandleSignals>(handles.first, Core.HandleSignals.WRITABLE));
+        WaitManyResult result = core.waitMany(handlesToWaitOn, 0);
+        assertEquals(MojoResult.OK, result.getMojoResult());
+        assertEquals(1, result.getHandleIndex());
+        for (HandleSignalsState state : result.getSignalStates()) {
+            assertEquals(HandleSignals.WRITABLE, state.getSatisfiedSignals());
+            assertEquals(ALL_SIGNALS, state.getSatisfiableSignals());
+        }
+
+        // Same test, but swap the handles around.
+        handlesToWaitOn.clear();
+        handlesToWaitOn.add(
+                new Pair<Handle, Core.HandleSignals>(handles.first, Core.HandleSignals.WRITABLE));
+        handlesToWaitOn.add(
+                new Pair<Handle, Core.HandleSignals>(handles.second, Core.HandleSignals.READABLE));
+        result = core.waitMany(handlesToWaitOn, 0);
+        assertEquals(MojoResult.OK, result.getMojoResult());
+        assertEquals(0, result.getHandleIndex());
+        for (HandleSignalsState state : result.getSignalStates()) {
+            assertEquals(HandleSignals.WRITABLE, state.getSatisfiedSignals());
+            assertEquals(ALL_SIGNALS, state.getSatisfiableSignals());
+        }
+    }
+
+    /**
      * Testing that Core can be retrieved from a handle.
      */
     @SmallTest
     public void testGetCore() {
         Core core = CoreImpl.getInstance();
 
         Pair<? extends Handle, ? extends Handle> handles = core.createMessagePipe(null);
         addHandlePairToClose(handles);
         assertEquals(core, handles.first.getCore());
         assertEquals(core, handles.second.getCore());
@@ skipping 30 matching lines @@
     }
 
     /**
      * Testing {@link MessagePipeHandle}.
      */
     @SmallTest
     public void testMessagePipeEmpty() {
         Core core = CoreImpl.getInstance();
         Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(null);
         addHandlePairToClose(handles);
+        // Test waiting on handles of a newly created message pipe.
+        WaitResult waitResult = handles.first.wait(
+                Core.HandleSignals.none().setReadable(true).setWritable(true), 0);
+        assertEquals(MojoResult.OK, waitResult.getMojoResult());
+        assertEquals(
+                HandleSignals.WRITABLE, waitResult.getHandleSignalsState().getSatisfiedSignals());
+        assertEquals(ALL_SIGNALS, waitResult.getHandleSignalsState().getSatisfiableSignals());
+
+        waitResult = handles.first.wait(Core.HandleSignals.WRITABLE, 0);
+        assertEquals(MojoResult.OK, waitResult.getMojoResult());
+        assertEquals(
+                HandleSignals.WRITABLE, waitResult.getHandleSignalsState().getSatisfiedSignals());
+        assertEquals(ALL_SIGNALS, waitResult.getHandleSignalsState().getSatisfiableSignals());
+
+        waitResult = handles.first.wait(Core.HandleSignals.READABLE, 0);
+        assertEquals(MojoResult.DEADLINE_EXCEEDED, waitResult.getMojoResult());
+        assertEquals(
+                HandleSignals.WRITABLE, waitResult.getHandleSignalsState().getSatisfiedSignals());
+        assertEquals(ALL_SIGNALS, waitResult.getHandleSignalsState().getSatisfiableSignals());
 
         // Testing read on an empty pipe.
         ResultAnd<MessagePipeHandle.ReadMessageResult> readResult =
                 handles.first.readMessage(null, 0, MessagePipeHandle.ReadFlags.NONE);
         assertEquals(MojoResult.SHOULD_WAIT, readResult.getMojoResult());
 
-        handles.first.close();
-        handles.second.close();
+        // Closing a pipe while waiting.
+        WORKER.schedule(new CloseHandle(handles.first), 10, TimeUnit.MILLISECONDS);
+        waitResult = handles.first.wait(Core.HandleSignals.READABLE, 1000000L);
+        assertEquals(MojoResult.CANCELLED, waitResult.getMojoResult());
+        assertEquals(
+                HandleSignals.none(), waitResult.getHandleSignalsState().getSatisfiedSignals());
+        assertEquals(
+                HandleSignals.none(), waitResult.getHandleSignalsState().getSatisfiableSignals());
+
+        handles = core.createMessagePipe(null);
+        addHandlePairToClose(handles);
+
+        // Closing the other pipe while waiting.
+        WORKER.schedule(new CloseHandle(handles.first), 10, TimeUnit.MILLISECONDS);
+        waitResult = handles.second.wait(Core.HandleSignals.READABLE, 1000000L);
+        assertEquals(MojoResult.FAILED_PRECONDITION, waitResult.getMojoResult());
+
+        // Waiting on a closed pipe.
+        waitResult = handles.second.wait(Core.HandleSignals.READABLE, 0);
+        assertEquals(MojoResult.FAILED_PRECONDITION, waitResult.getMojoResult());
+        waitResult = handles.second.wait(Core.HandleSignals.WRITABLE, 0);
+        assertEquals(MojoResult.FAILED_PRECONDITION, waitResult.getMojoResult());
     }
 
     /**
      * Testing {@link MessagePipeHandle}.
      */
     @SmallTest
     public void testMessagePipeSend() {
         Core core = CoreImpl.getInstance();
         Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(null);
         addHandlePairToClose(handles);
@@ skipping 199 matching lines @@
     }
 
     /**
      * Testing that invalid handle can be used with this implementation.
      */
     @SmallTest
     public void testInvalidHandle() {
         Core core = CoreImpl.getInstance();
         Handle handle = InvalidHandle.INSTANCE;
 
+        // Checking wait.
+        boolean exception = false;
+        try {
+            core.wait(handle, Core.HandleSignals.WRITABLE, 0);
+        } catch (MojoException e) {
+            assertEquals(MojoResult.INVALID_ARGUMENT, e.getMojoResult());
+            exception = true;
+        }
+        assertTrue(exception);
+
+        // Checking waitMany.
+        exception = false;
+        try {
+            List<Pair<Handle, Core.HandleSignals>> handles =
+                    new ArrayList<Pair<Handle, Core.HandleSignals>>();
+            handles.add(Pair.create(handle, Core.HandleSignals.WRITABLE));
+            core.waitMany(handles, 0);
+        } catch (MojoException e) {
+            assertEquals(MojoResult.INVALID_ARGUMENT, e.getMojoResult());
+            exception = true;
+        }
+        assertTrue(exception);
+
         // Checking sending an invalid handle.
         // Until the behavior is changed on the C++ side, handle gracefully 2 different use case:
         // - Receive a INVALID_ARGUMENT exception
         // - Receive an invalid handle on the other side.
         Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(null);
         addHandlePairToClose(handles);
         try {
             handles.first.writeMessage(null, Collections.<Handle>singletonList(handle),
                     MessagePipeHandle.WriteFlags.NONE);
             ResultAnd<MessagePipeHandle.ReadMessageResult> readMessageResult =
@@ skipping 82 matching lines @@
         MessagePipeHandle converted =
                 core.acquireNativeHandle(handles.first.releaseNativeHandle()).toMessagePipeHandle();
         addHandleToClose(converted);
 
         assertFalse(handles.first.isValid());
 
         checkSendingMessage(converted, handles.second);
         checkSendingMessage(handles.second, converted);
     }
 }