Growable typed data buffers.

pkg/collection_helpers/test/typed_buffers_test.dart

Index: pkg/collection_helpers/test/typed_buffers_test.dart
diff --git a/pkg/collection_helpers/test/typed_buffers_test.dart b/pkg/collection_helpers/test/typed_buffers_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..3e10facb506977f4d78477ad0eab50f7762fbb7d
--- /dev/null
+++ b/pkg/collection_helpers/test/typed_buffers_test.dart
@@ -0,0 +1,332 @@
+// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// Tests typed-data buffer classes.
+
+import "package:collection_helpers/all.dart";
+import "package:unittest/unittest.dart";
+import "dart:typed_data";
+
+main() {
+  testUint(8, (l) => new Uint8Buffer(l));
+  testInt(8, (l) => new Int8Buffer(l));
+  test("Uint8ClampedBuffer", () {
+    testIntBuffer(8, 0, 255, (l) => new Uint8ClampedBuffer(l), clampUint8);
+  });
+  testUint(16, (l) => new Uint16Buffer(l));
+  testInt(16, (l) => new Int16Buffer(l));
+  testUint(32, (l) => new Uint32Buffer(l));
+  testInt(32, (l) => new Int32Buffer(l));
+
+  List roundedFloatSamples = floatSamples.map(roundToFloat).toList();
+  testFloatBuffer(32, roundedFloatSamples,
+                  () => new Float32Buffer());
+  testFloatBuffer(64, doubleSamples, () => new Float64Buffer());
+
+  testFloat32x4Buffer(roundedFloatSamples);
+}
+
+double roundToFloat(double value) {
+  var list = new Float32List(1);
+  list[0] = value;
+  return list[0];
+}
+
+int roundUint(bits) {
+  int mask = (1 << bits) - 1;
+  return (x) => x & mask;
+}
+
+int roundInt(bits) {
+  int highBit = 1 << (bits - 1);
+  int mask = highBit - 1;
+  return (x) => (x & mask) - (x & highBit);
+}
+
+int clampUint8(x) => x < 0 ? 0 : x > 255 ? 255 : x;
+
+void testUint(int bits, var buffer) {
+  int min = 0;
+  int max = (1 << bits) - 1;
+  test("Uint${bits}Buffer", () {
+    testIntBuffer(bits, min, max, buffer, roundUint(bits));
+  });
+}
+
+void testInt(int bits, var buffer) {
+  int min = -1 << (bits - 1);
+  int max = -(min + 1);
+  test("Int${bits}Buffer", () {
+    testIntBuffer(bits, min, max, buffer, roundInt(bits));
+  });
+}
+
+const List<int> intSamples = const [
+  0x10000000000000001,
+  0x10000000000000000,  // 2^64
+  0x0ffffffffffffffff,
+  0xaaaaaaaaaaaaaaaa,
+  0x8000000000000001,
+  0x8000000000000000,   // 2^63
+  0x7fffffffffffffff,
+  0x5555555555555555,
+  0x100000001,
+  0x100000000,  // 2^32
+  0x0ffffffff,
+  0xaaaaaaaa,
+  0x80000001,
+  0x80000000,   // 2^31
+  0x7fffffff,
+  0x55555555,
+  0x10001,
+  0x10000,      // 2^16
+  0x0ffff,
+  0xaaaa,
+  0x8001,
+  0x8000,       // 2^15
+  0x7fff,
+  0x5555,
+  0x101,
+  0x100,        // 2^8
+  0x0ff,
+  0xaa,
+  0x81,
+  0x80,         // 2^7
+  0x7f,
+  0x55,
+  0x02,
+  0x01,
+  0x00
+];
+
+// Takes bit-size, min value, max value, function to create a buffer, and
+// the rounding that is applied when storing values outside the valid range
+// into the buffer.
+void testIntBuffer(int bits, int min, int max,
+                   create(int length),
+                   int round(int)) {
+  // All int buffers default to the value 0.
+  List buffer = create(0);
+  expect(buffer.length, equals(0));
+
+  TypedData td = buffer;  // It's both List and TypedData.
+  expect(td.elementSizeInBytes, equals(bits >> 3));

[floitsch, 2013/10/15 15:28:05]

~/ 8

create a "var bytes = bits ~/ 8" and use that instead of shifting in 3 places.

[Lasse Reichstein Nielsen, 2013/11/18 14:32:51]

Done.

+  expect(td.lengthInBytes, equals(0));
+  expect(td.offsetInBytes, equals(0));
+
+  buffer.add(min);
+  expect(buffer.length, equals(1));
+  expect(buffer[0], equals(min));
+
+  expect(td.elementSizeInBytes, equals(bits >> 3));
+  expect(td.lengthInBytes, equals(bits >> 3));
+  expect(td.offsetInBytes, equals(0));
+
+  buffer.length = 0;
+  expect(buffer.length, equals(0));
+
+  List samples = intSamples.toList()..addAll(intSamples.map((x) => -x));
+  for (int value in samples) {
+    int length = buffer.length;
+    buffer.add(value);
+    expect(buffer.length, equals(length + 1));
+    expect(buffer[length], equals(round(value)));
+  }
+  buffer.addAll(samples);  // Add all the values at once.
+  for (int i = 0; i < samples.length; i++) {
+    expect(buffer[samples.length + i], equals(buffer[i]));
+  }
+
+  // Remove range works and changes length.
+  buffer.removeRange(samples.length, buffer.length);
+  expect(buffer.length, equals(samples.length));
+
+  // Both values are in `samples`, but equality is performed without rounding.
+  expect(buffer.contains(min - 1), isFalse);
+  expect(buffer.contains(max + 1), isFalse);
+  expect(buffer.contains(round(min - 1)), isTrue);
+  expect(buffer.contains(round(max + 1)), isTrue);
+
+  // Accessing the underlying buffer works.
+  buffer.length = 2;
+  buffer[0] = min;
+  buffer[1] = max;
+  var bytes = new Uint8List.view(td.buffer);
+  int byteSize = td.elementSizeInBytes;
+  for (int i = 0; i < byteSize; i++) {
+    int tmp = bytes[i];
+    bytes[i] = bytes[byteSize + i];
+    bytes[byteSize + i] = tmp;
+  }
+  expect(buffer[0], equals(max));
+  expect(buffer[1], equals(min));
+}
+
+const List doubleSamples = const [
+  0.0,
+  5e-324,                    // Minimal denormal value.
+  2.225073858507201e-308,    // Maximal denormal value.
+  2.2250738585072014e-308,   // Minimal normal value.
+  0.9999999999999999,        // Maximum value < 1.
+  1.0,
+  1.0000000000000002,        // Minimum value > 1.
+  4294967295.0,              // 2^32 -1.
+  4294967296.0,              // 2^32.
+  4503599627370495.5,        // Maximal fractional value.
+  9007199254740992.0,        // Maximal exact value (adding one gets lost).
+  1.7976931348623157e+308,   // Maximal value.
+  1.0/0.0,                   // Infinity.
+  0.0/0.0,                   // NaN.
+  0.49999999999999994,       // Round-traps 1-3 (adding 0.5 and rounding towards
+  4503599627370497.0,        // minus infinity will not be the same as rounding
+  9007199254740991.0         // to nearest with 0.5 rounding up).
+];
+
+const List floatSamples = const [
+  0.0,
+  1.4e-45,          // Minimal denormal value.
+  1.1754942E-38,    // Maximal denormal value.
+  1.17549435E-38,   // Minimal normal value.
+  0.99999994,       // Maximal value < 1.
+  1.0,
+  1.0000001,        // Minimal value > 1.
+  8388607.5,        // Maximal fractional value.
+  16777216.0,       // Maximal exact value.
+  3.4028235e+38,    // Maximal value.
+  1.0/0.0,          // Infinity.
+  0.0/0.0,          // NaN.
+  0.99999994,       // Round traps 1-3.
+  8388609.0,
+  16777215.0
+];
+
+void doubleEqual(x, y) {
+  if (y.isNaN) {
+    expect(x.isNaN, isTrue);
+  } else {
+    expect(x, equals(y));
+  }
+}
+
+testFloatBuffer(int bitSize, List samples, create()) {
+  test("Float${bitSize}Buffer", () {
+    List<double> buffer = create();
+    TypedData td = buffer;
+    int byteSize = bitSize >> 3;
+
+    expect(buffer.length, equals(0));
+    buffer.add(0.0);
+    expect(buffer.length, equals(1));
+    expect(buffer.removeLast(), equals(0.0));
+    expect(buffer.length, equals(0));
+
+    for (double value in samples) {
+      buffer.add(value);
+      doubleEqual(buffer[buffer.length - 1], value);
+    }
+    expect(buffer.length, equals(samples.length));
+
+    buffer.addAll(samples);
+    expect(buffer.length, equals(samples.length * 2));
+    for (int i = 0; i < samples.length; i++) {
+      doubleEqual(buffer[i], buffer[samples.length + i]);
+    }
+
+    buffer.removeRange(samples.length, buffer.length);
+    expect(buffer.length, equals(samples.length));
+
+    buffer.insertAll(0, samples);
+    expect(buffer.length, equals(samples.length * 2));
+    for (int i = 0; i < samples.length; i++) {
+      doubleEqual(buffer[i], buffer[samples.length + i]);
+    }
+
+    buffer.length = samples.length;
+    expect(buffer.length, equals(samples.length));
+
+    // TypedData.
+    expect(td.elementSizeInBytes, equals(byteSize));
+    expect(td.lengthInBytes, equals(byteSize * buffer.length));
+    expect(td.offsetInBytes, equals(0));
+
+    // Accessing the buffer works.
+    // Accessing the underlying buffer works.
+    buffer.length = 2;
+    buffer[0] = samples[0];
+    buffer[1] = samples[1];
+    var bytes = new Uint8List.view(td.buffer);
+    for (int i = 0; i < byteSize; i++) {
+      int tmp = bytes[i];
+      bytes[i] = bytes[byteSize + i];
+      bytes[byteSize + i] = tmp;
+    }
+    expect(buffer[0], equals(samples[1]));
+    expect(buffer[1], equals(samples[0]));
+  });
+}
+
+testFloat32x4Buffer(List floatSamples) {
+  List float4Samples = [];
+  for (int i = 0; i < floatSamples.length - 3; i++) {
+    float4Samples.add(new Float32x4(floatSamples[i],
+                                    floatSamples[i + 1],
+                                    floatSamples[i + 2],
+                                    floatSamples[i + 3]));
+  }
+
+  void floatEquals(x, y) {
+    if (y.isNaN) {
+      expect(x.isNaN, isTrue);
+    } else {
+      expect(x, equals(y));
+    }
+  }
+
+  void x4Equals(Float32x4 x, Float32x4 y) {
+    floatEquals(x.x, y.x);
+    floatEquals(x.y, y.y);
+    floatEquals(x.z, y.z);
+    floatEquals(x.w, y.w);
+  }
+
+  test("Float32x4Buffer", () {
+    List buffer = new Float32x4Buffer(5);
+    TypedData td = buffer;
+    expect(buffer.length, equals(5));
+    expect(td.elementSizeInBytes, equals(128 >> 3));
+    expect(td.lengthInBytes, equals(5 * 128 >> 3));
+    expect(td.offsetInBytes, equals(0));
+
+    x4Equals(buffer[0], new Float32x4.zero());
+    buffer.length = 0;
+    expect(buffer.length, equals(0));
+
+    for (var sample in float4Samples) {
+      buffer.add(sample);
+      x4Equals(buffer[buffer.length - 1], sample);
+    }
+    expect(buffer.length, equals(float4Samples.length));
+
+    buffer.addAll(float4Samples);
+    expect(buffer.length, equals(float4Samples.length * 2));
+    for (int i = 0; i < float4Samples.length; i++) {
+      x4Equals(buffer[i], buffer[float4Samples.length + i]);
+    }
+
+    buffer.removeRange(4, 4 + float4Samples.length);
+    for (int i = 0; i < float4Samples.length; i++) {
+      x4Equals(buffer[i], float4Samples[i]);
+    }
+
+    // Test underlying buffer.
+    buffer.length = 1;
+    buffer[0] = float4Samples[0];  // Does not contain NaN.
+
+    Float32List floats = new Float32List.view(buffer.buffer);
+    expect(floats[0], equals(buffer[0].x));
+    expect(floats[1], equals(buffer[0].y));
+    expect(floats[2], equals(buffer[0].z));
+    expect(floats[3], equals(buffer[0].w));
+  });
+}