1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
function run_test() {
test(function() {
// "There MUST exist a property on the ECMAScript global object whose
// name is “DOMException” and value is an object called the
// DOMException constructor object, which provides access to legacy
// DOMException code constants. The property has the attributes
// { [[Writable]]: true, [[Enumerable]]: false,
// [[Configurable]]: true }."
assert_own_property(self, "DOMException",
"self does not have own property \"DOMException\"");
var desc = Object.getOwnPropertyDescriptor(self, "DOMException");
assert_false("get" in desc, "self's property \"DOMException\" has getter");
assert_false("set" in desc, "self's property \"DOMException\" has setter");
assert_true(desc.writable, "self's property \"DOMException\" is not writable");
assert_false(desc.enumerable, "self's property \"DOMException\" is enumerable");
assert_true(desc.configurable, "self's property \"DOMException\" is not configurable");
// "The DOMException constructor object MUST be a function object but
// with a [[Prototype]] value of %Error% ([ECMA-262], section 6.1.7.4)."
assert_equals(Object.getPrototypeOf(self.DOMException), Error,
"prototype of self's property \"DOMException\" is not Error");
// "Its [[Get]] internal property is set as described in ECMA-262
// section 9.1.8."
// Not much to test for this.
// "Its [[Construct]] internal property is set as described in ECMA-262
// section 19.2.2.3."
// "Its @@hasInstance property is set as described in ECMA-262 section
// 19.2.3.8, unless otherwise specified."
// String() returns something implementation-dependent, because it
// calls Function#toString.
assert_class_string(self.DOMException, "Function",
"class string of DOMException");
// "For every legacy code listed in the error names table, there MUST
// be a property on the DOMException constructor object whose name and
// value are as indicated in the table. The property has attributes
// { [[Writable]]: false, [[Enumerable]]: true,
// [[Configurable]]: false }."
// See DOMException-constants.html.
}, "existence and properties of DOMException");
test(function() {
assert_own_property(self, "DOMException",
"self does not have own property \"DOMException\"");
// "The DOMException constructor object MUST also have a property named
// “prototype” with attributes { [[Writable]]: false,
// [[Enumerable]]: false, [[Configurable]]: false } whose value is an
// object called the DOMException prototype object. This object also
// provides access to the legacy code values."
assert_own_property(self.DOMException, "prototype",
'exception "DOMException" does not have own property "prototype"');
var desc = Object.getOwnPropertyDescriptor(self.DOMException, "prototype");
assert_false("get" in desc, "DOMException.prototype has getter");
assert_false("set" in desc, "DOMException.prototype has setter");
assert_false(desc.writable, "DOMException.prototype is writable");
assert_false(desc.enumerable, "DOMException.prototype is enumerable");
assert_false(desc.configurable, "DOMException.prototype is configurable");
// "The DOMException prototype object MUST have an internal
// [[Prototype]] property whose value is %ErrorPrototype% ([ECMA-262],
// section 6.1.7.4)."
assert_own_property(self, "Error",
'should inherit from Error, but self has no such property');
assert_own_property(self.Error, "prototype",
'should inherit from Error, but that object has no "prototype" property');
assert_equals(Object.getPrototypeOf(self.DOMException.prototype),
self.Error.prototype,
'prototype of DOMException.prototype is not Error.prototype');
// "The class string of the DOMException prototype object is
// “DOMExceptionPrototype”."
assert_class_string(self.DOMException.prototype, "DOMExceptionPrototype",
"class string of DOMException.prototype");
}, "existence and properties of DOMException.prototype");
test(function() {
assert_false(self.DOMException.prototype.hasOwnProperty("name"),
"DOMException.prototype should not have an own \"name\" " +
"property.");
assert_false(self.DOMException.prototype.hasOwnProperty("code"),
"DOMException.prototype should not have an own \"name\" " +
"property.");
}, "existence of name and code properties on DOMException.prototype");
test(function() {
assert_own_property(self, "DOMException",
"self does not have own property \"DOMException\"");
assert_own_property(self.DOMException, "prototype",
'interface "DOMException" does not have own property "prototype"');
// "There MUST be a property named “constructor” on the DOMException
// prototype object with attributes { [[Writable]]: true,
// [[Enumerable]]: false, [[Configurable]]: true } and whose value is
// the DOMException constructor object."
assert_own_property(self.DOMException.prototype, "constructor",
"DOMException" + '.prototype does not have own property "constructor"');
var desc = Object.getOwnPropertyDescriptor(self.DOMException.prototype, "constructor");
assert_false("get" in desc, "DOMException.prototype.constructor has getter");
assert_false("set" in desc, "DOMException.prototype.constructor has setter");
assert_true(desc.writable, "DOMException.prototype.constructor is not writable");
assert_false(desc.enumerable, "DOMException.prototype.constructor is enumerable");
assert_true(desc.configurable, "DOMException.prototype.constructor in not configurable");
assert_equals(self.DOMException.prototype.constructor, self.DOMException,
"DOMException.prototype.constructor is not the same object as DOMException");
}, "existence and properties of exception interface prototype object's \"constructor\" property");
done();
}
|
