Fix invalid URIs generated using Uri constructor with clever paths.

tests/corelib/uri_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 uriTest;
 
 import "package:expect/expect.dart";
 import 'dart:convert';
 
 testUri(String uriText, bool isAbsolute) {
@@ skipping 747 matching lines @@
 void testRegression28359() {
   var uri = new Uri(path: "//");
   // This is an invalid path for a URI reference with no authority
   // since it looks like an authority.
   // Normalized to have an authority.
   Expect.equals("////", "$uri");
   Expect.equals("//", uri.path);
   Expect.isTrue(uri.hasAuthority, "$uri has authority");
 
   uri = new Uri(path: "file:///wat");
-  // This is an invalid pat for a URI reference with no authority or scheme
+  // This is an invalid path for a URI reference with no authority or scheme
   // since the path looks like it starts with a scheme.
   // Normalized by escaping the ":".
   Expect.equals("file%3A///wat", uri.path);
   Expect.equals("file%3A///wat", "$uri");
   Expect.isFalse(uri.hasAuthority);
   Expect.isFalse(uri.hasScheme);
 }
 
 main() {
   testUri("http:", true);
@@ skipping 49 matching lines @@
       Uri.parse("https://example.com/a/b/c").origin);
   Expect.stringEquals(
       "http://example.com:1234",
       Uri.parse("http://example.com:1234/a/b/c").origin);
   Expect.stringEquals(
       "https://example.com:1234",
       Uri.parse("https://example.com:1234/a/b/c").origin);
   Expect.throws(
       () => Uri.parse("http:").origin,
       (e) { return e is StateError; },
-      "origin for uri with empty host should fail");
+      "origin for URI with empty host should fail");
   Expect.throws(
       () => new Uri(
           scheme: "http",
           userInfo: null,
           host: "",
           port: 80,
           path: "/a/b/c",
           query: "query",
           fragment: "fragment").origin,
       (e) { return e is StateError; },
-      "origin for uri with empty host should fail");
+      "origin for URI with empty host should fail");
   Expect.throws(
       () => new Uri(
           scheme: null,
           userInfo: null,
           host: "",
           port: 80,
           path: "/a/b/c",
           query: "query",
           fragment: "fragment").origin,
       (e) { return e is StateError; },
-      "origin for uri with empty scheme should fail");
+      "origin for URI with empty scheme should fail");
   Expect.throws(
       () => new Uri(
           scheme: "http",
           userInfo: null,
           host: null,
           port: 80,
           path: "/a/b/c",
           query: "query",
           fragment: "fragment").origin,
       (e) { return e is StateError; },
-      "origin for uri with empty host should fail");
+      "origin for URI with empty host should fail");
   Expect.throws(
       () => Uri.parse("http://:80").origin,
       (e) { return e is StateError; },
-      "origin for uri with empty host should fail");
+      "origin for URI with empty host should fail");
   Expect.throws(
       () => Uri.parse("file://localhost/test.txt").origin,
       (e) { return e is StateError; },
       "origin for non-http/https uri should fail");
 
   // URI encode tests
   // Create a string with code point 0x10000 encoded as a surrogate pair.
   var s = UTF8.decode([0xf0, 0x90, 0x80, 0x80]);
 
   Expect.stringEquals("\u{10000}", s);
@@ skipping 60 matching lines @@
 String dump(Uri uri) {
   return "URI: $uri\n"
       "  Scheme:    ${uri.scheme} #${uri.scheme.length}\n"
       "  User-info: ${uri.userInfo} #${uri.userInfo.length}\n"
       "  Host:      ${uri.host} #${uri.host.length}\n"
       "  Port:      ${uri.port}\n"
       "  Path:      ${uri.path} #${uri.path.length}\n"
       "  Query:     ${uri.query} #${uri.query.length}\n"
       "  Fragment:  ${uri.fragment} #${uri.fragment.length}\n";
 }