Update charted to 0.4.8 and roll

packages/path/test/windows_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-library path.test.windows_test;
-
 import 'package:test/test.dart';
 import 'package:path/path.dart' as path;
 
 import 'utils.dart';
 
 main() {
   var context =
       new path.Context(style: path.Style.windows, current: r'C:\root\path');
 
   test('separator', () {
@@ skipping 308 matching lines @@
     });
 
     test('collapses redundant separators', () {
       expect(context.normalize(r'a\b\c'), r'a\b\c');
       expect(context.normalize(r'a\\b\\\c\\\\d'), r'a\b\c\d');
     });
 
     test('eliminates "." parts', () {
       expect(context.normalize(r'.\'), '.');
       expect(context.normalize(r'c:\.'), r'c:\');
+      expect(context.normalize(r'c:\foo\.'), r'c:\foo');
       expect(context.normalize(r'B:\.\'), r'B:\');
       expect(context.normalize(r'\\server\share\.'), r'\\server\share');
       expect(context.normalize(r'.\.'), '.');
       expect(context.normalize(r'a\.\b'), r'a\b');
       expect(context.normalize(r'a\.b\c'), r'a\.b\c');
       expect(context.normalize(r'a\./.\b\.\c'), r'a\b\c');
       expect(context.normalize(r'.\./a'), 'a');
       expect(context.normalize(r'a/.\.'), 'a');
       expect(context.normalize(r'\.'), r'\');
       expect(context.normalize('/.'), r'\');
     });
 
     test('eliminates ".." parts', () {
       expect(context.normalize('..'), '..');
       expect(context.normalize(r'..\'), '..');
       expect(context.normalize(r'..\..\..'), r'..\..\..');
       expect(context.normalize(r'../..\..\'), r'..\..\..');
       expect(context.normalize(r'\\server\share\..'), r'\\server\share');
       expect(
           context.normalize(r'\\server\share\..\../..\a'), r'\\server\share\a');
       expect(context.normalize(r'c:\..'), r'c:\');
+      expect(context.normalize(r'c:\foo\..'), r'c:\');
       expect(context.normalize(r'A:/..\..\..'), r'A:\');
       expect(context.normalize(r'b:\..\..\..\a'), r'b:\a');
       expect(context.normalize(r'b:\r\..\..\..\a\c\.\..'), r'b:\a');
       expect(context.normalize(r'a\..'), '.');
       expect(context.normalize(r'..\a'), r'..\a');
       expect(context.normalize(r'c:\..\a'), r'c:\a');
       expect(context.normalize(r'\..\a'), r'\a');
       expect(context.normalize(r'a\b\..'), 'a');
       expect(context.normalize(r'..\a\b\..'), r'..\a');
       expect(context.normalize(r'a\..\b'), 'b');
       expect(context.normalize(r'a\.\..\b'), 'b');
       expect(context.normalize(r'a\b\c\..\..\d\e\..'), r'a\d');
       expect(context.normalize(r'a\b\..\..\..\..\c'), r'..\..\c');
       expect(context.normalize(r'a/b/c/../../..d/./.e/f././'), r'a\..d\.e\f.');
     });
 
     test('removes trailing separators', () {
       expect(context.normalize(r'.\'), '.');
       expect(context.normalize(r'.\\'), '.');
       expect(context.normalize(r'a/'), 'a');
       expect(context.normalize(r'a\b\'), r'a\b');
       expect(context.normalize(r'a\b\\\'), r'a\b');
     });
 
     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', () {
     group('from absolute root', () {
       test('given absolute path in root', () {
         expect(context.relative(r'C:\'), r'..\..');
         expect(context.relative(r'C:\root'), '..');
         expect(context.relative(r'\root'), '..');
         expect(context.relative(r'C:\root\path'), '.');
         expect(context.relative(r'\root\path'), '.');
@@ skipping 27 matching lines @@
         // The path is considered relative to the root, so it basically just
         // normalizes.
         expect(context.relative(''), '.');
         expect(context.relative('.'), '.');
         expect(context.relative('a'), 'a');
         expect(context.relative(r'a\b.txt'), r'a\b.txt');
         expect(context.relative(r'..\a\b.txt'), r'..\a\b.txt');
         expect(context.relative(r'a\.\b\..\c.txt'), r'a\c.txt');
       });
 
+      test('is case-insensitive', () {
+        expect(context.relative(r'c:\'), r'..\..');
+        expect(context.relative(r'c:\RoOt'), r'..');
+        expect(context.relative(r'c:\rOoT\pAtH\a'), r'a');
+      });
+
       // Regression
       test('from root-only path', () {
         expect(context.relative(r'C:\', from: r'C:\'), '.');
         expect(context.relative(r'C:\root\path', from: r'C:\'), r'root\path');
       });
     });
 
     group('from relative root', () {
       var r = new path.Context(style: path.Style.windows, current: r'foo\bar');
 
@@ skipping 122 matching lines @@
     });
 
     test('from a relative root', () {
       var r = new path.Context(style: path.Style.windows, current: r'foo\bar');
       expect(r.isWithin('.', r'a\b\c'), isTrue);
       expect(r.isWithin('.', r'..\a\b\c'), isFalse);
       expect(r.isWithin('.', r'..\..\a\foo\b\c'), isFalse);
       expect(r.isWithin(r'C:\', r'C:\baz\bang'), isTrue);
       expect(r.isWithin('.', r'C:\baz\bang'), isFalse);
     });
+
+    test('is case-insensitive', () {
+      expect(context.isWithin(r'FoO', r'fOo\bar'), isTrue);
+      expect(context.isWithin(r'C:\', r'c:\foo'), isTrue);
+      expect(context.isWithin(r'fOo\qux\..\BaR', r'FoO\bAr\baz'), isTrue);
+    });
+  });
+
+  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');
       expect(context.absolute('a', 'b'), r'C:\root\path\a\b');
       expect(context.absolute('a', 'b', 'c'), r'C:\root\path\a\b\c');
       expect(context.absolute('a', 'b', 'c', 'd'), r'C:\root\path\a\b\c\d');
       expect(
           context.absolute('a', 'b', 'c', 'd', 'e'), r'C:\root\path\a\b\c\d\e');
@@ skipping 50 matching lines @@
           context.fromUri(Uri.parse('///C:/path/to/foo')), r'C:\path\to\foo');
       expect(context.fromUri(Uri.parse('//server/share/path/to/foo')),
           r'\\server\share\path\to\foo');
       expect(context.fromUri(Uri.parse('file:///C:/path/to/foo%23bar')),
           r'C:\path\to\foo#bar');
       expect(
           context.fromUri(Uri.parse('file://server/share/path/to/foo%23bar')),
           r'\\server\share\path\to\foo#bar');
       expect(context.fromUri(Uri.parse('_%7B_%7D_%60_%5E_%20_%22_%25_')),
           r'_{_}_`_^_ _"_%_');
+      expect(context.fromUri(Uri.parse('/foo')), r'\foo');
       expect(() => context.fromUri(Uri.parse('http://dartlang.org')),
           throwsArgumentError);
     });
 
     test('with a string', () {
       expect(context.fromUri('file:///C:/path/to/foo'), r'C:\path\to\foo');
     });
   });
 
   test('toUri', () {
@@ skipping 39 matching lines @@
 
     test('with a root-relative URI', () {
       expect(context.prettyUri('/D:/a/b'), r'D:\a\b');
     });
 
     test('with a Uri object', () {
       expect(context.prettyUri(Uri.parse('a/b')), r'a\b');
     });
   });
 }