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