Index: mojo/android/javatests/src/org/chromium/mojo/system/CoreTest.java |
diff --git a/mojo/android/javatests/src/org/chromium/mojo/system/CoreTest.java b/mojo/android/javatests/src/org/chromium/mojo/system/CoreTest.java |
deleted file mode 100644 |
index 87ea8755c9a0bcb9cdf53eb2ad9f4131462302b6..0000000000000000000000000000000000000000 |
--- a/mojo/android/javatests/src/org/chromium/mojo/system/CoreTest.java |
+++ /dev/null |
@@ -1,790 +0,0 @@ |
-// 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; |
- |
-import android.test.suitebuilder.annotation.SmallTest; |
- |
-import org.chromium.mojo.system.AsyncWaiter.Callback; |
-import org.chromium.mojo.system.AsyncWaiter.Cancellable; |
-import org.chromium.mojo.system.Core.WaitFlags; |
-import org.chromium.mojo.system.Core.WaitManyResult; |
-import org.chromium.mojo.system.MessagePipeHandle.ReadFlags; |
-import org.chromium.mojo.system.MessagePipeHandle.ReadMessageResult; |
-import org.chromium.mojo.system.MessagePipeHandle.WriteFlags; |
-import org.chromium.mojo.system.SharedBufferHandle.MapFlags; |
- |
-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 CoreTest extends MojoTestCase { |
- |
- private static final long RUN_LOOP_TIMEOUT_MS = 5; |
- |
- private static final ScheduledExecutorService WORKER = |
- Executors.newSingleThreadScheduledExecutor(); |
- |
- /** |
- * 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()); |
- |
- // Try to read into a small buffer. |
- ByteBuffer receiveBuffer = ByteBuffer.allocateDirect(bytes.length / 2); |
- MessagePipeHandle.ReadMessageResult result = out.readMessage(receiveBuffer, 0, |
- MessagePipeHandle.ReadFlags.none()); |
- assertEquals(MojoResult.RESOURCE_EXHAUSTED, result.getMojoResult()); |
- assertEquals(bytes.length, result.getMessageSize()); |
- assertEquals(0, result.getHandlesCount()); |
- |
- // Read into a correct buffer. |
- receiveBuffer = ByteBuffer.allocateDirect(bytes.length); |
- result = out.readMessage(receiveBuffer, 0, |
- MessagePipeHandle.ReadFlags.none()); |
- assertEquals(MojoResult.OK, result.getMojoResult()); |
- assertEquals(bytes.length, result.getMessageSize()); |
- assertEquals(0, result.getHandlesCount()); |
- assertEquals(0, receiveBuffer.position()); |
- assertEquals(result.getMessageSize(), receiveBuffer.limit()); |
- byte[] receivedBytes = new byte[result.getMessageSize()]; |
- receiveBuffer.get(receivedBytes); |
- assertTrue(Arrays.equals(bytes, receivedBytes)); |
- |
- } |
- |
- /** |
- * Testing {@link Core#waitMany(List, long)}. |
- */ |
- @SmallTest |
- public void testWaitMany() { |
- Core core = CoreImpl.getInstance(); |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- |
- try { |
- List<Pair<Handle, WaitFlags>> handlesToWaitOn = new ArrayList< |
- Pair<Handle, WaitFlags>>(); |
- |
- handlesToWaitOn.add( |
- new Pair<Handle, WaitFlags>(handles.second, |
- WaitFlags.none().setReadable(true))); |
- handlesToWaitOn.add( |
- new Pair<Handle, WaitFlags>(handles.first, WaitFlags.none().setWritable(true))); |
- WaitManyResult result = core.waitMany(handlesToWaitOn, 0); |
- assertEquals(MojoResult.OK, result.getMojoResult()); |
- assertEquals(1, result.getHandleIndex()); |
- |
- handlesToWaitOn.clear(); |
- handlesToWaitOn.add( |
- new Pair<Handle, WaitFlags>(handles.first, WaitFlags.none().setWritable(true))); |
- handlesToWaitOn.add( |
- new Pair<Handle, WaitFlags>(handles.second, |
- WaitFlags.none().setReadable(true))); |
- result = core.waitMany(handlesToWaitOn, 0); |
- assertEquals(MojoResult.OK, result.getMojoResult()); |
- assertEquals(0, result.getHandleIndex()); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing {@link MessagePipeHandle}. |
- */ |
- @SmallTest |
- public void testMessagePipeEmpty() { |
- Core core = CoreImpl.getInstance(); |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- |
- try { |
- // Testing wait. |
- assertEquals(MojoResult.OK, handles.first.wait(WaitFlags.all(), 0)); |
- assertEquals(MojoResult.OK, handles.first.wait(WaitFlags.none().setWritable(true), 0)); |
- assertEquals(MojoResult.DEADLINE_EXCEEDED, |
- handles.first.wait(WaitFlags.none().setReadable(true), 0)); |
- |
- // Testing read on an empty pipe. |
- ReadMessageResult result = handles.first.readMessage(null, 0, |
- MessagePipeHandle.ReadFlags.none()); |
- assertEquals(MojoResult.SHOULD_WAIT, result.getMojoResult()); |
- |
- // Closing a pipe while waiting. |
- WORKER.schedule(new CloseHandle(handles.first), 10, TimeUnit.MILLISECONDS); |
- assertEquals(MojoResult.CANCELLED, |
- handles.first.wait(WaitFlags.none().setReadable(true), 1000000L)); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- |
- handles = core.createMessagePipe(); |
- |
- try { |
- // Closing the other pipe while waiting. |
- WORKER.schedule(new CloseHandle(handles.first), 10, TimeUnit.MILLISECONDS); |
- assertEquals(MojoResult.FAILED_PRECONDITION, |
- handles.second.wait(WaitFlags.none().setReadable(true), 1000000L)); |
- |
- // Waiting on a closed pipe. |
- assertEquals(MojoResult.FAILED_PRECONDITION, |
- handles.second.wait(WaitFlags.none().setReadable(true), 0)); |
- assertEquals(MojoResult.FAILED_PRECONDITION, |
- handles.second.wait(WaitFlags.none().setWritable(true), 0)); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- |
- } |
- |
- /** |
- * Testing {@link MessagePipeHandle}. |
- */ |
- @SmallTest |
- public void testMessagePipeSend() { |
- Core core = CoreImpl.getInstance(); |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- |
- try { |
- checkSendingMessage(handles.first, handles.second); |
- checkSendingMessage(handles.second, handles.first); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing {@link MessagePipeHandle}. |
- */ |
- @SmallTest |
- public void testMessagePipeReceiveOnSmallBuffer() { |
- Random random = new Random(); |
- Core core = CoreImpl.getInstance(); |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- |
- try { |
- // Writing a random 8 bytes message. |
- byte[] bytes = new byte[8]; |
- random.nextBytes(bytes); |
- ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.length); |
- buffer.put(bytes); |
- handles.first.writeMessage(buffer, null, MessagePipeHandle.WriteFlags.none()); |
- |
- ByteBuffer receiveBuffer = ByteBuffer.allocateDirect(1); |
- MessagePipeHandle.ReadMessageResult result = handles.second.readMessage(receiveBuffer, |
- 0, |
- MessagePipeHandle.ReadFlags.none()); |
- assertEquals(MojoResult.RESOURCE_EXHAUSTED, result.getMojoResult()); |
- assertEquals(bytes.length, result.getMessageSize()); |
- assertEquals(0, result.getHandlesCount()); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing {@link MessagePipeHandle}. |
- */ |
- @SmallTest |
- public void testMessagePipeSendHandles() { |
- Core core = CoreImpl.getInstance(); |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- Pair<MessagePipeHandle, MessagePipeHandle> handlesToShare = core.createMessagePipe(); |
- |
- try { |
- handles.first.writeMessage(null, |
- Collections.<Handle> singletonList(handlesToShare.second), |
- WriteFlags.none()); |
- assertFalse(handlesToShare.second.isValid()); |
- ReadMessageResult readMessageResult = handles.second.readMessage(null, 1, |
- ReadFlags.none()); |
- assertEquals(1, readMessageResult.getHandlesCount()); |
- MessagePipeHandle newHandle = readMessageResult.getHandles().get(0) |
- .toMessagePipeHandle(); |
- try { |
- assertTrue(newHandle.isValid()); |
- checkSendingMessage(handlesToShare.first, newHandle); |
- checkSendingMessage(newHandle, handlesToShare.first); |
- } finally { |
- newHandle.close(); |
- } |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- handlesToShare.first.close(); |
- handlesToShare.second.close(); |
- } |
- } |
- |
- private static void createAndCloseDataPipe(DataPipe.CreateOptions options) { |
- Core core = CoreImpl.getInstance(); |
- Pair<DataPipe.ProducerHandle, DataPipe.ConsumerHandle> handles = core.createDataPipe( |
- options); |
- handles.first.close(); |
- handles.second.close(); |
- } |
- |
- /** |
- * Testing {@link DataPipe}. |
- */ |
- @SmallTest |
- public void testDataPipeCreation() { |
- // Create datapipe with null options. |
- createAndCloseDataPipe(null); |
- DataPipe.CreateOptions options = new DataPipe.CreateOptions(); |
- // Create datapipe with element size set. |
- options.setElementNumBytes(24); |
- createAndCloseDataPipe(options); |
- // Create datapipe with a flag set. |
- options.getFlags().setMayDiscard(true); |
- createAndCloseDataPipe(options); |
- // Create datapipe with capacity set. |
- options.setCapacityNumBytes(1024 * options.getElementNumBytes()); |
- createAndCloseDataPipe(options); |
- } |
- |
- /** |
- * Testing {@link DataPipe}. |
- */ |
- @SmallTest |
- public void testDataPipeSend() { |
- Core core = CoreImpl.getInstance(); |
- Random random = new Random(); |
- |
- Pair<DataPipe.ProducerHandle, DataPipe.ConsumerHandle> handles = core.createDataPipe(null); |
- try { |
- // Writing a random 8 bytes message. |
- byte[] bytes = new byte[8]; |
- random.nextBytes(bytes); |
- ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.length); |
- buffer.put(bytes); |
- int result = handles.first.writeData(buffer, DataPipe.WriteFlags.none()); |
- assertEquals(bytes.length, result); |
- |
- // Query number of bytes available. |
- result = handles.second.readData(null, |
- DataPipe.ReadFlags.none().query(true)); |
- assertEquals(bytes.length, result); |
- |
- // Read into a buffer. |
- ByteBuffer receiveBuffer = ByteBuffer.allocateDirect(bytes.length); |
- result = handles.second.readData(receiveBuffer, |
- DataPipe.ReadFlags.none()); |
- assertEquals(bytes.length, result); |
- assertEquals(0, receiveBuffer.position()); |
- assertEquals(bytes.length, receiveBuffer.limit()); |
- byte[] receivedBytes = new byte[bytes.length]; |
- receiveBuffer.get(receivedBytes); |
- assertTrue(Arrays.equals(bytes, receivedBytes)); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing {@link DataPipe}. |
- */ |
- @SmallTest |
- public void testDataPipeTwoPhaseSend() { |
- Random random = new Random(); |
- Core core = CoreImpl.getInstance(); |
- Pair<DataPipe.ProducerHandle, DataPipe.ConsumerHandle> handles = core.createDataPipe(null); |
- |
- try { |
- // Writing a random 8 bytes message. |
- byte[] bytes = new byte[8]; |
- random.nextBytes(bytes); |
- ByteBuffer buffer = handles.first.beginWriteData(bytes.length, |
- DataPipe.WriteFlags.none()); |
- assertTrue(buffer.capacity() >= bytes.length); |
- buffer.put(bytes); |
- handles.first.endWriteData(bytes.length); |
- |
- // Read into a buffer. |
- ByteBuffer receiveBuffer = handles.second.beginReadData(bytes.length, |
- DataPipe.ReadFlags.none()); |
- assertEquals(0, receiveBuffer.position()); |
- assertEquals(bytes.length, receiveBuffer.limit()); |
- byte[] receivedBytes = new byte[bytes.length]; |
- receiveBuffer.get(receivedBytes); |
- assertTrue(Arrays.equals(bytes, receivedBytes)); |
- handles.second.endReadData(bytes.length); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing {@link DataPipe}. |
- */ |
- @SmallTest |
- public void testDataPipeDiscard() { |
- Random random = new Random(); |
- Core core = CoreImpl.getInstance(); |
- Pair<DataPipe.ProducerHandle, DataPipe.ConsumerHandle> handles = core.createDataPipe(null); |
- |
- try { |
- // Writing a random 8 bytes message. |
- byte[] bytes = new byte[8]; |
- random.nextBytes(bytes); |
- ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.length); |
- buffer.put(bytes); |
- int result = handles.first.writeData(buffer, DataPipe.WriteFlags.none()); |
- assertEquals(bytes.length, result); |
- |
- // Discard bytes. |
- final int nbBytesToDiscard = 4; |
- assertEquals(nbBytesToDiscard, |
- handles.second.discardData(nbBytesToDiscard, DataPipe.ReadFlags.none())); |
- |
- // Read into a buffer. |
- ByteBuffer receiveBuffer = ByteBuffer.allocateDirect(bytes.length - nbBytesToDiscard); |
- result = handles.second.readData(receiveBuffer, |
- DataPipe.ReadFlags.none()); |
- assertEquals(bytes.length - nbBytesToDiscard, result); |
- assertEquals(0, receiveBuffer.position()); |
- assertEquals(bytes.length - nbBytesToDiscard, receiveBuffer.limit()); |
- byte[] receivedBytes = new byte[bytes.length - nbBytesToDiscard]; |
- receiveBuffer.get(receivedBytes); |
- assertTrue(Arrays.equals(Arrays.copyOfRange(bytes, nbBytesToDiscard, bytes.length), |
- receivedBytes)); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing {@link SharedBufferHandle}. |
- */ |
- @SmallTest |
- public void testSharedBufferCreation() { |
- Core core = CoreImpl.getInstance(); |
- // Test creation with empty options. |
- core.createSharedBuffer(null, 8).close(); |
- // Test creation with default options. |
- core.createSharedBuffer(new SharedBufferHandle.CreateOptions(), 8); |
- } |
- |
- /** |
- * Testing {@link SharedBufferHandle}. |
- */ |
- @SmallTest |
- public void testSharedBufferDuplication() { |
- Core core = CoreImpl.getInstance(); |
- SharedBufferHandle handle = core.createSharedBuffer(null, 8); |
- try { |
- // Test duplication with empty options. |
- handle.duplicate(null).close(); |
- // Test creation with default options. |
- handle.duplicate(new SharedBufferHandle.DuplicateOptions()).close(); |
- } finally { |
- handle.close(); |
- } |
- } |
- |
- /** |
- * Testing {@link SharedBufferHandle}. |
- */ |
- @SmallTest |
- public void testSharedBufferSending() { |
- Random random = new Random(); |
- Core core = CoreImpl.getInstance(); |
- SharedBufferHandle handle = core.createSharedBuffer(null, 8); |
- SharedBufferHandle newHandle = handle.duplicate(null); |
- |
- try { |
- ByteBuffer buffer1 = handle.map(0, 8, MapFlags.none()); |
- assertEquals(8, buffer1.capacity()); |
- ByteBuffer buffer2 = newHandle.map(0, 8, MapFlags.none()); |
- assertEquals(8, buffer2.capacity()); |
- |
- byte[] bytes = new byte[8]; |
- random.nextBytes(bytes); |
- buffer1.put(bytes); |
- |
- byte[] receivedBytes = new byte[bytes.length]; |
- buffer2.get(receivedBytes); |
- |
- assertTrue(Arrays.equals(bytes, receivedBytes)); |
- |
- handle.unmap(buffer1); |
- newHandle.unmap(buffer2); |
- } finally { |
- handle.close(); |
- newHandle.close(); |
- } |
- } |
- |
- /** |
- * Testing that invalid handle can be used with this implementation. |
- */ |
- @SmallTest |
- public void testInvalidHandle() { |
- Core core = CoreImpl.getInstance(); |
- Handle handle = new InvalidHandle(); |
- |
- // Checking wait. |
- boolean exception = false; |
- try { |
- core.wait(handle, WaitFlags.all(), 0); |
- } catch (MojoException e) { |
- assertEquals(MojoResult.INVALID_ARGUMENT, e.getMojoResult()); |
- exception = true; |
- } |
- assertTrue(exception); |
- |
- // Checking waitMany. |
- exception = false; |
- try { |
- List<Pair<Handle, WaitFlags>> handles = new ArrayList<Pair<Handle, WaitFlags>>(); |
- handles.add(Pair.create(handle, WaitFlags.all())); |
- 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(); |
- try { |
- handles.first.writeMessage(null, |
- Collections.<Handle> singletonList(handle), |
- WriteFlags.none()); |
- ReadMessageResult readMessageResult = handles.second.readMessage(null, 1, |
- ReadFlags.none()); |
- assertEquals(1, readMessageResult.getHandlesCount()); |
- assertFalse(readMessageResult.getHandles().get(0).isValid()); |
- } catch (MojoException e) { |
- assertEquals(MojoResult.INVALID_ARGUMENT, e.getMojoResult()); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- private static class AsyncWaiterResult implements Callback { |
- private int mResult = Integer.MIN_VALUE; |
- private MojoException mException = null; |
- |
- /** |
- * @see Callback#onResult(int) |
- */ |
- @Override |
- public void onResult(int result) { |
- this.mResult = result; |
- } |
- |
- /** |
- * @see Callback#onError(MojoException) |
- */ |
- @Override |
- public void onError(MojoException exception) { |
- this.mException = exception; |
- } |
- |
- /** |
- * @return the result |
- */ |
- public int getResult() { |
- return mResult; |
- } |
- |
- /** |
- * @return the exception |
- */ |
- public MojoException getException() { |
- return mException; |
- } |
- |
- } |
- |
- /** |
- * Testing core {@link AsyncWaiter} implementation. |
- */ |
- @SmallTest |
- public void testAsyncWaiterCorrectResult() { |
- Core core = CoreImpl.getInstance(); |
- |
- // Checking a correct result. |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- try { |
- final AsyncWaiterResult asyncWaiterResult = new AsyncWaiterResult(); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- core.getDefaultAsyncWaiter().asyncWait(handles.first, |
- WaitFlags.none().setReadable(true), Core.DEADLINE_INFINITE, asyncWaiterResult); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- handles.second.writeMessage(ByteBuffer.allocateDirect(1), null, |
- MessagePipeHandle.WriteFlags.none()); |
- nativeRunLoop(RUN_LOOP_TIMEOUT_MS); |
- assertNull(asyncWaiterResult.getException()); |
- assertEquals(MojoResult.OK, asyncWaiterResult.getResult()); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing core {@link AsyncWaiter} implementation. |
- */ |
- @SmallTest |
- public void testAsyncWaiterClosingPeerHandle() { |
- Core core = CoreImpl.getInstance(); |
- |
- // Closing the peer handle. |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- try { |
- final AsyncWaiterResult asyncWaiterResult = new AsyncWaiterResult(); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- core.getDefaultAsyncWaiter().asyncWait(handles.first, |
- WaitFlags.none().setReadable(true), Core.DEADLINE_INFINITE, asyncWaiterResult); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- nativeRunLoop(RUN_LOOP_TIMEOUT_MS); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- handles.second.close(); |
- nativeRunLoop(RUN_LOOP_TIMEOUT_MS); |
- assertNull(asyncWaiterResult.getException()); |
- assertEquals(MojoResult.FAILED_PRECONDITION, asyncWaiterResult.getResult()); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing core {@link AsyncWaiter} implementation. |
- */ |
- @SmallTest |
- public void testAsyncWaiterClosingWaitingHandle() { |
- Core core = CoreImpl.getInstance(); |
- |
- // Closing the peer handle. |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- try { |
- final AsyncWaiterResult asyncWaiterResult = new AsyncWaiterResult(); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- core.getDefaultAsyncWaiter().asyncWait(handles.first, |
- WaitFlags.none().setReadable(true), Core.DEADLINE_INFINITE, asyncWaiterResult); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- nativeRunLoop(RUN_LOOP_TIMEOUT_MS); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- handles.first.close(); |
- nativeRunLoop(RUN_LOOP_TIMEOUT_MS); |
- // TODO(qsr) Re-enable when MojoWaitMany handles it correctly. |
- // assertNull(asyncWaiterResult.getException()); |
- // assertEquals(MojoResult.CANCELLED, asyncWaiterResult.getResult()); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing core {@link AsyncWaiter} implementation. |
- */ |
- @SmallTest |
- public void testAsyncWaiterWaitingOnInvalidHandle() { |
- Core core = CoreImpl.getInstance(); |
- |
- // Closing the peer handle. |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- try { |
- final AsyncWaiterResult asyncWaiterResult = new AsyncWaiterResult(); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- handles.first.close(); |
- core.getDefaultAsyncWaiter().asyncWait(handles.first, |
- WaitFlags.none().setReadable(true), Core.DEADLINE_INFINITE, asyncWaiterResult); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- nativeRunLoop(RUN_LOOP_TIMEOUT_MS); |
- assertNotNull(asyncWaiterResult.getException()); |
- assertEquals(MojoResult.INVALID_ARGUMENT, |
- asyncWaiterResult.getException().getMojoResult()); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing core {@link AsyncWaiter} implementation. |
- */ |
- @SmallTest |
- public void testAsyncWaiterWaitingOnDefaultInvalidHandle() { |
- Core core = CoreImpl.getInstance(); |
- |
- final AsyncWaiterResult asyncWaiterResult = new AsyncWaiterResult(); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- core.getDefaultAsyncWaiter().asyncWait(new InvalidHandle(), |
- WaitFlags.none().setReadable(true), Core.DEADLINE_INFINITE, asyncWaiterResult); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- nativeRunLoop(RUN_LOOP_TIMEOUT_MS); |
- assertNotNull(asyncWaiterResult.getException()); |
- assertEquals(MojoResult.INVALID_ARGUMENT, |
- asyncWaiterResult.getException().getMojoResult()); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- } |
- |
- /** |
- * Testing core {@link AsyncWaiter} implementation. |
- */ |
- @SmallTest |
- public void testAsyncWaiterWaitingWithTimeout() { |
- Core core = CoreImpl.getInstance(); |
- |
- // Closing the peer handle. |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- try { |
- final AsyncWaiterResult asyncWaiterResult = new AsyncWaiterResult(); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- core.getDefaultAsyncWaiter().asyncWait(handles.first, |
- WaitFlags.none().setReadable(true), RUN_LOOP_TIMEOUT_MS, asyncWaiterResult); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- nativeRunLoop(10 * RUN_LOOP_TIMEOUT_MS); |
- assertNull(asyncWaiterResult.getException()); |
- assertEquals(MojoResult.DEADLINE_EXCEEDED, asyncWaiterResult.getResult()); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing core {@link AsyncWaiter} implementation. |
- */ |
- @SmallTest |
- public void testAsyncWaiterCancelWaiting() { |
- Core core = CoreImpl.getInstance(); |
- |
- // Closing the peer handle. |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- try { |
- final AsyncWaiterResult asyncWaiterResult = new AsyncWaiterResult(); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- Cancellable cancellable = core.getDefaultAsyncWaiter().asyncWait(handles.first, |
- WaitFlags.none().setReadable(true), Core.DEADLINE_INFINITE, asyncWaiterResult); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- nativeRunLoop(RUN_LOOP_TIMEOUT_MS); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- cancellable.cancel(); |
- nativeRunLoop(RUN_LOOP_TIMEOUT_MS); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- handles.second.writeMessage(ByteBuffer.allocateDirect(1), null, |
- MessagePipeHandle.WriteFlags.none()); |
- nativeRunLoop(RUN_LOOP_TIMEOUT_MS); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
- /** |
- * Testing core {@link AsyncWaiter} implementation. |
- */ |
- @SmallTest |
- public void testAsyncWaiterImmediateCancelOnInvalidHandle() { |
- Core core = CoreImpl.getInstance(); |
- |
- // Closing the peer handle. |
- Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe(); |
- try { |
- final AsyncWaiterResult asyncWaiterResult = new AsyncWaiterResult(); |
- handles.first.close(); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- |
- Cancellable cancellable = core.getDefaultAsyncWaiter().asyncWait(handles.first, |
- WaitFlags.none().setReadable(true), Core.DEADLINE_INFINITE, asyncWaiterResult); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- cancellable.cancel(); |
- |
- nativeRunLoop(RUN_LOOP_TIMEOUT_MS); |
- assertEquals(Integer.MIN_VALUE, asyncWaiterResult.getResult()); |
- assertEquals(null, asyncWaiterResult.getException()); |
- } finally { |
- handles.first.close(); |
- handles.second.close(); |
- } |
- } |
- |
-} |