The Tor Browser / file comparison

comparison: js/src/tests/ecma_5/Function/function-bind.js

js/src/tests/ecma_5/Function/function-bind.js

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:7ad0730b2999
1 /*
2 * Any copyright is dedicated to the Public Domain.
3 * http://creativecommons.org/licenses/publicdomain/
4 */
5
6 var gTestfile = 'function-bind.js';
7 var BUGNUMBER = 429507;
8 var summary = "ES5: Function.prototype.bind";
9
10 print(BUGNUMBER + ": " + summary);
11
12 /**************
13 * BEGIN TEST *
14 **************/
15
16 // ad-hoc testing
17
18 assertEq(Function.prototype.hasOwnProperty("bind"), true);
19
20 var bind = Function.prototype.bind;
21 assertEq(bind.length, 1);
22
23
24 var strictReturnThis = function() { "use strict"; return this; };
25
26 assertEq(strictReturnThis.bind(undefined)(), undefined);
27 assertEq(strictReturnThis.bind(null)(), null);
28
29 var obj = {};
30 assertEq(strictReturnThis.bind(obj)(), obj);
31
32 assertEq(strictReturnThis.bind(NaN)(), NaN);
33
34 assertEq(strictReturnThis.bind(true)(), true);
35 assertEq(strictReturnThis.bind(false)(), false);
36
37 assertEq(strictReturnThis.bind("foopy")(), "foopy");
38
39
40 // rigorous, step-by-step testing
41
42 function expectThrowTypeError(fun)
43 {
44 try
45 {
46 var r = fun();
47 throw new Error("didn't throw TypeError, returned " + r);
48 }
49 catch (e)
50 {
51 assertEq(e instanceof TypeError, true,
52 "didn't throw TypeError, got: " + e);
53 }
54 }
55
56 /*
57 * 1. Let Target be the this value.
58 * 2. If IsCallable(Target) is false, throw a TypeError exception.
59 */
60 expectThrowTypeError(function() { bind.call(null); });
61 expectThrowTypeError(function() { bind.call(undefined); });
62 expectThrowTypeError(function() { bind.call(NaN); });
63 expectThrowTypeError(function() { bind.call(0); });
64 expectThrowTypeError(function() { bind.call(-0); });
65 expectThrowTypeError(function() { bind.call(17); });
66 expectThrowTypeError(function() { bind.call(42); });
67 expectThrowTypeError(function() { bind.call("foobar"); });
68 expectThrowTypeError(function() { bind.call(true); });
69 expectThrowTypeError(function() { bind.call(false); });
70 expectThrowTypeError(function() { bind.call([]); });
71 expectThrowTypeError(function() { bind.call({}); });
72
73
74 /*
75 * 3. Let A be a new (possibly empty) internal list of all of the argument
76 * values provided after thisArg (arg1, arg2 etc), in order.
77 * 4. Let F be a new native ECMAScript object .
78 * 5. Set all the internal methods, except for [[Get]], of F as specified in
79 * 8.12.
80 * 6. Set the [[Get]] internal property of F as specified in 15.3.5.4.
81 * 7. Set the [[TargetFunction]] internal property of F to Target.
82 * 8. Set the [[BoundThis]] internal property of F to the value of thisArg.
83 * 9. Set the [[BoundArgs]] internal property of F to A.
84 */
85 // throughout
86
87
88 /* 10. Set the [[Class]] internal property of F to "Function". */
89 var toString = Object.prototype.toString;
90 assertEq(toString.call(function(){}), "[object Function]");
91 assertEq(toString.call(function a(){}), "[object Function]");
92 assertEq(toString.call(function(a){}), "[object Function]");
93 assertEq(toString.call(function a(b){}), "[object Function]");
94 assertEq(toString.call(function(){}.bind()), "[object Function]");
95 assertEq(toString.call(function a(){}.bind()), "[object Function]");
96 assertEq(toString.call(function(a){}.bind()), "[object Function]");
97 assertEq(toString.call(function a(b){}.bind()), "[object Function]");
98
99
100 /*
101 * 11. Set the [[Prototype]] internal property of F to the standard built-in
102 * Function prototype object as specified in 15.3.3.1.
103 */
104 assertEq(Object.getPrototypeOf(bind.call(function(){})), Function.prototype);
105 assertEq(Object.getPrototypeOf(bind.call(function a(){})), Function.prototype);
106 assertEq(Object.getPrototypeOf(bind.call(function(a){})), Function.prototype);
107 assertEq(Object.getPrototypeOf(bind.call(function a(b){})), Function.prototype);
108
109
110 /*
111 * 12. Set the [[Call]] internal property of F as described in 15.3.4.5.1.
112 */
113 var a = Array.bind(1, 2);
114 assertEq(a().length, 2);
115 assertEq(a(4).length, 2);
116 assertEq(a(4, 8).length, 3);
117
118 function t() { return this; }
119 var bt = t.bind(t);
120 assertEq(bt(), t);
121
122 function callee() { return arguments.callee; }
123 var call = callee.bind();
124 assertEq(call(), callee);
125 assertEq(new call(), callee);
126
127
128 /*
129 * 13. Set the [[Construct]] internal property of F as described in 15.3.4.5.2.
130 */
131 function Point(x, y)
132 {
133 this.x = x;
134 this.y = y;
135 }
136 var YAxisPoint = Point.bind(null, 0)
137
138 assertEq(YAxisPoint.hasOwnProperty("prototype"), false);
139 var p = new YAxisPoint(5);
140 assertEq(p.x, 0);
141 assertEq(p.y, 5);
142 assertEq(p instanceof Point, true);
143 assertEq(p instanceof YAxisPoint, true);
144 assertEq(Object.prototype.toString.call(YAxisPoint), "[object Function]");
145 assertEq(YAxisPoint.length, 1);
146
147
148 /*
149 * 14. Set the [[HasInstance]] internal property of F as described in
150 * 15.3.4.5.3.
151 */
152 function JoinArguments()
153 {
154 this.args = Array.prototype.join.call(arguments, ", ");
155 }
156
157 var Join1 = JoinArguments.bind(null, 1);
158 var Join2 = Join1.bind(null, 2);
159 var Join3 = Join2.bind(null, 3);
160 var Join4 = Join3.bind(null, 4);
161 var Join5 = Join4.bind(null, 5);
162 var Join6 = Join5.bind(null, 6);
163
164 var r = new Join6(7);
165 assertEq(r instanceof Join6, true);
166 assertEq(r instanceof Join5, true);
167 assertEq(r instanceof Join4, true);
168 assertEq(r instanceof Join3, true);
169 assertEq(r instanceof Join2, true);
170 assertEq(r instanceof Join1, true);
171 assertEq(r instanceof JoinArguments, true);
172 assertEq(r.args, "1, 2, 3, 4, 5, 6, 7");
173
174
175 /*
176 * 15. If the [[Class]] internal property of Target is "Function", then
177 * a. Let L be the length property of Target minus the length of A.
178 * b. Set the length own property of F to either 0 or L, whichever is larger.
179 * 16. Else set the length own property of F to 0.
180 */
181 function none() { return arguments.length; }
182 assertEq(none.bind(1, 2)(3, 4), 3);
183 assertEq(none.bind(1, 2)(), 1);
184 assertEq(none.bind(1)(2, 3), 2);
185 assertEq(none.bind().length, 0);
186 assertEq(none.bind(null).length, 0);
187 assertEq(none.bind(null, 1).length, 0);
188 assertEq(none.bind(null, 1, 2).length, 0);
189
190 function one(a) { }
191 assertEq(one.bind().length, 1);
192 assertEq(one.bind(null).length, 1);
193 assertEq(one.bind(null, 1).length, 0);
194 assertEq(one.bind(null, 1, 2).length, 0);
195
196 // retch
197 var br = Object.create(null, { length: { value: 0 } });
198 try
199 {
200 br = bind.call(/a/g, /a/g, "aaaa");
201 }
202 catch (e) { /* nothing */ }
203 assertEq(br.length, 0);
204
205
206 /*
207 * 17. Set the attributes of the length own property of F to the values
208 * specified in 15.3.5.1.
209 */
210 var len1Desc =
211 Object.getOwnPropertyDescriptor(function(a, b, c){}.bind(), "length");
212 assertEq(len1Desc.value, 3);
213 assertEq(len1Desc.writable, false);
214 assertEq(len1Desc.enumerable, false);
215 assertEq(len1Desc.configurable, false);
216
217 var len2Desc =
218 Object.getOwnPropertyDescriptor(function(a, b, c){}.bind(null, 2), "length");
219 assertEq(len2Desc.value, 2);
220 assertEq(len2Desc.writable, false);
221 assertEq(len2Desc.enumerable, false);
222 assertEq(len2Desc.configurable, false);
223
224
225 /*
226 * 18. Set the [[Extensible]] internal property of F to true.
227 */
228 var bound = (function() { }).bind();
229
230 var isExtensible = Object.isExtensible || function() { return true; };
231 assertEq(isExtensible(bound), true);
232
233 bound.foo = 17;
234 var fooDesc = Object.getOwnPropertyDescriptor(bound, "foo");
235 assertEq(fooDesc.value, 17);
236 assertEq(fooDesc.writable, true);
237 assertEq(fooDesc.enumerable, true);
238 assertEq(fooDesc.configurable, true);
239
240
241 /*
242 * 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).
243 * 20. Call the [[DefineOwnProperty]] internal method of F with arguments
244 * "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]: thrower,
245 * [[Enumerable]]: false, [[Configurable]]: false}, and false.
246 * 21. Call the [[DefineOwnProperty]] internal method of F with arguments
247 * "arguments", PropertyDescriptor {[[Get]]: thrower, [[Set]]: thrower,
248 * [[Enumerable]]: false, [[Configurable]]: false}, and false.
249 */
250 function f() { "use strict"; }
251 var canonicalTTE = Object.getOwnPropertyDescriptor(f, "caller").get;
252
253 var tte;
254
255 var boundf = f.bind();
256
257 var boundfCaller = Object.getOwnPropertyDescriptor(boundf, "caller");
258 assertEq("get" in boundfCaller, true);
259 assertEq("set" in boundfCaller, true);
260 tte = boundfCaller.get;
261 assertEq(tte, canonicalTTE);
262 assertEq(tte, boundfCaller.set);
263
264 var boundfArguments = Object.getOwnPropertyDescriptor(boundf, "arguments");
265 assertEq("get" in boundfArguments, true);
266 assertEq("set" in boundfArguments, true);
267 tte = boundfArguments.get;
268 assertEq(tte, canonicalTTE);
269 assertEq(tte, boundfArguments.set);
270
271
272 /* 22. Return F. */
273 var passim = function p(){}.bind(1);
274 assertEq(typeof passim, "function");
275
276
277 /******************************************************************************/
278
279 if (typeof reportCompare === "function")
280 reportCompare(true, true);
281
282 print("All tests passed!");

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial