Update the Angular/DI tests to latest from github.

third_party/pkg/route_hierarchical/test/client_test.dart

 import 'dart:async';
-import 'dart:html';
 
 import 'package:unittest/unittest.dart';
 import 'package:unittest/mock.dart';
-import 'package:unittest/html_enhanced_config.dart';
 import 'package:route_hierarchical/client.dart';
 import 'package:route_hierarchical/url_pattern.dart';
 
 import 'mocks.dart';
 
 main() {
-  useHtmlEnhancedConfiguration();
+  unittestConfiguration.timeout = new Duration(seconds: 1);
 
   test('paths are routed to routes added with addRoute', () {
     Router router = new Router();
     router.root.addRoute(
         name: 'foo',
         path: '/foo',
         enter: expectAsync1((RouteEvent e) {
           expect(e.path, '/foo');
+          expect(router.root.getRoute('foo').isActive, isTrue);
         }));
-    router.route('/foo');
+    return router.route('/foo');
   });
 
   group('hierarchical routing', () {
 
     _testParentChild(
         Pattern parentPath,
         Pattern childPath,
         String expectedParentPath,
         String expectedChildPath,
         String testPath) {
       Router router = new Router();
       router.root.addRoute(
           name: 'parent',
           path: parentPath,
           enter: expectAsync1((RouteEvent e) {
             expect(e.path, expectedParentPath);
+            expect(e.route, isNotNull);
+            expect(e.route.name, 'parent');
           }),
           mount: (Route child) {
             child.addRoute(
                 name: 'child',
                 path: childPath,
                 enter: expectAsync1((RouteEvent e) {
                   expect(e.path, expectedChildPath);
                 }));
           });
       router.route(testPath);
@@ skipping 16 matching lines @@
           '/bar',
           '/foo/bar');
     });
 
   });
 
   group('leave', () {
 
     test('should leave previous route and enter new', () {
       Map<String, int> counters = <String, int>{
+        'fooPreEnter': 0,
         'fooEnter': 0,
         'fooLeave': 0,
+        'barPreEnter': 0,
         'barEnter': 0,
         'barLeave': 0,
+        'bazPreEnter': 0,
         'bazEnter': 0,
         'bazLeave': 0
       };
       Router router = new Router();
       router.root
         ..addRoute(path: '/foo',
             name: 'foo',
+            preEnter: (RouteEvent e) => counters['fooPreEnter']++,
             enter: (RouteEvent e) => counters['fooEnter']++,
             leave: (RouteEvent e) => counters['fooLeave']++,
             mount: (Route route) => route
               ..addRoute(path: '/bar',
                   name: 'bar',
+                  preEnter: (RouteEvent e) => counters['barPreEnter']++,
                   enter: (RouteEvent e) => counters['barEnter']++,
                   leave: (RouteEvent e) => counters['barLeave']++)
               ..addRoute(path: '/baz',
                   name: 'baz',
+                  preEnter: (RouteEvent e) => counters['bazPreEnter']++,
                   enter: (RouteEvent e) => counters['bazEnter']++,
                   leave: (RouteEvent e) => counters['bazLeave']++));
 
       expect(counters, {
+        'fooPreEnter': 0,
         'fooEnter': 0,
         'fooLeave': 0,
+        'barPreEnter': 0,
         'barEnter': 0,
         'barLeave': 0,
+        'bazPreEnter': 0,
         'bazEnter': 0,
         'bazLeave': 0
       });
 
       router.route('/foo/bar').then(expectAsync1((_) {
         expect(counters, {
+          'fooPreEnter': 1,
           'fooEnter': 1,
           'fooLeave': 0,
+          'barPreEnter': 1,
           'barEnter': 1,
           'barLeave': 0,
+          'bazPreEnter': 0,
           'bazEnter': 0,
           'bazLeave': 0
         });
 
         router.route('/foo/baz').then(expectAsync1((_) {
           expect(counters, {
+            'fooPreEnter': 1,
             'fooEnter': 1,
             'fooLeave': 0,
+            'barPreEnter': 1,
             'barEnter': 1,
             'barLeave': 1,
+            'bazPreEnter': 1,
             'bazEnter': 1,
             'bazLeave': 0
           });
         }));
       }));
     });
 
     _testAllowLeave(bool allowLeave) {
       Completer<bool> completer = new Completer<bool>();
       bool barEntered = false;
       bool bazEntered = false;
 
       Router router = new Router();
       router.root
         ..addRoute(name: 'foo', path: '/foo',
             mount: (Route child) => child
               ..addRoute(name: 'bar', path: '/bar',
-                  enter: (RouteEvent e) => barEntered = true,
-                  leave: (RouteEvent e) => e.allowLeave(completer.future))
+                  enter: (RouteEnterEvent e) => barEntered = true,
+                  leave: (RouteLeaveEvent e) => e.allowLeave(completer.future))
               ..addRoute(name: 'baz', path: '/baz',
-                  enter: (RouteEvent e) => bazEntered = true));
+                  enter: (RouteEnterEvent e) => bazEntered = true));
 
       router.route('/foo/bar').then(expectAsync1((_) {
         expect(barEntered, true);
         expect(bazEntered, false);
         router.route('/foo/baz').then(expectAsync1((_) {
           expect(bazEntered, allowLeave);
         }));
         completer.complete(allowLeave);
       }));
     }
 
     test('should allow navigation', () {
       _testAllowLeave(true);
     });
 
     test('should veto navigation', () {
       _testAllowLeave(false);
     });
   });
 
+  group('preEnter', () {
+
+    _testAllowEnter(bool allowEnter) {
+      Completer<bool> completer = new Completer<bool>();
+      bool barEntered = false;
+
+      Router router = new Router();
+      router.root
+        ..addRoute(name: 'foo', path: '/foo',
+            mount: (Route child) => child
+              ..addRoute(name: 'bar', path: '/bar',
+                  enter: (RouteEnterEvent e) => barEntered = true,
+                  preEnter: (RoutePreEnterEvent e) =>
+                      e.allowEnter(completer.future)));
+
+      router.route('/foo/bar').then(expectAsync1((_) {
+        expect(barEntered, allowEnter);
+      }));
+      completer.complete(allowEnter);
+    }
+
+    test('should allow navigation', () {
+      _testAllowEnter(true);
+    });
+
+    test('should veto navigation', () {
+      _testAllowEnter(false);
+    });
+  });
+
   group('Default route', () {
 
     _testHeadTail(String path, String expectFoo, String expectBar) {
       Router router = new Router();
       router.root
         ..addRoute(
             name: 'foo',
             path: '/foo',
             defaultRoute: true,
             enter: expectAsync1((RouteEvent e) {
@@ skipping 499 matching lines @@
         });
       });
     });
 
   });
 
 }
 
 /// An alias for Router.root.getRoute(path)
 r(Router router, String path) => router.root.getRoute(path);