package main
func init() {
- addTestCases(go1renameTests, go1pkgrename)
+ addTestCases(go1pkgrenameTests, go1pkgrename)
}
-var go1renameTests = []testCase{
+var go1pkgrenameTests = []testCase{
{
Name: "go1rename.0",
In: `package main
package main
-var cryptotypeFix = fix{
- "cryptotype",
+func init() {
+ register(go1renameFix)
+}
+
+var go1renameFix = fix{
+ "go1rename",
"2012-02-12",
- renameFix(cryptotypeReplace),
- `Rewrite uses of concrete cipher types to refer to the generic cipher.Block.
+ renameFix(go1renameReplace),
+ `Rewrite package-level names that have been renamed in Go 1.
http://codereview.appspot.com/5625045/
+http://codereview.appspot.com/5672072/
`,
}
-var cryptotypeReplace = []rename{
+var go1renameReplace = []rename{
{
OldImport: "crypto/aes",
NewImport: "crypto/cipher",
Old: "*des.TripleDESCipher",
New: "cipher.Block",
},
+ {
+ OldImport: "net/url",
+ NewImport: "",
+ Old: "url.ParseWithReference",
+ New: "url.Parse",
+ },
+ {
+ OldImport: "net/url",
+ NewImport: "",
+ Old: "url.ParseRequest",
+ New: "url.ParseRequestURI",
+ },
+ {
+ OldImport: "os",
+ NewImport: "syscall",
+ Old: "os.Exec",
+ New: "syscall.Exec",
+ },
}
package main
func init() {
- addTestCases(cryptotypeTests, cryptotypeFix.f)
+ addTestCases(go1renameTests, go1renameFix.f)
}
-var cryptotypeTests = []testCase{
+var go1renameTests = []testCase{
{
- Name: "cryptotype.0",
+ Name: "go1rename.0",
In: `package main
import (
"crypto/aes"
"crypto/des"
+ "net/url"
+ "os"
)
var (
_ *des.Cipher
_ *des.TripleDESCipher
_ = aes.New()
+ _ = url.Parse
+ _ = url.ParseWithReference
+ _ = url.ParseRequest
+ _ = os.Exec
)
`,
Out: `package main
import (
"crypto/aes"
"crypto/cipher"
+ "net/url"
+ "syscall"
)
var (
_ cipher.Block
_ cipher.Block
_ = aes.New()
+ _ = url.Parse
+ _ = url.Parse
+ _ = url.ParseRequestURI
+ _ = syscall.Exec
)
`,
},
return readCookies(r.Header, "")
}
-var ErrNoCookie = errors.New("http: named cookied not present")
+var ErrNoCookie = errors.New("http: named cookie not present")
// Cookie returns the named cookie provided in the request or
// ErrNoCookie if not found.
rawurl = "http://" + rawurl
}
- if req.URL, err = url.ParseRequest(rawurl); err != nil {
+ if req.URL, err = url.ParseRequestURI(rawurl); err != nil {
return nil, err
}
}
// Parse parses rawurl into a URL structure.
-// The string rawurl is assumed not to have a #fragment suffix.
-// (Web browsers strip #fragment before sending the URL to a web server.)
// The rawurl may be relative or absolute.
func Parse(rawurl string) (url *URL, err error) {
- return parse(rawurl, false)
+ // Cut off #frag
+ u, frag := split(rawurl, '#', true)
+ if url, err = parse(u, false); err != nil {
+ return nil, err
+ }
+ if frag == "" {
+ return url, nil
+ }
+ if url.Fragment, err = unescape(frag, encodeFragment); err != nil {
+ return nil, &Error{"parse", rawurl, err}
+ }
+ return url, nil
}
-// ParseRequest parses rawurl into a URL structure. It assumes that
-// rawurl was received from an HTTP request, so the rawurl is interpreted
+// ParseRequestURI parses rawurl into a URL structure. It assumes that
+// rawurl was received in an HTTP request, so the rawurl is interpreted
// only as an absolute URI or an absolute path.
// The string rawurl is assumed not to have a #fragment suffix.
// (Web browsers strip #fragment before sending the URL to a web server.)
-func ParseRequest(rawurl string) (url *URL, err error) {
+func ParseRequestURI(rawurl string) (url *URL, err error) {
return parse(rawurl, true)
}
return
}
-// ParseWithFragment is like Parse but allows a trailing #fragment.
-func ParseWithFragment(rawurl string) (url *URL, err error) {
- // Cut off #frag
- u, frag := split(rawurl, '#', true)
- if url, err = Parse(u); err != nil {
- return nil, err
- }
- if frag == "" {
- return url, nil
- }
- if url.Fragment, err = unescape(frag, encodeFragment); err != nil {
- return nil, &Error{"parse", rawurl, err}
- }
- return url, nil
-}
-
// String reassembles the URL into a valid URL string.
func (u *URL) String() string {
// TODO: Rewrite to use bytes.Buffer
},
"http://user:password@google.com",
},
-}
-
-var urlnofragtests = []URLTest{
- {
- "http://www.google.com/?q=go+language#foo",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/",
- RawQuery: "q=go+language#foo",
- },
- "",
- },
-}
-
-var urlfragtests = []URLTest{
{
"http://www.google.com/?q=go+language#foo",
&URL{
func TestParse(t *testing.T) {
DoTest(t, Parse, "Parse", urltests)
- DoTest(t, Parse, "Parse", urlnofragtests)
-}
-
-func TestParseWithFragment(t *testing.T) {
- DoTest(t, ParseWithFragment, "ParseWithFragment", urltests)
- DoTest(t, ParseWithFragment, "ParseWithFragment", urlfragtests)
}
const pathThatLooksSchemeRelative = "//not.a.user@not.a.host/just/a/path"
{"../dir/", false},
}
-func TestParseRequest(t *testing.T) {
+func TestParseRequestURI(t *testing.T) {
for _, test := range parseRequestUrlTests {
- _, err := ParseRequest(test.url)
+ _, err := ParseRequestURI(test.url)
valid := err == nil
if valid != test.expectedValid {
t.Errorf("Expected valid=%v for %q; got %v", test.expectedValid, test.url, valid)
}
}
- url, err := ParseRequest(pathThatLooksSchemeRelative)
+ url, err := ParseRequestURI(pathThatLooksSchemeRelative)
if err != nil {
t.Fatalf("Unexpected error %v", err)
}
func TestURLString(t *testing.T) {
DoTestString(t, Parse, "Parse", urltests)
- DoTestString(t, Parse, "Parse", urlnofragtests)
- DoTestString(t, ParseWithFragment, "ParseWithFragment", urltests)
- DoTestString(t, ParseWithFragment, "ParseWithFragment", urlfragtests)
}
type EscapeTest struct {
func TestResolveReference(t *testing.T) {
mustParse := func(url string) *URL {
- u, err := ParseWithFragment(url)
+ u, err := Parse(url)
if err != nil {
t.Fatalf("Expected URL to parse: %q, got error: %v", url, err)
}
func TestResolveReferenceOpaque(t *testing.T) {
mustParse := func(url string) *URL {
- u, err := ParseWithFragment(url)
+ u, err := Parse(url)
if err != nil {
t.Fatalf("Expected URL to parse: %q, got error: %v", url, err)
}