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 152 matching lines @@
         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.
+      // Issue 9151 has been fixed, but there are still three errors reported.
+      // The second is now a copy of the first, rather than a copy of the third.

[nweiz, 2013/09/18 22:46:02]

This comment shouldn't look like a conversation; it should describe the current
state of the system.

Why are there three exceptions now? If the exceptions have the correct stack
traces, two identical exceptions shouldn't register as different.

Same goes for the following tests.

       expect(errors.length, inInclusiveRange(2, 3));
       expect(errors[0].error, equals("'scheduled server 0' expected GET "
           "/goodbye, but got GET /hello."));
-      expect(errors[1].error, new isInstanceOf<HttpException>());
+      expect(errors[1].error, anyOf(new isInstanceOf<HttpException>(),
+          equals("'scheduled server 0' expected GET "
+                 "/goodbye, but got GET /hello.")));
       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.
+      // Issue 9151 has been fixed, but there are still three errors reported.
+      // The second is now a copy of the first, rather than a copy of the third.
       expect(errors.length, inInclusiveRange(2, 3));
       expect(errors[0].error, equals("'scheduled server 0' expected GET "
           "/hello, but got HEAD /hello."));
-      expect(errors[1].error, new isInstanceOf<HttpException>());
+      expect(errors[1].error, anyOf(new isInstanceOf<HttpException>(),
+          equals("'scheduled server 0' expected GET "
+                 "/goodbye, but got GET /hello.")));
       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;
@@ skipping 113 matching lines @@
         throw '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.
+      // Issue 9151 has been fixed, but there are still three errors reported.
+      // The second is now a copy of the first, rather than a copy of the third.
       expect(errors.length, inInclusiveRange(2, 3));
       expect(errors[0].error, equals('oh no'));
-      expect(errors[1].error, new isInstanceOf<HttpException>());
+      expect(errors[1].error, anyOf(new isInstanceOf<HttpException>(),
+          equals("'scheduled server 0' expected GET "
+                 "/goodbye, but got GET /hello.")));
       if (errors.length > 2) {
         expect(errors[2].error, new isInstanceOf<HttpException>());
       }
     });
   }, passing: ['test 2']);
 }