| Index: tracing/tracing/base/math_test.html
|
| diff --git a/tracing/tracing/base/math_test.html b/tracing/tracing/base/math_test.html
|
| deleted file mode 100644
|
| index 4c71de1905afebeaa2cbdd5a1a31e62b019af25f..0000000000000000000000000000000000000000
|
| --- a/tracing/tracing/base/math_test.html
|
| +++ /dev/null
|
| @@ -1,149 +0,0 @@
|
| -<!DOCTYPE html>
|
| -<!--
|
| -Copyright (c) 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.
|
| --->
|
| -<link rel="import" href="/tracing/base/math.html">
|
| -
|
| -<script>
|
| -'use strict';
|
| -
|
| -tr.b.unittest.testSuite(function() {
|
| - test('erf', function() {
|
| - assert.closeTo(-1, tr.b.erf(-1e10), 1e-6);
|
| - assert.closeTo(-0.8427, tr.b.erf(-1), 1e-6);
|
| - assert.closeTo(-0.5205, tr.b.erf(-0.5), 1e-6);
|
| - assert.closeTo(0, tr.b.erf(0), 1e-6);
|
| - assert.closeTo(0.5205, tr.b.erf(0.5), 1e-6);
|
| - assert.closeTo(0.8427, tr.b.erf(1), 1e-6);
|
| - assert.closeTo(1, tr.b.erf(1e10), 1e-6);
|
| - });
|
| -
|
| - test('clamping', function() {
|
| - assert.equal(tr.b.clamp(2, 1, 3), 2);
|
| - assert.equal(tr.b.clamp(1, 1, 3), 1);
|
| - assert.equal(tr.b.clamp(0, 1, 3), 1);
|
| - assert.equal(tr.b.clamp(3, 1, 3), 3);
|
| - assert.equal(tr.b.clamp(4, 1, 3), 3);
|
| - });
|
| -
|
| - test('interpolatePiecewiseFunction', function() {
|
| - var points = [[0, 0], [0.1, 0.5], [1, 1]];
|
| - assert.equal(0, vec2.interpolatePiecewiseFunction(points, -1));
|
| - assert.equal(0, vec2.interpolatePiecewiseFunction(points, 0));
|
| - assert.equal(0.25, vec2.interpolatePiecewiseFunction(points, 0.05));
|
| - assert.equal(0.5, vec2.interpolatePiecewiseFunction(points, 0.1));
|
| - assert.equal(0.75, vec2.interpolatePiecewiseFunction(points, 0.55));
|
| - assert.equal(1, vec2.interpolatePiecewiseFunction(points, 1));
|
| - assert.equal(1, vec2.interpolatePiecewiseFunction(points, 2));
|
| - });
|
| -
|
| - test('powers', function() {
|
| - assert.strictEqual(0.01, tr.b.lesserPower(0.05));
|
| - assert.strictEqual(0.1, tr.b.greaterPower(0.05));
|
| - assert.strictEqual(0.1, tr.b.lesserPower(0.5));
|
| - assert.strictEqual(1, tr.b.greaterPower(0.5));
|
| - assert.strictEqual(1, tr.b.lesserPower(5));
|
| - assert.strictEqual(10, tr.b.greaterPower(5));
|
| - assert.strictEqual(10, tr.b.lesserPower(50));
|
| - assert.strictEqual(100, tr.b.greaterPower(50));
|
| -
|
| - assert.strictEqual(0, tr.b.lesserPower(0));
|
| - assert.strictEqual(0, tr.b.greaterPower(0));
|
| - assert.isTrue(isNaN(tr.b.lesserPower(-1)));
|
| - assert.isTrue(isNaN(tr.b.greaterPower(-1)));
|
| -
|
| - assert.strictEqual(0.25, tr.b.lesserPower(0.3, 2));
|
| - assert.strictEqual(0.5, tr.b.greaterPower(0.3, 2));
|
| - assert.strictEqual(0.5, tr.b.lesserPower(0.8, 2));
|
| - assert.strictEqual(1, tr.b.greaterPower(0.8, 2));
|
| - assert.strictEqual(1, tr.b.lesserPower(1.5, 2));
|
| - assert.strictEqual(2, tr.b.greaterPower(1.5, 2));
|
| - assert.strictEqual(2, tr.b.lesserPower(3, 2));
|
| - assert.strictEqual(4, tr.b.greaterPower(3, 2));
|
| - assert.strictEqual(4, tr.b.lesserPower(5, 2));
|
| - assert.strictEqual(8, tr.b.greaterPower(5, 2));
|
| -
|
| - assert.strictEqual(0, tr.b.lesserPower(0, 2));
|
| - assert.strictEqual(0, tr.b.greaterPower(0, 2));
|
| - assert.isTrue(isNaN(tr.b.lesserPower(-1, 2)));
|
| - assert.isTrue(isNaN(tr.b.greaterPower(-1, 2)));
|
| - });
|
| -
|
| - test('lesserWholeNumber', function() {
|
| - // Use powers of 2 less than 10 to prevent float rounding errors from
|
| - // breaking Math.floor().
|
| - for (const i of [1, 2, 4, 8]) {
|
| - assert.strictEqual(-i, tr.b.lesserWholeNumber(-i));
|
| - assert.strictEqual(-i * 10, tr.b.lesserWholeNumber(-i * 10));
|
| - assert.strictEqual(-i / 10, tr.b.lesserWholeNumber(-i / 10));
|
| - assert.strictEqual(-i * 100, tr.b.lesserWholeNumber(-i * 100));
|
| - assert.strictEqual(-i / 100, tr.b.lesserWholeNumber(-i / 100));
|
| -
|
| - assert.strictEqual(i, tr.b.lesserWholeNumber(i));
|
| - assert.strictEqual(i * 10, tr.b.lesserWholeNumber(i * 10));
|
| - assert.strictEqual(i / 10, tr.b.lesserWholeNumber(i / 10));
|
| - assert.strictEqual(i * 100, tr.b.lesserWholeNumber(i * 100));
|
| - assert.strictEqual(i / 100, tr.b.lesserWholeNumber(i / 100));
|
| -
|
| - const x = i * 1.01;
|
| - assert.strictEqual(-i, tr.b.lesserWholeNumber(-x));
|
| - assert.strictEqual(-i * 10, tr.b.lesserWholeNumber(-x * 10));
|
| - assert.strictEqual(-i / 10, tr.b.lesserWholeNumber(-x / 10));
|
| - assert.strictEqual(-i * 100, tr.b.lesserWholeNumber(-x * 100));
|
| - assert.strictEqual(-i / 100, tr.b.lesserWholeNumber(-x / 100));
|
| -
|
| - assert.strictEqual(i, tr.b.lesserWholeNumber(x));
|
| - assert.strictEqual(i * 10, tr.b.lesserWholeNumber(x * 10));
|
| - assert.strictEqual(i / 10, tr.b.lesserWholeNumber(x / 10));
|
| - assert.strictEqual(i * 100, tr.b.lesserWholeNumber(x * 100));
|
| - assert.strictEqual(i / 100, tr.b.lesserWholeNumber(x / 100));
|
| - }
|
| - });
|
| -
|
| - test('greaterWholeNumber', function() {
|
| - // Use powers of 2 great than 10 to prevent float rounding errors from
|
| - // breaking Math.floor().
|
| - for (const i of [1, 2, 4, 8]) {
|
| - assert.strictEqual(-i, tr.b.greaterWholeNumber(-i));
|
| - assert.strictEqual(-i * 10, tr.b.greaterWholeNumber(-i * 10));
|
| - assert.strictEqual(-i / 10, tr.b.greaterWholeNumber(-i / 10));
|
| - assert.strictEqual(-i * 100, tr.b.greaterWholeNumber(-i * 100));
|
| - assert.strictEqual(-i / 100, tr.b.greaterWholeNumber(-i / 100));
|
| -
|
| - assert.strictEqual(i, tr.b.greaterWholeNumber(i));
|
| - assert.strictEqual(i * 10, tr.b.greaterWholeNumber(i * 10));
|
| - assert.strictEqual(i / 10, tr.b.greaterWholeNumber(i / 10));
|
| - assert.strictEqual(i * 100, tr.b.greaterWholeNumber(i * 100));
|
| - assert.strictEqual(i / 100, tr.b.greaterWholeNumber(i / 100));
|
| -
|
| - const x = i * 0.99;
|
| - assert.strictEqual(-i, tr.b.greaterWholeNumber(-x));
|
| - assert.strictEqual(-i * 10, tr.b.greaterWholeNumber(-x * 10));
|
| - assert.strictEqual(-i / 10, tr.b.greaterWholeNumber(-x / 10));
|
| - assert.strictEqual(-i * 100, tr.b.greaterWholeNumber(-x * 100));
|
| - assert.strictEqual(-i / 100, tr.b.greaterWholeNumber(-x / 100));
|
| -
|
| - assert.strictEqual(i, tr.b.greaterWholeNumber(x));
|
| - assert.strictEqual(i * 10, tr.b.greaterWholeNumber(x * 10));
|
| - assert.strictEqual(i / 10, tr.b.greaterWholeNumber(x / 10));
|
| - assert.strictEqual(i * 100, tr.b.greaterWholeNumber(x * 100));
|
| - assert.strictEqual(i / 100, tr.b.greaterWholeNumber(x / 100));
|
| - }
|
| - });
|
| -
|
| - test('preferedNumberLargerThanMin', function() {
|
| - assert.strictEqual(tr.b.preferredNumberLargerThanMin(0), 0);
|
| - assert.strictEqual(tr.b.preferredNumberLargerThanMin(1), 1);
|
| - assert.strictEqual(tr.b.preferredNumberLargerThanMin(2), 2);
|
| - assert.strictEqual(tr.b.preferredNumberLargerThanMin(3), 5);
|
| - assert.strictEqual(tr.b.preferredNumberLargerThanMin(7), 10);
|
| - assert.strictEqual(tr.b.preferredNumberLargerThanMin(0.03), 0.05);
|
| - assert.strictEqual(tr.b.preferredNumberLargerThanMin(-1), -1);
|
| - assert.strictEqual(tr.b.preferredNumberLargerThanMin(237538), 500000);
|
| - assert.strictEqual(tr.b.preferredNumberLargerThanMin(46.13246), 50);
|
| - assert.strictEqual(tr.b.preferredNumberLargerThanMin(-823.34561), -1000);
|
| - });
|
| -});
|
| -</script>
|
|
|