OLD | NEW |
| (Empty) |
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 | |
3 // found in the LICENSE file. | |
4 | |
5 define([ | |
6 "gin/test/expect", | |
7 "mojo/public/js/core", | |
8 "gc", | |
9 ], function(expect, core, gc) { | |
10 | |
11 var HANDLE_SIGNAL_READWRITABLE = core.HANDLE_SIGNAL_WRITABLE | | |
12 core.HANDLE_SIGNAL_READABLE; | |
13 var HANDLE_SIGNAL_ALL = core.HANDLE_SIGNAL_WRITABLE | | |
14 core.HANDLE_SIGNAL_READABLE | | |
15 core.HANDLE_SIGNAL_PEER_CLOSED; | |
16 | |
17 runWithMessagePipe(testNop); | |
18 runWithMessagePipe(testReadAndWriteMessage); | |
19 runWithMessagePipeWithOptions(testNop); | |
20 runWithMessagePipeWithOptions(testReadAndWriteMessage); | |
21 runWithDataPipe(testNop); | |
22 runWithDataPipe(testReadAndWriteDataPipe); | |
23 runWithDataPipeWithOptions(testNop); | |
24 runWithDataPipeWithOptions(testReadAndWriteDataPipe); | |
25 runWithMessagePipe(testIsHandleMessagePipe); | |
26 runWithDataPipe(testIsHandleDataPipe); | |
27 runWithSharedBuffer(testSharedBuffer); | |
28 gc.collectGarbage(); // should not crash | |
29 this.result = "PASS"; | |
30 | |
31 function runWithMessagePipe(test) { | |
32 var pipe = core.createMessagePipe(); | |
33 expect(pipe.result).toBe(core.RESULT_OK); | |
34 | |
35 test(pipe); | |
36 | |
37 expect(core.close(pipe.handle0)).toBe(core.RESULT_OK); | |
38 expect(core.close(pipe.handle1)).toBe(core.RESULT_OK); | |
39 } | |
40 | |
41 function runWithMessagePipeWithOptions(test) { | |
42 var pipe = core.createMessagePipe({ | |
43 flags: core.CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE | |
44 }); | |
45 expect(pipe.result).toBe(core.RESULT_OK); | |
46 | |
47 test(pipe); | |
48 | |
49 expect(core.close(pipe.handle0)).toBe(core.RESULT_OK); | |
50 expect(core.close(pipe.handle1)).toBe(core.RESULT_OK); | |
51 } | |
52 | |
53 function runWithDataPipe(test) { | |
54 var pipe = core.createDataPipe(); | |
55 expect(pipe.result).toBe(core.RESULT_OK); | |
56 | |
57 test(pipe); | |
58 | |
59 expect(core.close(pipe.producerHandle)).toBe(core.RESULT_OK); | |
60 expect(core.close(pipe.consumerHandle)).toBe(core.RESULT_OK); | |
61 } | |
62 | |
63 function runWithDataPipeWithOptions(test) { | |
64 var pipe = core.createDataPipe({ | |
65 flags: core.CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, | |
66 elementNumBytes: 1, | |
67 capacityNumBytes: 64 | |
68 }); | |
69 expect(pipe.result).toBe(core.RESULT_OK); | |
70 | |
71 test(pipe); | |
72 | |
73 expect(core.close(pipe.producerHandle)).toBe(core.RESULT_OK); | |
74 expect(core.close(pipe.consumerHandle)).toBe(core.RESULT_OK); | |
75 } | |
76 | |
77 function runWithSharedBuffer(test) { | |
78 let buffer_size = 32; | |
79 let sharedBuffer = core.createSharedBuffer(buffer_size, | |
80 core.CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE); | |
81 | |
82 expect(sharedBuffer.result).toBe(core.RESULT_OK); | |
83 expect(core.isHandle(sharedBuffer.handle)).toBeTruthy(); | |
84 | |
85 test(sharedBuffer, buffer_size); | |
86 } | |
87 | |
88 function testNop(pipe) { | |
89 } | |
90 | |
91 function testReadAndWriteMessage(pipe) { | |
92 var wait = core.waitMany([], [], 0); | |
93 expect(wait.result).toBe(core.RESULT_INVALID_ARGUMENT); | |
94 expect(wait.index).toBe(null); | |
95 expect(wait.signalsState).toBe(null); | |
96 | |
97 wait = core.wait(pipe.handle0, core.HANDLE_SIGNAL_READABLE, 0); | |
98 expect(wait.result).toBe(core.RESULT_DEADLINE_EXCEEDED); | |
99 expect(wait.signalsState.satisfiedSignals).toBe( | |
100 core.HANDLE_SIGNAL_WRITABLE); | |
101 expect(wait.signalsState.satisfiableSignals).toBe(HANDLE_SIGNAL_ALL); | |
102 | |
103 wait = core.waitMany( | |
104 [pipe.handle0, pipe.handle1], | |
105 [core.HANDLE_SIGNAL_READABLE,core.HANDLE_SIGNAL_READABLE], | |
106 0); | |
107 expect(wait.result).toBe(core.RESULT_DEADLINE_EXCEEDED); | |
108 expect(wait.index).toBe(null); | |
109 expect(wait.signalsState[0].satisfiedSignals).toBe( | |
110 core.HANDLE_SIGNAL_WRITABLE); | |
111 expect(wait.signalsState[0].satisfiableSignals).toBe(HANDLE_SIGNAL_ALL); | |
112 expect(wait.signalsState[1].satisfiedSignals).toBe( | |
113 core.HANDLE_SIGNAL_WRITABLE); | |
114 expect(wait.signalsState[1].satisfiableSignals).toBe(HANDLE_SIGNAL_ALL); | |
115 | |
116 wait = core.wait(pipe.handle0, core.HANDLE_SIGNAL_WRITABLE, 0); | |
117 expect(wait.result).toBe(core.RESULT_OK); | |
118 expect(wait.signalsState.satisfiedSignals).toBe( | |
119 core.HANDLE_SIGNAL_WRITABLE); | |
120 expect(wait.signalsState.satisfiableSignals).toBe(HANDLE_SIGNAL_ALL); | |
121 | |
122 var senderData = new Uint8Array(42); | |
123 for (var i = 0; i < senderData.length; ++i) { | |
124 senderData[i] = i * i; | |
125 } | |
126 | |
127 var result = core.writeMessage( | |
128 pipe.handle0, senderData, [], | |
129 core.WRITE_MESSAGE_FLAG_NONE); | |
130 | |
131 expect(result).toBe(core.RESULT_OK); | |
132 | |
133 wait = core.wait(pipe.handle0, core.HANDLE_SIGNAL_WRITABLE, 0); | |
134 expect(wait.result).toBe(core.RESULT_OK); | |
135 expect(wait.signalsState.satisfiedSignals).toBe( | |
136 core.HANDLE_SIGNAL_WRITABLE); | |
137 expect(wait.signalsState.satisfiableSignals).toBe(HANDLE_SIGNAL_ALL); | |
138 | |
139 wait = core.wait(pipe.handle1, core.HANDLE_SIGNAL_READABLE, | |
140 core.DEADLINE_INDEFINITE); | |
141 expect(wait.result).toBe(core.RESULT_OK); | |
142 expect(wait.signalsState.satisfiedSignals).toBe(HANDLE_SIGNAL_READWRITABLE); | |
143 expect(wait.signalsState.satisfiableSignals).toBe(HANDLE_SIGNAL_ALL); | |
144 | |
145 var read = core.readMessage(pipe.handle1, core.READ_MESSAGE_FLAG_NONE); | |
146 | |
147 expect(read.result).toBe(core.RESULT_OK); | |
148 expect(read.buffer.byteLength).toBe(42); | |
149 expect(read.handles.length).toBe(0); | |
150 | |
151 var memory = new Uint8Array(read.buffer); | |
152 for (var i = 0; i < memory.length; ++i) | |
153 expect(memory[i]).toBe((i * i) & 0xFF); | |
154 } | |
155 | |
156 function testReadAndWriteDataPipe(pipe) { | |
157 var senderData = new Uint8Array(42); | |
158 for (var i = 0; i < senderData.length; ++i) { | |
159 senderData[i] = i * i; | |
160 } | |
161 | |
162 var write = core.writeData( | |
163 pipe.producerHandle, senderData, | |
164 core.WRITE_DATA_FLAG_ALL_OR_NONE); | |
165 | |
166 expect(write.result).toBe(core.RESULT_OK); | |
167 expect(write.numBytes).toBe(42); | |
168 | |
169 var wait = core.wait(pipe.consumerHandle, core.HANDLE_SIGNAL_READABLE, | |
170 core.DEADLINE_INDEFINITE); | |
171 expect(wait.result).toBe(core.RESULT_OK); | |
172 var peeked = core.readData( | |
173 pipe.consumerHandle, | |
174 core.READ_DATA_FLAG_PEEK | core.READ_DATA_FLAG_ALL_OR_NONE); | |
175 expect(peeked.result).toBe(core.RESULT_OK); | |
176 expect(peeked.buffer.byteLength).toBe(42); | |
177 | |
178 var peeked_memory = new Uint8Array(peeked.buffer); | |
179 for (var i = 0; i < peeked_memory.length; ++i) | |
180 expect(peeked_memory[i]).toBe((i * i) & 0xFF); | |
181 | |
182 var read = core.readData( | |
183 pipe.consumerHandle, core.READ_DATA_FLAG_ALL_OR_NONE); | |
184 | |
185 expect(read.result).toBe(core.RESULT_OK); | |
186 expect(read.buffer.byteLength).toBe(42); | |
187 | |
188 var memory = new Uint8Array(read.buffer); | |
189 for (var i = 0; i < memory.length; ++i) | |
190 expect(memory[i]).toBe((i * i) & 0xFF); | |
191 } | |
192 | |
193 function testIsHandleMessagePipe(pipe) { | |
194 expect(core.isHandle(123).toBeFalsy); | |
195 expect(core.isHandle("123").toBeFalsy); | |
196 expect(core.isHandle({}).toBeFalsy); | |
197 expect(core.isHandle([]).toBeFalsy); | |
198 expect(core.isHandle(undefined).toBeFalsy); | |
199 expect(core.isHandle(pipe).toBeFalsy); | |
200 expect(core.isHandle(pipe.handle0)).toBeTruthy(); | |
201 expect(core.isHandle(pipe.handle1)).toBeTruthy(); | |
202 expect(core.isHandle(null)).toBeTruthy(); | |
203 } | |
204 | |
205 function testIsHandleDataPipe(pipe) { | |
206 expect(core.isHandle(pipe.consumerHandle)).toBeTruthy(); | |
207 expect(core.isHandle(pipe.producerHandle)).toBeTruthy(); | |
208 } | |
209 | |
210 function testSharedBuffer(sharedBuffer, buffer_size) { | |
211 let offset = 0; | |
212 let mappedBuffer0 = core.mapBuffer(sharedBuffer.handle, | |
213 offset, | |
214 buffer_size, | |
215 core.MAP_BUFFER_FLAG_NONE); | |
216 | |
217 expect(mappedBuffer0.result).toBe(core.RESULT_OK); | |
218 | |
219 let dupedBufferHandle = core.duplicateBufferHandle(sharedBuffer.handle, | |
220 core.DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE); | |
221 | |
222 expect(dupedBufferHandle.result).toBe(core.RESULT_OK); | |
223 expect(core.isHandle(dupedBufferHandle.handle)).toBeTruthy(); | |
224 | |
225 let mappedBuffer1 = core.mapBuffer(dupedBufferHandle.handle, | |
226 offset, | |
227 buffer_size, | |
228 core.MAP_BUFFER_FLAG_NONE); | |
229 | |
230 expect(mappedBuffer1.result).toBe(core.RESULT_OK); | |
231 | |
232 let buffer0 = new Uint8Array(mappedBuffer0.buffer); | |
233 let buffer1 = new Uint8Array(mappedBuffer1.buffer); | |
234 for(let i = 0; i < buffer0.length; ++i) { | |
235 buffer0[i] = i; | |
236 expect(buffer1[i]).toBe(i); | |
237 } | |
238 | |
239 expect(core.unmapBuffer(mappedBuffer0.buffer)).toBe(core.RESULT_OK); | |
240 expect(core.unmapBuffer(mappedBuffer1.buffer)).toBe(core.RESULT_OK); | |
241 | |
242 expect(core.close(dupedBufferHandle.handle)).toBe(core.RESULT_OK); | |
243 expect(core.close(sharedBuffer.handle)).toBe(core.RESULT_OK); | |
244 } | |
245 | |
246 }); | |
OLD | NEW |