Remove DevTools utilities test

This test has been replaced by Karma tests in the DevTools repository.

R=szuend@chromium.org

Bug: 1050549
Change-Id: Ic257c7e74b5cdea66cac11f5231ec59a046d6063
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2621759
Commit-Queue: Tim van der Lippe <tvanderlippe@chromium.org>
Commit-Queue: Simon Zünd <szuend@chromium.org>
Auto-Submit: Tim van der Lippe <tvanderlippe@chromium.org>
Reviewed-by: Simon Zünd <szuend@chromium.org>
Cr-Commit-Position: refs/heads/master@{#842504}

third_party/blink/web_tests/http/tests/devtools/components/utilities-expected.txt

-This test checks Web Inspector utilities.
-
-
-Running: orderedMergeIntersect
-
-Running: lowerBoundTest
-
-Running: upperBoundTest
-
-Running: sortRangeTest
-
-Running: naturalOrderComparatorTest
-Sorted in natural order: [1, 2, 2, 2, 5, 10, 11, 5555, 555555, a1, a007, a07, a7, a91, a4222, abc, abc0, abc00, abc000, abcd, dup, dup, dup, dup, dup, x09y19z29, x9y19z29, x10y19z43, x10y20z30, x10y22z23]
-
-Running: stringHashTest
-
-Running: trimMiddle
-
-!
-!
-🙈A🙈L🙈I🙈N🙈A🙈🙈
-🙈A🙈L🙈I🙈N🙈A🙈🙈
-🙈A🙈L🙈I…N🙈A🙈🙈
-🙈A🙈L🙈…N🙈A🙈🙈
-🙈A🙈L🙈…🙈A🙈🙈
-🙈A🙈L…🙈A🙈🙈
-🙈A🙈L🙈…A🙈🙈
-🙈A🙈L…A🙈🙈
-🙈A🙈L…A🙈🙈
-🙈A🙈…A🙈🙈
-🙈A🙈…🙈🙈
-🙈A…🙈🙈
-🙈A🙈…🙈
-🙈A…🙈
-🙈A…🙈
-🙈…🙈
-🙈A…
-🙈…
-…
-…
-test
-test
-t…t
-t…
-…
-

third_party/blink/web_tests/http/tests/devtools/components/utilities.js

-// Copyright 2017 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.
-
-(async function() {
-  'use strict';
-  TestRunner.addResult(`This test checks Web Inspector utilities.\n`);
-
-
-  TestRunner.runTestSuite([
-    function orderedMergeIntersect(next) {
-      function comparator(a, b) {
-        return a - b;
-      }
-      function count(a, x) {
-        return a.upperBound(x) - a.lowerBound(x);
-      }
-      function testAll(a, b) {
-        testOperation(a, b, a.mergeOrdered(b, comparator), Math.max, 'U');
-        testOperation(a, b, a.intersectOrdered(b, comparator), Math.min, 'x');
-      }
-      function testOperation(a, b, actual, checkOperation, opName) {
-        var allValues = a.concat(b).concat(actual);
-        for (var i = 0; i < allValues.length; ++i) {
-          var value = allValues[i];
-          const expectedCount =
-              checkOperation(count(a, value), count(b, value));
-          const actualCount = count(actual, value);
-          TestRunner.assertEquals(
-              expectedCount, actualCount,
-              'Incorrect result for value: ' + value + ' at [' + a + '] ' + opName + ' [' + b + '] -> [' + actual +
-                  ']');
-        }
-        TestRunner.assertEquals(JSON.stringify(actual.sort()), JSON.stringify(actual), 'result array is ordered');
-      }
-      var testArrays = [
-        [], [], [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 (var i = 0; i < testArrays.length; i += 2) {
-        testAll(testArrays[i], testArrays[i + 1]);
-        testAll(testArrays[i + 1], testArrays[i]);
-      }
-      next();
-    },
-
-    function lowerBoundTest(next) {
-      var testArrays = [[], [1], [-1, -1, 0, 0, 0, 0, 2, 3, 4, 4, 4, 7, 9, 9, 9]];
-
-      function testArray(array, useComparator) {
-        function comparator(a, b) {
-          return a < b ? -1 : (a > b ? 1 : 0);
-        }
-
-        for (var value = -2; value <= 12; ++value) {
-          var index = useComparator ? array.lowerBound(value, comparator) : array.lowerBound(value);
-          TestRunner.assertTrue(0 <= index && index <= array.length, 'index is within bounds');
-          TestRunner.assertTrue(index === 0 || array[index - 1] < value, 'array[index - 1] < value');
-          TestRunner.assertTrue(index === array.length || array[index] >= value, 'array[index] >= value');
-        }
-      }
-
-      for (var i = 0, l = testArrays.length; i < l; ++i) {
-        testArray(testArrays[i], false);
-        testArray(testArrays[i], true);
-      }
-      next();
-    },
-
-    function upperBoundTest(next) {
-      var testArrays = [[], [1], [-1, -1, 0, 0, 0, 0, 2, 3, 4, 4, 4, 7, 9, 9, 9]];
-
-      function testArray(array, useComparator) {
-        function comparator(a, b) {
-          return a < b ? -1 : (a > b ? 1 : 0);
-        }
-
-        for (var value = -2; value <= 12; ++value) {
-          var index = useComparator ? array.upperBound(value, comparator) : array.upperBound(value);
-          TestRunner.assertTrue(0 <= index && index <= array.length, 'index is within bounds');
-          TestRunner.assertTrue(index === 0 || array[index - 1] <= value, 'array[index - 1] <= value');
-          TestRunner.assertTrue(index === array.length || array[index] > value, 'array[index] > value');
-        }
-      }
-
-      for (var i = 0, l = testArrays.length; i < l; ++i) {
-        testArray(testArrays[i], false);
-        testArray(testArrays[i], true);
-      }
-      next();
-    },
-
-    function sortRangeTest(next) {
-      var testArrays = [[], [1], [2, 1], [6, 4, 2, 7, 10, 15, 1], [10, 44, 3, 6, 56, 66, 10, 55, 32, 56, 2, 5]];
-
-      function testArray(array) {
-        function comparator(a, b) {
-          return a < b ? -1 : (a > b ? 1 : 0);
-        }
-
-        function compareArrays(a, b, message) {
-          TestRunner.assertEquals(JSON.stringify(a), JSON.stringify(b), message);
-        }
-
-        for (var left = 0, l = array.length - 1; left < l; ++left) {
-          for (var right = left, r = array.length; right < r; ++right) {
-            for (var first = left; first <= right; ++first) {
-              for (var count = 1, k = right - first + 1; count <= k; ++count) {
-                var actual = array.slice(0);
-                actual.sortRange(comparator, left, right, first, first + count - 1);
-                compareArrays(array.slice(0, left), actual.slice(0, left), 'left ' + left + ' ' + right + ' ' + count);
-                compareArrays(
-                    array.slice(right + 1), actual.slice(right + 1), 'right ' + left + ' ' + right + ' ' + count);
-                var middle = array.slice(left, right + 1);
-                middle.sort(comparator);
-                compareArrays(
-                    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);
-                compareArrays(
-                    middle.slice(first - left + count), actualRest,
-                    'unsorted ' + left + ' ' + right + ' ' + first + ' ' + count);
-              }
-            }
-          }
-        }
-      }
-
-      for (var i = 0, len = testArrays.length; i < len; ++i)
-        testArray(testArrays[i]);
-      next();
-    },
-
-    function naturalOrderComparatorTest(next) {
-      var testArray = [
-        'dup', 'a1',   'a4222',  'a91',       'a07',      'dup', 'a7',        'a007',      'abc00',     'abc0',
-        'abc', 'abcd', 'abc000', 'x10y20z30', 'x9y19z29', 'dup', 'x09y19z29', 'x10y22z23', 'x10y19z43', '1',
-        '10',  '11',   'dup',    '2',         '2',        '2',   '555555',    '5',         '5555',      'dup',
-      ];
-
-      for (var i = 0, n = testArray.length; i < n; ++i)
-        TestRunner.assertEquals(
-            0, String.naturalOrderComparator(testArray[i], testArray[i]), 'comparing equal strings');
-
-      testArray.sort(String.naturalOrderComparator);
-      TestRunner.addResult('Sorted in natural order: [' + testArray.join(', ') + ']');
-
-      // Check comparator's transitivity.
-      for (var i = 0, n = testArray.length; i < n; ++i) {
-        for (var j = 0; j < n; ++j) {
-          var a = testArray[i];
-          var b = testArray[j];
-          var diff = String.naturalOrderComparator(a, b);
-          if (diff === 0)
-            TestRunner.assertEquals(a, b, 'zero diff');
-          else if (diff < 0)
-            TestRunner.assertTrue(i < j);
-          else
-            TestRunner.assertTrue(i > j);
-        }
-      }
-      next();
-    },
-
-    function stringHashTest(next) {
-      var stringA = ' '.repeat(10000);
-      var stringB = stringA + ' ';
-      var hashA = String.hashCode(stringA);
-      TestRunner.assertTrue(hashA !== String.hashCode(stringB));
-      TestRunner.assertTrue(isFinite(hashA));
-      TestRunner.assertTrue(hashA + 1 !== hashA);
-      next();
-    },
-
-    function trimMiddle(next) {
-      var testArray = [
-        '', '!', '\uD83D\uDE48A\uD83D\uDE48L\uD83D\uDE48I\uD83D\uDE48N\uD83D\uDE48A\uD83D\uDE48\uD83D\uDE48', 'test'
-      ];
-      for (var string of testArray) {
-        for (var maxLength = string.length + 1; maxLength > 0; --maxLength) {
-          var trimmed = string.trimMiddle(maxLength);
-          TestRunner.addResult(trimmed);
-          TestRunner.assertTrue(trimmed.length <= maxLength);
-        }
-      }
-      next();
-    }
-  ]);
-})();