| OLD | NEW |
| (Empty) |
| 1 // Copyright 2011 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 | |
| 28 // Flags: --harmony-weakmaps --expose-gc | |
| 29 | |
| 30 | |
| 31 // Test valid getter and setter calls | |
| 32 var m = new WeakMap; | |
| 33 assertDoesNotThrow(function () { m.get(new Object) }); | |
| 34 assertDoesNotThrow(function () { m.set(new Object) }); | |
| 35 assertDoesNotThrow(function () { m.has(new Object) }); | |
| 36 assertDoesNotThrow(function () { m.delete(new Object) }); | |
| 37 | |
| 38 | |
| 39 // Test invalid getter and setter calls | |
| 40 var m = new WeakMap; | |
| 41 assertThrows(function () { m.get(undefined) }, TypeError); | |
| 42 assertThrows(function () { m.set(undefined, 0) }, TypeError); | |
| 43 assertThrows(function () { m.get(0) }, TypeError); | |
| 44 assertThrows(function () { m.set(0, 0) }, TypeError); | |
| 45 assertThrows(function () { m.get('a-key') }, TypeError); | |
| 46 assertThrows(function () { m.set('a-key', 0) }, TypeError); | |
| 47 | |
| 48 | |
| 49 // Test expected mapping behavior | |
| 50 var m = new WeakMap; | |
| 51 function TestMapping(map, key, value) { | |
| 52 map.set(key, value); | |
| 53 assertSame(value, map.get(key)); | |
| 54 } | |
| 55 TestMapping(m, new Object, 23); | |
| 56 TestMapping(m, new Object, 'the-value'); | |
| 57 TestMapping(m, new Object, new Object); | |
| 58 | |
| 59 | |
| 60 // Test expected querying behavior | |
| 61 var m = new WeakMap; | |
| 62 var key = new Object; | |
| 63 TestMapping(m, key, 'to-be-present'); | |
| 64 assertTrue(m.has(key)); | |
| 65 assertFalse(m.has(new Object)); | |
| 66 TestMapping(m, key, undefined); | |
| 67 assertFalse(m.has(key)); | |
| 68 assertFalse(m.has(new Object)); | |
| 69 | |
| 70 | |
| 71 // Test expected deletion behavior | |
| 72 var m = new WeakMap; | |
| 73 var key = new Object; | |
| 74 TestMapping(m, key, 'to-be-deleted'); | |
| 75 assertTrue(m.delete(key)); | |
| 76 assertFalse(m.delete(key)); | |
| 77 assertFalse(m.delete(new Object)); | |
| 78 assertSame(m.get(key), undefined); | |
| 79 | |
| 80 | |
| 81 // Test GC of map with entry | |
| 82 var m = new WeakMap; | |
| 83 var key = new Object; | |
| 84 m.set(key, 'not-collected'); | |
| 85 gc(); | |
| 86 assertSame('not-collected', m.get(key)); | |
| 87 | |
| 88 | |
| 89 // Test GC of map with chained entries | |
| 90 var m = new WeakMap; | |
| 91 var head = new Object; | |
| 92 for (key = head, i = 0; i < 10; i++, key = m.get(key)) { | |
| 93 m.set(key, new Object); | |
| 94 } | |
| 95 gc(); | |
| 96 var count = 0; | |
| 97 for (key = head; key != undefined; key = m.get(key)) { | |
| 98 count++; | |
| 99 } | |
| 100 assertEquals(11, count); | |
| 101 | |
| 102 | |
| 103 // Test property attribute [[Enumerable]] | |
| 104 var m = new WeakMap; | |
| 105 function props(x) { | |
| 106 var array = []; | |
| 107 for (var p in x) array.push(p); | |
| 108 return array.sort(); | |
| 109 } | |
| 110 assertArrayEquals([], props(WeakMap)); | |
| 111 assertArrayEquals([], props(WeakMap.prototype)); | |
| 112 assertArrayEquals([], props(m)); | |
| 113 | |
| 114 | |
| 115 // Test arbitrary properties on weak maps | |
| 116 var m = new WeakMap; | |
| 117 function TestProperty(map, property, value) { | |
| 118 map[property] = value; | |
| 119 assertEquals(value, map[property]); | |
| 120 } | |
| 121 for (i = 0; i < 20; i++) { | |
| 122 TestProperty(m, i, 'val' + i); | |
| 123 TestProperty(m, 'foo' + i, 'bar' + i); | |
| 124 } | |
| 125 TestMapping(m, new Object, 'foobar'); | |
| 126 | |
| 127 | |
| 128 // Test direct constructor call | |
| 129 var m = WeakMap(); | |
| 130 assertTrue(m instanceof WeakMap); | |
| 131 | |
| 132 | |
| 133 // Test some common JavaScript idioms | |
| 134 var m = new WeakMap; | |
| 135 assertTrue(m instanceof WeakMap); | |
| 136 assertTrue(WeakMap.prototype.set instanceof Function) | |
| 137 assertTrue(WeakMap.prototype.get instanceof Function) | |
| 138 assertTrue(WeakMap.prototype.has instanceof Function) | |
| 139 assertTrue(WeakMap.prototype.delete instanceof Function) | |
| 140 | |
| 141 | |
| 142 // Regression test for WeakMap prototype. | |
| 143 assertTrue(WeakMap.prototype.constructor === WeakMap) | |
| 144 assertTrue(Object.getPrototypeOf(WeakMap.prototype) === Object.prototype) | |
| 145 | |
| 146 | |
| 147 // Regression test for issue 1617: The prototype of the WeakMap constructor | |
| 148 // needs to be unique (i.e. different from the one of the Object constructor). | |
| 149 assertFalse(WeakMap.prototype === Object.prototype); | |
| 150 var o = Object.create({}); | |
| 151 assertFalse("get" in o); | |
| 152 assertFalse("set" in o); | |
| 153 assertEquals(undefined, o.get); | |
| 154 assertEquals(undefined, o.set); | |
| 155 var o = Object.create({}, { myValue: { | |
| 156 value: 10, | |
| 157 enumerable: false, | |
| 158 configurable: true, | |
| 159 writable: true | |
| 160 }}); | |
| 161 assertEquals(10, o.myValue); | |
| 162 | |
| 163 | |
| 164 // Stress Test | |
| 165 // There is a proposed stress-test available at the es-discuss mailing list | |
| 166 // which cannot be reasonably automated. Check it out by hand if you like: | |
| 167 // https://mail.mozilla.org/pipermail/es-discuss/2011-May/014096.html | |
| OLD | NEW |