Removed long-running array sort test.

test/mjsunit/array-sort.js

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 135 matching lines @@
 // in the array.
 function TestArraySortingWithUnsoundComparisonFunction() {
   var a = [ 3, void 0, 2 ];
   a.sort(function(x, y) { return 1; });
   a.sort();
   assertArrayEquals([ 2, 3, void 0 ], a);
 }
 
 TestArraySortingWithUnsoundComparisonFunction();
 
+
 function TestSparseNonArraySorting(length) {
   assertTrue(length > 101);
   var obj = {length: length};
   obj[0] = 42;
   obj[10] = 37;
   obj[100] = undefined;
   obj[length - 1] = null;
   Array.prototype.sort.call(obj);
   assertEquals(length, obj.length, "objsort length unaffected");
   assertEquals(37, obj[0], "objsort smallest number");
   assertEquals(42, obj[1], "objsort largest number");
   assertEquals(null, obj[2], "objsort null");
   assertEquals(undefined, obj[3], "objsort undefined");
   assertTrue(3 in obj, "objsort undefined retained");
   assertFalse(4 in obj, "objsort non-existing retained");
 }
 
 TestSparseNonArraySorting(5000);
 TestSparseNonArraySorting(500000);
 TestSparseNonArraySorting(Math.pow(2, 31) + 1);
 
+
 function TestArrayLongerLength(length) {
   var x = new Array(4);
   x[0] = 42;
   x[2] = 37;
   x.length = length;
   Array.prototype.sort.call(x);
   assertEquals(length, x.length, "longlength length");
   assertEquals(37, x[0], "longlength first");
   assertEquals(42, x[1], "longlength second");
   assertFalse(2 in x,"longlength third");
 }
 
 TestArrayLongerLength(4);
 TestArrayLongerLength(10);
 TestArrayLongerLength(1000);
 TestArrayLongerLength(500000);
 TestArrayLongerLength(Math.pow(2,32) - 1);
 
+
 function TestNonArrayLongerLength(length) {
   var x = {};
   x[0] = 42;
   x[2] = 37;
   x.length = length;
   Array.prototype.sort.call(x);
   assertEquals(length, x.length, "longlength length");
   assertEquals(37, x[0], "longlength first");
   assertEquals(42, x[1], "longlength second");
   assertFalse(2 in x,"longlength third");
@@ skipping 46 matching lines @@
 
   for (var i = 0; i < 5; i++) {
     x[i * 2 * scale] = 2 * (4 - i);
     y[(i * 2 + 1) * scale] = 2 * (4 - i) + 1;
   }
 
   var name = "SparseSortInherit(" + scale + ")-";
 
   Array.prototype.sort.call(y);
 
-  assertEquals(length, y.length, name+"length");
+  assertEquals(length, y.length, name +"length");

[William Hesse, 2009/05/04 08:55:21]

name + "length" ?  Spaces on both sides of operator.

 
   for (var i = 0; i < 10; i++) {
     assertTrue(y.hasOwnProperty(i), name + "hasvalue" + i);
     assertEquals(i, y[i], name + "value" + i);
   }
   for (var i = 10; i < length; i++) {
-    assertEquals(x.hasOwnProperty(i), y.hasOwnProperty(i), name+"hasundef"+i);
+    assertEquals(x.hasOwnProperty(i), y.hasOwnProperty(i), 

[William Hesse, 2009/05/04 08:55:21]

Remove space at end of line.

+                 name + "hasundef" + i);
     assertEquals(undefined, y[i], name+"undefined"+i);
     if (x.hasOwnProperty(i)) {
-      assertTrue(0 == i % (2 * scale), name+"new_x"+i);
+      assertTrue(0 == i % (2 * scale), name + "new_x" + i);
     }
   }
 }
 
 TestSparseInheritedElementSort(10);
 TestSparseInheritedElementSort(100);
 TestSparseInheritedElementSort(1000);
-TestSparseInheritedElementSort(10000);
 
 function TestSpecialCasesInheritedElementSort() {
   
   var x = {
     1:"d1",
     2:"c1",
     3:"b1",
     4: undefined,
     __proto__: {
       length: 10000,
@@ skipping 16 matching lines @@
     }
   };
   Array.prototype.sort.call(x);
   
   var name = "SpecialInherit-";
   
   assertEquals(10000, x.length, name + "length");
   var sorted = ["a2", "a3", "b1", "b2", "c1", "c2", "d1", "d2", "e3", 
                 undefined, undefined, undefined];
   for (var i = 0; i < sorted.length; i++) {
-    assertTrue(x[0], x.hasOwnProperty(i) + "has" + i)
+    assertTrue(x.hasOwnProperty(i), name + "has" + i)
     assertEquals(sorted[i], x[i], name + i);
   }
   assertFalse(x.hasOwnProperty(sorted.length), name + "haspost");
   assertFalse(sorted.length in x, name + "haspost2");
-  assertEquals(undefined, x[12000], name + "XX12000");
   
   assertTrue(x.hasOwnProperty(10), name + "hasundefined10");
   assertEquals(undefined, x[10], name + "undefined10");
   assertTrue(x.hasOwnProperty(100), name + "hasundefined100");
   assertEquals(undefined, x[100], name + "undefined100");
   assertTrue(x.hasOwnProperty(1000), name + "hasundefined1000");
   assertEquals(undefined, x[1000], name + "undefined1000");
   assertTrue(x.hasOwnProperty(2000), name + "hasundefined2000");
   assertEquals(undefined, x[2000], name + "undefined2000");
   assertTrue(x.hasOwnProperty(8000), name + "hasundefined8000");
   assertEquals(undefined, x[8000], name + "undefined8000");
   
-  assertFalse(x.hasOwnProperty(11), name + "hasundefined11");

[William Hesse, 2009/05/04 08:55:21]

Is what this test is meant to test still tested?

[Lasse Reichstein, 2009/05/04 09:07:07]

Yes. It's the sorted.length test above (11 should have been 12).

-  assertEquals(undefined, x[11], name + "undefined11");
-  
   assertFalse(x.hasOwnProperty(12000), name + "has12000");
   assertEquals("XX", x[12000], name + "XX12000");
 
-}
+}
+
+TestSpecialCasesInheritedElementSort();
+