The Tor Browser: comparison js/xpconnect/tests/chrome/test

--1:000000000000
+:c849d2c070d7
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet href="chrome://mochikit/content/tests/SimpleTest/test.css"
+type="text/css"?>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=500931
+-->
+<window title="Mozilla Bug 522764"
+xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+<script type="application/javascript"
+src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+<!-- test results are displayed in the html:body -->
+<body xmlns="http://www.w3.org/1999/xhtml">
+<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=522764 "
+target="_blank">Mozilla Bug 522764 </a>
+</body>
+<!-- test code goes here -->
+<script type="application/javascript"><![CDATA[
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+var sandbox = new Cu.Sandbox("about:blank");
+var test_utils = window.QueryInterface(Ci.nsIInterfaceRequestor).
+getInterface(Ci.nsIDOMWindowUtils);
+function getCOW(x) {
+if (typeof x != 'object' && typeof x != 'function')
+return x;
+var rval = {};
+if (typeof x == "function")
+rval = eval(uneval(x));
+for (var i in x) {
+if (x.__lookupGetter__(i))
+rval.__defineGetter__(i, eval(uneval(x.__lookupGetter__(i))))
+else
+rval[i] = getCOW(x[i]);
+}
+return rval;
+}
+// Give the sandbox a way to create ChromeObjectWrapped objects.
+sandbox.getCOW = getCOW;
+// Define test API functions in the sandbox.
+const TEST_API = ['is', 'isnot', 'ok', 'todo_is', 'todo_isnot', 'todo'];
+TEST_API.forEach(function(name) { sandbox[name] = window[name]; });
+sandbox.alienObject = {
+__exposedProps__: {funProp: 'r'},
+funProp: function foo(x) {
+return x + 1;
+}
+};
+sandbox.chromeGet = function (obj, prop) { return obj[prop]; };
+function COWTests() {
+// This function is actually decompiled and run inside a
+// sandbox with content privileges.
+// TODO: This could use some refactoring; creating helper
+// functions like assertIsWritable(myObj, 'someproperty') might
+// be useful.
+function isProp(obj, propName, value, desc) {
+try {
+is(obj[propName], value, "getting " + propName + " on " + desc);
+ok(propName in obj,
+propName + " on " + desc + " should exist");
+ok(Object.hasOwnProperty.call(obj, propName),
+propName + " on " + desc + " should exist");
+} catch (e) {
+ok(false, "getting " + propName + " on " + desc + " threw " + e);
+}
+}
+function isPropHidden(obj, propName, desc) {
+try {
+is(obj[propName], undefined,
+"getting " + propName + " on " + desc + " should return undefined");
+ok(!(propName in obj),
+propName + " on " + desc + " should act as if it doesn't exist");
+ok(!Object.hasOwnProperty.call(obj, propName),
+propName + " on " + desc + " should act as if it doesn't exist");
+} catch (e) {
+ok(false, "getting " + propName + " on " + desc + " threw " + e);
+}
+}
+const PROPS_TO_TEST = ['foo', 'bar', 'prototype'];
+var empty = {};
+var nonempty = {foo: 42, bar: 33};
+is(getCOW(empty).foo, undefined,
+"shouldn't throw when accessing exposed properties that doesn't exist");
+PROPS_TO_TEST.forEach(function(name) {
+isPropHidden(getCOW(nonempty), name, "object without exposedProps");
+});
+// Test function objects without __exposedProps__
+var func = function(x) { return 42; };
+func.foo = "foo property";
+var funcCOW = getCOW(func);
+PROPS_TO_TEST.forEach(function(name) {
+isPropHidden(funcCOW, name, "function without exposedProps");
+});
+is([name for (name in funcCOW)].length, 0,
+"function without exposedProps shouldn't have any properties");
+is(funcCOW(), 42, "COW without exposedProps should still be callable");
+// Test function objects with __exposedProps__
+var func = function(x) { return 42; };
+func.foo = "foo property";
+func.__exposedProps__ = { foo: "r" };
+var funcCOWr = getCOW(func);
+PROPS_TO_TEST.forEach(function(name) {
+if (name == "foo") {
+isProp(funcCOWr, name, "foo property",
+"function with exposedProps");
+}
+else {
+isPropHidden(funcCOWr, name, "function with exposedProps");
+}
+});
+is([name for (name in funcCOWr)].length, 1,
+"function with exposedProps should only enumerate exposed props");
+is([name for (name in funcCOWr)][0], "foo",
+"function with exposedProps should only enumerate exposed props");
+is(funcCOWr(), 42, "COW with exposedProps should be callable");
+// Test function objects with __exposedProps__
+var func = function(x) { return 42; };
+func.foo = "foo property";
+func.__exposedProps__ = { foo: "r", bar: "r" };
+var funcCOWr2 = getCOW(func);
+PROPS_TO_TEST.forEach(function(name) {
+if (name == "foo") {
+isProp(funcCOWr2, name, "foo property",
+"function with more exposedProps");
+}
+else {
+isPropHidden(funcCOWr2, name, "function with more exposedProps");
+}
+});
+is([name for (name in funcCOWr2)].length, 1,
+"function with exposedProps should only enumerate exposed props");
+is([name for (name in funcCOWr2)][0], "foo",
+"function with exposedProps should only enumerate exposed props");
+// Test object with empty exposedProps
+var strict = { __exposedProps__: {}, foo: "foo property" };
+var strictCOW = getCOW(strict);
+PROPS_TO_TEST.forEach(function(name) {
+isPropHidden(strictCOW, name, "object with empty exposedProps");
+});
+is([name for (name in strictCOW)].length, 0,
+"object with empty exposedProps shouldn't have any properties");
+// Test object with one exposed property
+var strict = { __exposedProps__: { foo: "r" }, foo: "foo property" };
+var strictCOWr = getCOW(strict);
+PROPS_TO_TEST.forEach(function(name) {
+if (name == "foo") {
+isProp(strictCOWr, name, "foo property",
+"object with exposed 'foo'");
+}
+else {
+isPropHidden(strictCOW, name, "object with exposed 'foo'");
+}
+});
+is([name for (name in strictCOWr)].length, 1,
+"object with exposedProps only enumerate exposed props");
+is([name for (name in strictCOWr)][0], "foo",
+"object with exposedProps only enumerate exposed props");
+// Test writable property
+var writable = getCOW({ __exposedProps__: {foo: 'w'}});
+try {
+ok(!("foo" in writable),
+"non-existing write-only property shouldn't exist");
+writable.foo = 5;
+is(chromeGet(writable, "foo"), 5, "writing to a write-only exposed prop works");
+todo("foo" in writable,
+"existing write-only property should exist");
+} catch (e) {
+ok(false, "writing to a write-only exposed prop shouldn't throw " + e);
+}
+try {
+writable.foo;
+todo(false, "reading from a write-only exposed prop should throw");
+} catch (e) {
+todo(/Permission denied/.test(e),
+"reading from a write-only exposed prop should throw");
+}
+try {
+delete writable.foo;
+is(chromeGet(writable, "foo"), undefined,
+"deleting a write-only exposed prop works");
+} catch (e) {
+ok(false, "deleting a write-only exposed prop shouldn't throw " + e);
+}
+// Test readable property
+var readable = { __exposedProps__: {foo: 'r'},
+foo: 5,
+bar: 6 };
+try {
+isProp(getCOW(readable), "foo", 5,
+"reading from a readable exposed prop works");
+} catch (e) {
+ok(false, "reading from a readable exposed prop shouldn't throw " + e);
+}
+try {
+getCOW(readable).foo = 1;
+ok(false, "writing to a read-only exposed prop should fail");
+} catch (e) {
+ok(/Permission denied/.test(e),
+"writing to a read-only exposed prop should fail");
+}
+try {
+delete getCOW(readable).foo;
+ok(false, "deleting a read-only exposed prop shouldn't work");
+} catch (e) {
+ok(/Permission denied/.test(e),
+"deleting a read-only exposed prop should throw error");
+}
+try {
+var props = [name for (name in getCOW(readable))];
+is(props.length, 1, "COW w/ one exposed prop should enumerate once");
+is(props[0], 'foo', "COW w/ one exposed prop should enumerate it");
+} catch (e) {
+ok(false, "COW w/ a readable prop should not raise exc " +
+"on enumeration: " + e);
+}
+// Test read/write property
+var readwrite = getCOW({ __exposedProps__: {foo: 'rw'}});
+try {
+ok(!("foo" in readwrite),
+"non-existing readwrite property shouldn't exist");
+readwrite.foo = 5;
+is(readwrite.foo, 5, "writing to a readwrite exposed prop looks like it worked");
+is(chromeGet(readwrite, "foo"), 5, "writing to a readwrite exposed prop works");
+ok("foo" in readwrite,
+"existing readwrite property should exist");
+} catch (e) {
+ok(false, "writing to a readwrite exposed prop shouldn't throw " + e);
+}
+try {
+delete readwrite.foo;
+is(readwrite.foo, undefined, "deleting readwrite prop looks like it worked");
+ok(!("foo" in readwrite), "deleting readwrite prop looks like it really worked");
+is(chromeGet(readwrite, "foo"), undefined,
+"deleting a readwrite exposed prop works");
+} catch (e) {
+ok(false, "deleting a readwrite exposed prop shouldn't throw " + e);
+}
+// Readables and functions
+try {
+var COWFunc = getCOW((function() { return 5; }));
+is(COWFunc(), 5, "COWed functions should be callable");
+} catch (e) {
+todo(false, "COWed functions should not raise " + e);
+}
+try {
+var objWithFunc = {__exposedProps__: {foo: 'r'},
+foo: function foo() { return 5; }};
+is(getCOW((objWithFunc)).foo(), 5,
+"Readable function exposed props should be callable");
+} catch (e) {
+ok(false, "Readable function exposed props should be callable" + e);
+}
+// Readables with getters
+var obj = {
+get prop() { return { __exposedProps__: {}, test: "FAIL" } },
+__exposedProps__: {prop: 'r'}
+};
+is(getCOW(obj).prop.test, undefined, "getting prop.test shouldn't return anything");
+ok(!("test" in getCOW(obj).prop), "getting prop.test shouldn't return anything");
+// Alien objects
+try {
+is(alienObject.funProp(1), 2,
+"COWs wrapping objects from different principals should work");
+} catch (e) {
+ok(false, "COWs wrapping objs from different principals " +
+"shouldn't throw " + e);
+}
+try {
+is(alienObject.funProp(1), 2,
+"COWs wrapping objs from different principals should work twice");
+} catch (e) {
+ok(false, "COWs wrapping objs from different principals " +
+"shouldn't throw on second access but not first: " + e);
+}
+}
+// Decompile the COW test suite, re-evaluate it in the sandbox and execute it.
+Cu.evalInSandbox('(' + uneval(COWTests) + ')()', sandbox);
+// Test that COWed objects passing from content to chrome get unwrapped.
+function returnCOW() {
+return getCOW({__exposedProps__: {},
+bar: 6});
+}
+var unwrapped = Cu.evalInSandbox(
+'(' + uneval(returnCOW) + ')()',
+sandbox
+);
+try {
+is(unwrapped.bar, 6,
+"COWs should be unwrapped when entering chrome space");
+} catch (e) {
+todo(false, "COWs should be unwrapped when entering chrome space, " +
+"not raise " + e);
+}
+]]></script>
+</window>

The Tor Browser / file comparison

comparison: js/xpconnect/tests/chrome/test_cows.xul

js/xpconnect/tests/chrome/test_cows.xul