Home | History | Annotate | Download | only in Array
      1 /* The contents of this file are subject to the Netscape Public
      2  * License Version 1.1 (the "License"); you may not use this file
      3  * except in compliance with the License. You may obtain a copy of
      4  * the License at http://www.mozilla.org/NPL/
      5  *
      6  * Software distributed under the License is distributed on an "AS
      7  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
      8  * implied. See the License for the specific language governing
      9  * rights and limitations under the License.
     10  *
     11  * The Original Code is Mozilla Communicator client code, released March
     12  * 31, 1998.
     13  *
     14  * The Initial Developer of the Original Code is Netscape Communications
     15  * Corporation. Portions created by Netscape are
     16  * Copyright (C) 1998 Netscape Communications Corporation. All
     17  * Rights Reserved.
     18  *
     19  * Contributor(s):
     20  *
     21  */
     22 /**
     23     File Name:          15.4.4.5.js
     24     ECMA Section:       Array.prototype.sort(comparefn)
     25     Description:
     26 
     27     This test file tests cases in which the compare function is not supplied.
     28 
     29     The elements of this array are sorted. The sort is not necessarily stable.
     30     If comparefn is provided, it should be a function that accepts two arguments
     31     x and y and returns a negative value if x < y, zero if x = y, or a positive
     32     value if x > y.
     33 
     34    1.   Call the [[Get]] method of this object with argument "length".
     35    2.   Call ToUint32(Result(1)).
     36         1.  Perform an implementation-dependent sequence of calls to the
     37         [[Get]] , [[Put]], and [[Delete]] methods of this object and
     38         toSortCompare (described below), where the first argument for each call
     39             to [[Get]], [[Put]] , or [[Delete]] is a nonnegative integer less
     40             than Result(2) and where the arguments for calls to SortCompare are
     41             results of previous calls to the [[Get]] method. After this sequence
     42             is complete, this object must have the following two properties.
     43             (1) There must be some mathematical permutation of the nonnegative
     44             integers less than Result(2), such that for every nonnegative integer
     45             j less than Result(2), if property old[j] existed, then new[(j)] is
     46             exactly the same value as old[j],. but if property old[j] did not exist,
     47             then new[(j)] either does not exist or exists with value undefined.
     48             (2) If comparefn is not supplied or is a consistent comparison
     49             function for the elements of this array, then for all nonnegative
     50             integers j and k, each less than Result(2), if old[j] compares less
     51             than old[k] (see SortCompare below), then (j) < (k). Here we use the
     52             notation old[j] to refer to the hypothetical result of calling the [
     53             [Get]] method of this object with argument j before this step is
     54             executed, and the notation new[j] to refer to the hypothetical result
     55             of calling the [[Get]] method of this object with argument j after this
     56             step has been completely executed. A function is a consistent
     57             comparison function for a set of values if (a) for any two of those
     58             values (possibly the same value) considered as an ordered pair, it
     59             always returns the same value when given that pair of values as its
     60             two arguments, and the result of applying ToNumber to this value is
     61             not NaN; (b) when considered as a relation, where the pair (x, y) is
     62             considered to be in the relation if and only if applying the function
     63             to x and y and then applying ToNumber to the result produces a
     64             negative value, this relation is a partial order; and (c) when
     65             considered as a different relation, where the pair (x, y) is considered
     66             to be in the relation if and only if applying the function to x and y
     67             and then applying ToNumber to the result produces a zero value (of either
     68             sign), this relation is an equivalence relation. In this context, the
     69             phrase "x compares less than y" means applying Result(2) to x and y and
     70             then applying ToNumber to the result produces a negative value.
     71     3.Return this object.
     72 
     73     When the SortCompare operator is called with two arguments x and y, the following steps are taken:
     74        1.If x and y are both undefined, return +0.
     75        2.If x is undefined, return 1.
     76        3.If y is undefined, return 1.
     77        4.If the argument comparefn was not provided in the call to sort, go to step 7.
     78        5.Call comparefn with arguments x and y.
     79        6.Return Result(5).
     80        7.Call ToString(x).
     81        8.Call ToString(y).
     82        9.If Result(7) < Result(8), return 1.
     83       10.If Result(7) > Result(8), return 1.
     84       11.Return +0.
     85 
     86 Note that, because undefined always compared greater than any other value, undefined and nonexistent
     87 property values always sort to the end of the result. It is implementation-dependent whether or not such
     88 properties will exist or not at the end of the array when the sort is concluded.
     89 
     90 Note that the sort function is intentionally generic; it does not require that its this value be an Array object.
     91 Therefore it can be transferred to other kinds of objects for use as a method. Whether the sort function can be
     92 applied successfully to a host object is implementation dependent .
     93 
     94     Author:             christine (at) netscape.com
     95     Date:               12 november 1997
     96 */
     97 
     98 
     99     var SECTION = "15.4.4.5-1";
    100     var VERSION = "ECMA_1";
    101     startTest();
    102     var TITLE   = "Array.prototype.sort(comparefn)";
    103 
    104     writeHeaderToLog( SECTION + " "+ TITLE);
    105 
    106     var testcases = new Array();
    107     getTestCases();
    108     test();
    109 
    110 function test() {
    111     for ( tc=0; tc < testcases.length; tc++ ) {
    112         testcases[tc].passed = writeTestCaseResult(
    113                             testcases[tc].expect,
    114                             testcases[tc].actual,
    115                             testcases[tc].description +" = "+
    116                             testcases[tc].actual );
    117 
    118         testcases[tc].reason += ( testcases[tc].passed ) ? "" : "wrong value ";
    119     }
    120     stopTest();
    121     return ( testcases );
    122 }
    123 function getTestCases() {
    124     var S = new Array();
    125     var item = 0;
    126 
    127     // array is empty.
    128     S[item++] = "var A = new Array()";
    129 
    130     // array contains one item
    131     S[item++] = "var A = new Array( true )";
    132 
    133     // length of array is 2
    134     S[item++] = "var A = new Array( true, false, new Boolean(true), new Boolean(false), 'true', 'false' )";
    135 
    136     S[item++] = "var A = new Array(); A[3] = 'undefined'; A[6] = null; A[8] = 'null'; A[0] = void 0";
    137 
    138     S[item] = "var A = new Array( ";
    139 
    140     var limit = 0x0061;
    141     for ( var i = 0x007A; i >= limit; i-- ) {
    142         S[item] += "\'"+ String.fromCharCode(i) +"\'" ;
    143         if ( i > limit ) {
    144             S[item] += ",";
    145         }
    146     }
    147 
    148     S[item] += ")";
    149 
    150     item++;
    151 
    152     for ( var i = 0; i < S.length; i++ ) {
    153         CheckItems( S[i] );
    154     }
    155 }
    156 function CheckItems( S ) {
    157     eval( S );
    158     var E = Sort( A );
    159 
    160     testcases[testcases.length] = new TestCase(   SECTION,
    161                                     S +";  A.sort(); A.length",
    162                                     E.length,
    163                                     eval( S + "; A.sort(); A.length") );
    164 
    165     for ( var i = 0; i < E.length; i++ ) {
    166         testcases[testcases.length] = new TestCase(
    167                                             SECTION,
    168                                             "A["+i+ "].toString()",
    169                                             E[i] +"",
    170                                             A[i] +"");
    171 
    172         if ( A[i] == void 0 && typeof A[i] == "undefined" ) {
    173             testcases[testcases.length] = new TestCase(
    174                                             SECTION,
    175                                             "typeof A["+i+ "]",
    176                                             typeof E[i],
    177                                             typeof A[i] );
    178         }
    179     }
    180 }
    181 function Object_1( value ) {
    182     this.array = value.split(",");
    183     this.length = this.array.length;
    184     for ( var i = 0; i < this.length; i++ ) {
    185         this[i] = eval(this.array[i]);
    186     }
    187     this.sort = Array.prototype.sort;
    188     this.getClass = Object.prototype.toString;
    189 }
    190 function Sort( a ) {
    191     for ( i = 0; i < a.length; i++ ) {
    192         for ( j = i+1; j < a.length; j++ ) {
    193             var lo = a[i];
    194             var hi = a[j];
    195             var c = Compare( lo, hi );
    196             if ( c == 1 ) {
    197                 a[i] = hi;
    198                 a[j] = lo;
    199             }
    200         }
    201     }
    202     return a;
    203 }
    204 function Compare( x, y ) {
    205     if ( x == void 0 && y == void 0  && typeof x == "undefined" && typeof y == "undefined" ) {
    206         return +0;
    207     }
    208     if ( x == void 0  && typeof x == "undefined" ) {
    209         return 1;
    210     }
    211     if ( y == void 0 && typeof y == "undefined" ) {
    212         return -1;
    213     }
    214     x = String(x);
    215     y = String(y);
    216     if ( x < y ) {
    217         return -1;
    218     }
    219     if ( x > y ) {
    220         return 1;
    221     }
    222     return 0;
    223 }
    224