Added some new tests for issue 6311

standalone/typed_array_test.dart

+import 'dart:isolate';
+import 'dart:scalarlist';
+
+void main() {
+  int8_receiver();
+  uint8_receiver();
+  int16_receiver();
+  uint16_receiver();
+  int32_receiver();
+  uint32_receiver();
+  int64_receiver();
+  uint64_receiver();
+  float32_receiver();
+  float64_receiver();
+}
+
+// Int8 array.
+const Int8List int8 = const [ 10, 100 ];
+
+void int8_receiver() {
+  var sp = spawnFunction(int8_sender);
+  sp.call(int8.length).then((a) {
+    Expect.equals(int8.length, a.length);
+    for (int i = 0; i < a.length; i++) {
+      Expect.equals(int8[i], a[i]);
+    }
+    print("int8_receiver");
+  });
+}
+
+int8_sender() {
+  port.receive((len, r) {
+    Expect.equals(int8.length, len);
+    var a = new Int8List(len);
+    for (int i = 0; i < len; i++) {
+      a[i] = int8[i];
+    }
+    r.send(a);
+  });
+}
+
+
+// Uint8 array.
+const Uint8List uint8 = const [ 0xff, 0x7f ];
+
+void uint8_receiver() {
+  var sp = spawnFunction(uint8_sender);
+  sp.call(uint8.length).then((a) {
+    Expect.equals(uint8.length, a.length);
+    for (int i = 0; i < a.length; i++) {
+      Expect.equals(uint8[i], a[i]);
+    }
+    print("uint8_receiver");
+  });
+}
+
+uint8_sender() {
+  port.receive((len, r) {
+    Expect.equals(uint8.length, len);
+    var a = new Uint8List(len);
+    for (int i = 0; i < len; i++) {
+      a[i] = uint8[i];
+    }
+    r.send(a);
+  });
+}
+
+
+// Int16 array.
+const Int16List int16 = const [ 1000, 10000 ];
+
+void int16_receiver() {
+  var sp = spawnFunction(int16_sender);
+  sp.call(int16.length).then((a) {
+    Expect.equals(int16.length, a.length);
+    for (int i = 0; i < a.length; i++) {
+      Expect.equals(int16[i], a[i]);
+    }
+    print("int16_receiver");
+  });
+}
+
+int16_sender() {
+  port.receive((len, r) {
+    Expect.equals(int16.length, len);
+    var a = new Int16List(len);
+    for (int i = 0; i < len; i++) {
+      a[i] = int16[i];
+    }
+    r.send(a);
+  });
+}
+
+
+// Uint16 array.
+const Uint16List uint16 = const [ 0xffff, 0x7fff ];
+
+void uint16_receiver() {
+  var sp = spawnFunction(uint16_sender);
+  sp.call(uint16.length).then((a) {
+    Expect.equals(uint16.length, a.length);
+    for (int i = 0; i < a.length; i++) {
+      Expect.equals(uint16[i], a[i]);
+    }
+    print("uint16_receiver");
+  });
+}
+
+uint16_sender() {
+  port.receive((len, r) {
+    Expect.equals(uint16.length, len);
+    var a = new Uint16List(len);
+    for (int i = 0; i < len; i++) {
+      a[i] = uint16[i];
+    }
+    r.send(a);
+  });
+}
+
+
+// Int32 array.
+const Int32List int32 = const [ 100000, 1000000 ];
+
+void int32_receiver() {
+  var sp = spawnFunction(int32_sender);
+  sp.call(int32.length).then((a) {
+    Expect.equals(int32.length, a.length);
+    for (int i = 0; i < a.length; i++) {
+      Expect.equals(int32[i], a[i]);
+    }
+    print("int32_receiver");
+  });
+}
+
+int32_sender() {
+  port.receive((len, r) {
+    Expect.equals(int32.length, len);
+    var a = new Int32List(len);
+    for (int i = 0; i < len; i++) {
+      a[i] = int32[i];
+    }
+    r.send(a);
+  });
+}
+
+
+// Uint32 array.
+const Uint32List uint32 = const [ 0xffffffff, 0x7fffffff ];
+
+void uint32_receiver() {
+  var sp = spawnFunction(uint32_sender);
+  sp.call(uint32.length).then((a) {
+    Expect.equals(uint32.length, a.length);
+    for (int i = 0; i < a.length; i++) {
+      Expect.equals(uint32[i], a[i]);
+    }
+    print("uint32_receiver");
+  });
+}
+
+uint32_sender() {
+  port.receive((len, r) {
+    Expect.equals(uint32.length, len);
+    var a = new Uint32List(len);
+    for (int i = 0; i < len; i++) {
+      a[i] = uint32[i];
+    }
+    r.send(a);
+  });
+}
+
+
+// Int64 array.
+const Int64List int64 = const [ 10000000, 100000000 ];
+
+void int64_receiver() {
+  var sp = spawnFunction(int64_sender);
+  sp.call(int64.length).then((a) {
+    Expect.equals(int64.length, a.length);
+    for (int i = 0; i < a.length; i++) {
+      Expect.equals(int64[i], a[i]);
+    }
+    print("int64_receiver");
+  });
+}
+
+int64_sender() {
+  port.receive((len, r) {
+    Expect.equals(int64.length, len);
+    var a = new Int64List(len);
+    for (int i = 0; i < len; i++) {
+      a[i] = int64[i];
+    }
+    r.send(a);
+  });
+}
+
+
+// Uint64 array.
+const Uint64List uint64 = const [ 0xffffffffffffffff, 0x7fffffffffffffff ];
+
+void uint64_receiver() {
+  var sp = spawnFunction(uint64_sender);
+  sp.call(uint64.length).then((a) {
+    Expect.equals(uint64.length, a.length);
+    for (int i = 0; i < a.length; i++) {
+      Expect.equals(uint64[i], a[i]);
+    }
+    print("uint64_receiver");
+  });
+}
+
+uint64_sender() {
+  port.receive((len, r) {
+    Expect.equals(uint64.length, len);
+    var a = new Uint64List(len);
+    for (int i = 0; i < len; i++) {
+      a[i] = uint64[i];
+    }
+    r.send(a);
+  });
+}
+
+
+// Float32 Array.
+const Float32List float32 = const [ 1.0, 2.0 ];
+
+void float32_receiver() {
+  var sp = spawnFunction(float32_sender);
+  sp.call(float32.length).then((a) {
+    Expect.equals(float32.length, a.length);
+    for (int i = 0; i < a.length; i++) {
+      Expect.equals(float32[i], a[i]);
+    }
+    print("float32_receiver");
+  });
+}
+
+float32_sender() {
+  port.receive((len, r) {
+    Expect.equals(float32.length, len);
+    var a = new Float32List(len);
+    for (int i = 0; i < len; i++) {
+      a[i] = float32[i];
+    }
+    r.send(a);
+  });
+}
+
+
+// Float64 Array.
+const Float64List float64 = const [ 101.234, 201.765 ];
+
+void float64_receiver() {
+  var sp = spawnFunction(float64_sender);
+  sp.call(float64.length).then((a) {
+    Expect.equals(float64.length, a.length);
+    for (int i = 0; i < a.length; i++) {
+      Expect.equals(float64[i], a[i]);
+    }
+    print("float64_receiver");
+  });
+}
+
+float64_sender() {
+  port.receive((len, r) {
+    Expect.equals(float64.length, len);
+    var a = new Float64List(len);
+    for (int i = 0; i < len; i++) {
+      a[i] = float64[i];
+    }
+    r.send(a);
+  });
+}