JavaScriptCore:
[WebKit-https.git] / LayoutTests / fast / js / resources / date-set-to-nan.js
1 description(
2 "This tests if the Date setters handle invalid parameters correctly resulting in a NaN date and if a recovery from such a NaN date is only possible by using the date.setTime() and date.set[[UTC]Full]Year() functions."
3 );
4
5 var dateFunctionNameRoots = [
6     "Time",
7     "Milliseconds",
8     "UTCMilliseconds",
9     "Seconds",
10     "UTCSeconds",
11     "Minutes",
12     "UTCMinutes",
13     "Hours",
14     "UTCHours",
15     "Date",
16     "UTCDate",
17     "Month",
18     "UTCMonth",
19     "FullYear",
20     "UTCFullYear",
21     "Year"
22 ];
23
24 var dateFunctionParameterNum = [
25     1,
26     1,
27     1,
28     2,
29     2,
30     3,
31     3,
32     4,
33     4,
34     1,
35     1,
36     2,
37     2,
38     3,
39     3,
40     1
41 ];
42
43 var testValues = [
44     0,
45     Number.NaN,
46     Number.POSITIVE_INFINITY,
47     Number.NEGATIVE_INFINITY
48 ];
49
50 function testDateFunctionWithValueNoRecoverNaN(functionNameRoot, steps)
51 {
52     var date = new Date();
53     var setValue = date["get" + functionNameRoot]();    
54     date.setMilliseconds(Number.NaN);
55     var params = [
56         "",
57         ", 0",
58         ", 0, 0",
59         ", 0, 0, 0"
60     ];
61     var setResult = (1 == steps) ?  date["set" + functionNameRoot](setValue)
62                   : ((2 == steps) ? date["set" + functionNameRoot](setValue, 0)
63                   : ((3 == steps) ? date["set" + functionNameRoot](setValue, 0, 0)
64                   :                  date["set" + functionNameRoot](setValue, 0, 0, 0)));
65     if (!isNaN(setResult)) {
66         testFailed("date(NaN).set" + functionNameRoot + "(" + setValue + params[steps - 1]
67                                    + ") was " + setResult + " instead of NaN");
68         return false;
69     }
70     var getResult = date["get" + functionNameRoot]();
71     if (!isNaN(getResult)) {
72         testFailed("date.get" + functionNameRoot + "() was " + getResult + " instead of NaN");
73         return false;
74     }
75     testPassed ("no recovering from NaN date using date.set" + functionNameRoot 
76         + "(arg0" + params[steps - 1] + ")");
77     return true;
78 }
79
80 function testDateFunctionWithValueRecoverTime(functionNameRoot)
81 {
82     var date = new Date();
83     var setValue = date["get" + functionNameRoot]();    
84     date.setMilliseconds(Number.NaN);
85     var setResult = date["set" + functionNameRoot](setValue);
86     if (setValue != setResult) {
87         testFailed("date(NaN).set" + functionNameRoot + "(" + setValue + ") was " + setResult + " instead of " + setValue);
88         return false;
89     }
90     var getResult = date["get" + functionNameRoot]();
91     if (getResult != setValue) {
92         testFailed("date.get" + functionNameRoot + "() was " + getResult + " instead of " + setValue);
93         return false;
94     }
95     testPassed ("recover from NaN date using date.set" + functionNameRoot + "()");
96     return true;
97 }
98
99 function testDateFunctionWithValueRecoverFullYear(functionNameRoot)
100 {
101     var result = true;
102     var date = new Date();
103     var setValue = date["get" + functionNameRoot]();    
104     date.setMilliseconds(Number.NaN);
105     var setResult = date["set" + functionNameRoot](setValue);    
106     var getResult = date["get" + functionNameRoot]();
107     if (getResult != setValue) {
108         testFailed("date.get" + functionNameRoot + "() was " + getResult + " instead of " + setValue);
109         result = false;
110     }
111     getResult = date.getMilliseconds();
112     if (getResult != 0) {
113         testFailed("date.getMilliseconds() was " + getResult + " instead of 0");
114         result = false;
115     }
116     getResult = date.getSeconds();
117     if (getResult != 0) {
118         testFailed("date.getSeconds() was " + getResult + " instead of 0");
119         result = false;
120     }
121     getResult = date.getMinutes();
122     if (getResult != 0) {
123         testFailed("date.getMinutes() was " + getResult + " instead of 0");
124         result = false;
125     }
126     getResult = date.getHours();
127     if (getResult != 0) {
128         testFailed("date.getHours() was " + getResult + " instead of 0");
129         result = false;
130     }
131     getResult = date.getDate();
132     if (getResult != 1) {
133         testFailed("date.getDate() was " + getResult + " instead of 1");
134         result = false;
135     }
136     getResult = date.getMonth();
137     if (getResult != 0) {
138         testFailed("date.getMonth() was " + getResult + " instead of 0");
139         result = false;
140     }
141     if (result)
142         testPassed ("recover from NaN date using date.setFullYear()");
143     else
144         testFailed ("recover from NaN date using date.setFullYear()");
145     return result;
146 }
147
148 function testDateFunctionWithValueRecoverUTCFullYear(functionNameRoot)
149 {
150     var result = true; 
151     var date = new Date();
152     var setValue = date["get" + functionNameRoot]();    
153     date.setMilliseconds(Number.NaN);
154     var setResult = date["set" + functionNameRoot](setValue);    
155     var getResult = date["get" + functionNameRoot]();
156     if (getResult != setValue) {
157         testFailed("date.get" + functionNameRoot + "() was " + getResult + " instead of " + setValue);
158         result = false;
159     }
160     getResult = date.getUTCMilliseconds();
161     if (getResult != 0) {
162         testFailed("date.getUTCMilliseconds() was " + getResult + " instead of 0");
163         result = false;
164     }
165     getResult = date.getUTCSeconds();
166     if (getResult != 0) {
167         testFailed("date.getUTCSeconds() was " + getResult + " instead of 0");
168         result = false;
169     }
170     getResult = date.getUTCMinutes();
171     if (getResult != 0) {
172         testFailed("date.getUTCMinutes() was " + getResult + " instead of 0");
173         result = false;
174     }
175     getResult = date.getUTCHours();
176     if (getResult != 0) {
177         testFailed("date.getUTCHours() was " + getResult + " instead of 0");
178         result = false;
179     }
180     getResult = date.getUTCDate();
181     if (getResult != 1) {
182         testFailed("date.getUTCDate() was " + getResult + " instead of 1");
183         result = false;
184     }
185     getResult = date.getUTCMonth();
186     if (getResult != 0) {
187         testFailed("date.getUTCMonth() was " + getResult + " instead of 0");
188         result = false;
189     }
190     if (result)
191         testPassed ("recover from NaN date using date.setUTCFullYear()");
192     else
193         testFailed ("recover from NaN date using date.setUTCFullYear()");
194     return result;
195 }
196
197 function testDateFunctionWithValueRecoverYear(functionNameRoot)
198 {
199     var result = true;
200     var is13Compatible = true;
201     
202     var date = new Date();
203     var setValue = date["get" + functionNameRoot]();
204     var fullYears = date.getFullYear() - 1900;    
205     if (setValue != fullYears) {
206         testFailed("date.get" + functionNameRoot + "() was " + setValue + " instead of " + fullYears);
207         is13Compatible = false;
208     } else 
209         testPassed("date.getYear() is compatible to JavaScript 1.3 and later");
210     
211     date.setMilliseconds(Number.NaN);
212     var setResult = date["set" + functionNameRoot](setValue + 1900);        
213     var getResult = date["get" + functionNameRoot]();
214     if (getResult != setValue) {
215         testFailed("date.get" + functionNameRoot + "() was " + getResult + " instead of " + setValue);
216         result = false;
217     }
218     getResult = date.getMilliseconds();
219     if (getResult != 0) {
220         testFailed("date.getMilliseconds() was " + getResult + " instead of 0");
221         result = false;
222     }
223     getResult = date.getSeconds();
224     if (getResult != 0) {
225         testFailed("date.getSeconds() was " + getResult + " instead of 0");
226         result = false;
227     }
228     getResult = date.getMinutes();
229     if (getResult != 0) {
230         testFailed("date.getMinutes() was " + getResult + " instead of 0");
231         result = false;
232     }
233     getResult = date.getHours();
234     if (getResult != 0) {
235         testFailed("date.getHours() was " + getResult + " instead of 0");
236         result = false;
237     }
238     getResult = date.getDate();
239     if (getResult != 1) {
240         testFailed("date.getDate() was " + getResult + " instead of 1");
241         result = false;
242     }
243     getResult = date.getMonth();
244     if (getResult != 0) {
245         testFailed("date.getMonth() was " + getResult + " instead of 0");
246         result = false;
247     }
248     if (result)
249         testPassed ("recover from NaN date using date.setUTCFullYear()");
250     else
251         testFailed ("recover from NaN date using date.setUTCFullYear()");
252     return result && is13Compatible;
253 }
254
255 function makeIEHappy(functionNameRoot, value)
256 {    
257     var date = new Date();
258     var setResult = date["set" + functionNameRoot](value);
259     if (!isNaN(setResult)) {
260         testFailed("date.set" + functionNameRoot 
261                               + "() was " 
262                               + setResult + " instead of NaN");                                                                       
263          return false;
264     }
265     var getResult = date["get" + functionNameRoot]();
266     if (!isNaN(getResult)) {
267         testFailed("date.get" + functionNameRoot + "() was "
268                               + getResult + " instead of NaN");
269         return false;
270     }   
271     return true
272 }
273
274 function testDateFunctionWithValueExpectingNaN1(functionNameRoot)
275 {
276     var result = true;
277     for (var idx0 in testValues)
278         if (idx0 != 0) {
279             var date = new Date();
280             var setResult = date["set" + functionNameRoot](testValues[idx0]);
281             if (!isNaN(setResult)) {
282                 testFailed("date.set" + functionNameRoot + "(" 
283                                       + testValues[idx0] + ") was " 
284                                       + setResult + " instead of NaN");                                                                       
285                 result = false;
286             }
287             var getResult = date["get" + functionNameRoot]();
288             if (!isNaN(getResult)) {
289                 testFailed("date.get" + functionNameRoot + "() was "
290                                       + getResult + " instead of NaN");
291                 result = false;
292             }                                               
293         } else if (!makeIEHappy(functionNameRoot))
294             result = false;
295     if (result) { 
296         testPassed("date.set" + functionNameRoot + "(arg0)");
297         testPassed("date.set" + functionNameRoot + "()");
298     }
299     return result;
300 }
301
302 function testDateFunctionWithValueExpectingNaN2(functionNameRoot)
303 {
304     var result = true;
305     for (var idx0 in testValues)
306         for (var idx1 in testValues)
307             if (idx0 != 0 || idx1 != 0) {
308                 var date = new Date();
309                 var setResult = date["set" + functionNameRoot](testValues[idx0],
310                                                                testValues[idx1]);
311                 
312                 if (!isNaN(setResult)) {
313                     testFailed("date.set" + functionNameRoot + "(" 
314                                           + testValues[idx0] + ", "
315                                           + testValues[idx1] + ") was " 
316                                           + setResult + " instead of NaN");                                                                       
317                     result = false;
318                 }
319                 var getResult = date["get" + functionNameRoot]();
320                 if (!isNaN(getResult)) {
321                     testFailed("date.get" + functionNameRoot + "() was "
322                                           + getResult + " instead of NaN");
323                     result = false;
324                 }                                               
325             }
326     
327     if (result) 
328         testPassed("date.set" + functionNameRoot + "(arg0, arg1)");
329     return result;
330 }
331
332 function testDateFunctionWithValueExpectingNaN3(functionNameRoot)
333 {
334     var result = true;
335     for (var idx0 in testValues)
336         for (var idx1 in testValues)
337             for (var idx2 in testValues)
338                 if (idx0 != 0 || idx1 != 0 || idx2 != 0) {
339                     var date = new Date();
340                     var setResult = date["set" + functionNameRoot](testValues[idx0],
341                                                                    testValues[idx1],
342                                                                    testValues[idx2]);
343                     if (!isNaN(setResult)) {
344                         testFailed("date.set" + functionNameRoot + "(" 
345                                               + testValues[idx0] + ", "
346                                               + testValues[idx1] + ", "
347                                               + testValues[idx2] + ") was " 
348                                               + setResult + " instead of NaN");                                                                       
349                         result = false;
350                     }
351                     var getResult = date["get" + functionNameRoot]();
352                     if (!isNaN(getResult)) {
353                         testFailed("date.get" + functionNameRoot + "() was "
354                                               + getResult + " instead of NaN");
355                         result = false;
356                     }                                               
357                 }
358                 
359     if (result) 
360         testPassed("date.set" + functionNameRoot + "(arg0, arg1, arg2)");
361     return result;
362 }
363
364 function testDateFunctionWithValueExpectingNaN4(functionNameRoot)
365 {
366     var result = true;
367     for (var idx0 in testValues)
368         for (var idx1 in testValues)
369             for (var idx2 in testValues)
370                 for (var idx3 in testValues)
371                     if (idx0 != 0 || idx1 != 0 || idx2 != 0 || idx3 != 0) {
372                         var date = new Date();
373                         var setResult = date["set" + functionNameRoot](testValues[idx0],
374                                                                        testValues[idx1],
375                                                                        testValues[idx2],
376                                                                        testValues[idx3]);
377                         if (!isNaN(setResult)) {
378                             testFailed("date.set" + functionNameRoot + "(" 
379                                                   + testValues[idx0] + ", "
380                                                   + testValues[idx1] + ", "
381                                                   + testValues[idx2] + ", "
382                                                   + testValues[idx3] + ") was " 
383                                                   + setResult + " instead of NaN");                                                                       
384                             result = false;
385                         }
386                         var getResult = date["get" + functionNameRoot]();
387                         if (!isNaN(getResult)) {
388                             testFailed("date.get" + functionNameRoot + "() was "
389                                                   + getResult + " instead of NaN");
390                             result = false;
391                         }                                          
392                     }
393     if (result) 
394         testPassed("date.set" + functionNameRoot + "(arg0, arg1, arg2, arg3)");
395     return result;
396 }
397
398
399
400 function testDateFunction(functionNameRoot, functionParamNum)
401 {
402     var success = true;
403     
404     switch (functionParamNum) {
405     case 4:
406         success &= testDateFunctionWithValueExpectingNaN4(functionNameRoot);
407         if (functionNameRoot != "Time" &&
408             functionNameRoot != "FullYear" &&
409             functionNameRoot != "UTCFullYear" &&
410             functionNameRoot != "Year")
411             success &= testDateFunctionWithValueNoRecoverNaN(functionNameRoot, 4);
412
413     case 3:
414         success &= testDateFunctionWithValueExpectingNaN3(functionNameRoot);
415         if (functionNameRoot != "Time" &&
416             functionNameRoot != "FullYear" &&
417             functionNameRoot != "UTCFullYear" &&
418             functionNameRoot != "Year")
419             success &= testDateFunctionWithValueNoRecoverNaN(functionNameRoot, 3);
420         
421     case 2:
422         success &= testDateFunctionWithValueExpectingNaN2(functionNameRoot);
423         if (functionNameRoot != "Time" &&
424             functionNameRoot != "FullYear" &&
425             functionNameRoot != "UTCFullYear" &&
426             functionNameRoot != "Year")
427             success &= testDateFunctionWithValueNoRecoverNaN(functionNameRoot, 2);
428         
429     case 1:
430         success &= testDateFunctionWithValueExpectingNaN1(functionNameRoot);
431         if (functionNameRoot == "Time")
432             success &= testDateFunctionWithValueRecoverTime(functionNameRoot);       
433         else if (functionNameRoot == "FullYear")
434             success &= testDateFunctionWithValueRecoverFullYear(functionNameRoot);
435         else if (functionNameRoot == "UTCFullYear")
436             success &= testDateFunctionWithValueRecoverUTCFullYear(functionNameRoot);
437         else if (functionNameRoot == "Year")
438             success &= testDateFunctionWithValueRecoverYear(functionNameRoot);
439         else
440             success &= testDateFunctionWithValueNoRecoverNaN(functionNameRoot, 1);
441     }
442         
443     if (success)
444         testPassed("date.set" + functionNameRoot + " passed all tests");
445 }
446
447 for (var x in dateFunctionNameRoots)
448 {
449     testDateFunction(dateFunctionNameRoots[x], dateFunctionParameterNum[x]);
450 }
451
452 var successfullyParsed = true;