Java API for mojo system.

mojo/system/android/javatests/src/org/chromium/mojo/system/CoreTest.java

Index: mojo/system/android/javatests/src/org/chromium/mojo/system/CoreTest.java
diff --git a/mojo/system/android/javatests/src/org/chromium/mojo/system/CoreTest.java b/mojo/system/android/javatests/src/org/chromium/mojo/system/CoreTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f27e0c38785ac3dbd9d1c3df98198e44e89ac399
--- /dev/null
+++ b/mojo/system/android/javatests/src/org/chromium/mojo/system/CoreTest.java
@@ -0,0 +1,307 @@
+// Copyright 2013 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.content.Context;
+import android.test.InstrumentationTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.chromium.base.JNINamespace;
+import org.chromium.base.library_loader.LibraryLoader;
+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;
+
+/**
+ * TODO(qsr): Insert description here.
+ */
+@JNINamespace("mojo")
+public class CoreTest extends InstrumentationTestCase {
+
+    /*
+     * (non-Javadoc)
+     * @see junit.framework.TestCase#setUp()
+     */
+    @Override
+    protected void setUp() throws Exception {
+        LibraryLoader.ensureInitialized();
+        nativeInitApplicationContext(getInstrumentation().getContext());
+    }
+
+    static class CloseHandle implements Runnable {
+        private Handle mHandle;
+
+        CloseHandle(Handle handle) {
+            this.mHandle = handle;
+        }
+
+        @Override
+        public void run() {
+            mHandle.close();
+        }
+    }
+
+    static class ExecuteAfterDelay implements Runnable {
+        private Runnable mRunnable;
+        private long mDelayMs;
+
+        ExecuteAfterDelay(Runnable runnable, long delayMs) {
+            this.mRunnable = runnable;
+            this.mDelayMs = delayMs;
+        }
+
+        @Override
+        public void run() {
+            try {
+                Thread.sleep(mDelayMs);
+            } catch (InterruptedException e) {
+                // Nothing to do.
+            }
+            mRunnable.run();
+        }
+    }
+
+    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());
+        assertFalse(result.wasMessageRead);
+        assertEquals(bytes.length, result.messageSize);
+        assertEquals(0, result.handlesCount);
+
+        // Read into a correct buffer.
+        receiveBuffer = ByteBuffer.allocateDirect(bytes.length);
+        result = out.readMessage(receiveBuffer, 0,
+                MessagePipeHandle.ReadFlags.none());
+        assertEquals(bytes.length, result.messageSize);
+        assertEquals(0, result.handlesCount);
+        assertEquals(0, receiveBuffer.position());
+        assertEquals(result.messageSize, receiveBuffer.limit());
+        byte[] receivedBytes = new byte[result.messageSize];
+        receiveBuffer.get(receivedBytes);
+        assertTrue(Arrays.equals(bytes, receivedBytes));
+
+    }
+
+    /**
+     * TODO(qsr):
+     */
+    @SmallTest
+    public void testWaitMany() {
+        Core core = CoreImpl.getInstance();
+        Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe();
+
+        List<Pair<Handle, WaitFlags>> handlesToWaitOn = new ArrayList<
+                Pair<Handle, WaitFlags>>();
+
+        handlesToWaitOn.add(
+                new Pair<Handle, WaitFlags>(handles.second, WaitFlags.none().readable(true)));
+        handlesToWaitOn.add(
+                new Pair<Handle, WaitFlags>(handles.first, WaitFlags.none().writable(true)));
+        WaitManyResult result = core.waitMany(handlesToWaitOn, 0);
+        assertEquals(MojoResult.OK, result.mojoResult);
+        assertEquals(1, result.handleIndex);
+
+        handlesToWaitOn.clear();
+        handlesToWaitOn.add(
+                new Pair<Handle, WaitFlags>(handles.first, WaitFlags.none().writable(true)));
+        handlesToWaitOn.add(
+                new Pair<Handle, WaitFlags>(handles.second, WaitFlags.none().readable(true)));
+        result = core.waitMany(handlesToWaitOn, 0);
+        assertEquals(MojoResult.OK, result.mojoResult);
+        assertEquals(0, result.handleIndex);
+    }
+
+    /**
+     * TODO(qsr):
+     *
+     * @throws InterruptedException
+     */
+    @SmallTest
+    public void testMessagePipeEmpty() throws InterruptedException {
+        Core core = CoreImpl.getInstance();
+        Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe();
+
+        // Testing wait.
+        assertEquals(MojoResult.OK, handles.first.wait(WaitFlags.all(), 0));
+        assertEquals(MojoResult.OK, handles.first.wait(WaitFlags.none().writable(true), 0));
+        assertEquals(MojoResult.DEADLINE_EXCEEDED,
+                handles.first.wait(WaitFlags.none().readable(true), 0));
+
+        // Testing read on an empty pipe.
+        boolean exception = false;
+        try {
+            handles.first.readMessage(null, 0, MessagePipeHandle.ReadFlags.none());
+        } catch (MojoException e) {
+            assertEquals(MojoResult.SHOULD_WAIT, e.getMojoResult());
+            exception = true;
+        }
+        assertTrue(exception);
+
+        // Closing a pipe while waiting.
+        Thread t = new Thread(new ExecuteAfterDelay(new CloseHandle(handles.first), 20));
+        t.start();
+        assertEquals(MojoResult.CANCELLED,
+                handles.first.wait(WaitFlags.none().readable(true), 1000000L));
+        t.join();
+
+        handles = core.createMessagePipe();
+
+        // Closing the other pipe while waiting.
+        t = new Thread(new ExecuteAfterDelay(new CloseHandle(handles.first), 20));
+        t.start();
+        assertEquals(MojoResult.FAILED_PRECONDITION,
+                handles.second.wait(WaitFlags.none().readable(true), 1000000L));
+        t.join();
+
+        // Waiting on a closed pipe.
+        assertEquals(MojoResult.FAILED_PRECONDITION,
+                handles.second.wait(WaitFlags.none().readable(true), 0));
+        assertEquals(MojoResult.FAILED_PRECONDITION,
+                handles.second.wait(WaitFlags.none().writable(true), 0));
+
+    }
+
+    /**
+     * TODO(qsr):
+     */
+    @SmallTest
+    public void testMessagePipeSend() {
+        Core core = CoreImpl.getInstance();
+        Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe();
+
+        checkSendingMessage(handles.first, handles.second);
+        checkSendingMessage(handles.second, handles.first);
+    }
+
+    /**
+     * TODO(qsr):
+     */
+    @SmallTest
+    public void testMessagePipeSendHandles() {
+        Core core = CoreImpl.getInstance();
+        Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessagePipe();
+        Pair<MessagePipeHandle, MessagePipeHandle> handlesToShare = core.createMessagePipe();
+
+        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.handlesCount);
+        MessagePipeHandle newHandle = readMessageResult.handles.get(0).toMessagePipeHandle();
+        assertTrue(newHandle.isValid());
+
+        checkSendingMessage(handlesToShare.first, newHandle);
+    }
+
+    /**
+     * TODO(qsr):
+     */
+    @SmallTest
+    public void testDataPipeSend() {
+        Core core = CoreImpl.getInstance();
+        Pair<DataPipe.ProducerHandle, DataPipe.ConsumerHandle> handles = core.createDataPipe(null);
+
+        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);
+        int result = handles.first.writeData(buffer, DataPipe.WriteFlags.none());
+        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));
+    }
+
+    /**
+     * TODO(qsr):
+     */
+    @SmallTest
+    public void testDataPipeTwoPhaseSend() {
+        Random random = new Random();
+        Core core = CoreImpl.getInstance();
+        Pair<DataPipe.ProducerHandle, DataPipe.ConsumerHandle> handles = core.createDataPipe(null);
+
+        // Writing a random 8 bytes message.
+        byte[] bytes = new byte[8];
+        random.nextBytes(bytes);
+        ByteBuffer buffer = handles.first.beingWriteData(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.beingReadData(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);
+    }
+
+    /**
+     * TODO(qsr):
+     */
+    @SmallTest
+    public void testSharedBuffer() {
+        Random random = new Random();
+        Core core = CoreImpl.getInstance();
+
+        SharedBufferHandle handle = core.createSharedBuffer(null, 8);
+        SharedBufferHandle newHandle = handle.duplicate(null);
+        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);
+    }
+
+    private native void nativeInitApplicationContext(Context context);
+}