Move helper files for iOS touch gestures into LayoutTests/resources
[WebKit-https.git] / LayoutTests / resources / standalone-pre.js
1 var wasPostTestScriptParsed = false;
2 var errorMessage;
3 var self = this;
4
5 self.testRunner = {
6     neverInlineFunction: neverInlineFunction,
7     numberOfDFGCompiles: numberOfDFGCompiles,
8     failNextNewCodeBlock: failNextNewCodeBlock
9 };
10
11 var silentTestPass, didPassSomeTestsSilently, didFailSomeTests, successfullyParsed;
12 silentTestPass = false;
13 didPassSomeTestsSilenty = false;
14 didFaileSomeTests = false;
15
16 function description(msg)
17 {
18     print(msg);
19     print("\nOn success, you will see a series of \"PASS\" messages, followed by \"TEST COMPLETE\".\n");
20     print();
21 }
22
23 function debug(msg)
24 {
25     print(msg);
26 }
27
28 function escapeString(text)
29 {
30     return text.replace(/\0/g, "");
31 }
32
33 function testPassed(msg)
34 {
35     if (silentTestPass)
36         didPassSomeTestsSilently = true;
37     else
38         print("PASS", escapeString(msg));
39 }
40
41 function testFailed(msg)
42 {
43     didFailSomeTests = true;
44     print("FAIL", escapeString(msg));
45 }
46
47 function areNumbersEqual(_actual, _expected)
48 {
49     if (_expected === 0)
50         return _actual === _expected && (1/_actual) === (1/_expected);
51     if (_actual === _expected)
52         return true;
53     if (typeof(_expected) == "number" && isNaN(_expected))
54         return typeof(_actual) == "number" && isNaN(_actual);
55     return false;
56 }
57
58 function areArraysEqual(_a, _b)
59 {
60     try {
61         if (_a.length !== _b.length)
62             return false;
63         for (var i = 0; i < _a.length; i++)
64             if (!areNumbersEqual(_a[i], _b[i]))
65                 return false;
66     } catch (ex) {
67         return false;
68     }
69     return true;
70 }
71
72 function isMinusZero(n)
73 {
74     // the only way to tell 0 from -0 in JS is the fact that 1/-0 is
75     // -Infinity instead of Infinity
76     return n === 0 && 1/n < 0;
77 }
78
79 function isTypedArray(array)
80 {
81     return array instanceof Int8Array
82         || array instanceof Int16Array
83         || array instanceof Int32Array
84         || array instanceof Uint8Array
85         || array instanceof Uint8ClampedArray
86         || array instanceof Uint16Array
87         || array instanceof Uint32Array
88         || array instanceof Float32Array
89         || array instanceof Float64Array;
90 }
91
92 function isResultCorrect(_actual, _expected)
93 {
94     if (areNumbersEqual(_actual, _expected))
95         return true;
96     if (_expected
97         && (Object.prototype.toString.call(_expected) ==
98             Object.prototype.toString.call([])
99             || isTypedArray(_expected)))
100         return areArraysEqual(_actual, _expected);
101     return false;
102 }
103
104 function stringify(v)
105 {
106     if (v === 0 && 1/v < 0)
107         return "-0";
108     else if (isTypedArray(v))
109         return v.__proto__.constructor.name + ":[" + Array.prototype.join.call(v, ",") + "]";
110     else
111         return "" + v;
112 }
113
114 function shouldBe(_a, _b, _quiet)
115 {
116     if ((typeof _a != "function" && typeof _a != "string") || (typeof _b != "function" && typeof _b != "string"))
117         debug("WARN: shouldBe() expects function or string arguments");
118     var _exception;
119     var _av;
120     try {
121         _av = (typeof _a == "function" ? _a() : eval(_a));
122     } catch (e) {
123         _exception = e;
124     }
125     var _bv = (typeof _b == "function" ? _b() : eval(_b));
126
127     if (_exception)
128         testFailed(_a + " should be " + stringify(_bv) + ". Threw exception " + _exception);
129     else if (isResultCorrect(_av, _bv)) {
130         if (!_quiet) {
131             testPassed(_a + " is " + (typeof _b == "function" ? _bv : _b));
132         }
133     } else if (typeof(_av) == typeof(_bv))
134         testFailed(_a + " should be " + stringify(_bv) + ". Was " + stringify(_av) + ".");
135     else
136         testFailed(_a + " should be " + stringify(_bv) + " (of type " + typeof _bv + "). Was " + _av + " (of type " + typeof _av + ").");
137 }
138
139 function dfgShouldBe(theFunction, _a, _b)
140 {
141   if (typeof theFunction != "function" || typeof _a != "string" || typeof _b != "string")
142     debug("WARN: dfgShouldBe() expects a function and two strings");
143   noInline(theFunction);
144   var exception;
145   var values = [];
146
147   // Defend against tests that muck with numeric properties on array.prototype.
148   values.__proto__ = null;
149   values.push = Array.prototype.push;
150   
151   try {
152     while (!dfgCompiled({f:theFunction}))
153       values.push(eval(_a));
154     values.push(eval(_a));
155   } catch (e) {
156     exception = e;
157   }
158
159   var _bv = eval(_b);
160   if (exception)
161     testFailed(_a + " should be " + stringify(_bv) + ". On iteration " + (values.length + 1) + ", threw exception " + exception);
162   else {
163     var allPassed = true;
164     for (var i = 0; i < values.length; ++i) {
165       var _av = values[i];
166       if (isResultCorrect(_av, _bv))
167         continue;
168       if (typeof(_av) == typeof(_bv))
169         testFailed(_a + " should be " + stringify(_bv) + ". On iteration " + (i + 1) + ", was " + stringify(_av) + ".");
170       else
171         testFailed(_a + " should be " + stringify(_bv) + " (of type " + typeof _bv + "). On iteration " + (i + 1) + ", was " + _av + " (of type " + typeof _av + ").");
172       allPassed = false;
173     }
174     if (allPassed)
175       testPassed(_a + " is " + _b + " on all iterations including after DFG tier-up.");
176   }
177   
178   return values.length;
179 }
180
181 function shouldBeType(_a, _type) {
182   var exception;
183   var _av;
184   try {
185     _av = eval(_a);
186   } catch (e) {
187     exception = e;
188   }
189
190   var _typev = eval(_type);
191   if (_av instanceof _typev) {
192     testPassed(_a + " is an instance of " + _type);
193   } else {
194     testFailed(_a + " is not an instance of " + _type);
195   }
196 }
197
198 function shouldNotBe(_a, _b, _quiet)
199 {
200     if ((typeof _a != "function" && typeof _a != "string") || (typeof _b != "function" && typeof _b != "string"))
201         debug("WARN: shouldNotBe() expects function or string arguments");
202     var _exception;
203     var _av;
204     try {
205         _av = (typeof _a == "function" ? _a() : eval(_a));
206     } catch (e) {
207         _exception = e;
208     }
209     var _bv = (typeof _b == "function" ? _b() : eval(_b));
210
211     if (_exception)
212         testFailed(_a + " should not be " + _bv + ". Threw exception " + _exception);
213     else if (!isResultCorrect(_av, _bv)) {
214         if (!_quiet) {
215             testPassed(_a + " is not " + (typeof _b == "function" ? _bv : _b));
216         }
217     } else
218         testFailed(_a + " should not be " + _bv + ".");
219 }
220
221 function shouldBeTrue(_a) { shouldBe(_a, "true"); }
222 function shouldBeFalse(_a) { shouldBe(_a, "false"); }
223 function shouldBeNaN(_a) { shouldBe(_a, "NaN"); }
224 function shouldBeNull(_a) { shouldBe(_a, "null"); }
225
226 function shouldBeEqualToString(a, b)
227 {
228   if (typeof a !== "string" || typeof b !== "string")
229     debug("WARN: shouldBeEqualToString() expects string arguments");
230   var unevaledString = JSON.stringify(b);
231   shouldBe(a, unevaledString);
232 }
233
234 function shouldBeUndefined(_a)
235 {
236   var exception;
237   var _av;
238   try {
239      _av = eval(_a);
240   } catch (e) {
241      exception = e;
242   }
243
244   if (exception)
245     testFailed(_a + " should be undefined. Threw exception " + exception);
246   else if (typeof _av == "undefined")
247     testPassed(_a + " is undefined.");
248   else
249     testFailed(_a + " should be undefined. Was " + _av);
250 }
251
252 function shouldBeDefined(_a)
253 {
254   var exception;
255   var _av;
256   try {
257      _av = eval(_a);
258   } catch (e) {
259      exception = e;
260   }
261
262   if (exception)
263     testFailed(_a + " should be defined. Threw exception " + exception);
264   else if (_av !== undefined)
265     testPassed(_a + " is defined.");
266   else
267     testFailed(_a + " should be defined. Was " + _av);
268 }
269
270 function shouldNotThrow(_a, _message) {
271     try {
272         typeof _a == "function" ? _a() : eval(_a);
273         testPassed((_message ? _message : _a) + " did not throw exception.");
274     } catch (e) {
275         testFailed((_message ? _message : _a) + " should not throw exception. Threw exception " + e + ".");
276     }
277 }
278
279 function shouldThrow(_a, _e, _message)
280 {
281     var _exception;
282     var _av;
283     try {
284         _av = typeof _a == "function" ? _a() : eval(_a);
285     } catch (e) {
286         _exception = e;
287     }
288
289     var _ev;
290     if (_e)
291         _ev = eval(_e);
292
293     if (_exception) {
294         if (typeof _e == "undefined" || _exception == _ev)
295             testPassed((_message ? _message : _a) + " threw exception " + _exception + ".");
296         else
297             testFailed((_message ? _message : _a) + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Threw exception " + _exception + ".");
298     } else if (typeof _av == "undefined")
299         testFailed((_message ? _message : _a) + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Was undefined.");
300     else
301         testFailed((_message ? _message : _a) + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Was " + _av + ".");
302 }
303
304 function isSuccessfullyParsed()
305 {
306     // FIXME: Remove this and only report unexpected syntax errors.
307     if (!errorMessage)
308         successfullyParsed = true;
309     shouldBeTrue("successfullyParsed");
310     if (silentTestPass && didPassSomeTestsSilently)
311         debug("Passed some tests silently.");
312     if (silentTestPass && didFailSomeTests)
313         debug("Some tests failed.");
314     debug("\nTEST COMPLETE\n");
315 }
316
317
318 function dfgCompiled(argument)
319 {
320     var numberOfCompiles = "compiles" in argument ? argument.compiles : 1;
321     
322     if (!("f" in argument))
323         throw new Error("dfgCompiled called with invalid argument.");
324     
325     if (argument.f instanceof Array) {
326         for (var i = 0; i < argument.f.length; ++i) {
327             if (testRunner.numberOfDFGCompiles(argument.f[i]) < numberOfCompiles)
328                 return false;
329         }
330     } else {
331         if (testRunner.numberOfDFGCompiles(argument.f) < numberOfCompiles)
332             return false;
333     }
334     
335     return true;
336 }
337
338 function dfgIncrement(argument)
339 {
340     if (!self.testRunner)
341         return argument.i;
342     
343     if (argument.i < argument.n)
344         return argument.i;
345     
346     if (didFailSomeTests)
347         return argument.i;
348     
349     if (!dfgCompiled(argument))
350         return "start" in argument ? argument.start : 0;
351     
352     return argument.i;
353 }
354
355 function noInline(theFunction)
356 {
357     if (!self.testRunner)
358         return;
359     
360     testRunner.neverInlineFunction(theFunction);
361 }
362
363 // It's possible for an async test to call finishJSTest() before js-test-post.js
364 // has been parsed.
365 function finishJSTest()
366 {
367     wasFinishJSTestCalled = true;
368     if (!wasPostTestScriptParsed)
369         return;
370     isSuccessfullyParsed();
371 }