First steps towards implementing ArrayBuffer &co in V8

test/mjsunit/harmony/typedarrays.js

Index: test/mjsunit/harmony/typedarrays.js
diff --git a/test/mjsunit/harmony/typedarrays.js b/test/mjsunit/harmony/typedarrays.js
new file mode 100644
index 0000000000000000000000000000000000000000..31e1ef49118a820a3de11a162e59262d14ec6610
--- /dev/null
+++ b/test/mjsunit/harmony/typedarrays.js
@@ -0,0 +1,118 @@
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Flags: --harmony-typed-arrays
+
+function TestByteLength(param, expectedByteLength) {
+  var ab = new __ArrayBuffer(param);
+  assertSame(expectedByteLength, ab.byteLength);
+}
+
+function TestArrayBufferCreation() {
+  TestByteLength(1, 1);
+  TestByteLength(256, 256);
+  TestByteLength(-10, 0);
+  TestByteLength(2.567, 2);
+  TestByteLength(-2.567, 0);

[rossberg, 2013/03/27 17:33:14]

Can we afford to include a TestByteLength(l, l) with l > 2^32 ?

Also, TestByteLength(0, 0).

[Dmitry Lomov (no reviews), 2013/03/27 18:45:00]

Hmm, I changed what we throw from OutOfMemory (uncatchable) to a RangeError.
Spec does not say anything here, I'd perfer a RangeError I guess

[rossberg, 2013/03/28 09:45:15]

Sorry, I don't like it. RangeError is for domain violations as prescribed by the
spec, which this condition isn't. I think OOM is far more adequate.
You seem to have overlooked that part. ;)

+
+  TestByteLength("abc", 0);
+
+  var ab = new __ArrayBuffer();
+  assertSame(0, ab.byteLength);
+}
+
+TestArrayBufferCreation();
+
+function TestByteLengthNotWritable() {
+  var ab = new __ArrayBuffer(1024);
+  assertSame(1024, ab.byteLength);
+
+  assertThrows(function() { "use strict"; ab.byteLength = 42; }, TypeError);
+}
+
+TestByteLengthNotWritable();
+
+function CheckSlice(expectedResultLen, initialLen, start, end) {

[rossberg, 2013/03/27 17:33:14]

Nit: TestSlice, for consistency.

[Dmitry Lomov (no reviews), 2013/03/27 18:45:00]

Done.

+  var ab = new __ArrayBuffer(initialLen);
+  var slice = ab.slice(start, end);
+  assertSame(expectedResultLen, slice.byteLength);
+}
+
+function TestArrayBufferSlice() {
+  var ab = new __ArrayBuffer(1024);
+  var ab1 = ab.slice(512, 1024);
+  assertSame(512, ab1.byteLength);
+
+  CheckSlice(512, 1024, 512, 1024);
+  CheckSlice(512, 1024, 512);
+
+  CheckSlice(0, 0, 1, 20);
+  CheckSlice(100, 100, 0, 100);
+  CheckSlice(100, 100, 0, 1000);
+  CheckSlice(0, 100, 5, 1);
+
+  CheckSlice(1, 100, -11, -10);
+  CheckSlice(9, 100, -10, 99);
+  CheckSlice(0, 100, -10, 80);
+  CheckSlice(10, 100, 80, -10);
+
+  CheckSlice(10, 100, 90);
+  CheckSlice(10, 100, -10);
+}
+
+TestArrayBufferSlice();

[rossberg, 2013/03/27 17:33:14]

Maybe add a sanity check for calling slice with weird or missing arguments.

[Dmitry Lomov (no reviews), 2013/03/27 18:45:00]

Done.

[rossberg, 2013/03/28 09:45:15]

I especially thought of calls with arguments of bogus types, to test the
conversions.

+
+// Test property attribute [[Enumerable]]
+function TestEnumerable(func) {
+  function props(x) {
+    var array = [];
+    for (var p in x) array.push(p);
+    return array.sort();
+  }
+  assertArrayEquals([], props(func));
+  assertArrayEquals([], props(func.prototype));
+  assertArrayEquals([], props(new func()));
+}
+TestEnumerable(__ArrayBuffer);
+
+
+// Test arbitrary properties on ArrayBuffer
+function TestArbitrary(m) {
+  function TestProperty(map, property, value) {
+    map[property] = value;
+    assertEquals(value, map[property]);
+  }
+  for (var i = 0; i < 20; i++) {
+    TestProperty(m, i, 'val' + i);
+    TestProperty(m, 'foo' + i, 'bar' + i);
+  }
+}
+TestArbitrary(new __ArrayBuffer(256));
+
+
+// Test direct constructor call
+assertTrue(__ArrayBuffer() instanceof __ArrayBuffer);