Update charted to 0.4.8 and roll

packages/path/test/url_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.
 
 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');
 
   test('separator', () {
     expect(context.separator, '/');
   });
 
   test('extension', () {
     expect(context.extension(''), '');
@@ skipping 13 matching lines @@
     expect(
         context.rootPrefix('http://dartlang.org/a/c'), 'http://dartlang.org');
     expect(context.rootPrefix('file:///a/c'), 'file://');
     expect(context.rootPrefix('/a/c'), '/');
     expect(context.rootPrefix('http://dartlang.org/'), 'http://dartlang.org');
     expect(context.rootPrefix('file:///'), 'file://');
     expect(context.rootPrefix('http://dartlang.org'), 'http://dartlang.org');
     expect(context.rootPrefix('file://'), 'file://');
     expect(context.rootPrefix('/'), '/');
     expect(context.rootPrefix('foo/bar://'), '');
+    expect(context.rootPrefix('package:foo/bar.dart'), 'package:foo');
+    expect(context.rootPrefix('foo/bar:baz/qux'), '');
   });
 
   test('dirname', () {
     expect(context.dirname(''), '.');
     expect(context.dirname('a'), '.');
     expect(context.dirname('a/b'), 'a');
     expect(context.dirname('a/b/c'), 'a/b');
     expect(context.dirname('a/b.c'), 'a');
     expect(context.dirname('a/'), '.');
     expect(context.dirname('a/.'), 'a');
@@ skipping 76 matching lines @@
     expect(context.isAbsolute('file:///a/b'), true);
     expect(context.isAbsolute('/a/b'), true);
     expect(context.isAbsolute('http://dartlang.org/'), true);
     expect(context.isAbsolute('file:///'), true);
     expect(context.isAbsolute('http://dartlang.org'), true);
     expect(context.isAbsolute('file://'), true);
     expect(context.isAbsolute('/'), true);
     expect(context.isAbsolute('~'), false);
     expect(context.isAbsolute('.'), false);
     expect(context.isAbsolute('../a'), false);
-    expect(context.isAbsolute('C:/a'), false);
-    expect(context.isAbsolute(r'C:\a'), false);
+    expect(context.isAbsolute('C:/a'), true);
+    expect(context.isAbsolute(r'C:\a'), true);
+    expect(context.isAbsolute('package:foo/bar.dart'), true);
+    expect(context.isAbsolute('foo/bar:baz/qux'), false);
     expect(context.isAbsolute(r'\\a'), false);
   });
 
   test('isRelative', () {
     expect(context.isRelative(''), true);
     expect(context.isRelative('a'), true);
     expect(context.isRelative('a/b'), true);
     expect(context.isRelative('http://dartlang.org/a'), false);
     expect(context.isRelative('file:///a'), false);
     expect(context.isRelative('/a'), false);
     expect(context.isRelative('http://dartlang.org/a/b'), false);
     expect(context.isRelative('file:///a/b'), false);
     expect(context.isRelative('/a/b'), false);
     expect(context.isRelative('http://dartlang.org/'), false);
     expect(context.isRelative('file:///'), false);
     expect(context.isRelative('http://dartlang.org'), false);
     expect(context.isRelative('file://'), false);
     expect(context.isRelative('/'), false);
     expect(context.isRelative('~'), true);
     expect(context.isRelative('.'), true);
     expect(context.isRelative('../a'), true);
-    expect(context.isRelative('C:/a'), true);
-    expect(context.isRelative(r'C:\a'), true);
+    expect(context.isRelative('C:/a'), false);
+    expect(context.isRelative(r'C:\a'), false);
+    expect(context.isRelative(r'package:foo/bar.dart'), false);
+    expect(context.isRelative('foo/bar:baz/qux'), true);
     expect(context.isRelative(r'\\a'), true);
   });
 
   test('isRootRelative', () {
     expect(context.isRootRelative(''), false);
     expect(context.isRootRelative('a'), false);
     expect(context.isRootRelative('a/b'), false);
     expect(context.isRootRelative('http://dartlang.org/a'), false);
     expect(context.isRootRelative('file:///a'), false);
     expect(context.isRootRelative('/a'), true);
     expect(context.isRootRelative('http://dartlang.org/a/b'), false);
     expect(context.isRootRelative('file:///a/b'), false);
     expect(context.isRootRelative('/a/b'), true);
     expect(context.isRootRelative('http://dartlang.org/'), false);
     expect(context.isRootRelative('file:///'), false);
     expect(context.isRootRelative('http://dartlang.org'), false);
     expect(context.isRootRelative('file://'), false);
     expect(context.isRootRelative('/'), true);
     expect(context.isRootRelative('~'), false);
     expect(context.isRootRelative('.'), false);
     expect(context.isRootRelative('../a'), false);
     expect(context.isRootRelative('C:/a'), false);
     expect(context.isRootRelative(r'C:\a'), false);
+    expect(context.isRootRelative(r'package:foo/bar.dart'), false);
+    expect(context.isRootRelative('foo/bar:baz/qux'), false);
     expect(context.isRootRelative(r'\\a'), false);
   });
 
   group('join', () {
     test('allows up to eight parts', () {
       expect(context.join('a'), 'a');
       expect(context.join('a', 'b'), 'a/b');
       expect(context.join('a', 'b', 'c'), 'a/b/c');
       expect(context.join('a', 'b', 'c', 'd'), 'a/b/c/d');
       expect(context.join('a', 'b', 'c', 'd', 'e'), 'a/b/c/d/e');
@@ skipping 12 matching lines @@
       expect(context.join('a', 'http://dartlang.org', 'b', 'c'),
           'http://dartlang.org/b/c');
       expect(context.join('a', 'file://', 'b', 'c'), 'file:///b/c');
       expect(context.join('a', '/', 'b', 'c'), '/b/c');
       expect(context.join('a', '/b', 'http://dartlang.org/c', 'd'),
           'http://dartlang.org/c/d');
       expect(context.join(
               'a', 'http://google.com/b', 'http://dartlang.org/c', 'd'),
           'http://dartlang.org/c/d');
       expect(context.join('a', '/b', '/c', 'd'), '/c/d');
-      expect(context.join('a', r'c:\b', 'c', 'd'), r'a/c:\b/c/d');
+      expect(context.join('a', r'c:\b', 'c', 'd'), r'c:\b/c/d');
+      expect(context.join('a', 'package:foo/bar', 'c', 'd'),
+          r'package:foo/bar/c/d');
       expect(context.join('a', r'\\b', 'c', 'd'), r'a/\\b/c/d');
     });
 
     test('preserves roots before a root-relative path', () {
       expect(context.join('http://dartlang.org', 'a', '/b', 'c'),
           'http://dartlang.org/b/c');
       expect(context.join('file://', 'a', '/b', 'c'), 'file:///b/c');
       expect(context.join('file://', 'a', '/b', 'c', '/d'), 'file:///d');
+      expect(context.join('package:foo/bar.dart', '/baz.dart'),
+          'package:foo/baz.dart');
     });
 
     test('ignores trailing nulls', () {
       expect(context.join('a', null), equals('a'));
       expect(context.join('a', 'b', 'c', null, null), equals('a/b/c'));
     });
 
     test('ignores empty strings', () {
       expect(context.join(''), '');
       expect(context.join('', ''), '');
       expect(context.join('', 'a'), 'a');
       expect(context.join('a', '', 'b', '', '', '', 'c'), 'a/b/c');
       expect(context.join('a', 'b', ''), 'a/b');
     });
 
     test('disallows intermediate nulls', () {
       expect(() => context.join('a', null, 'b'), throwsArgumentError);
       expect(() => context.join(null, 'a'), throwsArgumentError);
     });
 
-    test('Join does not modify internal ., .., or trailing separators', () {
+    test('does not modify internal ., .., or trailing separators', () {
       expect(context.join('a/', 'b/c/'), 'a/b/c/');
       expect(context.join('a/b/./c/..//', 'd/.././..//e/f//'),
           'a/b/./c/..//d/.././..//e/f//');
       expect(context.join('a/b', 'c/../../../..'), 'a/b/c/../../../..');
       expect(context.join('a', 'b${context.separator}'), 'a/b/');
     });
+
+    test('treats drive letters as part of the root for file: URLs', () {
+      expect(context.join('file:///c:/foo/bar', '/baz/qux'),
+          'file:///c:/baz/qux');
+      expect(context.join('file:///D:/foo/bar', '/baz/qux'),
+          'file:///D:/baz/qux');
+      expect(context.join('file:///c:/', '/baz/qux'), 'file:///c:/baz/qux');
+      expect(context.join('file:///c:', '/baz/qux'), 'file:///c:/baz/qux');
+      expect(context.join('file://host/c:/foo/bar', '/baz/qux'),
+          'file://host/c:/baz/qux');
+    });
+
+    test('treats drive letters as normal components for non-file: URLs', () {
+      expect(context.join('http://foo.com/c:/foo/bar', '/baz/qux'),
+          'http://foo.com/baz/qux');
+      expect(context.join('misfile:///c:/foo/bar', '/baz/qux'),
+          'misfile:///baz/qux');
+      expect(context.join('filer:///c:/foo/bar', '/baz/qux'),
+          'filer:///baz/qux');
+    });
   });
 
   group('joinAll', () {
     test('allows more than eight parts', () {
       expect(context.joinAll(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']),
           'a/b/c/d/e/f/g/h/i');
     });
 
     test('ignores parts before an absolute path', () {
       expect(context.joinAll(['a', 'http://dartlang.org', 'b', 'c']),
           'http://dartlang.org/b/c');
       expect(context.joinAll(['a', 'file://', 'b', 'c']), 'file:///b/c');
       expect(context.joinAll(['a', '/', 'b', 'c']), '/b/c');
       expect(context.joinAll(['a', '/b', 'http://dartlang.org/c', 'd']),
           'http://dartlang.org/c/d');
       expect(context.joinAll([
         'a',
         'http://google.com/b',
         'http://dartlang.org/c',
         'd'
       ]), 'http://dartlang.org/c/d');
       expect(context.joinAll(['a', '/b', '/c', 'd']), '/c/d');
-      expect(context.joinAll(['a', r'c:\b', 'c', 'd']), r'a/c:\b/c/d');
+      expect(context.joinAll(['a', r'c:\b', 'c', 'd']), r'c:\b/c/d');
+      expect(context.joinAll(['a', 'package:foo/bar', 'c', 'd']),
+          r'package:foo/bar/c/d');
       expect(context.joinAll(['a', r'\\b', 'c', 'd']), r'a/\\b/c/d');
     });
 
     test('preserves roots before a root-relative path', () {
       expect(context.joinAll(['http://dartlang.org', 'a', '/b', 'c']),
           'http://dartlang.org/b/c');
       expect(context.joinAll(['file://', 'a', '/b', 'c']), 'file:///b/c');
       expect(context.joinAll(['file://', 'a', '/b', 'c', '/d']), 'file:///d');
     });
   });
@@ skipping 90 matching lines @@
       expect(context.normalize('file:///..'), 'file://');
       expect(context.normalize('/..'), '/');
       expect(context.normalize('http://dartlang.org/../../..'),
           'http://dartlang.org');
       expect(context.normalize('file:///../../..'), 'file://');
       expect(context.normalize('/../../..'), '/');
       expect(context.normalize('http://dartlang.org/../../../a'),
           'http://dartlang.org/a');
       expect(context.normalize('file:///../../../a'), 'file:///a');
       expect(context.normalize('/../../../a'), '/a');
-      expect(context.normalize('c:/..'), '.');
-      expect(context.normalize('A:/../../..'), '../..');
+      expect(context.normalize('c:/..'), 'c:');
+      expect(context.normalize('package:foo/..'), 'package:foo');
+      expect(context.normalize('A:/../../..'), 'A:');
       expect(context.normalize('a/..'), '.');
       expect(context.normalize('a/b/..'), 'a');
       expect(context.normalize('a/../b'), 'b');
       expect(context.normalize('a/./../b'), 'b');
       expect(context.normalize('a/b/c/../../d/e/..'), 'a/d');
       expect(context.normalize('a/b/../../../../c'), '../../c');
       expect(context.normalize('z/a/b/../../..\../c'), 'z/..\../c');
       expect(context.normalize('a/b\c/../d'), 'a/d');
     });
 
     test('does not walk before root on absolute paths', () {
       expect(context.normalize('..'), '..');
       expect(context.normalize('../'), '..');
       expect(
           context.normalize('http://dartlang.org/..'), 'http://dartlang.org');
       expect(context.normalize('http://dartlang.org/../a'),
           'http://dartlang.org/a');
       expect(context.normalize('file:///..'), 'file://');
       expect(context.normalize('file:///../a'), 'file:///a');
       expect(context.normalize('/..'), '/');
       expect(context.normalize('a/..'), '.');
       expect(context.normalize('../a'), '../a');
       expect(context.normalize('/../a'), '/a');
-      expect(context.normalize('c:/../a'), 'a');
+      expect(context.normalize('c:/../a'), 'c:/a');
+      expect(context.normalize('package:foo/../a'), 'package:foo/a');
       expect(context.normalize('/../a'), '/a');
       expect(context.normalize('a/b/..'), 'a');
       expect(context.normalize('../a/b/..'), '../a');
       expect(context.normalize('a/../b'), 'b');
       expect(context.normalize('a/./../b'), 'b');
       expect(context.normalize('a/b/c/../../d/e/..'), 'a/d');
       expect(context.normalize('a/b/../../../../c'), '../../c');
       expect(context.normalize('a/b/c/../../..d/./.e/f././'), 'a/..d/.e/f.');
     });
 
     test('removes trailing separators', () {
       expect(context.normalize('./'), '.');
       expect(context.normalize('.//'), '.');
       expect(context.normalize('a/'), 'a');
       expect(context.normalize('a/b/'), 'a/b');
       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', () {
     group('from absolute root', () {
       test('given absolute path in root', () {
         expect(context.relative('http://dartlang.org'), '../..');
         expect(context.relative('http://dartlang.org/'), '../..');
         expect(context.relative('/'), '../..');
         expect(context.relative('http://dartlang.org/root'), '..');
         expect(context.relative('/root'), '..');
@@ skipping 32 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('a/b.txt'), 'a/b.txt');
         expect(context.relative('../a/b.txt'), '../a/b.txt');
         expect(context.relative('a/./b/../c.txt'), 'a/c.txt');
       });
 
+      test('is case-sensitive', () {
+        expect(context.relative('HtTp://dartlang.org/root'),
+            'HtTp://dartlang.org/root');
+        expect(context.relative('http://DaRtLaNg.OrG/root'),
+            'http://DaRtLaNg.OrG/root');
+        expect(context.relative('/RoOt'), '../../RoOt');
+        expect(context.relative('/rOoT/pAtH/a'), '../../rOoT/pAtH/a');
+      });
+
       // Regression
       test('from root-only path', () {
         expect(context.relative('http://dartlang.org',
             from: 'http://dartlang.org'), '.');
         expect(context.relative('http://dartlang.org/root/path',
             from: 'http://dartlang.org'), 'root/path');
       });
     });
 
     group('from relative root', () {
@@ skipping 166 matching lines @@
       var r = new path.Context(style: path.Style.url, current: 'foo/bar');
       expect(r.isWithin('.', 'a/b/c'), isTrue);
       expect(r.isWithin('.', '../a/b/c'), isFalse);
       expect(r.isWithin('.', '../../a/foo/b/c'), isFalse);
       expect(r.isWithin('http://dartlang.org/', 'http://dartlang.org/baz/bang'),
           isTrue);
       expect(r.isWithin('.', 'http://dartlang.org/baz/bang'), isFalse);
     });
   });
 
+  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');
       expect(context.absolute('a', 'b'), 'http://dartlang.org/root/path/a/b');
       expect(context.absolute('a', 'b', 'c'),
           'http://dartlang.org/root/path/a/b/c');
       expect(context.absolute('a', 'b', 'c', 'd'),
           'http://dartlang.org/root/path/a/b/c/d');
       expect(context.absolute('a', 'b', 'c', 'd', 'e'),
           'http://dartlang.org/root/path/a/b/c/d/e');
       expect(context.absolute('a', 'b', 'c', 'd', 'e', 'f'),
           'http://dartlang.org/root/path/a/b/c/d/e/f');
       expect(context.absolute('a', 'b', 'c', 'd', 'e', 'f', 'g'),
           'http://dartlang.org/root/path/a/b/c/d/e/f/g');
     });
 
     test('does not add separator if a part ends in one', () {
       expect(context.absolute('a/', 'b', 'c/', 'd'),
           'http://dartlang.org/root/path/a/b/c/d');
       expect(
           context.absolute(r'a\', 'b'), r'http://dartlang.org/root/path/a\/b');
     });
 
     test('ignores parts before an absolute path', () {
       expect(context.absolute('a', '/b', '/c', 'd'), 'http://dartlang.org/c/d');
       expect(context.absolute('a', '/b', 'file:///c', 'd'), 'file:///c/d');
-      expect(context.absolute('a', r'c:\b', 'c', 'd'),
-          r'http://dartlang.org/root/path/a/c:\b/c/d');
+      expect(context.absolute('a', r'c:\b', 'c', 'd'), r'c:\b/c/d');
       expect(context.absolute('a', r'\\b', 'c', 'd'),
           r'http://dartlang.org/root/path/a/\\b/c/d');
     });
   });
 
   test('withoutExtension', () {
     expect(context.withoutExtension(''), '');
     expect(context.withoutExtension('a'), 'a');
     expect(context.withoutExtension('.a'), '.a');
     expect(context.withoutExtension('a.b'), 'a');
@@ skipping 76 matching lines @@
 
     test('with a root-relative URI', () {
       expect(context.prettyUri('/a/b'), '/a/b');
     });
 
     test('with a Uri object', () {
       expect(context.prettyUri(Uri.parse('a/b')), 'a/b');
     });
   });
 }