Add support for file URIs and extracting the file path from file URIs

tests/corelib/uri_file_test.dart

Index: tests/corelib/uri_file_test.dart
diff --git a/tests/corelib/uri_file_test.dart b/tests/corelib/uri_file_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..4440a8d4bda3445ed9c181c58042ac70a751271d
--- /dev/null
+++ b/tests/corelib/uri_file_test.dart
@@ -0,0 +1,241 @@
+// 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:expect/expect.dart";
+
+testFileUri() {
+  final unsupported = new UnsupportedError("");
+
+  var tests = [
+    ["", "", ""],
+    ["relative", "relative", "relative"],
+    ["relative/", "relative/", "relative\\"],
+    ["a%20b", "a b", "a b"],
+    ["a%20b/", "a b/", "a b\\"],
+    ["a/b", "a/b", "a\\b"],
+    ["a/b/", "a/b/", "a\\b\\"],
+    ["a%20b/c%20d", "a b/c d", "a b\\c d"],
+    ["a%20b/c%20d/", "a b/c d/", "a b\\c d\\"],
+
+    ["file:///absolute", "/absolute", "\\absolute"],
+    ["file:///absolute", "/absolute", "\\absolute"],
+    ["file:///a/b", "/a/b", "\\a\\b"],
+    ["file:///a/b", "/a/b", "\\a\\b"],
+
+    ["file://server/a/b", unsupported, "\\\\server\\a\\b"],
+    ["file://server/a/b/", unsupported, "\\\\server\\a\\b\\"],
+
+    ["file:///C:/", "/C:/", "C:\\"],
+    ["file:///C:/a/b", "/C:/a/b", "C:\\a\\b"],
+    ["file:///C:/a/b/", "/C:/a/b/", "C:\\a\\b\\"],
+
+    ["http:/a/b", unsupported, unsupported],
+    ["https:/a/b", unsupported, unsupported],
+    ["urn:a:b", unsupported, unsupported],
+  ];
+
+  void check(String s, filePath, bool windowsPath) {
+    Uri uri = Uri.parse(s);
+    if (filePath is Error) {
+      if (filePath is UnsupportedError) {
+        Expect.throws(() => uri.toFilePath(windowsPath: windowsPath),
+                      (e) => e is UnsupportedError);
+      } else {
+        Expect.throws(() => uri.toFilePath(windowsPath: windowsPath));
+      }
+    } else {
+      Expect.equals(filePath, uri.toFilePath(windowsPath: windowsPath));
+      Expect.equals(
+          s, new Uri.file(filePath, windowsPath: windowsPath).toString());
+    }
+  }
+
+  for (var test in tests) {
+    check(test[0], test[1], false);
+    check(test[0], test[2], true);
+  }
+
+  Uri uri;
+  uri = Uri.parse("file:a");
+  Expect.equals("/a", uri.toFilePath(windowsPath: false));
+  Expect.equals("\\a", uri.toFilePath(windowsPath: true));
+  uri = Uri.parse("file:a/");
+  Expect.equals("/a/", uri.toFilePath(windowsPath: false));
+  Expect.equals("\\a\\", uri.toFilePath(windowsPath: true));
+}
+
+testFileUriWindowsSlash() {
+  var tests = [
+    ["", "", ""],
+    ["relative", "relative", "relative"],
+    ["relative/", "relative/", "relative\\"],
+    ["a%20b", "a b", "a b"],
+    ["a%20b/", "a b/", "a b\\"],
+    ["a/b", "a/b", "a\\b"],
+    ["a/b/", "a/b/", "a\\b\\"],
+    ["a%20b/c%20d", "a b/c d", "a b\\c d"],
+    ["a%20b/c%20d/", "a b/c d/", "a b\\c d\\"],
+
+    ["file:///absolute", "/absolute", "\\absolute"],
+    ["file:///absolute", "/absolute", "\\absolute"],
+    ["file:///a/b", "/a/b", "\\a\\b"],
+    ["file:///a/b", "/a/b", "\\a\\b"],
+
+    ["file://server/a/b", "//server/a/b", "\\\\server\\a\\b"],
+    ["file://server/a/b/", "//server/a/b/", "\\\\server\\a\\b\\"],
+
+    ["file:///C:/", "C:/", "C:\\"],
+    ["file:///C:/a/b", "C:/a/b", "C:\\a\\b"],
+    ["file:///C:/a/b/", "C:/a/b/", "C:\\a\\b\\"],
+  ];
+
+  for (var test in tests) {
+    Uri uri;
+    uri = new Uri.file(test[1], windowsPath: true);
+    Expect.equals(test[0], uri.toString());
+    Expect.equals(test[2], uri.toFilePath(windowsPath: true));
+  }
+}
+
+testFileUriWindowsWin32Namespace() {
+  var tests = [
+      ["\\\\?\\C:\\", "file:///C:/", "C:\\"],
+      ["\\\\?\\C:\\", "file:///C:/", "C:\\"],
+      ["\\\\?\\UNC\\server\\share\\file",
+       "file://server/share/file",
+       "\\\\server\\share\\file"],
+  ];
+
+  for (var test in tests) {
+    Uri uri = new Uri.file(test[0], windowsPath: true);
+    Expect.equals(test[1], uri.toString());
+    Expect.equals(test[2], uri.toFilePath(windowsPath: true));
+  }
+
+  Expect.throws(
+      () => new Uri.file("\\\\?\\file", windowsPath: true),
+      (e) => e is ArgumentError);
+  Expect.throws(
+      () => new Uri.file("\\\\?\\UNX\\server\\share\\file", windowsPath: true),
+      (e) => e is ArgumentError);
+}
+
+testFileUriDriveLetter() {
+  check(String s, String nonWindows, String windows) {
+    Uri uri;
+    uri = Uri.parse(s);
+    Expect.equals(nonWindows, uri.toFilePath(windowsPath: false));
+    Expect.equals(windows, uri.toFilePath(windowsPath: true));
+  }
+
+  check("file:///C:", "/C:", "C:\\");
+  check("file:///C:/", "/C:/", "C:\\");
+  check("file:///C:a", "/C:a", "C:\\a");
+  check("file:///C:a/", "/C:a/", "C:\\a\\");
+}
+
+testFileUriResolve() {
+  var tests = [
+    ["file:///a", "/a", "", "\\a", ""],
+    ["file:///a/", "/a/", "", "\\a\\", ""],
+    ["file:///b", "/a", "b", "\\a", "b"],
+    ["file:///b/", "/a", "b/", "\\a", "b\\"],
+    ["file:///a/b", "/a/", "b", "\\a\\", "b"],
+    ["file:///a/b/", "/a/", "b/", "\\a\\", "b\\"],
+    ["file:///a/c/d", "/a/b", "c/d", "\\a\\b", "c\\d"],
+    ["file:///a/c/d/", "/a/b", "c/d/", "\\a\\b", "c\\d\\"],
+    ["file:///a/b/c/d", "/a/b/", "c/d", "\\a\\b\\", "c\\d"],
+    ["file:///a/b/c/d/", "/a/b/", "c/d/", "\\a\\b\\", "c\\d\\"],
+  ];
+
+  check(String s, String absolute, String relative, bool windowsPath) {
+    Uri absoluteUri = new Uri.file(absolute, windowsPath: windowsPath);
+    Uri relativeUri = new Uri.file(relative, windowsPath: windowsPath);
+    String relativeString =
+        windowsPath ? relative.replaceAll("\\", "/") : relative;
+    Expect.equals(s, absoluteUri.resolve(relativeString).toString());
+    Expect.equals(s, absoluteUri.resolveUri(relativeUri).toString());
+  }
+
+  for (var test in tests) {
+    check(test[0], test[1], test[2], false);
+    check(test[0], test[1], test[2], true);
+    check(test[0], test[1], test[4], true);
+    check(test[0], test[3], test[2], true);
+    check(test[0], test[3], test[4], true);
+  }
+}
+
+testFileUriIllegalCharacters() {
+  // Slash is an invalid character in file names on both non-Windows and Windows.

[ahe, 2013/08/06 14:14:30]

Long line.

[Søren Gjesse, 2013/08/07 12:08:00]

Done.

+  Uri uri = Uri.parse("file:///a%2Fb");
+  Expect.throws(() => uri.toFilePath(windowsPath: false),
+                (e) => e is UnsupportedError);
+  Expect.throws(() => uri.toFilePath(windowsPath: true),
+                (e) => e is UnsupportedError);
+
+  // Illegal characters in windows file names. Note the test of colon
+  // cannot be in position 2 as it is then considered a drive letter
+  // separator and not illegal.
+  var illegalWindowsPaths =
+      ["a<b", "a>b", "aa:b", "a\"b", "a|b", "a?b", "a*b", "\\\\?\\c:\\a/b"];
+
+  for (var test in illegalWindowsPaths) {
+    Expect.throws(() => new Uri.file(test, windowsPath: true),
+                  (e) => e is ArgumentError);
+    Expect.throws(() => new Uri.file("\\$test", windowsPath: true),
+                  (e) => e is ArgumentError);
+
+    // It is possible to create non-Windows URIs, but not Windows URIs.
+    Uri uri = new Uri.file(test, windowsPath: false);
+    Uri absoluteUri = new Uri.file("/$test", windowsPath: false);
+    Expect.throws(() => new Uri.file(test, windowsPath: true));
+    Expect.throws(() => new Uri.file("\\$test", windowsPath: true));
+
+    // It is possible to extract non-Windows file path, but not
+    // Windows file path.
+    Expect.equals(test, uri.toFilePath(windowsPath: false));
+    Expect.equals("/$test", absoluteUri.toFilePath(windowsPath: false));
+    Expect.throws(() => uri.toFilePath(windowsPath: true));
+    Expect.throws(() => absoluteUri.toFilePath(windowsPath: true));
+  }
+
+  // Backslash
+  illegalWindowsPaths = ["a\\b", "a\\b\\"];
+  for (var test in illegalWindowsPaths) {
+    // It is possible to create both non-Windows URIs, and Windows URIs.
+    Uri uri = new Uri.file(test, windowsPath: false);
+    Uri absoluteUri = new Uri.file("/$test", windowsPath: false);
+    new Uri.file(test, windowsPath: true);
+    new Uri.file("\\$test", windowsPath: true);
+
+    // It is possible to extract non-Windows file path, but not
+    // Windows file path from the non-Windows URI (it has a backslash
+    // in a path segment).
+    Expect.equals(test, uri.toFilePath(windowsPath: false));
+    Expect.equals("/$test", absoluteUri.toFilePath(windowsPath: false));
+    Expect.throws(() => uri.toFilePath(windowsPath: true),
+                  (e) => e is UnsupportedError);
+    Expect.throws(() => absoluteUri.toFilePath(windowsPath: true));
+  }
+}
+
+testFileUriIllegalDriveLetter() {
+  Expect.throws(() => new Uri.file("1:\\", windowsPath: true),
+                (e) => e is ArgumentError);
+  Uri uri = new Uri.file("1:\\", windowsPath: false);
+  Expect.equals("1:\\", uri.toFilePath(windowsPath: false));
+  Expect.throws(() => uri.toFilePath(windowsPath: true),
+                (e) => e is UnsupportedError);
+}
+
+main() {
+  testFileUri();
+  testFileUriWindowsSlash();
+  testFileUriDriveLetter();
+  testFileUriWindowsWin32Namespace();
+  testFileUriResolve();
+  testFileUriIllegalCharacters();
+  testFileUriIllegalDriveLetter();
+}