First commit of Mozilla JavaScript tests.
[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 >= 0x00C0 && c <= 0x00D6) || (c >= 0x00D8 && c<=0x00DE) ) {
127         u[0] = c;
128         u[1] = c + 32;
129         return u;
130     }
131
132     // lower case Latin-1 Supplement
133     if ( (c >= 0x00E0 && c <= 0x00F6) || (c >= 0x00F8 && c <= 0x00FE) ) {
134         u[0] = c - 32;
135         u[1] = c;
136         return u;
137     }
138     if ( c == 0x00FF ) {
139         u[0] = 0x0178;
140         u[1] = c;
141         return u;
142     }
143     // Latin Extended A
144     if ( (c >= 0x0100 && c < 0x0138) || (c > 0x0149 && c < 0x0178) ) {
145         // special case for capital I
146         if ( c == 0x0130 ) {
147             u[0] = c;
148             u[1] = 0x0069;
149             return u;
150         }
151         if ( c == 0x0131 ) {
152             u[0] = 0x0049;
153             u[1] = c;
154             return u;
155         }
156
157         if ( c % 2 == 0 ) {
158         // if it's even, it's a capital and the lower case is c +1
159             u[0] = c;
160             u[1] = c+1;
161         } else {
162         // if it's odd, it's a lower case and upper case is c-1
163             u[0] = c-1;
164             u[1] = c;
165         }
166         return u;
167     }
168     if ( c == 0x0178 ) {
169         u[0] = c;
170         u[1] = 0x00FF;
171         return u;
172     }
173
174     if ( (c >= 0x0139 && c < 0x0149) || (c > 0x0178 && c < 0x017F) ) {
175         if ( c % 2 == 1 ) {
176         // if it's odd, it's a capital and the lower case is c +1
177             u[0] = c;
178             u[1] = c+1;
179         } else {
180         // if it's even, it's a lower case and upper case is c-1
181             u[0] = c-1;
182             u[1] = c;
183         }
184         return u;
185     }
186     if ( c == 0x017F ) {
187         u[0] = 0x0053;
188         u[1] = c;
189     }
190
191     // Latin Extended B
192     // need to improve this set
193
194     if ( c >= 0x0200 && c <= 0x0217 ) {
195         if ( c % 2 == 0 ) {
196             u[0] = c;
197             u[1] = c+1;
198         } else {
199             u[0] = c-1;
200             u[1] = c;
201         }
202         return u;
203     }
204
205     // Latin Extended Additional
206     // Range: U+1E00 to U+1EFF
207     // http://www.unicode.org/Unicode.charts/glyphless/U1E00.html
208
209     // Spacing Modifier Leters
210     // Range: U+02B0 to U+02FF
211
212     // Combining Diacritical Marks
213     // Range: U+0300 to U+036F
214
215     // skip Greek for now
216     // Greek
217     // Range: U+0370 to U+03FF
218
219     // Cyrillic
220     // Range: U+0400 to U+04FF
221
222     if ( (c >= 0x0401 && c <= 0x040C) || ( c>= 0x040E && c <= 0x040F ) ) {
223         u[0] = c;
224         u[1] = c + 80;
225         return u;
226     }
227
228
229     if ( c >= 0x0410  && c <= 0x042F ) {
230         u[0] = c;
231         u[1] = c + 32;
232         return u;
233     }
234
235     if ( c >= 0x0430 && c<= 0x044F ) {
236         u[0] = c - 32;
237         u[1] = c;
238         return u;
239
240     }
241     if ( (c >= 0x0451 && c <= 0x045C) || (c >=0x045E && c<= 0x045F) ) {
242         u[0] = c -80;
243         u[1] = c;
244         return u;
245     }
246
247     if ( c >= 0x0460 && c <= 0x047F ) {
248         if ( c % 2 == 0 ) {
249             u[0] = c;
250             u[1] = c +1;
251         } else {
252             u[0] = c - 1;
253             u[1] = c;
254         }
255         return u;
256     }
257
258     // Armenian
259     // Range: U+0530 to U+058F
260     if ( c >= 0x0531 && c <= 0x0556 ) {
261         u[0] = c;
262         u[1] = c + 48;
263         return u;
264     }
265     if ( c >= 0x0561 && c < 0x0587 ) {
266         u[0] = c - 48;
267         u[1] = c;
268         return u;
269     }
270
271     // Hebrew
272     // Range: U+0590 to U+05FF
273
274
275     // Arabic
276     // Range: U+0600 to U+06FF
277
278     // Devanagari
279     // Range: U+0900 to U+097F
280
281
282     // Bengali
283     // Range: U+0980 to U+09FF
284
285
286     // Gurmukhi
287     // Range: U+0A00 to U+0A7F
288
289
290     // Gujarati
291     // Range: U+0A80 to U+0AFF
292
293
294     // Oriya
295     // Range: U+0B00 to U+0B7F
296     // no capital / lower case
297
298
299     // Tamil
300     // Range: U+0B80 to U+0BFF
301     // no capital / lower case
302
303
304     // Telugu
305     // Range: U+0C00 to U+0C7F
306     // no capital / lower case
307
308
309     // Kannada
310     // Range: U+0C80 to U+0CFF
311     // no capital / lower case
312
313
314     // Malayalam
315     // Range: U+0D00 to U+0D7F
316
317     // Thai
318     // Range: U+0E00 to U+0E7F
319
320
321     // Lao
322     // Range: U+0E80 to U+0EFF
323
324
325     // Tibetan
326     // Range: U+0F00 to U+0FBF
327
328     // Georgian
329     // Range: U+10A0 to U+10F0
330     if ( c >= 0x10A0 && c <= 0x10C5 ) {
331         u[0] = c;
332         u[1] = c + 48;
333         return u;
334     }
335     if ( c >= 0x10D0 && c <= 0x10F5 ) {
336         u[0] = c;
337         u[1] = c;
338         return u;
339     }
340
341     // Hangul Jamo
342     // Range: U+1100 to U+11FF
343
344     // Greek Extended
345     // Range: U+1F00 to U+1FFF
346     // skip for now
347
348
349     // General Punctuation
350     // Range: U+2000 to U+206F
351
352     // Superscripts and Subscripts
353     // Range: U+2070 to U+209F
354
355     // Currency Symbols
356     // Range: U+20A0 to U+20CF
357
358
359     // Combining Diacritical Marks for Symbols
360     // Range: U+20D0 to U+20FF
361     // skip for now
362
363
364     // Number Forms
365     // Range: U+2150 to U+218F
366     // skip for now
367
368
369     // Arrows
370     // Range: U+2190 to U+21FF
371
372     // Mathematical Operators
373     // Range: U+2200 to U+22FF
374
375     // Miscellaneous Technical
376     // Range: U+2300 to U+23FF
377
378     // Control Pictures
379     // Range: U+2400 to U+243F
380
381     // Optical Character Recognition
382     // Range: U+2440 to U+245F
383
384     // Enclosed Alphanumerics
385     // Range: U+2460 to U+24FF
386
387     // Box Drawing
388     // Range: U+2500 to U+257F
389
390     // Block Elements
391     // Range: U+2580 to U+259F
392
393     // Geometric Shapes
394     // Range: U+25A0 to U+25FF
395
396     // Miscellaneous Symbols
397     // Range: U+2600 to U+26FF
398
399     // Dingbats
400     // Range: U+2700 to U+27BF
401
402     // CJK Symbols and Punctuation
403     // Range: U+3000 to U+303F
404
405     // Hiragana
406     // Range: U+3040 to U+309F
407
408     // Katakana
409     // Range: U+30A0 to U+30FF
410
411     // Bopomofo
412     // Range: U+3100 to U+312F
413
414     // Hangul Compatibility Jamo
415     // Range: U+3130 to U+318F
416
417     // Kanbun
418     // Range: U+3190 to U+319F
419
420
421     // Enclosed CJK Letters and Months
422     // Range: U+3200 to U+32FF
423
424     // CJK Compatibility
425     // Range: U+3300 to U+33FF
426
427     // Hangul Syllables
428     // Range: U+AC00 to U+D7A3
429
430     // High Surrogates
431     // Range: U+D800 to U+DB7F
432
433     // Private Use High Surrogates
434     // Range: U+DB80 to U+DBFF
435
436     // Low Surrogates
437     // Range: U+DC00 to U+DFFF
438
439     // Private Use Area
440     // Range: U+E000 to U+F8FF
441
442     // CJK Compatibility Ideographs
443     // Range: U+F900 to U+FAFF
444
445     // Alphabetic Presentation Forms
446     // Range: U+FB00 to U+FB4F
447
448     // Arabic Presentation Forms-A
449     // Range: U+FB50 to U+FDFF
450
451     // Combining Half Marks
452     // Range: U+FE20 to U+FE2F
453
454     // CJK Compatibility Forms
455     // Range: U+FE30 to U+FE4F
456
457     // Small Form Variants
458     // Range: U+FE50 to U+FE6F
459
460     // Arabic Presentation Forms-B
461     // Range: U+FE70 to U+FEFF
462
463     // Halfwidth and Fullwidth Forms
464     // Range: U+FF00 to U+FFEF
465
466     if ( c >= 0xFF21 && c <= 0xFF3A ) {
467         u[0] = c;
468         u[1] = c + 32;
469         return u;
470     }
471
472     if ( c >= 0xFF41 && c <= 0xFF5A ) {
473         u[0] = c - 32;
474         u[1] = c;
475         return u;
476     }
477
478     // Specials
479     // Range: U+FFF0 to U+FFFF
480
481     return u;
482 }
483
484 function DecimalToHexString( n ) {
485     n = Number( n );
486     var h = "0x";
487
488     for ( var i = 3; i >= 0; i-- ) {
489         if ( n >= Math.pow(16, i) ){
490             var t = Math.floor( n  / Math.pow(16, i));
491             n -= t * Math.pow(16, i);
492             if ( t >= 10 ) {
493                 if ( t == 10 ) {
494                     h += "A";
495                 }
496                 if ( t == 11 ) {
497                     h += "B";
498                 }
499                 if ( t == 12 ) {
500                     h += "C";
501                 }
502                 if ( t == 13 ) {
503                     h += "D";
504                 }
505                 if ( t == 14 ) {
506                     h += "E";
507                 }
508                 if ( t == 15 ) {
509                     h += "F";
510                 }
511             } else {
512                 h += String( t );
513             }
514         } else {
515             h += "0";
516         }
517     }
518
519     return h;
520 }