The Tor Browser: addon-sdk/source/test/test-xpcom.js@6474c204b198 (annotated)

addon-sdk/source/test/test-xpcom.js@6474c204b198 (annotated)

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

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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/. */
 const xpcom = require("sdk/platform/xpcom");
 const { Cc, Ci, Cm, Cr } = require("chrome");
 const { isCIDRegistered } = Cm.QueryInterface(Ci.nsIComponentRegistrar);
 const { Class } = require("sdk/core/heritage");
 const { Loader } = require("sdk/test/loader");
 exports['test Unknown implements nsISupports'] = function(assert) {
   let actual = xpcom.Unknown();
   assert.equal(actual.QueryInterface(Ci.nsISupports),
                actual,
                'component implements nsISupports');
 };
 exports['test implement xpcom interfaces'] = function(assert) {
   let WeakReference = Class({
     extends: xpcom.Unknown,
     interfaces: [ 'nsIWeakReference' ],
     QueryReferent: function() {}
   });
   let weakReference = WeakReference()
   assert.equal(weakReference.QueryInterface(Ci.nsISupports),
                weakReference,
                'component implements nsISupports');
   assert.equal(weakReference.QueryInterface(Ci.nsIWeakReference),
                weakReference,
                'component implements specified interface');
   assert.throws(function() {
     component.QueryInterface(Ci.nsIObserver);
   }, "component does not implements interface");
   let Observer = Class({
     extends: WeakReference,
     interfaces: [ 'nsIObserver', 'nsIRequestObserver' ],
     observe: function() {},
     onStartRequest: function() {},
     onStopRequest: function() {}
   });
   let observer = Observer()
   assert.equal(observer.QueryInterface(Ci.nsISupports),
                observer,
                'derived component implements nsISupports');
   assert.equal(observer.QueryInterface(Ci.nsIWeakReference),
                observer,
                'derived component implements supers interface');
   assert.equal(observer.QueryInterface(Ci.nsIObserver),
                observer.QueryInterface(Ci.nsIRequestObserver),
                'derived component implements specified interfaces');
 };
 exports['test implement factory without contract'] = function(assert) {
   let actual = xpcom.Factory({
     get wrappedJSObject() this,
   });
   assert.ok(isCIDRegistered(actual.id), 'factory is regiseterd');
   xpcom.unregister(actual);
   assert.ok(!isCIDRegistered(actual.id), 'factory is unregistered');
 };
 exports['test implement xpcom factory'] = function(assert) {
   let Component = Class({
     extends: xpcom.Unknown,
     interfaces: [ 'nsIObserver' ],
     get wrappedJSObject() this,
     observe: function() {}
   });
   let factory = xpcom.Factory({
     register: false,
     contract: '@jetpack/test/factory;1',
     Component: Component
   });
   assert.ok(!isCIDRegistered(factory.id), 'factory is not registered');
   xpcom.register(factory);
   assert.ok(isCIDRegistered(factory.id), 'factory is registered');
   let actual = Cc[factory.contract].createInstance(Ci.nsIObserver);
   assert.ok(actual.wrappedJSObject instanceof Component,
             "createInstance returnes wrapped factory instances");
   assert.notEqual(Cc[factory.contract].createInstance(Ci.nsIObserver),
                   Cc[factory.contract].createInstance(Ci.nsIObserver),
                   "createInstance returns new instance each time");
 };
 exports['test implement xpcom service'] = function(assert) {
   let actual = xpcom.Service({
     contract: '@jetpack/test/service;1',
     register: false,
     Component: Class({
       extends: xpcom.Unknown,
       interfaces: [ 'nsIObserver'],
       get wrappedJSObject() this,
       observe: function() {},
       name: 'my-service'
     })
   });
   assert.ok(!isCIDRegistered(actual.id), 'component is not registered');
   xpcom.register(actual);
   assert.ok(isCIDRegistered(actual.id), 'service is regiseterd');
   assert.ok(Cc[actual.contract].getService(Ci.nsIObserver).observe,
             'service can be accessed via get service');
   assert.equal(Cc[actual.contract].getService(Ci.nsIObserver).wrappedJSObject,
                actual.component,
                'wrappedJSObject is an actual component');
   xpcom.unregister(actual);
   assert.ok(!isCIDRegistered(actual.id), 'service is unregistered');
 };
 function testRegister(assert, text) {
   const service = xpcom.Service({
     description: 'test about:boop page',
     contract: '@mozilla.org/network/protocol/about;1?what=boop',
     register: false,
     Component: Class({
       extends: xpcom.Unknown,
       get wrappedJSObject() this,
       interfaces: [ 'nsIAboutModule' ],
       newChannel : function(aURI) {
         var ios = Cc["@mozilla.org/network/io-service;1"].
                   getService(Ci.nsIIOService);
         var channel = ios.newChannel(
           "data:text/plain;charset=utf-8," + text,
           null,
           null
         );
         channel.originalURI = aURI;
         return channel;
       },
       getURIFlags: function(aURI) {
         return Ci.nsIAboutModule.ALLOW_SCRIPT;
       }
     })
   });
   xpcom.register(service);
   assert.equal(isCIDRegistered(service.id), true);
   var aboutFactory = xpcom.factoryByContract(service.contract);
   var about = aboutFactory.createInstance(Ci.nsIAboutModule);
   var ios = Cc["@mozilla.org/network/io-service;1"].
             getService(Ci.nsIIOService);
   assert.equal(
     about.getURIFlags(ios.newURI("http://foo.com", null, null)),
     Ci.nsIAboutModule.ALLOW_SCRIPT
   );
   var aboutURI = ios.newURI("about:boop", null, null);
   var channel = ios.newChannelFromURI(aboutURI);
   var iStream = channel.open();
   var siStream = Cc['@mozilla.org/scriptableinputstream;1']
                  .createInstance(Ci.nsIScriptableInputStream);
   siStream.init(iStream);
   var data = new String();
   data += siStream.read(-1);
   siStream.close();
   iStream.close();
   assert.equal(data, text);
   xpcom.unregister(service);
   assert.equal(isCIDRegistered(service.id), false);
 }
 exports["test register"] = function(assert) {
   testRegister(assert, "hai2u");
 };
 exports["test re-register"] = function(assert) {
   testRegister(assert, "hai2u again");
 };
 exports["test unload"] = function(assert) {
   let loader = Loader(module);
   let sbxpcom = loader.require("sdk/platform/xpcom");
   let auto = sbxpcom.Factory({
     contract: "@mozilla.org/test/auto-unload;1",
     description: "test auto",
     name: "auto"
   });
   let manual = sbxpcom.Factory({
     contract: "@mozilla.org/test/manual-unload;1",
     description: "test manual",
     register: false,
     unregister: false,
     name: "manual"
   });
   assert.equal(isCIDRegistered(auto.id), true, 'component registered');
   assert.equal(isCIDRegistered(manual.id), false, 'component not registered');
   sbxpcom.register(manual)
   assert.equal(isCIDRegistered(manual.id), true,
                    'component was automatically registered on first instance');
   loader.unload();
   assert.equal(isCIDRegistered(auto.id), false,
                    'component was atumatically unregistered on unload');
   assert.equal(isCIDRegistered(manual.id), true,
                    'component was not automatically unregistered on unload');
   sbxpcom.unregister(manual);
   assert.equal(isCIDRegistered(manual.id), false,
                    'component was manually unregistered on unload');
 };
 require("test").run(exports);