Miscellaneous small improvements for scheduled_test.

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 '../../../pkg/http/lib/http.dart' as http;
@@ skipping 17 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>()));
-      expect(errors.length, equals(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
+      // 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>());
+      if (errors.length > 2) {
+        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+      }
     });
   }, 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 40 matching lines @@
       // for the immediately-preceding task.
       schedule(() => null);
 
       server.handle('GET', '/hello', (request) {
         request.response.write('Hello, test!');
         request.response.close();
       });
     });
 
     test('test 2', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.length, equals(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
+      // 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>());
+      if (errors.length > 2) {
+        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+      }
+      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'))),
           completion(equals('Hello, test!')));
 
@@ skipping 23 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', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.length, equals(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
+      // 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>());
+      if (errors.length > 2) {
+        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+      }
     });
   }, 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', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.length, equals(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
+      // 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>());
+      if (errors.length > 2) {
+        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+      }
     });
   }, 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', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.length, equals(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
+      // 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>());
+      if (errors.length > 2) {
+        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+      }
     });
   }, 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', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.length, equals(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
+      // 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>());
+      if (errors.length > 2) {
+        expect(errors[2].error, new isInstanceOf<HttpParserException>());
+      }
     });
   }, passing: ['test 2']);
 }