chrome-devtools-frontend 1.0.1506453 → 1.0.1510180

package/front_end/core/platform/ArrayUtilities.test.ts

@@ -1,499 +0,0 @@
-// Copyright (c) 2020 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.
-
-import * as Platform from './platform.js';
-
-function comparator(a: number, b: number): number {
-  return a < b ? -1 : (a > b ? 1 : 0);
-}
-
-describe('ArrayUtilities', () => {
-  describe('removeElement', () => {
-    it('removes elements', () => {
-      const testCases = [
-        {input: [], expectedFirstOnlyTrue: [], expectedFirstOnlyFalse: []},
-        {input: [1], expectedFirstOnlyTrue: [1], expectedFirstOnlyFalse: [1]},
-        {
-          input: [1, 2, 3, 4, 5, 4, 3, 2, 1],
-          expectedFirstOnlyTrue: [1, 3, 4, 5, 4, 3, 2, 1],
-          expectedFirstOnlyFalse: [1, 3, 4, 5, 4, 3, 1],
-        },
-        {input: [2, 2, 2, 2, 2], expectedFirstOnlyTrue: [2, 2, 2, 2], expectedFirstOnlyFalse: []},
-        {input: [2, 2, 2, 1, 2, 2, 3, 2], expectedFirstOnlyTrue: [2, 2, 1, 2, 2, 3, 2], expectedFirstOnlyFalse: [1, 3]},
-      ];
-
-      for (const testCase of testCases) {
-        const actualFirstOnlyTrue = [...testCase.input];
-
-        Platform.ArrayUtilities.removeElement(actualFirstOnlyTrue, 2, true);
-        assert.deepEqual(actualFirstOnlyTrue, testCase.expectedFirstOnlyTrue, 'Removing firstOnly (true) failed');
-
-        const actualFirstOnlyFalse = [...testCase.input];
-        Platform.ArrayUtilities.removeElement(actualFirstOnlyFalse, 2, false);
-        assert.deepEqual(actualFirstOnlyFalse, testCase.expectedFirstOnlyFalse, 'Removing firstOnly (false) failed');
-      }
-    });
-  });
-
-  const fixtures = [
-    [],
-    [1],
-    [2, 1],
-    [6, 4, 2, 7, 10, 15, 1],
-    [10, 44, 3, 6, 56, 66, 10, 55, 32, 56, 2, 5],
-  ];
-  for (let i = 0; i < fixtures.length; i++) {
-    const fixture = fixtures[i];
-
-    it(`sorts ranges, fixture ${i}`, () => {
-      for (let left = 0, l = fixture.length - 1; left < l; ++left) {
-        for (let right = left, r = fixture.length; right < r; ++right) {
-          for (let first = left; first <= right; ++first) {
-            for (let count = 1, k = right - first + 1; count <= k; ++count) {
-              const actual = fixture.slice(0);
-              Platform.ArrayUtilities.sortRange(actual, comparator, left, right, first, first + count - 1);
-              assert.deepEqual(
-                  fixture.slice(0, left), actual.slice(0, left), 'left ' + left + ' ' + right + ' ' + count);
-              assert.deepEqual(
-                  fixture.slice(right + 1), actual.slice(right + 1), 'right ' + left + ' ' + right + ' ' + count);
-
-              const middle = fixture.slice(left, right + 1);
-              middle.sort(comparator);
-              assert.deepEqual(
-                  middle.slice(first - left, first - left + count), actual.slice(first, first + count),
-                  'sorted ' + left + ' ' + right + ' ' + first + ' ' + count);
-
-              const actualRest = actual.slice(first + count, right + 1);
-              actualRest.sort(comparator);
-              assert.deepEqual(
-                  middle.slice(first - left + count), actualRest,
-                  'unsorted ' + left + ' ' + right + ' ' + first + ' ' + count);
-            }
-          }
-        }
-      }
-    });
-  }
-  describe('binaryIndexOf', () => {
-    it('calculates the correct binary index', () => {
-      const fixtures = [
-        [],
-        [1],
-        [1, 10],
-        [1, 10, 11, 12, 13, 14, 100],
-        [-100, -50, 0, 50, 100],
-        [-100, -14, -13, -12, -11, -10, -1],
-      ];
-
-      function testArray(array: number[]) {
-        function comparator(a: number, b: number) {
-          return a < b ? -1 : (a > b ? 1 : 0);
-        }
-
-        for (let i = -100; i <= 100; ++i) {
-          const reference = array.indexOf(i);
-          const actual = Platform.ArrayUtilities.binaryIndexOf(array, i, comparator);
-          assert.strictEqual(reference, actual);
-        }
-      }
-
-      for (const fixture of fixtures) {
-        testArray(fixture);
-      }
-    });
-  });
-  describe('merge and intersect', () => {
-    it('orders merge intersect', () => {
-      function comparator(a: number, b: number) {
-        return a - b;
-      }
-
-      function count(a: number[], x: number) {
-        return Platform.ArrayUtilities.upperBound(a, x, Platform.ArrayUtilities.DEFAULT_COMPARATOR) -
-            Platform.ArrayUtilities.lowerBound(a, x, Platform.ArrayUtilities.DEFAULT_COMPARATOR);
-      }
-
-      function testAll(a: number[], b: number[]) {
-        testOperation(a, b, Platform.ArrayUtilities.mergeOrdered(a, b, comparator), Math.max, 'U');
-        testOperation(a, b, Platform.ArrayUtilities.intersectOrdered(a, b, comparator), Math.min, 'x');
-      }
-
-      function testOperation(
-          a: number[], b: number[], actual: number[], checkOperation: (...values: number[]) => number, opName: string) {
-        const allValues = a.concat(b).concat(actual);
-        let expectedCount: number;
-        let actualCount: number;
-
-        for (let i = 0; i < allValues.length; ++i) {
-          const value = allValues[i];
-          expectedCount = checkOperation(count(a, value), count(b, value));
-          actualCount = count(actual, value);
-          assert.strictEqual(
-              expectedCount, actualCount,
-              'Incorrect result for value: ' + value + ' at [' + a + '] ' + opName + ' [' + b + '] -> [' + actual +
-                  ']');
-        }
-
-        const shallowCopy = [...actual];
-        assert.deepEqual(actual.sort(), shallowCopy, 'Result array is ordered');
-      }
-
-      const fixtures = new Map([
-        [[], []],
-        [[1], []],
-        [[1, 2, 2, 2, 3], []],
-        [[4, 5, 5, 8, 8], [1, 1, 1, 2, 6]],
-        [[1, 2, 2, 2, 2, 3, 3, 4], [2, 2, 2, 3, 3, 3, 3]],
-        [[1, 2, 3, 4, 5], [1, 2, 3]],
-      ]);
-
-      for (const [a, b] of fixtures) {
-        testAll(a, b);
-        testAll(b, a);
-      }
-    });
-  });
-
-  describe('upperBound', () => {
-    it('finds the first object after the needle whose value is greater than the needle', async () => {
-      const input = [0, 1, 2, 3, 4, 5];
-      const index = Platform.ArrayUtilities.upperBound(input, 2, Platform.ArrayUtilities.DEFAULT_COMPARATOR);
-      assert.strictEqual(index, 3);
-    });
-
-    it('can take left and right params to alter the range', async () => {
-      const input = [0, 1, 2, 3, 4, 5];
-      const index = Platform.ArrayUtilities.upperBound(input, 2, Platform.ArrayUtilities.DEFAULT_COMPARATOR, 4, 6);
-      assert.strictEqual(index, 4);
-    });
-
-    it('can take a custom comparator to determine how to compare elements', async () => {
-      const input = [{time: 0, name: 'test1'}, {time: 6, name: 'test2'}];
-      const index = Platform.ArrayUtilities.upperBound(input, 2, (needle, element) => {
-        if (needle > element.time) {
-          return 1;
-        }
-        if (element.time > needle) {
-          return -1;
-        }
-        return 0;
-      });
-      assert.strictEqual(index, 1);
-    });
-  });
-
-  describe('lowerBound', () => {
-    it('finds the first object after the needle whose value is equal to or greater than the needle', async () => {
-      const input = [0, 1, 2, 3, 4, 5];
-      const index = Platform.ArrayUtilities.lowerBound(input, 2, Platform.ArrayUtilities.DEFAULT_COMPARATOR);
-      assert.strictEqual(index, 2);
-    });
-
-    it('can take left and right params to alter the range', async () => {
-      const input = [0, 1, 2, 3, 4, 5];
-      const index = Platform.ArrayUtilities.lowerBound(input, 2, Platform.ArrayUtilities.DEFAULT_COMPARATOR, 5, 6);
-      assert.strictEqual(index, 5);
-    });
-
-    it('can take a custom comparator to determine how to compare elements', async () => {
-      const input = [{time: 0, name: 'test1'}, {time: 2, name: 'test2'}, {time: 3, name: 'test3'}];
-      const index = Platform.ArrayUtilities.lowerBound(input, 2, (needle, element) => {
-        if (needle > element.time) {
-          return 1;
-        }
-        if (element.time > needle) {
-          return -1;
-        }
-        return 0;
-      });
-      assert.strictEqual(index, 1);
-    });
-  });
-
-  describe('Nearest', () => {
-    describe('Finding the last item where predicate is true', () => {
-      it('works with an even number of entries', () => {
-        const ascEntries = [{a: 1}, {a: 3}, {a: 3}, {a: 12}, {a: 13}, {a: 18}, {a: 23}, {a: 24}];
-        let nearest = Platform.ArrayUtilities.nearestIndexFromEnd(ascEntries, value => value.a < 7);
-
-        assert.strictEqual(nearest, 2);
-
-        const descEntries = [{a: 23}, {a: 18}, {a: 13}, {a: 12}, {a: 12}, {a: 3}, {a: 1}, {a: 0}];
-        nearest = Platform.ArrayUtilities.nearestIndexFromEnd(descEntries, value => value.a > 7);
-
-        assert.strictEqual(nearest, 4);
-      });
-
-      it('works with an odd number of entries', () => {
-        const ascEntries = [
-          {a: 1},
-          {a: 3},
-          {a: 12},
-          {a: 13},
-          {a: 18},
-          {a: 23},
-          {a: 23},
-          {a: 32},
-          {a: 33},
-        ];
-        let nearest = Platform.ArrayUtilities.nearestIndexFromEnd(ascEntries, value => value.a < 31);
-        assert.strictEqual(nearest, 6);
-
-        const descEntries = [
-          {a: 32},
-          {a: 23},
-          {a: 18},
-          {a: 13},
-          {a: 12},
-          {a: 3},
-          {a: 3},
-          {a: 1},
-        ];
-        nearest = Platform.ArrayUtilities.nearestIndexFromEnd(descEntries, value => value.a > 2);
-        assert.strictEqual(nearest, 6);
-      });
-
-      it('returns null if there are no matches at all', () => {
-        const ascEntries = [
-          {a: 1},
-          {a: 3},
-          {a: 12},
-          {a: 13},
-          {a: 18},
-          {a: 23},
-          {a: 32},
-        ];
-        let zeroth = Platform.ArrayUtilities.nearestIndexFromEnd(ascEntries, value => value.a < 0);
-        assert.isNull(zeroth);
-
-        const descEntries = [
-          {a: 32},
-          {a: 23},
-          {a: 18},
-          {a: 13},
-          {a: 12},
-          {a: 3},
-          {a: 1},
-        ];
-        zeroth = Platform.ArrayUtilities.nearestIndexFromEnd(descEntries, value => value.a > 40);
-        assert.isNull(zeroth);
-      });
-
-      it('works when the result is the last item', () => {
-        const ascEntries = [
-          {a: 1},
-          {a: 3},
-          {a: 12},
-          {a: 13},
-          {a: 18},
-          {a: 23},
-          {a: 32},
-          {a: 32},
-        ];
-        let last = Platform.ArrayUtilities.nearestIndexFromEnd(ascEntries, value => value.a < 40);
-        assert.strictEqual(last, ascEntries.length - 1);
-
-        const descEntries = [
-          {a: 32},
-          {a: 23},
-          {a: 18},
-          {a: 13},
-          {a: 12},
-          {a: 3},
-          {a: 1},
-          {a: 1},
-        ];
-        last = Platform.ArrayUtilities.nearestIndexFromEnd(descEntries, value => value.a > 0);
-        assert.strictEqual(last, descEntries.length - 1);
-      });
-
-      it('works on exact values', () => {
-        const ascEntries = [
-          {a: 1},
-          {a: 2},
-          {a: 3},
-          {a: 3},
-          {a: 4},
-          {a: 5},
-          {a: 6},
-        ];
-        const predicateFunc = (value: {a: number}) => value.a <= 3;
-
-        // Odd number of entries.
-        // Note that the predicate is allowing an the exact match.
-        let nearest = Platform.ArrayUtilities.nearestIndexFromEnd(ascEntries, predicateFunc);
-        assert.strictEqual(nearest, 3);
-
-        // Even number of entries.
-        ascEntries.push({a: 7});
-        nearest = Platform.ArrayUtilities.nearestIndexFromEnd(ascEntries, predicateFunc);
-        assert.strictEqual(nearest, 3);
-
-        const descEntries = [
-          {a: 6},
-          {a: 5},
-          {a: 4},
-          {a: 3},
-          {a: 3},
-          {a: 2},
-          {a: 1},
-        ];
-        // Note that the predicate is allowing an the exact match.
-        const gePredicate = (value: {a: number}) => value.a >= 3;
-
-        // Odd number of entries.
-        nearest = Platform.ArrayUtilities.nearestIndexFromEnd(descEntries, gePredicate);
-        assert.strictEqual(nearest, 4);
-
-        // Even number of entries.
-        descEntries.push({a: 7});
-        nearest = Platform.ArrayUtilities.nearestIndexFromEnd(descEntries, gePredicate);
-        assert.strictEqual(nearest, 4);
-      });
-    });
-    describe('Finding the first item in the array where predicate is true', () => {
-      it('works with an even number of entries', () => {
-        const ascEntries = [{a: 1}, {a: 3}, {a: 12}, {a: 12}, {a: 13}, {a: 18}, {a: 23}, {a: 24}];
-        let nearest = Platform.ArrayUtilities.nearestIndexFromBeginning(ascEntries, value => value.a > 7);
-        assert.strictEqual(nearest, 2);
-
-        const descEntries = [{a: 23}, {a: 18}, {a: 13}, {a: 12}, {a: 12}, {a: 3}, {a: 1}, {a: 0}];
-        nearest = Platform.ArrayUtilities.nearestIndexFromBeginning(descEntries, value => value.a < 13);
-        assert.strictEqual(nearest, 3);
-      });
-
-      it('works with an odd number of entries', () => {
-        const ascEntries = [
-          {a: 1},
-          {a: 3},
-          {a: 12},
-          {a: 13},
-          {a: 18},
-          {a: 23},
-          {a: 32},
-          {a: 32},
-          {a: 33},
-        ];
-        let nearest = Platform.ArrayUtilities.nearestIndexFromBeginning(ascEntries, value => value.a > 31);
-        assert.strictEqual(nearest, 6);
-
-        const descEntries = [
-          {a: 33},
-          {a: 32},
-          {a: 23},
-          {a: 23},
-          {a: 18},
-          {a: 23},
-          {a: 32},
-          {a: 3},
-          {a: 1},
-        ];
-        nearest = Platform.ArrayUtilities.nearestIndexFromBeginning(descEntries, value => value.a < 32);
-        assert.strictEqual(nearest, 2);
-      });
-
-      it('returns null if there are no matches at all', () => {
-        const entries = [
-          {a: 1},
-          {a: 3},
-          {a: 12},
-          {a: 13},
-          {a: 18},
-          {a: 23},
-          {a: 32},
-        ];
-        const predicate = (value: {a: number}) => value.a > 33;
-        const nearest = Platform.ArrayUtilities.nearestIndexFromBeginning(entries, predicate);
-        assert.isNull(nearest);
-      });
-
-      it('works when the result is the first item', () => {
-        const ascEntries = [
-          {a: 1},
-          {a: 1},
-          {a: 3},
-          {a: 12},
-          {a: 13},
-          {a: 18},
-          {a: 23},
-          {a: 32},
-        ];
-        const greaterThanPredicate = (value: {a: number}) => value.a > 0;
-        let first = Platform.ArrayUtilities.nearestIndexFromBeginning(ascEntries, greaterThanPredicate);
-        assert.strictEqual(first, 0);
-
-        const descEntries = [
-          {a: 32},
-          {a: 32},
-          {a: 23},
-          {a: 18},
-          {a: 13},
-          {a: 12},
-          {a: 5},
-          {a: 5},
-        ];
-        const predicate = (value: {a: number}) => value.a < 64;
-        first = Platform.ArrayUtilities.nearestIndexFromBeginning(descEntries, predicate);
-        assert.strictEqual(first, 0);
-      });
-
-      it('works on exact values', () => {
-        const ascEntries = [
-          {a: 1},
-          {a: 2},
-          {a: 3},
-          {a: 3},
-          {a: 4},
-          {a: 5},
-          {a: 6},
-        ];
-        // Note that the predicate is allowing an the exact match.
-        const gePredicate = (value: {a: number}) => value.a >= 3;
-
-        // Even number of entries.
-        let nearest = Platform.ArrayUtilities.nearestIndexFromBeginning(ascEntries, gePredicate);
-        assert.strictEqual(nearest, 2);
-
-        // Odd number of entries.
-        ascEntries.push({a: 7});
-        nearest = Platform.ArrayUtilities.nearestIndexFromBeginning(ascEntries, gePredicate);
-        assert.strictEqual(nearest, 2);
-
-        const descEntries = [
-          {a: 6},
-          {a: 5},
-          {a: 4},
-          {a: 3},
-          {a: 3},
-          {a: 2},
-          {a: 1},
-        ];
-        // Note that the predicate is allowing an the exact match.
-        const predicateFunc = (value: {a: number}) => value.a <= 3;
-
-        // Even number of entries.
-        nearest = Platform.ArrayUtilities.nearestIndexFromBeginning(descEntries, predicateFunc);
-        assert.strictEqual(nearest, 3);
-
-        // Odd number of entries.
-        descEntries.push({a: 7});
-        nearest = Platform.ArrayUtilities.nearestIndexFromBeginning(descEntries, predicateFunc);
-
-        assert.strictEqual(nearest, 3);
-      });
-    });
-  });
-
-  describe('arrayDoesNotContainNullOrUndefined', () => {
-    it('should return false when array contains null', () => {
-      assert.isFalse(Platform.ArrayUtilities.arrayDoesNotContainNullOrUndefined([1, null, 2]));
-    });
-    it('should return false when array contains undefined', () => {
-      assert.isFalse(Platform.ArrayUtilities.arrayDoesNotContainNullOrUndefined([1, undefined, 2]));
-    });
-    it('should return true when array does not contain undefined and null', () => {
-      assert.isTrue(Platform.ArrayUtilities.arrayDoesNotContainNullOrUndefined([1, 2]));
-    });
-  });
-});

package/front_end/core/platform/DOMUtilities.test.ts

@@ -1,95 +0,0 @@
-// Copyright (c) 2022 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.
-
-import {renderElementIntoDOM} from '../../testing/DOMHelpers.js';
-
-import * as Platform from './platform.js';
-
-const cssInJS = (strings: ArrayLike<string>, ...values: any[]): CSSInJS =>
-    String.raw({raw: strings}, ...values) as CSSInJS;
-
-describe('DOMUtilities', () => {
-  describe('deepActiveElement', () => {
-    it('returns the active element if there is no shadow root', () => {
-      const btn = document.createElement('button');
-      btn.innerText = 'Click me!';
-      renderElementIntoDOM(btn);
-      btn.focus();
-      const activeElement = Platform.DOMUtilities.deepActiveElement(document);
-      assert.strictEqual(activeElement, btn);
-    });
-
-    it('dives through the shadow root and finds the right active element', () => {
-      class TestComponent extends HTMLElement {
-        shadow = this.attachShadow({mode: 'open'});
-        button = document.createElement('button');
-
-        connectedCallback(): void {
-          this.button.innerText = 'Click me from the shadow root!';
-          this.shadow.appendChild(this.button);
-          this.button.focus();
-        }
-      }
-      customElements.define('dom-utilities-test-component', TestComponent);
-
-      const component = new TestComponent();
-      renderElementIntoDOM(component);
-      const activeElement = Platform.DOMUtilities.deepActiveElement(document);
-      assert.strictEqual(activeElement, component.button);
-    });
-  });
-
-  describe('getEnclosingShadowRootForNode', () => {
-    it('returns null if no shadow root is found up the tree', () => {
-      const parent = document.createElement('div');
-      const child = document.createElement('p');
-      parent.appendChild(child);
-      renderElementIntoDOM(parent);
-      assert.isNull(Platform.DOMUtilities.getEnclosingShadowRootForNode(child));
-    });
-
-    it('returns the shadow root in the tree', () => {
-      const div = document.createElement('div');
-
-      class TestComponent extends HTMLElement {
-        readonly #shadow = this.attachShadow({mode: 'open'});
-
-        connectedCallback() {
-          this.#shadow.appendChild(div);
-        }
-      }
-      customElements.define('shadow-root-test', TestComponent);
-      const component = new TestComponent();
-      renderElementIntoDOM(component);
-      assert.strictEqual(Platform.DOMUtilities.getEnclosingShadowRootForNode(div), component.shadowRoot);
-    });
-  });
-
-  describe('appendStyle', () => {
-    const {appendStyle} = Platform.DOMUtilities;
-
-    it('correctly appends <style> elements', () => {
-      const parent = renderElementIntoDOM(document.createElement('main'));
-
-      appendStyle(parent, cssInJS`h1 { color: red; }`);
-      appendStyle(parent, cssInJS`h2 { color: green; } h1 { font-size: 1px; }`);
-
-      assert.lengthOf(parent.children, 2);
-      assert.instanceOf(parent.children[0], HTMLStyleElement);
-      assert.strictEqual(parent.children[0].textContent, 'h1 { color: red; }');
-      assert.instanceOf(parent.children[1], HTMLStyleElement);
-      assert.strictEqual(parent.children[1].textContent, 'h2 { color: green; } h1 { font-size: 1px; }');
-    });
-
-    it('correctly inserts <style> elements into disconnected nodes', () => {
-      const parent = document.createElement('div');
-
-      appendStyle(parent, cssInJS`div { color: red; }`);
-
-      assert.lengthOf(parent.children, 1);
-      assert.instanceOf(parent.children[0], HTMLStyleElement);
-      assert.strictEqual(parent.children[0].textContent, 'div { color: red; }');
-    });
-  });
-});

package/front_end/core/platform/DateUtilities.test.ts

@@ -1,31 +0,0 @@
-// Copyright (c) 2020 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.
-
-import * as Platform from './platform.js';
-
-describe('DateUtilities', () => {
-  describe('isValid', () => {
-    it('returns true for a valid date', () => {
-      assert.isTrue(Platform.DateUtilities.isValid(new Date()));
-    });
-
-    it('returns false for a nonsense date', () => {
-      const soNotADate = new Date('not-a-date');
-
-      assert.isFalse(Platform.DateUtilities.isValid(soNotADate));
-    });
-  });
-
-  describe('toISO8601Compact', () => {
-    it('formats a date into a string', () => {
-      const date = new Date(2020, 10, 20, 12, 13, 14);
-      assert.strictEqual(Platform.DateUtilities.toISO8601Compact(date), '20201120T121314');
-    });
-
-    it('adds leading zeroes', () => {
-      const date = new Date(2020, 0, 1, 0, 0, 0);
-      assert.strictEqual(Platform.DateUtilities.toISO8601Compact(date), '20200101T000000');
-    });
-  });
-});