Ben Murdoch | 3bec4d2 | 2010-07-22 14:51:16 +0100 | [diff] [blame] | 1 | // Copyright 2010 the V8 project authors. All rights reserved. |
| 2 | // Redistribution and use in source and binary forms, with or without |
| 3 | // modification, are permitted provided that the following conditions are |
| 4 | // met: |
| 5 | // |
| 6 | // * Redistributions of source code must retain the above copyright |
| 7 | // notice, this list of conditions and the following disclaimer. |
| 8 | // * Redistributions in binary form must reproduce the above |
| 9 | // copyright notice, this list of conditions and the following |
| 10 | // disclaimer in the documentation and/or other materials provided |
| 11 | // with the distribution. |
| 12 | // * Neither the name of Google Inc. nor the names of its |
| 13 | // contributors may be used to endorse or promote products derived |
| 14 | // from this software without specific prior written permission. |
| 15 | // |
| 16 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 17 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 18 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 19 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 20 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 21 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 22 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 23 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 24 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 25 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 26 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 27 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 28 | // Tests the Object.freeze and Object.isFrozen methods - ES 19.1.2.5 and |
| 29 | // ES 19.1.2.12 |
Ben Murdoch | 3bec4d2 | 2010-07-22 14:51:16 +0100 | [diff] [blame] | 30 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 31 | // Flags: --allow-natives-syntax |
Ben Murdoch | 3bec4d2 | 2010-07-22 14:51:16 +0100 | [diff] [blame] | 32 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 33 | // Test that we return obj if non-object is passed as argument |
| 34 | var non_objects = new Array(undefined, null, 1, -1, 0, 42.43, Symbol("test")); |
Ben Murdoch | 3bec4d2 | 2010-07-22 14:51:16 +0100 | [diff] [blame] | 35 | for (var key in non_objects) { |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 36 | assertSame(non_objects[key], Object.freeze(non_objects[key])); |
Ben Murdoch | 3bec4d2 | 2010-07-22 14:51:16 +0100 | [diff] [blame] | 37 | } |
| 38 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 39 | // Test that isFrozen always returns true for non-objects |
Ben Murdoch | 3bec4d2 | 2010-07-22 14:51:16 +0100 | [diff] [blame] | 40 | for (var key in non_objects) { |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 41 | assertTrue(Object.isFrozen(non_objects[key])); |
Ben Murdoch | 3bec4d2 | 2010-07-22 14:51:16 +0100 | [diff] [blame] | 42 | } |
| 43 | |
| 44 | // Test normal data properties. |
| 45 | var obj = { x: 42, z: 'foobar' }; |
| 46 | var desc = Object.getOwnPropertyDescriptor(obj, 'x'); |
| 47 | assertTrue(desc.writable); |
| 48 | assertTrue(desc.configurable); |
| 49 | assertEquals(42, desc.value); |
| 50 | |
| 51 | desc = Object.getOwnPropertyDescriptor(obj, 'z'); |
| 52 | assertTrue(desc.writable); |
| 53 | assertTrue(desc.configurable); |
| 54 | assertEquals('foobar', desc.value); |
| 55 | |
| 56 | assertTrue(Object.isExtensible(obj)); |
| 57 | assertFalse(Object.isFrozen(obj)); |
| 58 | |
| 59 | Object.freeze(obj); |
| 60 | |
| 61 | // Make sure we are no longer extensible. |
| 62 | assertFalse(Object.isExtensible(obj)); |
| 63 | assertTrue(Object.isFrozen(obj)); |
| 64 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 65 | obj.foo = 42; |
| 66 | assertEquals(obj.foo, undefined); |
Ben Murdoch | 3bec4d2 | 2010-07-22 14:51:16 +0100 | [diff] [blame] | 67 | |
| 68 | desc = Object.getOwnPropertyDescriptor(obj, 'x'); |
| 69 | assertFalse(desc.writable); |
| 70 | assertFalse(desc.configurable); |
| 71 | assertEquals(42, desc.value); |
| 72 | |
| 73 | desc = Object.getOwnPropertyDescriptor(obj, 'z'); |
| 74 | assertFalse(desc.writable); |
| 75 | assertFalse(desc.configurable); |
| 76 | assertEquals("foobar", desc.value); |
| 77 | |
| 78 | // Make sure that even if we try overwrite a value that is not writable, it is |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 79 | // not changed. |
Ben Murdoch | 3bec4d2 | 2010-07-22 14:51:16 +0100 | [diff] [blame] | 80 | obj.x = "tete"; |
| 81 | assertEquals(42, obj.x); |
| 82 | obj.x = { get: function() {return 43}, set: function() {} }; |
| 83 | assertEquals(42, obj.x); |
| 84 | |
| 85 | // Test on accessors. |
| 86 | var obj2 = {}; |
| 87 | function get() { return 43; }; |
| 88 | function set() {}; |
| 89 | Object.defineProperty(obj2, 'x', { get: get, set: set, configurable: true }); |
| 90 | |
| 91 | desc = Object.getOwnPropertyDescriptor(obj2, 'x'); |
| 92 | assertTrue(desc.configurable); |
| 93 | assertEquals(undefined, desc.value); |
| 94 | assertEquals(set, desc.set); |
| 95 | assertEquals(get, desc.get); |
| 96 | |
| 97 | assertTrue(Object.isExtensible(obj2)); |
| 98 | assertFalse(Object.isFrozen(obj2)); |
| 99 | Object.freeze(obj2); |
| 100 | assertTrue(Object.isFrozen(obj2)); |
| 101 | assertFalse(Object.isExtensible(obj2)); |
| 102 | |
| 103 | desc = Object.getOwnPropertyDescriptor(obj2, 'x'); |
| 104 | assertFalse(desc.configurable); |
| 105 | assertEquals(undefined, desc.value); |
| 106 | assertEquals(set, desc.set); |
| 107 | assertEquals(get, desc.get); |
| 108 | |
Steve Block | 44f0eee | 2011-05-26 01:26:41 +0100 | [diff] [blame] | 109 | obj2.foo = 42; |
| 110 | assertEquals(obj2.foo, undefined); |
Ben Murdoch | 3bec4d2 | 2010-07-22 14:51:16 +0100 | [diff] [blame] | 111 | |
| 112 | |
| 113 | // Test freeze on arrays. |
| 114 | var arr = new Array(42,43); |
| 115 | |
| 116 | desc = Object.getOwnPropertyDescriptor(arr, '0'); |
| 117 | assertTrue(desc.configurable); |
| 118 | assertTrue(desc.writable); |
| 119 | assertEquals(42, desc.value); |
| 120 | |
| 121 | desc = Object.getOwnPropertyDescriptor(arr, '1'); |
| 122 | assertTrue(desc.configurable); |
| 123 | assertTrue(desc.writable); |
| 124 | assertEquals(43, desc.value); |
| 125 | |
| 126 | assertTrue(Object.isExtensible(arr)); |
| 127 | assertFalse(Object.isFrozen(arr)); |
| 128 | Object.freeze(arr); |
| 129 | assertTrue(Object.isFrozen(arr)); |
| 130 | assertFalse(Object.isExtensible(arr)); |
| 131 | |
| 132 | desc = Object.getOwnPropertyDescriptor(arr, '0'); |
| 133 | assertFalse(desc.configurable); |
| 134 | assertFalse(desc.writable); |
| 135 | assertEquals(42, desc.value); |
| 136 | |
| 137 | desc = Object.getOwnPropertyDescriptor(arr, '1'); |
| 138 | assertFalse(desc.configurable); |
| 139 | assertFalse(desc.writable); |
| 140 | assertEquals(43, desc.value); |
| 141 | |
| 142 | arr[0] = 'foo'; |
| 143 | |
| 144 | assertEquals(arr[0], 42); |
| 145 | |
| 146 | |
| 147 | // Test that isFrozen return the correct value even if configurable has been set |
| 148 | // to false on all properties manually and the extensible flag has also been set |
| 149 | // to false manually. |
| 150 | var obj3 = { x: 42, y: 'foo' }; |
| 151 | |
| 152 | assertFalse(Object.isFrozen(obj3)); |
| 153 | |
| 154 | Object.defineProperty(obj3, 'x', {configurable: false, writable: false}); |
| 155 | Object.defineProperty(obj3, 'y', {configurable: false, writable: false}); |
| 156 | Object.preventExtensions(obj3); |
| 157 | |
| 158 | assertTrue(Object.isFrozen(obj3)); |
| 159 | |
| 160 | |
| 161 | // Make sure that an object that has only non-configurable, but one |
| 162 | // writable property, is not classified as frozen. |
| 163 | var obj4 = {}; |
| 164 | Object.defineProperty(obj4, 'x', {configurable: false, writable: true}); |
| 165 | Object.defineProperty(obj4, 'y', {configurable: false, writable: false}); |
| 166 | Object.preventExtensions(obj4); |
| 167 | |
| 168 | assertFalse(Object.isFrozen(obj4)); |
| 169 | |
| 170 | // Make sure that an object that has only non-writable, but one |
| 171 | // configurable property, is not classified as frozen. |
| 172 | var obj5 = {}; |
| 173 | Object.defineProperty(obj5, 'x', {configurable: true, writable: false}); |
| 174 | Object.defineProperty(obj5, 'y', {configurable: false, writable: false}); |
| 175 | Object.preventExtensions(obj5); |
| 176 | |
| 177 | assertFalse(Object.isFrozen(obj5)); |
Ben Murdoch | bb769b2 | 2010-08-11 14:56:33 +0100 | [diff] [blame] | 178 | |
| 179 | // Make sure that Object.freeze returns the frozen object. |
| 180 | var obj6 = {} |
| 181 | assertTrue(obj6 === Object.freeze(obj6)) |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 182 | |
| 183 | // Test that the enumerable attribute is unperturbed by freezing. |
| 184 | obj = { x: 42, y: 'foo' }; |
| 185 | Object.defineProperty(obj, 'y', {enumerable: false}); |
| 186 | Object.freeze(obj); |
| 187 | assertTrue(Object.isFrozen(obj)); |
| 188 | desc = Object.getOwnPropertyDescriptor(obj, 'x'); |
| 189 | assertTrue(desc.enumerable); |
| 190 | desc = Object.getOwnPropertyDescriptor(obj, 'y'); |
| 191 | assertFalse(desc.enumerable); |
| 192 | |
| 193 | // Fast properties should remain fast |
| 194 | obj = { x: 42, y: 'foo' }; |
| 195 | assertTrue(%HasFastProperties(obj)); |
| 196 | Object.freeze(obj); |
| 197 | assertTrue(Object.isFrozen(obj)); |
| 198 | assertTrue(%HasFastProperties(obj)); |
| 199 | |
| 200 | // Frozen objects should share maps where possible |
| 201 | obj = { prop1: 1, prop2: 2 }; |
| 202 | obj2 = { prop1: 3, prop2: 4 }; |
| 203 | assertTrue(%HaveSameMap(obj, obj2)); |
| 204 | Object.freeze(obj); |
| 205 | Object.freeze(obj2); |
| 206 | assertTrue(Object.isFrozen(obj)); |
| 207 | assertTrue(Object.isFrozen(obj2)); |
| 208 | assertTrue(%HaveSameMap(obj, obj2)); |
| 209 | |
| 210 | // Frozen objects should share maps even when they have elements |
| 211 | obj = { prop1: 1, prop2: 2, 75: 'foo' }; |
| 212 | obj2 = { prop1: 3, prop2: 4, 150: 'bar' }; |
| 213 | assertTrue(%HaveSameMap(obj, obj2)); |
| 214 | Object.freeze(obj); |
| 215 | Object.freeze(obj2); |
| 216 | assertTrue(Object.isFrozen(obj)); |
| 217 | assertTrue(Object.isFrozen(obj2)); |
| 218 | assertTrue(%HaveSameMap(obj, obj2)); |
| 219 | |
| 220 | // Setting elements after freezing should not be allowed |
| 221 | obj = { prop: 'thing' }; |
| 222 | Object.freeze(obj); |
| 223 | assertTrue(Object.isFrozen(obj)); |
| 224 | obj[0] = 'hello'; |
| 225 | assertFalse(obj.hasOwnProperty(0)); |
| 226 | |
| 227 | // Freezing an object in dictionary mode should work |
| 228 | // Also testing that getter/setter properties work after freezing |
| 229 | obj = { }; |
| 230 | for (var i = 0; i < 100; ++i) { |
| 231 | obj['x' + i] = i; |
| 232 | } |
| 233 | var accessorDidRun = false; |
| 234 | Object.defineProperty(obj, 'accessor', { |
| 235 | get: function() { return 42 }, |
| 236 | set: function() { accessorDidRun = true }, |
| 237 | configurable: true, |
| 238 | enumerable: true |
| 239 | }); |
| 240 | |
| 241 | assertFalse(%HasFastProperties(obj)); |
| 242 | Object.freeze(obj); |
| 243 | assertFalse(%HasFastProperties(obj)); |
| 244 | assertTrue(Object.isFrozen(obj)); |
| 245 | assertFalse(Object.isExtensible(obj)); |
| 246 | for (var i = 0; i < 100; ++i) { |
| 247 | desc = Object.getOwnPropertyDescriptor(obj, 'x' + i); |
| 248 | assertFalse(desc.writable); |
| 249 | assertFalse(desc.configurable); |
| 250 | } |
| 251 | assertEquals(42, obj.accessor); |
| 252 | assertFalse(accessorDidRun); |
| 253 | obj.accessor = 'ignored value'; |
| 254 | assertTrue(accessorDidRun); |
| 255 | |
| 256 | // Freezing arguments should work |
| 257 | var func = function(arg) { |
| 258 | Object.freeze(arguments); |
| 259 | assertTrue(Object.isFrozen(arguments)); |
| 260 | }; |
| 261 | func('hello', 'world'); |
| 262 | func('goodbye', 'world'); |
| 263 | |
| 264 | // Freezing sparse arrays |
| 265 | var sparseArr = [0, 1]; |
| 266 | sparseArr[10000] = 10000; |
| 267 | Object.freeze(sparseArr); |
| 268 | assertTrue(Object.isFrozen(sparseArr)); |
| 269 | |
| 270 | // Accessors on fast object should behavior properly after freezing |
| 271 | obj = {}; |
| 272 | Object.defineProperty(obj, 'accessor', { |
| 273 | get: function() { return 42 }, |
| 274 | set: function() { accessorDidRun = true }, |
| 275 | configurable: true, |
| 276 | enumerable: true |
| 277 | }); |
| 278 | assertTrue(%HasFastProperties(obj)); |
| 279 | Object.freeze(obj); |
| 280 | assertTrue(Object.isFrozen(obj)); |
| 281 | assertTrue(%HasFastProperties(obj)); |
| 282 | assertEquals(42, obj.accessor); |
| 283 | accessorDidRun = false; |
| 284 | obj.accessor = 'ignored value'; |
| 285 | assertTrue(accessorDidRun); |
| 286 | |
| 287 | // Test for regression in mixed accessor/data property objects. |
| 288 | // The strict function is one such object. |
| 289 | assertTrue(Object.isFrozen(Object.freeze(function(){"use strict";}))); |
| 290 | |
| 291 | // Also test a simpler case |
| 292 | obj = {}; |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 293 | Object.defineProperty(obj, 'accessor2', { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 294 | get: function() { return 42 }, |
| 295 | set: function() { accessorDidRun = true }, |
| 296 | configurable: true, |
| 297 | enumerable: true |
| 298 | }); |
| 299 | obj.data = 'foo'; |
| 300 | assertTrue(%HasFastProperties(obj)); |
| 301 | Object.freeze(obj); |
| 302 | assertTrue(%HasFastProperties(obj)); |
| 303 | assertTrue(Object.isFrozen(obj)); |
| 304 | |
| 305 | // Test array built-in functions with freeze. |
| 306 | obj = [1,2,3]; |
| 307 | Object.freeze(obj); |
| 308 | // if frozen implies sealed, then the tests in object-seal.js are mostly |
| 309 | // sufficient. |
| 310 | assertTrue(Object.isSealed(obj)); |
| 311 | |
| 312 | // Verify that the length can't be written by builtins. |
| 313 | assertThrows(function() { obj.push(); }, TypeError); |
| 314 | assertThrows(function() { obj.unshift(); }, TypeError); |
| 315 | assertThrows(function() { obj.splice(0,0); }, TypeError); |
| 316 | assertTrue(Object.isFrozen(obj)); |
| 317 | |
| 318 | // Verify that an item can't be changed with splice. |
| 319 | assertThrows(function() { obj.splice(0,1,1); }, TypeError); |
| 320 | assertTrue(Object.isFrozen(obj)); |
| 321 | |
| 322 | // Verify that unshift() with no arguments will fail if it reifies from |
| 323 | // the prototype into the object. |
| 324 | obj = [1,,3]; |
| 325 | obj.__proto__[1] = 1; |
| 326 | assertEquals(1, obj[1]); |
| 327 | Object.freeze(obj); |
| 328 | assertThrows(function() { obj.unshift(); }, TypeError); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 329 | |
| 330 | // Sealing and then Freezing should do the right thing. |
| 331 | var obj = { foo: 'bar', 0: 'element' }; |
| 332 | Object.seal(obj); |
| 333 | assertTrue(Object.isSealed(obj)); |
| 334 | assertFalse(Object.isFrozen(obj)); |
| 335 | Object.freeze(obj); |
| 336 | assertTrue(Object.isSealed(obj)); |
| 337 | assertTrue(Object.isFrozen(obj)); |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 338 | |
| 339 | |
| 340 | (function propertiesOfFrozenObjectNotFrozen() { |
| 341 | function Frozen() {} |
| 342 | Object.freeze(Frozen); |
| 343 | assertDoesNotThrow(function() { return new Frozen(); }); |
| 344 | Frozen.prototype.prototypeExists = true; |
| 345 | assertTrue((new Frozen()).prototypeExists); |
| 346 | })(); |
| 347 | |
| 348 | |
| 349 | (function frozenPrototypePreventsPUT() { |
| 350 | // A read-only property on the prototype should prevent a [[Put]] . |
| 351 | function Constructor() {} |
| 352 | Constructor.prototype.foo = 1; |
| 353 | Object.freeze(Constructor.prototype); |
| 354 | var obj = new Constructor(); |
| 355 | obj.foo = 2; |
| 356 | assertSame(1, obj.foo); |
| 357 | })(); |
| 358 | |
| 359 | |
| 360 | (function frozenFunctionSloppy() { |
| 361 | // Check that freezing a function works correctly. |
| 362 | var func = Object.freeze(function foo(){}); |
| 363 | assertTrue(Object.isFrozen(func)); |
| 364 | func.prototype = 42; |
| 365 | assertFalse(func.prototype === 42); |
| 366 | assertFalse(Object.getOwnPropertyDescriptor(func, "prototype").writable); |
| 367 | })(); |
| 368 | |
| 369 | |
| 370 | (function frozenFunctionStrict() { |
| 371 | // Check that freezing a strict function works correctly. |
| 372 | var func = Object.freeze(function foo(){ "use strict"; }); |
| 373 | assertTrue(Object.isFrozen(func)); |
| 374 | func.prototype = 42; |
| 375 | assertFalse(func.prototype === 42); |
| 376 | assertFalse(Object.getOwnPropertyDescriptor(func, "prototype").writable); |
| 377 | })(); |
| 378 | |
| 379 | |
| 380 | (function frozenArrayObject() { |
| 381 | // Check that freezing array objects works correctly. |
| 382 | var array = Object.freeze([0,1,2]); |
| 383 | assertTrue(Object.isFrozen(array)); |
| 384 | array[0] = 3; |
| 385 | assertEquals(0, array[0]); |
| 386 | assertFalse(Object.getOwnPropertyDescriptor(array, "length").writable); |
| 387 | })(); |
| 388 | |
| 389 | |
| 390 | (function frozenArgumentsObject() { |
| 391 | // Check that freezing arguments objects works correctly. |
| 392 | var args = Object.freeze((function(){ return arguments; })(0,1,2)); |
| 393 | assertTrue(Object.isFrozen(args)); |
| 394 | args[0] = 3; |
| 395 | assertEquals(0, args[0]); |
| 396 | assertFalse(Object.getOwnPropertyDescriptor(args, "length").writable); |
| 397 | assertFalse(Object.getOwnPropertyDescriptor(args, "callee").writable); |
| 398 | })(); |