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
112
113
114
115
116
117
118
119
120
121
122
123
124
|
// Copyright 2012 Mozilla Corporation. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/**
* @description Tests that obj meets the requirements for built-in objects
* defined by the introduction of chapter 15 of the ECMAScript Language Specification.
* @param {Object} obj the object to be tested.
* @param {boolean} isFunction whether the specification describes obj as a function.
* @param {boolean} isConstructor whether the specification describes obj as a constructor.
* @param {String[]} properties an array with the names of the built-in properties of obj,
* excluding length, prototype, or properties with non-default attributes.
* @param {number} length for functions only: the length specified for the function
* or derived from the argument list.
* @author Norbert Lindenberg
*/
function testBuiltInObject(obj, isFunction, isConstructor, properties, length) {
if (obj === undefined) {
$ERROR("Object being tested is undefined.");
}
var objString = Object.prototype.toString.call(obj);
if (isFunction) {
if (objString !== "[object Function]") {
$ERROR("The [[Class]] internal property of a built-in function must be " +
"\"Function\", but toString() returns " + objString);
}
} else {
if (objString !== "[object Object]") {
$ERROR("The [[Class]] internal property of a built-in non-function object must be " +
"\"Object\", but toString() returns " + objString);
}
}
if (!Object.isExtensible(obj)) {
$ERROR("Built-in objects must be extensible.");
}
if (isFunction && Object.getPrototypeOf(obj) !== Function.prototype) {
$ERROR("Built-in functions must have Function.prototype as their prototype.");
}
if (isConstructor && Object.getPrototypeOf(obj.prototype) !== Object.prototype) {
$ERROR("Built-in prototype objects must have Object.prototype as their prototype.");
}
// verification of the absence of the [[Construct]] internal property has
// been moved to the end of the test
// verification of the absence of the prototype property has
// been moved to the end of the test
if (isFunction) {
if (typeof obj.length !== "number" || obj.length !== Math.floor(obj.length)) {
$ERROR("Built-in functions must have a length property with an integer value.");
}
if (obj.length !== length) {
$ERROR("Function's length property doesn't have specified value; expected " +
length + ", got " + obj.length + ".");
}
var desc = Object.getOwnPropertyDescriptor(obj, "length");
if (desc.writable) {
$ERROR("The length property of a built-in function must not be writable.");
}
if (desc.enumerable) {
$ERROR("The length property of a built-in function must not be enumerable.");
}
if (desc.configurable) {
$ERROR("The length property of a built-in function must not be configurable.");
}
}
properties.forEach(function(prop) {
var desc = Object.getOwnPropertyDescriptor(obj, prop);
if (desc === undefined) {
$ERROR("Missing property " + prop + ".");
}
// accessor properties don't have writable attribute
if (desc.hasOwnProperty("writable") && !desc.writable) {
$ERROR("The " + prop + " property of this built-in function must be writable.");
}
if (desc.enumerable) {
$ERROR("The " + prop + " property of this built-in function must not be enumerable.");
}
if (!desc.configurable) {
$ERROR("The " + prop + " property of this built-in function must be configurable.");
}
});
// The remaining sections have been moved to the end of the test because
// unbound non-constructor functions written in JavaScript cannot possibly
// pass them, and we still want to test JavaScript implementations as much
// as possible.
var exception;
if (isFunction && !isConstructor) {
// this is not a complete test for the presence of [[Construct]]:
// if it's absent, the exception must be thrown, but it may also
// be thrown if it's present and just has preconditions related to
// arguments or the this value that this statement doesn't meet.
try {
/*jshint newcap:false*/
var instance = new obj();
} catch (e) {
exception = e;
}
if (exception === undefined || exception.name !== "TypeError") {
$ERROR("Built-in functions that aren't constructors must throw TypeError when " +
"used in a \"new\" statement.");
}
}
if (isFunction && !isConstructor && obj.hasOwnProperty("prototype")) {
$ERROR("Built-in functions that aren't constructors must not have a prototype property.");
}
// passed the complete test!
return true;
}
|
