Quelle test_cows.xhtml Sprache: unbekannt

Spracherkennung für: .xhtml vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]

<?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"?>

<window title="Mozilla Bug 522764"
  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>

  
  <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>

  
  <script type="application/javascript"><![CDATA[
add_task(async () => {
var sandbox = new Cu.Sandbox("about:blank");

await SpecialPowers.pushPrefEnv({"set": [["security.allow_eval_with_system_principal",
                                          true]]});

/* eslint-disable no-eval */

function getCOW(x) {
  if (typeof x != 'object' && typeof x != 'function')
    return x;
  x = Cu.waiveXrays(x);
  var rval = {};
  if (typeof x == "function")
    rval = eval(`(${x.toString()})`);
  for (var i in x) {
    if (x.__lookupGetter__(i))
      rval.__defineGetter__(i, eval(`(${x.__lookupGetter__(i).toString()})`))
    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.chromeGet = function (obj, prop) { return obj[prop]; };

function COWTests() {
    function getNames(cow) {
        let names = [];
        for (let name in cow) {
            names.push(name);
        }
        return names;
    }

    // This function is actually stringified 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 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 don't exist");

    PROPS_TO_TEST.forEach(function(name) {
        isPropHidden(getCOW(nonempty), name, "object without exposedProps");
    });

    // Test function objects.
    var func = function() { return 42; };
    func.foo = "foo property";
    var funcCOW = getCOW(func);
    try {
      funcCOW.foo;
      ok(false, 'Functions are no longer COWable');
    } catch (e) {
      ok(/denied|insecure/.test(e), 'Functions are no longer COWable');
    }
    is(funcCOW(), 42, "Chrome functions should be callable");

    // Test writable property
    var writable = getCOW({});
    try {
        ok(!("foo" in writable),
           "non-existing write-only property shouldn't exist");
        writable.foo = 5;
        ok(false, "writing to a write-only exposed prop should throw");
    } catch (e) {
        ok(/Permission denied/.test(e),
           "writing to a write-only exposed prop should throw the right error");
    }
    is(writable.foo, undefined,
       "reading from a write-only exposed prop should return undefined");
    try {
        delete writable.foo;
        ok(false, "deleting a write-only exposed prop should throw");
    } catch (e) {
        ok(true, "deleting a write-only exposed prop should throw " + e);
    }

    // Test readable property
    var readable = { foo: 5,
                     bar: 6 };
    try {
        isPropHidden(getCOW(readable), "foo", undefined,
                     "reading from a readable exposed prop shouldn't work");
    } 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 = getNames(getCOW(readable));
        is(props.length, 0, "COW w/ one exposed prop should not enumerate");
    } catch (e) {
        ok(false, "COW w/ a readable prop should not raise exc " +
                  "on enumeration: " + e);
    }

    // Test read/write property
    var readwrite = getCOW({});
    try {
        ok(!("foo" in readwrite),
           "non-existing readwrite property shouldn't exist");
        readwrite.foo = 5;
        ok(false, "writing to a readwrite exposed prop should throw");
    } catch (e) {
        ok(/Permission denied/.test(e),
           "writing to a readwrite exposed prop should throw the right error");
    }
    try {
        delete readwrite.foo;
        ok(false, "deleting a readwrite prop should throw");
    } catch (e) {
        ok(/Permission denied/.test(e),
           "deleting a readwrite exposed prop should throw the right error");
    }

    // 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);
    }
}

// Stringify the COW test suite and directly evaluate it in the sandbox.
Cu.evalInSandbox('(' + COWTests.toString() + ')()', sandbox);

// Test that COWed objects passing from content to chrome get unwrapped.
function returnCOW() {
    return getCOW({bar: 6});
}

var unwrapped = Cu.evalInSandbox(
    '(' + returnCOW.toString() + ')()',
    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>

Quelle test_cows.xhtml Sprache: unbekannt

[ Dauer der Verarbeitung: 0.34 Sekunden ]