OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 package org.chromium.mojo.system.impl; | 5 package org.chromium.mojo.system.impl; |
6 | 6 |
7 import android.support.test.filters.SmallTest; | 7 import android.support.test.filters.SmallTest; |
8 | 8 |
9 import org.chromium.mojo.MojoTestCase; | 9 import org.chromium.mojo.MojoTestCase; |
10 import org.chromium.mojo.system.Core; | 10 import org.chromium.mojo.system.Core; |
11 import org.chromium.mojo.system.Core.HandleSignals; | 11 import org.chromium.mojo.system.Core.HandleSignals; |
| 12 import org.chromium.mojo.system.Core.HandleSignalsState; |
| 13 import org.chromium.mojo.system.Core.WaitManyResult; |
| 14 import org.chromium.mojo.system.Core.WaitResult; |
12 import org.chromium.mojo.system.DataPipe; | 15 import org.chromium.mojo.system.DataPipe; |
13 import org.chromium.mojo.system.Handle; | 16 import org.chromium.mojo.system.Handle; |
14 import org.chromium.mojo.system.InvalidHandle; | 17 import org.chromium.mojo.system.InvalidHandle; |
15 import org.chromium.mojo.system.MessagePipeHandle; | 18 import org.chromium.mojo.system.MessagePipeHandle; |
16 import org.chromium.mojo.system.MojoException; | 19 import org.chromium.mojo.system.MojoException; |
17 import org.chromium.mojo.system.MojoResult; | 20 import org.chromium.mojo.system.MojoResult; |
18 import org.chromium.mojo.system.Pair; | 21 import org.chromium.mojo.system.Pair; |
19 import org.chromium.mojo.system.ResultAnd; | 22 import org.chromium.mojo.system.ResultAnd; |
20 import org.chromium.mojo.system.SharedBufferHandle; | 23 import org.chromium.mojo.system.SharedBufferHandle; |
21 | 24 |
22 import java.nio.ByteBuffer; | 25 import java.nio.ByteBuffer; |
23 import java.util.ArrayList; | 26 import java.util.ArrayList; |
24 import java.util.Arrays; | 27 import java.util.Arrays; |
25 import java.util.Collections; | 28 import java.util.Collections; |
26 import java.util.List; | 29 import java.util.List; |
27 import java.util.Random; | 30 import java.util.Random; |
28 import java.util.concurrent.Executors; | 31 import java.util.concurrent.Executors; |
29 import java.util.concurrent.ScheduledExecutorService; | 32 import java.util.concurrent.ScheduledExecutorService; |
| 33 import java.util.concurrent.TimeUnit; |
30 | 34 |
31 /** | 35 /** |
32 * Testing the core API. | 36 * Testing the core API. |
33 */ | 37 */ |
34 public class CoreImplTest extends MojoTestCase { | 38 public class CoreImplTest extends MojoTestCase { |
35 private static final long RUN_LOOP_TIMEOUT_MS = 5; | 39 private static final long RUN_LOOP_TIMEOUT_MS = 5; |
36 | 40 |
37 private static final ScheduledExecutorService WORKER = | 41 private static final ScheduledExecutorService WORKER = |
38 Executors.newSingleThreadScheduledExecutor(); | 42 Executors.newSingleThreadScheduledExecutor(); |
39 | 43 |
(...skipping 25 matching lines...) Expand all Loading... |
65 | 69 |
66 private void addHandleToClose(Handle handle) { | 70 private void addHandleToClose(Handle handle) { |
67 mHandlesToClose.add(handle); | 71 mHandlesToClose.add(handle); |
68 } | 72 } |
69 | 73 |
70 private void addHandlePairToClose(Pair<? extends Handle, ? extends Handle> h
andles) { | 74 private void addHandlePairToClose(Pair<? extends Handle, ? extends Handle> h
andles) { |
71 mHandlesToClose.add(handles.first); | 75 mHandlesToClose.add(handles.first); |
72 mHandlesToClose.add(handles.second); | 76 mHandlesToClose.add(handles.second); |
73 } | 77 } |
74 | 78 |
| 79 /** |
| 80 * Runnable that will close the given handle. |
| 81 */ |
| 82 private static class CloseHandle implements Runnable { |
| 83 private Handle mHandle; |
| 84 |
| 85 CloseHandle(Handle handle) { |
| 86 mHandle = handle; |
| 87 } |
| 88 |
| 89 @Override |
| 90 public void run() { |
| 91 mHandle.close(); |
| 92 } |
| 93 } |
| 94 |
75 private static void checkSendingMessage(MessagePipeHandle in, MessagePipeHan
dle out) { | 95 private static void checkSendingMessage(MessagePipeHandle in, MessagePipeHan
dle out) { |
76 Random random = new Random(); | 96 Random random = new Random(); |
77 | 97 |
78 // Writing a random 8 bytes message. | 98 // Writing a random 8 bytes message. |
79 byte[] bytes = new byte[8]; | 99 byte[] bytes = new byte[8]; |
80 random.nextBytes(bytes); | 100 random.nextBytes(bytes); |
81 ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.length); | 101 ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.length); |
82 buffer.put(bytes); | 102 buffer.put(bytes); |
83 in.writeMessage(buffer, null, MessagePipeHandle.WriteFlags.NONE); | 103 in.writeMessage(buffer, null, MessagePipeHandle.WriteFlags.NONE); |
84 | 104 |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
157 byte[] receivedBytes = new byte[bytes.length]; | 177 byte[] receivedBytes = new byte[bytes.length]; |
158 buffer2.get(receivedBytes); | 178 buffer2.get(receivedBytes); |
159 | 179 |
160 assertTrue(Arrays.equals(bytes, receivedBytes)); | 180 assertTrue(Arrays.equals(bytes, receivedBytes)); |
161 | 181 |
162 in.unmap(buffer1); | 182 in.unmap(buffer1); |
163 out.unmap(buffer2); | 183 out.unmap(buffer2); |
164 } | 184 } |
165 | 185 |
166 /** | 186 /** |
| 187 * Testing {@link Core#waitMany(List, long)}. |
| 188 */ |
| 189 @SmallTest |
| 190 public void testWaitMany() { |
| 191 Core core = CoreImpl.getInstance(); |
| 192 Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessageP
ipe(null); |
| 193 addHandlePairToClose(handles); |
| 194 |
| 195 // Test waiting on handles of a newly created message pipe - each should
be writable, but |
| 196 // not readable. |
| 197 List<Pair<Handle, Core.HandleSignals>> handlesToWaitOn = |
| 198 new ArrayList<Pair<Handle, Core.HandleSignals>>(); |
| 199 handlesToWaitOn.add( |
| 200 new Pair<Handle, Core.HandleSignals>(handles.second, Core.Handle
Signals.READABLE)); |
| 201 handlesToWaitOn.add( |
| 202 new Pair<Handle, Core.HandleSignals>(handles.first, Core.HandleS
ignals.WRITABLE)); |
| 203 WaitManyResult result = core.waitMany(handlesToWaitOn, 0); |
| 204 assertEquals(MojoResult.OK, result.getMojoResult()); |
| 205 assertEquals(1, result.getHandleIndex()); |
| 206 for (HandleSignalsState state : result.getSignalStates()) { |
| 207 assertEquals(HandleSignals.WRITABLE, state.getSatisfiedSignals()); |
| 208 assertEquals(ALL_SIGNALS, state.getSatisfiableSignals()); |
| 209 } |
| 210 |
| 211 // Same test, but swap the handles around. |
| 212 handlesToWaitOn.clear(); |
| 213 handlesToWaitOn.add( |
| 214 new Pair<Handle, Core.HandleSignals>(handles.first, Core.HandleS
ignals.WRITABLE)); |
| 215 handlesToWaitOn.add( |
| 216 new Pair<Handle, Core.HandleSignals>(handles.second, Core.Handle
Signals.READABLE)); |
| 217 result = core.waitMany(handlesToWaitOn, 0); |
| 218 assertEquals(MojoResult.OK, result.getMojoResult()); |
| 219 assertEquals(0, result.getHandleIndex()); |
| 220 for (HandleSignalsState state : result.getSignalStates()) { |
| 221 assertEquals(HandleSignals.WRITABLE, state.getSatisfiedSignals()); |
| 222 assertEquals(ALL_SIGNALS, state.getSatisfiableSignals()); |
| 223 } |
| 224 } |
| 225 |
| 226 /** |
167 * Testing that Core can be retrieved from a handle. | 227 * Testing that Core can be retrieved from a handle. |
168 */ | 228 */ |
169 @SmallTest | 229 @SmallTest |
170 public void testGetCore() { | 230 public void testGetCore() { |
171 Core core = CoreImpl.getInstance(); | 231 Core core = CoreImpl.getInstance(); |
172 | 232 |
173 Pair<? extends Handle, ? extends Handle> handles = core.createMessagePip
e(null); | 233 Pair<? extends Handle, ? extends Handle> handles = core.createMessagePip
e(null); |
174 addHandlePairToClose(handles); | 234 addHandlePairToClose(handles); |
175 assertEquals(core, handles.first.getCore()); | 235 assertEquals(core, handles.first.getCore()); |
176 assertEquals(core, handles.second.getCore()); | 236 assertEquals(core, handles.second.getCore()); |
(...skipping 30 matching lines...) Expand all Loading... |
207 } | 267 } |
208 | 268 |
209 /** | 269 /** |
210 * Testing {@link MessagePipeHandle}. | 270 * Testing {@link MessagePipeHandle}. |
211 */ | 271 */ |
212 @SmallTest | 272 @SmallTest |
213 public void testMessagePipeEmpty() { | 273 public void testMessagePipeEmpty() { |
214 Core core = CoreImpl.getInstance(); | 274 Core core = CoreImpl.getInstance(); |
215 Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessageP
ipe(null); | 275 Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessageP
ipe(null); |
216 addHandlePairToClose(handles); | 276 addHandlePairToClose(handles); |
| 277 // Test waiting on handles of a newly created message pipe. |
| 278 WaitResult waitResult = handles.first.wait( |
| 279 Core.HandleSignals.none().setReadable(true).setWritable(true), 0
); |
| 280 assertEquals(MojoResult.OK, waitResult.getMojoResult()); |
| 281 assertEquals( |
| 282 HandleSignals.WRITABLE, waitResult.getHandleSignalsState().getSa
tisfiedSignals()); |
| 283 assertEquals(ALL_SIGNALS, waitResult.getHandleSignalsState().getSatisfia
bleSignals()); |
| 284 |
| 285 waitResult = handles.first.wait(Core.HandleSignals.WRITABLE, 0); |
| 286 assertEquals(MojoResult.OK, waitResult.getMojoResult()); |
| 287 assertEquals( |
| 288 HandleSignals.WRITABLE, waitResult.getHandleSignalsState().getSa
tisfiedSignals()); |
| 289 assertEquals(ALL_SIGNALS, waitResult.getHandleSignalsState().getSatisfia
bleSignals()); |
| 290 |
| 291 waitResult = handles.first.wait(Core.HandleSignals.READABLE, 0); |
| 292 assertEquals(MojoResult.DEADLINE_EXCEEDED, waitResult.getMojoResult()); |
| 293 assertEquals( |
| 294 HandleSignals.WRITABLE, waitResult.getHandleSignalsState().getSa
tisfiedSignals()); |
| 295 assertEquals(ALL_SIGNALS, waitResult.getHandleSignalsState().getSatisfia
bleSignals()); |
217 | 296 |
218 // Testing read on an empty pipe. | 297 // Testing read on an empty pipe. |
219 ResultAnd<MessagePipeHandle.ReadMessageResult> readResult = | 298 ResultAnd<MessagePipeHandle.ReadMessageResult> readResult = |
220 handles.first.readMessage(null, 0, MessagePipeHandle.ReadFlags.N
ONE); | 299 handles.first.readMessage(null, 0, MessagePipeHandle.ReadFlags.N
ONE); |
221 assertEquals(MojoResult.SHOULD_WAIT, readResult.getMojoResult()); | 300 assertEquals(MojoResult.SHOULD_WAIT, readResult.getMojoResult()); |
222 | 301 |
223 handles.first.close(); | 302 // Closing a pipe while waiting. |
224 handles.second.close(); | 303 WORKER.schedule(new CloseHandle(handles.first), 10, TimeUnit.MILLISECOND
S); |
| 304 waitResult = handles.first.wait(Core.HandleSignals.READABLE, 1000000L); |
| 305 assertEquals(MojoResult.CANCELLED, waitResult.getMojoResult()); |
| 306 assertEquals( |
| 307 HandleSignals.none(), waitResult.getHandleSignalsState().getSati
sfiedSignals()); |
| 308 assertEquals( |
| 309 HandleSignals.none(), waitResult.getHandleSignalsState().getSati
sfiableSignals()); |
| 310 |
| 311 handles = core.createMessagePipe(null); |
| 312 addHandlePairToClose(handles); |
| 313 |
| 314 // Closing the other pipe while waiting. |
| 315 WORKER.schedule(new CloseHandle(handles.first), 10, TimeUnit.MILLISECOND
S); |
| 316 waitResult = handles.second.wait(Core.HandleSignals.READABLE, 1000000L); |
| 317 assertEquals(MojoResult.FAILED_PRECONDITION, waitResult.getMojoResult())
; |
| 318 |
| 319 // Waiting on a closed pipe. |
| 320 waitResult = handles.second.wait(Core.HandleSignals.READABLE, 0); |
| 321 assertEquals(MojoResult.FAILED_PRECONDITION, waitResult.getMojoResult())
; |
| 322 waitResult = handles.second.wait(Core.HandleSignals.WRITABLE, 0); |
| 323 assertEquals(MojoResult.FAILED_PRECONDITION, waitResult.getMojoResult())
; |
225 } | 324 } |
226 | 325 |
227 /** | 326 /** |
228 * Testing {@link MessagePipeHandle}. | 327 * Testing {@link MessagePipeHandle}. |
229 */ | 328 */ |
230 @SmallTest | 329 @SmallTest |
231 public void testMessagePipeSend() { | 330 public void testMessagePipeSend() { |
232 Core core = CoreImpl.getInstance(); | 331 Core core = CoreImpl.getInstance(); |
233 Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessageP
ipe(null); | 332 Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessageP
ipe(null); |
234 addHandlePairToClose(handles); | 333 addHandlePairToClose(handles); |
(...skipping 199 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
434 } | 533 } |
435 | 534 |
436 /** | 535 /** |
437 * Testing that invalid handle can be used with this implementation. | 536 * Testing that invalid handle can be used with this implementation. |
438 */ | 537 */ |
439 @SmallTest | 538 @SmallTest |
440 public void testInvalidHandle() { | 539 public void testInvalidHandle() { |
441 Core core = CoreImpl.getInstance(); | 540 Core core = CoreImpl.getInstance(); |
442 Handle handle = InvalidHandle.INSTANCE; | 541 Handle handle = InvalidHandle.INSTANCE; |
443 | 542 |
| 543 // Checking wait. |
| 544 boolean exception = false; |
| 545 try { |
| 546 core.wait(handle, Core.HandleSignals.WRITABLE, 0); |
| 547 } catch (MojoException e) { |
| 548 assertEquals(MojoResult.INVALID_ARGUMENT, e.getMojoResult()); |
| 549 exception = true; |
| 550 } |
| 551 assertTrue(exception); |
| 552 |
| 553 // Checking waitMany. |
| 554 exception = false; |
| 555 try { |
| 556 List<Pair<Handle, Core.HandleSignals>> handles = |
| 557 new ArrayList<Pair<Handle, Core.HandleSignals>>(); |
| 558 handles.add(Pair.create(handle, Core.HandleSignals.WRITABLE)); |
| 559 core.waitMany(handles, 0); |
| 560 } catch (MojoException e) { |
| 561 assertEquals(MojoResult.INVALID_ARGUMENT, e.getMojoResult()); |
| 562 exception = true; |
| 563 } |
| 564 assertTrue(exception); |
| 565 |
444 // Checking sending an invalid handle. | 566 // Checking sending an invalid handle. |
445 // Until the behavior is changed on the C++ side, handle gracefully 2 di
fferent use case: | 567 // Until the behavior is changed on the C++ side, handle gracefully 2 di
fferent use case: |
446 // - Receive a INVALID_ARGUMENT exception | 568 // - Receive a INVALID_ARGUMENT exception |
447 // - Receive an invalid handle on the other side. | 569 // - Receive an invalid handle on the other side. |
448 Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessageP
ipe(null); | 570 Pair<MessagePipeHandle, MessagePipeHandle> handles = core.createMessageP
ipe(null); |
449 addHandlePairToClose(handles); | 571 addHandlePairToClose(handles); |
450 try { | 572 try { |
451 handles.first.writeMessage(null, Collections.<Handle>singletonList(h
andle), | 573 handles.first.writeMessage(null, Collections.<Handle>singletonList(h
andle), |
452 MessagePipeHandle.WriteFlags.NONE); | 574 MessagePipeHandle.WriteFlags.NONE); |
453 ResultAnd<MessagePipeHandle.ReadMessageResult> readMessageResult = | 575 ResultAnd<MessagePipeHandle.ReadMessageResult> readMessageResult = |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
536 MessagePipeHandle converted = | 658 MessagePipeHandle converted = |
537 core.acquireNativeHandle(handles.first.releaseNativeHandle()).to
MessagePipeHandle(); | 659 core.acquireNativeHandle(handles.first.releaseNativeHandle()).to
MessagePipeHandle(); |
538 addHandleToClose(converted); | 660 addHandleToClose(converted); |
539 | 661 |
540 assertFalse(handles.first.isValid()); | 662 assertFalse(handles.first.isValid()); |
541 | 663 |
542 checkSendingMessage(converted, handles.second); | 664 checkSendingMessage(converted, handles.second); |
543 checkSendingMessage(handles.second, converted); | 665 checkSendingMessage(handles.second, converted); |
544 } | 666 } |
545 } | 667 } |
OLD | NEW |