Fix type warnings in declarer_test.

test/backend/declarer_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.
 
 import 'dart:async';
 
 import 'package:test/src/backend/group.dart';
 import 'package:test/src/backend/invoker.dart';
 import 'package:test/src/backend/suite.dart';
 import 'package:test/src/backend/test.dart';
@@ skipping 261 matching lines @@
 
   group("in a group,", () {
     test("tests inherit the group's description", () {
       var entries = declare(() {
         group("group", () {
           test("description", () {});
         });
       });
 
       expect(entries, hasLength(1));
-      expect(entries.single, new isInstanceOf<Group>());
-      expect(entries.single.name, equals("group"));
-      expect(entries.single.entries, hasLength(1));
-      expect(entries.single.entries.single, new isInstanceOf<Test>());
-      expect(entries.single.entries.single.name, "group description");
+      var testGroup = entries.single as Group;
+      expect(testGroup.name, equals("group"));
+      expect(testGroup.entries, hasLength(1));
+      expect(testGroup.entries.single, new isInstanceOf<Test>());
+      expect(testGroup.entries.single.name, "group description");
     });
 
     test("tests inherit the group's description when it's not a string", () {
       var entries = declare(() {
         group(Object, () {
           test("description", () {});
         });
       });
 
       expect(entries, hasLength(1));
-      expect(entries.single, new isInstanceOf<Group>());
-      expect(entries.single.name, equals("Object"));
-      expect(entries.single.entries, hasLength(1));
-      expect(entries.single.entries.single, new isInstanceOf<Test>());
-      expect(entries.single.entries.single.name, "Object description");
+      var testGroup = entries.single as Group;
+      expect(testGroup.name, equals("Object"));
+      expect(testGroup.entries, hasLength(1));
+      expect(testGroup.entries.single, new isInstanceOf<Test>());
+      expect(testGroup.entries.single.name, "Object description");
     });
 
     test("a test's timeout factor is applied to the group's", () {
       var entries = declare(() {
         group("group", () {
           test("test", () {},
               timeout: new Timeout.factor(3));
         }, timeout: new Timeout.factor(2));
       });
 
       expect(entries, hasLength(1));
-      expect(entries.single, new isInstanceOf<Group>());
-      expect(entries.single.metadata.timeout.scaleFactor, equals(2));
-      expect(entries.single.entries, hasLength(1));
-      expect(entries.single.entries.single, new isInstanceOf<Test>());
-      expect(entries.single.entries.single.metadata.timeout.scaleFactor,
+      var testGroup = entries.single as Group;
+      expect(testGroup.metadata.timeout.scaleFactor, equals(2));
+      expect(testGroup.entries, hasLength(1));
+      expect(testGroup.entries.single, new isInstanceOf<Test>());
+      expect(testGroup.entries.single.metadata.timeout.scaleFactor,
           equals(6));
     });
 
     test("a test's timeout factor is applied to the group's duration", () {
       var entries = declare(() {
         group("group", () {
           test("test", () {},
               timeout: new Timeout.factor(2));
         }, timeout: new Timeout(new Duration(seconds: 10)));
       });
 
       expect(entries, hasLength(1));
-      expect(entries.single, new isInstanceOf<Group>());
-      expect(entries.single.metadata.timeout.duration,
+      var testGroup = entries.single as Group;
+      expect(testGroup.metadata.timeout.duration,
           equals(new Duration(seconds: 10)));
-      expect(entries.single.entries, hasLength(1));
-      expect(entries.single.entries.single, new isInstanceOf<Test>());
-      expect(entries.single.entries.single.metadata.timeout.duration,
+      expect(testGroup.entries, hasLength(1));
+      expect(testGroup.entries.single, new isInstanceOf<Test>());
+      expect(testGroup.entries.single.metadata.timeout.duration,
           equals(new Duration(seconds: 20)));
     });
 
     test("a test's timeout duration is applied over the group's", () {
       var entries = declare(() {
         group("group", () {
           test("test", () {},
               timeout: new Timeout(new Duration(seconds: 15)));
         }, timeout: new Timeout(new Duration(seconds: 10)));
       });
 
       expect(entries, hasLength(1));
-      expect(entries.single, new isInstanceOf<Group>());
-      expect(entries.single.metadata.timeout.duration,
+      var testGroup = entries.single as Group;
+      expect(testGroup.metadata.timeout.duration,
           equals(new Duration(seconds: 10)));
-      expect(entries.single.entries, hasLength(1));
-      expect(entries.single.entries.single, new isInstanceOf<Test>());
-      expect(entries.single.entries.single.metadata.timeout.duration,
+      expect(testGroup.entries, hasLength(1));
+      expect(testGroup.entries.single, new isInstanceOf<Test>());
+      expect(testGroup.entries.single.metadata.timeout.duration,
           equals(new Duration(seconds: 15)));
     });
 
     group(".setUp()", () {
       test("is scoped to the group", () async {
         var setUpRun = false;
         var entries = declare(() {
           group("group", () {
             setUp(() => setUpRun = true);
 
             test("description 1", expectAsync(() {
               expect(setUpRun, isTrue);
               setUpRun = false;
             }, max: 1));
           });
 
           test("description 2", expectAsync(() {
             expect(setUpRun, isFalse);
             setUpRun = false;
           }, max: 1));
         });
 
-        await _runTest(entries[0].entries.single);
+        await _runTest((entries[0] as Group).entries.single);
         await _runTest(entries[1]);
       });
 
       test("runs from the outside in", () {
         var outerSetUpRun = false;
         var middleSetUpRun = false;
         var innerSetUpRun = false;
         var entries = declare(() {
           setUp(expectAsync(() {
             expect(middleSetUpRun, isFalse);
@@ skipping 17 matching lines @@
 
               test("description", expectAsync(() {
                 expect(outerSetUpRun, isTrue);
                 expect(middleSetUpRun, isTrue);
                 expect(innerSetUpRun, isTrue);
               }, max: 1));
             });
           });
         });
 
-        return _runTest(entries.single.entries.single.entries.single);
+        var middleGroup = entries.single as Group;
+        var innerGroup = middleGroup.entries.single as Group;
+        return _runTest(innerGroup.entries.single);
       });
 
       test("handles Futures when chained", () {
         var outerSetUpRun = false;
         var innerSetUpRun = false;
         var entries = declare(() {
           setUp(expectAsync(() {
             expect(innerSetUpRun, isFalse);
             return new Future(() => outerSetUpRun = true);
           }, max: 1));
 
           group("inner", () {
             setUp(expectAsync(() {
               expect(outerSetUpRun, isTrue);
               return new Future(() => innerSetUpRun = true);
             }, max: 1));
 
             test("description", expectAsync(() {
               expect(outerSetUpRun, isTrue);
               expect(innerSetUpRun, isTrue);
             }, max: 1));
           });
         });
 
-        return _runTest(entries.single.entries.single);
+        var innerGroup = entries.single as Group;
+        return _runTest(innerGroup.entries.single);
       });
 
       test("inherits group's tags", () {
         var tests = declare(() {
           group("outer", () {
             group("inner", () {
               test("with tags", () {}, tags: "d");
             }, tags: ["b", "c"]);
           }, tags: "a");
         });
 
-        var outerGroup = tests.single;
-        var innerGroup = outerGroup.entries.single;
+        var outerGroup = tests.single as Group;
+        var innerGroup = outerGroup.entries.single as Group;
         var testWithTags = innerGroup.entries.single;
         expect(outerGroup.metadata.tags, unorderedEquals(["a"]));
         expect(innerGroup.metadata.tags, unorderedEquals(["a", "b", "c"]));
         expect(testWithTags.metadata.tags,
             unorderedEquals(["a", "b", "c", "d"]));
       });
 
       test("throws on invalid tags", () {
         expect(() {
           declare(() {
@@ skipping 15 matching lines @@
             test("description 1", expectAsync(() {
               expect(tearDownRun, isFalse);
             }, max: 1));
           });
 
           test("description 2", expectAsync(() {
             expect(tearDownRun, isFalse);
           }, max: 1));
         });
 
-        await _runTest(entries[0].entries.single);
+        var testGroup = entries[0] as Group;
+        await _runTest(testGroup.entries.single);
         expect(tearDownRun, isTrue);
         await _runTest(entries[1]);
         expect(tearDownRun, isFalse);
       });
 
       test("runs from the inside out", () async {
         var innerTearDownRun = false;
         var middleTearDownRun = false;
         var outerTearDownRun = false;
         var entries = declare(() {
@@ skipping 19 matching lines @@
 
               test("description", expectAsync(() {
                 expect(outerTearDownRun, isFalse);
                 expect(middleTearDownRun, isFalse);
                 expect(innerTearDownRun, isFalse);
               }, max: 1));
             });
           });
         });
 
-        await _runTest(entries.single.entries.single.entries.single);
+        var middleGroup = entries.single as Group;
+        var innerGroup = middleGroup.entries.single as Group;
+        await _runTest(innerGroup.entries.single);
         expect(innerTearDownRun, isTrue);
         expect(middleTearDownRun, isTrue);
         expect(outerTearDownRun, isTrue);
       });
 
       test("handles Futures when chained", () async {
         var outerTearDownRun = false;
         var innerTearDownRun = false;
         var entries = declare(() {
           tearDown(expectAsync(() {
             expect(innerTearDownRun, isTrue);
             return new Future(() => outerTearDownRun = true);
           }, max: 1));
 
           group("inner", () {
             tearDown(expectAsync(() {
               expect(outerTearDownRun, isFalse);
               return new Future(() => innerTearDownRun = true);
             }, max: 1));
 
             test("description", expectAsync(() {
               expect(outerTearDownRun, isFalse);
               expect(innerTearDownRun, isFalse);
             }, max: 1));
           });
         });
 
-        await _runTest(entries.single.entries.single);
+        var innerGroup = entries.single as Group;
+        await _runTest(innerGroup.entries.single);
         expect(innerTearDownRun, isTrue);
         expect(outerTearDownRun, isTrue);
       });
 
       test("runs outer callbacks even when inner ones fail", () async {
         var outerTearDownRun = false;
         var entries = declare(() {
           tearDown(() {
             return new Future(() => outerTearDownRun = true);
           });
 
           group("inner", () {
             tearDown(() {
               throw 'inner error';
             });
 
             test("description", expectAsync(() {
               expect(outerTearDownRun, isFalse);
             }, max: 1));
           });
         });
 
-        await _runTest(entries.single.entries.single, shouldFail: true);
+        var innerGroup = entries.single as Group;
+        await _runTest(innerGroup.entries.single, shouldFail: true);
         expect(outerTearDownRun, isTrue);
       });
     });
   });
 }
 
 /// Runs [test].
 ///
 /// This automatically sets up an `onError` listener to ensure that the test
 /// doesn't throw any invisible exceptions.
 Future _runTest(Test test, {bool shouldFail: false}) {
   var liveTest = test.load(_suite);
 
   liveTest.onError.listen(shouldFail
       ? expectAsync((_) {})
       : (error) => registerException(error.error, error.stackTrace));
 
   return liveTest.run();
 }