| 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 import random | |
| 6 import sys | |
| 7 import time | |
| 8 import unittest | |
| 9 | |
| 10 # Setup sys path | |
| 11 for path in sys.argv[1:]: | |
| 12 sys.path.append(path) | |
| 13 | |
| 14 # pylint: disable=F0401 | |
| 15 from mojo.embedder import init as init_embedder | |
| 16 from mojo import system | |
| 17 | |
| 18 DATA_SIZE = 1024 | |
| 19 | |
| 20 | |
| 21 def get_random_buffer(size): | |
| 22 random.seed(size) | |
| 23 return bytearray(''.join(chr(random.randint(0, 255)) for i in xrange(size))) | |
| 24 | |
| 25 | |
| 26 class BaseMojoTest(unittest.TestCase): | |
| 27 | |
| 28 def setUp(self): | |
| 29 init_embedder() | |
| 30 | |
| 31 | |
| 32 class CoreTest(BaseMojoTest): | |
| 33 | |
| 34 def test_results(self): | |
| 35 self.assertEquals(system.RESULT_OK, 0) | |
| 36 self.assertLess(system.RESULT_CANCELLED, 0) | |
| 37 self.assertLess(system.RESULT_UNKNOWN, 0) | |
| 38 self.assertLess(system.RESULT_INVALID_ARGUMENT, 0) | |
| 39 self.assertLess(system.RESULT_DEADLINE_EXCEEDED, 0) | |
| 40 self.assertLess(system.RESULT_NOT_FOUND, 0) | |
| 41 self.assertLess(system.RESULT_ALREADY_EXISTS, 0) | |
| 42 self.assertLess(system.RESULT_PERMISSION_DENIED, 0) | |
| 43 self.assertLess(system.RESULT_RESOURCE_EXHAUSTED, 0) | |
| 44 self.assertLess(system.RESULT_FAILED_PRECONDITION, 0) | |
| 45 self.assertLess(system.RESULT_ABORTED, 0) | |
| 46 self.assertLess(system.RESULT_OUT_OF_RANGE, 0) | |
| 47 self.assertLess(system.RESULT_UNIMPLEMENTED, 0) | |
| 48 self.assertLess(system.RESULT_INTERNAL, 0) | |
| 49 self.assertLess(system.RESULT_UNAVAILABLE, 0) | |
| 50 self.assertLess(system.RESULT_DATA_LOSS, 0) | |
| 51 self.assertLess(system.RESULT_BUSY, 0) | |
| 52 self.assertLess(system.RESULT_SHOULD_WAIT, 0) | |
| 53 | |
| 54 def test_constants(self): | |
| 55 self.assertGreaterEqual(system.DEADLINE_INDEFINITE, 0) | |
| 56 self.assertGreaterEqual(system.HANDLE_SIGNAL_NONE, 0) | |
| 57 self.assertGreaterEqual(system.HANDLE_SIGNAL_READABLE, 0) | |
| 58 self.assertGreaterEqual(system.HANDLE_SIGNAL_WRITABLE, 0) | |
| 59 self.assertGreaterEqual(system.WRITE_MESSAGE_FLAG_NONE, 0) | |
| 60 self.assertGreaterEqual(system.READ_MESSAGE_FLAG_NONE, 0) | |
| 61 self.assertGreaterEqual(system.READ_MESSAGE_FLAG_MAY_DISCARD, 0) | |
| 62 self.assertGreaterEqual(system.WRITE_DATA_FLAG_NONE, 0) | |
| 63 self.assertGreaterEqual(system.WRITE_DATA_FLAG_ALL_OR_NONE, 0) | |
| 64 self.assertGreaterEqual(system.READ_DATA_FLAG_NONE, 0) | |
| 65 self.assertGreaterEqual(system.READ_DATA_FLAG_ALL_OR_NONE, 0) | |
| 66 self.assertGreaterEqual(system.READ_DATA_FLAG_DISCARD, 0) | |
| 67 self.assertGreaterEqual(system.READ_DATA_FLAG_QUERY, 0) | |
| 68 self.assertGreaterEqual(system.MAP_BUFFER_FLAG_NONE, 0) | |
| 69 | |
| 70 def test_get_time_ticks_now(self): | |
| 71 pt1 = time.time() | |
| 72 v1 = system.get_time_ticks_now() | |
| 73 time.sleep(1e-3) | |
| 74 v2 = system.get_time_ticks_now() | |
| 75 pt2 = time.time() | |
| 76 self.assertGreater(v1, 0) | |
| 77 self.assertGreater(v2, v1 + 1000) | |
| 78 self.assertGreater(1e6 * (pt2 - pt1), v2 - v1) | |
| 79 | |
| 80 def _test_handles_creation(self, *args): | |
| 81 for handle in args: | |
| 82 self.assertTrue(handle.is_valid()) | |
| 83 handle.close() | |
| 84 self.assertFalse(handle.is_valid()) | |
| 85 | |
| 86 def _test_message_handle_creation(self, handles): | |
| 87 self._test_handles_creation(handles.handle0, handles.handle1) | |
| 88 | |
| 89 def test_create_message_pipe(self): | |
| 90 self._test_message_handle_creation(system.MessagePipe()) | |
| 91 | |
| 92 def test_create_message_pipe_with_none_options(self): | |
| 93 self._test_message_handle_creation(system.MessagePipe(None)) | |
| 94 | |
| 95 def test_create_message_pipe_with_options(self): | |
| 96 self._test_message_handle_creation( | |
| 97 system.MessagePipe(system.CreateMessagePipeOptions())) | |
| 98 | |
| 99 def test_wait_over_message_pipe(self): | |
| 100 handles = system.MessagePipe() | |
| 101 handle = handles.handle0 | |
| 102 | |
| 103 self.assertEquals(system.RESULT_OK, handle.wait( | |
| 104 system.HANDLE_SIGNAL_WRITABLE, system.DEADLINE_INDEFINITE)) | |
| 105 self.assertEquals(system.RESULT_DEADLINE_EXCEEDED, | |
| 106 handle.wait(system.HANDLE_SIGNAL_READABLE, 0)) | |
| 107 | |
| 108 handles.handle1.write_message() | |
| 109 | |
| 110 self.assertEquals( | |
| 111 system.RESULT_OK, | |
| 112 handle.wait( | |
| 113 system.HANDLE_SIGNAL_READABLE, | |
| 114 system.DEADLINE_INDEFINITE)) | |
| 115 | |
| 116 def test_wait_over_many_message_pipe(self): | |
| 117 handles = system.MessagePipe() | |
| 118 handle0 = handles.handle0 | |
| 119 handle1 = handles.handle1 | |
| 120 | |
| 121 self.assertEquals( | |
| 122 0, | |
| 123 system.wait_many( | |
| 124 [(handle0, system.HANDLE_SIGNAL_WRITABLE), | |
| 125 (handle1, system.HANDLE_SIGNAL_WRITABLE)], | |
| 126 system.DEADLINE_INDEFINITE)) | |
| 127 self.assertEquals( | |
| 128 system.RESULT_DEADLINE_EXCEEDED, | |
| 129 system.wait_many( | |
| 130 [(handle0, system.HANDLE_SIGNAL_READABLE), | |
| 131 (handle1, system.HANDLE_SIGNAL_READABLE)], 0)) | |
| 132 | |
| 133 handle0.write_message() | |
| 134 | |
| 135 self.assertEquals( | |
| 136 1, | |
| 137 system.wait_many( | |
| 138 [(handle0, system.HANDLE_SIGNAL_READABLE), | |
| 139 (handle1, system.HANDLE_SIGNAL_READABLE)], | |
| 140 system.DEADLINE_INDEFINITE)) | |
| 141 | |
| 142 def test_send_bytes_over_message_pipe(self): | |
| 143 handles = system.MessagePipe() | |
| 144 data = get_random_buffer(DATA_SIZE) | |
| 145 handles.handle0.write_message(data) | |
| 146 (res, buffers, next_message) = handles.handle1.read_message() | |
| 147 self.assertEquals(system.RESULT_RESOURCE_EXHAUSTED, res) | |
| 148 self.assertEquals(None, buffers) | |
| 149 self.assertEquals((DATA_SIZE, 0), next_message) | |
| 150 result = bytearray(DATA_SIZE) | |
| 151 (res, buffers, next_message) = handles.handle1.read_message(result) | |
| 152 self.assertEquals(system.RESULT_OK, res) | |
| 153 self.assertEquals(None, next_message) | |
| 154 self.assertEquals((data, []), buffers) | |
| 155 | |
| 156 def test_send_empty_data_over_message_pipe(self): | |
| 157 handles = system.MessagePipe() | |
| 158 handles.handle0.write_message(None) | |
| 159 (res, buffers, next_message) = handles.handle1.read_message() | |
| 160 | |
| 161 self.assertEquals(system.RESULT_OK, res) | |
| 162 self.assertEquals(None, next_message) | |
| 163 self.assertEquals((None, []), buffers) | |
| 164 | |
| 165 def test_send_handle_over_message_pipe(self): | |
| 166 handles = system.MessagePipe() | |
| 167 handles_to_send = system.MessagePipe() | |
| 168 handles.handle0.write_message(handles=[handles_to_send.handle0, | |
| 169 handles_to_send.handle1]) | |
| 170 (res, buffers, next_message) = handles.handle1.read_message( | |
| 171 max_number_of_handles=2) | |
| 172 | |
| 173 self.assertFalse(handles_to_send.handle0.is_valid()) | |
| 174 self.assertFalse(handles_to_send.handle1.is_valid()) | |
| 175 self.assertEquals(system.RESULT_OK, res) | |
| 176 self.assertEquals(None, next_message) | |
| 177 self.assertEquals(None, buffers[0]) | |
| 178 self.assertEquals(2, len(buffers[1])) | |
| 179 | |
| 180 handles = buffers[1] | |
| 181 for handle in handles: | |
| 182 self.assertTrue(handle.is_valid()) | |
| 183 (res, buffers, next_message) = handle.read_message() | |
| 184 self.assertEquals(system.RESULT_SHOULD_WAIT, res) | |
| 185 | |
| 186 for handle in handles: | |
| 187 handle.write_message() | |
| 188 | |
| 189 for handle in handles: | |
| 190 (res, buffers, next_message) = handle.read_message() | |
| 191 self.assertEquals(system.RESULT_OK, res) | |
| 192 | |
| 193 def _test_data_handle_creation(self, handles): | |
| 194 self._test_handles_creation( | |
| 195 handles.producer_handle, handles.consumer_handle) | |
| 196 | |
| 197 def test_create_data_pipe(self): | |
| 198 self._test_data_handle_creation(system.DataPipe()) | |
| 199 | |
| 200 def test_create_data_pipe_with_none_options(self): | |
| 201 self._test_data_handle_creation(system.DataPipe(None)) | |
| 202 | |
| 203 def test_create_data_pipe_with_default_options(self): | |
| 204 self._test_data_handle_creation( | |
| 205 system.DataPipe(system.CreateDataPipeOptions())) | |
| 206 | |
| 207 def test_create_data_pipe_with_discard_flag(self): | |
| 208 options = system.CreateDataPipeOptions() | |
| 209 options.flags = system.CreateDataPipeOptions.FLAG_MAY_DISCARD | |
| 210 self._test_data_handle_creation(system.DataPipe(options)) | |
| 211 | |
| 212 def test_create_data_pipe_with_element_size(self): | |
| 213 options = system.CreateDataPipeOptions() | |
| 214 options.element_num_bytes = 5 | |
| 215 self._test_data_handle_creation(system.DataPipe(options)) | |
| 216 | |
| 217 def test_create_data_pipe_with_capacity(self): | |
| 218 options = system.CreateDataPipeOptions() | |
| 219 options.element_capacity_num_bytes = DATA_SIZE | |
| 220 self._test_data_handle_creation(system.DataPipe(options)) | |
| 221 | |
| 222 def test_create_data_pipe_with_incorrect_parameters(self): | |
| 223 options = system.CreateDataPipeOptions() | |
| 224 options.element_num_bytes = 5 | |
| 225 options.capacity_num_bytes = DATA_SIZE | |
| 226 with self.assertRaises(system.MojoException) as cm: | |
| 227 self._test_data_handle_creation(system.DataPipe(options)) | |
| 228 self.assertEquals(system.RESULT_INVALID_ARGUMENT, cm.exception.mojo_result) | |
| 229 | |
| 230 def test_send_empty_data_over_data_pipe(self): | |
| 231 pipes = system.DataPipe() | |
| 232 self.assertEquals((system.RESULT_OK, 0), pipes.producer_handle.write_data()) | |
| 233 self.assertEquals( | |
| 234 (system.RESULT_OK, None), pipes.consumer_handle.read_data()) | |
| 235 | |
| 236 def test_send_data_over_data_pipe(self): | |
| 237 pipes = system.DataPipe() | |
| 238 data = get_random_buffer(DATA_SIZE) | |
| 239 self.assertEquals((system.RESULT_OK, DATA_SIZE), | |
| 240 pipes.producer_handle.write_data(data)) | |
| 241 self.assertEquals((system.RESULT_OK, data), | |
| 242 pipes.consumer_handle.read_data(bytearray(DATA_SIZE))) | |
| 243 | |
| 244 def test_two_phase_write_on_data_pipe(self): | |
| 245 pipes = system.DataPipe() | |
| 246 (res, buf) = pipes.producer_handle.begin_write_data(DATA_SIZE) | |
| 247 self.assertEquals(system.RESULT_OK, res) | |
| 248 self.assertGreaterEqual(len(buf.buffer), DATA_SIZE) | |
| 249 data = get_random_buffer(DATA_SIZE) | |
| 250 buf.buffer[0:DATA_SIZE] = data | |
| 251 self.assertEquals(system.RESULT_OK, buf.end(DATA_SIZE)) | |
| 252 self.assertEquals((system.RESULT_OK, data), | |
| 253 pipes.consumer_handle.read_data(bytearray(DATA_SIZE))) | |
| 254 | |
| 255 def test_two_phase_read_on_data_pipe(self): | |
| 256 pipes = system.DataPipe() | |
| 257 data = get_random_buffer(DATA_SIZE) | |
| 258 self.assertEquals((system.RESULT_OK, DATA_SIZE), | |
| 259 pipes.producer_handle.write_data(data)) | |
| 260 (res, buf) = pipes.consumer_handle.begin_read_data() | |
| 261 self.assertEquals(system.RESULT_OK, res) | |
| 262 self.assertEquals(DATA_SIZE, len(buf.buffer)) | |
| 263 self.assertEquals(data, buf.buffer) | |
| 264 self.assertEquals(system.RESULT_OK, buf.end(DATA_SIZE)) | |
| 265 | |
| 266 def test_create_shared_buffer(self): | |
| 267 self._test_handles_creation(system.create_shared_buffer(DATA_SIZE)) | |
| 268 | |
| 269 def test_create_shared_buffer_with_none_options(self): | |
| 270 self._test_handles_creation(system.create_shared_buffer(DATA_SIZE, None)) | |
| 271 | |
| 272 def test_create_shared_buffer_with_default_options(self): | |
| 273 self._test_handles_creation( | |
| 274 system.create_shared_buffer( | |
| 275 DATA_SIZE, | |
| 276 system.CreateSharedBufferOptions())) | |
| 277 | |
| 278 def test_duplicate_shared_buffer(self): | |
| 279 handle = system.create_shared_buffer(DATA_SIZE) | |
| 280 self._test_handles_creation(handle.duplicate()) | |
| 281 | |
| 282 def test_duplicate_shared_buffer_with_none_options(self): | |
| 283 handle = system.create_shared_buffer(DATA_SIZE) | |
| 284 self._test_handles_creation(handle.duplicate(None)) | |
| 285 | |
| 286 def test_duplicate_shared_buffer_with_default_options(self): | |
| 287 handle = system.create_shared_buffer(DATA_SIZE) | |
| 288 self._test_handles_creation( | |
| 289 handle.duplicate(system.DuplicateSharedBufferOptions())) | |
| 290 | |
| 291 def test_send_bytes_over_shared_buffer(self): | |
| 292 handle = system.create_shared_buffer(DATA_SIZE) | |
| 293 duplicated = handle.duplicate() | |
| 294 data = get_random_buffer(DATA_SIZE) | |
| 295 (res1, buf1) = handle.map(0, DATA_SIZE) | |
| 296 (res2, buf2) = duplicated.map(0, DATA_SIZE) | |
| 297 self.assertEquals(system.RESULT_OK, res1) | |
| 298 self.assertEquals(system.RESULT_OK, res2) | |
| 299 self.assertEquals(DATA_SIZE, len(buf1.buffer)) | |
| 300 self.assertEquals(DATA_SIZE, len(buf2.buffer)) | |
| 301 self.assertEquals(buf1.buffer, buf2.buffer) | |
| 302 | |
| 303 buf1.buffer[:] = data | |
| 304 self.assertEquals(data, buf1.buffer) | |
| 305 self.assertEquals(data, buf2.buffer) | |
| 306 self.assertEquals(buf1.buffer, buf2.buffer) | |
| 307 | |
| 308 | |
| 309 if __name__ == '__main__': | |
| 310 suite = unittest.TestLoader().loadTestsFromTestCase(CoreTest) | |
| 311 test_results = unittest.TextTestRunner(verbosity=0).run(suite) | |
| 312 if not test_results.wasSuccessful(): | |
| 313 sys.exit(1) | |
| 314 sys.exit(0) | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 506593002:
Revert "Core mojo API for python." (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master