pkg/isolate: fix test library names and group tests

test/ports_test.dart

 // Copyright (c) 2015, 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.
 
-library dart.pkg.isolate.isolaterunner_test;
+library isolate.test.ports_test;
 
 import 'dart:async';
 import 'dart:isolate';
 
 import 'package:isolate/ports.dart';
 import 'package:unittest/unittest.dart';
 
 const Duration MS = const Duration(milliseconds: 1);
 
 main() {
-  testSingleCallbackPort();
-  testSingleCompletePort();
-  testSingleResponseFuture();
-  testSingleResultFuture();
-  testSingleResponseChannel();
+  group('SingleCallbackPort', testSingleCallbackPort);
+  group('SingleCompletePort', testSingleCompletePort);
+  group('SingleResponseFuture', testSingleResponseFuture);
+  group('SingleResponseFuture', testSingleResultFuture);
+  group('SingleResponseChannel', testSingleResponseChannel);
 }
 
 void testSingleCallbackPort() {
-  test("singleCallbackValue", () {
+  test("Value", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCallbackPort(completer.complete);
     p.send(42);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleCallbackFirstValue", () {
+  test("FirstValue", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCallbackPort(completer.complete);
     p.send(42);
     p.send(37);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
-  test("singleCallbackValue", () {
+  test("Value", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCallbackPort(completer.complete);
     p.send(42);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleCallbackValueBeforeTimeout", () {
+  test("ValueBeforeTimeout", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCallbackPort(completer.complete, timeout: MS * 500);
     p.send(42);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleCallbackTimeout", () {
+  test("Timeout", () {
     Completer completer = new Completer.sync();
     singleCallbackPort(completer.complete, timeout: MS * 100, timeoutValue: 37);
     return completer.future.then((v) {
       expect(v, 37);
     });
   });
 
-  test("singleCallbackTimeoutFirst", () {
+  test("TimeoutFirst", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCallbackPort(completer.complete,
                                     timeout: MS * 100,
                                     timeoutValue: 37);
     new Timer(MS * 500, () => p.send(42));
     return completer.future.then((v) {
       expect(v, 37);
     });
   });
 }
 
 
 void testSingleCompletePort() {
-  test("singleCompleteValue", () {
+  test("Value", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCompletePort(completer);
     p.send(42);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleCompleteValueCallback", () {
+  test("ValueCallback", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCompletePort(completer, callback: (v) {
       expect(42, v);
       return 87;
     });
     p.send(42);
     return completer.future.then((v) {
       expect(v, 87);
     });
   });
 
-  test("singleCompleteValueCallbackFuture", () {
+  test("ValueCallbackFuture", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCompletePort(completer, callback: (v) {
       expect(42, v);
       return new Future.delayed(MS * 500,
                                 () => 88);
     });
     p.send(42);
     return completer.future.then((v) {
       expect(v, 88);
     });
   });
 
-  test("singleCompleteValueCallbackThrows", () {
+  test("ValueCallbackThrows", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCompletePort(completer, callback: (v) {
       expect(42, v);
       throw 89;
     });
     p.send(42);
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e, 89);
     });
   });
 
-  test("singleCompleteValueCallbackThrowsFuture", () {
+  test("ValueCallbackThrowsFuture", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCompletePort(completer, callback: (v) {
       expect(42, v);
       return new Future.error(90);
     });
     p.send(42);
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e, 90);
     });
   });
 
-  test("singleCompleteFirstValue", () {
+  test("FirstValue", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCompletePort(completer);
     p.send(42);
     p.send(37);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleCompleteFirstValueCallback", () {
+  test("FirstValueCallback", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCompletePort(completer, callback: (v) {
        expect(v, 42);
        return 87;
      });
     p.send(42);
     p.send(37);
     return completer.future.then((v) {
       expect(v, 87);
     });
   });
 
-  test("singleCompleteValueBeforeTimeout", () {
+  test("ValueBeforeTimeout", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCompletePort(completer, timeout: MS * 500);
     p.send(42);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleCompleteTimeout", () {
+  test("Timeout", () {
     Completer completer = new Completer.sync();
     singleCompletePort(completer, timeout: MS * 100);
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e is TimeoutException, isTrue);
     });
   });
 
-  test("singleCompleteTimeoutCallback", () {
+  test("TimeoutCallback", () {
     Completer completer = new Completer.sync();
     singleCompletePort(completer, timeout: MS * 100, onTimeout: () => 87);
     return completer.future.then((v) {
       expect(v, 87);
     });
   });
 
-  test("singleCompleteTimeoutCallbackThrows", () {
+  test("TimeoutCallbackThrows", () {
     Completer completer = new Completer.sync();
     singleCompletePort(completer, timeout: MS * 100, onTimeout: () => throw 91);
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e, 91);
     });
   });
 
-  test("singleCompleteTimeoutCallbackFuture", () {
+  test("TimeoutCallbackFuture", () {
     Completer completer = new Completer.sync();
     singleCompletePort(completer,
                        timeout: MS * 100,
                        onTimeout: () => new Future.value(87));
     return completer.future.then((v) {
       expect(v, 87);
     });
   });
 
-  test("singleCompleteTimeoutCallbackThrowsFuture", () {
+  test("TimeoutCallbackThrowsFuture", () {
     Completer completer = new Completer.sync();
     singleCompletePort(completer,
                        timeout: MS * 100,
                        onTimeout: () => new Future.error(92));
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e, 92);
     });
   });
 
-  test("singleCompleteTimeoutCallbackSLow", () {
+  test("TimeoutCallbackSLow", () {
     Completer completer = new Completer.sync();
     singleCompletePort(
         completer,
         timeout: MS * 100,
         onTimeout: () => new Future.delayed(MS * 500, () => 87));
     return completer.future.then((v) {
       expect(v, 87);
     });
   });
 
-  test("singleCompleteTimeoutCallbackThrowsSlow", () {
+  test("TimeoutCallbackThrowsSlow", () {
     Completer completer = new Completer.sync();
     singleCompletePort(
         completer,
         timeout: MS * 100,
         onTimeout: () => new Future.delayed(MS * 500, () => throw 87));
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e, 87);
     });
   });
 
-  test("singleCompleteTimeoutFirst", () {
+  test("TimeoutFirst", () {
     Completer completer = new Completer.sync();
     SendPort p =
         singleCompletePort(completer, timeout: MS * 100, onTimeout: () => 37);
     new Timer(MS * 500, () => p.send(42));
     return completer.future.then((v) {
       expect(v, 37);
     });
   });
 }
 
 void testSingleResponseFuture() {
-  test("singleResponseFutureValue", () {
+  test("FutureValue", () {
     return singleResponseFuture((SendPort p) {
       p.send(42);
     }).then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleResponseFutureValueFirst", () {
+  test("FutureValueFirst", () {
     return singleResponseFuture((SendPort p) {
       p.send(42);
       p.send(37);
     }).then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleResponseFutureError", () {
+  test("FutureError", () {
     return singleResponseFuture((SendPort p) {
       throw 93;
     }).then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e, 93);
     });
   });
 
-  test("singleResponseFutureTimeout", () {
+  test("FutureTimeout", () {
     return singleResponseFuture((SendPort p) {
       // no-op.
     }, timeout: MS * 100).then((v) {
       expect(v, null);
     });
   });
 
-  test("singleResponseFutureTimeoutValue", () {
+  test("FutureTimeoutValue", () {
     return singleResponseFuture((SendPort p) {
       // no-op.
     }, timeout: MS * 100, timeoutValue: 42).then((v) {
       expect(v, 42);
     });
   });
 }
 
 void testSingleResultFuture() {
-  test("singleResultFutureValue", () {
+  test("Value", () {
     return singleResultFuture((SendPort p) {
       sendFutureResult(new Future.value(42), p);
     }).then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleResultFutureValueFirst", () {
+  test("ValueFirst", () {
     return singleResultFuture((SendPort p) {
       sendFutureResult(new Future.value(42), p);
       sendFutureResult(new Future.value(37), p);
     }).then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleResultFutureError", () {
+  test("Error", () {
     return singleResultFuture((SendPort p) {
       sendFutureResult(new Future.error(94), p);
     }).then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e is RemoteError, isTrue);
     });
   });
 
-  test("singleResultFutureErrorFirst", () {
+  test("ErrorFirst", () {
     return singleResultFuture((SendPort p) {
       sendFutureResult(new Future.error(95), p);
       sendFutureResult(new Future.error(96), p);
     }).then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e is RemoteError, isTrue);
     });
   });
 
-  test("singleResultFutureError", () {
+  test("Error", () {
     return singleResultFuture((SendPort p) {
       throw 93;
     }).then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e is RemoteError, isTrue);
     });
   });
 
-  test("singleResultFutureTimeout", () {
+  test("Timeout", () {
     return singleResultFuture((SendPort p) {
       // no-op.
     }, timeout: MS * 100).then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e is TimeoutException, isTrue);
     });
   });
 
-  test("singleResultFutureTimeoutValue", () {
+  test("TimeoutValue", () {
     return singleResultFuture((SendPort p) {
       // no-op.
     }, timeout: MS * 100, onTimeout: () => 42).then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleResultFutureTimeoutError", () {
+  test("TimeoutError", () {
     return singleResultFuture((SendPort p) {
       // no-op.
     }, timeout: MS * 100, onTimeout: () => throw 97).then((v) {
       expect(v, 42);
     }, onError: (e, s) {
       expect(e, 97);
     });
   });
 }
 
 void testSingleResponseChannel() {
-   test("singleResponseChannelValue", () {
+   test("Value", () {
     var channel = new SingleResponseChannel();
     channel.port.send(42);
     return channel.result.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleResponseChannelValueFirst", () {
+  test("ValueFirst", () {
     var channel = new SingleResponseChannel();
     channel.port.send(42);
     channel.port.send(37);
     return channel.result.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleResponseChannelValueCallback", () {
+  test("ValueCallback", () {
     var channel = new SingleResponseChannel(callback: (v) => v * 2);
     channel.port.send(42);
     return channel.result.then((v) {
       expect(v, 84);
     });
   });
 
-  test("singleResponseChannelErrorCallback", () {
+  test("ErrorCallback", () {
     var channel = new SingleResponseChannel(callback: (v) => throw 42);
     channel.port.send(37);
     return channel.result.then((v) { fail("unreachable"); },
                                onError: (v, s) {
                                  expect(v, 42);
                                });
   });
 
-  test("singleResponseChannelAsyncValueCallback", () {
+  test("AsyncValueCallback", () {
     var channel = new SingleResponseChannel(
                           callback: (v) => new Future.value(v * 2));
     channel.port.send(42);
     return channel.result.then((v) {
       expect(v, 84);
     });
   });
 
-  test("singleResponseChannelAsyncErrorCallback", () {
+  test("AsyncErrorCallback", () {
     var channel = new SingleResponseChannel(callback:
                                                 (v) => new Future.error(42));
     channel.port.send(37);
     return channel.result.then((v) { fail("unreachable"); },
                                onError: (v, s) {
                                  expect(v, 42);
                                });
   });
 
-  test("singleResponseChannelTimeout", () {
+  test("Timeout", () {
     var channel = new SingleResponseChannel(timeout: MS * 100);
     return channel.result.then((v) {
       expect(v, null);
     });
   });
 
-  test("singleResponseChannelTimeoutThrow", () {
+  test("TimeoutThrow", () {
     var channel = new SingleResponseChannel(timeout: MS * 100,
                                             throwOnTimeout: true);
     return channel.result.then((v) { fail("unreachable"); },
                                onError: (v, s) {
                                  expect(v is TimeoutException, isTrue);
                                });
   });
 
-  test("singleResponseChannelTimeoutThrowOnTimeoutAndValue", () {
+  test("TimeoutThrowOnTimeoutAndValue", () {
     var channel = new SingleResponseChannel(timeout: MS * 100,
                                             throwOnTimeout: true,
                                             onTimeout: () => 42,
                                             timeoutValue: 42);
     return channel.result.then((v) { fail("unreachable"); },
                                onError: (v, s) {
                                  expect(v is TimeoutException, isTrue);
                                });
   });
 
-  test("singleResponseChannelTimeoutOnTimeout", () {
+  test("TimeoutOnTimeout", () {
     var channel = new SingleResponseChannel(timeout: MS * 100,
                                             onTimeout: () => 42);
     return channel.result.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleResponseChannelTimeoutOnTimeoutAndValue", () {
+  test("TimeoutOnTimeoutAndValue", () {
     var channel = new SingleResponseChannel(timeout: MS * 100,
                                             onTimeout: () => 42,
                                             timeoutValue: 37);
     return channel.result.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleResponseChannelTimeoutValue", () {
+  test("TimeoutValue", () {
     var channel = new SingleResponseChannel(timeout: MS * 100,
                                             timeoutValue: 42);
     return channel.result.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleResponseChannelTimeoutOnTimeoutError", () {
+  test("TimeoutOnTimeoutError", () {
     var channel = new SingleResponseChannel(timeout: MS * 100,
                                             onTimeout: () => throw 42);
     return channel.result.then((v) { fail("unreachable"); },
                                onError: (v, s) {
                                  expect(v, 42);
                                });
   });
 
-  test("singleResponseChannelTimeoutOnTimeoutAsync", () {
+  test("TimeoutOnTimeoutAsync", () {
     var channel = new SingleResponseChannel(timeout: MS * 100,
                                             onTimeout:
                                                 () => new Future.value(42));
     return channel.result.then((v) {
       expect(v, 42);
     });
   });
 
-  test("singleResponseChannelTimeoutOnTimeoutAsyncError", () {
+  test("TimeoutOnTimeoutAsyncError", () {
     var channel = new SingleResponseChannel(timeout: MS * 100,
                                             onTimeout:
                                                 () => new Future.error(42));
     return channel.result.then((v) { fail("unreachable"); },
                                onError: (v, s) {
                                  expect(v, 42);
                                });
   });
 }