Lines Matching full:n
9 "function FindProxyForURL(url, host){\n" \
10 " function opt() {\n" \
11 " opt['x'] = 1.1;\n" \
12 " try {\n" \
13 " Object.create(object);\n" \
14 " } catch (e) {\n" \
15 " }\n" \
16 "\n" \
17 " for (let i = 0; i < 100000; i++) {\n" \
18 "\n" \
19 " }\n" \
20 " }\n" \
21 "\n" \
22 " opt();\n" \
23 " object = opt;\n" \
24 " opt();\n" \
25 "\n" \
26 " return \"DIRECT\";\n" \
27 "}\n" \
28 "\n" \
29 "var object;\n" \
33 "// Calls a bindings outside of FindProxyForURL(). This causes the code to\n" \
34 "// get exercised during initialization.\n" \
35 "\n" \
36 "var x = myIpAddress();\n" \
37 "\n" \
38 "function FindProxyForURL(url, host) {\n" \
39 " return \"PROXY \" + x + \":80\";\n" \
40 "}\n" \
44 "// Try calling the browser-side bound functions with varying (invalid)\n" \
45 "// inputs. There is no notion of \"success\" for this test, other than\n" \
46 "// verifying the correct C++ bindings were reached with expected values.\n" \
47 "\n" \
48 "function MyObject() {\n" \
49 " this.x = \"3\";\n" \
50 "}\n" \
51 "\n" \
52 "MyObject.prototype.toString = function() {\n" \
53 " throw \"exception from calling toString()\";\n" \
54 "}\n" \
55 "\n" \
56 "function expectEquals(expectation, actual) {\n" \
57 " if (!(expectation === actual)) {\n" \
58 " throw \"FAIL: expected: \" + expectation + \", actual: \" + actual;\n" \
59 " }\n" \
60 "}\n" \
61 "\n" \
62 "function FindProxyForURL(url, host) {\n" \
63 " // Call dnsResolve with some wonky arguments.\n" \
64 " // Those expected to fail (because we have passed a non-string parameter)\n" \
65 " // will return |null|, whereas those that have called through to the C++\n" \
66 " // bindings will return '127.0.0.1'.\n" \
67 " expectEquals(undefined, dnsResolve());\n" \
68 " expectEquals(undefined, dnsResolve(null));\n" \
69 " expectEquals(undefined, dnsResolve(undefined));\n" \
70 " expectEquals('127.0.0.1', dnsResolve(\"\"));\n" \
71 " expectEquals(undefined, dnsResolve({foo: 'bar'}));\n" \
72 " expectEquals(undefined, dnsResolve(fn));\n" \
73 " expectEquals(undefined, dnsResolve(['3']));\n" \
74 " expectEquals('127.0.0.1', dnsResolve(\"arg1\", \"arg2\", \"arg3\", \"arg4\"));\n" \
75 "\n" \
76 " // Call alert with some wonky arguments.\n" \
77 " alert();\n" \
78 " alert(null);\n" \
79 " alert(undefined);\n" \
80 " alert({foo:'bar'});\n" \
81 "\n" \
82 " // This should throw an exception when we toString() the argument\n" \
83 " // to alert in the bindings.\n" \
84 " try {\n" \
85 " alert(new MyObject());\n" \
86 " } catch (e) {\n" \
87 " alert(e);\n" \
88 " }\n" \
89 "\n" \
90 " // Call myIpAddress() with wonky arguments\n" \
91 " myIpAddress(null);\n" \
92 " myIpAddress(null, null);\n" \
93 "\n" \
94 " // Call myIpAddressEx() correctly (no arguments).\n" \
95 " myIpAddressEx();\n" \
96 "\n" \
97 " // Call dnsResolveEx() (note that isResolvableEx() implicity calls it.)\n" \
98 " isResolvableEx(\"is_resolvable\");\n" \
99 " dnsResolveEx(\"foobar\");\n" \
100 "\n" \
101 " return \"DIRECT\";\n" \
102 "}\n" \
103 "\n" \
104 "function fn() {}\n" \
105 "\n" \
109 "// PAC script with getter that changes element kind.\n" \
110 "\n" \
111 "function FindProxyForURL(url, host) {\n" \
112 " let arr = [];\n" \
113 " arr[1000] = 0x1234;\n" \
114 "\n" \
115 " arr.__defineGetter__(256, function () {\n" \
116 " delete arr[256];\n" \
117 " arr.unshift(1.1);\n" \
118 " });\n" \
119 "\n" \
120 " let results = Object.entries(arr);\n" \
121 " let str = results.toString();\n" \
122 " return \"DIRECT\";\n" \
123 "}\n" \
127 "function FindProxyForURL(url, host) {\n" \
128 " return \"DIRECT\";\n" \
129 "}\n" \
130 "\n" \
134 "// This script should be run in an environment where all DNS resolution are\n" \
135 "// failing. It tests that functions return the expected values.\n" \
136 "//\n" \
137 "// Returns \"PROXY success:80\" on success.\n" \
138 "function FindProxyForURL(url, host) {\n" \
139 " try {\n" \
140 " expectEq(\"127.0.0.1\", myIpAddress());\n" \
141 " expectEq(\"\", myIpAddressEx());\n" \
142 "\n" \
143 " expectEq(null, dnsResolve(\"not-found\"));\n" \
144 " expectEq(\"\", dnsResolveEx(\"not-found\"));\n" \
145 "\n" \
146 " expectEq(false, isResolvable(\"not-found\"));\n" \
147 " expectEq(false, isResolvableEx(\"not-found\"));\n" \
148 "\n" \
149 " return \"PROXY success:80\";\n" \
150 " } catch(e) {\n" \
151 " alert(e);\n" \
152 " return \"PROXY failed:80\";\n" \
153 " }\n" \
154 "}\n" \
155 "\n" \
156 "function expectEq(expected, actual) {\n" \
157 " if (expected != actual)\n" \
158 " throw \"Expected \" + expected + \" but was \" + actual;\n" \
159 "}\n" \
160 "\n" \
164 "function FindProxyForURL(url, host) {\n" \
165 " return \"PROXY success:80\";\n" \
166 "}\n" \
167 "\n" \
168 "// We end the script with a comment (and no trailing newline).\n" \
169 "// This used to cause problems, because internally ProxyResolverV8\n" \
170 "// would append some functions to the script; the first line of\n" \
171 "// those extra functions was being considered part of the comment.\n" \
175 "// Ends with a statement, and no terminal newline.\n" \
176 "function FindProxyForURL(url, host) { return \"PROXY success:\" + x; }\n" \
177 "x = 3\n" \
181 "// Try resolving hostnames containing non-ASCII characters.\n" \
182 "\n" \
183 "function FindProxyForURL(url, host) {\n" \
184 " // This international hostname has a non-ASCII character. It is represented\n" \
185 " // in punycode as 'xn--bcher-kva.ch'\n" \
186 " var idn = 'B\u00fccher.ch';\n" \
187 "\n" \
188 " // We disregard the actual return value -- all we care about is that on\n" \
189 " // the C++ end the bindings were passed the punycode equivalent of this\n" \
190 " // unicode hostname.\n" \
191 " dnsResolve(idn);\n" \
192 " dnsResolveEx(idn);\n" \
193 "\n" \
194 " return \"DIRECT\";\n" \
195 "}\n" \
196 "\n" \
200 "// This PAC script is invalid, because there is a missing close brace\n" \
201 "// on the function FindProxyForURL().\n" \
202 "\n" \
203 "function FindProxyForURL(url, host) {\n" \
204 " return \"DIRECT\";\n" \
205 "\n" \
209 "var x = \"This is an invalid PAC script because it lacks a \" +\n" \
210 " \"FindProxyForURL() function\";\n" \
214 "// This should output \"PROXY success:80\" if all the tests pass.\n" \
215 "// Otherwise it will output \"PROXY failure:<num-failures>\".\n" \
216 "//\n" \
217 "// This aims to unit-test the PAC library functions, which are\n" \
218 "// exposed in the PAC's execution environment. (Namely, dnsDomainLevels,\n" \
219 "// timeRange, etc.)\n" \
220 "\n" \
221 "function FindProxyForURL(url, host) {\n" \
222 " var numTestsFailed = 0;\n" \
223 "\n" \
224 " // Run all the tests\n" \
225 " for (var test in Tests) {\n" \
226 " var t = new TestContext(test);\n" \
227 "\n" \
228 " // Run the test.\n" \
229 " Tests[test](t);\n" \
230 "\n" \
231 " if (t.failed()) {\n" \
232 " numTestsFailed++;\n" \
233 " }\n" \
234 " }\n" \
235 "\n" \
236 " if (numTestsFailed == 0) {\n" \
237 " return \"PROXY success:80\";\n" \
238 " }\n" \
239 " return \"PROXY failure:\" + numTestsFailed;\n" \
240 "}\n" \
241 "\n" \
242 "// --------------------------\n" \
243 "// Tests\n" \
244 "// --------------------------\n" \
245 "\n" \
246 "var Tests = {};\n" \
247 "\n" \
248 "Tests.testDnsDomainIs = function(t) {\n" \
249 " t.expectTrue(dnsDomainIs(\"google.com\", \".com\"));\n" \
250 " t.expectTrue(dnsDomainIs(\"google.co.uk\", \".co.uk\"));\n" \
251 " t.expectFalse(dnsDomainIs(\"google.com\", \".co.uk\"));\n" \
252 " t.expectFalse(dnsDomainIs(\"www.adobe.com\", \".ad\"));\n" \
253 "};\n" \
254 "\n" \
255 "Tests.testDnsDomainLevels = function(t) {\n" \
256 " t.expectEquals(0, dnsDomainLevels(\"www\"));\n" \
257 " t.expectEquals(2, dnsDomainLevels(\"www.google.com\"));\n" \
258 " t.expectEquals(3, dnsDomainLevels(\"192.168.1.1\"));\n" \
259 "};\n" \
260 "\n" \
261 "Tests.testIsInNet = function(t) {\n" \
262 " t.expectTrue(\n" \
263 " isInNet(\"192.89.132.25\", \"192.89.132.25\", \"255.255.255.255\"));\n" \
264 " t.expectFalse(\n" \
265 " isInNet(\"193.89.132.25\", \"192.89.132.25\", \"255.255.255.255\"));\n" \
266 "\n" \
267 " t.expectTrue(isInNet(\"192.89.132.25\", \"192.89.0.0\", \"255.255.0.0\"));\n" \
268 " t.expectFalse(isInNet(\"193.89.132.25\", \"192.89.0.0\", \"255.255.0.0\"));\n" \
269 "\n" \
270 " t.expectFalse(\n" \
271 " isInNet(\"192.89.132.a\", \"192.89.0.0\", \"255.255.0.0\"));\n" \
272 "};\n" \
273 "\n" \
274 "Tests.testIsPlainHostName = function(t) {\n" \
275 " t.expectTrue(isPlainHostName(\"google\"));\n" \
276 " t.expectFalse(isPlainHostName(\"google.com\"));\n" \
277 "};\n" \
278 "\n" \
279 "Tests.testLocalHostOrDomainIs = function(t) {\n" \
280 " t.expectTrue(localHostOrDomainIs(\"www.google.com\", \"www.google.com\"));\n" \
281 " t.expectTrue(localHostOrDomainIs(\"www\", \"www.google.com\"));\n" \
282 " t.expectFalse(localHostOrDomainIs(\"maps.google.com\", \"www.google.com\"));\n" \
283 "};\n" \
284 "\n" \
285 "Tests.testShExpMatch = function(t) {\n" \
286 " t.expectTrue(shExpMatch(\"foo.jpg\", \"*.jpg\"));\n" \
287 " t.expectTrue(shExpMatch(\"foo5.jpg\", \"*o?.jpg\"));\n" \
288 " t.expectFalse(shExpMatch(\"foo.jpg\", \".jpg\"));\n" \
289 " t.expectFalse(shExpMatch(\"foo.jpg\", \"foo\"));\n" \
290 "};\n" \
291 "\n" \
292 "Tests.testSortIpAddressList = function(t) {\n" \
293 " t.expectEquals(\"::1;::2;::3\", sortIpAddressList(\"::2;::3;::1\"));\n" \
294 " t.expectEquals(\n" \
295 " \"2001:4898:28:3:201:2ff:feea:fc14;fe80::5efe:157:9d3b:8b16;157.59.139.22\",\n" \
296 " sortIpAddressList(\"157.59.139.22;\" +\n" \
297 " \"2001:4898:28:3:201:2ff:feea:fc14;\" +\n" \
298 " \"fe80::5efe:157:9d3b:8b16\"));\n" \
299 "\n" \
300 " // Single IP address (v4 and v6).\n" \
301 " t.expectEquals(\"127.0.0.1\", sortIpAddressList(\"127.0.0.1\"));\n" \
302 " t.expectEquals(\"::1\", sortIpAddressList(\"::1\"))\n" \
303 "\n" \
304 " // Verify that IPv6 address is not re-written (not reduced).\n" \
305 " t.expectEquals(\"0:0::1;192.168.1.1\", sortIpAddressList(\"192.168.1.1;0:0::1\"));\n" \
306 "\n" \
307 " // Input is already sorted.\n" \
308 " t.expectEquals(\"::1;192.168.1.3\", sortIpAddressList(\"::1;192.168.1.3\"));\n" \
309 "\n" \
310 " // Same-valued IP addresses (also tests stability).\n" \
311 " t.expectEquals(\"0::1;::1;0:0::1\", sortIpAddressList(\"0::1;::1;0:0::1\"));\n" \
312 "\n" \
313 " // Contains extra semi-colons.\n" \
314 " t.expectEquals(\"127.0.0.1\", sortIpAddressList(\";127.0.0.1;\"));\n" \
315 "\n" \
316 " // Contains whitespace (spaces and tabs).\n" \
317 " t.expectEquals(\"192.168.0.1;192.168.0.2\",\n" \
318 " sortIpAddressList(\"192.168.0.1; 192.168.0.2\"));\n" \
319 " t.expectEquals(\"127.0.0.0;127.0.0.1;127.0.0.2\",\n" \
320 " sortIpAddressList(\"127.0.0.1; 127.0.0.2; 127.0.0.0\"));\n" \
321 "\n" \
322 " // Empty lists.\n" \
323 " t.expectFalse(sortIpAddressList(\"\"));\n" \
324 " t.expectFalse(sortIpAddressList(\" \"));\n" \
325 " t.expectFalse(sortIpAddressList(\";\"));\n" \
326 " t.expectFalse(sortIpAddressList(\";;\"));\n" \
327 " t.expectFalse(sortIpAddressList(\" ; ; \"));\n" \
328 "\n" \
329 " // Invalid IP addresses.\n" \
330 " t.expectFalse(sortIpAddressList(\"256.0.0.1\"));\n" \
331 " t.expectFalse(sortIpAddressList(\"192.168.1.1;0:0:0:1;127.0.0.1\"));\n" \
332 "\n" \
333 " // Call sortIpAddressList() with wonky arguments.\n" \
334 " t.expectEquals(null, sortIpAddressList());\n" \
335 " t.expectEquals(null, sortIpAddressList(null));\n" \
336 " t.expectEquals(null, sortIpAddressList(null, null));\n" \
337 "};\n" \
338 "\n" \
339 "Tests.testIsInNetEx = function(t) {\n" \
340 " t.expectTrue(isInNetEx(\"198.95.249.79\", \"198.95.249.79/32\"));\n" \
341 " t.expectTrue(isInNetEx(\"198.95.115.10\", \"198.95.0.0/16\"));\n" \
342 " t.expectTrue(isInNetEx(\"198.95.1.1\", \"198.95.0.0/16\"));\n" \
343 " t.expectTrue(isInNetEx(\"198.95.1.1\", \"198.95.3.3/16\"));\n" \
344 " t.expectTrue(isInNetEx(\"0:0:0:0:0:0:7f00:1\", \"0:0:0:0:0:0:7f00:1/32\"));\n" \
345 " t.expectTrue(isInNetEx(\"3ffe:8311:ffff:abcd:1234:dead:beef:101\",\n" \
346 " \"3ffe:8311:ffff::/48\"));\n" \
347 "\n" \
348 " // IPv4 and IPv6 mix.\n" \
349 " t.expectFalse(isInNetEx(\"127.0.0.1\", \"0:0:0:0:0:0:7f00:1/16\"));\n" \
350 " t.expectFalse(isInNetEx(\"192.168.24.3\", \"fe80:0:0:0:0:0:c0a8:1803/32\"));\n" \
351 "\n" \
352 " t.expectFalse(isInNetEx(\"198.95.249.78\", \"198.95.249.79/32\"));\n" \
353 " t.expectFalse(isInNetEx(\"198.96.115.10\", \"198.95.0.0/16\"));\n" \
354 " t.expectFalse(isInNetEx(\"3fff:8311:ffff:abcd:1234:dead:beef:101\",\n" \
355 " \"3ffe:8311:ffff::/48\"));\n" \
356 "\n" \
357 " // Call isInNetEx with wonky arguments.\n" \
358 " t.expectEquals(null, isInNetEx());\n" \
359 " t.expectEquals(null, isInNetEx(null));\n" \
360 " t.expectEquals(null, isInNetEx(null, null));\n" \
361 " t.expectEquals(null, isInNetEx(null, null, null));\n" \
362 " t.expectEquals(null, isInNetEx(\"198.95.249.79\"));\n" \
363 "\n" \
364 " // Invalid IP address.\n" \
365 " t.expectFalse(isInNetEx(\"256.0.0.1\", \"198.95.249.79\"));\n" \
366 " t.expectFalse(isInNetEx(\"127.0.0.1 \", \"127.0.0.1/32\")); // Extra space.\n" \
367 "\n" \
368 " // Invalid prefix.\n" \
369 " t.expectFalse(isInNetEx(\"198.95.115.10\", \"198.95.0.0/34\"));\n" \
370 " t.expectFalse(isInNetEx(\"127.0.0.1\", \"127.0.0.1\")); // Missing '/' in prefix.\n" \
371 "};\n" \
372 "\n" \
373 "Tests.testWeekdayRange = function(t) {\n" \
374 " // Test with local time.\n" \
375 " MockDate.setCurrent(\"Tue Mar 03 2009\");\n" \
376 " t.expectEquals(true, weekdayRange(\"MON\", \"FRI\"));\n" \
377 " t.expectEquals(true, weekdayRange(\"TUE\", \"FRI\"));\n" \
378 " t.expectEquals(true, weekdayRange(\"TUE\", \"TUE\"));\n" \
379 " t.expectEquals(true, weekdayRange(\"TUE\"));\n" \
380 " t.expectEquals(false, weekdayRange(\"WED\", \"FRI\"));\n" \
381 " t.expectEquals(false, weekdayRange(\"SUN\", \"MON\"));\n" \
382 " t.expectEquals(false, weekdayRange(\"SAT\"));\n" \
383 " t.expectEquals(false, weekdayRange(\"FRI\", \"MON\"));\n" \
384 "\n" \
385 " // Test with GMT time.\n" \
386 " MockDate.setCurrent(\"Tue Mar 03 2009 GMT\");\n" \
387 " t.expectEquals(true, weekdayRange(\"MON\", \"FRI\", \"GMT\"));\n" \
388 " t.expectEquals(true, weekdayRange(\"TUE\", \"FRI\", \"GMT\"));\n" \
389 " t.expectEquals(true, weekdayRange(\"TUE\", \"TUE\", \"GMT\"));\n" \
390 " t.expectEquals(true, weekdayRange(\"TUE\", \"GMT\"));\n" \
391 " t.expectEquals(false, weekdayRange(\"WED\", \"FRI\", \"GMT\"));\n" \
392 " t.expectEquals(false, weekdayRange(\"SUN\", \"MON\", \"GMT\"));\n" \
393 " t.expectEquals(false, weekdayRange(\"SAT\", \"GMT\"));\n" \
394 "};\n" \
395 "\n" \
396 "Tests.testDateRange = function(t) {\n" \
397 " // dateRange(day)\n" \
398 " MockDate.setCurrent(\"Mar 03 2009\");\n" \
399 " t.expectEquals(true, dateRange(3));\n" \
400 " t.expectEquals(false, dateRange(1));\n" \
401 "\n" \
402 " // dateRange(day, \"GMT\")\n" \
403 " MockDate.setCurrent(\"Mar 03 2009 GMT\");\n" \
404 " t.expectEquals(true, dateRange(3, \"GMT\"));\n" \
405 " t.expectEquals(false, dateRange(1, \"GMT\"));\n" \
406 "\n" \
407 " // dateRange(day1, day2)\n" \
408 " MockDate.setCurrent(\"Mar 03 2009\");\n" \
409 " t.expectEquals(true, dateRange(1, 4));\n" \
410 " t.expectEquals(false, dateRange(4, 20));\n" \
411 "\n" \
412 " // dateRange(day, month)\n" \
413 " MockDate.setCurrent(\"Mar 03 2009\");\n" \
414 " t.expectEquals(true, dateRange(3, \"MAR\"));\n" \
415 " MockDate.setCurrent(\"Mar 03 2014\");\n" \
416 " t.expectEquals(true, dateRange(3, \"MAR\"));\n" \
417 " // TODO(eroman):\n" \
418 " //t.expectEquals(false, dateRange(2, \"MAR\"));\n" \
419 " //t.expectEquals(false, dateRange(3, \"JAN\"));\n" \
420 "\n" \
421 " // dateRange(day, month, year)\n" \
422 " MockDate.setCurrent(\"Mar 03 2009\");\n" \
423 " t.expectEquals(true, dateRange(3, \"MAR\", 2009));\n" \
424 " t.expectEquals(false, dateRange(4, \"MAR\", 2009));\n" \
425 " t.expectEquals(false, dateRange(3, \"FEB\", 2009));\n" \
426 " MockDate.setCurrent(\"Mar 03 2014\");\n" \
427 " t.expectEquals(false, dateRange(3, \"MAR\", 2009));\n" \
428 "\n" \
429 " // dateRange(month1, month2)\n" \
430 " MockDate.setCurrent(\"Mar 03 2009\");\n" \
431 " t.expectEquals(true, dateRange(\"JAN\", \"MAR\"));\n" \
432 " t.expectEquals(true, dateRange(\"MAR\", \"APR\"));\n" \
433 " t.expectEquals(false, dateRange(\"MAY\", \"SEP\"));\n" \
434 "\n" \
435 " // dateRange(day1, month1, day2, month2)\n" \
436 " MockDate.setCurrent(\"Mar 03 2009\");\n" \
437 " t.expectEquals(true, dateRange(1, \"JAN\", 3, \"MAR\"));\n" \
438 " t.expectEquals(true, dateRange(3, \"MAR\", 4, \"SEP\"));\n" \
439 " t.expectEquals(false, dateRange(4, \"MAR\", 4, \"SEP\"));\n" \
440 "\n" \
441 " // dateRange(month1, year1, month2, year2)\n" \
442 " MockDate.setCurrent(\"Mar 03 2009\");\n" \
443 " t.expectEquals(true, dateRange(\"FEB\", 2009, \"MAR\", 2009));\n" \
444 " MockDate.setCurrent(\"Apr 03 2009\");\n" \
445 " t.expectEquals(true, dateRange(\"FEB\", 2009, \"MAR\", 2010));\n" \
446 " t.expectEquals(false, dateRange(\"FEB\", 2009, \"MAR\", 2009));\n" \
447 "\n" \
448 " // dateRange(day1, month1, year1, day2, month2, year2)\n" \
449 " MockDate.setCurrent(\"Mar 03 2009\");\n" \
450 " t.expectEquals(true, dateRange(1, \"JAN\", 2009, 3, \"MAR\", 2009));\n" \
451 " t.expectEquals(true, dateRange(3, \"MAR\", 2009, 4, \"SEP\", 2009));\n" \
452 " t.expectEquals(true, dateRange(3, \"JAN\", 2009, 4, \"FEB\", 2010));\n" \
453 " t.expectEquals(false, dateRange(4, \"MAR\", 2009, 4, \"SEP\", 2009));\n" \
454 "};\n" \
455 "\n" \
456 "Tests.testTimeRange = function(t) {\n" \
457 " // timeRange(hour)\n" \
458 " MockDate.setCurrent(\"Mar 03, 2009 03:34:01\");\n" \
459 " t.expectEquals(true, timeRange(3));\n" \
460 " t.expectEquals(false, timeRange(2));\n" \
461 "\n" \
462 " // timeRange(hour1, hour2)\n" \
463 " MockDate.setCurrent(\"Mar 03, 2009 03:34:01\");\n" \
464 " t.expectEquals(true, timeRange(2, 3));\n" \
465 " t.expectEquals(true, timeRange(2, 4));\n" \
466 " t.expectEquals(true, timeRange(3, 5));\n" \
467 " t.expectEquals(false, timeRange(1, 2));\n" \
468 " t.expectEquals(false, timeRange(11, 12));\n" \
469 "\n" \
470 " // timeRange(hour1, min1, hour2, min2)\n" \
471 " MockDate.setCurrent(\"Mar 03, 2009 03:34:01\");\n" \
472 " t.expectEquals(true, timeRange(1, 0, 3, 34));\n" \
473 " t.expectEquals(true, timeRange(1, 0, 3, 35));\n" \
474 " t.expectEquals(true, timeRange(3, 34, 5, 0));\n" \
475 " t.expectEquals(false, timeRange(1, 0, 3, 0));\n" \
476 " t.expectEquals(false, timeRange(11, 0, 16, 0));\n" \
477 "\n" \
478 " // timeRange(hour1, min1, sec1, hour2, min2, sec2)\n" \
479 " MockDate.setCurrent(\"Mar 03, 2009 03:34:14\");\n" \
480 " t.expectEquals(true, timeRange(1, 0, 0, 3, 34, 14));\n" \
481 " t.expectEquals(false, timeRange(1, 0, 0, 3, 34, 0));\n" \
482 " t.expectEquals(true, timeRange(1, 0, 0, 3, 35, 0));\n" \
483 " t.expectEquals(true, timeRange(3, 34, 0, 5, 0, 0));\n" \
484 " t.expectEquals(false, timeRange(1, 0, 0, 3, 0, 0));\n" \
485 " t.expectEquals(false, timeRange(11, 0, 0, 16, 0, 0));\n" \
486 "};\n" \
487 "\n" \
488 "// --------------------------\n" \
489 "// TestContext\n" \
490 "// --------------------------\n" \
491 "\n" \
492 "// |name| is the name of the test being executed, it will be used when logging\n" \
493 "// errors.\n" \
494 "function TestContext(name) {\n" \
495 " this.numFailures_ = 0;\n" \
496 " this.name_ = name;\n" \
497 "};\n" \
498 "\n" \
499 "TestContext.prototype.failed = function() {\n" \
500 " return this.numFailures_ != 0;\n" \
501 "};\n" \
502 "\n" \
503 "TestContext.prototype.expectEquals = function(expectation, actual) {\n" \
504 " if (!(expectation === actual)) {\n" \
505 " this.numFailures_++;\n" \
506 " this.log(\"FAIL: expected: \" + expectation + \", actual: \" + actual);\n" \
507 " }\n" \
508 "};\n" \
509 "\n" \
510 "TestContext.prototype.expectTrue = function(x) {\n" \
511 " this.expectEquals(true, x);\n" \
512 "};\n" \
513 "\n" \
514 "TestContext.prototype.expectFalse = function(x) {\n" \
515 " this.expectEquals(false, x);\n" \
516 "};\n" \
517 "\n" \
518 "TestContext.prototype.log = function(x) {\n" \
519 " // Prefix with the test name that generated the log.\n" \
520 " try {\n" \
521 " alert(this.name_ + \": \" + x);\n" \
522 " } catch(e) {\n" \
523 " // In case alert() is not defined.\n" \
524 " }\n" \
525 "};\n" \
526 "\n" \
527 "// --------------------------\n" \
528 "// MockDate\n" \
529 "// --------------------------\n" \
530 "\n" \
531 "function MockDate() {\n" \
532 " this.wrappedDate_ = new MockDate.super_(MockDate.currentDateString_);\n" \
533 "};\n" \
534 "\n" \
535 "// Setup the MockDate so it forwards methods to \"this.wrappedDate_\" (which is a\n" \
536 "// real Date object). We can't simply chain the prototypes since Date() doesn't\n" \
537 "// allow it.\n" \
538 "MockDate.init = function() {\n" \
539 " MockDate.super_ = Date;\n" \
540 "\n" \
541 " function createProxyMethod(methodName) {\n" \
542 " return function() {\n" \
543 " return this.wrappedDate_[methodName]\n" \
544 " .apply(this.wrappedDate_, arguments);\n" \
545 " }\n" \
546 " };\n" \
547 "\n" \
548 " for (i in MockDate.methodNames_) {\n" \
549 " var methodName = MockDate.methodNames_[i];\n" \
550 " // Don't define the closure directly in the loop body, since Javascript's\n" \
551 " // crazy scoping rules mean |methodName| actually bleeds out of the loop!\n" \
552 " MockDate.prototype[methodName] = createProxyMethod(methodName);\n" \
553 " }\n" \
554 "\n" \
555 " // Replace the native Date() with our mock.\n" \
556 " Date = MockDate;\n" \
557 "};\n" \
558 "\n" \
559 "// Unfortunately Date()'s methods are non-enumerable, therefore list manually.\n" \
560 "MockDate.methodNames_ = [\n" \
561 " \"toString\", \"toDateString\", \"toTimeString\", \"toLocaleString\",\n" \
562 " \"toLocaleDateString\", \"toLocaleTimeString\", \"valueOf\", \"getTime\",\n" \
563 " \"getFullYear\", \"getUTCFullYear\", \"getMonth\", \"getUTCMonth\",\n" \
564 " \"getDate\", \"getUTCDate\", \"getDay\", \"getUTCDay\", \"getHours\", \"getUTCHours\",\n" \
565 " \"getMinutes\", \"getUTCMinutes\", \"getSeconds\", \"getUTCSeconds\",\n" \
566 " \"getMilliseconds\", \"getUTCMilliseconds\", \"getTimezoneOffset\", \"setTime\",\n" \
567 " \"setMilliseconds\", \"setUTCMilliseconds\", \"setSeconds\", \"setUTCSeconds\",\n" \
568 " \"setMinutes\", \"setUTCMinutes\", \"setHours\", \"setUTCHours\", \"setDate\",\n" \
569 " \"setUTCDate\", \"setMonth\", \"setUTCMonth\", \"setFullYear\", \"setUTCFullYear\",\n" \
570 " \"toGMTString\", \"toUTCString\", \"getYear\", \"setYear\"\n" \
571 "];\n" \
572 "\n" \
573 "MockDate.setCurrent = function(currentDateString) {\n" \
574 " MockDate.currentDateString_ = currentDateString;\n" \
575 "}\n" \
576 "\n" \
577 "// Bind the methods to proxy requests to the wrapped Date().\n" \
578 "MockDate.init();\n" \
579 "\n" \
583 "// Return a single-proxy result, which encodes ALL the arguments that were\n" \
584 "// passed to FindProxyForURL().\n" \
585 "\n" \
586 "function FindProxyForURL(url, host) {\n" \
587 " if (arguments.length != 2) {\n" \
588 " throw \"Wrong number of arguments passed to FindProxyForURL!\";\n" \
589 " return \"FAIL\";\n" \
590 " }\n" \
591 "\n" \
592 " return \"PROXY \" + makePseudoHost(url + \".\" + host);\n" \
593 "}\n" \
594 "\n" \
595 "// Form a string that kind-of resembles a host. We will replace any\n" \
596 "// non-alphanumeric character with a dot, then fix up the oddly placed dots.\n" \
597 "function makePseudoHost(str) {\n" \
598 " var result = \"\";\n" \
599 "\n" \
600 " for (var i = 0; i < str.length; ++i) {\n" \
601 " var c = str.charAt(i);\n" \
602 " if (!isValidPseudoHostChar(c)) {\n" \
603 " c = '.'; // Replace unsupported characters with a dot.\n" \
604 " }\n" \
605 "\n" \
606 " // Take care not to place multiple adjacent dots,\n" \
607 " // a dot at the beginning, or a dot at the end.\n" \
608 " if (c == '.' &&\n" \
609 " (result.length == 0 || \n" \
610 " i == str.length - 1 ||\n" \
611 " result.charAt(result.length - 1) == '.')) {\n" \
612 " continue;\n" \
613 " }\n" \
614 " result += c;\n" \
615 " }\n" \
616 " return result;\n" \
617 "}\n" \
618 "\n" \
619 "function isValidPseudoHostChar(c) {\n" \
620 " if (c >= '0' && c <= '9')\n" \
621 " return true;\n" \
622 " if (c >= 'a' && c <= 'z')\n" \
623 " return true;\n" \
624 " if (c >= 'A' && c <= 'Z')\n" \
625 " return true;\n" \
626 " return false;\n" \
627 "}\n" \
631 "function FindProxyForURL(url, host) {\n" \
632 " return \"\";\n" \
633 "}\n" \
634 "\n" \
638 "function FindProxyForURL(url, host) {\n" \
639 " return FindProxyForURL;\n" \
640 "}\n" \
641 "\n" \
645 "function FindProxyForURL(url, host) {\n" \
646 " return 0;\n" \
647 "}\n" \
648 "\n" \
652 "function FindProxyForURL(url, host) {\n" \
653 " return null;\n" \
654 "}\n" \
655 "\n" \
659 "function FindProxyForURL(url, host) {\n" \
660 " return {result: \"PROXY foo\"};\n" \
661 "}\n" \
662 "\n" \
666 "function FindProxyForURL(url, host) {\n" \
667 " return undefined;\n" \
668 "}\n" \
669 "\n" \
673 "// U+200B is the codepoint for zero-width-space.\n" \
674 "function FindProxyForURL(url, host) {\n" \
675 " return \"PROXY foo.com\u200B\";\n" \
676 "}\n" \
680 "if (!gCounter) {\n" \
681 " // We write it this way so if the script gets loaded twice,\n" \
682 " // gCounter remains dirty.\n" \
683 " var gCounter = 0;\n" \
684 "}\n" \
685 "\n" \
686 "function FindProxyForURL(url, host) {\n" \
687 " return \"PROXY sideffect_\" + gCounter++;\n" \
688 "}\n" \
689 "\n" \
693 "// PAC script which uses isInNet on both IP addresses and hosts, and calls\n" \
694 "// isResolvable().\n" \
695 "\n" \
696 "function FindProxyForURL(url, host) {\n" \
697 " var my_ip = myIpAddress();\n" \
698 "\n" \
699 " if (isInNet(my_ip, \"172.16.0.0\", \"255.248.0.0\")) {\n" \
700 " return \"PROXY a:80\";\n" \
701 " }\n" \
702 "\n" \
703 " if (url.substring(0, 6) != \"https:\" &&\n" \
704 " isInNet(host, \"10.0.0.0\", \"255.0.0.0\")) {\n" \
705 " return \"PROXY b:80\";\n" \
706 " }\n" \
707 "\n" \
708 " if (dnsDomainIs(host, \"foo.bar.baz.com\") || !isResolvable(host)) {\n" \
709 " return \"PROXY c:100\";\n" \
710 " }\n" \
711 "\n" \
712 " return \"DIRECT\";\n" \
713 "}\n" \
717 "function FindProxyForURL(url, host) {\n" \
718 " return \"direct\".toUpperCase();\n" \
719 "}\n" \
723 "function FindProxyForURL(url, host) {\n" \
724 " // This will throw a runtime exception.\n" \
725 " return \"PROXY x\" + undefined_variable;\n" \
726 "}\n" \
727 "\n" \