-
-
Notifications
You must be signed in to change notification settings - Fork 1.6k
/
es.weak-map.js
171 lines (163 loc) · 6.98 KB
/
es.weak-map.js
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants';
import { createIterable, nativeSubclass } from '../helpers/helpers';
const Symbol = GLOBAL.Symbol || {};
const { freeze, keys, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
QUnit.test('WeakMap', assert => {
assert.isFunction(WeakMap);
assert.name(WeakMap, 'WeakMap');
assert.arity(WeakMap, 0);
assert.looksNative(WeakMap);
assert.true('delete' in WeakMap.prototype, 'delete in WeakMap.prototype');
assert.true('get' in WeakMap.prototype, 'get in WeakMap.prototype');
assert.true('has' in WeakMap.prototype, 'has in WeakMap.prototype');
assert.true('set' in WeakMap.prototype, 'set in WeakMap.prototype');
assert.true(new WeakMap() instanceof WeakMap, 'new WeakMap instanceof WeakMap');
let object = {};
assert.same(new WeakMap(createIterable([[object, 42]])).get(object), 42, 'Init from iterable');
let weakmap = new WeakMap();
const frozen = freeze({});
weakmap.set(frozen, 42);
assert.same(weakmap.get(frozen), 42, 'Support frozen objects');
weakmap = new WeakMap();
weakmap.set(frozen, 42);
assert.true(weakmap.has(frozen), 'works with frozen objects, #1');
assert.same(weakmap.get(frozen), 42, 'works with frozen objects, #2');
weakmap.delete(frozen);
assert.false(weakmap.has(frozen), 'works with frozen objects, #3');
assert.same(weakmap.get(frozen), undefined, 'works with frozen objects, #4');
let done = false;
try {
new WeakMap(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.true(done, '.return #throw');
assert.false(('clear' in WeakMap.prototype), 'should not contains `.clear` method');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return [][Symbol.iterator].call(this);
};
new WeakMap(array);
assert.true(done);
object = {};
new WeakMap().set(object, 1);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakMap);
assert.true(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.true(new Subclass() instanceof WeakMap, 'correct subclassing with native classes #2');
object = {};
assert.same(new Subclass().set(object, 2).get(object), 2, 'correct subclassing with native classes #3');
}
const buffer = new ArrayBuffer(8);
const map = new WeakMap([[buffer, 8]]);
assert.true(map.has(buffer), 'works with ArrayBuffer keys');
});
QUnit.test('WeakMap#delete', assert => {
assert.isFunction(WeakMap.prototype.delete);
if (NATIVE) assert.name(WeakMap.prototype.delete, 'delete');
if (NATIVE) assert.arity(WeakMap.prototype.delete, 1);
assert.looksNative(WeakMap.prototype.delete);
assert.nonEnumerable(WeakMap.prototype, 'delete');
const a = {};
const b = {};
const weakmap = new WeakMap();
weakmap.set(a, 42);
weakmap.set(b, 21);
assert.true(weakmap.has(a), 'WeakMap has values before .delete() #1');
assert.true(weakmap.has(b), 'WeakMap has values before .delete() #2');
weakmap.delete(a);
assert.false(weakmap.has(a), 'WeakMap has not value after .delete() #1');
assert.true(weakmap.has(b), 'WeakMap has not value after .delete() #2');
assert.notThrows(() => !weakmap.delete(1), 'return false on primitive');
const object = {};
weakmap.set(object, 42);
freeze(object);
assert.true(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.false(weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#get', assert => {
assert.isFunction(WeakMap.prototype.get);
assert.name(WeakMap.prototype.get, 'get');
if (NATIVE) assert.arity(WeakMap.prototype.get, 1);
assert.looksNative(WeakMap.prototype.get);
assert.nonEnumerable(WeakMap.prototype, 'get');
const weakmap = new WeakMap();
assert.same(weakmap.get({}), undefined, 'WeakMap .get() before .set() return undefined');
let object = {};
weakmap.set(object, 42);
assert.same(weakmap.get(object), 42, 'WeakMap .get() return value');
weakmap.delete(object);
assert.same(weakmap.get(object), undefined, 'WeakMap .get() after .delete() return undefined');
assert.notThrows(() => weakmap.get(1) === undefined, 'return undefined on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.same(weakmap.get(object), 42, 'works with frozen objects #1');
weakmap.delete(object);
assert.same(weakmap.get(object), undefined, 'works with frozen objects #2');
});
QUnit.test('WeakMap#has', assert => {
assert.isFunction(WeakMap.prototype.has);
assert.name(WeakMap.prototype.has, 'has');
if (NATIVE) assert.arity(WeakMap.prototype.has, 1);
assert.looksNative(WeakMap.prototype.has);
assert.nonEnumerable(WeakMap.prototype, 'has');
const weakmap = new WeakMap();
assert.false(weakmap.has({}), 'WeakMap .has() before .set() return false');
let object = {};
weakmap.set(object, 42);
assert.true(weakmap.has(object), 'WeakMap .has() return true');
weakmap.delete(object);
assert.false(weakmap.has(object), 'WeakMap .has() after .delete() return false');
assert.notThrows(() => !weakmap.has(1), 'return false on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.true(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.false(weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#set', assert => {
assert.isFunction(WeakMap.prototype.set);
assert.name(WeakMap.prototype.set, 'set');
assert.arity(WeakMap.prototype.set, 2);
assert.looksNative(WeakMap.prototype.set);
assert.nonEnumerable(WeakMap.prototype, 'set');
const weakmap = new WeakMap();
const object = {};
weakmap.set(object, 33);
assert.same(weakmap.get(object), 33, 'works with object as keys');
assert.same(weakmap.set({}, 42), weakmap, 'chaining');
assert.throws(() => new WeakMap().set(42, 42), 'throws with primitive keys');
const object1 = freeze({});
const object2 = {};
weakmap.set(object1, 42);
weakmap.set(object2, 42);
freeze(object);
assert.same(weakmap.get(object1), 42, 'works with frozen objects #1');
assert.same(weakmap.get(object2), 42, 'works with frozen objects #2');
weakmap.delete(object1);
weakmap.delete(object2);
assert.same(weakmap.get(object1), undefined, 'works with frozen objects #3');
assert.same(weakmap.get(object2), undefined, 'works with frozen objects #4');
});
QUnit.test('WeakMap#@@toStringTag', assert => {
assert.same(WeakMap.prototype[Symbol.toStringTag], 'WeakMap', 'WeakMap::@@toStringTag is `WeakMap`');
assert.same(String(new WeakMap()), '[object WeakMap]', 'correct stringification');
});