Clean up dart:io exceptions.

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 20 matching lines @@
       });
 
       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
-      // HttpParserException is reported without a stack trace, and so when it's
+      // 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[1].error, new isInstanceOf<HttpParserException>());
+      expect(errors[1].error, new isInstanceOf<HttpException>());
       if (errors.length > 2) {
-        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+        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!')));
 
@@ skipping 42 matching lines @@
       schedule(() => null);
 
       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
-      // HttpParserException is reported without a stack trace, and so when it's
+      // 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[1].error, new isInstanceOf<HttpParserException>());
+      expect(errors[1].error, new isInstanceOf<HttpException>());
       if (errors.length > 2) {
-        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+        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", () {
     test('test', () {
       var server = new ScheduledServer();
       expect(server.url.then((url) => http.read(url.resolve('/hello'))),
@@ skipping 26 matching lines @@
           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
-      // HttpParserException is reported without a stack trace, and so when it's
+      // 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[1].error, new isInstanceOf<HttpParserException>());
+      expect(errors[1].error, new isInstanceOf<HttpException>());
       if (errors.length > 2) {
-        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+        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
-      // HttpParserException is reported without a stack trace, and so when it's
+      // 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[1].error, new isInstanceOf<HttpParserException>());
+      expect(errors[1].error, new isInstanceOf<HttpException>());
       if (errors.length > 2) {
-        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+        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);
@@ skipping 75 matching lines @@
       });
 
       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
-      // HttpParserException is reported without a stack trace, and so when it's
+      // 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[1].error, new isInstanceOf<HttpParserException>());
+      expect(errors[1].error, new isInstanceOf<HttpException>());
       if (errors.length > 2) {
-        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+        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';
       });
     });
 
     test('test 2', () {
       // TODO(nweiz): There can be three errors due to issue 9151. The
-      // HttpParserException is reported without a stack trace, and so when it's
+      // 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[1].error, new isInstanceOf<HttpParserException>());
+      expect(errors[1].error, new isInstanceOf<HttpException>());
       if (errors.length > 2) {
-        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+        expect(errors[2].error, new isInstanceOf<HttpException>());
       }
     });
   }, passing: ['test 2']);
 }