diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9bca49a..cde274e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,10 @@
-## 1.4.2
+## 1.5.0
+
+* Add `DelegatingIterable.typed()`, `DelegatingList.typed()`,
+  `DelegatingSet.typed()`, `DelegatingMap.typed()`, and
+  `DelegatingQueue.typed()` static methods. These wrap untyped instances of
+  these classes with the correct type parameter, and assert the types of values
+  as they're accessed.
 
 * Fix the types for `binarySearch()` and `lowerBound()` so they no longer
   require all arguments to be comparable.
diff --git a/lib/src/typed_wrappers.dart b/lib/src/typed_wrappers.dart
new file mode 100644
index 0000000..1dcb3b7
--- /dev/null
+++ b/lib/src/typed_wrappers.dart
@@ -0,0 +1,349 @@
+// Copyright (c) 2016, 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:collection";
+import "dart:math" as math;
+
+import "wrappers.dart";
+
+typedef F _UnaryFunction<E, F>(E argument);
+
+/// The base class for delegating, type-asserting iterables.
+///
+/// Subclasses can provide a [_base] that should be delegated to. Unlike
+/// [TypeSafeIterable], this allows the base to be created on demand.
+abstract class _TypeSafeIterableBase<E> implements Iterable<E> {
+  /// The base iterable to which operations are delegated.
+  Iterable get _base;
+
+  _TypeSafeIterableBase();
+
+  bool any(bool test(E element)) => _base.any(_validate(test));
+
+  bool contains(Object element) => _base.contains(element);
+
+  E elementAt(int index) => _base.elementAt(index) as E;
+
+  bool every(bool test(E element)) => _base.every(_validate(test));
+
+  Iterable/*<T>*/ expand/*<T>*/(Iterable/*<T>*/ f(E element)) =>
+      _base.expand(_validate(f));
+
+  E get first => _base.first as E;
+
+  E firstWhere(bool test(E element), {E orElse()}) =>
+      _base.firstWhere(_validate(test), orElse: orElse) as E;
+
+  /*=T*/ fold/*<T>*/(
+          /*=T*/ initialValue,
+          /*=T*/ combine(/*=T*/ previousValue, E element)) =>
+      _base.fold(initialValue,
+          (previousValue, element) => combine(previousValue, element as E));
+
+  void forEach(void f(E element)) => _base.forEach(_validate(f));
+
+  bool get isEmpty => _base.isEmpty;
+
+  bool get isNotEmpty => _base.isNotEmpty;
+
+  Iterator<E> get iterator => _base.map((element) => element as E).iterator;
+
+  String join([String separator = ""]) => _base.join(separator);
+
+  E get last => _base.last as E;
+
+  E lastWhere(bool test(E element), {E orElse()}) =>
+      _base.lastWhere(_validate(test), orElse: orElse) as E;
+
+  int get length => _base.length;
+
+  Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(E element)) => _base.map(_validate(f));
+
+  E reduce(E combine(E value, E element)) =>
+      _base.reduce((value, element) => combine(value as E, element as E)) as E;
+
+  E get single => _base.single as E;
+
+  E singleWhere(bool test(E element)) =>
+    _base.singleWhere(_validate(test)) as E;
+
+  Iterable<E> skip(int n) => new TypeSafeIterable<E>(_base.skip(n));
+
+  Iterable<E> skipWhile(bool test(E value)) =>
+      new TypeSafeIterable<E>(_base.skipWhile(_validate(test)));
+
+  Iterable<E> take(int n) => new TypeSafeIterable<E>(_base.take(n));
+
+  Iterable<E> takeWhile(bool test(E value)) =>
+      new TypeSafeIterable<E>(_base.takeWhile(_validate(test)));
+
+  List<E> toList({bool growable: true}) =>
+      new TypeSafeList<E>(_base.toList(growable: growable));
+
+  Set<E> toSet() => new TypeSafeSet<E>(_base.toSet());
+
+  Iterable<E> where(bool test(E element)) =>
+      new TypeSafeIterable<E>(_base.where(_validate(test)));
+
+  String toString() => _base.toString();
+
+  /// Returns a version of [function] that asserts that its argument is an
+  /// instance of `E`.
+  _UnaryFunction/*<dynamic, F>*/ _validate/*<F>*/(/*=F*/ function(E value)) =>
+      (value) => function(value as E);
+}
+
+/// An [Iterable] that asserts the types of values in a base iterable.
+///
+/// This is instantiated using [DelegatingIterable.typed].
+class TypeSafeIterable<E> extends _TypeSafeIterableBase<E>
+    implements DelegatingIterable<E> {
+  final Iterable _base;
+
+  TypeSafeIterable(Iterable base) : _base = base;
+}
+
+/// A [List] that asserts the types of values in a base list.
+///
+/// This is instantiated using [DelegatingList.typed].
+class TypeSafeList<E> extends TypeSafeIterable<E> implements DelegatingList<E> {
+  TypeSafeList(List base) : super(base);
+
+  /// A [List]-typed getter for [_base].
+  List get _listBase => _base;
+
+  E operator [](int index) => _listBase[index] as E;
+
+  void operator []=(int index, E value) {
+    _listBase[index] = value;
+  }
+
+  void add(E value) {
+    _listBase.add(value);
+  }
+
+  void addAll(Iterable<E> iterable) {
+    _listBase.addAll(iterable);
+  }
+
+  Map<int, E> asMap() => new TypeSafeMap<int, E>(_listBase.asMap());
+
+  void clear() {
+    _listBase.clear();
+  }
+
+  void fillRange(int start, int end, [E fillValue]) {
+    _listBase.fillRange(start, end, fillValue);
+  }
+
+  Iterable<E> getRange(int start, int end) =>
+      new TypeSafeIterable<E>(_listBase.getRange(start, end));
+
+  int indexOf(E element, [int start = 0]) => _listBase.indexOf(element, start);
+
+  void insert(int index, E element) {
+    _listBase.insert(index, element);
+  }
+
+  void insertAll(int index, Iterable<E> iterable) {
+    _listBase.insertAll(index, iterable);
+  }
+
+  int lastIndexOf(E element, [int start]) =>
+      _listBase.lastIndexOf(element, start);
+
+  void set length(int newLength) {
+    _listBase.length = newLength;
+  }
+
+  bool remove(Object value) => _listBase.remove(value);
+
+  E removeAt(int index) => _listBase.removeAt(index) as E;
+
+  E removeLast() => _listBase.removeLast() as E;
+
+  void removeRange(int start, int end) {
+    _listBase.removeRange(start, end);
+  }
+
+  void removeWhere(bool test(E element)) {
+    _listBase.removeWhere(_validate(test));
+  }
+
+  void replaceRange(int start, int end, Iterable<E> iterable) {
+    _listBase.replaceRange(start, end, iterable);
+  }
+
+  void retainWhere(bool test(E element)) {
+    _listBase.retainWhere(_validate(test));
+  }
+
+  Iterable<E> get reversed => new TypeSafeIterable<E>(_listBase.reversed);
+
+  void setAll(int index, Iterable<E> iterable) {
+    _listBase.setAll(index, iterable);
+  }
+
+  void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) {
+    _listBase.setRange(start, end, iterable, skipCount);
+  }
+
+  void shuffle([math.Random random]) {
+    _listBase.shuffle(random);
+  }
+
+  void sort([int compare(E a, E b)]) {
+    if (compare == null) {
+      _listBase.sort();
+    } else {
+      _listBase.sort((a, b) => compare(a as E, b as E));
+    }
+  }
+
+  List<E> sublist(int start, [int end]) =>
+      new TypeSafeList<E>(_listBase.sublist(start, end));
+}
+
+/// A [Set] that asserts the types of values in a base set.
+///
+/// This is instantiated using [DelegatingSet.typed].
+class TypeSafeSet<E> extends TypeSafeIterable<E> implements DelegatingSet<E> {
+  TypeSafeSet(Set base) : super(base);
+
+  /// A [Set]-typed getter for [_base].
+  Set get _setBase => _base;
+
+  bool add(E value) => _setBase.add(value);
+
+  void addAll(Iterable<E> elements) {
+    _setBase.addAll(elements);
+  }
+
+  void clear() {
+    _setBase.clear();
+  }
+
+  bool containsAll(Iterable<Object> other) => _setBase.containsAll(other);
+
+  Set<E> difference(Set<E> other) =>
+      new TypeSafeSet<E>(_setBase.difference(other));
+
+  Set<E> intersection(Set<Object> other) =>
+      new TypeSafeSet<E>(_setBase.intersection(other));
+
+  E lookup(Object element) => _setBase.lookup(element) as E;
+
+  bool remove(Object value) => _setBase.remove(value);
+
+  void removeAll(Iterable<Object> elements) {
+    _setBase.removeAll(elements);
+  }
+
+  void removeWhere(bool test(E element)) {
+    _setBase.removeWhere(_validate(test));
+  }
+
+  void retainAll(Iterable<Object> elements) {
+    _setBase.retainAll(elements);
+  }
+
+  void retainWhere(bool test(E element)) {
+    _setBase.retainWhere(_validate(test));
+  }
+
+  Set<E> union(Set<E> other) => new TypeSafeSet<E>(_setBase.union(other));
+}
+
+/// A [Queue] that asserts the types of values in a base queue.
+///
+/// This is instantiated using [DelegatingQueue.typed].
+class TypeSafeQueue<E> extends TypeSafeIterable<E>
+    implements DelegatingQueue<E> {
+  TypeSafeQueue(Queue queue) : super(queue);
+
+  /// A [Queue]-typed getter for [_base].
+  Queue get _baseQueue => _base;
+
+  void add(E value) {
+    _baseQueue.add(value);
+  }
+
+  void addAll(Iterable<E> iterable) {
+    _baseQueue.addAll(iterable);
+  }
+
+  void addFirst(E value) {
+    _baseQueue.addFirst(value);
+  }
+
+  void addLast(E value) {
+    _baseQueue.addLast(value);
+  }
+
+  void clear() {
+    _baseQueue.clear();
+  }
+
+  bool remove(Object object) => _baseQueue.remove(object);
+
+  void removeWhere(bool test(E element)) {
+    _baseQueue.removeWhere(_validate(test));
+  }
+
+  void retainWhere(bool test(E element)) {
+    _baseQueue.retainWhere(_validate(test));
+  }
+
+  E removeFirst() => _baseQueue.removeFirst() as E;
+
+  E removeLast() => _baseQueue.removeLast() as E;
+}
+
+/// A [Map] that asserts the types of keys and values in a base map.
+///
+/// This is instantiated using [DelegatingMap.typed].
+class TypeSafeMap<K, V> implements DelegatingMap<K, V> {
+  /// The base map to which operations are delegated.
+  final Map _base;
+
+  TypeSafeMap(Map base) : _base = base;
+
+  V operator [](Object key) => _base[key] as V;
+
+  void operator []=(K key, V value) {
+    _base[key] = value;
+  }
+
+  void addAll(Map<K, V> other) {
+    _base.addAll(other);
+  }
+
+  void clear() {
+    _base.clear();
+  }
+
+  bool containsKey(Object key) => _base.containsKey(key);
+
+  bool containsValue(Object value) => _base.containsValue(value);
+
+  void forEach(void f(K key, V value)) {
+    _base.forEach((key, value) => f(key as K, value as V));
+  }
+
+  bool get isEmpty => _base.isEmpty;
+
+  bool get isNotEmpty => _base.isNotEmpty;
+
+  Iterable<K> get keys => new TypeSafeIterable<K>(_base.keys);
+
+  int get length => _base.length;
+
+  V putIfAbsent(K key, V ifAbsent()) => _base.putIfAbsent(key, ifAbsent) as V;
+
+  V remove(Object key) => _base.remove(key) as V;
+
+  Iterable<V> get values => new TypeSafeIterable<V>(_base.values);
+
+  String toString() => _base.toString();
+}
diff --git a/lib/src/wrappers.dart b/lib/src/wrappers.dart
index fcd3315..c447427 100644
--- a/lib/src/wrappers.dart
+++ b/lib/src/wrappers.dart
@@ -5,6 +5,7 @@
 import "dart:collection";
 import "dart:math" as math;
 
+import "typed_wrappers.dart";
 import "unmodifiable_wrappers.dart";
 
 typedef K _KeyForValue<K, V>(V value);
@@ -81,27 +82,53 @@
   String toString() => _base.toString();
 }
 
-/// Creates an [Iterable] that delegates all operations to a base iterable.
+/// An [Iterable] that delegates all operations to a base iterable.
 ///
-/// This class can be used hide non-`Iterable` methods of an iterable object,
+/// This class can be used to hide non-`Iterable` methods of an iterable object,
 /// or it can be extended to add extra functionality on top of an existing
 /// iterable object.
 class DelegatingIterable<E> extends _DelegatingIterableBase<E> {
   final Iterable<E> _base;
 
-  /// Create a wrapper that forwards operations to [base].
+  /// Creates a wrapper that forwards operations to [base].
   const DelegatingIterable(Iterable<E> base) : _base = base;
+
+  /// Creates a wrapper that asserts the types of values in [base].
+  ///
+  /// This soundly converts an [Iterable] without a generic type to an
+  /// `Iterable<E>` by asserting that its elements are instances of `E` whenever
+  /// they're accessed. If they're not, it throws a [CastError].
+  ///
+  /// This forwards all operations to [base], so any changes in [base] will be
+  /// reflected in [this]. If [base] is already an `Iterable<E>`, it's returned
+  /// unmodified.
+  static Iterable/*<E>*/ typed/*<E>*/(Iterable base) =>
+      base is Iterable/*<E>*/ ? base : new TypedIterable/*<E>*/(base);
 }
 
 
-/// Creates a [List] that delegates all operations to a base list.
+/// A [List] that delegates all operations to a base list.
 ///
-/// This class can be used hide non-`List` methods of a list object,
-/// or it can be extended to add extra functionality on top of an existing
-/// list object.
+/// This class can be used to hide non-`List` methods of a list object, or it
+/// can be extended to add extra functionality on top of an existing list
+/// object.
 class DelegatingList<E> extends DelegatingIterable<E> implements List<E> {
   const DelegatingList(List<E> base) : super(base);
 
+  /// Creates a wrapper that asserts the types of values in [base].
+  ///
+  /// This soundly converts a [List] without a generic type to a `List<E>` by
+  /// asserting that its elements are instances of `E` whenever they're
+  /// accessed. If they're not, it throws a [CastError]. Note that even if an
+  /// operation throws a [CastError], it may still mutate the underlying
+  /// collection.
+  ///
+  /// This forwards all operations to [base], so any changes in [base] will be
+  /// reflected in [this]. If [base] is already a `List<E>`, it's returned
+  /// unmodified.
+  static List/*<E>*/ typed/*<E>*/(List base) =>
+      base is List/*<E>*/ ? base : new TypedList/*<E>*/(base);
+
   List<E> get _listBase => _base;
 
   E operator [](int index) => _listBase[index];
@@ -191,14 +218,27 @@
 }
 
 
-/// Creates a [Set] that delegates all operations to a base set.
+/// A [Set] that delegates all operations to a base set.
 ///
-/// This class can be used hide non-`Set` methods of a set object,
-/// or it can be extended to add extra functionality on top of an existing
-/// set object.
+/// This class can be used to hide non-`Set` methods of a set object, or it can
+/// be extended to add extra functionality on top of an existing set object.
 class DelegatingSet<E> extends DelegatingIterable<E> implements Set<E> {
   const DelegatingSet(Set<E> base) : super(base);
 
+  /// Creates a wrapper that asserts the types of values in [base].
+  ///
+  /// This soundly converts a [Set] without a generic type to a `Set<E>` by
+  /// asserting that its elements are instances of `E` whenever they're
+  /// accessed. If they're not, it throws a [CastError]. Note that even if an
+  /// operation throws a [CastError], it may still mutate the underlying
+  /// collection.
+  ///
+  /// This forwards all operations to [base], so any changes in [base] will be
+  /// reflected in [this]. If [base] is already a `Set<E>`, it's returned
+  /// unmodified.
+  static Set/*<E>*/ typed/*<E>*/(Set base) =>
+      base is Set/*<E>*/ ? base : new TypedSet/*<E>*/(base);
+
   Set<E> get _setBase => _base;
 
   bool add(E value) => _setBase.add(value);
@@ -242,14 +282,28 @@
   Set<E> toSet() => new DelegatingSet<E>(_setBase.toSet());
 }
 
-/// Creates a [Queue] that delegates all operations to a base queue.
+/// A [Queue] that delegates all operations to a base queue.
 ///
-/// This class can be used hide non-`Queue` methods of a queue object,
-/// or it can be extended to add extra functionality on top of an existing
-/// queue object.
+/// This class can be used to hide non-`Queue` methods of a queue object, or it
+/// can be extended to add extra functionality on top of an existing queue
+/// object.
 class DelegatingQueue<E> extends DelegatingIterable<E> implements Queue<E> {
   const DelegatingQueue(Queue<E> queue) : super(queue);
 
+  /// Creates a wrapper that asserts the types of values in [base].
+  ///
+  /// This soundly converts a [Queue] without a generic type to a `Queue<E>` by
+  /// asserting that its elements are instances of `E` whenever they're
+  /// accessed. If they're not, it throws a [CastError]. Note that even if an
+  /// operation throws a [CastError], it may still mutate the underlying
+  /// collection.
+  ///
+  /// This forwards all operations to [base], so any changes in [base] will be
+  /// reflected in [this]. If [base] is already a `Queue<E>`, it's returned
+  /// unmodified.
+  static Queue/*<E>*/ typed/*<E>*/(Queue base) =>
+      base is Queue/*<E>*/ ? base : new TypedQueue/*<E>*/(base);
+
   Queue<E> get _baseQueue => _base;
 
   void add(E value) {
@@ -283,9 +337,9 @@
   E removeLast() => _baseQueue.removeLast();
 }
 
-/// Creates a [Map] that delegates all operations to a base map.
+/// A [Map] that delegates all operations to a base map.
 ///
-/// This class can be used hide non-`Map` methods of an object that extends
+/// This class can be used to hide non-`Map` methods of an object that extends
 /// `Map`, or it can be extended to add extra functionality on top of an
 /// existing map object.
 class DelegatingMap<K, V> implements Map<K, V> {
@@ -293,6 +347,20 @@
 
   const DelegatingMap(Map<K, V> base) : _base = base;
 
+  /// Creates a wrapper that asserts the types of keys and values in [base].
+  ///
+  /// This soundly converts a [Map] without generic types to a `Map<K, V>` by
+  /// asserting that its keys are instances of `E` and its values are instances
+  /// of `V` whenever they're accessed. If they're not, it throws a [CastError].
+  /// Note that even if an operation throws a [CastError], it may still mutate
+  /// the underlying collection.
+  ///
+  /// This forwards all operations to [base], so any changes in [base] will be
+  /// reflected in [this]. If [base] is already a `Map<K, V>`, it's returned
+  /// unmodified.
+  static Map/*<K, V>*/ typed/*<K, V>*/(Map base) =>
+      base is Map<K, V> ? base : new TypedMap<K, V>(base);
+
   V operator [](Object key) => _base[key];
 
   void operator []=(K key, V value) {
diff --git a/pubspec.yaml b/pubspec.yaml
index 6f1d641..5023dbe 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: collection
-version: 1.4.2
+version: 1.5.0
 author: Dart Team <misc@dartlang.org>
 description: Collections and utilities functions and classes related to collections.
 homepage: https://www.github.com/dart-lang/collection
diff --git a/test/typed_wrapper/iterable_test.dart b/test/typed_wrapper/iterable_test.dart
new file mode 100644
index 0000000..3614ba4
--- /dev/null
+++ b/test/typed_wrapper/iterable_test.dart
@@ -0,0 +1,355 @@
+// Copyright (c) 2016, 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 "package:collection/collection.dart";
+import "package:test/test.dart";
+
+import '../utils.dart';
+
+void main() {
+  group("with valid types, forwards", () {
+    var wrapper;
+    var emptyWrapper;
+    var singleWrapper;
+    setUp(() {
+      wrapper = DelegatingIterable.typed/*<int>*/(
+          <Object>[1, 2, 3, 4, 5].map((i) => i));
+      emptyWrapper = DelegatingIterable.typed/*<int>*/(
+          <Object>[].map((i) => i));
+      singleWrapper = DelegatingIterable.typed/*<int>*/(
+          <Object>[1].map((i) => i));
+    });
+
+    test("any()", () {
+      expect(wrapper.any((i) => i > 3), isTrue);
+      expect(wrapper.any((i) => i > 5), isFalse);
+    });
+
+    test("contains()", () {
+      expect(wrapper.contains(2), isTrue);
+      expect(wrapper.contains(6), isFalse);
+      expect(wrapper.contains("foo"), isFalse);
+    });
+
+    test("elementAt()", () {
+      expect(wrapper.elementAt(1), equals(2));
+      expect(wrapper.elementAt(4), equals(5));
+      expect(() => wrapper.elementAt(5), throwsRangeError);
+      expect(() => wrapper.elementAt(-1), throwsRangeError);
+    });
+
+    test("every()", () {
+      expect(wrapper.every((i) => i < 6), isTrue);
+      expect(wrapper.every((i) => i > 3), isFalse);
+    });
+
+    test("expand()", () {
+      expect(wrapper.expand((i) => [i]), equals([1, 2, 3, 4, 5]));
+      expect(wrapper.expand((i) => [i, i]),
+          equals([1, 1, 2, 2, 3, 3, 4, 4, 5, 5]));
+    });
+
+    test("first", () {
+      expect(wrapper.first, equals(1));
+      expect(() => emptyWrapper.first, throwsStateError);
+    });
+
+    test("firstWhere()", () {
+      expect(wrapper.firstWhere((i) => i > 3), equals(4));
+      expect(() => wrapper.firstWhere((i) => i > 5), throwsStateError);
+      expect(wrapper.firstWhere((i) => i > 5, orElse: () => -1), equals(-1));
+    });
+
+    test("fold()", () {
+      expect(wrapper.fold("", (previous, i) => previous + i.toString()),
+          equals("12345"));
+      expect(emptyWrapper.fold(null, (previous, i) => previous + i), isNull);
+    });
+
+    test("forEach()", () {
+      var results = [];
+      wrapper.forEach(results.add);
+      expect(results, equals([1, 2, 3, 4, 5]));
+
+      emptyWrapper.forEach(expectAsync((_) {}, count: 0));
+    });
+
+    test("isEmpty", () {
+      expect(wrapper.isEmpty, isFalse);
+      expect(emptyWrapper.isEmpty, isTrue);
+    });
+
+    test("isNotEmpty", () {
+      expect(wrapper.isNotEmpty, isTrue);
+      expect(emptyWrapper.isNotEmpty, isFalse);
+    });
+
+    test("iterator", () {
+      var iterator = wrapper.iterator;
+      expect(iterator.current, isNull);
+      expect(iterator.moveNext(), isTrue);
+      expect(iterator.current, equals(1));
+      expect(iterator.moveNext(), isTrue);
+      expect(iterator.current, equals(2));
+      expect(iterator.moveNext(), isTrue);
+      expect(iterator.current, equals(3));
+      expect(iterator.moveNext(), isTrue);
+      expect(iterator.current, equals(4));
+      expect(iterator.moveNext(), isTrue);
+      expect(iterator.current, equals(5));
+      expect(iterator.moveNext(), isFalse);
+      expect(iterator.current, isNull);
+    });
+
+    test("join()", () {
+      expect(wrapper.join(), "12345");
+      expect(wrapper.join("-"), "1-2-3-4-5");
+    });
+
+    test("last", () {
+      expect(wrapper.last, equals(5));
+      expect(() => emptyWrapper.last, throwsStateError);
+    });
+
+    test("lastWhere()", () {
+      expect(wrapper.lastWhere((i) => i > 3), equals(5));
+      expect(() => wrapper.lastWhere((i) => i > 5), throwsStateError);
+      expect(wrapper.lastWhere((i) => i > 5, orElse: () => -1), equals(-1));
+    });
+
+    test("length", () {
+      expect(wrapper.length, equals(5));
+      expect(emptyWrapper.length, equals(0));
+    });
+
+    test("map()", () {
+      expect(wrapper.map((i) => i + 1), equals([2, 3, 4, 5, 6]));
+      expect(wrapper.map((i) => i / 2), equals([0.5, 1.0, 1.5, 2.0, 2.5]));
+    });
+
+    test("reduce()", () {
+      expect(wrapper.reduce((value, i) => value + i), equals(15));
+      expect(() => emptyWrapper.reduce((value, i) => value + i),
+          throwsStateError);
+    });
+
+    test("single", () {
+      expect(() => wrapper.single, throwsStateError);
+      expect(singleWrapper.single, equals(1));
+    });
+
+    test("singleWhere()", () {
+      expect(() => wrapper.singleWhere((i) => i.isOdd), throwsStateError);
+      expect(singleWrapper.singleWhere((i) => i.isOdd), equals(1));
+      expect(() => singleWrapper.singleWhere((i) => i.isEven),
+          throwsStateError);
+    });
+
+    test("skip()", () {
+      expect(wrapper.skip(3), equals([4, 5]));
+      expect(wrapper.skip(10), isEmpty);
+      expect(() => wrapper.skip(-1), throwsRangeError);
+    });
+
+    test("skipWhile()", () {
+      expect(wrapper.skipWhile((i) => i < 3), equals([3, 4, 5]));
+      expect(wrapper.skipWhile((i) => i < 10), isEmpty);
+    });
+
+    test("take()", () {
+      expect(wrapper.take(3), equals([1, 2, 3]));
+      expect(wrapper.take(10), equals([1, 2, 3, 4, 5]));
+      expect(() => wrapper.take(-1), throwsRangeError);
+    });
+
+    test("takeWhile()", () {
+      expect(wrapper.takeWhile((i) => i < 3), equals([1, 2]));
+      expect(wrapper.takeWhile((i) => i < 10), equals([1, 2, 3, 4, 5]));
+    });
+
+    test("toList()", () {
+      expect(wrapper.toList(), equals([1, 2, 3, 4, 5]));
+      expect(wrapper.toList(growable: false), equals([1, 2, 3, 4, 5]));
+      expect(() => wrapper.toList(growable: false).add(6),
+          throwsUnsupportedError);
+    });
+
+    test("toSet()", () {
+      expect(wrapper.toSet(), unorderedEquals([1, 2, 3, 4, 5]));
+      expect(DelegatingIterable.typed/*<int>*/(<Object>[1, 1, 2, 2]).toSet(),
+          unorderedEquals([1, 2]));
+    });
+
+    test("where()", () {
+      expect(wrapper.where((i) => i.isOdd), equals([1, 3, 5]));
+      expect(wrapper.where((i) => i.isEven), equals([2, 4]));
+    });
+
+    test("toString()", () {
+      expect(wrapper.toString(), equals("(1, 2, 3, 4, 5)"));
+      expect(emptyWrapper.toString(), equals("()"));
+    });
+  });
+
+  group("with invalid types", () {
+    var wrapper;
+    var singleWrapper;
+    setUp(() {
+      wrapper = DelegatingIterable.typed/*<int>*/(
+          <Object>["foo", "bar", "baz"].map((element) => element));
+      singleWrapper = DelegatingIterable.typed/*<int>*/(
+          <Object>["foo"].map((element) => element));
+    });
+
+    group("throws a CastError for", () {
+      test("any()", () {
+        expect(() => wrapper.any(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("elementAt()", () {
+        expect(() => wrapper.elementAt(1), throwsCastError);
+      });
+
+      test("every()", () {
+        expect(() => wrapper.every(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("expand()", () {
+        var lazy = wrapper.expand(expectAsync((_) => [], count: 0));
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("first", () {
+        expect(() => wrapper.first, throwsCastError);
+      });
+
+      test("firstWhere()", () {
+        expect(() => wrapper.firstWhere(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("fold()", () {
+        expect(() => wrapper.fold(null, expectAsync((_, __) => null, count: 0)),
+            throwsCastError);
+      });
+
+      test("forEach()", () {
+        expect(() => wrapper.forEach(expectAsync((_) {}, count: 0)),
+            throwsCastError);
+      });
+
+      test("iterator", () {
+        var iterator = wrapper.iterator;
+        expect(iterator.current, isNull);
+        expect(() => iterator.moveNext(), throwsCastError);
+      });
+
+      test("last", () {
+        expect(() => wrapper.last, throwsCastError);
+      });
+
+      test("lastWhere()", () {
+        expect(() => wrapper.lastWhere(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("map()", () {
+        var lazy = wrapper.map(expectAsync((_) => null, count: 0));
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("reduce()", () {
+        expect(() => wrapper.reduce(expectAsync((_, __) => null, count: 0)),
+            throwsCastError);
+      });
+
+      test("single", () {
+        expect(() => singleWrapper.single, throwsCastError);
+      });
+
+      test("singleWhere()", () {
+        expect(() {
+          singleWrapper.singleWhere(expectAsync((_) => false, count: 0));
+        }, throwsCastError);
+      });
+
+      test("skip()", () {
+        var lazy = wrapper.skip(1);
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("skipWhile()", () {
+        var lazy = wrapper.skipWhile(expectAsync((_) => false, count: 0));
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("take()", () {
+        var lazy = wrapper.take(1);
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("takeWhile()", () {
+        var lazy = wrapper.takeWhile(expectAsync((_) => false, count: 0));
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("toList()", () {
+        var list = wrapper.toList();
+        expect(() => list.first, throwsCastError);
+      });
+
+      test("toSet()", () {
+        var asSet = wrapper.toSet();
+        expect(() => asSet.first, throwsCastError);
+      });
+
+      test("where()", () {
+        var lazy = wrapper.where(expectAsync((_) => false, count: 0));
+        expect(() => lazy.first, throwsCastError);
+      });
+    });
+
+    group("doesn't throw a CastError for", () {
+      test("contains()", () {
+        expect(wrapper.contains(1), isFalse);
+        expect(wrapper.contains("foo"), isTrue);
+      });
+
+      test("elementAt()", () {
+        expect(() => wrapper.elementAt(-1), throwsRangeError);
+        expect(() => wrapper.elementAt(10), throwsRangeError);
+      });
+
+      test("isEmpty", () {
+        expect(wrapper.isEmpty, isFalse);
+      });
+
+      test("isNotEmpty", () {
+        expect(wrapper.isNotEmpty, isTrue);
+      });
+
+      test("join()", () {
+        expect(wrapper.join(), "foobarbaz");
+      });
+
+      test("length", () {
+        expect(wrapper.length, equals(3));
+      });
+
+      test("single", () {
+        expect(() => wrapper.single, throwsStateError);
+      });
+
+      test("skip()", () {
+        expect(() => wrapper.skip(-1), throwsRangeError);
+      });
+
+      test("toString()", () {
+        expect(wrapper.toString(), equals("(foo, bar, baz)"));
+      });
+    });
+  }, skip: "Re-enable this when test can run DDC (test#414).");
+}
diff --git a/test/typed_wrapper/list_test.dart b/test/typed_wrapper/list_test.dart
new file mode 100644
index 0000000..5dd81ca
--- /dev/null
+++ b/test/typed_wrapper/list_test.dart
@@ -0,0 +1,421 @@
+// Copyright (c) 2016, 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:math' as math;
+
+import "package:collection/collection.dart";
+import "package:test/test.dart";
+
+import '../utils.dart';
+
+void main() {
+  group("with valid types, forwards", () {
+    var wrapper;
+    var emptyWrapper;
+    setUp(() {
+      wrapper = DelegatingList.typed/*<int>*/(<Object>[1, 2, 3, 4, 5]);
+      emptyWrapper = DelegatingList.typed/*<int>*/(<Object>[]);
+    });
+
+    test("[]", () {
+      expect(wrapper[0], equals(1));
+      expect(wrapper[1], equals(2));
+      expect(() => wrapper[-1], throwsRangeError);
+      expect(() => wrapper[10], throwsRangeError);
+    });
+
+    test("[]=", () {
+      wrapper[1] = 10;
+      wrapper[3] = 15;
+      expect(wrapper, equals([1, 10, 3, 15, 5]));
+      expect(() => wrapper[-1] = 10, throwsRangeError);
+      expect(() => wrapper[10] = 10, throwsRangeError);
+    });
+
+    test("add()", () {
+      wrapper.add(6);
+      wrapper.add(7);
+      expect(wrapper, equals([1, 2, 3, 4, 5, 6, 7]));
+    });
+
+    test("addAll()", () {
+      wrapper.addAll([6, 7, 8]);
+      expect(wrapper, equals([1, 2, 3, 4, 5, 6, 7, 8]));
+    });
+
+    test("asMap()", () {
+      expect(wrapper.asMap(), equals({0: 1, 1: 2, 2: 3, 3: 4, 4: 5}));
+    });
+
+    test("clear()", () {
+      wrapper.clear();
+      expect(wrapper, isEmpty);
+    });
+
+    test("fillRange()", () {
+      wrapper.fillRange(2, 4);
+      expect(wrapper, equals([1, 2, null, null, 5]));
+
+      wrapper.fillRange(1, 2, 7);
+      expect(wrapper, equals([1, 7, null, null, 5]));
+
+      expect(() => wrapper.fillRange(-1, 2), throwsRangeError);
+      expect(() => wrapper.fillRange(1, 10), throwsRangeError);
+      expect(() => wrapper.fillRange(4, 2), throwsRangeError);
+      expect(() => wrapper.fillRange(10, 12), throwsRangeError);
+    });
+
+    test("getRange()", () {
+      expect(wrapper.getRange(2, 4), equals([3, 4]));
+      expect(wrapper.getRange(1, 2), equals([2]));
+
+      expect(() => wrapper.getRange(-1, 2), throwsRangeError);
+      expect(() => wrapper.getRange(1, 10), throwsRangeError);
+      expect(() => wrapper.getRange(4, 2), throwsRangeError);
+      expect(() => wrapper.getRange(10, 12), throwsRangeError);
+    });
+
+    test("indexOf()", () {
+      expect(wrapper.indexOf(4), equals(3));
+      expect(wrapper.indexOf(10), equals(-1));
+      expect(wrapper.indexOf(4, 2), equals(3));
+      expect(wrapper.indexOf(4, 4), equals(-1));
+    });
+
+    test("insert()", () {
+      wrapper.insert(3, 10);
+      expect(wrapper, equals([1, 2, 3, 10, 4, 5]));
+
+      wrapper.insert(0, 15);
+      expect(wrapper, equals([15, 1, 2, 3, 10, 4, 5]));
+
+      expect(() => wrapper.insert(-1, 0), throwsRangeError);
+      expect(() => wrapper.insert(10, 0), throwsRangeError);
+    });
+
+    test("insertAll()", () {
+      wrapper.insertAll(3, [10, 11, 12]);
+      expect(wrapper, equals([1, 2, 3, 10, 11, 12, 4, 5]));
+
+      wrapper.insertAll(0, [15, 16, 17]);
+      expect(wrapper, equals([15, 16, 17, 1, 2, 3, 10, 11, 12, 4, 5]));
+
+      expect(() => wrapper.insertAll(-1, []), throwsRangeError);
+      expect(() => wrapper.insertAll(100, []), throwsRangeError);
+    });
+
+    test("lastIndexOf()", () {
+      expect(wrapper.lastIndexOf(4), equals(3));
+      expect(wrapper.lastIndexOf(10), equals(-1));
+      expect(wrapper.lastIndexOf(4, 4), equals(3));
+      expect(wrapper.lastIndexOf(4, 2), equals(-1));
+    });
+
+    test("length=", () {
+      wrapper.length = 10;
+      expect(wrapper, equals([1, 2, 3, 4, 5, null, null, null, null, null]));
+
+      wrapper.length = 3;
+      expect(wrapper, equals([1, 2, 3]));
+    });
+
+    test("remove()", () {
+      expect(wrapper.remove(3), isTrue);
+      expect(wrapper, equals([1, 2, 4, 5]));
+
+      expect(wrapper.remove(3), isFalse);
+      expect(wrapper.remove("foo"), isFalse);
+    });
+
+    test("removeAt()", () {
+      expect(wrapper.removeAt(3), equals(4));
+      expect(wrapper, equals([1, 2, 3, 5]));
+
+      expect(() => wrapper.removeAt(-1), throwsRangeError);
+      expect(() => wrapper.removeAt(10), throwsRangeError);
+    });
+
+    test("removeLast()", () {
+      expect(wrapper.removeLast(), equals(5));
+      expect(wrapper, equals([1, 2, 3, 4]));
+
+      // See sdk#26087. We want this to pass with the current implementation and
+      // with the fix.
+      expect(() => emptyWrapper.removeLast(),
+          anyOf(throwsStateError, throwsRangeError));
+    });
+
+    test("removeRange()", () {
+      wrapper.removeRange(2, 4);
+      expect(wrapper, equals([1, 2, 5]));
+
+      expect(() => wrapper.removeRange(-1, 2), throwsRangeError);
+      expect(() => wrapper.removeRange(1, 10), throwsRangeError);
+      expect(() => wrapper.removeRange(4, 2), throwsRangeError);
+      expect(() => wrapper.removeRange(10, 12), throwsRangeError);
+    });
+
+    test("removeWhere()", () {
+      wrapper.removeWhere((i) => i.isOdd);
+      expect(wrapper, equals([2, 4]));
+    });
+
+    test("replaceRange()", () {
+      wrapper.replaceRange(2, 4, [10, 11, 12]);
+      expect(wrapper, equals([1, 2, 10, 11, 12, 5]));
+
+      expect(() => wrapper.replaceRange(-1, 2, []), throwsRangeError);
+      expect(() => wrapper.replaceRange(1, 10, []), throwsRangeError);
+      expect(() => wrapper.replaceRange(4, 2, []), throwsRangeError);
+      expect(() => wrapper.replaceRange(10, 12, []), throwsRangeError);
+    });
+
+    test("retainWhere()", () {
+      wrapper.retainWhere((i) => i.isOdd);
+      expect(wrapper, equals([1, 3, 5]));
+    });
+
+    test("reversed", () {
+      expect(wrapper.reversed, equals([5, 4, 3, 2, 1]));
+    });
+
+    test("setAll()", () {
+      wrapper.setAll(2, [10, 11]);
+      expect(wrapper, equals([1, 2, 10, 11, 5]));
+
+      expect(() => wrapper.setAll(-1, []), throwsRangeError);
+      expect(() => wrapper.setAll(10, []), throwsRangeError);
+    });
+
+    test("setRange()", () {
+      wrapper.setRange(2, 4, [10, 11, 12]);
+      expect(wrapper, equals([1, 2, 10, 11, 5]));
+
+      wrapper.setRange(2, 4, [10, 11, 12], 1);
+      expect(wrapper, equals([1, 2, 11, 12, 5]));
+
+      expect(() => wrapper.setRange(-1, 2, []), throwsRangeError);
+      expect(() => wrapper.setRange(1, 10, []), throwsRangeError);
+      expect(() => wrapper.setRange(4, 2, []), throwsRangeError);
+      expect(() => wrapper.setRange(10, 12, []), throwsRangeError);
+      expect(() => wrapper.setRange(2, 4, []), throwsStateError);
+    });
+
+    test("shuffle()", () {
+      wrapper.shuffle(new math.Random(1234));
+      expect(wrapper, equals([1, 2, 3, 4, 5]..shuffle(new math.Random(1234))));
+    });
+
+    test("sort()", () {
+      wrapper.sort((a, b) => b.compareTo(a));
+      expect(wrapper, equals([5, 4, 3, 2, 1]));
+
+      wrapper.sort();
+      expect(wrapper, equals([1, 2, 3, 4, 5]));
+    });
+
+    test("sublist()", () {
+      expect(wrapper.sublist(2), equals([3, 4, 5]));
+      expect(wrapper.sublist(2, 4), equals([3, 4]));
+    });
+  });
+
+  group("with invalid types", () {
+    var inner;
+    var wrapper;
+    setUp(() {
+      inner = <Object>["foo", "bar", "baz"];
+      wrapper = DelegatingList.typed/*<int>*/(inner);
+    });
+
+    group("throws a CastError for", () {
+      test("[]", () {
+        expect(() => wrapper[0], throwsCastError);
+      });
+
+      test("asMap()", () {
+        var map = wrapper.asMap();
+        expect(() => map[1], throwsCastError);
+      });
+
+      test("getRange()", () {
+        var lazy = wrapper.getRange(1, 2);
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("removeAt()", () {
+        expect(() => wrapper.removeAt(2), throwsCastError);
+      });
+
+      test("removeLast()", () {
+        expect(() => wrapper.removeLast(), throwsCastError);
+      });
+
+      test("removeWhere()", () {
+        expect(() => wrapper.removeWhere(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("retainWhere()", () {
+        expect(() => wrapper.retainWhere(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("reversed", () {
+        var lazy = wrapper.reversed;
+        expect(() => lazy.first, throwsCastError);
+      });
+
+      test("sort()", () {
+        expect(() => wrapper.sort(expectAsync((_, __) => 0, count: 0)),
+            throwsCastError);
+      });
+
+      test("sublist()", () {
+        var list = wrapper.sublist(1);
+        expect(() => list[0], throwsCastError);
+      });
+    });
+
+    group("doesn't throw a CastError for", () {
+      test("[]", () {
+        expect(() => wrapper[-1], throwsRangeError);
+        expect(() => wrapper[10], throwsRangeError);
+      });
+
+      test("[]=", () {
+        wrapper[1] = 10;
+        expect(inner, equals(["foo", 10, "baz"]));
+        expect(() => wrapper[-1] = 10, throwsRangeError);
+        expect(() => wrapper[10] = 10, throwsRangeError);
+      });
+
+      test("add()", () {
+        wrapper.add(6);
+        wrapper.add(7);
+        expect(inner, equals(["foo", "bar", "baz", 6, 7]));
+      });
+
+      test("addAll()", () {
+        wrapper.addAll([6, 7, 8]);
+        expect(inner, equals(["foo", "bar", "baz", 6, 7, 8]));
+      });
+
+      test("clear()", () {
+        wrapper.clear();
+        expect(wrapper, isEmpty);
+      });
+
+      test("fillRange()", () {
+        wrapper.fillRange(1, 3, 7);
+        expect(inner, equals(["foo", 7, 7]));
+
+        expect(() => wrapper.fillRange(-1, 2), throwsRangeError);
+        expect(() => wrapper.fillRange(1, 10), throwsRangeError);
+        expect(() => wrapper.fillRange(4, 2), throwsRangeError);
+        expect(() => wrapper.fillRange(10, 12), throwsRangeError);
+      });
+
+      test("getRange()", () {
+        expect(() => wrapper.getRange(-1, 2), throwsRangeError);
+        expect(() => wrapper.getRange(1, 10), throwsRangeError);
+        expect(() => wrapper.getRange(4, 2), throwsRangeError);
+        expect(() => wrapper.getRange(10, 12), throwsRangeError);
+      });
+
+      test("indexOf()", () {
+        expect(wrapper.indexOf(4), equals(-1));
+      });
+
+      test("insert()", () {
+        wrapper.insert(0, 15);
+        expect(inner, equals([15, "foo", "bar", "baz"]));
+
+        expect(() => wrapper.insert(-1, 0), throwsRangeError);
+        expect(() => wrapper.insert(10, 0), throwsRangeError);
+      });
+
+      test("insertAll()", () {
+        wrapper.insertAll(0, [15, 16, 17]);
+        expect(inner, equals([15, 16, 17, "foo", "bar", "baz"]));
+
+        expect(() => wrapper.insertAll(-1, []), throwsRangeError);
+        expect(() => wrapper.insertAll(100, []), throwsRangeError);
+      });
+
+      test("lastIndexOf()", () {
+        expect(wrapper.lastIndexOf(4), equals(-1));
+      });
+
+      test("length=", () {
+        wrapper.length = 5;
+        expect(inner, equals(["foo", "bar", "baz", null, null]));
+
+        wrapper.length = 1;
+        expect(inner, equals(["foo"]));
+      });
+
+      test("remove()", () {
+        expect(wrapper.remove(3), isFalse);
+        expect(wrapper.remove("foo"), isTrue);
+        expect(inner, equals(["bar", "baz"]));
+      });
+
+      test("removeAt()", () {
+        expect(() => wrapper.removeAt(-1), throwsRangeError);
+        expect(() => wrapper.removeAt(10), throwsRangeError);
+      });
+
+      test("removeRange()", () {
+        wrapper.removeRange(1, 3);
+        expect(inner, equals(["foo"]));
+
+        expect(() => wrapper.removeRange(-1, 2), throwsRangeError);
+        expect(() => wrapper.removeRange(1, 10), throwsRangeError);
+        expect(() => wrapper.removeRange(4, 2), throwsRangeError);
+        expect(() => wrapper.removeRange(10, 12), throwsRangeError);
+      });
+
+      test("replaceRange()", () {
+        wrapper.replaceRange(1, 2, [10, 11, 12]);
+        expect(inner, equals(["foo", 10, 11, 12, "baz"]));
+
+        expect(() => wrapper.replaceRange(-1, 2, []), throwsRangeError);
+        expect(() => wrapper.replaceRange(1, 10, []), throwsRangeError);
+        expect(() => wrapper.replaceRange(4, 2, []), throwsRangeError);
+        expect(() => wrapper.replaceRange(10, 12, []), throwsRangeError);
+      });
+
+      test("setAll()", () {
+        wrapper.setAll(1, [10, 11]);
+        expect(inner, equals(["foo", 10, 11]));
+
+        expect(() => wrapper.setAll(-1, []), throwsRangeError);
+        expect(() => wrapper.setAll(10, []), throwsRangeError);
+      });
+
+      test("setRange()", () {
+        wrapper.setRange(1, 2, [10, 11, 12]);
+        expect(inner, equals(["foo", 10, "baz"]));
+
+        expect(() => wrapper.setRange(-1, 2, []), throwsRangeError);
+        expect(() => wrapper.setRange(1, 10, []), throwsRangeError);
+        expect(() => wrapper.setRange(4, 2, []), throwsRangeError);
+        expect(() => wrapper.setRange(10, 12, []), throwsRangeError);
+        expect(() => wrapper.setRange(1, 2, []), throwsStateError);
+      });
+
+      test("shuffle()", () {
+        wrapper.shuffle(new math.Random(1234));
+        expect(inner,
+            equals(["foo", "bar", "baz"]..shuffle(new math.Random(1234))));
+      });
+
+      test("sort()", () {
+        wrapper.sort();
+        expect(inner, equals(["bar", "baz", "foo"]));
+      });
+    });
+  }, skip: "Re-enable this when test can run DDC (test#414).");
+}
diff --git a/test/typed_wrapper/map_test.dart b/test/typed_wrapper/map_test.dart
new file mode 100644
index 0000000..3546ae8
--- /dev/null
+++ b/test/typed_wrapper/map_test.dart
@@ -0,0 +1,315 @@
+// Copyright (c) 2016, 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 "package:collection/collection.dart";
+import "package:test/test.dart";
+
+import '../utils.dart';
+
+void main() {
+  group("with valid types, forwards", () {
+    var wrapper;
+    var emptyWrapper;
+    setUp(() {
+      wrapper = DelegatingMap.typed/*<String, int>*/(
+          <Object, Object>{"foo": 1, "bar": 2, "baz": 3, "bang": 4});
+      emptyWrapper = DelegatingMap.typed/*<String, int>*/(<Object, Object>{});
+    });
+
+    test("[]", () {
+      expect(wrapper["foo"], equals(1));
+      expect(wrapper["bar"], equals(2));
+      expect(wrapper["qux"], isNull);
+      expect(wrapper[1], isNull);
+    });
+
+    test("[]=", () {
+      wrapper["foo"] = 5;
+      expect(wrapper, equals({"foo": 5, "bar": 2, "baz": 3, "bang": 4}));
+
+      wrapper["qux"] = 6;
+      expect(wrapper,
+          equals({"foo": 5, "bar": 2, "baz": 3, "bang": 4, "qux": 6}));
+    });
+
+    test("addAll()", () {
+      wrapper.addAll({"bar": 5, "qux": 6});
+      expect(wrapper,
+          equals({"foo": 1, "bar": 5, "baz": 3, "bang": 4, "qux": 6}));
+    });
+
+    test("clear()", () {
+      wrapper.clear();
+      expect(wrapper, isEmpty);
+    });
+
+    test("containsKey()", () {
+      expect(wrapper.containsKey("foo"), isTrue);
+      expect(wrapper.containsKey("qux"), isFalse);
+      expect(wrapper.containsKey(1), isFalse);
+    });
+
+    test("containsValue()", () {
+      expect(wrapper.containsValue(1), isTrue);
+      expect(wrapper.containsValue(7), isFalse);
+      expect(wrapper.containsValue("foo"), isFalse);
+    });
+
+    test("forEach()", () {
+      var results = [];
+      wrapper.forEach((key, value) => results.add([key, value]));
+      expect(results,
+          unorderedEquals([["foo", 1], ["bar", 2], ["baz", 3], ["bang", 4]]));
+
+      emptyWrapper.forEach(expectAsync((_, __) {}, count: 0));
+    });
+
+    test("isEmpty", () {
+      expect(wrapper.isEmpty, isFalse);
+      expect(emptyWrapper.isEmpty, isTrue);
+    });
+
+    test("isNotEmpty", () {
+      expect(wrapper.isNotEmpty, isTrue);
+      expect(emptyWrapper.isNotEmpty, isFalse);
+    });
+
+    test("keys", () {
+      expect(wrapper.keys, unorderedEquals(["foo", "bar", "baz", "bang"]));
+      expect(emptyWrapper.keys, isEmpty);
+    });
+
+    test("length", () {
+      expect(wrapper.length, equals(4));
+      expect(emptyWrapper.length, equals(0));
+    });
+
+    test("putIfAbsent()", () {
+      expect(wrapper.putIfAbsent("foo", expectAsync(() => null, count: 0)),
+          equals(1));
+
+      expect(wrapper.putIfAbsent("qux", () => 6), equals(6));
+      expect(wrapper,
+          equals({"foo": 1, "bar": 2, "baz": 3, "bang": 4, "qux": 6}));
+    });
+
+    test("remove()", () {
+      expect(wrapper.remove("foo"), equals(1));
+      expect(wrapper, equals({"bar": 2, "baz": 3, "bang": 4}));
+
+      expect(wrapper.remove("foo"), isNull);
+      expect(wrapper.remove(3), isNull);
+    });
+
+    test("values", () {
+      expect(wrapper.values, unorderedEquals([1, 2, 3, 4]));
+      expect(emptyWrapper.values, isEmpty);
+    });
+
+    test("toString()", () {
+      expect(wrapper.toString(), allOf([
+        startsWith("{"),
+        contains("foo: 1"),
+        contains("bar: 2"),
+        contains("baz: 3"),
+        contains("bang: 4"),
+        endsWith("}")
+      ]));
+    });
+  });
+
+  group("with invalid key types", () {
+    var inner;
+    var wrapper;
+    setUp(() {
+      inner = <Object, Object>{1: 1, 2: 2, 3: 3, 4: 4};
+      wrapper = DelegatingMap.typed/*<String, int>*/(inner);
+    });
+
+    group("throws a CastError for", () {
+      test("forEach()", () {
+        expect(() => wrapper.forEach(expectAsync((_, __) {}, count: 0)),
+            throwsCastError);
+      });
+
+      test("keys", () {
+        var lazy = wrapper.keys;
+        expect(() => lazy.first, throwsCastError);
+      });
+    });
+
+    group("doesn't throw a CastError for", () {
+      test("[]", () {
+        expect(wrapper["foo"], isNull);
+        expect(wrapper[1], equals(1));
+        expect(wrapper[7], isNull);
+      });
+
+      test("[]=", () {
+        wrapper["foo"] = 5;
+        expect(inner, equals({"foo": 5, 1: 1, 2: 2, 3: 3, 4: 4}));
+      });
+
+      test("addAll()", () {
+        wrapper.addAll({"foo": 1, "bar": 2});
+        expect(inner, equals({"foo": 1, "bar": 2, 1: 1, 2: 2, 3: 3, 4: 4}));
+      });
+
+      test("clear()", () {
+        wrapper.clear();
+        expect(wrapper, isEmpty);
+      });
+
+      test("containsKey()", () {
+        expect(wrapper.containsKey(1), isTrue);
+        expect(wrapper.containsKey(7), isFalse);
+        expect(wrapper.containsKey("foo"), isFalse);
+      });
+
+      test("containsValue()", () {
+        expect(wrapper.containsValue(1), isTrue);
+        expect(wrapper.containsValue(7), isFalse);
+        expect(wrapper.containsValue("foo"), isFalse);
+      });
+
+      test("isEmpty", () {
+        expect(wrapper.isEmpty, isFalse);
+      });
+
+      test("isNotEmpty", () {
+        expect(wrapper.isNotEmpty, isTrue);
+      });
+
+      test("length", () {
+        expect(wrapper.length, equals(4));
+      });
+
+      test("putIfAbsent()", () {
+        expect(wrapper.putIfAbsent("foo", () => 1), equals(1));
+        expect(inner, equals({"foo": 1, 1: 1, 2: 2, 3: 3, 4: 4}));
+      });
+
+      test("remove()", () {
+        expect(wrapper.remove(1), equals(1));
+        expect(inner, equals({2: 2, 3: 3, 4: 4}));
+
+        expect(wrapper.remove("foo"), isNull);
+        expect(wrapper.remove(7), isNull);
+      });
+
+      test("values", () {
+        expect(wrapper.values, unorderedEquals([1, 2, 3, 4]));
+      });
+
+      test("toString()", () {
+        expect(wrapper.toString(), allOf([
+          startsWith("{"),
+          contains("1: 1"),
+          contains("2: 2"),
+          contains("3: 3"),
+          contains("4: 4"),
+          endsWith("}")
+        ]));
+      });
+    });
+  }, skip: "Re-enable this when test can run DDC (test#414).");
+
+  group("with invalid value types", () {
+    var inner;
+    var wrapper;
+    setUp(() {
+      inner = <Object, Object>{"foo": "bar", "baz": "bang"};
+      wrapper = DelegatingMap.typed/*<String, int>*/(inner);
+    });
+
+    group("throws a CastError for", () {
+      test("forEach()", () {
+        expect(() => wrapper.forEach(expectAsync((_, __) {}, count: 0)),
+            throwsCastError);
+      });
+
+      test("[]", () {
+        expect(() => wrapper["foo"], throwsCastError);
+        expect(wrapper["qux"], isNull);
+      });
+
+      test("putIfAbsent()", () {
+        expect(() => wrapper.putIfAbsent("foo", () => 1), throwsCastError);
+      });
+
+      test("remove()", () {
+        expect(() => wrapper.remove("foo"), throwsCastError);
+      });
+
+      test("values", () {
+        var lazy = wrapper.values;
+        expect(() => lazy.first, throwsCastError);
+      });
+    });
+
+    group("doesn't throw a CastError for", () {
+      test("[]=", () {
+        wrapper["foo"] = 5;
+        expect(inner, equals({"foo": 5, "baz": "bang"}));
+      });
+
+      test("addAll()", () {
+        wrapper.addAll({"foo": 1, "qux": 2});
+        expect(inner, equals({"foo": 1, "baz": "bang", "qux": 2}));
+      });
+
+      test("clear()", () {
+        wrapper.clear();
+        expect(wrapper, isEmpty);
+      });
+
+      test("containsKey()", () {
+        expect(wrapper.containsKey("foo"), isTrue);
+        expect(wrapper.containsKey(1), isFalse);
+        expect(wrapper.containsKey("qux"), isFalse);
+      });
+
+      test("containsValue()", () {
+        expect(wrapper.containsValue("bar"), isTrue);
+        expect(wrapper.containsValue(1), isFalse);
+        expect(wrapper.containsValue("foo"), isFalse);
+      });
+
+      test("isEmpty", () {
+        expect(wrapper.isEmpty, isFalse);
+      });
+
+      test("isNotEmpty", () {
+        expect(wrapper.isNotEmpty, isTrue);
+      });
+
+      test("keys", () {
+        expect(wrapper.keys, unorderedEquals(["foo", "baz"]));
+      });
+
+      test("length", () {
+        expect(wrapper.length, equals(2));
+      });
+
+      test("putIfAbsent()", () {
+        expect(wrapper.putIfAbsent("qux", () => 1), equals(1));
+        expect(inner, equals({"foo": "bar", "baz": "bang", "qux": 1}));
+      });
+
+      test("remove()", () {
+        expect(wrapper.remove("qux"), isNull);
+        expect(wrapper.remove(7), isNull);
+      });
+
+      test("toString()", () {
+        expect(wrapper.toString(), allOf([
+          startsWith("{"),
+          contains("foo: bar"),
+          contains("baz: bang"),
+          endsWith("}")
+        ]));
+      });
+    });
+  }, skip: "Re-enable this when test can run DDC (test#414).");
+}
diff --git a/test/typed_wrapper/queue_test.dart b/test/typed_wrapper/queue_test.dart
new file mode 100644
index 0000000..dc93321
--- /dev/null
+++ b/test/typed_wrapper/queue_test.dart
@@ -0,0 +1,141 @@
+// Copyright (c) 2016, 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:collection";
+
+import "package:collection/collection.dart";
+import "package:test/test.dart";
+
+import '../utils.dart';
+
+void main() {
+  group("with valid types, forwards", () {
+    var wrapper;
+    var emptyWrapper;
+    setUp(() {
+      wrapper = DelegatingQueue.typed/*<int>*/(
+          new Queue<Object>.from([1, 2, 3, 4, 5]));
+      emptyWrapper = DelegatingQueue.typed/*<int>*/(new Queue<Object>());
+    });
+
+    test("add()", () {
+      wrapper.add(6);
+      wrapper.add(7);
+      expect(wrapper, equals([1, 2, 3, 4, 5, 6, 7]));
+    });
+
+    test("addAll()", () {
+      wrapper.addAll([6, 7, 8]);
+      expect(wrapper, equals([1, 2, 3, 4, 5, 6, 7, 8]));
+    });
+
+    test("addFirst()", () {
+      wrapper.addFirst(6);
+      wrapper.addFirst(7);
+      expect(wrapper, equals([7, 6, 1, 2, 3, 4, 5]));
+    });
+
+    test("addLast()", () {
+      wrapper.addLast(6);
+      wrapper.addLast(7);
+      expect(wrapper, equals([1, 2, 3, 4, 5, 6, 7]));
+    });
+
+    test("clear()", () {
+      wrapper.clear();
+      expect(wrapper, isEmpty);
+    });
+
+    test("remove()", () {
+      expect(wrapper.remove(3), isTrue);
+      expect(wrapper, equals([1, 2, 4, 5]));
+
+      expect(wrapper.remove(3), isFalse);
+      expect(wrapper.remove("foo"), isFalse);
+    });
+
+    test("removeWhere()", () {
+      wrapper.removeWhere((i) => i.isOdd);
+      expect(wrapper, equals([2, 4]));
+    });
+
+    test("retainWhere()", () {
+      wrapper.retainWhere((i) => i.isOdd);
+      expect(wrapper, equals([1, 3, 5]));
+    });
+
+    test("removeLast()", () {
+      expect(wrapper.removeLast(), equals(5));
+      expect(wrapper, equals([1, 2, 3, 4]));
+
+      expect(() => emptyWrapper.removeLast(), throwsStateError);
+    });
+
+    test("removeFirst()", () {
+      expect(wrapper.removeFirst(), equals(1));
+      expect(wrapper, equals([2, 3, 4, 5]));
+
+      expect(() => emptyWrapper.removeFirst(), throwsStateError);
+    });
+  });
+
+  group("with invalid types", () {
+    var inner;
+    var wrapper;
+    setUp(() {
+      inner = new Queue<Object>.from(["foo", "bar", "baz"]);
+      wrapper = DelegatingQueue.typed/*<int>*/(inner);
+    });
+
+    group("throws a CastError for", () {
+      test("removeLast()", () {
+        expect(() => wrapper.removeLast(), throwsCastError);
+      });
+
+      test("removeFirst()", () {
+        expect(() => wrapper.removeFirst(), throwsCastError);
+      });
+
+      test("removeWhere()", () {
+        expect(() => wrapper.removeWhere(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("retainWhere()", () {
+        expect(() => wrapper.retainWhere(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+    });
+
+    group("doesn't throw a CastError for", () {
+      test("add()", () {
+        wrapper.add(6);
+        wrapper.add(7);
+        expect(inner, equals(["foo", "bar", "baz", 6, 7]));
+      });
+
+      test("addAll()", () {
+        wrapper.addAll([6, 7, 8]);
+        expect(inner, equals(["foo", "bar", "baz", 6, 7, 8]));
+      });
+
+      test("addFirst()", () {
+        wrapper.addFirst(6);
+        wrapper.addFirst(7);
+        expect(inner, equals([7, 6, "foo", "bar", "baz"]));
+      });
+
+      test("addLast()", () {
+        wrapper.addLast(6);
+        wrapper.addLast(7);
+        expect(inner, equals(["foo", "bar", "baz", 6, 7]));
+      });
+
+      test("clear()", () {
+        wrapper.clear();
+        expect(wrapper, isEmpty);
+      });
+    });
+  }, skip: "Re-enable this when test can run DDC (test#414).");
+}
diff --git a/test/typed_wrapper/set_test.dart b/test/typed_wrapper/set_test.dart
new file mode 100644
index 0000000..c3f84bc
--- /dev/null
+++ b/test/typed_wrapper/set_test.dart
@@ -0,0 +1,176 @@
+// Copyright (c) 2016, 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 "package:collection/collection.dart";
+import "package:test/test.dart";
+
+import '../utils.dart';
+
+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()", () {
+      wrapper.add(1);
+      wrapper.add(6);
+      expect(wrapper, unorderedEquals([1, 2, 3, 4, 5, 6]));
+    });
+
+    test("addAll()", () {
+      wrapper.addAll([1, 6, 7]);
+      expect(wrapper, unorderedEquals([1, 2, 3, 4, 5, 6, 7]));
+    });
+
+    test("clear()", () {
+      wrapper.clear();
+      expect(wrapper, isEmpty);
+    });
+
+    test("containsAll()", () {
+      expect(wrapper.containsAll([1, 3, 5]), isTrue);
+      expect(wrapper.containsAll([1, 3, 6]), isFalse);
+      expect(wrapper.containsAll([1, 3, "foo"]), isFalse);
+    });
+
+    test("difference()", () {
+      expect(wrapper.difference(new Set.from([1, 3, 6])),
+          unorderedEquals([2, 4, 5]));
+    });
+
+    test("intersection()", () {
+      expect(wrapper.intersection(new Set.from([1, 3, 6, "foo"])),
+          unorderedEquals([1, 3]));
+    });
+
+    test("lookup()", () {
+      expect(wrapper.lookup(1), equals(1));
+      expect(wrapper.lookup(7), isNull);
+      expect(wrapper.lookup("foo"), isNull);
+    });
+
+    test("remove()", () {
+      expect(wrapper.remove(3), isTrue);
+      expect(wrapper, unorderedEquals([1, 2, 4, 5]));
+
+      expect(wrapper.remove(3), isFalse);
+      expect(wrapper.remove("foo"), isFalse);
+    });
+
+    test("removeAll()", () {
+      wrapper.removeAll([1, 3, 6, "foo"]);
+      expect(wrapper, unorderedEquals([2, 4, 5]));
+    });
+
+    test("removeWhere()", () {
+      wrapper.removeWhere((i) => i.isOdd);
+      expect(wrapper, unorderedEquals([2, 4]));
+    });
+
+    test("retainAll()", () {
+      wrapper.retainAll([1, 3, 6, "foo"]);
+      expect(wrapper, unorderedEquals([1, 3]));
+    });
+
+    test("retainWhere()", () {
+      wrapper.retainWhere((i) => i.isOdd);
+      expect(wrapper, unorderedEquals([1, 3, 5]));
+    });
+
+    test("union()", () {
+      expect(wrapper.union(new Set.from([5, 6, 7])),
+          unorderedEquals([1, 2, 3, 4, 5, 6, 7]));
+    });
+  });
+
+  group("with invalid types", () {
+    var inner;
+    var wrapper;
+    setUp(() {
+      inner = new Set<Object>.from(["foo", "bar", "baz"]);
+      wrapper = DelegatingSet.typed/*<int>*/(inner);
+    });
+
+    group("throws a CastError for", () {
+      test("difference()", () {
+        var result = wrapper.difference(new Set.from([1, 3, 6]));
+        expect(() => result.first, throwsCastError);
+      });
+
+      test("intersection()", () {
+        var result = wrapper.intersection(new Set.from([1, 3, 6, "foo"]));
+        expect(() => result.first, throwsCastError);
+      });
+
+      test("lookup()", () {
+        expect(() => wrapper.lookup("foo"), throwsCastError);
+      });
+
+      test("removeWhere()", () {
+        expect(() => wrapper.removeWhere(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("retainWhere()", () {
+        expect(() => wrapper.retainWhere(expectAsync((_) => false, count: 0)),
+            throwsCastError);
+      });
+
+      test("union()", () {
+        var result = wrapper.union(new Set.from([5, 6, 7]));
+        expect(() => result.first, throwsCastError);
+      });
+    });
+
+    group("doesn't throw a CastError for", () {
+      test("add()", () {
+        wrapper.add(6);
+        expect(inner, unorderedEquals(["foo", "bar", "baz", 6]));
+      });
+
+      test("addAll()", () {
+        wrapper.addAll([6, 7]);
+        expect(inner, unorderedEquals(["foo", "bar", "baz", 6, 7]));
+      });
+
+      test("clear()", () {
+        wrapper.clear();
+        expect(wrapper, isEmpty);
+      });
+
+      test("containsAll()", () {
+        expect(wrapper.containsAll(["foo", "bar"]), isTrue);
+        expect(wrapper.containsAll(["foo", "bar", 1]), isFalse);
+      });
+
+      test("lookup()", () {
+        expect(wrapper.lookup(1), isNull);
+        expect(wrapper.lookup("zap"), isNull);
+      });
+
+      test("remove()", () {
+        expect(wrapper.remove("foo"), isTrue);
+        expect(inner, unorderedEquals(["bar", "baz"]));
+
+        expect(wrapper.remove(3), isFalse);
+        expect(wrapper.remove("foo"), isFalse);
+      });
+
+      test("removeAll()", () {
+        wrapper.removeAll([1, "foo", "baz"]);
+        expect(inner, unorderedEquals(["bar"]));
+      });
+
+      test("retainAll()", () {
+        wrapper.retainAll([1, "foo", "baz"]);
+        expect(inner, unorderedEquals(["foo", "baz"]));
+      });
+    });
+  }, skip: "Re-enable this when test can run DDC (test#414).");
+}
diff --git a/test/utils.dart b/test/utils.dart
new file mode 100644
index 0000000..d8ab082
--- /dev/null
+++ b/test/utils.dart
@@ -0,0 +1,7 @@
+// Copyright (c) 2016, 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 "package:test/test.dart";
+
+final Matcher throwsCastError = throwsA(new isInstanceOf<CastError>());