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