Modified unittest to use new argument syntax.

utils/tests/pub/version_solver_test.dart

 // Copyright (c) 2012, 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 pub_update_test;
 
 import 'dart:io';
 import 'dart:isolate';
 
 import '../../pub/lock_file.dart';
@@ skipping 321 matching lines @@
 // TODO(rnystrom): More stuff to test:
 // - Two packages depend on the same package, but from different sources. Should
 //   fail.
 // - Depending on a non-existent package.
 // - Test that only a certain number requests are sent to the mock source so we
 //   can keep track of server traffic.
 }
 
 testResolve(description, packages, {lockfile, result, error}) {
   test(description, () {
+    var isNoVersionException = predicate((x)=> x is NoVersionException,
+        "is a NoVersionException");
+    var isDisjointConstraintException =
+        predicate((x)=> x is DisjointConstraintException,
+       "    is a DisjointConstraintException");
+    var isSourceMismatchException =
+        predicate((x)=> x is SourceMismatchException,
+            "is a SourceMismatchException");
+    var isDescriptionMismatchException =
+        predicate((x)=> x is DescriptionMismatchException,
+            "is a DescriptionMismatchException");
+    var isCouldNotSolveException = predicate((x)=> x is CouldNotSolveException,
+            "is a CouldNotSolveException");
+
     var sources = new SourceRegistry();
     source1 = new MockSource('mock1');
     source2 = new MockSource('mock2');
     versionlessSource = new MockVersionlessSource();
     sources.register(source1);
     sources.register(source2);
     sources.register(versionlessSource);
     sources.setDefault(source1.name);
 
     // Build the test package graph.
@@ skipping 46 matching lines @@
     var future = resolveVersions(sources, root, realLockFile);
 
     if (result != null) {
       expect(future, completion(predicate((actualResult) {
         for (var actualId in actualResult) {
           if (!result.containsKey(actualId.name)) return false;
           var expectedId = result.remove(actualId.name);
           if (actualId != expectedId) return false;
         }
         return result.isEmpty;
-      }, description: 'packages to match $result')));
+      }, 'packages to match $result')));
     } else if (error == noVersion) {
-      expect(future, throwsA(new isInstanceOf<NoVersionException>()));
+      expect(future, throwsA(isNoVersionException));
     } else if (error == disjointConstraint) {
-      expect(future, throwsA(new isInstanceOf<DisjointConstraintException>()));
+      expect(future, throwsA(isDisjointConstraintException));
     } else if (error == sourceMismatch) {
-      expect(future, throwsA(new isInstanceOf<SourceMismatchException>()));
+      expect(future, throwsA(isSourceMismatchException));
     } else if (error == descriptionMismatch) {
-      expect(future, throwsA(new isInstanceOf<DescriptionMismatchException>()));
+      expect(future, throwsA(isDescriptionMismatchException));
     } else if (error == couldNotSolve) {
-      expect(future, throwsA(new isInstanceOf<CouldNotSolveException>()));
+      expect(future, throwsA(isCouldNotSolveException));
     } else {
       expect(future, throwsA(error));
     }
 
     // If we aren't expecting an error, print some debugging info if we get one.
     if (error == null) {
       future.handleException((ex) {
         print(ex);
         print(future.stackTrace);
         return true;
@@ skipping 95 matching lines @@
   var match = new RegExp(r"(.*) from (.*)").firstMatch(name);
   if (match == null) return new Pair<String, Source>(name, source1);
   switch (match[2]) {
   case 'mock1': return new Pair<String, Source>(match[1], source1);
   case 'mock2': return new Pair<String, Source>(match[1], source2);
   case 'root': return new Pair<String, Source>(match[1], rootSource);
   case 'versionless':
     return new Pair<String, Source>(match[1], versionlessSource);
   }
 }