diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3c9fb6b..2818f7b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
-## 1.3.10
+## 1.4.0
+
+* Add `equals()`, `hash()` and `canonicalize()` top-level functions and
+  `Context` methods. These make it easier to treat paths as map keys.
 
 * Properly compare Windows paths case-insensitively.
 
diff --git a/lib/path.dart b/lib/path.dart
index 25236ea..59cc520 100644
--- a/lib/path.dart
+++ b/lib/path.dart
@@ -281,9 +281,27 @@
 ///       // -> ['http://dartlang.org', 'path', 'to', 'foo']
 List<String> split(String path) => context.split(path);
 
+/// Canonicalizes [path].
+///
+/// This is guaranteed to return the same path for two different input paths
+/// if and only if both input paths point to the same location. Unlike
+/// [normalize], it returns absolute paths when possible and canonicalizes
+/// ASCII case on Windows.
+///
+/// Note that this does not resolve symlinks.
+///
+/// If you want a map that uses path keys, it's probably more efficient to
+/// pass [equals] and [hash] to [new HashMap] than it is to canonicalize every
+/// key.
+String canonicalize(String path) => context.canonicalize(path);
+
 /// Normalizes [path], simplifying it by handling `..`, and `.`, and
 /// removing redundant path separators whenever possible.
 ///
+/// Note that this is *not* guaranteed to return the same result for two
+/// equivalent input paths. For that, see [canonicalize]. Or, if you're using
+/// paths as map keys, pass [equals] and [hash] to [new HashMap].
+///
 ///     path.normalize('path/./to/..//file.text'); // -> 'path/file.txt'
 String normalize(String path) => context.normalize(path);
 
@@ -324,6 +342,20 @@
 ///     path.isWithin('/root/path', '/root/path') // -> false
 bool isWithin(String parent, String child) => context.isWithin(parent, child);
 
+/// Returns `true` if [path1] points to the same location as [path2], and
+/// `false` otherwise.
+///
+/// The [hash] function returns a hash code that matches these equality
+/// semantics.
+bool equals(String path1, String path2) => context.equals(path1, path2);
+
+/// Returns a hash code for [path] such that, if [equals] returns `true` for two
+/// paths, their hash codes are the same.
+///
+/// Note that the same path may have different hash codes on different platforms
+/// or with different [current] directories.
+int hash(String path) => context.hash(path);
+
 /// Removes a trailing extension from the last part of [path].
 ///
 ///     withoutExtension('path/to/foo.dart'); // -> 'path/to/foo'
diff --git a/lib/src/context.dart b/lib/src/context.dart
index 3e84cae..af97f90 100644
--- a/lib/src/context.dart
+++ b/lib/src/context.dart
@@ -2,6 +2,8 @@
 // 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 'characters.dart' as chars;
 import 'internal_style.dart';
 import 'style.dart';
@@ -298,9 +300,34 @@
     return parsed.parts;
   }
 
+  /// Canonicalizes [path].
+  ///
+  /// This is guaranteed to return the same path for two different input paths
+  /// if and only if both input paths point to the same location. Unlike
+  /// [normalize], it returns absolute paths when possible and canonicalizes
+  /// ASCII case on Windows.
+  ///
+  /// Note that this does not resolve symlinks.
+  ///
+  /// If you want a map that uses path keys, it's probably more efficient to
+  /// pass [equals] and [hash] to [new HashMap] than it is to canonicalize every
+  /// key.
+  String canonicalize(String path) {
+    path = absolute(path);
+    if (style != Style.windows && !_needsNormalization(path)) return path;
+
+    var parsed = _parse(path);
+    parsed.normalize(canonicalize: true);
+    return parsed.toString();
+  }
+
   /// Normalizes [path], simplifying it by handling `..`, and `.`, and
   /// removing redundant path separators whenever possible.
   ///
+  /// Note that this is *not* guaranteed to return the same result for two
+  /// equivalent input paths. For that, see [canonicalize]. Or, if you're using
+  /// paths as map keys, pass [equals] and [hash] to [new HashMap].
+  ///
   ///     context.normalize('path/./to/..//file.text'); // -> 'path/file.txt'
   String normalize(String path) {
     if (!_needsNormalization(path)) return path;
@@ -496,7 +523,22 @@
   ///     path.isWithin('/root/path', '/root/path/a'); // -> true
   ///     path.isWithin('/root/path', '/root/other'); // -> false
   ///     path.isWithin('/root/path', '/root/path'); // -> false
-  bool isWithin(String parent, String child) {
+  bool isWithin(String parent, String child) =>
+      _isWithinOrEquals(parent, child) == _PathRelation.within;
+
+  /// Returns `true` if [path1] points to the same location as [path2], and
+  /// `false` otherwise.
+  ///
+  /// The [hash] function returns a hash code that matches these equality
+  /// semantics.
+  bool equals(String path1, String path2) =>
+      _isWithinOrEquals(path1, path2) == _PathRelation.equal;
+
+  /// Compares two paths and returns an enum value indicating their relationship
+  /// to one another.
+  ///
+  /// This never returns [_PathRelation.inconclusive].
+  _PathRelation _isWithinOrEquals(String parent, String child) {
     // Make both paths the same level of relative. We're only able to do the
     // quick comparison if both paths are in the same format, and making a path
     // absolute is faster than making it relative.
@@ -519,8 +561,8 @@
       }
     }
 
-    var fastResult = _isWithinFast(parent, child);
-    if (fastResult != null) return fastResult;
+    var result = _isWithinOrEqualsFast(parent, child);
+    if (result != _PathRelation.inconclusive) return result;
 
     var relative;
     try {
@@ -528,18 +570,22 @@
     } on PathException catch (_) {
       // If no relative path from [parent] to [child] is found, [child]
       // definitely isn't a child of [parent].
-      return false;
+      return _PathRelation.different;
     }
 
-    var parts = this.split(relative);
-    return this.isRelative(relative) &&
-        parts.first != '..' &&
-        parts.first != '.';
+    if (!this.isRelative(relative)) return _PathRelation.different;
+    if (relative == '.') return _PathRelation.equal;
+    if (relative == '..') return _PathRelation.different;
+    return (relative.length >= 3 &&
+            relative.startsWith('..') &&
+             style.isSeparator(relative.codeUnitAt(2)))
+        ? _PathRelation.different
+        : _PathRelation.within;
   }
 
-  /// An optimized implementation of [isWithin] that doesn't handle a few
-  /// complex cases.
-  bool _isWithinFast(String parent, String child) {
+  /// An optimized implementation of [_isWithinOrEquals] that doesn't handle a
+  /// few complex cases.
+  _PathRelation _isWithinOrEqualsFast(String parent, String child) {
     // Normally we just bail when we see "." path components, but we can handle
     // a single dot easily enough.
     if (parent == '.') parent = '';
@@ -553,7 +599,7 @@
     //
     //     isWithin("C:/bar", "//foo/bar/baz") //=> false
     //     isWithin("http://example.com/", "http://google.com/bar") //=> false
-    if (parentRootLength != childRootLength) return false;
+    if (parentRootLength != childRootLength) return _PathRelation.different;
 
     // Make sure that the roots are textually the same as well.
     //
@@ -562,7 +608,9 @@
     for (var i = 0; i < parentRootLength; i++) {
       var parentCodeUnit = parent.codeUnitAt(i);
       var childCodeUnit = child.codeUnitAt(i);
-      if (!style.codeUnitsEqual(parentCodeUnit, childCodeUnit)) return false;
+      if (!style.codeUnitsEqual(parentCodeUnit, childCodeUnit)) {
+        return _PathRelation.different;
+      }
     }
 
     // Start by considering the last code unit as a separator, since
@@ -570,6 +618,9 @@
     // comparing relative paths.
     var lastCodeUnit = chars.SLASH;
 
+    /// The index of the last separator in [parent].
+    int lastParentSeparator;
+
     // Iterate through both paths as long as they're semantically identical.
     var parentIndex = parentRootLength;
     var childIndex = childRootLength;
@@ -577,6 +628,10 @@
       var parentCodeUnit = parent.codeUnitAt(parentIndex);
       var childCodeUnit = child.codeUnitAt(childIndex);
       if (style.codeUnitsEqual(parentCodeUnit, childCodeUnit)) {
+        if (style.isSeparator(parentCodeUnit)) {
+          lastParentSeparator = parentIndex;
+        }
+
         lastCodeUnit = parentCodeUnit;
         parentIndex++;
         childIndex++;
@@ -586,6 +641,7 @@
       // Ignore multiple separators in a row.
       if (style.isSeparator(parentCodeUnit) &&
           style.isSeparator(lastCodeUnit)) {
+        lastParentSeparator = parentIndex;
         parentIndex++;
         continue;
       } else if (style.isSeparator(childCodeUnit) &&
@@ -594,35 +650,34 @@
         continue;
       }
 
-      if (parentCodeUnit == chars.PERIOD) {
-        // If a dot comes after a separator, it may be a directory traversal
-        // operator. To check that, we need to know if it's followed by either
-        // "/" or "./". Otherwise, it's just a normal non-matching character.
-        //
-        //     isWithin("foo/./bar", "foo/bar/baz") //=> true
-        //     isWithin("foo/bar/../baz", "foo/bar/.foo") //=> false
-        if (style.isSeparator(lastCodeUnit)) {
+      // If a dot comes after a separator, it may be a directory traversal
+      // operator. To check that, we need to know if it's followed by either
+      // "/" or "./". Otherwise, it's just a normal non-matching character.
+      //
+      //     isWithin("foo/./bar", "foo/bar/baz") //=> true
+      //     isWithin("foo/bar/../baz", "foo/bar/.foo") //=> false
+      if (parentCodeUnit == chars.PERIOD && style.isSeparator(lastCodeUnit)) {
+        parentIndex++;
+
+        // We've hit "/." at the end of the parent path, which we can ignore,
+        // since the paths were equivalent up to this point.
+        if (parentIndex == parent.length) break;
+        parentCodeUnit = parent.codeUnitAt(parentIndex);
+
+        // We've hit "/./", which we can ignore.
+        if (style.isSeparator(parentCodeUnit)) {
+          lastParentSeparator = parentIndex;
           parentIndex++;
+          continue;
+        }
 
-          // We've hit "/." at the end of the parent path, which we can ignore,
-          // since the paths were equivalent up to this point.
-          if (parentIndex == parent.length) break;
-          parentCodeUnit = parent.codeUnitAt(parentIndex);
-
-          // We've hit "/./", which we can ignore.
-          if (style.isSeparator(parentCodeUnit)) {
-            parentIndex++;
-            continue;
-          }
-
-          // We've hit "/..", which may be a directory traversal operator that
-          // we can't handle on the fast track.
-          if (parentCodeUnit == chars.PERIOD) {
-            parentIndex++;
-            if (parentIndex == parent.length ||
-                style.isSeparator(parent.codeUnitAt(parentIndex))) {
-              return null;
-            }
+        // We've hit "/..", which may be a directory traversal operator that
+        // we can't handle on the fast track.
+        if (parentCodeUnit == chars.PERIOD) {
+          parentIndex++;
+          if (parentIndex == parent.length ||
+              style.isSeparator(parent.codeUnitAt(parentIndex))) {
+            return _PathRelation.inconclusive;
           }
         }
 
@@ -632,23 +687,21 @@
 
       // This is the same logic as above, but for the child path instead of the
       // parent.
-      if (childCodeUnit == chars.PERIOD) {
-        if (style.isSeparator(lastCodeUnit)) {
+      if (childCodeUnit == chars.PERIOD && style.isSeparator(lastCodeUnit)) {
+        childIndex++;
+        if (childIndex == child.length) break;
+        childCodeUnit = child.codeUnitAt(childIndex);
+
+        if (style.isSeparator(childCodeUnit)) {
           childIndex++;
-          if (childIndex == child.length) break;
-          childCodeUnit = child.codeUnitAt(childIndex);
+          continue;
+        }
 
-          if (style.isSeparator(childCodeUnit)) {
-            childIndex++;
-            continue;
-          }
-
-          if (childCodeUnit == chars.PERIOD) {
-            childIndex++;
-            if (childIndex == child.length ||
-                style.isSeparator(child.codeUnitAt(childIndex))) {
-              return null;
-            }
+        if (childCodeUnit == chars.PERIOD) {
+          childIndex++;
+          if (childIndex == child.length ||
+              style.isSeparator(child.codeUnitAt(childIndex))) {
+            return _PathRelation.inconclusive;
           }
         }
       }
@@ -658,11 +711,16 @@
       // ".." components, we can be confident that [child] is not within
       // [parent].
       var childDirection = _pathDirection(child, childIndex);
-      if (childDirection != _PathDirection.belowRoot) return null;
-      var parentDirection = _pathDirection(parent, parentIndex);
-      if (parentDirection != _PathDirection.belowRoot) return null;
+      if (childDirection != _PathDirection.belowRoot) {
+        return _PathRelation.inconclusive;
+      }
 
-      return false;
+      var parentDirection = _pathDirection(parent, parentIndex);
+      if (parentDirection != _PathDirection.belowRoot) {
+        return _PathRelation.inconclusive;
+      }
+
+      return _PathRelation.different;
     }
 
     // If the child is shorter than the parent, it's probably not within the
@@ -672,8 +730,19 @@
     //     isWithin("foo/bar/baz", "foo/bar") //=> false
     //     isWithin("foo/bar/baz/../..", "foo/bar") //=> true
     if (childIndex == child.length) {
-      var direction = _pathDirection(parent, parentIndex);
-      return direction == _PathDirection.aboveRoot ? null : false;
+      if (parentIndex == parent.length ||
+          style.isSeparator(parent.codeUnitAt(parentIndex))) {
+        lastParentSeparator = parentIndex;
+      } else {
+        lastParentSeparator ??= math.max(0, parentRootLength - 1);
+      }
+
+      var direction = _pathDirection(parent,
+          lastParentSeparator ?? parentRootLength - 1);
+      if (direction == _PathDirection.atRoot) return _PathRelation.equal;
+      return direction == _PathDirection.aboveRoot
+          ? _PathRelation.inconclusive
+          : _PathRelation.different;
     }
 
     // We've reached the end of the parent path, which means it's time to make a
@@ -682,11 +751,13 @@
     var direction = _pathDirection(child, childIndex);
 
     // If there are no more components in the child, then it's the same as
-    // the parent, not within it.
+    // the parent.
     //
     //     isWithin("foo/bar", "foo/bar") //=> false
     //     isWithin("foo/bar", "foo/bar//") //=> false
-    if (direction == _PathDirection.atRoot) return false;
+    //     equals("foo/bar", "foo/bar") //=> true
+    //     equals("foo/bar", "foo/bar//") //=> true
+    if (direction == _PathDirection.atRoot) return _PathRelation.equal;
 
     // If there are unresolved ".." components in the child, no decision we make
     // will be valid. We'll abort and do the slow check instead.
@@ -694,7 +765,9 @@
     //     isWithin("foo/bar", "foo/bar/..") //=> false
     //     isWithin("foo/bar", "foo/bar/baz/bang/../../..") //=> false
     //     isWithin("foo/bar", "foo/bar/baz/bang/../../../bar/baz") //=> true
-    if (direction == _PathDirection.aboveRoot) return null;
+    if (direction == _PathDirection.aboveRoot) {
+      return _PathRelation.inconclusive;
+    }
 
     // The child is within the parent if and only if we're on a separator
     // boundary.
@@ -702,12 +775,14 @@
     //     isWithin("foo/bar", "foo/bar/baz") //=> true
     //     isWithin("foo/bar/", "foo/bar/baz") //=> true
     //     isWithin("foo/bar", "foo/barbaz") //=> false
-    return style.isSeparator(child.codeUnitAt(childIndex)) ||
-        style.isSeparator(lastCodeUnit);
+    return (style.isSeparator(child.codeUnitAt(childIndex)) ||
+            style.isSeparator(lastCodeUnit))
+        ? _PathRelation.within
+        : _PathRelation.different;
   }
 
   // Returns a [_PathDirection] describing the path represented by [codeUnits]
-  // after [index].
+  // starting at [index].
   //
   // This ignores leading separators.
   //
@@ -771,6 +846,80 @@
     return _PathDirection.belowRoot;
   }
 
+  /// Returns a hash code for [path] that matches the semantics of [equals].
+  ///
+  /// Note that the same path may have different hash codes in different
+  /// [Context]s.
+  int hash(String path) {
+    // Make [path] absolute to ensure that equivalent relative and absolute
+    // paths have the same hash code.
+    path = absolute(path);
+
+    var result = _hashFast(path);
+    if (result != null) return result;
+
+    var parsed = _parse(path);
+    parsed.normalize();
+    return _hashFast(parsed.toString());
+  }
+
+  /// An optimized implementation of [hash] that doesn't handle internal `..`
+  /// components.
+  ///
+  /// This will handle `..` components that appear at the beginning of the path.
+  int _hashFast(String path) {
+    var hash = 4603;
+    var beginning = true;
+    var wasSeparator = true;
+    for (var i = 0; i < path.length; i++) {
+      var codeUnit = style.canonicalizeCodeUnit(path.codeUnitAt(i));
+
+      // Take advantage of the fact that collisions are allowed to ignore
+      // separators entirely. This lets us avoid worrying about cases like
+      // multiple trailing slashes.
+      if (style.isSeparator(codeUnit)) {
+        wasSeparator = true;
+        continue;
+      }
+
+      if (codeUnit == chars.PERIOD && wasSeparator) {
+        // If a dot comes after a separator, it may be a directory traversal
+        // operator. To check that, we need to know if it's followed by either
+        // "/" or "./". Otherwise, it's just a normal character.
+        //
+        //     hash("foo/./bar") == hash("foo/bar")
+
+        // We've hit "/." at the end of the path, which we can ignore.
+        if (i + 1 == path.length) break;
+
+        var next = path.codeUnitAt(i + 1);
+
+        // We can just ignore "/./", since they don't affect the semantics of
+        // the path.
+        if (style.isSeparator(next)) continue;
+
+        // If the path ends with "/.." or contains "/../", we need to
+        // canonicalize it before we can hash it. We make an exception for ".."s
+        // at the beginning of the path, since those may appear even in a
+        // canonicalized path.
+        if (!beginning &&
+            next == chars.PERIOD &&
+            (i + 2 == path.length ||
+             style.isSeparator(path.codeUnitAt(i + 2)))) {
+          return null;
+        }
+      }
+
+      // Make sure [hash] stays under 32 bits even after multiplication.
+      hash &= 0x3FFFFFF;
+      hash *= 33;
+      hash ^= codeUnit;
+      wasSeparator = false;
+      beginning = false;
+    }
+    return hash;
+  }
+
   /// Removes a trailing extension from the last part of [path].
   ///
   ///     context.withoutExtension('path/to/foo.dart'); // -> 'path/to/foo'
@@ -930,3 +1079,32 @@
 
   String toString() => name;
 }
+
+/// An enum of possible return values for [Context._isWithinOrEquals].
+class _PathRelation {
+  /// The first path is a proper parent of the second.
+  ///
+  /// For example, `foo` is a proper parent of `foo/bar`, but not of `foo`.
+  static const within = const _PathRelation("within");
+
+  /// The two paths are equivalent.
+  ///
+  /// For example, `foo//bar` is equivalent to `foo/bar`.
+  static const equal = const _PathRelation("equal");
+
+  /// The first path is neither a parent of nor equal to the second.
+  static const different = const _PathRelation("different");
+
+  /// We couldn't quickly determine any information about the paths'
+  /// relationship to each other.
+  ///
+  /// Only returned by [Context._isWithinOrEqualsFast].
+  static const inconclusive = const _PathRelation("inconclusive");
+
+  final String name;
+
+  const _PathRelation(this.name);
+
+  String toString() => name;
+}
+
diff --git a/lib/src/internal_style.dart b/lib/src/internal_style.dart
index 1450d53..1874afc 100644
--- a/lib/src/internal_style.dart
+++ b/lib/src/internal_style.dart
@@ -76,4 +76,8 @@
   /// This only needs to handle character-by-character comparison; it can assume
   /// the paths are normalized and contain no `..` components.
   bool pathsEqual(String path1, String path2) => path1 == path2;
+
+  int canonicalizeCodeUnit(int codeUnit) => codeUnit;
+
+  String canonicalizePart(String part) => part;
 }
diff --git a/lib/src/parsed_path.dart b/lib/src/parsed_path.dart
index a3d68c7..619ffbf 100644
--- a/lib/src/parsed_path.dart
+++ b/lib/src/parsed_path.dart
@@ -97,7 +97,7 @@
     if (separators.length > 0) separators[separators.length - 1] = '';
   }
 
-  void normalize() {
+  void normalize({bool canonicalize: false}) {
     // Handle '.', '..', and empty parts.
     var leadingDoubles = 0;
     var newParts = <String>[];
@@ -113,7 +113,7 @@
           leadingDoubles++;
         }
       } else {
-        newParts.add(part);
+        newParts.add(canonicalize ? style.canonicalizePart(part) : part);
       }
     }
 
@@ -139,6 +139,7 @@
 
     // Normalize the Windows root if needed.
     if (root != null && style == Style.windows) {
+      if (canonicalize) root = root.toLowerCase();
       root = root.replaceAll('/', '\\');
     }
     removeTrailingSeparators();
diff --git a/lib/src/style/windows.dart b/lib/src/style/windows.dart
index 0d89764..57989af 100644
--- a/lib/src/style/windows.dart
+++ b/lib/src/style/windows.dart
@@ -151,4 +151,13 @@
     }
     return true;
   }
+
+  int canonicalizeCodeUnit(int codeUnit) {
+    if (codeUnit == chars.SLASH) return chars.BACKSLASH;
+    if (codeUnit < chars.UPPER_A) return codeUnit;
+    if (codeUnit > chars.UPPER_Z) return codeUnit;
+    return codeUnit | _asciiCaseBit;
+  }
+
+  String canonicalizePart(String part) => part.toLowerCase();
 }
diff --git a/pubspec.yaml b/pubspec.yaml
index 31bf492..a0475a1 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: path
-version: 1.3.10-dev
+version: 1.4.0-dev
 author: Dart Team <misc@dartlang.org>
 description: >
  A string-based path manipulation library. All of the path operations you know
diff --git a/test/posix_test.dart b/test/posix_test.dart
index 7b55dd3..4549ebd 100644
--- a/test/posix_test.dart
+++ b/test/posix_test.dart
@@ -317,6 +317,12 @@
       expect(context.normalize(r'a/b\'), r'a/b\');
       expect(context.normalize('a/b///'), 'a/b');
     });
+
+    test('when canonicalizing', () {
+      expect(context.canonicalize('.'), '/root/path');
+      expect(context.canonicalize('foo/bar'), '/root/path/foo/bar');
+      expect(context.canonicalize('FoO'), '/root/path/FoO');
+    });
   });
 
   group('relative', () {
@@ -445,6 +451,44 @@
     });
   });
 
+  group('equals and hash', () {
+    test('simple cases', () {
+      expectEquals(context, 'foo/bar', 'foo/bar');
+      expectNotEquals(context, 'foo/bar', 'foo/bar/baz');
+      expectNotEquals(context, 'foo/bar', 'foo');
+      expectNotEquals(context, 'foo/bar', 'foo/baz');
+      expectEquals(context, 'foo/bar', '../path/foo/bar');
+      expectEquals(context, '/', '/');
+      expectEquals(context, '/', '../..');
+      expectEquals(context, 'baz', '/root/path/baz');
+    });
+
+    test('complex cases', () {
+      expectEquals(context, 'foo/./bar', 'foo/bar');
+      expectEquals(context, 'foo//bar', 'foo/bar');
+      expectEquals(context, 'foo/qux/../bar', 'foo/bar');
+      expectNotEquals(context, 'foo/qux/../bar', 'foo/qux');
+      expectNotEquals(context, 'foo/bar', 'foo/bar/baz/../..');
+      expectEquals(context, 'foo/bar', 'foo/bar///');
+      expectEquals(context, 'foo/.bar', 'foo/.bar');
+      expectNotEquals(context, 'foo/./bar', 'foo/.bar');
+      expectEquals(context, 'foo/..bar', 'foo/..bar');
+      expectNotEquals(context, 'foo/../bar', 'foo/..bar');
+      expectEquals(context, 'foo/bar', 'foo/bar/baz/..');
+      expectNotEquals(context, 'FoO/bAr', 'foo/bar');
+    });
+
+    test('from a relative root', () {
+      var r = new path.Context(style: path.Style.posix, current: 'foo/bar');
+      expectEquals(r, 'a/b', 'a/b');
+      expectNotEquals(r, '.', 'foo/bar');
+      expectNotEquals(r, '.', '../a/b');
+      expectEquals(r, '.', '../bar');
+      expectEquals(r, '/baz/bang', '/baz/bang');
+      expectNotEquals(r, 'baz/bang', '/baz/bang');
+    });
+  });
+
   group('absolute', () {
     test('allows up to seven parts', () {
       expect(context.absolute('a'), '/root/path/a');
diff --git a/test/url_test.dart b/test/url_test.dart
index 4adfb48..32c02da 100644
--- a/test/url_test.dart
+++ b/test/url_test.dart
@@ -5,6 +5,8 @@
 import 'package:test/test.dart';
 import 'package:path/path.dart' as path;
 
+import 'utils.dart';
+
 main() {
   var context = new path.Context(
       style: path.Style.url, current: 'http://dartlang.org/root/path');
@@ -427,6 +429,16 @@
       expect(context.normalize(r'a/b\'), r'a/b\');
       expect(context.normalize('a/b///'), 'a/b');
     });
+
+    test('when canonicalizing', () {
+      expect(context.canonicalize('.'), 'http://dartlang.org/root/path');
+      expect(context.canonicalize('foo/bar'),
+          'http://dartlang.org/root/path/foo/bar');
+      expect(context.canonicalize('FoO'), 'http://dartlang.org/root/path/FoO');
+      expect(context.canonicalize('/foo'), 'http://dartlang.org/foo');
+      expect(context.canonicalize('http://google.com/foo'),
+          'http://google.com/foo');
+    });
   });
 
   group('relative', () {
@@ -674,6 +686,52 @@
     });
   });
 
+  group('equals and hash', () {
+    test('simple cases', () {
+      expectEquals(context, 'foo/bar', 'foo/bar');
+      expectNotEquals(context, 'foo/bar', 'foo/bar/baz');
+      expectNotEquals(context, 'foo/bar', 'foo');
+      expectNotEquals(context, 'foo/bar', 'foo/baz');
+      expectEquals(context, 'foo/bar', '../path/foo/bar');
+      expectEquals(context, 'http://google.com', 'http://google.com');
+      expectEquals(context, 'http://dartlang.org', '../..');
+      expectEquals(context, 'baz', '/root/path/baz');
+    });
+
+    test('complex cases', () {
+      expectEquals(context, 'foo/./bar', 'foo/bar');
+      expectEquals(context, 'foo//bar', 'foo/bar');
+      expectEquals(context, 'foo/qux/../bar', 'foo/bar');
+      expectNotEquals(context, 'foo/qux/../bar', 'foo/qux');
+      expectNotEquals(context, 'foo/bar', 'foo/bar/baz/../..');
+      expectEquals(context, 'foo/bar', 'foo/bar///');
+      expectEquals(context, 'foo/.bar', 'foo/.bar');
+      expectNotEquals(context, 'foo/./bar', 'foo/.bar');
+      expectEquals(context, 'foo/..bar', 'foo/..bar');
+      expectNotEquals(context, 'foo/../bar', 'foo/..bar');
+      expectEquals(context, 'foo/bar', 'foo/bar/baz/..');
+      expectNotEquals(context, 'FoO/bAr', 'foo/bar');
+      expectEquals(context, 'http://google.com', 'http://google.com/');
+      expectEquals(context, 'http://dartlang.org/root', '..');
+    });
+
+    test('with root-relative paths', () {
+      expectEquals(context, '/foo', 'http://dartlang.org/foo');
+      expectNotEquals(context, '/foo', 'http://google.com/foo');
+      expectEquals(context, '/root/path/foo/bar', 'foo/bar');
+    });
+
+    test('from a relative root', () {
+      var r = new path.Context(style: path.Style.posix, current: 'foo/bar');
+      expectEquals(r, 'a/b', 'a/b');
+      expectNotEquals(r, '.', 'foo/bar');
+      expectNotEquals(r, '.', '../a/b');
+      expectEquals(r, '.', '../bar');
+      expectEquals(r, '/baz/bang', '/baz/bang');
+      expectNotEquals(r, 'baz/bang', '/baz/bang');
+    });
+  });
+
   group('absolute', () {
     test('allows up to seven parts', () {
       expect(context.absolute('a'), 'http://dartlang.org/root/path/a');
diff --git a/test/utils.dart b/test/utils.dart
index ae3ea46..5e22ce1 100644
--- a/test/utils.dart
+++ b/test/utils.dart
@@ -3,7 +3,30 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:test/test.dart";
-import "package:path/path.dart" as path;
+import "package:path/path.dart" as p;
 
 /// A matcher for a closure that throws a [path.PathException].
-final throwsPathException = throwsA(new isInstanceOf<path.PathException>());
+final throwsPathException = throwsA(new isInstanceOf<p.PathException>());
+
+void expectEquals(p.Context context, String path1, String path2) {
+  expect(context.equals(path1, path2), isTrue,
+      reason: 'Expected "$path1" to equal "$path2".');
+  expect(context.equals(path2, path1), isTrue,
+      reason: 'Expected "$path2" to equal "$path1".');
+  expect(context.hash(path1), equals(context.hash(path2)),
+      reason: 'Expected "$path1" to hash the same as "$path2".');
+}
+
+void expectNotEquals(p.Context context, String path1, String path2,
+    {bool allowSameHash: false}) {
+  expect(context.equals(path1, path2), isFalse,
+      reason: 'Expected "$path1" not to equal "$path2".');
+  expect(context.equals(path2, path1), isFalse,
+      reason: 'Expected "$path2" not to equal "$path1".');
+
+  // Hash collisions are allowed, but the test author should be explicitly aware
+  // when they occur.
+  if (allowSameHash) return;
+  expect(context.hash(path1), isNot(equals(context.hash(path2))),
+      reason: 'Expected "$path1" not to hash the same as "$path2".');
+}
diff --git a/test/windows_test.dart b/test/windows_test.dart
index 8e72bb1..f4453a7 100644
--- a/test/windows_test.dart
+++ b/test/windows_test.dart
@@ -378,6 +378,14 @@
     test('normalizes separators', () {
       expect(context.normalize(r'a/b\c'), r'a\b\c');
     });
+
+    test('when canonicalizing', () {
+      expect(context.canonicalize('.'), r'c:\root\path');
+      expect(context.canonicalize('foo/bar'), r'c:\root\path\foo\bar');
+      expect(context.canonicalize('FoO'), r'c:\root\path\foo');
+      expect(context.canonicalize('/foo'), r'c:\foo');
+      expect(context.canonicalize('D:/foo'), r'd:\foo');
+    });
   });
 
   group('relative', () {
@@ -581,6 +589,53 @@
     });
   });
 
+  group('equals and hash', () {
+    test('simple cases', () {
+      expectEquals(context, r'foo\bar', r'foo\bar');
+      expectNotEquals(context, r'foo\bar', r'foo\bar\baz');
+      expectNotEquals(context, r'foo\bar', r'foo');
+      expectNotEquals(context, r'foo\bar', r'foo\baz');
+      expectEquals(context, r'foo\bar', r'..\path\foo\bar');
+      expectEquals(context, r'D:\', r'D:\');
+      expectEquals(context, r'C:\', r'..\..');
+      expectEquals(context, r'baz', r'C:\root\path\baz');
+    });
+
+    test('complex cases', () {
+      expectEquals(context, r'foo\.\bar', r'foo\bar');
+      expectEquals(context, r'foo\\bar', r'foo\bar');
+      expectEquals(context, r'foo\qux\..\bar', r'foo\bar');
+      expectNotEquals(context, r'foo\qux\..\bar', r'foo\qux');
+      expectNotEquals(context, r'foo\bar', r'foo\bar\baz\..\..');
+      expectEquals(context, r'foo\bar', r'foo\bar\\\');
+      expectEquals(context, r'foo\.bar', r'foo\.bar');
+      expectNotEquals(context, r'foo\.\bar', r'foo\.bar');
+      expectEquals(context, r'foo\..bar', r'foo\..bar');
+      expectNotEquals(context, r'foo\..\bar', r'foo\..bar');
+      expectEquals(context, r'foo\bar', r'foo\bar\baz\..');
+      expectEquals(context, r'FoO\bAr', r'foo\bar');
+      expectEquals(context, r'foo/\bar', r'foo\/bar');
+      expectEquals(context, r'c:\', r'C:\');
+      expectEquals(context, r'C:\root', r'..');
+    });
+
+    test('with root-relative paths', () {
+      expectEquals(context, r'\foo', r'C:\foo');
+      expectNotEquals(context, r'\foo', 'http://google.com/foo');
+      expectEquals(context, r'C:\root\path\foo\bar', r'foo\bar');
+    });
+
+    test('from a relative root', () {
+      var r = new path.Context(style: path.Style.windows, current: r'foo\bar');
+      expectEquals(r, r'a\b', r'a\b');
+      expectNotEquals(r, '.', r'foo\bar');
+      expectNotEquals(r, '.', r'..\a\b');
+      expectEquals(r, '.', r'..\bar');
+      expectEquals(r, r'C:\baz\bang', r'C:\baz\bang');
+      expectNotEquals(r, r'baz\bang', r'C:\baz\bang');
+    });
+  });
+
   group('absolute', () {
     test('allows up to seven parts', () {
       expect(context.absolute('a'), r'C:\root\path\a');