From f988d2582ae20f002ebbfac6d14063e422b7f54f Mon Sep 17 00:00:00 2001 From: Sami Vaarala Date: Mon, 25 Mar 2013 19:01:08 +0200 Subject: [PATCH] intermediate commit for Array.prototype.sort() testcase, not finished --- testcases/test-builtin-array-proto-sort.js | 376 +++++++++++++++++++++ 1 file changed, 376 insertions(+) create mode 100644 testcases/test-builtin-array-proto-sort.js diff --git a/testcases/test-builtin-array-proto-sort.js b/testcases/test-builtin-array-proto-sort.js new file mode 100644 index 00000000..395aa183 --- /dev/null +++ b/testcases/test-builtin-array-proto-sort.js @@ -0,0 +1,376 @@ +/* + * Array.prototype.sort() tests. + * + * The current implementation is qsort() with a random pivot, which makes + * this test non-deterministic unless the internal randomizer state is + * initialized with a fixed seed. + */ + +function dumpValue(v) { + var i, n; + var tmp; + var t; + + n = v.length; + tmp = []; + for (i = 0; i < n; i++) { + if (v.hasOwnProperty(i)) { + t = v[i]; + if (typeof t === 'function') { + tmp.push('function'); + } else if (typeof t === 'object') { + tmp.push('object'); + } else { + tmp.push(String(t)); + } + } else { + tmp.push('nonexistent'); + } + } + + return tmp.join(','); +} + +function test(this_value, args) { + var t; + + try { + t = Array.prototype.sort.apply(this_value, args); + print(dumpValue(t)); + } catch (e) { + print(e.name); + } +} + +function printDesc(obj, key) { + var pd = Object.getOwnPropertyDescriptor(obj, key); + if (!pd) { + print(key, 'nonexistent'); + return; + } + + print(key, + 'value=' + pd.value, + 'writable=' + pd.writable, + 'enumerable=' + pd.enumerable, + 'configurable=' + pd.configurable); +} + +/*=== +===*/ + +print('basic'); + +function basicTest() { + /* Note that all cases without an explicit compare function will sort + * elements as strings after ToString() coercion, e.g. 1 and 2 are + * compared with string comparison "1" vs "2". Thus, "1" < "10" < "2". + */ + + // empty case + + test([], []); + test({ length: 0 }, []); + test({}, []); + + // one element case + + test([1], []); + + // a few different lengths, in various orders + + test([1,2], []); + test([2,1], []); + test([1,2,3], []); + test([1,3,2], []); + test([2,1,3], []); + test([2,3,1], []); + test([3,1,2], []); + test([3,2,1], []); + + // a few different lengths with some equal elements + + test([1,1], []); + test([1,1,2], []); + test([1,2,1], []); + test([2,1,1], []); + + // undefined elements will be pushed to the end, and 'nonexistent' elements + // even farther + + obj = [1,2,undefined,3,4,undefined,5,6,undefined,7,8,undefined,9,10]; + obj.length = 20; + test(obj, []); + + // sparse array + + obj = [1,5,10]; + obj[100] = 2; + obj[101] = 7; + obj[102] = 13; + obj[50] = 12; + test(obj, []); + + // elements are compared as strings by default + + test([1,2,3,4,5,6,7,8,9,10], []); + test([2,4,6,8,10,1,3,5,7,9], []); + + // explicit sort function for numbers, ascending and descending + + test([1,2,3,4,5,6,7,8,9,10], [ function(a,b) { return a-b; } ]); + test([2,4,6,8,10,1,3,5,7,9], [ function(a,b) { return b-a; } ]); +} + +try { + basicTest(); +} catch (e) { + print(e); +} + +/*=== +===*/ + +print('exhaustive'); + +function cloneArray(x) { + return x.map(function(x) { return x; }); +} + +function makeNonArray(x) { + var res = {}; + var i; + + for (i = 0; i < x.length; i++) { + if (x.hasOwnProperty(i)) { + res[i] = x[i]; + } + } + res.length = x.length; + + return res; +} + +function exhaustiveSortTest(input, make_sparse, make_nonarray) { + function f(arr, rem) { + var i, n; + var new_arr, new_rem; + var tmp; + + n = rem.length; + if (n == 0) { + if (make_sparse) { + n = arr.length; + arr[10000] = 'foo'; + delete arr[10000]; + arr.length = n; + } else if (make_nonarray) { + arr = makeNonArray(arr); + } + + tmp = dumpValue(arr); + Array.prototype.sort.call(arr); + print(tmp, '--', dumpValue(arr)); + } else { + for (i = 0; i < n; i++) { + new_arr = cloneArray(arr); + new_rem = cloneArray(rem); + new_arr.push(new_rem.splice(i, 1)[0]); + f(new_arr, new_rem); + } + } + } + + f([], input); +} + +try { + exhaustiveSortTest([1,2,3], false, false); + exhaustiveSortTest([1,2,3], true, false); + exhaustiveSortTest([1,2,3], false, true); + exhaustiveSortTest([1,2,3,3,4,5], false, false); + exhaustiveSortTest([1,2,3,3,4,5], true, false); + exhaustiveSortTest([1,2,3,3,4,5], false, true); +} catch (e) { + print(e); +} + +/*=== +===*/ + +// http://en.wikipedia.org/wiki/Linear_congruential_generator#Parameters_in_common_use + +print('random strings'); + +var rnd_x = 123; +function prng(max) { + rnd_x = (rnd_x * 16807) % 0x7fffffff; + return rnd_x % max; +} + +function rndString(maxLen) { + var len = prng(maxLen); + var i; + var res = ''; + + for (i = 0; i < len; i++) { + res += String.fromCharCode(0x41 + prng(26)); + } + + return res; +} + +function randomStringsTest() { + var arr = []; + var i; + var str1, str2; + + for (i = 0; i < 10000; i++) { + arr.push(rndString(8)); + } + + print(arr); + + arr.sort(); + str1 = arr.toString(); + print(str1); + + arr.sort(); + str2 = arr.toString(); + print(str1 === str2); +} + +randomStringsTest(); + +/*=== +===*/ + +print('attributes'); + +function attributeTest() { + var obj; + + // attributes are kept when both swapped elements exist: two [[Get]]+[[Put]] + // pairs are used + + obj = []; + Object.defineProperties(obj, { + '0': { value: 'foo', writable: true, enumerable: false, configurable: true }, + '1': { value: 'bar', writable: true, enumerable: true, configurable: true }, + }); + printDesc(obj, '0'); printDesc(obj, '1'); printDesc(obj, 'length'); + obj.sort(); + printDesc(obj, '0'); printDesc(obj, '1'); printDesc(obj, 'length'); + + // same test but make attributes non-configurable; this must not prevent sorting + // because writability is sufficient when swapped pairs exist + + obj = []; + Object.defineProperties(obj, { + '0': { value: 'foo', writable: true, enumerable: false, configurable: false }, + '1': { value: 'bar', writable: true, enumerable: true, configurable: false }, + }); + printDesc(obj, '0'); printDesc(obj, '1'); printDesc(obj, 'length'); + obj.sort(); + printDesc(obj, '0'); printDesc(obj, '1'); printDesc(obj, 'length'); + + // if only one end of the swapped pair exists, the other is [[Delete]]'d + // and [[Put]] will create a property with default [[Put]] attributes, i.e. + // writable, configurable, and enumerable + + obj = []; + Object.defineProperties(obj, { + '1': { value: 'bar', writable: true, enumerable: false, configurable: true }, + }); + printDesc(obj, '0'); printDesc(obj, '1'); printDesc(obj, 'length'); + obj.sort(); + printDesc(obj, '0'); printDesc(obj, '1'); printDesc(obj, 'length'); + + // same test but '1' is non-configurable -> TypeError + // the final state of 'obj' is implementation defined: the specification doesn't + // mandate whether or not the [[Put]] for '0' should precede the [[Delete]] for '1'. + + obj = []; + Object.defineProperties(obj, { + '1': { value: 'bar', writable: true, enumerable: false, configurable: false }, + }); + printDesc(obj, '0'); printDesc(obj, '1'); printDesc(obj, 'length'); + obj.sort(); + printDesc(obj, '0'); printDesc(obj, '1'); printDesc(obj, 'length'); +} + +try { + attributeTest(); +} catch (e) { + print(e); +} + +/*=== +===*/ + +print('comparefunction'); + +function compareFunctionTest() { + // the default comparison function compares strings with ToString(); verify + // its behavior first + + // basic ascending numeric sort + + test([ '1', 5, '3e0', '9.8', { valueOf: function() { return '7' } }], + [ function(a,b) { return Number(a) - Number(b); } ]); + + // basic descending numeric sort + + test([ '1', 5, '3e0', '9.8', { valueOf: function() { return '7' } }], + [ function(a,b) { return Number(b) - Number(a); } ]); + + // compareFn TypeError for a non-callable compareFn only occurs when + // it is about to be called for the first time + + test([1], [ 'non-callable' ]); // *no* TypeError + test([1,2], [ 'non-callable' ]); // -> TypeError + test([1,2], [ {} ]); // -> TypeError + test([1,2], [ { toLocaleString: 'non-callable' } ]); // -> TypeError + + // compareFn only gets called if both SortCompare() arguments exist + // and neither is 'undefined'. In this test only one element exists + // and is not undefined, so no compareFn calls can be made + + obj = []; + obj.length = 10; + obj[0] = undefined; + obj[2] = undefined; + obj[3] = 'foo'; + obj[6] = undefined; + obj[7] = undefined; + obj[9] = undefined; + test(obj, [ function(a,b) { print('should never be called'); } ]); +} + +try { + compareFunctionTest(); +} catch (e) { + print(e); +} + +/* +automatic comparefn +manual comparefn + +already ascending +already descending +random + +sparse array with an inherited index showing through +-> impl dependent, what does e.g. node do? + +non-extensible object -> impl dep +non-configurable elem (below length) -> impl dep +non-writable elem (below length) -> impl dep +accessor elem (below length) + +non-configrable elem above length -> NOT impl dep +non-writable elem (above length) -> NOT impl dep +accessor elem (above length) +*/ +