1 // Copyright 2015 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-sharedarraybuffer 29 30 31 // SharedArrayBuffer 32 33 function TestByteLength(param, expectedByteLength) { 34 var sab = new SharedArrayBuffer(param); 35 assertSame(expectedByteLength, sab.byteLength); 36 } 37 38 function TestArrayBufferCreation() { 39 TestByteLength(1, 1); 40 TestByteLength(256, 256); 41 TestByteLength(2.567, 2); 42 43 TestByteLength("abc", 0); 44 45 TestByteLength(0, 0); 46 47 assertThrows(function() { new SharedArrayBuffer(-10); }, RangeError); 48 assertThrows(function() { new SharedArrayBuffer(-2.567); }, RangeError); 49 50 /* TODO[dslomov]: Reenable the test 51 assertThrows(function() { 52 var ab1 = new SharedArrayBuffer(0xFFFFFFFFFFFF) 53 }, RangeError); 54 */ 55 56 var sab = new SharedArrayBuffer(); 57 assertSame(0, sab.byteLength); 58 assertEquals("[object SharedArrayBuffer]", 59 Object.prototype.toString.call(sab)); 60 } 61 62 TestArrayBufferCreation(); 63 64 function TestByteLengthNotWritable() { 65 var sab = new SharedArrayBuffer(1024); 66 assertSame(1024, sab.byteLength); 67 68 assertThrows(function() { "use strict"; sab.byteLength = 42; }, TypeError); 69 } 70 71 TestByteLengthNotWritable(); 72 73 function TestArrayBufferNoSlice() { 74 var sab = new SharedArrayBuffer(10); 75 assertEquals(undefined, sab.slice); 76 } 77 78 TestArrayBufferNoSlice(); 79 80 // Typed arrays using SharedArrayBuffers 81 82 // TODO(binji): how many of these tests are necessary if there are no new 83 // TypedArray types? 84 85 function MakeSharedTypedArray(constr, numElements) { 86 var sab = new SharedArrayBuffer(constr.BYTES_PER_ELEMENT * numElements); 87 return new constr(sab); 88 } 89 90 function TestTypedArray(constr, elementSize, typicalElement) { 91 assertSame(elementSize, constr.BYTES_PER_ELEMENT); 92 93 var sab = new SharedArrayBuffer(256*elementSize); 94 95 var a0 = new constr(30); 96 assertEquals("[object " + constr.name + "]", 97 Object.prototype.toString.call(a0)); 98 99 // TODO(binji): Should this return false here? It is a view, but it doesn't 100 // view a SharedArrayBuffer... 101 assertTrue(SharedArrayBuffer.isView(a0)); 102 assertSame(elementSize, a0.BYTES_PER_ELEMENT); 103 assertSame(30, a0.length); 104 assertSame(30*elementSize, a0.byteLength); 105 assertSame(0, a0.byteOffset); 106 assertSame(30*elementSize, a0.buffer.byteLength); 107 108 var aOverBufferLen0 = new constr(sab, 128*elementSize, 0); 109 assertSame(sab, aOverBufferLen0.buffer); 110 assertSame(elementSize, aOverBufferLen0.BYTES_PER_ELEMENT); 111 assertSame(0, aOverBufferLen0.length); 112 assertSame(0, aOverBufferLen0.byteLength); 113 assertSame(128*elementSize, aOverBufferLen0.byteOffset); 114 115 var a1 = new constr(sab, 128*elementSize, 128); 116 assertSame(sab, a1.buffer); 117 assertSame(elementSize, a1.BYTES_PER_ELEMENT); 118 assertSame(128, a1.length); 119 assertSame(128*elementSize, a1.byteLength); 120 assertSame(128*elementSize, a1.byteOffset); 121 122 123 var a2 = new constr(sab, 64*elementSize, 128); 124 assertSame(sab, a2.buffer); 125 assertSame(elementSize, a2.BYTES_PER_ELEMENT); 126 assertSame(128, a2.length); 127 assertSame(128*elementSize, a2.byteLength); 128 assertSame(64*elementSize, a2.byteOffset); 129 130 var a3 = new constr(sab, 192*elementSize); 131 assertSame(sab, a3.buffer); 132 assertSame(64, a3.length); 133 assertSame(64*elementSize, a3.byteLength); 134 assertSame(192*elementSize, a3.byteOffset); 135 136 var a4 = new constr(sab); 137 assertSame(sab, a4.buffer); 138 assertSame(256, a4.length); 139 assertSame(256*elementSize, a4.byteLength); 140 assertSame(0, a4.byteOffset); 141 142 143 var i; 144 for (i = 0; i < 128; i++) { 145 a1[i] = typicalElement; 146 } 147 148 for (i = 0; i < 128; i++) { 149 assertSame(typicalElement, a1[i]); 150 } 151 152 for (i = 0; i < 64; i++) { 153 assertSame(0, a2[i]); 154 } 155 156 for (i = 64; i < 128; i++) { 157 assertSame(typicalElement, a2[i]); 158 } 159 160 for (i = 0; i < 64; i++) { 161 assertSame(typicalElement, a3[i]); 162 } 163 164 for (i = 0; i < 128; i++) { 165 assertSame(0, a4[i]); 166 } 167 168 for (i = 128; i < 256; i++) { 169 assertSame(typicalElement, a4[i]); 170 } 171 172 var aAtTheEnd = new constr(sab, 256*elementSize); 173 assertSame(elementSize, aAtTheEnd.BYTES_PER_ELEMENT); 174 assertSame(0, aAtTheEnd.length); 175 assertSame(0, aAtTheEnd.byteLength); 176 assertSame(256*elementSize, aAtTheEnd.byteOffset); 177 178 assertThrows(function () { new constr(sab, 257*elementSize); }, RangeError); 179 assertThrows( 180 function () { new constr(sab, 128*elementSize, 192); }, 181 RangeError); 182 183 if (elementSize !== 1) { 184 assertThrows(function() { new constr(sab, 128*elementSize - 1, 10); }, 185 RangeError); 186 var unalignedArrayBuffer = new SharedArrayBuffer(10*elementSize + 1); 187 var goodArray = new constr(unalignedArrayBuffer, 0, 10); 188 assertSame(10, goodArray.length); 189 assertSame(10*elementSize, goodArray.byteLength); 190 assertThrows(function() { new constr(unalignedArrayBuffer)}, RangeError); 191 assertThrows(function() { new constr(unalignedArrayBuffer, 5*elementSize)}, 192 RangeError); 193 } 194 195 var abLen0 = new SharedArrayBuffer(0); 196 var aOverAbLen0 = new constr(abLen0); 197 assertSame(abLen0, aOverAbLen0.buffer); 198 assertSame(elementSize, aOverAbLen0.BYTES_PER_ELEMENT); 199 assertSame(0, aOverAbLen0.length); 200 assertSame(0, aOverAbLen0.byteLength); 201 assertSame(0, aOverAbLen0.byteOffset); 202 203 var a = new constr(sab, 64*elementSize, 128); 204 assertEquals("[object " + constr.name + "]", 205 Object.prototype.toString.call(a)); 206 var desc = Object.getOwnPropertyDescriptor( 207 constr.prototype.__proto__, Symbol.toStringTag); 208 assertTrue(desc.configurable); 209 assertFalse(desc.enumerable); 210 assertFalse(!!desc.writable); 211 assertFalse(!!desc.set); 212 assertEquals("function", typeof desc.get); 213 } 214 215 TestTypedArray(Uint8Array, 1, 0xFF); 216 TestTypedArray(Int8Array, 1, -0x7F); 217 TestTypedArray(Uint16Array, 2, 0xFFFF); 218 TestTypedArray(Int16Array, 2, -0x7FFF); 219 TestTypedArray(Uint32Array, 4, 0xFFFFFFFF); 220 TestTypedArray(Int32Array, 4, -0x7FFFFFFF); 221 TestTypedArray(Float32Array, 4, 0.5); 222 TestTypedArray(Float64Array, 8, 0.5); 223 TestTypedArray(Uint8ClampedArray, 1, 0xFF); 224 225 226 function SubarrayTestCase(constructor, item, expectedResultLen, 227 expectedStartIndex, initialLen, start, end) { 228 var a = MakeSharedTypedArray(constructor, initialLen); 229 var s = a.subarray(start, end); 230 assertSame(constructor, s.constructor); 231 assertSame(expectedResultLen, s.length); 232 if (s.length > 0) { 233 s[0] = item; 234 assertSame(item, a[expectedStartIndex]); 235 } 236 } 237 238 function TestSubArray(constructor, item) { 239 SubarrayTestCase(constructor, item, 512, 512, 1024, 512, 1024); 240 SubarrayTestCase(constructor, item, 512, 512, 1024, 512); 241 242 SubarrayTestCase(constructor, item, 0, undefined, 0, 1, 20); 243 SubarrayTestCase(constructor, item, 100, 0, 100, 0, 100); 244 SubarrayTestCase(constructor, item, 100, 0, 100, 0, 1000); 245 SubarrayTestCase(constructor, item, 0, undefined, 100, 5, 1); 246 247 SubarrayTestCase(constructor, item, 1, 89, 100, -11, -10); 248 SubarrayTestCase(constructor, item, 9, 90, 100, -10, 99); 249 SubarrayTestCase(constructor, item, 0, undefined, 100, -10, 80); 250 SubarrayTestCase(constructor, item, 10,80, 100, 80, -10); 251 252 SubarrayTestCase(constructor, item, 10,90, 100, 90, "100"); 253 SubarrayTestCase(constructor, item, 10,90, 100, "90", "100"); 254 255 SubarrayTestCase(constructor, item, 0, undefined, 100, 90, "abc"); 256 SubarrayTestCase(constructor, item, 10,0, 100, "abc", 10); 257 258 SubarrayTestCase(constructor, item, 10,0, 100, 0.96, 10.96); 259 SubarrayTestCase(constructor, item, 10,0, 100, 0.96, 10.01); 260 SubarrayTestCase(constructor, item, 10,0, 100, 0.01, 10.01); 261 SubarrayTestCase(constructor, item, 10,0, 100, 0.01, 10.96); 262 263 264 SubarrayTestCase(constructor, item, 10,90, 100, 90); 265 SubarrayTestCase(constructor, item, 10,90, 100, -10); 266 } 267 268 TestSubArray(Uint8Array, 0xFF); 269 TestSubArray(Int8Array, -0x7F); 270 TestSubArray(Uint16Array, 0xFFFF); 271 TestSubArray(Int16Array, -0x7FFF); 272 TestSubArray(Uint32Array, 0xFFFFFFFF); 273 TestSubArray(Int32Array, -0x7FFFFFFF); 274 TestSubArray(Float32Array, 0.5); 275 TestSubArray(Float64Array, 0.5); 276 TestSubArray(Uint8ClampedArray, 0xFF); 277 278 function TestTypedArrayOutOfRange(constructor, value, result) { 279 var a = MakeSharedTypedArray(constructor, 1); 280 a[0] = value; 281 assertSame(result, a[0]); 282 } 283 284 TestTypedArrayOutOfRange(Uint8Array, 0x1FA, 0xFA); 285 TestTypedArrayOutOfRange(Uint8Array, -1, 0xFF); 286 287 TestTypedArrayOutOfRange(Int8Array, 0x1FA, 0x7A - 0x80); 288 289 TestTypedArrayOutOfRange(Uint16Array, 0x1FFFA, 0xFFFA); 290 TestTypedArrayOutOfRange(Uint16Array, -1, 0xFFFF); 291 TestTypedArrayOutOfRange(Int16Array, 0x1FFFA, 0x7FFA - 0x8000); 292 293 TestTypedArrayOutOfRange(Uint32Array, 0x1FFFFFFFA, 0xFFFFFFFA); 294 TestTypedArrayOutOfRange(Uint32Array, -1, 0xFFFFFFFF); 295 TestTypedArrayOutOfRange(Int32Array, 0x1FFFFFFFA, 0x7FFFFFFA - 0x80000000); 296 297 TestTypedArrayOutOfRange(Uint8ClampedArray, 0x1FA, 0xFF); 298 TestTypedArrayOutOfRange(Uint8ClampedArray, -1, 0); 299 300 var typedArrayConstructors = [ 301 Uint8Array, 302 Int8Array, 303 Uint16Array, 304 Int16Array, 305 Uint32Array, 306 Int32Array, 307 Uint8ClampedArray, 308 Float32Array, 309 Float64Array]; 310 311 function TestPropertyTypeChecks(constructor) { 312 function CheckProperty(name) { 313 var d = Object.getOwnPropertyDescriptor(constructor.prototype.__proto__, 314 name); 315 var o = {}; 316 assertThrows(function() {d.get.call(o);}, TypeError); 317 for (var i = 0; i < typedArrayConstructors.length; i++) { 318 var ctor = typedArrayConstructors[i]; 319 var a = MakeSharedTypedArray(ctor, 10); 320 d.get.call(a); // shouldn't throw 321 } 322 } 323 324 CheckProperty("buffer"); 325 CheckProperty("byteOffset"); 326 CheckProperty("byteLength"); 327 CheckProperty("length"); 328 } 329 330 for(i = 0; i < typedArrayConstructors.length; i++) { 331 TestPropertyTypeChecks(typedArrayConstructors[i]); 332 } 333 334 function TestTypedArraySet() { 335 // Test array.set in different combinations. 336 337 function assertArrayPrefix(expected, array) { 338 for (var i = 0; i < expected.length; ++i) { 339 assertEquals(expected[i], array[i]); 340 } 341 } 342 343 // SharedTypedArrays don't allow initialization via array-like 344 function initializeFromArray(constructor, array) { 345 var buffer = MakeSharedTypedArray(constructor, array.length); 346 for (var i = 0; i < array.length; ++i) { 347 buffer[i] = array[i]; 348 } 349 return buffer; 350 } 351 352 var a11 = initializeFromArray(Int16Array, [1, 2, 3, 4, 0, -1]) 353 var a12 = MakeSharedTypedArray(Uint16Array, 15); 354 a12.set(a11, 3) 355 assertArrayPrefix([0, 0, 0, 1, 2, 3, 4, 0, 0xffff, 0, 0], a12) 356 assertThrows(function(){ a11.set(a12) }) 357 358 var a21 = [1, undefined, 10, NaN, 0, -1, {valueOf: function() {return 3}}] 359 var a22 = MakeSharedTypedArray(Int32Array, 12) 360 a22.set(a21, 2) 361 assertArrayPrefix([0, 0, 1, 0, 10, 0, 0, -1, 3, 0], a22) 362 363 var a31 = initializeFromArray(Float32Array, [2, 4, 6, 8, 11, NaN, 1/0, -3]) 364 var a32 = a31.subarray(2, 6) 365 a31.set(a32, 4) 366 assertArrayPrefix([2, 4, 6, 8, 6, 8, 11, NaN], a31) 367 assertArrayPrefix([6, 8, 6, 8], a32) 368 369 var a4 = initializeFromArray(Uint8ClampedArray, [3,2,5,6]) 370 a4.set(a4) 371 assertArrayPrefix([3, 2, 5, 6], a4) 372 373 // Cases with overlapping backing store but different element sizes. 374 var b = new SharedArrayBuffer(4) 375 var a5 = new Int16Array(b) 376 var a50 = new Int8Array(b) 377 var a51 = new Int8Array(b, 0, 2) 378 var a52 = new Int8Array(b, 1, 2) 379 var a53 = new Int8Array(b, 2, 2) 380 381 a5.set([0x5050, 0x0a0a]) 382 assertArrayPrefix([0x50, 0x50, 0x0a, 0x0a], a50) 383 assertArrayPrefix([0x50, 0x50], a51) 384 assertArrayPrefix([0x50, 0x0a], a52) 385 assertArrayPrefix([0x0a, 0x0a], a53) 386 387 a50.set([0x50, 0x50, 0x0a, 0x0a]) 388 a51.set(a5) 389 assertArrayPrefix([0x50, 0x0a, 0x0a, 0x0a], a50) 390 391 a50.set([0x50, 0x50, 0x0a, 0x0a]) 392 a52.set(a5) 393 assertArrayPrefix([0x50, 0x50, 0x0a, 0x0a], a50) 394 395 a50.set([0x50, 0x50, 0x0a, 0x0a]) 396 a53.set(a5) 397 assertArrayPrefix([0x50, 0x50, 0x50, 0x0a], a50) 398 399 a50.set([0x50, 0x51, 0x0a, 0x0b]) 400 a5.set(a51) 401 assertArrayPrefix([0x0050, 0x0051], a5) 402 403 a50.set([0x50, 0x51, 0x0a, 0x0b]) 404 a5.set(a52) 405 assertArrayPrefix([0x0051, 0x000a], a5) 406 407 a50.set([0x50, 0x51, 0x0a, 0x0b]) 408 a5.set(a53) 409 assertArrayPrefix([0x000a, 0x000b], a5) 410 411 // Mixed types of same size. 412 var a61 = initializeFromArray(Float32Array, [1.2, 12.3]) 413 var a62 = MakeSharedTypedArray(Int32Array, 2) 414 a62.set(a61) 415 assertArrayPrefix([1, 12], a62) 416 a61.set(a62) 417 assertArrayPrefix([1, 12], a61) 418 419 // Invalid source 420 var a = MakeSharedTypedArray(Uint16Array, 50); 421 var expected = []; 422 for (i = 0; i < 50; i++) { 423 a[i] = i; 424 expected.push(i); 425 } 426 a.set({}); 427 assertArrayPrefix(expected, a); 428 assertThrows(function() { a.set.call({}) }, TypeError); 429 assertThrows(function() { a.set.call([]) }, TypeError); 430 431 assertThrows(function() { a.set(0); }, TypeError); 432 assertThrows(function() { a.set(0, 1); }, TypeError); 433 } 434 435 TestTypedArraySet(); 436 437 function TestTypedArraysWithIllegalIndices() { 438 var a = MakeSharedTypedArray(Int32Array, 100); 439 440 a[-10] = 10; 441 assertEquals(undefined, a[-10]); 442 a["-10"] = 10; 443 assertEquals(undefined, a["-10"]); 444 445 var s = " -10"; 446 a[s] = 10; 447 assertEquals(10, a[s]); 448 var s1 = " -10 "; 449 a[s] = 10; 450 assertEquals(10, a[s]); 451 452 a["-1e2"] = 10; 453 assertEquals(10, a["-1e2"]); 454 assertEquals(undefined, a[-1e2]); 455 456 a["-0"] = 256; 457 var s2 = " -0"; 458 a[s2] = 255; 459 assertEquals(undefined, a["-0"]); 460 assertEquals(255, a[s2]); 461 assertEquals(0, a[-0]); 462 463 /* Chromium bug: 424619 464 * a[-Infinity] = 50; 465 * assertEquals(undefined, a[-Infinity]); 466 */ 467 a[1.5] = 10; 468 assertEquals(undefined, a[1.5]); 469 var nan = Math.sqrt(-1); 470 a[nan] = 5; 471 assertEquals(undefined, a[nan]); 472 473 var x = 0; 474 var y = -0; 475 assertEquals(Infinity, 1/x); 476 assertEquals(-Infinity, 1/y); 477 a[x] = 5; 478 a[y] = 27; 479 assertEquals(27, a[x]); 480 assertEquals(27, a[y]); 481 } 482 483 TestTypedArraysWithIllegalIndices(); 484 485 function TestTypedArraysWithIllegalIndicesStrict() { 486 'use strict'; 487 var a = MakeSharedTypedArray(Int32Array, 100); 488 489 a[-10] = 10; 490 assertEquals(undefined, a[-10]); 491 a["-10"] = 10; 492 assertEquals(undefined, a["-10"]); 493 494 var s = " -10"; 495 a[s] = 10; 496 assertEquals(10, a[s]); 497 var s1 = " -10 "; 498 a[s] = 10; 499 assertEquals(10, a[s]); 500 501 a["-1e2"] = 10; 502 assertEquals(10, a["-1e2"]); 503 assertEquals(undefined, a[-1e2]); 504 505 a["-0"] = 256; 506 var s2 = " -0"; 507 a[s2] = 255; 508 assertEquals(undefined, a["-0"]); 509 assertEquals(255, a[s2]); 510 assertEquals(0, a[-0]); 511 512 /* Chromium bug: 424619 513 * a[-Infinity] = 50; 514 * assertEquals(undefined, a[-Infinity]); 515 */ 516 a[1.5] = 10; 517 assertEquals(undefined, a[1.5]); 518 var nan = Math.sqrt(-1); 519 a[nan] = 5; 520 assertEquals(undefined, a[nan]); 521 522 var x = 0; 523 var y = -0; 524 assertEquals(Infinity, 1/x); 525 assertEquals(-Infinity, 1/y); 526 a[x] = 5; 527 a[y] = 27; 528 assertEquals(27, a[x]); 529 assertEquals(27, a[y]); 530 } 531 532 TestTypedArraysWithIllegalIndicesStrict(); 533 534 // General tests for properties 535 536 // Test property attribute [[Enumerable]] 537 function TestEnumerable(func, obj) { 538 function props(x) { 539 var array = []; 540 for (var p in x) array.push(p); 541 return array.sort(); 542 } 543 assertArrayEquals([], props(func)); 544 assertArrayEquals([], props(func.prototype)); 545 if (obj) 546 assertArrayEquals([], props(obj)); 547 } 548 TestEnumerable(ArrayBuffer, new SharedArrayBuffer()); 549 for(i = 0; i < typedArrayConstructors.length; i++) { 550 TestEnumerable(typedArrayConstructors[i]); 551 } 552 553 // Test arbitrary properties on ArrayBuffer 554 function TestArbitrary(m) { 555 function TestProperty(map, property, value) { 556 map[property] = value; 557 assertEquals(value, map[property]); 558 } 559 for (var i = 0; i < 20; i++) { 560 TestProperty(m, 'key' + i, 'val' + i); 561 TestProperty(m, 'foo' + i, 'bar' + i); 562 } 563 } 564 TestArbitrary(new SharedArrayBuffer(256)); 565 for(i = 0; i < typedArrayConstructors.length; i++) { 566 TestArbitrary(MakeSharedTypedArray(typedArrayConstructors[i], 10)); 567 } 568 569 // Test direct constructor call 570 assertThrows(function() { SharedArrayBuffer(); }, TypeError); 571 for(i = 0; i < typedArrayConstructors.length; i++) { 572 assertThrows(function(i) { typedArrayConstructors[i](); }.bind(this, i), 573 TypeError); 574 } 575
