third_party/WebKit/LayoutTests/inspector/components/utilities.html - chromium/src.git - Git at Google

 <html>
 <head>
 <script src="../../http/tests/inspector/inspector-test.js"></script>
 <script>

 function test()
 {
     InspectorTest.runTestSuite([
         function remove(next)
         {
             var testArrays = [
                 [], [], [],
                 [1], [1], [1],
                 [1, 2, 3, 4, 5, 4, 3, 2, 1], [1, 3, 4, 5, 4, 3, 2, 1], [1, 3, 4, 5, 4, 3, 1],
                 [2, 2, 2, 2, 2], [2, 2, 2, 2], [],
                 [2, 2, 2, 1, 2, 2, 3, 2], [2, 2, 1, 2, 2, 3, 2], [1, 3]
             ];
             for (var i = 0; i < testArrays.length; i += 3) {
                 var actual = testArrays[i].slice(0);
                 var expected = testArrays[i + 1];
                 actual.remove(2, true);
                 InspectorTest.assertEquals(JSON.stringify(expected), JSON.stringify(actual), "remove(2, true) passed");
                 actual = testArrays[i].slice(0);
                 expected = testArrays[i + 2];
                 actual.remove(2, false);
                 InspectorTest.assertEquals(JSON.stringify(expected), JSON.stringify(actual), "remove(2, false) passed");
             }
             next();
         },

         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];
                     expectedCount = checkOperation(count(a, value), count(b, value));
                     actualCount = count(actual, value);
                     InspectorTest.assertEquals(expectedCount, actualCount,
                         "Incorrect result for value: " + value + " at [" + a + "] " + opName + " [" + b + "] -> [" + actual + "]");
                 }
                 InspectorTest.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 binaryIndexOfTest(next)
         {
             var testArrays = [
                 [],
                 [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)
             {
                 function comparator(a, b)
                 {
                     return a < b ? -1 : (a > b ? 1 : 0);
                 }

                 for (var i = -100; i <= 100; ++i) {
                     var reference = array.indexOf(i);
                     var actual = array.binaryIndexOf(i, comparator);
                     InspectorTest.assertEquals(reference, actual, "binaryIndexOf");
                 }
                 return true;
             }

             for (var i = 0, l = testArrays.length; i < l; ++i)
                 testArray(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);
                     InspectorTest.assertTrue(0 <= index && index <= array.length, "index is within bounds");
                     InspectorTest.assertTrue(index === 0 || array[index - 1] < value, "array[index - 1] < value");
                     InspectorTest.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);
                     InspectorTest.assertTrue(0 <= index && index <= array.length, "index is within bounds");
                     InspectorTest.assertTrue(index === 0 || array[index - 1] <= value, "array[index - 1] <= value");
                     InspectorTest.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 qselectTest(next)
         {
             var testArrays = [
                 [],
                 [0],
                 [0, 0, 0, 0, 0, 0, 0, 0],
                 [4, 3, 2, 1],
                 [1, 2, 3, 4, 5],
                 [-1, 3, 2, 7, 7, 7, 10, 12, 3, 4, -1, 2]
             ];

             function testArray(array)
             {
                 function compare(a, b)
                 {
                     return a - b;
                 }
                 var sorted = array.slice(0).sort(compare);

                 var reference = {
                     min: sorted[0],
                     median: sorted[Math.floor(sorted.length / 2)],
                     max: sorted[sorted.length - 1]
                 }

                 var actual = {
                     min: array.slice(0).qselect(0),
                     median: array.slice(0).qselect(Math.floor(array.length / 2)),
                     max: array.slice(0).qselect(array.length - 1)
                 }
                 InspectorTest.addResult("Array: " + JSON.stringify(array));
                 InspectorTest.addResult("Reference: " + JSON.stringify(reference));
                 InspectorTest.addResult("Actual:    " + JSON.stringify(actual));
             }
             for (var i = 0, l = testArrays.length; i < l; ++i)
                 testArray(testArrays[i]);
             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)
                 {
                     InspectorTest.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);
                                 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)
                 InspectorTest.assertEquals(0, String.naturalOrderComparator(testArray[i], testArray[i]), "comparing equal strings");

             testArray.sort(String.naturalOrderComparator);
             InspectorTest.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)
                         InspectorTest.assertEquals(a, b, "zero diff");
                     else if (diff < 0)
                         InspectorTest.assertTrue(i < j);
                     else
                         InspectorTest.assertTrue(i > j);
                 }
             }
             next();
         },

         function stableSortPrimitiveTest(next)
         {
             InspectorTest.assertEquals("", [].stableSort().join(","));
             InspectorTest.assertEquals("1", [1].stableSort().join(","));
             InspectorTest.assertEquals("1,2", [2,1].stableSort().join(","));
             InspectorTest.assertEquals("1,1,1", [1,1,1].stableSort().join(","));
             InspectorTest.assertEquals("1,2,3,4", [1,2,3,4].stableSort().join(","));

             function defaultComparator(a, b)
             {
                 return a < b ? -1 : (a > b ? 1 : 0);
             }

             function strictNumberCmp(a, b)
             {
                 if (a !== b)
                     return false;
                 if (a)
                     return true;
                 return 1/a === 1/b; // Neg zero comparison.
             }

             // The following fails with standard Array.sort()
             var original = [0,-0,0,-0,-0,-0,0,0,0,-0,0,-0,-0,-0,0,0];
             var sorted = original.slice(0).stableSort(defaultComparator);
             for (var i = 0; i < original.length; ++i)
                 InspectorTest.assertTrue(strictNumberCmp(original[i], sorted[i]), "Sorting negative zeros");

             // Test sorted and backward-sorted arrays.
             var identity = [];
             var reverse = [];
             for (var i = 0; i < 100; ++i) {
                 identity[i] = i;
                 reverse[i] = -i;
             }
             identity.stableSort(defaultComparator);
             reverse.stableSort(defaultComparator);
             for (var i = 1; i < identity.length; ++i) {
                 InspectorTest.assertTrue(identity[i - 1] < identity[i], "identity");
                 InspectorTest.assertTrue(reverse[i - 1] < reverse[i], "reverse");
             }

             next();
         },

         function stableSortTest(next)
         {
             function Pair(key1, key2)
             {
                 this.key1 = key1;
                 this.key2 = key2;
             }
             Pair.prototype.toString = function() {
                 return "Pair(" + this.key1 + ", " + this.key2 + ")";
             }

             var testArray = [
                 new Pair(1, 1),
                 new Pair(3, 31),
                 new Pair(3, 30),
                 new Pair(5, 55),
                 new Pair(5, 54),
                 new Pair(5, 57),
                 new Pair(4, 47),
                 new Pair(4, 46),
                 new Pair(4, 45),
                 new Pair(5, 52),
                 new Pair(5, 59),
                 new Pair(3, 37),
                 new Pair(3, 38),
                 new Pair(5, -58),
                 new Pair(5, 58),
                 new Pair(4, 41),
                 new Pair(4, 42),
                 new Pair(4, 43),
                 new Pair(3, 33),
                 new Pair(3, 32),
                 new Pair(9, 9),
             ];

             var testArrayKey2Values = [];
             for (var i = 0, n = testArray.length; i < n; ++i) {
                 var value = testArray[i].key2;
                 InspectorTest.assertTrue(testArrayKey2Values.indexOf(value) === -1, "FAIL: key2 values should be unique");
                 testArrayKey2Values.push(value);
             }

             function comparator(a, b)
             {
                 return a.key1 - b.key1;
             }
             testArray.stableSort(comparator);
             InspectorTest.addResult("Stable sort result:\n" + testArray.join("\n"));

             function assertHelper(condition, message, i, a, b)
             {
                 InspectorTest.assertTrue(condition, "FAIL: " + message + " at index " + i + ": " + a + " < " + b);
             }

             for (var i = 1, n = testArray.length; i < n; ++i) {
                 var a = testArray[i - 1];
                 var b = testArray[i];
                 assertHelper(a.key1 <= b.key1, "primary key order", i, a, b);
                 if (a.key1 !== b.key1)
                     continue;
                 var key2IndexA = testArrayKey2Values.indexOf(a.key2);
                 InspectorTest.assertTrue(key2IndexA !== -1);
                 var key2IndexB = testArrayKey2Values.indexOf(b.key2);
                 InspectorTest.assertTrue(key2IndexB !== -1);
                 assertHelper(key2IndexA < key2IndexB, "stable order", i, a, b);
             }
             next();
         },

         function stringHashTest(next)
         {
             var stringA = " ".repeat(10000);
             var stringB = stringA + " ";
             var hashA = String.hashCode(stringA);
             InspectorTest.assertTrue(hashA !== String.hashCode(stringB));
             InspectorTest.assertTrue(isFinite(hashA));
             InspectorTest.assertTrue(hashA + 1 !== hashA);
             next();
         },

         function stringTrimURLTest(next)
         {
             var baseURLDomain = "www.chromium.org";
             var testArray = [
                 "http://www.chromium.org/foo/bar", "/foo/bar",
                 "https://www.CHromium.ORG/BAZ/zoo", "/BAZ/zoo",
                 "https://example.com/foo[]", "example.com/foo[]",
             ];
             for (var i = 0; i < testArray.length; i += 2) {
                 var url = testArray[i];
                 var expected = testArray[i + 1];
                 InspectorTest.assertEquals(expected, url.trimURL(baseURLDomain), url);
             }
             next();
         },

         function stringToBase64Test(next)
         {
             var testArray = [
                 "", "",
                 "a", "YQ==",
                 "bc", "YmM=",
                 "def", "ZGVm",
                 "ghij", "Z2hpag==",
                 "klmno", "a2xtbm8=",
                 "pqrstu", "cHFyc3R1",
                 String.fromCharCode(0x444, 0x5555, 0x66666, 0x777777), "0YTllZXmmabnnbc="
             ];
             for (var i = 0; i < testArray.length; i += 2) {
                 var string = testArray[i];
                 var encodedString = testArray[i + 1];
                 InspectorTest.assertEquals(encodedString, string.toBase64());
             }
             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);
                     InspectorTest.addResult(trimmed);
                     InspectorTest.assertTrue(trimmed.length <= maxLength);
                 }
             }
             next();
         }
     ]);
 }

 </script>
 </head>

 <body onload="runTest()">
 <p>
 This test checks Web Inspector utilities.
 </p>

 </body>
 </html>
	<html>
	<head>
	<script src="../../http/tests/inspector/inspector-test.js"></script>
	<script>

	function test()
	{
	InspectorTest.runTestSuite([
	function remove(next)
	{
	var testArrays = [
	[], [], [],
	[1], [1], [1],
	[1, 2, 3, 4, 5, 4, 3, 2, 1], [1, 3, 4, 5, 4, 3, 2, 1], [1, 3, 4, 5, 4, 3, 1],
	[2, 2, 2, 2, 2], [2, 2, 2, 2], [],
	[2, 2, 2, 1, 2, 2, 3, 2], [2, 2, 1, 2, 2, 3, 2], [1, 3]
	];
	for (var i = 0; i < testArrays.length; i += 3) {
	var actual = testArrays[i].slice(0);
	var expected = testArrays[i + 1];
	actual.remove(2, true);
	InspectorTest.assertEquals(JSON.stringify(expected), JSON.stringify(actual), "remove(2, true) passed");
	actual = testArrays[i].slice(0);
	expected = testArrays[i + 2];
	actual.remove(2, false);
	InspectorTest.assertEquals(JSON.stringify(expected), JSON.stringify(actual), "remove(2, false) passed");
	}
	next();
	},

	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];
	expectedCount = checkOperation(count(a, value), count(b, value));
	actualCount = count(actual, value);
	InspectorTest.assertEquals(expectedCount, actualCount,
	"Incorrect result for value: " + value + " at [" + a + "] " + opName + " [" + b + "] -> [" + actual + "]");
	}
	InspectorTest.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 binaryIndexOfTest(next)
	{
	var testArrays = [
	[],
	[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)
	{
	function comparator(a, b)
	{
	return a < b ? -1 : (a > b ? 1 : 0);
	}

	for (var i = -100; i <= 100; ++i) {
	var reference = array.indexOf(i);
	var actual = array.binaryIndexOf(i, comparator);
	InspectorTest.assertEquals(reference, actual, "binaryIndexOf");
	}
	return true;
	}

	for (var i = 0, l = testArrays.length; i < l; ++i)
	testArray(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);
	InspectorTest.assertTrue(0 <= index && index <= array.length, "index is within bounds");
	InspectorTest.assertTrue(index === 0 \|\| array[index - 1] < value, "array[index - 1] < value");
	InspectorTest.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);
	InspectorTest.assertTrue(0 <= index && index <= array.length, "index is within bounds");
	InspectorTest.assertTrue(index === 0 \|\| array[index - 1] <= value, "array[index - 1] <= value");
	InspectorTest.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 qselectTest(next)
	{
	var testArrays = [
	[],
	[0],
	[0, 0, 0, 0, 0, 0, 0, 0],
	[4, 3, 2, 1],
	[1, 2, 3, 4, 5],
	[-1, 3, 2, 7, 7, 7, 10, 12, 3, 4, -1, 2]
	];

	function testArray(array)
	{
	function compare(a, b)
	{
	return a - b;
	}
	var sorted = array.slice(0).sort(compare);

	var reference = {
	min: sorted[0],
	median: sorted[Math.floor(sorted.length / 2)],
	max: sorted[sorted.length - 1]
	}

	var actual = {
	min: array.slice(0).qselect(0),
	median: array.slice(0).qselect(Math.floor(array.length / 2)),
	max: array.slice(0).qselect(array.length - 1)
	}
	InspectorTest.addResult("Array: " + JSON.stringify(array));
	InspectorTest.addResult("Reference: " + JSON.stringify(reference));
	InspectorTest.addResult("Actual: " + JSON.stringify(actual));
	}
	for (var i = 0, l = testArrays.length; i < l; ++i)
	testArray(testArrays[i]);
	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)
	{
	InspectorTest.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);
	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)
	InspectorTest.assertEquals(0, String.naturalOrderComparator(testArray[i], testArray[i]), "comparing equal strings");

	testArray.sort(String.naturalOrderComparator);
	InspectorTest.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)
	InspectorTest.assertEquals(a, b, "zero diff");
	else if (diff < 0)
	InspectorTest.assertTrue(i < j);
	else
	InspectorTest.assertTrue(i > j);
	}
	}
	next();
	},

	function stableSortPrimitiveTest(next)
	{
	InspectorTest.assertEquals("", [].stableSort().join(","));
	InspectorTest.assertEquals("1", [1].stableSort().join(","));
	InspectorTest.assertEquals("1,2", [2,1].stableSort().join(","));
	InspectorTest.assertEquals("1,1,1", [1,1,1].stableSort().join(","));
	InspectorTest.assertEquals("1,2,3,4", [1,2,3,4].stableSort().join(","));

	function defaultComparator(a, b)
	{
	return a < b ? -1 : (a > b ? 1 : 0);
	}

	function strictNumberCmp(a, b)
	{
	if (a !== b)
	return false;
	if (a)
	return true;
	return 1/a === 1/b; // Neg zero comparison.
	}

	// The following fails with standard Array.sort()
	var original = [0,-0,0,-0,-0,-0,0,0,0,-0,0,-0,-0,-0,0,0];
	var sorted = original.slice(0).stableSort(defaultComparator);
	for (var i = 0; i < original.length; ++i)
	InspectorTest.assertTrue(strictNumberCmp(original[i], sorted[i]), "Sorting negative zeros");

	// Test sorted and backward-sorted arrays.
	var identity = [];
	var reverse = [];
	for (var i = 0; i < 100; ++i) {
	identity[i] = i;
	reverse[i] = -i;
	}
	identity.stableSort(defaultComparator);
	reverse.stableSort(defaultComparator);
	for (var i = 1; i < identity.length; ++i) {
	InspectorTest.assertTrue(identity[i - 1] < identity[i], "identity");
	InspectorTest.assertTrue(reverse[i - 1] < reverse[i], "reverse");
	}

	next();
	},

	function stableSortTest(next)
	{
	function Pair(key1, key2)
	{
	this.key1 = key1;
	this.key2 = key2;
	}
	Pair.prototype.toString = function() {
	return "Pair(" + this.key1 + ", " + this.key2 + ")";
	}

	var testArray = [
	new Pair(1, 1),
	new Pair(3, 31),
	new Pair(3, 30),
	new Pair(5, 55),
	new Pair(5, 54),
	new Pair(5, 57),
	new Pair(4, 47),
	new Pair(4, 46),
	new Pair(4, 45),
	new Pair(5, 52),
	new Pair(5, 59),
	new Pair(3, 37),
	new Pair(3, 38),
	new Pair(5, -58),
	new Pair(5, 58),
	new Pair(4, 41),
	new Pair(4, 42),
	new Pair(4, 43),
	new Pair(3, 33),
	new Pair(3, 32),
	new Pair(9, 9),
	];

	var testArrayKey2Values = [];
	for (var i = 0, n = testArray.length; i < n; ++i) {
	var value = testArray[i].key2;
	InspectorTest.assertTrue(testArrayKey2Values.indexOf(value) === -1, "FAIL: key2 values should be unique");
	testArrayKey2Values.push(value);
	}

	function comparator(a, b)
	{
	return a.key1 - b.key1;
	}
	testArray.stableSort(comparator);
	InspectorTest.addResult("Stable sort result:\n" + testArray.join("\n"));

	function assertHelper(condition, message, i, a, b)
	{
	InspectorTest.assertTrue(condition, "FAIL: " + message + " at index " + i + ": " + a + " < " + b);
	}

	for (var i = 1, n = testArray.length; i < n; ++i) {
	var a = testArray[i - 1];
	var b = testArray[i];
	assertHelper(a.key1 <= b.key1, "primary key order", i, a, b);
	if (a.key1 !== b.key1)
	continue;
	var key2IndexA = testArrayKey2Values.indexOf(a.key2);
	InspectorTest.assertTrue(key2IndexA !== -1);
	var key2IndexB = testArrayKey2Values.indexOf(b.key2);
	InspectorTest.assertTrue(key2IndexB !== -1);
	assertHelper(key2IndexA < key2IndexB, "stable order", i, a, b);
	}
	next();
	},

	function stringHashTest(next)
	{
	var stringA = " ".repeat(10000);
	var stringB = stringA + " ";
	var hashA = String.hashCode(stringA);
	InspectorTest.assertTrue(hashA !== String.hashCode(stringB));
	InspectorTest.assertTrue(isFinite(hashA));
	InspectorTest.assertTrue(hashA + 1 !== hashA);
	next();
	},

	function stringTrimURLTest(next)
	{
	var baseURLDomain = "www.chromium.org";
	var testArray = [
	"http://www.chromium.org/foo/bar", "/foo/bar",
	"https://www.CHromium.ORG/BAZ/zoo", "/BAZ/zoo",
	"https://example.com/foo[]", "example.com/foo[]",
	];
	for (var i = 0; i < testArray.length; i += 2) {
	var url = testArray[i];
	var expected = testArray[i + 1];
	InspectorTest.assertEquals(expected, url.trimURL(baseURLDomain), url);
	}
	next();
	},

	function stringToBase64Test(next)
	{
	var testArray = [
	"", "",
	"a", "YQ==",
	"bc", "YmM=",
	"def", "ZGVm",
	"ghij", "Z2hpag==",
	"klmno", "a2xtbm8=",
	"pqrstu", "cHFyc3R1",
	String.fromCharCode(0x444, 0x5555, 0x66666, 0x777777), "0YTllZXmmabnnbc="
	];
	for (var i = 0; i < testArray.length; i += 2) {
	var string = testArray[i];
	var encodedString = testArray[i + 1];
	InspectorTest.assertEquals(encodedString, string.toBase64());
	}
	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);
	InspectorTest.addResult(trimmed);
	InspectorTest.assertTrue(trimmed.length <= maxLength);
	}
	}
	next();
	}
	]);
	}

	</script>
	</head>

	<body onload="runTest()">
	<p>
	This test checks Web Inspector utilities.
	</p>

	</body>
	</html>