diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000000..8b2754cd9d4
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+/node_modules/
+/.local-chromium/
+/.dev_profile*
+.DS_Store
+*.swp
+*.pyc
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000000..ae319c70aca
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,23 @@
+# How to Contribute
+
+We'd love to accept your patches and contributions to this project. There are
+just a few small guidelines you need to follow.
+
+## Contributor License Agreement
+
+Contributions to this project must be accompanied by a Contributor License
+Agreement. You (or your employer) retain the copyright to your contribution,
+this simply gives us permission to use and redistribute your contributions as
+part of the project. Head over to to see
+your current agreements on file or to sign a new one.
+
+You generally only need to submit a CLA once, so if you've already submitted one
+(even if it was for a different project), you probably don't need to do it
+again.
+
+## Code reviews
+
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose. Consult
+[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
+information on using pull requests.
diff --git a/README.md b/README.md
index 50eee758267..699aa6915f8 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,36 @@
-# puppeteer
-Headless Chrome Node API
+### Status
+
+Test results on Mac OS X in headless mode:
+```
+ 111 passed
+ 20 failed as expected
+ 1 skipped
+ 49 unsupported
+```
+
+### Installing
+
+```bash
+npm i
+npm link # this adds puppeteer to $PATH
+```
+
+### Run
+
+```bash
+# run phantomjs script
+puppeteer third_party/phantomjs/examples/colorwheel.js
+
+# run 'headful'
+puppeteer --no-headless third_party/phantomjs/examples/colorwheel.js
+
+# run puppeteer example
+node examples/screenshot.js
+```
+
+### Tests
+
+Run phantom.js tests using puppeteer:
+```
+./third_party/phantomjs/test/run-tests.py
+```
diff --git a/examples/custom-chromium-revision.js b/examples/custom-chromium-revision.js
new file mode 100644
index 00000000000..e49b3f6a80f
--- /dev/null
+++ b/examples/custom-chromium-revision.js
@@ -0,0 +1,41 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var Browser = require('../lib/Browser');
+var Downloader = require('../lib/Downloader');
+
+var revision = "464642";
+console.log('Downloading custom chromium revision - ' + revision);
+Downloader.downloadChromium(revision).then(async () => {
+ console.log('Done.');
+ var executablePath = Downloader.executablePath(revision);
+ var browser1 = new Browser({
+ remoteDebuggingPort: 9228,
+ executablePath,
+ });
+ var browser2 = new Browser({
+ remoteDebuggingPort: 9229,
+ });
+ var [version1, version2] = await Promise.all([
+ browser1.version(),
+ browser2.version()
+ ]);
+ console.log('browser1: ' + version1);
+ console.log('browser2: ' + version2);
+ browser1.close();
+ browser2.close();
+});
+
diff --git a/examples/screenshot.js b/examples/screenshot.js
new file mode 100644
index 00000000000..51a2f69f02c
--- /dev/null
+++ b/examples/screenshot.js
@@ -0,0 +1,27 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var Browser = require('./lib/Browser');
+var Page = require('./lib/Page');
+var fs = require('fs');
+var browser = new Browser();
+
+browser.newPage().then(async page => {
+ await page.navigate('http://example.com');
+ var screenshotBuffer = await page.screenshot(Page.ScreenshotTypes.PNG);
+ fs.writeFileSync('example.png', screenshotBuffer);
+ browser.close();
+});
diff --git a/index.js b/index.js
new file mode 100755
index 00000000000..1053460736b
--- /dev/null
+++ b/index.js
@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var vm = require('vm');
+var fs = require('fs');
+var path = require('path');
+var Browser = require('./lib/Browser');
+var argv = require('minimist')(process.argv.slice(2), {
+ alias: { v: 'version' },
+ boolean: ['headless'],
+ default: {'headless': true },
+});
+
+if (argv.version) {
+ console.log('Puppeteer v' + require('./package.json').version);
+ return;
+}
+
+if (argv['ssl-certificates-path']) {
+ console.error('Flag --ssl-certificates-path is not currently supported.\nMore information at https://github.com/aslushnikov/puppeteer/issues/1');
+ process.exit(1);
+ return;
+}
+
+var scriptArguments = argv._;
+if (!scriptArguments.length) {
+ console.log('puppeteer [scriptfile]');
+ return;
+}
+
+var scriptPath = path.resolve(process.cwd(), scriptArguments[0]);
+if (!fs.existsSync(scriptPath)) {
+ console.error(`script not found: ${scriptPath}`);
+ process.exit(1);
+ return;
+}
+
+var browser = new Browser({
+ remoteDebuggingPort: 9229,
+ headless: argv.headless,
+});
+
+var PhatomJs = require('./phantomjs');
+var context = PhatomJs.createContext(browser, scriptPath, argv);
+var scriptContent = fs.readFileSync(scriptPath, 'utf8');
+vm.runInContext(scriptContent, context);
diff --git a/install.js b/install.js
new file mode 100644
index 00000000000..1a0cfae017b
--- /dev/null
+++ b/install.js
@@ -0,0 +1,32 @@
+var Downloader = require('./lib/Downloader');
+var revision = require('./package').puppeteer.chromium_revision;
+var fs = require('fs');
+var ProgressBar = require('progress');
+
+var executable = Downloader.executablePath(revision);
+if (fs.existsSync(executable))
+ return;
+
+Downloader.downloadChromium(revision, onProgress)
+ .catch(error => {
+ console.error('Download failed: ' + error.message);
+ });
+
+var progressBar = null;
+function onProgress(bytesTotal, delta) {
+ if (!progressBar) {
+ progressBar = new ProgressBar(`Downloading Chromium - ${toMegabytes(bytesTotal)} [:bar] :percent :etas `, {
+ complete: '=',
+ incomplete: ' ',
+ width: 20,
+ total: bytesTotal,
+ });
+ }
+ progressBar.tick(delta);
+}
+
+function toMegabytes(bytes) {
+ var mb = bytes / 1024 / 1024;
+ return (Math.round(mb * 10) / 10) + ' Mb';
+}
+
diff --git a/lib/Browser.js b/lib/Browser.js
new file mode 100644
index 00000000000..20b09ecfa9c
--- /dev/null
+++ b/lib/Browser.js
@@ -0,0 +1,142 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var CDP = require('chrome-remote-interface');
+var http = require('http');
+var path = require('path');
+var removeRecursive = require('rimraf').sync;
+var Page = require('./Page');
+var childProcess = require('child_process');
+var Downloader = require('./Downloader');
+
+var CHROME_PROFILE_PATH = path.resolve(__dirname, '..', '.dev_profile');
+var browserId = 0;
+
+var DEFAULT_ARGS = [
+ '--disable-background-timer-throttling',
+ '--no-first-run',
+];
+
+class Browser {
+ /**
+ * @param {(!Object|undefined)} options
+ */
+ constructor(options) {
+ options = options || {};
+ ++browserId;
+ this._userDataDir = CHROME_PROFILE_PATH + browserId;
+ this._remoteDebuggingPort = 9229;
+ if (typeof options.remoteDebuggingPort === 'number')
+ this._remoteDebuggingPort = options.remoteDebuggingPort;
+ this._chromeArguments = DEFAULT_ARGS.concat([
+ `--user-data-dir=${this._userDataDir}`,
+ `--remote-debugging-port=${this._remoteDebuggingPort}`,
+ ]);
+ if (typeof options.headless !== 'boolean' || options.headless) {
+ this._chromeArguments.push(...[
+ `--headless`,
+ `--disable-gpu`,
+ ]);
+ }
+ if (typeof options.executablePath === 'string') {
+ this._chromeExecutable = options.executablePath;
+ } else {
+ var chromiumRevision = require('../package.json').puppeteer.chromium_revision;
+ this._chromeExecutable = Downloader.executablePath(chromiumRevision);
+ }
+ if (Array.isArray(options.args))
+ this._chromeArguments.push(...options.args);
+ this._chromeProcess = null;
+ this._tabSymbol = Symbol('Browser.TabSymbol');
+ }
+
+ /**
+ * @return {!Promise}
+ */
+ async newPage() {
+ await this._ensureChromeIsRunning();
+ if (!this._chromeProcess || this._chromeProcess.killed)
+ throw new Error('ERROR: this chrome instance is not alive any more!');
+ var tab = await CDP.New({port: this._remoteDebuggingPort});
+ var client = await CDP({tab: tab, port: this._remoteDebuggingPort});
+ var page = await Page.create(this, client);
+ page[this._tabSymbol] = tab;
+ return page;
+ }
+
+ /**
+ * @param {!Page} page
+ */
+ async closePage(page) {
+ if (!this._chromeProcess || this._chromeProcess.killed)
+ throw new Error('ERROR: this chrome instance is not running');
+ var tab = page[this._tabSymbol];
+ if (!tab)
+ throw new Error('ERROR: page does not belong to this chrome instance');
+ await CDP.Close({id: tab.id, port: this._remoteDebuggingPort});
+ }
+
+ /**
+ * @return {string}
+ */
+ async version() {
+ await this._ensureChromeIsRunning();
+ var version = await CDP.Version({port: this._remoteDebuggingPort});
+ return version.Browser;
+ }
+
+ async _ensureChromeIsRunning() {
+ if (this._chromeProcess)
+ return;
+ this._chromeProcess = childProcess.spawn(this._chromeExecutable, this._chromeArguments, {});
+ // Cleanup as processes exit.
+ process.on('exit', () => this._chromeProcess.kill());
+ this._chromeProcess.on('exit', () => removeRecursive(this._userDataDir));
+
+ await waitForChromeResponsive(this._remoteDebuggingPort);
+ }
+
+ close() {
+ if (!this._chromeProcess)
+ return;
+ this._chromeProcess.kill();
+ }
+}
+
+module.exports = Browser;
+
+function waitForChromeResponsive(remoteDebuggingPort) {
+ var fulfill;
+ var promise = new Promise(x => fulfill = x);
+ var options = {
+ method: 'GET',
+ host: 'localhost',
+ port: remoteDebuggingPort,
+ path: '/json/list'
+ };
+ var probeTimeout = 100;
+ var probeAttempt = 1;
+ sendRequest();
+ return promise;
+
+ function sendRequest() {
+ var req = http.request(options, res => {
+ fulfill()
+ });
+ req.on('error', e => setTimeout(sendRequest, probeTimeout));
+ req.end();
+ }
+}
diff --git a/lib/Downloader.js b/lib/Downloader.js
new file mode 100644
index 00000000000..5b63cfefc41
--- /dev/null
+++ b/lib/Downloader.js
@@ -0,0 +1,123 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var os = require('os');
+var https = require('https');
+var fs = require('fs');
+var path = require('path');
+var extract = require('extract-zip');
+var util = require('util');
+
+var CHROMIUM_PATH = path.join(__dirname, '..', '.local-chromium');
+
+var downloadURLs = {
+ linux: 'https://storage.googleapis.com/chromium-browser-snapshots/Linux_x64/%d/chrome-linux.zip',
+ darwin: 'https://storage.googleapis.com/chromium-browser-snapshots/Mac/%d/chrome-mac.zip',
+ win32: 'https://storage.googleapis.com/chromium-browser-snapshots/Win/%d/chrome-win32.zip',
+ win64: 'https://storage.googleapis.com/chromium-browser-snapshots/Win_x64/%d/chrome-win32.zip',
+};
+
+module.exports = {
+ downloadChromium,
+ executablePath,
+};
+
+/**
+ * @param {string} revision
+ * @param {?function(number, number)} progressCallback
+ * @return {!Promise}
+ */
+async function downloadChromium(revision, progressCallback) {
+ var url = null;
+ var platform = os.platform();
+ if (platform === 'darwin')
+ url = downloadURLs.darwin;
+ else if (platform === 'linux')
+ url = downloadURLs.linux;
+ else if (platform === 'win32')
+ url = os.arch() === 'x64' ? downloadURLs.win64 : downloadURLs.win32;
+ console.assert(url, `Unsupported platform: ${platform}`);
+ url = util.format(url, revision);
+ var zipPath = path.join(CHROMIUM_PATH, `download-${revision}.zip`);
+ var folderPath = path.join(CHROMIUM_PATH, revision);
+ if (fs.existsSync(folderPath))
+ return;
+ try {
+ if (!fs.existsSync(CHROMIUM_PATH))
+ fs.mkdirSync(CHROMIUM_PATH);
+ await downloadFile(url, zipPath, progressCallback);
+ await extractZip(zipPath, folderPath);
+ } finally {
+ if (fs.existsSync(zipPath))
+ fs.unlinkSync(zipPath);
+ }
+}
+
+/**
+ * @return {string}
+ */
+function executablePath(revision) {
+ var platform = os.platform();
+ if (platform === 'darwin')
+ return path.join(CHROMIUM_PATH, revision, 'chrome-mac', 'Chromium.app', 'Contents', 'MacOS', 'Chromium');
+ if (platform === 'linux')
+ return path.join(CHROMIUM_PATH, revision, 'chrome-linux', 'chrome');
+ if (platform === 'win32')
+ return path.join(CHROMIUM_PATH, revision, 'chrome-win32', 'chrome.exe');
+ throw new Error(`Unsupported platform: ${platform}`);
+}
+
+/**
+ * @param {string} url
+ * @param {string} destinationPath
+ * @param {?function(number, number)} progressCallback
+ * @return {!Promise}
+ */
+function downloadFile(url, destinationPath, progressCallback) {
+ var fulfill, reject;
+ var promise = new Promise((x, y) => { fulfill = x; reject = y; });
+ var request = https.get(url, response => {
+ if (response.statusCode !== 200) {
+ var error = new Error(`Download failed: server returned code ${response.statusCode}. URL: ${url}`);
+ // consume response data to free up memory
+ response.resume();
+ reject(error);
+ return;
+ }
+ var file = fs.createWriteStream(destinationPath);
+ file.on('finish', () => fulfill());
+ file.on('error', error => reject(error));
+ response.pipe(file);
+ var totalBytes = parseInt(response.headers['content-length'], 10);
+ if (progressCallback)
+ response.on('data', onData.bind(null, totalBytes));
+ });
+ request.on('error', error => reject(error));
+ return promise;
+
+ function onData(totalBytes, chunk) {
+ progressCallback(totalBytes, chunk.length);
+ }
+}
+
+/**
+ * @param {string} zipPath
+ * @param {string} folderPath
+ * @return {!Promise}
+ */
+function extractZip(zipPath, folderPath) {
+ return new Promise(fulfill => extract(zipPath, {dir: folderPath}, fulfill));
+}
diff --git a/lib/Page.js b/lib/Page.js
new file mode 100644
index 00000000000..5553cd16c50
--- /dev/null
+++ b/lib/Page.js
@@ -0,0 +1,350 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var fs = require('fs');
+var EventEmitter = require('events');
+var helpers = require('./helpers');
+
+class Page extends EventEmitter {
+ /**
+ * @param {!Browser} browser
+ * @param {!CDP} client
+ * @return {!Promise}
+ */
+ static async create(browser, client) {
+ await Promise.all([
+ client.send('Network.enable', {}),
+ client.send('Page.enable', {}),
+ client.send('Runtime.enable', {}),
+ client.send('Security.enable', {}),
+ ]);
+ var screenDPI = await helpers.evaluate(client, () => window.devicePixelRatio, []);
+ var page = new Page(browser, client, screenDPI.result.value);
+ // Initialize default page size.
+ await page.setSize({width: 400, height: 300});
+ return page;
+ }
+
+ /**
+ * @param {!Browser} browser
+ * @param {!CDP} client
+ * @param {number} screenDPI
+ */
+ constructor(browser, client, screenDPI) {
+ super();
+ this._browser = browser;
+ this._client = client;
+ this._screenDPI = screenDPI;
+ this._extraHeaders = {};
+ /** @type {!Map} */
+ this._scriptIdToPageCallback = new Map();
+ /** @type {!Map} */
+ this._scriptIdToCallbackName = new Map();
+
+ client.on('Debugger.paused', event => this._onDebuggerPaused(event));
+ client.on('Network.responseReceived', event => this.emit(Page.Events.ResponseReceived, event.response));
+ client.on('Network.loadingFailed', event => this.emit(Page.Events.ResourceLoadingFailed, event));
+ client.on('Runtime.consoleAPICalled', event => this._onConsoleAPI(event));
+ client.on('Page.javascriptDialogOpening', dialog => this.emit(Page.Events.DialogOpened, dialog));
+ client.on('Runtime.exceptionThrown', exception => this._handleException(exception.exceptionDetails));
+ }
+
+ /**
+ * @param {string} name
+ * @param {function(?)} callback
+ */
+ async setInPageCallback(name, callback) {
+ var hasCallback = await this.evaluate(function(name) {
+ return !!window[name];
+ }, name);
+ if (hasCallback)
+ throw new Error(`Failed to set in-page callback with name ${name}: window['${name}'] already exists!`);
+
+ var sourceURL = '__in_page_callback__' + name;
+ // Ensure debugger is enabled.
+ await this._client.send('Debugger.enable', {});
+ var scriptPromise = helpers.waitForScriptWithURL(this._client, sourceURL);
+ helpers.evaluate(this._client, inPageCallback, [name], false /* awaitPromise */, sourceURL);
+ var script = await scriptPromise;
+ if (!script)
+ throw new Error(`Failed to set in-page callback with name "${name}"`);
+ this._scriptIdToPageCallback.set(script.scriptId, callback);
+ this._scriptIdToCallbackName.set(script.scriptId, name);
+
+ function inPageCallback(callbackName) {
+ window[callbackName] = (...args) => {
+ window[callbackName].__args = args;
+ window[callbackName].__result = undefined;
+ debugger;
+ return window[callbackName].__result;
+ };
+ }
+ }
+
+ /**
+ * @param {string} scriptId
+ */
+ async _handleInPageCallback(scriptId) {
+ var name = /** @type {string} */ (this._scriptIdToCallbackName.get(scriptId));
+ var callback = /** @type {function()} */ (this._scriptIdToPageCallback.get(scriptId));
+ var args = await this.evaluate(callbackName => window[callbackName].__args, name);
+ var result = callback.apply(null, args);
+ await this.evaluate(assignResult, name, result);
+ this._client.send('Debugger.resume');
+
+ /**
+ * @param {string} callbackName
+ * @param {string} callbackResult
+ */
+ function assignResult(callbackName, callbackResult) {
+ window[callbackName].__result = callbackResult;
+ }
+ }
+
+ _onDebuggerPaused(event) {
+ var location = event.callFrames[0] ? event.callFrames[0].location : null;
+ if (location && this._scriptIdToPageCallback.has(location.scriptId)) {
+ this._handleInPageCallback(location.scriptId);
+ return;
+ }
+ this._client.send('Debugger.resume');
+ }
+
+ /**
+ * @param {!Object} headers
+ * @return {!Promise}
+ */
+ async setExtraHTTPHeaders(headers) {
+ this._extraHeaders = {};
+ // Note: header names are case-insensitive.
+ for (var key of Object.keys(headers))
+ this._extraHeaders[key.toLowerCase()] = headers[key];
+ return this._client.send('Network.setExtraHTTPHeaders', { headers });
+ }
+
+ /**
+ * @return {!Object}
+ */
+ extraHTTPHeaders() {
+ return Object.assign({}, this._extraHeaders);
+ }
+
+ /**
+ * @param {string} userAgent
+ * @return {!Promise}
+ */
+ async setUserAgentOverride(userAgent) {
+ this._userAgent = userAgent;
+ return this._client.send('Network.setUserAgentOverride', { userAgent });
+ }
+
+ /**
+ * @return {string}
+ */
+ userAgentOverride() {
+ return this._userAgent;
+ }
+
+ _handleException(exceptionDetails) {
+ var stack = [];
+ if (exceptionDetails.stackTrace) {
+ stack = exceptionDetails.stackTrace.callFrames.map(cf => cf.url);
+ }
+ var stackTrace = exceptionDetails.stackTrace;
+ this.emit(Page.Events.ExceptionThrown, exceptionDetails.exception.description, stack);
+ }
+
+ _onConsoleAPI(event) {
+ var values = event.args.map(arg => arg.value || arg.description || '');
+ this.emit(Page.Events.ConsoleMessageAdded, values.join(' '));
+ }
+
+ /**
+ * @param {boolean} accept
+ * @param {string} promptText
+ * @return {!Promise}
+ */
+ async handleDialog(accept, promptText) {
+ return this._client.send('Page.handleJavaScriptDialog', {accept, promptText});
+ }
+
+ /**
+ * @return {!Promise}
+ */
+ async url() {
+ return this.evaluate(function() {
+ return window.location.href;
+ });
+ }
+
+ /**
+ * @param {string} html
+ * @return {!Promise}
+ */
+ async setContent(html) {
+ var resourceTree = await this._client.send('Page.getResourceTree', {});
+ await this._client.send('Page.setDocumentContent', {
+ frameId: resourceTree.frameTree.frame.id,
+ html: html
+ });
+ }
+
+ /**
+ * @param {string} html
+ * @return {!Promise}
+ */
+ async navigate(url) {
+ var loadPromise = new Promise(fulfill => this._client.once('Page.loadEventFired', fulfill)).then(() => true);
+ var interstitialPromise = new Promise(fulfill => this._client.once('Security.certificateError', fulfill)).then(() => false);
+ var referrer = this._extraHeaders.referer;
+ // Await for the command to throw exception in case of illegal arguments.
+ await this._client.send('Page.navigate', {url, referrer});
+ return await Promise.race([loadPromise, interstitialPromise]);
+ }
+
+ /**
+ * @param {!{width: number, height: number}} size
+ * @return {!Promise}
+ */
+ async setSize(size) {
+ this._size = size;
+ var width = size.width;
+ var height = size.height;
+ var zoom = this._screenDPI;
+ return Promise.all([
+ this._client.send('Emulation.setDeviceMetricsOverride', {
+ width,
+ height,
+ deviceScaleFactor: 1,
+ scale: 1 / zoom,
+ mobile: false,
+ fitWindow: false
+ }),
+ this._client.send('Emulation.setVisibleSize', {
+ width: width / zoom,
+ height: height / zoom,
+ })
+ ]);
+ }
+
+ /**
+ * @return {!{width: number, height: number}}
+ */
+ size() {
+ return this._size;
+ }
+
+ /**
+ * @param {function()} fun
+ * @param {!Array<*>} args
+ * @return {!Promise<(!Object|udndefined)>}
+ */
+ async evaluate(fun, ...args) {
+ var response = await helpers.evaluate(this._client, fun, args, false /* awaitPromise */);
+ if (response.exceptionDetails) {
+ this._handleException(response.exceptionDetails);
+ return;
+ }
+ return response.result.value;
+ }
+
+ /**
+ * @param {function()} fun
+ * @param {!Array<*>} args
+ * @return {!Promise<(!Object|udndefined)>}
+ */
+ async evaluateAsync(fun, ...args) {
+ var response = await helpers.evaluate(this._client, fun, args, true /* awaitPromise */);
+ if (response.exceptionDetails) {
+ this._handleException(response.exceptionDetails);
+ return;
+ }
+ return response.result.value;
+ }
+
+ /**
+ * @param {!Page.ScreenshotType} screenshotType
+ * @param {?{x: number, y: number, width: number, height: number}} clipRect
+ * @return {!Promise}
+ */
+ async screenshot(screenshotType, clipRect) {
+ if (clipRect) {
+ await Promise.all([
+ this._client.send('Emulation.setVisibleSize', {
+ width: clipRect.width / this._screenDPI,
+ height: clipRect.height / this._screenDPI,
+ }),
+ this._client.send('Emulation.forceViewport', {
+ x: clipRect.x / this._screenDPI,
+ y: clipRect.y / this._screenDPI,
+ scale: 1,
+ })
+ ]);
+ }
+ var result = await this._client.send('Page.captureScreenshot', {
+ fromSurface: true,
+ format: screenshotType,
+ });
+ if (clipRect) {
+ await Promise.all([
+ this.setSize(this.size()),
+ this._client.send('Emulation.resetViewport')
+ ]);
+ }
+ return new Buffer(result.data, 'base64');
+ }
+
+ /**
+ * @return {!Promise}
+ */
+ async plainText() {
+ return this.evaluate(function() {
+ return document.body.innerText;
+ });
+ }
+
+ /**
+ * @return {!Promise}
+ */
+ async title() {
+ return this.evaluate(function() {
+ return document.title;
+ });
+ }
+
+ /**
+ * @return {!Promise}
+ */
+ async close() {
+ return this._browser.closePage(this);
+ }
+}
+
+/** @enum {string} */
+Page.ScreenshotTypes = {
+ PNG: "png",
+ JPG: "jpeg",
+};
+
+Page.Events = {
+ ConsoleMessageAdded: 'Page.Events.ConsoleMessageAdded',
+ DialogOpened: 'Page.Events.DialogOpened',
+ ExceptionThrown: 'Page.Events.ExceptionThrown',
+ ResourceLoadingFailed: 'Page.Events.ResourceLoadingFailed',
+ ResponseReceived: 'Page.Events.ResponseReceived',
+};
+
+module.exports = Page;
diff --git a/lib/helpers.js b/lib/helpers.js
new file mode 100644
index 00000000000..b5a868e0f3b
--- /dev/null
+++ b/lib/helpers.js
@@ -0,0 +1,68 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module.exports = {
+ /**
+ * @param {!CDP} client
+ * @param {string} url
+ * @return {!Promise}
+ */
+ waitForScriptWithURL: function(client, url) {
+ var fulfill;
+ var promise = new Promise(x => fulfill = x);
+ client.on('Debugger.scriptParsed', onScriptParsed);
+ client.on('Debugger.scriptFailedToParse', onScriptFailedToParse);
+ return promise;
+
+ function onScriptParsed(event) {
+ if (event.url !== url)
+ return;
+ client.removeListener('Debugger.scriptParsed', onScriptParsed);
+ client.removeListener('Debugger.scriptFailedToParse', onScriptFailedToParse);
+ fulfill(event);
+ }
+
+ function onScriptFailedToParse(event) {
+ if (event.url !== url)
+ return;
+ client.removeListener('Debugger.scriptParsed', onScriptParsed);
+ client.removeListener('Debugger.scriptFailedToParse', onScriptFailedToParse);
+ fulfill(null);
+ }
+ },
+
+ /**
+ * @param {!CDP} client
+ * @param {function()} fun
+ * @param {!Array<*>} args
+ * @param {boolean} awaitPromise
+ * @param {string=} sourceURL
+ * @return {!Promise}
+ */
+ evaluate: function(client, fun, args, awaitPromise, sourceURL) {
+ var argsString = args.map(x => JSON.stringify(x)).join(',');
+ var code = `(${fun.toString()})(${argsString})`;
+ if (awaitPromise)
+ code = `Promise.resolve(${code})`;
+ if (sourceURL)
+ code += `\n//# sourceURL=${sourceURL}`;
+ return client.send('Runtime.evaluate', {
+ expression: code,
+ awaitPromise: awaitPromise,
+ returnByValue: true
+ });
+ },
+}
diff --git a/package.json b/package.json
new file mode 100644
index 00000000000..4fa90178da6
--- /dev/null
+++ b/package.json
@@ -0,0 +1,28 @@
+{
+ "name": "puppeteer",
+ "version": "0.0.1",
+ "description": "",
+ "main": "index.js",
+ "scripts": {
+ "test": "python third_party/phantomjs/test/run-tests.py",
+ "install": "node install.js"
+ },
+ "author": "The Chromium Authors",
+ "license": "SEE LICENSE IN LICENSE",
+ "dependencies": {
+ "chrome-remote-interface": "^0.18.0",
+ "deasync": "^0.1.9",
+ "extract-zip": "^1.6.5",
+ "mime": "^1.3.4",
+ "minimist": "^1.2.0",
+ "ncp": "^2.0.0",
+ "progress": "^2.0.0",
+ "rimraf": "^2.6.1"
+ },
+ "bin": {
+ "puppeteer": "index.js"
+ },
+ "puppeteer": {
+ "chromium_revision": "468266"
+ }
+}
diff --git a/phantomjs/FileSystem.js b/phantomjs/FileSystem.js
new file mode 100644
index 00000000000..bbc5d575ccd
--- /dev/null
+++ b/phantomjs/FileSystem.js
@@ -0,0 +1,365 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var path = require('path');
+var fs = require('fs');
+var deasync = require('deasync');
+var removeRecursive = require('rimraf').sync;
+var copyRecursive = deasync(require('ncp').ncp);
+
+class FileSystem {
+ constructor() {
+ this.separator = path.sep;
+ }
+
+ /**
+ * @return {string}
+ */
+ get workingDirectory() {
+ return process.cwd();
+ }
+
+ /**
+ * @param {string} directoryPath
+ */
+ changeWorkingDirectory(directoryPath) {
+ try {
+ process.chdir(directoryPath);
+ return true;
+ } catch (e){
+ return false;
+ }
+ }
+
+ /**
+ * @param {string} relativePath
+ * @return {string}
+ */
+ absolute(relativePath) {
+ relativePath = path.normalize(relativePath);
+ if (path.isAbsolute(relativePath))
+ return relativePath;
+ return path.resolve(path.join(process.cwd(), relativePath));
+ }
+
+ /**
+ * @param {string} filePath
+ * @return {boolean}
+ */
+ exists(filePath) {
+ return fs.existsSync(filePath);
+ }
+
+ /**
+ * @param {string} fromPath
+ * @param {string} toPath
+ */
+ copy(fromPath, toPath) {
+ var content = fs.readFileSync(fromPath);
+ fs.writeFileSync(toPath, content);
+ }
+
+ /**
+ * @param {string} fromPath
+ * @param {string} toPath
+ */
+ move(fromPath, toPath) {
+ var content = fs.readFileSync(fromPath);
+ fs.writeFileSync(toPath, content);
+ fs.unlinkSync(fromPath);
+ }
+
+ /**
+ * @param {string} filePath
+ * @return {number}
+ */
+ size(filePath) {
+ return fs.statSync(filePath).size;
+ }
+
+ /**
+ * @param {string} filePath
+ */
+ touch(filePath) {
+ fs.closeSync(fs.openSync(filePath, 'a'));
+ }
+
+ /**
+ * @param {string} filePath
+ */
+ remove(filePath) {
+ fs.unlinkSync(filePath);
+ }
+
+ /**
+ * @param {string} filePath
+ */
+ lastModified(filePath) {
+ return fs.statSync(filePath).mtime;
+ }
+
+ /**
+ * @param {string} dirPath
+ */
+ makeDirectory(dirPath) {
+ try {
+ fs.mkdirSync(dirPath);
+ return true;
+ } catch (e) {
+ return false;
+ }
+ }
+
+ /**
+ * @param {string} dirPath
+ */
+ removeTree(dirPath) {
+ removeRecursive(dirPath);
+ }
+
+ /**
+ * @param {string} fromPath
+ * @param {string} toPath
+ */
+ copyTree(fromPath, toPath) {
+ copyRecursive(fromPath, toPath);
+ }
+
+ /**
+ * @param {string} dirPath
+ * @return {!Array}
+ */
+ list(dirPath) {
+ return fs.readdirSync(dirPath);
+ }
+
+ /**
+ * @param {string} linkPath
+ * @return {string}
+ */
+ readLink(linkPath) {
+ return fs.readlinkSync(linkPath);
+ }
+
+ /**
+ * @param {string} filePath
+ * @param {Object} data
+ * @param {string} mode
+ */
+ write(filePath, data, mode) {
+ var fd = new FileDescriptor(filePath, mode, 'utf8');
+ fd.write(data);
+ fd.close();
+ }
+
+ /**
+ * @param {string} somePath
+ * @return {boolean}
+ */
+ isAbsolute(somePath) {
+ return path.isAbsolute(somePath);
+ }
+
+ /**
+ * @return {string}
+ */
+ read(filePath) {
+ return fs.readFileSync(filePath, 'utf8');
+ }
+
+ /**
+ * @param {string} filePath
+ * @return {boolean}
+ */
+ isFile(filePath) {
+ return fs.existsSync(filePath) && fs.lstatSync(filePath).isFile();
+ }
+
+ /**
+ * @param {string} dirPath
+ * @return {boolean}
+ */
+ isDirectory(dirPath) {
+ return fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();
+ }
+
+ /**
+ * @param {string} filePath
+ * @return {boolean}
+ */
+ isLink(filePath) {
+ return fs.existsSync(filePath) && fs.lstatSync(filePath).isSymbolicLink();
+ }
+
+ /**
+ * @param {string} filePath
+ * @return {boolean}
+ */
+ isReadable(filePath) {
+ try {
+ fs.accessSync(filePath, fs.constants.R_OK);
+ return true;
+ } catch (e) {
+ return false;
+ }
+ }
+
+ /**
+ * @param {string} filePath
+ * @return {boolean}
+ */
+ isWritable(filePath) {
+ try {
+ fs.accessSync(filePath, fs.constants.W_OK);
+ return true;
+ } catch (e) {
+ return false;
+ }
+ }
+
+ /**
+ * @param {string} filePath
+ * @return {boolean}
+ */
+ isExecutable(filePath) {
+ try {
+ fs.accessSync(filePath, fs.constants.X_OK);
+ return true;
+ } catch (e) {
+ return false;
+ }
+ }
+
+ /**
+ * @param {string} somePath
+ * @return {!Array}
+ */
+ split(somePath) {
+ somePath = path.normalize(somePath);
+ if (somePath.endsWith(path.sep))
+ somePath = somePath.substring(0, somePath.length - path.sep.length);
+ return somePath.split(path.sep);
+ }
+
+ /**
+ * @param {string} path1
+ * @param {string} path2
+ * @return {string}
+ */
+ join(...args) {
+ if (args[0] === '' && args.length > 1)
+ args[0] = path.sep;
+ args = args.filter(part => typeof part === 'string');
+ return path.join.apply(path, args);
+ }
+
+ /**
+ * @param {string} filePath
+ * @param {(string|!Object)} option
+ * @return {!FileDescriptor}
+ */
+ open(filePath, option) {
+ if (typeof option === 'string')
+ return new FileDescriptor(filePath, option);
+ return new FileDescriptor(filePath, option.mode);
+ }
+}
+
+var fdwrite = deasync(fs.write);
+var fdread = deasync(fs.read);
+
+class FileDescriptor {
+ /**
+ * @param {string} filePath
+ * @param {string} mode
+ */
+ constructor(filePath, mode) {
+ this._position = 0;
+ this._encoding = 'utf8';
+ if (mode === 'rb') {
+ this._mode = 'r';
+ this._encoding = 'latin1';
+ } else if (mode === 'wb' || mode === 'b') {
+ this._mode = 'w';
+ this._encoding = 'latin1';
+ } else if (mode === 'rw+') {
+ this._mode = 'a+';
+ this._position = fs.existsSync(filePath) ? fs.statSync(filePath).size : 0;
+ } else {
+ this._mode = mode;
+ }
+ this._fd = fs.openSync(filePath, this._mode);
+ }
+
+ /**
+ * @param {string} data
+ */
+ write(data) {
+ var buffer = Buffer.from(data, this._encoding);
+ var written = fdwrite(this._fd, buffer, 0, buffer.length, this._position);
+ this._position += written;
+ }
+
+ getEncoding() {
+ return 'UTF-8';
+ }
+
+ /**
+ * @param {string} data
+ */
+ writeLine(data) {
+ this.write(data + '\n');
+ }
+
+ /**
+ * @param {number=} size
+ * @return {string}
+ */
+ read(size) {
+ var position = this._position;
+ if (!size) {
+ size = fs.fstatSync(this._fd).size;
+ position = 0;
+ }
+ var buffer = new Buffer(size);
+ var bytesRead = fdread(this._fd, buffer, 0, size, position);
+ this._position += bytesRead;
+ return buffer.toString(this._encoding);
+ }
+
+ flush() {
+ // noop.
+ }
+
+ /**
+ * @param {number} position
+ */
+ seek(position) {
+ this._position = position;
+ }
+
+ close() {
+ fs.closeSync(this._fd);
+ }
+
+ /**
+ * @return {boolean}
+ */
+ atEnd() {
+ }
+}
+
+module.exports = FileSystem;
diff --git a/phantomjs/Phantom.js b/phantomjs/Phantom.js
new file mode 100644
index 00000000000..ed0269681ee
--- /dev/null
+++ b/phantomjs/Phantom.js
@@ -0,0 +1,139 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var fs = require('fs');
+var path = require('path');
+var vm = require('vm');
+var url = require('url');
+
+/**
+ * @param {!Object} context
+ * @param {string} scriptPath
+ */
+module.exports.create = function(context, scriptPath) {
+ var phantom = {
+ page: {
+ onConsoleMessage: null,
+ },
+
+ /**
+ * @param {string} relative
+ * @param {string} base
+ * @return {string}
+ */
+ resolveRelativeUrl: function(relative, base) {
+ return url.resolve(base, relative);
+ },
+
+ /**
+ * @param {string} url
+ * @return {string}
+ */
+ fullyDecodeUrl: function(url) {
+ return decodeURI(url);
+ },
+
+ libraryPath: path.dirname(scriptPath),
+
+ onError: null,
+
+ /**
+ * @return {string}
+ */
+ get outputEncoding() {
+ return 'UTF-8';
+ },
+
+ /**
+ * @param {string} value
+ */
+ set outputEncoding(value) {
+ throw new Error('Phantom.outputEncoding setter is not implemented');
+ },
+
+ /**
+ * @return {boolean}
+ */
+ get cookiesEnabled() {
+ return true;
+ },
+
+ /**
+ * @param {boolean} value
+ */
+ set cookiesEnabled(value) {
+ throw new Error('Phantom.cookiesEnabled setter is not implemented');
+ },
+
+ /**
+ * @return {!{major: number, minor: number, patch: number}}
+ */
+ get version() {
+ var versionParts = require('../package.json').version.split('.');
+ return {
+ major: parseInt(versionParts[0], 10),
+ minor: parseInt(versionParts[1], 10),
+ patch: parseInt(versionParts[2], 10),
+ };
+ },
+
+ /**
+ * @param {number=} code
+ */
+ exit: function(code) {
+ process.exit(code);
+ },
+
+ /**
+ * @param {string} filePath
+ * @return {boolean}
+ */
+ injectJs: function(filePath) {
+ filePath = path.resolve(phantom.libraryPath, filePath);
+ if (!fs.existsSync(filePath))
+ return false;
+ var code = fs.readFileSync(filePath, 'utf8');
+ if (code.startsWith('#!'))
+ code = code.substring(code.indexOf('\n'));
+ vm.runInContext(code, context, {
+ filename: filePath,
+ displayErrors: true
+ });
+ return true;
+ },
+
+ /**
+ * @param {string} moduleSource
+ * @param {string} filename
+ */
+ loadModule: function(moduleSource, filename) {
+ var code = [
+ "(function(require, exports, module) {\n",
+ moduleSource,
+ "\n}.call({},",
+ "require.cache['" + filename + "']._getRequire(),",
+ "require.cache['" + filename + "'].exports,",
+ "require.cache['" + filename + "']",
+ "));"
+ ].join('');
+ vm.runInContext(code, context, {
+ filename: filename,
+ displayErrors: true
+ });
+ },
+ };
+ return phantom;
+}
diff --git a/phantomjs/System.js b/phantomjs/System.js
new file mode 100644
index 00000000000..770929350ba
--- /dev/null
+++ b/phantomjs/System.js
@@ -0,0 +1,118 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var readline = require('readline');
+var await = require('./utilities').await;
+var os = require('os');
+
+class System {
+ /**
+ * @param {!Array} args
+ */
+ constructor(args) {
+ this.args = args;
+ this.env = {};
+ Object.assign(this.env, process.env);
+ this.stdin = new StandardInput(process.stdin);
+ this.stdout = new StandardOutput(process.stdout);
+ this.stderr = new StandardOutput(process.stderr);
+ this.platform = "phantomjs";
+ this.pid = process.pid;
+ this.isSSLSupported = false;
+ this.os = {
+ architecture: os.arch(),
+ name: os.type(),
+ version: os.release()
+ };
+ }
+}
+
+class StandardInput {
+ /**
+ * @param {!Readable} readableStream
+ */
+ constructor(readableStream) {
+ this._readline = readline.createInterface({
+ input: readableStream
+ });
+ this._lines = [];
+ this._closed = false;
+ this._readline.on('line', line => this._lines.push(line));
+ this._readline.on('close', () => this._closed = true);
+ }
+
+ /**
+ * @return {string}
+ */
+ readLine() {
+ if (this._closed && !this._lines.length)
+ return '';
+ if (!this._lines.length) {
+ var linePromise = new Promise(fulfill => this._readline.once('line', fulfill));
+ await(linePromise);
+ }
+ return this._lines.shift();
+ }
+
+ /**
+ * @return {string}
+ */
+ read() {
+ if (!this._closed) {
+ var closePromise = new Promise(fulfill => this._readline.once('close', fulfill));
+ await(closePromise);
+ }
+ var text = this._lines.join('\n');
+ this._lines = [];
+ return text;
+ }
+
+ close() {
+ this._readline.close();
+ }
+}
+
+class StandardOutput {
+ /**
+ * @param {!Writable} writableStream
+ */
+ constructor(writableStream) {
+ this._stream = writableStream;
+ }
+
+ /**
+ * @param {string} data
+ */
+ write(data) {
+ this._stream.write(data);
+ }
+
+ /**
+ * @param {string} data
+ */
+ writeLine(data) {
+ this._stream.write(data + '\n');
+ }
+
+ flush() {
+ }
+
+ close() {
+ this._stream.end();
+ }
+}
+
+module.exports = System;
diff --git a/phantomjs/WebPage.js b/phantomjs/WebPage.js
new file mode 100644
index 00000000000..2ea290a2311
--- /dev/null
+++ b/phantomjs/WebPage.js
@@ -0,0 +1,327 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var await = require('./utilities').await;
+var EventEmitter = require('events');
+var fs = require('fs');
+var path = require('path');
+var mime = require('mime');
+
+var PageEvents = require('../lib/Page').Events;
+var ScreenshotTypes = require('../lib/Page').ScreenshotTypes;
+
+var noop = function() { };
+
+class WebPage {
+ /**
+ * @param {!Browser} browser
+ * @param {string} scriptPath
+ * @param {!Object=} options
+ */
+ constructor(browser, scriptPath, options) {
+ this._page = await(browser.newPage());
+ this.settings = new WebPageSettings(this._page);
+
+ options = options || {};
+ options.settings = options.settings || {};
+ if (options.settings.userAgent)
+ this.settings.userAgent = options.settings.userAgent;
+ if (options.viewportSize)
+ await(this._page.setSize(options.viewportSize));
+
+ await(this._page.setInPageCallback('callPhantom', (...args) => {
+ return this.onCallback.apply(null, args);
+ }));
+
+ this.clipRect = options.clipRect || {left: 0, top: 0, width: 0, height: 0};
+ this.onCallback = null;
+ this.onConsoleMessage = null;
+ this.onLoadFinished = null;
+ this.onResourceError = null;
+ this.onResourceReceived = null;
+ this.libraryPath = path.dirname(scriptPath);
+
+ this._onConfirm = undefined;
+ this._onError = noop;
+
+ this._pageEvents = new AsyncEmitter(this._page);
+ this._pageEvents.on(PageEvents.ResponseReceived, response => this._onResponseReceived(response));
+ this._pageEvents.on(PageEvents.ResourceLoadingFailed, event => (this.onResourceError || noop).call(null, event));
+ this._pageEvents.on(PageEvents.ConsoleMessageAdded, msg => (this.onConsoleMessage || noop).call(null, msg));
+ this._pageEvents.on(PageEvents.DialogOpened, dialog => this._onDialog(dialog));
+ this._pageEvents.on(PageEvents.ExceptionThrown, (exception, stack) => (this._onError || noop).call(null, exception, stack));
+ }
+
+ _onResponseReceived(response) {
+ if (!this.onResourceReceived)
+ return;
+ var headers = [];
+ for (var key in response.headers) {
+ headers.push({
+ name: key,
+ value: response.headers[key]
+ });
+ }
+ response.headers = headers;
+ this.onResourceReceived.call(null, response);
+ }
+
+ /**
+ * @param {string} url
+ * @param {function()} callback
+ */
+ includeJs(url, callback) {
+ this._page.evaluateAsync(include, url).then(callback);
+
+ function include(url) {
+ var script = document.createElement('script');
+ script.src = url;
+ var promise = new Promise(x => script.onload = x);
+ document.head.appendChild(script);
+ return promise;
+ }
+ }
+
+ /**
+ * @return {!{width: number, height: number}}
+ */
+ get viewportSize() {
+ return this._page.size();
+ }
+
+ /**
+ * @return {!Object}
+ */
+ get customHeaders() {
+ return this._page.extraHTTPHeaders();
+ }
+
+ /**
+ * @param {!Object} value
+ */
+ set customHeaders(value) {
+ await(this._page.setExtraHTTPHeaders(value));
+ }
+
+ /**
+ * @param {string} filePath
+ */
+ injectJs(filePath) {
+ if (!fs.existsSync(filePath))
+ filePath = path.resolve(this.libraryPath, filePath);
+ if (!fs.existsSync(filePath))
+ return;
+ var code = fs.readFileSync(filePath, 'utf8');
+ this.evaluate(code);
+ }
+
+ /**
+ * @return {string}
+ */
+ get plainText() {
+ return await(this._page.plainText());
+ }
+
+ /**
+ * @return {string}
+ */
+ get title() {
+ return await(this._page.title());
+ }
+
+ /**
+ * @return {(function()|undefined)}
+ */
+ get onError() {
+ return this._onError;
+ }
+
+ /**
+ * @param {(function()|undefined)} handler
+ */
+ set onError(handler) {
+ if (typeof handler !== 'function')
+ handler = undefined;
+ this._onError = handler;
+ }
+
+ /**
+ * @return {(function()|undefined)}
+ */
+ get onConfirm() {
+ return this._onConfirm;
+ }
+
+ /**
+ * @param {function()} handler
+ */
+ set onConfirm(handler) {
+ if (typeof handler !== 'function')
+ handler = undefined;
+ this._onConfirm = handler;
+ }
+
+ _onDialog(dialog) {
+ if (!this._onConfirm)
+ return;
+ var accept = this._onConfirm.call(null);
+ await(this._page.handleDialog(accept));
+ }
+
+ /**
+ * @return {string}
+ */
+ get url() {
+ return await(this._page.url());
+ }
+
+ /**
+ * @param {string} html
+ */
+ set content(html) {
+ await(this._page.setContent(html));
+ }
+
+ /**
+ * @param {string} html
+ * @param {function()=} callback
+ */
+ open(url, callback) {
+ console.assert(arguments.length <= 2, 'WebPage.open does not support METHOD and DATA arguments');
+ this._page.navigate(url).then(result => {
+ var status = result ? 'success' : 'fail';
+ if (!result) {
+ this.onResourceError.call(null, {
+ url,
+ errorString: 'SSL handshake failed'
+ });
+ }
+ if (this.onLoadFinished)
+ this.onLoadFinished.call(null, status);
+ if (callback)
+ callback.call(null, status);
+ });
+ }
+
+ /**
+ * @param {!{width: number, height: number}} options
+ */
+ set viewportSize(options) {
+ await(this._page.setSize(options));
+ }
+
+ /**
+ * @param {function()} fun
+ * @param {!Array} args
+ */
+ evaluate(fun, ...args) {
+ return await(this._page.evaluate(fun, ...args));
+ }
+
+ /**
+ * {string} fileName
+ */
+ render(fileName) {
+ var mimeType = mime.lookup(fileName);
+ var screenshotType = null;
+ if (mimeType === 'image/png')
+ screenshotType = ScreenshotTypes.PNG;
+ else if (mimeType === 'image/jpeg')
+ screenshotType = ScreenshotTypes.JPG;
+ if (!screenshotType)
+ throw new Error(`Cannot render to file ${fileName} - unsupported mimeType ${mimeType}`);
+ var clipRect = null;
+ if (this.clipRect && (this.clipRect.left || this.clipRect.top || this.clipRect.width || this.clipRect.height)) {
+ clipRect = {
+ x: this.clipRect.left,
+ y: this.clipRect.top,
+ width: this.clipRect.width,
+ height: this.clipRect.height
+ };
+ }
+ var imageBuffer = await(this._page.screenshot(screenshotType, clipRect));
+ fs.writeFileSync(fileName, imageBuffer);
+ }
+
+ release() {
+ this._page.close();
+ }
+
+ close() {
+ this._page.close();
+ }
+}
+
+class WebPageSettings {
+ /**
+ * @param {!Page} page
+ */
+ constructor(page) {
+ this._page = page;
+ }
+
+ /**
+ * @param {string} value
+ */
+ set userAgent(value) {
+ await(this._page.setUserAgentOverride(value));
+ }
+
+ /**
+ * @return {string}
+ */
+ get userAgent() {
+ return this._page.userAgentOverride();
+ }
+}
+
+// To prevent reenterability, eventemitters should emit events
+// only being in a consistent state.
+// This is not the case for 'ws' npm module: https://goo.gl/sy3dJY
+//
+// Since out phantomjs environment uses nested event loops, we
+// exploit this condition in 'ws', which probably never happens
+// in case of regular I/O.
+//
+// This class is a wrapper around EventEmitter which re-emits events asynchronously,
+// helping to overcome the issue.
+class AsyncEmitter extends EventEmitter {
+ /**
+ * @param {!Page} page
+ */
+ constructor(page) {
+ super();
+ this._page = page;
+ this._symbol = Symbol('AsyncEmitter');
+ this.on('newListener', this._onListenerAdded);
+ this.on('removeListener', this._onListenerRemoved);
+ }
+
+ _onListenerAdded(event, listener) {
+ // Async listener calls original listener on next tick.
+ var asyncListener = (...args) => {
+ process.nextTick(() => listener.apply(null, args));
+ };
+ listener[this._symbol] = asyncListener;
+ this._page.on(event, asyncListener);
+ }
+
+ _onListenerRemoved(event, listener) {
+ this._page.removeListener(event, listener[this._symbol]);
+ }
+}
+
+module.exports = WebPage;
diff --git a/phantomjs/WebServer.js b/phantomjs/WebServer.js
new file mode 100644
index 00000000000..4d99b3246d7
--- /dev/null
+++ b/phantomjs/WebServer.js
@@ -0,0 +1,83 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var http = require('http');
+var await = require('./utilities').await;
+
+class WebServer {
+ constructor() {
+ this._server = http.createServer();
+ this.objectName = 'WebServer';
+ this.listenOnPort = this.listen;
+ this.newRequest = function(req, res) { }
+ Object.defineProperty(this, 'port', {
+ get: () => {
+ if (!this._server.listening)
+ return '';
+ return this._server.address().port + '';
+ },
+ enumerable: true,
+ configurable: false
+ });
+ }
+
+ close() {
+ this._server.close();
+ }
+
+ /**
+ * @param {nubmer} port
+ * @return {boolean}
+ */
+ listen(port, callback) {
+ if (this._server.listening)
+ return false;
+ this.newRequest = callback;
+ this._server.listen(port);
+ var errorPromise = new Promise(x => this._server.once('error', x));
+ var successPromise = new Promise(x => this._server.once('listening', x));
+ await(Promise.race([errorPromise, successPromise]));
+ if (!this._server.listening)
+ return false;
+
+ this._server.on('request', (req, res) => {
+ res.close = res.end.bind(res);
+ var headers = res.getHeaders();
+ res.headers = [];
+ for (var key in headers) {
+ res.headers.push({
+ name: key,
+ value: headers[key]
+ });
+ }
+ res.header = res.getHeader;
+ res.setHeaders = (headers) => {
+ for (var key in headers)
+ res.setHeader(key, headers[key]);
+ }
+ Object.defineProperty(res, 'statusCode', {
+ enumerable: true,
+ configurable: true,
+ writable: true,
+ value: res.statusCode
+ });
+ this.newRequest.call(null, req, res);
+ });
+ return true;
+ }
+}
+
+module.exports = WebServer;
diff --git a/phantomjs/index.js b/phantomjs/index.js
new file mode 100644
index 00000000000..4dca15dfd02
--- /dev/null
+++ b/phantomjs/index.js
@@ -0,0 +1,71 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var vm = require('vm');
+var path = require('path');
+var fs = require('fs');
+var Phantom = require('./Phantom');
+var FileSystem = require('./FileSystem');
+var System = require('./System');
+var WebPage = require('./WebPage');
+var WebServer = require('./WebServer');
+var child_process = require('child_process');
+
+var bootstrapPath = path.join(__dirname, '..', 'third_party', 'phantomjs', 'bootstrap.js');
+var bootstrapCode = fs.readFileSync(bootstrapPath, 'utf8');
+
+module.exports = {
+ /**
+ * @param {!Browser} browser
+ * @param {string} scriptPath
+ * @param {!Array} argv
+ * @return {!Object}
+ */
+ createContext(browser, scriptPath, argv) {
+ var context = {};
+ context.setInterval = setInterval;
+ context.setTimeout = setTimeout;
+ context.clearInterval = clearInterval;
+ context.clearTimeout = clearTimeout;
+
+ context.phantom = Phantom.create(context, scriptPath);
+ context.console = console;
+ context.window = context;
+ context.WebPage = (options) => new WebPage(browser, scriptPath, options);
+
+ vm.createContext(context);
+
+ var nativeExports = {
+ fs: new FileSystem(),
+ system: new System(argv._),
+ webpage: {
+ create: context.WebPage,
+ },
+ webserver: {
+ create: () => new WebServer(),
+ },
+ cookiejar: {
+ create: () => {},
+ },
+ child_process: child_process
+ };
+ vm.runInContext(bootstrapCode, context, {
+ filename: 'bootstrap.js'
+ })(nativeExports);
+ return context;
+ }
+}
+
diff --git a/phantomjs/utilities.js b/phantomjs/utilities.js
new file mode 100644
index 00000000000..9663d196611
--- /dev/null
+++ b/phantomjs/utilities.js
@@ -0,0 +1,33 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var loopWhile = require('deasync').loopWhile;
+
+module.exports = {
+ await: function(promise) {
+ var error;
+ var result;
+ var done = false;
+ promise.then(r => result = r)
+ .catch(err => error = err)
+ .then(() => done = true);
+ loopWhile(() => !done);
+ if (error)
+ throw error;
+ return result;
+ }
+}
+
diff --git a/third_party/phantomjs/CHANGES.md b/third_party/phantomjs/CHANGES.md
new file mode 100644
index 00000000000..d5256cfec4c
--- /dev/null
+++ b/third_party/phantomjs/CHANGES.md
@@ -0,0 +1,19 @@
+Short Name: phantomjs
+URL: https://github.com/ariya/phantomjs/tree/2.1.1
+Version: 2.1.1
+License: BSD
+License File: LICENSE.BSD
+Security Critical: no
+
+Description:
+This package is used to aid puppeteer in running phantom.js scripts:
+- test/ - testsuite is used to validate puppeteer running phantom.js scripts
+- boostrap.js - used to bootstrap puppeteer environment
+
+Local Modifications:
+
+- test/run_test.py was changed to run puppeteer instead of phantomjs
+- Certain tests under test/ were changed where tests were unreasonably strict in their expectations
+ (e.g. validating the exact format of error messages)
+- bootstrap.js was changed to accept native modules as function arguments.
+- test/run_test.py was enhanced to support "unsupported" directive
diff --git a/third_party/phantomjs/LICENSE.BSD b/third_party/phantomjs/LICENSE.BSD
new file mode 100644
index 00000000000..d5dfdd1f661
--- /dev/null
+++ b/third_party/phantomjs/LICENSE.BSD
@@ -0,0 +1,22 @@
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the nor the
+ names of its contributors may be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/third_party/phantomjs/bootstrap.js b/third_party/phantomjs/bootstrap.js
new file mode 100644
index 00000000000..f3a69c55009
--- /dev/null
+++ b/third_party/phantomjs/bootstrap.js
@@ -0,0 +1,235 @@
+/*jslint sloppy: true, nomen: true */
+/*global window:true,phantom:true */
+
+/*
+ This file is part of the PhantomJS project from Ofi Labs.
+
+ Copyright (C) 2011 Ariya Hidayat
+ Copyright (C) 2011 Ivan De Marino
+ Copyright (C) 2011 James Roe
+ Copyright (C) 2011 execjosh, http://execjosh.blogspot.com
+ Copyright (C) 2012 James M. Greene
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the nor the
+ names of its contributors may be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+(function(nativeExports) {
+ // CommonJS module implementation follows
+
+ window.global = window;
+ // fs is loaded at the end, when everything is ready
+ var fs;
+ var cache = {};
+ var paths = [];
+ var extensions = {
+ '.js': function(module, filename) {
+ var code = fs.read(filename);
+ module._compile(code);
+ },
+
+ '.json': function(module, filename) {
+ module.exports = JSON.parse(fs.read(filename));
+ }
+ };
+
+ function dirname(path) {
+ var replaced = path.replace(/\/[^\/]*\/?$/, '');
+ if (replaced == path) {
+ replaced = '';
+ }
+ return replaced;
+ }
+
+ function basename(path) {
+ return path.replace(/.*\//, '');
+ }
+
+ function joinPath() {
+ // It should be okay to hard-code a slash here.
+ // The FileSystem module returns a platform-specific
+ // separator, but the JavaScript engine only expects
+ // the slash.
+ var args = Array.prototype.slice.call(arguments);
+ return args.join('/');
+ }
+
+ function tryFile(path) {
+ if (fs.isFile(path)) return path;
+ return null;
+ }
+
+ function tryExtensions(path) {
+ var filename, exts = Object.keys(extensions);
+ for (var i=0; i 0) {
+ page.render('report.png');
+ phantom.exit();
+ } else {
+ setTimeout(monitor, 1000);
+ }
+ }
+
+ setTimeout(monitor, 0);
+});
diff --git a/third_party/phantomjs/test/module/cookiejar/cookiejar.js b/third_party/phantomjs/test/module/cookiejar/cookiejar.js
new file mode 100644
index 00000000000..4c9e4cc4c76
--- /dev/null
+++ b/third_party/phantomjs/test/module/cookiejar/cookiejar.js
@@ -0,0 +1,93 @@
+//! unsupported
+var cookie0 = {
+ 'name': 'Valid-Cookie-Name',
+ 'value': 'Valid-Cookie-Value',
+ 'domain': 'localhost',
+ 'path': '/foo',
+ 'httponly': true,
+ 'secure': false
+};
+var cookie1 = {
+ 'name': 'Valid-Cookie-Name-1',
+ 'value': 'Valid-Cookie-Value',
+ 'domain': 'localhost',
+ 'path': '/foo',
+ 'httponly': true,
+ 'secure': false
+};
+var cookie2 = {
+ 'name': 'Valid-Cookie-Name-2',
+ 'value': 'Valid-Cookie-Value',
+ 'domain': 'localhost',
+ 'path': '/foo',
+ 'httponly': true,
+ 'secure': false
+};
+var cookies = [{
+ 'name': 'Valid-Cookie-Name',
+ 'value': 'Valid-Cookie-Value',
+ 'domain': 'localhost',
+ 'path': '/foo',
+ 'httponly': true,
+ 'secure': false
+},{
+ 'name': 'Valid-Cookie-Name-Sec',
+ 'value': 'Valid-Cookie-Value-Sec',
+ 'domain': 'localhost',
+ 'path': '/foo',
+ 'httponly': true,
+ 'secure': false,
+ 'expires': new Date().getTime() + 3600 //< expires in 1h
+}];
+
+var cookiejar, jar1, jar2;
+setup(function () {
+ cookiejar = require('cookiejar');
+ jar1 = cookiejar.create();
+ jar2 = cookiejar.create();
+});
+
+test(function () {
+ assert_type_of(jar1, 'object');
+ assert_not_equals(jar1, null);
+ assert_type_of(jar1.cookies, 'object');
+
+ assert_type_of(jar1.addCookie, 'function');
+ assert_type_of(jar1.deleteCookie, 'function');
+ assert_type_of(jar1.clearCookies, 'function');
+}, "cookie jar properties");
+
+test(function () {
+ assert_equals(jar1.cookies.length, 0);
+
+ jar1.addCookie(cookie0);
+ assert_equals(jar1.cookies.length, 1);
+
+ jar1.deleteCookie('Valid-Cookie-Name');
+ assert_equals(jar1.cookies.length, 0);
+}, "adding and removing cookies");
+
+test(function () {
+ assert_equals(jar1.cookies.length, 0);
+
+ jar1.cookies = cookies;
+ assert_equals(jar1.cookies.length, 2);
+
+ jar1.clearCookies();
+ assert_equals(jar1.cookies.length, 0);
+}, "setting and clearing a cookie jar");
+
+test(function () {
+ jar1.addCookie(cookie1);
+ assert_equals(jar1.cookies.length, 1);
+ assert_equals(jar2.cookies.length, 0);
+
+ jar2.addCookie(cookie2);
+ jar1.deleteCookie('Valid-Cookie-Name-1');
+ assert_equals(jar1.cookies.length, 0);
+ assert_equals(jar2.cookies.length, 1);
+
+ jar1.close();
+ jar2.close();
+
+}, "cookie jar isolation");
diff --git a/third_party/phantomjs/test/module/cookiejar/to-map.js b/third_party/phantomjs/test/module/cookiejar/to-map.js
new file mode 100644
index 00000000000..7528e3fc578
--- /dev/null
+++ b/third_party/phantomjs/test/module/cookiejar/to-map.js
@@ -0,0 +1,52 @@
+//! unsupported
+var cookies = {
+ 'beforeExpires': {
+ 'name': 'beforeExpires',
+ 'value': 'expireValue',
+ 'domain': '.abc.com',
+ 'path': '/',
+ 'httponly': false,
+ 'secure': false,
+ 'expires': 'Tue, 10 Jun 2025 12:28:29 GMT'
+ },
+ 'noExpiresDate': {
+ 'name': 'noExpiresDate',
+ 'value': 'value',
+ 'domain': '.abc.com',
+ 'path': '/',
+ 'httponly': false,
+ 'secure': false,
+ 'expires': null
+ },
+ 'afterExpires': {
+ 'name': 'afterExpires',
+ 'value': 'value',
+ 'domain': '.abc.com',
+ 'path': '/',
+ 'httponly': false,
+ 'secure': false,
+ 'expires': 'Mon, 10 Jun 2024 12:28:29 GMT'
+ }
+};
+
+test(function () {
+ var i, c, d, prop;
+ for (i in cookies) {
+ if (!cookies.hasOwnProperty(i)) continue;
+ phantom.addCookie(cookies[i]);
+ }
+ for (i in phantom.cookies) {
+ d = phantom.cookies[i];
+ c = cookies[d.name];
+ for (prop in c) {
+ if (!c.hasOwnProperty(prop)) continue;
+ if (c[prop] === null) {
+ assert_no_property(d, prop);
+ } else {
+ assert_own_property(d, prop);
+ assert_equals(c[prop], d[prop]);
+ }
+ }
+ }
+
+}, "optional cookie properties should not leak");
diff --git a/third_party/phantomjs/test/module/fs/basics.js b/third_party/phantomjs/test/module/fs/basics.js
new file mode 100644
index 00000000000..c522ab7f299
--- /dev/null
+++ b/third_party/phantomjs/test/module/fs/basics.js
@@ -0,0 +1,220 @@
+// Basic Files API (read, write, remove, ...)
+
+var FILENAME = "temp-01.test",
+ FILENAME_COPY = FILENAME + ".copy",
+ FILENAME_MOVED = FILENAME + ".moved",
+ FILENAME_EMPTY = FILENAME + ".empty",
+ FILENAME_ENC = FILENAME + ".enc",
+ FILENAME_BIN = FILENAME + ".bin",
+ ABSENT = "absent-01.test";
+
+var fs;
+
+setup(function () {
+ fs = require('fs');
+ var f = fs.open(FILENAME, "w");
+
+ f.write("hello");
+ f.writeLine("");
+ f.writeLine("world");
+ f.close();
+});
+
+test(function () {
+ assert_is_true(fs.exists(FILENAME));
+ // we might've gotten DOS line endings
+ assert_greater_than_equal(fs.size(FILENAME), "hello\nworld\n".length);
+
+}, "create a file with contents");
+
+test(function () {
+ assert_is_false(fs.exists(FILENAME_EMPTY));
+ fs.touch(FILENAME_EMPTY);
+ assert_is_true(fs.exists(FILENAME_EMPTY));
+ assert_equals(fs.size(FILENAME_EMPTY), 0);
+
+}, "create (touch) an empty file");
+
+test(function () {
+ var content = "";
+ var f = fs.open(FILENAME, "r");
+ this.add_cleanup(function () { f.close(); });
+
+ content = f.read();
+ assert_equals(content, "hello\nworld\n");
+
+}, "read content from a file");
+
+test(function () {
+ var content = "";
+ var f = fs.open(FILENAME, "r");
+ this.add_cleanup(function () { f.close(); });
+
+ f.seek(3);
+ content = f.read(5);
+ assert_equals(content, "lo\nwo");
+
+}, "read specific number of bytes from a specific position in a file");
+
+test(function () {
+ var content = "";
+ var f = fs.open(FILENAME, "rw+");
+ this.add_cleanup(function () { f.close(); });
+
+ f.writeLine("asdf");
+ content = f.read();
+ assert_equals(content, "hello\nworld\nasdf\n");
+
+}, "append content to a file");
+
+test(function () {
+ var f = fs.open(FILENAME, "r");
+ this.add_cleanup(function () { f.close(); });
+ assert_equals(f.getEncoding(), "UTF-8");
+
+}, "get the file encoding (default: UTF-8)");
+
+test(function () {
+ var f = fs.open(FILENAME, { charset: "UTF-8", mode: "r" });
+ this.add_cleanup(function () { f.close(); });
+ assert_equals(f.getEncoding(), "UTF-8");
+
+ var g = fs.open(FILENAME, { charset: "SJIS", mode: "r" });
+ this.add_cleanup(function () { g.close(); });
+ assert_equals(g.getEncoding(), "Shift_JIS");
+
+}, "set the encoding on open", {/* unsupported */expected_fail: true});
+
+test(function () {
+ var f = fs.open(FILENAME, { charset: "UTF-8", mode: "r" });
+ this.add_cleanup(function () { f.close(); });
+ assert_equals(f.getEncoding(), "UTF-8");
+ f.setEncoding("utf8");
+ assert_equals(f.getEncoding(), "UTF-8");
+
+ var g = fs.open(FILENAME, { charset: "SJIS", mode: "r" });
+ this.add_cleanup(function () { g.close(); });
+ assert_equals(g.getEncoding(), "Shift_JIS");
+ g.setEncoding("eucjp");
+ assert_equals(g.getEncoding(), "EUC-JP");
+
+}, "change the encoding using setEncoding", {/* unsupported */expected_fail: true});
+
+test(function () {
+ assert_is_false(fs.exists(FILENAME_COPY));
+ fs.copy(FILENAME, FILENAME_COPY);
+ assert_is_true(fs.exists(FILENAME_COPY));
+ assert_equals(fs.read(FILENAME), fs.read(FILENAME_COPY));
+
+}, "copy a file");
+
+test(function () {
+ assert_is_true(fs.exists(FILENAME));
+ var contentBeforeMove = fs.read(FILENAME);
+ fs.move(FILENAME, FILENAME_MOVED);
+ assert_is_false(fs.exists(FILENAME));
+ assert_is_true(fs.exists(FILENAME_MOVED));
+ assert_equals(fs.read(FILENAME_MOVED), contentBeforeMove);
+
+}, "move a file");
+
+test(function () {
+ assert_is_true(fs.exists(FILENAME_MOVED));
+ assert_is_true(fs.exists(FILENAME_COPY));
+ assert_is_true(fs.exists(FILENAME_EMPTY));
+
+ fs.remove(FILENAME_MOVED);
+ fs.remove(FILENAME_COPY);
+ fs.remove(FILENAME_EMPTY);
+
+ assert_is_false(fs.exists(FILENAME_MOVED));
+ assert_is_false(fs.exists(FILENAME_COPY));
+ assert_is_false(fs.exists(FILENAME_EMPTY));
+
+}, "remove a file");
+
+test(function () {
+ assert_throws("Unable to open file '"+ ABSENT +"'",
+ function () { fs.open(ABSENT, "r"); });
+
+ assert_throws("Unable to copy file '" + ABSENT +
+ "' at '" + FILENAME_COPY + "'",
+ function () { fs.copy(ABSENT, FILENAME_COPY); });
+
+}, "operations on nonexistent files throw an exception", {/* unsupported */expected_fail: true});
+
+test(function () {
+ var data = "ÄABCÖ";
+ var data_b = String.fromCharCode(
+ 0xC3, 0x84, 0x41, 0x42, 0x43, 0xC3, 0x96);
+
+ var f = fs.open(FILENAME_ENC, "w");
+ this.add_cleanup(function () {
+ f.close();
+ fs.remove(FILENAME_ENC);
+ });
+
+ f.write(data);
+ f.close();
+
+ f = fs.open(FILENAME_ENC, "r");
+ assert_equals(f.read(), data);
+
+ var g = fs.open(FILENAME_ENC, "rb");
+ this.add_cleanup(function () { g.close(); });
+ assert_equals(g.read(), data_b);
+
+}, "read/write UTF-8 text by default");
+
+test(function () {
+ var data = "ピタゴラスイッチ";
+ var data_b = String.fromCharCode(
+ 0x83, 0x73, 0x83, 0x5e, 0x83, 0x53, 0x83, 0x89,
+ 0x83, 0x58, 0x83, 0x43, 0x83, 0x62, 0x83, 0x60);
+
+ var f = fs.open(FILENAME_ENC, { mode: "w", charset: "Shift_JIS" });
+ this.add_cleanup(function () {
+ f.close();
+ fs.remove(FILENAME_ENC);
+ });
+
+ f.write(data);
+ f.close();
+
+ f = fs.open(FILENAME_ENC, { mode: "r", charset: "Shift_JIS" });
+ assert_equals(f.read(), data);
+
+ var g = fs.open(FILENAME_ENC, "rb");
+ this.add_cleanup(function () { g.close(); });
+ assert_equals(g.read(), data_b);
+
+}, "read/write Shift-JIS text with options", {/* unsupported */expected_fail: true});
+
+test(function () {
+ var data = String.fromCharCode(0, 1, 2, 3, 4, 5);
+
+ var f = fs.open(FILENAME_BIN, "wb");
+ this.add_cleanup(function () {
+ f.close();
+ fs.remove(FILENAME_BIN);
+ });
+
+ f.write(data);
+ f.close();
+
+ f = fs.open(FILENAME_BIN, "rb");
+ assert_equals(f.read(), data);
+
+}, "read/write binary data");
+
+test(function () {
+ var data = String.fromCharCode(0, 1, 2, 3, 4, 5);
+
+ fs.write(FILENAME_BIN, data, "b");
+ this.add_cleanup(function () {
+ fs.remove(FILENAME_BIN);
+ });
+
+ assert_equals(fs.read(FILENAME_BIN, "b"), data);
+
+}, "read/write binary data (shortcuts)");
diff --git a/third_party/phantomjs/test/module/fs/fileattrs.js b/third_party/phantomjs/test/module/fs/fileattrs.js
new file mode 100644
index 00000000000..f973abbaeb2
--- /dev/null
+++ b/third_party/phantomjs/test/module/fs/fileattrs.js
@@ -0,0 +1,91 @@
+
+var fs = require('fs');
+
+var ABSENT_DIR = "absentdir02",
+ ABSENT_FILE = "absentfile02",
+ TEST_DIR = "testdir02",
+ TEST_FILE = "temp-02.test",
+ TEST_FILE_PATH = fs.join(TEST_DIR, TEST_FILE),
+ TEST_CONTENT = "test content",
+ CONTENT_MULTIPLIER = 1024;
+
+test(function () {
+ assert_throws("Unable to read file '"+ ABSENT_FILE +"' size",
+ function () { fs.size(ABSENT_FILE); });
+
+ assert_equals(fs.lastModified(ABSENT_FILE), null);
+
+}, "size/date queries on nonexistent files", {/* unsupported */expected_fail: true});
+
+test(function () {
+ // Round down to the nearest multiple of two seconds, because
+ // file timestamps might only have that much precision.
+ var before_creation = Math.floor(Date.now() / 2000) * 2000;
+
+ var f = fs.open(TEST_FILE, "w");
+ this.add_cleanup(function () {
+ if (f !== null) f.close();
+ fs.remove(TEST_FILE);
+ });
+
+ for (var i = 0; i < CONTENT_MULTIPLIER; i++) {
+ f.write(TEST_CONTENT);
+ }
+ f.close(); f = null;
+
+ // Similarly, but round _up_.
+ var after_creation = Math.ceil(Date.now() / 2000) * 2000;
+
+ assert_equals(fs.size(TEST_FILE),
+ TEST_CONTENT.length * CONTENT_MULTIPLIER);
+
+ var flm = fs.lastModified(TEST_FILE).getTime();
+
+ assert_greater_than_equal(flm, before_creation);
+ assert_less_than_equal(flm, after_creation);
+
+}, "size/date queries on existing files");
+
+test(function () {
+ fs.makeDirectory(TEST_DIR);
+ this.add_cleanup(function () { fs.removeTree(TEST_DIR); });
+ fs.write(TEST_FILE_PATH, TEST_CONTENT, "w");
+
+ assert_is_true(fs.exists(TEST_FILE_PATH));
+ assert_is_true(fs.exists(TEST_DIR));
+ assert_is_false(fs.exists(ABSENT_FILE));
+ assert_is_false(fs.exists(ABSENT_DIR));
+
+ assert_is_true(fs.isDirectory(TEST_DIR));
+ assert_is_false(fs.isDirectory(ABSENT_DIR));
+
+
+ assert_is_true(fs.isFile(TEST_FILE_PATH));
+ assert_is_false(fs.isFile(ABSENT_FILE));
+
+ var absPath = fs.absolute(TEST_FILE_PATH);
+ assert_is_false(fs.isAbsolute(TEST_FILE_PATH));
+ assert_is_true(fs.isAbsolute(absPath));
+
+ assert_is_true(fs.isReadable(TEST_FILE_PATH));
+ assert_is_true(fs.isWritable(TEST_FILE_PATH));
+ assert_is_false(fs.isExecutable(TEST_FILE_PATH));
+
+ assert_is_false(fs.isReadable(ABSENT_FILE));
+ assert_is_false(fs.isWritable(ABSENT_FILE));
+ assert_is_false(fs.isExecutable(ABSENT_FILE));
+
+ assert_is_true(fs.isReadable(TEST_DIR));
+ assert_is_true(fs.isWritable(TEST_DIR));
+ assert_is_true(fs.isExecutable(TEST_DIR));
+
+ assert_is_false(fs.isReadable(ABSENT_DIR));
+ assert_is_false(fs.isWritable(ABSENT_DIR));
+ assert_is_false(fs.isExecutable(ABSENT_DIR));
+
+ assert_is_false(fs.isLink(TEST_DIR));
+ assert_is_false(fs.isLink(TEST_FILE_PATH));
+ assert_is_false(fs.isLink(ABSENT_DIR));
+ assert_is_false(fs.isLink(ABSENT_FILE));
+
+}, "file types and access modes");
diff --git a/third_party/phantomjs/test/module/fs/paths.js b/third_party/phantomjs/test/module/fs/paths.js
new file mode 100644
index 00000000000..0910f20bb3d
--- /dev/null
+++ b/third_party/phantomjs/test/module/fs/paths.js
@@ -0,0 +1,72 @@
+
+var fs = require('fs');
+var system = require('system');
+
+var TEST_DIR = "testdir",
+ TEST_FILE = "testfile",
+ START_CWD = fs.workingDirectory;
+
+test(function () {
+ assert_is_true(fs.makeDirectory(TEST_DIR));
+ this.add_cleanup(function () { fs.removeTree(TEST_DIR); });
+
+ assert_is_true(fs.changeWorkingDirectory(TEST_DIR));
+ this.add_cleanup(function () { fs.changeWorkingDirectory(START_CWD); });
+
+ fs.write(TEST_FILE, TEST_FILE, "w");
+ var suffix = fs.join("", TEST_DIR, TEST_FILE),
+ abs = fs.absolute(".." + suffix),
+ lastIndex = abs.lastIndexOf(suffix);
+
+ assert_not_equals(lastIndex, -1);
+ assert_equals(lastIndex + suffix.length, abs.length);
+
+}, "manipulation of current working directory");
+
+test(function () {
+
+ fs.copyTree(phantom.libraryPath, TEST_DIR);
+ this.add_cleanup(function () { fs.removeTree(TEST_DIR); });
+
+ assert_deep_equals(fs.list(phantom.libraryPath), fs.list(TEST_DIR));
+
+}, "copying a directory tree");
+
+test(function () {
+ assert_type_of(fs.readLink, 'function');
+ // TODO: test the actual functionality once we can create symlinks.
+}, "fs.readLink exists");
+
+generate_tests(function fs_join_test (parts, expected) {
+ var actual = fs.join.apply(null, parts);
+ assert_equals(actual, expected);
+}, [
+ [ "fs.join: []", [], "." ],
+ [ "fs.join: nonsense", [[], null], "." ],
+ [ "fs.join: 1 element", [""], "." ],
+ [ "fs.join: 2 elements", ["", "a"], "/a" ],
+ [ "fs.join: 3 elements", ["a", "b", "c"], "a/b/c" ],
+ [ "fs.join: 4 elements", ["", "a", "b", "c"], "/a/b/c" ],
+ [ "fs.join: empty elements", ["", "a", "", "b", "", "c"], "/a/b/c" ],
+ [ "fs.join: empty elements 2", ["a", "", "b", "", "c"], "a/b/c" ]
+]);
+
+generate_tests(function fs_split_test (input, expected) {
+ var path = input.join(fs.separator);
+ var actual = fs.split(path);
+ assert_deep_equals(actual, expected);
+}, [
+ [ "fs.split: absolute",
+ ["", "a", "b", "c", "d"], ["", "a", "b", "c", "d"] ],
+ [ "fs.split: absolute, trailing",
+ ["", "a", "b", "c", "d", ""], ["", "a", "b", "c", "d"] ],
+ [ "fs.split: non-absolute",
+ ["a", "b", "c", "d"], ["a", "b", "c", "d"] ],
+ [ "fs.split: non-absolute, trailing",
+ ["a", "b", "c", "d", ""], ["a", "b", "c", "d"] ],
+ [ "fs.split: repeated separators",
+ ["a", "", "", "",
+ "b", "",
+ "c", "", "",
+ "d", "", "", ""], ["a", "b", "c", "d"] ]
+]);
diff --git a/third_party/phantomjs/test/module/system/stdin.js b/third_party/phantomjs/test/module/system/stdin.js
new file mode 100644
index 00000000000..8a08f2631cf
--- /dev/null
+++ b/third_party/phantomjs/test/module/system/stdin.js
@@ -0,0 +1,22 @@
+//! stdin: Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich
+//! stdin: いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしゑひもせす
+
+//^ first line: pangram in German
+//^ second line: pan+isogram in hiragana (the Iroha)
+
+var stdin;
+setup(function () { stdin = require("system").stdin; });
+
+test(function () {
+ assert_equals(stdin.readLine(),
+ "Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich");
+}, "input line one (German)");
+
+test(function () {
+ assert_equals(stdin.readLine(),
+ "いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしゑひもせす");
+}, "input line two (Japanese)");
+
+test(function () {
+ assert_equals(stdin.readLine(), "");
+}, "input line three (EOF)");
diff --git a/third_party/phantomjs/test/module/system/stdout-err.js b/third_party/phantomjs/test/module/system/stdout-err.js
new file mode 100644
index 00000000000..2281b42fdd8
--- /dev/null
+++ b/third_party/phantomjs/test/module/system/stdout-err.js
@@ -0,0 +1,14 @@
+//! no-harness
+//! expect-stdout: Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich
+//! expect-stderr: いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしゑひもせす
+
+//^ stdout: pangram in German
+//^ stderr: pan+isogram in hiragana (the Iroha)
+
+phantom.onError = function () { phantom.exit(1); };
+
+var sys = require("system");
+
+sys.stdout.write("Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich\n");
+sys.stderr.write("いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしゑひもせす");
+phantom.exit(0);
diff --git a/third_party/phantomjs/test/module/system/system.js b/third_party/phantomjs/test/module/system/system.js
new file mode 100644
index 00000000000..ae5422d041b
--- /dev/null
+++ b/third_party/phantomjs/test/module/system/system.js
@@ -0,0 +1,77 @@
+var system = require('system');
+
+test(function () {
+ assert_type_of(system, 'object');
+ assert_not_equals(system, null);
+}, "system object");
+
+test(function () {
+ assert_own_property(system, 'pid');
+ assert_type_of(system.pid, 'number');
+ assert_greater_than(system.pid, 0);
+}, "system.pid");
+
+test(function () {
+ assert_own_property(system, 'isSSLSupported');
+ assert_type_of(system.isSSLSupported, 'boolean');
+ assert_equals(system.isSSLSupported, true);
+}, "system.isSSLSupported", {/* unsupported */expected_fail: true});
+
+test(function () {
+ assert_own_property(system, 'args');
+ assert_type_of(system.args, 'object');
+ assert_instance_of(system.args, Array);
+ assert_greater_than_equal(system.args.length, 1);
+
+ // args[0] will be the test harness.
+ assert_regexp_match(system.args[0], /\btestharness\.js$/);
+}, "system.args", {/* unsupported */expected_fail: true});
+
+test(function () {
+ assert_own_property(system, 'env');
+ assert_type_of(system.env, 'object');
+}, "system.env");
+
+test(function () {
+ assert_own_property(system, 'platform');
+ assert_type_of(system.platform, 'string');
+ assert_equals(system.platform, 'phantomjs');
+}, "system.platform");
+
+test(function () {
+ assert_own_property(system, 'os');
+ assert_type_of(system.os, 'object');
+
+ assert_type_of(system.os.architecture, 'string');
+ assert_type_of(system.os.name, 'string');
+ assert_type_of(system.os.version, 'string');
+
+ if (system.os.name === 'mac') {
+ // release is x.y.z with x = 10 for Snow Leopard and 14 for Yosemite
+ assert_type_of(system.os.release, 'string');
+ assert_greater_than_equal(parseInt(system.os.release, 10), 10);
+ }
+}, "system.os");
+
+test(function () {
+ assert_type_of(system.stdin, 'object');
+ assert_type_of(system.stdin.read, 'function');
+ assert_type_of(system.stdin.readLine, 'function');
+ assert_type_of(system.stdin.close, 'function');
+}, "system.stdin");
+
+test(function () {
+ assert_type_of(system.stdout, 'object');
+ assert_type_of(system.stdout.write, 'function');
+ assert_type_of(system.stdout.writeLine, 'function');
+ assert_type_of(system.stdout.flush, 'function');
+ assert_type_of(system.stdout.close, 'function');
+}, "system.stdout");
+
+test(function () {
+ assert_type_of(system.stderr, 'object');
+ assert_type_of(system.stderr.write, 'function');
+ assert_type_of(system.stderr.writeLine, 'function');
+ assert_type_of(system.stderr.flush, 'function');
+ assert_type_of(system.stderr.close, 'function');
+}, "system.stderr");
diff --git a/third_party/phantomjs/test/module/webpage/abort-network-request.js b/third_party/phantomjs/test/module/webpage/abort-network-request.js
new file mode 100644
index 00000000000..e6718ff7435
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/abort-network-request.js
@@ -0,0 +1,37 @@
+//! unsupported
+var webpage = require('webpage');
+
+async_test(function () {
+ var page = webpage.create();
+ var abortCount = 0;
+ var errorCount = 0;
+ var abortedIds = {};
+ var urlToBlockRegExp = /logo\.png$/i;
+
+ page.onResourceRequested = this.step_func(function(requestData, request) {
+ assert_type_of(request, 'object');
+ assert_type_of(request.abort, 'function');
+ if (urlToBlockRegExp.test(requestData.url)) {
+ request.abort();
+ ++abortCount;
+ abortedIds[requestData.id] = 1;
+ }
+ });
+ page.onResourceError = this.step_func(function(error) {
+ // We can't match up errors to requests by URL because error.url will
+ // be the empty string in this case. FIXME.
+ assert_own_property(abortedIds, error.id);
+ ++errorCount;
+ });
+ page.onResourceReceived = this.step_func(function(response) {
+ assert_regexp_not_match(response.url, urlToBlockRegExp);
+ });
+
+ page.open(TEST_HTTP_BASE + 'logo.html',
+ this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_equals(abortCount, 1);
+ assert_equals(errorCount, 1);
+ }));
+
+}, "can abort network requests");
diff --git a/third_party/phantomjs/test/module/webpage/add-header.js b/third_party/phantomjs/test/module/webpage/add-header.js
new file mode 100644
index 00000000000..5594f4e2834
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/add-header.js
@@ -0,0 +1,25 @@
+//! unsupported
+async_test(function () {
+ var webpage = require('webpage');
+
+ // NOTE: HTTP header names are case-insensitive. Our test server
+ // returns the name in lowercase.
+
+ var page = webpage.create();
+ assert_type_of(page.customHeaders, 'object');
+ assert_deep_equals(page.customHeaders, {});
+
+ page.onResourceRequested = this.step_func(function(requestData, request) {
+ assert_type_of(request.setHeader, 'function');
+ request.setHeader('CustomHeader', 'CustomValue');
+ });
+ page.open(TEST_HTTP_BASE + 'echo', this.step_func_done(function (status) {
+ var json, headers;
+ assert_equals(status, 'success');
+ json = JSON.parse(page.plainText);
+ headers = json.headers;
+ assert_own_property(headers, 'customheader');
+ assert_equals(headers.customheader, 'CustomValue');
+ }));
+
+}, "add custom headers in onResourceRequested");
diff --git a/third_party/phantomjs/test/module/webpage/callback.js b/third_party/phantomjs/test/module/webpage/callback.js
new file mode 100644
index 00000000000..0c14c44105e
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/callback.js
@@ -0,0 +1,16 @@
+test(function () {
+ var page = require('webpage').create();
+
+ var msgA = "a",
+ msgB = "b",
+ result,
+ expected = msgA + msgB;
+ page.onCallback = function(a, b) {
+ return a + b;
+ };
+ result = page.evaluate(function(a, b) {
+ return window.callPhantom(a, b);
+ }, msgA, msgB);
+
+ assert_equals(result, expected);
+}, "page.onCallback");
diff --git a/third_party/phantomjs/test/module/webpage/capture-content.js b/third_party/phantomjs/test/module/webpage/capture-content.js
new file mode 100644
index 00000000000..99f64ad57c4
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/capture-content.js
@@ -0,0 +1,50 @@
+//! unsupported
+var content;
+setup(function () {
+ var fs = require('fs');
+ // libraryPath is test/module/webpage
+ content = fs.read(fs.join(phantom.libraryPath,
+ "../../www/hello.html"));
+});
+
+// XFAIL: This feature had to be backed out for breaking WebSockets.
+async_test(function () {
+ var page = require('webpage').create();
+ var lastChunk = "";
+ var bodySize = 0;
+ page.captureContent = ['.*'];
+ // Not a step function because it may be called several times
+ // and doesn't need to make assertions.
+ page.onResourceReceived = function (resource) {
+ lastChunk = resource.body;
+ bodySize = resource.bodySize;
+ };
+ page.open(TEST_HTTP_BASE + "hello.html",
+ this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ assert_equals(bodySize, content.length);
+ assert_equals(lastChunk, content);
+ }));
+
+}, "onResourceReceived sees the body if captureContent is activated",
+ { expected_fail: true }
+);
+
+async_test(function () {
+ var page = require('webpage').create();
+ var lastChunk = "";
+ var bodySize = 0;
+ page.captureContent = ['/some/other/url'];
+ // Not a step function because it may be called several times
+ // and doesn't need to make assertions.
+ page.onResourceReceived = function (resource) {
+ lastChunk = resource.body;
+ bodySize = resource.bodySize;
+ };
+ page.open(TEST_HTTP_BASE + "hello.html",
+ this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ assert_equals(bodySize, 0);
+ assert_equals(lastChunk, "");
+ }));
+}, "onResourceReceived doesn't see the body if captureContent doesn't match");
diff --git a/third_party/phantomjs/test/module/webpage/change-request-encoded-url.js b/third_party/phantomjs/test/module/webpage/change-request-encoded-url.js
new file mode 100644
index 00000000000..b6d5327b280
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/change-request-encoded-url.js
@@ -0,0 +1,27 @@
+//! unsupported
+var webpage = require('webpage');
+
+async_test(function () {
+ var page = webpage.create();
+
+ var url = TEST_HTTP_BASE + "cdn-cgi/pe/bag?r%5B%5D="+
+ "http%3A%2F%2Fwww.example.org%2Fcdn-cgi%2Fnexp%2F"+
+ "abv%3D927102467%2Fapps%2Fabetterbrowser.js";
+ var receivedUrl;
+
+ page.onResourceRequested = this.step_func(function(requestData, request) {
+ request.changeUrl(requestData.url);
+ });
+
+ page.onResourceReceived = this.step_func(function(data) {
+ if (data.stage === 'end') {
+ receivedUrl = data.url;
+ }
+ });
+
+ page.open(url, this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_equals(receivedUrl, url);
+ }));
+
+}, "encoded URLs properly round-trip through request.changeUrl");
diff --git a/third_party/phantomjs/test/module/webpage/change-request-url.js b/third_party/phantomjs/test/module/webpage/change-request-url.js
new file mode 100644
index 00000000000..ea8e7e8a583
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/change-request-url.js
@@ -0,0 +1,40 @@
+//! unsupported
+var webpage = require('webpage');
+
+async_test(function () {
+
+ var page = webpage.create();
+ var urlToChange = TEST_HTTP_BASE + 'logo.png';
+ var alternativeUrl = TEST_HTTP_BASE + 'phantomjs-logo.gif';
+ var startStage = 0;
+ var endStage = 0;
+
+ page.onResourceRequested = this.step_func(function(requestData, request) {
+ if (requestData.url === urlToChange) {
+ assert_type_of(request, 'object');
+ assert_type_of(request.changeUrl, 'function');
+ request.changeUrl(alternativeUrl);
+ }
+ });
+
+ page.onResourceReceived = this.step_func(function(data) {
+ if (data.url === alternativeUrl && data.stage === 'start') {
+ ++startStage;
+ }
+ if (data.url === alternativeUrl && data.stage === 'end') {
+ ++endStage;
+ }
+ });
+
+ page.open(TEST_HTTP_BASE + 'logo.html',
+ this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_equals(startStage, 1);
+ assert_equals(endStage, 1);
+
+ // The page HTML should still refer to the original image.
+ assert_regexp_match(page.content, /logo\.png/);
+ assert_regexp_not_match(page.content, /logo\.gif/);
+ }));
+
+}, "request.changeUrl");
diff --git a/third_party/phantomjs/test/module/webpage/cjk-text-codecs.js b/third_party/phantomjs/test/module/webpage/cjk-text-codecs.js
new file mode 100644
index 00000000000..afd653c6982
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/cjk-text-codecs.js
@@ -0,0 +1,33 @@
+var webpage = require('webpage');
+
+function test_one(text) {
+ var t = async_test(text.codec);
+ t.step(function () {
+ var page = webpage.create();
+ page.open(text.url, t.step_func_done(function () {
+ var decodedText = page.evaluate(function() {
+ return document.querySelector('pre').innerText;
+ });
+ var regex = '^' + text.reference + '$';
+ assert_regexp_match(text.reference, new RegExp(regex));
+ }));
+ });
+}
+
+function Text(codec, base64, reference) {
+ this.codec = codec;
+ this.base64 = base64;
+ this.reference = reference;
+ this.url = 'data:text/plain;charset=' + this.codec +
+ ';base64,' + this.base64;
+}
+
+[
+ new Text('Shift_JIS', 'g3SDQIOTg2eDgA==', 'ファントム'),
+ new Text('EUC-JP', 'pdWloaXzpcil4A0K', 'ファントム'),
+ new Text('ISO-2022-JP', 'GyRCJVUlISVzJUglYBsoQg0K', 'ファントム'),
+ new Text('Big5', 'pNu2SA0K', '幻象'),
+ new Text('GBK', 'u8PP8w0K', '幻象'),
+ new Text('EUC-KR', 'yK+/tQ==', '환영'),
+]
+ .forEach(test_one);
diff --git a/third_party/phantomjs/test/module/webpage/clip-rect.js b/third_party/phantomjs/test/module/webpage/clip-rect.js
new file mode 100644
index 00000000000..46c9e40d840
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/clip-rect.js
@@ -0,0 +1,19 @@
+var webpage = require('webpage');
+
+test(function () {
+ var defaultPage = webpage.create();
+ assert_deep_equals(defaultPage.clipRect, {height:0,left:0,top:0,width:0});
+}, "default page.clipRect");
+
+test(function () {
+ var options = {
+ clipRect: {
+ height: 100,
+ left: 10,
+ top: 20,
+ width: 200
+ }
+ };
+ var customPage = webpage.create(options);
+ assert_deep_equals(customPage.clipRect, options.clipRect);
+}, "custom page.clipRect");
diff --git a/third_party/phantomjs/test/module/webpage/construction-with-options.js b/third_party/phantomjs/test/module/webpage/construction-with-options.js
new file mode 100644
index 00000000000..42d67371d49
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/construction-with-options.js
@@ -0,0 +1,59 @@
+//! unsupported
+test(function () {
+ var opts = {},
+ page = new WebPage(opts);
+ assert_type_of(page, 'object');
+ assert_not_equals(page, null);
+}, "webpage constructor accepts an opts object");
+
+async_test(function () {
+ var opts = {
+ onConsoleMessage: this.step_func_done(function (msg) {
+ assert_equals(msg, "test log");
+ })
+ };
+ var page = new WebPage(opts);
+ assert_equals(page.onConsoleMessage, opts.onConsoleMessage);
+ page.evaluate(function () {console.log('test log');});
+
+}, "specifying onConsoleMessage with opts");
+
+async_test(function () {
+ var page_opened = false;
+ var opts = {
+ onLoadStarted: this.step_func_done(function (msg) {
+ assert_is_true(page_opened);
+ })
+ };
+ var page = new WebPage(opts);
+ assert_equals(page.onLoadStarted, opts.onLoadStarted);
+ page_opened = true;
+ page.open("about:blank");
+
+}, "specifying onLoadStarted with opts");
+
+async_test(function () {
+ var page_opened = false;
+ var opts = {
+ onLoadFinished: this.step_func_done(function (msg) {
+ assert_is_true(page_opened);
+ })
+ };
+ var page = new WebPage(opts);
+ assert_equals(page.onLoadFinished, opts.onLoadFinished);
+ page_opened = true;
+ page.open("about:blank");
+
+}, "specifying onLoadFinished with opts");
+
+// FIXME: Actually test that the timeout is effective.
+test(function () {
+ var opts = {
+ settings: {
+ timeout: 100 // time in ms
+ }
+ };
+ var page = new WebPage(opts);
+ assert_equals(page.settings.timeout, opts.settings.timeout);
+
+}, "specifying timeout with opts");
diff --git a/third_party/phantomjs/test/module/webpage/contextclick-event.js b/third_party/phantomjs/test/module/webpage/contextclick-event.js
new file mode 100644
index 00000000000..af046110d89
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/contextclick-event.js
@@ -0,0 +1,33 @@
+//! unsupported
+test(function () {
+ var page = require('webpage').create();
+
+ page.evaluate(function() {
+ window.addEventListener('contextmenu', function(event) {
+ window.loggedEvent = window.loggedEvent || {};
+ window.loggedEvent.contextmenu = event;
+ }, false);
+ });
+ page.sendEvent('contextmenu', 42, 217);
+
+ var event = page.evaluate(function() {
+ return window.loggedEvent;
+ });
+ assert_equals(event.contextmenu.clientX, 42);
+ assert_equals(event.contextmenu.clientY, 217);
+
+ // click with modifier key
+ page.evaluate(function() {
+ window.addEventListener('contextmenu', function(event) {
+ window.loggedEvent = window.loggedEvent || {};
+ window.loggedEvent.contextmenu = event;
+ }, false);
+ });
+ page.sendEvent('contextmenu', 100, 100, 'left', page.event.modifier.shift);
+
+ var event = page.evaluate(function() {
+ return window.loggedEvent.contextmenu;
+ });
+ assert_is_true(event.shiftKey);
+
+}, "context click events");
diff --git a/third_party/phantomjs/test/module/webpage/cookies.js b/third_party/phantomjs/test/module/webpage/cookies.js
new file mode 100644
index 00000000000..e1137a5dcd0
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/cookies.js
@@ -0,0 +1,112 @@
+//! unsupported
+async_test(function () {
+ var url = TEST_HTTP_BASE + "echo";
+ var page = new WebPage();
+
+ page.cookies = [{
+ 'name' : 'Valid-Cookie-Name',
+ 'value' : 'Valid-Cookie-Value',
+ 'domain' : 'localhost',
+ 'path' : '/',
+ 'httponly' : true,
+ 'secure' : false
+ },{
+ 'name' : 'Valid-Cookie-Name-Sec',
+ 'value' : 'Valid-Cookie-Value-Sec',
+ 'domain' : 'localhost',
+ 'path' : '/',
+ 'httponly' : true,
+ 'secure' : false,
+ 'expires' : Date.now() + 3600 //< expires in 1h
+ }];
+
+ page.open(url, this.step_func(function (status) {
+ assert_equals(status, "success");
+ var headers = JSON.parse(page.plainText).headers;
+ assert_own_property(headers, 'cookie');
+ assert_regexp_match(headers.cookie, /\bValid-Cookie-Name\b/);
+ assert_regexp_match(headers.cookie, /\bValid-Cookie-Value\b/);
+ assert_regexp_match(headers.cookie, /\bValid-Cookie-Name-Sec\b/);
+ assert_regexp_match(headers.cookie, /\bValid-Cookie-Value-Sec\b/);
+ assert_not_equals(page.cookies.length, 0);
+
+ page.cookies = [];
+ page.open(url, this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ var headers = JSON.parse(page.plainText).headers;
+ assert_no_property(headers, 'cookie');
+ }));
+ }));
+}, "adding and deleting cookies with page.cookies");
+
+async_test(function () {
+ var url = TEST_HTTP_BASE + "echo";
+ var page = new WebPage();
+
+ page.addCookie({
+ 'name' : 'Added-Cookie-Name',
+ 'value' : 'Added-Cookie-Value',
+ 'domain' : 'localhost'
+ });
+
+ page.open(url, this.step_func(function (status) {
+ assert_equals(status, "success");
+ var headers = JSON.parse(page.plainText).headers;
+ assert_own_property(headers, 'cookie');
+ assert_regexp_match(headers.cookie, /\bAdded-Cookie-Name\b/);
+ assert_regexp_match(headers.cookie, /\bAdded-Cookie-Value\b/);
+
+ page.deleteCookie("Added-Cookie-Name");
+ page.open(url, this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ var headers = JSON.parse(page.plainText).headers;
+ assert_no_property(headers, 'cookie');
+ }));
+ }));
+
+}, "adding and deleting cookies with page.addCookie and page.deleteCookie");
+
+async_test(function () {
+ var url = TEST_HTTP_BASE + "echo";
+ var page = new WebPage();
+
+ page.cookies = [
+ { // domain mismatch.
+ 'name' : 'Invalid-Cookie-Name-1',
+ 'value' : 'Invalid-Cookie-Value-1',
+ 'domain' : 'foo.example'
+ },{ // path mismatch: the cookie will be set,
+ // but won't be visible from the given URL (not same path).
+ 'name' : 'Invalid-Cookie-Name-2',
+ 'value' : 'Invalid-Cookie-Value-2',
+ 'domain' : 'localhost',
+ 'path' : '/bar'
+ },{ // cookie expired.
+ 'name' : 'Invalid-Cookie-Name-3',
+ 'value' : 'Invalid-Cookie-Value-3',
+ 'domain' : 'localhost',
+ 'expires' : 'Sat, 01 Jan 2000 00:00:00 GMT'
+ },{ // https only: the cookie will be set,
+ // but won't be visible from the given URL (not https).
+ 'name' : 'Invalid-Cookie-Name-4',
+ 'value' : 'Invalid-Cookie-Value-4',
+ 'domain' : 'localhost',
+ 'secure' : true
+ },{ // cookie expired (date in "sec since epoch").
+ 'name' : 'Invalid-Cookie-Name-5',
+ 'value' : 'Invalid-Cookie-Value-5',
+ 'domain' : 'localhost',
+ 'expires' : new Date().getTime() - 1 //< date in the past
+ },{ // cookie expired (date in "sec since epoch" - using "expiry").
+ 'name' : 'Invalid-Cookie-Name-6',
+ 'value' : 'Invalid-Cookie-Value-6',
+ 'domain' : 'localhost',
+ 'expiry' : new Date().getTime() - 1 //< date in the past
+ }];
+
+ page.open(url, this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ var headers = JSON.parse(page.plainText).headers;
+ assert_no_property(headers, 'cookie');
+ }));
+}, "page.cookies provides cookies only to appropriate requests");
diff --git a/third_party/phantomjs/test/module/webpage/custom-headers.js b/third_party/phantomjs/test/module/webpage/custom-headers.js
new file mode 100644
index 00000000000..0aaefd79dc7
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/custom-headers.js
@@ -0,0 +1,30 @@
+async_test(function () {
+ var webpage = require('webpage');
+ var page = webpage.create();
+ assert_type_of(page.customHeaders, 'object');
+ assert_deep_equals(page.customHeaders, {});
+
+ // NOTE: HTTP header names are case-insensitive. Our test server
+ // returns the name in lowercase.
+ page.customHeaders = {
+ 'Custom-Key': 'Custom-Value',
+ 'User-Agent': 'Overriden-UA',
+ 'Referer': 'http://example.com/'
+ };
+ page.open(TEST_HTTP_BASE + 'echo', this.step_func_done(function (status) {
+ var json, headers;
+ assert_equals(status, 'success');
+ json = JSON.parse(page.plainText);
+ assert_type_of(json, 'object');
+ headers = json.headers;
+ assert_type_of(headers, 'object');
+
+ assert_own_property(headers, 'custom-key');
+ assert_own_property(headers, 'user-agent');
+ assert_own_property(headers, 'referer');
+ assert_equals(headers['custom-key'], 'Custom-Value');
+ assert_equals(headers['user-agent'], 'Overriden-UA');
+ assert_equals(headers['referer'], 'http://example.com/');
+ }));
+
+}, "adding custom headers with page.customHeaders");
diff --git a/third_party/phantomjs/test/module/webpage/evaluate-broken-json.js b/third_party/phantomjs/test/module/webpage/evaluate-broken-json.js
new file mode 100644
index 00000000000..1f1d263598e
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/evaluate-broken-json.js
@@ -0,0 +1,14 @@
+test(function () {
+ var webpage = require('webpage');
+ var page = webpage.create();
+
+ // Hijack JSON.parse to something completely useless.
+ page.content = '';
+
+ var result = page.evaluate(function(obj) {
+ return obj.value * obj.value;
+ }, { value: 4 });
+
+ assert_equals(result, 16);
+
+}, "page script should not interfere with page.evaluate");
diff --git a/third_party/phantomjs/test/module/webpage/file-upload.js b/third_party/phantomjs/test/module/webpage/file-upload.js
new file mode 100644
index 00000000000..711ef30c82c
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/file-upload.js
@@ -0,0 +1,56 @@
+//! unsupported
+
+// Note: uses various files in module/webpage as things to be uploaded.
+// Which files they are doesn't matter.
+
+var page;
+setup(function () {
+ page = new WebPage();
+ page.content =
+ '\n' +
+ '\n' +
+ '' +
+ '';
+ page.uploadFile("#file", "file-upload.js");
+ page.uploadFile("#file2", "file-upload.js");
+ page.uploadFile("#file3", ["file-upload.js", "object.js"]);
+});
+
+function test_one_elt(id, names) {
+ var files = page.evaluate(function (id) {
+ var elt = document.getElementById(id);
+ var rv = [];
+ for (var i = 0; i < elt.files.length; i++) {
+ rv.push(elt.files[i].fileName);
+ }
+ return rv;
+ }, id);
+ assert_deep_equals(files, names);
+}
+
+generate_tests(test_one_elt, [
+ ["single upload single file", "file", ["file-upload.js"]],
+ ["multiple upload single file", "file2", ["file-upload.js"]],
+ ["multiple upload multiple file", "file3", ["file-upload.js", "object.js"]],
+], { expected_fail: true });
+
+async_test(function () {
+ page.onFilePicker = this.step_func(function (oldFile) {
+ assert_equals(oldFile, "");
+ return "no-plugin.js";
+ });
+
+ test_one_elt("file4", []);
+
+ page.evaluate(function () {
+ var fileUp = document.querySelector("#file4");
+ var ev = document.createEvent("MouseEvents");
+ ev.initEvent("click", true, true);
+ fileUp.dispatchEvent(ev);
+ });
+
+ setTimeout(this.step_func_done(function () {
+ test_one_elt("file4", ["no-plugin.js"]);
+ }, 0));
+
+}, "page.onFilePicker", { expected_fail: true });
diff --git a/third_party/phantomjs/test/module/webpage/frame-switching-deprecated.js b/third_party/phantomjs/test/module/webpage/frame-switching-deprecated.js
new file mode 100644
index 00000000000..f20938c9a6f
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/frame-switching-deprecated.js
@@ -0,0 +1,69 @@
+//! unsupported
+async_test(function () {
+ var p = require("webpage").create();
+
+ function pageTitle(page) {
+ return page.evaluate(function(){
+ return window.document.title;
+ });
+ }
+
+ function setPageTitle(page, newTitle) {
+ page.evaluate(function(newTitle){
+ window.document.title = newTitle;
+ }, newTitle);
+ }
+
+ function testFrameSwitchingDeprecated() {
+ assert_equals(pageTitle(p), "index");
+ assert_equals(p.currentFrameName(), "");
+ assert_equals(p.childFramesCount(), 2);
+ assert_deep_equals(p.childFramesName(), ["frame1", "frame2"]);
+ setPageTitle(p, pageTitle(p) + "-visited");
+
+ assert_is_true(p.switchToChildFrame("frame1"));
+ assert_equals(pageTitle(p), "frame1");
+ assert_equals(p.currentFrameName(), "frame1");
+ assert_equals(p.childFramesCount(), 2);
+ assert_deep_equals(p.childFramesName(), ["frame1-1", "frame1-2"]);
+ setPageTitle(p, pageTitle(p) + "-visited");
+
+ assert_is_true(p.switchToChildFrame("frame1-2"));
+ assert_equals(pageTitle(p), "frame1-2");
+ assert_equals(p.currentFrameName(), "frame1-2");
+ assert_equals(p.childFramesCount(), 0);
+ assert_deep_equals(p.childFramesName(), []);
+ setPageTitle(p, pageTitle(p) + "-visited");
+
+ assert_is_true(p.switchToParentFrame());
+ assert_equals(pageTitle(p), "frame1-visited");
+ assert_equals(p.currentFrameName(), "frame1");
+ assert_equals(p.childFramesCount(), 2);
+ assert_deep_equals(p.childFramesName(), ["frame1-1", "frame1-2"]);
+
+ assert_is_true(p.switchToChildFrame(0));
+ assert_equals(pageTitle(p), "frame1-1");
+ assert_equals(p.currentFrameName(), "frame1-1");
+ assert_equals(p.childFramesCount(), 0);
+ assert_deep_equals(p.childFramesName(), []);
+
+ assert_equals(p.switchToMainFrame(), undefined);
+ assert_equals(pageTitle(p), "index-visited");
+ assert_equals(p.currentFrameName(), "");
+ assert_equals(p.childFramesCount(), 2);
+ assert_deep_equals(p.childFramesName(), ["frame1", "frame2"]);
+
+ assert_is_true(p.switchToChildFrame("frame2"));
+ assert_equals(pageTitle(p), "frame2");
+ assert_equals(p.currentFrameName(), "frame2");
+ assert_equals(p.childFramesCount(), 3);
+ assert_deep_equals(p.childFramesName(),
+ ["frame2-1", "frame2-2", "frame2-3"]);
+ }
+
+ p.open(TEST_HTTP_BASE + "frameset", this.step_func_done(function (s) {
+ assert_equals(s, "success");
+ testFrameSwitchingDeprecated();
+ }));
+
+}, "frame switching deprecated API");
diff --git a/third_party/phantomjs/test/module/webpage/frame-switching.js b/third_party/phantomjs/test/module/webpage/frame-switching.js
new file mode 100644
index 00000000000..295bf37776d
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/frame-switching.js
@@ -0,0 +1,98 @@
+//! unsupported
+async_test(function () {
+ var p = require("webpage").create();
+
+ function pageTitle(page) {
+ return page.evaluate(function(){
+ return window.document.title;
+ });
+ }
+
+ function setPageTitle(page, newTitle) {
+ page.evaluate(function(newTitle){
+ window.document.title = newTitle;
+ }, newTitle);
+ }
+
+ function testFrameSwitching() {
+ assert_equals(pageTitle(p), "index");
+ assert_equals(p.frameName, "");
+ assert_equals(p.framesCount, 2);
+ assert_deep_equals(p.framesName, ["frame1", "frame2"]);
+ setPageTitle(p, pageTitle(p) + "-visited");
+
+ assert_is_true(p.switchToFrame("frame1"));
+ assert_equals(pageTitle(p), "frame1");
+ assert_equals(p.frameName, "frame1");
+ assert_equals(p.framesCount, 2);
+ assert_deep_equals(p.framesName, ["frame1-1", "frame1-2"]);
+ setPageTitle(p, pageTitle(p) + "-visited");
+
+ assert_is_true(p.switchToFrame("frame1-2"));
+ assert_equals(pageTitle(p), "frame1-2");
+ assert_equals(p.frameName, "frame1-2");
+ assert_equals(p.framesCount, 0);
+ assert_deep_equals(p.framesName, []);
+ setPageTitle(p, pageTitle(p) + "-visited");
+
+ assert_is_true(p.switchToParentFrame());
+ assert_equals(pageTitle(p), "frame1-visited");
+ assert_equals(p.frameName, "frame1");
+ assert_equals(p.framesCount, 2);
+ assert_deep_equals(p.framesName, ["frame1-1", "frame1-2"]);
+
+ assert_is_true(p.switchToFrame(0));
+ assert_equals(pageTitle(p), "frame1-1");
+ assert_equals(p.frameName, "frame1-1");
+ assert_equals(p.framesCount, 0);
+ assert_deep_equals(p.framesName, []);
+
+ assert_equals(p.switchToMainFrame(), undefined);
+ assert_equals(pageTitle(p), "index-visited");
+ assert_equals(p.frameName, "");
+ assert_equals(p.framesCount, 2);
+ assert_deep_equals(p.framesName, ["frame1", "frame2"]);
+
+ assert_is_true(p.switchToFrame("frame2"));
+ assert_equals(pageTitle(p), "frame2");
+ assert_equals(p.frameName, "frame2");
+ assert_equals(p.framesCount, 3);
+ assert_deep_equals(p.framesName,
+ ["frame2-1", "frame2-2", "frame2-3"]);
+
+ assert_equals(p.focusedFrameName, "");
+
+ p.evaluate(function(){
+ window.focus();
+ });
+ assert_equals(p.focusedFrameName, "frame2");
+
+ assert_is_true(p.switchToFrame("frame2-1"));
+ p.evaluate(function(){
+ window.focus();
+ });
+ assert_equals(p.focusedFrameName, "frame2-1");
+
+ assert_equals(p.switchToMainFrame(), undefined);
+ p.evaluate(function(){
+ window.focus();
+ });
+ assert_equals(p.focusedFrameName, "");
+
+ p.evaluate(function(){
+ window.frames[0].focus();
+ });
+ assert_equals(p.focusedFrameName, "frame1");
+ assert_equals(p.frameName, "");
+
+ assert_equals(p.switchToFocusedFrame(), undefined);
+ assert_equals(p.frameName, "frame1");
+ }
+
+ p.open(TEST_HTTP_BASE + "frameset",
+ this.step_func_done(function (s) {
+ assert_equals(s, "success");
+ testFrameSwitching();
+ }));
+
+}, "frame switching API");
diff --git a/third_party/phantomjs/test/module/webpage/https-bad-cert.js b/third_party/phantomjs/test/module/webpage/https-bad-cert.js
new file mode 100644
index 00000000000..fcdb7d4878b
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/https-bad-cert.js
@@ -0,0 +1,15 @@
+async_test(function () {
+ // This loads the same page as https-good-cert.js, but does not
+ // tell PhantomJS to trust the snakeoil certificate that the test
+ // HTTPS server uses, so it should fail.
+
+ var page = require('webpage').create();
+ var url = TEST_HTTPS_BASE;
+ page.onResourceError = this.step_func(function (err) {
+ assert_equals(err.url, url);
+ assert_equals(err.errorString, "SSL handshake failed");
+ });
+ page.open(url, this.step_func_done(function (status) {
+ assert_not_equals(status, "success");
+ }));
+}, "should fail to load an HTTPS webpage with a self-signed certificate");
diff --git a/third_party/phantomjs/test/module/webpage/https-good-cert.js b/third_party/phantomjs/test/module/webpage/https-good-cert.js
new file mode 100644
index 00000000000..af9cf075c83
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/https-good-cert.js
@@ -0,0 +1,14 @@
+//! unsupported
+//! snakeoil
+async_test(function () {
+ // This loads the same page as https-bad-cert.js, but tells
+ // PhantomJS to trust the snakeoil certificate
+ // that the test HTTPS server uses, so it should succeed.
+
+ var page = require('webpage').create();
+ var url = TEST_HTTPS_BASE;
+ page.onResourceError = this.unreached_func();
+ page.open(url, this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ }));
+}, "loading an HTTPS webpage");
diff --git a/third_party/phantomjs/test/module/webpage/includejs.js b/third_party/phantomjs/test/module/webpage/includejs.js
new file mode 100644
index 00000000000..df3d922ebb2
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/includejs.js
@@ -0,0 +1,42 @@
+var webpage = require('webpage');
+
+async_test(function () {
+ var page = webpage.create();
+ page.open(TEST_HTTP_BASE + 'includejs1.html',
+ this.step_func(function (status) {
+ assert_equals(status, 'success');
+ page.includeJs(TEST_HTTP_BASE + 'includejs.js',
+ this.step_func_done(function () {
+ var title = page.evaluate('getTitle');
+ assert_equals(title, 'i am includejs one');
+ }));
+ }));
+
+}, "including JS in a page");
+
+async_test(function () {
+ var page = webpage.create();
+ var already = false;
+ page.open(TEST_HTTP_BASE + 'includejs1.html',
+ this.step_func(function (status) {
+ assert_equals(status, 'success');
+ page.includeJs(TEST_HTTP_BASE + 'includejs.js',
+ this.step_func(function () {
+ assert_is_false(already);
+ already = true;
+ var title = page.evaluate('getTitle');
+ assert_equals(title, 'i am includejs one');
+ page.open(TEST_HTTP_BASE + 'includejs2.html',
+ this.step_func(function (status) {
+ assert_equals(status, 'success');
+ page.includeJs(TEST_HTTP_BASE + 'includejs.js',
+ this.step_func_done(function () {
+ assert_is_true(already);
+ var title = page.evaluate('getTitle');
+ assert_equals(title, 'i am includejs two');
+ }));
+ }));
+ }));
+ }));
+
+}, "after-inclusion callbacks should fire only once");
diff --git a/third_party/phantomjs/test/module/webpage/keydown-event.js b/third_party/phantomjs/test/module/webpage/keydown-event.js
new file mode 100644
index 00000000000..12bca8ab0b3
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/keydown-event.js
@@ -0,0 +1,21 @@
+//! unsupported
+test(function () {
+ var webpage = require('webpage');
+
+ var page = webpage.create();
+
+ page.evaluate(function() {
+ window.addEventListener('keydown', function(event) {
+ window.loggedEvent = window.loggedEvent || [];
+ window.loggedEvent.push(event);
+ }, false);
+ });
+
+ page.sendEvent('keydown', page.event.key.A);
+ var loggedEvent = page.evaluate(function() {
+ return window.loggedEvent;
+ });
+
+ assert_equals(loggedEvent.length, 1);
+ assert_equals(loggedEvent[0].which, page.event.key.A);
+}, "key-down events");
diff --git a/third_party/phantomjs/test/module/webpage/keypress-event.js b/third_party/phantomjs/test/module/webpage/keypress-event.js
new file mode 100644
index 00000000000..e781fdad5a6
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/keypress-event.js
@@ -0,0 +1,66 @@
+//! unsupported
+test(function () {
+ var webpage = require('webpage');
+
+ var page = webpage.create();
+
+ page.evaluate(function() {
+ window.addEventListener('keypress', function(event) {
+ window.loggedEvent = window.loggedEvent || [];
+ window.loggedEvent.push(event);
+ }, false);
+ });
+
+ page.sendEvent('keypress', page.event.key.C);
+ var loggedEvent = page.evaluate(function() {
+ return window.loggedEvent;
+ });
+
+ assert_equals(loggedEvent.length, 1);
+ assert_equals(loggedEvent[0].which, page.event.key.C);
+
+
+ // Send keypress events to an input element and observe the effect.
+
+ page.content = '';
+ page.evaluate(function() {
+ document.querySelector('input').focus();
+ });
+
+ function getText() {
+ return page.evaluate(function() {
+ return document.querySelector('input').value;
+ });
+ }
+
+ page.sendEvent('keypress', page.event.key.A);
+ assert_equals(getText(), 'A');
+ page.sendEvent('keypress', page.event.key.B);
+ assert_equals(getText(), 'AB');
+ page.sendEvent('keypress', page.event.key.Backspace);
+ assert_equals(getText(), 'A');
+ page.sendEvent('keypress', page.event.key.Backspace);
+ assert_equals(getText(), '');
+
+ page.sendEvent('keypress', 'XYZ');
+ assert_equals(getText(), 'XYZ');
+
+ // Special character: A with umlaut
+ page.sendEvent('keypress', 'ä');
+ assert_equals(getText(), 'XYZä');
+
+ // 0x02000000 is the Shift modifier.
+ page.sendEvent('keypress', page.event.key.Home, null, null, 0x02000000);
+ page.sendEvent('keypress', page.event.key.Delete);
+ assert_equals(getText(), '');
+
+ // Cut and Paste
+ // 0x04000000 is the Control modifier.
+ page.sendEvent('keypress', 'ABCD');
+ assert_equals(getText(), 'ABCD');
+ page.sendEvent('keypress', page.event.key.Home, null, null, 0x02000000);
+ page.sendEvent('keypress', 'x', null, null, 0x04000000);
+ assert_equals(getText(), '');
+ page.sendEvent('keypress', 'v', null, null, 0x04000000);
+ assert_equals(getText(), 'ABCD');
+}, "key press events");
diff --git a/third_party/phantomjs/test/module/webpage/keyup-event.js b/third_party/phantomjs/test/module/webpage/keyup-event.js
new file mode 100644
index 00000000000..c22fe9990ff
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/keyup-event.js
@@ -0,0 +1,21 @@
+//! unsupported
+test(function () {
+ var webpage = require('webpage');
+
+ var page = webpage.create();
+
+ page.evaluate(function() {
+ window.addEventListener('keyup', function(event) {
+ window.loggedEvent = window.loggedEvent || [];
+ window.loggedEvent.push(event);
+ }, false);
+ });
+
+ page.sendEvent('keyup', page.event.key.B);
+ var loggedEvent = page.evaluate(function() {
+ return window.loggedEvent;
+ });
+
+ assert_equals(loggedEvent.length, 1);
+ assert_equals(loggedEvent[0].which, page.event.key.B);
+}, "key-up events");
diff --git a/third_party/phantomjs/test/module/webpage/loading.js b/third_party/phantomjs/test/module/webpage/loading.js
new file mode 100644
index 00000000000..52cc7d4420c
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/loading.js
@@ -0,0 +1,22 @@
+//! unsupported
+async_test(function () {
+ var webpage = require('webpage');
+ var page = webpage.create();
+
+ assert_type_of(page, 'object');
+ assert_type_of(page.loading, 'boolean');
+ assert_type_of(page.loadingProgress, 'number');
+
+ assert_is_false(page.loading);
+ assert_equals(page.loadingProgress, 0);
+
+ page.open(TEST_HTTP_BASE + 'hello.html',
+ this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_equals(page.loading, false);
+ assert_equals(page.loadingProgress, 100);
+ }));
+
+ assert_is_true(page.loading);
+ assert_greater_than(page.loadingProgress, 0);
+}, "page loading progress");
diff --git a/third_party/phantomjs/test/module/webpage/local-urls-disabled-iframe.js b/third_party/phantomjs/test/module/webpage/local-urls-disabled-iframe.js
new file mode 100644
index 00000000000..3144299b318
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/local-urls-disabled-iframe.js
@@ -0,0 +1,23 @@
+//! unsupported
+//! phantomjs: --web-security=no --local-url-access=no
+
+var webpage = require("webpage");
+
+async_test(function () {
+ var page = webpage.create();
+ var url = TEST_HTTP_BASE + "iframe.html#file:///nonexistent";
+ var rsErrorCalled = false;
+
+ page.onResourceError = this.step_func(function (error) {
+ rsErrorCalled = true;
+ assert_equals(error.url, "file:///nonexistent");
+ assert_equals(error.errorCode, 301);
+ assert_equals(error.errorString, 'Protocol "file" is unknown');
+ });
+
+ page.open(url, this.step_func_done(function () {
+ assert_is_true(rsErrorCalled);
+ }));
+
+},
+"doesn't attempt to load a file: URL in an iframe with --local-url-access=no");
diff --git a/third_party/phantomjs/test/module/webpage/local-urls-disabled.js b/third_party/phantomjs/test/module/webpage/local-urls-disabled.js
new file mode 100644
index 00000000000..07853d86e8f
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/local-urls-disabled.js
@@ -0,0 +1,22 @@
+//! unsupported
+//! phantomjs: --local-url-access=no
+
+var webpage = require("webpage");
+
+async_test(function () {
+ var page = webpage.create();
+ var url = "file:///nonexistent";
+ var rsErrorCalled = false;
+
+ page.onResourceError = this.step_func(function (error) {
+ rsErrorCalled = true;
+ assert_equals(error.url, url);
+ assert_equals(error.errorCode, 301);
+ assert_equals(error.errorString, 'Protocol "file" is unknown');
+ });
+
+ page.open(url, this.step_func_done(function () {
+ assert_is_true(rsErrorCalled);
+ }));
+
+}, "doesn't attempt to load a file: URL with --local-url-access=no");
diff --git a/third_party/phantomjs/test/module/webpage/local-urls-enabled-iframe.js b/third_party/phantomjs/test/module/webpage/local-urls-enabled-iframe.js
new file mode 100644
index 00000000000..76d05a5aade
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/local-urls-enabled-iframe.js
@@ -0,0 +1,23 @@
+//! unsupported
+//! phantomjs: --web-security=no --local-url-access=yes
+
+var webpage = require("webpage");
+
+async_test(function () {
+ var page = webpage.create();
+ var url = TEST_HTTP_BASE + "iframe.html#file:///nonexistent";
+ var rsErrorCalled = false;
+
+ page.onResourceError = this.step_func(function (error) {
+ rsErrorCalled = true;
+ assert_equals(error.url, "file:///nonexistent");
+ assert_equals(error.errorCode, 203);
+ assert_regexp_match(error.errorString,
+ /^Error opening\b.*?\bnonexistent:/);
+ });
+
+ page.open(url, this.step_func_done(function () {
+ assert_is_true(rsErrorCalled);
+ }));
+
+}, "attempts to load a file: URL in an iframe with --local-url-access=yes");
diff --git a/third_party/phantomjs/test/module/webpage/local-urls-enabled.js b/third_party/phantomjs/test/module/webpage/local-urls-enabled.js
new file mode 100644
index 00000000000..b3f74bf5de5
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/local-urls-enabled.js
@@ -0,0 +1,23 @@
+//! unsupported
+//! phantomjs: --local-url-access=yes
+
+var webpage = require("webpage");
+
+async_test(function () {
+ var page = webpage.create();
+ var url = "file:///nonexistent";
+ var rsErrorCalled = false;
+
+ page.onResourceError = this.step_func(function (error) {
+ rsErrorCalled = true;
+ assert_equals(error.url, url);
+ assert_equals(error.errorCode, 203);
+ assert_regexp_match(error.errorString,
+ /^Error opening\b.*?\bnonexistent:/);
+ });
+
+ page.open(url, this.step_func_done(function () {
+ assert_is_true(rsErrorCalled);
+ }));
+
+}, "attempts to load a file: URL with --local-url-access=yes");
diff --git a/third_party/phantomjs/test/module/webpage/long-running-javascript.js b/third_party/phantomjs/test/module/webpage/long-running-javascript.js
new file mode 100644
index 00000000000..fa07bafbc7a
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/long-running-javascript.js
@@ -0,0 +1,19 @@
+//! unsupported
+async_test(function () {
+ var page = require('webpage').create();
+
+ page.onLongRunningScript = this.step_func_done(function () {
+ page.stopJavaScript();
+ });
+
+ page.open(TEST_HTTP_BASE + "js-infinite-loop.html",
+ this.step_func(function (s) {
+ assert_equals(s, "success");
+ }));
+
+}, "page.onLongRunningScript can interrupt scripts", {
+ skip: true // https://github.com/ariya/phantomjs/issues/13490
+ // The underlying WebKit feature is so broken that an
+ // infinite loop in a _page_ script prevents timeouts
+ // from firing in the _controller_!
+});
diff --git a/third_party/phantomjs/test/module/webpage/modify-header.js b/third_party/phantomjs/test/module/webpage/modify-header.js
new file mode 100644
index 00000000000..b37d2473261
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/modify-header.js
@@ -0,0 +1,28 @@
+//! unsupported
+async_test(function () {
+ var webpage = require('webpage');
+
+ // NOTE: HTTP header names are case-insensitive. Our test server
+ // returns the name in lowercase.
+
+ var page = webpage.create();
+ assert_type_of(page.customHeaders, 'object');
+ assert_deep_equals(page.customHeaders, {});
+
+ page.customHeaders = { 'CustomHeader': 'CustomValue' };
+
+ page.onResourceRequested = this.step_func(function(requestData, request) {
+ assert_type_of(request.setHeader, 'function');
+ request.setHeader('CustomHeader', 'ModifiedCustomValue');
+ });
+
+ page.open(TEST_HTTP_BASE + 'echo', this.step_func_done(function (status) {
+ var json, headers;
+ assert_equals(status, 'success');
+ json = JSON.parse(page.plainText);
+ headers = json.headers;
+ assert_own_property(headers, 'customheader');
+ assert_equals(headers.customheader, 'ModifiedCustomValue');
+ }));
+
+}, "modifying HTTP headers");
diff --git a/third_party/phantomjs/test/module/webpage/mouseclick-event.js b/third_party/phantomjs/test/module/webpage/mouseclick-event.js
new file mode 100644
index 00000000000..44734bfa680
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/mouseclick-event.js
@@ -0,0 +1,39 @@
+//! unsupported
+test(function () {
+ var page = require('webpage').create();
+
+ page.evaluate(function() {
+ window.addEventListener('mousedown', function(event) {
+ window.loggedEvent = window.loggedEvent || {};
+ window.loggedEvent.mousedown = event;
+ }, false);
+ window.addEventListener('mouseup', function(event) {
+ window.loggedEvent = window.loggedEvent || {};
+ window.loggedEvent.mouseup = event;
+ }, false);
+ });
+ page.sendEvent('click', 42, 217);
+
+ var event = page.evaluate(function() {
+ return window.loggedEvent;
+ });
+ assert_equals(event.mouseup.clientX, 42);
+ assert_equals(event.mouseup.clientY, 217);
+ assert_equals(event.mousedown.clientX, 42);
+ assert_equals(event.mousedown.clientY, 217);
+
+ // click with modifier key
+ page.evaluate(function() {
+ window.addEventListener('click', function(event) {
+ window.loggedEvent = window.loggedEvent || {};
+ window.loggedEvent.click = event;
+ }, false);
+ });
+ page.sendEvent('click', 100, 100, 'left', page.event.modifier.shift);
+
+ var event = page.evaluate(function() {
+ return window.loggedEvent.click;
+ });
+ assert_is_true(event.shiftKey);
+
+}, "mouse click events");
diff --git a/third_party/phantomjs/test/module/webpage/mousedoubleclick-event.js b/third_party/phantomjs/test/module/webpage/mousedoubleclick-event.js
new file mode 100644
index 00000000000..3a777f9a72a
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/mousedoubleclick-event.js
@@ -0,0 +1,31 @@
+//! unsupported
+test(function () {
+ var page = require('webpage').create();
+
+ page.content = '';
+ var point = page.evaluate(function () {
+ var el = document.querySelector('input');
+ var rect = el.getBoundingClientRect();
+ return { x: rect.left + Math.floor(rect.width / 2), y: rect.top + (rect.height / 2) };
+ });
+ page.sendEvent('doubleclick', point.x, point.y);
+
+ var text = page.evaluate(function () {
+ return document.querySelector('input').value;
+ });
+ assert_equals(text, "doubleclicked");
+
+ // click with modifier key
+ page.evaluate(function() {
+ window.addEventListener('dblclick', function(event) {
+ window.loggedEvent = window.loggedEvent || {};
+ window.loggedEvent.dblclick = event;
+ }, false);
+ });
+ page.sendEvent('doubleclick', 100, 100, 'left', page.event.modifier.shift);
+
+ var event = page.evaluate(function() {
+ return window.loggedEvent.dblclick;
+ });
+ assert_is_true(event.shiftKey);
+}, "mouse double-click events");
diff --git a/third_party/phantomjs/test/module/webpage/mousedown-event.js b/third_party/phantomjs/test/module/webpage/mousedown-event.js
new file mode 100644
index 00000000000..ee67275b58b
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/mousedown-event.js
@@ -0,0 +1,27 @@
+//! unsupported
+test(function () {
+ var page = require('webpage').create();
+
+ page.evaluate(function() {
+ window.addEventListener('mousedown', function(event) {
+ window.loggedEvent = window.loggedEvent || [];
+ window.loggedEvent.push(event);
+ }, false);
+ });
+
+ page.sendEvent('mousedown', 42, 217);
+ var loggedEvent = page.evaluate(function() {
+ return window.loggedEvent;
+ });
+ assert_equals(loggedEvent.length, 1);
+ assert_equals(loggedEvent[0].clientX, 42);
+ assert_equals(loggedEvent[0].clientY, 217);
+
+ page.sendEvent('mousedown', 100, 100, 'left', page.event.modifier.shift);
+ loggedEvent = page.evaluate(function() {
+ return window.loggedEvent;
+ });
+ assert_equals(loggedEvent.length, 2);
+ assert_is_true(loggedEvent[1].shiftKey);
+
+}, "mouse-down events");
diff --git a/third_party/phantomjs/test/module/webpage/mousemove-event.js b/third_party/phantomjs/test/module/webpage/mousemove-event.js
new file mode 100644
index 00000000000..c2beaadca1e
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/mousemove-event.js
@@ -0,0 +1,19 @@
+//! unsupported
+test(function () {
+ var page = require('webpage').create();
+
+ page.evaluate(function() {
+ window.addEventListener('mousemove', function(event) {
+ window.loggedEvent = window.loggedEvent || [];
+ window.loggedEvent.push(event);
+ }, false);
+ });
+
+ page.sendEvent('mousemove', 14, 3);
+ var loggedEvent = page.evaluate(function() {
+ return window.loggedEvent;
+ });
+ assert_equals(loggedEvent.length, 1);
+ assert_equals(loggedEvent[0].clientX, 14);
+ assert_equals(loggedEvent[0].clientY, 3);
+}, "mouse-move events");
diff --git a/third_party/phantomjs/test/module/webpage/mouseup-event.js b/third_party/phantomjs/test/module/webpage/mouseup-event.js
new file mode 100644
index 00000000000..80c3496eca4
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/mouseup-event.js
@@ -0,0 +1,27 @@
+//! unsupported
+test(function () {
+ var webpage = require('webpage');
+ var page = webpage.create();
+
+ page.evaluate(function() {
+ window.addEventListener('mouseup', function(event) {
+ window.loggedEvent = window.loggedEvent || [];
+ window.loggedEvent.push(event);
+ }, false);
+ });
+
+ page.sendEvent('mouseup', 42, 217);
+ var loggedEvent = page.evaluate(function() {
+ return window.loggedEvent;
+ });
+ assert_equals(loggedEvent.length, 1);
+ assert_equals(loggedEvent[0].clientX, 42);
+ assert_equals(loggedEvent[0].clientY, 217);
+
+ page.sendEvent('mouseup', 100, 100, 'left', page.event.modifier.shift);
+ loggedEvent = page.evaluate(function() {
+ return window.loggedEvent;
+ });
+ assert_equals(loggedEvent.length, 2);
+ assert_is_true(loggedEvent[1].shiftKey);
+}, "mouse-up events");
diff --git a/third_party/phantomjs/test/module/webpage/navigation.js b/third_party/phantomjs/test/module/webpage/navigation.js
new file mode 100644
index 00000000000..41c1509419f
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/navigation.js
@@ -0,0 +1,31 @@
+//! unsupported
+async_test(function () {
+ var page = require("webpage").create();
+ var url1 = TEST_HTTP_BASE + "navigation/index.html";
+ var url2 = TEST_HTTP_BASE + "navigation/dest.html";
+
+ var onLoadFinished1 = this.step_func(function (status) {
+ assert_equals(status, "success");
+ assert_equals(page.url, url1);
+ assert_equals(page.evaluate(function () {
+ return document.body.innerHTML;
+ }), "INDEX\n");
+
+ page.onLoadFinished = onLoadFinished2;
+ page.evaluate(function() {
+ window.location = "dest.html";
+ });
+ });
+
+ var onLoadFinished2 = this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ assert_equals(page.url, url2);
+ assert_equals(page.evaluate(function () {
+ return document.body.innerHTML;
+ }), "DEST\n");
+ });
+
+ page.onLoadFinished = onLoadFinished1;
+ page.open(url1);
+
+}, "navigating to a relative URL using window.location");
diff --git a/third_party/phantomjs/test/module/webpage/no-plugin.js b/third_party/phantomjs/test/module/webpage/no-plugin.js
new file mode 100644
index 00000000000..1e563f2a9b9
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/no-plugin.js
@@ -0,0 +1,19 @@
+async_test(function () {
+ var webpage = require('webpage');
+ var page = webpage.create();
+
+ var pluginLength = page.evaluate(function() {
+ return window.navigator.plugins.length;
+ });
+ assert_equals(pluginLength, 0);
+
+ page.open(TEST_HTTP_BASE + 'hello.html',
+ this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ var pluginLength = page.evaluate(function() {
+ return window.navigator.plugins.length;
+ });
+ assert_equals(pluginLength, 0);
+ }));
+
+}, "window.navigator.plugins is empty");
diff --git a/third_party/phantomjs/test/module/webpage/object.js b/third_party/phantomjs/test/module/webpage/object.js
new file mode 100644
index 00000000000..d0920e28120
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/object.js
@@ -0,0 +1,77 @@
+//! unsupported
+var webpage = require("webpage");
+var page = webpage.create();
+
+test(function () {
+ assert_equals(webpage.create, WebPage);
+}, "require('webpage').create === global WebPage");
+
+test(function () {
+ assert_type_of(page, 'object');
+ assert_not_equals(page, null);
+
+ assert_equals(page.objectName, 'WebPage');
+ assert_deep_equals(page.paperSize, {});
+
+ assert_not_equals(page.settings, null);
+ assert_not_equals(page.settings, {});
+
+ assert_type_of(page.canGoForward, 'boolean');
+ assert_type_of(page.canGoBack, 'boolean');
+ assert_type_of(page.clipRect, 'object');
+ assert_type_of(page.content, 'string');
+ assert_type_of(page.cookieJar, 'object');
+ assert_type_of(page.cookies, 'object');
+ assert_type_of(page.customHeaders, 'object');
+ assert_type_of(page.event, 'object');
+ assert_type_of(page.libraryPath, 'string');
+ assert_type_of(page.loading, 'boolean');
+ assert_type_of(page.loadingProgress, 'number');
+ assert_type_of(page.navigationLocked, 'boolean');
+ assert_type_of(page.offlineStoragePath, 'string');
+ assert_type_of(page.offlineStorageQuota, 'number');
+ assert_type_of(page.paperSize, 'object');
+ assert_type_of(page.plainText, 'string');
+ assert_type_of(page.scrollPosition, 'object');
+ assert_type_of(page.settings, 'object');
+ assert_type_of(page.title, 'string');
+ assert_type_of(page.url, 'string');
+ assert_type_of(page.frameUrl, 'string');
+ assert_type_of(page.viewportSize, 'object');
+ assert_type_of(page.windowName, 'string');
+ assert_type_of(page.zoomFactor, 'number');
+
+}, "page object properties");
+
+test(function () {
+ assert_type_of(page.childFramesCount, 'function');
+ assert_type_of(page.childFramesName, 'function');
+ assert_type_of(page.clearMemoryCache, 'function');
+ assert_type_of(page.close, 'function');
+ assert_type_of(page.currentFrameName, 'function');
+ assert_type_of(page.deleteLater, 'function');
+ assert_type_of(page.destroyed, 'function');
+ assert_type_of(page.evaluate, 'function');
+ assert_type_of(page.initialized, 'function');
+ assert_type_of(page.injectJs, 'function');
+ assert_type_of(page.javaScriptAlertSent, 'function');
+ assert_type_of(page.javaScriptConsoleMessageSent, 'function');
+ assert_type_of(page.loadFinished, 'function');
+ assert_type_of(page.loadStarted, 'function');
+ assert_type_of(page.openUrl, 'function');
+ assert_type_of(page.release, 'function');
+ assert_type_of(page.render, 'function');
+ assert_type_of(page.resourceError, 'function');
+ assert_type_of(page.resourceReceived, 'function');
+ assert_type_of(page.resourceRequested, 'function');
+ assert_type_of(page.uploadFile, 'function');
+ assert_type_of(page.sendEvent, 'function');
+ assert_type_of(page.setContent, 'function');
+ assert_type_of(page.switchToChildFrame, 'function');
+ assert_type_of(page.switchToMainFrame, 'function');
+ assert_type_of(page.switchToParentFrame, 'function');
+
+ assert_type_of(page.addCookie, 'function');
+ assert_type_of(page.deleteCookie, 'function');
+ assert_type_of(page.clearCookies, 'function');
+}, "page object methods");
diff --git a/third_party/phantomjs/test/module/webpage/on-confirm.js b/third_party/phantomjs/test/module/webpage/on-confirm.js
new file mode 100644
index 00000000000..2f0f2ac83d4
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/on-confirm.js
@@ -0,0 +1,36 @@
+test(function () {
+ var page = require('webpage').create();
+
+ var msg = "message body",
+ result,
+ expected = true;
+
+ assert_equals(page.onConfirm, undefined);
+
+ var onConfirmTrue = function(msg) {
+ return true;
+ };
+ page.onConfirm = onConfirmTrue;
+ assert_equals(page.onConfirm, onConfirmTrue);
+
+ result = page.evaluate(function(m) {
+ return window.confirm(m);
+ }, msg);
+
+ assert_equals(result, expected);
+
+ var onConfirmFunc = function() { return !!"y"; };
+ page.onConfirm = onConfirmFunc;
+ assert_equals(page.onConfirm, onConfirmFunc);
+ assert_not_equals(page.onConfirm, onConfirmTrue);
+
+ page.onConfirm = null;
+ // Will only allow setting to a function value, so setting it to `null` returns `undefined`
+ assert_equals(page.onConfirm, undefined);
+ page.onConfirm = undefined;
+ assert_equals(page.onConfirm, undefined);
+
+}, "page.onConfirm", {
+ /* @see crbug.com/718235 */
+ expected_fail: true
+});
diff --git a/third_party/phantomjs/test/module/webpage/on-error.js b/third_party/phantomjs/test/module/webpage/on-error.js
new file mode 100644
index 00000000000..f5f892a7645
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/on-error.js
@@ -0,0 +1,110 @@
+//! unsupported
+var webpage = require('webpage');
+
+test(function () {
+ var page = webpage.create();
+ assert_not_equals(page.onError, undefined);
+
+ var onErrorFunc1 = function() { return !"x"; };
+ page.onError = onErrorFunc1;
+ assert_equals(page.onError, onErrorFunc1);
+
+ var onErrorFunc2 = function() { return !!"y"; };
+ page.onError = onErrorFunc2;
+ assert_equals(page.onError, onErrorFunc2);
+ assert_not_equals(page.onError, onErrorFunc1);
+
+ page.onError = null;
+ // Will only allow setting to a function value, so setting it to `null` returns `undefined`
+ assert_equals(page.onError, undefined);
+ page.onError = undefined;
+ assert_equals(page.onError, undefined);
+}, "setting and clearing page.onError");
+
+test(function () {
+ var page = webpage.create();
+ var lastError = null;
+ page.onError = function(message) { lastError = message; };
+
+ page.evaluate(function() { referenceError2(); });
+ assert_equals(lastError, "ReferenceError: Can't find variable: referenceError2");
+
+ page.evaluate(function() { throw "foo"; });
+ assert_equals(lastError, "foo");
+
+ page.evaluate(function() { throw Error("foo"); });
+ assert_equals(lastError, "Error: foo");
+}, "basic error reporting");
+
+async_test(function () {
+ var page = webpage.create();
+ var lastError = null;
+ page.onError = this.step_func_done(function(message) {
+ assert_equals(message, "ReferenceError: Can't find variable: referenceError");
+ });
+
+ page.evaluate(function() {
+ setTimeout(function() { referenceError(); }, 0);
+ });
+
+}, "error reporting from async events");
+
+test(function () {
+ var page = webpage.create();
+ var hadError = false;
+ page.onError = function() { hadError = true; };
+ page.evaluate(function() {
+ window.caughtError = false;
+
+ try {
+ referenceError();
+ } catch(e) {
+ window.caughtError = true;
+ }
+ });
+
+ assert_equals(hadError, false);
+ assert_is_true(page.evaluate(function() { return window.caughtError; }));
+}, "should not report errors that were caught");
+
+function check_stack(message, stack) {
+ assert_equals(message,
+ "ReferenceError: Can't find variable: referenceError");
+
+ if (typeof stack === "string") {
+ var lines = stack.split("\n");
+ assert_regexp_match(lines[0], RegExp("^bar@.*?"+helperBase+":7:23$"));
+ assert_regexp_match(lines[1], RegExp("^foo@.*?"+helperBase+":3:17$"));
+ } else {
+ assert_regexp_match(stack[0].file, RegExp(helperBase));
+ assert_equals(stack[0].line, 7);
+ assert_equals(stack[0]["function"], "bar");
+
+ assert_regexp_match(stack[1].file, RegExp(helperBase));
+ assert_equals(stack[1].line, 3);
+ assert_equals(stack[1]["function"], "foo");
+ }
+}
+
+var helperBase = "error-helper.js";
+var helperFile = "../../fixtures/" + helperBase;
+assert_is_true(phantom.injectJs(helperFile));
+
+test(function () {
+ try {
+ ErrorHelper.foo();
+ } catch (e) {
+ check_stack(e.toString(), e.stack);
+ }
+}, "stack trace accuracy (controller script)");
+
+async_test(function () {
+ var page = webpage.create();
+ page.libraryPath = phantom.libraryPath;
+ assert_is_true(page.injectJs(helperFile));
+
+ page.onError = this.step_func_done(check_stack);
+ page.evaluate(function () {
+ setTimeout(function () { ErrorHelper.foo(); }, 0);
+ });
+}, "stack trace accuracy (webpage script)");
diff --git a/third_party/phantomjs/test/module/webpage/on-initialized.js b/third_party/phantomjs/test/module/webpage/on-initialized.js
new file mode 100644
index 00000000000..a32d1f58fb0
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/on-initialized.js
@@ -0,0 +1,22 @@
+//! unsupported
+test(function () {
+ var page = require('webpage').create();
+
+ assert_equals(page.onInitialized, undefined);
+
+ var onInitialized1 = function() { var x = "x"; };
+ page.onInitialized = onInitialized1;
+ assert_equals(page.onInitialized, onInitialized1);
+
+ var onInitialized2 = function() { var y = "y"; };
+ page.onInitialized = onInitialized2;
+ assert_equals(page.onInitialized, onInitialized2);
+ assert_not_equals(page.onInitialized, onInitialized1);
+
+ page.onInitialized = null;
+ // Will only allow setting to a function value, so setting it to `null` returns `undefined`
+ assert_equals(page.onInitialized, undefined);
+
+ page.onInitialized = undefined;
+ assert_equals(page.onInitialized, undefined);
+}, "page.onInitialized");
diff --git a/third_party/phantomjs/test/module/webpage/open.js b/third_party/phantomjs/test/module/webpage/open.js
new file mode 100644
index 00000000000..ff7ef855a70
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/open.js
@@ -0,0 +1,53 @@
+async_test(function () {
+ var webpage = require('webpage');
+ var page = webpage.create();
+ assert_type_of(page, 'object');
+
+ page.onResourceReceived = this.step_func(function (resource) {
+ assert_equals(resource.status, 200);
+ });
+ page.open(TEST_HTTP_BASE + 'hello.html',
+ this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_type_of(page.title, 'string');
+ assert_equals(page.title, 'Hello');
+ assert_type_of(page.plainText, 'string');
+ assert_equals(page.plainText, 'Hello, world!');
+ }));
+}, "opening a webpage");
+
+async_test(function () {
+ var webpage = require('webpage');
+ var page = webpage.create();
+
+ // both onResourceReceived and onResourceError should be called
+ page.onResourceReceived = this.step_func(function (resource) {
+ assert_equals(resource.status, 401);
+ });
+ page.onResourceError = this.step_func(function (err) {
+ assert_equals(err.errorString, "Operation canceled");
+ });
+
+ page.open(TEST_HTTP_BASE + 'status?status=401' +
+ '&WWW-Authenticate=Basic%20realm%3D%22PhantomJS%20test%22',
+ this.step_func_done(function (status) {
+ assert_equals(status, 'fail');
+ }));
+
+}, "proper handling of HTTP error responses", {/* unsupported */expected_fail: true});
+
+async_test(function () {
+ var webpage = require('webpage');
+ var page = webpage.create();
+
+ page.settings.resourceTimeout = 1;
+
+ // This is all you have to do to assert that a hook does get called.
+ page.onResourceTimeout = this.step_func(function(){});
+
+ page.open(TEST_HTTP_BASE + "delay?5",
+ this.step_func_done(function (s) {
+ assert_not_equals(s, "success");
+ }));
+
+}, "onResourceTimeout fires after resourceTimeout ms", {/* unsupported */expected_fail: true});
diff --git a/third_party/phantomjs/test/module/webpage/postdata.js b/third_party/phantomjs/test/module/webpage/postdata.js
new file mode 100644
index 00000000000..dd3d725fa92
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/postdata.js
@@ -0,0 +1,47 @@
+//! unsupported
+function validate_echo_response (status, page, postdata) {
+ assert_equals(status, 'success');
+
+ var desc = JSON.parse(page.plainText);
+ assert_equals(desc.command, "POST");
+ assert_equals(desc.postdata, postdata);
+ assert_equals(desc.headers['content-type'],
+ 'application/x-www-form-urlencoded');
+}
+
+async_test(function () {
+
+ var utfString = '안녕';
+ var openOptions = {
+ operation: 'POST',
+ data: utfString,
+ encoding: 'utf8'
+ };
+ var pageOptions = {
+ onLoadFinished: this.step_func_done(function(status) {
+ validate_echo_response(status, page, utfString);
+ })
+ };
+ var page = new WebPage(pageOptions);
+ page.openUrl(TEST_HTTP_BASE + "echo", openOptions, {});
+
+
+}, "processing request body for POST");
+
+async_test(function () {
+
+ var postdata = "ab=cd";
+ var pageOptions = {
+ onResourceRequested: this.step_func(function (request) {
+ assert_equals(request.postData, postdata);
+ }),
+ onLoadFinished: this.step_func_done(function (status) {
+ validate_echo_response(status, page, postdata);
+ })
+ };
+
+ var page = new WebPage(pageOptions);
+ page.open(TEST_HTTP_BASE + "echo", 'post', postdata);
+
+
+}, "POST data is available in onResourceRequested");
diff --git a/third_party/phantomjs/test/module/webpage/prompt.js b/third_party/phantomjs/test/module/webpage/prompt.js
new file mode 100644
index 00000000000..2826acf3cd2
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/prompt.js
@@ -0,0 +1,17 @@
+//! unsupported
+test(function () {
+ var page = require('webpage').create();
+
+ var msg = "message",
+ value = "value",
+ result,
+ expected = "extra-value";
+ page.onPrompt = function(msg, value) {
+ return "extra-"+value;
+ };
+ result = page.evaluate(function(m, v) {
+ return window.prompt(m, v);
+ }, msg, value);
+
+ assert_equals(result, expected);
+}, "page.onPrompt");
diff --git a/third_party/phantomjs/test/module/webpage/remove-header.js b/third_party/phantomjs/test/module/webpage/remove-header.js
new file mode 100644
index 00000000000..24a4519969a
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/remove-header.js
@@ -0,0 +1,27 @@
+//! unsupported
+var webpage = require('webpage');
+
+// NOTE: HTTP header names are case-insensitive. Our test server
+// returns the name in lowercase.
+async_test(function () {
+ var page = webpage.create();
+ assert_type_of(page.customHeaders, 'object');
+ assert_deep_equals(page.customHeaders, {});
+
+ page.customHeaders = { 'CustomHeader': 'ModifiedCustomValue' };
+
+ page.onResourceRequested = this.step_func(function(requestData, request) {
+ assert_type_of(request.setHeader, 'function');
+ request.setHeader('CustomHeader', null);
+ });
+
+ page.open(TEST_HTTP_BASE + 'echo',
+ this.step_func_done(function (status) {
+ var json, headers;
+ assert_equals(status, 'success');
+ json = JSON.parse(page.plainText);
+ headers = json.headers;
+ assert_no_property(headers, 'customheader');
+ assert_no_property(headers, 'CustomHeader');
+ }));
+});
diff --git a/third_party/phantomjs/test/module/webpage/render.js b/third_party/phantomjs/test/module/webpage/render.js
new file mode 100644
index 00000000000..230192ccfc3
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/render.js
@@ -0,0 +1,67 @@
+var fs = require("fs");
+var system = require("system");
+var webpage = require("webpage");
+var renders = require("./renders");
+
+function clean_pdf(data) {
+ // FIXME: This is not nearly enough normalization.
+ data = data.replace(/\/(Title|Creator|Producer|CreationDate) \([^\n]*\)/g, "/$1 ()");
+ data = data.replace(/\nxref\n[0-9 nf\n]+trailer\b/, "\ntrailer");
+ data = data.replace(/\nstartxref\n[0-9]+\n%%EOF\n/, "\n");
+ return data;
+}
+
+function render_test(format, option) {
+ var opt = option || {};
+ var scratch = "temp_render";
+ if (!opt.format) {
+ scratch += ".";
+ scratch += format;
+ }
+ var expect_content = renders.get(format, opt.quality || "");
+ var p = webpage.create();
+
+ p.paperSize = { width: '300px', height: '300px', border: '0px' };
+ p.clipRect = { top: 0, left: 0, width: 300, height: 300};
+ p.viewportSize = { width: 300, height: 300};
+
+ p.open(TEST_HTTP_BASE + "render/", this.step_func_done(function (status) {
+ p.render(scratch, opt);
+ this.add_cleanup(function () { fs.remove(scratch); });
+ var content = fs.read(scratch, "b");
+
+ // expected variation in PDF output
+ if (format === "pdf") {
+ content = clean_pdf(content);
+ expect_content = clean_pdf(expect_content);
+ }
+
+ // Don't dump entire images to the log on failure.
+ assert_is_true(content === expect_content);
+ }));
+}
+
+[
+ ["PDF", "pdf", {}],
+ ["PDF (format option)", "pdf", {format: "pdf"}],
+ ["PNG", "png", {}],
+ ["PNG (format option)", "png", {format: "png"}],
+ ["JPEG", "jpg", {}],
+ ["JPEG (format option)", "jpg", {format: "jpg"}],
+ ["JPEG (quality option)", "jpg", {quality: 50}],
+ ["JPEG (format and quality options)", "jpg", {format: "jpg", quality: 50}],
+]
+.forEach(function (arr) {
+ var label = arr[0];
+ var format = arr[1];
+ var opt = arr[2];
+ var props = {};
+
+ // All tests fail on Linux. All tests except JPG fail on Mac.
+ // Currently unknown which tests fail on Windows.
+ if (format !== "jpg" || system.os.name !== "mac")
+ props.expected_fail = true;
+
+ async_test(function () { render_test.call(this, format, opt); },
+ label, props);
+});
diff --git a/third_party/phantomjs/test/module/webpage/renders/index.js b/third_party/phantomjs/test/module/webpage/renders/index.js
new file mode 100644
index 00000000000..47e83b6a7ea
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/renders/index.js
@@ -0,0 +1,7 @@
+var fs = require("fs");
+
+exports.get = function get(format, quality) {
+ var expect_file = fs.join(
+ module.dirname, "test" + quality + "." + format);
+ return fs.read(expect_file, "b");
+};
diff --git a/third_party/phantomjs/test/module/webpage/renders/test.jpg b/third_party/phantomjs/test/module/webpage/renders/test.jpg
new file mode 100644
index 00000000000..b597dba47fb
Binary files /dev/null and b/third_party/phantomjs/test/module/webpage/renders/test.jpg differ
diff --git a/third_party/phantomjs/test/module/webpage/renders/test.pdf b/third_party/phantomjs/test/module/webpage/renders/test.pdf
new file mode 100644
index 00000000000..b1beecd1d73
Binary files /dev/null and b/third_party/phantomjs/test/module/webpage/renders/test.pdf differ
diff --git a/third_party/phantomjs/test/module/webpage/renders/test.png b/third_party/phantomjs/test/module/webpage/renders/test.png
new file mode 100644
index 00000000000..7932eeb11bb
Binary files /dev/null and b/third_party/phantomjs/test/module/webpage/renders/test.png differ
diff --git a/third_party/phantomjs/test/module/webpage/renders/test50.jpg b/third_party/phantomjs/test/module/webpage/renders/test50.jpg
new file mode 100644
index 00000000000..a3e04420682
Binary files /dev/null and b/third_party/phantomjs/test/module/webpage/renders/test50.jpg differ
diff --git a/third_party/phantomjs/test/module/webpage/repaint-requested.js b/third_party/phantomjs/test/module/webpage/repaint-requested.js
new file mode 100644
index 00000000000..bb3bb355d5e
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/repaint-requested.js
@@ -0,0 +1,20 @@
+//! unsupported
+var webpage = require('webpage');
+
+async_test(function () {
+ var page = webpage.create();
+ var requestCount = 0;
+
+ page.onRepaintRequested = this.step_func(function(x, y, w, h) {
+ if ((w > 0) && (h > 0)) {
+ ++requestCount;
+ }
+ });
+
+ page.open(TEST_HTTP_BASE + 'hello.html',
+ this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_greater_than(requestCount, 0);
+ }));
+
+}, "onRepaintRequested should be called at least once for each page load");
diff --git a/third_party/phantomjs/test/module/webpage/resource-received-error.js b/third_party/phantomjs/test/module/webpage/resource-received-error.js
new file mode 100644
index 00000000000..dae581e1115
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/resource-received-error.js
@@ -0,0 +1,33 @@
+//! unsupported
+var webpage = require('webpage');
+
+async_test(function () {
+ var page = webpage.create();
+ var url = TEST_HTTP_BASE + 'status?400';
+ var startStage = 0;
+ var endStage = 0;
+ var errors = 0;
+
+ page.onResourceReceived = this.step_func(function (resource) {
+ assert_equals(resource.url, url);
+ if (resource.stage === 'start') {
+ ++startStage;
+ }
+ if (resource.stage === 'end') {
+ ++endStage;
+ }
+ });
+ page.onResourceError = this.step_func(function (error) {
+ assert_equals(error.url, url);
+ assert_equals(error.status, 400);
+ ++errors;
+ });
+
+ page.open(url, this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_equals(startStage, 1);
+ assert_equals(endStage, 1);
+ assert_equals(errors, 1);
+ }));
+
+}, "onResourceReceived should still be called for failed requests");
diff --git a/third_party/phantomjs/test/module/webpage/resource-request-error.js b/third_party/phantomjs/test/module/webpage/resource-request-error.js
new file mode 100644
index 00000000000..0f150362392
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/resource-request-error.js
@@ -0,0 +1,27 @@
+//! unsupported
+var webpage = require('webpage');
+
+async_test(function () {
+ var page = webpage.create();
+ var resourceErrors = 0;
+
+ page.onResourceError = this.step_func(function(err) {
+ ++resourceErrors;
+
+ assert_equals(err.status, 404);
+ assert_equals(err.statusText, 'File not found');
+ assert_equals(err.url, TEST_HTTP_BASE + 'notExist.png');
+ assert_equals(err.errorCode, 203);
+ assert_regexp_match(err.errorString,
+ /Error downloading http:\/\/localhost:[0-9]+\/notExist\.png/);
+ assert_regexp_match(err.errorString,
+ /server replied: File not found/);
+ });
+
+ page.open(TEST_HTTP_BASE + 'missing-img.html',
+ this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_equals(resourceErrors, 1);
+ }));
+
+}, "resourceError basic functionality");
diff --git a/third_party/phantomjs/test/module/webpage/scroll-position.js b/third_party/phantomjs/test/module/webpage/scroll-position.js
new file mode 100644
index 00000000000..a1550531a14
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/scroll-position.js
@@ -0,0 +1,18 @@
+//! unsupported
+var webpage = require('webpage');
+
+test(function () {
+ var defaultPage = webpage.create();
+ assert_deep_equals(defaultPage.scrollPosition, {left:0,top:0});
+}, "default scroll position");
+
+test(function () {
+ var options = {
+ scrollPosition: {
+ left: 1,
+ top: 2
+ }
+ };
+ var customPage = webpage.create(options);
+ assert_deep_equals(customPage.scrollPosition, options.scrollPosition);
+}, "custom scroll position");
diff --git a/third_party/phantomjs/test/module/webpage/set-content.js b/third_party/phantomjs/test/module/webpage/set-content.js
new file mode 100644
index 00000000000..52e823368c1
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/set-content.js
@@ -0,0 +1,20 @@
+//! unsupported
+var webpage = require('webpage');
+
+test(function () {
+ var page = webpage.create();
+ var expectedContent = '
Test div
';
+ var expectedLocation = 'http://www.phantomjs.org/';
+ page.setContent(expectedContent, expectedLocation);
+
+ var actualContent = page.evaluate(function() {
+ return document.documentElement.textContent;
+ });
+ assert_equals(actualContent, 'Test div');
+
+ var actualLocation = page.evaluate(function() {
+ return window.location.href;
+ });
+ assert_equals(actualLocation, expectedLocation);
+
+}, "manually set page content and location");
diff --git a/third_party/phantomjs/test/module/webpage/subwindows.js b/third_party/phantomjs/test/module/webpage/subwindows.js
new file mode 100644
index 00000000000..392b664d6a8
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/subwindows.js
@@ -0,0 +1,130 @@
+//! unsupported
+async_test(function () {
+ var test = this;
+ var top = require('webpage').create();
+ var pages_created = 0;
+ var expect_to_close = null;
+ var after_close = null;
+
+ top.onPageCreated = function (page) {
+ pages_created++;
+ page.onClosing = test.step_func(function (page) {
+ assert_equals(page.windowName, expect_to_close);
+ setTimeout(after_close, 0);
+ });
+ if (pages_created === 3) {
+ setTimeout(after_open_3, 0);
+ }
+ };
+
+ var after_open_3 = test.step_func(function () {
+ assert_equals(top.pages.length, 3);
+ assert_deep_equals(top.pagesWindowName, ["A", "B", "C"]);
+
+ after_close = after_close_1;
+ expect_to_close = "A";
+ top.evaluate(function () { window.wA.close(); });
+ });
+
+ var after_close_1 = test.step_func(function () {
+ assert_equals(top.pages.length, 2);
+ assert_deep_equals(top.pagesWindowName, ["B", "C"]);
+
+
+ var pageB = top.getPage("B");
+ assert_not_equals(pageB, null);
+
+ after_close = after_close_2;
+ expect_to_close = "B";
+ pageB.close();
+ });
+
+ var after_close_2 = test.step_func(function () {
+ assert_equals(top.pages.length, 1);
+ assert_deep_equals(top.pagesWindowName, ["C"]);
+
+ // Must close C as well, because its onclosing hook is a step
+ // function that hasn't run yet.
+ after_close = test.step_func_done();
+ expect_to_close = "C";
+ top.close();
+ });
+
+ top.evaluate(function () {
+ var w = window;
+ w.wA = w.open("data:text/html,%3Ctitle%3Epage%20A%3C/title%3E", "A");
+ w.wB = w.open("data:text/html,%3Ctitle%3Epage%20B%3C/title%3E", "B");
+ w.wC = w.open("data:text/html,%3Ctitle%3Epage%20C%3C/title%3E", "C");
+ });
+
+}, "pages and pagesWindowName arrays; onPageCreated and onClosing hooks");
+
+async_test(function () {
+ var test = this;
+ var pages_opened = 1, pages_closed = 0;
+ var top = require("webpage").create();
+
+ var onPageCreated = test.step_func(function onPageCreated(page) {
+ pages_opened++;
+ page.onPageCreated = onPageCreated;
+ page.onClosing = onClosing;
+ if (pages_opened === 4) {
+ setTimeout(after_open_4, 0);
+ }
+ });
+ var onClosing = test.step_func(function onClosing(page) {
+ pages_closed++;
+ if (pages_opened === pages_closed) {
+ test.done();
+ }
+ });
+
+ // This can't be inlined into onPageCreated because
+ // pagesWindowName is not quite up-to-date when that hook fires.
+ var after_open_4 = test.step_func(function () {
+ assert_equals(top.pages.length, 3);
+ assert_deep_equals(top.pagesWindowName, ["A", "B", "C"]);
+ top.close();
+ });
+
+ top.onPageCreated = onPageCreated;
+ top.onClosing = onClosing;
+
+ top.evaluate(function () {
+ var w = window;
+ w.wA = w.open("data:text/html,%3Ctitle%3Epage%20A%3C/title%3E", "A");
+ w.wB = w.open("data:text/html,%3Ctitle%3Epage%20B%3C/title%3E", "B");
+ w.wC = w.open("data:text/html,%3Ctitle%3Epage%20C%3C/title%3E", "C");
+ });
+
+}, "close subwindows when parent page is closed (default behavior)");
+
+async_test(function () {
+ var test = this;
+ var pages_opened = 1;
+ var top = require("webpage").create();
+ top.ownsPages = false;
+
+ var onPageCreated = test.step_func(function onPageCreated(page) {
+ pages_opened++;
+ page.onPageCreated = onPageCreated;
+ page.onClosing = test.unreached_func();
+ if (pages_opened === 4) {
+ assert_equals(top.pages.length, 0);
+ assert_deep_equals(top.pagesWindowName, []);
+ top.close();
+ }
+ });
+ top.onPageCreated = onPageCreated;
+
+ top.onClosing = test.step_func(function onTopClosing(page) {
+ setTimeout(function () { test.done(); }, 50);
+ });
+
+ top.evaluate(function () {
+ var w = window;
+ w.wA = w.open("data:text/html,%3Ctitle%3Epage%20A%3C/title%3E", "A");
+ w.wB = w.open("data:text/html,%3Ctitle%3Epage%20B%3C/title%3E", "B");
+ w.wC = w.open("data:text/html,%3Ctitle%3Epage%20C%3C/title%3E", "C");
+ });
+}, "don't close subwindows when parent page is closed (ownsPages=false)");
diff --git a/third_party/phantomjs/test/module/webpage/url-encoding.js b/third_party/phantomjs/test/module/webpage/url-encoding.js
new file mode 100644
index 00000000000..d0026dc40cc
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/url-encoding.js
@@ -0,0 +1,134 @@
+//! unsupported
+var webpage = require('webpage');
+
+// Many of the URLs used in this file contain text encoded in
+// Shift_JIS, so that they will not round-trip correctly if
+// misinterpreted at any point as UTF-8 (and thus, the test will
+// fail). See www/url-encoding.py for Unicode equivalents.
+
+function URL(path) {
+ return TEST_HTTP_BASE + 'url-encoding?' + path;
+}
+
+async_test(function () {
+ var p = webpage.create();
+ p.open(URL('/'), this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_equals(p.url, URL('/%83y%81[%83W'));
+ assert_equals(p.plainText, 'PASS');
+ }));
+
+}, "page.url");
+
+async_test(function () {
+ var p = webpage.create();
+ p.open(URL('/f'), this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_equals(p.url, URL('/f'));
+ assert_equals(p.framesCount, 2);
+
+ assert_is_true(p.switchToFrame('a'));
+ assert_equals(p.frameUrl, URL('/%98g'));
+ assert_equals(p.framePlainText, 'PASS');
+
+ assert_is_true(p.switchToParentFrame());
+ assert_is_true(p.switchToFrame('b'));
+ assert_equals(p.frameUrl, URL('/%95s%96%D1%82%C8%98_%91%88'));
+ assert_equals(p.framePlainText, 'FRAME');
+ }));
+
+}, "page.frameUrl");
+
+async_test(function () {
+ var p = webpage.create();
+ var n = 0;
+ var expectedUrls = [ URL('/'), URL('/%83y%81[%83W') ];
+
+ p.onNavigationRequested = this.step_func(function (url, ty, will, main) {
+ assert_equals(url, expectedUrls[n]);
+ assert_equals(ty, 'Other');
+ assert_is_true(will);
+ assert_is_true(main);
+ n++;
+
+ if (n === expectedUrls.length) {
+ p.onNavigationRequested = this.unreached_func();
+ }
+ });
+ p.open(URL('/'), this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_equals(n, expectedUrls.length);
+ assert_equals(p.plainText, 'PASS');
+ }));
+
+}, "arguments to onNavigationRequested");
+
+async_test(function () {
+ var p = webpage.create();
+ var n = 0;
+ var n_req = 0;
+ var n_recv = 0;
+ var expectedUrls = [ URL('/r'), URL('/%8F%91') ];
+ var receivedUrls = {};
+
+ p.onResourceRequested = this.step_func(function (req, nr) {
+ assert_equals(req.url, expectedUrls[n_req]);
+ n_req++;
+ if (n_req === expectedUrls.length) {
+ p.onResourceRequested = this.unreached_func();
+ }
+ });
+
+ p.onResourceReceived = this.step_func(function (resp) {
+ // This function may be called more than once per URL.
+ if (receivedUrls.hasOwnProperty(resp.url))
+ return;
+ receivedUrls[resp.url] = true;
+ assert_equals(resp.url, expectedUrls[n_recv]);
+ n_recv++;
+ });
+
+ p.open(URL('/r'), this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_equals(n_req, expectedUrls.length);
+ assert_equals(n_recv, expectedUrls.length);
+ assert_equals(p.plainText, 'PASS');
+ }));
+
+}, "arguments to onResourceRequested and onResourceReceived");
+
+async_test(function () {
+ var p = webpage.create();
+ p.settings.resourceTimeout = 100;
+
+ var n_timeout = 0;
+ var n_error = 0;
+ var expectedUrls_timeout = [ URL('/%89i%8Bv') ];
+ // the error hook is called for timeouts as well
+ var expectedUrls_error = [ URL('/%8C%CC%8F%E1'), URL('/%89i%8Bv') ];
+
+ p.onResourceTimeout = this.step_func(function (req) {
+ assert_equals(req.url, expectedUrls_timeout[n_timeout]);
+ n_timeout++;
+
+ if (n_timeout === expectedUrls_timeout.length) {
+ p.onResourceTimeout = this.unreached_func();
+ }
+ });
+
+ p.onResourceError = this.step_func(function (err) {
+ assert_equals(err.url, expectedUrls_error[n_error]);
+ n_error++;
+
+ if (n_error === expectedUrls_error.length) {
+ p.onResourceTimeout = this.unreached_func();
+ }
+ });
+
+ p.open(URL("/re"), this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ assert_equals(n_timeout, expectedUrls_timeout.length);
+ assert_equals(n_error, expectedUrls_error.length);
+ }));
+
+}, " arguments to onResourceError and onResourceTimeout");
diff --git a/third_party/phantomjs/test/module/webpage/user-agent.js b/third_party/phantomjs/test/module/webpage/user-agent.js
new file mode 100644
index 00000000000..1dc1962ea8e
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/user-agent.js
@@ -0,0 +1,22 @@
+var webpage = require('webpage');
+
+async_test(function () {
+ var ua = 'PHANTOMJS-TEST-USER-AGENT';
+ var page = webpage.create({
+ settings: {
+ userAgent: ua
+ }
+ });
+
+ assert_equals(page.settings.userAgent, ua);
+
+ page.open(TEST_HTTP_BASE + 'user-agent.html',
+ this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ var agent = page.evaluate(function() {
+ return document.getElementById('ua').textContent;
+ });
+ assert_equals(agent, ua);
+ }));
+
+}, "load a page with a custom user agent");
diff --git a/third_party/phantomjs/test/module/webpage/viewport-size.js b/third_party/phantomjs/test/module/webpage/viewport-size.js
new file mode 100644
index 00000000000..dc2412c2793
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/viewport-size.js
@@ -0,0 +1,17 @@
+var webpage = require('webpage');
+
+test(function () {
+ var defaultPage = webpage.create();
+ assert_deep_equals(defaultPage.viewportSize, {height:300,width:400});
+}, "default viewport size");
+
+test(function () {
+ var options = {
+ viewportSize: {
+ height: 100,
+ width: 200
+ }
+ };
+ var customPage = webpage.create(options);
+ assert_deep_equals(customPage.viewportSize, options.viewportSize);
+}, "custom viewport size");
diff --git a/third_party/phantomjs/test/module/webpage/window.js b/third_party/phantomjs/test/module/webpage/window.js
new file mode 100644
index 00000000000..c8ddaaf63ce
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/window.js
@@ -0,0 +1,4 @@
+test(function () {
+ assert_own_property(window, 'WebPage');
+ assert_type_of(window.WebPage, 'function');
+}, "window.WebPage global property");
diff --git a/third_party/phantomjs/test/module/webpage/zoom-factor.js b/third_party/phantomjs/test/module/webpage/zoom-factor.js
new file mode 100644
index 00000000000..f8f447e4eca
--- /dev/null
+++ b/third_party/phantomjs/test/module/webpage/zoom-factor.js
@@ -0,0 +1,18 @@
+//! unsupported
+var webpage = require('webpage');
+
+test(function () {
+ var page = webpage.create();
+ assert_equals(page.zoomFactor, 1.0);
+
+ page.zoomFactor = 1.5;
+ assert_equals(page.zoomFactor, 1.5);
+
+ page.zoomFactor = 2.0;
+ assert_equals(page.zoomFactor, 2.0);
+
+ page.zoomFactor = 0.5;
+ assert_equals(page.zoomFactor, 0.5);
+}, "page.zoomFactor");
+
+// TODO: render using zoomFactor != 1 and check the result
diff --git a/third_party/phantomjs/test/module/webserver/basics.js b/third_party/phantomjs/test/module/webserver/basics.js
new file mode 100644
index 00000000000..4f124cc4202
--- /dev/null
+++ b/third_party/phantomjs/test/module/webserver/basics.js
@@ -0,0 +1,25 @@
+test(function () {
+ assert_no_property(window, "WebServer",
+ "WebServer constructor should not be global");
+
+ var WebServer = require("webserver").create;
+ assert_type_of(WebServer, "function");
+
+}, "WebServer constructor");
+
+test(function () {
+ var server = require("webserver").create();
+
+ assert_not_equals(server, null);
+ assert_type_of(server, "object");
+ assert_equals(server.objectName, "WebServer");
+
+ assert_own_property(server, "port");
+ assert_type_of(server.port, "string");
+ assert_equals(server.port, "");
+
+ assert_type_of(server.listenOnPort, "function");
+ assert_type_of(server.newRequest, "function");
+ assert_type_of(server.close, "function");
+
+}, "WebServer object properties");
diff --git a/third_party/phantomjs/test/module/webserver/requests.js b/third_party/phantomjs/test/module/webserver/requests.js
new file mode 100644
index 00000000000..843a041c578
--- /dev/null
+++ b/third_party/phantomjs/test/module/webserver/requests.js
@@ -0,0 +1,179 @@
+var server, port, request_cb;
+setup(function () {
+ server = require("webserver").create();
+
+ // Should be unable to listen on port 1 (FIXME: this might succeed if
+ // the test suite is being run with root privileges).
+ assert_is_false(server.listen(1, function () {}));
+ assert_equals(server.port, "");
+
+ // Find an unused port in the 1024--32767 range on which to run the
+ // rest of the tests. The function in "request_cb" will be called
+ // for each request; it is set appropriately by each test case.
+ for (var i = 1024; i < 32768; i++) {
+ if (server.listen(i, function(rq,rs){return request_cb(rq,rs);})) {
+ assert_equals(server.port, i.toString());
+ port = server.port;
+ return;
+ }
+ }
+ assert_unreached("unable to find a free TCP port for server tests");
+},
+ { "test_timeout": 1000 });
+
+function arm_check_request (test, expected_postdata, expected_bindata,
+ expected_mimetype) {
+ request_cb = test.step_func(function check_request (request, response) {
+ try {
+ assert_type_of(request, "object");
+ assert_own_property(request, "url");
+ assert_own_property(request, "method");
+ assert_own_property(request, "httpVersion");
+ assert_own_property(request, "headers");
+ assert_type_of(request.headers, "object");
+
+ assert_type_of(response, "object");
+ assert_own_property(response, "statusCode");
+ assert_own_property(response, "headers");
+ assert_type_of(response.setHeaders, "function");
+ assert_type_of(response.setHeader, "function");
+ assert_type_of(response.header, "function");
+ assert_type_of(response.write, "function");
+ assert_type_of(response.writeHead, "function");
+
+ if (expected_postdata !== false) {
+ assert_equals(request.method, "POST");
+ assert_own_property(request, "post");
+ if (request.headers["Content-Type"] ===
+ "application/x-www-form-urlencoded") {
+ assert_own_property(request, "postRaw");
+ assert_type_of(request.postRaw, "string");
+ assert_type_of(request.post, "object");
+ assert_deep_equals(request.post, expected_postdata);
+ } else {
+ assert_no_property(request, "postRaw");
+ assert_type_of(request.post, "string");
+ assert_not_equals(request.post, expected_postdata);
+ }
+ }
+
+ response.setHeader("X-Request-URL", request.url);
+
+ if (expected_bindata !== false) {
+ response.setEncoding("binary");
+ response.setHeader("Content-Type", expected_mimetype);
+ response.write(expected_bindata);
+ } else {
+ response.write("request handled");
+ }
+ } finally {
+ response.close();
+ request_cb = test.unreached_func();
+ }
+ });
+}
+
+async_test(function () {
+ var page = require("webpage").create();
+ var url = "http://localhost:"+port+"/foo/bar.php?asdf=true";
+
+ arm_check_request(this, false, false);
+ page.open(url, this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ assert_equals(page.plainText, "request handled");
+ }));
+
+}, "basic request handling");
+
+async_test(function () {
+ var page = require("webpage").create();
+ var url = "http://localhost:"+port+"/%95s%96%D1%82%C8%98_%91%88";
+ var already = false;
+
+ arm_check_request(this, false, false);
+ page.onResourceReceived = this.step_func(function (resp) {
+ if (already) return;
+ already = true;
+
+ var found = false;
+ resp.headers.forEach(function (hdr) {
+ if (hdr.name.toLowerCase() === "x-request-url") {
+ assert_equals(hdr.value, "/%95s%96%D1%82%C8%98_%91%88");
+ found = true;
+ }
+ });
+ assert_is_true(found);
+ });
+
+ page.open(url, this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ assert_equals(page.plainText, "request handled");
+ }));
+
+}, "round-trip of URLs containing encoded non-Unicode text");
+
+async_test(function () {
+ var page = require("webpage").create();
+ var url = "http://localhost:"+port+"/foo/bar.txt?asdf=true";
+
+ arm_check_request(this,
+ {"answer" : "42", "universe" : "expanding"}, false);
+
+ page.open(url, "post", "universe=expanding&answer=42",
+ { "Content-Type" : "application/x-www-form-urlencoded" },
+ this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ assert_equals(page.plainText, "request handled");
+ }));
+
+}, "handling POST with application/x-www-form-urlencoded data", {
+ expected_fail: true /* unsupported */
+});
+
+async_test(function () {
+ var page = require("webpage").create();
+ var url = "http://localhost:"+port+"/foo/bar.txt?asdf=true";
+
+ arm_check_request(this,
+ {"answer" : "42", "universe" : "expanding"}, false);
+
+ page.open(url, "post", "universe=expanding&answer=42",
+ { "Content-Type" : "application/json;charset=UTF-8" },
+ this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ assert_equals(page.plainText, "request handled");
+ }));
+
+}, "handling POST with ill-formed application/json data", {
+ expected_fail: true /* unsupported */
+});
+
+async_test(function () {
+ var page = require("webpage").create();
+ var url = "http://localhost:"+port+"/";
+ var fs = require("fs");
+ var png = fs.read(fs.join(phantom.libraryPath,
+ "../../www/phantomjs.png"), "b");
+
+ arm_check_request(this, false, png, "image/png");
+ page.open(url, "get", this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ function checkImg() {
+ var img = document.querySelector("img");
+ if (img) {
+ return { w: img.width, h: img.height };
+ } else {
+ return {};
+ }
+ }
+ // XFAIL: image doesn't load properly and we receive the dimensions of
+ // the ?-in-a-box placeholder
+ assert_deep_equals(page.evaluate(checkImg), { w: 200, h: 200 });
+ }));
+
+}, "handling binary data", {
+ skip: true, // crash: https://github.com/ariya/phantomjs/issues/13461
+ expected_fail: true // received image is corrupt:
+ // https://github.com/ariya/phantomjs/issues/13026
+ // and perhaps others
+});
diff --git a/third_party/phantomjs/test/node_modules/dummy_exposed.js b/third_party/phantomjs/test/node_modules/dummy_exposed.js
new file mode 100644
index 00000000000..143519bddd5
--- /dev/null
+++ b/third_party/phantomjs/test/node_modules/dummy_exposed.js
@@ -0,0 +1 @@
+module.exports = module;
diff --git a/third_party/phantomjs/test/node_modules/dummy_file.js b/third_party/phantomjs/test/node_modules/dummy_file.js
new file mode 100644
index 00000000000..a18d8a9185a
--- /dev/null
+++ b/third_party/phantomjs/test/node_modules/dummy_file.js
@@ -0,0 +1 @@
+module.exports = 'spec/node_modules/dummy_file';
diff --git a/third_party/phantomjs/test/node_modules/dummy_file2.js b/third_party/phantomjs/test/node_modules/dummy_file2.js
new file mode 100644
index 00000000000..77e02ec1ebf
--- /dev/null
+++ b/third_party/phantomjs/test/node_modules/dummy_file2.js
@@ -0,0 +1 @@
+module.exports = 'spec/node_modules/dummy_file2';
diff --git a/third_party/phantomjs/test/regression/README b/third_party/phantomjs/test/regression/README
new file mode 100644
index 00000000000..2e8394c9e3d
--- /dev/null
+++ b/third_party/phantomjs/test/regression/README
@@ -0,0 +1,3 @@
+Tests in this directory are named for their bug number.
+pjs-NNNN corresponds to https://github.com/ariya/phantomjs/issues/NNNN.
+webkit-NNNN corresponds to https://bugs.webkit.org/show_bug.cgi?id=NNNN.
diff --git a/third_party/phantomjs/test/regression/pjs-10690.js b/third_party/phantomjs/test/regression/pjs-10690.js
new file mode 100644
index 00000000000..7e45c82d45e
--- /dev/null
+++ b/third_party/phantomjs/test/regression/pjs-10690.js
@@ -0,0 +1,14 @@
+// Issue 10690: the second page load used to crash on OSX.
+
+var url = TEST_HTTP_BASE + 'regression/pjs-10690/index.html';
+function do_test() {
+ var page = require('webpage').create();
+
+ page.open(url, this.step_func_done (function (status) {
+ assert_equals(status, "success");
+ page.release();
+ }));
+}
+
+async_test(do_test, "load a page with a downloadable font, once");
+async_test(do_test, "load a page with a downloadable font, again");
diff --git a/third_party/phantomjs/test/regression/pjs-12482.js b/third_party/phantomjs/test/regression/pjs-12482.js
new file mode 100644
index 00000000000..7df89dd3540
--- /dev/null
+++ b/third_party/phantomjs/test/regression/pjs-12482.js
@@ -0,0 +1,48 @@
+//! no-harness
+
+// https://github.com/ariya/phantomjs/issues/12482
+// regression caused by fix for
+// https://github.com/ariya/phantomjs/issues/12431
+
+var webpage = require('webpage');
+var sys = require('system');
+
+var pages = [
+ webpage.create(),
+ webpage.create(),
+ webpage.create()
+];
+
+var loaded = 0;
+
+sys.stdout.write("1.." + pages.length + "\n");
+setTimeout(function () { phantom.exit(1); }, 200);
+
+function loadHook (status) {
+ loaded++;
+ if (status === "success") {
+ sys.stdout.write("ok " + loaded + " loading page\n");
+ } else {
+ sys.stdout.write("not ok " + loaded + " loading page\n");
+ }
+
+ if (loaded === pages.length) {
+ pages[1].close();
+ setTimeout(function(){
+ phantom.exit(0);
+ sys.stdout.write("not ok " + (pages.length+1) +
+ " should not get here # TODO\n");
+ }, 50);
+ }
+}
+function consoleHook (msg) {
+ sys.stdout.write(msg + "\n");
+}
+
+for (var i = 0; i < pages.length; i++) {
+ pages[i].onConsoleMessage = consoleHook;
+ pages[i].open(
+ "data:text/html,",
+ loadHook);
+}
diff --git a/third_party/phantomjs/test/regression/pjs-13551.js b/third_party/phantomjs/test/regression/pjs-13551.js
new file mode 100644
index 00000000000..73236b2cb9d
--- /dev/null
+++ b/third_party/phantomjs/test/regression/pjs-13551.js
@@ -0,0 +1,52 @@
+//! unsupported
+// Issue #13551: Crash when switching "back" from frame that no longer
+// exists (for whatever reason)
+
+var webpage = require('webpage');
+
+function test_template(parent, action) {
+ var page;
+ var url = TEST_HTTP_BASE +
+ "/regression/pjs-13551/" + parent + "-parent.html";
+ var s_callback0, s_callback1, s_callback2;
+
+ function callback0 (n) {
+ assert_equals(n, 0);
+ page.onCallback = s_callback1;
+ page.evaluate(function () {
+ document.getElementById("prepare").click();
+ });
+ }
+ function callback1 (n) {
+ assert_equals(n, 1);
+ page.onCallback = s_callback2;
+ assert_equals(page.switchToFrame("target"), true);
+ assert_equals(page.switchToFrame("actor"), true);
+ page.evaluate(function () {
+ document.getElementById("execute").click();
+ });
+ }
+ function callback2 (n) {
+ assert_equals(n, 2);
+ assert_is_true(action == 'main' || action == 'parent');
+ if (action == 'main') {
+ page.switchToMainFrame(); // Crash here
+ } else {
+ page.switchToParentFrame(); // Or here
+ }
+ }
+
+ return function test_action () {
+ page = webpage.create();
+ s_callback0 = this.step_func(callback0);
+ s_callback1 = this.step_func(callback1);
+ s_callback2 = this.step_func_done(callback2);
+ page.onCallback = s_callback0;
+ page.open(url);
+ };
+}
+
+async_test(test_template('closing', 'main'), "main from closed");
+async_test(test_template('closing', 'parent'), "parent from closed");
+async_test(test_template('reloading', 'main'), "main from reloaded");
+async_test(test_template('reloading', 'parent'), "parent from reloaded");
diff --git a/third_party/phantomjs/test/regression/webkit-60448.js b/third_party/phantomjs/test/regression/webkit-60448.js
new file mode 100644
index 00000000000..46280936f6a
--- /dev/null
+++ b/third_party/phantomjs/test/regression/webkit-60448.js
@@ -0,0 +1,12 @@
+var url = TEST_HTTP_BASE + "regression/webkit-60448.html";
+
+async_test(function () {
+ var p = require("webpage").create();
+ p.open(url, this.step_func_done(function (status) {
+ assert_equals(status, "success");
+ assert_is_true(p.evaluate(function () {
+ return document.getElementById("test") === null;
+ }));
+ }));
+},
+"remove an inline HTML element from the document");
diff --git a/third_party/phantomjs/test/run-tests.py b/third_party/phantomjs/test/run-tests.py
new file mode 100755
index 00000000000..9262c43c544
--- /dev/null
+++ b/third_party/phantomjs/test/run-tests.py
@@ -0,0 +1,1051 @@
+#!/usr/bin/env python
+
+import argparse
+import collections
+import errno
+import glob
+import imp
+import os
+import platform
+import posixpath
+import re
+import shlex
+import SimpleHTTPServer
+import socket
+import SocketServer
+import ssl
+import string
+import cStringIO as StringIO
+import subprocess
+import sys
+import threading
+import time
+import traceback
+import urllib
+
+# All files matching one of these glob patterns will be run as tests.
+TESTS = [
+ 'basics/*.js',
+ 'module/*/*.js',
+ 'standards/*/*.js',
+ 'regression/*.js',
+]
+
+TIMEOUT = 7 # Maximum duration of PhantomJS execution (in seconds).
+ # This is a backstop; testharness.js imposes a shorter
+ # timeout. Both can be increased if necessary.
+
+#
+# Utilities
+#
+
+# FIXME: assumes ANSI/VT100 escape sequences
+# properly this should use curses, but that's an awful lot of work
+# One of colors 30 ("black" -- usually a dark gray) and 37 ("white" --
+# usually a very light gray) will almost certainly be illegible
+# against the terminal background, so we provide neither.
+# The colorization mode is global because so is sys.stdout.
+_COLOR_NONE = {
+ "_": "", "^": "",
+ "r": "", "R": "",
+ "g": "", "G": "",
+ "y": "", "Y": "",
+ "b": "", "B": "",
+ "m": "", "M": "",
+ "c": "", "C": "",
+}
+_COLOR_ON = {
+ "_": "\033[0m", "^": "\033[1m",
+ "r": "\033[31m", "R": "\033[1;31m",
+ "g": "\033[32m", "G": "\033[1;32m",
+ "y": "\033[33m", "Y": "\033[1;33m",
+ "b": "\033[34m", "B": "\033[1;34m",
+ "m": "\033[35m", "M": "\033[1;35m",
+ "c": "\033[36m", "C": "\033[1;36m",
+}
+_COLOR_BOLD = {
+ "_": "\033[0m", "^": "\033[1m",
+ "r": "\033[0m", "R": "\033[1m",
+ "g": "\033[0m", "G": "\033[1m",
+ "y": "\033[0m", "Y": "\033[1m",
+ "b": "\033[0m", "B": "\033[1m",
+ "m": "\033[0m", "M": "\033[1m",
+ "c": "\033[0m", "C": "\033[1m",
+}
+_COLORS = None
+def activate_colorization(options):
+ global _COLORS
+ if options.color == "always":
+ _COLORS = _COLOR_ON
+ elif options.color == "never":
+ _COLORS = _COLOR_NONE
+ else:
+ if sys.stdout.isatty() and platform.system() != "Windows":
+ try:
+ n = int(subprocess.check_output(["tput", "colors"]))
+ if n >= 8:
+ _COLORS = _COLOR_ON
+ else:
+ _COLORS = _COLOR_BOLD
+ except subprocess.CalledProcessError:
+ _COLORS = _COLOR_NONE
+ else:
+ _COLORS = _COLOR_NONE
+
+def colorize(color, message):
+ return _COLORS[color] + message + _COLORS["_"]
+
+# create_default_context and SSLContext were only added in 2.7.9,
+# which is newer than the python2 that ships with OSX :-(
+# The fallback tries to mimic what create_default_context(CLIENT_AUTH)
+# does. Security obviously isn't important in itself for a test
+# server, but making sure the PJS client can talk to a server
+# configured according to modern TLS best practices _is_ important.
+# Unfortunately, there is no way to set things like OP_NO_SSL2 or
+# OP_CIPHER_SERVER_PREFERENCE prior to 2.7.9.
+CIPHERLIST_2_7_9 = (
+ 'ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+HIGH:'
+ 'DH+HIGH:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+HIGH:RSA+3DES:!aNULL:'
+ '!eNULL:!MD5:!DSS:!RC4'
+)
+def wrap_socket_ssl(sock, base_path):
+ crtfile = os.path.join(base_path, 'certs/https-snakeoil.crt')
+ keyfile = os.path.join(base_path, 'certs/https-snakeoil.key')
+
+ try:
+ ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+ ctx.load_cert_chain(crtfile, keyfile)
+ return ctx.wrap_socket(sock, server_side=True)
+
+ except AttributeError:
+ return ssl.wrap_socket(sock,
+ keyfile=keyfile,
+ certfile=crtfile,
+ server_side=True,
+ ciphers=CIPHERLIST_2_7_9)
+
+# This should be in the standard library somewhere, but as far as I
+# can tell, it isn't.
+class ResponseHookImporter(object):
+ def __init__(self, www_path):
+ # All Python response hooks, no matter how deep below www_path,
+ # are treated as direct children of the fake "test_www" package.
+ if 'test_www' not in sys.modules:
+ imp.load_source('test_www', www_path + '/__init__.py')
+
+ self.tr = string.maketrans('-./%', '____')
+
+ def __call__(self, path):
+ modname = 'test_www.' + path.translate(self.tr)
+ try:
+ return sys.modules[modname]
+ except KeyError:
+ return imp.load_source(modname, path)
+
+# This should also be in the standard library somewhere, and
+# definitely isn't.
+#
+# FIXME: This currently involves *three* threads for every process,
+# and a fourth if the process takes input. (On Unix, clever use of
+# select() might be able to get that down to one, but zero is Hard.
+# On Windows, we're hosed. 3.4's asyncio module would make everything
+# better, but 3.4 is its own can of worms.)
+try:
+ devnull = subprocess.DEVNULL
+except:
+ devnull = os.open(os.devnull, os.O_RDONLY)
+
+def do_call_subprocess(command, verbose, stdin_data, timeout):
+
+ def read_thread(linebuf, fp):
+ while True:
+ line = fp.readline().rstrip()
+ if not line: break # EOF
+ line = line.rstrip()
+ if line:
+ linebuf.append(line)
+ if verbose >= 3:
+ sys.stdout.write(line + '\n')
+
+ def write_thread(data, fp):
+ fp.writelines(data)
+ fp.close()
+
+ def reap_thread(proc, timed_out):
+ if proc.returncode is None:
+ proc.terminate()
+ timed_out[0] = True
+
+ class DummyThread:
+ def start(self): pass
+ def join(self): pass
+
+ if stdin_data:
+ stdin = subprocess.PIPE
+ else:
+ stdin = devnull
+
+ proc = subprocess.Popen(command,
+ stdin=stdin,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+
+ if stdin_data:
+ sithrd = threading.Thread(target=write_thread,
+ args=(stdin_data, proc.stdin))
+ else:
+ sithrd = DummyThread()
+
+ stdout = []
+ stderr = []
+ timed_out = [False]
+ sothrd = threading.Thread(target=read_thread, args=(stdout, proc.stdout))
+ sethrd = threading.Thread(target=read_thread, args=(stderr, proc.stderr))
+ rpthrd = threading.Timer(timeout, reap_thread, args=(proc, timed_out))
+
+ sithrd.start()
+ sothrd.start()
+ sethrd.start()
+ rpthrd.start()
+
+ proc.wait()
+ if not timed_out[0]: rpthrd.cancel()
+
+ sithrd.join()
+ sothrd.join()
+ sethrd.join()
+ rpthrd.join()
+
+ if timed_out[0]:
+ stderr.append("TIMEOUT: Process terminated after {} seconds."
+ .format(timeout))
+ if verbose >= 3:
+ sys.stdout.write(stderr[-1] + "\n")
+
+ rc = proc.returncode
+ if verbose >= 3:
+ if rc < 0:
+ sys.stdout.write("## killed by signal {}\n".format(-rc))
+ else:
+ sys.stdout.write("## exit {}\n".format(rc))
+ return proc.returncode, stdout, stderr
+
+#
+# HTTP/HTTPS server, presented on localhost to the tests
+#
+
+class FileHandler(SimpleHTTPServer.SimpleHTTPRequestHandler, object):
+
+ def __init__(self, *args, **kwargs):
+ self._cached_untranslated_path = None
+ self._cached_translated_path = None
+ self.postdata = None
+ super(FileHandler, self).__init__(*args, **kwargs)
+
+ # silent, do not pollute stdout nor stderr.
+ def log_message(self, format, *args):
+ return
+
+ # accept POSTs, read the postdata and stash it in an instance variable,
+ # then forward to do_GET; handle_request hooks can vary their behavior
+ # based on the presence of postdata and/or the command verb.
+ def do_POST(self):
+ try:
+ ln = int(self.headers.get('content-length'))
+ except TypeError, ValueError:
+ self.send_response(400, 'Bad Request')
+ self.send_header('Content-Type', 'text/plain')
+ self.end_headers()
+ self.wfile.write("No or invalid Content-Length in POST (%r)"
+ % self.headers.get('content-length'))
+ return
+
+ self.postdata = self.rfile.read(ln)
+ self.do_GET()
+
+ # allow provision of a .py file that will be interpreted to
+ # produce the response.
+ def send_head(self):
+ path = self.translate_path(self.path)
+
+ # do not allow direct references to .py(c) files,
+ # or indirect references to __init__.py
+ if (path.endswith('.py') or path.endswith('.pyc') or
+ path.endswith('__init__')):
+ self.send_error(404, 'File not found')
+ return None
+
+ if os.path.exists(path):
+ return super(FileHandler, self).send_head()
+
+ py = path + '.py'
+ if os.path.exists(py):
+ try:
+ mod = self.get_response_hook(py)
+ return mod.handle_request(self)
+ except:
+ self.send_error(500, 'Internal Server Error in '+py)
+ raise
+
+ self.send_error(404, 'File not found')
+ return None
+
+ # modified version of SimpleHTTPRequestHandler's translate_path
+ # to resolve the URL relative to the www/ directory
+ # (e.g. /foo -> test/www/foo)
+ def translate_path(self, path):
+
+ # Cache for efficiency, since our send_head calls this and
+ # then, in the normal case, the parent class's send_head
+ # immediately calls it again.
+ if (self._cached_translated_path is not None and
+ self._cached_untranslated_path == path):
+ return self._cached_translated_path
+
+ orig_path = path
+
+ # Strip query string and/or fragment, if present.
+ x = path.find('?')
+ if x != -1: path = path[:x]
+ x = path.find('#')
+ if x != -1: path = path[:x]
+
+ # Ensure consistent encoding of special characters, then
+ # lowercase everything so that the tests behave consistently
+ # whether or not the local filesystem is case-sensitive.
+ path = urllib.quote(urllib.unquote(path)).lower()
+
+ # Prevent access to files outside www/.
+ # At this point we want specifically POSIX-like treatment of 'path'
+ # because it is still a URL component and not a filesystem path.
+ # SimpleHTTPRequestHandler.send_head() expects us to preserve the
+ # distinction between paths with and without a trailing slash, but
+ # posixpath.normpath() discards that distinction.
+ trailing_slash = path.endswith('/')
+ path = posixpath.normpath(path)
+ while path.startswith('/'):
+ path = path[1:]
+ while path.startswith('../'):
+ path = path[3:]
+
+ # Now resolve the normalized, clamped path relative to the www/
+ # directory, according to local OS conventions.
+ path = os.path.normpath(os.path.join(self.www_path, *path.split('/')))
+ if trailing_slash:
+ # it must be a '/' even on Windows
+ path += '/'
+
+ self._cached_untranslated_path = orig_path
+ self._cached_translated_path = path
+ return path
+
+class TCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
+ # This is how you are officially supposed to set SO_REUSEADDR per
+ # https://docs.python.org/2/library/socketserver.html#SocketServer.BaseServer.allow_reuse_address
+ allow_reuse_address = True
+
+ def __init__(self, use_ssl, handler, base_path, signal_error):
+ SocketServer.TCPServer.__init__(self, ('localhost', 0), handler)
+ if use_ssl:
+ self.socket = wrap_socket_ssl(self.socket, base_path)
+ self._signal_error = signal_error
+
+ def handle_error(self, request, client_address):
+ # Ignore errors which can occur naturally if the client
+ # disconnects in the middle of a request. EPIPE and
+ # ECONNRESET *should* be the only such error codes
+ # (according to the OSX manpage for send()).
+ _, exval, _ = sys.exc_info()
+ if getattr(exval, 'errno', None) in (errno.EPIPE, errno.ECONNRESET):
+ return
+
+ # Otherwise, report the error to the test runner.
+ self._signal_error(sys.exc_info())
+
+class HTTPTestServer(object):
+ def __init__(self, base_path, signal_error, verbose):
+ self.httpd = None
+ self.httpsd = None
+ self.base_path = base_path
+ self.www_path = os.path.join(base_path, 'www')
+ self.signal_error = signal_error
+ self.verbose = verbose
+
+ def __enter__(self):
+ handler = FileHandler
+ handler.extensions_map.update({
+ '.htm': 'text/html',
+ '.html': 'text/html',
+ '.css': 'text/css',
+ '.js': 'application/javascript',
+ '.json': 'application/json'
+ })
+ handler.www_path = self.www_path
+ handler.get_response_hook = ResponseHookImporter(self.www_path)
+
+ self.httpd = TCPServer(False, handler,
+ self.base_path, self.signal_error)
+ os.environ['TEST_HTTP_BASE'] = \
+ 'http://localhost:{}/'.format(self.httpd.server_address[1])
+ httpd_thread = threading.Thread(target=self.httpd.serve_forever)
+ httpd_thread.daemon = True
+ httpd_thread.start()
+ if self.verbose >= 3:
+ sys.stdout.write("## HTTP server at {}\n".format(
+ os.environ['TEST_HTTP_BASE']))
+
+ self.httpsd = TCPServer(True, handler,
+ self.base_path, self.signal_error)
+ os.environ['TEST_HTTPS_BASE'] = \
+ 'https://localhost:{}/'.format(self.httpsd.server_address[1])
+ httpsd_thread = threading.Thread(target=self.httpsd.serve_forever)
+ httpsd_thread.daemon = True
+ httpsd_thread.start()
+ if self.verbose >= 3:
+ sys.stdout.write("## HTTPS server at {}\n".format(
+ os.environ['TEST_HTTPS_BASE']))
+
+ return self
+
+ def __exit__(self, *dontcare):
+ self.httpd.shutdown()
+ del os.environ['TEST_HTTP_BASE']
+ self.httpsd.shutdown()
+ del os.environ['TEST_HTTPS_BASE']
+
+#
+# Running tests and interpreting their results
+#
+class TestDetailCode(collections.namedtuple("TestDetailCode", (
+ "idx", "color", "short_label", "label", "long_label"))):
+ def __index__(self): return self.idx
+ def __hash__(self): return self.idx
+ def __eq__(self, other): return self.idx == other.idx
+ def __ne__(self, other): return self.idx != other.idx
+
+class T(object):
+ PASS = TestDetailCode(0, "g", ".", "pass", "passed")
+ FAIL = TestDetailCode(1, "R", "F", "FAIL", "failed")
+ XFAIL = TestDetailCode(2, "y", "f", "xfail", "failed as expected")
+ XPASS = TestDetailCode(3, "Y", "P", "XPASS", "passed unexpectedly")
+ ERROR = TestDetailCode(4, "R", "E", "ERROR", "had errors")
+ SKIP = TestDetailCode(5, "m", "s", "skip", "skipped")
+ UNSUPPORTED = TestDetailCode(6, "y", "u", "unsupported", "unsupported")
+ MAX = 7
+
+class TestDetail(object):
+ """Holds one block of details about a test that failed."""
+ # types of details:
+
+ def __init__(self, message, test_id, detail_type):
+ if not isinstance(message, list):
+ message = [message]
+ self.message = [line.rstrip()
+ for chunk in message
+ for line in chunk.split("\n")]
+
+ self.dtype = detail_type
+ self.test_id = test_id
+
+ def report(self, fp):
+ col, label = self.dtype.color, self.dtype.label
+ if self.test_id:
+ fp.write("{:>5}: {}\n".format(colorize(col, label),
+ self.test_id))
+ lo = 0
+ else:
+ fp.write("{:>5}: {}\n".format(colorize(col, label),
+ self.message[0]))
+ lo = 1
+ for line in self.message[lo:]:
+ fp.write(" {}\n".format(colorize("b", line)))
+
+class TestGroup(object):
+ """Holds the result of one group of tests (that is, one .js file),
+ parsed from the output of run_phantomjs (see below).
+ Subclasses specify what the output means.
+ A test with zero details is considered to be successful.
+ """
+
+ def __init__(self, name):
+ self.name = name
+ self.n = [0]*T.MAX
+ self.details = []
+
+ def parse(self, rc, out, err):
+ raise NotImplementedError
+
+ def _add_d(self, message, test_id, dtype):
+ self.n[dtype] += 1
+ self.details.append(TestDetail(message, test_id, dtype))
+
+ def add_pass (self, m, t): self._add_d(m, t, T.PASS)
+ def add_fail (self, m, t): self._add_d(m, t, T.FAIL)
+ def add_xpass(self, m, t): self._add_d(m, t, T.XPASS)
+ def add_xfail(self, m, t): self._add_d(m, t, T.XFAIL)
+ def add_error(self, m, t): self._add_d(m, t, T.ERROR)
+ def add_skip (self, m, t): self._add_d(m, t, T.SKIP)
+ def add_unsupported (self, m, t): self._add_d(m, t, T.UNSUPPORTED)
+
+ def default_interpret_exit_code(self, rc):
+ if rc == 0:
+ if not self.is_successful() and not self.n[T.ERROR]:
+ self.add_error([],
+ "PhantomJS exited successfully when test failed")
+
+ # Exit code -15 indicates a timeout.
+ elif rc == 1 or rc == -15:
+ if self.is_successful():
+ self.add_error([], "PhantomJS exited unsuccessfully")
+
+ elif rc >= 2:
+ self.add_error([], "PhantomJS exited with code {}".format(rc))
+ else:
+ self.add_error([], "PhantomJS killed by signal {}".format(-rc))
+
+ def is_successful(self):
+ return self.n[T.FAIL] + self.n[T.XPASS] + self.n[T.ERROR] == 0
+
+ def worst_code(self):
+ # worst-to-best ordering
+ for code in (T.ERROR, T.FAIL, T.XPASS, T.SKIP, T.XFAIL, T.PASS, T.UNSUPPORTED):
+ if self.n[code] > 0:
+ return code
+ return T.PASS
+
+ def one_char_summary(self, fp):
+ code = self.worst_code()
+ fp.write(colorize(code.color, code.short_label))
+ fp.flush()
+
+ def line_summary(self, fp):
+ code = self.worst_code()
+ fp.write("{}: {}\n".format(colorize("^", self.name),
+ colorize(code.color, code.label)))
+
+ def report(self, fp, show_all):
+ self.line_summary(fp)
+ need_blank_line = False
+ for detail in self.details:
+ if show_all or detail.dtype not in (T.PASS, T.XFAIL, T.SKIP):
+ detail.report(fp)
+ need_blank_line = True
+ if need_blank_line:
+ fp.write("\n")
+
+ def report_for_verbose_level(self, fp, verbose):
+ if verbose == 0:
+ self.one_char_summary(sys.stdout)
+ elif verbose == 1:
+ self.report(sys.stdout, False)
+ else:
+ self.report(sys.stdout, True)
+
+class UnsupportedTestGroup(TestGroup):
+ """Test group which is currently unsupported and should
+ be skipped altogether.
+ """
+ def __init__(self, name):
+ TestGroup.__init__(self, name)
+ self.add_unsupported('', 'Skipping the whole file');
+
+
+class ExpectTestGroup(TestGroup):
+ """Test group whose output must be exactly as specified by directives
+ in the file. This is how you test for an _unsuccessful_ exit code,
+ or for output appearing on a specific one of stdout/stderr.
+ """
+ def __init__(self, name, rc_exp, stdout_exp, stderr_exp,
+ rc_xfail, stdout_xfail, stderr_xfail):
+ TestGroup.__init__(self, name)
+ if rc_exp is None: rc_exp = 0
+ self.rc_exp = rc_exp
+ self.stdout_exp = stdout_exp
+ self.stderr_exp = stderr_exp
+ self.rc_xfail = rc_xfail
+ self.stdout_xfail = stdout_xfail
+ self.stderr_xfail = stderr_xfail
+
+ def parse(self, rc, out, err):
+ self.parse_output("stdout", self.stdout_exp, out, self.stdout_xfail)
+ self.parse_output("stderr", self.stderr_exp, err, self.stderr_xfail)
+
+ exit_msg = ["expected exit code {} got {}"
+ .format(self.rc_exp, rc)]
+
+ if rc != self.rc_exp:
+ exit_desc = "did not exit as expected"
+ if self.rc_xfail:
+ self.add_xfail(exit_msg, exit_desc)
+ else:
+ self.add_fail(exit_msg, exit_desc)
+ else:
+ exit_desc = "exited as expected"
+ if self.rc_xfail:
+ self.add_xpass(exit_msg, exit_desc)
+ else:
+ self.add_pass(exit_msg, exit_desc)
+
+ def parse_output(self, what, exp, got, xfail):
+ diff = []
+ le = len(exp)
+ lg = len(got)
+ for i in range(max(le, lg)):
+ e = ""
+ g = ""
+ if i < le: e = exp[i]
+ if i < lg: g = got[i]
+ if e != g:
+ diff.extend(("{}: line {} not as expected".format(what, i+1),
+ "-" + repr(e)[1:-1],
+ "+" + repr(g)[1:-1]))
+
+ if diff:
+ desc = what + " not as expected"
+ if xfail:
+ self.add_xfail(diff, desc)
+ else:
+ self.add_fail(diff, desc)
+ else:
+ desc = what + " as expected"
+ if xfail:
+ self.add_xpass(diff, desc)
+ else:
+ self.add_pass(diff, desc)
+
+
+class TAPTestGroup(TestGroup):
+ """Test group whose output is interpreted according to a variant of the
+ Test Anything Protocol (http://testanything.org/tap-specification.html).
+
+ Relative to that specification, these are the changes:
+
+ * Plan-at-the-end, explanations for directives, and "Bail out!"
+ are not supported. ("1..0 # SKIP: explanation" *is* supported.)
+ * "Anything else" lines are an error.
+ * Repeating a test point number, or using one outside the plan
+ range, is an error (this is unspecified in TAP proper).
+ * Diagnostic lines beginning with # are taken as additional
+ information about the *next* test point. Diagnostic lines
+ beginning with ## are ignored.
+ * Directives are case sensitive.
+
+ """
+
+ diag_r = re.compile(r"^#(#*)\s*(.*)$")
+ plan_r = re.compile(r"^1..(\d+)(?:\s*\#\s*SKIP(?::\s*(.*)))?$")
+ test_r = re.compile(r"^(not ok|ok)\s*"
+ r"([0-9]+)?\s*"
+ r"([^#]*)(?:# (TODO|SKIP))?$")
+
+ def parse(self, rc, out, err):
+ self.parse_tap(out, err)
+ self.default_interpret_exit_code(rc)
+
+ def parse_tap(self, out, err):
+ points_already_used = set()
+ messages = []
+
+ # Look for the plan.
+ # Diagnostic lines are allowed to appear above the plan, but not
+ # test lines.
+ for i in range(len(out)):
+ line = out[i]
+ m = self.diag_r.match(line)
+ if m:
+ if not m.group(1):
+ messages.append(m.group(2))
+ continue
+
+ m = self.plan_r.match(line)
+ if m:
+ break
+
+ messages.insert(0, line)
+ self.add_error(messages, "Plan line not interpretable")
+ if i + 1 < len(out):
+ self.add_skip(out[(i+1):], "All further output ignored")
+ return
+ else:
+ self.add_error(messages, "No plan line detected in output")
+ return
+
+ max_point = int(m.group(1))
+ if max_point == 0:
+ if any(msg.startswith("ERROR:") for msg in messages):
+ self.add_error(messages, m.group(2) or "Test group skipped")
+ else:
+ self.add_skip(messages, m.group(2) or "Test group skipped")
+ if i + 1 < len(out):
+ self.add_skip(out[(i+1):], "All further output ignored")
+ return
+
+ prev_point = 0
+
+ for i in range(i+1, len(out)):
+ line = out[i]
+ m = self.diag_r.match(line)
+ if m:
+ if not m.group(1):
+ messages.append(m.group(2))
+ continue
+ m = self.test_r.match(line)
+ if m:
+ status = m.group(1)
+ point = m.group(2)
+ desc = m.group(3)
+ dirv = m.group(4)
+
+ if point:
+ point = int(point)
+ else:
+ point = prev_point + 1
+
+ if point in points_already_used:
+ # A reused test point is an error.
+ self.add_error(messages, desc + " [test point repeated]")
+ else:
+ points_already_used.add(point)
+ # A point above the plan limit is an automatic *fail*.
+ # The test suite relies on this in testing exit().
+ if point > max_point:
+ status = "not ok"
+
+ if status == "ok":
+ if not dirv:
+ self.add_pass(messages, desc)
+ elif dirv == "TODO":
+ self.add_xpass(messages, desc)
+ elif dirv == "SKIP":
+ self.add_skip(messages, desc)
+ else:
+ self.add_error(messages, desc +
+ " [ok, with invalid directive "+dirv+"]")
+ else:
+ if not dirv:
+ self.add_fail(messages, desc)
+ elif dirv == "TODO":
+ self.add_xfail(messages, desc)
+ else:
+ self.add_error(messages, desc +
+ " [not ok, with invalid directive "+dirv+"]")
+
+ del messages[:]
+ prev_point = point
+
+ else:
+ self.add_error([line], "neither a test nor a diagnostic")
+
+ # Any output on stderr is an error, with one exception: the timeout
+ # message added by record_process_output, which is treated as an
+ # unnumbered "not ok".
+ if err:
+ if len(err) == 1 and err[0].startswith("TIMEOUT: "):
+ points_already_used.add(prev_point + 1)
+ self.add_fail(messages, err[0][len("TIMEOUT: "):])
+ else:
+ self.add_error(err, "Unexpected output on stderr")
+
+ # Any missing test points are fails.
+ for pt in range(1, max_point+1):
+ if pt not in points_already_used:
+ self.add_fail([], "test {} did not report status".format(pt))
+
+class TestRunner(object):
+ def __init__(self, base_path, phantomjs_exe, options):
+ self.base_path = base_path
+ self.cert_path = os.path.join(base_path, 'certs')
+ self.harness = os.path.join(base_path, 'testharness.js')
+ self.phantomjs_exe = phantomjs_exe
+ self.verbose = options.verbose
+ self.debugger = options.debugger
+ self.to_run = options.to_run
+ self.run_unsupported = options.run_unsupported
+ self.server_errs = []
+
+ def signal_server_error(self, exc_info):
+ self.server_errs.append(exc_info)
+
+ def get_base_command(self, debugger):
+ if debugger is None:
+ return [self.phantomjs_exe]
+ elif debugger == "gdb":
+ return ["gdb", "--args", self.phantomjs_exe]
+ elif debugger == "lldb":
+ return ["lldb", "--", self.phantomjs_exe]
+ elif debugger == "valgrind":
+ return ["valgrind", self.phantomjs_exe]
+ else:
+ raise RuntimeError("Don't know how to invoke " + self.debugger)
+
+ def run_phantomjs(self, script,
+ script_args=[], pjs_args=[], stdin_data=[],
+ timeout=TIMEOUT, silent=False):
+ verbose = self.verbose
+ debugger = self.debugger
+ if silent:
+ verbose = False
+ debugger = None
+
+ output = []
+ command = self.get_base_command(debugger)
+ command.extend(pjs_args)
+ command.append(script)
+ if verbose:
+ command.append('--verbose={}'.format(verbose))
+ command.extend(script_args)
+
+ if verbose >= 3:
+ sys.stdout.write("## running {}\n".format(" ".join(command)))
+
+ if debugger:
+ # FIXME: input-feed mode doesn't work with a debugger,
+ # because how do you tell the debugger that the *debuggee*
+ # needs to read from a pipe?
+ subprocess.call(command)
+ return 0, [], []
+ else:
+ return do_call_subprocess(command, verbose, stdin_data, timeout)
+
+ def run_test(self, script, name):
+ script_args = []
+ pjs_args = []
+ use_harness = True
+ use_snakeoil = False
+ stdin_data = []
+ stdout_exp = []
+ stderr_exp = []
+ rc_exp = None
+ stdout_xfail = False
+ stderr_xfail = False
+ rc_xfail = False
+ timeout = TIMEOUT
+ unsupported = False
+
+ def require_args(what, i, tokens):
+ if i+1 == len(tokens):
+ raise ValueError(what + "directive requires an argument")
+
+ if self.verbose >= 3:
+ sys.stdout.write(colorize("^", name) + ":\n")
+ # Parse any directives at the top of the script.
+ try:
+ with open(script, "rt") as s:
+ for line in s:
+ if not line.startswith("//!"):
+ break
+ tokens = shlex.split(line[3:], comments=True)
+
+ skip = False
+ for i in range(len(tokens)):
+ if skip:
+ skip = False
+ continue
+ tok = tokens[i]
+ if tok == "unsupported":
+ unsupported = True
+ elif tok == "no-harness":
+ use_harness = False
+ elif tok == "snakeoil":
+ use_snakeoil = True
+ elif tok == "expect-exit-fails":
+ rc_xfail = True
+ elif tok == "expect-stdout-fails":
+ stdout_xfail = True
+ elif tok == "expect-stderr-fails":
+ stderr_xfail = True
+ elif tok == "timeout:":
+ require_args(tok, i, tokens)
+ timeout = float(tokens[i+1])
+ if timeout <= 0:
+ raise ValueError("timeout must be positive")
+ skip = True
+ elif tok == "expect-exit:":
+ require_args(tok, i, tokens)
+ rc_exp = int(tokens[i+1])
+ skip = True
+ elif tok == "phantomjs:":
+ require_args(tok, i, tokens)
+ pjs_args.extend(tokens[(i+1):])
+ break
+ elif tok == "script:":
+ require_args(tok, i, tokens)
+ script_args.extend(tokens[(i+1):])
+ break
+ elif tok == "stdin:":
+ require_args(tok, i, tokens)
+ stdin_data.append(" ".join(tokens[(i+1):]) + "\n")
+ break
+ elif tok == "expect-stdout:":
+ require_args(tok, i, tokens)
+ stdout_exp.append(" ".join(tokens[(i+1):]))
+ break
+ elif tok == "expect-stderr:":
+ require_args(tok, i, tokens)
+ stderr_exp.append(" ".join(tokens[(i+1):]))
+ break
+ else:
+ raise ValueError("unrecognized directive: " + tok)
+
+ except Exception as e:
+ grp = TestGroup(name)
+ if hasattr(e, 'strerror') and hasattr(e, 'filename'):
+ grp.add_error([], '{} ({}): {}\n'
+ .format(name, e.filename, e.strerror))
+ else:
+ grp.add_error([], '{} ({}): {}\n'
+ .format(name, script, str(e)))
+ return grp
+
+ if use_harness:
+ script_args.insert(0, script)
+ script = self.harness
+
+ if use_snakeoil:
+ pjs_args.insert(0, '--ssl-certificates-path=' + self.cert_path)
+
+ if unsupported and not self.run_unsupported:
+ return UnsupportedTestGroup(name)
+ rc, out, err = self.run_phantomjs(script, script_args, pjs_args,
+ stdin_data, timeout)
+
+ if rc_exp or stdout_exp or stderr_exp:
+ grp = ExpectTestGroup(name,
+ rc_exp, stdout_exp, stderr_exp,
+ rc_xfail, stdout_xfail, stderr_xfail)
+ else:
+ grp = TAPTestGroup(name)
+ grp.parse(rc, out, err)
+ return grp
+
+ def run_tests(self):
+ start = time.time()
+ base = self.base_path
+ nlen = len(base) + 1
+
+ results = []
+
+ for test_glob in TESTS:
+ test_glob = os.path.join(base, test_glob)
+
+ for test_script in sorted(glob.glob(test_glob)):
+ tname = os.path.splitext(test_script)[0][nlen:]
+ if self.to_run:
+ for to_run in self.to_run:
+ if to_run in tname:
+ break
+ else:
+ continue
+
+ any_executed = True
+ grp = self.run_test(test_script, tname)
+ grp.report_for_verbose_level(sys.stdout, self.verbose)
+ results.append(grp)
+
+ grp = TestGroup("HTTP server errors")
+ for ty, val, tb in self.server_errs:
+ grp.add_error(traceback.format_tb(tb, 5),
+ traceback.format_exception_only(ty, val)[-1])
+ grp.report_for_verbose_level(sys.stdout, self.verbose)
+ results.append(grp)
+
+ sys.stdout.write("\n")
+ return self.report(results, time.time() - start)
+
+ def report(self, results, elapsed):
+ # There is always one test group, for the HTTP server errors.
+ if len(results) == 1:
+ sys.stderr.write("No tests selected for execution.\n")
+ return 1
+
+ n = [0] * T.MAX
+
+ for grp in results:
+ if self.verbose == 0 and not grp.is_successful():
+ grp.report(sys.stdout, False)
+ for i, x in enumerate(grp.n): n[i] += x
+
+ sys.stdout.write("{:6.3f}s elapsed\n".format(elapsed))
+ for s in (T.PASS, T.FAIL, T.XPASS, T.XFAIL, T.ERROR, T.SKIP, T.UNSUPPORTED):
+ if n[s]:
+ sys.stdout.write(" {:>4} {}\n".format(n[s], s.long_label))
+
+ if n[T.FAIL] == 0 and n[T.XPASS] == 0 and n[T.ERROR] == 0:
+ return 0
+ else:
+ return 1
+
+def init():
+ base_path = os.path.normpath(os.path.dirname(os.path.abspath(__file__)))
+ phantomjs_exe = os.path.normpath(base_path + '/../../../index.js')
+ if not os.path.isfile(phantomjs_exe):
+ sys.stdout.write("{} is unavailable, cannot run tests.\n"
+ .format(phantomjs_exe))
+ sys.exit(1)
+
+ parser = argparse.ArgumentParser(description='Run PhantomJS tests.')
+ parser.add_argument('-v', '--verbose', action='count', default=0,
+ help='Increase verbosity of logs (repeat for more)')
+ parser.add_argument('to_run', nargs='*', metavar='test',
+ help='tests to run (default: all of them)')
+ parser.add_argument('--debugger', default=None,
+ help="Run PhantomJS under DEBUGGER")
+ parser.add_argument('--run-unsupported', action='count', default=0,
+ help='Run unsupported tests.')
+ parser.add_argument('--color', metavar="WHEN", default='auto',
+ choices=['always', 'never', 'auto'],
+ help="colorize the output; can be 'always',"
+ " 'never', or 'auto' (the default)")
+
+ options = parser.parse_args()
+ activate_colorization(options)
+ runner = TestRunner(base_path, phantomjs_exe, options)
+ if options.verbose:
+ rc, ver, err = runner.run_phantomjs('--version', silent=True)
+ if rc != 0 or len(ver) != 1 or len(err) != 0:
+ sys.stdout.write(colorize("R", "FATAL")+": Version check failed\n")
+ for l in ver:
+ sys.stdout.write(colorize("b", "## " + l) + "\n")
+ for l in err:
+ sys.stdout.write(colorize("b", "## " + l) + "\n")
+ sys.stdout.write(colorize("b", "## exit {}".format(rc)) + "\n")
+ sys.exit(1)
+
+ sys.stdout.write(colorize("b", "## Testing PhantomJS "+ver[0])+"\n")
+
+ # Run all the tests in Chatham Islands Standard Time, UTC+12:45.
+ # This timezone is deliberately chosen to be unusual: it's not a
+ # whole number of hours offset from UTC *and* it's more than twelve
+ # hours offset from UTC.
+ #
+ # The Chatham Islands do observe daylight savings, but we don't
+ # implement that because testsuite issues only reproducible on two
+ # particular days out of the year are too much tsuris.
+ #
+ # Note that the offset in a TZ value is the negative of the way it's
+ # usually written, e.g. UTC+1 would be xxx-1:00.
+ os.environ["TZ"] = "CIST-12:45:00"
+
+ return runner
+
+def main():
+ runner = init()
+ try:
+ with HTTPTestServer(runner.base_path,
+ runner.signal_server_error,
+ runner.verbose):
+ sys.exit(runner.run_tests())
+
+ except Exception:
+ trace = traceback.format_exc(5).split("\n")
+ # there will be a blank line at the end of 'trace'
+ sys.stdout.write(colorize("R", "FATAL") + ": " + trace[-2] + "\n")
+ for line in trace[:-2]:
+ sys.stdout.write(colorize("b", "## " + line) + "\n")
+
+ sys.exit(1)
+
+ except KeyboardInterrupt:
+ sys.exit(2)
+
+main()
diff --git a/third_party/phantomjs/test/standards/console/console_log.js b/third_party/phantomjs/test/standards/console/console_log.js
new file mode 100644
index 00000000000..7b17aba81c8
--- /dev/null
+++ b/third_party/phantomjs/test/standards/console/console_log.js
@@ -0,0 +1,9 @@
+async_test(function () {
+ var page = require('webpage').create();
+ page.onConsoleMessage = this.step_func_done(function (msg) {
+ assert_equals(msg, "answer 42");
+ });
+ page.evaluate(function () {
+ console.log('answer', 42);
+ });
+}, "console.log should support multiple arguments");
diff --git a/third_party/phantomjs/test/standards/javascript/date.js b/third_party/phantomjs/test/standards/javascript/date.js
new file mode 100644
index 00000000000..b2a1f97f83a
--- /dev/null
+++ b/third_party/phantomjs/test/standards/javascript/date.js
@@ -0,0 +1,12 @@
+test(function() {
+ var date = new Date('2012-09-07');
+ assert_not_equals(date.toString(), 'Invalid Date');
+ assert_equals(date.getUTCDate(), 7);
+ assert_equals(date.getUTCMonth(), 8);
+ assert_equals(date.getYear(), 112);
+}, "new Date()");
+
+test(function () {
+ var date = Date.parse("2012-01-01");
+ assert_equals(date, 1325376000000);
+}, "Date.parse()");
diff --git a/third_party/phantomjs/test/standards/javascript/function.js b/third_party/phantomjs/test/standards/javascript/function.js
new file mode 100644
index 00000000000..2b6f4734c76
--- /dev/null
+++ b/third_party/phantomjs/test/standards/javascript/function.js
@@ -0,0 +1,46 @@
+test(function () {
+ assert_type_of(Function.length, 'number');
+ assert_type_of(Function.prototype, 'function');
+ assert_type_of(Function.prototype.apply, 'function');
+ assert_type_of(Function.prototype.bind, 'function');
+ assert_type_of(Function.prototype.call, 'function');
+ assert_type_of(Function.prototype.name, 'string');
+ assert_type_of(Function.prototype.toString, 'function');
+}, "Function properties");
+
+test(function () {
+ var f = function foo(){};
+ assert_equals(f.name, 'foo');
+}, ".name");
+
+test(function () {
+ assert_equals(Function.length, 1);
+ assert_equals(function(){}.length, 0);
+ assert_equals(function(x){}.length, 1);
+ assert_equals(function(x, y){}.length, 2);
+ assert_equals(function(x, y){}.length, 2);
+}, ".length");
+
+test(function () {
+ var args, keys, str, enumerable;
+ (function() {
+ args = arguments;
+ keys = Object.keys(arguments);
+ str = JSON.stringify(arguments);
+ enumerable = false;
+ for (var i in arguments) enumerable = true;
+ })(14);
+
+ assert_type_of(args, 'object');
+ assert_type_of(args.length, 'number');
+ assert_equals(args.toString(), '[object Arguments]');
+ assert_equals(args.length, 1);
+ assert_equals(args[0], 14);
+
+ assert_type_of(keys.length, 'number');
+ assert_equals(keys.length, 1);
+ assert_equals(keys[0], "0");
+
+ assert_equals(str, '{"0":14}');
+ assert_is_true(enumerable);
+}, "arguments object");
diff --git a/third_party/phantomjs/test/testharness.js b/third_party/phantomjs/test/testharness.js
new file mode 100644
index 00000000000..706048b3d79
--- /dev/null
+++ b/third_party/phantomjs/test/testharness.js
@@ -0,0 +1,1489 @@
+/* vim: set expandtab shiftwidth=4 tabstop=4: */
+/*global require, phantom, setTimeout, clearTimeout */
+
+/*
+ This file is part of the PhantomJS project from Ofi Labs.
+
+ Copyright 2015 Zachary Weinberg
+
+ Based on testharness.js
+ produced by the W3C and distributed under the W3C 3-Clause BSD
+ License .
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the nor the
+ names of its contributors may be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+
+(function () {
+
+"use strict";
+
+/** Public API: Defining and running tests.
+ *
+ * Compared to the W3C testharness.js, a number of minor changes have
+ * been made to fit the rather different PhantomJS controller
+ * environment, but the basic API is the same.
+ */
+
+/** Define an asynchronous test. Returns a Test object. In response
+ to appropriate events, call the Test object's step() method,
+ passing a function containing assertions (as for synch tests).
+ Eventually, call the Test object's done() method (inside a step).
+
+ All arguments are optional. If |func| is provided, it is called
+ immediately (after the previous test completes) as the first step
+ function. |properties| is the same as for test().
+
+ Test has several convenience methods for creating step functions,
+ see below. */
+function async_test(func, name, properties) {
+ var test_obj;
+
+ if (func && typeof func !== "function") {
+ properties = name;
+ name = func;
+ func = null;
+ }
+ test_obj = new Test(test_name(func, name), properties);
+ if (func) {
+ test_obj.step(func);
+ }
+ return test_obj;
+}
+expose(async_test, 'async_test');
+
+/** Define a synchronous test, which is just an asynchronous test that
+ calls done() immediately after its first step function (func) returns.
+
+ |func| is a function containing the test code, and |name|
+ (optionally) is a descriptive name for the test. |func| will be
+ called (after the previous test completes), with |this| a Test
+ object (see below), and should make use of the global assert_*
+ functions. |properties| is an optional dictionary of test
+ properties; currently only one is defined:
+
+ timeout - Timeout for this test, in milliseconds. */
+function test(func, name, properties) {
+ return async_test(function sync_step () {
+ func.call(this);
+ this.done();
+ }, name, properties);
+}
+expose(test, 'test');
+
+/** Define a series of synchronous tests all at once.
+ Easiest to explain by example:
+
+ generate_tests(assert_equals, [
+ ["Sum one and one", 1+1, 2],
+ ["Sum one and zero", 1+0, 1]
+ ]);
+
+ is equivalent to
+
+ test(function() {assert_equals(1+1, 2)}, "Sum one and one");
+ test(function() {assert_equals(1+0, 1)}, "Sum one and zero");
+
+ The first argument can be an arbitrary function, and you can provide
+ as many arguments in each test vector entry as you like.
+
+ The properties argument can be a single dictionary, which is applied to
+ all the tests, or an array, applied entry-by-entry.
+ */
+function generate_tests(func, args, properties) {
+ function generate_one_test(argv) {
+ return function generated_step () {
+ // 'this' will be set by bind() inside test().
+ func.apply(this, argv);
+ };
+ }
+
+ var i;
+ for (i = 0; i < args.length; i++) {
+ test(generate_one_test(args[i].slice(1)),
+ args[i][0],
+ Array.isArray(properties) ? properties[i] : properties);
+ }
+}
+expose(generate_tests, 'generate_tests');
+
+/** Set up the test harness. Does nothing if called after any test has
+ begun execution. May be called as setup(func), setup(properties), or
+ setup(func, properties). |func| is a function to call synchronously;
+ if it throws an exception the entire test group is considered failed.
+ |properties| is a dictionary containing one or more of these keys:
+
+ explicit_done - Wait for an explicit call to done() before
+ declaring all tests complete (see below; implicitly true for
+ single-test files)
+
+ allow_uncaught_exception - Don't treat an uncaught exception from
+ non-test code as an error. (Exceptions thrown out of test
+ functions are still errors.)
+
+ timeout - Global timeout in milliseconds (default: 5 seconds)
+ test_timeout - Per-test timeout in milliseconds, unless overridden
+ by the timeout property on a specific test (default: none)
+ */
+function setup(func_or_properties, maybe_properties) {
+ var func = null,
+ properties = {};
+
+ if (arguments.length === 2) {
+ func = func_or_properties;
+ properties = maybe_properties;
+ } else if (typeof func_or_properties === "function") {
+ func = func_or_properties;
+ } else {
+ properties = func_or_properties;
+ }
+ tests.setup(func, properties);
+}
+expose(setup, 'setup');
+
+/** Signal that all tests are complete. Must be called explicitly if
+ setup({explicit_done: true}) was used; otherwise implicitly
+ happens when all individual tests are done. */
+function done() {
+ tests.end_wait();
+}
+expose(done, 'done');
+
+
+/** Public API: Assertions.
+ * All assertion functions take a |description| argument which is used to
+ * annotate any failing tests.
+ */
+
+/** Assert that |actual| is strictly true. */
+function assert_is_true(actual, description) {
+ assert(actual === true, "assert_is_true", description,
+ "expected true got ${actual}", {actual: actual});
+}
+expose(assert_is_true, 'assert_is_true');
+
+/** Assert that |actual| is strictly false. */
+function assert_is_false(actual, description) {
+ assert(actual === false, "assert_is_false", description,
+ "expected false got ${actual}", {actual: actual});
+}
+expose(assert_is_false, 'assert_is_false');
+
+/** Assert that |actual| is strictly equal to |expected|.
+ The test is even more stringent than === (see same_value, below). */
+function assert_equals(actual, expected, description) {
+ if (typeof actual !== typeof expected) {
+ assert(false, "assert_equals", description,
+ "expected (${expectedT}) ${expected} " +
+ "but got (${actualT}) ${actual}",
+ {expectedT: typeof expected,
+ expected: expected,
+ actualT: typeof actual,
+ actual: actual});
+ }
+ assert(same_value(actual, expected), "assert_equals", description,
+ "expected ${expected} but got ${actual}",
+ {expected: expected, actual: actual});
+}
+expose(assert_equals, 'assert_equals');
+
+/** Assert that |actual| is not strictly equal to |expected|, using the
+ same extra-stringent criterion as for assert_equals. */
+function assert_not_equals(actual, expected, description) {
+ if (typeof actual !== typeof expected) {
+ return;
+ }
+ assert(!same_value(actual, expected), "assert_not_equals", description,
+ "got disallowed value ${actual}",
+ {actual: actual});
+}
+expose(assert_not_equals, 'assert_not_equals');
+
+/** Assert that |expected|, a duck-typed array, contains |actual|,
+ according to indexOf. */
+function assert_in_array(actual, expected, description) {
+ assert(expected.indexOf(actual) !== -1, "assert_in_array", description,
+ "value ${actual} not in array ${expected}",
+ {actual: actual, expected: expected});
+}
+expose(assert_in_array, 'assert_in_array');
+
+/** Assert that |expected| and |actual| have all the same properties,
+ which are, recursively, strictly equal. For primitive types this
+ is the same as |assert_equals|.
+ */
+function assert_deep_equals(actual, expected, description) {
+ var stack = [];
+ function check_equal_r(act, exp) {
+ if (is_primitive_value(exp) || is_primitive_value(act)) {
+ assert(same_value(act, exp),
+ "assert_deep_equals", description,
+ "expected ${exp} but got ${act}" +
+ " (top level: expected ${expected} but got ${actual})",
+ {exp: exp, act: act, expected: expected, actual: actual});
+
+ } else if (stack.indexOf(act) === -1) {
+ var ka = {}, ke = {}, k;
+ stack.push(act);
+
+ Object.getOwnPropertyNames(actual).forEach(function (x) {
+ ka[x] = true;
+ });
+ Object.getOwnPropertyNames(expected).forEach(function (x) {
+ ke[x] = true;
+ });
+
+ for (k in ke) {
+ assert(k in ka,
+ "assert_deep_equals", description,
+ "expected property ${k} missing" +
+ " (top level: expected ${expected} but got ${actual})",
+ {k: k, expected: expected, actual: actual});
+
+ check_equal_r(act[k], exp[k]);
+ delete ka[k];
+ }
+ for (k in ka) {
+ assert(false, "assert_deep_equals", description,
+ "unexpected property ${k}" +
+ " (top level: expected ${expected} but got ${actual})",
+ {k: k, expected: expected, actual: actual});
+ }
+
+ stack.pop();
+ }
+ }
+ check_equal_r(actual, expected);
+}
+expose(assert_deep_equals, 'assert_deep_equals');
+
+/** Assert that |expected| and |actual|, both primitive numbers, are
+ within |epsilon| of each other. */
+function assert_approx_equals(actual, expected, epsilon, description) {
+ assert(typeof actual === "number",
+ "assert_approx_equals", description,
+ "expected a number but got a ${type_actual}",
+ {type_actual: typeof actual});
+ assert(typeof expected === "number",
+ "assert_approx_equals", description,
+ "expectation should be a number, got a ${type_expected}",
+ {type_expected: typeof expected});
+ assert(typeof epsilon === "number",
+ "assert_approx_equals", description,
+ "epsilon should be a number but got a ${type_epsilon}",
+ {type_epsilon: typeof epsilon});
+
+ assert(Math.abs(actual - expected) <= epsilon,
+ "assert_approx_equals", description,
+ "expected ${expected} +/- ${epsilon} but got ${actual}",
+ {expected: expected, actual: actual, epsilon: epsilon});
+}
+expose(assert_approx_equals, 'assert_approx_equals');
+
+/** Assert that |actual| is less than |expected|, where both are
+ primitive numbers. */
+function assert_less_than(actual, expected, description) {
+ assert(typeof actual === "number",
+ "assert_less_than", description,
+ "expected a number but got a ${type_actual}",
+ {type_actual: typeof actual});
+ assert(typeof expected === "number",
+ "assert_approx_equals", description,
+ "expectation should be a number, got a ${type_expected}",
+ {type_expected: typeof expected});
+
+ assert(actual < expected,
+ "assert_less_than", description,
+ "expected a number less than ${expected} but got ${actual}",
+ {expected: expected, actual: actual});
+}
+expose(assert_less_than, 'assert_less_than');
+
+/** Assert that |actual| is greater than |expected|, where both are
+ primitive numbers. */
+function assert_greater_than(actual, expected, description) {
+ assert(typeof actual === "number",
+ "assert_greater_than", description,
+ "expected a number but got a ${type_actual}",
+ {type_actual: typeof actual});
+ assert(typeof expected === "number",
+ "assert_approx_equals", description,
+ "expectation should be a number, got a ${type_expected}",
+ {type_expected: typeof expected});
+
+ assert(actual > expected,
+ "assert_greater_than", description,
+ "expected a number greater than ${expected} but got ${actual}",
+ {expected: expected, actual: actual});
+}
+expose(assert_greater_than, 'assert_greater_than');
+
+/** Assert that |actual| is less than or equal to |expected|, where
+ both are primitive numbers. */
+function assert_less_than_equal(actual, expected, description) {
+ assert(typeof actual === "number",
+ "assert_less_than_equal", description,
+ "expected a number but got a ${type_actual}",
+ {type_actual: typeof actual});
+ assert(typeof expected === "number",
+ "assert_approx_equals", description,
+ "expectation should be a number, got a ${type_expected}",
+ {type_expected: typeof expected});
+
+ assert(actual <= expected,
+ "assert_less_than", description,
+ "expected a number less than or equal to ${expected} "+
+ "but got ${actual}",
+ {expected: expected, actual: actual});
+}
+expose(assert_less_than_equal, 'assert_less_than_equal');
+
+/** Assert that |actual| is greater than or equal to |expected|, where
+ both are primitive numbers. */
+function assert_greater_than_equal(actual, expected, description) {
+ assert(typeof actual === "number",
+ "assert_greater_than_equal", description,
+ "expected a number but got a ${type_actual}",
+ {type_actual: typeof actual});
+ assert(typeof expected === "number",
+ "assert_approx_equals", description,
+ "expectation should be a number, got a ${type_expected}",
+ {type_expected: typeof expected});
+
+ assert(actual >= expected,
+ "assert_greater_than_equal", description,
+ "expected a number greater than or equal to ${expected} "+
+ "but got ${actual}",
+ {expected: expected, actual: actual});
+}
+expose(assert_greater_than_equal, 'assert_greater_than_equal');
+
+/** Assert that |actual|, a string, matches a regexp, |expected|. */
+function assert_regexp_match(actual, expected, description) {
+ assert(expected.test(actual),
+ "assert_regexp_match", description,
+ "expected ${actual} to match ${expected}",
+ {expected: expected, actual: actual});
+}
+expose(assert_regexp_match, 'assert_regexp_match');
+
+/** Assert that |actual|, a string, does _not_ match a regexp, |expected|. */
+function assert_regexp_not_match(actual, expected, description) {
+ assert(!expected.test(actual),
+ "assert_regexp_not_match", description,
+ "expected ${actual} not to match ${expected}",
+ {expected: expected, actual: actual});
+}
+expose(assert_regexp_not_match, 'assert_regexp_not_match');
+
+/** Assert that |typeof object| is strictly equal to |type|. */
+function assert_type_of(object, type, description) {
+ assert(typeof object === type,
+ "assert_type_of", description,
+ "expected typeof ${object} to be ${expected}, got ${actual}",
+ {object: object, expected: type, actual: typeof object});
+}
+expose(assert_type_of, 'assert_type_of');
+
+/** Assert that |object instanceof type|. */
+function assert_instance_of(object, type, description) {
+ assert(object instanceof type,
+ "assert_instance_of", description,
+ "expected ${object} to be instanceof ${expected}",
+ {object: object, expected: type});
+}
+expose(assert_instance_of, 'assert_instance_of');
+
+/** Assert that |object| has the class string |expected|. */
+function assert_class_string(object, expected, description) {
+ var actual = ({}).toString.call(object).slice(8, -1);
+ assert(actual === expected,
+ "assert_class_string", description,
+ "expected ${object} to have class string ${expected}, "+
+ "but got ${actual}",
+ {object: object, expected: expected, actual: actual});
+}
+expose(assert_class_string, 'assert_class_string');
+
+/** Assert that |object| has a property named |name|. */
+function assert_own_property(object, name, description) {
+ assert(typeof object === "object",
+ "assert_own_property", description,
+ "provided value is not an object");
+
+ assert("hasOwnProperty" in object,
+ "assert_own_property", description,
+ "provided value is an object but has no hasOwnProperty method");
+
+ assert(object.hasOwnProperty(name),
+ "assert_own_property", description,
+ "expected property ${name} missing", {name: name});
+}
+expose(assert_own_property, 'assert_own_property');
+
+/** Assert that |object| inherits a property named |name|.
+ Note: this assertion will fail for objects that have an
+ own-property named |name|. */
+function assert_inherits(object, name, description) {
+ assert(typeof object === "object",
+ "assert_inherits", description,
+ "provided value is not an object");
+
+ assert("hasOwnProperty" in object,
+ "assert_inherits", description,
+ "provided value is an object but has no hasOwnProperty method");
+
+ assert(!object.hasOwnProperty(name),
+ "assert_inherits", description,
+ "property ${p} found on object, expected only in prototype chain",
+ {p: name});
+
+ assert(name in object,
+ "assert_inherits", description,
+ "property ${p} not found in prototype chain",
+ {p: name});
+
+}
+expose(assert_inherits, 'assert_inherits');
+
+/** Assert that |object| neither has nor inherits a property named |name|. */
+function assert_no_property(object, name, description) {
+ assert(typeof object === "object",
+ "assert_no_property", description,
+ "provided value is not an object");
+
+ assert("hasOwnProperty" in object,
+ "assert_no_property", description,
+ "provided value is an object but has no hasOwnProperty method");
+
+ assert(!object.hasOwnProperty(name),
+ "assert_no_property", description,
+ "property ${p} found on object, expected to be absent",
+ {p: name});
+
+ assert(!(name in object),
+ "assert_no_property", description,
+ "property ${p} found in prototype chain, expected to be absent",
+ {p: name});
+}
+expose(assert_no_property, 'assert_no_property');
+
+/** Assert that property |name| of |object| is read-only according
+ to its property descriptor. */
+function assert_readonly(object, name, description) {
+ var o = {}, desc;
+
+ assert('getOwnPropertyDescriptor' in o,
+ "assert_readonly", description,
+ "Object.getOwnPropertyDescriptor is missing");
+
+ assert(object.hasOwnProperty(name),
+ "assert_readonly", description,
+ "expected property ${name} missing", {name: name});
+
+ desc = o.getOwnPropertyDescriptor.call(object, name);
+ if ('writable' in desc) {
+ assert(!desc.writable, "assert_readonly", description,
+ "data property ${name} is writable (expected read-only)",
+ {name: name});
+ } else {
+ assert('get' in desc && 'set' in desc,
+ "assert_readonly", description,
+ "unrecognized type of property descriptor "+
+ "for ${name}: ${desc}",
+ {name: name, desc: desc});
+ assert(desc.set === undefined,
+ "assert_readonly", description,
+ "property ${name} has a setter (expected read-only)",
+ {name: name, desc: desc});
+ }
+}
+expose(assert_readonly, 'assert_readonly');
+
+/** Assert that |func| throws an exception described by |code|.
+ |func| is called with no arguments and no |this| -- use bind() if
+ that's a problem. |code| can take one of two forms:
+
+ string - the thrown exception must be a DOMException with the
+ given name, e.g., "TimeoutError", or else it must
+ stringify to this string.
+
+ object - must have one or more of the properties "code", "name",
+ and "message". Whichever properties are present must
+ match the corresponding properties of the thrown
+ exception. As a special case, "message" will also match
+ the stringification of the exception.
+*/
+
+function assert_throws(code, func, description) {
+ var name_code_map = {
+ IndexSizeError: 1,
+ HierarchyRequestError: 3,
+ WrongDocumentError: 4,
+ InvalidCharacterError: 5,
+ NoModificationAllowedError: 7,
+ NotFoundError: 8,
+ NotSupportedError: 9,
+ InvalidStateError: 11,
+ SyntaxError: 12,
+ InvalidModificationError: 13,
+ NamespaceError: 14,
+ InvalidAccessError: 15,
+ TypeMismatchError: 17,
+ SecurityError: 18,
+ NetworkError: 19,
+ AbortError: 20,
+ URLMismatchError: 21,
+ QuotaExceededError: 22,
+ TimeoutError: 23,
+ InvalidNodeTypeError: 24,
+ DataCloneError: 25,
+
+ UnknownError: 0,
+ ConstraintError: 0,
+ DataError: 0,
+ TransactionInactiveError: 0,
+ ReadOnlyError: 0,
+ VersionError: 0
+ };
+
+ if (typeof code === "object") {
+ assert("name" in code || "code" in code || "message" in code,
+ "assert_throws", description,
+ "exception spec ${code} has no 'name', 'code', or 'message'" +
+ "properties",
+ {code: code});
+ } else if (name_code_map.hasOwnProperty(code)) {
+ code = { name: code,
+ code: name_code_map[code] };
+ } else {
+ code = { message: code.toString() };
+ }
+
+ try {
+ func();
+ assert(false, "assert_throws", description,
+ "${func} did not throw", {func: func});
+ } catch (e) {
+ if (e instanceof AssertionError) {
+ throw e;
+ }
+
+ // Backward compatibility wart for DOMExceptions identified
+ // only by numeric code.
+ if ("code" in code && code.code !== 0 &&
+ (!("name" in e) || e.name === e.name.toUpperCase() ||
+ e.name === "DOMException"))
+ delete code.name;
+
+ if ("name" in code) {
+ assert("name" in e && e.name === code.name,
+ "assert_throws", description,
+ "${func} threw ${actual} (${actual_name}), "+
+ "expected ${expected} (${expected_name})",
+ {func: func, actual: e, actual_name: e.name,
+ expected: code,
+ expected_name: code.name});
+ }
+ if ("code" in code) {
+ assert("code" in e && e.code === code.code,
+ "assert_throws", description,
+ "${func} threw ${actual} (${actual_code}), "+
+ "expected ${expected} (${expected_code})",
+ {func: func, actual: e, actual_code: e.code,
+ expected: code,
+ expected_code: code.code});
+ }
+ if ("message" in code) {
+ if (Object.hasOwnProperty.call(e, "message")) {
+ assert(e.message === code.message,
+ "assert_throws", description,
+ "${func} threw ${actual} (${actual_message}), "+
+ "expected ${expected} (${expected_message})",
+ {func: func, actual: e, actual_message: e.message,
+ expected: code, expected_message: code.message});
+ } else {
+ // Intentional use of loose equality
+ assert(e == code.message,
+ "assert_throws", description,
+ "${func} threw ${actual}, expected ${expected})",
+ {func: func, actual: e, expected: code.message});
+ }
+ }
+ }
+}
+expose(assert_throws, 'assert_throws');
+
+/** Assert that control flow cannot reach the point where this
+ assertion appears. */
+function assert_unreached(description) {
+ assert(false, "assert_unreached", description,
+ "reached unreachable code");
+}
+expose(assert_unreached, 'assert_unreached');
+
+/** Test object.
+ * These must be created by calling test() or async_test(), but
+ * many of their methods are part of the public API.
+ */
+
+function Test(name, properties) {
+ this.name = name;
+ this.phase = Test.phases.INITIAL;
+ this.in_done = false;
+ this.status = Test.NOTRUN;
+ this.timeout_id = null;
+ this.message = null;
+ this.steps = [];
+ this.cleanup_callbacks = [];
+
+ if (!properties) {
+ properties = {};
+ }
+ this.properties = properties;
+ this.timeout_length = properties.timeout ? properties.timeout
+ : tests.test_timeout_length;
+ this.should_run = !properties.skip;
+ tests.push(this);
+ this.number = tests.tests.length;
+
+ if (!this.should_run) {
+ // Fake initial step that _does_ run, but short-circuits the test.
+ // All other steps will be marked not to be run via the defaults
+ // in step(). The step function does not call done() because that
+ // would record a success. We can't do this ourselves because the
+ // plan line has not been emitted yet.
+ var stepdata = this.step(function () {
+ this.phase = Test.phases.COMPLETE;
+ tests.result(this);
+ });
+ stepdata.should_run = true;
+ stepdata.auto_run = true;
+ }
+}
+
+Test.phases = {
+ INITIAL: 0,
+ STARTED: 1,
+ HAS_RESULT: 2,
+ COMPLETE: 3
+};
+Test.statuses = {
+ NOTRUN: -1,
+ PASS: 0,
+ FAIL: 1,
+ XFAIL: 4,
+ XPASS: 5
+};
+Test.prototype.phases = Test.phases;
+Test.prototype.statuses = Test.phases;
+
+(function() {
+ var x;
+ var o = Test.statuses;
+ for (x in o) {
+ if (o.hasOwnProperty(x)) {
+ Test[x] = Test.statuses[x];
+ Test.prototype[x] = Test.statuses[x];
+ }
+ }
+})();
+
+/** Queue one step of a test. |func| will eventually be called, with
+ |this| set to |this_obj|, or to the Test object if |this_obj| is
+ absent. Any further arguments will be passed down to |func|. It
+ should carry out some tests using assert_* and eventually return.
+ |func| will _not_ be called if a previous step of the test has
+ already failed.
+
+ Returns an object which can be passed to this.perform_step() to
+ cause |func| actually to be called -- but you should not do this
+ yourself unless absolutely unavoidable.
+ */
+Test.prototype.step = function step(func, this_obj) {
+ if (this_obj == null) {
+ this_obj = this;
+ }
+ func = func.bind(this_obj, ...Array.prototype.slice.call(arguments, 2));
+
+ var stepdata = {
+ func: func,
+ should_run: this.should_run,
+ auto_run: this.should_run,
+ has_run: false
+ };
+
+ this.steps.push(stepdata);
+ return stepdata;
+};
+
+/** Internal: perform one step of a test.
+ */
+Test.prototype.perform_step = function perform_step(stepdata) {
+ var message;
+
+ if (this.phase > this.phases.STARTED ||
+ tests.phase > tests.phases.HAVE_RESULTS) {
+ return undefined;
+ }
+
+ this.phase = this.phases.STARTED;
+ tests.started = true;
+ stepdata.has_run = true;
+
+ // Arm the local timeout if it hasn't happened already.
+ if (this.timeout_id === null && this.timeout_length !== null) {
+ this.timeout_id = setTimeout(this.force_timeout.bind(this),
+ this.timeout_length);
+ }
+
+ var rv = undefined;
+ try {
+ rv = stepdata.func();
+ } catch (e) {
+ this.fail(format_exception(e));
+ }
+ return rv;
+};
+
+/** Mark this test as failed. */
+Test.prototype.fail = function fail(message) {
+ if (this.phase < this.phases.HAS_RESULT) {
+ this.message = message;
+ this.status = this.FAIL;
+ this.phase = this.phases.HAS_RESULT;
+ if (!this.in_done) {
+ this.done();
+ }
+ } else {
+ tests.output.error(message);
+ }
+};
+
+/** Mark this test as completed. */
+Test.prototype.done = function done() {
+ var i;
+
+ this.in_done = true;
+
+ if (this.timeout_id !== null) {
+ clearTimeout(this.timeout_id);
+ this.timeout_id = null;
+ }
+
+ if (this.phase == this.phases.COMPLETE) {
+ return;
+ }
+
+ // Cleanups run in reverse order (most recently added first).
+ for (i = this.cleanup_callbacks.length - 1; i >= 0; i--) {
+ try {
+ this.cleanup_callbacks[i].call(this);
+ } catch (e) {
+ this.fail("In cleanup: " + format_exception(e));
+ }
+ }
+
+ // If any step of the test was not run (except those that are not
+ // _supposed_ to run), and no previous error was detected, that is
+ // an error.
+ if (this.phase < this.phases.HAS_RESULT) {
+ for (i = 0; i < this.steps.length; i++) {
+ if (this.steps[i].should_run && !this.steps[i].has_run) {
+ this.fail("Step "+i+" was not run");
+ } else if (!this.steps[i].should_run && this.steps[i].has_run) {
+ this.fail("Step "+i+" should not have run");
+ }
+ }
+ }
+
+ if (this.phase == this.phases.STARTED) {
+ this.message = null;
+ this.status = this.PASS;
+ }
+
+ if (this.properties.expected_fail) {
+ if (this.status === this.PASS) {
+ this.status = this.XPASS;
+ } else if (this.status === this.FAIL) {
+ this.status = this.XFAIL;
+ }
+ }
+
+ this.phase = this.phases.COMPLETE;
+
+ tests.result(this);
+
+};
+
+/** Register |func| as a step function, and return a function that
+ will run |func|'s step when called. The arguments to |func| are
+ whatever the arguments to the callback were, and |this| is
+ |this_obj|, which defaults to the Test object. Useful as an event
+ handler, for instance. */
+Test.prototype.step_func = function(func, this_obj) {
+ var test_this = this;
+ var cb_args = [];
+ if (arguments.length === 1) {
+ this_obj = test_this;
+ }
+
+ // The function returned stashes its arguments in |cb_args|, then
+ // the registered step function uses them to call |func| with the
+ // appropriate arguments. We have to do it this way because
+ // perform_step() doesn't forward its arguments.
+ var stepdata = this.step(function cb_step () {
+ return func.apply(this_obj, cb_args);
+ });
+
+ stepdata.auto_run = false;
+ return function() {
+ cb_args = Array.prototype.slice.call(arguments);
+ return test_this.perform_step(stepdata);
+ };
+};
+
+/** As |step_func|, but the step calls this.done() after |func|
+ returns (regardless of what it returns). |func| may be omitted,
+ in which case the step just calls this.done(). */
+Test.prototype.step_func_done = function(func, this_obj) {
+ var test_this = this;
+ var cb_args = [];
+
+ if (arguments.length <= 1) {
+ this_obj = test_this;
+ }
+ if (!func) {
+ func = function () {};
+ }
+
+ // The function returned stashes its arguments in |cb_args|, then
+ // the registered step function uses them to call |func| with the
+ // appropriate arguments. We have to do it this way because
+ // perform_step() doesn't forward its arguments.
+ var stepdata = this.step(function cb_done_step () {
+ var rv = func.apply(this_obj, cb_args);
+ test_this.done();
+ return rv;
+ });
+
+ stepdata.auto_run = false;
+ return function() {
+ cb_args = Array.prototype.slice.call(arguments);
+ return test_this.perform_step(stepdata);
+ };
+};
+
+/** Returns a function that, if called, will call assert_unreached()
+ inside a perform_step() invocation. Use to set event handlers for
+ events that should _not_ happen. */
+Test.prototype.unreached_func = function unreached_func(description) {
+ var test_this = this;
+ var stepdata = this.step(function unreached_step () {
+ assert_unreached(description);
+ });
+ stepdata.should_run = false;
+ stepdata.auto_run = false;
+
+ return function() { test_this.perform_step(stepdata); };
+};
+
+/** Register |callback| to be called once this test is done. */
+Test.prototype.add_cleanup = function add_cleanup(callback) {
+ this.cleanup_callbacks.push(callback);
+};
+
+/** Treat this test as having timed out. */
+Test.prototype.force_timeout = function force_timeout() {
+ this.message = "Test timed out";
+ this.status = this.FAIL;
+ this.phase = this.phases.HAS_RESULT;
+ this.done();
+};
+
+
+/*
+ * Private implementation logic begins at this point.
+ */
+
+/*
+ * The Tests object is responsible for tracking the complete set of
+ * tests in this file.
+ */
+
+function Tests(output) {
+ this.tests = [];
+ this.num_pending = 0;
+
+ this.all_loaded = false;
+ this.wait_for_finish = false;
+ this.allow_uncaught_exception = false;
+
+ this.test_timeout_length = settings.test_timeout;
+ this.harness_timeout_length = settings.harness_timeout;
+ this.timeout_id = null;
+
+ this.properties = {};
+ this.phase = Test.phases.INITIAL;
+ this.output = output;
+
+ var this_obj = this;
+ phantom.onError = function (message, stack) {
+ if (!tests.allow_uncaught_exception) {
+ this_obj.output.error(message);
+ }
+ if (this_obj.all_done()) {
+ this_obj.complete();
+ }
+ };
+ phantom.page.onConsoleMessage = function (message) {
+ if (!tests.allow_uncaught_exception) {
+ this_obj.output.error("stray console message: " + message);
+ }
+ };
+ this.set_timeout();
+}
+
+Tests.phases = {
+ INITIAL: 0,
+ SETUP: 1,
+ HAVE_TESTS: 2,
+ HAVE_RESULTS: 3,
+ ABANDONED: 4,
+ COMPLETE: 5
+};
+Tests.prototype.phases = Tests.phases;
+
+Tests.prototype.setup = function setup(func, properties) {
+ if (this.phase >= this.phases.HAVE_RESULTS) {
+ return;
+ }
+
+ if (this.phase < this.phases.SETUP) {
+ this.phase = this.phases.SETUP;
+ }
+
+ this.properties = properties;
+
+ for (var p in properties) {
+ if (properties.hasOwnProperty(p)) {
+ var value = properties[p];
+ if (p == "allow_uncaught_exception") {
+ this.allow_uncaught_exception = value;
+ } else if (p == "explicit_done" && value) {
+ this.wait_for_finish = true;
+ } else if (p == "timeout" && value) {
+ this.harness_timeout_length = value;
+ } else if (p == "test_timeout") {
+ this.test_timeout_length = value;
+ }
+ }
+ }
+ this.set_timeout();
+
+ if (func) {
+ try {
+ func();
+ } catch (e) {
+ this.output.error(e);
+ this.phase = this.phases.ABANDONED;
+ }
+ }
+};
+
+Tests.prototype.set_timeout = function set_timeout() {
+ var this_obj = this;
+ clearTimeout(this.timeout_id);
+ if (this.harness_timeout_length !== null) {
+ this.timeout_id = setTimeout(function () { this_obj.timeout(); },
+ this.harness_timeout_length);
+ }
+};
+
+Tests.prototype.timeout = function timeout() {
+ this.output.error("Global timeout expired");
+ for (var i = 0; i < tests.tests.length; i++) {
+ var t = tests.tests[i];
+ if (t.phase < Test.phases.HAS_RESULT) {
+ t.force_timeout();
+ }
+ }
+ this.complete();
+};
+
+Tests.prototype.end_wait = function end_wait() {
+ this.wait_for_finish = false;
+ if (this.all_done()) {
+ this.complete();
+ }
+};
+
+Tests.prototype.push = function push(test)
+{
+ if (this.phase < this.phases.HAVE_TESTS) {
+ this.phase = this.phases.HAVE_TESTS;
+ }
+ this.num_pending++;
+ this.tests.push(test);
+};
+
+Tests.prototype.all_done = function all_done() {
+ return (this.tests.length > 0 &&
+ this.all_loaded &&
+ this.num_pending === 0 &&
+ !this.wait_for_finish);
+};
+
+Tests.prototype.result = function result(test) {
+ if (this.phase < this.phases.HAVE_RESULTS) {
+ this.phase = this.phases.HAVE_RESULTS;
+ }
+ this.num_pending--;
+ this.output.result(test);
+ if (this.all_done()) {
+ this.complete();
+ } else {
+ setTimeout(this.run_tests.bind(this), 0);
+ }
+};
+
+Tests.prototype.run_tests = function run_tests() {
+ if (this.phase >= this.phases.COMPLETE) {
+ return;
+ }
+ if (this.all_done() || this.phase >= this.phases.ABANDONED) {
+ this.complete();
+ return;
+ }
+ for (var i = 0; i < this.tests.length; i++) {
+ var t = this.tests[i];
+ if (t.phase < t.phases.STARTED && t.steps.length > 0) {
+ for (var j = 0; j < t.steps.length; j++) {
+ if (t.steps[j].auto_run) {
+ t.perform_step(t.steps[j]);
+ }
+ }
+ // We will come back here via the setTimeout in
+ // Tests.prototype.result.
+ break;
+ }
+ }
+};
+
+Tests.prototype.begin = function begin() {
+ this.all_loaded = true;
+ this.output.begin(this.tests.length, this.phase);
+ this.run_tests();
+ if (this.all_done()) {
+ this.complete();
+ }
+};
+
+Tests.prototype.complete = function complete() {
+ var i, x;
+
+ if (this.phase === this.phases.COMPLETE) {
+ return;
+ }
+ for (i = 0; i < this.tests.length; i++) {
+ this.tests[i].done();
+ }
+
+ this.phase = this.phases.COMPLETE;
+ this.output.complete(this);
+};
+
+/*
+ * The Output object is responsible for reporting the status of each
+ * test. For PhantomJS, output is much simpler than for the W3C
+ * harness; we basically just log things to the console as
+ * appropriate. The output format is meant to be compatible with
+ * TAP (http://testanything.org/tap-specification.html).
+ */
+
+function Output(fp, verbose) {
+ this.fp = fp;
+ this.verbose = verbose;
+ this.failed = false;
+}
+
+Output.prototype.begin = function begin(n, phase) {
+ if (phase === Tests.phases.ABANDONED) {
+ this.fp.write("1..0 # SKIP: setup failed\n");
+ } else {
+ this.fp.write("1.." + n + "\n");
+ }
+};
+
+Output.prototype.diagnostic = function diagnostic(message, is_info) {
+ var fp = this.fp;
+ var prefix = "# ";
+ if (is_info) {
+ prefix = "## ";
+ }
+ message.split("\n").forEach(function (line) {
+ fp.write(prefix + line + "\n");
+ });
+};
+
+Output.prototype.error = function error(message) {
+ this.diagnostic("ERROR: " + message);
+ this.failed = true;
+};
+
+Output.prototype.info = function info(message) {
+ this.diagnostic(message, true);
+};
+
+Output.prototype.result = function result(test) {
+ if (test.message) {
+ this.diagnostic(test.message);
+ }
+ var prefix, directive = "";
+ switch (test.status) {
+ case Test.PASS: prefix = "ok "; break;
+ case Test.FAIL: prefix = "not ok "; break;
+ case Test.XPASS: prefix = "ok "; directive = " # TODO"; break;
+ case Test.XFAIL: prefix = "not ok "; directive = " # TODO"; break;
+ case Test.NOTRUN: prefix = "ok "; directive = " # SKIP"; break;
+ default:
+ this.error("Unrecognized test status " + test.status);
+ prefix = "not ok ";
+ }
+ if ((prefix === "not ok " && directive !== " # TODO") ||
+ (prefix === "ok " && directive === " # TODO")) {
+ this.failed = true;
+ }
+ this.fp.write(prefix + test.number + " " + test.name + directive + "\n");
+};
+
+Output.prototype.complete = function complete(tests) {
+ phantom.exit(this.failed ? 1 : 0);
+};
+
+/*
+ * Utilities.
+ */
+
+function expose(fn, name) {
+ window[name] = fn;
+}
+
+/** This function is not part of the public API, but its
+ *behavior* is part of the contract of several assert_* functions. */
+function same_value(x, y) {
+ if (x === y) {
+ // Distinguish +0 and -0
+ if (x === 0 && y === 0) {
+ return 1/x === 1/y;
+ }
+ return true;
+ } else {
+ // NaN !== _everything_, including another NaN.
+ // Make it same_value as itself.
+ if (x !== x) {
+ return y !== y;
+ }
+ // Compare Date and RegExp by value.
+ if (x instanceof Date) {
+ return y instanceof Date && x.getTime() === y.getTime();
+ }
+ if (x instanceof RegExp) {
+ return y instanceof RegExp && x.toString() === y.toString();
+ }
+ return false;
+ }
+}
+
+/** Similarly, this function's behavior is part of the contract of
+ assert_deep_equals. (These are the things for which it will just
+ call same_value rather than doing a recursive property comparison.) */
+function is_primitive_value(val) {
+ return (val === undefined || val === null || typeof val !== 'object' ||
+ val instanceof Date || val instanceof RegExp);
+}
+
+var names_used = {};
+function test_name(func, name) {
+ var n, c;
+
+ if (name)
+ ;
+ else if (func && func.displayName)
+ name = func.displayName;
+ else if (func && func.name)
+ name = func.name;
+ else
+ name = "test";
+
+ n = name;
+ c = 0;
+ while (n in names_used) {
+ n = name + "." + c.toString();
+ c += 1;
+ }
+ return n;
+}
+
+function AssertionError(message) {
+ this.message = message;
+}
+
+AssertionError.prototype.toString = function toString() {
+ return this.message;
+};
+
+function assert(expected_true, name, description, error, substitutions) {
+ if (expected_true !== true) {
+ throw new AssertionError(make_message(
+ name, description, error, substitutions));
+ } else if (output.verbose >= 4) {
+ output.info(make_message(name, description, error, substitutions));
+ }
+}
+
+function make_message(function_name, description, error, substitutions) {
+ var p, message;
+
+ for (p in substitutions) {
+ if (substitutions.hasOwnProperty(p)) {
+ substitutions[p] = format_value(substitutions[p]);
+ }
+ }
+
+ if (description) {
+ description += ": ";
+ } else {
+ description = "";
+ }
+
+ return (function_name + ": " + description +
+ error.replace(/\$\{[^}]+\}/g, function (match) {
+ return substitutions[match.slice(2,-1)];
+ }));
+}
+
+function format_value(val, seen) {
+ if (seen === undefined)
+ seen = [];
+
+ var s;
+ function truncate(s, len) {
+ if (s.length > len) {
+ return s.slice(-3) + "...";
+ }
+ return s;
+ }
+
+ switch (typeof val) {
+ case "number":
+ // In JavaScript, -0 === 0 and String(-0) == "0", so we have to
+ // special-case.
+ if (val === -0 && 1/val === -Infinity) {
+ return "-0";
+ }
+ // falls through
+ case "boolean":
+ case "undefined":
+ return String(val);
+
+ case "string":
+ // Escape ", \, all C0 and C1 control characters, and
+ // Unicode's LINE SEPARATOR and PARAGRAPH SEPARATOR.
+ // The latter two are the only characters above U+009F
+ // that may not appear verbatim in a JS string constant.
+ val = val.replace(/["\\\u0000-\u001f\u007f-\u009f\u2028\u2029]/g,
+ function (c) {
+ switch (c) {
+ case "\b": return "\\b";
+ case "\f": return "\\f";
+ case "\n": return "\\n";
+ case "\r": return "\\r";
+ case "\t": return "\\t";
+ case "\v": return "\\v";
+ case "\\": return "\\\\";
+ case "\"": return "\\\"";
+ default:
+ // We know by construction that c is
+ // a single BMP character.
+ c = c.charCodeAt(0);
+ if (c < 0x0080) {
+ return "\\x" +
+ ("00" + c.toString(16)).slice(-2);
+ } else {
+ return "\\u" +
+ ("0000" + c.toString(16)).slice(-4);
+ }
+ }
+ });
+ return '"' + val + '"';
+
+ case "object":
+ if (val === null) {
+ return "null";
+ }
+ if (seen.indexOf(val) >= 0) {
+ return "";
+ }
+ seen.push(val);
+
+ if (Array.isArray(val)) {
+ return "[" + val.map(function (x) {
+ return format_value(x, seen);
+ }).join(", ") + "]";
+ }
+
+ s = String(val);
+ if (s != "[object Object]") {
+ return truncate(s, 60);
+ }
+ return "{ " + Object.keys(val).map(function (k) {
+ return format_value(k, seen) + ": " + format_value(val[k], seen);
+ }).join(", ") + "}";
+
+ default:
+ return typeof val + ' "' + truncate(String(val), 60) + '"';
+ }
+}
+
+function format_exception (e) {
+ var message = (typeof e === "object" && e !== null) ? e.message : e;
+ if (typeof e.stack != "undefined" && typeof e.message == "string") {
+ // Prune the stack. This knows the format of WebKit's stack traces.
+ var stack = e.stack.split("\n");
+ var lo, hi;
+ // We do not need to hear about initial lines naming the
+ // assertion function.
+ for (lo = 0; lo < stack.length; lo++) {
+ if (!/^assert(?:_[a-z0-9_]+)?@.*?testharness\.js:/
+ .test(stack[lo])) {
+ break;
+ }
+ }
+ // We do not need to hear about how we got _to_ the test function.
+ // The caller of the test function is guaranteed to have "_step" in
+ // its name.
+ for (hi = lo; hi < stack.length; hi++) {
+ if (/^[a-z_]+_step.*?testharness\.js:/.test(stack[hi])) {
+ break;
+ }
+ }
+ if (lo < stack.length && lo < hi) {
+ stack = stack.slice(lo, hi);
+ }
+ message += "\n";
+ message += stack.join("\n");
+ }
+ return message;
+}
+
+function process_command_line(sys) {
+ function usage(error) {
+ sys.stderr.write("error: " + error + "\n");
+ sys.stderr.write("usage: " + sys.args[0] +
+ " [--verbose=N] test_script.js ...\n");
+ }
+ var args = { verbose: -1,
+ test_script: "" };
+
+ for (var i = 1; i < sys.args.length; i++) {
+ if (sys.args[i].length === 0) {
+ usage("empty argument is not meaningful");
+ return args;
+ }
+ if (sys.args[i][0] !== '-') {
+ args.test_script = sys.args[i];
+ break;
+ }
+ var n = "--verbose=".length;
+ var v = sys.args[i].slice(0, n);
+ var a = sys.args[i].slice(n);
+ if (v === "--verbose=" && /^[0-9]+$/.test(a)) {
+ if (args.verbose === -1) {
+ args.verbose = parseInt(a, 10);
+ continue;
+ } else {
+ usage("--verbose specified twice");
+ return args;
+ }
+ }
+ usage("unrecognized option " + format_value(sys.args[i]));
+ return args;
+ }
+
+ if (args.test_script === "") {
+ usage("no test script specified");
+ return args;
+ }
+
+ if (args.verbose === -1) {
+ args.verbose = 0;
+ }
+
+ return args;
+}
+
+/*
+ * Global state
+ */
+
+var settings = {
+ harness_timeout: 5000,
+ test_timeout: null
+};
+
+var sys = require('system');
+var fs = require('fs');
+var args = process_command_line(sys);
+
+if (args.test_script === "") {
+ // process_command_line has already issued an error message.
+ phantom.exit(2);
+} else {
+ // Reset the library paths for injectJs and require to the
+ // directory containing the test script, so relative imports work
+ // as expected. Unfortunately, phantom.libraryPath is not a
+ // proper search path -- it can only hold one directory at a time.
+ // require.paths has no such limitation.
+ var test_script = fs.absolute(args.test_script);
+ phantom.libraryPath = test_script.slice(0,
+ test_script.lastIndexOf(fs.separator));
+ require.paths.push(phantom.libraryPath);
+
+ // run-tests.py sets these environment variables to the base URLs
+ // of its HTTP and HTTPS servers.
+ expose(sys.env['TEST_HTTP_BASE'], 'TEST_HTTP_BASE');
+ expose(sys.env['TEST_HTTPS_BASE'], 'TEST_HTTPS_BASE');
+
+ var output = new Output(sys.stdout, args.verbose);
+ var tests = new Tests(output);
+
+ // This evaluates the test script synchronously.
+ // Any errors should be caught by our onError hook.
+ phantom.injectJs(test_script);
+
+ tests.begin();
+}
+
+})();
diff --git a/third_party/phantomjs/test/writing-tests.md b/third_party/phantomjs/test/writing-tests.md
new file mode 100644
index 00000000000..c04f27beaa0
--- /dev/null
+++ b/third_party/phantomjs/test/writing-tests.md
@@ -0,0 +1,596 @@
+# How to Write Tests for PhantomJS
+
+PhantomJS's automated tests are `.js` files located in subdirectories
+of this directory. The test runner, [`run-tests.py`](run-tests.py),
+executes each as a PhantomJS controller script. (Not all
+subdirectories of this directory contain tests; the authoritative list
+of test subdirectories is in
+[the `TESTS` variable in `run-tests.py`](run-tests.py#L26).)
+
+In addition to all of the usual PhantomJS API, these scripts have
+access to a special testing API, loosely based on
+[W3C testharness.js](https://github.com/w3c/testharness.js) and
+defined in [`testharness.js`](testharness.js) in this directory. They
+also have access to HTTP and HTTPS servers on `localhost`, which serve
+the files in the [`www`](www) directory.
+
+## The Structure of Test Scripts
+
+Test scripts are divided into _subtests_. There are two kinds of
+subtest: synchronous and asynchronous. The only difference is that a
+synchronous subtest consists of a single JavaScript function (plus
+anything it calls) and is considered to be complete when that function
+returns. An asynchronous subtest, however, consists of many
+JavaScript functions; these functions are referred to as _steps_. One
+step will be invoked to start the subtest, and the others are called
+in response to events. Eventually one of the steps will indicate that
+the subtest is complete. (The single function used for a synchronous
+subtest is also referred to as a step, when the difference doesn't
+matter.)
+
+All of the code in a test script should be part of a subtest, or part
+of a setup function (see below). You may define helper functions at
+top level, so long as they are only ever _called_ from subtests. You
+may also initialize global variables at top level if this
+initialization cannot possibly fail, e.g. with constant data or with
+`require` calls for core PhantomJS modules.
+
+The testing API is visible to a test script as a collection of global
+functions and variables, documented below.
+
+A subtest is considered to have failed if any of its steps throws a
+JavaScript exception, if an `unreached_func` is called, if the
+per-test timeout expires, or if `done` is called before all of its
+steps have run. It is considered to succeed if `done` is called
+(explicitly or implicitly) after all of its steps have run to
+completion. Normally, you should use the assertion functions to detect
+failure conditions; these ensure that clear diagnostic information is
+printed when a test fails.
+
+Subtests are executed strictly in the order they appear in the file,
+even if some of them are synchronous and some are asynchronous. The
+order of steps *within* an asynchronous subtest, however, may be
+unpredictable. Also, subtests do not begin to execute until after all
+top-level code in the file has been evaluated.
+
+Some anomalous conditions are reported not as a failure, but as an
+"error". For instance, if PhantomJS crashes during a test run, or if
+an exception is thrown from outside a step, that is an error, and the
+entire test will be abandoned.
+
+**WARNING:** The harness will become confused if any function passed
+as the `func` argument to `test`, `async_test`, `generate_tests`,
+`Test.step`, `Test.step_func`, `Test.step_func_done`, or
+`Test.add_cleanup` has a name that ends with `_step`.
+
+### Accessing the HTTP and HTTPS Test Servers
+
+The global variables `TEST_HTTP_BASE` and `TEST_HTTPS_BASE` are the
+base URLs of the test HTTP and HTTPS servers, respectively. Their
+values are guaranteed to match the regex `/https?:\/\/localhost:[0-9]+\//`,
+but the port number is dynamically assigned for each test run, so you
+must not hardwire it.
+
+### Synchronous Subtests
+
+There are two functions for defining synchronous subtests.
+
+* `test(func, name, properties)`
+
+ Run `func` as a subtest; the subtest is considered to be complete as
+ soon as it returns. `name` is an optional descriptive name for the
+ subtest. `func` will be called with no arguments, and `this` set to
+ a `Test` object (see below). `properties` is an optional object
+ containing properties to apply to the test. Currently there are
+ three meaningful properties; any other keys in the `properties`
+ object are ignored:
+
+ * `timeout` - Maximum amount of time the subtest is allowed to run, in
+ milliseconds. If the timeout expires, the subtest will be
+ considered to have failed.
+
+ * `expected_fail`: If truthy, this subtest is expected to fail. It will
+ still be run, but a failure will be considered "normal" and the
+ overall test will be reported as successful. Conversely, if the
+ subtest *succeeds* that is considered "abnormal" and the overall
+ test will be reported as failing.
+
+ * `skip`: If truthy, this subtest will not be run at all, will be
+ reported as "skipped" rather than "succeeded" or "failed", and
+ will not affect the overall outcome of the test. Use `skip` only
+ when `expected_fail` will not do—for instance, when a test
+ provokes a PhantomJS crash (there currently being no way to label
+ a crash as "expected").
+
+ `test` returns the same `Test` object that is available as `this`
+ within `func`.
+
+* `generate_tests(func, args, properties)`
+
+ Define a group of synchronous subtests, each of which will call
+ `func`, but with different arguments. This is easiest to explain by
+ example:
+
+ generate_tests(assert_equals, [
+ ["Sum one and one", 1 + 1, 2],
+ ["Sum one and zero", 1 + 0, 1]
+ ]);
+
+ ... is equivalent to ...
+
+ test(function() {assert_equals(1+1, 2)}, "Sum one and one");
+ test(function() {assert_equals(1+0, 1)}, "Sum one and zero");
+
+ Of course `func` may be as complicated as you like, and there is no
+ limit either to the number of arguments passed to each subtest, or
+ to the number of subtests.
+
+ The `properties` argument may be a single properties object, which
+ will be applied uniformly to all the subtests, or an array of the
+ same length as `args`, containing appropriate property objects for
+ each subtest.
+
+ `generate_tests` returns no value.
+
+### Asynchronous Subtests
+
+An asynchronous subtest consists of one or more _step_ functions, and
+unlike a synchronous subtest, it is not considered to be complete until
+the `done` method is called on its `Test` object. When this happens,
+if any of the step functions have not been executed, the subtest is a
+failure.
+
+Asynchronous subtests are defined with the `async_test` function, which
+is almost the same as `test`:
+
+* `async_test(func, name, properties)`
+
+ Define an asynchronous subtest. The arguments and their
+ interpretation are the same as for `test`, except that `func` is
+ optional, and the subtest is *not* considered to be complete after
+ `func` returns; `func` (if present) is only the first step of the
+ subtest. Additional steps may be defined, either within `func` or
+ outside the call to `async_test`, by use of methods on the `Test`
+ object that is returned (and available as `this` within `func`).
+
+ Normally, an asynchronous subtest's first step will set up whatever
+ is being tested, and define the remainder of the steps, which will
+ be run in response to events.
+
+### Test Object Methods
+
+These methods are provided by the `Test` object which is returned by
+`test` and `async_test`, and available as `this` within step
+functions.
+
+* `Test.step(func[, this_obj, ...])`
+
+ Queue one step of a subtest. `func` will eventually be called, with
+ `this` set to `this_obj`, or (if `this_obj` is null or absent) to
+ the `Test` object. Any further arguments will be passed down to
+ `func`. `func` will _not_ be called if a previous step has failed.
+
+ Do not use this function to define steps that should run in response
+ to event callbacks; only steps that should be automatically run by
+ the test harness.
+
+ The object returned by this function is private. Please let us know
+ if you think you need to use it.
+
+* `Test.done()`
+
+ Indicate that this subtest is complete. One, and only one, step of
+ an asynchronous subtest must call this function, or the subtest will
+ never complete (and eventually it will time out).
+
+ If an asynchronous subtest has several steps, but not all of them
+ have run when `done` is called, the subtest is considered to have
+ failed.
+
+* `Test.step_func(func[, this_obj])`
+
+ Register `func` as a step that will *not* be run automatically by
+ the test harness. Instead, the function *returned* by this function
+ (the "callback") will run `func`'s step when it is called.
+ (`func`'s step must still somehow get run before `done` is called,
+ or the subtest will be considered to have failed.)
+
+ `this_obj` will be supplied as `this` to `func`; if omitted, it
+ defaults to the `Test` object. Further arguments are ignored.
+ However, `func` will receive all of the arguments passed to the
+ callback, and the callback will return whatever `func` returns.
+
+ This is the normal way to register a step that should run in
+ response to an event. For instance, here is a minimal test of a
+ page load:
+
+ async_test(function () {
+ var p = require('webpage').create();
+ p.open(TEST_HTTP_BASE + 'hello.html',
+ this.step_func(function (status) {
+ assert_equals(status, 'success');
+ this.done();
+ }));
+ });
+
+ This also serves to illustrate why asynchronous subtests may be
+ necessary: this subtest is not complete when its first step returns,
+ only when the `onLoadFinished` event fires.
+
+* `Test.step_func_done([func[, this_obj]])`
+
+ Same as `Test.step_func`, but the callback additionally calls `done`
+ after `func` returns. `func` may be omitted, in which case the
+ callback just calls `done`.
+
+ The example above can be shortened to
+
+ async_test(function () {
+ var p = require('webpage').create();
+ p.open(TEST_HTTP_BASE + 'hello.html',
+ this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ }));
+ });
+
+* `Test.unreached_func([description])`
+
+ Returns a function that, if called, will call
+ `assert_unreached(description)` inside a step. Use this to set
+ event handlers for events that should _not_ happen. You need to use
+ this method instead of `step_func(function () { assert_unreached(); })`
+ so the step is properly marked as expected _not_ to run; otherwise
+ the test will fail whether or not the event happens.
+
+ A slightly more thorough test of a page load might read
+
+ async_test(function () {
+ var p = require('webpage').create();
+ p.onResourceError = this.unreached_func("onResourceError");
+ p.open(TEST_HTTP_BASE + 'hello.html',
+ this.step_func_done(function (status) {
+ assert_equals(status, 'success');
+ }));
+ });
+
+* `Test.add_cleanup(func)`
+
+ Register `func` to be called (with no arguments, and `this` set to
+ the `Test` object) when `done` is called, whether or not the subtest
+ has failed. Use this to deallocate persistent resources or undo
+ changes to global state. For example, a subtest that uses a scratch
+ file might read
+
+ test(function () {
+ var fs = require('fs');
+ var f = fs.open('scratch_file', 'w');
+ this.add_cleanup(function () {
+ f.close();
+ fs.remove('scratch_file');
+ });
+
+ // ... more test logic here ...
+ });
+
+ If the step function had simply deleted the file at its end, the
+ file would only get deleted when the test succeeds. This example
+ could be rewritten using `try ... finally ...`, but that will not
+ work for asynchronous tests.
+
+* `Test.fail(message)`
+
+ Explicitly mark this subtest has having failed, with failure message
+ `message`. You should not normally need to call this function yourself.
+
+* `Test.force_timeout()`
+
+ Explicitly mark this subtest as having failed because its timeout has
+ expired. You should not normally need to call this function yourself.
+
+### Test Script-Wide Setup
+
+All of the subtests of a test script are normally run, even if one of
+them fails. Complex tests may involve complex initialization actions
+that may fail, in which case the entire test script should be aborted.
+There is also a small amount of harness-wide configuration that is
+possible. Both these tasks are handled by the global function
+`setup`.
+
+* `setup([func], [properties])`
+
+ One may specify either `func` or `properties` or both, but if both
+ are specified, `func` must be first.
+
+ `func` is called immediately, with no arguments. If it throws an
+ exception, the entire test script is considered to have failed and
+ none of the subtests are run.
+
+ `properties` is an object containing one or more of the following
+ keys:
+
+ * `explicit_done`: Wait for the global function `done` (not to be
+ confused with `Test.done` to be called, before declaring the test
+ script complete.
+
+ * `allow_uncaught_exception`: Don't treat an uncaught exception from
+ non-test code as an error. (Exceptions thrown out of test steps
+ are still errors.)
+
+ * `timeout`: Overall timeout for the test script, in milliseconds.
+ The default is five seconds. Note that `run-tests.py` imposes a
+ "backstop" timeout itself; if you raise this timeout you may also
+ need to raise that one.
+
+ * `test_timeout`: Default timeout for individual subtests. This may
+ be overridden by the `timeout` property on a specific subtest.
+ The default is not to have a timeout for individual subtests.
+
+
+### Assertions
+
+Whenever possible, use these functions to detect failure conditions.
+All of them either throw a JavaScript exception (when the test fails)
+or return no value (when the test succeeds). All take one or more
+values to be tested, and an optional _description_. If present, the
+description should be a string to be printed to clarify why the test
+has failed. (The assertions all go to some length to print out values
+that were not as expected in a clear format, so descriptions will
+often not be necessary.)
+
+* `assert_is_true(value[, description])`
+
+ `value` must be strictly equal to `true`.
+
+* `assert_is_false(value[, description])`
+
+ `value` must be strictly equal to `false`.
+
+* `assert_equals(actual, expected[, description])`
+
+ `actual` and `expected` must be shallowly, strictly equal. The
+ criterion used is `===` with the following exceptions:
+
+ * If `x === y`, but one of them is `+0` and the other is `-0`, they
+ are *not* considered equal.
+
+ * If `x !== y`, but one of the following cases holds, they *are*
+ considered equal:
+ * both are `NaN`
+ * both are `Date` objects and `x.getTime() === y.getTime()`
+ * both are `RegExp` objects and `x.toString() === y.toString()`
+
+* `assert_not_equals(actual, expected[, description])`
+
+ `actual` and `expected` must *not* be shallowly, strictly equal,
+ using the same criterion as `assert_equals`.
+
+* `assert_deep_equals(actual, expected[, description])`
+
+ If `actual` and `expected` are not objects, or if they are
+ `Date` or `RegExp` objects, this is the same as `assert_equals`.
+
+ Objects that are not `Date` or `RegExp` must have the same set of
+ own-properties (including non-enumerable own-properties), and each
+ pair of values for with each own-property must be `deep_equals`,
+ recursively. Prototype chains are ignored. Back-references are
+ detected and ignored; they will not cause an infinite recursion.
+
+* `assert_approx_equals(actual, expected, epsilon[, description])`
+
+ The absolute value of the difference between `actual` and `expected`
+ must be no greater than `epsilon`. All three arguments must be
+ primitive numbers.
+
+* `assert_less_than(actual, expected[, description])`
+* `assert_less_than_equal(actual, expected[, description])`
+* `assert_greater_than(actual, expected[, description])`
+* `assert_greater_than_equal(actual, expected[, description])`
+
+ `actual` and `expected` must be primitive numbers, and `actual` must
+ be, respectively: less than, less than or equal to, greater than,
+ greater than or equal to `expected`.
+
+* `assert_in_array(value, array[, description])`
+
+ `array` must contain `value` according to `Array.indexOf`.
+
+* `assert_regexp_match(string, regexp[, description])`
+
+ The regular expression `regexp` must match the string `string`,
+ according to `RegExp.test()`.
+
+* `assert_regexp_not_match(string, regexp[, description])`
+
+ The regular expression `regexp` must *not* match the string `string`,
+ according to `RegExp.test()`.
+
+* `assert_type_of(object, type[, description])`
+
+ `typeof object` must be strictly equal to `type`.
+
+* `assert_instance_of(object, type[, description])`
+
+ `object instanceof type` must be true.
+
+* `assert_class_string(object, expected[, description])`
+
+ `object` must have the class string `expected`. The class string is
+ the second word in the string returned by `Object.prototype.toString`:
+ for instance, `({}).toString.call([])` returns `[object Array]`, so
+ `[]`'s class string is `Array`.
+
+* `assert_own_property(object, name[, description])`
+
+ `object` must have an own-property named `name`.
+
+* `assert_inherits(object, name[, description])`
+
+ `object` must inherit a property named `name`; that is,
+ `name in object` must be true but `object.hasOwnProperty(name)`
+ must be false.
+
+* `assert_no_property(object, name[, description])`
+
+ `object` must neither have nor inherit a property named `name`.
+
+* `assert_readonly(object, name[, description])`
+
+ `object` must have an own-property named `name` which is marked
+ read-only (according to `Object.getOwnPropertyDescriptor`).
+
+* `assert_throws(code, func[, description])`
+
+ `func` must throw an exception described by `code`. `func` is
+ called with no arguments and no `this` (you can supply arguments
+ using `bind`). `code` can take one of two forms. If it is a
+ string, the thrown exception must either stringify to that string,
+ or it must be a DOMException whose `name` property is that string.
+ Otherwise, `code` must be an object with one or more of the
+ properties `code`, `name`, and `message`; whichever properties are
+ present must be `===` to the corresponding properties of the
+ exception. As a special case, if `message` is present in the
+ `code` object but *not* on the exception object, and the exception
+ stringifies to the same string as `message`, that's also considered
+ valid.
+
+ `assert_throws` cannot be used to catch the exception thrown by any
+ of the other `assert_*` functions when they fail. (You might be
+ looking for the `expected_fail` property on a subtest.)
+
+* `assert_unreached([description])`
+
+ Control flow must not reach the point where this assertion appears.
+ (In other words, this assertion fails unconditionally.)
+
+## Test Annotations
+
+Some tests need to be run in a special way. You can indicate this to
+the test runner with _annotations_. Annotations are lines in the test
+script that begin with the three characters '`//!`'. They must be all
+together at the very top of the script; `run-tests.py` stops parsing
+at the first line that does _not_ begin with the annotation marker.
+
+Annotation lines are split into _tokens_ in a shell-like fashion,
+which means they are normally separated by whitespace, but you can use
+backslashes or quotes to put whitespace inside a token. Backslashes
+are significant inside double quotes, but not inside single quotes.
+There can be any number of tokens on a line. Everything following an
+unquoted, un-backslashed `#` is discarded. (The exact algorithm is
+[`shlex.split`](https://docs.python.org/2/library/shlex.html), in
+`comments=True`, `posix=True` mode.)
+
+These are the recognized tokens:
+
+* `no-harness`: Run this test script directly; the testing API
+ described above will not be available. This is necessary to
+ test PhantomJS features that `testharness.js` reserves for its
+ own use, such as `phantom.onError` and `phantom.exit`. No-harness
+ tests will usually also be output-expectations tests (see below)
+ but this is not required.
+
+* `snakeoil`: Instruct PhantomJS to accept the self-signed
+ certificate presented by the HTTPS test server.
+
+* `timeout:` The next token on the line must be a positive
+ floating-point number. `run-tests.py` will kill the PhantomJS
+ process, and consider the test to have failed, if it runs for longer
+ than that many seconds. The default timeout is seven seconds.
+
+ This timeout is separate from the per-subtest and global timeouts
+ enforced by the testing API. It is intended as a backstop against
+ bugs which cause PhantomJS to stop executing the controller script.
+ (In no-harness mode, it's the only timeout, unless you implement
+ your own.)
+
+* `phantomjs:` All subsequent tokens on the line will be passed as
+ command-line arguments to PhantomJS, before the controller script.
+ Note that `run-tests.py` sets several PhantomJS command line options
+ itself; you must take care not to do something contradictory.
+
+* `script:` All subsequent tokens on the line will be passed as
+ command-line arguments to the *controller script*; that is, they
+ will be available in
+ [`system.args`](http://phantomjs.org/api/system/property/args.html).
+ Note that your controller script will only be `system.args[0]` if
+ you are using no-harness mode, and that `run-tests.py` may pass
+ additional script arguments of its own.
+
+* `stdin:` All subsequent tokens on the line will be concatenated
+ (separated by a single space) and fed to PhantomJS's standard input,
+ with a trailing newline. If this token is used more than once,
+ that produces several lines of input. If this token is not used at
+ all, standard input will read as empty.
+
+* `unsupported:` The whole file will be skipped.
+ This directive should be used to notify that the functionality is not yet
+ implemented by Puppeteer. Tests could be run ignoring this directive
+ with the `--run-unsupported` flag.
+
+## Output-Expectations Tests
+
+Normally, `run-tests.py` expects each test to produce parseable output
+in the [TAP](http://testanything.org/tap-specification.html) format.
+This is too inflexible for testing things like `system.stdout.write`,
+so there is also a mode in which you specify exactly what output the
+test should produce, with additional annotations. Output-expectations
+tests are not *required* to be no-harness tests, but the only reason
+to use this mode for harness tests would be to test the harness
+itself, and it's not sophisticated enough for that.
+
+Using any of the following annotations makes a test an
+output-expectations test:
+
+* `expect-exit:` The next token on the line must be an integer. If it
+ is nonnegative, the PhantomJS process is expected to exit with that
+ exit code. If it is negative, the process is expected to be
+ terminated by the signal whose number is the absolute value of the
+ token. (For instance, `expect-exit: -15` for a test that is
+ expected to hit the backstop timeout.)
+
+* `expect-stdout:` All subsequent tokens on the line are concatenated,
+ with spaces in between, and a newline is appeneded. The PhantomJS
+ process is expected to emit that text, verbatim, on its standard
+ output. If used more than once, that produces multiple lines of
+ expected output.
+
+* `expect-stderr:` Same as `expect-stdout`, but the output is expected
+ to appear on standard error.
+
+* `expect-exit-fails`, `expect-stdout-fails`, `expect-stderr-fails`:
+ The corresponding test (of the exit code, stdout, or stderr) is
+ expected to fail.
+
+If some but not all of these annotations are used in a test, the
+omitted ones default to exit code 0 (success) and no output on their
+respective streams.
+
+## Test Server Modules
+
+The HTTP and HTTPS servers exposed to the test suite serve the static
+files in the `www` subdirectory with URLs corresponding to their paths
+relative to that directory. If you need more complicated server
+behavior than that, you can write custom Python code that executes
+when the server receives a request. Any `.py` file below the `www`
+directory will be invoked to provide the response for that path
+*without* the `.py` suffix. (For instance, `www/echo.py` provides
+responses for `TEST_HTTP_BASE + 'echo'`.) Such files must define a
+top-level function named `handle_request`. This function receives a
+single argument, which is an instance of a subclass of
+[`BaseHTTPServer.BaseHTTPRequestHandler`](https://docs.python.org/2/library/basehttpserver.html#BaseHTTPServer.BaseHTTPRequestHandler).
+The request headers and body (if any) may be retrieved from this
+object. The function must use the `send_response`, `send_header`, and
+`end_headers` methods of this object to generate HTTP response
+headers, and then return a *file-like object* (**not** a string)
+containing the response body. The function is responsible for
+generating appropriate `Content-Type` and `Content-Length` headers;
+the server framework does not do this automatically.
+
+Test server modules cannot directly cause a test to fail; the server
+does not know which test is responsible for any given request. If
+there is something wrong with a request, generate an HTTP error
+response; then write your test to fail if it receives an error
+response.
+
+Python exceptions thrown by test server modules are treated as
+failures *of the testsuite*, but they are all attributed to a virtual
+"HTTP server errors" test.
diff --git a/third_party/phantomjs/test/www/__init__.py b/third_party/phantomjs/test/www/__init__.py
new file mode 100644
index 00000000000..b2858867a75
--- /dev/null
+++ b/third_party/phantomjs/test/www/__init__.py
@@ -0,0 +1,2 @@
+# This file makes test/www/ into a "package" so that
+# importing Python response hooks works correctly.
diff --git a/third_party/phantomjs/test/www/delay.py b/third_party/phantomjs/test/www/delay.py
new file mode 100644
index 00000000000..9653499eb8b
--- /dev/null
+++ b/third_party/phantomjs/test/www/delay.py
@@ -0,0 +1,15 @@
+import cStringIO as StringIO
+import urlparse
+import time
+
+def handle_request(req):
+ url = urlparse.urlparse(req.path)
+ delay = float(int(url.query))
+ time.sleep(delay / 1000) # argument is in milliseconds
+
+ body = "OK ({}ms delayed)\n".format(delay)
+ req.send_response(200)
+ req.send_header('Content-Type', 'text/plain')
+ req.send_header('Content-Length', str(len(body)))
+ req.end_headers()
+ return StringIO.StringIO(body)
diff --git a/third_party/phantomjs/test/www/echo.py b/third_party/phantomjs/test/www/echo.py
new file mode 100644
index 00000000000..8a7ba2d9693
--- /dev/null
+++ b/third_party/phantomjs/test/www/echo.py
@@ -0,0 +1,29 @@
+import json
+import urlparse
+import cStringIO as StringIO
+
+def handle_request(req):
+ url = urlparse.urlparse(req.path)
+ headers = {}
+ for name, value in req.headers.items():
+ headers[name] = value.rstrip()
+
+ d = dict(
+ command = req.command,
+ version = req.protocol_version,
+ origin = req.client_address,
+ url = req.path,
+ path = url.path,
+ params = url.params,
+ query = url.query,
+ fragment = url.fragment,
+ headers = headers,
+ postdata = req.postdata
+ )
+ body = json.dumps(d, indent=2) + '\n'
+
+ req.send_response(200)
+ req.send_header('Content-Type', 'application/json')
+ req.send_header('Content-Length', str(len(body)))
+ req.end_headers()
+ return StringIO.StringIO(body)
diff --git a/third_party/phantomjs/test/www/frameset/frame1-1.html b/third_party/phantomjs/test/www/frameset/frame1-1.html
new file mode 100644
index 00000000000..c80ec458368
--- /dev/null
+++ b/third_party/phantomjs/test/www/frameset/frame1-1.html
@@ -0,0 +1,8 @@
+
+
+ frame1-1
+
+
+