tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

import-namespace.js (3687B)

      1 // |jit-test|
      2 // Test importing module namespaces
      3 
      4 "use strict";
      5 
      6 load(libdir + "asserts.js");
      7 load(libdir + "iteration.js");
      8 
      9 function parseAndEvaluate(source) {
     10    let m = parseModule(source);
     11    moduleLink(m);
     12    return moduleEvaluate(m);
     13 }
     14 
     15 function testHasNames(names, expected) {
     16    assertEq(names.length, expected.length);
     17    expected.forEach(function(name) {
     18        assertEq(names.includes(name), true);
     19    });
     20 }
     21 
     22 function testEqualArrays(actual, expected) {
     23 assertEq(Array.isArray(actual), true);
     24 assertEq(Array.isArray(expected), true);
     25    assertEq(actual.length, expected.length);
     26    for (let i = 0; i < expected.length; i++) {
     27    	assertEq(actual[i], expected[i]);
     28    }
     29 }
     30 
     31 let a = registerModule('a', parseModule(
     32    `// Reflection methods should return these exports alphabetically sorted.
     33     export var b = 2;
     34     export var a = 1;`
     35 ));
     36 
     37 let b = registerModule('b', parseModule(
     38    `import * as ns from 'a';
     39     export { ns };
     40     export var x = ns.a + ns.b;`
     41 ));
     42 
     43 moduleLink(b);
     44 moduleEvaluate(b);
     45 testHasNames(getModuleEnvironmentNames(b), ["ns", "x"]);
     46 let ns = getModuleEnvironmentValue(b, "ns");
     47 testHasNames(Object.keys(ns), ["a", "b"]);
     48 assertEq(ns.a, 1);
     49 assertEq(ns.b, 2);
     50 assertEq(ns.c, undefined);
     51 assertEq(getModuleEnvironmentValue(b, "x"), 3);
     52 
     53 // Test module namespace internal methods as defined in 9.4.6
     54 assertEq(Object.getPrototypeOf(ns), null);
     55 assertEq(Reflect.setPrototypeOf(ns, null), true);
     56 assertEq(Reflect.setPrototypeOf(ns, Object.prototype), false);
     57 assertThrowsInstanceOf(() => Object.setPrototypeOf(ns, {}), TypeError);
     58 assertThrowsInstanceOf(function() { ns.foo = 1; }, TypeError);
     59 assertEq(Object.isExtensible(ns), false);
     60 Object.preventExtensions(ns);
     61 let desc = Object.getOwnPropertyDescriptor(ns, "a");
     62 assertEq(desc.value, 1);
     63 assertEq(desc.writable, true);
     64 assertEq(desc.enumerable, true);
     65 assertEq(desc.configurable, false);
     66 assertEq(typeof desc.get, "undefined");
     67 assertEq(typeof desc.set, "undefined");
     68 assertThrowsInstanceOf(function() { ns.a = 1; }, TypeError);
     69 delete ns.foo;
     70 assertThrowsInstanceOf(function() { delete ns.a; }, TypeError);
     71 
     72 // Test @@toStringTag property
     73 desc = Object.getOwnPropertyDescriptor(ns, Symbol.toStringTag);
     74 assertEq(desc.value, "Module");
     75 assertEq(desc.writable, false);
     76 assertEq(desc.enumerable, false);
     77 assertEq(desc.configurable, false);
     78 assertEq(typeof desc.get, "undefined");
     79 assertEq(typeof desc.set, "undefined");
     80 assertEq(Object.prototype.toString.call(ns), "[object Module]");
     81 
     82 // Test [[OwnPropertyKeys]] internal method.
     83 testEqualArrays(Reflect.ownKeys(ns), ["a", "b", Symbol.toStringTag]);
     84 testEqualArrays(Object.getOwnPropertyNames(ns), ["a", "b"]);
     85 testEqualArrays(Object.getOwnPropertySymbols(ns), [Symbol.toStringTag]);
     86 
     87 // Test cyclic namespace import and access in module evaluation.
     88 let c = registerModule('c',
     89    parseModule("export let c = 1; import * as ns from 'd'; let d = ns.d;"));
     90 let d = registerModule('d',
     91    parseModule("export let d = 2; import * as ns from 'c'; let c = ns.c;"));
     92 moduleLink(c);
     93 moduleLink(d);
     94 moduleEvaluate(c)
     95  .then(r => {
     96    // We expect the evaluation to throw, so we should not reach this.
     97    assertEq(false, true)
     98  })
     99  .catch(e => {
    100   assertEq(e instanceof ReferenceError, true)
    101  });
    102 
    103 // Test cyclic namespace import.
    104 let e = registerModule('e',
    105    parseModule("export let e = 1; import * as ns from 'f'; export function f() { return ns.f }"));
    106 let f = registerModule('f',
    107    parseModule("export let f = 2; import * as ns from 'e'; export function e() { return ns.e }"));
    108 moduleLink(e);
    109 moduleLink(f);
    110 moduleEvaluate(e);
    111 moduleEvaluate(f);
    112 assertEq(e.namespace.f(), 2);
    113 assertEq(f.namespace.e(), 1);
    114 drainJobQueue();