Make package:scheduled_test throw ScheduledServerErrors, not strings.

pkg/scheduled_test/test/scheduled_server_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.
 
 library scheduled_server_test;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:http/http.dart' as http;
@@ skipping 19 matching lines @@
         errors = currentSchedule.errors;
       });
 
       var server = new ScheduledServer();
       expect(server.url.then((url) => http.read(url.resolve('/hello'))),
           completion(equals('Hello, test!')));
     });
 
     test('test 2', () {
       expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      // TODO(nweiz): There can be three errors due to issue 9151. The
-      // HttpException is reported without a stack trace, and so when it's
-      // wrapped twice it registers as a different exception each time (because
-      // it's given an ad-hoc stack trace). Always expect two exceptions when
-      // issue 9151 is fixed.
-      expect(errors.length, inInclusiveRange(2, 3));
-      expect(errors[0].error, equals("'scheduled server 0' received GET /hello "
-          "when no more requests were expected."));
+      expect(errors.length, 2);
+      expect(errors[0].error, new isInstanceOf<ScheduledServerError>());
+      expect(errors[0].error.message, equals("'scheduled server 0' received "
+          "GET /hello when no more requests were expected."));
       expect(errors[1].error, new isInstanceOf<HttpException>());
-      if (errors.length > 2) {
-        expect(errors[2].error, new isInstanceOf<HttpException>());
-      }
     });
   }, passing: ['test 2']);
 
   expectTestsPass("a handler runs when it's hit", () {
     test('test', () {
       var server = new ScheduledServer();
       expect(server.url.then((url) => http.read(url.resolve('/hello'))),
           completion(equals('Hello, test!')));
 
       server.handle('GET', '/hello', (request) {
@@ skipping 46 matching lines @@
       });
     });
 
     test('test 2', () {
       // TODO(nweiz): There can be three errors due to issue 9151. The
       // HttpException is reported without a stack trace, and so when it's
       // wrapped twice it registers as a different exception each time (because
       // it's given an ad-hoc stack trace). Always expect two exceptions when
       // issue 9151 is fixed.
       expect(errors.length, inInclusiveRange(2, 3));
-      expect(errors[0].error, equals("'scheduled server 0' received GET /hello "
-          "earlier than expected."));
+      expect(errors[0].error, new isInstanceOf<ScheduledServerError>());
+      expect(errors[0].error.message, equals(
+          "'scheduled server 0' received GET /hello earlier than expected."));
       expect(errors[1].error, new isInstanceOf<HttpException>());
       if (errors.length > 2) {
         expect(errors[2].error, new isInstanceOf<HttpException>());
       }
       expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
     });
   }, passing: ['test 2']);
 
   expectTestsPass("a handler waits for the immediately prior task to complete "
       "before checking if it's too early", () {
@@ skipping 28 matching lines @@
       expect(server.url.then((url) => http.read(url.resolve('/hello'))),
           completion(equals('Hello, test!')));
 
       server.handle('GET', '/goodbye', (request) {
         request.response.write('Goodbye, test!');
         request.response.close();
       });
     });
 
     test('test 2', () {
-      // TODO(nweiz): There can be three errors due to issue 9151. The
-      // HttpException is reported without a stack trace, and so when it's
-      // wrapped twice it registers as a different exception each time (because
-      // it's given an ad-hoc stack trace). Always expect two exceptions when
-      // issue 9151 is fixed.
-      expect(errors.length, inInclusiveRange(2, 3));
-      expect(errors[0].error, equals("'scheduled server 0' expected GET "
-          "/goodbye, but got GET /hello."));
+      expect(errors.length, 2);
+      expect(errors[0].error, new isInstanceOf<ScheduledServerError>());
+      expect(errors[0].error.message, equals(
+          "'scheduled server 0' expected GET /goodbye, but got GET /hello."));
       expect(errors[1].error, new isInstanceOf<HttpException>());
-      if (errors.length > 2) {
-        expect(errors[2].error, new isInstanceOf<HttpException>());
-      }
     });
   }, passing: ['test 2']);
 
   expectTestsPass("a handler fails if the method is wrong", () {
     var errors;
     test('test 1', () {
       currentSchedule.onException.schedule(() {
         errors = currentSchedule.errors;
       });
 
       var server = new ScheduledServer();
       expect(server.url.then((url) => http.head(url.resolve('/hello'))),
           completes);
 
       server.handle('GET', '/hello', (request) {
         request.response.write('Hello, test!');
         request.response.close();
       });
     });
 
     test('test 2', () {
-      // TODO(nweiz): There can be three errors due to issue 9151. The
-      // HttpException is reported without a stack trace, and so when it's
-      // wrapped twice it registers as a different exception each time (because
-      // it's given an ad-hoc stack trace). Always expect two exceptions when
-      // issue 9151 is fixed.
-      expect(errors.length, inInclusiveRange(2, 3));
-      expect(errors[0].error, equals("'scheduled server 0' expected GET "
-          "/hello, but got HEAD /hello."));
+      expect(errors.length, 2);
+      expect(errors[0].error, new isInstanceOf<ScheduledServerError>());
+      expect(errors[0].error.message, equals(
+          "'scheduled server 0' expected GET /hello, but got HEAD /hello."));
       expect(errors[1].error, new isInstanceOf<HttpException>());
-      if (errors.length > 2) {
-        expect(errors[2].error, new isInstanceOf<HttpException>());
-      }
     });
   }, passing: ['test 2']);
 
   expectTestsPass("a handler times out waiting to be hit", () {
     var clock = mock_clock.mock()..run();
     var timeOfException;
     var errors;
     test('test 1', () {
       currentSchedule.timeout = new Duration(milliseconds: 2);
       currentSchedule.onException.schedule(() {
@@ skipping 73 matching lines @@
         request.response.close();
       });
 
       server.handle('GET', '/hello/2', (request) {
         request.response.write('Hello, request 2!');
         request.response.close();
       });
     });
 
     test('test 2', () {
-      // TODO(nweiz): There can be three errors due to issue 9151. The
-      // HttpException is reported without a stack trace, and so when it's
-      // wrapped twice it registers as a different exception each time (because
-      // it's given an ad-hoc stack trace). Always expect two exceptions when
-      // issue 9151 is fixed.
-      expect(errors.length, inInclusiveRange(2, 3));
-      expect(errors[0].error, equals("'scheduled server 0' received GET "
-          "/hello/3 when no more requests were expected."));
+      expect(errors.length, 2);
+      expect(errors[0].error, new isInstanceOf<ScheduledServerError>());
+      expect(errors[0].error.message, equals("'scheduled server 0' received "
+          "GET /hello/3 when no more requests were expected."));
       expect(errors[1].error, new isInstanceOf<HttpException>());
-      if (errors.length > 2) {
-        expect(errors[2].error, new isInstanceOf<HttpException>());
-      }
     });
   }, passing: ['test 2']);
 
   expectTestsPass("an error in a handler doesn't cause a timeout", () {
     var errors;
     test('test 1', () {
       currentSchedule.onException.schedule(() {
         errors = currentSchedule.errors;
       });
 
       var server = new ScheduledServer();
       expect(server.url.then((url) => http.read(url.resolve('/hello'))),
           completion(equals('Hello, test!')));
 
       server.handle('GET', '/hello', (request) {
-        throw 'oh no';
+        throw new TestFailure('oh no');
       });
     });
 
     test('test 2', () {
-      // TODO(nweiz): There can be three errors due to issue 9151. The
-      // HttpException is reported without a stack trace, and so when it's
-      // wrapped twice it registers as a different exception each time (because
-      // it's given an ad-hoc stack trace). Always expect two exceptions when
-      // issue 9151 is fixed.
-      expect(errors.length, inInclusiveRange(2, 3));
-      expect(errors[0].error, equals('oh no'));
+      expect(errors.length, 2);
+      expect(errors[0].error, new isInstanceOf<TestFailure>());
+      expect(errors[0].error.message, equals('oh no'));
       expect(errors[1].error, new isInstanceOf<HttpException>());
-      if (errors.length > 2) {
-        expect(errors[2].error, new isInstanceOf<HttpException>());
-      }
     });
   }, passing: ['test 2']);
 }