OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 the V8 project authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 // Flags: --harmony-reflect |
| 6 |
| 7 |
| 8 (function testReflectApplyArity() { |
| 9 assertEquals(3, Reflect.apply.length); |
| 10 })(); |
| 11 |
| 12 |
| 13 (function testReflectApplyNonConstructor() { |
| 14 assertThrows(function() { |
| 15 new Reflect.apply(function(){}, null, []); |
| 16 }, TypeError); |
| 17 })(); |
| 18 |
| 19 |
| 20 (function testAppliedReceiverSloppy() { |
| 21 function returnThis() { return this; } |
| 22 var receiver = {}; |
| 23 |
| 24 assertSame(this, Reflect.apply(returnThis, void 0, [])); |
| 25 assertSame(this, Reflect.apply(returnThis, null, [])); |
| 26 assertSame(this, Reflect.apply(returnThis, this, [])); |
| 27 assertSame(receiver, Reflect.apply(returnThis, receiver, [])); |
| 28 |
| 29 // Wrap JS values |
| 30 assertSame(String.prototype, |
| 31 Object.getPrototypeOf(Reflect.apply(returnThis, "str", []))); |
| 32 assertSame(Number.prototype, |
| 33 Object.getPrototypeOf(Reflect.apply(returnThis, 123, []))); |
| 34 assertSame(Boolean.prototype, |
| 35 Object.getPrototypeOf(Reflect.apply(returnThis, true, []))); |
| 36 assertSame(Symbol.prototype, |
| 37 Object.getPrototypeOf( |
| 38 Reflect.apply(returnThis, Symbol("test"), []))); |
| 39 })(); |
| 40 |
| 41 |
| 42 (function testAppliedReceiverStrict() { |
| 43 function returnThis() { 'use strict'; return this; } |
| 44 var receiver = {}; |
| 45 |
| 46 assertSame(void 0, Reflect.apply(returnThis, void 0, [])); |
| 47 assertSame(this, Reflect.apply(returnThis, this, [])); |
| 48 assertSame(receiver, Reflect.apply(returnThis, receiver, [])); |
| 49 |
| 50 // Don't wrap value types |
| 51 var regexp = /123/; |
| 52 var symbol = Symbol("test"); |
| 53 assertSame("str", Reflect.apply(returnThis, "str", [])); |
| 54 assertSame(123, Reflect.apply(returnThis, 123, [])); |
| 55 assertSame(true, Reflect.apply(returnThis, true, [])); |
| 56 assertSame(regexp, Reflect.apply(returnThis, regexp, [])); |
| 57 assertSame(symbol, Reflect.apply(returnThis, symbol, [])); |
| 58 })(); |
| 59 |
| 60 |
| 61 (function testAppliedArgumentsLength() { |
| 62 function returnLengthStrict() { 'use strict'; return arguments.length; } |
| 63 function returnLengthSloppy() { return arguments.length; } |
| 64 |
| 65 assertEquals(0, Reflect.apply(returnLengthStrict, this, [])); |
| 66 assertEquals(0, Reflect.apply(returnLengthSloppy, this, [])); |
| 67 assertEquals(0, Reflect.apply(returnLengthStrict, this, {})); |
| 68 assertEquals(0, Reflect.apply(returnLengthSloppy, this, {})); |
| 69 |
| 70 for (var i = 0; i < 256; ++i) { |
| 71 assertEquals(i, Reflect.apply(returnLengthStrict, this, new Array(i))); |
| 72 assertEquals(i, Reflect.apply(returnLengthSloppy, this, new Array(i))); |
| 73 assertEquals(i, Reflect.apply(returnLengthStrict, this, { length: i })); |
| 74 assertEquals(i, Reflect.apply(returnLengthSloppy, this, { length: i })); |
| 75 } |
| 76 })(); |
| 77 |
| 78 |
| 79 (function testAppliedArgumentsLengthThrows() { |
| 80 function noopStrict() { 'use strict'; } |
| 81 function noopSloppy() { } |
| 82 function MyError() {} |
| 83 |
| 84 var argsList = {}; |
| 85 Object.defineProperty(argsList, "length", { |
| 86 get: function() { throw new MyError(); } |
| 87 }); |
| 88 |
| 89 assertThrows(function() { |
| 90 Reflect.apply(noopStrict, this, argsList); |
| 91 }, MyError); |
| 92 |
| 93 assertThrows(function() { |
| 94 Reflect.apply(noopSloppy, this, argsList); |
| 95 }, MyError); |
| 96 })(); |
| 97 |
| 98 |
| 99 (function testAppliedArgumentsElementThrows() { |
| 100 function noopStrict() { 'use strict'; } |
| 101 function noopSloppy() { } |
| 102 function MyError() {} |
| 103 |
| 104 var argsList = { length: 1 }; |
| 105 Object.defineProperty(argsList, "0", { |
| 106 get: function() { throw new MyError(); } |
| 107 }); |
| 108 |
| 109 assertThrows(function() { |
| 110 Reflect.apply(noopStrict, this, argsList); |
| 111 }, MyError); |
| 112 |
| 113 assertThrows(function() { |
| 114 Reflect.apply(noopSloppy, this, argsList); |
| 115 }, MyError); |
| 116 })(); |
| 117 |
| 118 |
| 119 (function testAppliedNonFunctionStrict() { |
| 120 'use strict'; |
| 121 assertThrows(function() { Reflect.apply(void 0); }, TypeError); |
| 122 assertThrows(function() { Reflect.apply(null); }, TypeError); |
| 123 assertThrows(function() { Reflect.apply(123); }, TypeError); |
| 124 assertThrows(function() { Reflect.apply("str"); }, TypeError); |
| 125 assertThrows(function() { Reflect.apply(Symbol("x")); }, TypeError); |
| 126 assertThrows(function() { Reflect.apply(/123/); }, TypeError); |
| 127 assertThrows(function() { Reflect.apply(NaN); }, TypeError); |
| 128 assertThrows(function() { Reflect.apply({}); }, TypeError); |
| 129 assertThrows(function() { Reflect.apply([]); }, TypeError); |
| 130 })(); |
| 131 |
| 132 |
| 133 (function testAppliedNonFunctionSloppy() { |
| 134 assertThrows(function() { Reflect.apply(void 0); }, TypeError); |
| 135 assertThrows(function() { Reflect.apply(null); }, TypeError); |
| 136 assertThrows(function() { Reflect.apply(123); }, TypeError); |
| 137 assertThrows(function() { Reflect.apply("str"); }, TypeError); |
| 138 assertThrows(function() { Reflect.apply(Symbol("x")); }, TypeError); |
| 139 assertThrows(function() { Reflect.apply(/123/); }, TypeError); |
| 140 assertThrows(function() { Reflect.apply(NaN); }, TypeError); |
| 141 assertThrows(function() { Reflect.apply({}); }, TypeError); |
| 142 assertThrows(function() { Reflect.apply([]); }, TypeError); |
| 143 })(); |
| 144 |
| 145 |
| 146 (function testAppliedArgumentsNonList() { |
| 147 function noopStrict() { 'use strict'; } |
| 148 function noopSloppy() {} |
| 149 var R = void 0; |
| 150 assertThrows(function() { Reflect.apply(noopStrict, R, null); }, TypeError); |
| 151 assertThrows(function() { Reflect.apply(noopSloppy, R, null); }, TypeError); |
| 152 assertThrows(function() { Reflect.apply(noopStrict, R, 1); }, TypeError); |
| 153 assertThrows(function() { Reflect.apply(noopSloppy, R, 1); }, TypeError); |
| 154 assertThrows(function() { Reflect.apply(noopStrict, R, "BAD"); }, TypeError); |
| 155 assertThrows(function() { Reflect.apply(noopSloppy, R, "BAD"); }, TypeError); |
| 156 assertThrows(function() { Reflect.apply(noopStrict, R, true); }, TypeError); |
| 157 assertThrows(function() { Reflect.apply(noopSloppy, R, true); }, TypeError); |
| 158 var sym = Symbol("x"); |
| 159 assertThrows(function() { Reflect.apply(noopStrict, R, sym); }, TypeError); |
| 160 assertThrows(function() { Reflect.apply(noopSloppy, R, sym); }, TypeError); |
| 161 })(); |
| 162 |
| 163 |
| 164 (function testAppliedArgumentValue() { |
| 165 function returnFirstStrict(a) { 'use strict'; return a; } |
| 166 function returnFirstSloppy(a) { return a; } |
| 167 function returnLastStrict(a) { |
| 168 'use strict'; return arguments[arguments.length - 1]; } |
| 169 function returnLastSloppy(a) { return arguments[arguments.length - 1]; } |
| 170 function returnSumStrict() { |
| 171 'use strict'; |
| 172 var sum = arguments[0]; |
| 173 for (var i = 1; i < arguments.length; ++i) { |
| 174 sum += arguments[i]; |
| 175 } |
| 176 return sum; |
| 177 } |
| 178 function returnSumSloppy() { |
| 179 var sum = arguments[0]; |
| 180 for (var i = 1; i < arguments.length; ++i) { |
| 181 sum += arguments[i]; |
| 182 } |
| 183 return sum; |
| 184 } |
| 185 |
| 186 assertEquals("OK!", Reflect.apply(returnFirstStrict, this, ["OK!"])); |
| 187 assertEquals("OK!", Reflect.apply(returnFirstSloppy, this, ["OK!"])); |
| 188 assertEquals("OK!", Reflect.apply(returnFirstStrict, this, |
| 189 { 0: "OK!", length: 1 })); |
| 190 assertEquals("OK!", Reflect.apply(returnFirstSloppy, this, |
| 191 { 0: "OK!", length: 1 })); |
| 192 assertEquals("OK!", Reflect.apply(returnLastStrict, this, |
| 193 [0, 1, 2, 3, 4, 5, 6, 7, 8, "OK!"])); |
| 194 assertEquals("OK!", Reflect.apply(returnLastSloppy, this, |
| 195 [0, 1, 2, 3, 4, 5, 6, 7, 8, "OK!"])); |
| 196 assertEquals("OK!", Reflect.apply(returnLastStrict, this, |
| 197 { 9: "OK!", length: 10 })); |
| 198 assertEquals("OK!", Reflect.apply(returnLastSloppy, this, |
| 199 { 9: "OK!", length: 10 })); |
| 200 assertEquals("TEST", Reflect.apply(returnSumStrict, this, |
| 201 ["T", "E", "S", "T"])); |
| 202 assertEquals("TEST!!", Reflect.apply(returnSumStrict, this, |
| 203 ["T", "E", "S", "T", "!", "!"])); |
| 204 assertEquals(10, Reflect.apply(returnSumStrict, this, |
| 205 { 0: 1, 1: 2, 2: 3, 3: 4, length: 4 })); |
| 206 assertEquals("TEST", Reflect.apply(returnSumSloppy, this, |
| 207 ["T", "E", "S", "T"])); |
| 208 assertEquals("TEST!!", Reflect.apply(returnSumSloppy, this, |
| 209 ["T", "E", "S", "T", "!", "!"])); |
| 210 assertEquals(10, Reflect.apply(returnSumSloppy, this, |
| 211 { 0: 1, 1: 2, 2: 3, 3: 4, length: 4 })); |
| 212 })(); |
OLD | NEW |