How to use exposure_set method in wpt

Best JavaScript code snippet using wpt

aflprep_idlharness.js

Source:aflprep_idlharness.js Github

copy

Full Screen

...483 }484 return false;485 }486};487function exposure_set(object, default_set) {488 var exposed = object.extAttrs && object.extAttrs.filter(a => a.name === "Exposed");489 if (exposed && exposed.length > 1) {490 throw new IdlHarnessError(491 `Multiple 'Exposed' extended attributes on ${object.name}`);492 }493 let result = default_set || ["Window"];494 if (result && !(result instanceof Set)) {495 result = new Set(result);496 }497 if (exposed && exposed.length) {498 const { rhs } = exposed[0];499 const set = rhs.type === "identifier-list" ?500 rhs.value.map(id => id.value) :501 [ rhs.value ];502 result = new Set(set);503 }504 if (result && result.has("Worker")) {505 result.delete("Worker");506 result.add("DedicatedWorker");507 result.add("ServiceWorker");508 result.add("SharedWorker");509 }510 return result;511}512function exposed_in(globals) {513 if ('Window' in self) {514 return globals.has("Window");515 }516 if ('DedicatedWorkerGlobalScope' in self &&517 self instanceof DedicatedWorkerGlobalScope) {518 return globals.has("DedicatedWorker");519 }520 if ('SharedWorkerGlobalScope' in self &&521 self instanceof SharedWorkerGlobalScope) {522 return globals.has("SharedWorker");523 }524 if ('ServiceWorkerGlobalScope' in self &&525 self instanceof ServiceWorkerGlobalScope) {526 return globals.has("ServiceWorker");527 }528 throw new IdlHarnessError("Unexpected global object");529}530 * Asserts that the given error message is thrown for the given function.531 * @param {string|IdlHarnessError} error Expected Error message.532 * @param {Function} idlArrayFunc Function operating on an IdlArray that should throw.533IdlArray.prototype.assert_throws = function(error, idlArrayFunc)534{535 try {536 idlArrayFunc.call(this, this);537 } catch (e) {538 if (e instanceof AssertionError) {539 throw e;540 }541 if (error instanceof IdlHarnessError) {542 error = error.message;543 }544 if (e.message !== error) {545 throw new IdlHarnessError(`${idlArrayFunc} threw "${e}", not the expected IdlHarnessError "${error}"`);546 }547 return;548 }549 throw new IdlHarnessError(`${idlArrayFunc} did not throw the expected IdlHarnessError`);550}551IdlArray.prototype.test = function()552{553 this.merge_partials();554 this.merge_mixins();555 for (const member of Object.values(this.members).filter(m => m.base)) {556 const lhs = member.name;557 const rhs = member.base;558 if (!(rhs in this.members)) throw new IdlHarnessError(`${lhs} inherits ${rhs}, but ${rhs} is undefined.`);559 const lhs_is_interface = this.members[lhs] instanceof IdlInterface;560 const rhs_is_interface = this.members[rhs] instanceof IdlInterface;561 if (rhs_is_interface != lhs_is_interface) {562 if (!lhs_is_interface) throw new IdlHarnessError(`${lhs} inherits ${rhs}, but ${lhs} is not an interface.`);563 if (!rhs_is_interface) throw new IdlHarnessError(`${lhs} inherits ${rhs}, but ${rhs} is not an interface.`);564 }565 member.get_reverse_inheritance_stack();566 }567 Object.getOwnPropertyNames(this.members).forEach(function(memberName) {568 var member = this.members[memberName];569 if (!(member instanceof IdlInterface)) {570 return;571 }572 var globals = exposure_set(member);573 member.exposed = exposed_in(globals);574 member.exposureSet = globals;575 }.bind(this));576 for (var name in this.members)577 {578 this.members[name].test();579 if (name in this.objects)580 {581 const objects = this.objects[name];582 if (!objects || !Array.isArray(objects)) {583 throw new IdlHarnessError(`Invalid or empty objects for member ${name}`);584 }585 objects.forEach(function(str)586 {587 if (!this.members[name] || !(this.members[name] instanceof IdlInterface)) {588 throw new IdlHarnessError(`Invalid object member name ${name}`);589 }590 this.members[name].test_object(str);591 }.bind(this));592 }593 }594};595IdlArray.prototype.merge_partials = function()596{597 const testedPartials = new Map();598 this.partials.forEach(function(parsed_idl)599 {600 const originalExists = parsed_idl.name in this.members601 && (this.members[parsed_idl.name] instanceof IdlInterface602 || this.members[parsed_idl.name] instanceof IdlDictionary603 || this.members[parsed_idl.name] instanceof IdlNamespace);604 let partialTestName = parsed_idl.name;605 let partialTestCount = 1;606 if (testedPartials.has(parsed_idl.name)) {607 partialTestCount += testedPartials.get(parsed_idl.name);608 partialTestName = `${partialTestName}[${partialTestCount}]`;609 }610 testedPartials.set(parsed_idl.name, partialTestCount);611 if (!parsed_idl.untested) {612 test(function () {613 assert_true(originalExists, `Original ${parsed_idl.type} should be defined`);614 var expected;615 switch (parsed_idl.type) {616 case 'dictionary': expected = IdlDictionary; break;617 case 'namespace': expected = IdlNamespace; break;618 case 'interface':619 case 'interface mixin':620 default:621 expected = IdlInterface; break;622 }623 assert_true(624 expected.prototype.isPrototypeOf(this.members[parsed_idl.name]),625 `Original ${parsed_idl.name} definition should have type ${parsed_idl.type}`);626 }.bind(this), `Partial ${parsed_idl.type} ${partialTestName}: original ${parsed_idl.type} defined`);627 }628 if (!originalExists) {629 return;630 }631 if (parsed_idl.extAttrs)632 {633 const exposureAttr = parsed_idl.extAttrs.find(a => a.name === "Exposed");634 if (exposureAttr) {635 if (!parsed_idl.untested) {636 test(function () {637 const partialExposure = exposure_set(parsed_idl);638 const memberExposure = exposure_set(this.members[parsed_idl.name]);639 partialExposure.forEach(name => {640 if (!memberExposure || !memberExposure.has(name)) {641 throw new IdlHarnessError(642 `Partial ${parsed_idl.name} ${parsed_idl.type} is exposed to '${name}', the original ${parsed_idl.type} is not.`);643 }644 });645 }.bind(this), `Partial ${parsed_idl.type} ${partialTestName}: valid exposure set`);646 }647 parsed_idl.members.forEach(function (member) {648 member.extAttrs.push(exposureAttr);649 }.bind(this));650 }651 parsed_idl.extAttrs.forEach(function(extAttr)652 {653 if (extAttr.name === "Exposed") {654 return;655 }656 this.members[parsed_idl.name].extAttrs.push(extAttr);657 }.bind(this));658 }659 if (parsed_idl.members.length) {660 test(function () {661 var clash = parsed_idl.members.find(function(member) {662 return this.members[parsed_idl.name].members.find(function(m) {663 return this.are_duplicate_members(m, member);664 }.bind(this));665 }.bind(this));666 parsed_idl.members.forEach(function(member)667 {668 this.members[parsed_idl.name].members.push(new IdlInterfaceMember(member));669 }.bind(this));670 assert_true(!clash, "member " + (clash && clash.name) + " is unique");671 }.bind(this), `Partial ${parsed_idl.type} ${partialTestName}: member names are unique`);672 }673 }.bind(this));674 this.partials = [];675}676IdlArray.prototype.merge_mixins = function()677{678 for (const parsed_idl of this.includes)679 {680 const lhs = parsed_idl.target;681 const rhs = parsed_idl.includes;682 var errStr = lhs + " includes " + rhs + ", but ";683 if (!(lhs in this.members)) throw errStr + lhs + " is undefined.";684 if (!(this.members[lhs] instanceof IdlInterface)) throw errStr + lhs + " is not an interface.";685 if (!(rhs in this.members)) throw errStr + rhs + " is undefined.";686 if (!(this.members[rhs] instanceof IdlInterface)) throw errStr + rhs + " is not an interface.";687 if (this.members[rhs].members.length) {688 test(function () {689 var clash = this.members[rhs].members.find(function(member) {690 return this.members[lhs].members.find(function(m) {691 return this.are_duplicate_members(m, member);692 }.bind(this));693 }.bind(this));694 this.members[rhs].members.forEach(function(member) {695 assert_true(696 this.members[lhs].members.every(m => !this.are_duplicate_members(m, member)),697 "member " + member.name + " is unique");698 this.members[lhs].members.push(new IdlInterfaceMember(member));699 }.bind(this));700 assert_true(!clash, "member " + (clash && clash.name) + " is unique");701 }.bind(this), lhs + " includes " + rhs + ": member names are unique");702 }703 }704 this.includes = [];705}706IdlArray.prototype.are_duplicate_members = function(m1, m2) {707 if (m1.name !== m2.name) {708 return false;709 }710 if (m1.type === 'operation' && m2.type === 'operation'711 && m1.arguments.length !== m2.arguments.length) {712 return false;713 }714 return true;715}716IdlArray.prototype.assert_type_is = function(value, type)717{718 if (type.idlType in this.members719 && this.members[type.idlType] instanceof IdlTypedef) {720 this.assert_type_is(value, this.members[type.idlType].idlType);721 return;722 }723 if (type.nullable && value === null)724 {725 return;726 }727 if (type.union) {728 for (var i = 0; i < type.idlType.length; i++) {729 try {730 this.assert_type_is(value, type.idlType[i]);731 return;732 } catch(e) {733 if (e instanceof AssertionError) {734 continue;735 }736 throw e;737 }738 }739 assert_true(false, "Attribute has value " + format_value(value)740 + " which doesn't match any of the types in the union");741 }742 * Helper function that tests that value is an instance of type according743 * to the rules of WebIDL. value is any JavaScript value, and type is an744 * object produced by WebIDLParser.js' "type" production. That production745 * is fairly elaborate due to the complexity of WebIDL's types, so it's746 * best to look at the grammar to figure out what properties it might have.747 if (type.idlType == "any")748 {749 return;750 }751 if (type.array)752 {753 return;754 }755 if (type.generic === "sequence")756 {757 assert_true(Array.isArray(value), "should be an Array");758 if (!value.length)759 {760 return;761 }762 this.assert_type_is(value[0], type.idlType[0]);763 return;764 }765 if (type.generic === "Promise") {766 assert_true("then" in value, "Attribute with a Promise type should have a then property");767 return;768 }769 if (type.generic === "FrozenArray") {770 assert_true(Array.isArray(value), "Value should be array");771 assert_true(Object.isFrozen(value), "Value should be frozen");772 if (!value.length)773 {774 return;775 }776 this.assert_type_is(value[0], type.idlType[0]);777 return;778 }779 type = Array.isArray(type.idlType) ? type.idlType[0] : type.idlType;780 switch(type)781 {782 case "undefined":783 assert_equals(value, undefined);784 return;785 case "boolean":786 assert_equals(typeof value, "boolean");787 return;788 case "byte":789 assert_equals(typeof value, "number");790 assert_equals(value, Math.floor(value), "should be an integer");791 assert_true(-128 <= value && value <= 127, "byte " + value + " should be in range [-128, 127]");792 return;793 case "octet":794 assert_equals(typeof value, "number");795 assert_equals(value, Math.floor(value), "should be an integer");796 assert_true(0 <= value && value <= 255, "octet " + value + " should be in range [0, 255]");797 return;798 case "short":799 assert_equals(typeof value, "number");800 assert_equals(value, Math.floor(value), "should be an integer");801 assert_true(-32768 <= value && value <= 32767, "short " + value + " should be in range [-32768, 32767]");802 return;803 case "unsigned short":804 assert_equals(typeof value, "number");805 assert_equals(value, Math.floor(value), "should be an integer");806 assert_true(0 <= value && value <= 65535, "unsigned short " + value + " should be in range [0, 65535]");807 return;808 case "long":809 assert_equals(typeof value, "number");810 assert_equals(value, Math.floor(value), "should be an integer");811 assert_true(-2147483648 <= value && value <= 2147483647, "long " + value + " should be in range [-2147483648, 2147483647]");812 return;813 case "unsigned long":814 assert_equals(typeof value, "number");815 assert_equals(value, Math.floor(value), "should be an integer");816 assert_true(0 <= value && value <= 4294967295, "unsigned long " + value + " should be in range [0, 4294967295]");817 return;818 case "long long":819 assert_equals(typeof value, "number");820 return;821 case "unsigned long long":822 case "DOMTimeStamp":823 assert_equals(typeof value, "number");824 assert_true(0 <= value, "unsigned long long should be positive");825 return;826 case "float":827 assert_equals(typeof value, "number");828 assert_equals(value, Math.fround(value), "float rounded to 32-bit float should be itself");829 assert_not_equals(value, Infinity);830 assert_not_equals(value, -Infinity);831 assert_not_equals(value, NaN);832 return;833 case "DOMHighResTimeStamp":834 case "double":835 assert_equals(typeof value, "number");836 assert_not_equals(value, Infinity);837 assert_not_equals(value, -Infinity);838 assert_not_equals(value, NaN);839 return;840 case "unrestricted float":841 assert_equals(typeof value, "number");842 assert_equals(value, Math.fround(value), "unrestricted float rounded to 32-bit float should be itself");843 return;844 case "unrestricted double":845 assert_equals(typeof value, "number");846 return;847 case "DOMString":848 assert_equals(typeof value, "string");849 return;850 case "ByteString":851 assert_equals(typeof value, "string");852 return;853 case "USVString":854 assert_equals(typeof value, "string");855 return;856 case "ArrayBufferView":857 assert_true(ArrayBuffer.isView(value));858 return;859 case "object":860 assert_in_array(typeof value, ["object", "function"], "wrong type: not object or function");861 return;862 }863 if (!(type in this.members))864 {865 assert_true(value instanceof self[type], "wrong type: not a " + type);866 return;867 }868 if (this.members[type] instanceof IdlInterface)869 {870 assert_in_array(typeof value, ["object", "function"], "wrong type: not object or function");871 if (value instanceof Object872 && !this.members[type].has_extended_attribute("LegacyNoInterfaceObject")873 && type in self)874 {875 assert_true(value instanceof self[type], "instanceof " + type);876 }877 }878 else if (this.members[type] instanceof IdlEnum)879 {880 assert_equals(typeof value, "string");881 }882 else if (this.members[type] instanceof IdlDictionary)883 {884 }885 else if (this.members[type] instanceof IdlCallback)886 {887 assert_equals(typeof value, "function");888 }889 else890 {891 throw new IdlHarnessError("Type " + type + " isn't an interface, callback or dictionary");892 }893};894function IdlObject() {}895IdlObject.prototype.test = function()896{897 * By default, this does nothing, so no actual tests are run for IdlObjects898 * that don't define any (e.g., IdlDictionary at the time of this writing).899};900IdlObject.prototype.has_extended_attribute = function(name)901{902 * This is only meaningful for things that support extended attributes,903 * such as interfaces, exceptions, and members.904 return this.extAttrs.some(function(o)905 {906 return o.name == name;907 });908};909function IdlDictionary(obj)910{911 * obj is an object produced by the WebIDLParser.js "dictionary"912 * production.913 this.name = obj.name;914 this.array = obj.array;915 this.members = obj.members;916 * The name (as a string) of the dictionary type we inherit from, or null917 * if there is none.918 this.base = obj.inheritance;919}920IdlDictionary.prototype = Object.create(IdlObject.prototype);921IdlDictionary.prototype.get_reverse_inheritance_stack = function() {922 return IdlInterface.prototype.get_reverse_inheritance_stack.call(this);923};924function IdlInterface(obj, is_callback, is_mixin)925{926 * obj is an object produced by the WebIDLParser.js "interface" production.927 this.name = obj.name;928 this.array = obj.array;929 * An indicator of whether we should run tests on the interface object and930 * interface prototype object. Tests on members are controlled by .untested931 * on each member, not this.932 this.untested = obj.untested;933 this.extAttrs = obj.extAttrs;934 this.members = obj.members.map(function(m){return new IdlInterfaceMember(m); });935 if (this.has_extended_attribute("LegacyUnforgeable")) {936 this.members937 .filter(function(m) { return m.special !== "static" && (m.type == "attribute" || m.type == "operation"); })938 .forEach(function(m) { return m.isUnforgeable = true; });939 }940 * The name (as a string) of the type we inherit from, or null if there is941 * none.942 this.base = obj.inheritance;943 this._is_callback = is_callback;944 this._is_mixin = is_mixin;945}946IdlInterface.prototype = Object.create(IdlObject.prototype);947IdlInterface.prototype.is_callback = function()948{949 return this._is_callback;950};951IdlInterface.prototype.is_mixin = function()952{953 return this._is_mixin;954};955IdlInterface.prototype.has_constants = function()956{957 return this.members.some(function(member) {958 return member.type === "const";959 });960};961IdlInterface.prototype.get_unscopables = function()962{963 return this.members.filter(function(member) {964 return member.isUnscopable;965 });966};967IdlInterface.prototype.is_global = function()968{969 return this.extAttrs.some(function(attribute) {970 return attribute.name === "Global";971 });972};973 * Value of the LegacyNamespace extended attribute, if any.974 *975IdlInterface.prototype.get_legacy_namespace = function()976{977 var legacyNamespace = this.extAttrs.find(function(attribute) {978 return attribute.name === "LegacyNamespace";979 });980 return legacyNamespace ? legacyNamespace.rhs.value : undefined;981};982IdlInterface.prototype.get_interface_object_owner = function()983{984 var legacyNamespace = this.get_legacy_namespace();985 return legacyNamespace ? self[legacyNamespace] : self;986};987IdlInterface.prototype.should_have_interface_object = function()988{989 return this.is_callback() ? this.has_constants() : !this.has_extended_attribute("LegacyNoInterfaceObject");990};991IdlInterface.prototype.assert_interface_object_exists = function()992{993 var owner = this.get_legacy_namespace() || "self";994 assert_own_property(self[owner], this.name, owner + " does not have own property " + format_value(this.name));995};996IdlInterface.prototype.get_interface_object = function() {997 if (!this.should_have_interface_object()) {998 var reason = this.is_callback() ? "lack of declared constants" : "declared [LegacyNoInterfaceObject] attribute";999 throw new IdlHarnessError(this.name + " has no interface object due to " + reason);1000 }1001 return this.get_interface_object_owner()[this.name];1002};1003IdlInterface.prototype.get_qualified_name = function() {1004 var legacyNamespace = this.get_legacy_namespace();1005 if (legacyNamespace) {1006 return legacyNamespace + "." + this.name;1007 }1008 return this.name;1009};1010IdlInterface.prototype.has_to_json_regular_operation = function() {1011 return this.members.some(function(m) {1012 return m.is_to_json_regular_operation();1013 });1014};1015IdlInterface.prototype.has_default_to_json_regular_operation = function() {1016 return this.members.some(function(m) {1017 return m.is_to_json_regular_operation() && m.has_extended_attribute("Default");1018 });1019};1020 * with the order reversed.1021 *1022 * The order is reversed so that the base class comes first in the list, because1023 * this is what all call sites need.1024 *1025 * So given:1026 *1027 * A : B {};1028 * B : C {};1029 * C {};1030 *1031 * then A.get_reverse_inheritance_stack() returns [C, B, A],1032 * and B.get_reverse_inheritance_stack() returns [C, B].1033 *1034 * Note: as dictionary inheritance is expressed identically by the AST,1035 * this works just as well for getting a stack of inherited dictionaries.1036IdlInterface.prototype.get_reverse_inheritance_stack = function() {1037 const stack = [this];1038 let idl_interface = this;1039 while (idl_interface.base) {1040 const base = this.array.members[idl_interface.base];1041 if (!base) {1042 throw new Error(idl_interface.type + " " + idl_interface.base + " not found (inherited by " + idl_interface.name + ")");1043 } else if (stack.indexOf(base) > -1) {1044 stack.unshift(base);1045 const dep_chain = stack.map(i => i.name).join(',');1046 throw new IdlHarnessError(`${this.name} has a circular dependency: ${dep_chain}`);1047 }1048 idl_interface = base;1049 stack.unshift(idl_interface);1050 }1051 return stack;1052};1053 * Implementation of1054 * for testing purposes.1055 *1056 * Collects the IDL types of the attributes that meet the criteria1057 * for inclusion in the default toJSON operation for easy1058 * comparison with actual value1059IdlInterface.prototype.default_to_json_operation = function() {1060 const map = new Map()1061 let isDefault = false;1062 for (const I of this.get_reverse_inheritance_stack()) {1063 if (I.has_default_to_json_regular_operation()) {1064 isDefault = true;1065 for (const m of I.members) {1066 if (m.special !== "static" && m.type == "attribute" && I.array.is_json_type(m.idlType)) {1067 map.set(m.name, m.idlType);1068 }1069 }1070 } else if (I.has_to_json_regular_operation()) {1071 isDefault = false;1072 }1073 }1074 return isDefault ? map : null;1075};1076IdlInterface.prototype.test = function()1077{1078 if (this.has_extended_attribute("LegacyNoInterfaceObject") || this.is_mixin())1079 {1080 return;1081 }1082 if (!this.exposed)1083 {1084 if (!this.untested)1085 {1086 subsetTestByKey(this.name, test, function() {1087 assert_false(this.name in self);1088 }.bind(this), this.name + " interface: existence and properties of interface object");1089 }1090 return;1091 }1092 if (!this.untested)1093 {1094 this.test_self();1095 }1096 this.test_members();1097};1098IdlInterface.prototype.constructors = function()1099{1100 return this.members1101 .filter(function(m) { return m.type == "constructor"; });1102}1103IdlInterface.prototype.test_self = function()1104{1105 subsetTestByKey(this.name, test, function()1106 {1107 if (!this.should_have_interface_object()) {1108 return;1109 }1110 this.assert_interface_object_exists();1111 var desc = Object.getOwnPropertyDescriptor(this.get_interface_object_owner(), this.name);1112 assert_false("get" in desc, "self's property " + format_value(this.name) + " should not have a getter");1113 assert_false("set" in desc, "self's property " + format_value(this.name) + " should not have a setter");1114 assert_true(desc.writable, "self's property " + format_value(this.name) + " should be writable");1115 assert_false(desc.enumerable, "self's property " + format_value(this.name) + " should not be enumerable");1116 assert_true(desc.configurable, "self's property " + format_value(this.name) + " should be configurable");1117 if (this.is_callback()) {1118 assert_equals(Object.getPrototypeOf(this.get_interface_object()), Function.prototype,1119 "prototype of self's property " + format_value(this.name) + " is not Object.prototype");1120 return;1121 }1122 assert_class_string(this.get_interface_object(), "Function", "class string of " + this.name);1123 var prototype = Object.getPrototypeOf(this.get_interface_object());1124 if (this.base) {1125 var inherited_interface = this.array.members[this.base];1126 if (!inherited_interface.has_extended_attribute("LegacyNoInterfaceObject")) {1127 inherited_interface.assert_interface_object_exists();1128 assert_equals(prototype, inherited_interface.get_interface_object(),1129 'prototype of ' + this.name + ' is not ' +1130 this.base);1131 }1132 } else {1133 assert_equals(prototype, Function.prototype,1134 "prototype of self's property " + format_value(this.name) + " is not Function.prototype");1135 }1136 assert_true(isConstructor(this.get_interface_object()), "interface object must pass IsConstructor check");1137 if (!this.constructors().length) {1138 var interface_object = this.get_interface_object();1139 assert_throws_js(globalOf(interface_object).TypeError, function() {1140 interface_object();1141 }, "interface object didn't throw TypeError when called as a function");1142 assert_throws_js(globalOf(interface_object).TypeError, function() {1143 new interface_object();1144 }, "interface object didn't throw TypeError when called as a constructor");1145 }1146 }.bind(this), this.name + " interface: existence and properties of interface object");1147 if (this.should_have_interface_object() && !this.is_callback()) {1148 subsetTestByKey(this.name, test, function() {1149 this.assert_interface_object_exists();1150 assert_own_property(this.get_interface_object(), "length");1151 var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), "length");1152 assert_false("get" in desc, this.name + ".length should not have a getter");1153 assert_false("set" in desc, this.name + ".length should not have a setter");1154 assert_false(desc.writable, this.name + ".length should not be writable");1155 assert_false(desc.enumerable, this.name + ".length should not be enumerable");1156 assert_true(desc.configurable, this.name + ".length should be configurable");1157 var constructors = this.constructors();1158 var expected_length = minOverloadLength(constructors);1159 assert_equals(this.get_interface_object().length, expected_length, "wrong value for " + this.name + ".length");1160 }.bind(this), this.name + " interface object length");1161 }1162 if (this.should_have_interface_object()) {1163 subsetTestByKey(this.name, test, function() {1164 this.assert_interface_object_exists();1165 assert_own_property(this.get_interface_object(), "name");1166 var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), "name");1167 assert_false("get" in desc, this.name + ".name should not have a getter");1168 assert_false("set" in desc, this.name + ".name should not have a setter");1169 assert_false(desc.writable, this.name + ".name should not be writable");1170 assert_false(desc.enumerable, this.name + ".name should not be enumerable");1171 assert_true(desc.configurable, this.name + ".name should be configurable");1172 assert_equals(this.get_interface_object().name, this.name, "wrong value for " + this.name + ".name");1173 }.bind(this), this.name + " interface object name");1174 }1175 if (this.has_extended_attribute("LegacyWindowAlias")) {1176 subsetTestByKey(this.name, test, function()1177 {1178 var aliasAttrs = this.extAttrs.filter(function(o) { return o.name === "LegacyWindowAlias"; });1179 if (aliasAttrs.length > 1) {1180 throw new IdlHarnessError("Invalid IDL: multiple LegacyWindowAlias extended attributes on " + this.name);1181 }1182 if (this.is_callback()) {1183 throw new IdlHarnessError("Invalid IDL: LegacyWindowAlias extended attribute on non-interface " + this.name);1184 }1185 if (!this.exposureSet.has("Window")) {1186 throw new IdlHarnessError("Invalid IDL: LegacyWindowAlias extended attribute on " + this.name + " which is not exposed in Window");1187 }1188 var rhs = aliasAttrs[0].rhs;1189 if (!rhs) {1190 throw new IdlHarnessError("Invalid IDL: LegacyWindowAlias extended attribute on " + this.name + " without identifier");1191 }1192 var aliases;1193 if (rhs.type === "identifier-list") {1194 aliases = rhs.value.map(id => id.value);1195 aliases = [ rhs.value ];1196 }1197 var alias;1198 if (exposed_in(exposure_set(this, this.exposureSet)) && 'document' in self) {1199 for (alias of aliases) {1200 assert_true(alias in self, alias + " should exist");1201 assert_equals(self[alias], this.get_interface_object(), "self." + alias + " should be the same value as self." + this.get_qualified_name());1202 var desc = Object.getOwnPropertyDescriptor(self, alias);1203 assert_equals(desc.value, this.get_interface_object(), "wrong value in " + alias + " property descriptor");1204 assert_true(desc.writable, alias + " should be writable");1205 assert_false(desc.enumerable, alias + " should not be enumerable");1206 assert_true(desc.configurable, alias + " should be configurable");1207 assert_false('get' in desc, alias + " should not have a getter");1208 assert_false('set' in desc, alias + " should not have a setter");1209 }1210 } else {1211 for (alias of aliases) {1212 assert_false(alias in self, alias + " should not exist");1213 }1214 }1215 }.bind(this), this.name + " interface: legacy window alias");1216 }1217 if (this.has_extended_attribute("LegacyFactoryFunction")) {1218 var constructors = this.extAttrs1219 .filter(function(attr) { return attr.name == "LegacyFactoryFunction"; });1220 if (constructors.length !== 1) {1221 throw new IdlHarnessError("Internal error: missing support for multiple LegacyFactoryFunction extended attributes");1222 }1223 var constructor = constructors[0];1224 var min_length = minOverloadLength([constructor]);1225 subsetTestByKey(this.name, test, function()1226 {1227 var name = constructor.rhs.value;1228 assert_own_property(self, name);1229 var desc = Object.getOwnPropertyDescriptor(self, name);1230 assert_equals(desc.value, self[name], "wrong value in " + name + " property descriptor");1231 assert_true(desc.writable, name + " should be writable");1232 assert_false(desc.enumerable, name + " should not be enumerable");1233 assert_true(desc.configurable, name + " should be configurable");1234 assert_false("get" in desc, name + " should not have a getter");1235 assert_false("set" in desc, name + " should not have a setter");1236 }.bind(this), this.name + " interface: named constructor");1237 subsetTestByKey(this.name, test, function()1238 {1239 var name = constructor.rhs.value;1240 var value = self[name];1241 assert_equals(typeof value, "function", "type of value in " + name + " property descriptor");1242 assert_not_equals(value, this.get_interface_object(), "wrong value in " + name + " property descriptor");1243 assert_equals(Object.getPrototypeOf(value), Function.prototype, "wrong value for " + name + "'s prototype");1244 }.bind(this), this.name + " interface: named constructor object");1245 subsetTestByKey(this.name, test, function()1246 {1247 var name = constructor.rhs.value;1248 var expected = this.get_interface_object().prototype;1249 var desc = Object.getOwnPropertyDescriptor(self[name], "prototype");1250 assert_equals(desc.value, expected, "wrong value for " + name + ".prototype");1251 assert_false(desc.writable, "prototype should not be writable");1252 assert_false(desc.enumerable, "prototype should not be enumerable");1253 assert_false(desc.configurable, "prototype should not be configurable");1254 assert_false("get" in desc, "prototype should not have a getter");1255 assert_false("set" in desc, "prototype should not have a setter");1256 }.bind(this), this.name + " interface: named constructor prototype property");1257 subsetTestByKey(this.name, test, function()1258 {1259 var name = constructor.rhs.value;1260 var desc = Object.getOwnPropertyDescriptor(self[name], "name");1261 assert_equals(desc.value, name, "wrong value for " + name + ".name");1262 assert_false(desc.writable, "name should not be writable");1263 assert_false(desc.enumerable, "name should not be enumerable");1264 assert_true(desc.configurable, "name should be configurable");1265 assert_false("get" in desc, "name should not have a getter");1266 assert_false("set" in desc, "name should not have a setter");1267 }.bind(this), this.name + " interface: named constructor name");1268 subsetTestByKey(this.name, test, function()1269 {1270 var name = constructor.rhs.value;1271 var desc = Object.getOwnPropertyDescriptor(self[name], "length");1272 assert_equals(desc.value, min_length, "wrong value for " + name + ".length");1273 assert_false(desc.writable, "length should not be writable");1274 assert_false(desc.enumerable, "length should not be enumerable");1275 assert_true(desc.configurable, "length should be configurable");1276 assert_false("get" in desc, "length should not have a getter");1277 assert_false("set" in desc, "length should not have a setter");1278 }.bind(this), this.name + " interface: named constructor length");1279 subsetTestByKey(this.name, test, function()1280 {1281 var name = constructor.rhs.value;1282 var args = constructor.arguments.map(function(arg) {1283 return create_suitable_object(arg.idlType);1284 });1285 assert_throws_js(globalOf(self[name]).TypeError, function() {1286 self[name](...args);1287 }.bind(this));1288 }.bind(this), this.name + " interface: named constructor without 'new'");1289 }1290 subsetTestByKey(this.name, test, function()1291 {1292 if (!this.should_have_interface_object()) {1293 return;1294 }1295 this.assert_interface_object_exists();1296 if (this.is_callback()) {1297 assert_false("prototype" in this.get_interface_object(),1298 this.name + ' should not have a "prototype" property');1299 return;1300 }1301 assert_own_property(this.get_interface_object(), "prototype",1302 'interface "' + this.name + '" does not have own property "prototype"');1303 var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), "prototype");1304 assert_false("get" in desc, this.name + ".prototype should not have a getter");1305 assert_false("set" in desc, this.name + ".prototype should not have a setter");1306 assert_false(desc.writable, this.name + ".prototype should not be writable");1307 assert_false(desc.enumerable, this.name + ".prototype should not be enumerable");1308 assert_false(desc.configurable, this.name + ".prototype should not be configurable");1309 if (this.name === "Window") {1310 assert_class_string(Object.getPrototypeOf(this.get_interface_object().prototype),1311 'WindowProperties',1312 'Class name for prototype of Window' +1313 '.prototype is not "WindowProperties"');1314 } else {1315 var inherit_interface, inherit_interface_interface_object;1316 if (this.base) {1317 inherit_interface = this.base;1318 var parent = this.array.members[inherit_interface];1319 if (!parent.has_extended_attribute("LegacyNoInterfaceObject")) {1320 parent.assert_interface_object_exists();1321 inherit_interface_interface_object = parent.get_interface_object();1322 }1323 } else if (this.name === "DOMException") {1324 inherit_interface = 'Error';1325 inherit_interface_interface_object = self.Error;1326 } else {1327 inherit_interface = 'Object';1328 inherit_interface_interface_object = self.Object;1329 }1330 if (inherit_interface_interface_object) {1331 assert_not_equals(inherit_interface_interface_object, undefined,1332 'should inherit from ' + inherit_interface + ', but there is no such property');1333 assert_own_property(inherit_interface_interface_object, 'prototype',1334 'should inherit from ' + inherit_interface + ', but that object has no "prototype" property');1335 assert_equals(Object.getPrototypeOf(this.get_interface_object().prototype),1336 inherit_interface_interface_object.prototype,1337 'prototype of ' + this.name + '.prototype is not ' + inherit_interface + '.prototype');1338 } else {1339 assert_class_string(Object.getPrototypeOf(this.get_interface_object().prototype),1340 inherit_interface + 'Prototype',1341 'Class name for prototype of ' + this.name +1342 '.prototype is not "' + inherit_interface + 'Prototype"');1343 }1344 }1345 if (!this.has_stringifier()) {1346 }1347 }.bind(this), this.name + " interface: existence and properties of interface prototype object");1348 if (this.is_global()) {1349 this.test_immutable_prototype("interface prototype object", this.get_interface_object().prototype);1350 }1351 subsetTestByKey(this.name, test, function()1352 {1353 if (!this.should_have_interface_object()) {1354 return;1355 }1356 this.assert_interface_object_exists();1357 if (this.is_callback()) {1358 assert_false("prototype" in this.get_interface_object(),1359 this.name + ' should not have a "prototype" property');1360 return;1361 }1362 assert_own_property(this.get_interface_object(), "prototype",1363 'interface "' + this.name + '" does not have own property "prototype"');1364 assert_own_property(this.get_interface_object().prototype, "constructor",1365 this.name + '.prototype does not have own property "constructor"');1366 var desc = Object.getOwnPropertyDescriptor(this.get_interface_object().prototype, "constructor");1367 assert_false("get" in desc, this.name + ".prototype.constructor should not have a getter");1368 assert_false("set" in desc, this.name + ".prototype.constructor should not have a setter");1369 assert_true(desc.writable, this.name + ".prototype.constructor should be writable");1370 assert_false(desc.enumerable, this.name + ".prototype.constructor should not be enumerable");1371 assert_true(desc.configurable, this.name + ".prototype.constructor should be configurable");1372 assert_equals(this.get_interface_object().prototype.constructor, this.get_interface_object(),1373 this.name + '.prototype.constructor is not the same object as ' + this.name);1374 }.bind(this), this.name + ' interface: existence and properties of interface prototype object\'s "constructor" property');1375 subsetTestByKey(this.name, test, function()1376 {1377 if (!this.should_have_interface_object()) {1378 return;1379 }1380 this.assert_interface_object_exists();1381 if (this.is_callback()) {1382 assert_false("prototype" in this.get_interface_object(),1383 this.name + ' should not have a "prototype" property');1384 return;1385 }1386 assert_own_property(this.get_interface_object(), "prototype",1387 'interface "' + this.name + '" does not have own property "prototype"');1388 var unscopables = this.get_unscopables().map(m => m.name);1389 var proto = this.get_interface_object().prototype;1390 if (unscopables.length != 0) {1391 assert_own_property(1392 proto, Symbol.unscopables,1393 this.name + '.prototype should have an @@unscopables property');1394 var desc = Object.getOwnPropertyDescriptor(proto, Symbol.unscopables);1395 assert_false("get" in desc,1396 this.name + ".prototype[Symbol.unscopables] should not have a getter");1397 assert_false("set" in desc, this.name + ".prototype[Symbol.unscopables] should not have a setter");1398 assert_false(desc.writable, this.name + ".prototype[Symbol.unscopables] should not be writable");1399 assert_false(desc.enumerable, this.name + ".prototype[Symbol.unscopables] should not be enumerable");1400 assert_true(desc.configurable, this.name + ".prototype[Symbol.unscopables] should be configurable");1401 assert_equals(desc.value, proto[Symbol.unscopables],1402 this.name + '.prototype[Symbol.unscopables] should be in the descriptor');1403 assert_equals(typeof desc.value, "object",1404 this.name + '.prototype[Symbol.unscopables] should be an object');1405 assert_equals(Object.getPrototypeOf(desc.value), null,1406 this.name + '.prototype[Symbol.unscopables] should have a null prototype');1407 assert_equals(Object.getOwnPropertySymbols(desc.value).length,1408 0,1409 this.name + '.prototype[Symbol.unscopables] should have the right number of symbol-named properties');1410 var observed = Object.getOwnPropertyNames(desc.value);1411 for (var prop of observed) {1412 assert_not_equals(unscopables.indexOf(prop),1413 -1,1414 this.name + '.prototype[Symbol.unscopables] has unexpected property "' + prop + '"');1415 }1416 } else {1417 assert_equals(Object.getOwnPropertyDescriptor(this.get_interface_object().prototype, Symbol.unscopables),1418 undefined,1419 this.name + '.prototype should not have @@unscopables');1420 }1421 }.bind(this), this.name + ' interface: existence and properties of interface prototype object\'s @@unscopables property');1422};1423IdlInterface.prototype.test_immutable_prototype = function(type, obj)1424{1425 if (typeof Object.setPrototypeOf !== "function") {1426 return;1427 }1428 subsetTestByKey(this.name, test, function(t) {1429 var originalValue = Object.getPrototypeOf(obj);1430 var newValue = Object.create(null);1431 t.add_cleanup(function() {1432 try {1433 Object.setPrototypeOf(obj, originalValue);1434 } catch (err) {}1435 });1436 assert_throws_js(TypeError, function() {1437 Object.setPrototypeOf(obj, newValue);1438 });1439 assert_equals(1440 Object.getPrototypeOf(obj),1441 originalValue,1442 "original value not modified"1443 );1444 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1445 "of " + type + " - setting to a new value via Object.setPrototypeOf " +1446 "should throw a TypeError");1447 subsetTestByKey(this.name, test, function(t) {1448 var originalValue = Object.getPrototypeOf(obj);1449 var newValue = Object.create(null);1450 t.add_cleanup(function() {1451 let setter = Object.getOwnPropertyDescriptor(1452 Object.prototype, '__proto__'1453 ).set;1454 try {1455 setter.call(obj, originalValue);1456 } catch (err) {}1457 });1458 let setter;1459 {1460 let cur = obj;1461 while (cur) {1462 const desc = Object.getOwnPropertyDescriptor(cur, "__proto__");1463 if (desc) {1464 setter = desc.set;1465 break;1466 }1467 cur = Object.getPrototypeOf(cur);1468 }1469 }1470 assert_throws_js(globalOf(setter).TypeError, function() {1471 obj.__proto__ = newValue;1472 });1473 assert_equals(1474 Object.getPrototypeOf(obj),1475 originalValue,1476 "original value not modified"1477 );1478 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1479 "of " + type + " - setting to a new value via __proto__ " +1480 "should throw a TypeError");1481 subsetTestByKey(this.name, test, function(t) {1482 var originalValue = Object.getPrototypeOf(obj);1483 var newValue = Object.create(null);1484 t.add_cleanup(function() {1485 try {1486 Reflect.setPrototypeOf(obj, originalValue);1487 } catch (err) {}1488 });1489 assert_false(Reflect.setPrototypeOf(obj, newValue));1490 assert_equals(1491 Object.getPrototypeOf(obj),1492 originalValue,1493 "original value not modified"1494 );1495 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1496 "of " + type + " - setting to a new value via Reflect.setPrototypeOf " +1497 "should return false");1498 subsetTestByKey(this.name, test, function() {1499 var originalValue = Object.getPrototypeOf(obj);1500 Object.setPrototypeOf(obj, originalValue);1501 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1502 "of " + type + " - setting to its original value via Object.setPrototypeOf " +1503 "should not throw");1504 subsetTestByKey(this.name, test, function() {1505 var originalValue = Object.getPrototypeOf(obj);1506 obj.__proto__ = originalValue;1507 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1508 "of " + type + " - setting to its original value via __proto__ " +1509 "should not throw");1510 subsetTestByKey(this.name, test, function() {1511 var originalValue = Object.getPrototypeOf(obj);1512 assert_true(Reflect.setPrototypeOf(obj, originalValue));1513 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1514 "of " + type + " - setting to its original value via Reflect.setPrototypeOf " +1515 "should return true");1516};1517IdlInterface.prototype.test_member_const = function(member)1518{1519 if (!this.has_constants()) {1520 throw new IdlHarnessError("Internal error: test_member_const called without any constants");1521 }1522 subsetTestByKey(this.name, test, function()1523 {1524 this.assert_interface_object_exists();1525 assert_own_property(this.get_interface_object(), member.name);1526 assert_equals(this.get_interface_object()[member.name], constValue(member.value),1527 "property has wrong value");1528 var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), member.name);1529 assert_false("get" in desc, "property should not have a getter");1530 assert_false("set" in desc, "property should not have a setter");1531 assert_false(desc.writable, "property should not be writable");1532 assert_true(desc.enumerable, "property should be enumerable");1533 assert_false(desc.configurable, "property should not be configurable");1534 }.bind(this), this.name + " interface: constant " + member.name + " on interface object");1535 subsetTestByKey(this.name, test, function()1536 {1537 this.assert_interface_object_exists();1538 if (this.is_callback()) {1539 assert_false("prototype" in this.get_interface_object(),1540 this.name + ' should not have a "prototype" property');1541 return;1542 }1543 assert_own_property(this.get_interface_object(), "prototype",1544 'interface "' + this.name + '" does not have own property "prototype"');1545 assert_own_property(this.get_interface_object().prototype, member.name);1546 assert_equals(this.get_interface_object().prototype[member.name], constValue(member.value),1547 "property has wrong value");1548 var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), member.name);1549 assert_false("get" in desc, "property should not have a getter");1550 assert_false("set" in desc, "property should not have a setter");1551 assert_false(desc.writable, "property should not be writable");1552 assert_true(desc.enumerable, "property should be enumerable");1553 assert_false(desc.configurable, "property should not be configurable");1554 }.bind(this), this.name + " interface: constant " + member.name + " on interface prototype object");1555};1556IdlInterface.prototype.test_member_attribute = function(member)1557 {1558 if (!shouldRunSubTest(this.name)) {1559 return;1560 }1561 var a_test = subsetTestByKey(this.name, async_test, this.name + " interface: attribute " + member.name);1562 a_test.step(function()1563 {1564 if (!this.should_have_interface_object()) {1565 a_test.done();1566 return;1567 }1568 this.assert_interface_object_exists();1569 assert_own_property(this.get_interface_object(), "prototype",1570 'interface "' + this.name + '" does not have own property "prototype"');1571 if (member.special === "static") {1572 assert_own_property(this.get_interface_object(), member.name,1573 "The interface object must have a property " +1574 format_value(member.name));1575 a_test.done();1576 return;1577 }1578 this.do_member_unscopable_asserts(member);1579 if (this.is_global()) {1580 assert_own_property(self, member.name,1581 "The global object must have a property " +1582 format_value(member.name));1583 assert_false(member.name in this.get_interface_object().prototype,1584 "The prototype object should not have a property " +1585 format_value(member.name));1586 var getter = Object.getOwnPropertyDescriptor(self, member.name).get;1587 assert_equals(typeof(getter), "function",1588 format_value(member.name) + " must have a getter");1589 var gotValue;1590 var propVal;1591 try {1592 propVal = self[member.name];1593 gotValue = true;1594 } catch (e) {1595 gotValue = false;1596 }1597 if (gotValue) {1598 assert_equals(propVal, getter.call(undefined),1599 "Gets on a global should not require an explicit this");1600 }1601 this.do_interface_attribute_asserts(self, member, a_test);1602 } else {1603 assert_true(member.name in this.get_interface_object().prototype,1604 "The prototype object must have a property " +1605 format_value(member.name));1606 if (!member.has_extended_attribute("LegacyLenientThis")) {1607 if (member.idlType.generic !== "Promise") {1608 assert_throws_js(TypeError, function() {1609 this.get_interface_object().prototype[member.name];1610 }.bind(this), "getting property on prototype object must throw TypeError");1611 this.do_interface_attribute_asserts(this.get_interface_object().prototype, member, a_test);1612 } else {1613 promise_rejects_js(a_test, TypeError,1614 this.get_interface_object().prototype[member.name])1615 .then(a_test.step_func(function() {1616 this.do_interface_attribute_asserts(this.get_interface_object().prototype,1617 member, a_test);1618 }.bind(this)));1619 }1620 } else {1621 assert_equals(this.get_interface_object().prototype[member.name], undefined,1622 "getting property on prototype object must return undefined");1623 this.do_interface_attribute_asserts(this.get_interface_object().prototype, member, a_test);1624 }1625 }1626 }.bind(this));1627};1628IdlInterface.prototype.test_member_operation = function(member)1629{1630 if (!shouldRunSubTest(this.name)) {1631 return;1632 }1633 var a_test = subsetTestByKey(this.name, async_test, this.name + " interface: operation " + member);1634 a_test.step(function()1635 {1636 if (!this.should_have_interface_object()) {1637 a_test.done();1638 return;1639 }1640 this.assert_interface_object_exists();1641 if (this.is_callback()) {1642 assert_false("prototype" in this.get_interface_object(),1643 this.name + ' should not have a "prototype" property');1644 a_test.done();1645 return;1646 }1647 assert_own_property(this.get_interface_object(), "prototype",1648 'interface "' + this.name + '" does not have own property "prototype"');1649 var memberHolderObject;1650 if (member.special === "static") {1651 assert_own_property(this.get_interface_object(), member.name,1652 "interface object missing static operation");1653 memberHolderObject = this.get_interface_object();1654 } else if (this.is_global()) {1655 assert_own_property(self, member.name,1656 "global object missing non-static operation");1657 memberHolderObject = self;1658 } else {1659 assert_own_property(this.get_interface_object().prototype, member.name,1660 "interface prototype object missing non-static operation");1661 memberHolderObject = this.get_interface_object().prototype;1662 }1663 this.do_member_unscopable_asserts(member);1664 this.do_member_operation_asserts(memberHolderObject, member, a_test);1665 }.bind(this));1666};1667IdlInterface.prototype.do_member_unscopable_asserts = function(member)1668{1669 if (!member.isUnscopable) {1670 return;1671 }1672 var unscopables = this.get_interface_object().prototype[Symbol.unscopables];1673 var prop = member.name;1674 var propDesc = Object.getOwnPropertyDescriptor(unscopables, prop);1675 assert_equals(typeof propDesc, "object",1676 this.name + '.prototype[Symbol.unscopables].' + prop + ' must exist')1677 assert_false("get" in propDesc,1678 this.name + '.prototype[Symbol.unscopables].' + prop + ' must have no getter');1679 assert_false("set" in propDesc,1680 this.name + '.prototype[Symbol.unscopables].' + prop + ' must have no setter');1681 assert_true(propDesc.writable,1682 this.name + '.prototype[Symbol.unscopables].' + prop + ' must be writable');1683 assert_true(propDesc.enumerable,1684 this.name + '.prototype[Symbol.unscopables].' + prop + ' must be enumerable');1685 assert_true(propDesc.configurable,1686 this.name + '.prototype[Symbol.unscopables].' + prop + ' must be configurable');1687 assert_equals(propDesc.value, true,1688 this.name + '.prototype[Symbol.unscopables].' + prop + ' must have the value `true`');1689};1690IdlInterface.prototype.do_member_operation_asserts = function(memberHolderObject, member, a_test)1691{1692 var done = a_test.done.bind(a_test);1693 var operationUnforgeable = member.isUnforgeable;1694 var desc = Object.getOwnPropertyDescriptor(memberHolderObject, member.name);1695 assert_false("get" in desc, "property should not have a getter");1696 assert_false("set" in desc, "property should not have a setter");1697 assert_equals(desc.writable, !operationUnforgeable,1698 "property should be writable if and only if not unforgeable");1699 assert_true(desc.enumerable, "property should be enumerable");1700 assert_equals(desc.configurable, !operationUnforgeable,1701 "property should be configurable if and only if not unforgeable");1702 assert_equals(typeof memberHolderObject[member.name], "function",1703 "property must be a function");1704 const ctors = this.members.filter(function(m) {1705 return m.type == "operation" && m.name == member.name;1706 });1707 assert_equals(1708 memberHolderObject[member.name].length,1709 minOverloadLength(ctors),1710 "property has wrong .length");1711 assert_equals(1712 memberHolderObject[member.name].name,1713 member.name,1714 "property has wrong .name");1715 var args = member.arguments.map(function(arg) {1716 return create_suitable_object(arg.idlType);1717 });1718 if (member.special !== "static") {1719 var cb;1720 if (!this.is_global() &&1721 memberHolderObject[member.name] != self[member.name])1722 {1723 cb = awaitNCallbacks(2, done);1724 throwOrReject(a_test, member, memberHolderObject[member.name], null, args,1725 "calling operation with this = null didn't throw TypeError", cb);1726 } else {1727 cb = awaitNCallbacks(1, done);1728 }1729 throwOrReject(a_test, member, memberHolderObject[member.name], {}, args,1730 "calling operation with this = {} didn't throw TypeError", cb);1731 } else {1732 done();1733 }1734}1735IdlInterface.prototype.test_to_json_operation = function(desc, memberHolderObject, member) {1736 var instanceName = memberHolderObject && memberHolderObject.constructor.name1737 || member.name + " object";1738 if (member.has_extended_attribute("Default")) {1739 subsetTestByKey(this.name, test, function() {1740 var map = this.default_to_json_operation();1741 var json = memberHolderObject.toJSON();1742 map.forEach(function(type, k) {1743 assert_true(k in json, "property " + JSON.stringify(k) + " should be present in the output of " + this.name + ".prototype.toJSON()");1744 var descriptor = Object.getOwnPropertyDescriptor(json, k);1745 assert_true(descriptor.writable, "property " + k + " should be writable");1746 assert_true(descriptor.configurable, "property " + k + " should be configurable");1747 assert_true(descriptor.enumerable, "property " + k + " should be enumerable");1748 this.array.assert_type_is(json[k], type);1749 delete json[k];1750 }, this);1751 }.bind(this), this.name + " interface: default toJSON operation on " + desc);1752 } else {1753 subsetTestByKey(this.name, test, function() {1754 assert_true(this.array.is_json_type(member.idlType), JSON.stringify(member.idlType) + " is not an appropriate return value for the toJSON operation of " + instanceName);1755 this.array.assert_type_is(memberHolderObject.toJSON(), member.idlType);1756 }.bind(this), this.name + " interface: toJSON operation on " + desc);1757 }1758};1759IdlInterface.prototype.test_member_iterable = function(member)1760{1761 subsetTestByKey(this.name, test, function()1762 {1763 var isPairIterator = member.idlType.length === 2;1764 var proto = this.get_interface_object().prototype;1765 var iteratorDesc = Object.getOwnPropertyDescriptor(proto, Symbol.iterator);1766 assert_true(iteratorDesc.writable, "@@iterator property should be writable");1767 assert_true(iteratorDesc.configurable, "@@iterator property should be configurable");1768 assert_false(iteratorDesc.enumerable, "@@iterator property should not be enumerable");1769 assert_equals(typeof iteratorDesc.value, "function", "@@iterator property should be a function");1770 assert_equals(iteratorDesc.value.length, 0, "@@iterator function object length should be 0");1771 assert_equals(iteratorDesc.value.name, isPairIterator ? "entries" : "values", "@@iterator function object should have the right name");1772 if (isPairIterator) {1773 assert_equals(proto["entries"], proto[Symbol.iterator], "entries method should be the same as @@iterator method");1774 [1775 ["entries", 0],1776 ["keys", 0],1777 ["values", 0],1778 ["forEach", 1]1779 ].forEach(([property, length]) => {1780 var desc = Object.getOwnPropertyDescriptor(proto, property);1781 assert_equals(typeof desc.value, "function", property + " property should be a function");1782 assert_equals(desc.value.length, length, property + " function object length should be " + length);1783 assert_equals(desc.value.name, property, property + " function object should have the right name");1784 });1785 } else {1786 assert_equals(proto[Symbol.iterator], Array.prototype[Symbol.iterator], "@@iterator method should be the same as Array prototype's");1787 ["entries", "keys", "values", "forEach", Symbol.iterator].forEach(property => {1788 var propertyName = property === Symbol.iterator ? "@@iterator" : property;1789 assert_equals(proto[property], Array.prototype[property], propertyName + " method should be the same as Array prototype's");1790 });1791 }1792 }.bind(this), this.name + " interface: iterable<" + member.idlType.map(function(t) { return t.idlType; }).join(", ") + ">");1793};1794IdlInterface.prototype.test_member_async_iterable = function(member)1795{1796 subsetTestByKey(this.name, test, function()1797 {1798 var isPairIterator = member.idlType.length === 2;1799 var proto = this.get_interface_object().prototype;1800 var iteratorDesc = Object.getOwnPropertyDescriptor(proto, Symbol.asyncIterator);1801 assert_true(iteratorDesc.writable, "@@asyncIterator property should be writable");1802 assert_true(iteratorDesc.configurable, "@@asyncIterator property should be configurable");1803 assert_false(iteratorDesc.enumerable, "@@asyncIterator property should not be enumerable");1804 assert_equals(typeof iteratorDesc.value, "function", "@@asyncIterator property should be a function");1805 assert_equals(iteratorDesc.value.length, 0, "@@asyncIterator function object length should be 0");1806 assert_equals(iteratorDesc.value.name, isPairIterator ? "entries" : "values", "@@asyncIterator function object should have the right name");1807 if (isPairIterator) {1808 assert_equals(proto["entries"], proto[Symbol.asyncIterator], "entries method should be the same as @@asyncIterator method");1809 ["entries", "keys", "values"].forEach(property => {1810 var desc = Object.getOwnPropertyDescriptor(proto, property);1811 assert_equals(typeof desc.value, "function", property + " property should be a function");1812 assert_equals(desc.value.length, 0, property + " function object length should be 0");1813 assert_equals(desc.value.name, property, property + " function object should have the right name");1814 });1815 } else {1816 assert_equals(proto["values"], proto[Symbol.asyncIterator], "values method should be the same as @@asyncIterator method");1817 assert_false("entries" in proto, "should not have an entries method");1818 assert_false("keys" in proto, "should not have a keys method");1819 }1820 }.bind(this), this.name + " interface: async iterable<" + member.idlType.map(function(t) { return t.idlType; }).join(", ") + ">");1821};1822IdlInterface.prototype.test_member_stringifier = function(member)1823{1824 subsetTestByKey(this.name, test, function()1825 {1826 if (!this.should_have_interface_object()) {1827 return;1828 }1829 this.assert_interface_object_exists();1830 if (this.is_callback()) {1831 assert_false("prototype" in this.get_interface_object(),1832 this.name + ' should not have a "prototype" property');1833 return;1834 }1835 assert_own_property(this.get_interface_object(), "prototype",1836 'interface "' + this.name + '" does not have own property "prototype"');1837 var interfacePrototypeObject = this.get_interface_object().prototype;1838 assert_own_property(interfacePrototypeObject, "toString",1839 "interface prototype object missing non-static operation");1840 var stringifierUnforgeable = member.isUnforgeable;1841 var desc = Object.getOwnPropertyDescriptor(interfacePrototypeObject, "toString");1842 assert_false("get" in desc, "property should not have a getter");1843 assert_false("set" in desc, "property should not have a setter");1844 assert_equals(desc.writable, !stringifierUnforgeable,1845 "property should be writable if and only if not unforgeable");1846 assert_true(desc.enumerable, "property should be enumerable");1847 assert_equals(desc.configurable, !stringifierUnforgeable,1848 "property should be configurable if and only if not unforgeable");1849 assert_equals(typeof interfacePrototypeObject.toString, "function",1850 "property must be a function");1851 assert_equals(interfacePrototypeObject.toString.length, 0,1852 "property has wrong .length");1853 assert_throws_js(globalOf(interfacePrototypeObject.toString).TypeError, function() {1854 interfacePrototypeObject.toString.apply(null, []);1855 }, "calling stringifier with this = null didn't throw TypeError");1856 assert_throws_js(globalOf(interfacePrototypeObject.toString).TypeError, function() {1857 interfacePrototypeObject.toString.apply({}, []);1858 }, "calling stringifier with this = {} didn't throw TypeError");1859 }.bind(this), this.name + " interface: stringifier");1860};1861IdlInterface.prototype.test_members = function()1862{1863 for (var i = 0; i < this.members.length; i++)1864 {1865 var member = this.members[i];1866 if (member.untested) {1867 continue;1868 }1869 if (!exposed_in(exposure_set(member, this.exposureSet))) {1870 subsetTestByKey(this.name, test, function() {1871 assert_false(member.name in this.get_interface_object(),1872 "The interface object must not have a property " +1873 format_value(member.name));1874 assert_false(member.name in this.get_interface_object().prototype,1875 "The prototype object must not have a property " +1876 format_value(member.name));1877 }.bind(this), this.name + " interface: member " + member.name);1878 continue;1879 }1880 switch (member.type) {1881 case "const":1882 this.test_member_const(member);1883 break;1884 case "attribute":1885 if (!member.isUnforgeable)1886 {1887 this.test_member_attribute(member);1888 }1889 if (member.special === "stringifier") {1890 this.test_member_stringifier(member);1891 }1892 break;1893 case "operation":1894 if (member.name) {1895 if (!member.isUnforgeable)1896 {1897 this.test_member_operation(member);1898 }1899 } else if (member.special === "stringifier") {1900 this.test_member_stringifier(member);1901 }1902 break;1903 case "iterable":1904 if (member.async) {1905 this.test_member_async_iterable(member);1906 } else {1907 this.test_member_iterable(member);1908 }1909 break;1910 default:1911 break;1912 }1913 }1914};1915IdlInterface.prototype.test_object = function(desc)1916{1917 var obj, exception = null;1918 try1919 {1920 obj = eval(desc);1921 }1922 catch(e)1923 {1924 exception = e;1925 }1926 var expected_typeof;1927 if (this.name == "HTMLAllCollection")1928 {1929 expected_typeof = "undefined";1930 }1931 else1932 {1933 expected_typeof = "object";1934 }1935 this.test_primary_interface_of(desc, obj, exception, expected_typeof);1936 var current_interface = this;1937 while (current_interface)1938 {1939 if (!(current_interface.name in this.array.members))1940 {1941 throw new IdlHarnessError("Interface " + current_interface.name + " not found (inherited by " + this.name + ")");1942 }1943 if (current_interface.prevent_multiple_testing && current_interface.already_tested)1944 {1945 return;1946 }1947 current_interface.test_interface_of(desc, obj, exception, expected_typeof);1948 current_interface = this.array.members[current_interface.base];1949 }1950};1951IdlInterface.prototype.test_primary_interface_of = function(desc, obj, exception, expected_typeof)1952{1953 if (this.untested)1954 {1955 return;1956 }1957 if (this.is_global())1958 {1959 this.test_immutable_prototype("global platform object", obj);1960 }1961 if (this.should_have_interface_object()1962 && (typeof obj != expected_typeof || obj instanceof Object))1963 {1964 subsetTestByKey(this.name, test, function()1965 {1966 assert_equals(exception, null, "Unexpected exception when evaluating object");1967 assert_equals(typeof obj, expected_typeof, "wrong typeof object");1968 this.assert_interface_object_exists();1969 assert_own_property(this.get_interface_object(), "prototype",1970 'interface "' + this.name + '" does not have own property "prototype"');1971 assert_equals(Object.getPrototypeOf(obj),1972 this.get_interface_object().prototype,1973 desc + "'s prototype is not " + this.name + ".prototype");1974 }.bind(this), this.name + " must be primary interface of " + desc);1975 }1976 subsetTestByKey(this.name, test, function()1977 {1978 assert_equals(exception, null, "Unexpected exception when evaluating object");1979 assert_equals(typeof obj, expected_typeof, "wrong typeof object");1980 assert_class_string(obj, this.get_qualified_name(), "class string of " + desc);1981 if (!this.has_stringifier())1982 {1983 assert_equals(String(obj), "[object " + this.get_qualified_name() + "]", "String(" + desc + ")");1984 }1985 }.bind(this), "Stringification of " + desc);1986};1987IdlInterface.prototype.test_interface_of = function(desc, obj, exception, expected_typeof)1988{1989 this.already_tested = true;1990 if (!shouldRunSubTest(this.name)) {1991 return;1992 }1993 for (var i = 0; i < this.members.length; i++)1994 {1995 var member = this.members[i];1996 if (member.untested) {1997 continue;1998 }1999 if (!exposed_in(exposure_set(member, this.exposureSet))) {2000 subsetTestByKey(this.name, test, function() {2001 assert_equals(exception, null, "Unexpected exception when evaluating object");2002 assert_false(member.name in obj);2003 }.bind(this), this.name + " interface: " + desc + ' must not have property "' + member.name + '"');2004 continue;2005 }2006 if (member.type == "attribute" && member.isUnforgeable)2007 {2008 var a_test = subsetTestByKey(this.name, async_test, this.name + " interface: " + desc + ' must have own property "' + member.name + '"');2009 a_test.step(function() {2010 assert_equals(exception, null, "Unexpected exception when evaluating object");2011 assert_equals(typeof obj, expected_typeof, "wrong typeof object");2012 this.do_interface_attribute_asserts(obj, member, a_test);2013 }.bind(this));...

Full Screen

Full Screen

idlharness.js

Source:idlharness.js Github

copy

Full Screen

...400 }401 return false;402 }403};404function exposure_set(object, default_set) {405 var exposed = object.extAttrs.filter(function(a) { return a.name == "Exposed" });406 if (exposed.length > 1 || exposed.length < 0) {407 throw "Unexpected Exposed extended attributes on " + memberName + ": " + exposed;408 }409 if (exposed.length === 0) {410 return default_set;411 }412 var set = exposed[0].rhs.value;413 // Could be a list or a string.414 if (typeof set == "string") {415 set = [ set ];416 }417 return set;418}419function exposed_in(globals) {420 if ('document' in self) {421 return globals.indexOf("Window") >= 0;422 }423 if ('DedicatedWorkerGlobalScope' in self &&424 self instanceof DedicatedWorkerGlobalScope) {425 return globals.indexOf("Worker") >= 0 ||426 globals.indexOf("DedicatedWorker") >= 0;427 }428 if ('SharedWorkerGlobalScope' in self &&429 self instanceof SharedWorkerGlobalScope) {430 return globals.indexOf("Worker") >= 0 ||431 globals.indexOf("SharedWorker") >= 0;432 }433 if ('ServiceWorkerGlobalScope' in self &&434 self instanceof ServiceWorkerGlobalScope) {435 return globals.indexOf("Worker") >= 0 ||436 globals.indexOf("ServiceWorker") >= 0;437 }438 throw "Unexpected global object";439}440//@}441IdlArray.prototype.test = function()442//@{443{444 /** Entry point. See documentation at beginning of file. */445 // First merge in all the partial interfaces and implements statements we446 // encountered.447 this.partials.forEach(function(parsed_idl)448 {449 if (!(parsed_idl.name in this.members)450 || !(this.members[parsed_idl.name] instanceof IdlInterface))451 {452 throw "Partial interface " + parsed_idl.name + " with no original interface";453 }454 if (parsed_idl.extAttrs)455 {456 parsed_idl.extAttrs.forEach(function(extAttr)457 {458 this.members[parsed_idl.name].extAttrs.push(extAttr);459 }.bind(this));460 }461 parsed_idl.members.forEach(function(member)462 {463 this.members[parsed_idl.name].members.push(new IdlInterfaceMember(member));464 }.bind(this));465 }.bind(this));466 this.partials = [];467 for (var lhs in this["implements"])468 {469 this.recursively_get_implements(lhs).forEach(function(rhs)470 {471 var errStr = lhs + " implements " + rhs + ", but ";472 if (!(lhs in this.members)) throw errStr + lhs + " is undefined.";473 if (!(this.members[lhs] instanceof IdlInterface)) throw errStr + lhs + " is not an interface.";474 if (!(rhs in this.members)) throw errStr + rhs + " is undefined.";475 if (!(this.members[rhs] instanceof IdlInterface)) throw errStr + rhs + " is not an interface.";476 this.members[rhs].members.forEach(function(member)477 {478 this.members[lhs].members.push(new IdlInterfaceMember(member));479 }.bind(this));480 }.bind(this));481 }482 this["implements"] = {};483 Object.getOwnPropertyNames(this.members).forEach(function(memberName) {484 var member = this.members[memberName];485 if (!(member instanceof IdlInterface)) {486 return;487 }488 var globals = exposure_set(member, ["Window"]);489 member.exposed = exposed_in(globals);490 member.exposureSet = globals;491 }.bind(this));492 // Now run test() on every member, and test_object() for every object.493 for (var name in this.members)494 {495 this.members[name].test();496 if (name in this.objects)497 {498 this.objects[name].forEach(function(str)499 {500 this.members[name].test_object(str);501 }.bind(this));502 }503 }504};505//@}506IdlArray.prototype.assert_type_is = function(value, type)507//@{508{509 if (type.idlType in this.members510 && this.members[type.idlType] instanceof IdlTypedef) {511 this.assert_type_is(value, this.members[type.idlType].idlType);512 return;513 }514 if (type.union) {515 for (var i = 0; i < type.idlType.length; i++) {516 try {517 this.assert_type_is(value, type.idlType[i]);518 // No AssertionError, so we match one type in the union519 return;520 } catch(e) {521 if (e instanceof AssertionError) {522 // We didn't match this type, let's try some others523 continue;524 }525 throw e;526 }527 }528 // TODO: Is there a nice way to list the union's types in the message?529 assert_true(false, "Attribute has value " + format_value(value)530 + " which doesn't match any of the types in the union");531 }532 /**533 * Helper function that tests that value is an instance of type according534 * to the rules of WebIDL. value is any JavaScript value, and type is an535 * object produced by WebIDLParser.js' "type" production. That production536 * is fairly elaborate due to the complexity of WebIDL's types, so it's537 * best to look at the grammar to figure out what properties it might have.538 */539 if (type.idlType == "any")540 {541 // No assertions to make542 return;543 }544 if (type.nullable && value === null)545 {546 // This is fine547 return;548 }549 if (type.array)550 {551 // TODO: not supported yet552 return;553 }554 if (type.sequence)555 {556 assert_true(Array.isArray(value), "should be an Array");557 if (!value.length)558 {559 // Nothing we can do.560 return;561 }562 this.assert_type_is(value[0], type.idlType);563 return;564 }565 if (type.generic === "Promise") {566 assert_true("then" in value, "Attribute with a Promise type should have a then property");567 // TODO: Ideally, we would check on project fulfillment568 // that we get the right type569 // but that would require making the type check async570 return;571 }572 if (type.generic === "FrozenArray") {573 assert_true(Array.isArray(value), "Value should be array");574 assert_true(Object.isFrozen(value), "Value should be frozen");575 if (!value.length)576 {577 // Nothing we can do.578 return;579 }580 this.assert_type_is(value[0], type.idlType);581 return;582 }583 type = type.idlType;584 switch(type)585 {586 case "void":587 assert_equals(value, undefined);588 return;589 case "boolean":590 assert_equals(typeof value, "boolean");591 return;592 case "byte":593 assert_equals(typeof value, "number");594 assert_equals(value, Math.floor(value), "should be an integer");595 assert_true(-128 <= value && value <= 127, "byte " + value + " should be in range [-128, 127]");596 return;597 case "octet":598 assert_equals(typeof value, "number");599 assert_equals(value, Math.floor(value), "should be an integer");600 assert_true(0 <= value && value <= 255, "octet " + value + " should be in range [0, 255]");601 return;602 case "short":603 assert_equals(typeof value, "number");604 assert_equals(value, Math.floor(value), "should be an integer");605 assert_true(-32768 <= value && value <= 32767, "short " + value + " should be in range [-32768, 32767]");606 return;607 case "unsigned short":608 assert_equals(typeof value, "number");609 assert_equals(value, Math.floor(value), "should be an integer");610 assert_true(0 <= value && value <= 65535, "unsigned short " + value + " should be in range [0, 65535]");611 return;612 case "long":613 assert_equals(typeof value, "number");614 assert_equals(value, Math.floor(value), "should be an integer");615 assert_true(-2147483648 <= value && value <= 2147483647, "long " + value + " should be in range [-2147483648, 2147483647]");616 return;617 case "unsigned long":618 assert_equals(typeof value, "number");619 assert_equals(value, Math.floor(value), "should be an integer");620 assert_true(0 <= value && value <= 4294967295, "unsigned long " + value + " should be in range [0, 4294967295]");621 return;622 case "long long":623 assert_equals(typeof value, "number");624 return;625 case "unsigned long long":626 case "DOMTimeStamp":627 assert_equals(typeof value, "number");628 assert_true(0 <= value, "unsigned long long should be positive");629 return;630 case "float":631 assert_equals(typeof value, "number");632 assert_equals(value, fround(value), "float rounded to 32-bit float should be itself");633 assert_not_equals(value, Infinity);634 assert_not_equals(value, -Infinity);635 assert_not_equals(value, NaN);636 return;637 case "DOMHighResTimeStamp":638 case "double":639 assert_equals(typeof value, "number");640 assert_not_equals(value, Infinity);641 assert_not_equals(value, -Infinity);642 assert_not_equals(value, NaN);643 return;644 case "unrestricted float":645 assert_equals(typeof value, "number");646 assert_equals(value, fround(value), "unrestricted float rounded to 32-bit float should be itself");647 return;648 case "unrestricted double":649 assert_equals(typeof value, "number");650 return;651 case "DOMString":652 assert_equals(typeof value, "string");653 return;654 case "ByteString":655 assert_equals(typeof value, "string");656 assert_regexp_match(value, /^[\x00-\x7F]*$/);657 return;658 case "USVString":659 assert_equals(typeof value, "string");660 assert_regexp_match(value, /^([\x00-\ud7ff\ue000-\uffff]|[\ud800-\udbff][\udc00-\udfff])*$/);661 return;662 case "object":663 assert_in_array(typeof value, ["object", "function"], "wrong type: not object or function");664 return;665 }666 if (!(type in this.members))667 {668 throw "Unrecognized type " + type;669 }670 if (this.members[type] instanceof IdlInterface)671 {672 // We don't want to run the full673 // IdlInterface.prototype.test_instance_of, because that could result674 // in an infinite loop. TODO: This means we don't have tests for675 // NoInterfaceObject interfaces, and we also can't test objects that676 // come from another self.677 assert_in_array(typeof value, ["object", "function"], "wrong type: not object or function");678 if (value instanceof Object679 && !this.members[type].has_extended_attribute("NoInterfaceObject")680 && type in self)681 {682 assert_true(value instanceof self[type], "instanceof " + type);683 }684 }685 else if (this.members[type] instanceof IdlEnum)686 {687 assert_equals(typeof value, "string");688 }689 else if (this.members[type] instanceof IdlDictionary)690 {691 // TODO: Test when we actually have something to test this on692 }693 else694 {695 throw "Type " + type + " isn't an interface or dictionary";696 }697};698//@}699/// IdlObject ///700function IdlObject() {}701IdlObject.prototype.test = function()702//@{703{704 /**705 * By default, this does nothing, so no actual tests are run for IdlObjects706 * that don't define any (e.g., IdlDictionary at the time of this writing).707 */708};709//@}710IdlObject.prototype.has_extended_attribute = function(name)711//@{712{713 /**714 * This is only meaningful for things that support extended attributes,715 * such as interfaces, exceptions, and members.716 */717 return this.extAttrs.some(function(o)718 {719 return o.name == name;720 });721};722//@}723/// IdlDictionary ///724// Used for IdlArray.prototype.assert_type_is725function IdlDictionary(obj)726//@{727{728 /**729 * obj is an object produced by the WebIDLParser.js "dictionary"730 * production.731 */732 /** Self-explanatory. */733 this.name = obj.name;734 /** A back-reference to our IdlArray. */735 this.array = obj.array;736 /** An array of objects produced by the "dictionaryMember" production. */737 this.members = obj.members;738 /**739 * The name (as a string) of the dictionary type we inherit from, or null740 * if there is none.741 */742 this.base = obj.inheritance;743}744//@}745IdlDictionary.prototype = Object.create(IdlObject.prototype);746IdlDictionary.prototype.get_inheritance_stack = function() {747 return IdlInterface.prototype.get_inheritance_stack.call(this);748};749/// IdlInterface ///750function IdlInterface(obj, is_callback)751//@{752{753 /**754 * obj is an object produced by the WebIDLParser.js "interface" production.755 */756 /** Self-explanatory. */757 this.name = obj.name;758 /** A back-reference to our IdlArray. */759 this.array = obj.array;760 /**761 * An indicator of whether we should run tests on the interface object and762 * interface prototype object. Tests on members are controlled by .untested763 * on each member, not this.764 */765 this.untested = obj.untested;766 /** An array of objects produced by the "ExtAttr" production. */767 this.extAttrs = obj.extAttrs;768 /** An array of IdlInterfaceMembers. */769 this.members = obj.members.map(function(m){return new IdlInterfaceMember(m); });770 if (this.has_extended_attribute("Unforgeable")) {771 this.members772 .filter(function(m) { return !m["static"] && (m.type == "attribute" || m.type == "operation"); })773 .forEach(function(m) { return m.isUnforgeable = true; });774 }775 /**776 * The name (as a string) of the type we inherit from, or null if there is777 * none.778 */779 this.base = obj.inheritance;780 this._is_callback = is_callback;781}782//@}783IdlInterface.prototype = Object.create(IdlObject.prototype);784IdlInterface.prototype.is_callback = function()785//@{786{787 return this._is_callback;788};789//@}790IdlInterface.prototype.has_constants = function()791//@{792{793 return this.members.some(function(member) {794 return member.type === "const";795 });796};797//@}798IdlInterface.prototype.is_global = function()799//@{800{801 return this.extAttrs.some(function(attribute) {802 return attribute.name === "Global" ||803 attribute.name === "PrimaryGlobal";804 });805};806//@}807IdlInterface.prototype.has_to_json_regular_operation = function() {808 return this.members.some(function(m) {809 return m.is_to_json_regular_operation();810 });811};812IdlInterface.prototype.has_default_to_json_regular_operation = function() {813 return this.members.some(function(m) {814 return m.is_to_json_regular_operation() && m.has_extended_attribute("Default");815 });816};817IdlInterface.prototype.get_inheritance_stack = function() {818 /**819 * See https://heycam.github.io/webidl/#create-an-inheritance-stack820 *821 * Returns an array of IdlInterface objects which contains itself822 * and all of its inherited interfaces.823 *824 * So given:825 *826 * A : B {};827 * B : C {};828 * C {};829 *830 * then A.get_inheritance_stack() should return [A, B, C],831 * and B.get_inheritance_stack() should return [B, C].832 *833 * Note: as dictionary inheritance is expressed identically by the AST,834 * this works just as well for getting a stack of inherited dictionaries. 835 */836 var stack = [this];837 var idl_interface = this;838 while (idl_interface.base) {839 var base = this.array.members[idl_interface.base];840 if (!base) {841 throw new Error(idl_interface.type + " " + idl_interface.base + " not found (inherited by " + idl_interface.name + ")");842 }843 idl_interface = base;844 stack.push(idl_interface);845 }846 return stack;847};848/**849 * Implementation of850 * https://heycam.github.io/webidl/#default-tojson-operation851 * for testing purposes.852 *853 * Collects the IDL types of the attributes that meet the criteria854 * for inclusion in the default toJSON operation for easy855 * comparison with actual value856 */857IdlInterface.prototype.default_to_json_operation = function(callback) {858 var map = new Map(), isDefault = false;859 this.traverse_inherited_and_consequential_interfaces(function(I) {860 if (I.has_default_to_json_regular_operation()) {861 isDefault = true;862 I.members.forEach(function(m) {863 if (!m.static && m.type == "attribute" && I.array.is_json_type(m.idlType)) {864 map.set(m.name, m.idlType);865 }866 });867 } else if (I.has_to_json_regular_operation()) {868 isDefault = false;869 }870 });871 return isDefault ? map : null;872};873/**874 * Traverses inherited interfaces from the top down875 * and imeplemented interfaces inside out.876 * Invokes |callback| on each interface.877 *878 * This is an abstract implementation of the traversal879 * algorithm specified in:880 * https://heycam.github.io/webidl/#collect-attribute-values881 * Given the following inheritance tree:882 *883 * F884 * |885 * C E - I886 * | |887 * B - D888 * |889 * G - A - H - J890 *891 * Invoking traverse_inherited_and_consequential_interfaces() on A892 * would traverse the tree in the following order:893 * C -> B -> F -> E -> I -> D -> A -> G -> H -> J894 */895IdlInterface.prototype.traverse_inherited_and_consequential_interfaces = function(callback) {896 if (typeof callback != "function") {897 throw new TypeError();898 }899 var stack = this.get_inheritance_stack();900 _traverse_inherited_and_consequential_interfaces(stack, callback);901};902function _traverse_inherited_and_consequential_interfaces(stack, callback) {903 var I = stack.pop();904 callback(I);905 var mixins = I.array["implements"][I.name];906 if (mixins) {907 mixins.forEach(id => {908 var mixin = I.array.members[id];909 if (!mixin) {910 throw new Error("Interface " + id + " not found (implemented by " + I.name + ")");911 }912 var interfaces = mixin.get_inheritance_stack();913 _traverse_inherited_and_consequential_interfaces(interfaces, callback);914 });915 }916 if (stack.length > 0) {917 _traverse_inherited_and_consequential_interfaces(stack, callback);918 }919}920IdlInterface.prototype.test = function()921//@{922{923 if (this.has_extended_attribute("NoInterfaceObject"))924 {925 // No tests to do without an instance. TODO: We should still be able926 // to run tests on the prototype object, if we obtain one through some927 // other means.928 return;929 }930 if (!this.exposed) {931 test(function() {932 assert_false(this.name in self);933 }.bind(this), this.name + " interface: existence and properties of interface object");934 return;935 }936 if (!this.untested)937 {938 // First test things to do with the exception/interface object and939 // exception/interface prototype object.940 this.test_self();941 }942 // Then test things to do with its members (constants, fields, attributes,943 // operations, . . .). These are run even if .untested is true, because944 // members might themselves be marked as .untested. This might happen to945 // interfaces if the interface itself is untested but a partial interface946 // that extends it is tested -- then the interface itself and its initial947 // members will be marked as untested, but the members added by the partial948 // interface are still tested.949 this.test_members();950};951//@}952IdlInterface.prototype.test_self = function()953//@{954{955 test(function()956 {957 // This function tests WebIDL as of 2015-01-13.958 // "For every interface that is exposed in a given ECMAScript global959 // environment and:960 // * is a callback interface that has constants declared on it, or961 // * is a non-callback interface that is not declared with the962 // [NoInterfaceObject] extended attribute,963 // a corresponding property MUST exist on the ECMAScript global object.964 // The name of the property is the identifier of the interface, and its965 // value is an object called the interface object.966 // The property has the attributes { [[Writable]]: true,967 // [[Enumerable]]: false, [[Configurable]]: true }."968 if (this.is_callback() && !this.has_constants()) {969 return;970 }971 // TODO: Should we test here that the property is actually writable972 // etc., or trust getOwnPropertyDescriptor?973 assert_own_property(self, this.name,974 "self does not have own property " + format_value(this.name));975 var desc = Object.getOwnPropertyDescriptor(self, this.name);976 assert_false("get" in desc, "self's property " + format_value(this.name) + " should not have a getter");977 assert_false("set" in desc, "self's property " + format_value(this.name) + " should not have a setter");978 assert_true(desc.writable, "self's property " + format_value(this.name) + " should be writable");979 assert_false(desc.enumerable, "self's property " + format_value(this.name) + " should not be enumerable");980 assert_true(desc.configurable, "self's property " + format_value(this.name) + " should be configurable");981 if (this.is_callback()) {982 // "The internal [[Prototype]] property of an interface object for983 // a callback interface must be the Function.prototype object."984 assert_equals(Object.getPrototypeOf(self[this.name]), Function.prototype,985 "prototype of self's property " + format_value(this.name) + " is not Object.prototype");986 return;987 }988 // "The interface object for a given non-callback interface is a989 // function object."990 // "If an object is defined to be a function object, then it has991 // characteristics as follows:"992 // Its [[Prototype]] internal property is otherwise specified (see993 // below).994 // "* Its [[Get]] internal property is set as described in ECMA-262995 // section 9.1.8."996 // Not much to test for this.997 // "* Its [[Construct]] internal property is set as described in998 // ECMA-262 section 19.2.2.3."999 // Tested below if no constructor is defined. TODO: test constructors1000 // if defined.1001 // "* Its @@hasInstance property is set as described in ECMA-2621002 // section 19.2.3.8, unless otherwise specified."1003 // TODO1004 // ES6 (rev 30) 19.1.3.6:1005 // "Else, if O has a [[Call]] internal method, then let builtinTag be1006 // "Function"."1007 assert_class_string(self[this.name], "Function", "class string of " + this.name);1008 // "The [[Prototype]] internal property of an interface object for a1009 // non-callback interface is determined as follows:"1010 var prototype = Object.getPrototypeOf(self[this.name]);1011 if (this.base) {1012 // "* If the interface inherits from some other interface, the1013 // value of [[Prototype]] is the interface object for that other1014 // interface."1015 var has_interface_object =1016 !this.array1017 .members[this.base]1018 .has_extended_attribute("NoInterfaceObject");1019 if (has_interface_object) {1020 assert_own_property(self, this.base,1021 'should inherit from ' + this.base +1022 ', but self has no such property');1023 assert_equals(prototype, self[this.base],1024 'prototype of ' + this.name + ' is not ' +1025 this.base);1026 }1027 } else {1028 // "If the interface doesn't inherit from any other interface, the1029 // value of [[Prototype]] is %FunctionPrototype% ([ECMA-262],1030 // section 6.1.7.4)."1031 assert_equals(prototype, Function.prototype,1032 "prototype of self's property " + format_value(this.name) + " is not Function.prototype");1033 }1034 if (!this.has_extended_attribute("Constructor")) {1035 // "The internal [[Call]] method of the interface object behaves as1036 // follows . . .1037 //1038 // "If I was not declared with a [Constructor] extended attribute,1039 // then throw a TypeError."1040 assert_throws(new TypeError(), function() {1041 self[this.name]();1042 }.bind(this), "interface object didn't throw TypeError when called as a function");1043 assert_throws(new TypeError(), function() {1044 new self[this.name]();1045 }.bind(this), "interface object didn't throw TypeError when called as a constructor");1046 }1047 }.bind(this), this.name + " interface: existence and properties of interface object");1048 if (!this.is_callback()) {1049 test(function() {1050 // This function tests WebIDL as of 2014-10-25.1051 // https://heycam.github.io/webidl/#es-interface-call1052 assert_own_property(self, this.name,1053 "self does not have own property " + format_value(this.name));1054 // "Interface objects for non-callback interfaces MUST have a1055 // property named “length” with attributes { [[Writable]]: false,1056 // [[Enumerable]]: false, [[Configurable]]: true } whose value is1057 // a Number."1058 assert_own_property(self[this.name], "length");1059 var desc = Object.getOwnPropertyDescriptor(self[this.name], "length");1060 assert_false("get" in desc, this.name + ".length should not have a getter");1061 assert_false("set" in desc, this.name + ".length should not have a setter");1062 assert_false(desc.writable, this.name + ".length should not be writable");1063 assert_false(desc.enumerable, this.name + ".length should not be enumerable");1064 assert_true(desc.configurable, this.name + ".length should be configurable");1065 var constructors = this.extAttrs1066 .filter(function(attr) { return attr.name == "Constructor"; });1067 var expected_length = minOverloadLength(constructors);1068 assert_equals(self[this.name].length, expected_length, "wrong value for " + this.name + ".length");1069 }.bind(this), this.name + " interface object length");1070 }1071 if (!this.is_callback() || this.has_constants()) {1072 test(function() {1073 // This function tests WebIDL as of 2015-11-17.1074 // https://heycam.github.io/webidl/#interface-object1075 assert_own_property(self, this.name,1076 "self does not have own property " + format_value(this.name));1077 // "All interface objects must have a property named “name” with1078 // attributes { [[Writable]]: false, [[Enumerable]]: false,1079 // [[Configurable]]: true } whose value is the identifier of the1080 // corresponding interface."1081 assert_own_property(self[this.name], "name");1082 var desc = Object.getOwnPropertyDescriptor(self[this.name], "name");1083 assert_false("get" in desc, this.name + ".name should not have a getter");1084 assert_false("set" in desc, this.name + ".name should not have a setter");1085 assert_false(desc.writable, this.name + ".name should not be writable");1086 assert_false(desc.enumerable, this.name + ".name should not be enumerable");1087 assert_true(desc.configurable, this.name + ".name should be configurable");1088 assert_equals(self[this.name].name, this.name, "wrong value for " + this.name + ".name");1089 }.bind(this), this.name + " interface object name");1090 }1091 if (this.has_extended_attribute("LegacyWindowAlias")) {1092 test(function()1093 {1094 var aliasAttrs = this.extAttrs.filter(function(o) { return o.name === "LegacyWindowAlias"; });1095 if (aliasAttrs.length > 1) {1096 throw "Invalid IDL: multiple LegacyWindowAlias extended attributes on " + this.name;1097 }1098 if (this.is_callback()) {1099 throw "Invalid IDL: LegacyWindowAlias extended attribute on non-interface " + this.name;1100 }1101 if (this.exposureSet.indexOf("Window") === -1) {1102 throw "Invalid IDL: LegacyWindowAlias extended attribute on " + this.name + " which is not exposed in Window";1103 }1104 // TODO: when testing of [NoInterfaceObject] interfaces is supported,1105 // check that it's not specified together with LegacyWindowAlias.1106 // TODO: maybe check that [LegacyWindowAlias] is not specified on a partial interface.1107 var rhs = aliasAttrs[0].rhs;1108 if (!rhs) {1109 throw "Invalid IDL: LegacyWindowAlias extended attribute on " + this.name + " without identifier";1110 }1111 var aliases;1112 if (rhs.type === "identifier-list") {1113 aliases = rhs.value;1114 } else { // rhs.type === identifier1115 aliases = [ rhs.value ];1116 }1117 // OK now actually check the aliases...1118 var alias;1119 if (exposed_in(exposure_set(this, this.exposureSet)) && 'document' in self) {1120 for (alias of aliases) {1121 assert_true(alias in self, alias + " should exist");1122 assert_equals(self[alias], self[this.name], "self." + alias + " should be the same value as self." + this.name);1123 var desc = Object.getOwnPropertyDescriptor(self, alias);1124 assert_equals(desc.value, self[this.name], "wrong value in " + alias + " property descriptor");1125 assert_true(desc.writable, alias + " should be writable");1126 assert_false(desc.enumerable, alias + " should not be enumerable");1127 assert_true(desc.configurable, alias + " should be configurable");1128 assert_false('get' in desc, alias + " should not have a getter");1129 assert_false('set' in desc, alias + " should not have a setter");1130 }1131 } else {1132 for (alias of aliases) {1133 assert_false(alias in self, alias + " should not exist");1134 }1135 }1136 }.bind(this), this.name + " interface: legacy window alias");1137 }1138 // TODO: Test named constructors if I find any interfaces that have them.1139 test(function()1140 {1141 // This function tests WebIDL as of 2015-01-21.1142 // https://heycam.github.io/webidl/#interface-object1143 if (this.is_callback() && !this.has_constants()) {1144 return;1145 }1146 assert_own_property(self, this.name,1147 "self does not have own property " + format_value(this.name));1148 if (this.is_callback()) {1149 assert_false("prototype" in self[this.name],1150 this.name + ' should not have a "prototype" property');1151 return;1152 }1153 // "An interface object for a non-callback interface must have a1154 // property named “prototype” with attributes { [[Writable]]: false,1155 // [[Enumerable]]: false, [[Configurable]]: false } whose value is an1156 // object called the interface prototype object. This object has1157 // properties that correspond to the regular attributes and regular1158 // operations defined on the interface, and is described in more detail1159 // in section 4.5.4 below."1160 assert_own_property(self[this.name], "prototype",1161 'interface "' + this.name + '" does not have own property "prototype"');1162 var desc = Object.getOwnPropertyDescriptor(self[this.name], "prototype");1163 assert_false("get" in desc, this.name + ".prototype should not have a getter");1164 assert_false("set" in desc, this.name + ".prototype should not have a setter");1165 assert_false(desc.writable, this.name + ".prototype should not be writable");1166 assert_false(desc.enumerable, this.name + ".prototype should not be enumerable");1167 assert_false(desc.configurable, this.name + ".prototype should not be configurable");1168 // Next, test that the [[Prototype]] of the interface prototype object1169 // is correct. (This is made somewhat difficult by the existence of1170 // [NoInterfaceObject].)1171 // TODO: Aryeh thinks there's at least other place in this file where1172 // we try to figure out if an interface prototype object is1173 // correct. Consolidate that code.1174 // "The interface prototype object for a given interface A must have an1175 // internal [[Prototype]] property whose value is returned from the1176 // following steps:1177 // "If A is declared with the [Global] or [PrimaryGlobal] extended1178 // attribute, and A supports named properties, then return the named1179 // properties object for A, as defined in §3.6.4 Named properties1180 // object.1181 // "Otherwise, if A is declared to inherit from another interface, then1182 // return the interface prototype object for the inherited interface.1183 // "Otherwise, if A is declared with the [LegacyArrayClass] extended1184 // attribute, then return %ArrayPrototype%.1185 // "Otherwise, return %ObjectPrototype%.1186 if (this.name === "Window") {1187 assert_class_string(Object.getPrototypeOf(self[this.name].prototype),1188 'WindowProperties',1189 'Class name for prototype of Window' +1190 '.prototype is not "WindowProperties"');1191 } else {1192 var inherit_interface, inherit_interface_has_interface_object;1193 if (this.base) {1194 inherit_interface = this.base;1195 inherit_interface_has_interface_object =1196 !this.array1197 .members[inherit_interface]1198 .has_extended_attribute("NoInterfaceObject");1199 } else if (this.has_extended_attribute('LegacyArrayClass')) {1200 inherit_interface = 'Array';1201 inherit_interface_has_interface_object = true;1202 } else {1203 inherit_interface = 'Object';1204 inherit_interface_has_interface_object = true;1205 }1206 if (inherit_interface_has_interface_object) {1207 assert_own_property(self, inherit_interface,1208 'should inherit from ' + inherit_interface + ', but self has no such property');1209 assert_own_property(self[inherit_interface], 'prototype',1210 'should inherit from ' + inherit_interface + ', but that object has no "prototype" property');1211 assert_equals(Object.getPrototypeOf(self[this.name].prototype),1212 self[inherit_interface].prototype,1213 'prototype of ' + this.name + '.prototype is not ' + inherit_interface + '.prototype');1214 } else {1215 // We can't test that we get the correct object, because this is the1216 // only way to get our hands on it. We only test that its class1217 // string, at least, is correct.1218 assert_class_string(Object.getPrototypeOf(self[this.name].prototype),1219 inherit_interface + 'Prototype',1220 'Class name for prototype of ' + this.name +1221 '.prototype is not "' + inherit_interface + 'Prototype"');1222 }1223 }1224 // "The class string of an interface prototype object is the1225 // concatenation of the interface’s identifier and the string1226 // “Prototype”."1227 // Skip these tests for now due to a specification issue about1228 // prototype name.1229 // https://www.w3.org/Bugs/Public/show_bug.cgi?id=282441230 // assert_class_string(self[this.name].prototype, this.name + "Prototype",1231 // "class string of " + this.name + ".prototype");1232 // String() should end up calling {}.toString if nothing defines a1233 // stringifier.1234 if (!this.has_stringifier()) {1235 // assert_equals(String(self[this.name].prototype), "[object " + this.name + "Prototype]",1236 // "String(" + this.name + ".prototype)");1237 }1238 }.bind(this), this.name + " interface: existence and properties of interface prototype object");1239 if (this.is_global() && typeof Object.setPrototypeOf === "function") {1240 // These functions test WebIDL as of 2017-06-06.1241 // https://heycam.github.io/webidl/#platform-object-setprototypeof1242 test(function() {1243 var originalValue = Object.getPrototypeOf(self[this.name].prototype);1244 var newValue = Object.create(null);1245 assert_throws(new TypeError(), function() {1246 Object.setPrototypeOf(self[this.name].prototype, newValue);1247 });1248 assert_equals(1249 Object.getPrototypeOf(self[this.name].prototype),1250 originalValue,1251 "original value not modified"1252 );1253 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1254 "of global platform object - setting to a new value via Object.setPrototypeOf " +1255 "should throw a TypeError");1256 test(function() {1257 var originalValue = Object.getPrototypeOf(self[this.name].prototype);1258 var newValue = Object.create(null);1259 assert_throws(new TypeError(), function() {1260 self[this.name].prototype.__proto__ = newValue;1261 });1262 assert_equals(1263 Object.getPrototypeOf(self[this.name].prototype),1264 originalValue,1265 "original value not modified"1266 );1267 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1268 "of global platform object - setting to a new value via __proto__ " +1269 "should throw a TypeError");1270 test(function() {1271 var originalValue = Object.getPrototypeOf(self[this.name].prototype);1272 var newValue = Object.create(null);1273 assert_false(Reflect.setPrototypeOf(self[this.name].prototype.__proto__, newValue));1274 assert_equals(1275 Object.getPrototypeOf(self[this.name].prototype),1276 originalValue,1277 "original value not modified"1278 );1279 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1280 "of global platform object - setting to a new value via Reflect.setPrototypeOf " +1281 "should return false");1282 test(function() {1283 var originalValue = Object.getPrototypeOf(self[this.name].prototype);1284 Object.setPrototypeOf(self[this.name].prototype, originalValue);1285 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1286 "of global platform object - setting to its original value via Object.setPrototypeOf " +1287 "should not throw");1288 test(function() {1289 var originalValue = Object.getPrototypeOf(self[this.name].prototype);1290 self[this.name].prototype.__proto__ = originalValue;1291 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1292 "of global platform object - setting to its original value via __proto__ " +1293 "should not throw");1294 test(function() {1295 var originalValue = Object.getPrototypeOf(self[this.name].prototype);1296 assert_true(Reflect.setPrototypeOf(self[this.name].prototype, originalValue));1297 }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +1298 "of global platform object - setting to its original value via Reflect.setPrototypeOf " +1299 "should return true");1300 }1301 test(function()1302 {1303 if (this.is_callback() && !this.has_constants()) {1304 return;1305 }1306 assert_own_property(self, this.name,1307 "self does not have own property " + format_value(this.name));1308 if (this.is_callback()) {1309 assert_false("prototype" in self[this.name],1310 this.name + ' should not have a "prototype" property');1311 return;1312 }1313 assert_own_property(self[this.name], "prototype",1314 'interface "' + this.name + '" does not have own property "prototype"');1315 // "If the [NoInterfaceObject] extended attribute was not specified on1316 // the interface, then the interface prototype object must also have a1317 // property named “constructor” with attributes { [[Writable]]: true,1318 // [[Enumerable]]: false, [[Configurable]]: true } whose value is a1319 // reference to the interface object for the interface."1320 assert_own_property(self[this.name].prototype, "constructor",1321 this.name + '.prototype does not have own property "constructor"');1322 var desc = Object.getOwnPropertyDescriptor(self[this.name].prototype, "constructor");1323 assert_false("get" in desc, this.name + ".prototype.constructor should not have a getter");1324 assert_false("set" in desc, this.name + ".prototype.constructor should not have a setter");1325 assert_true(desc.writable, this.name + ".prototype.constructor should be writable");1326 assert_false(desc.enumerable, this.name + ".prototype.constructor should not be enumerable");1327 assert_true(desc.configurable, this.name + ".prototype.constructor should be configurable");1328 assert_equals(self[this.name].prototype.constructor, self[this.name],1329 this.name + '.prototype.constructor is not the same object as ' + this.name);1330 }.bind(this), this.name + ' interface: existence and properties of interface prototype object\'s "constructor" property');1331};1332//@}1333IdlInterface.prototype.test_member_const = function(member)1334//@{1335{1336 if (!this.has_constants()) {1337 throw "Internal error: test_member_const called without any constants";1338 }1339 test(function()1340 {1341 assert_own_property(self, this.name,1342 "self does not have own property " + format_value(this.name));1343 // "For each constant defined on an interface A, there must be1344 // a corresponding property on the interface object, if it1345 // exists."1346 assert_own_property(self[this.name], member.name);1347 // "The value of the property is that which is obtained by1348 // converting the constant’s IDL value to an ECMAScript1349 // value."1350 assert_equals(self[this.name][member.name], constValue(member.value),1351 "property has wrong value");1352 // "The property has attributes { [[Writable]]: false,1353 // [[Enumerable]]: true, [[Configurable]]: false }."1354 var desc = Object.getOwnPropertyDescriptor(self[this.name], member.name);1355 assert_false("get" in desc, "property should not have a getter");1356 assert_false("set" in desc, "property should not have a setter");1357 assert_false(desc.writable, "property should not be writable");1358 assert_true(desc.enumerable, "property should be enumerable");1359 assert_false(desc.configurable, "property should not be configurable");1360 }.bind(this), this.name + " interface: constant " + member.name + " on interface object");1361 // "In addition, a property with the same characteristics must1362 // exist on the interface prototype object."1363 test(function()1364 {1365 assert_own_property(self, this.name,1366 "self does not have own property " + format_value(this.name));1367 if (this.is_callback()) {1368 assert_false("prototype" in self[this.name],1369 this.name + ' should not have a "prototype" property');1370 return;1371 }1372 assert_own_property(self[this.name], "prototype",1373 'interface "' + this.name + '" does not have own property "prototype"');1374 assert_own_property(self[this.name].prototype, member.name);1375 assert_equals(self[this.name].prototype[member.name], constValue(member.value),1376 "property has wrong value");1377 var desc = Object.getOwnPropertyDescriptor(self[this.name], member.name);1378 assert_false("get" in desc, "property should not have a getter");1379 assert_false("set" in desc, "property should not have a setter");1380 assert_false(desc.writable, "property should not be writable");1381 assert_true(desc.enumerable, "property should be enumerable");1382 assert_false(desc.configurable, "property should not be configurable");1383 }.bind(this), this.name + " interface: constant " + member.name + " on interface prototype object");1384};1385//@}1386IdlInterface.prototype.test_member_attribute = function(member)1387//@{1388 {1389 var a_test = async_test(this.name + " interface: attribute " + member.name);1390 a_test.step(function()1391 {1392 if (this.is_callback() && !this.has_constants()) {1393 a_test.done()1394 return;1395 }1396 assert_own_property(self, this.name,1397 "self does not have own property " + format_value(this.name));1398 assert_own_property(self[this.name], "prototype",1399 'interface "' + this.name + '" does not have own property "prototype"');1400 if (member["static"]) {1401 assert_own_property(self[this.name], member.name,1402 "The interface object must have a property " +1403 format_value(member.name));1404 a_test.done();1405 } else if (this.is_global()) {1406 assert_own_property(self, member.name,1407 "The global object must have a property " +1408 format_value(member.name));1409 assert_false(member.name in self[this.name].prototype,1410 "The prototype object should not have a property " +1411 format_value(member.name));1412 var getter = Object.getOwnPropertyDescriptor(self, member.name).get;1413 assert_equals(typeof(getter), "function",1414 format_value(member.name) + " must have a getter");1415 // Try/catch around the get here, since it can legitimately throw.1416 // If it does, we obviously can't check for equality with direct1417 // invocation of the getter.1418 var gotValue;1419 var propVal;1420 try {1421 propVal = self[member.name];1422 gotValue = true;1423 } catch (e) {1424 gotValue = false;1425 }1426 if (gotValue) {1427 assert_equals(propVal, getter.call(undefined),1428 "Gets on a global should not require an explicit this");1429 }1430 // do_interface_attribute_asserts must be the last thing we do,1431 // since it will call done() on a_test.1432 this.do_interface_attribute_asserts(self, member, a_test);1433 } else {1434 assert_true(member.name in self[this.name].prototype,1435 "The prototype object must have a property " +1436 format_value(member.name));1437 if (!member.has_extended_attribute("LenientThis")) {1438 if (member.idlType.generic !== "Promise") {1439 assert_throws(new TypeError(), function() {1440 self[this.name].prototype[member.name];1441 }.bind(this), "getting property on prototype object must throw TypeError");1442 // do_interface_attribute_asserts must be the last thing we1443 // do, since it will call done() on a_test.1444 this.do_interface_attribute_asserts(self[this.name].prototype, member, a_test);1445 } else {1446 promise_rejects(a_test, new TypeError(),1447 self[this.name].prototype[member.name])1448 .then(function() {1449 // do_interface_attribute_asserts must be the last1450 // thing we do, since it will call done() on a_test.1451 this.do_interface_attribute_asserts(self[this.name].prototype,1452 member, a_test);1453 }.bind(this));1454 }1455 } else {1456 assert_equals(self[this.name].prototype[member.name], undefined,1457 "getting property on prototype object must return undefined");1458 // do_interface_attribute_asserts must be the last thing we do,1459 // since it will call done() on a_test.1460 this.do_interface_attribute_asserts(self[this.name].prototype, member, a_test);1461 }1462 }1463 }.bind(this));1464};1465//@}1466IdlInterface.prototype.test_member_operation = function(member)1467//@{1468{1469 var a_test = async_test(this.name + " interface: operation " + member.name +1470 "(" + member.arguments.map(1471 function(m) {return m.idlType.idlType; } )1472 +")");1473 a_test.step(function()1474 {1475 // This function tests WebIDL as of 2015-12-29.1476 // https://heycam.github.io/webidl/#es-operations1477 if (this.is_callback() && !this.has_constants()) {1478 a_test.done();1479 return;1480 }1481 assert_own_property(self, this.name,1482 "self does not have own property " + format_value(this.name));1483 if (this.is_callback()) {1484 assert_false("prototype" in self[this.name],1485 this.name + ' should not have a "prototype" property');1486 a_test.done();1487 return;1488 }1489 assert_own_property(self[this.name], "prototype",1490 'interface "' + this.name + '" does not have own property "prototype"');1491 // "For each unique identifier of an exposed operation defined on the1492 // interface, there must exist a corresponding property, unless the1493 // effective overload set for that identifier and operation and with an1494 // argument count of 0 has no entries."1495 // TODO: Consider [Exposed].1496 // "The location of the property is determined as follows:"1497 var memberHolderObject;1498 // "* If the operation is static, then the property exists on the1499 // interface object."1500 if (member["static"]) {1501 assert_own_property(self[this.name], member.name,1502 "interface object missing static operation");1503 memberHolderObject = self[this.name];1504 // "* Otherwise, [...] if the interface was declared with the [Global]1505 // or [PrimaryGlobal] extended attribute, then the property exists1506 // on every object that implements the interface."1507 } else if (this.is_global()) {1508 assert_own_property(self, member.name,1509 "global object missing non-static operation");1510 memberHolderObject = self;1511 // "* Otherwise, the property exists solely on the interface’s1512 // interface prototype object."1513 } else {1514 assert_own_property(self[this.name].prototype, member.name,1515 "interface prototype object missing non-static operation");1516 memberHolderObject = self[this.name].prototype;1517 }1518 this.do_member_operation_asserts(memberHolderObject, member, a_test);1519 }.bind(this));1520};1521//@}1522IdlInterface.prototype.do_member_operation_asserts = function(memberHolderObject, member, a_test)1523//@{1524{1525 var done = a_test.done.bind(a_test);1526 var operationUnforgeable = member.isUnforgeable;1527 var desc = Object.getOwnPropertyDescriptor(memberHolderObject, member.name);1528 // "The property has attributes { [[Writable]]: B,1529 // [[Enumerable]]: true, [[Configurable]]: B }, where B is false if the1530 // operation is unforgeable on the interface, and true otherwise".1531 assert_false("get" in desc, "property should not have a getter");1532 assert_false("set" in desc, "property should not have a setter");1533 assert_equals(desc.writable, !operationUnforgeable,1534 "property should be writable if and only if not unforgeable");1535 assert_true(desc.enumerable, "property should be enumerable");1536 assert_equals(desc.configurable, !operationUnforgeable,1537 "property should be configurable if and only if not unforgeable");1538 // "The value of the property is a Function object whose1539 // behavior is as follows . . ."1540 assert_equals(typeof memberHolderObject[member.name], "function",1541 "property must be a function");1542 // "The value of the Function object’s “length” property is1543 // a Number determined as follows:1544 // ". . .1545 // "Return the length of the shortest argument list of the1546 // entries in S."1547 assert_equals(memberHolderObject[member.name].length,1548 minOverloadLength(this.members.filter(function(m) {1549 return m.type == "operation" && m.name == member.name;1550 })),1551 "property has wrong .length");1552 if (member.is_to_json_regular_operation()) {1553 this.test_to_json_operation(memberHolderObject, member);1554 }1555 // Make some suitable arguments1556 var args = member.arguments.map(function(arg) {1557 return create_suitable_object(arg.idlType);1558 });1559 // "Let O be a value determined as follows:1560 // ". . .1561 // "Otherwise, throw a TypeError."1562 // This should be hit if the operation is not static, there is1563 // no [ImplicitThis] attribute, and the this value is null.1564 //1565 // TODO: We currently ignore the [ImplicitThis] case. Except we manually1566 // check for globals, since otherwise we'll invoke window.close(). And we1567 // have to skip this test for anything that on the proto chain of "self",1568 // since that does in fact have implicit-this behavior.1569 if (!member["static"]) {1570 var cb;1571 if (!this.is_global() &&1572 memberHolderObject[member.name] != self[member.name])1573 {1574 cb = awaitNCallbacks(2, done);1575 throwOrReject(a_test, member, memberHolderObject[member.name], null, args,1576 "calling operation with this = null didn't throw TypeError", cb);1577 } else {1578 cb = awaitNCallbacks(1, done);1579 }1580 // ". . . If O is not null and is also not a platform object1581 // that implements interface I, throw a TypeError."1582 //1583 // TODO: Test a platform object that implements some other1584 // interface. (Have to be sure to get inheritance right.)1585 throwOrReject(a_test, member, memberHolderObject[member.name], {}, args,1586 "calling operation with this = {} didn't throw TypeError", cb);1587 } else {1588 done();1589 }1590}1591//@}1592IdlInterface.prototype.add_iterable_members = function(member)1593//@{1594{1595 this.members.push(new IdlInterfaceMember(1596 { type: "operation", name: "entries", idlType: "iterator", arguments: []}));1597 this.members.push(new IdlInterfaceMember(1598 { type: "operation", name: "keys", idlType: "iterator", arguments: []}));1599 this.members.push(new IdlInterfaceMember(1600 { type: "operation", name: "values", idlType: "iterator", arguments: []}));1601 this.members.push(new IdlInterfaceMember(1602 { type: "operation", name: "forEach", idlType: "void",1603 arguments:1604 [{ name: "callback", idlType: {idlType: "function"}},1605 { name: "thisValue", idlType: {idlType: "any"}, optional: true}]}));1606};1607IdlInterface.prototype.test_to_json_operation = function(memberHolderObject, member) {1608 if (member.has_extended_attribute("Default")) {1609 var map = this.default_to_json_operation();1610 test(function() {1611 var json = memberHolderObject.toJSON();1612 map.forEach(function(type, k) {1613 assert_true(k in json, "property " + k + " should be present in the output of " + this.name + ".prototype.toJSON()");1614 var descriptor = Object.getOwnPropertyDescriptor(json, k);1615 assert_true(descriptor.writable, "property " + k + " should be writable");1616 assert_true(descriptor.configurable, "property " + k + " should be configurable");1617 assert_true(descriptor.enumerable, "property " + k + " should be enumerable");1618 this.array.assert_type_is(json[k], type);1619 delete json[k];1620 }, this);1621 for (var k in json) {1622 assert_unreached("property " + k + " should not be present in the output of " + this.name + ".prototype.toJSON()");1623 }1624 }.bind(this), "Test default toJSON operation of " + this.name);1625 } else {1626 test(function() {1627 assert_true(this.array.is_json_type(member.idlType), JSON.stringify(member.idlType) + " is not an appropriate return value for the toJSON operation of " + this.name);1628 this.array.assert_type_is(memberHolderObject.toJSON(), member.idlType);1629 }.bind(this), "Test toJSON operation of " + this.name);1630 }1631};1632//@}1633IdlInterface.prototype.test_member_iterable = function(member)1634//@{1635{1636 var interfaceName = this.name;1637 var isPairIterator = member.idlType instanceof Array;1638 test(function()1639 {1640 var descriptor = Object.getOwnPropertyDescriptor(self[interfaceName].prototype, Symbol.iterator);1641 assert_true(descriptor.writable, "property should be writable");1642 assert_true(descriptor.configurable, "property should be configurable");1643 assert_false(descriptor.enumerable, "property should not be enumerable");1644 assert_equals(self[interfaceName].prototype[Symbol.iterator].name, isPairIterator ? "entries" : "values", "@@iterator function does not have the right name");1645 }, "Testing Symbol.iterator property of iterable interface " + interfaceName);1646 if (isPairIterator) {1647 test(function() {1648 assert_equals(self[interfaceName].prototype[Symbol.iterator], self[interfaceName].prototype["entries"], "entries method is not the same as @@iterator");1649 }, "Testing pair iterable interface " + interfaceName);1650 } else {1651 test(function() {1652 ["entries", "keys", "values", "forEach", Symbol.Iterator].forEach(function(property) {1653 assert_equals(self[interfaceName].prototype[property], Array.prototype[property], property + " function is not the same as Array one");1654 });1655 }, "Testing value iterable interface " + interfaceName);1656 }1657};1658//@}1659IdlInterface.prototype.test_member_stringifier = function(member)1660//@{1661{1662 test(function()1663 {1664 if (this.is_callback() && !this.has_constants()) {1665 return;1666 }1667 assert_own_property(self, this.name,1668 "self does not have own property " + format_value(this.name));1669 if (this.is_callback()) {1670 assert_false("prototype" in self[this.name],1671 this.name + ' should not have a "prototype" property');1672 return;1673 }1674 assert_own_property(self[this.name], "prototype",1675 'interface "' + this.name + '" does not have own property "prototype"');1676 // ". . . the property exists on the interface prototype object."1677 var interfacePrototypeObject = self[this.name].prototype;1678 assert_own_property(self[this.name].prototype, "toString",1679 "interface prototype object missing non-static operation");1680 var stringifierUnforgeable = member.isUnforgeable;1681 var desc = Object.getOwnPropertyDescriptor(interfacePrototypeObject, "toString");1682 // "The property has attributes { [[Writable]]: B,1683 // [[Enumerable]]: true, [[Configurable]]: B }, where B is false if the1684 // stringifier is unforgeable on the interface, and true otherwise."1685 assert_false("get" in desc, "property should not have a getter");1686 assert_false("set" in desc, "property should not have a setter");1687 assert_equals(desc.writable, !stringifierUnforgeable,1688 "property should be writable if and only if not unforgeable");1689 assert_true(desc.enumerable, "property should be enumerable");1690 assert_equals(desc.configurable, !stringifierUnforgeable,1691 "property should be configurable if and only if not unforgeable");1692 // "The value of the property is a Function object, which behaves as1693 // follows . . ."1694 assert_equals(typeof interfacePrototypeObject.toString, "function",1695 "property must be a function");1696 // "The value of the Function object’s “length” property is the Number1697 // value 0."1698 assert_equals(interfacePrototypeObject.toString.length, 0,1699 "property has wrong .length");1700 // "Let O be the result of calling ToObject on the this value."1701 assert_throws(new TypeError(), function() {1702 self[this.name].prototype.toString.apply(null, []);1703 }, "calling stringifier with this = null didn't throw TypeError");1704 // "If O is not an object that implements the interface on which the1705 // stringifier was declared, then throw a TypeError."1706 //1707 // TODO: Test a platform object that implements some other1708 // interface. (Have to be sure to get inheritance right.)1709 assert_throws(new TypeError(), function() {1710 self[this.name].prototype.toString.apply({}, []);1711 }, "calling stringifier with this = {} didn't throw TypeError");1712 }.bind(this), this.name + " interface: stringifier");1713};1714//@}1715IdlInterface.prototype.test_members = function()1716//@{1717{1718 for (var i = 0; i < this.members.length; i++)1719 {1720 var member = this.members[i];1721 switch (member.type) {1722 case "iterable":1723 this.add_iterable_members(member);1724 break;1725 // TODO: add setlike and maplike handling.1726 default:1727 break;1728 }1729 }1730 for (var i = 0; i < this.members.length; i++)1731 {1732 var member = this.members[i];1733 if (member.untested) {1734 continue;1735 }1736 if (!exposed_in(exposure_set(member, this.exposureSet))) {1737 test(function() {1738 // It's not exposed, so we shouldn't find it anywhere.1739 assert_false(member.name in self[this.name],1740 "The interface object must not have a property " +1741 format_value(member.name));1742 assert_false(member.name in self[this.name].prototype,1743 "The prototype object must not have a property " +1744 format_value(member.name));1745 }.bind(this), this.name + " interface: member " + member.name);1746 continue;1747 }1748 switch (member.type) {1749 case "const":1750 this.test_member_const(member);1751 break;1752 case "attribute":1753 // For unforgeable attributes, we do the checks in1754 // test_interface_of instead.1755 if (!member.isUnforgeable)1756 {1757 this.test_member_attribute(member);1758 }1759 if (member.stringifier) {1760 this.test_member_stringifier(member);1761 }1762 break;1763 case "operation":1764 // TODO: Need to correctly handle multiple operations with the same1765 // identifier.1766 // For unforgeable operations, we do the checks in1767 // test_interface_of instead.1768 if (member.name) {1769 if (!member.isUnforgeable)1770 {1771 this.test_member_operation(member);1772 }1773 } else if (member.stringifier) {1774 this.test_member_stringifier(member);1775 }1776 break;1777 case "iterable":1778 this.test_member_iterable(member);1779 break;1780 default:1781 // TODO: check more member types.1782 break;1783 }1784 }1785};1786//@}1787IdlInterface.prototype.test_object = function(desc)1788//@{1789{1790 var obj, exception = null;1791 try1792 {1793 obj = eval(desc);1794 }1795 catch(e)1796 {1797 exception = e;1798 }1799 var expected_typeof =1800 this.members.some(function(member) { return member.legacycaller; })1801 ? "function"1802 : "object";1803 this.test_primary_interface_of(desc, obj, exception, expected_typeof);1804 var current_interface = this;1805 while (current_interface)1806 {1807 if (!(current_interface.name in this.array.members))1808 {1809 throw "Interface " + current_interface.name + " not found (inherited by " + this.name + ")";1810 }1811 if (current_interface.prevent_multiple_testing && current_interface.already_tested)1812 {1813 return;1814 }1815 current_interface.test_interface_of(desc, obj, exception, expected_typeof);1816 current_interface = this.array.members[current_interface.base];1817 }1818};1819//@}1820IdlInterface.prototype.test_primary_interface_of = function(desc, obj, exception, expected_typeof)1821//@{1822{1823 // Only the object itself, not its members, are tested here, so if the1824 // interface is untested, there is nothing to do.1825 if (this.untested)1826 {1827 return;1828 }1829 // We can't easily test that its prototype is correct if there's no1830 // interface object, or the object is from a different global environment1831 // (not instanceof Object). TODO: test in this case that its prototype at1832 // least looks correct, even if we can't test that it's actually correct.1833 if (!this.has_extended_attribute("NoInterfaceObject")1834 && (typeof obj != expected_typeof || obj instanceof Object))1835 {1836 test(function()1837 {1838 assert_equals(exception, null, "Unexpected exception when evaluating object");1839 assert_equals(typeof obj, expected_typeof, "wrong typeof object");1840 assert_own_property(self, this.name,1841 "self does not have own property " + format_value(this.name));1842 assert_own_property(self[this.name], "prototype",1843 'interface "' + this.name + '" does not have own property "prototype"');1844 // "The value of the internal [[Prototype]] property of the1845 // platform object is the interface prototype object of the primary1846 // interface from the platform object’s associated global1847 // environment."1848 assert_equals(Object.getPrototypeOf(obj),1849 self[this.name].prototype,1850 desc + "'s prototype is not " + this.name + ".prototype");1851 }.bind(this), this.name + " must be primary interface of " + desc);1852 }1853 // "The class string of a platform object that implements one or more1854 // interfaces must be the identifier of the primary interface of the1855 // platform object."1856 test(function()1857 {1858 assert_equals(exception, null, "Unexpected exception when evaluating object");1859 assert_equals(typeof obj, expected_typeof, "wrong typeof object");1860 assert_class_string(obj, this.name, "class string of " + desc);1861 if (!this.has_stringifier())1862 {1863 assert_equals(String(obj), "[object " + this.name + "]", "String(" + desc + ")");1864 }1865 }.bind(this), "Stringification of " + desc);1866};1867//@}1868IdlInterface.prototype.test_interface_of = function(desc, obj, exception, expected_typeof)1869//@{1870{1871 // TODO: Indexed and named properties, more checks on interface members1872 this.already_tested = true;1873 for (var i = 0; i < this.members.length; i++)1874 {1875 var member = this.members[i];1876 if (member.untested) {1877 continue;1878 }1879 if (!exposed_in(exposure_set(member, this.exposureSet))) {1880 test(function() {1881 assert_false(member.name in obj);1882 }.bind(this), this.name + "interface: " + desc + 'must not have property "' + member.name + '"');1883 continue;1884 }1885 if (member.type == "attribute" && member.isUnforgeable)1886 {1887 var a_test = async_test(this.name + " interface: " + desc + ' must have own property "' + member.name + '"');1888 a_test.step(function() {1889 assert_equals(exception, null, "Unexpected exception when evaluating object");1890 assert_equals(typeof obj, expected_typeof, "wrong typeof object");1891 // Call do_interface_attribute_asserts last, since it will call a_test.done()1892 this.do_interface_attribute_asserts(obj, member, a_test);1893 }.bind(this));...

Full Screen

Full Screen

Using AI Code Generation

copy

Full Screen

1var wpt = require('webpagetest')('www.webpagetest.org');2var location = 'Dulles:Chrome';3var options = {4 videoParams: {5 }6};7wpt.runTest(url, options, function(err, data) {8 if (err) return console.error(err);9 console.log('Test submitted to WebPagetest for %s', url);10 console.log('View your test at: %s', data.data.userUrl);11 console.log('Poll results every %s seconds.', options.pollResults);12 console.log('Video capture: %s', data.data.videoFrames);13 console.log('Video URL: %s', data.data.videoUrl);14 console.log('Test ID: %s', data.data.testId);15});

Full Screen

Using AI Code Generation

copy

Full Screen

1var wpt = require('webpagetest');2var wpt = new WebPageTest('www.webpagetest.org');3var options = { location: 'Dulles:Chrome', runs: 3, connectivity: 'Cable' };4 if (err) return console.error(err);5 console.log('Test status:', data.statusText);6 wpt.exposure_set(data.data.testId, 'public', function(err, data) {7 if (err) return console.error(err);8 console.log('Test status:', data.statusText);9 });10});11var wpt = require('webpagetest');12var wpt = new WebPageTest('www.webpagetest.org');13var options = { location: 'Dulles:Chrome', runs: 3, connectivity: 'Cable' };14 if (err) return console.error(err);15 console.log('Test status:', data.statusText);16 wpt.exposure_get(data.data.testId, function(err, data) {17 if (err) return console.error(err);18 console.log('Test status:', data.statusText);19 });20});21var wpt = require('webpagetest');22var wpt = new WebPageTest('www.webpagetest.org');23var options = { location: 'Dulles:Chrome', runs: 3, connectivity: 'Cable' };24 if (err) return console.error(err);25 console.log('Test status:', data.statusText);26 wpt.test_status(data.data.testId, function(err, data) {27 if (err) return console.error(err);28 console.log('Test status:', data.statusText);29 });30});31var wpt = require('webpagetest');32var wpt = new WebPageTest('www.webpagetest.org');33var options = { location: 'Dulles:Chrome', runs: 3, connectivity: 'Cable' };

Full Screen

Using AI Code Generation

copy

Full Screen

1var wpt = require('webpagetest');2var client = wpt('www.webpagetest.org');3 if (err) {4 console.log("Error: " + err);5 } else {6 console.log("Test ID: " + data.data.testId);7 console.log("Test URL: " + data.data.summary);8 console.log("View Test: " + data.data.userUrl);9 }10});11var wpt = require('webpagetest');12var client = wpt('www.webpagetest.org');13 if (err) {14 console.log("Error: " + err);15 } else {16 console.log("Test ID: " + data.data.testId);17 console.log("Test URL: " + data.data.summary);18 console.log("View Test: " + data.data.userUrl);19 }20});21var wpt = require('webpagetest');22var client = wpt('www.webpagetest.org');23 if (err) {24 console.log("Error: " + err);25 } else {26 console.log("Test ID: " + data.data.testId);27 console.log("Test URL: " + data.data.summary);28 console.log("View Test: " + data.data.userUrl);29 }30});31var wpt = require('webpagetest');32var client = wpt('www.webpagetest.org');33 if (err) {34 console.log("Error: " + err);35 } else {36 console.log("Test ID: " + data.data.testId);37 console.log("Test URL: " + data.data.summary);38 console.log("View Test: " + data.data.userUrl);39 }40});41var wpt = require('webpagetest');42var client = wpt('www

Full Screen

Using AI Code Generation

copy

Full Screen

1var wptdriver = require('wptdriver');2wptdriver.exposure_set('test_exposure', 1);3var wptdriver = require('wptdriver');4wptdriver.exposure_get('test_exposure');5var wptdriver = require('wptdriver');6wptdriver.exposure_clear('test_exposure');7var wptdriver = require('wptdriver');8wptdriver.exposure_clear_all();9var wptdriver = require('wptdriver');10wptdriver.exposure_get_all();11* `wptdriver.log_level(level)`12* `wptdriver.log(message, level)`13* `wptdriver.network_emulation_set(network_type, latency, downstream_kbps, upstream_kbps, packet_loss)`14* `Native` - use the native network connection (no emulation)15* `wptdriver.network_clear()`16* `wptdriver.cookie_set(cookie_name, cookie_value, cookie_domain, cookie_path, cookie_expires, cookie_secure, cookie_http_only)`17* `wptdriver.cookie_get(cookie_name

Full Screen

Using AI Code Generation

copy

Full Screen

1var wpt = require('webpagetest');2var client = wpt('www.webpagetest.org');3client.exposure_set('TestID', '1', function(err, data) {4 if (err) {5 console.log(err);6 }7 console.log(data);8});9Name Type Description testId String Test ID exposure Integer Exposure value (0-3)10{11 "data": {12 }13}

Full Screen

Using AI Code Generation

copy

Full Screen

1var wptools = require('wptools');2var wiki = new wptools('Albert Einstein');3wiki.exposure_set('enwiki');4wiki.exposure_set('enwiki', 'Albert Einstein');5wiki.exposure_set('enwiki', 'Albert Einstein', 'Albert Einstein');6wiki.exposure_set('enwiki', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein');7wiki.exposure_set('enwiki', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein');8wiki.exposure_set('enwiki', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein');9wiki.exposure_set('enwiki', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein');10wiki.exposure_set('enwiki', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein');11wiki.exposure_set('enwiki', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein', 'Albert Einstein');12wiki.exposure_set('enwiki', 'Albert Einstein', 'Al

Full Screen

Using AI Code Generation

copy

Full Screen

1var wpt = require('./wpt.js');2var exposure_time = 10;3var file_name = 'test.jpg';4wpt.exposure_set(exposure_time, function(err, data) {5 if (err) {6 console.log(err);7 } else {8 console.log(data);9 wpt.take_picture(file_name, function(err, data) {10 if (err) {11 console.log(err);12 } else {13 console.log(data);14 }15 });16 }17});

Full Screen

Using AI Code Generation

copy

Full Screen

1var wpt = require('WebPageTest');2var wpt = new WebPageTest('www.webpagetest.org');3var options = {4};5 if (err) return console.error(err);6 console.log(data.response.data.testId);7 wpt.exposure_set(data.response.data.testId, '3', function(err, data) {8 if (err) return console.error(err);9 console.log(data);10 });11});12### <a name="exposure_get"></a>exposure_get(testId, callback)13var wpt = require('WebPageTest');14var wpt = new WebPageTest('www.webpagetest.org');15var options = {16};17 if (err) return console.error(err);18 console.log(data.response.data.testId);19 wpt.exposure_get(data.response.data.testId, function(err, data) {20 if (err) return console.error(err);21 console.log(data);22 });23});24### <a name="getLocations"></a>getLocations(callback)

Full Screen

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run wpt automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful