More thorough tests of sorting integers in lexicographic order.

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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// Flags: --allow-natives-syntax
+
 // Test array sort.
 
 // Test counter-intuitive default number sorting.
 function TestNumberSort() {
   var a = [ 200, 45, 7 ];
 
   // Default sort converts each element to string and orders
   // lexicographically.
   a.sort();
   assertArrayEquals([ 200, 45, 7 ], a);
   // Sort numbers by value using a compare functions.
   a.sort(function(x, y) { return x - y; });
   assertArrayEquals([ 7, 45, 200 ], a);
 
   // Default sort on negative numbers.
   a = [-12345,-123,-1234,-123456];
   a.sort();
   assertArrayEquals([-123,-1234,-12345,-123456], a);
 
   // Default sort on negative and non-negative numbers.
   a = [123456,0,-12345,-123,123,1234,-1234,0,12345,-123456];
   a.sort();
   assertArrayEquals([-123,-1234,-12345,-123456,0,0,123,1234,12345,123456], a);
 
+  // Tricky case avoiding integer overflow in Runtime_SmiLexicographicCompare.
+  a = [9, 1000000000].sort();
+  assertArrayEquals([1000000000, 9], a);
+  a = [1000000000, 1].sort();
+  assertArrayEquals([1, 1000000000], a);
+  a = [1000000000, 0].sort();
+  assertArrayEquals([0, 1000000000], a);
+
+  // One string is a prefix of the other.
+  a = [1230, 123].sort();
+  assertArrayEquals([123, 1230], a);
+  a = [1231, 123].sort();
+  assertArrayEquals([123, 1231], a);
+
   // Default sort on Smis and non-Smis.
   a = [1000000000, 10000000000, 1000000001, -1000000000, -10000000000, -1000000001];
   a.sort();
   assertArrayEquals([-1000000000, -10000000000, -1000000001, 1000000000, 10000000000, 1000000001], a);
+
+
+  for (var xb = 1; xb <= 1000 * 1000 * 1000; xb *= 10) {
+    for (var xf = 0; xf <= 9; xf++) {
+      for (var xo = -1; xo <= 1; xo++) {
+        for (var yb = 1; yb <= 1000 * 1000 * 1000; yb *= 10) {
+          for (var yf = 0; yf <= 9; yf++) {
+            for (var yo = -1; yo <= 1; yo++) {
+              var x = xb * xf + xo;
+              var y = yb * yf + yo;
+              if (!%_IsSmi(x)) continue;
+              if (!%_IsSmi(y)) continue;
+              var lex = %SmiLexicographicCompare(x, y);
+              if (lex < 0) lex = -1;
+              if (lex > 0) lex = 1;
+              assertEquals(lex, (x == y) ? 0 : ((x + "") < (y + "") ? -1 : 1), x + " < " + y);
+            }
+          }
+        }
+      }
+    }
+  }
 }
 
 TestNumberSort();
 
 
 // Test lexicographical string sorting.
 function TestStringSort() {
   var a = [ "cc", "c", "aa", "a", "bb", "b", "ab", "ac" ];
   a.sort();
   assertArrayEquals([ "a", "aa", "ab", "ac", "b", "bb", "c", "cc" ], a);
 }
 
 TestStringSort();
 
 
 // Test object sorting.  Calls toString on each element and sorts
 // lexicographically.
 function TestObjectSort() {
   var obj0 = { toString: function() { return "a"; } };
   var obj1 = { toString: function() { return "b"; } };
   var obj2 = { toString: function() { return "c"; } };
   var a = [ obj2, obj0, obj1 ];
   a.sort();
   assertArrayEquals([ obj0, obj1, obj2 ], a);
 }
 
 TestObjectSort();