mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-25 03:05:34 +00:00
5dec0e0beb
This patch was autogenerated by my decomponents.py
It covers almost every file with the extension js, jsm, html, py,
xhtml, or xul.
It removes blank lines after removed lines, when the removed lines are
preceded by either blank lines or the start of a new block. The "start
of a new block" is defined fairly hackily: either the line starts with
//, ends with */, ends with {, <![CDATA[, """ or '''. The first two
cover comments, the third one covers JS, the fourth covers JS embedded
in XUL, and the final two cover JS embedded in Python. This also
applies if the removed line was the first line of the file.
It covers the pattern matching cases like "var {classes: Cc,
interfaces: Ci, utils: Cu, results: Cr} = Components;". It'll remove
the entire thing if they are all either Ci, Cr, Cc or Cu, or it will
remove the appropriate ones and leave the residue behind. If there's
only one behind, then it will turn it into a normal, non-pattern
matching variable definition. (For instance, "const { classes: Cc,
Constructor: CC, interfaces: Ci, utils: Cu } = Components" becomes
"const CC = Components.Constructor".)
MozReview-Commit-ID: DeSHcClQ7cG
--HG--
extra : rebase_source : d9c41878036c1ef7766ef5e91a7005025bc1d72b
634 lines
20 KiB
JavaScript
634 lines
20 KiB
JavaScript
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
"use strict";
|
|
|
|
ChromeUtils.import("chrome://marionette/content/action.js");
|
|
const {ContentWebElement} = ChromeUtils.import("chrome://marionette/content/element.js", {});
|
|
ChromeUtils.import("chrome://marionette/content/error.js");
|
|
|
|
const XHTMLNS = "http://www.w3.org/1999/xhtml";
|
|
|
|
const domEl = {
|
|
nodeType: 1,
|
|
ELEMENT_NODE: 1,
|
|
namespaceURI: XHTMLNS,
|
|
};
|
|
|
|
action.inputStateMap = new Map();
|
|
|
|
add_test(function test_createAction() {
|
|
Assert.throws(() => new action.Action(), InvalidArgumentError,
|
|
"Missing Action constructor args");
|
|
Assert.throws(() => new action.Action(1, 2), InvalidArgumentError,
|
|
"Missing Action constructor args");
|
|
Assert.throws(
|
|
() => new action.Action(1, 2, "sometype"), /Expected string/, "Non-string arguments.");
|
|
ok(new action.Action("id", "sometype", "sometype"));
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_defaultPointerParameters() {
|
|
let defaultParameters = {pointerType: action.PointerType.Mouse};
|
|
deepEqual(action.PointerParameters.fromJSON(), defaultParameters);
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processPointerParameters() {
|
|
let check = (regex, message, arg) => checkErrors(
|
|
regex, action.PointerParameters.fromJSON, [arg], message);
|
|
let parametersData;
|
|
for (let d of ["foo", "", "get", "Get"]) {
|
|
parametersData = {pointerType: d};
|
|
let message = `parametersData: [pointerType: ${parametersData.pointerType}]`;
|
|
check(/Unknown pointerType/, message, parametersData);
|
|
}
|
|
parametersData.pointerType = "mouse"; //TODO "pen";
|
|
deepEqual(action.PointerParameters.fromJSON(parametersData),
|
|
{pointerType: "mouse"}); //TODO action.PointerType.Pen});
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processPointerUpDownAction() {
|
|
let actionItem = {type: "pointerDown"};
|
|
let actionSequence = {type: "pointer", id: "some_id"};
|
|
for (let d of [-1, "a"]) {
|
|
actionItem.button = d;
|
|
checkErrors(
|
|
/Expected 'button' \(.*\) to be >= 0/, action.Action.fromJSON, [actionSequence, actionItem],
|
|
`button: ${actionItem.button}`);
|
|
}
|
|
actionItem.button = 5;
|
|
let act = action.Action.fromJSON(actionSequence, actionItem);
|
|
equal(act.button, actionItem.button);
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_validateActionDurationAndCoordinates() {
|
|
let actionItem = {};
|
|
let actionSequence = {id: "some_id"};
|
|
let check = function (type, subtype, message = undefined) {
|
|
message = message || `duration: ${actionItem.duration}, subtype: ${subtype}`;
|
|
actionItem.type = subtype;
|
|
actionSequence.type = type;
|
|
checkErrors(/Expected '.*' \(.*\) to be >= 0/,
|
|
action.Action.fromJSON, [actionSequence, actionItem], message);
|
|
};
|
|
for (let d of [-1, "a"]) {
|
|
actionItem.duration = d;
|
|
check("none", "pause");
|
|
check("pointer", "pointerMove");
|
|
}
|
|
actionItem.duration = 5000;
|
|
for (let name of ["x", "y"]) {
|
|
actionItem[name] = "a";
|
|
actionItem.type = "pointerMove";
|
|
actionSequence.type = "pointer";
|
|
checkErrors(/Expected '.*' \(.*\) to be an Integer/,
|
|
action.Action.fromJSON, [actionSequence, actionItem],
|
|
`duration: ${actionItem.duration}, subtype: pointerMove`);
|
|
}
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processPointerMoveActionOriginValidation() {
|
|
let actionSequence = {type: "pointer", id: "some_id"};
|
|
let actionItem = {duration: 5000, type: "pointerMove"};
|
|
for (let d of [-1, {a: "blah"}, []]) {
|
|
actionItem.origin = d;
|
|
|
|
checkErrors(/Expected \'origin\' to be undefined, "viewport", "pointer", or an element/,
|
|
action.Action.fromJSON,
|
|
[actionSequence, actionItem],
|
|
`actionItem.origin: (${getTypeString(d)})`);
|
|
}
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processPointerMoveActionOriginStringValidation() {
|
|
let actionSequence = {type: "pointer", id: "some_id"};
|
|
let actionItem = {duration: 5000, type: "pointerMove"};
|
|
for (let d of ["a", "", "get", "Get"]) {
|
|
actionItem.origin = d;
|
|
checkErrors(/Unknown pointer-move origin/,
|
|
action.Action.fromJSON,
|
|
[actionSequence, actionItem],
|
|
`actionItem.origin: ${d}`);
|
|
}
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processPointerMoveActionElementOrigin() {
|
|
let actionSequence = {type: "pointer", id: "some_id"};
|
|
let actionItem = {duration: 5000, type: "pointerMove"};
|
|
actionItem.origin = domEl;
|
|
let a = action.Action.fromJSON(actionSequence, actionItem);
|
|
deepEqual(a.origin, actionItem.origin);
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processPointerMoveActionDefaultOrigin() {
|
|
let actionSequence = {type: "pointer", id: "some_id"};
|
|
// origin left undefined
|
|
let actionItem = {duration: 5000, type: "pointerMove"};
|
|
let a = action.Action.fromJSON(actionSequence, actionItem);
|
|
deepEqual(a.origin, action.PointerOrigin.Viewport);
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processPointerMoveAction() {
|
|
let actionSequence = {id: "some_id", type: "pointer"};
|
|
let actionItems = [
|
|
{
|
|
duration: 5000,
|
|
type: "pointerMove",
|
|
origin: undefined,
|
|
x: undefined,
|
|
y: undefined,
|
|
},
|
|
{
|
|
duration: undefined,
|
|
type: "pointerMove",
|
|
origin: domEl,
|
|
x: undefined,
|
|
y: undefined,
|
|
},
|
|
{
|
|
duration: 5000,
|
|
type: "pointerMove",
|
|
x: 0,
|
|
y: undefined,
|
|
origin: undefined,
|
|
},
|
|
{
|
|
duration: 5000,
|
|
type: "pointerMove",
|
|
x: 1,
|
|
y: 2,
|
|
origin: undefined,
|
|
},
|
|
];
|
|
for (let expected of actionItems) {
|
|
let actual = action.Action.fromJSON(actionSequence, expected);
|
|
ok(actual instanceof action.Action);
|
|
equal(actual.duration, expected.duration);
|
|
equal(actual.x, expected.x);
|
|
equal(actual.y, expected.y);
|
|
|
|
let origin = expected.origin;
|
|
if (typeof origin == "undefined") {
|
|
origin = action.PointerOrigin.Viewport;
|
|
}
|
|
deepEqual(actual.origin, origin);
|
|
|
|
}
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_computePointerDestinationViewport() {
|
|
let act = { type: "pointerMove", x: 100, y: 200, origin: "viewport"};
|
|
let inputState = new action.InputState.Pointer(action.PointerType.Mouse);
|
|
// these values should not affect the outcome
|
|
inputState.x = "99";
|
|
inputState.y = "10";
|
|
let target = action.computePointerDestination(act, inputState);
|
|
equal(act.x, target.x);
|
|
equal(act.y, target.y);
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_computePointerDestinationPointer() {
|
|
let act = { type: "pointerMove", x: 100, y: 200, origin: "pointer"};
|
|
let inputState = new action.InputState.Pointer(action.PointerType.Mouse);
|
|
inputState.x = 10;
|
|
inputState.y = 99;
|
|
let target = action.computePointerDestination(act, inputState);
|
|
equal(act.x + inputState.x, target.x);
|
|
equal(act.y + inputState.y, target.y);
|
|
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_computePointerDestinationElement() {
|
|
// origin represents a web element
|
|
// using an object literal instead to test default case in computePointerDestination
|
|
let act = {type: "pointerMove", x: 100, y: 200, origin: {}};
|
|
let inputState = new action.InputState.Pointer(action.PointerType.Mouse);
|
|
let elementCenter = {x: 10, y: 99};
|
|
let target = action.computePointerDestination(act, inputState, elementCenter);
|
|
equal(act.x + elementCenter.x, target.x);
|
|
equal(act.y + elementCenter.y, target.y);
|
|
|
|
Assert.throws(
|
|
() => action.computePointerDestination(act, inputState, {a: 1}),
|
|
InvalidArgumentError,
|
|
"Invalid element center coordinates.");
|
|
|
|
Assert.throws(
|
|
() => action.computePointerDestination(act, inputState, undefined),
|
|
InvalidArgumentError,
|
|
"Undefined element center coordinates.");
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processPointerAction() {
|
|
let actionSequence = {
|
|
type: "pointer",
|
|
id: "some_id",
|
|
parameters: {
|
|
pointerType: "mouse" //TODO "touch"
|
|
},
|
|
};
|
|
let actionItems = [
|
|
{
|
|
duration: 2000,
|
|
type: "pause",
|
|
},
|
|
{
|
|
type: "pointerMove",
|
|
duration: 2000,
|
|
},
|
|
{
|
|
type: "pointerUp",
|
|
button: 1,
|
|
}
|
|
];
|
|
for (let expected of actionItems) {
|
|
let actual = action.Action.fromJSON(actionSequence, expected);
|
|
equal(actual.type, actionSequence.type);
|
|
equal(actual.subtype, expected.type);
|
|
equal(actual.id, actionSequence.id);
|
|
if (expected.type === "pointerUp") {
|
|
equal(actual.button, expected.button);
|
|
} else {
|
|
equal(actual.duration, expected.duration);
|
|
}
|
|
if (expected.type !== "pause") {
|
|
equal(actual.pointerType, actionSequence.parameters.pointerType);
|
|
}
|
|
}
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processPauseAction() {
|
|
let actionItem = {type: "pause", duration: 5000};
|
|
let actionSequence = {id: "some_id"};
|
|
for (let type of ["none", "key", "pointer"]) {
|
|
actionSequence.type = type;
|
|
let act = action.Action.fromJSON(actionSequence, actionItem);
|
|
ok(act instanceof action.Action);
|
|
equal(act.type, type);
|
|
equal(act.subtype, actionItem.type);
|
|
equal(act.id, actionSequence.id);
|
|
equal(act.duration, actionItem.duration);
|
|
}
|
|
actionItem.duration = undefined;
|
|
let act = action.Action.fromJSON(actionSequence, actionItem);
|
|
equal(act.duration, actionItem.duration);
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processActionSubtypeValidation() {
|
|
let actionItem = {type: "dancing"};
|
|
let actionSequence = {id: "some_id"};
|
|
let check = function (regex) {
|
|
let message = `type: ${actionSequence.type}, subtype: ${actionItem.type}`;
|
|
checkErrors(regex, action.Action.fromJSON, [actionSequence, actionItem], message);
|
|
};
|
|
for (let type of ["none", "key", "pointer"]) {
|
|
actionSequence.type = type;
|
|
check(new RegExp(`Unknown subtype for ${type} action`));
|
|
}
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processKeyActionUpDown() {
|
|
let actionSequence = {type: "key", id: "some_id"};
|
|
let actionItem = {type: "keyDown"};
|
|
|
|
for (let v of [-1, undefined, [], ["a"], {length: 1}, null]) {
|
|
actionItem.value = v;
|
|
let message = `actionItem.value: (${getTypeString(v)})`;
|
|
Assert.throws(() => action.Action.fromJSON(actionSequence, actionItem),
|
|
InvalidArgumentError, message);
|
|
Assert.throws(() => action.Action.fromJSON(actionSequence, actionItem),
|
|
/Expected 'value' to be a string that represents single code point/, message);
|
|
}
|
|
|
|
actionItem.value = "\uE004";
|
|
let act = action.Action.fromJSON(actionSequence, actionItem);
|
|
ok(act instanceof action.Action);
|
|
equal(act.type, actionSequence.type);
|
|
equal(act.subtype, actionItem.type);
|
|
equal(act.id, actionSequence.id);
|
|
equal(act.value, actionItem.value);
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processInputSourceActionSequenceValidation() {
|
|
let actionSequence = {type: "swim", id: "some id"};
|
|
let check = (message, regex) => checkErrors(
|
|
regex, action.Sequence.fromJSON, [actionSequence], message);
|
|
check(`actionSequence.type: ${actionSequence.type}`, /Unknown action type/);
|
|
action.inputStateMap.clear();
|
|
|
|
actionSequence.type = "none";
|
|
actionSequence.id = -1;
|
|
check(`actionSequence.id: ${getTypeString(actionSequence.id)}`,
|
|
/Expected 'id' to be a string/);
|
|
action.inputStateMap.clear();
|
|
|
|
actionSequence.id = undefined;
|
|
check(`actionSequence.id: ${getTypeString(actionSequence.id)}`,
|
|
/Expected 'id' to be defined/);
|
|
action.inputStateMap.clear();
|
|
|
|
actionSequence.id = "some_id";
|
|
actionSequence.actions = -1;
|
|
check(`actionSequence.actions: ${getTypeString(actionSequence.actions)}`,
|
|
/Expected 'actionSequence.actions' to be an array/);
|
|
action.inputStateMap.clear();
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processInputSourceActionSequence() {
|
|
let actionItem = { type: "pause", duration: 5};
|
|
let actionSequence = {
|
|
type: "none",
|
|
id: "some id",
|
|
actions: [actionItem],
|
|
};
|
|
let expectedAction = new action.Action(actionSequence.id, "none", actionItem.type);
|
|
expectedAction.duration = actionItem.duration;
|
|
let actions = action.Sequence.fromJSON(actionSequence);
|
|
equal(actions.length, 1);
|
|
deepEqual(actions[0], expectedAction);
|
|
action.inputStateMap.clear();
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processInputSourceActionSequencePointer() {
|
|
let actionItem = {type: "pointerDown", button: 1};
|
|
let actionSequence = {
|
|
type: "pointer",
|
|
id: "9",
|
|
actions: [actionItem],
|
|
parameters: {
|
|
pointerType: "mouse" // TODO "pen"
|
|
},
|
|
};
|
|
let expectedAction = new action.Action(
|
|
actionSequence.id, actionSequence.type, actionItem.type);
|
|
expectedAction.pointerType = actionSequence.parameters.pointerType;
|
|
expectedAction.button = actionItem.button;
|
|
let actions = action.Sequence.fromJSON(actionSequence);
|
|
equal(actions.length, 1);
|
|
deepEqual(actions[0], expectedAction);
|
|
action.inputStateMap.clear();
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processInputSourceActionSequenceKey() {
|
|
let actionItem = {type: "keyUp", value: "a"};
|
|
let actionSequence = {
|
|
type: "key",
|
|
id: "9",
|
|
actions: [actionItem],
|
|
};
|
|
let expectedAction = new action.Action(
|
|
actionSequence.id, actionSequence.type, actionItem.type);
|
|
expectedAction.value = actionItem.value;
|
|
let actions = action.Sequence.fromJSON(actionSequence);
|
|
equal(actions.length, 1);
|
|
deepEqual(actions[0], expectedAction);
|
|
action.inputStateMap.clear();
|
|
run_next_test();
|
|
});
|
|
|
|
|
|
add_test(function test_processInputSourceActionSequenceInputStateMap() {
|
|
let id = "1";
|
|
let actionItem = {type: "pause", duration: 5000};
|
|
let actionSequence = {
|
|
type: "key",
|
|
id: id,
|
|
actions: [actionItem],
|
|
};
|
|
let wrongInputState = new action.InputState.Null();
|
|
action.inputStateMap.set(actionSequence.id, wrongInputState);
|
|
checkErrors(/to be mapped to/, action.Sequence.fromJSON, [actionSequence],
|
|
`${actionSequence.type} using ${wrongInputState}`);
|
|
action.inputStateMap.clear();
|
|
let rightInputState = new action.InputState.Key();
|
|
action.inputStateMap.set(id, rightInputState);
|
|
let acts = action.Sequence.fromJSON(actionSequence);
|
|
equal(acts.length, 1);
|
|
action.inputStateMap.clear();
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_processPointerActionInputStateMap() {
|
|
let actionItem = {type: "pointerDown"};
|
|
let id = "1";
|
|
let parameters = {pointerType: "mouse"};
|
|
let a = new action.Action(id, "pointer", actionItem.type);
|
|
let wrongInputState = new action.InputState.Key();
|
|
action.inputStateMap.set(id, wrongInputState);
|
|
checkErrors(
|
|
/to be mapped to InputState whose type is/, action.processPointerAction,
|
|
[id, parameters, a],
|
|
`type "pointer" with ${wrongInputState.type} in inputState`);
|
|
action.inputStateMap.clear();
|
|
|
|
// TODO - uncomment once pen is supported
|
|
//wrongInputState = new action.InputState.Pointer("pen");
|
|
//action.inputStateMap.set(id, wrongInputState);
|
|
//checkErrors(
|
|
// /to be mapped to InputState whose subtype is/, action.processPointerAction,
|
|
// [id, parameters, a],
|
|
// `subtype ${parameters.pointerType} with ${wrongInputState.subtype} in inputState`);
|
|
//action.inputStateMap.clear();
|
|
|
|
let rightInputState = new action.InputState.Pointer("mouse");
|
|
action.inputStateMap.set(id, rightInputState);
|
|
action.processPointerAction(id, parameters, a);
|
|
action.inputStateMap.clear();
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_createInputState() {
|
|
for (let kind in action.InputState) {
|
|
let state;
|
|
if (kind == "Pointer") {
|
|
state = new action.InputState[kind]("mouse");
|
|
} else {
|
|
state = new action.InputState[kind]();
|
|
}
|
|
ok(state);
|
|
if (kind === "Null") {
|
|
equal(state.type, "none");
|
|
} else {
|
|
equal(state.type, kind.toLowerCase());
|
|
}
|
|
}
|
|
Assert.throws(() => new action.InputState.Pointer(), InvalidArgumentError,
|
|
"Missing InputState.Pointer constructor arg");
|
|
Assert.throws(() => new action.InputState.Pointer("foo"), InvalidArgumentError,
|
|
"Invalid InputState.Pointer constructor arg");
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_extractActionChainValidation() {
|
|
for (let actions of [-1, "a", undefined, null]) {
|
|
let message = `actions: ${getTypeString(actions)}`;
|
|
Assert.throws(() => action.Chain.fromJSON(actions),
|
|
InvalidArgumentError, message);
|
|
Assert.throws(() => action.Chain.fromJSON(actions),
|
|
/Expected 'actions' to be an array/, message);
|
|
}
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_extractActionChainEmpty() {
|
|
deepEqual(action.Chain.fromJSON([]), []);
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_extractActionChain_oneTickOneInput() {
|
|
let actionItem = {type: "pause", duration: 5000};
|
|
let actionSequence = {
|
|
type: "none",
|
|
id: "some id",
|
|
actions: [actionItem],
|
|
};
|
|
let expectedAction = new action.Action(actionSequence.id, "none", actionItem.type);
|
|
expectedAction.duration = actionItem.duration;
|
|
let actionsByTick = action.Chain.fromJSON([actionSequence]);
|
|
equal(1, actionsByTick.length);
|
|
equal(1, actionsByTick[0].length);
|
|
deepEqual(actionsByTick, [[expectedAction]]);
|
|
action.inputStateMap.clear();
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_extractActionChain_twoAndThreeTicks() {
|
|
let mouseActionItems = [
|
|
{
|
|
type: "pointerDown",
|
|
button: 2,
|
|
},
|
|
{
|
|
type: "pointerUp",
|
|
button: 2,
|
|
},
|
|
];
|
|
let mouseActionSequence = {
|
|
type: "pointer",
|
|
id: "7",
|
|
actions: mouseActionItems,
|
|
parameters: {
|
|
pointerType: "mouse" //TODO "touch"
|
|
},
|
|
};
|
|
let keyActionItems = [
|
|
{
|
|
type: "keyDown",
|
|
value: "a",
|
|
},
|
|
{
|
|
type: "pause",
|
|
duration: 4,
|
|
},
|
|
{
|
|
type: "keyUp",
|
|
value: "a",
|
|
},
|
|
];
|
|
let keyActionSequence = {
|
|
type: "key",
|
|
id: "1",
|
|
actions: keyActionItems,
|
|
};
|
|
let actionsByTick = action.Chain.fromJSON([keyActionSequence, mouseActionSequence]);
|
|
// number of ticks is same as longest action sequence
|
|
equal(keyActionItems.length, actionsByTick.length);
|
|
equal(2, actionsByTick[0].length);
|
|
equal(2, actionsByTick[1].length);
|
|
equal(1, actionsByTick[2].length);
|
|
let expectedAction = new action.Action(keyActionSequence.id, "key", keyActionItems[2].type);
|
|
expectedAction.value = keyActionItems[2].value;
|
|
deepEqual(actionsByTick[2][0], expectedAction);
|
|
action.inputStateMap.clear();
|
|
|
|
// one empty action sequence
|
|
actionsByTick = action.Chain.fromJSON(
|
|
[keyActionSequence, {type: "none", id: "some", actions: []}]);
|
|
equal(keyActionItems.length, actionsByTick.length);
|
|
equal(1, actionsByTick[0].length);
|
|
action.inputStateMap.clear();
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_computeTickDuration() {
|
|
let expected = 8000;
|
|
let tickActions = [
|
|
{type: "none", subtype: "pause", duration: 5000},
|
|
{type: "key", subtype: "pause", duration: 1000},
|
|
{type: "pointer", subtype: "pointerMove", duration: 6000},
|
|
// invalid because keyDown should not have duration, so duration should be ignored.
|
|
{type: "key", subtype: "keyDown", duration: 100000},
|
|
{type: "pointer", subtype: "pause", duration: expected},
|
|
{type: "pointer", subtype: "pointerUp"},
|
|
];
|
|
equal(expected, action.computeTickDuration(tickActions));
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_computeTickDuration_empty() {
|
|
equal(0, action.computeTickDuration([]));
|
|
run_next_test();
|
|
});
|
|
|
|
add_test(function test_computeTickDuration_noDurations() {
|
|
let tickActions = [
|
|
// invalid because keyDown should not have duration, so duration should be ignored.
|
|
{type: "key", subtype: "keyDown", duration: 100000},
|
|
// undefined duration permitted
|
|
{type: "none", subtype: "pause"},
|
|
{type: "pointer", subtype: "pointerMove"},
|
|
{type: "pointer", subtype: "pointerDown"},
|
|
{type: "key", subtype: "keyUp"},
|
|
];
|
|
|
|
equal(0, action.computeTickDuration(tickActions));
|
|
run_next_test();
|
|
});
|
|
|
|
|
|
// helpers
|
|
function getTypeString(obj) {
|
|
return Object.prototype.toString.call(obj);
|
|
};
|
|
|
|
function checkErrors(regex, func, args, message) {
|
|
if (typeof message == "undefined") {
|
|
message = `actionFunc: ${func.name}; args: ${args}`;
|
|
}
|
|
Assert.throws(() => func.apply(this, args), InvalidArgumentError, message);
|
|
Assert.throws(() => func.apply(this, args), regex, message);
|
|
};
|