Use the new test runner.

test/typed_buffers_test.dart

 // 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 "dart:typed_data";
+
+import "package:test/test.dart";
 import "package:typed_data/typed_buffers.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));  /// 01: ok
   testInt(32, (l) => new Int32Buffer(l));
-  testUint(64, (l) => new Uint64Buffer(l));  /// 01: continued
-  testInt(64, (l) => new Int64Buffer(l));    /// 01: continued
+  testUint(64, (l) => new Uint64Buffer(l),   /// 01: continued
+      // JS doesn't support 64-bit ints, so only test this on the VM.
+      testOn: "dart-vm");
+  testInt(64, (l) => new Int64Buffer(l),    /// 01: continued
+      // JS doesn't support 64-bit ints, so only test this on the VM.
+      testOn: "dart-vm");
 
   testInt32x4Buffer(intSamples);
 
   List roundedFloatSamples = floatSamples.map(roundToFloat).toList();
   testFloatBuffer(32, roundedFloatSamples,
                   () => new Float32Buffer(),
                   roundToFloat);
   testFloatBuffer(64, doubleSamples, () => new Float64Buffer(), (x) => x);
 
   testFloat32x4Buffer(roundedFloatSamples);
@@ skipping 12 matching lines @@
 }
 
 Rounder roundInt(bits) {
   int highBit = 1 << (bits - 1);
   int mask = highBit - 1;
   return (int x) => (x & mask) - (x & highBit);
 }
 
 int clampUint8(x) => x < 0 ? 0 : x > 255 ? 255 : x;
 
-void testUint(int bits, var buffer) {
+void testUint(int bits, var buffer, {String testOn}) {
   int min = 0;
   Function round = roundUint(bits);
   int max = round(-1);
   test("Uint${bits}Buffer", () {
     testIntBuffer(bits, min, max, buffer, round);
-  });
+  }, testOn: testOn);
 }
 
-void testInt(int bits, var buffer) {
+void testInt(int bits, var buffer, {String testOn}) {
   int min = -(1 << (bits - 1));
   int max = -(min + 1);
   test("Int${bits}Buffer", () {
     testIntBuffer(bits, min, max, buffer, roundInt(bits));
-  });
+  }, testOn: testOn);
 }
 
 const List<int> intSamples = const [
   0x10000000000000001,
   0x10000000000000000,  // 2^64
   0x0ffffffffffffffff,
   0xaaaaaaaaaaaaaaaa,
   0x8000000000000001,
   0x8000000000000000,   // 2^63
   0x7fffffffffffffff,
@@ skipping 332 matching lines @@
   bool matches(item, Map matchState) {
     if (item is! Int32x4) return false;
     Int32x4 value = item;
     return result.x == value.x && result.y == value.y &&
            result.z == value.z && result.w == value.w;
   }
 
   Description describe(Description description) =>
       description.add('Int32x4.==');
 }