valid-keys.js (14953B)
1 // Copyright (C) 2021 Rick Waldron. All rights reserved. 2 // This code is governed by the BSD license found in the LICENSE file. 3 /*--- 4 esid: sec-map.prototype.set 5 description: Observing the expected behavior of valid keys 6 info: | 7 Map.prototype.set ( key , value ) 8 9 ... 10 Let p be the Record {[[key]]: key, [[value]]: value}. 11 Append p as the last element of entries. 12 ... 13 14 features: [BigInt, Symbol, TypedArray, WeakRef, exponentiation] 15 ---*/ 16 17 18 const negativeZero = -0; 19 const positiveZero = +0; 20 const zero = 0; 21 const one = 1; 22 const twoRaisedToFiftyThreeMinusOne = 2 ** 53 - 1; 23 const int32Array = new Int32Array([zero, one]); 24 const uint32Array = new Uint32Array([zero, one]); 25 const n = 100000000000000000000000000000000000000000000000000000000000000000000000000000000001n; 26 const bigInt = BigInt('100000000000000000000000000000000000000000000000000000000000000000000000000000000001'); 27 const n1 = 1n; 28 const n53 = 9007199254740991n; 29 const fiftyThree = BigInt('9007199254740991'); 30 const bigInt64Array = new BigInt64Array([n1, n53]); 31 const bigUint64Array = new BigUint64Array([n1, n53]); 32 const symbol = Symbol(''); 33 const object = {}; 34 const array = []; 35 const string = ''; 36 const booleanTrue = true; 37 const booleanFalse = true; 38 const functionExprValue = function() {}; 39 const arrowFunctionValue = () => {}; 40 const classValue = class {}; 41 const map = new Map(); 42 const set = new Set(); 43 const weakMap = new WeakMap(); 44 const weakRef = new WeakRef({}); 45 const weakSet = new WeakSet(); 46 const nullValue = null; 47 const undefinedValue = undefined; 48 let unassigned; 49 50 { 51 const m = new Map([[negativeZero, negativeZero]]); 52 assert.sameValue(m.size, 1); 53 assert.sameValue(m.has(negativeZero), true); 54 assert.sameValue(m.get(negativeZero), negativeZero); 55 m.delete(negativeZero); 56 assert.sameValue(m.size, 0); 57 assert.sameValue(m.has(negativeZero), false); 58 m.set(negativeZero, negativeZero); 59 assert.sameValue(m.size, 1); 60 assert.sameValue(m.has(negativeZero), true); 61 assert.sameValue(m.get(negativeZero), negativeZero); 62 }; 63 64 { 65 const m = new Map([[positiveZero, positiveZero]]); 66 assert.sameValue(m.size, 1); 67 assert.sameValue(m.has(positiveZero), true); 68 assert.sameValue(m.get(positiveZero), positiveZero); 69 m.delete(positiveZero); 70 assert.sameValue(m.size, 0); 71 assert.sameValue(m.has(positiveZero), false); 72 m.set(positiveZero, positiveZero); 73 assert.sameValue(m.size, 1); 74 assert.sameValue(m.has(positiveZero), true); 75 assert.sameValue(m.get(positiveZero), positiveZero); 76 }; 77 78 { 79 const m = new Map([[zero, zero]]); 80 assert.sameValue(m.size, 1); 81 assert.sameValue(m.has(zero), true); 82 assert.sameValue(m.get(zero), zero); 83 m.delete(zero); 84 assert.sameValue(m.size, 0); 85 assert.sameValue(m.has(zero), false); 86 m.set(zero, zero); 87 assert.sameValue(m.size, 1); 88 assert.sameValue(m.has(zero), true); 89 assert.sameValue(m.get(zero), zero); 90 }; 91 92 { 93 const m = new Map([[one, one]]); 94 assert.sameValue(m.size, 1); 95 assert.sameValue(m.has(one), true); 96 assert.sameValue(m.get(one), one); 97 m.delete(one); 98 assert.sameValue(m.size, 0); 99 assert.sameValue(m.has(one), false); 100 m.set(one, one); 101 assert.sameValue(m.size, 1); 102 assert.sameValue(m.has(one), true); 103 assert.sameValue(m.get(one), one); 104 }; 105 106 { 107 const m = new Map([[twoRaisedToFiftyThreeMinusOne, twoRaisedToFiftyThreeMinusOne]]); 108 assert.sameValue(m.size, 1); 109 assert.sameValue(m.has(twoRaisedToFiftyThreeMinusOne), true); 110 assert.sameValue(m.get(twoRaisedToFiftyThreeMinusOne), twoRaisedToFiftyThreeMinusOne); 111 m.delete(twoRaisedToFiftyThreeMinusOne); 112 assert.sameValue(m.size, 0); 113 assert.sameValue(m.has(twoRaisedToFiftyThreeMinusOne), false); 114 m.set(twoRaisedToFiftyThreeMinusOne, twoRaisedToFiftyThreeMinusOne); 115 assert.sameValue(m.size, 1); 116 assert.sameValue(m.has(twoRaisedToFiftyThreeMinusOne), true); 117 assert.sameValue(m.get(twoRaisedToFiftyThreeMinusOne), twoRaisedToFiftyThreeMinusOne); 118 }; 119 120 { 121 const m = new Map([[int32Array, int32Array]]); 122 assert.sameValue(m.size, 1); 123 assert.sameValue(m.has(int32Array), true); 124 assert.sameValue(m.get(int32Array), int32Array); 125 m.delete(int32Array); 126 assert.sameValue(m.size, 0); 127 assert.sameValue(m.has(int32Array), false); 128 m.set(int32Array, int32Array); 129 assert.sameValue(m.size, 1); 130 assert.sameValue(m.has(int32Array), true); 131 assert.sameValue(m.get(int32Array), int32Array); 132 }; 133 134 { 135 const m = new Map([[uint32Array, uint32Array]]); 136 assert.sameValue(m.size, 1); 137 assert.sameValue(m.has(uint32Array), true); 138 assert.sameValue(m.get(uint32Array), uint32Array); 139 m.delete(uint32Array); 140 assert.sameValue(m.size, 0); 141 assert.sameValue(m.has(uint32Array), false); 142 m.set(uint32Array, uint32Array); 143 assert.sameValue(m.size, 1); 144 assert.sameValue(m.has(uint32Array), true); 145 assert.sameValue(m.get(uint32Array), uint32Array); 146 }; 147 148 { 149 const m = new Map([[n, n]]); 150 assert.sameValue(m.size, 1); 151 assert.sameValue(m.has(n), true); 152 assert.sameValue(m.get(n), n); 153 m.delete(n); 154 assert.sameValue(m.size, 0); 155 assert.sameValue(m.has(n), false); 156 m.set(n, n); 157 assert.sameValue(m.size, 1); 158 assert.sameValue(m.has(n), true); 159 assert.sameValue(m.get(n), n); 160 }; 161 162 { 163 const m = new Map([[bigInt, bigInt]]); 164 assert.sameValue(m.size, 1); 165 assert.sameValue(m.has(bigInt), true); 166 assert.sameValue(m.get(bigInt), bigInt); 167 m.delete(bigInt); 168 assert.sameValue(m.size, 0); 169 assert.sameValue(m.has(bigInt), false); 170 m.set(bigInt, bigInt); 171 assert.sameValue(m.size, 1); 172 assert.sameValue(m.has(bigInt), true); 173 assert.sameValue(m.get(bigInt), bigInt); 174 }; 175 176 { 177 const m = new Map([[n1, n1]]); 178 assert.sameValue(m.size, 1); 179 assert.sameValue(m.has(n1), true); 180 assert.sameValue(m.get(n1), n1); 181 m.delete(n1); 182 assert.sameValue(m.size, 0); 183 assert.sameValue(m.has(n1), false); 184 m.set(n1, n1); 185 assert.sameValue(m.size, 1); 186 assert.sameValue(m.has(n1), true); 187 assert.sameValue(m.get(n1), n1); 188 }; 189 190 { 191 const m = new Map([[n53, n53]]); 192 assert.sameValue(m.size, 1); 193 assert.sameValue(m.has(n53), true); 194 assert.sameValue(m.get(n53), n53); 195 m.delete(n53); 196 assert.sameValue(m.size, 0); 197 assert.sameValue(m.has(n53), false); 198 m.set(n53, n53); 199 assert.sameValue(m.size, 1); 200 assert.sameValue(m.has(n53), true); 201 assert.sameValue(m.get(n53), n53); 202 }; 203 204 { 205 const m = new Map([[fiftyThree, fiftyThree]]); 206 assert.sameValue(m.size, 1); 207 assert.sameValue(m.has(fiftyThree), true); 208 assert.sameValue(m.get(fiftyThree), fiftyThree); 209 m.delete(fiftyThree); 210 assert.sameValue(m.size, 0); 211 assert.sameValue(m.has(fiftyThree), false); 212 m.set(fiftyThree, fiftyThree); 213 assert.sameValue(m.size, 1); 214 assert.sameValue(m.has(fiftyThree), true); 215 assert.sameValue(m.get(fiftyThree), fiftyThree); 216 }; 217 218 { 219 const m = new Map([[bigInt64Array, bigInt64Array]]); 220 assert.sameValue(m.size, 1); 221 assert.sameValue(m.has(bigInt64Array), true); 222 assert.sameValue(m.get(bigInt64Array), bigInt64Array); 223 m.delete(bigInt64Array); 224 assert.sameValue(m.size, 0); 225 assert.sameValue(m.has(bigInt64Array), false); 226 m.set(bigInt64Array, bigInt64Array); 227 assert.sameValue(m.size, 1); 228 assert.sameValue(m.has(bigInt64Array), true); 229 assert.sameValue(m.get(bigInt64Array), bigInt64Array); 230 }; 231 232 { 233 const m = new Map([[bigUint64Array, bigUint64Array]]); 234 assert.sameValue(m.size, 1); 235 assert.sameValue(m.has(bigUint64Array), true); 236 assert.sameValue(m.get(bigUint64Array), bigUint64Array); 237 m.delete(bigUint64Array); 238 assert.sameValue(m.size, 0); 239 assert.sameValue(m.has(bigUint64Array), false); 240 m.set(bigUint64Array, bigUint64Array); 241 assert.sameValue(m.size, 1); 242 assert.sameValue(m.has(bigUint64Array), true); 243 assert.sameValue(m.get(bigUint64Array), bigUint64Array); 244 }; 245 246 { 247 const m = new Map([[symbol, symbol]]); 248 assert.sameValue(m.size, 1); 249 assert.sameValue(m.has(symbol), true); 250 assert.sameValue(m.get(symbol), symbol); 251 m.delete(symbol); 252 assert.sameValue(m.size, 0); 253 assert.sameValue(m.has(symbol), false); 254 m.set(symbol, symbol); 255 assert.sameValue(m.size, 1); 256 assert.sameValue(m.has(symbol), true); 257 assert.sameValue(m.get(symbol), symbol); 258 }; 259 260 { 261 const m = new Map([[object, object]]); 262 assert.sameValue(m.size, 1); 263 assert.sameValue(m.has(object), true); 264 assert.sameValue(m.get(object), object); 265 m.delete(object); 266 assert.sameValue(m.size, 0); 267 assert.sameValue(m.has(object), false); 268 m.set(object, object); 269 assert.sameValue(m.size, 1); 270 assert.sameValue(m.has(object), true); 271 assert.sameValue(m.get(object), object); 272 }; 273 274 { 275 const m = new Map([[array, array]]); 276 assert.sameValue(m.size, 1); 277 assert.sameValue(m.has(array), true); 278 assert.sameValue(m.get(array), array); 279 m.delete(array); 280 assert.sameValue(m.size, 0); 281 assert.sameValue(m.has(array), false); 282 m.set(array, array); 283 assert.sameValue(m.size, 1); 284 assert.sameValue(m.has(array), true); 285 assert.sameValue(m.get(array), array); 286 }; 287 288 { 289 const m = new Map([[string, string]]); 290 assert.sameValue(m.size, 1); 291 assert.sameValue(m.has(string), true); 292 assert.sameValue(m.get(string), string); 293 m.delete(string); 294 assert.sameValue(m.size, 0); 295 assert.sameValue(m.has(string), false); 296 m.set(string, string); 297 assert.sameValue(m.size, 1); 298 assert.sameValue(m.has(string), true); 299 assert.sameValue(m.get(string), string); 300 }; 301 302 { 303 const m = new Map([[booleanTrue, booleanTrue]]); 304 assert.sameValue(m.size, 1); 305 assert.sameValue(m.has(booleanTrue), true); 306 assert.sameValue(m.get(booleanTrue), booleanTrue); 307 m.delete(booleanTrue); 308 assert.sameValue(m.size, 0); 309 assert.sameValue(m.has(booleanTrue), false); 310 m.set(booleanTrue, booleanTrue); 311 assert.sameValue(m.size, 1); 312 assert.sameValue(m.has(booleanTrue), true); 313 assert.sameValue(m.get(booleanTrue), booleanTrue); 314 }; 315 316 { 317 const m = new Map([[booleanFalse, booleanFalse]]); 318 assert.sameValue(m.size, 1); 319 assert.sameValue(m.has(booleanFalse), true); 320 assert.sameValue(m.get(booleanFalse), booleanFalse); 321 m.delete(booleanFalse); 322 assert.sameValue(m.size, 0); 323 assert.sameValue(m.has(booleanFalse), false); 324 m.set(booleanFalse, booleanFalse); 325 assert.sameValue(m.size, 1); 326 assert.sameValue(m.has(booleanFalse), true); 327 assert.sameValue(m.get(booleanFalse), booleanFalse); 328 }; 329 330 { 331 const m = new Map([[functionExprValue, functionExprValue]]); 332 assert.sameValue(m.size, 1); 333 assert.sameValue(m.has(functionExprValue), true); 334 assert.sameValue(m.get(functionExprValue), functionExprValue); 335 m.delete(functionExprValue); 336 assert.sameValue(m.size, 0); 337 assert.sameValue(m.has(functionExprValue), false); 338 m.set(functionExprValue, functionExprValue); 339 assert.sameValue(m.size, 1); 340 assert.sameValue(m.has(functionExprValue), true); 341 assert.sameValue(m.get(functionExprValue), functionExprValue); 342 }; 343 344 { 345 const m = new Map([[arrowFunctionValue, arrowFunctionValue]]); 346 assert.sameValue(m.size, 1); 347 assert.sameValue(m.has(arrowFunctionValue), true); 348 assert.sameValue(m.get(arrowFunctionValue), arrowFunctionValue); 349 m.delete(arrowFunctionValue); 350 assert.sameValue(m.size, 0); 351 assert.sameValue(m.has(arrowFunctionValue), false); 352 m.set(arrowFunctionValue, arrowFunctionValue); 353 assert.sameValue(m.size, 1); 354 assert.sameValue(m.has(arrowFunctionValue), true); 355 assert.sameValue(m.get(arrowFunctionValue), arrowFunctionValue); 356 }; 357 358 { 359 const m = new Map([[classValue, classValue]]); 360 assert.sameValue(m.size, 1); 361 assert.sameValue(m.has(classValue), true); 362 assert.sameValue(m.get(classValue), classValue); 363 m.delete(classValue); 364 assert.sameValue(m.size, 0); 365 assert.sameValue(m.has(classValue), false); 366 m.set(classValue, classValue); 367 assert.sameValue(m.size, 1); 368 assert.sameValue(m.has(classValue), true); 369 assert.sameValue(m.get(classValue), classValue); 370 }; 371 372 { 373 const m = new Map([[map, map]]); 374 assert.sameValue(m.size, 1); 375 assert.sameValue(m.has(map), true); 376 assert.sameValue(m.get(map), map); 377 m.delete(map); 378 assert.sameValue(m.size, 0); 379 assert.sameValue(m.has(map), false); 380 m.set(map, map); 381 assert.sameValue(m.size, 1); 382 assert.sameValue(m.has(map), true); 383 assert.sameValue(m.get(map), map); 384 }; 385 386 { 387 const m = new Map([[set, set]]); 388 assert.sameValue(m.size, 1); 389 assert.sameValue(m.has(set), true); 390 assert.sameValue(m.get(set), set); 391 m.delete(set); 392 assert.sameValue(m.size, 0); 393 assert.sameValue(m.has(set), false); 394 m.set(set, set); 395 assert.sameValue(m.size, 1); 396 assert.sameValue(m.has(set), true); 397 assert.sameValue(m.get(set), set); 398 }; 399 400 { 401 const m = new Map([[weakMap, weakMap]]); 402 assert.sameValue(m.size, 1); 403 assert.sameValue(m.has(weakMap), true); 404 assert.sameValue(m.get(weakMap), weakMap); 405 m.delete(weakMap); 406 assert.sameValue(m.size, 0); 407 assert.sameValue(m.has(weakMap), false); 408 m.set(weakMap, weakMap); 409 assert.sameValue(m.size, 1); 410 assert.sameValue(m.has(weakMap), true); 411 assert.sameValue(m.get(weakMap), weakMap); 412 }; 413 414 { 415 const m = new Map([[weakRef, weakRef]]); 416 assert.sameValue(m.size, 1); 417 assert.sameValue(m.has(weakRef), true); 418 assert.sameValue(m.get(weakRef), weakRef); 419 m.delete(weakRef); 420 assert.sameValue(m.size, 0); 421 assert.sameValue(m.has(weakRef), false); 422 m.set(weakRef, weakRef); 423 assert.sameValue(m.size, 1); 424 assert.sameValue(m.has(weakRef), true); 425 assert.sameValue(m.get(weakRef), weakRef); 426 }; 427 428 { 429 const m = new Map([[weakSet, weakSet]]); 430 assert.sameValue(m.size, 1); 431 assert.sameValue(m.has(weakSet), true); 432 assert.sameValue(m.get(weakSet), weakSet); 433 m.delete(weakSet); 434 assert.sameValue(m.size, 0); 435 assert.sameValue(m.has(weakSet), false); 436 m.set(weakSet, weakSet); 437 assert.sameValue(m.size, 1); 438 assert.sameValue(m.has(weakSet), true); 439 assert.sameValue(m.get(weakSet), weakSet); 440 }; 441 442 { 443 const m = new Map([[nullValue, nullValue]]); 444 assert.sameValue(m.size, 1); 445 assert.sameValue(m.has(nullValue), true); 446 assert.sameValue(m.get(nullValue), nullValue); 447 m.delete(nullValue); 448 assert.sameValue(m.size, 0); 449 assert.sameValue(m.has(nullValue), false); 450 m.set(nullValue, nullValue); 451 assert.sameValue(m.size, 1); 452 assert.sameValue(m.has(nullValue), true); 453 assert.sameValue(m.get(nullValue), nullValue); 454 }; 455 456 { 457 const m = new Map([[undefinedValue, undefinedValue]]); 458 assert.sameValue(m.size, 1); 459 assert.sameValue(m.has(undefinedValue), true); 460 assert.sameValue(m.get(undefinedValue), undefinedValue); 461 m.delete(undefinedValue); 462 assert.sameValue(m.size, 0); 463 assert.sameValue(m.has(undefinedValue), false); 464 m.set(undefinedValue, undefinedValue); 465 assert.sameValue(m.size, 1); 466 assert.sameValue(m.has(undefinedValue), true); 467 assert.sameValue(m.get(undefinedValue), undefinedValue); 468 }; 469 470 { 471 const m = new Map([[unassigned, unassigned]]); 472 assert.sameValue(m.size, 1); 473 assert.sameValue(m.has(unassigned), true); 474 assert.sameValue(m.get(unassigned), unassigned); 475 m.delete(unassigned); 476 assert.sameValue(m.size, 0); 477 assert.sameValue(m.has(unassigned), false); 478 m.set(unassigned, unassigned); 479 assert.sameValue(m.size, 1); 480 assert.sameValue(m.has(unassigned), true); 481 assert.sameValue(m.get(unassigned), unassigned); 482 }; 483 484 485 reportCompare(0, 0);