| // Copyright 2014 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. |
| |
| /** |
| * Unit tests for the JS serial service client. |
| * |
| * These test that configuration and data are correctly transmitted between the |
| * client and the service. They are launched by |
| * extensions/renderer/api/serial/serial_api_unittest.cc. |
| */ |
| |
| var test = require('test').binding; |
| var serial = require('serial').binding; |
| var unittestBindings = require('test_environment_specific_bindings'); |
| var utils = require('utils'); |
| |
| var timeoutManager = new unittestBindings.TimeoutManager(); |
| timeoutManager.installGlobals(); |
| |
| var BUFFER_SIZE = 10; |
| |
| var connectionId = null; |
| |
| var OPTIONS_VALUES = [ |
| {}, // SetPortOptions is called once during connection. |
| {bitrate: 57600}, |
| {dataBits: 'seven'}, |
| {dataBits: 'eight'}, |
| {parityBit: 'no'}, |
| {parityBit: 'odd'}, |
| {parityBit: 'even'}, |
| {stopBits: 'one'}, |
| {stopBits: 'two'}, |
| {ctsFlowControl: false}, |
| {ctsFlowControl: true}, |
| {bufferSize: 1}, |
| {sendTimeout: 0}, |
| {receiveTimeout: 0}, |
| {persistent: false}, |
| {name: 'name'}, |
| ]; |
| |
| // Create a serial connection. That serial connection will be used by the other |
| // helper functions below. |
| function connect(options) { |
| options = options || { |
| name: 'test connection', |
| bufferSize: BUFFER_SIZE, |
| receiveTimeout: 12345, |
| sendTimeout: 6789, |
| persistent: true, |
| }; |
| return utils.promise(serial.connect, 'device', options).then(function(info) { |
| connectionId = info.connectionId; |
| return info; |
| }); |
| } |
| |
| // Serialize and deserialize all serial connections, preserving onData and |
| // onError event listeners. |
| function serializeRoundTrip() { |
| return requireAsync('serial_service').then(function(serialService) { |
| function serializeConnections(connections) { |
| var serializedConnections = []; |
| for (var connection of connections.values()) { |
| serializedConnections.push(serializeConnection(connection)); |
| } |
| return Promise.all(serializedConnections); |
| } |
| |
| function serializeConnection(connection) { |
| var onData = connection.onData; |
| var onError = connection.onError; |
| return connection.serialize().then(function(serialization) { |
| return { |
| serialization: serialization, |
| onData: onData, |
| onError: onError, |
| }; |
| }); |
| } |
| |
| function deserializeConnections(serializedConnections) { |
| $Array.forEach(serializedConnections, function(serializedConnection) { |
| var connection = serialService.Connection.deserialize( |
| serializedConnection.serialization); |
| connection.onData = serializedConnection.onData; |
| connection.onError = serializedConnection.onError; |
| connection.resumeReceives(); |
| }); |
| } |
| |
| return serialService.getConnections() |
| .then(serializeConnections) |
| .then(deserializeConnections); |
| }); |
| } |
| |
| // Returns a promise that will resolve to the connection info for the |
| // connection. |
| function getInfo() { |
| return utils.promise(serial.getInfo, connectionId); |
| } |
| |
| // Returns a function that checks that the values of keys contained within |
| // |expectedInfo| match the values of the same keys contained within |info|. |
| function checkInfo(expectedInfo) { |
| return function(info) { |
| for (var key in expectedInfo) { |
| test.assertEq(expectedInfo[key], info[key]); |
| } |
| }; |
| } |
| |
| // Returns a function that will update the options of the serial connection with |
| // those contained within |values|. |
| function update(values) { |
| return function() { |
| return utils.promise(serial.update, connectionId, values); |
| }; |
| } |
| |
| // Checks that the previous operation succeeded. |
| function expectSuccess(success) { |
| test.assertTrue(success); |
| } |
| |
| // Returns a function that checks that the send result matches |bytesSent| and |
| // |error|. If no error is expected, |error| may be omitted. |
| function expectSendResult(bytesSent, error) { |
| return function(sendInfo) { |
| test.assertEq(bytesSent, sendInfo.bytesSent); |
| test.assertEq(error, sendInfo.error); |
| }; |
| } |
| |
| // Returns a function that checks that the current time is |expectedTime|. |
| function expectCurrentTime(expectedTime) { |
| return function() { |
| test.assertEq(expectedTime, timeoutManager.currentTime); |
| } |
| } |
| |
| // Returns a promise that will resolve to the device control signals for the |
| // serial connection. |
| function getControlSignals() { |
| return utils.promise(serial.getControlSignals, connectionId); |
| } |
| |
| // Returns a function that will set the control signals for the serial |
| // connection to |signals|. |
| function setControlSignals(signals) { |
| return function() { |
| return utils.promise(serial.setControlSignals, connectionId, signals); |
| }; |
| } |
| |
| // Returns a function that will set the paused state of the serial connection to |
| // |paused|. |
| function setPaused(paused) { |
| return function() { |
| return utils.promise(serial.setPaused, connectionId, paused); |
| } |
| } |
| |
| // Sets a function to be called once when data is received. Returns a promise |
| // that will resolve once the hook is installed. |
| function addReceiveHook(callback) { |
| return requireAsync('serial_service').then(function(serialService) { |
| var called = false; |
| var dataReceived = serialService.Connection.prototype.onDataReceived_; |
| serialService.Connection.prototype.onDataReceived_ = function() { |
| var result = $Function.apply(dataReceived, this, arguments); |
| if (!called) |
| callback(); |
| called = true; |
| return result; |
| }; |
| }); |
| } |
| |
| // Sets a function to be called once when a receive error is received. Returns a |
| // promise that will resolve once the hook is installed. |
| function addReceiveErrorHook(callback) { |
| return requireAsync('serial_service').then(function(serialService) { |
| var called = false; |
| var receiveError = serialService.Connection.prototype.onReceiveError_; |
| serialService.Connection.prototype.onReceiveError_ = function() { |
| var result = $Function.apply(receiveError, this, arguments); |
| if (!called) |
| callback(); |
| called = true; |
| return result; |
| }; |
| }); |
| } |
| |
| function listenOnce(targetEvent) { |
| return new Promise(function(resolve, reject) { |
| targetEvent.addListener(function(result) { |
| resolve(result); |
| }); |
| }); |
| } |
| |
| function disconnect() { |
| return utils.promise(serial.disconnect, connectionId).then(function(success) { |
| test.assertTrue(success); |
| connectionId = null; |
| }); |
| } |
| |
| function checkClientConnectionInfo(connectionInfo) { |
| test.assertTrue(connectionInfo.persistent); |
| test.assertEq('test connection', connectionInfo.name); |
| test.assertEq(12345, connectionInfo.receiveTimeout); |
| test.assertEq(6789, connectionInfo.sendTimeout); |
| test.assertEq(BUFFER_SIZE, connectionInfo.bufferSize); |
| test.assertFalse(connectionInfo.paused); |
| } |
| |
| function checkServiceConnectionInfo(connectionInfo) { |
| test.assertEq(9600, connectionInfo.bitrate); |
| test.assertEq('eight', connectionInfo.dataBits); |
| test.assertEq('no', connectionInfo.parityBit); |
| test.assertEq('one', connectionInfo.stopBits); |
| test.assertFalse(connectionInfo.ctsFlowControl); |
| } |
| |
| function checkConnectionInfo(connectionInfo) { |
| checkClientConnectionInfo(connectionInfo); |
| checkServiceConnectionInfo(connectionInfo); |
| test.assertEq(12, $Object.keys(connectionInfo).length); |
| } |
| |
| function sendData() { |
| var data = 'data'; |
| var buffer = new ArrayBuffer(data.length); |
| var byteBuffer = new Int8Array(buffer); |
| for (var i = 0; i < data.length; i++) { |
| byteBuffer[i] = data.charCodeAt(i); |
| } |
| return utils.promise(serial.send, connectionId, buffer); |
| } |
| |
| function checkReceivedData(result) { |
| var data = 'data'; |
| test.assertEq(connectionId, result.connectionId); |
| test.assertEq(data.length, result.data.byteLength); |
| var resultByteBuffer = new Int8Array(result.data); |
| for (var i = 0; i < data.length; i++) { |
| test.assertEq(data.charCodeAt(i), resultByteBuffer[i]); |
| } |
| } |
| |
| function checkReceiveError(expectedError) { |
| return function(result) { |
| test.assertEq(connectionId, result.connectionId); |
| test.assertEq(expectedError, result.error); |
| } |
| } |
| |
| function runReceiveErrorTest(expectedError) { |
| var errorReceived = listenOnce(serial.onReceiveError); |
| Promise.all([ |
| connect(), |
| errorReceived |
| .then(checkReceiveError(expectedError)), |
| errorReceived |
| .then(getInfo) |
| .then(checkInfo({paused: true})), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| } |
| |
| function runSendErrorTest(expectedError) { |
| connect() |
| .then(sendData) |
| .then(expectSendResult(0, expectedError)) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| } |
| |
| unittestBindings.exportTests([ |
| // Test that getDevices correctly transforms the data returned by the |
| // SerialDeviceEnumerator. |
| function testGetDevices() { |
| utils.promise(serial.getDevices).then(function(devices) { |
| test.assertEq(3, devices.length); |
| test.assertEq(4, $Object.keys(devices[0]).length); |
| test.assertEq('device', devices[0].path); |
| test.assertEq(1234, devices[0].vendorId); |
| test.assertEq(5678, devices[0].productId); |
| test.assertEq('foo', devices[0].displayName); |
| test.assertEq(1, $Object.keys(devices[1]).length); |
| test.assertEq('another_device', devices[1].path); |
| test.assertEq(1, $Object.keys(devices[2]).length); |
| test.assertEq('', devices[2].path); |
| }).then(test.succeed, test.fail); |
| }, |
| |
| // Test that the correct error message is returned when an error occurs in |
| // connecting to the port. This test uses an IoHandler that fails to connect. |
| function testConnectFail() { |
| serial.connect('device', |
| test.callbackFail('Failed to connect to the port.')); |
| }, |
| |
| // Test that the correct error message is returned when an error occurs in |
| // calling getPortInfo after connecting to the port. This test uses an |
| // IoHandler that fails on calls to GetPortInfo. |
| function testGetInfoFailOnConnect() { |
| serial.connect('device', |
| test.callbackFail('Failed to connect to the port.')); |
| }, |
| |
| // Test that the correct error message is returned when an invalid bit-rate |
| // value is passed to connect. |
| function testConnectInvalidBitrate() { |
| serial.connect('device', {bitrate: -1}, test.callbackFail( |
| 'Failed to connect to the port.')); |
| }, |
| |
| // Test that a successful connect returns the expected connection info. |
| function testConnect() { |
| connect() |
| .then(checkConnectionInfo) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a connection created with no options has the correct default |
| // options. |
| function testConnectDefaultOptions() { |
| connect({}).then(function(connectionInfo) { |
| test.assertEq(9600, connectionInfo.bitrate); |
| test.assertEq('eight', connectionInfo.dataBits); |
| test.assertEq('no', connectionInfo.parityBit); |
| test.assertEq('one', connectionInfo.stopBits); |
| test.assertFalse(connectionInfo.ctsFlowControl); |
| test.assertFalse(connectionInfo.persistent); |
| test.assertEq('', connectionInfo.name); |
| test.assertEq(0, connectionInfo.receiveTimeout); |
| test.assertEq(0, connectionInfo.sendTimeout); |
| test.assertEq(4096, connectionInfo.bufferSize); |
| }) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a getInfo call correctly converts the service-side info from the |
| // Mojo format and returns both it and the client-side configuration. |
| function testGetInfo() { |
| connect() |
| .then(getInfo) |
| .then(checkConnectionInfo) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a getInfo call returns the correct info after serialization. |
| function testGetInfoAfterSerialization() { |
| connect() |
| .then(serializeRoundTrip) |
| .then(getInfo) |
| .then(checkConnectionInfo) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that only client-side options are returned when the service fails a |
| // getInfo call. This test uses an IoHandler that fails GetPortInfo calls |
| // after the initial call during connect. |
| function testGetInfoFailToGetPortInfo() { |
| var info = connect().then(getInfo); |
| Promise.all([ |
| info.then(function(connectionInfo) { |
| test.assertFalse('bitrate' in connectionInfo); |
| test.assertFalse('dataBits' in connectionInfo); |
| test.assertFalse('parityBit' in connectionInfo); |
| test.assertFalse('stopBit' in connectionInfo); |
| test.assertFalse('ctsFlowControl' in connectionInfo); |
| }), |
| info.then(checkClientConnectionInfo), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that getConnections returns an array containing the open connection. |
| function testGetConnections() { |
| connect().then(function() { |
| return utils.promise(serial.getConnections); |
| }).then(function(connections) { |
| test.assertEq(1, connections.length); |
| checkConnectionInfo(connections[0]); |
| }) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that getControlSignals correctly converts the Mojo format result. This |
| // test uses an IoHandler that returns values matching the pattern being |
| // tested. |
| function testGetControlSignals() { |
| function checkControlSignals(expectedBitfield) { |
| return function(signals) { |
| test.assertEq(!!(expectedBitfield & 1), signals.dcd); |
| test.assertEq(!!(expectedBitfield & 2), signals.cts); |
| test.assertEq(!!(expectedBitfield & 4), signals.ri); |
| test.assertEq(!!(expectedBitfield & 8), signals.dsr); |
| }; |
| } |
| var promiseChain = connect(); |
| for (var i = 0; i < 16; i++) { |
| promiseChain = promiseChain |
| .then(getControlSignals) |
| .then(checkControlSignals(i)); |
| } |
| promiseChain |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that setControlSignals correctly converts to the Mojo format result. |
| // This test uses an IoHandler that returns values following the same table of |
| // values as |signalsValues|. |
| function testSetControlSignals() { |
| var signalsValues = [ |
| {}, |
| {dtr: false}, |
| {dtr: true}, |
| {rts: false}, |
| {dtr: false, rts: false}, |
| {dtr: true, rts: false}, |
| {rts: true}, |
| {dtr: false, rts: true}, |
| {dtr: true, rts: true}, |
| ]; |
| var promiseChain = connect(); |
| for (var i = 0; i < signalsValues.length; i++) { |
| promiseChain = promiseChain.then(setControlSignals(signalsValues[i])); |
| } |
| promiseChain |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that update correctly passes values to the service only for |
| // service-side options and that all update calls are reflected by the result |
| // of getInfo calls. This test uses an IoHandler that expects corresponding |
| // ConfigurePort calls. |
| function testUpdate() { |
| var promiseChain = connect() |
| .then(getInfo) |
| .then(checkInfo(OPTIONS_VALUES[i])); |
| for (var i = 1; i < OPTIONS_VALUES.length; i++) { |
| promiseChain = promiseChain |
| .then(update(OPTIONS_VALUES[i])) |
| .then(expectSuccess) |
| .then(getInfo) |
| .then(checkInfo(OPTIONS_VALUES[i])); |
| } |
| promiseChain |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that options set by update persist after serialization. |
| function testUpdateAcrossSerialization() { |
| var promiseChain = connect() |
| .then(serializeRoundTrip) |
| .then(getInfo) |
| .then(checkInfo(OPTIONS_VALUES[i])); |
| for (var i = 1; i < OPTIONS_VALUES.length; i++) { |
| promiseChain = promiseChain |
| .then(update(OPTIONS_VALUES[i])) |
| .then(expectSuccess) |
| .then(serializeRoundTrip) |
| .then(getInfo) |
| .then(checkInfo(OPTIONS_VALUES[i])); |
| } |
| promiseChain |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that passing an invalid bit-rate reslts in an error. |
| function testUpdateInvalidBitrate() { |
| connect() |
| .then(update({bitrate: -1})) |
| .then(function(success) { |
| test.assertFalse(success); |
| }) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test flush. This test uses an IoHandler that counts the number of flush |
| // calls. |
| function testFlush() { |
| connect().then(function() { |
| return utils.promise(serial.flush, connectionId); |
| }) |
| .then(expectSuccess) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that setPaused values are reflected by the results returned by getInfo |
| // calls. |
| function testSetPaused() { |
| connect() |
| .then(setPaused(true)) |
| .then(getInfo) |
| .then(checkInfo({paused: true})) |
| .then(setPaused(false)) |
| .then(getInfo) |
| .then(checkInfo({paused: false})) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a send and a receive correctly echoes data. This uses an |
| // IoHandler that echoes data sent to it. |
| function testEcho() { |
| Promise.all([ |
| connect() |
| .then(sendData) |
| .then(expectSendResult(4)), |
| listenOnce(serial.onReceive) |
| .then(checkReceivedData), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a send while another send is in progress returns a pending error. |
| function testSendDuringExistingSend() { |
| var connected = connect(); |
| Promise.all([ |
| connected |
| .then(sendData) |
| .then(expectSendResult(4)), |
| connected |
| .then(sendData) |
| .then(expectSendResult(0, 'pending')), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a second send after the first finishes is successful. This uses |
| // an IoHandler that echoes data sent to it. |
| function testSendAfterSuccessfulSend() { |
| connect() |
| .then(sendData) |
| .then(expectSendResult(4)) |
| .then(sendData) |
| .then(expectSendResult(4)) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a second send after the first fails is successful. This uses an |
| // IoHandler that returns system_error for only the first send. |
| function testSendPartialSuccessWithError() { |
| connect() |
| .then(sendData) |
| .then(expectSendResult(2, 'system_error')) |
| .then(sendData) |
| .then(expectSendResult(4)) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a send and a receive correctly echoes data after serialization. |
| function testEchoAfterSerialization() { |
| Promise.all([ |
| connect() |
| .then(serializeRoundTrip) |
| .then(sendData) |
| .then(expectSendResult(4)), |
| listenOnce(serial.onReceive).then(checkReceivedData) |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a timed-out send returns a timeout error and that changing the |
| // send timeout during a send does not affect its timeout. This test uses an |
| // IoHandle that never completes sends. |
| function testSendTimeout() { |
| var connected = connect({sendTimeout: 5}); |
| var sent = connected.then(sendData); |
| Promise.all([ |
| sent.then(expectSendResult(0, 'timeout')), |
| sent.then(expectCurrentTime(5)), |
| connected.then(update({sendTimeout: 10})) |
| .then(expectSuccess) |
| .then(timeoutManager.run.bind(timeoutManager, 1)), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that send timeouts still function correctly after a serialization |
| // round trip. |
| function testSendTimeoutAfterSerialization() { |
| var connected = connect({sendTimeout: 5}).then(serializeRoundTrip); |
| var sent = connected.then(sendData); |
| Promise.all([ |
| sent.then(expectSendResult(0, 'timeout')), |
| sent.then(expectCurrentTime(5)), |
| connected.then(update({sendTimeout: 10})) |
| .then(expectSuccess) |
| .then(timeoutManager.run.bind(timeoutManager, 1)), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a timed-out send returns a timeout error and that disabling the |
| // send timeout during a send does not affect its timeout. This test uses an |
| // IoHandle that never completes sends. |
| function testDisableSendTimeout() { |
| var connected = connect({sendTimeout: 5}); |
| var sent = connected.then(sendData); |
| Promise.all([ |
| sent.then(expectSendResult(0, 'timeout')), |
| sent.then(expectCurrentTime(5)), |
| connected.then(update({sendTimeout: 0})) |
| .then(expectSuccess) |
| .then(timeoutManager.run.bind(timeoutManager, 1)), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that data received while the connection is paused is queued and |
| // dispatched once the connection is unpaused. |
| function testPausedReceive() { |
| Promise.all([ |
| // Wait until the receive hook is installed, then start the test. |
| addReceiveHook(function() { |
| // Unpause the connection after the connection has queued the received |
| // data to ensure the queued data is dispatched when the connection is |
| // unpaused. |
| Promise.all([ |
| utils.promise(serial.setPaused, connectionId, false), |
| // Check that setPaused(false) is idempotent. |
| utils.promise(serial.setPaused, connectionId, false), |
| ]).catch(test.fail); |
| }) |
| .then(connect) |
| .then(function() { |
| // Check that setPaused(true) is idempotent. |
| return Promise.all([ |
| utils.promise(serial.setPaused, connectionId, true), |
| utils.promise(serial.setPaused, connectionId, true), |
| ]); |
| }), |
| listenOnce(serial.onReceive).then(checkReceivedData), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a receive error received while the connection is paused is queued |
| // and dispatched once the connection is unpaused. |
| function testPausedReceiveError() { |
| Promise.all([ |
| // Wait until the receive hook is installed, then start the test. |
| addReceiveErrorHook(function() { |
| // Unpause the connection after the connection has queued the received |
| // data to ensure the queued data is dispatched when the connection is |
| // unpaused. |
| utils.promise(serial.setPaused, connectionId, false).catch(test.fail); |
| }) |
| .then(connect) |
| .then(setPaused(true)), |
| listenOnce(serial.onReceiveError) |
| .then(checkReceiveError('device_lost')), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| serial.onReceive.addListener(function() { |
| test.fail('unexpected onReceive event'); |
| }); |
| }, |
| |
| // Test that receive timeouts trigger after the timeout time elapses and that |
| // changing the receive timeout does not affect a wait in progress. |
| function testReceiveTimeout() { |
| var errorReceived = listenOnce(serial.onReceiveError); |
| Promise.all([ |
| errorReceived.then(checkReceiveError('timeout')), |
| errorReceived.then(expectCurrentTime(20)), |
| errorReceived |
| .then(getInfo) |
| .then(checkInfo({paused: false})), |
| connect({receiveTimeout: 20}) |
| // Changing the timeout does not take effect until the current |
| // timeout expires or a receive completes. |
| .then(update({receiveTimeout: 10})) |
| .then(expectSuccess) |
| .then(timeoutManager.run.bind(timeoutManager, 1)), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that receive timeouts still function correctly after a serialization |
| // round trip. |
| function testReceiveTimeoutAfterSerialization() { |
| var errorReceived = listenOnce(serial.onReceiveError); |
| Promise.all([ |
| errorReceived.then(checkReceiveError('timeout')), |
| errorReceived.then(expectCurrentTime(20)), |
| errorReceived |
| .then(getInfo) |
| .then(checkInfo({paused: false})), |
| connect({receiveTimeout: 20}) |
| .then(serializeRoundTrip) |
| .then(timeoutManager.run.bind(timeoutManager, 1)), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that receive timeouts trigger after the timeout time elapses and that |
| // disabling the receive timeout does not affect a wait in progress. |
| function testDisableReceiveTimeout() { |
| var errorReceived = listenOnce(serial.onReceiveError); |
| Promise.all([ |
| errorReceived.then(checkReceiveError('timeout')), |
| errorReceived.then(expectCurrentTime(20)), |
| errorReceived |
| .then(getInfo) |
| .then(checkInfo({paused: false})), |
| connect({receiveTimeout: 20}) |
| // Disabling the timeout does not take effect until the current |
| // timeout expires or a receive completes. |
| .then(update({receiveTimeout: 0})) |
| .then(expectSuccess) |
| .then(timeoutManager.run.bind(timeoutManager, 1)), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| // Test that a receive error from the service is correctly dispatched. This |
| // test uses an IoHandler that only reports 'disconnected' receive errors. |
| function testReceiveErrorDisconnected() { |
| runReceiveErrorTest('disconnected'); |
| }, |
| |
| // Test that a receive error from the service is correctly dispatched. This |
| // test uses an IoHandler that only reports 'device_lost' receive errors. |
| function testReceiveErrorDeviceLost() { |
| runReceiveErrorTest('device_lost'); |
| }, |
| |
| // Test that a receive from error the service is correctly dispatched. This |
| // test uses an IoHandler that only reports 'break' receive errors. |
| function testReceiveErrorBreak() { |
| runReceiveErrorTest('break'); |
| }, |
| |
| // Test that a receive from error the service is correctly dispatched. This |
| // test uses an IoHandler that only reports 'frame_error' receive errors. |
| function testReceiveErrorFrameError() { |
| runReceiveErrorTest('frame_error'); |
| }, |
| |
| // Test that a receive from error the service is correctly dispatched. This |
| // test uses an IoHandler that only reports 'overrun' receive errors. |
| function testReceiveErrorOverrun() { |
| runReceiveErrorTest('overrun'); |
| }, |
| |
| // Test that a receive from error the service is correctly dispatched. This |
| // test uses an IoHandler that only reports 'buffer_overflow' receive errors. |
| function testReceiveErrorBufferOverflow() { |
| runReceiveErrorTest('buffer_overflow'); |
| }, |
| |
| // Test that a receive from error the service is correctly dispatched. This |
| // test uses an IoHandler that only reports 'parity_error' receive errors. |
| function testReceiveErrorParityError() { |
| runReceiveErrorTest('parity_error'); |
| }, |
| |
| // Test that a receive from error the service is correctly dispatched. This |
| // test uses an IoHandler that only reports 'system_error' receive errors. |
| function testReceiveErrorSystemError() { |
| runReceiveErrorTest('system_error'); |
| }, |
| |
| // Test that a send error from the service is correctly returned as the send |
| // result. This test uses an IoHandler that only reports 'disconnected' send |
| // errors. |
| function testSendErrorDisconnected() { |
| runSendErrorTest('disconnected'); |
| }, |
| |
| // Test that a send error from the service is correctly returned as the send |
| // result. This test uses an IoHandler that only reports 'system_error' send |
| // errors. |
| function testSendErrorSystemError() { |
| runSendErrorTest('system_error'); |
| }, |
| |
| // Test that disconnect returns the correct error for a connection ID that |
| // does not exist. |
| function testDisconnectUnknownConnectionId() { |
| serial.disconnect(-1, test.callbackFail('Serial connection not found.')); |
| }, |
| |
| // Test that getInfo returns the correct error for a connection ID that does |
| // not exist. |
| function testGetInfoUnknownConnectionId() { |
| serial.getInfo(-1, test.callbackFail('Serial connection not found.')); |
| }, |
| |
| // Test that update returns the correct error for a connection ID that does |
| // not exist. |
| function testUpdateUnknownConnectionId() { |
| serial.update(-1, {}, test.callbackFail('Serial connection not found.')); |
| }, |
| |
| // Test that setControlSignals returns the correct error for a connection ID |
| // that does not exist. |
| function testSetControlSignalsUnknownConnectionId() { |
| serial.setControlSignals(-1, {}, test.callbackFail( |
| 'Serial connection not found.')); |
| }, |
| |
| // Test that getControlSignals returns the correct error for a connection ID |
| // that does not exist. |
| function testGetControlSignalsUnknownConnectionId() { |
| serial.getControlSignals(-1, test.callbackFail( |
| 'Serial connection not found.')); |
| }, |
| |
| // Test that flush returns the correct error for a connection ID that does not |
| // exist. |
| function testFlushUnknownConnectionId() { |
| serial.flush(-1, test.callbackFail('Serial connection not found.')); |
| }, |
| |
| // Test that setPaused returns the correct error for a connection ID that does |
| // not exist. |
| function testSetPausedUnknownConnectionId() { |
| serial.setPaused( |
| -1, true, test.callbackFail('Serial connection not found.')); |
| serial.setPaused( |
| -1, false, test.callbackFail('Serial connection not found.')); |
| }, |
| |
| // Test that send returns the correct error for a connection ID that does not |
| // exist. |
| function testSendUnknownConnectionId() { |
| var buffer = new ArrayBuffer(1); |
| serial.send(-1, buffer, test.callbackFail('Serial connection not found.')); |
| }, |
| |
| function testSendAndStash() { |
| connect() |
| .then(setPaused(true)) |
| .then(sendData) |
| .then(expectSendResult(4)) |
| .then(test.succeed, test.fail); |
| }, |
| |
| function testRestoreAndReceive() { |
| connectionId = 0; |
| Promise.all([ |
| utils.promise(serial.setPaused, connectionId, false), |
| listenOnce(serial.onReceive).then(checkReceivedData), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| function testRestoreAndReceiveErrorSetUp() { |
| connect().then(test.succeed, test.fail); |
| }, |
| |
| function testRestoreAndReceiveError() { |
| connectionId = 0; |
| Promise.all([ |
| utils.promise(serial.setPaused, connectionId, false), |
| listenOnce(serial.onReceiveError) |
| .then(checkReceiveError('device_lost')), |
| ]) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| function testStashNoConnections() { |
| connect({persistent: false}).then(test.succeed, test.fail); |
| }, |
| |
| function testRestoreNoConnections() { |
| connect() |
| .then(function(connectionInfo) { |
| test.assertEq(0, connectionInfo.connectionId); |
| return connectionInfo; |
| }) |
| .then(checkConnectionInfo) |
| .then(disconnect) |
| .then(test.succeed, test.fail); |
| }, |
| |
| ], test.runTests, exports); |
