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());
 
-        // 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());
+        handles.first.close();
+        handles.second.close();
     }
 
     /**
      * 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);
     }
 }