diff --git a/test/canonicalized_map_test.dart b/test/canonicalized_map_test.dart
index 33e663f..19e6a48 100644
--- a/test/canonicalized_map_test.dart
+++ b/test/canonicalized_map_test.dart
@@ -10,7 +10,7 @@
     var map;
     setUp(() {
       map = new CanonicalizedMap<int, String, String>(int.parse,
-          isValidKey: new RegExp(r"^\d+$").hasMatch);
+          isValidKey: (s) => new RegExp(r"^\d+$").hasMatch(s));
     });
 
     test("canonicalizes keys on set and get", () {
diff --git a/test/comparators_test.dart b/test/comparators_test.dart
index 4acdc2c..169c688 100644
--- a/test/comparators_test.dart
+++ b/test/comparators_test.dart
@@ -85,7 +85,7 @@
   // This will sort alphabetically (by charcode) the way digits sort
   // numerically, and the leading 0 means it sorts like a digit
   // compared to non-digits.
-  replaceNumbers(string) => string.replaceAllMapped(new RegExp(r"\d+"), (m) {
+  replaceNumbers(String string) => string.replaceAllMapped(new RegExp(r"\d+"), (m) {
     var digits = m[0];
     return new String.fromCharCodes([0x30, int.parse(digits), digits.length]);
   });
diff --git a/test/priority_queue_test.dart b/test/priority_queue_test.dart
index 1aabcc1..3131b15 100644
--- a/test/priority_queue_test.dart
+++ b/test/priority_queue_test.dart
@@ -165,7 +165,7 @@
 int compare(C c1, C c2) => c1.value - c2.value;
 int compareNeg(C c1, C c2) => c2.value - c1.value;
 
-class C implements Comparable {
+class C implements Comparable<C> {
   final int value;
   const C(this.value);
   int get hashCode => value;
diff --git a/test/queue_list_test.dart b/test/queue_list_test.dart
index cbe518f..deee459 100644
--- a/test/queue_list_test.dart
+++ b/test/queue_list_test.dart
@@ -176,7 +176,7 @@
 
   group("[]=", () {
     test("sets individual entries in the queue", () {
-      var queue = new QueueList.from([1, 2, 3]);
+      var queue = new QueueList<dynamic>.from([1, 2, 3]);
       queue[0] = "a";
       queue[1] = "b";
       queue[2] = "c";
diff --git a/test/typed_wrapper/set_test.dart b/test/typed_wrapper/set_test.dart
index c3f84bc..031bb4c 100644
--- a/test/typed_wrapper/set_test.dart
+++ b/test/typed_wrapper/set_test.dart
@@ -10,11 +10,9 @@
 void main() {
   group("with valid types, forwards", () {
     var wrapper;
-    var emptyWrapper;
     setUp(() {
       wrapper = DelegatingSet.typed/*<int>*/(
           new Set<Object>.from([1, 2, 3, 4, 5]));
-      emptyWrapper = DelegatingSet.typed/*<int>*/(new Set<Object>());
     });
 
     test("add()", () {
diff --git a/test/union_set_test.dart b/test/union_set_test.dart
index 15d9d49..8bce470 100644
--- a/test/union_set_test.dart
+++ b/test/union_set_test.dart
@@ -134,7 +134,7 @@
   group("after an inner set was modified", () {
     var set;
     setUp(() {
-      var innerSet = new Set.from([3, 7]);
+      var innerSet = new Set<int>.from([3, 7]);
       set = new UnionSet<int>.from([
         new Set.from([1, 2]),
         new Set.from([5]),
@@ -179,7 +179,7 @@
     var set;
     setUp(() {
       var innerSet = new Set.from([6]);
-      var outerSet = new Set.from([
+      var outerSet = new Set<Set<int>>.from([
         new Set.from([1, 2]),
         new Set.from([5]),
         innerSet
diff --git a/test/wrapper_test.dart b/test/wrapper_test.dart
index 035783e..e488945 100644
--- a/test/wrapper_test.dart
+++ b/test/wrapper_test.dart
@@ -56,7 +56,7 @@
   static const int SETTER = 0x02;
   final Symbol memberName;
   final List positionalArguments;
-  final Map namedArguments;
+  final Map<Symbol, dynamic> namedArguments;
   final int _type;
   const SyntheticInvocation(this.memberName,
                             this.positionalArguments,
