diff options
Diffstat (limited to 'devtools/client/shared/test/xpcshell/test_linearEasing.js')
| -rw-r--r-- | devtools/client/shared/test/xpcshell/test_linearEasing.js | 217 |
1 files changed, 217 insertions, 0 deletions
diff --git a/devtools/client/shared/test/xpcshell/test_linearEasing.js b/devtools/client/shared/test/xpcshell/test_linearEasing.js new file mode 100644 index 0000000000..66e487e17b --- /dev/null +++ b/devtools/client/shared/test/xpcshell/test_linearEasing.js @@ -0,0 +1,217 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +// Tests methods from the LinearEasingWidget module + +const { + LinearEasingFunctionWidget, + parseTimingFunction, +} = require("resource://devtools/client/shared/widgets/LinearEasingFunctionWidget.js"); + +add_task(function testParseTimingFunction() { + info("test parseTimingFunction"); + + for (const test of ["ease", "linear", "ease-in", "ease-out", "ease-in-out"]) { + ok(!parseTimingFunction(test), `"${test}" is not valid`); + } + + ok(!parseTimingFunction("something"), "non-function token"); + ok(!parseTimingFunction("something()"), "non-linear function"); + ok( + !parseTimingFunction( + "linear(something)", + "linear with non-numeric argument" + ) + ); + + ok(!parseTimingFunction("linear(0)", "linear with only 1 point")); + + deepEqual( + parseTimingFunction("linear(0, 0.5, 1)"), + [ + { input: 0, output: 0 }, + { input: 0.5, output: 0.5 }, + { input: 1, output: 1 }, + ], + "correct invocation" + ); + deepEqual( + parseTimingFunction("linear(0, 0.5 /* mid */, 1)"), + [ + { input: 0, output: 0 }, + { input: 0.5, output: 0.5 }, + { input: 1, output: 1 }, + ], + "correct with comments and whitespace" + ); + deepEqual( + parseTimingFunction("linear(0 10%, 0.5 20%, 1 90%)"), + [ + { input: 0.1, output: 0 }, + { input: 0.2, output: 0.5 }, + { input: 0.9, output: 1 }, + ], + "correct invocation with single stop" + ); + deepEqual( + parseTimingFunction( + "linear(0, 0.1, 0.2, 0.3, 0.4, 0.5 50%, 0.6, 0.7, 0.8, 0.9 70%, 1)" + ), + [ + { input: 0, output: 0 }, + { input: 0.1, output: 0.1 }, + { input: 0.2, output: 0.2 }, + { input: 0.3, output: 0.3 }, + { input: 0.4, output: 0.4 }, + { input: 0.5, output: 0.5 }, + { input: 0.55, output: 0.6 }, + { input: 0.6, output: 0.7 }, + { + // This should be 0.65, but JS doesn't play well with floating points, which makes + // the test fail. So re-do the computation here + input: 0.5 * 0.25 + 0.7 * 0.75, + output: 0.8, + }, + { input: 0.7, output: 0.9 }, + { input: 1, output: 1 }, + ], + "correct invocation with single stop and run of non-stop values" + ); + + deepEqual( + parseTimingFunction("linear(0, 0.5 80%, 0.75 40%, 1)"), + [ + { input: 0, output: 0 }, + { input: 0.8, output: 0.5 }, + { input: 0.8, output: 0.75 }, + { input: 1, output: 1 }, + ], + "correct invocation with out of order single stop" + ); + + deepEqual( + parseTimingFunction("linear(0.5 10% 40%, 0, 0.2 60% 70%, 0.75 80% 100%)"), + [ + { input: 0.1, output: 0.5 }, + { input: 0.4, output: 0.5 }, + { input: 0.5, output: 0 }, + { input: 0.6, output: 0.2 }, + { input: 0.7, output: 0.2 }, + { input: 0.8, output: 0.75 }, + { input: 1, output: 0.75 }, + ], + "correct invocation with multiple stops" + ); + + deepEqual( + parseTimingFunction("linear(0, 0.2 60% 10%, 1)"), + [ + { input: 0, output: 0 }, + { input: 0.6, output: 0.2 }, + { input: 0.6, output: 0.2 }, + { input: 1, output: 1 }, + ], + "correct invocation with multiple out of order stops" + ); + + deepEqual( + parseTimingFunction("linear(0, 1.5, 1)"), + [ + { input: 0, output: 0 }, + { input: 0.5, output: 1.5 }, + { input: 1, output: 1 }, + ], + "linear function easing with output greater than 1" + ); + + deepEqual( + parseTimingFunction("linear(1, -0.5, 0)"), + [ + { input: 0, output: 1 }, + { input: 0.5, output: -0.5 }, + { input: 1, output: 0 }, + ], + "linear function easing with output less than 1" + ); + + deepEqual( + parseTimingFunction("linear(0, 0.1 -10%, 1)"), + [ + { input: 0, output: 0 }, + { input: 0, output: 0.1 }, + { input: 1, output: 1 }, + ], + "correct invocation, input value being unspecified in the first entry implies zero" + ); + + deepEqual( + parseTimingFunction("linear(0, 0.9 110%, 1)"), + [ + { input: 0, output: 0 }, + { input: 1.1, output: 0.9 }, + { input: 1.1, output: 1 }, + ], + "correct invocation, input value being unspecified in the last entry implies max input value" + ); +}); + +add_task(function testGetSetCssLinearValue() { + const doc = Services.appShell.createWindowlessBrowser().document; + const widget = new LinearEasingFunctionWidget(doc.body); + + widget.setCssLinearValue("linear(0)"); + ok(!widget.getCssLinearValue(), "no value returned for invalid value"); + + widget.setCssLinearValue("linear(0, 0.5, 1)"); + deepEqual( + widget.getCssLinearValue(), + "linear(0 0%, 0.5 50%, 1 100%)", + "no stops" + ); + + widget.setCssLinearValue("linear(0 10%, 0.5 20%, 1 90%)"); + deepEqual( + widget.getCssLinearValue(), + "linear(0 10%, 0.5 20%, 1 90%)", + "with single stops" + ); + + widget.setCssLinearValue("linear(0, 0.5 80%, 0.75 40%, 1)"); + deepEqual( + widget.getCssLinearValue(), + "linear(0 0%, 0.5 80%, 0.75 80%, 1 100%)", + "correcting out of order single stops" + ); + + widget.setCssLinearValue( + "linear(0.5 10% 40%, 0, 0.2 60% 70%, 0.75 80% 100%)" + ); + deepEqual( + widget.getCssLinearValue(), + "linear(0.5 10%, 0.5 40%, 0 50%, 0.2 60%, 0.2 70%, 0.75 80%, 0.75 100%)", + "multiple stops" + ); + + widget.setCssLinearValue("linear(0, 0.2 60% 10%, 1)"); + deepEqual( + widget.getCssLinearValue(), + "linear(0 0%, 0.2 60%, 0.2 60%, 1 100%)", + "correcting multiple out-of-order stops" + ); + + widget.setCssLinearValue("linear(1, -0.5, 1.5)"); + deepEqual( + widget.getCssLinearValue(), + "linear(1 0%, -0.5 50%, 1.5 100%)", + "output outside of [0,1] range" + ); + + widget.setCssLinearValue("linear(0 -10%, 0.5, 1 130%)"); + deepEqual( + widget.getCssLinearValue(), + "linear(0 -10%, 0.5 60%, 1 130%)", + "input outside of [0%,100%] range" + ); +}); |