// Copyright 2010 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// 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);

  // Other cases are tested implicitly in TestSmiLexicographicCompare.
}

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();

// Test array sorting with holes in the array.
function TestArraySortingWithHoles() {
  var a = [];
  a[4] = "18";
  a[10] = "12";
  a.sort();
  assertEquals(11, a.length);
  assertEquals("12", a[0]);
  assertEquals("18", a[1]);
}

TestArraySortingWithHoles();

// Test array sorting with undefined elemeents in the array.
function TestArraySortingWithUndefined() {
  var a = [ 3, void 0, 2 ];
  a.sort();
  assertArrayEquals([ 2, 3, void 0 ], a);
}

TestArraySortingWithUndefined();

// Test that sorting using an unsound comparison function still gives a
// sensible result, i.e. it terminates without error and retains the elements
// 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(1000);
TestSparseNonArraySorting(5000);


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(5000);


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");
}

TestNonArrayLongerLength(4);
TestNonArrayLongerLength(10);
TestNonArrayLongerLength(1000);
TestNonArrayLongerLength(5000);


function TestNonArrayWithAccessors() {
  // Regression test for issue 346, more info at URL
  // http://code.google.com/p/v8/issues/detail?id=346
  // Reported by nth10sd, test based on this report.
  var x = {};
  x[0] = 42;
  x.__defineGetter__("1", function(){return this.foo;});
  x.__defineSetter__("1", function(val){this.foo = val;});
  x[1] = 49
  x[3] = 37;
  x.length = 4;
  Array.prototype.sort.call(x);
  // Behavior of sort with accessors is undefined.  This accessor is
  // well-behaved (acts like a normal property), so it should work.
  assertEquals(4, x.length, "sortaccessors length");
  assertEquals(37, x[0], "sortaccessors first");
  assertEquals(42, x[1], "sortaccessors second");
  assertEquals(49, x[2], "sortaccessors third")
  assertFalse(3 in x, "sortaccessors fourth");
}

TestNonArrayWithAccessors();


function TestInheritedElementSort(depth) {
  var length = depth * 2 + 3;
  var obj = {length: length};
  obj[depth * 2 + 1] = 0;
  for (var i = 0; i < depth; i++) {
    var newObj = {};
    newObj.__proto__ = obj;
    obj[i] = undefined;
    obj[i + depth + 1] = depth - i;
    obj = newObj;
  }
  // expected (inherited) object: [undef1,...undefdepth,hole,1,...,depth,0,hole]

  Array.prototype.sort.call(obj, function(a,b) { return (b < a) - (a < b); });
  // expected result: [0,1,...,depth,undef1,...,undefdepth,hole]
  var name = "SortInherit("+depth+")-";

  assertEquals(length, obj.length, name+"length");
  for (var i = 0; i <= depth; i++) {
    assertTrue(obj.hasOwnProperty(i), name + "hasvalue" + i);
    assertEquals(i, obj[i], name + "value" + i);
  }
  for (var i = depth + 1; i < depth * 2 + 1; i++) {
    assertEquals(undefined, obj[i], name + "undefined" + i);
    assertTrue(obj.hasOwnProperty(i), name + "hasundefined" + i);
  }
  assertFalse(obj.hasOwnProperty(depth * 2 + 1), name + "hashole")
  assertFalse(obj.hasOwnProperty(depth * 2 + 2), name + "hashole");
}

TestInheritedElementSort(5);
TestInheritedElementSort(15);

function TestSparseInheritedElementSort(scale) {
  var length = scale * 10;
  var x = {length: length};
  var y = {};
  y.__proto__ = x;

  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");

  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++) {
    assertFalse(y.hasOwnProperty(i), name + "noundef" + i);

    if (x.hasOwnProperty(i)) {
      assertTrue(0 == i % (2 * scale), name + "new_x" + i);
    }
  }
}

TestSparseInheritedElementSort(10);
TestSparseInheritedElementSort(100);
TestSparseInheritedElementSort(1000);

function TestSpecialCasesInheritedElementSort() {

  var x = {
    1:"d1",
    2:"c1",
    3:"b1",
    4: undefined,
    __proto__: {
      length: 10000,
      1: "e2",
      10: "a2",
      100: "b2",
      1000: "c2",
      2000: undefined,
      8000: "d2",
      12000: "XX",
      __proto__: {
        0: "e3",
        1: "d3",
        2: "c3",
        3: "b3",
        4: "f3",
        5: "a3",
        6: undefined,
      }
    }
  };
  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.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");
  assertTrue(x.hasOwnProperty(10), name + "hasundefined10");
  assertEquals(undefined, x[10], name + "undefined10");
  assertFalse(x.hasOwnProperty(100), name + "hasno100");
  assertEquals("b2", x[100], "inherits100");
  assertFalse(x.hasOwnProperty(1000), name + "hasno1000");
  assertEquals("c2", x[1000], "inherits1000");
  assertFalse(x.hasOwnProperty(2000), name + "hasno2000");
  assertEquals(undefined, x[2000], "inherits2000");
  assertFalse(x.hasOwnProperty(8000), name + "hasno8000");
  assertEquals("d2", x[8000], "inherits8000");
  assertFalse(x.hasOwnProperty(12000), name + "has12000");
  assertEquals("XX", x[12000], name + "XX12000");
}

TestSpecialCasesInheritedElementSort();

// Test that sort calls compare function with global object as receiver,
// and with only elements of the array as arguments.
function o(v) {
  return {__proto__: o.prototype, val: v};
}
var arr = [o(1), o(2), o(4), o(8), o(16), o(32), o(64), o(128), o(256), o(-0)];
var global = this;
function cmpTest(a, b) {
  assertEquals(global, this);
  assertTrue(a instanceof o);
  assertTrue(b instanceof o);
  return a.val - b.val;
}
arr.sort(cmpTest);

function TestSortDoesNotDependOnObjectPrototypeHasOwnProperty() {
  Array.prototype.sort.call({
    __proto__: { hasOwnProperty: null, 0: 1 },
    length: 5
  });

  var arr = new Array(2);
  Object.defineProperty(arr, 0, { get: function() {}, set: function() {} });
  arr.hasOwnProperty = null;
  arr.sort();
}

TestSortDoesNotDependOnObjectPrototypeHasOwnProperty();

function TestSortDoesNotDependOnArrayPrototypePush() {
  // InsertionSort is used for arrays which length <= 22
  var arr = [];
  for (var i = 0; i < 22; i++) arr[i] = {};
  Array.prototype.push = function() {
    fail('Should not call push');
  };
  arr.sort();

  // Quicksort is used for arrays which length > 22
  // Arrays which length > 1000 guarantee GetThirdIndex is executed
  arr = [];
  for (var i = 0; i < 2000; ++i) arr[i] = {};
  arr.sort();
}

TestSortDoesNotDependOnArrayPrototypePush();

function TestSortDoesNotDependOnArrayPrototypeSort() {
  var arr = [];
  for (var i = 0; i < 2000; i++) arr[i] = {};
  var sortfn = Array.prototype.sort;
  Array.prototype.sort = function() {
    fail('Should not call sort');
  };
  sortfn.call(arr);
  // Restore for the next test
  Array.prototype.sort = sortfn;
}

TestSortDoesNotDependOnArrayPrototypeSort();

function TestSortToObject() {
  Number.prototype[0] = 5;
  Number.prototype[1] = 4;
  Number.prototype.length = 2;
  x = new Number(0);
  assertEquals(0, Number(Array.prototype.sort.call(x)));
  assertEquals(4, x[0]);
  assertEquals(5, x[1]);
  assertArrayEquals(["0", "1"], Object.getOwnPropertyNames(x));
  // The following would throw if ToObject weren't called.
  assertEquals(0, Number(Array.prototype.sort.call(0)));
}
TestSortToObject();

function TestSortOnProxy() {
  {
    var p = new Proxy([2,1,3], {});
    assertEquals([1,2,3], p.sort());
  }

  {
    function f() { return arguments };
    var a = f(2,1,3);
    a.__proto__ = new Proxy({}, {});
    assertEquals([1,2,3], [...(Array.prototype.sort.apply(a))]);
  }
}
TestSortOnProxy();

function TestSortOnNonExtensible() {
  {
    var arr = [1,,2];
    Object.preventExtensions(arr);
    assertThrows(() => arr.sort(), TypeError);
    assertEquals(arr, [1,,2]);
  }
  {
    var arr = [1,,undefined];
    Object.preventExtensions(arr);
    assertThrows(() => arr.sort(), TypeError);
    assertFalse(arr.hasOwnProperty(1));
    assertEquals(arr, [1,,undefined]);
  }
  {
    var arr = [1,undefined,2];
    Object.preventExtensions(arr);
    arr.sort();
    assertEquals(arr, [1,2,undefined]);
  }
}
TestSortOnNonExtensible();

function TestSortOnTypedArray() {
  var array = new Int8Array([10,9,8,7,6,5,4,3,2,1]);
  Object.defineProperty(array, "length", {value: 5});
  Array.prototype.sort.call(array);
  assertEquals(array, new Int8Array([10,6,7,8,9,5,4,3,2,1]));

  var array = new Int8Array([10,9,8,7,6,5,4,3,2,1]);
  Object.defineProperty(array, "length", {value: 15});
  Array.prototype.sort.call(array);
  assertEquals(array, new Int8Array([1,10,2,3,4,5,6,7,8,9]));
}
TestSortOnTypedArray();


// Test special prototypes
(function testSortSpecialPrototypes() {
  function test(proto, length, expected) {
    var result = {
       length: length,
       __proto__: proto,
     };
    Array.prototype.sort.call(result);
    assertEquals(expected.length, result.length, "result.length");
    for (var i = 0; i<expected.length; i++) {
      assertEquals(expected[i], result[i], "result["+i+"]");
    }
  }

  (function fast() {
    // Fast elements, non-empty
    test(arguments, 0, []);
    test(arguments, 1, [2]);
    test(arguments, 2, [1, 2]);
    test(arguments, 4, [1, 2, 3, 4]);
    delete arguments[0]
    // sort copies down the properties to the receiver, hence result[1]
    // is read on the arguments through the hole on the receiver.
    test(arguments, 2, [1, 1]);
    arguments[0] = undefined;
    test(arguments, 2, [1, undefined]);
  })(2, 1, 4, 3);

  (function fastSloppy(a) {
    // Fast sloppy
    test(arguments, 0, []);
    test(arguments, 1, [2]);
    test(arguments, 2, [1, 2]);
    delete arguments[0]
    test(arguments, 2, [1, 1]);
    arguments[0] = undefined;
    test(arguments, 2, [1, undefined]);
  })(2, 1);

  (function fastEmpty() {
    test(arguments, 0, []);
    test(arguments, 1, [undefined]);
    test(arguments, 2, [undefined, undefined]);
  })();

  (function stringWrapper() {
    // cannot redefine string wrapper properties
    assertThrows(() => test(new String('cba'), 3, []), TypeError);
  })();

  (function typedArrys() {
    test(new Int32Array(0), 0, []);
    test(new Int32Array(1), 1, [0]);
    var array = new Int32Array(3);
    array[0] = 2;
    array[1] = 1;
    array[2] = 3;
    test(array, 1, [2]);
    test(array, 2, [1, 2]);
    test(array, 3, [1, 2, 3]);
  })()

})();

assertThrows(() => {
  Array.prototype.sort.call(undefined);
}, TypeError);

// This test ensures that RemoveArrayHoles does not shadow indices in the
// prototype chain. There are multiple code paths, we force both and check that
// they have the same behavior.
function TestPrototypeHoles() {
  function test(forceGenericFallback) {
    let proto2 = {
      7: 27,
    };

    let proto1 = {
      __proto__: proto2,
      8: 18,
      9: 19,
    };

    let xs = {
      __proto__: proto1,
      length: 10,
      7: 7,
      8: 8,
      9: 9,
    };

    if (forceGenericFallback) {
      Object.defineProperty(xs, "6", {
        get: () => this.foo,
        set: (val) => this.foo = val
      });
    }
    xs[6] = 6;

    Array.prototype.sort.call(xs, (a, b) => a - b);

    assertEquals(10, xs.length);
    assertEquals(6, xs[0]);
    assertEquals(7, xs[1]);
    assertEquals(8, xs[2]);
    assertEquals(9, xs[3]);

    // Index 7,8,9 will get the prototype values.
    assertFalse(xs.hasOwnProperty(7));
    assertEquals(27, xs[7]);

    assertFalse(xs.hasOwnProperty(8));
    assertEquals(18, xs[8]);

    assertFalse(xs.hasOwnProperty(9));
    assertEquals(19, xs[9]);
  }

  test(false);
  // Expect a TypeError when trying to delete the accessor.
  assertThrows(() => test(true), TypeError);
}
TestPrototypeHoles();

// The following test ensures that [[Delete]] is called and it throws.
function TestArrayWithAccessorThrowsOnDelete() {
  let array = [5, 4, 1, /*hole*/, /*hole*/];

  Object.defineProperty(array, '4', {
    get: () => array.foo,
    set: (val) => array.foo = val
  });
  assertThrows(() => array.sort((a, b) => a - b), TypeError);
}
TestArrayWithAccessorThrowsOnDelete();

// The following test ensures that elements on the prototype are also copied
// for JSArrays and not only JSObjects.
function TestArrayPrototypeHasElements() {
  let array = [1, 2, 3, 4, 5];
  for (let i = 0; i < array.length; i++) {
    delete array[i];
    Object.prototype[i] = 42;
  }

  let comparator_called = false;
  array.sort(function (a, b) {
    if (a === 42 || b === 42) {
      comparator_called = true;
    }
    return a - b;
  });

  assertTrue(comparator_called);
}
TestArrayPrototypeHasElements();

// The following Tests make sure that there is no crash when the element kind
// or the array length changes. Since comparison functions like this are not
// consistent, we do not have to make sure that the array is actually sorted
//
// The assertions for the element kinds are not there to ensure that a specific
// action causes a specific element kind change, but rather that we have most
// of the transitions covered.

function cmp_smaller(a, b) {
  if (a < b) return -1;
  if (b < a) return 1;
  return 0;
}

function create_cmpfn(transformfn) {
  let cmp_count = 0;
  return (a, b) => {
    ++cmp_count;
    if (cmp_count == 2) {
      transformfn();
    }

    return cmp_smaller(a, b);
  }
}

function HasPackedSmi(xs) {
  return %HasFastPackedElements(xs) && %HasSmiElements(xs);
}

function HasPackedDouble(xs) {
  return %HasFastPackedElements(xs) && %HasDoubleElements(xs);
}

function HasPackedObject(xs) {
  return %HasFastPackedElements(xs) && %HasObjectElements(xs);
}

function HasHoleySmi(xs) {
  return %HasHoleyElements(xs) && %HasSmiElements(xs);
}

function HasHoleyDouble(xs) {
  return %HasHoleyElements(xs) && %HasDoubleElements(xs);
}

function HasHoleyObject(xs) {
  return %HasHoleyElements(xs) && %HasObjectElements(xs);
}

function TestSortCmpPackedSmiToPackedDouble() {
  let xs = [2,1,4];

  assertTrue(HasPackedSmi(xs));
  xs.sort(create_cmpfn(() => xs[0] += 0.1));
  assertTrue(HasPackedDouble(xs));
}
TestSortCmpPackedSmiToPackedDouble();

function TestSortCmpPackedDoubleToPackedElement() {
  let xs = [2.1, 1.2, 4.4];

  assertTrue(HasPackedDouble(xs));
  xs.sort(create_cmpfn(() => xs[0] = 'a'));
  assertTrue(HasPackedObject(xs));
}
TestSortCmpPackedDoubleToPackedElement();

function TestSortCmpPackedElementToDictionary() {
  let xs = ['a', 'b', 'c'];

  assertTrue(HasPackedObject(xs));
  xs.sort(create_cmpfn(() => xs[%MaxSmi()] = 'd'));
  assertTrue(%HasDictionaryElements(xs));
}
TestSortCmpPackedElementToDictionary();

function TestSortCmpHoleySmiToHoleyDouble() {
  let xs = [2, 1, 4];
  xs[5] = 42;

  assertTrue(HasHoleySmi(xs));
  xs.sort(create_cmpfn(() => xs[0] += 0.1));
  assertTrue(HasHoleyDouble(xs));
}
TestSortCmpHoleySmiToHoleyDouble();

function TestSortCmpHoleyDoubleToHoleyElement() {
  let xs = [2.1, 1.2, 4];
  xs[5] = 42;

  assertTrue(HasHoleyDouble(xs));
  xs.sort(create_cmpfn(() => xs[0] = 'a'));
  assertTrue(HasHoleyObject(xs));
}
TestSortCmpHoleyDoubleToHoleyElement();

function TestSortCmpHoleyElementToDictionary() {
  let xs = ['b', 'a', 'd'];
  xs[5] = '42';

  assertTrue(HasHoleyObject(xs));
  xs.sort(create_cmpfn(() => xs[%MaxSmi()] = 'e'));
  assertTrue(%HasDictionaryElements(xs));
}
TestSortCmpHoleyElementToDictionary();

function TestSortCmpPackedSmiToHoleySmi() {
  let xs = [2, 1, 4];

  assertTrue(HasPackedSmi(xs));
  xs.sort(create_cmpfn(() => xs[10] = 42));
  assertTrue(HasHoleySmi(xs));
}
TestSortCmpPackedSmiToHoleySmi();

function TestSortCmpPackedDoubleToHoleyDouble() {
  let xs = [2.1, 1.2, 4];

  assertTrue(HasPackedDouble(xs));
  xs.sort(create_cmpfn(() => xs[10] = 42));
  assertTrue(HasHoleyDouble(xs));
}
TestSortCmpPackedDoubleToHoleyDouble();

function TestSortCmpPackedObjectToHoleyObject() {
  let xs = ['b', 'a', 'd'];

  assertTrue(HasPackedObject(xs));
  xs.sort(create_cmpfn(() => xs[10] = '42'));
  assertTrue(HasHoleyObject(xs));
}
TestSortCmpPackedObjectToHoleyObject();

function TestSortCmpPackedChangesLength() {
  let xs = [2, 1, 4];

  assertTrue(HasPackedSmi(xs));
  xs.sort(create_cmpfn(() => xs.length *= 2));
  assertTrue(HasHoleySmi(xs));
}
TestSortCmpPackedChangesLength();

function TestSortCmpPackedSetLengthToZero() {
  let xs = [2, 1, 4, 3];

  assertTrue(HasPackedSmi(xs));
  xs.sort(create_cmpfn(() => xs.length = 0));
  assertTrue(HasPackedSmi(xs));
}