Reviewed by Ken.
[WebKit-https.git] / JavaScriptCore / tests / mozilla / ecma / String / 15.5.4.12-1.js
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.5.4.12-1.js
24     ECMA Section:       15.5.4.12 String.prototype.toUpperCase()
25     Description:
26
27     Returns a string equal in length to the length of the result of converting
28     this object to a string. The result is a string value, not a String object.
29
30     Every character of the result is equal to the corresponding character of the
31     string, unless that character has a Unicode 2.0 uppercase equivalent, in which
32     case the uppercase equivalent is used instead. (The canonical Unicode 2.0 case
33     mapping shall be used, which does not depend on implementation or locale.)
34
35     Note that the toUpperCase function is intentionally generic; it does not require
36     that its this value be a String object. Therefore it can be transferred to other
37     kinds of objects for use as a method.
38
39     Author:             christine@netscape.com
40     Date:               12 november 1997
41 */
42
43     var SECTION = "15.5.4.12-1";
44     var VERSION = "ECMA_1";
45     startTest();
46     var TITLE   = "String.prototype.toUpperCase()";
47
48     writeHeaderToLog( SECTION + " "+ TITLE);
49
50     var testcases = getTestCases();
51     test();
52
53 function getTestCases() {
54     var array = new Array();
55     var item = 0;
56
57     array[item++] = new TestCase( SECTION,  "String.prototype.toUpperCase.length",        0,          String.prototype.toUpperCase.length );
58     array[item++] = new TestCase( SECTION,  "delete String.prototype.toUpperCase.length", false,      delete String.prototype.toUpperCase.length );
59     array[item++] = new TestCase( SECTION,  "delete String.prototype.toupperCase.length; String.prototype.toupperCase.length", 0,      eval("delete String.prototype.toUpperCase.length; String.prototype.toUpperCase.length") );
60
61     // Basic Latin, Latin-1 Supplement, Latin Extended A
62     for ( var i = 0; i <= 0x017f; i++ ) {
63         var U = new Unicode( i );
64
65         // XXX DF fails in java
66
67         if ( i == 0x00DF ) {
68             continue;
69         }
70
71
72         array[item++] = new TestCase(   SECTION,
73                                         "var s = new String( String.fromCharCode("+i+") ); s.toUpperCase().charCodeAt(0)",
74                                         U.upper,
75                                         eval("var s = new String( String.fromCharCode(i) ); s.toUpperCase().charCodeAt(0)") );
76     }
77
78     return array;
79 }
80 function test() {
81     for ( tc=0; tc < testcases.length; tc++ ) {
82         testcases[tc].passed = writeTestCaseResult(
83                             testcases[tc].expect,
84                             testcases[tc].actual,
85                             testcases[tc].description +" = "+
86                             testcases[tc].actual );
87
88         testcases[tc].reason += ( testcases[tc].passed ) ? "" : "wrong value ";
89     }
90     stopTest();
91     return ( testcases );
92 }
93 function MyObject( value ) {
94     this.value = value;
95     this.substring = String.prototype.substring;
96     this.toString = new Function ( "return this.value+''" );
97 }
98 function Unicode( c ) {
99     u = GetUnicodeValues( c );
100     this.upper = u[0];
101     this.lower = u[1]
102     return this;
103 }
104 function GetUnicodeValues( c ) {
105     u = new Array();
106
107     u[0] = c;
108     u[1] = c;
109
110     // upper case Basic Latin
111
112     if ( c >= 0x0041 && c <= 0x005A) {
113         u[0] = c;
114         u[1] = c + 32;
115         return u;
116     }
117
118     // lower case Basic Latin
119     if ( c >= 0x0061 && c <= 0x007a ) {
120         u[0] = c - 32;
121         u[1] = c;
122         return u;
123     }
124
125     // upper case Latin-1 Supplement
126     if ( c == 0x00B5 ) {
127         u[0] = 0x039C;
128         u[1] = c;
129         return u;
130     }
131     if ( (c >= 0x00C0 && c <= 0x00D6) || (c >= 0x00D8 && c<=0x00DE) ) {
132         u[0] = c;
133         u[1] = c + 32;
134         return u;
135     }
136
137     // lower case Latin-1 Supplement
138     if ( (c >= 0x00E0 && c <= 0x00F6) || (c >= 0x00F8 && c <= 0x00FE) ) {
139         u[0] = c - 32;
140         u[1] = c;
141         return u;
142     }
143     if ( c == 0x00FF ) {
144         u[0] = 0x0178;
145         u[1] = c;
146         return u;
147     }
148     // Latin Extended A
149     if ( (c >= 0x0100 && c < 0x0138) || (c > 0x0149 && c < 0x0178) ) {
150         // special case for capital I
151         if ( c == 0x0130 ) {
152             u[0] = c;
153             u[1] = 0x0069;
154             return u;
155         }
156         if ( c == 0x0131 ) {
157             u[0] = 0x0049;
158             u[1] = c;
159             return u;
160         }
161
162         if ( c % 2 == 0 ) {
163         // if it's even, it's a capital and the lower case is c +1
164             u[0] = c;
165             u[1] = c+1;
166         } else {
167         // if it's odd, it's a lower case and upper case is c-1
168             u[0] = c-1;
169             u[1] = c;
170         }
171         return u;
172     }
173     if ( c == 0x0178 ) {
174         u[0] = c;
175         u[1] = 0x00FF;
176         return u;
177     }
178
179     if ( (c >= 0x0139 && c < 0x0149) || (c > 0x0178 && c < 0x017F) ) {
180         if ( c % 2 == 1 ) {
181         // if it's odd, it's a capital and the lower case is c +1
182             u[0] = c;
183             u[1] = c+1;
184         } else {
185         // if it's even, it's a lower case and upper case is c-1
186             u[0] = c-1;
187             u[1] = c;
188         }
189         return u;
190     }
191     if ( c == 0x017F ) {
192         u[0] = 0x0053;
193         u[1] = c;
194     }
195
196     // Latin Extended B
197     // need to improve this set
198
199     if ( c >= 0x0200 && c <= 0x0217 ) {
200         if ( c % 2 == 0 ) {
201             u[0] = c;
202             u[1] = c+1;
203         } else {
204             u[0] = c-1;
205             u[1] = c;
206         }
207         return u;
208     }
209
210     // Latin Extended Additional
211     // Range: U+1E00 to U+1EFF
212     // http://www.unicode.org/Unicode.charts/glyphless/U1E00.html
213
214     // Spacing Modifier Leters
215     // Range: U+02B0 to U+02FF
216
217     // Combining Diacritical Marks
218     // Range: U+0300 to U+036F
219
220     // skip Greek for now
221     // Greek
222     // Range: U+0370 to U+03FF
223
224     // Cyrillic
225     // Range: U+0400 to U+04FF
226
227     if ( c >= 0x0400 && c <= 0x040F) {
228         u[0] = c;
229         u[1] = c + 80;
230         return u;
231     }
232
233
234     if ( c >= 0x0410  && c <= 0x042F ) {
235         u[0] = c;
236         u[1] = c + 32;
237         return u;
238     }
239
240     if ( c >= 0x0430 && c<= 0x044F ) {
241         u[0] = c - 32;
242         u[1] = c;
243         return u;
244
245     }
246     if ( c >= 0x0450 && c<= 0x045F ) {
247         u[0] = c -80;
248         u[1] = c;
249         return u;
250     }
251
252     if ( c >= 0x0460 && c <= 0x047F ) {
253         if ( c % 2 == 0 ) {
254             u[0] = c;
255             u[1] = c +1;
256         } else {
257             u[0] = c - 1;
258             u[1] = c;
259         }
260         return u;
261     }
262
263     // Armenian
264     // Range: U+0530 to U+058F
265     if ( c >= 0x0531 && c <= 0x0556 ) {
266         u[0] = c;
267         u[1] = c + 48;
268         return u;
269     }
270     if ( c >= 0x0561 && c < 0x0587 ) {
271         u[0] = c - 48;
272         u[1] = c;
273         return u;
274     }
275
276     // Hebrew
277     // Range: U+0590 to U+05FF
278
279
280     // Arabic
281     // Range: U+0600 to U+06FF
282
283     // Devanagari
284     // Range: U+0900 to U+097F
285
286
287     // Bengali
288     // Range: U+0980 to U+09FF
289
290
291     // Gurmukhi
292     // Range: U+0A00 to U+0A7F
293
294
295     // Gujarati
296     // Range: U+0A80 to U+0AFF
297
298
299     // Oriya
300     // Range: U+0B00 to U+0B7F
301     // no capital / lower case
302
303
304     // Tamil
305     // Range: U+0B80 to U+0BFF
306     // no capital / lower case
307
308
309     // Telugu
310     // Range: U+0C00 to U+0C7F
311     // no capital / lower case
312
313
314     // Kannada
315     // Range: U+0C80 to U+0CFF
316     // no capital / lower case
317
318
319     // Malayalam
320     // Range: U+0D00 to U+0D7F
321
322     // Thai
323     // Range: U+0E00 to U+0E7F
324
325
326     // Lao
327     // Range: U+0E80 to U+0EFF
328
329
330     // Tibetan
331     // Range: U+0F00 to U+0FBF
332
333     // Georgian
334     // Range: U+10A0 to U+10F0
335
336     // Hangul Jamo
337     // Range: U+1100 to U+11FF
338
339     // Greek Extended
340     // Range: U+1F00 to U+1FFF
341     // skip for now
342
343
344     // General Punctuation
345     // Range: U+2000 to U+206F
346
347     // Superscripts and Subscripts
348     // Range: U+2070 to U+209F
349
350     // Currency Symbols
351     // Range: U+20A0 to U+20CF
352
353
354     // Combining Diacritical Marks for Symbols
355     // Range: U+20D0 to U+20FF
356     // skip for now
357
358
359     // Number Forms
360     // Range: U+2150 to U+218F
361     // skip for now
362
363
364     // Arrows
365     // Range: U+2190 to U+21FF
366
367     // Mathematical Operators
368     // Range: U+2200 to U+22FF
369
370     // Miscellaneous Technical
371     // Range: U+2300 to U+23FF
372
373     // Control Pictures
374     // Range: U+2400 to U+243F
375
376     // Optical Character Recognition
377     // Range: U+2440 to U+245F
378
379     // Enclosed Alphanumerics
380     // Range: U+2460 to U+24FF
381
382     // Box Drawing
383     // Range: U+2500 to U+257F
384
385     // Block Elements
386     // Range: U+2580 to U+259F
387
388     // Geometric Shapes
389     // Range: U+25A0 to U+25FF
390
391     // Miscellaneous Symbols
392     // Range: U+2600 to U+26FF
393
394     // Dingbats
395     // Range: U+2700 to U+27BF
396
397     // CJK Symbols and Punctuation
398     // Range: U+3000 to U+303F
399
400     // Hiragana
401     // Range: U+3040 to U+309F
402
403     // Katakana
404     // Range: U+30A0 to U+30FF
405
406     // Bopomofo
407     // Range: U+3100 to U+312F
408
409     // Hangul Compatibility Jamo
410     // Range: U+3130 to U+318F
411
412     // Kanbun
413     // Range: U+3190 to U+319F
414
415
416     // Enclosed CJK Letters and Months
417     // Range: U+3200 to U+32FF
418
419     // CJK Compatibility
420     // Range: U+3300 to U+33FF
421
422     // Hangul Syllables
423     // Range: U+AC00 to U+D7A3
424
425     // High Surrogates
426     // Range: U+D800 to U+DB7F
427
428     // Private Use High Surrogates
429     // Range: U+DB80 to U+DBFF
430
431     // Low Surrogates
432     // Range: U+DC00 to U+DFFF
433
434     // Private Use Area
435     // Range: U+E000 to U+F8FF
436
437     // CJK Compatibility Ideographs
438     // Range: U+F900 to U+FAFF
439
440     // Alphabetic Presentation Forms
441     // Range: U+FB00 to U+FB4F
442
443     // Arabic Presentation Forms-A
444     // Range: U+FB50 to U+FDFF
445
446     // Combining Half Marks
447     // Range: U+FE20 to U+FE2F
448
449     // CJK Compatibility Forms
450     // Range: U+FE30 to U+FE4F
451
452     // Small Form Variants
453     // Range: U+FE50 to U+FE6F
454
455     // Arabic Presentation Forms-B
456     // Range: U+FE70 to U+FEFF
457
458     // Halfwidth and Fullwidth Forms
459     // Range: U+FF00 to U+FFEF
460
461     if ( c >= 0xFF21 && c <= 0xFF3A ) {
462         u[0] = c;
463         u[1] = c + 32;
464         return u;
465     }
466
467     if ( c >= 0xFF41 && c <= 0xFF5A ) {
468         u[0] = c - 32;
469         u[1] = c;
470         return u;
471     }
472
473     // Specials
474     // Range: U+FFF0 to U+FFFF
475
476     return u;
477 }
478
479 function DecimalToHexString( n ) {
480     n = Number( n );
481     var h = "0x";
482
483     for ( var i = 3; i >= 0; i-- ) {
484         if ( n >= Math.pow(16, i) ){
485             var t = Math.floor( n  / Math.pow(16, i));
486             n -= t * Math.pow(16, i);
487             if ( t >= 10 ) {
488                 if ( t == 10 ) {
489                     h += "A";
490                 }
491                 if ( t == 11 ) {
492                     h += "B";
493                 }
494                 if ( t == 12 ) {
495                     h += "C";
496                 }
497                 if ( t == 13 ) {
498                     h += "D";
499                 }
500                 if ( t == 14 ) {
501                     h += "E";
502                 }
503                 if ( t == 15 ) {
504                     h += "F";
505                 }
506             } else {
507                 h += String( t );
508             }
509         } else {
510             h += "0";
511         }
512     }
513
514     return h;
515 }