The Tor Browser: addon-sdk/source/test/test-panel.js@129ffea94266 (annotated)

addon-sdk/source/test/test-panel.js@129ffea94266 (annotated)

addon-sdk/source/test/test-panel.js

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 'use strict';
 module.metadata = {
   'engines': {
     'Firefox': '*'
   }
 };
 const { Cc, Ci } = require("chrome");
 const { Loader } = require('sdk/test/loader');
 const { LoaderWithHookedConsole } = require("sdk/test/loader");
 const timer = require("sdk/timers");
 const self = require('sdk/self');
 const { open, close, focus, ready } = require('sdk/window/helpers');
 const { isPrivate } = require('sdk/private-browsing');
 const { isWindowPBSupported, isGlobalPBSupported } = require('sdk/private-browsing/utils');
 const { defer, all } = require('sdk/core/promise');
 const { getMostRecentBrowserWindow } = require('sdk/window/utils');
 const { getWindow } = require('sdk/panel/window');
 const { pb } = require('./private-browsing/helper');
 const { URL } = require('sdk/url');
 const fixtures = require('./fixtures')
 const SVG_URL = fixtures.url('mofo_logo.SVG');
 const CSS_URL = fixtures.url('css-include-file.css');
 const Isolate = fn => '(' + fn + ')()';
 function ignorePassingDOMNodeWarning(type, message) {
   if (type !== 'warn' || !message.startsWith('Passing a DOM node'))
     console[type](message);
 }
 function makeEmptyPrivateBrowserWindow(options) {
   options = options || {};
   return open('chrome://browser/content/browser.xul', {
     features: {
       chrome: true,
       toolbar: true,
       private: true
     }
   });
 }
 exports["test Panel"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   let panel = Panel({
     contentURL: "about:buildconfig",
     contentScript: "self.postMessage(1); self.on('message', function() self.postMessage(2));",
     onMessage: function (message) {
       assert.equal(this, panel, "The 'this' object is the panel.");
       switch(message) {
         case 1:
           assert.pass("The panel was loaded.");
           panel.postMessage('');
           break;
         case 2:
           assert.pass("The panel posted a message and received a response.");
           panel.destroy();
           done();
           break;
       }
     }
   });
 };
 exports["test Panel Emit"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   let panel = Panel({
     contentURL: "about:buildconfig",
     contentScript: "self.port.emit('loaded');" +
                    "self.port.on('addon-to-content', " +
                    "             function() self.port.emit('received'));",
   });
   panel.port.on("loaded", function () {
     assert.pass("The panel was loaded and sent a first event.");
     panel.port.emit("addon-to-content");
   });
   panel.port.on("received", function () {
     assert.pass("The panel posted a message and received a response.");
     panel.destroy();
     done();
   });
 };
 exports["test Panel Emit Early"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   let panel = Panel({
     contentURL: "about:buildconfig",
     contentScript: "self.port.on('addon-to-content', " +
                    "             function() self.port.emit('received'));",
   });
   panel.port.on("received", function () {
     assert.pass("The panel posted a message early and received a response.");
     panel.destroy();
     done();
   });
   panel.port.emit("addon-to-content");
 };
 exports["test Show Hide Panel"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   let panel = Panel({
     contentScript: "self.postMessage('')",
     contentScriptWhen: "end",
     contentURL: "data:text/html;charset=utf-8,",
     onMessage: function (message) {
       panel.show();
     },
     onShow: function () {
       assert.pass("The panel was shown.");
       assert.equal(this, panel, "The 'this' object is the panel.");
       assert.equal(this.isShowing, true, "panel.isShowing == true.");
       panel.hide();
     },
     onHide: function () {
       assert.pass("The panel was hidden.");
       assert.equal(this, panel, "The 'this' object is the panel.");
       assert.equal(this.isShowing, false, "panel.isShowing == false.");
       panel.destroy();
       done();
     }
   });
 };
 exports["test Document Reload"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   let url2 = "data:text/html;charset=utf-8,page2";
   let content =
     "<script>" +
     "window.addEventListener('message', function({ data }) {"+
     "  if (data == 'move') window.location = '" + url2 + "';" +
     '}, false);' +
     "</script>";
   let messageCount = 0;
   let panel = Panel({
     // using URL here is intentional, see bug 859009
     contentURL: URL("data:text/html;charset=utf-8," + encodeURIComponent(content)),
     contentScript: "self.postMessage(window.location.href);" +
                    // initiate change to url2
                    "self.port.once('move', function() document.defaultView.postMessage('move', '*'));",
     onMessage: function (message) {
       messageCount++;
       assert.notEqual(message, "about:blank", "about:blank is not a message " + messageCount);
       if (messageCount == 1) {
         assert.ok(/data:text\/html/.test(message), "First document had a content script; " + message);
         panel.port.emit('move');
         assert.pass('move message was sent');
         return;
       }
       else if (messageCount == 2) {
         assert.equal(message, url2, "Second document too; " + message);
         panel.destroy();
         done();
       }
     }
   });
   assert.pass('Panel was created');
 };
 // Test disabled because of bug 910230
 /*
 exports["test Parent Resize Hack"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   let browserWindow = getMostRecentBrowserWindow();
   let previousWidth = browserWindow.outerWidth;
   let previousHeight = browserWindow.outerHeight;
   let content = "<script>" +
                 "function contentResize() {" +
                 "  resizeTo(200,200);" +
                 "  resizeBy(200,200);" +
                 "  window.postMessage('resize-attempt', '*');" +
                 "}" +
                 "</script>" +
                 "Try to resize browser window";
   let panel = Panel({
     contentURL: "data:text/html;charset=utf-8," + encodeURIComponent(content),
     contentScriptWhen: "ready",
     contentScript: Isolate(() => {
         self.on('message', message => {
           if (message === 'resize') unsafeWindow.contentResize();
         });
         window.addEventListener('message', ({ data }) => self.postMessage(data));
       }),
     onMessage: function (message) {
       if (message !== "resize-attempt") return;
       assert.equal(browserWindow, getMostRecentBrowserWindow(),
         "The browser window is still the same");
       assert.equal(previousWidth, browserWindow.outerWidth,
         "Size doesn't change by calling resizeTo/By/...");
       assert.equal(previousHeight, browserWindow.outerHeight,
         "Size doesn't change by calling resizeTo/By/...");
       try {
         panel.destroy();
       }
       catch (e) {
         assert.fail(e);
         throw e;
       }
       done();
     },
     onShow: () => panel.postMessage('resize')
   });
   panel.show();
 }
 */
 exports["test Resize Panel"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   // These tests fail on Linux if the browser window in which the panel
   // is displayed is not active.  And depending on what other tests have run
   // before this one, it might not be (the untitled window in which the test
   // runner executes is often active).  So we make sure the browser window
   // is focused by focusing it before running the tests.  Then, to be the best
   // possible test citizen, we refocus whatever window was focused before we
   // started running these tests.
   let activeWindow = Cc["@mozilla.org/embedcomp/window-watcher;1"].
                       getService(Ci.nsIWindowWatcher).
                       activeWindow;
   let browserWindow = Cc["@mozilla.org/appshell/window-mediator;1"].
                       getService(Ci.nsIWindowMediator).
                       getMostRecentWindow("navigator:browser");
   function onFocus() {
     browserWindow.removeEventListener("focus", onFocus, true);
     let panel = Panel({
       contentScript: "self.postMessage('')",
       contentScriptWhen: "end",
       contentURL: "data:text/html;charset=utf-8,",
       height: 10,
       width: 10,
       onMessage: function (message) {
         panel.show();
       },
       onShow: function () {
         panel.resize(100,100);
         panel.hide();
       },
       onHide: function () {
         assert.ok((panel.width == 100) && (panel.height == 100),
           "The panel was resized.");
         if (activeWindow)
           activeWindow.focus();
         done();
       }
     });
   }
   if (browserWindow === activeWindow) {
     onFocus();
   }
   else {
     browserWindow.addEventListener("focus", onFocus, true);
     browserWindow.focus();
   }
 };
 exports["test Hide Before Show"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   let showCalled = false;
   let panel = Panel({
     onShow: function () {
       showCalled = true;
     },
     onHide: function () {
       assert.ok(!showCalled, 'must not emit show if was hidden before');
       done();
     }
   });
   panel.show();
   panel.hide();
 };
 exports["test Several Show Hides"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   let hideCalled = 0;
   let panel = Panel({
     contentURL: "about:buildconfig",
     onShow: function () {
       panel.hide();
     },
     onHide: function () {
       hideCalled++;
       if (hideCalled < 3)
         panel.show();
       else {
         assert.pass("onHide called three times as expected");
         done();
       }
     }
   });
   panel.on('error', function(e) {
     assert.fail('error was emitted:' + e.message + '\n' + e.stack);
   });
   panel.show();
 };
 exports["test Anchor And Arrow"] = function(assert, done) {
   let { loader } = LoaderWithHookedConsole(module, ignorePassingDOMNodeWarning);
   let { Panel } = loader.require('sdk/panel');
   let count = 0;
   let queue = [];
   let tab;
   function newPanel(anchor) {
     let panel = Panel({
       contentURL: "data:text/html;charset=utf-8,<html><body style='padding: 0; margin: 0; " +
                   "background: gray; text-align: center;'>Anchor: " +
                   anchor.id + "</body></html>",
       width: 200,
       height: 100,
       onShow: function () {
         panel.destroy();
         next();
       }
     });
     queue.push({ panel: panel, anchor: anchor });
   }
   function next () {
     if (!queue.length) {
       assert.pass("All anchored panel test displayed");
       tab.close(function () {
         done();
       });
       return;
     }
     let { panel, anchor } = queue.shift();
     panel.show(null, anchor);
   }
   let tabs= require("sdk/tabs");
   let url = 'data:text/html;charset=utf-8,' +
     '<html><head><title>foo</title></head><body>' +
     '<style>div {background: gray; position: absolute; width: 300px; ' +
            'border: 2px solid black;}</style>' +
     '<div id="tl" style="top: 0px; left: 0px;">Top Left</div>' +
     '<div id="tr" style="top: 0px; right: 0px;">Top Right</div>' +
     '<div id="bl" style="bottom: 0px; left: 0px;">Bottom Left</div>' +
     '<div id="br" style="bottom: 0px; right: 0px;">Bottom right</div>' +
     '</body></html>';
   tabs.open({
     url: url,
     onReady: function(_tab) {
       tab = _tab;
       let browserWindow = Cc["@mozilla.org/appshell/window-mediator;1"].
                       getService(Ci.nsIWindowMediator).
                       getMostRecentWindow("navigator:browser");
       let window = browserWindow.content;
       newPanel(window.document.getElementById('tl'));
       newPanel(window.document.getElementById('tr'));
       newPanel(window.document.getElementById('bl'));
       newPanel(window.document.getElementById('br'));
       let anchor = browserWindow.document.getElementById("identity-box");
       newPanel(anchor);
       next();
     }
   });
 };
 exports["test Panel Focus True"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   const FM = Cc["@mozilla.org/focus-manager;1"].
                 getService(Ci.nsIFocusManager);
   let browserWindow = Cc["@mozilla.org/appshell/window-mediator;1"].
                       getService(Ci.nsIWindowMediator).
                       getMostRecentWindow("navigator:browser");
   // Make sure there is a focused element
   browserWindow.document.documentElement.focus();
   // Get the current focused element
   let focusedElement = FM.focusedElement;
   let panel = Panel({
     contentURL: "about:buildconfig",
     focus: true,
     onShow: function () {
       assert.ok(focusedElement !== FM.focusedElement,
         "The panel takes the focus away.");
       done();
     }
   });
   panel.show();
 };
 exports["test Panel Focus False"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   const FM = Cc["@mozilla.org/focus-manager;1"].
                 getService(Ci.nsIFocusManager);
   let browserWindow = Cc["@mozilla.org/appshell/window-mediator;1"].
                       getService(Ci.nsIWindowMediator).
                       getMostRecentWindow("navigator:browser");
   // Make sure there is a focused element
   browserWindow.document.documentElement.focus();
   // Get the current focused element
   let focusedElement = FM.focusedElement;
   let panel = Panel({
     contentURL: "about:buildconfig",
     focus: false,
     onShow: function () {
       assert.ok(focusedElement === FM.focusedElement,
         "The panel does not take the focus away.");
       done();
     }
   });
   panel.show();
 };
 exports["test Panel Focus Not Set"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   const FM = Cc["@mozilla.org/focus-manager;1"].
                 getService(Ci.nsIFocusManager);
   let browserWindow = Cc["@mozilla.org/appshell/window-mediator;1"].
                       getService(Ci.nsIWindowMediator).
                       getMostRecentWindow("navigator:browser");
   // Make sure there is a focused element
   browserWindow.document.documentElement.focus();
   // Get the current focused element
   let focusedElement = FM.focusedElement;
   let panel = Panel({
     contentURL: "about:buildconfig",
     onShow: function () {
       assert.ok(focusedElement !== FM.focusedElement,
         "The panel takes the focus away.");
       done();
     }
   });
   panel.show();
 };
 exports["test Panel Text Color"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   let html = "<html><head><style>body {color: yellow}</style></head>" +
              "<body><p>Foo</p></body></html>";
   let panel = Panel({
     contentURL: "data:text/html;charset=utf-8," + encodeURI(html),
     contentScript: "self.port.emit('color', " +
                    "window.getComputedStyle(document.body.firstChild, null). " +
                    "       getPropertyValue('color'));"
   });
   panel.port.on("color", function (color) {
     assert.equal(color, "rgb(255, 255, 0)",
       "The panel text color style is preserved when a style exists.");
     panel.destroy();
     done();
   });
 };
 // Bug 866333
 exports["test watch event name"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   let html = "<html><head><style>body {color: yellow}</style></head>" +
              "<body><p>Foo</p></body></html>";
   let panel = Panel({
     contentURL: "data:text/html;charset=utf-8," + encodeURI(html),
     contentScript: "self.port.emit('watch', 'test');"
   });
   panel.port.on("watch", function (msg) {
     assert.equal(msg, "test", 'watch event name works');
     panel.destroy();
     done();
   });
 }
 // Bug 696552: Ensure panel.contentURL modification support
 exports["test Change Content URL"] = function(assert, done) {
   const { Panel } = require('sdk/panel');
   let panel = Panel({
     contentURL: "about:blank",
     contentScript: "self.port.emit('ready', document.location.href);"
   });
   let count = 0;
   panel.port.on("ready", function (location) {
     count++;
     if (count == 1) {
       assert.equal(location, "about:blank");
       assert.equal(panel.contentURL, "about:blank");
       panel.contentURL = "about:buildconfig";
     }
     else {
       assert.equal(location, "about:buildconfig");
       assert.equal(panel.contentURL, "about:buildconfig");
       panel.destroy();
       done();
     }
   });
 };
 function makeEventOrderTest(options) {
   let expectedEvents = [];
   return function(assert, done) {
     const { Panel } = require('sdk/panel');
     let panel = Panel({ contentURL: "about:buildconfig" });
     function expect(event, cb) {
       expectedEvents.push(event);
       panel.on(event, function() {
         assert.equal(event, expectedEvents.shift());
         if (cb)
           timer.setTimeout(cb, 1);
       });
       return {then: expect};
     }
     options.test(assert, done, expect, panel);
   }
 }
 exports["test Automatic Destroy"] = function(assert) {
   let loader = Loader(module);
   let panel = loader.require("sdk/panel").Panel({
     contentURL: "about:buildconfig",
     contentScript:
       "self.port.on('event', function() self.port.emit('event-back'));"
   });
   loader.unload();
   assert.throws(() => {
     panel.port.emit("event");
   }, /already have been unloaded/, "check automatic destroy");
 };
 exports["test Show Then Destroy"] = makeEventOrderTest({
   test: function(assert, done, expect, panel) {
     panel.show();
     expect('show', function() { panel.destroy(); }).
       then('hide', function() { done(); });
   }
 });
 exports["test Show Then Hide Then Destroy"] = makeEventOrderTest({
   test: function(assert, done, expect, panel) {
     panel.show();
     expect('show', function() { panel.hide(); }).
       then('hide', function() { panel.destroy(); done(); });
   }
 });
 exports["test Content URL Option"] = function(assert) {
   const { Panel } = require('sdk/panel');
   const URL_STRING = "about:buildconfig";
   const HTML_CONTENT = "<html><title>Test</title><p>This is a test.</p></html>";
   let (panel = Panel({ contentURL: URL_STRING })) {
     assert.pass("contentURL accepts a string URL.");
     assert.equal(panel.contentURL, URL_STRING,
                 "contentURL is the string to which it was set.");
   }
   let dataURL = "data:text/html;charset=utf-8," + encodeURIComponent(HTML_CONTENT);
   let (panel = Panel({ contentURL: dataURL })) {
     assert.pass("contentURL accepts a data: URL.");
   }
   let (panel = Panel({})) {
     assert.ok(panel.contentURL == null,
                 "contentURL is undefined.");
   }
   assert.throws(function () Panel({ contentURL: "foo" }),
                     /The `contentURL` option must be a valid URL./,
                     "Panel throws an exception if contentURL is not a URL.");
 };
 exports["test SVG Document"] = function(assert) {
   let panel = require("sdk/panel").Panel({ contentURL: SVG_URL });
   panel.show();
   panel.hide();
   panel.destroy();
   assert.pass("contentURL accepts a svg document");
   assert.equal(panel.contentURL, SVG_URL,
               "contentURL is the string to which it was set.");
 };
 exports["test ContentScriptOptions Option"] = function(assert, done) {
   let loader = Loader(module);
   let panel = loader.require("sdk/panel").Panel({
       contentScript: "self.postMessage( [typeof self.options.d, self.options] );",
       contentScriptWhen: "end",
       contentScriptOptions: {a: true, b: [1,2,3], c: "string", d: function(){ return 'test'}},
       contentURL: "data:text/html;charset=utf-8,",
       onMessage: function(msg) {
         assert.equal( msg[0], 'undefined', 'functions are stripped from contentScriptOptions' );
         assert.equal( typeof msg[1], 'object', 'object as contentScriptOptions' );
         assert.equal( msg[1].a, true, 'boolean in contentScriptOptions' );
         assert.equal( msg[1].b.join(), '1,2,3', 'array and numbers in contentScriptOptions' );
         assert.equal( msg[1].c, 'string', 'string in contentScriptOptions' );
         done();
       }
     });
 };
 exports["test console.log in Panel"] = function(assert, done) {
   let text = 'console.log() in Panel works!';
   let html = '<script>onload = function log(){\
                 console.log("' + text + '");\
               }</script>';
   let { loader } = LoaderWithHookedConsole(module, onMessage);
   let { Panel } = loader.require('sdk/panel');
   let panel = Panel({
     contentURL: 'data:text/html;charset=utf-8,' + encodeURIComponent(html)
   });
   panel.show();
   function onMessage(type, message) {
     assert.equal(type, 'log', 'console.log() works');
     assert.equal(message, text, 'console.log() works');
     panel.destroy();
     done();
   }
 };
 if (isWindowPBSupported) {
   exports.testPanelDoesNotShowInPrivateWindowNoAnchor = function(assert, done) {
     let { loader } = LoaderWithHookedConsole(module, ignorePassingDOMNodeWarning);
     let { Panel } = loader.require("sdk/panel");
     let browserWindow = getMostRecentBrowserWindow();
     assert.equal(isPrivate(browserWindow), false, 'open window is not private');
     let panel = Panel({
       contentURL: SVG_URL
     });
     testShowPanel(assert, panel).
       then(makeEmptyPrivateBrowserWindow).
       then(focus).
       then(function(window) {
         assert.equal(isPrivate(window), true, 'opened window is private');
         assert.pass('private window was focused');
         return window;
       }).
       then(function(window) {
         let { promise, resolve } = defer();
         let showTries = 0;
         let showCount = 0;
         panel.on('show', function runTests() {
           showCount++;
           if (showTries == 2) {
             panel.removeListener('show', runTests);
             assert.equal(showCount, 1, 'show count is correct - 1');
             resolve(window);
           }
         });
         showTries++;
         panel.show();
         showTries++;
         panel.show(null, browserWindow.gBrowser);
         return promise;
       }).
       then(function(window) {
         assert.equal(panel.isShowing, true, 'panel is still showing');
         panel.hide();
         assert.equal(panel.isShowing, false, 'panel is hidden');
         return window;
       }).
       then(close).
       then(function() {
         assert.pass('private window was closed');
       }).
       then(testShowPanel.bind(null, assert, panel)).
       then(done, assert.fail.bind(assert));
   }
   exports.testPanelDoesNotShowInPrivateWindowWithAnchor = function(assert, done) {
     let { loader } = LoaderWithHookedConsole(module, ignorePassingDOMNodeWarning);
     let { Panel } = loader.require("sdk/panel");
     let browserWindow = getMostRecentBrowserWindow();
     assert.equal(isPrivate(browserWindow), false, 'open window is not private');
     let panel = Panel({
       contentURL: SVG_URL
     });
     testShowPanel(assert, panel).
       then(makeEmptyPrivateBrowserWindow).
       then(focus).
       then(function(window) {
         assert.equal(isPrivate(window), true, 'opened window is private');
         assert.pass('private window was focused');
         return window;
       }).
       then(function(window) {
         let { promise, resolve } = defer();
         let showTries = 0;
         let showCount = 0;
         panel.on('show', function runTests() {
           showCount++;
           if (showTries == 2) {
             panel.removeListener('show', runTests);
             assert.equal(showCount, 1, 'show count is correct - 1');
             resolve(window);
           }
         });
         showTries++;
         panel.show(null, window.gBrowser);
         showTries++;
         panel.show(null, browserWindow.gBrowser);
         return promise;
       }).
       then(function(window) {
         assert.equal(panel.isShowing, true, 'panel is still showing');
         panel.hide();
         assert.equal(panel.isShowing, false, 'panel is hidden');
         return window;
       }).
       then(close).
       then(function() {
         assert.pass('private window was closed');
       }).
       then(testShowPanel.bind(null, assert, panel)).
       then(done, assert.fail.bind(assert));
   }
 }
 function testShowPanel(assert, panel) {
   let { promise, resolve } = defer();
   assert.ok(!panel.isShowing, 'the panel is not showing [1]');
   panel.once('show', function() {
     assert.ok(panel.isShowing, 'the panel is showing');
     panel.once('hide', function() {
       assert.ok(!panel.isShowing, 'the panel is not showing [2]');
       resolve(null);
     });
     panel.hide();
   })
   panel.show();
   return promise;
 }
 exports['test Style Applied Only Once'] = function (assert, done) {
   let loader = Loader(module);
   let panel = loader.require("sdk/panel").Panel({
     contentURL: "data:text/html;charset=utf-8,",
     contentScript:
       'self.port.on("check",function() { self.port.emit("count", document.getElementsByTagName("style").length); });' +
       'self.port.on("ping", function (count) { self.port.emit("pong", count); });'
   });
   panel.port.on('count', function (styleCount) {
     assert.equal(styleCount, 1, 'should only have one style');
     done();
   });
   panel.port.on('pong', function (counter) {
     panel[--counter % 2 ? 'hide' : 'show']();
     panel.port.emit(!counter ? 'check' : 'ping', counter);
   });
   panel.on('show', init);
   panel.show();
   function init () {
     panel.removeListener('show', init);
     panel.port.emit('ping', 10);
   }
 };
 exports['test Only One Panel Open Concurrently'] = function (assert, done) {
   const loader = Loader(module);
   const { Panel } = loader.require('sdk/panel')
   let panelA = Panel({
     contentURL: 'about:buildconfig'
   });
   let panelB = Panel({
     contentURL: 'about:buildconfig',
     onShow: function () {
       // When loading two panels simulataneously, only the second
       // should be shown, never showing the first
       assert.equal(panelA.isShowing, false, 'First panel is hidden');
       assert.equal(panelB.isShowing, true, 'Second panel is showing');
       panelC.show();
     }
   });
   let panelC = Panel({
     contentURL: 'about:buildconfig',
     onShow: function () {
       assert.equal(panelA.isShowing, false, 'First panel is hidden');
       assert.equal(panelB.isShowing, false, 'Second panel is hidden');
       assert.equal(panelC.isShowing, true, 'Third panel is showing');
       done();
     }
   });
   panelA.show();
   panelB.show();
 };
 exports['test passing DOM node as first argument'] = function (assert, done) {
   let warned = defer();
   let shown = defer();
   function onMessage(type, message) {
     if (type != 'warn') return;
     let warning = 'Passing a DOM node to Panel.show() method is an unsupported ' +
                   'feature that will be soon replaced. ' +
                   'See: https://bugzilla.mozilla.org/show_bug.cgi?id=878877';
     assert.equal(type, 'warn',
       'the message logged is a warning');
     assert.equal(message, warning,
       'the warning content is correct');
     warned.resolve();
   }
   let { loader } = LoaderWithHookedConsole(module, onMessage);
   let { Panel } = loader.require('sdk/panel');
   let { Widget } = loader.require('sdk/widget');
   let { document } = getMostRecentBrowserWindow();
   let widgetId = 'widget:' + self.id + '-panel-widget';
   let panel = Panel({
     onShow: function() {
       let panelNode = document.getElementById('mainPopupSet').lastChild;
       assert.equal(panelNode.anchorNode, widgetNode,
         'the panel is properly anchored to the widget');
       shown.resolve();
     }
   });
   let widget = Widget({
     id: 'panel-widget',
     label: 'panel widget',
     content: '<i></i>',
   });
   let widgetNode = document.getElementById(widgetId);
   all([warned.promise, shown.promise]).
     then(loader.unload).
     then(done, assert.fail)
   panel.show(widgetNode);
 };
 // This test is checking that `onpupshowing` events emitted by panel's children
 // are not considered.
 // See Bug 886329
 exports['test nested popups'] = function (assert, done) {
   let loader = Loader(module);
   let { Panel } = loader.require('sdk/panel');
   let { getActiveView } = loader.require('sdk/view/core');
   let url = '<select><option>1<option>2<option>3</select>';
   let getContentWindow = panel => {
     return getActiveView(panel).querySelector('iframe').contentWindow;
   }
   let panel = Panel({
     contentURL: 'data:text/html;charset=utf-8,' + encodeURIComponent(url),
     onShow: () => {
       ready(getContentWindow(panel)).then(({ window, document }) => {
         let select = document.querySelector('select');
         let event = document.createEvent('UIEvent');
         event.initUIEvent('popupshowing', true, true, window, null);
         select.dispatchEvent(event);
         assert.equal(
           select,
           getContentWindow(panel).document.querySelector('select'),
           'select is still loaded in panel'
         );
         done();
       });
     }
   });
   panel.show();
 };
 exports['test emits on url changes'] = function (assert, done) {
   let loader = Loader(module);
   let { Panel } = loader.require('sdk/panel');
   let uriA = 'data:text/html;charset=utf-8,A';
   let uriB = 'data:text/html;charset=utf-8,B';
   let panel = Panel({
     contentURL: uriA,
     contentScript: 'new ' + function() {
       self.port.on('hi', function() {
         self.port.emit('bye', document.URL);
       });
     }
   });
   panel.contentURL = uriB;
   panel.port.emit('hi', 'hi')
   panel.port.on('bye', function(uri) {
     assert.equal(uri, uriB, 'message was delivered to new uri');
     loader.unload();
     done();
   });
 };
 exports['test panel can be constructed without any arguments'] = function (assert) {
   const { Panel } = require('sdk/panel');
   let panel = Panel();
   assert.ok(true, "Creating a panel with no arguments does not throw");
 };
 exports['test panel CSS'] = function(assert, done) {
   const loader = Loader(module);
   const { Panel } = loader.require('sdk/panel');
   const { getActiveView } = loader.require('sdk/view/core');
   const getContentWindow = panel =>
     getActiveView(panel).querySelector('iframe').contentWindow;
   let panel = Panel({
     contentURL: 'data:text/html;charset=utf-8,' +
                 '<div style="background: silver">css test</div>',
     contentStyle: 'div { height: 100px; }',
     contentStyleFile: CSS_URL,
     onShow: () => {
       ready(getContentWindow(panel)).then(({ document }) => {
         let div = document.querySelector('div');
         assert.equal(div.clientHeight, 100, 'Panel contentStyle worked');
         assert.equal(div.offsetHeight, 120, 'Panel contentStyleFile worked');
         loader.unload();
         done();
       }).then(null, assert.fail);
     }
   });
   panel.show();
 };
 exports['test panel CSS list'] = function(assert, done) {
   const loader = Loader(module);
   const { Panel } = loader.require('sdk/panel');
   const { getActiveView } = loader.require('sdk/view/core');
   const getContentWindow = panel =>
     getActiveView(panel).querySelector('iframe').contentWindow;
   let panel = Panel({
     contentURL: 'data:text/html;charset=utf-8,' +
                 '<div style="width:320px; max-width: 480px!important">css test</div>',
     contentStyleFile: [
       // Highlight evaluation order in this list
       "data:text/css;charset=utf-8,div { border: 1px solid black; }",
       "data:text/css;charset=utf-8,div { border: 10px solid black; }",
       // Highlight evaluation order between contentStylesheet & contentStylesheetFile
       "data:text/css;charset=utf-8s,div { height: 1000px; }",
       // Highlight precedence between the author and user style sheet
       "data:text/css;charset=utf-8,div { width: 200px; max-width: 640px!important}",
     ],
     contentStyle: [
       "div { height: 10px; }",
       "div { height: 100px; }"
     ],
     onShow: () => {
       ready(getContentWindow(panel)).then(({ window, document }) => {
         let div = document.querySelector('div');
         let style = window.getComputedStyle(div);
         assert.equal(div.clientHeight, 100,
           'Panel contentStyle list is evaluated after contentStyleFile');
         assert.equal(div.offsetHeight, 120,
           'Panel contentStyleFile list works');
         assert.equal(style.width, '320px',
           'add-on author/page author stylesheet precedence works');
         assert.equal(style.maxWidth, '480px',
           'add-on author/page author stylesheet !important precedence works');
         loader.unload();
         done();
       }).then(null, assert.fail);
     }
   });
   panel.show();
 };
 if (isWindowPBSupported) {
   exports.testGetWindow = function(assert, done) {
     let activeWindow = getMostRecentBrowserWindow();
     open(null, { features: {
       toolbar: true,
       chrome: true,
       private: true
     } }).then(function(window) {
       assert.ok(isPrivate(window), 'window is private');
       assert.equal(getWindow(window.gBrowser), null, 'private window elements returns null');
       assert.equal(getWindow(activeWindow.gBrowser), activeWindow, 'non-private window elements returns window');
       close(window).then(done);
     })
   }
 }
 else if (isGlobalPBSupported) {
   exports.testGetWindow = function(assert, done) {
     let activeWindow = getMostRecentBrowserWindow();
     assert.equal(getWindow(activeWindow.gBrowser), activeWindow, 'non-private window elements returns window');
     pb.once('start', function() {
       assert.ok(isPrivate(activeWindow), 'window is private');
       assert.equal(getWindow(activeWindow.gBrowser), activeWindow, 'private window elements returns window');
       open(null, { features: {
         toolbar: true,
         chrome: true
       } }).then(function(window) {
         assert.ok(isPrivate(window), 'window is private');
         assert.equal(getWindow(window.gBrowser), window, 'private window elements returns window');
         assert.equal(getWindow(activeWindow.gBrowser), activeWindow, 'active window elements returns window');
         pb.once('stop', done);
         pb.deactivate();
       })
     });
     pb.activate();
   }
 }
 require("test").run(exports);