| 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 /** | |
| 6 * Unit tests for the JS serial service client. | |
| 7 * | |
| 8 * These test that configuration and data are correctly transmitted between the | |
| 9 * client and the service. They are launched by | |
| 10 * extensions/renderer/api/serial/serial_api_unittest.cc. | |
| 11 */ | |
| 12 | |
| 13 var test = require('test').binding; | |
| 14 var serial = require('serial').binding; | |
| 15 var unittestBindings = require('test_environment_specific_bindings'); | |
| 16 var utils = require('utils'); | |
| 17 | |
| 18 var timeoutManager = new unittestBindings.TimeoutManager(); | |
| 19 timeoutManager.installGlobals(); | |
| 20 | |
| 21 var BUFFER_SIZE = 10; | |
| 22 | |
| 23 var connectionId = null; | |
| 24 | |
| 25 var OPTIONS_VALUES = [ | |
| 26 {}, // SetPortOptions is called once during connection. | |
| 27 {bitrate: 57600}, | |
| 28 {dataBits: 'seven'}, | |
| 29 {dataBits: 'eight'}, | |
| 30 {parityBit: 'no'}, | |
| 31 {parityBit: 'odd'}, | |
| 32 {parityBit: 'even'}, | |
| 33 {stopBits: 'one'}, | |
| 34 {stopBits: 'two'}, | |
| 35 {ctsFlowControl: false}, | |
| 36 {ctsFlowControl: true}, | |
| 37 {bufferSize: 1}, | |
| 38 {sendTimeout: 0}, | |
| 39 {receiveTimeout: 0}, | |
| 40 {persistent: false}, | |
| 41 {name: 'name'}, | |
| 42 ]; | |
| 43 | |
| 44 // Create a serial connection. That serial connection will be used by the other | |
| 45 // helper functions below. | |
| 46 function connect(options) { | |
| 47 options = options || { | |
| 48 name: 'test connection', | |
| 49 bufferSize: BUFFER_SIZE, | |
| 50 receiveTimeout: 12345, | |
| 51 sendTimeout: 6789, | |
| 52 persistent: true, | |
| 53 }; | |
| 54 return utils.promise(serial.connect, 'device', options).then(function(info) { | |
| 55 connectionId = info.connectionId; | |
| 56 return info; | |
| 57 }); | |
| 58 } | |
| 59 | |
| 60 // Serialize and deserialize all serial connections, preserving onData and | |
| 61 // onError event listeners. | |
| 62 function serializeRoundTrip() { | |
| 63 return requireAsync('serial_service').then(function(serialService) { | |
| 64 function serializeConnections(connections) { | |
| 65 var serializedConnections = []; | |
| 66 for (var connection of connections.values()) { | |
| 67 serializedConnections.push(serializeConnection(connection)); | |
| 68 } | |
| 69 return Promise.all(serializedConnections); | |
| 70 } | |
| 71 | |
| 72 function serializeConnection(connection) { | |
| 73 var onData = connection.onData; | |
| 74 var onError = connection.onError; | |
| 75 return connection.serialize().then(function(serialization) { | |
| 76 return { | |
| 77 serialization: serialization, | |
| 78 onData: onData, | |
| 79 onError: onError, | |
| 80 }; | |
| 81 }); | |
| 82 } | |
| 83 | |
| 84 function deserializeConnections(serializedConnections) { | |
| 85 $Array.forEach(serializedConnections, function(serializedConnection) { | |
| 86 var connection = serialService.Connection.deserialize( | |
| 87 serializedConnection.serialization); | |
| 88 connection.onData = serializedConnection.onData; | |
| 89 connection.onError = serializedConnection.onError; | |
| 90 connection.resumeReceives(); | |
| 91 }); | |
| 92 } | |
| 93 | |
| 94 return serialService.getConnections() | |
| 95 .then(serializeConnections) | |
| 96 .then(deserializeConnections); | |
| 97 }); | |
| 98 } | |
| 99 | |
| 100 // Returns a promise that will resolve to the connection info for the | |
| 101 // connection. | |
| 102 function getInfo() { | |
| 103 return utils.promise(serial.getInfo, connectionId); | |
| 104 } | |
| 105 | |
| 106 // Returns a function that checks that the values of keys contained within | |
| 107 // |expectedInfo| match the values of the same keys contained within |info|. | |
| 108 function checkInfo(expectedInfo) { | |
| 109 return function(info) { | |
| 110 for (var key in expectedInfo) { | |
| 111 test.assertEq(expectedInfo[key], info[key]); | |
| 112 } | |
| 113 }; | |
| 114 } | |
| 115 | |
| 116 // Returns a function that will update the options of the serial connection with | |
| 117 // those contained within |values|. | |
| 118 function update(values) { | |
| 119 return function() { | |
| 120 return utils.promise(serial.update, connectionId, values); | |
| 121 }; | |
| 122 } | |
| 123 | |
| 124 // Checks that the previous operation succeeded. | |
| 125 function expectSuccess(success) { | |
| 126 test.assertTrue(success); | |
| 127 } | |
| 128 | |
| 129 // Returns a function that checks that the send result matches |bytesSent| and | |
| 130 // |error|. If no error is expected, |error| may be omitted. | |
| 131 function expectSendResult(bytesSent, error) { | |
| 132 return function(sendInfo) { | |
| 133 test.assertEq(bytesSent, sendInfo.bytesSent); | |
| 134 test.assertEq(error, sendInfo.error); | |
| 135 }; | |
| 136 } | |
| 137 | |
| 138 // Returns a function that checks that the current time is |expectedTime|. | |
| 139 function expectCurrentTime(expectedTime) { | |
| 140 return function() { | |
| 141 test.assertEq(expectedTime, timeoutManager.currentTime); | |
| 142 } | |
| 143 } | |
| 144 | |
| 145 // Returns a promise that will resolve to the device control signals for the | |
| 146 // serial connection. | |
| 147 function getControlSignals() { | |
| 148 return utils.promise(serial.getControlSignals, connectionId); | |
| 149 } | |
| 150 | |
| 151 // Returns a function that will set the control signals for the serial | |
| 152 // connection to |signals|. | |
| 153 function setControlSignals(signals) { | |
| 154 return function() { | |
| 155 return utils.promise(serial.setControlSignals, connectionId, signals); | |
| 156 }; | |
| 157 } | |
| 158 | |
| 159 // Returns a function that will set the paused state of the serial connection to | |
| 160 // |paused|. | |
| 161 function setPaused(paused) { | |
| 162 return function() { | |
| 163 return utils.promise(serial.setPaused, connectionId, paused); | |
| 164 } | |
| 165 } | |
| 166 | |
| 167 // Sets a function to be called once when data is received. Returns a promise | |
| 168 // that will resolve once the hook is installed. | |
| 169 function addReceiveHook(callback) { | |
| 170 return requireAsync('serial_service').then(function(serialService) { | |
| 171 var called = false; | |
| 172 var dataReceived = serialService.Connection.prototype.onDataReceived_; | |
| 173 serialService.Connection.prototype.onDataReceived_ = function() { | |
| 174 var result = $Function.apply(dataReceived, this, arguments); | |
| 175 if (!called) | |
| 176 callback(); | |
| 177 called = true; | |
| 178 return result; | |
| 179 }; | |
| 180 }); | |
| 181 } | |
| 182 | |
| 183 // Sets a function to be called once when a receive error is received. Returns a | |
| 184 // promise that will resolve once the hook is installed. | |
| 185 function addReceiveErrorHook(callback) { | |
| 186 return requireAsync('serial_service').then(function(serialService) { | |
| 187 var called = false; | |
| 188 var receiveError = serialService.Connection.prototype.onReceiveError_; | |
| 189 serialService.Connection.prototype.onReceiveError_ = function() { | |
| 190 var result = $Function.apply(receiveError, this, arguments); | |
| 191 if (!called) | |
| 192 callback(); | |
| 193 called = true; | |
| 194 return result; | |
| 195 }; | |
| 196 }); | |
| 197 } | |
| 198 | |
| 199 function listenOnce(targetEvent) { | |
| 200 return new Promise(function(resolve, reject) { | |
| 201 targetEvent.addListener(function(result) { | |
| 202 resolve(result); | |
| 203 }); | |
| 204 }); | |
| 205 } | |
| 206 | |
| 207 function disconnect() { | |
| 208 return utils.promise(serial.disconnect, connectionId).then(function(success) { | |
| 209 test.assertTrue(success); | |
| 210 connectionId = null; | |
| 211 }); | |
| 212 } | |
| 213 | |
| 214 function checkClientConnectionInfo(connectionInfo) { | |
| 215 test.assertTrue(connectionInfo.persistent); | |
| 216 test.assertEq('test connection', connectionInfo.name); | |
| 217 test.assertEq(12345, connectionInfo.receiveTimeout); | |
| 218 test.assertEq(6789, connectionInfo.sendTimeout); | |
| 219 test.assertEq(BUFFER_SIZE, connectionInfo.bufferSize); | |
| 220 test.assertFalse(connectionInfo.paused); | |
| 221 } | |
| 222 | |
| 223 function checkServiceConnectionInfo(connectionInfo) { | |
| 224 test.assertEq(9600, connectionInfo.bitrate); | |
| 225 test.assertEq('eight', connectionInfo.dataBits); | |
| 226 test.assertEq('no', connectionInfo.parityBit); | |
| 227 test.assertEq('one', connectionInfo.stopBits); | |
| 228 test.assertFalse(connectionInfo.ctsFlowControl); | |
| 229 } | |
| 230 | |
| 231 function checkConnectionInfo(connectionInfo) { | |
| 232 checkClientConnectionInfo(connectionInfo); | |
| 233 checkServiceConnectionInfo(connectionInfo); | |
| 234 test.assertEq(12, $Object.keys(connectionInfo).length); | |
| 235 } | |
| 236 | |
| 237 function sendData() { | |
| 238 var data = 'data'; | |
| 239 var buffer = new ArrayBuffer(data.length); | |
| 240 var byteBuffer = new Int8Array(buffer); | |
| 241 for (var i = 0; i < data.length; i++) { | |
| 242 byteBuffer[i] = data.charCodeAt(i); | |
| 243 } | |
| 244 return utils.promise(serial.send, connectionId, buffer); | |
| 245 } | |
| 246 | |
| 247 function checkReceivedData(result) { | |
| 248 var data = 'data'; | |
| 249 test.assertEq(connectionId, result.connectionId); | |
| 250 test.assertEq(data.length, result.data.byteLength); | |
| 251 var resultByteBuffer = new Int8Array(result.data); | |
| 252 for (var i = 0; i < data.length; i++) { | |
| 253 test.assertEq(data.charCodeAt(i), resultByteBuffer[i]); | |
| 254 } | |
| 255 } | |
| 256 | |
| 257 function checkReceiveError(expectedError) { | |
| 258 return function(result) { | |
| 259 test.assertEq(connectionId, result.connectionId); | |
| 260 test.assertEq(expectedError, result.error); | |
| 261 } | |
| 262 } | |
| 263 | |
| 264 function runReceiveErrorTest(expectedError) { | |
| 265 var errorReceived = listenOnce(serial.onReceiveError); | |
| 266 Promise.all([ | |
| 267 connect(), | |
| 268 errorReceived | |
| 269 .then(checkReceiveError(expectedError)), | |
| 270 errorReceived | |
| 271 .then(getInfo) | |
| 272 .then(checkInfo({paused: true})), | |
| 273 ]) | |
| 274 .then(disconnect) | |
| 275 .then(test.succeed, test.fail); | |
| 276 } | |
| 277 | |
| 278 function runSendErrorTest(expectedError) { | |
| 279 connect() | |
| 280 .then(sendData) | |
| 281 .then(expectSendResult(0, expectedError)) | |
| 282 .then(disconnect) | |
| 283 .then(test.succeed, test.fail); | |
| 284 } | |
| 285 | |
| 286 unittestBindings.exportTests([ | |
| 287 // Test that getDevices correctly transforms the data returned by the | |
| 288 // SerialDeviceEnumerator. | |
| 289 function testGetDevices() { | |
| 290 utils.promise(serial.getDevices).then(function(devices) { | |
| 291 test.assertEq(3, devices.length); | |
| 292 test.assertEq(4, $Object.keys(devices[0]).length); | |
| 293 test.assertEq('device', devices[0].path); | |
| 294 test.assertEq(1234, devices[0].vendorId); | |
| 295 test.assertEq(5678, devices[0].productId); | |
| 296 test.assertEq('foo', devices[0].displayName); | |
| 297 test.assertEq(1, $Object.keys(devices[1]).length); | |
| 298 test.assertEq('another_device', devices[1].path); | |
| 299 test.assertEq(1, $Object.keys(devices[2]).length); | |
| 300 test.assertEq('', devices[2].path); | |
| 301 }).then(test.succeed, test.fail); | |
| 302 }, | |
| 303 | |
| 304 // Test that the correct error message is returned when an error occurs in | |
| 305 // connecting to the port. This test uses an IoHandler that fails to connect. | |
| 306 function testConnectFail() { | |
| 307 serial.connect('device', | |
| 308 test.callbackFail('Failed to connect to the port.')); | |
| 309 }, | |
| 310 | |
| 311 // Test that the correct error message is returned when an error occurs in | |
| 312 // calling getPortInfo after connecting to the port. This test uses an | |
| 313 // IoHandler that fails on calls to GetPortInfo. | |
| 314 function testGetInfoFailOnConnect() { | |
| 315 serial.connect('device', | |
| 316 test.callbackFail('Failed to connect to the port.')); | |
| 317 }, | |
| 318 | |
| 319 // Test that the correct error message is returned when an invalid bit-rate | |
| 320 // value is passed to connect. | |
| 321 function testConnectInvalidBitrate() { | |
| 322 serial.connect('device', {bitrate: -1}, test.callbackFail( | |
| 323 'Failed to connect to the port.')); | |
| 324 }, | |
| 325 | |
| 326 // Test that a successful connect returns the expected connection info. | |
| 327 function testConnect() { | |
| 328 connect() | |
| 329 .then(checkConnectionInfo) | |
| 330 .then(disconnect) | |
| 331 .then(test.succeed, test.fail); | |
| 332 }, | |
| 333 | |
| 334 // Test that a connection created with no options has the correct default | |
| 335 // options. | |
| 336 function testConnectDefaultOptions() { | |
| 337 connect({}).then(function(connectionInfo) { | |
| 338 test.assertEq(9600, connectionInfo.bitrate); | |
| 339 test.assertEq('eight', connectionInfo.dataBits); | |
| 340 test.assertEq('no', connectionInfo.parityBit); | |
| 341 test.assertEq('one', connectionInfo.stopBits); | |
| 342 test.assertFalse(connectionInfo.ctsFlowControl); | |
| 343 test.assertFalse(connectionInfo.persistent); | |
| 344 test.assertEq('', connectionInfo.name); | |
| 345 test.assertEq(0, connectionInfo.receiveTimeout); | |
| 346 test.assertEq(0, connectionInfo.sendTimeout); | |
| 347 test.assertEq(4096, connectionInfo.bufferSize); | |
| 348 }) | |
| 349 .then(disconnect) | |
| 350 .then(test.succeed, test.fail); | |
| 351 }, | |
| 352 | |
| 353 // Test that a getInfo call correctly converts the service-side info from the | |
| 354 // Mojo format and returns both it and the client-side configuration. | |
| 355 function testGetInfo() { | |
| 356 connect() | |
| 357 .then(getInfo) | |
| 358 .then(checkConnectionInfo) | |
| 359 .then(disconnect) | |
| 360 .then(test.succeed, test.fail); | |
| 361 }, | |
| 362 | |
| 363 // Test that a getInfo call returns the correct info after serialization. | |
| 364 function testGetInfoAfterSerialization() { | |
| 365 connect() | |
| 366 .then(serializeRoundTrip) | |
| 367 .then(getInfo) | |
| 368 .then(checkConnectionInfo) | |
| 369 .then(disconnect) | |
| 370 .then(test.succeed, test.fail); | |
| 371 }, | |
| 372 | |
| 373 // Test that only client-side options are returned when the service fails a | |
| 374 // getInfo call. This test uses an IoHandler that fails GetPortInfo calls | |
| 375 // after the initial call during connect. | |
| 376 function testGetInfoFailToGetPortInfo() { | |
| 377 var info = connect().then(getInfo); | |
| 378 Promise.all([ | |
| 379 info.then(function(connectionInfo) { | |
| 380 test.assertFalse('bitrate' in connectionInfo); | |
| 381 test.assertFalse('dataBits' in connectionInfo); | |
| 382 test.assertFalse('parityBit' in connectionInfo); | |
| 383 test.assertFalse('stopBit' in connectionInfo); | |
| 384 test.assertFalse('ctsFlowControl' in connectionInfo); | |
| 385 }), | |
| 386 info.then(checkClientConnectionInfo), | |
| 387 ]) | |
| 388 .then(disconnect) | |
| 389 .then(test.succeed, test.fail); | |
| 390 }, | |
| 391 | |
| 392 // Test that getConnections returns an array containing the open connection. | |
| 393 function testGetConnections() { | |
| 394 connect().then(function() { | |
| 395 return utils.promise(serial.getConnections); | |
| 396 }).then(function(connections) { | |
| 397 test.assertEq(1, connections.length); | |
| 398 checkConnectionInfo(connections[0]); | |
| 399 }) | |
| 400 .then(disconnect) | |
| 401 .then(test.succeed, test.fail); | |
| 402 }, | |
| 403 | |
| 404 // Test that getControlSignals correctly converts the Mojo format result. This | |
| 405 // test uses an IoHandler that returns values matching the pattern being | |
| 406 // tested. | |
| 407 function testGetControlSignals() { | |
| 408 function checkControlSignals(expectedBitfield) { | |
| 409 return function(signals) { | |
| 410 test.assertEq(!!(expectedBitfield & 1), signals.dcd); | |
| 411 test.assertEq(!!(expectedBitfield & 2), signals.cts); | |
| 412 test.assertEq(!!(expectedBitfield & 4), signals.ri); | |
| 413 test.assertEq(!!(expectedBitfield & 8), signals.dsr); | |
| 414 }; | |
| 415 } | |
| 416 var promiseChain = connect(); | |
| 417 for (var i = 0; i < 16; i++) { | |
| 418 promiseChain = promiseChain | |
| 419 .then(getControlSignals) | |
| 420 .then(checkControlSignals(i)); | |
| 421 } | |
| 422 promiseChain | |
| 423 .then(disconnect) | |
| 424 .then(test.succeed, test.fail); | |
| 425 }, | |
| 426 | |
| 427 // Test that setControlSignals correctly converts to the Mojo format result. | |
| 428 // This test uses an IoHandler that returns values following the same table of | |
| 429 // values as |signalsValues|. | |
| 430 function testSetControlSignals() { | |
| 431 var signalsValues = [ | |
| 432 {}, | |
| 433 {dtr: false}, | |
| 434 {dtr: true}, | |
| 435 {rts: false}, | |
| 436 {dtr: false, rts: false}, | |
| 437 {dtr: true, rts: false}, | |
| 438 {rts: true}, | |
| 439 {dtr: false, rts: true}, | |
| 440 {dtr: true, rts: true}, | |
| 441 ]; | |
| 442 var promiseChain = connect(); | |
| 443 for (var i = 0; i < signalsValues.length; i++) { | |
| 444 promiseChain = promiseChain.then(setControlSignals(signalsValues[i])); | |
| 445 } | |
| 446 promiseChain | |
| 447 .then(disconnect) | |
| 448 .then(test.succeed, test.fail); | |
| 449 }, | |
| 450 | |
| 451 // Test that update correctly passes values to the service only for | |
| 452 // service-side options and that all update calls are reflected by the result | |
| 453 // of getInfo calls. This test uses an IoHandler that expects corresponding | |
| 454 // ConfigurePort calls. | |
| 455 function testUpdate() { | |
| 456 var promiseChain = connect() | |
| 457 .then(getInfo) | |
| 458 .then(checkInfo(OPTIONS_VALUES[i])); | |
| 459 for (var i = 1; i < OPTIONS_VALUES.length; i++) { | |
| 460 promiseChain = promiseChain | |
| 461 .then(update(OPTIONS_VALUES[i])) | |
| 462 .then(expectSuccess) | |
| 463 .then(getInfo) | |
| 464 .then(checkInfo(OPTIONS_VALUES[i])); | |
| 465 } | |
| 466 promiseChain | |
| 467 .then(disconnect) | |
| 468 .then(test.succeed, test.fail); | |
| 469 }, | |
| 470 | |
| 471 // Test that options set by update persist after serialization. | |
| 472 function testUpdateAcrossSerialization() { | |
| 473 var promiseChain = connect() | |
| 474 .then(serializeRoundTrip) | |
| 475 .then(getInfo) | |
| 476 .then(checkInfo(OPTIONS_VALUES[i])); | |
| 477 for (var i = 1; i < OPTIONS_VALUES.length; i++) { | |
| 478 promiseChain = promiseChain | |
| 479 .then(update(OPTIONS_VALUES[i])) | |
| 480 .then(expectSuccess) | |
| 481 .then(serializeRoundTrip) | |
| 482 .then(getInfo) | |
| 483 .then(checkInfo(OPTIONS_VALUES[i])); | |
| 484 } | |
| 485 promiseChain | |
| 486 .then(disconnect) | |
| 487 .then(test.succeed, test.fail); | |
| 488 }, | |
| 489 | |
| 490 // Test that passing an invalid bit-rate reslts in an error. | |
| 491 function testUpdateInvalidBitrate() { | |
| 492 connect() | |
| 493 .then(update({bitrate: -1})) | |
| 494 .then(function(success) { | |
| 495 test.assertFalse(success); | |
| 496 }) | |
| 497 .then(disconnect) | |
| 498 .then(test.succeed, test.fail); | |
| 499 }, | |
| 500 | |
| 501 // Test flush. This test uses an IoHandler that counts the number of flush | |
| 502 // calls. | |
| 503 function testFlush() { | |
| 504 connect().then(function() { | |
| 505 return utils.promise(serial.flush, connectionId); | |
| 506 }) | |
| 507 .then(expectSuccess) | |
| 508 .then(disconnect) | |
| 509 .then(test.succeed, test.fail); | |
| 510 }, | |
| 511 | |
| 512 // Test that setPaused values are reflected by the results returned by getInfo | |
| 513 // calls. | |
| 514 function testSetPaused() { | |
| 515 connect() | |
| 516 .then(setPaused(true)) | |
| 517 .then(getInfo) | |
| 518 .then(checkInfo({paused: true})) | |
| 519 .then(setPaused(false)) | |
| 520 .then(getInfo) | |
| 521 .then(checkInfo({paused: false})) | |
| 522 .then(disconnect) | |
| 523 .then(test.succeed, test.fail); | |
| 524 }, | |
| 525 | |
| 526 // Test that a send and a receive correctly echoes data. This uses an | |
| 527 // IoHandler that echoes data sent to it. | |
| 528 function testEcho() { | |
| 529 Promise.all([ | |
| 530 connect() | |
| 531 .then(sendData) | |
| 532 .then(expectSendResult(4)), | |
| 533 listenOnce(serial.onReceive) | |
| 534 .then(checkReceivedData), | |
| 535 ]) | |
| 536 .then(disconnect) | |
| 537 .then(test.succeed, test.fail); | |
| 538 }, | |
| 539 | |
| 540 // Test that a send while another send is in progress returns a pending error. | |
| 541 function testSendDuringExistingSend() { | |
| 542 var connected = connect(); | |
| 543 Promise.all([ | |
| 544 connected | |
| 545 .then(sendData) | |
| 546 .then(expectSendResult(4)), | |
| 547 connected | |
| 548 .then(sendData) | |
| 549 .then(expectSendResult(0, 'pending')), | |
| 550 ]) | |
| 551 .then(disconnect) | |
| 552 .then(test.succeed, test.fail); | |
| 553 }, | |
| 554 | |
| 555 // Test that a second send after the first finishes is successful. This uses | |
| 556 // an IoHandler that echoes data sent to it. | |
| 557 function testSendAfterSuccessfulSend() { | |
| 558 connect() | |
| 559 .then(sendData) | |
| 560 .then(expectSendResult(4)) | |
| 561 .then(sendData) | |
| 562 .then(expectSendResult(4)) | |
| 563 .then(disconnect) | |
| 564 .then(test.succeed, test.fail); | |
| 565 }, | |
| 566 | |
| 567 // Test that a second send after the first fails is successful. This uses an | |
| 568 // IoHandler that returns system_error for only the first send. | |
| 569 function testSendPartialSuccessWithError() { | |
| 570 connect() | |
| 571 .then(sendData) | |
| 572 .then(expectSendResult(2, 'system_error')) | |
| 573 .then(sendData) | |
| 574 .then(expectSendResult(4)) | |
| 575 .then(disconnect) | |
| 576 .then(test.succeed, test.fail); | |
| 577 }, | |
| 578 | |
| 579 // Test that a send and a receive correctly echoes data after serialization. | |
| 580 function testEchoAfterSerialization() { | |
| 581 Promise.all([ | |
| 582 connect() | |
| 583 .then(serializeRoundTrip) | |
| 584 .then(sendData) | |
| 585 .then(expectSendResult(4)), | |
| 586 listenOnce(serial.onReceive).then(checkReceivedData) | |
| 587 ]) | |
| 588 .then(disconnect) | |
| 589 .then(test.succeed, test.fail); | |
| 590 }, | |
| 591 | |
| 592 // Test that a timed-out send returns a timeout error and that changing the | |
| 593 // send timeout during a send does not affect its timeout. This test uses an | |
| 594 // IoHandle that never completes sends. | |
| 595 function testSendTimeout() { | |
| 596 var connected = connect({sendTimeout: 5}); | |
| 597 var sent = connected.then(sendData); | |
| 598 Promise.all([ | |
| 599 sent.then(expectSendResult(0, 'timeout')), | |
| 600 sent.then(expectCurrentTime(5)), | |
| 601 connected.then(update({sendTimeout: 10})) | |
| 602 .then(expectSuccess) | |
| 603 .then(timeoutManager.run.bind(timeoutManager, 1)), | |
| 604 ]) | |
| 605 .then(disconnect) | |
| 606 .then(test.succeed, test.fail); | |
| 607 }, | |
| 608 | |
| 609 // Test that send timeouts still function correctly after a serialization | |
| 610 // round trip. | |
| 611 function testSendTimeoutAfterSerialization() { | |
| 612 var connected = connect({sendTimeout: 5}).then(serializeRoundTrip); | |
| 613 var sent = connected.then(sendData); | |
| 614 Promise.all([ | |
| 615 sent.then(expectSendResult(0, 'timeout')), | |
| 616 sent.then(expectCurrentTime(5)), | |
| 617 connected.then(update({sendTimeout: 10})) | |
| 618 .then(expectSuccess) | |
| 619 .then(timeoutManager.run.bind(timeoutManager, 1)), | |
| 620 ]) | |
| 621 .then(disconnect) | |
| 622 .then(test.succeed, test.fail); | |
| 623 }, | |
| 624 | |
| 625 // Test that a timed-out send returns a timeout error and that disabling the | |
| 626 // send timeout during a send does not affect its timeout. This test uses an | |
| 627 // IoHandle that never completes sends. | |
| 628 function testDisableSendTimeout() { | |
| 629 var connected = connect({sendTimeout: 5}); | |
| 630 var sent = connected.then(sendData); | |
| 631 Promise.all([ | |
| 632 sent.then(expectSendResult(0, 'timeout')), | |
| 633 sent.then(expectCurrentTime(5)), | |
| 634 connected.then(update({sendTimeout: 0})) | |
| 635 .then(expectSuccess) | |
| 636 .then(timeoutManager.run.bind(timeoutManager, 1)), | |
| 637 ]) | |
| 638 .then(disconnect) | |
| 639 .then(test.succeed, test.fail); | |
| 640 }, | |
| 641 | |
| 642 // Test that data received while the connection is paused is queued and | |
| 643 // dispatched once the connection is unpaused. | |
| 644 function testPausedReceive() { | |
| 645 Promise.all([ | |
| 646 // Wait until the receive hook is installed, then start the test. | |
| 647 addReceiveHook(function() { | |
| 648 // Unpause the connection after the connection has queued the received | |
| 649 // data to ensure the queued data is dispatched when the connection is | |
| 650 // unpaused. | |
| 651 Promise.all([ | |
| 652 utils.promise(serial.setPaused, connectionId, false), | |
| 653 // Check that setPaused(false) is idempotent. | |
| 654 utils.promise(serial.setPaused, connectionId, false), | |
| 655 ]).catch(test.fail); | |
| 656 }) | |
| 657 .then(connect) | |
| 658 .then(function() { | |
| 659 // Check that setPaused(true) is idempotent. | |
| 660 return Promise.all([ | |
| 661 utils.promise(serial.setPaused, connectionId, true), | |
| 662 utils.promise(serial.setPaused, connectionId, true), | |
| 663 ]); | |
| 664 }), | |
| 665 listenOnce(serial.onReceive).then(checkReceivedData), | |
| 666 ]) | |
| 667 .then(disconnect) | |
| 668 .then(test.succeed, test.fail); | |
| 669 }, | |
| 670 | |
| 671 // Test that a receive error received while the connection is paused is queued | |
| 672 // and dispatched once the connection is unpaused. | |
| 673 function testPausedReceiveError() { | |
| 674 Promise.all([ | |
| 675 // Wait until the receive hook is installed, then start the test. | |
| 676 addReceiveErrorHook(function() { | |
| 677 // Unpause the connection after the connection has queued the received | |
| 678 // data to ensure the queued data is dispatched when the connection is | |
| 679 // unpaused. | |
| 680 utils.promise(serial.setPaused, connectionId, false).catch(test.fail); | |
| 681 }) | |
| 682 .then(connect) | |
| 683 .then(setPaused(true)), | |
| 684 listenOnce(serial.onReceiveError) | |
| 685 .then(checkReceiveError('device_lost')), | |
| 686 ]) | |
| 687 .then(disconnect) | |
| 688 .then(test.succeed, test.fail); | |
| 689 serial.onReceive.addListener(function() { | |
| 690 test.fail('unexpected onReceive event'); | |
| 691 }); | |
| 692 }, | |
| 693 | |
| 694 // Test that receive timeouts trigger after the timeout time elapses and that | |
| 695 // changing the receive timeout does not affect a wait in progress. | |
| 696 function testReceiveTimeout() { | |
| 697 var errorReceived = listenOnce(serial.onReceiveError); | |
| 698 Promise.all([ | |
| 699 errorReceived.then(checkReceiveError('timeout')), | |
| 700 errorReceived.then(expectCurrentTime(20)), | |
| 701 errorReceived | |
| 702 .then(getInfo) | |
| 703 .then(checkInfo({paused: false})), | |
| 704 connect({receiveTimeout: 20}) | |
| 705 // Changing the timeout does not take effect until the current | |
| 706 // timeout expires or a receive completes. | |
| 707 .then(update({receiveTimeout: 10})) | |
| 708 .then(expectSuccess) | |
| 709 .then(timeoutManager.run.bind(timeoutManager, 1)), | |
| 710 ]) | |
| 711 .then(disconnect) | |
| 712 .then(test.succeed, test.fail); | |
| 713 }, | |
| 714 | |
| 715 // Test that receive timeouts still function correctly after a serialization | |
| 716 // round trip. | |
| 717 function testReceiveTimeoutAfterSerialization() { | |
| 718 var errorReceived = listenOnce(serial.onReceiveError); | |
| 719 Promise.all([ | |
| 720 errorReceived.then(checkReceiveError('timeout')), | |
| 721 errorReceived.then(expectCurrentTime(20)), | |
| 722 errorReceived | |
| 723 .then(getInfo) | |
| 724 .then(checkInfo({paused: false})), | |
| 725 connect({receiveTimeout: 20}) | |
| 726 .then(serializeRoundTrip) | |
| 727 .then(timeoutManager.run.bind(timeoutManager, 1)), | |
| 728 ]) | |
| 729 .then(disconnect) | |
| 730 .then(test.succeed, test.fail); | |
| 731 }, | |
| 732 | |
| 733 // Test that receive timeouts trigger after the timeout time elapses and that | |
| 734 // disabling the receive timeout does not affect a wait in progress. | |
| 735 function testDisableReceiveTimeout() { | |
| 736 var errorReceived = listenOnce(serial.onReceiveError); | |
| 737 Promise.all([ | |
| 738 errorReceived.then(checkReceiveError('timeout')), | |
| 739 errorReceived.then(expectCurrentTime(20)), | |
| 740 errorReceived | |
| 741 .then(getInfo) | |
| 742 .then(checkInfo({paused: false})), | |
| 743 connect({receiveTimeout: 20}) | |
| 744 // Disabling the timeout does not take effect until the current | |
| 745 // timeout expires or a receive completes. | |
| 746 .then(update({receiveTimeout: 0})) | |
| 747 .then(expectSuccess) | |
| 748 .then(timeoutManager.run.bind(timeoutManager, 1)), | |
| 749 ]) | |
| 750 .then(disconnect) | |
| 751 .then(test.succeed, test.fail); | |
| 752 }, | |
| 753 | |
| 754 // Test that a receive error from the service is correctly dispatched. This | |
| 755 // test uses an IoHandler that only reports 'disconnected' receive errors. | |
| 756 function testReceiveErrorDisconnected() { | |
| 757 runReceiveErrorTest('disconnected'); | |
| 758 }, | |
| 759 | |
| 760 // Test that a receive error from the service is correctly dispatched. This | |
| 761 // test uses an IoHandler that only reports 'device_lost' receive errors. | |
| 762 function testReceiveErrorDeviceLost() { | |
| 763 runReceiveErrorTest('device_lost'); | |
| 764 }, | |
| 765 | |
| 766 // Test that a receive from error the service is correctly dispatched. This | |
| 767 // test uses an IoHandler that only reports 'break' receive errors. | |
| 768 function testReceiveErrorBreak() { | |
| 769 runReceiveErrorTest('break'); | |
| 770 }, | |
| 771 | |
| 772 // Test that a receive from error the service is correctly dispatched. This | |
| 773 // test uses an IoHandler that only reports 'frame_error' receive errors. | |
| 774 function testReceiveErrorFrameError() { | |
| 775 runReceiveErrorTest('frame_error'); | |
| 776 }, | |
| 777 | |
| 778 // Test that a receive from error the service is correctly dispatched. This | |
| 779 // test uses an IoHandler that only reports 'overrun' receive errors. | |
| 780 function testReceiveErrorOverrun() { | |
| 781 runReceiveErrorTest('overrun'); | |
| 782 }, | |
| 783 | |
| 784 // Test that a receive from error the service is correctly dispatched. This | |
| 785 // test uses an IoHandler that only reports 'buffer_overflow' receive errors. | |
| 786 function testReceiveErrorBufferOverflow() { | |
| 787 runReceiveErrorTest('buffer_overflow'); | |
| 788 }, | |
| 789 | |
| 790 // Test that a receive from error the service is correctly dispatched. This | |
| 791 // test uses an IoHandler that only reports 'parity_error' receive errors. | |
| 792 function testReceiveErrorParityError() { | |
| 793 runReceiveErrorTest('parity_error'); | |
| 794 }, | |
| 795 | |
| 796 // Test that a receive from error the service is correctly dispatched. This | |
| 797 // test uses an IoHandler that only reports 'system_error' receive errors. | |
| 798 function testReceiveErrorSystemError() { | |
| 799 runReceiveErrorTest('system_error'); | |
| 800 }, | |
| 801 | |
| 802 // Test that a send error from the service is correctly returned as the send | |
| 803 // result. This test uses an IoHandler that only reports 'disconnected' send | |
| 804 // errors. | |
| 805 function testSendErrorDisconnected() { | |
| 806 runSendErrorTest('disconnected'); | |
| 807 }, | |
| 808 | |
| 809 // Test that a send error from the service is correctly returned as the send | |
| 810 // result. This test uses an IoHandler that only reports 'system_error' send | |
| 811 // errors. | |
| 812 function testSendErrorSystemError() { | |
| 813 runSendErrorTest('system_error'); | |
| 814 }, | |
| 815 | |
| 816 // Test that disconnect returns the correct error for a connection ID that | |
| 817 // does not exist. | |
| 818 function testDisconnectUnknownConnectionId() { | |
| 819 serial.disconnect(-1, test.callbackFail('Serial connection not found.')); | |
| 820 }, | |
| 821 | |
| 822 // Test that getInfo returns the correct error for a connection ID that does | |
| 823 // not exist. | |
| 824 function testGetInfoUnknownConnectionId() { | |
| 825 serial.getInfo(-1, test.callbackFail('Serial connection not found.')); | |
| 826 }, | |
| 827 | |
| 828 // Test that update returns the correct error for a connection ID that does | |
| 829 // not exist. | |
| 830 function testUpdateUnknownConnectionId() { | |
| 831 serial.update(-1, {}, test.callbackFail('Serial connection not found.')); | |
| 832 }, | |
| 833 | |
| 834 // Test that setControlSignals returns the correct error for a connection ID | |
| 835 // that does not exist. | |
| 836 function testSetControlSignalsUnknownConnectionId() { | |
| 837 serial.setControlSignals(-1, {}, test.callbackFail( | |
| 838 'Serial connection not found.')); | |
| 839 }, | |
| 840 | |
| 841 // Test that getControlSignals returns the correct error for a connection ID | |
| 842 // that does not exist. | |
| 843 function testGetControlSignalsUnknownConnectionId() { | |
| 844 serial.getControlSignals(-1, test.callbackFail( | |
| 845 'Serial connection not found.')); | |
| 846 }, | |
| 847 | |
| 848 // Test that flush returns the correct error for a connection ID that does not | |
| 849 // exist. | |
| 850 function testFlushUnknownConnectionId() { | |
| 851 serial.flush(-1, test.callbackFail('Serial connection not found.')); | |
| 852 }, | |
| 853 | |
| 854 // Test that setPaused returns the correct error for a connection ID that does | |
| 855 // not exist. | |
| 856 function testSetPausedUnknownConnectionId() { | |
| 857 serial.setPaused( | |
| 858 -1, true, test.callbackFail('Serial connection not found.')); | |
| 859 serial.setPaused( | |
| 860 -1, false, test.callbackFail('Serial connection not found.')); | |
| 861 }, | |
| 862 | |
| 863 // Test that send returns the correct error for a connection ID that does not | |
| 864 // exist. | |
| 865 function testSendUnknownConnectionId() { | |
| 866 var buffer = new ArrayBuffer(1); | |
| 867 serial.send(-1, buffer, test.callbackFail('Serial connection not found.')); | |
| 868 }, | |
| 869 | |
| 870 function testSendAndStash() { | |
| 871 connect() | |
| 872 .then(setPaused(true)) | |
| 873 .then(sendData) | |
| 874 .then(expectSendResult(4)) | |
| 875 .then(test.succeed, test.fail); | |
| 876 }, | |
| 877 | |
| 878 function testRestoreAndReceive() { | |
| 879 connectionId = 0; | |
| 880 Promise.all([ | |
| 881 utils.promise(serial.setPaused, connectionId, false), | |
| 882 listenOnce(serial.onReceive).then(checkReceivedData), | |
| 883 ]) | |
| 884 .then(disconnect) | |
| 885 .then(test.succeed, test.fail); | |
| 886 }, | |
| 887 | |
| 888 function testRestoreAndReceiveErrorSetUp() { | |
| 889 connect().then(test.succeed, test.fail); | |
| 890 }, | |
| 891 | |
| 892 function testRestoreAndReceiveError() { | |
| 893 connectionId = 0; | |
| 894 Promise.all([ | |
| 895 utils.promise(serial.setPaused, connectionId, false), | |
| 896 listenOnce(serial.onReceiveError) | |
| 897 .then(checkReceiveError('device_lost')), | |
| 898 ]) | |
| 899 .then(disconnect) | |
| 900 .then(test.succeed, test.fail); | |
| 901 }, | |
| 902 | |
| 903 function testStashNoConnections() { | |
| 904 connect({persistent: false}).then(test.succeed, test.fail); | |
| 905 }, | |
| 906 | |
| 907 function testRestoreNoConnections() { | |
| 908 connect() | |
| 909 .then(function(connectionInfo) { | |
| 910 test.assertEq(0, connectionInfo.connectionId); | |
| 911 return connectionInfo; | |
| 912 }) | |
| 913 .then(checkConnectionInfo) | |
| 914 .then(disconnect) | |
| 915 .then(test.succeed, test.fail); | |
| 916 }, | |
| 917 | |
| 918 ], test.runTests, exports); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2410743002:
Remove the mojo serial interfaces and related infrastructure. (Closed)
